The world's most popular open source database
mysql/src/5.1-dbg/storage/innobase/include/page0page.h File Reference
#include "univ.i"#include "page0types.h"#include "fil0fil.h"#include "buf0buf.h"#include "data0data.h"#include "dict0dict.h"#include "rem0rec.h"#include "fsp0fsp.h"#include "mtr0mtr.h"Include dependency graph for page0page.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Define Documentation
| #define PAGE_BTR_IBUF_FREE_LIST PAGE_BTR_SEG_LEAF |
Definition at line 67 of file page0page.h.
Referenced by btr_create(), btr_page_alloc_for_ibuf(), btr_page_free_for_ibuf(), ibuf_add_free_page(), ibuf_data_sizes_update(), and ibuf_remove_free_page().
| #define PAGE_BTR_IBUF_FREE_LIST_NODE PAGE_BTR_SEG_LEAF |
Definition at line 68 of file page0page.h.
Referenced by btr_page_alloc_for_ibuf(), btr_page_free_for_ibuf(), ibuf_add_free_page(), and ibuf_remove_free_page().
| #define PAGE_BTR_SEG_LEAF 36 |
Definition at line 64 of file page0page.h.
Referenced by btr_create(), btr_free_but_not_root(), btr_get_size(), btr_page_alloc(), and btr_page_free_low().
| #define PAGE_BTR_SEG_TOP (36 + FSEG_HEADER_SIZE) |
Definition at line 74 of file page0page.h.
Referenced by btr_create(), btr_free_but_not_root(), btr_free_root(), btr_get_size(), btr_page_alloc(), and btr_page_free_low().
| #define PAGE_DATA (PAGE_HEADER + 36 + 2 * FSEG_HEADER_SIZE) |
| #define PAGE_DIR FIL_PAGE_DATA_END |
Definition at line 120 of file page0page.h.
Referenced by page_dir_find_owner_slot(), and row_search_for_mysql().
| #define PAGE_DIR_SLOT_MAX_N_OWNED 8 |
Definition at line 132 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_cur_insert_rec_low(), page_dir_balance_slot(), page_dir_slot_check(), page_dir_split_slot(), and page_rec_validate().
| #define PAGE_DIR_SLOT_MIN_N_OWNED 4 |
Definition at line 133 of file page0page.h.
Referenced by page_cur_delete_rec(), page_dir_balance_slot(), page_dir_slot_check(), and page_dir_split_slot().
| #define PAGE_DIR_SLOT_SIZE 2 |
Definition at line 123 of file page0page.h.
Referenced by btr_cur_optimistic_insert(), and page_dir_find_owner_slot().
| #define PAGE_DIRECTION 12 |
Definition at line 47 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_insert_rec_low(), page_cur_search_with_match(), page_header_print(), and page_parse_copy_rec_list_to_created_page().
| #define PAGE_EMPTY_DIR_START (PAGE_DIR + 2 * PAGE_DIR_SLOT_SIZE) |
| #define PAGE_FREE 6 |
Definition at line 42 of file page0page.h.
Referenced by page_create(), page_delete_rec_list_end(), page_header_print(), page_mem_alloc(), page_simple_validate(), and page_validate().
| #define PAGE_GARBAGE 8 |
Definition at line 43 of file page0page.h.
Referenced by page_create(), page_delete_rec_list_end(), page_header_print(), and page_mem_alloc().
| #define PAGE_HEADER FSEG_PAGE_DATA |
Definition at line 35 of file page0page.h.
Referenced by btr_create(), btr_free_but_not_root(), btr_free_root(), btr_get_size(), btr_page_alloc(), btr_page_alloc_for_ibuf(), btr_page_free_for_ibuf(), btr_page_free_low(), ibuf_add_free_page(), ibuf_data_sizes_update(), ibuf_remove_free_page(), and page_set_max_trx_id().
| #define PAGE_HEADER_PRIV_END 26 |
Definition at line 58 of file page0page.h.
| #define PAGE_HEAP_TOP 2 |
Definition at line 39 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_header_print(), page_mem_alloc(), page_simple_validate(), and page_validate().
| #define PAGE_INDEX_ID 28 |
Definition at line 63 of file page0page.h.
| #define PAGE_LAST_INSERT 10 |
Definition at line 44 of file page0page.h.
Referenced by btr_page_get_split_rec_to_left(), btr_page_get_split_rec_to_right(), page_copy_rec_list_end_to_created_page(), page_create(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_cur_search_with_match(), page_delete_rec_list_end(), page_header_print(), and page_parse_copy_rec_list_to_created_page().
| #define PAGE_LEFT 1 |
| #define PAGE_LEVEL 26 |
| #define PAGE_MAX_TRX_ID 18 |
| #define PAGE_N_DIR_SLOTS 0 |
Definition at line 38 of file page0page.h.
Referenced by page_create(), page_dir_delete_slots(), and page_header_print().
| #define PAGE_N_DIRECTION 14 |
Definition at line 48 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_insert_rec_low(), page_cur_search_with_match(), page_header_print(), and page_parse_copy_rec_list_to_created_page().
| #define PAGE_N_HEAP 4 |
| #define PAGE_N_RECS 16 |
Definition at line 50 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_delete_rec_list_end(), page_header_print(), page_simple_validate(), and page_validate().
| #define PAGE_NEW_INFIMUM (PAGE_DATA + REC_N_NEW_EXTRA_BYTES) |
Definition at line 92 of file page0page.h.
Referenced by page_copy_rec_list_end_no_locks(), and page_create().
| #define PAGE_NEW_SUPREMUM (PAGE_DATA + 2 * REC_N_NEW_EXTRA_BYTES + 8) |
Definition at line 95 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_dir_find_owner_slot(), and row_search_for_mysql().
| #define PAGE_NEW_SUPREMUM_END (PAGE_NEW_SUPREMUM + 8) |
Definition at line 98 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), and page_create().
| #define PAGE_NO_DIRECTION 5 |
Definition at line 108 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_insert_rec_low(), and page_parse_copy_rec_list_to_created_page().
| #define PAGE_OLD_INFIMUM (PAGE_DATA + 1 + REC_N_OLD_EXTRA_BYTES) |
Definition at line 83 of file page0page.h.
Referenced by page_copy_rec_list_end_no_locks(), and page_create().
| #define PAGE_OLD_SUPREMUM (PAGE_DATA + 2 + 2 * REC_N_OLD_EXTRA_BYTES + 8) |
Definition at line 86 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_dir_find_owner_slot(), and row_search_for_mysql().
| #define PAGE_OLD_SUPREMUM_END (PAGE_OLD_SUPREMUM + 9) |
Definition at line 89 of file page0page.h.
Referenced by page_copy_rec_list_end_to_created_page(), and page_create().
| #define PAGE_RIGHT 2 |
Definition at line 105 of file page0page.h.
Referenced by page_cur_insert_rec_low(), and page_cur_search_with_match().
| #define PAGE_SAME_PAGE 4 |
Definition at line 107 of file page0page.h.
| #define PAGE_SAME_REC 3 |
Definition at line 106 of file page0page.h.
Typedef Documentation
| typedef byte page_dir_slot_t |
Definition at line 114 of file page0page.h.
| typedef page_dir_slot_t page_dir_t |
Definition at line 115 of file page0page.h.
| typedef byte page_header_t |
Definition at line 33 of file page0page.h.
Function Documentation
| void page_check_dir | ( | page_t * | page | ) |
Definition at line 1502 of file page0page.c.
References buf_page_print(), page_dir_get_n_slots(), page_dir_get_nth_slot(), page_dir_slot_get_rec(), page_get_infimum_rec(), and page_get_supremum_rec().
Referenced by btr_pcur_move_to_next_page(), and page_cur_search_with_match().
01504 : index page */ 01505 { 01506 ulint n_slots; 01507 01508 n_slots = page_dir_get_n_slots(page); 01509 01510 if (page_dir_slot_get_rec(page_dir_get_nth_slot(page, 0)) 01511 != page_get_infimum_rec(page)) { 01512 01513 fprintf(stderr, 01514 "InnoDB: Page directory corruption: supremum not pointed to\n"); 01515 buf_page_print(page); 01516 } 01517 01518 if (page_dir_slot_get_rec(page_dir_get_nth_slot(page, n_slots - 1)) 01519 != page_get_supremum_rec(page)) { 01520 01521 fprintf(stderr, 01522 "InnoDB: Page directory corruption: supremum not pointed to\n"); 01523 buf_page_print(page); 01524 } 01525 }
Here is the call graph for this function:
Here is the caller graph for this function:
| UNIV_INLINE int page_cmp_dtuple_rec_with_match | ( | dtuple_t * | dtuple, | |
| rec_t * | rec, | |||
| const ulint * | offsets, | |||
| ulint * | matched_fields, | |||
| ulint * | matched_bytes | |||
| ) |
Referenced by btr_search_check_guess(), and page_cur_search_with_match().
Here is the caller graph for this function:
| void page_copy_rec_list_end | ( | page_t * | new_page, | |
| page_t * | page, | |||
| rec_t * | rec, | |||
| dict_index_t * | index, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 541 of file page0page.c.
References btr_search_move_or_delete_hash_entries(), index(), lock_move_rec_list_end(), page_copy_rec_list_end_no_locks(), page_copy_rec_list_end_to_created_page(), page_dir_get_n_heap(), page_get_max_trx_id(), and page_update_max_trx_id().
Referenced by btr_compress(), btr_lift_page_up(), and page_move_rec_list_end().
00543 : index page to copy to */ 00544 page_t* page, /* in: index page */ 00545 rec_t* rec, /* in: record on page */ 00546 dict_index_t* index, /* in: record descriptor */ 00547 mtr_t* mtr) /* in: mtr */ 00548 { 00549 if (page_dir_get_n_heap(new_page) == 2) { 00550 page_copy_rec_list_end_to_created_page(new_page, page, rec, 00551 index, mtr); 00552 } else { 00553 page_copy_rec_list_end_no_locks(new_page, page, rec, 00554 index, mtr); 00555 } 00556 00557 /* Update the lock table, MAX_TRX_ID, and possible hash index */ 00558 00559 lock_move_rec_list_end(new_page, page, rec); 00560 00561 page_update_max_trx_id(new_page, page_get_max_trx_id(page)); 00562 00563 btr_search_move_or_delete_hash_entries(new_page, page, index); 00564 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_copy_rec_list_end_no_locks | ( | page_t * | new_page, | |
| page_t * | page, | |||
| rec_t * | rec, | |||
| dict_index_t * | index, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 465 of file page0page.c.
References buf_page_print(), dict_table_is_comp(), index(), mach_read_from_2(), mem_heap_free, NULL, page_cur_get_rec(), page_cur_is_before_first(), page_cur_move_to_next(), page_cur_position(), page_cur_rec_insert(), page_cur_set_before_first(), page_get_supremum_rec(), page_is_comp(), PAGE_NEW_INFIMUM, PAGE_OLD_INFIMUM, rec_get_offsets, REC_OFFS_NORMAL_SIZE, UNIV_PAGE_SIZE, ut_a, ut_error, and ut_print_timestamp().
Referenced by btr_page_reorganize_low(), and page_copy_rec_list_end().
00467 : index page to copy to */ 00468 page_t* page, /* in: index page */ 00469 rec_t* rec, /* in: record on page */ 00470 dict_index_t* index, /* in: record descriptor */ 00471 mtr_t* mtr) /* in: mtr */ 00472 { 00473 page_cur_t cur1; 00474 page_cur_t cur2; 00475 rec_t* sup; 00476 mem_heap_t* heap = NULL; 00477 ulint offsets_[REC_OFFS_NORMAL_SIZE]; 00478 ulint* offsets = offsets_; 00479 *offsets_ = (sizeof offsets_) / sizeof *offsets_; 00480 00481 page_cur_position(rec, &cur1); 00482 00483 if (page_cur_is_before_first(&cur1)) { 00484 00485 page_cur_move_to_next(&cur1); 00486 } 00487 00488 ut_a((ibool)!!page_is_comp(new_page) 00489 == dict_table_is_comp(index->table)); 00490 ut_a(page_is_comp(new_page) == page_is_comp(page)); 00491 ut_a(mach_read_from_2(new_page + UNIV_PAGE_SIZE - 10) == (ulint) 00492 (page_is_comp(new_page) 00493 ? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM)); 00494 00495 page_cur_set_before_first(new_page, &cur2); 00496 00497 /* Copy records from the original page to the new page */ 00498 00499 sup = page_get_supremum_rec(page); 00500 00501 for (;;) { 00502 rec_t* cur1_rec = page_cur_get_rec(&cur1); 00503 if (cur1_rec == sup) { 00504 break; 00505 } 00506 offsets = rec_get_offsets(cur1_rec, index, offsets, 00507 ULINT_UNDEFINED, &heap); 00508 if (UNIV_UNLIKELY(!page_cur_rec_insert(&cur2, cur1_rec, index, 00509 offsets, mtr))) { 00510 /* Track an assertion failure reported on the mailing 00511 list on June 18th, 2003 */ 00512 00513 buf_page_print(new_page); 00514 buf_page_print(page); 00515 ut_print_timestamp(stderr); 00516 00517 fprintf(stderr, 00518 "InnoDB: rec offset %lu, cur1 offset %lu, cur2 offset %lu\n", 00519 (ulong)(rec - page), 00520 (ulong)(page_cur_get_rec(&cur1) - page), 00521 (ulong)(page_cur_get_rec(&cur2) - new_page)); 00522 00523 ut_error; 00524 } 00525 00526 page_cur_move_to_next(&cur1); 00527 page_cur_move_to_next(&cur2); 00528 } 00529 00530 if (UNIV_LIKELY_NULL(heap)) { 00531 mem_heap_free(heap); 00532 } 00533 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_copy_rec_list_start | ( | page_t * | new_page, | |
| page_t * | page, | |||
| rec_t * | rec, | |||
| dict_index_t * | index, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 572 of file page0page.c.
References btr_search_move_or_delete_hash_entries(), index(), lock_move_rec_list_start(), mem_heap_free, NULL, page_cur_get_rec(), page_cur_move_to_next(), page_cur_move_to_prev(), page_cur_rec_insert(), page_cur_set_after_last(), page_cur_set_before_first(), page_get_max_trx_id(), page_update_max_trx_id(), rec_get_offsets, REC_OFFS_NORMAL_SIZE, and ut_a.
Referenced by btr_compress(), and page_move_rec_list_start().
00574 : index page to copy to */ 00575 page_t* page, /* in: index page */ 00576 rec_t* rec, /* in: record on page */ 00577 dict_index_t* index, /* in: record descriptor */ 00578 mtr_t* mtr) /* in: mtr */ 00579 { 00580 page_cur_t cur1; 00581 page_cur_t cur2; 00582 rec_t* old_end; 00583 mem_heap_t* heap = NULL; 00584 ulint offsets_[REC_OFFS_NORMAL_SIZE]; 00585 ulint* offsets = offsets_; 00586 *offsets_ = (sizeof offsets_) / sizeof *offsets_; 00587 00588 page_cur_set_before_first(page, &cur1); 00589 00590 if (rec == page_cur_get_rec(&cur1)) { 00591 00592 return; 00593 } 00594 00595 page_cur_move_to_next(&cur1); 00596 00597 page_cur_set_after_last(new_page, &cur2); 00598 page_cur_move_to_prev(&cur2); 00599 old_end = page_cur_get_rec(&cur2); 00600 00601 /* Copy records from the original page to the new page */ 00602 00603 while (page_cur_get_rec(&cur1) != rec) { 00604 rec_t* ins_rec; 00605 rec_t* cur1_rec = page_cur_get_rec(&cur1); 00606 offsets = rec_get_offsets(cur1_rec, index, offsets, 00607 ULINT_UNDEFINED, &heap); 00608 ins_rec = page_cur_rec_insert(&cur2, cur1_rec, index, 00609 offsets, mtr); 00610 ut_a(ins_rec); 00611 00612 page_cur_move_to_next(&cur1); 00613 page_cur_move_to_next(&cur2); 00614 } 00615 00616 /* Update the lock table, MAX_TRX_ID, and possible hash index */ 00617 00618 lock_move_rec_list_start(new_page, page, rec, old_end); 00619 00620 page_update_max_trx_id(new_page, page_get_max_trx_id(page)); 00621 00622 btr_search_move_or_delete_hash_entries(new_page, page, index); 00623 00624 if (UNIV_LIKELY_NULL(heap)) { 00625 mem_heap_free(heap); 00626 } 00627 }
Here is the call graph for this function:
Here is the caller graph for this function:
| page_t* page_create | ( | buf_frame_t * | frame, | |
| mtr_t * | mtr, | |||
| ulint | comp | |||
| ) |
Definition at line 332 of file page0page.c.
References buf_frame_modify_clock_inc(), DATA_ENGLISH, DATA_NOT_NULL, DATA_VARCHAR, dfield_get_type(), dfield_set_data(), dtuple_create(), dtuple_get_nth_field(), dtuple_set_info_bits(), dtype_set(), srv_sys_struct::dummy_ind1, srv_sys_struct::dummy_ind2, FIL_PAGE_INDEX, fil_page_set_type(), index(), mem_heap_create, mem_heap_free, memset, NULL, page, page_create_write_log(), PAGE_DATA, page_dir_get_nth_slot(), page_dir_slot_set_rec(), PAGE_DIRECTION, PAGE_EMPTY_DIR_START, PAGE_FREE, PAGE_GARBAGE, page_header_set_field(), page_header_set_ptr(), PAGE_HEAP_TOP, PAGE_LAST_INSERT, PAGE_N_DIR_SLOTS, PAGE_N_DIRECTION, PAGE_N_HEAP, PAGE_N_RECS, PAGE_NEW_INFIMUM, PAGE_NEW_SUPREMUM, PAGE_NEW_SUPREMUM_END, PAGE_NO_DIRECTION, PAGE_OLD_INFIMUM, PAGE_OLD_SUPREMUM, PAGE_OLD_SUPREMUM_END, page_set_max_trx_id(), page_t, rec_convert_dtuple_to_rec(), rec_get_end(), rec_get_offsets, rec_set_heap_no(), rec_set_n_owned(), rec_set_next_offs(), REC_STATUS_INFIMUM, REC_STATUS_SUPREMUM, srv_sys, UNIV_PAGE_SIZE, ut_a, ut_ad, and ut_dulint_zero.
Referenced by btr_create(), btr_page_create(), btr_page_empty(), btr_page_reorganize_low(), and page_parse_create().
00334 : pointer to the page */ 00335 buf_frame_t* frame, /* in: a buffer frame where the page is 00336 created */ 00337 mtr_t* mtr, /* in: mini-transaction handle */ 00338 ulint comp) /* in: nonzero=compact page format */ 00339 { 00340 page_dir_slot_t* slot; 00341 mem_heap_t* heap; 00342 dtuple_t* tuple; 00343 dfield_t* field; 00344 byte* heap_top; 00345 rec_t* infimum_rec; 00346 rec_t* supremum_rec; 00347 page_t* page; 00348 dict_index_t* index; 00349 ulint* offsets; 00350 00351 index = comp ? srv_sys->dummy_ind2 : srv_sys->dummy_ind1; 00352 00353 ut_ad(frame && mtr); 00354 #if PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE > PAGE_DATA 00355 # error "PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE > PAGE_DATA" 00356 #endif 00357 #if PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE > PAGE_DATA 00358 # error "PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE > PAGE_DATA" 00359 #endif 00360 00361 /* 1. INCREMENT MODIFY CLOCK */ 00362 buf_frame_modify_clock_inc(frame); 00363 00364 /* 2. WRITE LOG INFORMATION */ 00365 page_create_write_log(frame, mtr, comp); 00366 00367 page = frame; 00368 00369 fil_page_set_type(page, FIL_PAGE_INDEX); 00370 00371 heap = mem_heap_create(200); 00372 00373 /* 3. CREATE THE INFIMUM AND SUPREMUM RECORDS */ 00374 00375 /* Create first a data tuple for infimum record */ 00376 tuple = dtuple_create(heap, 1); 00377 dtuple_set_info_bits(tuple, REC_STATUS_INFIMUM); 00378 field = dtuple_get_nth_field(tuple, 0); 00379 00380 dfield_set_data(field, "infimum", 8); 00381 dtype_set(dfield_get_type(field), 00382 DATA_VARCHAR, DATA_ENGLISH | DATA_NOT_NULL, 8, 0); 00383 /* Set the corresponding physical record to its place in the page 00384 record heap */ 00385 00386 heap_top = page + PAGE_DATA; 00387 00388 infimum_rec = rec_convert_dtuple_to_rec(heap_top, index, tuple); 00389 00390 ut_a(infimum_rec == 00391 page + (comp ? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM)); 00392 00393 rec_set_n_owned(infimum_rec, comp, 1); 00394 rec_set_heap_no(infimum_rec, comp, 0); 00395 offsets = rec_get_offsets(infimum_rec, index, NULL, 00396 ULINT_UNDEFINED, &heap); 00397 00398 heap_top = rec_get_end(infimum_rec, offsets); 00399 00400 /* Create then a tuple for supremum */ 00401 00402 tuple = dtuple_create(heap, 1); 00403 dtuple_set_info_bits(tuple, REC_STATUS_SUPREMUM); 00404 field = dtuple_get_nth_field(tuple, 0); 00405 00406 dfield_set_data(field, "supremum", comp ? 8 : 9); 00407 dtype_set(dfield_get_type(field), 00408 DATA_VARCHAR, DATA_ENGLISH | DATA_NOT_NULL, comp ? 8 : 9, 0); 00409 00410 supremum_rec = rec_convert_dtuple_to_rec(heap_top, index, tuple); 00411 00412 ut_a(supremum_rec == 00413 page + (comp ? PAGE_NEW_SUPREMUM : PAGE_OLD_SUPREMUM)); 00414 00415 rec_set_n_owned(supremum_rec, comp, 1); 00416 rec_set_heap_no(supremum_rec, comp, 1); 00417 00418 offsets = rec_get_offsets(supremum_rec, index, offsets, 00419 ULINT_UNDEFINED, &heap); 00420 heap_top = rec_get_end(supremum_rec, offsets); 00421 00422 ut_ad(heap_top == 00423 page + (comp ? PAGE_NEW_SUPREMUM_END : PAGE_OLD_SUPREMUM_END)); 00424 00425 mem_heap_free(heap); 00426 00427 /* 4. INITIALIZE THE PAGE */ 00428 00429 page_header_set_field(page, PAGE_N_DIR_SLOTS, 2); 00430 page_header_set_ptr(page, PAGE_HEAP_TOP, heap_top); 00431 page_header_set_field(page, PAGE_N_HEAP, comp ? 0x8002 : 2); 00432 page_header_set_ptr(page, PAGE_FREE, NULL); 00433 page_header_set_field(page, PAGE_GARBAGE, 0); 00434 page_header_set_ptr(page, PAGE_LAST_INSERT, NULL); 00435 page_header_set_field(page, PAGE_DIRECTION, PAGE_NO_DIRECTION); 00436 page_header_set_field(page, PAGE_N_DIRECTION, 0); 00437 page_header_set_field(page, PAGE_N_RECS, 0); 00438 page_set_max_trx_id(page, ut_dulint_zero); 00439 memset(heap_top, 0, UNIV_PAGE_SIZE - PAGE_EMPTY_DIR_START 00440 - (heap_top - page)); 00441 00442 /* 5. SET POINTERS IN RECORDS AND DIR SLOTS */ 00443 00444 /* Set the slots to point to infimum and supremum. */ 00445 00446 slot = page_dir_get_nth_slot(page, 0); 00447 page_dir_slot_set_rec(slot, infimum_rec); 00448 00449 slot = page_dir_get_nth_slot(page, 1); 00450 page_dir_slot_set_rec(slot, supremum_rec); 00451 00452 /* Set the next pointers in infimum and supremum */ 00453 00454 rec_set_next_offs(infimum_rec, comp, (ulint)(supremum_rec - page)); 00455 rec_set_next_offs(supremum_rec, comp, 0); 00456 00457 return(page); 00458 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_delete_rec_list_end | ( | page_t * | page, | |
| rec_t * | rec, | |||
| dict_index_t * | index, | |||
| ulint | n_recs, | |||
| ulint | size, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 712 of file page0page.c.
References buf_frame_modify_clock_inc(), count, free, index(), mem_heap_free, MLOG_COMP_LIST_END_DELETE, MLOG_LIST_END_DELETE, NULL, page_delete_rec_list_write_log(), page_dir_find_owner_slot(), page_dir_get_nth_slot(), page_dir_set_n_slots(), page_dir_slot_set_n_owned(), page_dir_slot_set_rec(), PAGE_FREE, PAGE_GARBAGE, page_get_n_recs(), page_get_supremum_rec(), page_header_get_field(), page_header_get_ptr(), page_header_set_field(), page_header_set_ptr(), page_is_comp(), PAGE_LAST_INSERT, PAGE_N_RECS, page_rec_get_next(), page_rec_get_prev(), page_rec_is_infimum_low(), page_rec_set_next(), rec_get_n_owned(), rec_get_offsets, rec_offs_extra_size(), REC_OFFS_NORMAL_SIZE, rec_offs_size(), UNIV_PAGE_SIZE, and ut_ad.
Referenced by page_move_rec_list_end(), and page_parse_delete_rec_list().
00714 : index page */ 00715 rec_t* rec, /* in: record on page */ 00716 dict_index_t* index, /* in: record descriptor */ 00717 ulint n_recs, /* in: number of records to delete, 00718 or ULINT_UNDEFINED if not known */ 00719 ulint size, /* in: the sum of the sizes of the 00720 records in the end of the chain to 00721 delete, or ULINT_UNDEFINED if not known */ 00722 mtr_t* mtr) /* in: mtr */ 00723 { 00724 page_dir_slot_t* slot; 00725 ulint slot_index; 00726 rec_t* last_rec; 00727 rec_t* prev_rec; 00728 rec_t* free; 00729 rec_t* rec2; 00730 ulint count; 00731 ulint n_owned; 00732 rec_t* sup; 00733 ulint comp; 00734 00735 /* Reset the last insert info in the page header and increment 00736 the modify clock for the frame */ 00737 00738 ut_ad(size == ULINT_UNDEFINED || size < UNIV_PAGE_SIZE); 00739 page_header_set_ptr(page, PAGE_LAST_INSERT, NULL); 00740 00741 /* The page gets invalid for optimistic searches: increment the 00742 frame modify clock */ 00743 00744 buf_frame_modify_clock_inc(page); 00745 00746 sup = page_get_supremum_rec(page); 00747 00748 comp = page_is_comp(page); 00749 if (page_rec_is_infimum_low(rec - page)) { 00750 rec = page_rec_get_next(rec); 00751 } 00752 00753 page_delete_rec_list_write_log(rec, index, 00754 comp ? MLOG_COMP_LIST_END_DELETE : MLOG_LIST_END_DELETE, mtr); 00755 00756 if (rec == sup) { 00757 00758 return; 00759 } 00760 00761 prev_rec = page_rec_get_prev(rec); 00762 00763 last_rec = page_rec_get_prev(sup); 00764 00765 if ((size == ULINT_UNDEFINED) || (n_recs == ULINT_UNDEFINED)) { 00766 mem_heap_t* heap = NULL; 00767 ulint offsets_[REC_OFFS_NORMAL_SIZE]; 00768 ulint* offsets = offsets_; 00769 *offsets_ = (sizeof offsets_) / sizeof *offsets_; 00770 /* Calculate the sum of sizes and the number of records */ 00771 size = 0; 00772 n_recs = 0; 00773 rec2 = rec; 00774 00775 while (rec2 != sup) { 00776 ulint s; 00777 offsets = rec_get_offsets(rec2, index, offsets, 00778 ULINT_UNDEFINED, &heap); 00779 s = rec_offs_size(offsets); 00780 ut_ad(rec2 - page + s - rec_offs_extra_size(offsets) 00781 < UNIV_PAGE_SIZE); 00782 ut_ad(size + s < UNIV_PAGE_SIZE); 00783 size += s; 00784 n_recs++; 00785 00786 rec2 = page_rec_get_next(rec2); 00787 } 00788 00789 if (UNIV_LIKELY_NULL(heap)) { 00790 mem_heap_free(heap); 00791 } 00792 } 00793 00794 ut_ad(size < UNIV_PAGE_SIZE); 00795 00796 /* Update the page directory; there is no need to balance the number 00797 of the records owned by the supremum record, as it is allowed to be 00798 less than PAGE_DIR_SLOT_MIN_N_OWNED */ 00799 00800 rec2 = rec; 00801 count = 0; 00802 00803 while (rec_get_n_owned(rec2, comp) == 0) { 00804 count++; 00805 00806 rec2 = page_rec_get_next(rec2); 00807 } 00808 00809 ut_ad(rec_get_n_owned(rec2, comp) - count > 0); 00810 00811 n_owned = rec_get_n_owned(rec2, comp) - count; 00812 00813 slot_index = page_dir_find_owner_slot(rec2); 00814 slot = page_dir_get_nth_slot(page, slot_index); 00815 00816 page_dir_slot_set_rec(slot, sup); 00817 page_dir_slot_set_n_owned(slot, n_owned); 00818 00819 page_dir_set_n_slots(page, slot_index + 1); 00820 00821 /* Remove the record chain segment from the record chain */ 00822 page_rec_set_next(prev_rec, page_get_supremum_rec(page)); 00823 00824 /* Catenate the deleted chain segment to the page free list */ 00825 00826 free = page_header_get_ptr(page, PAGE_FREE); 00827 00828 page_rec_set_next(last_rec, free); 00829 page_header_set_ptr(page, PAGE_FREE, rec); 00830 00831 page_header_set_field(page, PAGE_GARBAGE, 00832 size + page_header_get_field(page, PAGE_GARBAGE)); 00833 00834 page_header_set_field(page, PAGE_N_RECS, 00835 (ulint)(page_get_n_recs(page) - n_recs)); 00836 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_delete_rec_list_start | ( | page_t * | page, | |
| rec_t * | rec, | |||
| dict_index_t * | index, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 843 of file page0page.c.
References dict_table_is_comp(), index(), mem_heap_free, MLOG_COMP_LIST_START_DELETE, MLOG_LIST_START_DELETE, MTR_LOG_NONE, mtr_set_log_mode(), NULL, page_cur_delete_rec(), page_cur_get_rec(), page_cur_move_to_next(), page_cur_set_before_first(), page_delete_rec_list_write_log(), page_is_comp(), rec_get_offsets, REC_OFFS_NORMAL_SIZE, and ut_ad.
Referenced by page_move_rec_list_start(), and page_parse_delete_rec_list().
00845 : index page */ 00846 rec_t* rec, /* in: record on page */ 00847 dict_index_t* index, /* in: record descriptor */ 00848 mtr_t* mtr) /* in: mtr */ 00849 { 00850 page_cur_t cur1; 00851 ulint log_mode; 00852 ulint offsets_[REC_OFFS_NORMAL_SIZE]; 00853 ulint* offsets = offsets_; 00854 mem_heap_t* heap = NULL; 00855 byte type; 00856 *offsets_ = (sizeof offsets_) / sizeof *offsets_; 00857 00858 ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table)); 00859 00860 if (page_is_comp(page)) { 00861 type = MLOG_COMP_LIST_START_DELETE; 00862 } else { 00863 type = MLOG_LIST_START_DELETE; 00864 } 00865 00866 page_delete_rec_list_write_log(rec, index, type, mtr); 00867 00868 page_cur_set_before_first(page, &cur1); 00869 00870 if (rec == page_cur_get_rec(&cur1)) { 00871 00872 return; 00873 } 00874 00875 page_cur_move_to_next(&cur1); 00876 00877 /* Individual deletes are not logged */ 00878 00879 log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE); 00880 00881 while (page_cur_get_rec(&cur1) != rec) { 00882 offsets = rec_get_offsets(page_cur_get_rec(&cur1), index, 00883 offsets, ULINT_UNDEFINED, &heap); 00884 page_cur_delete_rec(&cur1, index, offsets, mtr); 00885 } 00886 00887 if (UNIV_LIKELY_NULL(heap)) { 00888 mem_heap_free(heap); 00889 } 00890 00891 /* Restore log mode */ 00892 00893 mtr_set_log_mode(mtr, log_mode); 00894 }
Here is the call graph for this function:
Here is the caller graph for this function:
Definition at line 1123 of file page0page.c.
References page_dir_delete_slots(), page_dir_get_n_slots(), page_dir_get_nth_slot(), page_dir_slot_get_n_owned(), page_dir_slot_get_rec(), PAGE_DIR_SLOT_MAX_N_OWNED, PAGE_DIR_SLOT_MIN_N_OWNED, page_dir_slot_set_n_owned(), page_dir_slot_set_rec(), page_is_comp(), page_rec_get_next(), rec_set_n_owned(), and ut_ad.
Referenced by page_cur_delete_rec().
01125 : index page */ 01126 ulint slot_no) /* in: the directory slot */ 01127 { 01128 page_dir_slot_t* slot; 01129 page_dir_slot_t* up_slot; 01130 ulint n_owned; 01131 ulint up_n_owned; 01132 rec_t* old_rec; 01133 rec_t* new_rec; 01134 01135 ut_ad(page); 01136 ut_ad(slot_no > 0); 01137 01138 slot = page_dir_get_nth_slot(page, slot_no); 01139 01140 /* The last directory slot cannot be balanced with the upper 01141 neighbor, as there is none. */ 01142 01143 if (slot_no == page_dir_get_n_slots(page) - 1) { 01144 01145 return; 01146 } 01147 01148 up_slot = page_dir_get_nth_slot(page, slot_no + 1); 01149 01150 n_owned = page_dir_slot_get_n_owned(slot); 01151 up_n_owned = page_dir_slot_get_n_owned(up_slot); 01152 01153 ut_ad(n_owned == PAGE_DIR_SLOT_MIN_N_OWNED - 1); 01154 01155 /* If the upper slot has the minimum value of n_owned, we will merge 01156 the two slots, therefore we assert: */ 01157 ut_ad(2 * PAGE_DIR_SLOT_MIN_N_OWNED - 1 <= PAGE_DIR_SLOT_MAX_N_OWNED); 01158 01159 if (up_n_owned > PAGE_DIR_SLOT_MIN_N_OWNED) { 01160 01161 /* In this case we can just transfer one record owned 01162 by the upper slot to the property of the lower slot */ 01163 old_rec = page_dir_slot_get_rec(slot); 01164 new_rec = page_rec_get_next(old_rec); 01165 01166 rec_set_n_owned(old_rec, page_is_comp(page), 0); 01167 rec_set_n_owned(new_rec, page_is_comp(page), n_owned + 1); 01168 01169 page_dir_slot_set_rec(slot, new_rec); 01170 01171 page_dir_slot_set_n_owned(up_slot, up_n_owned -1); 01172 } else { 01173 /* In this case we may merge the two slots */ 01174 page_dir_delete_slots(page, slot_no, 1); 01175 } 01176 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by btr_page_get_sure_split_rec(), btr_page_insert_fits(), ibuf_insert_low(), ibuf_merge_or_delete_for_page(), and ibuf_rec_get_volume().
Here is the caller graph for this function:
Definition at line 70 of file page0page.c.
References buf_frame_align(), buf_frame_get_page_no(), buf_page_print(), FALSE, mach_decode_2(), mach_encode_2(), page, PAGE_DIR, page_dir_get_n_slots(), page_dir_get_nth_slot(), PAGE_DIR_SLOT_SIZE, page_is_comp(), PAGE_NEW_SUPREMUM, PAGE_OLD_SUPREMUM, page_rec_check(), page_t, rec_get_n_owned(), rec_get_next_offs(), rec_print_old(), TRUE, UNIV_PAGE_SIZE, ut_ad, and ut_error.
Referenced by page_cur_delete_rec(), page_cur_insert_rec_low(), and page_delete_rec_list_end().
00072 : the directory slot number */ 00073 rec_t* rec) /* in: the physical record */ 00074 { 00075 page_t* page; 00076 register uint16 rec_offs_bytes; 00077 register page_dir_slot_t* slot; 00078 register const page_dir_slot_t* first_slot; 00079 register rec_t* r = rec; 00080 00081 ut_ad(page_rec_check(rec)); 00082 00083 page = buf_frame_align(rec); 00084 first_slot = page_dir_get_nth_slot(page, 0); 00085 slot = page_dir_get_nth_slot(page, page_dir_get_n_slots(page) - 1); 00086 00087 if (page_is_comp(page)) { 00088 while (rec_get_n_owned(r, TRUE) == 0) { 00089 r = page + rec_get_next_offs(r, TRUE); 00090 ut_ad(r >= page + PAGE_NEW_SUPREMUM); 00091 ut_ad(r < page + (UNIV_PAGE_SIZE - PAGE_DIR)); 00092 } 00093 } else { 00094 while (rec_get_n_owned(r, FALSE) == 0) { 00095 r = page + rec_get_next_offs(r, FALSE); 00096 ut_ad(r >= page + PAGE_OLD_SUPREMUM); 00097 ut_ad(r < page + (UNIV_PAGE_SIZE - PAGE_DIR)); 00098 } 00099 } 00100 00101 rec_offs_bytes = mach_encode_2(r - page); 00102 00103 while (UNIV_LIKELY(*(uint16*) slot != rec_offs_bytes)) { 00104 00105 if (UNIV_UNLIKELY(slot == first_slot)) { 00106 fprintf(stderr, 00107 "InnoDB: Probable data corruption on page %lu\n" 00108 "InnoDB: Original record ", 00109 (ulong) buf_frame_get_page_no(page)); 00110 00111 if (page_is_comp(page)) { 00112 fputs("(compact record)", stderr); 00113 } else { 00114 rec_print_old(stderr, rec); 00115 } 00116 00117 fputs("\n" 00118 "InnoDB: on that page.\n" 00119 "InnoDB: Cannot find the dir slot for record ", 00120 stderr); 00121 if (page_is_comp(page)) { 00122 fputs("(compact record)", stderr); 00123 } else { 00124 rec_print_old(stderr, page 00125 + mach_decode_2(rec_offs_bytes)); 00126 } 00127 fputs("\n" 00128 "InnoDB: on that page!\n", stderr); 00129 00130 buf_page_print(page); 00131 00132 ut_error; 00133 } 00134 00135 slot += PAGE_DIR_SLOT_SIZE; 00136 } 00137 00138 return(((ulint) (first_slot - slot)) / PAGE_DIR_SLOT_SIZE); 00139 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by lock_rec_create(), page_copy_rec_list_end(), page_copy_rec_list_end_to_created_page(), page_header_print(), page_mem_alloc(), page_rec_validate(), page_simple_validate(), and page_validate().
Here is the caller graph for this function:
Referenced by page_check_dir(), page_cur_search_with_match(), page_dir_add_slots(), page_dir_balance_slot(), page_dir_delete_slots(), page_dir_find_owner_slot(), page_dir_print(), page_dir_slot_check(), page_simple_validate(), and page_validate().
Here is the caller graph for this function:
| UNIV_INLINE page_dir_slot_t* page_dir_get_nth_slot | ( | page_t * | page, | |
| ulint | n | |||
| ) |
Referenced by page_check_dir(), page_copy_rec_list_end_to_created_page(), page_create(), page_cur_delete_rec(), page_cur_search_with_match(), page_delete_rec_list_end(), page_dir_add_slots(), page_dir_balance_slot(), page_dir_delete_slots(), page_dir_find_owner_slot(), page_dir_print(), page_dir_slot_check(), page_dir_split_slot(), page_get_middle_rec(), page_rec_get_n_recs_before(), page_simple_validate(), and page_validate().
Here is the caller graph for this function:
Definition at line 1302 of file page0page.c.
References n, page_dir_get_n_slots(), page_dir_get_nth_slot(), page_dir_slot_get_n_owned(), page_dir_slot_get_rec(), and page_get_n_recs().
Referenced by page_print().
01304 : index page */ 01305 ulint pr_n) /* in: print n first and n last entries */ 01306 { 01307 ulint n; 01308 ulint i; 01309 page_dir_slot_t* slot; 01310 01311 n = page_dir_get_n_slots(page); 01312 01313 fprintf(stderr, "--------------------------------\n" 01314 "PAGE DIRECTORY\n" 01315 "Page address %p\n" 01316 "Directory stack top at offs: %lu; number of slots: %lu\n", 01317 page, (ulong)(page_dir_get_nth_slot(page, n - 1) - page), (ulong) n); 01318 for (i = 0; i < n; i++) { 01319 slot = page_dir_get_nth_slot(page, i); 01320 if ((i == pr_n) && (i < n - pr_n)) { 01321 fputs(" ... \n", stderr); 01322 } 01323 if ((i < pr_n) || (i >= n - pr_n)) { 01324 fprintf(stderr, 01325 "Contents of slot: %lu: n_owned: %lu, rec offs: %lu\n", 01326 (ulong) i, (ulong) page_dir_slot_get_n_owned(slot), 01327 (ulong)(page_dir_slot_get_rec(slot) - page)); 01328 } 01329 } 01330 fprintf(stderr, "Total of %lu records\n" 01331 "--------------------------------\n", 01332 (ulong) (2 + page_get_n_recs(page))); 01333 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by page_copy_rec_list_end_to_created_page(), and page_mem_alloc().
Here is the caller graph for this function:
Referenced by page_copy_rec_list_end_to_created_page(), page_delete_rec_list_end(), and page_dir_add_slots().
Here is the caller graph for this function:
| UNIV_INLINE ulint page_dir_slot_get_n_owned | ( | page_dir_slot_t * | slot | ) |
Referenced by page_cur_delete_rec(), page_dir_balance_slot(), page_dir_delete_slots(), page_dir_print(), page_dir_split_slot(), and page_get_middle_rec().
Here is the caller graph for this function:
| UNIV_INLINE rec_t* page_dir_slot_get_rec | ( | page_dir_slot_t * | slot | ) |
Referenced by page_check_dir(), page_cur_delete_rec(), page_cur_search_with_match(), page_dir_add_slots(), page_dir_balance_slot(), page_dir_delete_slots(), page_dir_print(), page_dir_slot_check(), page_dir_split_slot(), page_get_middle_rec(), page_rec_get_n_recs_before(), page_simple_validate(), and page_validate().
Here is the caller graph for this function:
| UNIV_INLINE void page_dir_slot_set_n_owned | ( | page_dir_slot_t * | slot, | |
| ulint | n | |||
| ) |
Referenced by page_copy_rec_list_end_to_created_page(), page_cur_delete_rec(), page_delete_rec_list_end(), page_dir_balance_slot(), page_dir_delete_slots(), and page_dir_split_slot().
Here is the caller graph for this function:
| UNIV_INLINE void page_dir_slot_set_rec | ( | page_dir_slot_t * | slot, | |
| rec_t * | rec | |||
| ) |
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_delete_rec(), page_delete_rec_list_end(), page_dir_add_slots(), page_dir_balance_slot(), page_dir_delete_slots(), and page_dir_split_slot().
Here is the caller graph for this function:
Definition at line 1063 of file page0page.c.
References page_dir_add_slots(), page_dir_get_nth_slot(), page_dir_slot_get_n_owned(), page_dir_slot_get_rec(), PAGE_DIR_SLOT_MAX_N_OWNED, PAGE_DIR_SLOT_MIN_N_OWNED, page_dir_slot_set_n_owned(), page_dir_slot_set_rec(), page_rec_get_next(), and ut_ad.
Referenced by page_cur_insert_rec_low().
01065 : the index page in question */ 01066 ulint slot_no) /* in: the directory slot */ 01067 { 01068 rec_t* rec; 01069 page_dir_slot_t* new_slot; 01070 page_dir_slot_t* prev_slot; 01071 page_dir_slot_t* slot; 01072 ulint i; 01073 ulint n_owned; 01074 01075 ut_ad(page); 01076 ut_ad(slot_no > 0); 01077 01078 slot = page_dir_get_nth_slot(page, slot_no); 01079 01080 n_owned = page_dir_slot_get_n_owned(slot); 01081 ut_ad(n_owned == PAGE_DIR_SLOT_MAX_N_OWNED + 1); 01082 01083 /* 1. We loop to find a record approximately in the middle of the 01084 records owned by the slot. */ 01085 01086 prev_slot = page_dir_get_nth_slot(page, slot_no - 1); 01087 rec = page_dir_slot_get_rec(prev_slot); 01088 01089 for (i = 0; i < n_owned / 2; i++) { 01090 rec = page_rec_get_next(rec); 01091 } 01092 01093 ut_ad(n_owned / 2 >= PAGE_DIR_SLOT_MIN_N_OWNED); 01094 01095 /* 2. We add one directory slot immediately below the slot to be 01096 split. */ 01097 01098 page_dir_add_slots(page, slot_no - 1, 1); 01099 01100 /* The added slot is now number slot_no, and the old slot is 01101 now number slot_no + 1 */ 01102 01103 new_slot = page_dir_get_nth_slot(page, slot_no); 01104 slot = page_dir_get_nth_slot(page, slot_no + 1); 01105 01106 /* 3. We store the appropriate values to the new slot. */ 01107 01108 page_dir_slot_set_rec(new_slot, rec); 01109 page_dir_slot_set_n_owned(new_slot, n_owned / 2); 01110 01111 /* 4. Finally, we update the number of records field of the 01112 original slot */ 01113 01114 page_dir_slot_set_n_owned(slot, n_owned - (n_owned / 2)); 01115 }
Here is the call graph for this function:
Here is the caller graph for this function:
Definition at line 1977 of file page0page.c.
References NULL, page_cur_is_after_last(), page_cur_move_to_next(), page_cur_set_before_first(), page_is_comp(), page_cur_struct::rec, and rec_get_heap_no().
Referenced by lock_rec_print(), and lock_rec_validate_page().
01979 : record, NULL if not found */ 01980 page_t* page, /* in: index page */ 01981 ulint heap_no)/* in: heap number */ 01982 { 01983 page_cur_t cur; 01984 01985 page_cur_set_before_first(page, &cur); 01986 01987 for (;;) { 01988 if (rec_get_heap_no(cur.rec, page_is_comp(page)) == heap_no) { 01989 01990 return(cur.rec); 01991 } 01992 01993 if (page_cur_is_after_last(&cur)) { 01994 01995 return(NULL); 01996 } 01997 01998 page_cur_move_to_next(&cur); 01999 } 02000 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_optimistic_update(), btr_page_get_sure_split_rec(), btr_page_insert_fits(), btr_page_reorganize_low(), page_move_rec_list_end(), and page_validate().
Here is the caller graph for this function:
Referenced by btr_cur_optimistic_insert(), btr_cur_optimistic_update(), btr_cur_pessimistic_insert(), btr_cur_pessimistic_update(), btr_page_get_sure_split_rec(), btr_page_insert_fits(), dtuple_convert_big_rec(), and ibuf_insert().
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_pess_upd_restore_supremum(), btr_cur_pessimistic_delete(), btr_discard_page(), btr_estimate_number_of_different_key_vals(), btr_get_next_user_rec(), btr_lift_page_up(), btr_page_get_father_for_rec(), btr_page_get_father_node_ptr(), btr_page_get_split_rec_to_left(), btr_page_get_sure_split_rec(), btr_page_insert_fits(), btr_page_reorganize_low(), btr_root_raise_and_insert(), btr_search_build_page_hash_index(), btr_search_drop_page_hash_index(), btr_validate_level(), ibuf_get_volume_buffered(), ibuf_insert_to_index_page(), lock_rec_restore_from_page_infimum(), lock_rec_store_on_page_infimum(), lock_update_discard(), lock_update_split_left(), lock_update_split_right(), page_check_dir(), page_copy_rec_list_end_to_created_page(), page_cur_delete_rec(), page_cur_open_on_rnd_user_rec(), page_cur_search_with_match(), row_ins_index_entry_low(), and row_ins_scan_sec_index_for_duplicate().
Here is the caller graph for this function:
Referenced by btr_compress(), btr_create(), btr_cur_optimistic_insert(), ibuf_insert_to_index_page(), and page_mem_alloc().
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_optimistic_delete(), btr_cur_optimistic_insert(), btr_cur_optimistic_update(), and btr_page_reorganize_low().
Here is the caller graph for this function:
Referenced by btr_page_reorganize_low(), ibuf_merge_or_delete_for_page(), lock_sec_rec_cons_read_sees(), lock_sec_rec_read_check_and_lock(), lock_sec_rec_some_has_impl_off_kernel(), page_copy_rec_list_end(), and page_copy_rec_list_start().
Here is the caller graph for this function:
Definition at line 1183 of file page0page.c.
References count, page_dir_get_nth_slot(), page_dir_slot_get_n_owned(), page_dir_slot_get_rec(), page_get_n_recs(), page_rec_get_next(), and ut_ad.
Referenced by btr_page_split_and_insert().
01185 : middle record */ 01186 page_t* page) /* in: page */ 01187 { 01188 page_dir_slot_t* slot; 01189 ulint middle; 01190 ulint i; 01191 ulint n_owned; 01192 ulint count; 01193 rec_t* rec; 01194 01195 /* This many records we must leave behind */ 01196 middle = (page_get_n_recs(page) + 2) / 2; 01197 01198 count = 0; 01199 01200 for (i = 0;; i++) { 01201 01202 slot = page_dir_get_nth_slot(page, i); 01203 n_owned = page_dir_slot_get_n_owned(slot); 01204 01205 if (count + n_owned > middle) { 01206 break; 01207 } else { 01208 count += n_owned; 01209 } 01210 } 01211 01212 ut_ad(i > 0); 01213 slot = page_dir_get_nth_slot(page, i - 1); 01214 rec = page_dir_slot_get_rec(slot); 01215 rec = page_rec_get_next(rec); 01216 01217 /* There are now count records behind rec */ 01218 01219 for (i = 0; i < middle - count; i++) { 01220 rec = page_rec_get_next(rec); 01221 } 01222 01223 return(rec); 01224 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_add_path_info(), btr_cur_optimistic_insert(), btr_cur_optimistic_update(), btr_cur_pessimistic_delete(), btr_discard_only_page_on_level(), btr_page_get_sure_split_rec(), btr_page_insert_fits(), btr_page_split_and_insert(), btr_pcur_store_position(), btr_search_build_page_hash_index(), btr_search_drop_page_hash_index(), btr_search_update_block_hash_info(), btr_validate_level(), ibuf_data_sizes_update(), ibuf_is_empty(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_cur_open_on_rnd_user_rec(), page_delete_rec_list_end(), page_dir_print(), page_get_middle_rec(), page_move_rec_list_end(), and page_print_list().
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_pess_upd_restore_supremum(), btr_discard_only_page_on_level(), btr_discard_page(), btr_estimate_number_of_different_key_vals(), btr_get_prev_user_rec(), btr_page_insert_fits(), btr_validate_level(), ibuf_get_volume_buffered(), lock_move_rec_list_end(), lock_move_reorganize_page(), lock_rec_create(), lock_update_copy_and_discard(), lock_update_merge_left(), lock_update_merge_right(), lock_update_root_raise(), lock_update_split_left(), lock_update_split_right(), page_check_dir(), page_copy_rec_list_end_no_locks(), page_copy_rec_list_end_to_created_page(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_cur_parse_insert_rec(), page_cur_search_with_match(), page_delete_rec_list_end(), and row_ins_index_entry_low().
Here is the caller graph for this function:
Referenced by page_cur_insert_rec_low(), page_cur_search_with_match(), page_delete_rec_list_end(), page_header_print(), page_mem_alloc(), page_simple_validate(), and page_validate().
Here is the caller graph for this function:
Referenced by btr_page_get_split_rec_to_left(), btr_page_get_split_rec_to_right(), page_cur_insert_rec_low(), page_cur_search_with_match(), page_delete_rec_list_end(), page_mem_alloc(), page_simple_validate(), and page_validate().
Here is the caller graph for this function:
| void page_header_print | ( | page_t * | page | ) |
Definition at line 1409 of file page0page.c.
References page_dir_get_n_heap(), PAGE_DIRECTION, PAGE_FREE, PAGE_GARBAGE, page_header_get_field(), PAGE_HEAP_TOP, page_is_comp(), PAGE_LAST_INSERT, PAGE_N_DIR_SLOTS, PAGE_N_DIRECTION, and PAGE_N_RECS.
Referenced by page_print().
01412 { 01413 fprintf(stderr, 01414 "--------------------------------\n" 01415 "PAGE HEADER INFO\n" 01416 "Page address %p, n records %lu (%s)\n" 01417 "n dir slots %lu, heap top %lu\n" 01418 "Page n heap %lu, free %lu, garbage %lu\n" 01419 "Page last insert %lu, direction %lu, n direction %lu\n", 01420 page, (ulong) page_header_get_field(page, PAGE_N_RECS), 01421 page_is_comp(page) ? "compact format" : "original format", 01422 (ulong) page_header_get_field(page, PAGE_N_DIR_SLOTS), 01423 (ulong) page_header_get_field(page, PAGE_HEAP_TOP), 01424 (ulong) page_dir_get_n_heap(page), 01425 (ulong) page_header_get_field(page, PAGE_FREE), 01426 (ulong) page_header_get_field(page, PAGE_GARBAGE), 01427 (ulong) page_header_get_field(page, PAGE_LAST_INSERT), 01428 (ulong) page_header_get_field(page, PAGE_DIRECTION), 01429 (ulong) page_header_get_field(page, PAGE_N_DIRECTION)); 01430 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_delete_rec_list_end(), page_dir_delete_slots(), page_mem_alloc(), and page_parse_copy_rec_list_to_created_page().
Here is the caller graph for this function:
Referenced by page_copy_rec_list_end_to_created_page(), page_create(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_delete_rec_list_end(), page_mem_alloc(), and page_parse_copy_rec_list_to_created_page().
Here is the caller graph for this function:
Referenced by btr_attach_half_pages(), btr_compress(), btr_cur_del_mark_set_sec_rec(), btr_cur_del_unmark_for_ibuf(), btr_cur_latch_leaves(), btr_cur_optimistic_insert(), btr_cur_optimistic_update(), btr_cur_parse_del_mark_set_clust_rec(), btr_cur_parse_del_mark_set_sec_rec(), btr_cur_parse_update_in_place(), btr_cur_pessimistic_delete(), btr_cur_pessimistic_insert(), btr_cur_pessimistic_update(), btr_cur_search_to_nth_level(), btr_cur_update_in_place(), btr_cur_update_in_place_log(), btr_discard_page(), btr_get_next_user_rec(), btr_get_prev_user_rec(), btr_index_rec_validate(), btr_level_list_remove(), btr_page_empty(), btr_page_get_sure_split_rec(), btr_page_insert_fits(), btr_page_reorganize_low(), btr_parse_set_min_rec_mark(), btr_pcur_move_to_next_page(), btr_root_get(), btr_root_raise_and_insert(), btr_search_move_or_delete_hash_entries(), btr_validate_level(), dict_truncate_index_tree(), ibuf_insert_to_index_page(), lock_move_rec_list_end(), lock_move_rec_list_start(), lock_move_reorganize_page(), lock_rec_create(), lock_rec_restore_from_page_infimum(), lock_rec_store_on_page_infimum(), lock_update_copy_and_discard(), lock_update_merge_left(), lock_update_root_raise(), lock_update_split_right(), page_copy_rec_list_end_no_locks(), page_copy_rec_list_end_to_created_page(), page_copy_rec_list_to_created_page_write_log(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_cur_parse_insert_rec(), page_delete_rec_list_end(), page_delete_rec_list_start(), page_dir_balance_slot(), page_dir_find_owner_slot(), page_dir_slot_check(), page_find_rec_with_heap_no(), page_header_print(), page_mem_alloc(), page_parse_delete_rec_list(), page_print_list(), page_rec_get_n_recs_before(), page_rec_print(), page_rec_validate(), page_simple_validate(), page_validate(), and recv_parse_or_apply_log_rec_body().
Here is the caller graph for this function:
| byte* page_mem_alloc | ( | page_t * | page, | |
| ulint | need, | |||
| dict_index_t * | index, | |||
| ulint * | heap_no | |||
| ) |
Definition at line 215 of file page0page.c.
References yaSSL::block, index(), mem_heap_free, NULL, page_dir_get_n_heap(), page_dir_set_n_heap(), PAGE_FREE, PAGE_GARBAGE, page_get_max_insert_size(), page_header_get_field(), page_header_get_ptr(), page_header_set_field(), page_header_set_ptr(), PAGE_HEAP_TOP, page_is_comp(), page_rec_get_next(), rec_get_heap_no(), rec_get_offsets, rec_get_start(), REC_OFFS_NORMAL_SIZE, rec_offs_size(), and ut_ad.
Referenced by page_cur_insert_rec_low().
00217 : pointer to start of allocated 00218 buffer, or NULL if allocation fails */ 00219 page_t* page, /* in: index page */ 00220 ulint need, /* in: number of bytes needed */ 00221 dict_index_t* index, /* in: record descriptor */ 00222 ulint* heap_no)/* out: this contains the heap number 00223 of the allocated record 00224 if allocation succeeds */ 00225 { 00226 rec_t* rec; 00227 byte* block; 00228 ulint avl_space; 00229 ulint garbage; 00230 00231 ut_ad(page && heap_no); 00232 00233 /* If there are records in the free list, look if the first is 00234 big enough */ 00235 00236 rec = page_header_get_ptr(page, PAGE_FREE); 00237 00238 if (rec) { 00239 mem_heap_t* heap = NULL; 00240 ulint offsets_[REC_OFFS_NORMAL_SIZE]; 00241 ulint* offsets = offsets_; 00242 *offsets_ = (sizeof offsets_) / sizeof *offsets_; 00243 00244 offsets = rec_get_offsets(rec, index, offsets, 00245 ULINT_UNDEFINED, &heap); 00246 00247 if (rec_offs_size(offsets) >= need) { 00248 page_header_set_ptr(page, PAGE_FREE, 00249 page_rec_get_next(rec)); 00250 00251 garbage = page_header_get_field(page, PAGE_GARBAGE); 00252 ut_ad(garbage >= need); 00253 00254 page_header_set_field(page, PAGE_GARBAGE, 00255 garbage - need); 00256 00257 *heap_no = rec_get_heap_no(rec, page_is_comp(page)); 00258 00259 block = rec_get_start(rec, offsets); 00260 if (UNIV_LIKELY_NULL(heap)) { 00261 mem_heap_free(heap); 00262 } 00263 return(block); 00264 } 00265 00266 if (UNIV_LIKELY_NULL(heap)) { 00267 mem_heap_free(heap); 00268 } 00269 } 00270 00271 /* Could not find space from the free list, try top of heap */ 00272 00273 avl_space = page_get_max_insert_size(page, 1); 00274 00275 if (avl_space >= need) { 00276 block = page_header_get_ptr(page, PAGE_HEAP_TOP); 00277 00278 page_header_set_ptr(page, PAGE_HEAP_TOP, block + need); 00279 *heap_no = page_dir_get_n_heap(page); 00280 00281 page_dir_set_n_heap(page, 1 + *heap_no); 00282 00283 return(block); 00284 } 00285 00286 return(NULL); 00287 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_move_rec_list_end | ( | page_t * | new_page, | |
| page_t * | page, | |||
| rec_t * | split_rec, | |||
| dict_index_t * | index, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 901 of file page0page.c.
References index(), page_copy_rec_list_end(), page_delete_rec_list_end(), page_get_data_size(), page_get_n_recs(), and ut_ad.
Referenced by btr_page_split_and_insert(), and btr_root_raise_and_insert().
00903 : index page where to move */ 00904 page_t* page, /* in: index page */ 00905 rec_t* split_rec, /* in: first record to move */ 00906 dict_index_t* index, /* in: record descriptor */ 00907 mtr_t* mtr) /* in: mtr */ 00908 { 00909 ulint old_data_size; 00910 ulint new_data_size; 00911 ulint old_n_recs; 00912 ulint new_n_recs; 00913 00914 old_data_size = page_get_data_size(new_page); 00915 old_n_recs = page_get_n_recs(new_page); 00916 00917 page_copy_rec_list_end(new_page, page, split_rec, index, mtr); 00918 00919 new_data_size = page_get_data_size(new_page); 00920 new_n_recs = page_get_n_recs(new_page); 00921 00922 ut_ad(new_data_size >= old_data_size); 00923 00924 page_delete_rec_list_end(page, split_rec, index, 00925 new_n_recs - old_n_recs, new_data_size - old_data_size, mtr); 00926 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_move_rec_list_start | ( | page_t * | new_page, | |
| page_t * | page, | |||
| rec_t * | split_rec, | |||
| dict_index_t * | index, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 933 of file page0page.c.
References index(), page_copy_rec_list_start(), and page_delete_rec_list_start().
Referenced by btr_page_split_and_insert().
00935 : index page where to move */ 00936 page_t* page, /* in: index page */ 00937 rec_t* split_rec, /* in: first record not to move */ 00938 dict_index_t* index, /* in: record descriptor */ 00939 mtr_t* mtr) /* in: mtr */ 00940 { 00941 page_copy_rec_list_start(new_page, page, split_rec, index, mtr); 00942 00943 page_delete_rec_list_start(page, split_rec, index, mtr); 00944 }
Here is the call graph for this function:
Here is the caller graph for this function:
| byte* page_parse_delete_rec_list | ( | byte | type, | |
| byte * | ptr, | |||
| byte * | end_ptr, | |||
| dict_index_t * | index, | |||
| page_t * | page, | |||
| mtr_t * | mtr | |||
| ) |
Definition at line 659 of file page0page.c.
References dict_table_is_comp(), index(), mach_read_from_2(), MLOG_COMP_LIST_END_DELETE, MLOG_COMP_LIST_START_DELETE, MLOG_LIST_END_DELETE, MLOG_LIST_START_DELETE, NULL, offset, page_delete_rec_list_end(), page_delete_rec_list_start(), page_is_comp(), and ut_ad.
Referenced by recv_parse_or_apply_log_rec_body().
00661 : end of log record or NULL */ 00662 byte type, /* in: MLOG_LIST_END_DELETE, 00663 MLOG_LIST_START_DELETE, 00664 MLOG_COMP_LIST_END_DELETE or 00665 MLOG_COMP_LIST_START_DELETE */ 00666 byte* ptr, /* in: buffer */ 00667 byte* end_ptr,/* in: buffer end */ 00668 dict_index_t* index, /* in: record descriptor */ 00669 page_t* page, /* in: page or NULL */ 00670 mtr_t* mtr) /* in: mtr or NULL */ 00671 { 00672 ulint offset; 00673 00674 ut_ad(type == MLOG_LIST_END_DELETE 00675 || type == MLOG_LIST_START_DELETE 00676 || type == MLOG_COMP_LIST_END_DELETE 00677 || type == MLOG_COMP_LIST_START_DELETE); 00678 00679 /* Read the record offset as a 2-byte ulint */ 00680 00681 if (end_ptr < ptr + 2) { 00682 00683 return(NULL); 00684 } 00685 00686 offset = mach_read_from_2(ptr); 00687 ptr += 2; 00688 00689 if (!page) { 00690 00691 return(ptr); 00692 } 00693 00694 ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table)); 00695 00696 if (type == MLOG_LIST_END_DELETE 00697 || type == MLOG_COMP_LIST_END_DELETE) { 00698 page_delete_rec_list_end(page, page + offset, index, 00699 ULINT_UNDEFINED, ULINT_UNDEFINED, mtr); 00700 } else { 00701 page_delete_rec_list_start(page, page + offset, index, mtr); 00702 } 00703 00704 return(ptr); 00705 }
Here is the call graph for this function:
Here is the caller graph for this function:
| void page_print | ( | page_t * | page, | |
| dict_index_t * | index, | |||
| ulint | dn, | |||
| ulint | rn | |||
| ) |
Definition at line 1437 of file page0page.c.
References index(), page_dir_print(), page_header_print(), and page_print_list().
01439 : index page */ 01440 dict_index_t* index, /* in: dictionary index of the page */ 01441 ulint dn, /* in: print dn first and last entries 01442 in directory */ 01443 ulint rn) /* in: print rn first and last records 01444 in directory */ 01445 { 01446 page_header_print(page); 01447 page_dir_print(page, dn); 01448 page_print_list(page, index, rn); 01449 }
Here is the call graph for this function:
| void page_print_list | ( | page_t * | page, | |
| dict_index_t * | index, | |||
| ulint | pr_n | |||
| ) |
Definition at line 1340 of file page0page.c.
References count, dict_table_is_comp(), index(), mem_heap_free, NULL, page_cur_is_after_last(), page_cur_move_to_next(), page_cur_set_before_first(), page_get_n_recs(), page_is_comp(), page_rec_print(), page_cur_struct::rec, rec_get_offsets, REC_OFFS_NORMAL_SIZE, and ut_a.
Referenced by page_print().
01342 : index page */ 01343 dict_index_t* index, /* in: dictionary index of the page */ 01344 ulint pr_n) /* in: print n first and n last entries */ 01345 { 01346 page_cur_t cur; 01347 ulint count; 01348 ulint n_recs; 01349 mem_heap_t* heap = NULL; 01350 ulint offsets_[REC_OFFS_NORMAL_SIZE]; 01351 ulint* offsets = offsets_; 01352 *offsets_ = (sizeof offsets_) / sizeof *offsets_; 01353 01354 ut_a((ibool)!!page_is_comp(page) == dict_table_is_comp(index->table)); 01355 01356 fprintf(stderr, 01357 "--------------------------------\n" 01358 "PAGE RECORD LIST\n" 01359 "Page address %p\n", page); 01360 01361 n_recs = page_get_n_recs(page); 01362 01363 page_cur_set_before_first(page, &cur); 01364 count = 0; 01365 for (;;) { 01366 offsets = rec_get_offsets(cur.rec, index, offsets, 01367 ULINT_UNDEFINED, &heap); 01368 page_rec_print(cur.rec, offsets); 01369 01370 if (count == pr_n) { 01371 break; 01372 } 01373 if (page_cur_is_after_last(&cur)) { 01374 break; 01375 } 01376 page_cur_move_to_next(&cur); 01377 count++; 01378 } 01379 01380 if (n_recs > 2 * pr_n) { 01381 fputs(" ... \n", stderr); 01382 } 01383 01384 while (!page_cur_is_after_last(&cur)) { 01385 page_cur_move_to_next(&cur); 01386 01387 if (count + pr_n >= n_recs) { 01388 offsets = rec_get_offsets(cur.rec, index, offsets, 01389 ULINT_UNDEFINED, &heap); 01390 page_rec_print(cur.rec, offsets); 01391 } 01392 count++; 01393 } 01394 01395 fprintf(stderr, 01396 "Total of %lu records \n" 01397 "--------------------------------\n", 01398 (ulong) (count + 1)); 01399 01400 if (UNIV_LIKELY_NULL(heap)) { 01401 mem_heap_free(heap); 01402 } 01403 }
Here is the call graph for this function:
Here is the caller graph for this function:
| UNIV_INLINE ibool page_rec_check | ( | rec_t * | rec | ) |
Referenced by page_dir_find_owner_slot(), page_dir_slot_check(), page_rec_get_n_recs_before(), page_rec_print(), and page_rec_validate().
Here is the caller graph for this function:
Definition at line 1231 of file page0page.c.
References buf_frame_align(), n, page, page_dir_get_nth_slot(), page_dir_slot_get_rec(), page_is_comp(), page_rec_check(), page_rec_get_next(), page_t, rec_get_n_owned(), and ut_ad.
Referenced by btr_cur_add_path_info().
01233 : number of records */ 01234 rec_t* rec) /* in: the physical record */ 01235 { 01236 page_dir_slot_t* slot; 01237 rec_t* slot_rec; 01238 page_t* page; 01239 ulint i; 01240 ulint comp; 01241 lint n = 0; 01242 01243 ut_ad(page_rec_check(rec)); 01244 01245 page = buf_frame_align(rec); 01246 comp = page_is_comp(page); 01247 01248 while (rec_get_n_owned(rec, comp) == 0) { 01249 01250 rec = page_rec_get_next(rec); 01251 n--; 01252 } 01253 01254 for (i = 0; ; i++) { 01255 slot = page_dir_get_nth_slot(page, i); 01256 slot_rec = page_dir_slot_get_rec(slot); 01257 01258 n += rec_get_n_owned(slot_rec, comp); 01259 01260 if (rec == slot_rec) { 01261 01262 break; 01263 } 01264 } 01265 01266 n--; 01267 01268 ut_ad(n >= 0); 01269 01270 return((ulint) n); 01271 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_pess_upd_restore_supremum(), btr_cur_pessimistic_delete(), btr_discard_page(), btr_estimate_number_of_different_key_vals(), btr_get_next_user_rec(), btr_page_get_father_for_rec(), btr_page_get_father_node_ptr(), btr_page_get_split_rec_to_left(), btr_page_get_split_rec_to_right(), btr_page_get_sure_split_rec(), btr_page_insert_fits(), btr_page_split_and_insert(), btr_pcur_store_position(), btr_root_raise_and_insert(), btr_search_build_page_hash_index(), btr_search_check_guess(), btr_search_drop_page_hash_index(), btr_search_update_hash_node_on_insert(), btr_search_update_hash_on_insert(), btr_validate_level(), ibuf_delete_rec(), ibuf_get_merge_page_nos(), ibuf_get_volume_buffered(), ibuf_insert_to_index_page(), lock_rec_insert_check_and_lock(), lock_update_delete(), lock_update_discard(), lock_update_insert(), lock_update_merge_left(), lock_update_split_left(), lock_update_split_right(), page_copy_rec_list_end_to_created_page(), page_cur_delete_rec(), page_cur_insert_rec_low(), page_cur_open_on_rnd_user_rec(), page_cur_search_with_match(), page_delete_rec_list_end(), page_dir_balance_slot(), page_dir_split_slot(), page_get_middle_rec(), page_mem_alloc(), page_rec_get_n_recs_before(), page_simple_validate(), page_validate(), row_ins_duplicate_error_in_clust(), row_ins_index_entry_low(), and row_sel().
Here is the caller graph for this function:
Referenced by btr_compress(), btr_cur_pessimistic_insert(), btr_get_prev_user_rec(), btr_pcur_store_position(), btr_search_check_guess(), btr_validate_level(), ibuf_get_merge_page_nos(), ibuf_get_volume_buffered(), page_cur_parse_insert_rec(), page_delete_rec_list_end(), and row_ins_foreign_report_add_err().
Here is the caller graph for this function:
Referenced by btr_cur_del_mark_set_clust_rec(), btr_cur_del_mark_set_clust_rec_log(), btr_cur_optimistic_update(), btr_cur_update_in_place(), lock_rec_add_to_queue(), lock_rec_convert_impl_to_expl(), lock_rec_enqueue_waiting(), lock_rec_find_similar_on_page(), lock_rec_get_first(), lock_rec_get_next(), lock_rec_lock_fast(), lock_rec_queue_validate(), lock_rec_reset_and_release_wait(), lock_rec_restore_from_page_infimum(), lock_rec_unlock(), mlog_open_and_write_index(), page_cur_delete_rec_write_log(), page_cur_insert_rec_write_log(), row_search_for_mysql(), row_vers_impl_x_locked_off_kernel(), and row_vers_old_has_index_entry().
Here is the caller graph for this function:
| UNIV_INLINE ibool page_rec_is_infimum | ( | const rec_t * | rec | ) |
Referenced by btr_get_prev_user_rec(), btr_search_check_guess(), btr_search_update_hash_on_insert(), ibuf_get_merge_page_nos(), ibuf_get_volume_buffered(), row_ins_duplicate_error_in_clust(), row_ins_must_modify(), row_search_for_mysql(), row_search_index_entry(), row_search_on_row_ref(), and row_sel().
Here is the caller graph for this function:
| UNIV_INLINE ibool page_rec_is_infimum_low | ( | ulint | offset | ) |
Referenced by btr_pcur_store_position(), and page_delete_rec_list_end().
Here is the caller graph for this function:
| UNIV_INLINE ibool page_rec_is_supremum | ( | const rec_t * | rec | ) |
Referenced by btr_get_next_user_rec(), btr_page_get_split_rec_to_right(), btr_page_get_sure_split_rec(), btr_search_build_page_hash_index(), btr_search_check_guess(), btr_search_drop_page_hash_index(), btr_search_guess_on_hash(), btr_search_update_hash_on_insert(), ibuf_get_merge_page_nos(), ibuf_get_volume_buffered(), lock_clust_rec_read_check_and_lock(), lock_rec_add_to_queue(), lock_rec_has_expl(), lock_rec_inherit_to_gap_if_gap_lock(), lock_rec_other_has_conflicting(), lock_rec_other_has_expl_req(), lock_sec_rec_read_check_and_lock(), lock_update_discard(), row_ins_duplicate_error_in_clust(), row_ins_foreign_report_add_err(), row_ins_scan_sec_index_for_duplicate(), row_search_for_mysql(), and row_sel().
Here is the caller graph for this function:
| UNIV_INLINE ibool page_rec_is_supremum_low | ( | ulint | offset | ) |
| UNIV_INLINE ibool page_rec_is_user_rec | ( | const rec_t * | rec | ) |
Referenced by btr_discard_page(), btr_page_get_father_for_rec(), btr_search_check_guess(), btr_search_guess_on_hash(), btr_search_update_hash_ref(), lock_clust_rec_cons_read_sees(), lock_clust_rec_read_check_and_lock(), lock_rec_convert_impl_to_expl(), lock_rec_queue_validate(), lock_sec_rec_cons_read_sees(), lock_sec_rec_read_check_and_lock(), lock_sec_rec_some_has_impl_off_kernel(), page_validate(), row_ins_foreign_check_on_constraint(), row_sel(), row_sel_get_clust_rec(), row_sel_get_clust_rec_for_mysql(), row_sel_try_search_shortcut(), and row_sel_try_search_shortcut_for_mysql().
Here is the caller graph for this function:
| UNIV_INLINE ibool page_rec_is_user_rec_low | ( | ulint | offset | ) |
Definition at line 1278 of file page0page.c.
References buf_frame_align(), page_is_comp(), page_rec_check(), rec_get_heap_no(), rec_get_n_owned(), rec_get_next_offs(), rec_offs_comp(), rec_print_new(), rec_validate(), and ut_a.
Referenced by btr_page_get_father_for_rec(), and page_print_list().
01280 : physical record */ 01281 const ulint* offsets)/* in: record descriptor */ 01282 { 01283 ulint comp = page_is_comp(buf_frame_align(rec)); 01284 01285 ut_a(!comp == !rec_offs_comp(offsets)); 01286 rec_print_new(stderr, rec, offsets); 01287 fprintf(stderr, 01288 " n_owned: %lu; heap_no: %lu; next rec: %lu\n", 01289 (ulong) rec_get_n_owned(rec, comp), 01290 (ulong) rec_get_heap_no(rec, comp), 01291 (ulong) rec_get_next_offs(rec, comp)); 01292 01293 page_rec_check(rec); 01294 rec_validate(rec, offsets); 01295 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by page_cur_delete_rec(), page_cur_insert_rec_low(), and page_delete_rec_list_end().
Here is the caller graph for this function:
Definition at line 1457 of file page0page.c.
References buf_frame_align(), FALSE, page, page_dir_get_n_heap(), PAGE_DIR_SLOT_MAX_N_OWNED, page_is_comp(), page_rec_check(), page_t, rec_get_heap_no(), rec_get_n_owned(), rec_offs_comp(), rec_validate(), TRUE, and ut_a.
Referenced by page_validate().
01459 : TRUE if ok */ 01460 rec_t* rec, /* in: physical record */ 01461 const ulint* offsets)/* in: array returned by rec_get_offsets() */ 01462 { 01463 ulint n_owned; 01464 ulint heap_no; 01465 page_t* page; 01466 ulint comp; 01467 01468 page = buf_frame_align(rec); 01469 comp = page_is_comp(page); 01470 ut_a(!comp == !rec_offs_comp(offsets)); 01471 01472 page_rec_check(rec); 01473 rec_validate(rec, offsets); 01474 01475 n_owned = rec_get_n_owned(rec, comp); 01476 heap_no = rec_get_heap_no(rec, comp); 01477 01478 if (!(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED)) { 01479 fprintf(stderr, 01480 "InnoDB: Dir slot of rec %lu, n owned too big %lu\n", 01481 (ulong)(rec - page), (ulong) n_owned); 01482 return(FALSE); 01483 } 01484 01485 if (!(heap_no < page_dir_get_n_heap(page))) { 01486 fprintf(stderr, 01487 "InnoDB: Heap no of rec %lu too big %lu %lu\n", 01488 (ulong)(rec - page), (ulong) heap_no, 01489 (ulong) page_dir_get_n_heap(page)); 01490 return(FALSE); 01491 } 01492 01493 return(TRUE); 01494 }
Here is the call graph for this function:
Here is the caller graph for this function:
Definition at line 951 of file page0page.c.
References data, MLOG_4BYTES, mlog_write_ulint(), rec_get_nth_field_old(), and ut_ad.
Referenced by dict_create_index_tree_step(), dict_drop_index_tree(), dict_truncate_index_tree(), and row_truncate_table_for_mysql().
00953 : record to update */ 00954 ulint i, /* in: index of the field to update */ 00955 ulint page_no,/* in: value to write */ 00956 mtr_t* mtr) /* in: mtr */ 00957 { 00958 byte* data; 00959 ulint len; 00960 00961 data = rec_get_nth_field_old(rec, i, &len); 00962 00963 ut_ad(len == 4); 00964 00965 mlog_write_ulint(data, page_no, MLOG_4BYTES, mtr); 00966 }
Here is the call graph for this function:
Here is the caller graph for this function:
Definition at line 185 of file page0page.c.
References yaSSL::block, btr_search_latch, buf_block_align(), mach_write_to_8(), PAGE_HEADER, PAGE_MAX_TRX_ID, rw_lock_x_lock, rw_lock_x_unlock, and ut_ad.
Referenced by btr_page_reorganize_low(), and page_create().
00187 : page */ 00188 dulint trx_id) /* in: transaction id */ 00189 { 00190 buf_block_t* block; 00191 00192 ut_ad(page); 00193 00194 block = buf_block_align(page); 00195 00196 if (block->is_hashed) { 00197 rw_lock_x_lock(&btr_search_latch); 00198 } 00199 00200 /* It is not necessary to write this change to the redo log, as 00201 during a database recovery we assume that the max trx id of every 00202 page is the maximum trx id assigned before the crash. */ 00203 00204 mach_write_to_8(page + PAGE_HEADER + PAGE_MAX_TRX_ID, trx_id); 00205 00206 if (block->is_hashed) { 00207 rw_lock_x_unlock(&btr_search_latch); 00208 } 00209 }
Here is the call graph for this function:
Here is the caller graph for this function:
| ibool page_simple_validate | ( | page_t * | page | ) |
Definition at line 1533 of file page0page.c.
References count, FALSE, FIL_PAGE_DATA, NULL, page_cur_is_after_last(), page_cur_move_to_next(), page_cur_set_before_first(), page_dir_get_n_heap(), page_dir_get_n_slots(), page_dir_get_nth_slot(), page_dir_slot_get_rec(), PAGE_FREE, page_header_get_field(), page_header_get_ptr(), PAGE_HEAP_TOP, page_is_comp(), PAGE_N_RECS, page_rec_get_next(), rec_get_n_owned(), rec_get_next_offs(), TRUE, and UNIV_PAGE_SIZE.
Referenced by buf_flush_buffered_writes(), and page_validate().
01535 : TRUE if ok */ 01536 page_t* page) /* in: index page */ 01537 { 01538 page_cur_t cur; 01539 page_dir_slot_t* slot; 01540 ulint slot_no; 01541 ulint n_slots; 01542 rec_t* rec; 01543 byte* rec_heap_top; 01544 ulint count; 01545 ulint own_count; 01546 ibool ret = FALSE; 01547 ulint comp = page_is_comp(page); 01548 01549 /* Check first that the record heap and the directory do not 01550 overlap. */ 01551 01552 n_slots = page_dir_get_n_slots(page); 01553 01554 if (n_slots > UNIV_PAGE_SIZE / 4) { 01555 fprintf(stderr, 01556 "InnoDB: Nonsensical number %lu of page dir slots\n", (ulong) n_slots); 01557 01558 goto func_exit; 01559 } 01560 01561 rec_heap_top = page_header_get_ptr(page, PAGE_HEAP_TOP); 01562 01563 if (rec_heap_top > page_dir_get_nth_slot(page, n_slots - 1)) { 01564 01565 fprintf(stderr, 01566 "InnoDB: Record heap and dir overlap on a page, heap top %lu, dir %lu\n", 01567 (ulong)(page_header_get_ptr(page, PAGE_HEAP_TOP) - page), 01568 (ulong)(page_dir_get_nth_slot(page, n_slots - 1) - page)); 01569 01570 goto func_exit; 01571 } 01572 01573 /* Validate the record list in a loop checking also that it is 01574 consistent with the page record directory. */ 01575 01576 count = 0; 01577 own_count = 1; 01578 slot_no = 0; 01579 slot = page_dir_get_nth_slot(page, slot_no); 01580 01581 page_cur_set_before_first(page, &cur); 01582 01583 for (;;) { 01584 rec = (&cur)->rec; 01585 01586 if (rec > rec_heap_top) { 01587 fprintf(stderr, 01588 "InnoDB: Record %lu is above rec heap top %lu\n", 01589 (ulong)(rec - page), (ulong)(rec_heap_top - page)); 01590 01591 goto func_exit; 01592 } 01593 01594 if (rec_get_n_owned(rec, comp) != 0) { 01595 /* This is a record pointed to by a dir slot */ 01596 if (rec_get_n_owned(rec, comp) != own_count) { 01597 01598 fprintf(stderr, 01599 "InnoDB: Wrong owned count %lu, %lu, rec %lu\n", 01600 (ulong) rec_get_n_owned(rec, comp), 01601 (ulong) own_count, 01602 (ulong)(rec - page)); 01603 01604 goto func_exit; 01605 } 01606 01607 if (page_dir_slot_get_rec(slot) != rec) { 01608 fprintf(stderr, 01609 "InnoDB: Dir slot does not point to right rec %lu\n", 01610 (ulong)(rec - page)); 01611 01612 goto func_exit; 01613 } 01614 01615 own_count = 0; 01616 01617 if (!page_cur_is_after_last(&cur)) { 01618 slot_no++; 01619 slot = page_dir_get_nth_slot(page, slot_no); 01620 } 01621 } 01622 01623 if (page_cur_is_after_last(&cur)) { 01624 01625 break; 01626 } 01627 01628 if (rec_get_next_offs(rec, comp) < FIL_PAGE_DATA 01629 || rec_get_next_offs(rec, comp) >= UNIV_PAGE_SIZE) { 01630 fprintf(stderr, 01631 "InnoDB: Next record offset nonsensical %lu for rec %lu\n", 01632 (ulong) rec_get_next_offs(rec, comp), 01633 (ulong)(rec - page)); 01634 01635 goto func_exit; 01636 } 01637 01638 count++; 01639 01640 if (count > UNIV_PAGE_SIZE) { 01641 fprintf(stderr, 01642 "InnoDB: Page record list appears to be circular %lu\n", 01643 (ulong) count); 01644 goto func_exit; 01645 } 01646 01647 page_cur_move_to_next(&cur); 01648 own_count++; 01649 } 01650 01651 if (rec_get_n_owned(rec, comp) == 0) { 01652 fprintf(stderr, "InnoDB: n owned is zero in a supremum rec\n"); 01653 01654 goto func_exit; 01655 } 01656 01657 if (slot_no != n_slots - 1) { 01658 fprintf(stderr, "InnoDB: n slots wrong %lu, %lu\n", 01659 (ulong) slot_no, (ulong) (n_slots - 1)); 01660 goto func_exit; 01661 } 01662 01663 if (page_header_get_field(page, PAGE_N_RECS) + 2 != count + 1) { 01664 fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n", 01665 (ulong) page_header_get_field(page, PAGE_N_RECS) + 2, 01666 (ulong) (count + 1)); 01667 01668 goto func_exit; 01669 } 01670 01671 /* Check then the free list */ 01672 rec = page_header_get_ptr(page, PAGE_FREE); 01673 01674 while (rec != NULL) { 01675 if (rec < page + FIL_PAGE_DATA 01676 || rec >= page + UNIV_PAGE_SIZE) { 01677 fprintf(stderr, 01678 "InnoDB: Free list record has a nonsensical offset %lu\n", 01679 (ulong)(rec - page)); 01680 01681 goto func_exit; 01682 } 01683 01684 if (rec > rec_heap_top) { 01685 fprintf(stderr, 01686 "InnoDB: Free list record %lu is above rec heap top %lu\n", 01687 (ulong)(rec - page), (ulong)(rec_heap_top - page)); 01688 01689 goto func_exit; 01690 } 01691 01692 count++; 01693 01694 if (count > UNIV_PAGE_SIZE) { 01695 fprintf(stderr, 01696 "InnoDB: Page free list appears to be circular %lu\n", 01697 (ulong) count); 01698 goto func_exit; 01699 } 01700 01701 rec = page_rec_get_next(rec); 01702 } 01703 01704 if (page_dir_get_n_heap(page) != count + 1) { 01705 01706 fprintf(stderr, "InnoDB: N heap is wrong %lu, %lu\n", 01707 (ulong) page_dir_get_n_heap(page), 01708 (ulong) (count + 1)); 01709 01710 goto func_exit; 01711 } 01712 01713 ret = TRUE; 01714 01715 func_exit: 01716 return(ret); 01717 }
Here is the call graph for this function:
Here is the caller graph for this function:
Referenced by ibuf_insert_low(), ibuf_merge_or_delete_for_page(), lock_rec_insert_check_and_lock(), lock_sec_rec_modify_check_and_lock(), page_copy_rec_list_end(), and page_copy_rec_list_start().
Here is the caller graph for this function:
| ibool page_validate | ( | page_t * | page, | |
| dict_index_t * | index | |||
| ) |
Definition at line 1723 of file page0page.c.
References btr_page_get_level_low(), buf, buf_frame_get_page_no(), buf_page_print(), cmp_rec_rec(), count, dict_index_name_print(), dict_table_is_comp(), FALSE, FIL_PAGE_DATA, index(), mem_heap_alloc(), mem_heap_create, mem_heap_free, memset, NULL, page_cur_is_after_last(), page_cur_move_to_next(), page_cur_set_before_first(), page_dir_get_n_heap(), page_dir_get_n_slots(), page_dir_get_nth_slot(), page_dir_slot_check(), page_dir_slot_get_rec(), PAGE_FREE, page_get_data_size(), page_header_get_field(), page_header_get_ptr(), PAGE_HEAP_TOP, page_is_comp(), PAGE_N_RECS, page_rec_get_next(), page_rec_is_user_rec(), page_rec_validate(), page_simple_validate(), page_cur_struct::rec, rec_get_n_owned(), rec_get_next_offs(), rec_get_node_ptr_flag(), rec_get_offsets, rec_get_start(), rec_offs_size(), rec_print_new(), TRUE, and UNIV_PAGE_SIZE.
Referenced by btr_compress(), btr_lift_page_up(), btr_page_split_and_insert(), and btr_validate_level().
01725 : TRUE if ok */ 01726 page_t* page, /* in: index page */ 01727 dict_index_t* index) /* in: data dictionary index containing 01728 the page record type definition */ 01729 { 01730 page_dir_slot_t* slot; 01731 mem_heap_t* heap; 01732 page_cur_t cur; 01733 byte* buf; 01734 ulint count; 01735 ulint own_count; 01736 ulint slot_no; 01737 ulint data_size; 01738 rec_t* rec; 01739 rec_t* old_rec = NULL; 01740 ulint offs; 01741 ulint n_slots; 01742 ibool ret = FALSE; 01743 ulint i; 01744 ulint comp = page_is_comp(page); 01745 ulint* offsets = NULL; 01746 ulint* old_offsets = NULL; 01747 01748 if ((ibool)!!comp != dict_table_is_comp(index->table)) { 01749 fputs("InnoDB: 'compact format' flag mismatch\n", stderr); 01750 goto func_exit2; 01751 } 01752 if (!page_simple_validate(page)) { 01753 goto func_exit2; 01754 } 01755 01756 heap = mem_heap_create(UNIV_PAGE_SIZE + 200); 01757 01758 /* The following buffer is used to check that the 01759 records in the page record heap do not overlap */ 01760 01761 buf = mem_heap_alloc(heap, UNIV_PAGE_SIZE); 01762 memset(buf, 0, UNIV_PAGE_SIZE); 01763 01764 /* Check first that the record heap and the directory do not 01765 overlap. */ 01766 01767 n_slots = page_dir_get_n_slots(page); 01768 01769 if (!(page_header_get_ptr(page, PAGE_HEAP_TOP) <= 01770 page_dir_get_nth_slot(page, n_slots - 1))) { 01771 01772 fputs("InnoDB: Record heap and dir overlap on a page ", 01773 stderr); 01774 dict_index_name_print(stderr, NULL, index); 01775 fprintf(stderr, ", %p, %p\n", 01776 page_header_get_ptr(page, PAGE_HEAP_TOP), 01777 page_dir_get_nth_slot(page, n_slots - 1)); 01778 01779 goto func_exit; 01780 } 01781 01782 /* Validate the record list in a loop checking also that 01783 it is consistent with the directory. */ 01784 count = 0; 01785 data_size = 0; 01786 own_count = 1; 01787 slot_no = 0; 01788 slot = page_dir_get_nth_slot(page, slot_no); 01789 01790 page_cur_set_before_first(page, &cur); 01791 01792 for (;;) { 01793 rec = cur.rec; 01794 offsets = rec_get_offsets(rec, index, offsets, 01795 ULINT_UNDEFINED, &heap); 01796 01797 if (comp && page_rec_is_user_rec(rec) 01798 && rec_get_node_ptr_flag(rec) 01799 != (ibool) 01800 (btr_page_get_level_low(page) != 0)) { 01801 fputs("InnoDB: node_ptr flag mismatch\n", stderr); 01802 goto func_exit; 01803 } 01804 01805 if (!page_rec_validate(rec, offsets)) { 01806 goto func_exit; 01807 } 01808 01809 /* Check that the records are in the ascending order */ 01810 if ((count >= 2) && (!page_cur_is_after_last(&cur))) { 01811 if (!(1 == cmp_rec_rec(rec, old_rec, 01812 offsets, old_offsets, index))) { 01813 fprintf(stderr, 01814 "InnoDB: Records in wrong order on page %lu", 01815 (ulong) buf_frame_get_page_no(page)); 01816 dict_index_name_print(stderr, NULL, index); 01817 fputs("\nInnoDB: previous record ", stderr); 01818 rec_print_new(stderr, old_rec, old_offsets); 01819 fputs("\nInnoDB: record ", stderr); 01820 rec_print_new(stderr, rec, offsets); 01821 putc('\n', stderr); 01822 01823 goto func_exit; 01824 } 01825 } 01826 01827 if (page_rec_is_user_rec(rec)) { 01828 01829 data_size += rec_offs_size(offsets); 01830 } 01831 01832 offs = rec_get_start(rec, offsets) - page; 01833 01834 for (i = 0; i < rec_offs_size(offsets); i++) { 01835 if (!buf[offs + i] == 0) { 01836 /* No other record may overlap this */ 01837 01838 fputs("InnoDB: Record overlaps another\n", 01839 stderr); 01840 goto func_exit; 01841 } 01842 01843 buf[offs + i] = 1; 01844 } 01845 01846 if (rec_get_n_owned(rec, comp) != 0) { 01847 /* This is a record pointed to by a dir slot */ 01848 if (rec_get_n_owned(rec, comp) != own_count) { 01849 fprintf(stderr, 01850 "InnoDB: Wrong owned count %lu, %lu\n", 01851 (ulong) rec_get_n_owned(rec, comp), 01852 (ulong) own_count); 01853 goto func_exit; 01854 } 01855 01856 if (page_dir_slot_get_rec(slot) != rec) { 01857 fputs( 01858 "InnoDB: Dir slot does not point to right rec\n", 01859 stderr); 01860 goto func_exit; 01861 } 01862 01863 page_dir_slot_check(slot); 01864 01865 own_count = 0; 01866 if (!page_cur_is_after_last(&cur)) { 01867 slot_no++; 01868 slot = page_dir_get_nth_slot(page, slot_no); 01869 } 01870 } 01871 01872 if (page_cur_is_after_last(&cur)) { 01873 break; 01874 } 01875 01876 if (rec_get_next_offs(rec, comp) < FIL_PAGE_DATA 01877 || rec_get_next_offs(rec, comp) >= UNIV_PAGE_SIZE) { 01878 fprintf(stderr, 01879 "InnoDB: Next record offset wrong %lu\n", 01880 (ulong) rec_get_next_offs(rec, comp)); 01881 goto func_exit; 01882 } 01883 01884 count++; 01885 page_cur_move_to_next(&cur); 01886 own_count++; 01887 old_rec = rec; 01888 /* set old_offsets to offsets; recycle offsets */ 01889 { 01890 ulint* offs = old_offsets; 01891 old_offsets = offsets; 01892 offsets = offs; 01893 } 01894 } 01895 01896 if (rec_get_n_owned(rec, comp) == 0) { 01897 fputs("InnoDB: n owned is zero\n", stderr); 01898 goto func_exit; 01899 } 01900 01901 if (slot_no != n_slots - 1) { 01902 fprintf(stderr, "InnoDB: n slots wrong %lu %lu\n", 01903 (ulong) slot_no, (ulong) (n_slots - 1)); 01904 goto func_exit; 01905 } 01906 01907 if (page_header_get_field(page, PAGE_N_RECS) + 2 != count + 1) { 01908 fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n", 01909 (ulong) page_header_get_field(page, PAGE_N_RECS) + 2, 01910 (ulong) (count + 1)); 01911 goto func_exit; 01912 } 01913 01914 if (data_size != page_get_data_size(page)) { 01915 fprintf(stderr, 01916 "InnoDB: Summed data size %lu, returned by func %lu\n", 01917 (ulong) data_size, (ulong) page_get_data_size(page)); 01918 goto func_exit; 01919 } 01920 01921 /* Check then the free list */ 01922 rec = page_header_get_ptr(page, PAGE_FREE); 01923 01924 while (rec != NULL) { 01925 offsets = rec_get_offsets(rec, index, offsets, 01926 ULINT_UNDEFINED, &heap); 01927 if (!page_rec_validate(rec, offsets)) { 01928 01929 goto func_exit; 01930 } 01931 01932 count++; 01933 offs = rec_get_start(rec, offsets) - page; 01934 01935 for (i = 0; i < rec_offs_size(offsets); i++) { 01936 01937 if (buf[offs + i] != 0) { 01938 fputs( 01939 "InnoDB: Record overlaps another in free list\n", stderr); 01940 goto func_exit; 01941 } 01942 01943 buf[offs + i] = 1; 01944 } 01945 01946 rec = page_rec_get_next(rec); 01947 } 01948 01949 if (page_dir_get_n_heap(page) != count + 1) { 01950 fprintf(stderr, "InnoDB: N heap is wrong %lu %lu\n", 01951 (ulong) page_dir_get_n_heap(page), 01952 (ulong) count + 1); 01953 goto func_exit; 01954 } 01955 01956 ret = TRUE; 01957 01958 func_exit: 01959 mem_heap_free(heap); 01960 01961 if (ret == FALSE) { 01962 func_exit2: 01963 fprintf(stderr, "InnoDB: Apparent corruption in page %lu in ", 01964 (ulong) buf_frame_get_page_no(page)); 01965 dict_index_name_print(stderr, NULL, index); 01966 putc('\n', stderr); 01967 buf_page_print(page); 01968 } 01969 01970 return(ret); 01971 }
Here is the call graph for this function:
Here is the caller graph for this function:
Generated on Sat Sep 9 08:41:00 2006 for MySQL 5.1 by
1.4.7