1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix many -Wunused-parameter

Browse Source 
Remove unused InnoDB function parameters and functions.

i_s_sys_virtual_fill_table(): Do not allocate heap memory.

mtr_is_block_fix(): Replace with mtr_memo_contains().

mtr_is_page_fix(): Replace with mtr_memo_contains_page().
This commit is contained in:
Marko Mäkelä 2018-05-01 01:10:37 +03:00
parent 87b0434e0f
commit 2b27ac8282
78 changed files with 422 additions and 1076 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sql/mdl.h
View File

@ -456,7 +456,7 @@ public:
static void *operator new(size_t size, MEM_ROOT *mem_root) throw () static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return alloc_root(mem_root, size); } { return alloc_root(mem_root, size); }
static void operator delete(void *ptr, MEM_ROOT *mem_root) {} static void operator delete(void *, MEM_ROOT *) {}
void init(MDL_key::enum_mdl_namespace namespace_arg, void init(MDL_key::enum_mdl_namespace namespace_arg,
const char *db_arg, const char *name_arg, const char *db_arg, const char *name_arg,
@ -497,7 +497,7 @@ public:
is mandatory. Can only be used before the request has been is mandatory. Can only be used before the request has been
granted. granted.
*/ */
MDL_request& operator=(const MDL_request &rhs) MDL_request& operator=(const MDL_request &)
{ {
ticket= NULL; ticket= NULL;
/* Do nothing, in particular, don't try to copy the key. */ /* Do nothing, in particular, don't try to copy the key. */

2
sql/sql_alloc.h
View File

@ -39,7 +39,7 @@ public:
{ return alloc_root(mem_root, size); } { return alloc_root(mem_root, size); }
static void operator delete(void *ptr, size_t size) { TRASH_FREE(ptr, size); } static void operator delete(void *ptr, size_t size) { TRASH_FREE(ptr, size); }
static void operator delete(void *, MEM_ROOT *){} static void operator delete(void *, MEM_ROOT *){}
static void operator delete[](void *ptr, MEM_ROOT *mem_root) static void operator delete[](void *, MEM_ROOT *)
{ /* never called */ } { /* never called */ }
static void operator delete[](void *ptr, size_t size) { TRASH_FREE(ptr, size); } static void operator delete[](void *ptr, size_t size) { TRASH_FREE(ptr, size); }
#ifdef HAVE_valgrind #ifdef HAVE_valgrind

12
sql/sql_list.h
View File

@ -164,7 +164,7 @@ public:
*/ */
bool copy(const base_list *rhs, MEM_ROOT *mem_root); bool copy(const base_list *rhs, MEM_ROOT *mem_root);
base_list(const base_list &rhs, MEM_ROOT *mem_root) { copy(&rhs, mem_root); } base_list(const base_list &rhs, MEM_ROOT *mem_root) { copy(&rhs, mem_root); }
inline base_list(bool error) { } inline base_list(bool) {}
inline bool push_back(void *info) inline bool push_back(void *info)
{ {
if (((*last)=new list_node(info, &end_of_list))) if (((*last)=new list_node(info, &end_of_list)))
@ -533,10 +533,10 @@ public:
template <class T> class List_iterator_fast :public base_list_iterator template <class T> class List_iterator_fast :public base_list_iterator
{ {
protected: protected:
inline T *replace(T *a) { return (T*) 0; } inline T *replace(T *) { return (T*) 0; }
inline T *replace(List<T> &a) { return (T*) 0; } inline T *replace(List<T> &) { return (T*) 0; }
inline void remove(void) { } inline void remove(void) {}
inline void after(T *a) { } inline void after(T *) {}
inline T** ref(void) { return (T**) 0; } inline T** ref(void) { return (T**) 0; }
public: public:
@ -605,7 +605,7 @@ struct ilink
{ {
return (void*)my_malloc((uint)size, MYF(MY_WME | MY_FAE | ME_FATALERROR)); return (void*)my_malloc((uint)size, MYF(MY_WME | MY_FAE | ME_FATALERROR));
} }
static void operator delete(void* ptr_arg, size_t size) static void operator delete(void* ptr_arg, size_t)
{ {
my_free(ptr_arg); my_free(ptr_arg);
} }

8
sql/sql_plist.h
View File

@ -230,7 +230,7 @@ protected:
void reset() {} void reset() {}
void inc() {} void inc() {}
void dec() {} void dec() {}
void swap(I_P_List_null_counter &rhs) {} void swap(I_P_List_null_counter &) {}
}; };
@ -262,14 +262,14 @@ public:
template <typename T> class I_P_List_no_push_back template <typename T> class I_P_List_no_push_back
{ {
protected: protected:
I_P_List_no_push_back(T **a) {}; I_P_List_no_push_back(T **) {}
void set_last(T **a) {} void set_last(T **) {}
/* /*
T** get_last() const method is intentionally left unimplemented T** get_last() const method is intentionally left unimplemented
in order to prohibit usage of push_back() method in lists which in order to prohibit usage of push_back() method in lists which
use this policy. use this policy.
*/ */
void swap(I_P_List_no_push_back<T> &rhs) {} void swap(I_P_List_no_push_back<T> &) {}
}; };

2
sql/sql_string.h
View File

@ -190,7 +190,7 @@ public:
{ /* never called */ } { /* never called */ }
static void operator delete[](void *ptr, size_t size) static void operator delete[](void *ptr, size_t size)
{ TRASH_FREE(ptr, size); } { TRASH_FREE(ptr, size); }
static void operator delete[](void *ptr, MEM_ROOT *mem_root) static void operator delete[](void *, MEM_ROOT *)
{ /* never called */ } { /* never called */ }
~String() { free(); } ~String() { free(); }

65
storage/innobase/btr/btr0btr.cc
View File

@ -435,7 +435,7 @@ btr_page_create(
{ {
page_t* page = buf_block_get_frame(block); page_t* page = buf_block_get_frame(block);
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
if (page_zip) { if (page_zip) {
page_create_zip(block, index, level, 0, NULL, mtr); page_create_zip(block, index, level, 0, NULL, mtr);
@ -712,7 +712,7 @@ btr_page_free_for_ibuf(
{ {
page_t* root; page_t* root;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
root = btr_root_get(index, mtr); root = btr_root_get(index, mtr);
flst_add_first(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST, flst_add_first(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
@ -738,7 +738,7 @@ btr_page_free_low(
fseg_header_t* seg_header; fseg_header_t* seg_header;
page_t* root; page_t* root;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
/* The page gets invalid for optimistic searches: increment the frame /* The page gets invalid for optimistic searches: increment the frame
modify clock */ modify clock */
@ -853,7 +853,7 @@ btr_page_free_low(
/* The page was marked free in the allocation bitmap, but it /* The page was marked free in the allocation bitmap, but it
should remain buffer-fixed until mtr_commit(mtr) or until it should remain buffer-fixed until mtr_commit(mtr) or until it
is explicitly freed from the mini-transaction. */ is explicitly freed from the mini-transaction. */
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
/* TODO: Discard any operations on the page from the redo log /* TODO: Discard any operations on the page from the redo log
and remove the block from the flush list and the buffer pool. and remove the block from the flush list and the buffer pool.
This would free up buffer pool earlier and reduce writes to This would free up buffer pool earlier and reduce writes to
@ -1599,7 +1599,7 @@ btr_page_reorganize_low(
bool log_compressed; bool log_compressed;
bool is_spatial; bool is_spatial;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
btr_assert_not_corrupted(block, index); btr_assert_not_corrupted(block, index);
#ifdef UNIV_ZIP_DEBUG #ifdef UNIV_ZIP_DEBUG
ut_a(!page_zip || page_zip_validate(page_zip, page, index)); ut_a(!page_zip || page_zip_validate(page_zip, page, index));
@ -1905,7 +1905,7 @@ btr_page_empty(
{ {
page_t* page = buf_block_get_frame(block); page_t* page = buf_block_get_frame(block);
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
ut_ad(page_zip == buf_block_get_page_zip(block)); ut_ad(page_zip == buf_block_get_page_zip(block));
#ifdef UNIV_ZIP_DEBUG #ifdef UNIV_ZIP_DEBUG
ut_a(!page_zip || page_zip_validate(page_zip, page, index)); ut_a(!page_zip || page_zip_validate(page_zip, page, index));
@ -1995,8 +1995,7 @@ btr_root_raise_and_insert(
ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index), ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
MTR_MEMO_X_LOCK MTR_MEMO_X_LOCK
| MTR_MEMO_SX_LOCK)); | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, root_block, MTR_MEMO_PAGE_X_FIX));
mtr, root_block, MTR_MEMO_PAGE_X_FIX, index->table));
/* Allocate a new page to the tree. Root splitting is done by first /* Allocate a new page to the tree. Root splitting is done by first
moving the root records to the new page, emptying the root, putting moving the root records to the new page, emptying the root, putting
@ -2103,7 +2102,7 @@ btr_root_raise_and_insert(
rtr_page_cal_mbr(index, new_block, &new_mbr, *heap); rtr_page_cal_mbr(index, new_block, &new_mbr, *heap);
node_ptr = rtr_index_build_node_ptr( node_ptr = rtr_index_build_node_ptr(
index, &new_mbr, rec, new_page_no, *heap, level); index, &new_mbr, rec, new_page_no, *heap);
} else { } else {
node_ptr = dict_index_build_node_ptr( node_ptr = dict_index_build_node_ptr(
index, rec, new_page_no, *heap, level); index, rec, new_page_no, *heap, level);
@ -2608,9 +2607,8 @@ btr_attach_half_pages(
buf_block_t* prev_block = NULL; buf_block_t* prev_block = NULL;
buf_block_t* next_block = NULL; buf_block_t* next_block = NULL;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, new_block, MTR_MEMO_PAGE_X_FIX));
mtr, new_block, MTR_MEMO_PAGE_X_FIX, index->table));
/* Create a memory heap where the data tuple is stored */ /* Create a memory heap where the data tuple is stored */
heap = mem_heap_create(1024); heap = mem_heap_create(1024);
@ -2794,8 +2792,7 @@ btr_insert_into_right_sibling(
ut_ad(mtr_memo_contains_flagged( ut_ad(mtr_memo_contains_flagged(
mtr, dict_index_get_lock(cursor->index), mtr, dict_index_get_lock(cursor->index),
MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)); MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
mtr, block, MTR_MEMO_PAGE_X_FIX, cursor->index->table));
ut_ad(heap); ut_ad(heap);
if (next_page_no == FIL_NULL || !page_rec_is_supremum( if (next_page_no == FIL_NULL || !page_rec_is_supremum(
@ -2977,8 +2974,7 @@ func_start:
page = buf_block_get_frame(block); page = buf_block_get_frame(block);
page_zip = buf_block_get_page_zip(block); page_zip = buf_block_get_page_zip(block);
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
mtr, block, MTR_MEMO_PAGE_X_FIX, cursor->index->table));
ut_ad(!page_is_empty(page)); ut_ad(!page_is_empty(page));
/* try to insert to the next page if possible before split */ /* try to insert to the next page if possible before split */
@ -3350,7 +3346,7 @@ btr_level_list_remove_func(
{ {
ut_ad(page != NULL); ut_ad(page != NULL);
ut_ad(mtr != NULL); ut_ad(mtr != NULL);
ut_ad(mtr_is_page_fix(mtr, page, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX));
ut_ad(space == page_get_space_id(page)); ut_ad(space == page_get_space_id(page));
/* Get the previous and next page numbers of page */ /* Get the previous and next page numbers of page */
@ -3484,7 +3480,7 @@ btr_node_ptr_delete(
ibool compressed; ibool compressed;
dberr_t err; dberr_t err;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
/* Delete node pointer on father page */ /* Delete node pointer on father page */
btr_page_get_father(index, block, mtr, &cursor); btr_page_get_father(index, block, mtr, &cursor);
@ -3526,7 +3522,7 @@ btr_lift_page_up(
buf_block_t* block_orig = block; buf_block_t* block_orig = block;
ut_ad(!page_has_siblings(page)); ut_ad(!page_has_siblings(page));
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
page_level = btr_page_get_level(page); page_level = btr_page_get_level(page);
root_page_no = dict_index_get_page(index); root_page_no = dict_index_get_page(index);
@ -3594,8 +3590,8 @@ btr_lift_page_up(
page_level = btr_page_get_level(page); page_level = btr_page_get_level(page);
ut_ad(!page_has_siblings(page)); ut_ad(!page_has_siblings(page));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(
mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); mtr, block, MTR_MEMO_PAGE_X_FIX));
father_block = blocks[0]; father_block = blocks[0];
father_page_zip = buf_block_get_page_zip(father_block); father_page_zip = buf_block_get_page_zip(father_block);
@ -3754,7 +3750,7 @@ btr_compress(
} }
#endif /* UNIV_DEBUG */ #endif /* UNIV_DEBUG */
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
const page_size_t page_size(index->table->space->flags); const page_size_t page_size(index->table->space->flags);
@ -3899,8 +3895,7 @@ retry:
/* Check if parent entry needs to be updated */ /* Check if parent entry needs to be updated */
mbr_changed = rtr_merge_mbr_changed( mbr_changed = rtr_merge_mbr_changed(
&cursor2, &father_cursor, &cursor2, &father_cursor,
offsets2, offsets, &new_mbr, offsets2, offsets, &new_mbr);
merge_block, block, index);
} }
rec_t* orig_pred = page_copy_rec_list_start( rec_t* orig_pred = page_copy_rec_list_start(
@ -3945,8 +3940,7 @@ retry:
merge_page, &new_mbr, NULL, mtr); merge_page, &new_mbr, NULL, mtr);
#endif #endif
} else { } else {
rtr_node_ptr_delete( rtr_node_ptr_delete(&father_cursor, mtr);
index, &father_cursor, block, mtr);
} }
/* No GAP lock needs to be worrying about */ /* No GAP lock needs to be worrying about */
@ -4092,9 +4086,7 @@ retry:
rtr_merge_and_update_mbr(&father_cursor, rtr_merge_and_update_mbr(&father_cursor,
&cursor2, &cursor2,
offsets, offsets2, offsets, offsets2,
merge_page, merge_page, mtr);
merge_block,
block, index, mtr);
} else { } else {
/* Otherwise, we will keep the node ptr of /* Otherwise, we will keep the node ptr of
merge page and delete the father node ptr. merge page and delete the father node ptr.
@ -4103,9 +4095,7 @@ retry:
rtr_merge_and_update_mbr(&cursor2, rtr_merge_and_update_mbr(&cursor2,
&father_cursor, &father_cursor,
offsets2, offsets, offsets2, offsets,
merge_page, merge_page, mtr);
merge_block,
block, index, mtr);
} }
lock_mutex_enter(); lock_mutex_enter();
lock_prdt_page_free_from_discard( lock_prdt_page_free_from_discard(
@ -4258,8 +4248,7 @@ btr_discard_only_page_on_level(
ut_a(page_level == btr_page_get_level(page)); ut_a(page_level == btr_page_get_level(page));
ut_a(!page_has_siblings(page)); ut_a(!page_has_siblings(page));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
mtr, block, MTR_MEMO_PAGE_X_FIX, index->table));
btr_search_drop_page_hash_index(block); btr_search_drop_page_hash_index(block);
if (dict_index_is_spatial(index)) { if (dict_index_is_spatial(index)) {
@ -4350,7 +4339,7 @@ btr_discard_page(
ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index), ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)); MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
MONITOR_INC(MONITOR_INDEX_DISCARD); MONITOR_INC(MONITOR_INDEX_DISCARD);
@ -4430,7 +4419,7 @@ btr_discard_page(
node ptr, so, we need to get father node ptr first and then node ptr, so, we need to get father node ptr first and then
delete it. */ delete it. */
rtr_page_get_father(index, block, mtr, cursor, &father_cursor); rtr_page_get_father(index, block, mtr, cursor, &father_cursor);
rtr_node_ptr_delete(index, &father_cursor, block, mtr); rtr_node_ptr_delete(&father_cursor, mtr);
} else { } else {
btr_node_ptr_delete(index, block, mtr); btr_node_ptr_delete(index, block, mtr);
} }
@ -4532,7 +4521,7 @@ btr_print_recursive(
ulint i = 0; ulint i = 0;
mtr_t mtr2; mtr_t mtr2;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_SX_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_SX_FIX));
ib::info() << "NODE ON LEVEL " << btr_page_get_level(page) ib::info() << "NODE ON LEVEL " << btr_page_get_level(page)
<< " page " << block->page.id; << " page " << block->page.id;
@ -4626,7 +4615,7 @@ btr_check_node_ptr(
btr_cur_t cursor; btr_cur_t cursor;
page_t* page = buf_block_get_frame(block); page_t* page = buf_block_get_frame(block);
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
if (dict_index_get_page(index) == block->page.id.page_no()) { if (dict_index_get_page(index) == block->page.id.page_no()) {

51
storage/innobase/btr/btr0cur.cc
View File

@ -1718,7 +1718,7 @@ retry_page_get:
} }
lock_prdt_lock(block, &prdt, index, LOCK_S, lock_prdt_lock(block, &prdt, index, LOCK_S,
LOCK_PREDICATE, cursor->thr, mtr); LOCK_PREDICATE, cursor->thr);
if (rw_latch == RW_NO_LATCH && height != 0) { if (rw_latch == RW_NO_LATCH && height != 0) {
rw_lock_s_unlock(&(block->lock)); rw_lock_s_unlock(&(block->lock));
@ -2919,9 +2919,8 @@ btr_cur_insert_if_possible(
ut_ad(dtuple_check_typed(tuple)); ut_ad(dtuple_check_typed(tuple));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX));
MTR_MEMO_PAGE_X_FIX, cursor->index->table));
page_cursor = btr_cur_get_page_cur(cursor); page_cursor = btr_cur_get_page_cur(cursor);
/* Now, try the insert */ /* Now, try the insert */
@ -3111,7 +3110,7 @@ btr_cur_optimistic_insert(
page = buf_block_get_frame(block); page = buf_block_get_frame(block);
index = cursor->index; index = cursor->index;
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
ut_ad(!dict_index_is_online_ddl(index) ut_ad(!dict_index_is_online_ddl(index)
|| dict_index_is_clust(index) || dict_index_is_clust(index)
|| (flags & BTR_CREATE_FLAG)); || (flags & BTR_CREATE_FLAG));
@ -3403,9 +3402,8 @@ btr_cur_pessimistic_insert(
ut_ad(mtr_memo_contains_flagged( ut_ad(mtr_memo_contains_flagged(
mtr, dict_index_get_lock(btr_cur_get_index(cursor)), mtr, dict_index_get_lock(btr_cur_get_index(cursor)),
MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)); MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX));
MTR_MEMO_PAGE_X_FIX, cursor->index->table));
ut_ad(!dict_index_is_online_ddl(index) ut_ad(!dict_index_is_online_ddl(index)
|| dict_index_is_clust(index) || dict_index_is_clust(index)
|| (flags & BTR_CREATE_FLAG)); || (flags & BTR_CREATE_FLAG));
@ -4099,7 +4097,7 @@ btr_cur_optimistic_update(
index = cursor->index; index = cursor->index;
ut_ad(trx_id > 0 || (flags & BTR_KEEP_SYS_FLAG)); ut_ad(trx_id > 0 || (flags & BTR_KEEP_SYS_FLAG));
ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table)); ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table));
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
/* This is intended only for leaf page updates */ /* This is intended only for leaf page updates */
ut_ad(page_is_leaf(page)); ut_ad(page_is_leaf(page));
/* The insert buffer tree should never be updated in place. */ /* The insert buffer tree should never be updated in place. */
@ -4450,7 +4448,7 @@ btr_cur_pessimistic_update(
ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index), ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
MTR_MEMO_X_LOCK | MTR_MEMO_X_LOCK |
MTR_MEMO_SX_LOCK)); MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
#ifdef UNIV_ZIP_DEBUG #ifdef UNIV_ZIP_DEBUG
ut_a(!page_zip || page_zip_validate(page_zip, page, index)); ut_a(!page_zip || page_zip_validate(page_zip, page, index));
#endif /* UNIV_ZIP_DEBUG */ #endif /* UNIV_ZIP_DEBUG */
@ -5234,9 +5232,8 @@ btr_cur_compress_if_useful(
ut_ad(mtr_memo_contains_flagged( ut_ad(mtr_memo_contains_flagged(
mtr, dict_index_get_lock(btr_cur_get_index(cursor)), mtr, dict_index_get_lock(btr_cur_get_index(cursor)),
MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)); MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX));
MTR_MEMO_PAGE_X_FIX, cursor->index->table));
if (dict_index_is_spatial(cursor->index)) { if (dict_index_is_spatial(cursor->index)) {
const page_t* page = btr_cur_get_page(cursor); const page_t* page = btr_cur_get_page(cursor);
@ -5288,8 +5285,8 @@ btr_cur_optimistic_delete_func(
ut_ad(flags == 0 || flags == BTR_CREATE_FLAG); ut_ad(flags == 0 || flags == BTR_CREATE_FLAG);
ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor), ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
MTR_MEMO_PAGE_X_FIX)); MTR_MEMO_PAGE_X_FIX));
ut_ad(mtr_is_block_fix(mtr, btr_cur_get_block(cursor), ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
MTR_MEMO_PAGE_X_FIX, cursor->index->table)); MTR_MEMO_PAGE_X_FIX));
ut_ad(mtr->is_named_space(cursor->index->table->space)); ut_ad(mtr->is_named_space(cursor->index->table->space));
/* This is intended only for leaf page deletions */ /* This is intended only for leaf page deletions */
@ -5480,7 +5477,7 @@ btr_cur_pessimistic_delete(
ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index), ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
MTR_MEMO_X_LOCK MTR_MEMO_X_LOCK
| MTR_MEMO_SX_LOCK)); | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
ut_ad(mtr->is_named_space(index->table->space)); ut_ad(mtr->is_named_space(index->table->space));
if (!has_reserved_extents) { if (!has_reserved_extents) {
@ -6922,7 +6919,6 @@ static
void void
btr_blob_free( btr_blob_free(
/*==========*/ /*==========*/
dict_index_t* index, /*!< in: index */
buf_block_t* block, /*!< in: buffer block */ buf_block_t* block, /*!< in: buffer block */
ibool all, /*!< in: TRUE=remove also the compressed page ibool all, /*!< in: TRUE=remove also the compressed page
if there is one */ if there is one */
@ -6932,7 +6928,7 @@ btr_blob_free(
ulint space = block->page.id.space(); ulint space = block->page.id.space();
ulint page_no = block->page.id.page_no(); ulint page_no = block->page.id.page_no();
ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
mtr_commit(mtr); mtr_commit(mtr);
@ -7121,8 +7117,7 @@ btr_store_big_rec_extern_fields(
ut_ad(rec_offs_any_extern(offsets)); ut_ad(rec_offs_any_extern(offsets));
ut_ad(mtr_memo_contains_flagged(btr_mtr, dict_index_get_lock(index), ut_ad(mtr_memo_contains_flagged(btr_mtr, dict_index_get_lock(index),
MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)); MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(btr_mtr, rec_block, MTR_MEMO_PAGE_X_FIX));
btr_mtr, rec_block, MTR_MEMO_PAGE_X_FIX, index->table));
ut_ad(buf_block_get_frame(rec_block) == page_align(rec)); ut_ad(buf_block_get_frame(rec_block) == page_align(rec));
ut_a(dict_index_is_clust(index)); ut_a(dict_index_is_clust(index));
@ -7436,7 +7431,7 @@ next_zip_page:
/* Commit mtr and release the /* Commit mtr and release the
uncompressed page frame to save memory. */ uncompressed page frame to save memory. */
btr_blob_free(index, block, FALSE, &mtr); btr_blob_free(block, FALSE, &mtr);
if (err == Z_STREAM_END) { if (err == Z_STREAM_END) {
break; break;
@ -7618,11 +7613,11 @@ btr_free_externally_stored_field(
ulint next_page_no; ulint next_page_no;
mtr_t mtr; mtr_t mtr;
ut_ad(dict_index_is_clust(index)); ut_ad(index->is_primary());
ut_ad(mtr_memo_contains_flagged(local_mtr, dict_index_get_lock(index), ut_ad(mtr_memo_contains_flagged(local_mtr, dict_index_get_lock(index),
MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)); MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
ut_ad(mtr_is_page_fix( ut_ad(mtr_memo_contains_page(local_mtr, field_ref,
local_mtr, field_ref, MTR_MEMO_PAGE_X_FIX, index->table)); MTR_MEMO_PAGE_X_FIX));
ut_ad(!rec || rec_offs_validate(rec, index, offsets)); ut_ad(!rec || rec_offs_validate(rec, index, offsets));
ut_ad(!rec || field_ref == btr_rec_get_field_ref(rec, offsets, i)); ut_ad(!rec || field_ref == btr_rec_get_field_ref(rec, offsets, i));
ut_ad(local_mtr->is_named_space( ut_ad(local_mtr->is_named_space(
@ -7764,7 +7759,7 @@ btr_free_externally_stored_field(
} }
/* Commit mtr and release the BLOB block to save memory. */ /* Commit mtr and release the BLOB block to save memory. */
btr_blob_free(index, ext_block, TRUE, &mtr); btr_blob_free(ext_block, TRUE, &mtr);
} }
} }
@ -7789,8 +7784,8 @@ btr_rec_free_externally_stored_fields(
ulint i; ulint i;
ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(rec_offs_validate(rec, index, offsets));
ut_ad(mtr_is_page_fix(mtr, rec, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains_page(mtr, rec, MTR_MEMO_PAGE_X_FIX));
ut_ad(dict_index_is_clust(index)); ut_ad(index->is_primary());
ut_ad(page_rec_is_leaf(rec)); ut_ad(page_rec_is_leaf(rec));
/* Free possible externally stored fields in the record */ /* Free possible externally stored fields in the record */
@ -7828,7 +7823,7 @@ btr_rec_free_updated_extern_fields(
ulint i; ulint i;
ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(rec_offs_validate(rec, index, offsets));
ut_ad(mtr_is_page_fix(mtr, rec, MTR_MEMO_PAGE_X_FIX, index->table)); ut_ad(mtr_memo_contains_page(mtr, rec, MTR_MEMO_PAGE_X_FIX));
/* Free possible externally stored fields in the record */ /* Free possible externally stored fields in the record */

4
storage/innobase/btr/btr0pcur.cc
View File

@ -490,7 +490,7 @@ btr_pcur_move_backward_from_page(
ut_ad(cursor->latch_mode != BTR_NO_LATCHES); ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
ut_ad(btr_pcur_is_before_first_on_page(cursor)); ut_ad(btr_pcur_is_before_first_on_page(cursor));
ut_ad(!btr_pcur_is_before_first_in_tree(cursor, mtr)); ut_ad(!btr_pcur_is_before_first_in_tree(cursor));
latch_mode = cursor->latch_mode; latch_mode = cursor->latch_mode;
@ -562,7 +562,7 @@ btr_pcur_move_to_prev(
if (btr_pcur_is_before_first_on_page(cursor)) { if (btr_pcur_is_before_first_on_page(cursor)) {
if (btr_pcur_is_before_first_in_tree(cursor, mtr)) { if (btr_pcur_is_before_first_in_tree(cursor)) {
return(FALSE); return(FALSE);
} }

11
storage/innobase/btr/btr0sea.cc
View File

@ -565,14 +565,10 @@ block->n_hash_helps, n_fields, n_bytes, left_side are NOT protected by any
semaphore, to save CPU time! Do not assume the fields are consistent. semaphore, to save CPU time! Do not assume the fields are consistent.
@return TRUE if building a (new) hash index on the block is recommended @return TRUE if building a (new) hash index on the block is recommended
@param[in,out] info search info @param[in,out] info search info
@param[in,out] block buffer block @param[in,out] block buffer block */
@param[in] cursor cursor */
static static
bool bool
btr_search_update_block_hash_info( btr_search_update_block_hash_info(btr_search_t* info, buf_block_t* block)
btr_search_t* info,
buf_block_t* block,
const btr_cur_t* cursor)
{ {
ut_ad(!btr_search_own_any(RW_LOCK_S)); ut_ad(!btr_search_own_any(RW_LOCK_S));
ut_ad(!btr_search_own_any(RW_LOCK_X)); ut_ad(!btr_search_own_any(RW_LOCK_X));
@ -1548,8 +1544,7 @@ btr_search_info_update_slow(btr_search_t* info, btr_cur_t* cursor)
btr_search_info_update_hash(info, cursor); btr_search_info_update_hash(info, cursor);
bool build_index = btr_search_update_block_hash_info( bool build_index = btr_search_update_block_hash_info(info, block);
info, block, cursor);
if (build_index || (cursor->flag == BTR_CUR_HASH_FAIL)) { if (build_index || (cursor->flag == BTR_CUR_HASH_FAIL)) {

11
storage/innobase/buf/buf0flu.cc
View File

@ -2983,16 +2983,9 @@ buf_flush_page_cleaner_disabled_loop(void)
} }
/** Disables page cleaner threads (coordinator and workers). /** Disables page cleaner threads (coordinator and workers).
It's used by: SET GLOBAL innodb_page_cleaner_disabled_debug = 1 (0).
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
void void buf_flush_page_cleaner_disabled_debug_update(THD*,
buf_flush_page_cleaner_disabled_debug_update( st_mysql_sys_var*, void*,
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save) const void* save)
{ {
if (!page_cleaner.is_running) { if (!page_cleaner.is_running) {

10
storage/innobase/dict/dict0load.cc
View File

@ -144,7 +144,6 @@ dict_load_column_low(
/** Load a virtual column "mapping" (to base columns) information /** Load a virtual column "mapping" (to base columns) information
from a SYS_VIRTUAL record from a SYS_VIRTUAL record
@param[in,out] table table @param[in,out] table table
@param[in,out] heap memory heap
@param[in,out] column mapped base column's dict_column_t @param[in,out] column mapped base column's dict_column_t
@param[in,out] table_id table id @param[in,out] table_id table id
@param[in,out] pos virtual column position @param[in,out] pos virtual column position
@ -156,7 +155,6 @@ static
const char* const char*
dict_load_virtual_low( dict_load_virtual_low(
dict_table_t* table, dict_table_t* table,
mem_heap_t* heap,
dict_col_t** column, dict_col_t** column,
table_id_t* table_id, table_id_t* table_id,
ulint* pos, ulint* pos,
@ -467,7 +465,6 @@ dict_process_sys_columns_rec(
/** This function parses a SYS_VIRTUAL record and extracts virtual column /** This function parses a SYS_VIRTUAL record and extracts virtual column
information information
@param[in,out] heap heap memory
@param[in] rec current SYS_COLUMNS rec @param[in] rec current SYS_COLUMNS rec
@param[in,out] table_id table id @param[in,out] table_id table id
@param[in,out] pos virtual column position @param[in,out] pos virtual column position
@ -475,7 +472,6 @@ information
@return error message, or NULL on success */ @return error message, or NULL on success */
const char* const char*
dict_process_sys_virtual_rec( dict_process_sys_virtual_rec(
mem_heap_t* heap,
const rec_t* rec, const rec_t* rec,
table_id_t* table_id, table_id_t* table_id,
ulint* pos, ulint* pos,
@ -484,7 +480,7 @@ dict_process_sys_virtual_rec(
const char* err_msg; const char* err_msg;
/* Parse the record, and get "dict_col_t" struct filled */ /* Parse the record, and get "dict_col_t" struct filled */
err_msg = dict_load_virtual_low(NULL, heap, NULL, table_id, err_msg = dict_load_virtual_low(NULL, NULL, table_id,
pos, base_pos, rec); pos, base_pos, rec);
return(err_msg); return(err_msg);
@ -1693,7 +1689,6 @@ static const char* dict_load_virtual_del = "delete-marked record in SYS_VIRTUAL"
/** Load a virtual column "mapping" (to base columns) information /** Load a virtual column "mapping" (to base columns) information
from a SYS_VIRTUAL record from a SYS_VIRTUAL record
@param[in,out] table table @param[in,out] table table
@param[in,out] heap memory heap
@param[in,out] column mapped base column's dict_column_t @param[in,out] column mapped base column's dict_column_t
@param[in,out] table_id table id @param[in,out] table_id table id
@param[in,out] pos virtual column position @param[in,out] pos virtual column position
@ -1705,7 +1700,6 @@ static
const char* const char*
dict_load_virtual_low( dict_load_virtual_low(
dict_table_t* table, dict_table_t* table,
mem_heap_t* heap,
dict_col_t** column, dict_col_t** column,
table_id_t* table_id, table_id_t* table_id,
ulint* pos, ulint* pos,
@ -1965,7 +1959,7 @@ dict_load_virtual_one_col(
ut_a(btr_pcur_is_on_user_rec(&pcur)); ut_a(btr_pcur_is_on_user_rec(&pcur));
err_msg = dict_load_virtual_low(table, heap, err_msg = dict_load_virtual_low(table,
&v_col->base_col[i - skipped], &v_col->base_col[i - skipped],
NULL, NULL,
&pos, NULL, rec); &pos, NULL, rec);

9
storage/innobase/dict/dict0stats_bg.cc
View File

@ -399,15 +399,8 @@ dict_stats_process_entry_from_recalc_pool()
#ifdef UNIV_DEBUG #ifdef UNIV_DEBUG
/** Disables dict stats thread. It's used by: /** Disables dict stats thread. It's used by:
SET GLOBAL innodb_dict_stats_disabled_debug = 1 (0). SET GLOBAL innodb_dict_stats_disabled_debug = 1 (0).
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
void void dict_stats_disabled_debug_update(THD*, st_mysql_sys_var*, void*,
dict_stats_disabled_debug_update(
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save) const void* save)
{ {
/* This method is protected by mutex, as every SET GLOBAL .. */ /* This method is protected by mutex, as every SET GLOBAL .. */

13
storage/innobase/fil/fil0crypt.cc
View File

@ -469,7 +469,6 @@ byte*
fil_parse_write_crypt_data( fil_parse_write_crypt_data(
byte* ptr, byte* ptr,
const byte* end_ptr, const byte* end_ptr,
const buf_block_t* block,
dberr_t* err) dberr_t* err)
{ {
/* check that redo log entry is complete */ /* check that redo log entry is complete */
@ -2051,13 +2050,8 @@ fil_crypt_flush_space(
/*********************************************************************** /***********************************************************************
Complete rotating a space Complete rotating a space
@param[in,out] key_state Key state
@param[in,out] state Rotation state */ @param[in,out] state Rotation state */
static static void fil_crypt_complete_rotate_space(rotate_thread_t* state)
void
fil_crypt_complete_rotate_space(
const key_state_t* key_state,
rotate_thread_t* state)
{ {
fil_space_crypt_t *crypt_data = state->space->crypt_data; fil_space_crypt_t *crypt_data = state->space->crypt_data;
@ -2220,8 +2214,7 @@ DECLARE_THREAD(fil_crypt_thread)(
/* If space is marked as stopping, release /* If space is marked as stopping, release
space and stop rotation. */ space and stop rotation. */
if (thr.space->is_stopping()) { if (thr.space->is_stopping()) {
fil_crypt_complete_rotate_space( fil_crypt_complete_rotate_space(&thr);
&new_state, &thr);
thr.space->release(); thr.space->release();
thr.space = NULL; thr.space = NULL;
break; break;
@ -2233,7 +2226,7 @@ DECLARE_THREAD(fil_crypt_thread)(
/* complete rotation */ /* complete rotation */
if (thr.space) { if (thr.space) {
fil_crypt_complete_rotate_space(&new_state, &thr); fil_crypt_complete_rotate_space(&thr);
} }
/* force key state refresh */ /* force key state refresh */

17
storage/innobase/fsp/fsp0file.cc
View File

@ -831,7 +831,10 @@ open that file, and read the contents into m_filepath.
dberr_t dberr_t
RemoteDatafile::open_link_file() RemoteDatafile::open_link_file()
{ {
set_link_filepath(NULL); if (m_link_filepath == NULL) {
m_link_filepath = fil_make_filepath(NULL, name(), ISL, false);
}
m_filepath = read_link_file(m_link_filepath); m_filepath = read_link_file(m_link_filepath);
return(m_filepath == NULL ? DB_CANNOT_OPEN_FILE : DB_SUCCESS); return(m_filepath == NULL ? DB_CANNOT_OPEN_FILE : DB_SUCCESS);
@ -897,18 +900,6 @@ RemoteDatafile::shutdown()
} }
} }
/** Set the link filepath. Use default datadir, the base name of
the path provided without its suffix, plus DOT_ISL.
@param[in] path filepath which contains a basename to use.
If NULL, use m_name as the basename. */
void
RemoteDatafile::set_link_filepath(const char* path)
{
if (m_link_filepath == NULL) {
m_link_filepath = fil_make_filepath(NULL, name(), ISL, false);
}
}
/** Creates a new InnoDB Symbolic Link (ISL) file. It is always created /** Creates a new InnoDB Symbolic Link (ISL) file. It is always created
under the 'datadir' of MySQL. The datadir is the directory of a under the 'datadir' of MySQL. The datadir is the directory of a
running mysqld program. We can refer to it by simply using the path ".". running mysqld program. We can refer to it by simply using the path ".".

13
storage/innobase/fts/fts0fts.cc
View File

@ -502,7 +502,6 @@ fts_load_user_stopword(
stopword_info); stopword_info);
graph = fts_parse_sql_no_dict_lock( graph = fts_parse_sql_no_dict_lock(
NULL,
info, info,
"DECLARE FUNCTION my_func;\n" "DECLARE FUNCTION my_func;\n"
"DECLARE CURSOR c IS" "DECLARE CURSOR c IS"
@ -1932,7 +1931,7 @@ fts_create_common_tables(
pars_info_bind_id(info, true, "config_table", fts_name); pars_info_bind_id(info, true, "config_table", fts_name);
graph = fts_parse_sql_no_dict_lock( graph = fts_parse_sql_no_dict_lock(
&fts_table, info, fts_config_table_insert_values_sql); info, fts_config_table_insert_values_sql);
error = fts_eval_sql(trx, graph); error = fts_eval_sql(trx, graph);
@ -2311,7 +2310,7 @@ fts_trx_create(
savep != NULL; savep != NULL;
savep = UT_LIST_GET_NEXT(trx_savepoints, savep)) { savep = UT_LIST_GET_NEXT(trx_savepoints, savep)) {
fts_savepoint_take(trx, ftt, savep->name); fts_savepoint_take(ftt, savep->name);
} }
return(ftt); return(ftt);
@ -3561,7 +3560,7 @@ fts_add_doc_by_id(
dict_index_copy_types(clust_ref, clust_index, n_fields); dict_index_copy_types(clust_ref, clust_index, n_fields);
row_build_row_ref_in_tuple( row_build_row_ref_in_tuple(
clust_ref, rec, fts_id_index, NULL, NULL); clust_ref, rec, fts_id_index, NULL);
btr_pcur_open_with_no_init( btr_pcur_open_with_no_init(
clust_index, clust_ref, PAGE_CUR_LE, clust_index, clust_ref, PAGE_CUR_LE,
@ -4725,7 +4724,7 @@ fts_tokenize_add_word_for_parser(
MYSQL_FTPARSER_PARAM* param, /* in: parser paramter */ MYSQL_FTPARSER_PARAM* param, /* in: parser paramter */
const char* word, /* in: token word */ const char* word, /* in: token word */
int word_len, /* in: word len */ int word_len, /* in: word len */
MYSQL_FTPARSER_BOOLEAN_INFO* boolean_info) /* in: word boolean info */ MYSQL_FTPARSER_BOOLEAN_INFO*)
{ {
fts_string_t str; fts_string_t str;
fts_tokenize_param_t* fts_param; fts_tokenize_param_t* fts_param;
@ -5634,7 +5633,6 @@ Take a FTS savepoint. */
void void
fts_savepoint_take( fts_savepoint_take(
/*===============*/ /*===============*/
trx_t* trx, /*!< in: transaction */
fts_trx_t* fts_trx, /*!< in: fts transaction */ fts_trx_t* fts_trx, /*!< in: fts transaction */
const char* name) /*!< in: savepoint name */ const char* name) /*!< in: savepoint name */
{ {
@ -5912,7 +5910,7 @@ fts_savepoint_rollback(
ut_a(ib_vector_size(savepoints) > 0); ut_a(ib_vector_size(savepoints) > 0);
/* Restore the savepoint. */ /* Restore the savepoint. */
fts_savepoint_take(trx, trx->fts_trx, name); fts_savepoint_take(trx->fts_trx, name);
} }
} }
@ -7175,7 +7173,6 @@ fts_drop_orphaned_tables(void)
pars_info_bind_function(info, "my_func", fts_read_tables, tables); pars_info_bind_function(info, "my_func", fts_read_tables, tables);
graph = fts_parse_sql_no_dict_lock( graph = fts_parse_sql_no_dict_lock(
NULL,
info, info,
"DECLARE FUNCTION my_func;\n" "DECLARE FUNCTION my_func;\n"
"DECLARE CURSOR c IS" "DECLARE CURSOR c IS"

18
storage/innobase/fts/fts0plugin.cc
View File

@ -32,26 +32,12 @@ Created 2013/06/04 Shaohua Wang
/******************************************************************//** /******************************************************************//**
FTS default parser init FTS default parser init
@return 0 */ @return 0 */
static static int fts_default_parser_init(MYSQL_FTPARSER_PARAM*) { return 0; }
int
fts_default_parser_init(
/*====================*/
MYSQL_FTPARSER_PARAM *param) /*!< in: plugin parser param */
{
return(0);
}
/******************************************************************//** /******************************************************************//**
FTS default parser deinit FTS default parser deinit
@return 0 */ @return 0 */
static static int fts_default_parser_deinit(MYSQL_FTPARSER_PARAM*) { return 0; }
int
fts_default_parser_deinit(
/*======================*/
MYSQL_FTPARSER_PARAM *param) /*!< in: plugin parser param */
{
return(0);
}
/******************************************************************//** /******************************************************************//**
FTS default parser parse from ft_static.c in MYISAM. FTS default parser parse from ft_static.c in MYISAM.

4
storage/innobase/fts/fts0que.cc
View File

@ -1750,7 +1750,7 @@ fts_query_match_phrase_add_word_for_parser(
MYSQL_FTPARSER_PARAM* param, /*!< in: parser param */ MYSQL_FTPARSER_PARAM* param, /*!< in: parser param */
const char* word, /*!< in: token */ const char* word, /*!< in: token */
int word_len, /*!< in: token length */ int word_len, /*!< in: token length */
MYSQL_FTPARSER_BOOLEAN_INFO* info) /*!< in: token info */ MYSQL_FTPARSER_BOOLEAN_INFO*)
{ {
fts_phrase_param_t* phrase_param; fts_phrase_param_t* phrase_param;
fts_phrase_t* phrase; fts_phrase_t* phrase;
@ -3920,7 +3920,6 @@ fts_query_can_optimize(
} }
/** FTS Query entry point. /** FTS Query entry point.
@param[in] trx transaction
@param[in] index fts index to search @param[in] index fts index to search
@param[in] flags FTS search mode @param[in] flags FTS search mode
@param[in] query_str FTS query @param[in] query_str FTS query
@ -3929,7 +3928,6 @@ fts_query_can_optimize(
@return DB_SUCCESS if successful otherwise error code */ @return DB_SUCCESS if successful otherwise error code */
dberr_t dberr_t
fts_query( fts_query(
trx_t* trx,
dict_index_t* index, dict_index_t* index,
uint flags, uint flags,
const byte* query_str, const byte* query_str,

3
storage/innobase/fts/fts0sql.cc
View File

@ -199,16 +199,13 @@ Parse an SQL string.
que_t* que_t*
fts_parse_sql_no_dict_lock( fts_parse_sql_no_dict_lock(
/*=======================*/ /*=======================*/
fts_table_t* fts_table, /*!< in: FTS aux table info */
pars_info_t* info, /*!< in: info struct, or NULL */ pars_info_t* info, /*!< in: info struct, or NULL */
const char* sql) /*!< in: SQL string to evaluate */ const char* sql) /*!< in: SQL string to evaluate */
{ {
char* str; char* str;
que_t* graph; que_t* graph;
#ifdef UNIV_DEBUG
ut_ad(mutex_own(&dict_sys->mutex)); ut_ad(mutex_own(&dict_sys->mutex));
#endif
str = ut_str3cat(fts_sql_begin, sql, fts_sql_end); str = ut_str3cat(fts_sql_begin, sql, fts_sql_end);

41
storage/innobase/gis/gis0geo.cc
View File

@ -72,7 +72,6 @@ rtree_add_point_to_mbr(
where point is stored */ where point is stored */
uchar* end, /*!< in: end of wkb. */ uchar* end, /*!< in: end of wkb. */
uint n_dims, /*!< in: dimensions. */ uint n_dims, /*!< in: dimensions. */
uchar byte_order, /*!< in: byte order. */
double* mbr) /*!< in/out: mbr, which double* mbr) /*!< in/out: mbr, which
must be of length n_dims * 2. */ must be of length n_dims * 2. */
{ {
@ -112,11 +111,10 @@ rtree_get_point_mbr(
where point is stored. */ where point is stored. */
uchar* end, /*!< in: end of wkb. */ uchar* end, /*!< in: end of wkb. */
uint n_dims, /*!< in: dimensions. */ uint n_dims, /*!< in: dimensions. */
uchar byte_order, /*!< in: byte order. */
double* mbr) /*!< in/out: mbr, double* mbr) /*!< in/out: mbr,
must be of length n_dims * 2. */ must be of length n_dims * 2. */
{ {
return rtree_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr); return rtree_add_point_to_mbr(wkb, end, n_dims, mbr);
} }
@ -131,7 +129,6 @@ rtree_get_linestring_mbr(
where point is stored. */ where point is stored. */
uchar* end, /*!< in: end of wkb. */ uchar* end, /*!< in: end of wkb. */
uint n_dims, /*!< in: dimensions. */ uint n_dims, /*!< in: dimensions. */
uchar byte_order, /*!< in: byte order. */
double* mbr) /*!< in/out: mbr, double* mbr) /*!< in/out: mbr,
must be of length n_dims * 2. */ must be of length n_dims * 2. */
{ {
@ -142,8 +139,7 @@ rtree_get_linestring_mbr(
for (; n_points > 0; --n_points) { for (; n_points > 0; --n_points) {
/* Add next point to mbr */ /* Add next point to mbr */
if (rtree_add_point_to_mbr(wkb, end, n_dims, if (rtree_add_point_to_mbr(wkb, end, n_dims, mbr)) {
byte_order, mbr)) {
return(-1); return(-1);
} }
} }
@ -162,7 +158,6 @@ rtree_get_polygon_mbr(
where point is stored. */ where point is stored. */
uchar* end, /*!< in: end of wkb. */ uchar* end, /*!< in: end of wkb. */
uint n_dims, /*!< in: dimensions. */ uint n_dims, /*!< in: dimensions. */
uchar byte_order, /*!< in: byte order. */
double* mbr) /*!< in/out: mbr, double* mbr) /*!< in/out: mbr,
must be of length n_dims * 2. */ must be of length n_dims * 2. */
{ {
@ -178,8 +173,7 @@ rtree_get_polygon_mbr(
for (; n_points > 0; --n_points) { for (; n_points > 0; --n_points) {
/* Add next point to mbr */ /* Add next point to mbr */
if (rtree_add_point_to_mbr(wkb, end, n_dims, if (rtree_add_point_to_mbr(wkb, end, n_dims, mbr)) {
byte_order, mbr)) {
return(-1); return(-1);
} }
} }
@ -205,11 +199,10 @@ rtree_get_geometry_mbr(
by itself. */ by itself. */
{ {
int res; int res;
uchar byte_order = 2;
uint wkb_type = 0; uint wkb_type = 0;
uint n_items; uint n_items;
byte_order = *(*wkb); /* byte_order = *(*wkb); */
++(*wkb); ++(*wkb);
wkb_type = uint4korr((*wkb)); wkb_type = uint4korr((*wkb));
@ -217,24 +210,22 @@ rtree_get_geometry_mbr(
switch ((enum wkbType) wkb_type) { switch ((enum wkbType) wkb_type) {
case wkbPoint: case wkbPoint:
res = rtree_get_point_mbr(wkb, end, n_dims, byte_order, mbr); res = rtree_get_point_mbr(wkb, end, n_dims, mbr);
break; break;
case wkbLineString: case wkbLineString:
res = rtree_get_linestring_mbr(wkb, end, n_dims, res = rtree_get_linestring_mbr(wkb, end, n_dims, mbr);
byte_order, mbr);
break; break;
case wkbPolygon: case wkbPolygon:
res = rtree_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr); res = rtree_get_polygon_mbr(wkb, end, n_dims, mbr);
break; break;
case wkbMultiPoint: case wkbMultiPoint:
n_items = uint4korr((*wkb)); n_items = uint4korr((*wkb));
(*wkb) += 4; (*wkb) += 4;
for (; n_items > 0; --n_items) { for (; n_items > 0; --n_items) {
byte_order = *(*wkb); /* byte_order = *(*wkb); */
++(*wkb); ++(*wkb);
(*wkb) += 4; (*wkb) += 4;
if (rtree_get_point_mbr(wkb, end, n_dims, if (rtree_get_point_mbr(wkb, end, n_dims, mbr)) {
byte_order, mbr)) {
return(-1); return(-1);
} }
} }
@ -244,11 +235,10 @@ rtree_get_geometry_mbr(
n_items = uint4korr((*wkb)); n_items = uint4korr((*wkb));
(*wkb) += 4; (*wkb) += 4;
for (; n_items > 0; --n_items) { for (; n_items > 0; --n_items) {
byte_order = *(*wkb); /* byte_order = *(*wkb); */
++(*wkb); ++(*wkb);
(*wkb) += 4; (*wkb) += 4;
if (rtree_get_linestring_mbr(wkb, end, n_dims, if (rtree_get_linestring_mbr(wkb, end, n_dims, mbr)) {
byte_order, mbr)) {
return(-1); return(-1);
} }
} }
@ -258,11 +248,10 @@ rtree_get_geometry_mbr(
n_items = uint4korr((*wkb)); n_items = uint4korr((*wkb));
(*wkb) += 4; (*wkb) += 4;
for (; n_items > 0; --n_items) { for (; n_items > 0; --n_items) {
byte_order = *(*wkb); /* byte_order = *(*wkb); */
++(*wkb); ++(*wkb);
(*wkb) += 4; (*wkb) += 4;
if (rtree_get_polygon_mbr(wkb, end, n_dims, if (rtree_get_polygon_mbr(wkb, end, n_dims, mbr)) {
byte_order, mbr)) {
return(-1); return(-1);
} }
} }
@ -402,7 +391,7 @@ copy_coords(
/*========*/ /*========*/
double* dst, /*!< in/out: destination. */ double* dst, /*!< in/out: destination. */
const double* src, /*!< in: source. */ const double* src, /*!< in: source. */
int n_dim) /*!< in: dimensions. */ int)
{ {
memcpy(dst, src, DATA_MBR_LEN); memcpy(dst, src, DATA_MBR_LEN);
} }
@ -624,7 +613,7 @@ rtree_key_cmp(
/*==========*/ /*==========*/
page_cur_mode_t mode, /*!< in: compare method. */ page_cur_mode_t mode, /*!< in: compare method. */
const uchar* b, /*!< in: first key. */ const uchar* b, /*!< in: first key. */
int b_len, /*!< in: first key len. */ int,
const uchar* a, /*!< in: second key. */ const uchar* a, /*!< in: second key. */
int a_len) /*!< in: second key len. */ int a_len) /*!< in: second key len. */
{ {

54
storage/innobase/gis/gis0rtree.cc
View File

@ -133,10 +133,8 @@ rtr_index_build_node_ptr(
pointer */ pointer */
ulint page_no,/*!< in: page number to put in node ulint page_no,/*!< in: page number to put in node
pointer */ pointer */
mem_heap_t* heap, /*!< in: memory heap where pointer mem_heap_t* heap) /*!< in: memory heap where pointer
created */ created */
ulint level) /*!< in: level of rec in tree:
0 means leaf level */
{ {
dtuple_t* tuple; dtuple_t* tuple;
dfield_t* field; dfield_t* field;
@ -291,7 +289,6 @@ rtr_update_mbr_field(
ulint up_match = 0; ulint up_match = 0;
ulint low_match = 0; ulint low_match = 0;
ulint child; ulint child;
ulint level;
ulint rec_info; ulint rec_info;
page_zip_des_t* page_zip; page_zip_des_t* page_zip;
bool ins_suc = true; bool ins_suc = true;
@ -310,7 +307,7 @@ rtr_update_mbr_field(
page_zip = buf_block_get_page_zip(block); page_zip = buf_block_get_page_zip(block);
child = btr_node_ptr_get_child_page_no(rec, offsets); child = btr_node_ptr_get_child_page_no(rec, offsets);
level = btr_page_get_level(buf_block_get_frame(block)); const bool is_leaf = page_is_leaf(block->frame);
if (new_rec) { if (new_rec) {
child_rec = new_rec; child_rec = new_rec;
@ -319,7 +316,7 @@ rtr_update_mbr_field(
} }
dtuple_t* node_ptr = rtr_index_build_node_ptr( dtuple_t* node_ptr = rtr_index_build_node_ptr(
index, mbr, child_rec, child, heap, level); index, mbr, child_rec, child, heap);
/* We need to remember the child page no of cursor2, since page could be /* We need to remember the child page no of cursor2, since page could be
reorganized or insert a new rec before it. */ reorganized or insert a new rec before it. */
@ -429,7 +426,7 @@ rtr_update_mbr_field(
ut_ad(old_rec != insert_rec); ut_ad(old_rec != insert_rec);
page_cur_position(old_rec, block, &page_cur); page_cur_position(old_rec, block, &page_cur);
offsets2 = rec_get_offsets(old_rec, index, NULL, !level, offsets2 = rec_get_offsets(old_rec, index, NULL, is_leaf,
ULINT_UNDEFINED, &heap); ULINT_UNDEFINED, &heap);
page_cur_delete_rec(&page_cur, index, offsets2, mtr); page_cur_delete_rec(&page_cur, index, offsets2, mtr);
@ -459,7 +456,7 @@ update_mbr:
cur2_rec = cursor2->page_cur.rec; cur2_rec = cursor2->page_cur.rec;
offsets2 = rec_get_offsets(cur2_rec, index, NULL, offsets2 = rec_get_offsets(cur2_rec, index, NULL,
!level, is_leaf,
ULINT_UNDEFINED, &heap); ULINT_UNDEFINED, &heap);
cur2_rec_info = rec_get_info_bits(cur2_rec, cur2_rec_info = rec_get_info_bits(cur2_rec,
@ -519,7 +516,7 @@ update_mbr:
if (ins_suc) { if (ins_suc) {
btr_cur_position(index, insert_rec, block, cursor); btr_cur_position(index, insert_rec, block, cursor);
offsets = rec_get_offsets(insert_rec, offsets = rec_get_offsets(insert_rec,
index, offsets, !level, index, offsets, is_leaf,
ULINT_UNDEFINED, &heap); ULINT_UNDEFINED, &heap);
} }
@ -534,7 +531,7 @@ update_mbr:
cur2_rec = btr_cur_get_rec(cursor2); cur2_rec = btr_cur_get_rec(cursor2);
offsets2 = rec_get_offsets(cur2_rec, index, NULL, offsets2 = rec_get_offsets(cur2_rec, index, NULL,
!level, is_leaf,
ULINT_UNDEFINED, &heap); ULINT_UNDEFINED, &heap);
/* If the cursor2 position is on a wrong rec, we /* If the cursor2 position is on a wrong rec, we
@ -548,7 +545,7 @@ update_mbr:
while (!page_rec_is_supremum(cur2_rec)) { while (!page_rec_is_supremum(cur2_rec)) {
offsets2 = rec_get_offsets(cur2_rec, index, offsets2 = rec_get_offsets(cur2_rec, index,
NULL, NULL,
!level, is_leaf,
ULINT_UNDEFINED, ULINT_UNDEFINED,
&heap); &heap);
cur2_pno = btr_node_ptr_get_child_page_no( cur2_pno = btr_node_ptr_get_child_page_no(
@ -634,7 +631,6 @@ rtr_adjust_upper_level(
buf_block_t* new_block, /*!< in/out: the new half page */ buf_block_t* new_block, /*!< in/out: the new half page */
rtr_mbr_t* mbr, /*!< in: MBR on the old page */ rtr_mbr_t* mbr, /*!< in: MBR on the old page */
rtr_mbr_t* new_mbr, /*!< in: MBR on the new page */ rtr_mbr_t* new_mbr, /*!< in: MBR on the new page */
ulint direction, /*!< in: FSP_UP or FSP_DOWN */
mtr_t* mtr) /*!< in: mtr */ mtr_t* mtr) /*!< in: mtr */
{ {
page_t* page; page_t* page;
@ -653,10 +649,8 @@ rtr_adjust_upper_level(
ulint next_page_no; ulint next_page_no;
ulint space; ulint space;
page_cur_t* page_cursor; page_cur_t* page_cursor;
rtr_mbr_t parent_mbr;
lock_prdt_t prdt; lock_prdt_t prdt;
lock_prdt_t new_prdt; lock_prdt_t new_prdt;
lock_prdt_t parent_prdt;
dberr_t err; dberr_t err;
big_rec_t* dummy_big_rec; big_rec_t* dummy_big_rec;
rec_t* rec; rec_t* rec;
@ -686,8 +680,6 @@ rtr_adjust_upper_level(
page_cursor = btr_cur_get_page_cur(&cursor); page_cursor = btr_cur_get_page_cur(&cursor);
rtr_get_mbr_from_rec(page_cursor->rec, offsets, &parent_mbr);
rtr_update_mbr_field(&cursor, offsets, NULL, page, mbr, NULL, mtr); rtr_update_mbr_field(&cursor, offsets, NULL, page, mbr, NULL, mtr);
/* Already updated parent MBR, reset in our path */ /* Already updated parent MBR, reset in our path */
@ -703,7 +695,7 @@ rtr_adjust_upper_level(
node_ptr_upper = rtr_index_build_node_ptr( node_ptr_upper = rtr_index_build_node_ptr(
index, new_mbr, index, new_mbr,
page_rec_get_next(page_get_infimum_rec(new_page)), page_rec_get_next(page_get_infimum_rec(new_page)),
new_page_no, heap, level); new_page_no, heap);
ulint up_match = 0; ulint up_match = 0;
ulint low_match = 0; ulint low_match = 0;
@ -742,11 +734,9 @@ rtr_adjust_upper_level(
prdt.op = 0; prdt.op = 0;
new_prdt.data = static_cast<void*>(new_mbr); new_prdt.data = static_cast<void*>(new_mbr);
new_prdt.op = 0; new_prdt.op = 0;
parent_prdt.data = static_cast<void*>(&parent_mbr);
parent_prdt.op = 0;
lock_prdt_update_parent(block, new_block, &prdt, &new_prdt, lock_prdt_update_parent(block, new_block, &prdt, &new_prdt,
&parent_prdt, index->table->space->id, index->table->space->id,
page_cursor->block->page.id.page_no()); page_cursor->block->page.id.page_no());
mem_heap_free(heap); mem_heap_free(heap);
@ -1001,7 +991,6 @@ rtr_page_split_and_insert(
page_t* page; page_t* page;
page_t* new_page; page_t* new_page;
ulint page_no; ulint page_no;
byte direction;
ulint hint_page_no; ulint hint_page_no;
buf_block_t* new_block; buf_block_t* new_block;
page_zip_des_t* page_zip; page_zip_des_t* page_zip;
@ -1091,9 +1080,8 @@ func_start:
static_cast<uchar*>(first_rec)); static_cast<uchar*>(first_rec));
/* Allocate a new page to the index */ /* Allocate a new page to the index */
direction = FSP_UP;
hint_page_no = page_no + 1; hint_page_no = page_no + 1;
new_block = btr_page_alloc(cursor->index, hint_page_no, direction, new_block = btr_page_alloc(cursor->index, hint_page_no, FSP_UP,
page_level, mtr, mtr); page_level, mtr, mtr);
new_page_zip = buf_block_get_page_zip(new_block); new_page_zip = buf_block_get_page_zip(new_block);
btr_page_create(new_block, new_page_zip, cursor->index, btr_page_create(new_block, new_page_zip, cursor->index,
@ -1268,12 +1256,12 @@ after_insert:
/* Check any predicate locks need to be moved/copied to the /* Check any predicate locks need to be moved/copied to the
new page */ new page */
lock_prdt_update_split(block, new_block, &prdt, &new_prdt, lock_prdt_update_split(new_block, &prdt, &new_prdt,
cursor->index->table->space->id, page_no); cursor->index->table->space->id, page_no);
/* Adjust the upper level. */ /* Adjust the upper level. */
rtr_adjust_upper_level(cursor, flags, block, new_block, rtr_adjust_upper_level(cursor, flags, block, new_block,
&mbr, &new_mbr, direction, mtr); &mbr, &new_mbr, mtr);
/* Save the new ssn to the root page, since we need to reinit /* Save the new ssn to the root page, since we need to reinit
the first ssn value from it after restart server. */ the first ssn value from it after restart server. */
@ -1334,7 +1322,6 @@ dberr_t
rtr_ins_enlarge_mbr( rtr_ins_enlarge_mbr(
/*================*/ /*================*/
btr_cur_t* btr_cur, /*!< in: btr cursor */ btr_cur_t* btr_cur, /*!< in: btr cursor */
que_thr_t* thr, /*!< in: query thread */
mtr_t* mtr) /*!< in: mtr */ mtr_t* mtr) /*!< in: mtr */
{ {
dberr_t err = DB_SUCCESS; dberr_t err = DB_SUCCESS;
@ -1668,10 +1655,7 @@ rtr_merge_mbr_changed(
btr_cur_t* cursor2, /*!< in: the other cursor */ btr_cur_t* cursor2, /*!< in: the other cursor */
ulint* offsets, /*!< in: rec offsets */ ulint* offsets, /*!< in: rec offsets */
ulint* offsets2, /*!< in: rec offsets */ ulint* offsets2, /*!< in: rec offsets */
rtr_mbr_t* new_mbr, /*!< out: MBR to update */ rtr_mbr_t* new_mbr) /*!< out: MBR to update */
buf_block_t* merge_block, /*!< in: page to merge */
buf_block_t* block, /*!< in: page be merged */
dict_index_t* index) /*!< in: index */
{ {
double* mbr; double* mbr;
double mbr1[SPDIMS * 2]; double mbr1[SPDIMS * 2];
@ -1716,9 +1700,6 @@ rtr_merge_and_update_mbr(
ulint* offsets, /*!< in: rec offsets */ ulint* offsets, /*!< in: rec offsets */
ulint* offsets2, /*!< in: rec offsets */ ulint* offsets2, /*!< in: rec offsets */
page_t* child_page, /*!< in: the page. */ page_t* child_page, /*!< in: the page. */
buf_block_t* merge_block, /*!< in: page to merge */
buf_block_t* block, /*!< in: page be merged */
dict_index_t* index, /*!< in: index */
mtr_t* mtr) /*!< in: mtr */ mtr_t* mtr) /*!< in: mtr */
{ {
dberr_t err = DB_SUCCESS; dberr_t err = DB_SUCCESS;
@ -1728,8 +1709,7 @@ rtr_merge_and_update_mbr(
ut_ad(dict_index_is_spatial(cursor->index)); ut_ad(dict_index_is_spatial(cursor->index));
changed = rtr_merge_mbr_changed(cursor, cursor2, offsets, offsets2, changed = rtr_merge_mbr_changed(cursor, cursor2, offsets, offsets2,
&new_mbr, merge_block, &new_mbr);
block, index);
/* Update the mbr field of the rec. And will delete the record /* Update the mbr field of the rec. And will delete the record
pointed by cursor2 */ pointed by cursor2 */
@ -1739,7 +1719,7 @@ rtr_merge_and_update_mbr(
err = DB_ERROR; err = DB_ERROR;
} }
} else { } else {
rtr_node_ptr_delete(cursor2->index, cursor2, block, mtr); rtr_node_ptr_delete(cursor2, mtr);
} }
return(err); return(err);
@ -1750,10 +1730,8 @@ Deletes on the upper level the node pointer to a page. */
void void
rtr_node_ptr_delete( rtr_node_ptr_delete(
/*================*/ /*================*/
dict_index_t* index, /*!< in: index tree */
btr_cur_t* cursor, /*!< in: search cursor, contains information btr_cur_t* cursor, /*!< in: search cursor, contains information
about parent nodes in search */ about parent nodes in search */
buf_block_t* block, /*!< in: page whose node pointer is deleted */
mtr_t* mtr) /*!< in: mtr */ mtr_t* mtr) /*!< in: mtr */
{ {
ibool compressed; ibool compressed;

5
storage/innobase/gis/gis0sea.cc
View File

@ -407,8 +407,7 @@ rtr_pcur_getnext_from_path(
} }
lock_prdt_lock(block, &prdt, index, LOCK_S, lock_prdt_lock(block, &prdt, index, LOCK_S,
LOCK_PREDICATE, btr_cur->rtr_info->thr, LOCK_PREDICATE, btr_cur->rtr_info->thr);
mtr);
if (rw_latch == RW_NO_LATCH) { if (rw_latch == RW_NO_LATCH) {
rw_lock_s_unlock(&(block->lock)); rw_lock_s_unlock(&(block->lock));
@ -729,7 +728,7 @@ rtr_page_get_father_node_ptr(
rtr_get_mbr_from_rec(user_rec, offsets, &mbr); rtr_get_mbr_from_rec(user_rec, offsets, &mbr);
tuple = rtr_index_build_node_ptr( tuple = rtr_index_build_node_ptr(
index, &mbr, user_rec, page_no, heap, level); index, &mbr, user_rec, page_no, heap);
if (sea_cur && !sea_cur->rtr_info) { if (sea_cur && !sea_cur->rtr_info) {
sea_cur = NULL; sea_cur = NULL;

396
storage/innobase/handler/ha_innodb.cc
View File

@ -779,7 +779,7 @@ static
int int
innodb_tmpdir_validate( innodb_tmpdir_validate(
THD* thd, THD* thd,
struct st_mysql_sys_var* var, struct st_mysql_sys_var*,
void* save, void* save,
struct st_mysql_value* value) struct st_mysql_value* value)
{ {
@ -1531,9 +1531,7 @@ static
int int
innobase_commit_concurrency_validate( innobase_commit_concurrency_validate(
/*=================================*/ /*=================================*/
THD* thd, /*!< in: thread handle */ THD*, st_mysql_sys_var*,
struct st_mysql_sys_var* var, /*!< in: pointer to system
variable */
void* save, /*!< out: immediate result void* save, /*!< out: immediate result
for update function */ for update function */
struct st_mysql_value* value) /*!< in: incoming string */ struct st_mysql_value* value) /*!< in: incoming string */
@ -1695,10 +1693,7 @@ extern "C" time_t thd_start_time(const THD* thd);
/******************************************************************//** /******************************************************************//**
Get the thread start time. Get the thread start time.
@return the thread start time in seconds since the epoch. */ @return the thread start time in seconds since the epoch. */
ulint ulint thd_start_time_in_secs(THD*)
thd_start_time_in_secs(
/*===================*/
THD* thd) /*!< in: thread handle, or NULL */
{ {
// FIXME: This function should be added to the server code. // FIXME: This function should be added to the server code.
//return(thd_start_time(thd)); //return(thd_start_time(thd));
@ -3133,7 +3128,7 @@ innobase_query_caching_of_table_permitted(
const char* full_name, /*!< in: normalized path to the table */ const char* full_name, /*!< in: normalized path to the table */
uint full_name_len, /*!< in: length of the normalized path uint full_name_len, /*!< in: length of the normalized path
to the table */ to the table */
ulonglong *unused) /*!< unused for this engine */ ulonglong *)
{ {
char norm_name[1000]; char norm_name[1000];
trx_t* trx = check_trx_exists(thd); trx_t* trx = check_trx_exists(thd);
@ -3187,13 +3182,11 @@ innobase_invalidate_query_cache(
/*============================*/ /*============================*/
trx_t* trx, /*!< in: transaction which trx_t* trx, /*!< in: transaction which
modifies the table */ modifies the table */
const char* full_name, /*!< in: concatenation of const char* full_name) /*!< in: concatenation of
database name, path separator, database name, path separator,
table name, null char NUL; table name, null char NUL;
NOTE that in Windows this is NOTE that in Windows this is
always in LOWER CASE! */ always in LOWER CASE! */
ulint full_name_len) /*!< in: full name length where
also the null chars count */
{ {
/* Note that the sync0mutex.h rank of the query cache mutex is just /* Note that the sync0mutex.h rank of the query cache mutex is just
above the InnoDB trx_sys_t->lock. The caller of this function must above the InnoDB trx_sys_t->lock. The caller of this function must
@ -4793,7 +4786,6 @@ UNIV_INTERN
void void
innobase_mysql_log_notify( innobase_mysql_log_notify(
/*======================*/ /*======================*/
ib_uint64_t write_lsn, /*!< in: LSN written to log file */
ib_uint64_t flush_lsn) /*!< in: LSN flushed to disk */ ib_uint64_t flush_lsn) /*!< in: LSN flushed to disk */
{ {
struct pending_checkpoint * pending; struct pending_checkpoint * pending;
@ -4996,7 +4988,7 @@ innobase_savepoint(
dberr_t error = trx_savepoint_for_mysql(trx, name, 0); dberr_t error = trx_savepoint_for_mysql(trx, name, 0);
if (error == DB_SUCCESS && trx->fts_trx != NULL) { if (error == DB_SUCCESS && trx->fts_trx != NULL) {
fts_savepoint_take(trx, trx->fts_trx, name); fts_savepoint_take(trx->fts_trx, name);
} }
DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL)); DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL));
@ -6432,7 +6424,11 @@ platforms.
@return dictionary table object or NULL if not found */ @return dictionary table object or NULL if not found */
dict_table_t* dict_table_t*
ha_innobase::open_dict_table( ha_innobase::open_dict_table(
const char* table_name, const char*
#ifdef _WIN32
table_name
#endif
,
const char* norm_name, const char* norm_name,
bool is_partition, bool is_partition,
dict_err_ignore_t ignore_err) dict_err_ignore_t ignore_err)
@ -8727,8 +8723,7 @@ wsrep_calc_row_hash(
const uchar* row, /*!< in: row in MySQL format */ const uchar* row, /*!< in: row in MySQL format */
TABLE* table, /*!< in: table in MySQL data TABLE* table, /*!< in: table in MySQL data
dictionary */ dictionary */
row_prebuilt_t* prebuilt, /*!< in: InnoDB prebuilt struct */ row_prebuilt_t* prebuilt) /*!< in: InnoDB prebuilt struct */
THD* thd) /*!< in: user thread */
{ {
Field* field; Field* field;
enum_field_types field_mysql_type; enum_field_types field_mysql_type;
@ -9116,8 +9111,7 @@ int
ha_innobase::index_init( ha_innobase::index_init(
/*====================*/ /*====================*/
uint keynr, /*!< in: key (index) number */ uint keynr, /*!< in: key (index) number */
bool sorted) /*!< in: 1 if result MUST be sorted bool)
according to index */
{ {
DBUG_ENTER("index_init"); DBUG_ENTER("index_init");
@ -9303,8 +9297,7 @@ ha_innobase::index_read(
m_prebuilt->srch_key_val_len, m_prebuilt->srch_key_val_len,
index, index,
(byte*) key_ptr, (byte*) key_ptr,
(ulint) key_len, (ulint) key_len);
m_prebuilt->trx);
DBUG_ASSERT(m_prebuilt->search_tuple->n_fields > 0); DBUG_ASSERT(m_prebuilt->search_tuple->n_fields > 0);
} else { } else {
@ -9723,8 +9716,7 @@ int
ha_innobase::index_next_same( ha_innobase::index_next_same(
/*=========================*/ /*=========================*/
uchar* buf, /*!< in/out: buffer for the row */ uchar* buf, /*!< in/out: buffer for the row */
const uchar* key, /*!< in: key value */ const uchar*, uint)
uint keylen) /*!< in: key value length */
{ {
return(general_fetch(buf, ROW_SEL_NEXT, m_last_match_mode)); return(general_fetch(buf, ROW_SEL_NEXT, m_last_match_mode));
} }
@ -10016,7 +10008,8 @@ ha_innobase::ft_init_ext(
const_cast<char*>(query)); const_cast<char*>(query));
// FIXME: support ft_init_ext_with_hints(), pass LIMIT // FIXME: support ft_init_ext_with_hints(), pass LIMIT
dberr_t error = fts_query(trx, index, flags, q, query_len, &result); // FIXME: use trx
dberr_t error = fts_query(index, flags, q, query_len, &result);
if (error != DB_SUCCESS) { if (error != DB_SUCCESS) {
my_error(convert_error_code_to_mysql(error, 0, NULL), MYF(0)); my_error(convert_error_code_to_mysql(error, 0, NULL), MYF(0));
@ -10038,25 +10031,6 @@ ha_innobase::ft_init_ext(
return(reinterpret_cast<FT_INFO*>(fts_hdl)); return(reinterpret_cast<FT_INFO*>(fts_hdl));
} }
/**********************************************************************//**
Initialize FT index scan
@return FT_INFO structure if successful or NULL */
FT_INFO*
ha_innobase::ft_init_ext_with_hints(
/*================================*/
uint keynr, /* in: key num */
String* key, /* in: key */
void* hints) /* in: hints */
{
/* TODO Implement function properly working with FT hint. */
#ifdef MYSQL_FT_INIT_EXT
return(ft_init_ext(hints->get_flags(), keynr, key));
#else
return NULL;
#endif
}
/*****************************************************************//** /*****************************************************************//**
Set up search tuple for a query through FTS_DOC_ID_INDEX on Set up search tuple for a query through FTS_DOC_ID_INDEX on
supplied Doc ID. This is used by MySQL to retrieve the documents supplied Doc ID. This is used by MySQL to retrieve the documents
@ -10460,7 +10434,6 @@ wsrep_append_key(
THD *thd, THD *thd,
trx_t *trx, trx_t *trx,
TABLE_SHARE *table_share, TABLE_SHARE *table_share,
TABLE *table,
const char* key, const char* key,
uint16_t key_len, uint16_t key_len,
bool shared bool shared
@ -10573,7 +10546,7 @@ ha_innobase::wsrep_append_keys(
if (!is_null) { if (!is_null) {
rcode = wsrep_append_key( rcode = wsrep_append_key(
thd, trx, table_share, table, keyval, thd, trx, table_share, keyval,
len, shared); len, shared);
if (rcode) { if (rcode) {
@ -10627,7 +10600,7 @@ ha_innobase::wsrep_append_keys(
record0, &is_null); record0, &is_null);
if (!is_null) { if (!is_null) {
rcode = wsrep_append_key( rcode = wsrep_append_key(
thd, trx, table_share, table, thd, trx, table_share,
keyval0, len+1, shared); keyval0, len+1, shared);
if (rcode) { if (rcode) {
@ -10650,7 +10623,6 @@ ha_innobase::wsrep_append_keys(
if (!is_null && memcmp(key0, key1, len)) { if (!is_null && memcmp(key0, key1, len)) {
rcode = wsrep_append_key( rcode = wsrep_append_key(
thd, trx, table_share, thd, trx, table_share,
table,
keyval1, len+1, shared); keyval1, len+1, shared);
if (rcode) DBUG_RETURN(rcode); if (rcode) DBUG_RETURN(rcode);
} }
@ -10664,9 +10636,9 @@ ha_innobase::wsrep_append_keys(
uchar digest[16]; uchar digest[16];
int rcode; int rcode;
wsrep_calc_row_hash(digest, record0, table, m_prebuilt, thd); wsrep_calc_row_hash(digest, record0, table, m_prebuilt);
if ((rcode = wsrep_append_key(thd, trx, table_share, table, if ((rcode = wsrep_append_key(thd, trx, table_share,
(const char*) digest, 16, (const char*) digest, 16,
shared))) { shared))) {
DBUG_RETURN(rcode); DBUG_RETURN(rcode);
@ -10674,9 +10646,8 @@ ha_innobase::wsrep_append_keys(
if (record1) { if (record1) {
wsrep_calc_row_hash( wsrep_calc_row_hash(
digest, record1, table, m_prebuilt, thd); digest, record1, table, m_prebuilt);
if ((rcode = wsrep_append_key(thd, trx, table_share, if ((rcode = wsrep_append_key(thd, trx, table_share,
table,
(const char*) digest, (const char*) digest,
16, shared))) { 16, shared))) {
DBUG_RETURN(rcode); DBUG_RETURN(rcode);
@ -11817,7 +11788,11 @@ innobase_fts_load_stopword(
@return 0 if successful, otherwise, error number */ @return 0 if successful, otherwise, error number */
int int
create_table_info_t::parse_table_name( create_table_info_t::parse_table_name(
const char* name) const char*
#ifdef _WIN32
name
#endif
)
{ {
DBUG_ENTER("parse_table_name"); DBUG_ENTER("parse_table_name");
@ -12096,8 +12071,7 @@ index_bad:
m_use_data_dir, m_use_data_dir,
options->page_compressed, options->page_compressed,
options->page_compression_level == 0 ? options->page_compression_level == 0 ?
default_compression_level : static_cast<ulint>(options->page_compression_level), default_compression_level : ulint(options->page_compression_level));
0);
if (m_form->s->table_type == TABLE_TYPE_SEQUENCE) { if (m_form->s->table_type == TABLE_TYPE_SEQUENCE) {
m_flags |= DICT_TF_MASK_NO_ROLLBACK; m_flags |= DICT_TF_MASK_NO_ROLLBACK;
@ -13430,8 +13404,7 @@ ha_innobase::records_in_range(
m_prebuilt->srch_key_val_len, m_prebuilt->srch_key_val_len,
index, index,
(byte*) (min_key ? min_key->key : (const uchar*) 0), (byte*) (min_key ? min_key->key : (const uchar*) 0),
(ulint) (min_key ? min_key->length : 0), (ulint) (min_key ? min_key->length : 0));
m_prebuilt->trx);
DBUG_ASSERT(min_key DBUG_ASSERT(min_key
? range_start->n_fields > 0 ? range_start->n_fields > 0
@ -13443,8 +13416,7 @@ ha_innobase::records_in_range(
m_prebuilt->srch_key_val_len, m_prebuilt->srch_key_val_len,
index, index,
(byte*) (max_key ? max_key->key : (const uchar*) 0), (byte*) (max_key ? max_key->key : (const uchar*) 0),
(ulint) (max_key ? max_key->length : 0), (ulint) (max_key ? max_key->length : 0));
m_prebuilt->trx);
DBUG_ASSERT(max_key DBUG_ASSERT(max_key
? range_end->n_fields > 0 ? range_end->n_fields > 0
@ -14203,10 +14175,7 @@ each index tree. This does NOT calculate exact statistics on the table.
@return HA_ADMIN_* error code or HA_ADMIN_OK */ @return HA_ADMIN_* error code or HA_ADMIN_OK */
int int
ha_innobase::analyze( ha_innobase::analyze(THD*, HA_CHECK_OPT*)
/*=================*/
THD* thd, /*!< in: connection thread handle */
HA_CHECK_OPT* check_opt) /*!< in: currently ignored */
{ {
/* Simply call info_low() with all the flags /* Simply call info_low() with all the flags
and request recalculation of the statistics */ and request recalculation of the statistics */
@ -14343,7 +14312,7 @@ int
ha_innobase::optimize( ha_innobase::optimize(
/*==================*/ /*==================*/
THD* thd, /*!< in: connection thread handle */ THD* thd, /*!< in: connection thread handle */
HA_CHECK_OPT* check_opt) /*!< in: currently ignored */ HA_CHECK_OPT*)
{ {
/* FTS-FIXME: Since MySQL doesn't support engine-specific commands, /* FTS-FIXME: Since MySQL doesn't support engine-specific commands,
@ -15926,12 +15895,10 @@ struct ShowStatus {
spins=N,waits=N,calls=N" spins=N,waits=N,calls=N"
The user has to parse the dataunfortunately The user has to parse the dataunfortunately
@param[in,out] hton the innodb handlerton
@param[in,out] thd the MySQL query thread of the caller @param[in,out] thd the MySQL query thread of the caller
@param[in,out] stat_print function for printing statistics @param[in,out] stat_print function for printing statistics
@return true on success. */ @return true on success. */
bool to_string( bool to_string(
handlerton* hton,
THD* thd, THD* thd,
stat_print_fn* stat_print) stat_print_fn* stat_print)
UNIV_NOTHROW; UNIV_NOTHROW;
@ -15947,13 +15914,11 @@ We store the metrics in the "Status" column as:
spins=N,waits=N,calls=N" spins=N,waits=N,calls=N"
The user has to parse the dataunfortunately The user has to parse the dataunfortunately
@param[in,out] hton the innodb handlerton
@param[in,out] thd the MySQL query thread of the caller @param[in,out] thd the MySQL query thread of the caller
@param[in,out] stat_print function for printing statistics @param[in,out] stat_print function for printing statistics
@return true on success. */ @return true on success. */
bool bool
ShowStatus::to_string( ShowStatus::to_string(
handlerton* hton,
THD* thd, THD* thd,
stat_print_fn* stat_print) stat_print_fn* stat_print)
UNIV_NOTHROW UNIV_NOTHROW
@ -16002,7 +15967,11 @@ ShowStatus::to_string(
static static
int int
innodb_show_mutex_status( innodb_show_mutex_status(
handlerton* hton, handlerton*
#ifndef DBUG_OFF
hton
#endif
,
THD* thd, THD* thd,
stat_print_fn* stat_print) stat_print_fn* stat_print)
{ {
@ -16014,7 +15983,7 @@ innodb_show_mutex_status(
mutex_monitor.iterate(collector); mutex_monitor.iterate(collector);
if (!collector.to_string(hton, thd, stat_print)) { if (!collector.to_string(thd, stat_print)) {
DBUG_RETURN(1); DBUG_RETURN(1);
} }
@ -16029,7 +15998,11 @@ innodb_show_mutex_status(
static static
int int
innodb_show_rwlock_status( innodb_show_rwlock_status(
handlerton* hton, handlerton*
#ifndef DBUG_OFF
hton
#endif
,
THD* thd, THD* thd,
stat_print_fn* stat_print) stat_print_fn* stat_print)
{ {
@ -17225,10 +17198,7 @@ void
innodb_io_capacity_max_update( innodb_io_capacity_max_update(
/*===========================*/ /*===========================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*, void*,
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
from check function */ from check function */
{ {
@ -17260,10 +17230,7 @@ void
innodb_io_capacity_update( innodb_io_capacity_update(
/*======================*/ /*======================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*, void*,
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
from check function */ from check function */
{ {
@ -17295,10 +17262,7 @@ void
innodb_max_dirty_pages_pct_update( innodb_max_dirty_pages_pct_update(
/*==============================*/ /*==============================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*, void*,
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
from check function */ from check function */
{ {
@ -17329,10 +17293,7 @@ void
innodb_max_dirty_pages_pct_lwm_update( innodb_max_dirty_pages_pct_lwm_update(
/*==================================*/ /*==================================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*, void*,
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
from check function */ from check function */
{ {
@ -17394,8 +17355,7 @@ int
innodb_stopword_table_validate( innodb_stopword_table_validate(
/*===========================*/ /*===========================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to system st_mysql_sys_var*,
variable */
void* save, /*!< out: immediate result void* save, /*!< out: immediate result
for update function */ for update function */
struct st_mysql_value* value) /*!< in: incoming string */ struct st_mysql_value* value) /*!< in: incoming string */
@ -17430,17 +17390,10 @@ innodb_stopword_table_validate(
/** Update the system variable innodb_buffer_pool_size using the "saved" /** Update the system variable innodb_buffer_pool_size using the "saved"
value. This function is registered as a callback with MySQL. value. This function is registered as a callback with MySQL.
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
static static
void void
innodb_buffer_pool_size_update( innodb_buffer_pool_size_update(THD*,st_mysql_sys_var*,void*, const void* save)
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save)
{ {
longlong in_val = *static_cast<const longlong*>(save); longlong in_val = *static_cast<const longlong*>(save);
@ -17462,9 +17415,7 @@ static
int int
innodb_internal_table_validate( innodb_internal_table_validate(
/*===========================*/ /*===========================*/
THD* thd, /*!< in: thread handle */ THD*, st_mysql_sys_var*,
struct st_mysql_sys_var* var, /*!< in: pointer to system
variable */
void* save, /*!< out: immediate result void* save, /*!< out: immediate result
for update function */ for update function */
struct st_mysql_value* value) /*!< in: incoming string */ struct st_mysql_value* value) /*!< in: incoming string */
@ -17514,9 +17465,7 @@ static
void void
innodb_internal_table_update( innodb_internal_table_update(
/*=========================*/ /*=========================*/
THD* thd, /*!< in: thread handle */ THD*, st_mysql_sys_var*,
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the void* var_ptr,/*!< out: where the
formal string goes */ formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
@ -17547,15 +17496,8 @@ Update the system variable innodb_adaptive_hash_index using the "saved"
value. This function is registered as a callback with MySQL. */ value. This function is registered as a callback with MySQL. */
static static
void void
innodb_adaptive_hash_index_update( innodb_adaptive_hash_index_update(THD*, st_mysql_sys_var*, void*,
/*==============================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
if (*(my_bool*) save) { if (*(my_bool*) save) {
btr_search_enable(); btr_search_enable();
@ -17570,15 +17512,7 @@ Update the system variable innodb_cmp_per_index using the "saved"
value. This function is registered as a callback with MySQL. */ value. This function is registered as a callback with MySQL. */
static static
void void
innodb_cmp_per_index_update( innodb_cmp_per_index_update(THD*, st_mysql_sys_var*, void*, const void* save)
/*========================*/
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
/* Reset the stats whenever we enable the table /* Reset the stats whenever we enable the table
INFORMATION_SCHEMA.innodb_cmp_per_index. */ INFORMATION_SCHEMA.innodb_cmp_per_index. */
@ -17594,15 +17528,7 @@ Update the system variable innodb_old_blocks_pct using the "saved"
value. This function is registered as a callback with MySQL. */ value. This function is registered as a callback with MySQL. */
static static
void void
innodb_old_blocks_pct_update( innodb_old_blocks_pct_update(THD*, st_mysql_sys_var*, void*, const void* save)
/*=========================*/
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
innobase_old_blocks_pct = static_cast<uint>( innobase_old_blocks_pct = static_cast<uint>(
buf_LRU_old_ratio_update( buf_LRU_old_ratio_update(
@ -17614,15 +17540,8 @@ Update the system variable innodb_old_blocks_pct using the "saved"
value. This function is registered as a callback with MySQL. */ value. This function is registered as a callback with MySQL. */
static static
void void
innodb_change_buffer_max_size_update( innodb_change_buffer_max_size_update(THD*, st_mysql_sys_var*, void*,
/*=================================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
srv_change_buffer_max_size = srv_change_buffer_max_size =
(*static_cast<const uint*>(save)); (*static_cast<const uint*>(save));
@ -17637,15 +17556,7 @@ static ulong srv_saved_page_number_debug = 0;
Save an InnoDB page number. */ Save an InnoDB page number. */
static static
void void
innodb_save_page_no( innodb_save_page_no(THD*, st_mysql_sys_var*, void*, const void* save)
/*================*/
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
srv_saved_page_number_debug = *static_cast<const ulong*>(save); srv_saved_page_number_debug = *static_cast<const ulong*>(save);
@ -17657,15 +17568,7 @@ innodb_save_page_no(
Make the first page of given user tablespace dirty. */ Make the first page of given user tablespace dirty. */
static static
void void
innodb_make_page_dirty( innodb_make_page_dirty(THD*, st_mysql_sys_var*, void*, const void* save)
/*===================*/
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
mtr_t mtr; mtr_t mtr;
ulong space_id = *static_cast<const ulong*>(save); ulong space_id = *static_cast<const ulong*>(save);
@ -17709,10 +17612,7 @@ void
innodb_stats_sample_pages_update( innodb_stats_sample_pages_update(
/*=============================*/ /*=============================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*, void*,
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
from check function */ from check function */
{ {
@ -17988,9 +17888,7 @@ static
int int
innodb_monitor_validate( innodb_monitor_validate(
/*====================*/ /*====================*/
THD* thd, /*!< in: thread handle */ THD*, st_mysql_sys_var*,
struct st_mysql_sys_var* var, /*!< in: pointer to system
variable */
void* save, /*!< out: immediate result void* save, /*!< out: immediate result
for update function */ for update function */
struct st_mysql_value* value) /*!< in: incoming string */ struct st_mysql_value* value) /*!< in: incoming string */
@ -18234,13 +18132,8 @@ SET GLOBAL innodb_buffer_pool_evict='uncompressed'
evicts all uncompressed page frames of compressed tablespaces. */ evicts all uncompressed page frames of compressed tablespaces. */
static static
void void
innodb_buffer_pool_evict_update( innodb_buffer_pool_evict_update(THD*, st_mysql_sys_var*, void*,
/*============================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var*var, /*!< in: pointer to system variable */
void* var_ptr,/*!< out: ignored */
const void* save) /*!< in: immediate result
from check function */
{ {
if (const char* op = *static_cast<const char*const*>(save)) { if (const char* op = *static_cast<const char*const*>(save)) {
if (!strcmp(op, "uncompressed")) { if (!strcmp(op, "uncompressed")) {
@ -18268,8 +18161,7 @@ void
innodb_enable_monitor_update( innodb_enable_monitor_update(
/*=========================*/ /*=========================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*,
system variable */
void* var_ptr,/*!< out: where the void* var_ptr,/*!< out: where the
formal string goes */ formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
@ -18286,8 +18178,7 @@ void
innodb_disable_monitor_update( innodb_disable_monitor_update(
/*==========================*/ /*==========================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*,
system variable */
void* var_ptr,/*!< out: where the void* var_ptr,/*!< out: where the
formal string goes */ formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
@ -18305,8 +18196,7 @@ void
innodb_reset_monitor_update( innodb_reset_monitor_update(
/*========================*/ /*========================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*,
system variable */
void* var_ptr,/*!< out: where the void* var_ptr,/*!< out: where the
formal string goes */ formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
@ -18324,8 +18214,7 @@ void
innodb_reset_all_monitor_update( innodb_reset_all_monitor_update(
/*============================*/ /*============================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*,
system variable */
void* var_ptr,/*!< out: where the void* var_ptr,/*!< out: where the
formal string goes */ formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
@ -18337,15 +18226,8 @@ innodb_reset_all_monitor_update(
static static
void void
innodb_defragment_frequency_update( innodb_defragment_frequency_update(THD*, st_mysql_sys_var*, void*,
/*===============================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
srv_defragment_frequency = (*static_cast<const uint*>(save)); srv_defragment_frequency = (*static_cast<const uint*>(save));
srv_defragment_interval = ut_microseconds_to_timer( srv_defragment_interval = ut_microseconds_to_timer(
@ -18399,13 +18281,7 @@ innodb_enable_monitor_at_startup(
/****************************************************************//** /****************************************************************//**
Callback function for accessing the InnoDB variables from MySQL: Callback function for accessing the InnoDB variables from MySQL:
SHOW VARIABLES. */ SHOW VARIABLES. */
static static int show_innodb_vars(THD*, SHOW_VAR* var, char*)
int
show_innodb_vars(
/*=============*/
THD* thd,
SHOW_VAR* var,
char* buff)
{ {
innodb_export_status(); innodb_export_status();
var->type = SHOW_ARRAY; var->type = SHOW_ARRAY;
@ -18524,17 +18400,7 @@ static uint innodb_merge_threshold_set_all_debug
/** Wait for the background drop list to become empty. */ /** Wait for the background drop list to become empty. */
static static
void void
wait_background_drop_list_empty( wait_background_drop_list_empty(THD*, st_mysql_sys_var*, void*, const void*)
THD* thd /*!< in: thread handle */
MY_ATTRIBUTE((unused)),
struct st_mysql_sys_var* var /*!< in: pointer to system
variable */
MY_ATTRIBUTE((unused)),
void* var_ptr /*!< out: where the formal
string goes */
MY_ATTRIBUTE((unused)),
const void* save) /*!< in: immediate result from
check function */
{ {
row_wait_for_background_drop_list_empty(); row_wait_for_background_drop_list_empty();
} }
@ -18543,18 +18409,7 @@ wait_background_drop_list_empty(
Force innodb to checkpoint. */ Force innodb to checkpoint. */
static static
void void
checkpoint_now_set( checkpoint_now_set(THD*, st_mysql_sys_var*, void*, const void* save)
/*===============*/
THD* thd /*!< in: thread handle */
MY_ATTRIBUTE((unused)),
struct st_mysql_sys_var* var /*!< in: pointer to system
variable */
MY_ATTRIBUTE((unused)),
void* var_ptr /*!< out: where the formal
string goes */
MY_ATTRIBUTE((unused)),
const void* save) /*!< in: immediate result from
check function */
{ {
if (*(my_bool*) save) { if (*(my_bool*) save) {
while (log_sys.last_checkpoint_lsn while (log_sys.last_checkpoint_lsn
@ -18578,18 +18433,7 @@ checkpoint_now_set(
Force a dirty pages flush now. */ Force a dirty pages flush now. */
static static
void void
buf_flush_list_now_set( buf_flush_list_now_set(THD*, st_mysql_sys_var*, void*, const void* save)
/*===================*/
THD* thd /*!< in: thread handle */
MY_ATTRIBUTE((unused)),
struct st_mysql_sys_var* var /*!< in: pointer to system
variable */
MY_ATTRIBUTE((unused)),
void* var_ptr /*!< out: where the formal
string goes */
MY_ATTRIBUTE((unused)),
const void* save) /*!< in: immediate result from
check function */
{ {
if (*(my_bool*) save) { if (*(my_bool*) save) {
buf_flush_sync_all_buf_pools(); buf_flush_sync_all_buf_pools();
@ -18598,16 +18442,10 @@ buf_flush_list_now_set(
/** Override current MERGE_THRESHOLD setting for all indexes at dictionary /** Override current MERGE_THRESHOLD setting for all indexes at dictionary
now. now.
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
static static
void void
innodb_merge_threshold_set_all_debug_update( innodb_merge_threshold_set_all_debug_update(THD*, st_mysql_sys_var*, void*,
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save) const void* save)
{ {
innodb_merge_threshold_set_all_debug innodb_merge_threshold_set_all_debug
@ -18735,10 +18573,7 @@ void
innodb_log_write_ahead_size_update( innodb_log_write_ahead_size_update(
/*===============================*/ /*===============================*/
THD* thd, /*!< in: thread handle */ THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to st_mysql_sys_var*, void*,
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result const void* save) /*!< in: immediate result
from check function */ from check function */
{ {
@ -18781,12 +18616,8 @@ which control InnoDB "status monitor" output to the error log.
@param[in] save to-be-assigned value */ @param[in] save to-be-assigned value */
static static
void void
innodb_status_output_update( innodb_status_output_update(THD*, st_mysql_sys_var*, void* var_ptr,
/*========================*/ const void* save)
THD* thd __attribute__((unused)),
struct st_mysql_sys_var* var __attribute__((unused)),
void* var_ptr __attribute__((unused)),
const void* save __attribute__((unused)))
{ {
*static_cast<my_bool*>(var_ptr) = *static_cast<const my_bool*>(save); *static_cast<my_bool*>(var_ptr) = *static_cast<const my_bool*>(save);
/* Wakeup server monitor thread. */ /* Wakeup server monitor thread. */
@ -18797,15 +18628,8 @@ innodb_status_output_update(
Update the system variable innodb_encryption_threads */ Update the system variable innodb_encryption_threads */
static static
void void
innodb_encryption_threads_update( innodb_encryption_threads_update(THD*, st_mysql_sys_var*, void*,
/*=============================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
fil_crypt_set_thread_cnt(*static_cast<const uint*>(save)); fil_crypt_set_thread_cnt(*static_cast<const uint*>(save));
} }
@ -18814,15 +18638,8 @@ innodb_encryption_threads_update(
Update the system variable innodb_encryption_rotate_key_age */ Update the system variable innodb_encryption_rotate_key_age */
static static
void void
innodb_encryption_rotate_key_age_update( innodb_encryption_rotate_key_age_update(THD*, st_mysql_sys_var*, void*,
/*====================================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
fil_crypt_set_rotate_key_age(*static_cast<const uint*>(save)); fil_crypt_set_rotate_key_age(*static_cast<const uint*>(save));
} }
@ -18831,15 +18648,8 @@ innodb_encryption_rotate_key_age_update(
Update the system variable innodb_encryption_rotation_iops */ Update the system variable innodb_encryption_rotation_iops */
static static
void void
innodb_encryption_rotation_iops_update( innodb_encryption_rotation_iops_update(THD*, st_mysql_sys_var*, void*,
/*===================================*/ const void* save)
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
fil_crypt_set_rotation_iops(*static_cast<const uint*>(save)); fil_crypt_set_rotation_iops(*static_cast<const uint*>(save));
} }
@ -18848,30 +18658,18 @@ innodb_encryption_rotation_iops_update(
Update the system variable innodb_encrypt_tables*/ Update the system variable innodb_encrypt_tables*/
static static
void void
innodb_encrypt_tables_update( innodb_encrypt_tables_update(THD*, st_mysql_sys_var*, void*, const void* save)
/*=========================*/
THD* thd, /*!< in: thread handle */
struct st_mysql_sys_var* var, /*!< in: pointer to
system variable */
void* var_ptr,/*!< out: where the
formal string goes */
const void* save) /*!< in: immediate result
from check function */
{ {
fil_crypt_set_encrypt_tables(*static_cast<const ulong*>(save)); fil_crypt_set_encrypt_tables(*static_cast<const ulong*>(save));
} }
/** Update the innodb_log_checksums parameter. /** Update the innodb_log_checksums parameter.
@param[in] thd thread handle @param[in,out] thd client connection
@param[in] var system variable
@param[out] var_ptr current value @param[out] var_ptr current value
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
static static
void void
innodb_log_checksums_update( innodb_log_checksums_update(THD* thd, st_mysql_sys_var*, void* var_ptr,
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save) const void* save)
{ {
*static_cast<my_bool*>(var_ptr) = innodb_log_checksums_func_update( *static_cast<my_bool*>(var_ptr) = innodb_log_checksums_func_update(
@ -19127,7 +18925,7 @@ static
int int
wsrep_abort_transaction( wsrep_abort_transaction(
/*====================*/ /*====================*/
handlerton* hton, handlerton*,
THD *bf_thd, THD *bf_thd,
THD *victim_thd, THD *victim_thd,
my_bool signal) my_bool signal)
@ -19191,12 +18989,7 @@ innobase_wsrep_get_checkpoint(
return 0; return 0;
} }
static static void wsrep_fake_trx_id(handlerton *, THD *thd)
void
wsrep_fake_trx_id(
/*==============*/
handlerton *hton,
THD *thd) /*!< in: user thread handle */
{ {
trx_id_t trx_id = trx_sys.get_new_trx_id(); trx_id_t trx_id = trx_sys.get_new_trx_id();
WSREP_DEBUG("innodb fake trx id: " TRX_ID_FMT " thd: %s", WSREP_DEBUG("innodb fake trx id: " TRX_ID_FMT " thd: %s",
@ -20074,14 +19867,8 @@ static my_bool innobase_disallow_writes = FALSE;
An "update" method for innobase_disallow_writes variable. */ An "update" method for innobase_disallow_writes variable. */
static static
void void
innobase_disallow_writes_update( innobase_disallow_writes_update(THD*, st_mysql_sys_var*,
/*============================*/ void* var_ptr, const void* save)
THD* thd, /* in: thread handle */
st_mysql_sys_var* var, /* in: pointer to system
variable */
void* var_ptr, /* out: pointer to dynamic
variable */
const void* save) /* in: temporary storage */
{ {
*(my_bool*)var_ptr = *(my_bool*)save; *(my_bool*)var_ptr = *(my_bool*)save;
ut_a(srv_allow_writes_event); ut_a(srv_allow_writes_event);
@ -21371,7 +21158,6 @@ ib_warn_row_too_big(const dict_table_t* table)
/** Validate the requested buffer pool size. Also, reserve the necessary /** Validate the requested buffer pool size. Also, reserve the necessary
memory needed for buffer pool resize. memory needed for buffer pool resize.
@param[in] thd thread handle @param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] save immediate result for update function @param[out] save immediate result for update function
@param[in] value incoming string @param[in] value incoming string
@return 0 on success, 1 on failure. @return 0 on success, 1 on failure.
@ -21380,7 +21166,7 @@ static
int int
innodb_buffer_pool_size_validate( innodb_buffer_pool_size_validate(
THD* thd, THD* thd,
struct st_mysql_sys_var* var, st_mysql_sys_var*,
void* save, void* save,
struct st_mysql_value* value) struct st_mysql_value* value)
{ {

6
storage/innobase/handler/ha_innodb.h
View File

@ -186,12 +186,6 @@ public:
FT_INFO* ft_init_ext(uint flags, uint inx, String* key); FT_INFO* ft_init_ext(uint flags, uint inx, String* key);
FT_INFO* ft_init_ext_with_hints(
uint inx,
String* key,
void* hints);
//Ft_hints* hints);
int ft_read(uchar* buf); int ft_read(uchar* buf);
void position(const uchar *record); void position(const uchar *record);

58
storage/innobase/handler/handler0alter.cc
View File

@ -223,7 +223,6 @@ struct ha_innobase_inplace_ctx : public inplace_alter_handler_ctx
ulint add_autoinc_arg, ulint add_autoinc_arg,
ulonglong autoinc_col_min_value_arg, ulonglong autoinc_col_min_value_arg,
ulonglong autoinc_col_max_value_arg, ulonglong autoinc_col_max_value_arg,
ulint num_to_drop_vcol_arg,
bool ignore_flag) : bool ignore_flag) :
inplace_alter_handler_ctx(), inplace_alter_handler_ctx(),
prebuilt (prebuilt_arg), prebuilt (prebuilt_arg),
@ -1522,12 +1521,10 @@ no_match:
Find an index whose first fields are the columns in the array Find an index whose first fields are the columns in the array
in the same order and is not marked for deletion in the same order and is not marked for deletion
@return matching index, NULL if not found */ @return matching index, NULL if not found */
static MY_ATTRIBUTE((nonnull(1,2,6), warn_unused_result)) static MY_ATTRIBUTE((nonnull(1,5), warn_unused_result))
dict_index_t* dict_index_t*
innobase_find_fk_index( innobase_find_fk_index(
/*===================*/ /*===================*/
Alter_inplace_info* ha_alter_info,
/*!< in: alter table info */
dict_table_t* table, /*!< in: table */ dict_table_t* table, /*!< in: table */
const char** col_names, const char** col_names,
/*!< in: column names, or NULL /*!< in: column names, or NULL
@ -1708,7 +1705,6 @@ innobase_get_foreign_key_info(
} }
index = innobase_find_fk_index( index = innobase_find_fk_index(
ha_alter_info,
table, col_names, table, col_names,
drop_index, n_drop_index, drop_index, n_drop_index,
column_names, i); column_names, i);
@ -3138,12 +3134,11 @@ column that is being dropped or modified to NOT NULL.
@retval true Not allowed (will call my_error()) @retval true Not allowed (will call my_error())
@retval false Allowed @retval false Allowed
*/ */
MY_ATTRIBUTE((pure, nonnull(1,2,3,4), warn_unused_result)) MY_ATTRIBUTE((pure, nonnull(1,2,3), warn_unused_result))
static static
bool bool
innobase_check_foreigns( innobase_check_foreigns(
Alter_inplace_info* ha_alter_info, Alter_inplace_info* ha_alter_info,
const TABLE* altered_table,
const TABLE* old_table, const TABLE* old_table,
const dict_table_t* user_table, const dict_table_t* user_table,
dict_foreign_t** drop_fk, dict_foreign_t** drop_fk,
@ -3899,7 +3894,6 @@ prepare_inplace_add_virtual(
/** Collect virtual column info for its addition /** Collect virtual column info for its addition
@param[in] ha_alter_info Data used during in-place alter @param[in] ha_alter_info Data used during in-place alter
@param[in] altered_table MySQL table that is being altered to
@param[in] table MySQL table as it is before the ALTER operation @param[in] table MySQL table as it is before the ALTER operation
@retval true Failure @retval true Failure
@retval false Success */ @retval false Success */
@ -3907,7 +3901,6 @@ static
bool bool
prepare_inplace_drop_virtual( prepare_inplace_drop_virtual(
Alter_inplace_info* ha_alter_info, Alter_inplace_info* ha_alter_info,
const TABLE* altered_table,
const TABLE* table) const TABLE* table)
{ {
ha_innobase_inplace_ctx* ctx; ha_innobase_inplace_ctx* ctx;
@ -4134,8 +4127,6 @@ innodb_update_n_cols(const dict_table_t* table, ulint n_cols, trx_t* trx)
/** Update system table for adding virtual column(s) /** Update system table for adding virtual column(s)
@param[in] ha_alter_info Data used during in-place alter @param[in] ha_alter_info Data used during in-place alter
@param[in] altered_table MySQL table that is being altered
@param[in] table MySQL table as it is before the ALTER operation
@param[in] user_table InnoDB table @param[in] user_table InnoDB table
@param[in] trx transaction @param[in] trx transaction
@retval true Failure @retval true Failure
@ -4144,8 +4135,6 @@ static
bool bool
innobase_add_virtual_try( innobase_add_virtual_try(
Alter_inplace_info* ha_alter_info, Alter_inplace_info* ha_alter_info,
const TABLE* altered_table,
const TABLE* table,
const dict_table_t* user_table, const dict_table_t* user_table,
trx_t* trx) trx_t* trx)
{ {
@ -4180,7 +4169,6 @@ innobase_add_virtual_try(
/** Insert into SYS_COLUMNS and insert/update the 'default row' /** Insert into SYS_COLUMNS and insert/update the 'default row'
for instant ADD COLUMN. for instant ADD COLUMN.
@param[in,out] ha_alter_info Data used during in-place alter
@param[in,out] ctx ALTER TABLE context for the current partition @param[in,out] ctx ALTER TABLE context for the current partition
@param[in] altered_table MySQL table that is being altered @param[in] altered_table MySQL table that is being altered
@param[in] table MySQL table as it is before the ALTER operation @param[in] table MySQL table as it is before the ALTER operation
@ -4190,7 +4178,6 @@ for instant ADD COLUMN.
static static
bool bool
innobase_add_instant_try( innobase_add_instant_try(
Alter_inplace_info* ha_alter_info,
ha_innobase_inplace_ctx*ctx, ha_innobase_inplace_ctx*ctx,
const TABLE* altered_table, const TABLE* altered_table,
const TABLE* table, const TABLE* table,
@ -4592,8 +4579,6 @@ innobase_drop_one_virtual_sys_virtual(
/** Update system table for dropping virtual column(s) /** Update system table for dropping virtual column(s)
@param[in] ha_alter_info Data used during in-place alter @param[in] ha_alter_info Data used during in-place alter
@param[in] altered_table MySQL table that is being altered
@param[in] table MySQL table as it is before the ALTER operation
@param[in] user_table InnoDB table @param[in] user_table InnoDB table
@param[in] trx transaction @param[in] trx transaction
@retval true Failure @retval true Failure
@ -4602,8 +4587,6 @@ static
bool bool
innobase_drop_virtual_try( innobase_drop_virtual_try(
Alter_inplace_info* ha_alter_info, Alter_inplace_info* ha_alter_info,
const TABLE* altered_table,
const TABLE* table,
const dict_table_t* user_table, const dict_table_t* user_table,
trx_t* trx) trx_t* trx)
{ {
@ -4827,8 +4810,7 @@ prepare_inplace_alter_table_dict(
if (ha_alter_info->handler_flags if (ha_alter_info->handler_flags
& ALTER_DROP_VIRTUAL_COLUMN) { & ALTER_DROP_VIRTUAL_COLUMN) {
if (prepare_inplace_drop_virtual( if (prepare_inplace_drop_virtual(ha_alter_info, old_table)) {
ha_alter_info, altered_table, old_table)) {
DBUG_RETURN(true); DBUG_RETURN(true);
} }
} }
@ -4942,7 +4924,7 @@ prepare_inplace_alter_table_dict(
if (new_clustered) { if (new_clustered) {
if (innobase_check_foreigns( if (innobase_check_foreigns(
ha_alter_info, altered_table, old_table, ha_alter_info, old_table,
user_table, ctx->drop_fk, ctx->num_to_drop_fk)) { user_table, ctx->drop_fk, ctx->num_to_drop_fk)) {
new_clustered_failed: new_clustered_failed:
DBUG_ASSERT(ctx->trx != ctx->prebuilt->trx); DBUG_ASSERT(ctx->trx != ctx->prebuilt->trx);
@ -6770,7 +6752,7 @@ err_exit:
add_fk, n_add_fk, add_fk, n_add_fk,
ha_alter_info->online, ha_alter_info->online,
heap, indexed_table, heap, indexed_table,
col_names, ULINT_UNDEFINED, 0, 0, 0, col_names, ULINT_UNDEFINED, 0, 0,
ha_alter_info->ignore); ha_alter_info->ignore);
} }
@ -6784,8 +6766,7 @@ err_exit:
if ((ha_alter_info->handler_flags if ((ha_alter_info->handler_flags
& ALTER_DROP_VIRTUAL_COLUMN) & ALTER_DROP_VIRTUAL_COLUMN)
&& prepare_inplace_drop_virtual( && prepare_inplace_drop_virtual(ha_alter_info, table)) {
ha_alter_info, altered_table, table)) {
DBUG_RETURN(true); DBUG_RETURN(true);
} }
@ -6906,7 +6887,7 @@ found_col:
heap, m_prebuilt->table, col_names, heap, m_prebuilt->table, col_names,
add_autoinc_col_no, add_autoinc_col_no,
ha_alter_info->create_info->auto_increment_value, ha_alter_info->create_info->auto_increment_value,
autoinc_col_max_value, 0, ha_alter_info->ignore); autoinc_col_max_value, ha_alter_info->ignore);
DBUG_RETURN(prepare_inplace_alter_table_dict( DBUG_RETURN(prepare_inplace_alter_table_dict(
ha_alter_info, altered_table, table, ha_alter_info, altered_table, table,
@ -7568,8 +7549,7 @@ innobase_rename_column_try(
ulint nth_col, ulint nth_col,
const char* from, const char* from,
const char* to, const char* to,
bool new_clustered, bool new_clustered)
bool is_virtual)
{ {
pars_info_t* info; pars_info_t* info;
dberr_t error; dberr_t error;
@ -7805,8 +7785,7 @@ innobase_rename_columns_try(
col_n, col_n,
cf->field->field_name.str, cf->field->field_name.str,
cf->field_name.str, cf->field_name.str,
ctx->need_rebuild(), ctx->need_rebuild())) {
is_virtual)) {
return(true); return(true);
} }
goto processed_field; goto processed_field;
@ -8741,22 +8720,17 @@ commit_try_norebuild(
if ((ha_alter_info->handler_flags if ((ha_alter_info->handler_flags
& ALTER_DROP_VIRTUAL_COLUMN) & ALTER_DROP_VIRTUAL_COLUMN)
&& innobase_drop_virtual_try( && innobase_drop_virtual_try(ha_alter_info, ctx->old_table, trx)) {
ha_alter_info, altered_table, old_table,
ctx->old_table, trx)) {
DBUG_RETURN(true); DBUG_RETURN(true);
} }
if ((ha_alter_info->handler_flags if ((ha_alter_info->handler_flags
& ALTER_ADD_VIRTUAL_COLUMN) & ALTER_ADD_VIRTUAL_COLUMN)
&& innobase_add_virtual_try( && innobase_add_virtual_try(ha_alter_info, ctx->old_table, trx)) {
ha_alter_info, altered_table, old_table,
ctx->old_table, trx)) {
DBUG_RETURN(true); DBUG_RETURN(true);
} }
if (innobase_add_instant_try(ha_alter_info, ctx, altered_table, if (innobase_add_instant_try(ctx, altered_table, old_table, trx)) {
old_table, trx)) {
DBUG_RETURN(true); DBUG_RETURN(true);
} }
@ -8891,8 +8865,6 @@ Remove statistics for dropped indexes, add statistics for created indexes
and rename statistics for renamed indexes. and rename statistics for renamed indexes.
@param ha_alter_info Data used during in-place alter @param ha_alter_info Data used during in-place alter
@param ctx In-place ALTER TABLE context @param ctx In-place ALTER TABLE context
@param altered_table MySQL table that is being altered
@param table_name Table name in MySQL
@param thd MySQL connection @param thd MySQL connection
*/ */
static static
@ -8901,8 +8873,6 @@ alter_stats_norebuild(
/*==================*/ /*==================*/
Alter_inplace_info* ha_alter_info, Alter_inplace_info* ha_alter_info,
ha_innobase_inplace_ctx* ctx, ha_innobase_inplace_ctx* ctx,
TABLE* altered_table,
const char* table_name,
THD* thd) THD* thd)
{ {
ulint i; ulint i;
@ -9775,9 +9745,7 @@ foreign_fail:
(*pctx); (*pctx);
DBUG_ASSERT(!ctx->need_rebuild()); DBUG_ASSERT(!ctx->need_rebuild());
alter_stats_norebuild( alter_stats_norebuild(ha_alter_info, ctx, m_user_thd);
ha_alter_info, ctx, altered_table,
table->s->table_name.str, m_user_thd);
DBUG_INJECT_CRASH("ib_commit_inplace_crash", DBUG_INJECT_CRASH("ib_commit_inplace_crash",
crash_inject_count++); crash_inject_count++);
} }

15
storage/innobase/handler/i_s.cc
View File

@ -5910,12 +5910,8 @@ UNIV_INTERN struct st_maria_plugin i_s_innodb_buffer_page_lru =
/*******************************************************************//** /*******************************************************************//**
Unbind a dynamic INFORMATION_SCHEMA table. Unbind a dynamic INFORMATION_SCHEMA table.
@return 0 on success */ @return 0 */
static static int i_s_common_deinit(void*)
int
i_s_common_deinit(
/*==============*/
void* p) /*!< in/out: table schema object */
{ {
DBUG_ENTER("i_s_common_deinit"); DBUG_ENTER("i_s_common_deinit");
@ -7113,7 +7109,6 @@ i_s_sys_virtual_fill_table(
const rec_t* rec; const rec_t* rec;
ulint pos; ulint pos;
ulint base_pos; ulint base_pos;
mem_heap_t* heap;
mtr_t mtr; mtr_t mtr;
DBUG_ENTER("i_s_sys_virtual_fill_table"); DBUG_ENTER("i_s_sys_virtual_fill_table");
@ -7124,7 +7119,6 @@ i_s_sys_virtual_fill_table(
DBUG_RETURN(0); DBUG_RETURN(0);
} }
heap = mem_heap_create(1000);
mutex_enter(&dict_sys->mutex); mutex_enter(&dict_sys->mutex);
mtr_start(&mtr); mtr_start(&mtr);
@ -7136,7 +7130,7 @@ i_s_sys_virtual_fill_table(
/* populate a dict_col_t structure with information from /* populate a dict_col_t structure with information from
a SYS_VIRTUAL row */ a SYS_VIRTUAL row */
err_msg = dict_process_sys_virtual_rec(heap, rec, err_msg = dict_process_sys_virtual_rec(rec,
&table_id, &pos, &table_id, &pos,
&base_pos); &base_pos);
@ -7152,8 +7146,6 @@ i_s_sys_virtual_fill_table(
err_msg); err_msg);
} }
mem_heap_empty(heap);
/* Get the next record */ /* Get the next record */
mutex_enter(&dict_sys->mutex); mutex_enter(&dict_sys->mutex);
mtr_start(&mtr); mtr_start(&mtr);
@ -7162,7 +7154,6 @@ i_s_sys_virtual_fill_table(
mtr_commit(&mtr); mtr_commit(&mtr);
mutex_exit(&dict_sys->mutex); mutex_exit(&dict_sys->mutex);
mem_heap_free(heap);
DBUG_RETURN(0); DBUG_RETURN(0);
} }

6
storage/innobase/ibuf/ibuf0ibuf.cc
View File

@ -4582,8 +4582,7 @@ loop:
} }
if (!btr_pcur_is_on_user_rec(&pcur)) { if (!btr_pcur_is_on_user_rec(&pcur)) {
ut_ad(btr_pcur_is_after_last_in_tree(&pcur, &mtr)); ut_ad(btr_pcur_is_after_last_in_tree(&pcur));
goto reset_bit; goto reset_bit;
} }
@ -4820,8 +4819,7 @@ loop:
&pcur, &mtr); &pcur, &mtr);
if (!btr_pcur_is_on_user_rec(&pcur)) { if (!btr_pcur_is_on_user_rec(&pcur)) {
ut_ad(btr_pcur_is_after_last_in_tree(&pcur, &mtr)); ut_ad(btr_pcur_is_after_last_in_tree(&pcur));
goto leave_loop; goto leave_loop;
} }

5
storage/innobase/include/btr0cur.ic
View File

@ -129,9 +129,8 @@ btr_cur_compress_recommendation(
{ {
const page_t* page; const page_t* page;
ut_ad(mtr_is_block_fix( ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor),
mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX));
MTR_MEMO_PAGE_X_FIX, cursor->index->table));
page = btr_cur_get_page(cursor); page = btr_cur_get_page(cursor);

14
storage/innobase/include/btr0pcur.h
View File

@ -426,21 +426,11 @@ btr_pcur_is_before_first_on_page(
/*********************************************************//** /*********************************************************//**
Checks if the persistent cursor is before the first user record in Checks if the persistent cursor is before the first user record in
the index tree. */ the index tree. */
UNIV_INLINE static inline bool btr_pcur_is_before_first_in_tree(btr_pcur_t* cursor);
ibool
btr_pcur_is_before_first_in_tree(
/*=============================*/
btr_pcur_t* cursor, /*!< in: persistent cursor */
mtr_t* mtr); /*!< in: mtr */
/*********************************************************//** /*********************************************************//**
Checks if the persistent cursor is after the last user record in Checks if the persistent cursor is after the last user record in
the index tree. */ the index tree. */
UNIV_INLINE static inline bool btr_pcur_is_after_last_in_tree(btr_pcur_t* cursor);
ibool
btr_pcur_is_after_last_in_tree(
/*===========================*/
btr_pcur_t* cursor, /*!< in: persistent cursor */
mtr_t* mtr); /*!< in: mtr */
/*********************************************************//** /*********************************************************//**
Moves the persistent cursor to the next record on the same page. */ Moves the persistent cursor to the next record on the same page. */
UNIV_INLINE UNIV_INLINE

24
storage/innobase/include/btr0pcur.ic
View File

@ -209,12 +209,7 @@ btr_pcur_is_on_user_rec(
/*********************************************************//** /*********************************************************//**
Checks if the persistent cursor is before the first user record in Checks if the persistent cursor is before the first user record in
the index tree. */ the index tree. */
UNIV_INLINE static inline bool btr_pcur_is_before_first_in_tree(btr_pcur_t* cursor)
ibool
btr_pcur_is_before_first_in_tree(
/*=============================*/
btr_pcur_t* cursor, /*!< in: persistent cursor */
mtr_t* mtr) /*!< in: mtr */
{ {
ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED); ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
ut_ad(cursor->latch_mode != BTR_NO_LATCHES); ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
@ -226,12 +221,7 @@ btr_pcur_is_before_first_in_tree(
/*********************************************************//** /*********************************************************//**
Checks if the persistent cursor is after the last user record in Checks if the persistent cursor is after the last user record in
the index tree. */ the index tree. */
UNIV_INLINE static inline bool btr_pcur_is_after_last_in_tree(btr_pcur_t* cursor)
ibool
btr_pcur_is_after_last_in_tree(
/*===========================*/
btr_pcur_t* cursor, /*!< in: persistent cursor */
mtr_t* mtr) /*!< in: mtr */
{ {
ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED); ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
ut_ad(cursor->latch_mode != BTR_NO_LATCHES); ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
@ -307,9 +297,7 @@ btr_pcur_move_to_next_user_rec(
cursor->old_stored = false; cursor->old_stored = false;
loop: loop:
if (btr_pcur_is_after_last_on_page(cursor)) { if (btr_pcur_is_after_last_on_page(cursor)) {
if (btr_pcur_is_after_last_in_tree(cursor)) {
if (btr_pcur_is_after_last_in_tree(cursor, mtr)) {
return(FALSE); return(FALSE);
} }
@ -344,19 +332,15 @@ btr_pcur_move_to_next(
cursor->old_stored = false; cursor->old_stored = false;
if (btr_pcur_is_after_last_on_page(cursor)) { if (btr_pcur_is_after_last_on_page(cursor)) {
if (btr_pcur_is_after_last_in_tree(cursor)) {
if (btr_pcur_is_after_last_in_tree(cursor, mtr)) {
return(FALSE); return(FALSE);
} }
btr_pcur_move_to_next_page(cursor, mtr); btr_pcur_move_to_next_page(cursor, mtr);
return(TRUE); return(TRUE);
} }
btr_pcur_move_to_next_on_page(cursor); btr_pcur_move_to_next_on_page(cursor);
return(TRUE); return(TRUE);
} }

10
storage/innobase/include/buf0flu.h
View File

@ -217,15 +217,9 @@ buf_flush_ready_for_replace(
#ifdef UNIV_DEBUG #ifdef UNIV_DEBUG
/** Disables page cleaner threads (coordinator and workers). /** Disables page cleaner threads (coordinator and workers).
It's used by: SET GLOBAL innodb_page_cleaner_disabled_debug = 1 (0). It's used by: SET GLOBAL innodb_page_cleaner_disabled_debug = 1 (0).
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
void void buf_flush_page_cleaner_disabled_debug_update(THD*,
buf_flush_page_cleaner_disabled_debug_update( st_mysql_sys_var*, void*,
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save); const void* save);
#endif /* UNIV_DEBUG */ #endif /* UNIV_DEBUG */

6
storage/innobase/include/dict0dict.h
View File

@ -939,8 +939,7 @@ dict_table_has_atomic_blobs(const dict_table_t* table)
@param[in] zip_ssize Zip Shift Size @param[in] zip_ssize Zip Shift Size
@param[in] use_data_dir Table uses DATA DIRECTORY @param[in] use_data_dir Table uses DATA DIRECTORY
@param[in] page_compressed Table uses page compression @param[in] page_compressed Table uses page compression
@param[in] page_compression_level Page compression level @param[in] page_compression_level Page compression level */
@param[in] not_used For future */
UNIV_INLINE UNIV_INLINE
void void
dict_tf_set( dict_tf_set(
@ -949,8 +948,7 @@ dict_tf_set(
ulint zip_ssize, ulint zip_ssize,
bool use_data_dir, bool use_data_dir,
bool page_compressed, bool page_compressed,
ulint page_compression_level, ulint page_compression_level);
ulint not_used);
/** Convert a 32 bit integer table flags to the 32 bit FSP Flags. /** Convert a 32 bit integer table flags to the 32 bit FSP Flags.
Fsp Flags are written into the tablespace header at the offset Fsp Flags are written into the tablespace header at the offset

6
storage/innobase/include/dict0dict.ic
View File

@ -693,8 +693,7 @@ dict_tf_get_rec_format(
@param[in] zip_ssize Zip Shift Size @param[in] zip_ssize Zip Shift Size
@param[in] use_data_dir Table uses DATA DIRECTORY @param[in] use_data_dir Table uses DATA DIRECTORY
@param[in] page_compressed Table uses page compression @param[in] page_compressed Table uses page compression
@param[in] page_compression_level Page compression level @param[in] page_compression_level Page compression level */
@param[in] not_used For future */
UNIV_INLINE UNIV_INLINE
void void
dict_tf_set( dict_tf_set(
@ -704,8 +703,7 @@ dict_tf_set(
ulint zip_ssize, ulint zip_ssize,
bool use_data_dir, bool use_data_dir,
bool page_compressed, bool page_compressed,
ulint page_compression_level, ulint page_compression_level)
ulint not_used)
{ {
switch (format) { switch (format) {
case REC_FORMAT_REDUNDANT: case REC_FORMAT_REDUNDANT:

1
storage/innobase/include/dict0load.h
View File

@ -233,7 +233,6 @@ information
@return error message, or NULL on success */ @return error message, or NULL on success */
const char* const char*
dict_process_sys_virtual_rec( dict_process_sys_virtual_rec(
mem_heap_t* heap,
const rec_t* rec, const rec_t* rec,
table_id_t* table_id, table_id_t* table_id,
ulint* pos, ulint* pos,

11
storage/innobase/include/dict0stats_bg.h
View File

@ -1,7 +1,7 @@
/***************************************************************************** /*****************************************************************************
Copyright (c) 2012, 2017, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2012, 2017, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, MariaDB Corporation. Copyright (c) 2017, 2018, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software the terms of the GNU General Public License as published by the Free Software
@ -116,15 +116,8 @@ dict_stats_thread_deinit();
#ifdef UNIV_DEBUG #ifdef UNIV_DEBUG
/** Disables dict stats thread. It's used by: /** Disables dict stats thread. It's used by:
SET GLOBAL innodb_dict_stats_disabled_debug = 1 (0). SET GLOBAL innodb_dict_stats_disabled_debug = 1 (0).
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
void void dict_stats_disabled_debug_update(THD*, st_mysql_sys_var*, void*,
dict_stats_disabled_debug_update(
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save); const void* save);
#endif /* UNIV_DEBUG */ #endif /* UNIV_DEBUG */

2
storage/innobase/include/fil0crypt.h
View File

@ -296,7 +296,6 @@ fil_space_destroy_crypt_data(
Parse a MLOG_FILE_WRITE_CRYPT_DATA log entry Parse a MLOG_FILE_WRITE_CRYPT_DATA log entry
@param[in] ptr Log entry start @param[in] ptr Log entry start
@param[in] end_ptr Log entry end @param[in] end_ptr Log entry end
@param[in] block buffer block
@param[out] err DB_SUCCESS or DB_DECRYPTION_FAILED @param[out] err DB_SUCCESS or DB_DECRYPTION_FAILED
@return position on log buffer */ @return position on log buffer */
UNIV_INTERN UNIV_INTERN
@ -304,7 +303,6 @@ byte*
fil_parse_write_crypt_data( fil_parse_write_crypt_data(
byte* ptr, byte* ptr,
const byte* end_ptr, const byte* end_ptr,
const buf_block_t* block,
dberr_t* err) dberr_t* err)
MY_ATTRIBUTE((warn_unused_result)); MY_ATTRIBUTE((warn_unused_result));

8
storage/innobase/include/fsp0file.h
View File

@ -481,7 +481,7 @@ public:
/* No op - base constructor is called. */ /* No op - base constructor is called. */
} }
RemoteDatafile(const char* name, ulint size, ulint order) RemoteDatafile(const char*, ulint, ulint)
: :
m_link_filepath() m_link_filepath()
{ {
@ -503,12 +503,6 @@ public:
return(m_link_filepath); return(m_link_filepath);
} }
/** Set the link filepath. Use default datadir, the base name of
the path provided without its suffix, plus DOT_ISL.
@param[in] path filepath which contains a basename to use.
If NULL, use m_name as the basename. */
void set_link_filepath(const char* path);
/** Create a link filename based on the contents of m_name, /** Create a link filename based on the contents of m_name,
open that file, and read the contents into m_filepath. open that file, and read the contents into m_filepath.
@retval DB_SUCCESS if remote linked tablespace file is opened and read. @retval DB_SUCCESS if remote linked tablespace file is opened and read.

3
storage/innobase/include/fts0fts.h
View File

@ -561,7 +561,6 @@ fts_commit(
MY_ATTRIBUTE((warn_unused_result)); MY_ATTRIBUTE((warn_unused_result));
/** FTS Query entry point. /** FTS Query entry point.
@param[in] trx transaction
@param[in] index fts index to search @param[in] index fts index to search
@param[in] flags FTS search mode @param[in] flags FTS search mode
@param[in] query_str FTS query @param[in] query_str FTS query
@ -570,7 +569,6 @@ fts_commit(
@return DB_SUCCESS if successful otherwise error code */ @return DB_SUCCESS if successful otherwise error code */
dberr_t dberr_t
fts_query( fts_query(
trx_t* trx,
dict_index_t* index, dict_index_t* index,
uint flags, uint flags,
const byte* query_str, const byte* query_str,
@ -736,7 +734,6 @@ Take a FTS savepoint. */
void void
fts_savepoint_take( fts_savepoint_take(
/*===============*/ /*===============*/
trx_t* trx, /*!< in: transaction */
fts_trx_t* fts_trx, /*!< in: fts transaction */ fts_trx_t* fts_trx, /*!< in: fts transaction */
const char* name); /*!< in: savepoint name */ const char* name); /*!< in: savepoint name */

1
storage/innobase/include/fts0priv.h
View File

@ -319,7 +319,6 @@ the dict mutex
que_t* que_t*
fts_parse_sql_no_dict_lock( fts_parse_sql_no_dict_lock(
/*=======================*/ /*=======================*/
fts_table_t* fts_table, /*!< in: table with FTS index */
pars_info_t* info, /*!< in: parser info */ pars_info_t* info, /*!< in: parser info */
const char* sql) /*!< in: SQL string to evaluate */ const char* sql) /*!< in: SQL string to evaluate */
MY_ATTRIBUTE((warn_unused_result)); MY_ATTRIBUTE((warn_unused_result));

19
storage/innobase/include/gis0rtree.h
View File

@ -1,7 +1,7 @@
/***************************************************************************** /*****************************************************************************
Copyright (c) 2014, 2016, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2014, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, MariaDB Corporation. Copyright (c) 2017, 2018, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software the terms of the GNU General Public License as published by the Free Software
@ -88,10 +88,8 @@ rtr_index_build_node_ptr(
pointer */ pointer */
ulint page_no,/*!< in: page number to put in node ulint page_no,/*!< in: page number to put in node
pointer */ pointer */
mem_heap_t* heap, /*!< in: memory heap where pointer mem_heap_t* heap); /*!< in: memory heap where pointer
created */ created */
ulint level); /*!< in: level of rec in tree:
0 means leaf level */
/*************************************************************//** /*************************************************************//**
Splits an R-tree index page to halves and inserts the tuple. It is assumed Splits an R-tree index page to halves and inserts the tuple. It is assumed
@ -180,7 +178,6 @@ dberr_t
rtr_ins_enlarge_mbr( rtr_ins_enlarge_mbr(
/*=================*/ /*=================*/
btr_cur_t* cursor, /*!< in: btr cursor */ btr_cur_t* cursor, /*!< in: btr cursor */
que_thr_t* thr, /*!< in: query thread */
mtr_t* mtr); /*!< in: mtr */ mtr_t* mtr); /*!< in: mtr */
/********************************************************************//** /********************************************************************//**
@ -439,9 +436,6 @@ rtr_merge_and_update_mbr(
ulint* offsets, /*!< in: rec offsets */ ulint* offsets, /*!< in: rec offsets */
ulint* offsets2, /*!< in: rec offsets */ ulint* offsets2, /*!< in: rec offsets */
page_t* child_page, /*!< in: the child page. */ page_t* child_page, /*!< in: the child page. */
buf_block_t* merge_block, /*!< in: page to merge */
buf_block_t* block, /*!< in: page be merged */
dict_index_t* index, /*!< in: index */
mtr_t* mtr); /*!< in: mtr */ mtr_t* mtr); /*!< in: mtr */
/*************************************************************//** /*************************************************************//**
@ -449,10 +443,8 @@ Deletes on the upper level the node pointer to a page. */
void void
rtr_node_ptr_delete( rtr_node_ptr_delete(
/*================*/ /*================*/
dict_index_t* index, /*!< in: index tree */ btr_cur_t* cursor, /*!< in: search cursor, contains information
btr_cur_t* sea_cur,/*!< in: search cursor, contains information
about parent nodes in search */ about parent nodes in search */
buf_block_t* block, /*!< in: page whose node pointer is deleted */
mtr_t* mtr); /*!< in: mtr */ mtr_t* mtr); /*!< in: mtr */
/****************************************************************//** /****************************************************************//**
@ -464,10 +456,7 @@ rtr_merge_mbr_changed(
btr_cur_t* cursor2, /*!< in: the other cursor */ btr_cur_t* cursor2, /*!< in: the other cursor */
ulint* offsets, /*!< in: rec offsets */ ulint* offsets, /*!< in: rec offsets */
ulint* offsets2, /*!< in: rec offsets */ ulint* offsets2, /*!< in: rec offsets */
rtr_mbr_t* new_mbr, /*!< out: MBR to update */ rtr_mbr_t* new_mbr); /*!< out: MBR to update */
buf_block_t* merge_block, /*!< in: page to merge */
buf_block_t* block, /*!< in: page be merged */
dict_index_t* index); /*!< in: index */
/**************************************************************//** /**************************************************************//**

5
storage/innobase/include/ha_prototypes.h
View File

@ -70,13 +70,11 @@ innobase_invalidate_query_cache(
/*============================*/ /*============================*/
trx_t* trx, /*!< in: transaction which trx_t* trx, /*!< in: transaction which
modifies the table */ modifies the table */
const char* full_name, /*!< in: concatenation of const char* full_name); /*!< in: concatenation of
database name, path separator, database name, path separator,
table name, null char NUL; table name, null char NUL;
NOTE that in Windows this is NOTE that in Windows this is
always in LOWER CASE! */ always in LOWER CASE! */
ulint full_name_len); /*!< in: full name length where
also the null chars count */
/** Quote a standard SQL identifier like tablespace, index or column name. /** Quote a standard SQL identifier like tablespace, index or column name.
@param[in] file output stream @param[in] file output stream
@ -158,7 +156,6 @@ UNIV_INTERN
void void
innobase_mysql_log_notify( innobase_mysql_log_notify(
/*======================*/ /*======================*/
ib_uint64_t write_lsn, /*!< in: LSN written to log file */
ib_uint64_t flush_lsn); /*!< in: LSN flushed to disk */ ib_uint64_t flush_lsn); /*!< in: LSN flushed to disk */
/** Converts a MySQL type to an InnoDB type. Note that this function returns /** Converts a MySQL type to an InnoDB type. Note that this function returns

77
storage/innobase/include/ib0mutex.h
View File

@ -53,15 +53,8 @@ struct OSTrackMutex {
ut_ad(!m_destroy_at_exit || !m_locked); ut_ad(!m_destroy_at_exit || !m_locked);
} }
/** Initialise the mutex. /** Initialise the mutex. */
@param[in] id Mutex ID void init(latch_id_t, const char*, uint32_t) UNIV_NOTHROW
@param[in] filename File where mutex was created
@param[in] line Line in filename */
void init(
latch_id_t id,
const char* filename,
uint32_t line)
UNIV_NOTHROW
{ {
ut_ad(m_freed); ut_ad(m_freed);
ut_ad(!m_locked); ut_ad(!m_locked);
@ -92,16 +85,8 @@ struct OSTrackMutex {
m_mutex.exit(); m_mutex.exit();
} }
/** Acquire the mutex. /** Acquire the mutex. */
@param[in] max_spins max number of spins void enter(uint32_t, uint32_t, const char*, uint32_t)
@param[in] max_delay max delay per spin
@param[in] filename from where called
@param[in] line within filename */
void enter(
uint32_t max_spins,
uint32_t max_delay,
const char* filename,
uint32_t line)
UNIV_NOTHROW UNIV_NOTHROW
{ {
ut_ad(!m_freed); ut_ad(!m_freed);
@ -186,15 +171,8 @@ struct TTASFutexMutex {
} }
/** Called when the mutex is "created". Note: Not from the constructor /** Called when the mutex is "created". Note: Not from the constructor
but when the mutex is initialised. but when the mutex is initialised. */
@param[in] id Mutex ID void init(latch_id_t, const char*, uint32_t) UNIV_NOTHROW
@param[in] filename File where mutex was created
@param[in] line Line in filename */
void init(
latch_id_t id,
const char* filename,
uint32_t line)
UNIV_NOTHROW
{ {
ut_a(m_lock_word == MUTEX_STATE_UNLOCKED); ut_a(m_lock_word == MUTEX_STATE_UNLOCKED);
} }
@ -208,14 +186,9 @@ struct TTASFutexMutex {
/** Acquire the mutex. /** Acquire the mutex.
@param[in] max_spins max number of spins @param[in] max_spins max number of spins
@param[in] max_delay max delay per spin @param[in] max_delay max delay per spin */
@param[in] filename from where called void enter(uint32_t max_spins, uint32_t max_delay,
@param[in] line within filename */ const char*, uint32_t) UNIV_NOTHROW
void enter(
uint32_t max_spins,
uint32_t max_delay,
const char* filename,
uint32_t line) UNIV_NOTHROW
{ {
uint32_t n_spins, n_waits; uint32_t n_spins, n_waits;
@ -308,15 +281,8 @@ struct TTASMutex {
} }
/** Called when the mutex is "created". Note: Not from the constructor /** Called when the mutex is "created". Note: Not from the constructor
but when the mutex is initialised. but when the mutex is initialised. */
@param[in] id Mutex ID void init(latch_id_t) UNIV_NOTHROW
@param[in] filename File where mutex was created
@param[in] line Line in filename */
void init(
latch_id_t id,
const char* filename,
uint32_t line)
UNIV_NOTHROW
{ {
ut_ad(m_lock_word == MUTEX_STATE_UNLOCKED); ut_ad(m_lock_word == MUTEX_STATE_UNLOCKED);
} }
@ -349,14 +315,9 @@ struct TTASMutex {
/** Acquire the mutex. /** Acquire the mutex.
@param max_spins max number of spins @param max_spins max number of spins
@param max_delay max delay per spin @param max_delay max delay per spin */
@param filename from where called void enter(uint32_t max_spins, uint32_t max_delay,
@param line within filename */ const char*, uint32_t) UNIV_NOTHROW
void enter(
uint32_t max_spins,
uint32_t max_delay,
const char* filename,
uint32_t line) UNIV_NOTHROW
{ {
const uint32_t step = max_spins; const uint32_t step = max_spins;
uint32_t n_spins = 0; uint32_t n_spins = 0;
@ -420,14 +381,8 @@ struct TTASEventMutex {
/** Called when the mutex is "created". Note: Not from the constructor /** Called when the mutex is "created". Note: Not from the constructor
but when the mutex is initialised. but when the mutex is initialised.
@param[in] id Mutex ID @param[in] id Mutex ID */
@param[in] filename File where mutex was created void init(latch_id_t id, const char*, uint32_t) UNIV_NOTHROW
@param[in] line Line in filename */
void init(
latch_id_t id,
const char* filename,
uint32_t line)
UNIV_NOTHROW
{ {
ut_a(m_event == 0); ut_a(m_event == 0);
ut_a(m_lock_word == MUTEX_STATE_UNLOCKED); ut_a(m_lock_word == MUTEX_STATE_UNLOCKED);

5
storage/innobase/include/lock0prdt.h
View File

@ -51,9 +51,8 @@ lock_prdt_lock(
SELECT FOR UPDATE */ SELECT FOR UPDATE */
ulint type_mode, ulint type_mode,
/*!< in: LOCK_PREDICATE or LOCK_PRDT_PAGE */ /*!< in: LOCK_PREDICATE or LOCK_PRDT_PAGE */
que_thr_t* thr, /*!< in: query thread que_thr_t* thr); /*!< in: query thread
(can be NULL if BTR_NO_LOCKING_FLAG) */ (can be NULL if BTR_NO_LOCKING_FLAG) */
mtr_t* mtr); /*!< in/out: mini-transaction */
/*********************************************************************//** /*********************************************************************//**
Acquire a "Page" lock on a block Acquire a "Page" lock on a block
@ -107,7 +106,6 @@ Update predicate lock when page splits */
void void
lock_prdt_update_split( lock_prdt_update_split(
/*===================*/ /*===================*/
buf_block_t* block, /*!< in/out: page to be split */
buf_block_t* new_block, /*!< in/out: the new half page */ buf_block_t* new_block, /*!< in/out: the new half page */
lock_prdt_t* prdt, /*!< in: MBR on the old page */ lock_prdt_t* prdt, /*!< in: MBR on the old page */
lock_prdt_t* new_prdt, /*!< in: MBR on the new page */ lock_prdt_t* new_prdt, /*!< in: MBR on the new page */
@ -123,7 +121,6 @@ lock_prdt_update_parent(
buf_block_t* right_block, /*!< in/out: the new half page */ buf_block_t* right_block, /*!< in/out: the new half page */
lock_prdt_t* left_prdt, /*!< in: MBR on the old page */ lock_prdt_t* left_prdt, /*!< in: MBR on the old page */
lock_prdt_t* right_prdt, /*!< in: MBR on the new page */ lock_prdt_t* right_prdt, /*!< in: MBR on the new page */
lock_prdt_t* parent_prdt, /*!< in: original parent MBR */
ulint space, /*!< in: space id */ ulint space, /*!< in: space id */
ulint page_no); /*!< in: page number */ ulint page_no); /*!< in: page number */

3
storage/innobase/include/log0log.h
View File

@ -293,11 +293,10 @@ log_block_calc_checksum_crc32(
const byte* block); const byte* block);
/** Calculates the checksum for a log block using the "no-op" algorithm. /** Calculates the checksum for a log block using the "no-op" algorithm.
@param[in] block the redo log block
@return the calculated checksum value */ @return the calculated checksum value */
UNIV_INLINE UNIV_INLINE
ulint ulint
log_block_calc_checksum_none(const byte* block); log_block_calc_checksum_none(const byte*);
/************************************************************//** /************************************************************//**
Gets a log block checksum field value. Gets a log block checksum field value.

4
storage/innobase/include/log0log.ic
View File

@ -241,12 +241,10 @@ log_block_calc_checksum_crc32(
} }
/** Calculates the checksum for a log block using the "no-op" algorithm. /** Calculates the checksum for a log block using the "no-op" algorithm.
@param[in] block log block
@return checksum */ @return checksum */
UNIV_INLINE UNIV_INLINE
ulint ulint
log_block_calc_checksum_none( log_block_calc_checksum_none(const byte*)
const byte* block)
{ {
return(LOG_NO_CHECKSUM_MAGIC); return(LOG_NO_CHECKSUM_MAGIC);
} }

7
storage/innobase/include/mem0mem.h
View File

@ -1,7 +1,7 @@
/***************************************************************************** /*****************************************************************************
Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, MariaDB Corporation. Copyright (c) 2017, 2018, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software the terms of the GNU General Public License as published by the Free Software
@ -464,13 +464,14 @@ public:
allocated by mem_heap_allocator) can be used as a hint to the allocated by mem_heap_allocator) can be used as a hint to the
implementation about where the new memory should be allocated in implementation about where the new memory should be allocated in
order to improve locality. */ order to improve locality. */
pointer allocate(size_type n, const_pointer hint = 0) pointer allocate(size_type n)
{ {
return(reinterpret_cast<pointer>( return(reinterpret_cast<pointer>(
mem_heap_alloc(m_heap, n * sizeof(T)))); mem_heap_alloc(m_heap, n * sizeof(T))));
} }
pointer allocate(size_type n, const_pointer) { return allocate(n); }
void deallocate(pointer p, size_type n) { } void deallocate(pointer, size_type) {}
pointer address (reference r) const { return(&r); } pointer address (reference r) const { return(&r); }

12
storage/innobase/include/mtr0mtr.h
View File

@ -78,13 +78,6 @@ savepoint. */
(m)->memo_release((o), (t)) (m)->memo_release((o), (t))
#ifdef UNIV_DEBUG #ifdef UNIV_DEBUG
/** Check if memo contains the given item. */
#define mtr_is_block_fix(m, o, t, table) mtr_memo_contains(m, o, t)
/** Check if memo contains the given page. */
#define mtr_is_page_fix(m, p, t, table) mtr_memo_contains_page(m, p, t)
/** Check if memo contains the given item. /** Check if memo contains the given item.
@return TRUE if contains */ @return TRUE if contains */
#define mtr_memo_contains(m, o, t) \ #define mtr_memo_contains(m, o, t) \
@ -213,9 +206,8 @@ struct mtr_t {
~mtr_t() { } ~mtr_t() { }
/** Start a mini-transaction. /** Start a mini-transaction.
@param sync true if it is a synchronous mini-transaction @param sync true if it is a synchronous mini-transaction */
@param read_only true if read only mini-transaction */ void start(bool sync = true);
void start(bool sync = true, bool read_only = false);
/** @return whether this is an asynchronous mini-transaction. */ /** @return whether this is an asynchronous mini-transaction. */
bool is_async() const bool is_async() const

6
storage/innobase/include/os0event.h
View File

@ -42,11 +42,7 @@ Creates an event semaphore, i.e., a semaphore which may just have two states:
signaled and nonsignaled. The created event is manual reset: it must be reset signaled and nonsignaled. The created event is manual reset: it must be reset
explicitly by calling os_event_reset(). explicitly by calling os_event_reset().
@return the event handle */ @return the event handle */
os_event_t os_event_t os_event_create(const char*);
os_event_create(
/*============*/
const char* name); /*!< in: the name of the event, if NULL
the event is created without a name */
/** /**
Sets an event semaphore to the signaled state: lets waiting threads Sets an event semaphore to the signaled state: lets waiting threads

6
storage/innobase/include/page0cur.h
View File

@ -1,6 +1,7 @@
/***************************************************************************** /*****************************************************************************
Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2018, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software the terms of the GNU General Public License as published by the Free Software
@ -156,10 +157,7 @@ page_cur_tuple_insert(
ulint** offsets,/*!< out: offsets on *rec */ ulint** offsets,/*!< out: offsets on *rec */
mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */ mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */
ulint n_ext, /*!< in: number of externally stored columns */ ulint n_ext, /*!< in: number of externally stored columns */
mtr_t* mtr, /*!< in: mini-transaction handle, or NULL */ mtr_t* mtr) /*!< in: mini-transaction handle, or NULL */
bool use_cache = false)
/*!< in: if true, then use record cache to
hold the tuple converted record. */
MY_ATTRIBUTE((nonnull(1,2,3,4,5), warn_unused_result)); MY_ATTRIBUTE((nonnull(1,2,3,4,5), warn_unused_result));
/***********************************************************//** /***********************************************************//**
Inserts a record next to page cursor. Returns pointer to inserted record if Inserts a record next to page cursor. Returns pointer to inserted record if

7
storage/innobase/include/page0cur.ic
View File

@ -1,7 +1,7 @@
/***************************************************************************** /*****************************************************************************
Copyright (c) 1994, 2014, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 1994, 2014, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2015, MariaDB Corporation. Copyright (c) 2015, 2018, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software the terms of the GNU General Public License as published by the Free Software
@ -262,10 +262,7 @@ page_cur_tuple_insert(
ulint** offsets,/*!< out: offsets on *rec */ ulint** offsets,/*!< out: offsets on *rec */
mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */ mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */
ulint n_ext, /*!< in: number of externally stored columns */ ulint n_ext, /*!< in: number of externally stored columns */
mtr_t* mtr, /*!< in: mini-transaction handle, or NULL */ mtr_t* mtr) /*!< in: mini-transaction handle, or NULL */
bool use_cache)
/*!< in: if true, then use record cache to
hold the tuple converted record. */
{ {
rec_t* rec; rec_t* rec;
ulint size = rec_get_converted_size(index, tuple, n_ext); ulint size = rec_get_converted_size(index, tuple, n_ext);

3
storage/innobase/include/row0row.h
View File

@ -269,9 +269,8 @@ row_build_row_ref_in_tuple(
held as long as the row held as long as the row
reference is used! */ reference is used! */
const dict_index_t* index, /*!< in: secondary index */ const dict_index_t* index, /*!< in: secondary index */
ulint* offsets,/*!< in: rec_get_offsets(rec, index) ulint* offsets)/*!< in: rec_get_offsets(rec, index)
or NULL */ or NULL */
trx_t* trx) /*!< in: transaction or NULL */
MY_ATTRIBUTE((nonnull(1,2,3))); MY_ATTRIBUTE((nonnull(1,2,3)));
/*******************************************************************//** /*******************************************************************//**
Builds from a secondary index record a row reference with which we can Builds from a secondary index record a row reference with which we can

3
storage/innobase/include/row0sel.h
View File

@ -135,8 +135,7 @@ row_sel_convert_mysql_key_to_innobase(
ulint buf_len, /*!< in: buffer length */ ulint buf_len, /*!< in: buffer length */
dict_index_t* index, /*!< in: index of the key value */ dict_index_t* index, /*!< in: index of the key value */
const byte* key_ptr, /*!< in: MySQL key value */ const byte* key_ptr, /*!< in: MySQL key value */
ulint key_len, /*!< in: MySQL key value length */ ulint key_len); /*!< in: MySQL key value length */
trx_t* trx); /*!< in: transaction */
/** Searches for rows in the database. This is used in the interface to /** Searches for rows in the database. This is used in the interface to

8
storage/innobase/include/srv0srv.h
View File

@ -920,15 +920,9 @@ srv_was_tablespace_truncated(const fil_space_t* space);
#ifdef UNIV_DEBUG #ifdef UNIV_DEBUG
/** Disables master thread. It's used by: /** Disables master thread. It's used by:
SET GLOBAL innodb_master_thread_disabled_debug = 1 (0). SET GLOBAL innodb_master_thread_disabled_debug = 1 (0).
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
void void
srv_master_thread_disabled_debug_update( srv_master_thread_disabled_debug_update(THD*, st_mysql_sys_var*, void*,
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save); const void* save);
#endif /* UNIV_DEBUG */ #endif /* UNIV_DEBUG */

19
storage/innobase/include/sync0policy.h
View File

@ -167,8 +167,7 @@ public:
/** Called when the mutex is "created". Note: Not from the constructor /** Called when the mutex is "created". Note: Not from the constructor
but when the mutex is initialised. but when the mutex is initialised.
@param[in] id Mutex ID */ @param[in] id Mutex ID */
void init(latch_id_t id) void init(latch_id_t id) UNIV_NOTHROW;
UNIV_NOTHROW;
/** Called when an attempt is made to lock the mutex /** Called when an attempt is made to lock the mutex
@param[in] mutex Mutex instance to be locked @param[in] mutex Mutex instance to be locked
@ -241,7 +240,7 @@ struct NoPolicy {
void init(const Mutex&, latch_id_t, const char*, uint32_t) void init(const Mutex&, latch_id_t, const char*, uint32_t)
UNIV_NOTHROW { } UNIV_NOTHROW { }
void destroy() UNIV_NOTHROW { } void destroy() UNIV_NOTHROW { }
void enter(const Mutex&, const char*, unsigned line) UNIV_NOTHROW { } void enter(const Mutex&, const char*, unsigned) UNIV_NOTHROW { }
void add(uint32_t, uint32_t) UNIV_NOTHROW { } void add(uint32_t, uint32_t) UNIV_NOTHROW { }
void locked(const Mutex&, const char*, ulint) UNIV_NOTHROW { } void locked(const Mutex&, const char*, ulint) UNIV_NOTHROW { }
void release(const Mutex&) UNIV_NOTHROW { } void release(const Mutex&) UNIV_NOTHROW { }
@ -275,12 +274,11 @@ public:
/** Called when the mutex is "created". Note: Not from the constructor /** Called when the mutex is "created". Note: Not from the constructor
but when the mutex is initialised. but when the mutex is initialised.
@param[in] mutex Mutex instance to track
@param[in] id Mutex ID @param[in] id Mutex ID
@param[in] filename File where mutex was created @param[in] filename File where mutex was created
@param[in] line Line in filename */ @param[in] line Line in filename */
void init( void init(
const MutexType& mutex, const Mutex&,
latch_id_t id, latch_id_t id,
const char* filename, const char* filename,
uint32_t line) uint32_t line)
@ -423,15 +421,8 @@ public:
/** Called when the mutex is "created". Note: Not from the constructor /** Called when the mutex is "created". Note: Not from the constructor
but when the mutex is initialised. but when the mutex is initialised.
@param[in] mutex Mutex instance to track @param[in] id Mutex ID */
@param[in] id Mutex ID void init(const Mutex&, latch_id_t id, const char*, uint32)
@param[in] filename File where mutex was created
@param[in] line Line in filename */
void init(
const MutexType& mutex,
latch_id_t id,
const char* filename,
uint32_t line)
UNIV_NOTHROW UNIV_NOTHROW
{ {
/* It can be LATCH_ID_BUF_BLOCK_MUTEX or /* It can be LATCH_ID_BUF_BLOCK_MUTEX or

2
storage/innobase/include/sync0policy.ic
View File

@ -88,7 +88,7 @@ void MutexDebug<Mutex>::locked(
} }
template <typename Mutex> template <typename Mutex>
void MutexDebug<Mutex>::release(const Mutex* mutex) void MutexDebug<Mutex>::release(const Mutex*)
UNIV_NOTHROW UNIV_NOTHROW
{ {
ut_ad(is_owned()); ut_ad(is_owned());

14
storage/innobase/include/trx0undo.h
View File

@ -166,13 +166,11 @@ trx_undo_get_first_rec(
mtr_t* mtr); mtr_t* mtr);
/** Allocate an undo log page. /** Allocate an undo log page.
@param[in,out] trx transaction
@param[in,out] undo undo log @param[in,out] undo undo log
@param[in,out] mtr mini-transaction that does not hold any page latch @param[in,out] mtr mini-transaction that does not hold any page latch
@return X-latched block if success @return X-latched block if success
@retval NULL on failure */ @retval NULL on failure */
buf_block_t* buf_block_t* trx_undo_add_page(trx_undo_t* undo, mtr_t* mtr)
trx_undo_add_page(trx_t* trx, trx_undo_t* undo, mtr_t* mtr)
MY_ATTRIBUTE((nonnull, warn_unused_result)); MY_ATTRIBUTE((nonnull, warn_unused_result));
/** Free the last undo log page. The caller must hold the rseg mutex. /** Free the last undo log page. The caller must hold the rseg mutex.
@ -282,23 +280,17 @@ trx_undo_truncate_tablespace(
@return end of log record @return end of log record
@retval NULL if the log record is incomplete */ @retval NULL if the log record is incomplete */
byte* byte*
trx_undo_parse_page_init( trx_undo_parse_page_init(const byte* ptr, const byte* end_ptr, page_t* page);
const byte* ptr,
const byte* end_ptr,
page_t* page,
mtr_t* mtr);
/** Parse MLOG_UNDO_HDR_REUSE for crash-upgrade from MariaDB 10.2. /** Parse MLOG_UNDO_HDR_REUSE for crash-upgrade from MariaDB 10.2.
@param[in] ptr redo log record @param[in] ptr redo log record
@param[in] end_ptr end of log buffer @param[in] end_ptr end of log buffer
@param[in,out] page undo page or NULL @param[in,out] page undo page or NULL
@param[in,out] mtr mini-transaction
@return end of log record or NULL */ @return end of log record or NULL */
byte* byte*
trx_undo_parse_page_header_reuse( trx_undo_parse_page_header_reuse(
const byte* ptr, const byte* ptr,
const byte* end_ptr, const byte* end_ptr,
page_t* page, page_t* page);
mtr_t* mtr);
/** Parse the redo log entry of an undo log page header create. /** Parse the redo log entry of an undo log page header create.
@param[in] ptr redo log record @param[in] ptr redo log record

2
storage/innobase/include/ut0lst.h
View File

@ -426,7 +426,7 @@ Gets the last node in a two-way list.
@return last node, or NULL if the list is empty */ @return last node, or NULL if the list is empty */
#define UT_LIST_GET_LAST(BASE) (BASE).end #define UT_LIST_GET_LAST(BASE) (BASE).end
struct NullValidate { void operator()(const void* elem) { } }; struct NullValidate { void operator()(const void*) { } };
/********************************************************************//** /********************************************************************//**
Iterate over all the elements and call the functor for each element. Iterate over all the elements and call the functor for each element.

63
storage/innobase/include/ut0new.h
View File

@ -238,11 +238,18 @@ struct ut_new_pfx_t {
#endif #endif
}; };
static inline void ut_allocate_trace_dontdump(void * ptr, static inline void ut_allocate_trace_dontdump(void *ptr, size_t bytes,
size_t bytes, bool
bool dontdump, #if defined(DBUG_OFF) && defined(HAVE_MADVISE) && defined(MADV_DONTDUMP)
ut_new_pfx_t* pfx, dontdump
const char* file) #endif
, ut_new_pfx_t* pfx,
const char*
#ifdef UNIV_PFS_MEMORY
file
#endif
)
{ {
ut_a(ptr != NULL); ut_a(ptr != NULL);
@ -262,17 +269,19 @@ static inline void ut_allocate_trace_dontdump(void * ptr,
} }
} }
#if defined(DBUG_OFF) && defined(HAVE_MADVISE) && defined(MADV_DODUMP)
static inline void ut_dodump(void* ptr, size_t m_size) static inline void ut_dodump(void* ptr, size_t m_size)
{ {
#if defined(DBUG_OFF) && defined(HAVE_MADVISE) && defined(MADV_DODUMP)
if (ptr && madvise(ptr, m_size, MADV_DODUMP)) { if (ptr && madvise(ptr, m_size, MADV_DODUMP)) {
ib::warn() << "Failed to set memory to DODUMP: " ib::warn() << "Failed to set memory to DODUMP: "
<< strerror(errno) << strerror(errno)
<< " ptr " << ptr << " ptr " << ptr
<< " size " << m_size; << " size " << m_size;
} }
#endif
} }
#else
static inline void ut_dodump(void*, size_t) {}
#endif
/** Allocator class for allocating memory from inside std::* containers. /** Allocator class for allocating memory from inside std::* containers.
@tparam T type of allocated object @tparam T type of allocated object
@ -288,19 +297,25 @@ public:
typedef size_t size_type; typedef size_t size_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#ifdef UNIV_PFS_MEMORY
/** Default constructor. */ /** Default constructor. */
explicit explicit
ut_allocator(PSI_memory_key key = PSI_NOT_INSTRUMENTED) ut_allocator(PSI_memory_key key = PSI_NOT_INSTRUMENTED)
#ifdef UNIV_PFS_MEMORY
: m_key(key) : m_key(key)
#endif /* UNIV_PFS_MEMORY */
{ {
} }
#else
ut_allocator() {}
ut_allocator(PSI_memory_key) {}
#endif /* UNIV_PFS_MEMORY */
/** Constructor from allocator of another type. */ /** Constructor from allocator of another type. */
template <class U> template <class U>
ut_allocator( ut_allocator(const ut_allocator<U>&
const ut_allocator<U>& other) #ifdef UNIV_PFS_MEMORY
other
#endif
)
#ifdef UNIV_PFS_MEMORY #ifdef UNIV_PFS_MEMORY
: m_key(other.m_key) : m_key(other.m_key)
#endif /* UNIV_PFS_MEMORY */ #endif /* UNIV_PFS_MEMORY */
@ -321,6 +336,8 @@ public:
#endif /* UNIV_PFS_MEMORY */ #endif /* UNIV_PFS_MEMORY */
} }
pointer allocate(size_type n) { return allocate(n, NULL, NULL); }
/** Allocate a chunk of memory that can hold 'n_elements' objects of /** Allocate a chunk of memory that can hold 'n_elements' objects of
type 'T' and trace the allocation. type 'T' and trace the allocation.
If the allocation fails this method may throw an exception. This If the allocation fails this method may throw an exception. This
@ -329,9 +346,6 @@ public:
After successfull allocation the returned pointer must be passed After successfull allocation the returned pointer must be passed
to ut_allocator::deallocate() when no longer needed. to ut_allocator::deallocate() when no longer needed.
@param[in] n_elements number of elements @param[in] n_elements number of elements
@param[in] hint pointer to a nearby memory location,
unused by this implementation
@param[in] file file name of the caller
@param[in] set_to_zero if true, then the returned memory is @param[in] set_to_zero if true, then the returned memory is
initialized with 0x0 bytes. initialized with 0x0 bytes.
@param[in] throw_on_error if true, raize exception if too big @param[in] throw_on_error if true, raize exception if too big
@ -339,8 +353,12 @@ public:
pointer pointer
allocate( allocate(
size_type n_elements, size_type n_elements,
const_pointer hint = NULL, const_pointer,
const char* file = NULL, const char*
#ifdef UNIV_PFS_MEMORY
file /*!< file name of the caller */
#endif
,
bool set_to_zero = false, bool set_to_zero = false,
bool throw_on_error = true) bool throw_on_error = true)
{ {
@ -648,7 +666,11 @@ public:
void void
deallocate_large( deallocate_large(
pointer ptr, pointer ptr,
const ut_new_pfx_t* pfx, const ut_new_pfx_t*
#ifdef UNIV_PFS_MEMORY
pfx
#endif
,
size_t size, size_t size,
bool dodump = false) bool dodump = false)
{ {
@ -775,12 +797,7 @@ could be freed by A2 even if the pfs mem key is different. */
template <typename T> template <typename T>
inline inline
bool bool
operator==( operator==(const ut_allocator<T>&, const ut_allocator<T>&) { return(true); }
const ut_allocator<T>& lhs,
const ut_allocator<T>& rhs)
{
return(true);
}
/** Compare two allocators of the same type. */ /** Compare two allocators of the same type. */
template <typename T> template <typename T>

61
storage/innobase/include/ut0stage.h
View File

@ -529,65 +529,28 @@ ut_stage_alter_t::change_phase(
class ut_stage_alter_t { class ut_stage_alter_t {
public: public:
explicit explicit ut_stage_alter_t(const dict_index_t*) {}
ut_stage_alter_t(
const dict_index_t* pk)
{
}
void void begin_phase_read_pk(ulint) {}
begin_phase_read_pk(
ulint n_sort_indexes)
{
}
void void n_pk_recs_inc() {}
n_pk_recs_inc()
{
}
void void inc() {}
inc( void inc(ulint) {}
ulint inc_val = 1)
{
}
void void end_phase_read_pk() {}
end_phase_read_pk()
{
}
void void begin_phase_sort(double) {}
begin_phase_sort(
double sort_multi_factor)
{
}
void void begin_phase_insert() {}
begin_phase_insert()
{
}
void void begin_phase_flush(ulint) {}
begin_phase_flush(
ulint n_flush_pages)
{
}
void void begin_phase_log_index() {}
begin_phase_log_index()
{
}
void void begin_phase_log_table() {}
begin_phase_log_table()
{
}
void void begin_phase_end() {}
begin_phase_end()
{
}
}; };
#endif /* HAVE_PSI_STAGE_INTERFACE */ #endif /* HAVE_PSI_STAGE_INTERFACE */

6
storage/innobase/lock/lock0lock.cc
View File

@ -5243,8 +5243,7 @@ lock_rec_block_validate(
} }
static my_bool lock_validate_table_locks(rw_trx_hash_element_t *element, static my_bool lock_validate_table_locks(rw_trx_hash_element_t *element, void*)
void *arg)
{ {
ut_ad(lock_mutex_own()); ut_ad(lock_mutex_own());
mutex_enter(&element->mutex); mutex_enter(&element->mutex);
@ -5481,7 +5480,6 @@ lock_rec_convert_impl_to_expl_for_trx(
const buf_block_t* block, /*!< in: buffer block of rec */ const buf_block_t* block, /*!< in: buffer block of rec */
const rec_t* rec, /*!< in: user record on page */ const rec_t* rec, /*!< in: user record on page */
dict_index_t* index, /*!< in: index of record */ dict_index_t* index, /*!< in: index of record */
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
trx_t* trx, /*!< in/out: active transaction */ trx_t* trx, /*!< in/out: active transaction */
ulint heap_no)/*!< in: rec heap number to lock */ ulint heap_no)/*!< in: rec heap number to lock */
{ {
@ -5626,7 +5624,7 @@ lock_rec_convert_impl_to_expl(
trx cannot be committed until the ref count is zero. */ trx cannot be committed until the ref count is zero. */
lock_rec_convert_impl_to_expl_for_trx( lock_rec_convert_impl_to_expl_for_trx(
block, rec, index, offsets, trx, heap_no); block, rec, index, trx, heap_no);
} }
} }

10
storage/innobase/lock/lock0prdt.cc
View File

@ -628,7 +628,6 @@ lock_prdt_update_parent(
buf_block_t* right_block, /*!< in/out: the new half page */ buf_block_t* right_block, /*!< in/out: the new half page */
lock_prdt_t* left_prdt, /*!< in: MBR on the old page */ lock_prdt_t* left_prdt, /*!< in: MBR on the old page */
lock_prdt_t* right_prdt, /*!< in: MBR on the new page */ lock_prdt_t* right_prdt, /*!< in: MBR on the new page */
lock_prdt_t* parent_prdt, /*!< in: original parent MBR */
ulint space, /*!< in: parent space id */ ulint space, /*!< in: parent space id */
ulint page_no) /*!< in: parent page number */ ulint page_no) /*!< in: parent page number */
{ {
@ -682,7 +681,6 @@ static
void void
lock_prdt_update_split_low( lock_prdt_update_split_low(
/*=======================*/ /*=======================*/
buf_block_t* block, /*!< in/out: page to be split */
buf_block_t* new_block, /*!< in/out: the new half page */ buf_block_t* new_block, /*!< in/out: the new half page */
lock_prdt_t* prdt, /*!< in: MBR on the old page */ lock_prdt_t* prdt, /*!< in: MBR on the old page */
lock_prdt_t* new_prdt, /*!< in: MBR on the new page */ lock_prdt_t* new_prdt, /*!< in: MBR on the new page */
@ -759,17 +757,16 @@ Update predicate lock when page splits */
void void
lock_prdt_update_split( lock_prdt_update_split(
/*===================*/ /*===================*/
buf_block_t* block, /*!< in/out: page to be split */
buf_block_t* new_block, /*!< in/out: the new half page */ buf_block_t* new_block, /*!< in/out: the new half page */
lock_prdt_t* prdt, /*!< in: MBR on the old page */ lock_prdt_t* prdt, /*!< in: MBR on the old page */
lock_prdt_t* new_prdt, /*!< in: MBR on the new page */ lock_prdt_t* new_prdt, /*!< in: MBR on the new page */
ulint space, /*!< in: space id */ ulint space, /*!< in: space id */
ulint page_no) /*!< in: page number */ ulint page_no) /*!< in: page number */
{ {
lock_prdt_update_split_low(block, new_block, prdt, new_prdt, lock_prdt_update_split_low(new_block, prdt, new_prdt,
space, page_no, LOCK_PREDICATE); space, page_no, LOCK_PREDICATE);
lock_prdt_update_split_low(block, new_block, NULL, NULL, lock_prdt_update_split_low(new_block, NULL, NULL,
space, page_no, LOCK_PRDT_PAGE); space, page_no, LOCK_PRDT_PAGE);
} }
@ -811,9 +808,8 @@ lock_prdt_lock(
SELECT FOR UPDATE */ SELECT FOR UPDATE */
ulint type_mode, ulint type_mode,
/*!< in: LOCK_PREDICATE or LOCK_PRDT_PAGE */ /*!< in: LOCK_PREDICATE or LOCK_PRDT_PAGE */
que_thr_t* thr, /*!< in: query thread que_thr_t* thr) /*!< in: query thread
(can be NULL if BTR_NO_LOCKING_FLAG) */ (can be NULL if BTR_NO_LOCKING_FLAG) */
mtr_t* mtr) /*!< in/out: mini-transaction */
{ {
trx_t* trx = thr_get_trx(thr); trx_t* trx = thr_get_trx(thr);
dberr_t err = DB_SUCCESS; dberr_t err = DB_SUCCESS;

3
storage/innobase/log/log0log.cc
View File

@ -1119,11 +1119,10 @@ loop:
if (flush_to_disk) { if (flush_to_disk) {
log_write_flush_to_disk_low(); log_write_flush_to_disk_low();
ib_uint64_t write_lsn = log_sys.write_lsn;
ib_uint64_t flush_lsn = log_sys.flushed_to_disk_lsn; ib_uint64_t flush_lsn = log_sys.flushed_to_disk_lsn;
log_mutex_exit(); log_mutex_exit();
innobase_mysql_log_notify(write_lsn, flush_lsn); innobase_mysql_log_notify(flush_lsn);
} }
} }

7
storage/innobase/log/log0recv.cc
View File

@ -1346,12 +1346,11 @@ parse_log:
break; break;
case MLOG_UNDO_INIT: case MLOG_UNDO_INIT:
/* Allow anything in page_type when creating a page. */ /* Allow anything in page_type when creating a page. */
ptr = trx_undo_parse_page_init(ptr, end_ptr, page, mtr); ptr = trx_undo_parse_page_init(ptr, end_ptr, page);
break; break;
case MLOG_UNDO_HDR_REUSE: case MLOG_UNDO_HDR_REUSE:
ut_ad(!page || page_type == FIL_PAGE_UNDO_LOG); ut_ad(!page || page_type == FIL_PAGE_UNDO_LOG);
ptr = trx_undo_parse_page_header_reuse(ptr, end_ptr, page, ptr = trx_undo_parse_page_header_reuse(ptr, end_ptr, page);
mtr);
break; break;
case MLOG_UNDO_HDR_CREATE: case MLOG_UNDO_HDR_CREATE:
ut_ad(!page || page_type == FIL_PAGE_UNDO_LOG); ut_ad(!page || page_type == FIL_PAGE_UNDO_LOG);
@ -1431,7 +1430,7 @@ parse_log:
break; break;
case MLOG_FILE_WRITE_CRYPT_DATA: case MLOG_FILE_WRITE_CRYPT_DATA:
dberr_t err; dberr_t err;
ptr = const_cast<byte*>(fil_parse_write_crypt_data(ptr, end_ptr, block, &err)); ptr = const_cast<byte*>(fil_parse_write_crypt_data(ptr, end_ptr, &err));
if (err != DB_SUCCESS) { if (err != DB_SUCCESS) {
recv_sys->found_corrupt_log = TRUE; recv_sys->found_corrupt_log = TRUE;

5
storage/innobase/mtr/mtr0mtr.cc
View File

@ -489,10 +489,9 @@ mtr_write_log(
} }
/** Start a mini-transaction. /** Start a mini-transaction.
@param sync true if it is a synchronous mini-transaction @param sync true if it is a synchronous mini-transaction */
@param read_only true if read only mini-transaction */
void void
mtr_t::start(bool sync, bool read_only) mtr_t::start(bool sync)
{ {
UNIV_MEM_INVALID(this, sizeof(*this)); UNIV_MEM_INVALID(this, sizeof(*this));

13
storage/innobase/os/os0event.cc
View File

@ -48,7 +48,7 @@ typedef os_event_list_t::iterator event_iter_t;
/** InnoDB condition variable. */ /** InnoDB condition variable. */
struct os_event { struct os_event {
os_event(const char* name) UNIV_NOTHROW; os_event() UNIV_NOTHROW;
~os_event() UNIV_NOTHROW; ~os_event() UNIV_NOTHROW;
@ -415,7 +415,7 @@ os_event::wait_time_low(
} }
/** Constructor */ /** Constructor */
os_event::os_event(const char* name) UNIV_NOTHROW os_event::os_event() UNIV_NOTHROW
{ {
init(); init();
@ -444,14 +444,9 @@ Creates an event semaphore, i.e., a semaphore which may just have two
states: signaled and nonsignaled. The created event is manual reset: it states: signaled and nonsignaled. The created event is manual reset: it
must be reset explicitly by calling sync_os_reset_event. must be reset explicitly by calling sync_os_reset_event.
@return the event handle */ @return the event handle */
os_event_t os_event_t os_event_create(const char*)
os_event_create(
/*============*/
const char* name) /*!< in: the name of the
event, if NULL the event
is created without a name */
{ {
return(UT_NEW_NOKEY(os_event(name))); return(UT_NEW_NOKEY(os_event()));
} }
/** /**

6
storage/innobase/page/page0page.cc
View File

@ -2752,7 +2752,11 @@ page_delete_rec(
belongs to */ belongs to */
page_cur_t* pcur, /*!< in/out: page cursor on record page_cur_t* pcur, /*!< in/out: page cursor on record
to delete */ to delete */
page_zip_des_t* page_zip,/*!< in: compressed page descriptor */ page_zip_des_t*
#ifdef UNIV_ZIP_DEBUG
page_zip/*!< in: compressed page descriptor */
#endif
,
const ulint* offsets)/*!< in: offsets for record */ const ulint* offsets)/*!< in: offsets for record */
{ {
bool no_compress_needed; bool no_compress_needed;

10
storage/innobase/rem/rem0cmp.cc
View File

@ -229,7 +229,6 @@ static
int int
cmp_geometry_field( cmp_geometry_field(
/*===============*/ /*===============*/
ulint mtype, /*!< in: main type */
ulint prtype, /*!< in: precise type */ ulint prtype, /*!< in: precise type */
const byte* a, /*!< in: data field */ const byte* a, /*!< in: data field */
unsigned int a_length, /*!< in: data field length, unsigned int a_length, /*!< in: data field length,
@ -303,10 +302,8 @@ cmp_gis_field(
not UNIV_SQL_NULL */ not UNIV_SQL_NULL */
{ {
if (mode == PAGE_CUR_MBR_EQUAL) { if (mode == PAGE_CUR_MBR_EQUAL) {
/* TODO: Since the DATA_GEOMETRY is not used in compare return cmp_geometry_field(DATA_GIS_MBR,
function, we could pass it instead of a specific type now */ a, a_length, b, b_length);
return(cmp_geometry_field(DATA_GEOMETRY, DATA_GIS_MBR,
a, a_length, b, b_length));
} else { } else {
return rtree_key_cmp(mode, a, int(a_length), b, int(b_length)); return rtree_key_cmp(mode, a, int(a_length), b, int(b_length));
} }
@ -379,8 +376,7 @@ cmp_whole_field(
return(innobase_mysql_cmp(prtype, return(innobase_mysql_cmp(prtype,
a, a_length, b, b_length)); a, a_length, b, b_length));
case DATA_GEOMETRY: case DATA_GEOMETRY:
return(cmp_geometry_field(mtype, prtype, a, a_length, b, return cmp_geometry_field(prtype, a, a_length, b, b_length);
b_length));
default: default:
ib::fatal() << "Unknown data type number " << mtype; ib::fatal() << "Unknown data type number " << mtype;
} }

29
storage/innobase/row/row0import.cc
View File

@ -886,17 +886,14 @@ private:
/** Purge delete-marked records, only if it is possible to do /** Purge delete-marked records, only if it is possible to do
so without re-organising the B+tree. so without re-organising the B+tree.
@param offsets current row offsets.
@retval true if purged */ @retval true if purged */
bool purge(const ulint* offsets) UNIV_NOTHROW; bool purge() UNIV_NOTHROW;
/** Adjust the BLOB references and sys fields for the current record. /** Adjust the BLOB references and sys fields for the current record.
@param index the index being converted
@param rec record to update @param rec record to update
@param offsets column offsets for the record @param offsets column offsets for the record
@return DB_SUCCESS or error code. */ @return DB_SUCCESS or error code. */
dberr_t adjust_cluster_record( dberr_t adjust_cluster_record(
const dict_index_t* index,
rec_t* rec, rec_t* rec,
const ulint* offsets) UNIV_NOTHROW; const ulint* offsets) UNIV_NOTHROW;
@ -1631,11 +1628,8 @@ PageConverter::adjust_cluster_index_blob_ref(
/** Purge delete-marked records, only if it is possible to do so without /** Purge delete-marked records, only if it is possible to do so without
re-organising the B+tree. re-organising the B+tree.
@param offsets current row offsets.
@return true if purge succeeded */ @return true if purge succeeded */
inline inline bool PageConverter::purge() UNIV_NOTHROW
bool
PageConverter::purge(const ulint* offsets) UNIV_NOTHROW
{ {
const dict_index_t* index = m_index->m_srv_index; const dict_index_t* index = m_index->m_srv_index;
@ -1659,7 +1653,6 @@ PageConverter::purge(const ulint* offsets) UNIV_NOTHROW
inline inline
dberr_t dberr_t
PageConverter::adjust_cluster_record( PageConverter::adjust_cluster_record(
const dict_index_t* index,
rec_t* rec, rec_t* rec,
const ulint* offsets) UNIV_NOTHROW const ulint* offsets) UNIV_NOTHROW
{ {
@ -1726,8 +1719,7 @@ PageConverter::update_records(
if (clust_index) { if (clust_index) {
dberr_t err = adjust_cluster_record( dberr_t err = adjust_cluster_record(rec, m_offsets);
m_index->m_srv_index, rec, m_offsets);
if (err != DB_SUCCESS) { if (err != DB_SUCCESS) {
return(err); return(err);
@ -1741,7 +1733,7 @@ PageConverter::update_records(
/* A successful purge will move the cursor to the /* A successful purge will move the cursor to the
next record. */ next record. */
if (!purge(m_offsets)) { if (!purge()) {
m_rec_iter.next(); m_rec_iter.next();
} }
@ -2108,8 +2100,6 @@ static MY_ATTRIBUTE((nonnull, warn_unused_result))
dberr_t dberr_t
row_import_adjust_root_pages_of_secondary_indexes( row_import_adjust_root_pages_of_secondary_indexes(
/*==============================================*/ /*==============================================*/
row_prebuilt_t* prebuilt, /*!< in/out: prebuilt from
handler */
trx_t* trx, /*!< in: transaction used for trx_t* trx, /*!< in: transaction used for
the import */ the import */
dict_table_t* table, /*!< in: table the indexes dict_table_t* table, /*!< in: table the indexes
@ -2367,8 +2357,7 @@ row_import_cfg_read_index_fields(
/*=============================*/ /*=============================*/
FILE* file, /*!< in: file to write to */ FILE* file, /*!< in: file to write to */
THD* thd, /*!< in/out: session */ THD* thd, /*!< in/out: session */
row_index_t* index, /*!< Index being read in */ row_index_t* index) /*!< Index being read in */
row_import* cfg) /*!< in/out: meta-data read */
{ {
byte row[sizeof(ib_uint32_t) * 3]; byte row[sizeof(ib_uint32_t) * 3];
ulint n_fields = index->m_n_fields; ulint n_fields = index->m_n_fields;
@ -2588,8 +2577,7 @@ row_import_read_index_data(
return(err); return(err);
} }
err = row_import_cfg_read_index_fields( err = row_import_cfg_read_index_fields(file, thd, cfg_index);
file, thd, cfg_index, cfg);
if (err != DB_SUCCESS) { if (err != DB_SUCCESS) {
return(err); return(err);
@ -2965,7 +2953,6 @@ static MY_ATTRIBUTE((nonnull, warn_unused_result))
dberr_t dberr_t
row_import_read_meta_data( row_import_read_meta_data(
/*======================*/ /*======================*/
dict_table_t* table, /*!< in: table */
FILE* file, /*!< in: File to read from */ FILE* file, /*!< in: File to read from */
THD* thd, /*!< in: session */ THD* thd, /*!< in: session */
row_import& cfg) /*!< out: contents of the .cfg file */ row_import& cfg) /*!< out: contents of the .cfg file */
@ -3039,7 +3026,7 @@ row_import_read_cfg(
cfg.m_missing = false; cfg.m_missing = false;
err = row_import_read_meta_data(table, file, thd, cfg); err = row_import_read_meta_data(file, thd, cfg);
fclose(file); fclose(file);
} }
@ -3998,7 +3985,7 @@ row_import_for_mysql(
during the page conversion phase. */ during the page conversion phase. */
err = row_import_adjust_root_pages_of_secondary_indexes( err = row_import_adjust_root_pages_of_secondary_indexes(
prebuilt, trx, table, cfg); trx, table, cfg);
DBUG_EXECUTE_IF("ib_import_sec_root_adjust_failure", DBUG_EXECUTE_IF("ib_import_sec_root_adjust_failure",
err = DB_CORRUPTION;); err = DB_CORRUPTION;);

9
storage/innobase/row/row0ins.cc
View File

@ -915,8 +915,7 @@ row_ins_invalidate_query_cache(
const char* name) /*!< in: table name prefixed with const char* name) /*!< in: table name prefixed with
database name and a '/' character */ database name and a '/' character */
{ {
ulint len = strlen(name) + 1; innobase_invalidate_query_cache(thr_get_trx(thr), name);
innobase_invalidate_query_cache(thr_get_trx(thr), name, len);
} }
@ -3133,7 +3132,7 @@ row_ins_sec_index_entry_low(
if (err == DB_SUCCESS && dict_index_is_spatial(index) if (err == DB_SUCCESS && dict_index_is_spatial(index)
&& rtr_info.mbr_adj) { && rtr_info.mbr_adj) {
err = rtr_ins_enlarge_mbr(&cursor, thr, &mtr); err = rtr_ins_enlarge_mbr(&cursor, &mtr);
} }
} else { } else {
rec_t* insert_rec; rec_t* insert_rec;
@ -3147,7 +3146,7 @@ row_ins_sec_index_entry_low(
if (err == DB_SUCCESS if (err == DB_SUCCESS
&& dict_index_is_spatial(index) && dict_index_is_spatial(index)
&& rtr_info.mbr_adj) { && rtr_info.mbr_adj) {
err = rtr_ins_enlarge_mbr(&cursor, thr, &mtr); err = rtr_ins_enlarge_mbr(&cursor, &mtr);
} }
} else { } else {
ut_ad(mode == BTR_MODIFY_TREE); ut_ad(mode == BTR_MODIFY_TREE);
@ -3172,7 +3171,7 @@ row_ins_sec_index_entry_low(
if (err == DB_SUCCESS if (err == DB_SUCCESS
&& dict_index_is_spatial(index) && dict_index_is_spatial(index)
&& rtr_info.mbr_adj) { && rtr_info.mbr_adj) {
err = rtr_ins_enlarge_mbr(&cursor, thr, &mtr); err = rtr_ins_enlarge_mbr(&cursor, &mtr);
} }
} }

14
storage/innobase/row/row0log.cc
View File

@ -1132,7 +1132,6 @@ row_log_table_get_pk_old_col(
} }
/** Maps an old table column of a PRIMARY KEY column. /** Maps an old table column of a PRIMARY KEY column.
@param[in] col old table column (before ALTER TABLE)
@param[in] ifield clustered index field in the new table (after @param[in] ifield clustered index field in the new table (after
ALTER TABLE) ALTER TABLE)
@param[in,out] dfield clustered index tuple field in the new table @param[in,out] dfield clustered index tuple field in the new table
@ -1148,7 +1147,6 @@ table
static static
dberr_t dberr_t
row_log_table_get_pk_col( row_log_table_get_pk_col(
const dict_col_t* col,
const dict_field_t* ifield, const dict_field_t* ifield,
dfield_t* dfield, dfield_t* dfield,
mem_heap_t* heap, mem_heap_t* heap,
@ -1334,7 +1332,7 @@ row_log_table_get_pk(
} }
log->error = row_log_table_get_pk_col( log->error = row_log_table_get_pk_col(
col, ifield, dfield, *heap, ifield, dfield, *heap,
rec, offsets, i, page_size, max_len, rec, offsets, i, page_size, max_len,
log->ignore, log->defaults); log->ignore, log->defaults);
@ -1897,11 +1895,10 @@ flag_ok:
/******************************************************//** /******************************************************//**
Replays a delete operation on a table that was rebuilt. Replays a delete operation on a table that was rebuilt.
@return DB_SUCCESS or error code */ @return DB_SUCCESS or error code */
static MY_ATTRIBUTE((nonnull(1, 3, 4, 5, 6, 7), warn_unused_result)) static MY_ATTRIBUTE((nonnull(2, 3, 4, 5, 6), warn_unused_result))
dberr_t dberr_t
row_log_table_apply_delete( row_log_table_apply_delete(
/*=======================*/ /*=======================*/
que_thr_t* thr, /*!< in: query graph */
ulint trx_id_col, /*!< in: position of ulint trx_id_col, /*!< in: position of
DB_TRX_ID in the new DB_TRX_ID in the new
clustered index */ clustered index */
@ -1911,9 +1908,8 @@ row_log_table_apply_delete(
that can be emptied */ that can be emptied */
mem_heap_t* heap, /*!< in/out: memory heap */ mem_heap_t* heap, /*!< in/out: memory heap */
const row_log_t* log, /*!< in: online log */ const row_log_t* log, /*!< in: online log */
const row_ext_t* save_ext, /*!< in: saved external field const row_ext_t* save_ext) /*!< in: saved external field
info, or NULL */ info, or NULL */
ulint ext_size) /*!< in: external field size */
{ {
dict_table_t* new_table = log->table; dict_table_t* new_table = log->table;
dict_index_t* index = dict_table_get_first_index(new_table); dict_index_t* index = dict_table_get_first_index(new_table);
@ -2525,9 +2521,9 @@ row_log_table_apply_op(
} }
*error = row_log_table_apply_delete( *error = row_log_table_apply_delete(
thr, new_trx_id_col, new_trx_id_col,
mrec, offsets, offsets_heap, heap, mrec, offsets, offsets_heap, heap,
log, ext, ext_size); log, ext);
break; break;
case ROW_T_UPDATE: case ROW_T_UPDATE:

14
storage/innobase/row/row0merge.cc
View File

@ -232,7 +232,7 @@ public:
if (error == DB_SUCCESS) { if (error == DB_SUCCESS) {
if (rtr_info.mbr_adj) { if (rtr_info.mbr_adj) {
error = rtr_ins_enlarge_mbr( error = rtr_ins_enlarge_mbr(
&ins_cur, NULL, &mtr); &ins_cur, &mtr);
} }
if (error == DB_SUCCESS) { if (error == DB_SUCCESS) {
@ -2940,10 +2940,10 @@ wait_again:
@param[in,out] foffs1 offset of second source list in the file @param[in,out] foffs1 offset of second source list in the file
@param[in,out] of output file @param[in,out] of output file
@param[in,out] stage performance schema accounting object, used by @param[in,out] stage performance schema accounting object, used by
@param[in,out] crypt_block encryption buffer
@param[in] space tablespace ID for encryption
ALTER TABLE. If not NULL stage->inc() will be called for each record ALTER TABLE. If not NULL stage->inc() will be called for each record
processed. processed.
@param[in,out] crypt_block encryption buffer
@param[in] space tablespace ID for encryption
@return DB_SUCCESS or error code */ @return DB_SUCCESS or error code */
static MY_ATTRIBUTE((warn_unused_result)) static MY_ATTRIBUTE((warn_unused_result))
dberr_t dberr_t
@ -2954,7 +2954,7 @@ row_merge_blocks(
ulint* foffs0, ulint* foffs0,
ulint* foffs1, ulint* foffs1,
merge_file_t* of, merge_file_t* of,
ut_stage_alter_t* stage, ut_stage_alter_t* stage MY_ATTRIBUTE((unused)),
row_merge_block_t* crypt_block, row_merge_block_t* crypt_block,
ulint space) ulint space)
{ {
@ -3062,10 +3062,10 @@ done1:
@param[in,out] foffs0 input file offset @param[in,out] foffs0 input file offset
@param[in,out] of output file @param[in,out] of output file
@param[in,out] stage performance schema accounting object, used by @param[in,out] stage performance schema accounting object, used by
@param[in,out] crypt_block encryption buffer
@param[in] space tablespace ID for encryption
ALTER TABLE. If not NULL stage->inc() will be called for each record ALTER TABLE. If not NULL stage->inc() will be called for each record
processed. processed.
@param[in,out] crypt_block encryption buffer
@param[in] space tablespace ID for encryption
@return TRUE on success, FALSE on failure */ @return TRUE on success, FALSE on failure */
static MY_ATTRIBUTE((warn_unused_result)) static MY_ATTRIBUTE((warn_unused_result))
ibool ibool
@ -3075,7 +3075,7 @@ row_merge_blocks_copy(
row_merge_block_t* block, row_merge_block_t* block,
ulint* foffs0, ulint* foffs0,
merge_file_t* of, merge_file_t* of,
ut_stage_alter_t* stage, ut_stage_alter_t* stage MY_ATTRIBUTE((unused)),
row_merge_block_t* crypt_block, row_merge_block_t* crypt_block,
ulint space) ulint space)
{ {

3
storage/innobase/row/row0row.cc
View File

@ -909,9 +909,8 @@ row_build_row_ref_in_tuple(
held as long as the row held as long as the row
reference is used! */ reference is used! */
const dict_index_t* index, /*!< in: secondary index */ const dict_index_t* index, /*!< in: secondary index */
ulint* offsets,/*!< in: rec_get_offsets(rec, index) ulint* offsets)/*!< in: rec_get_offsets(rec, index)
or NULL */ or NULL */
trx_t* trx) /*!< in: transaction */
{ {
const dict_index_t* clust_index; const dict_index_t* clust_index;
dfield_t* dfield; dfield_t* dfield;

5
storage/innobase/row/row0sel.cc
View File

@ -2489,8 +2489,7 @@ row_sel_convert_mysql_key_to_innobase(
ulint buf_len, /*!< in: buffer length */ ulint buf_len, /*!< in: buffer length */
dict_index_t* index, /*!< in: index of the key value */ dict_index_t* index, /*!< in: index of the key value */
const byte* key_ptr, /*!< in: MySQL key value */ const byte* key_ptr, /*!< in: MySQL key value */
ulint key_len, /*!< in: MySQL key value length */ ulint key_len) /*!< in: MySQL key value length */
trx_t* trx) /*!< in: transaction */
{ {
byte* original_buf = buf; byte* original_buf = buf;
const byte* original_key_ptr = key_ptr; const byte* original_key_ptr = key_ptr;
@ -3288,7 +3287,7 @@ row_sel_get_clust_rec_for_mysql(
thd_get_thread_id(trx->mysql_thd)); thd_get_thread_id(trx->mysql_thd));
row_build_row_ref_in_tuple(prebuilt->clust_ref, rec, row_build_row_ref_in_tuple(prebuilt->clust_ref, rec,
sec_index, *offsets, trx); sec_index, *offsets);
clust_index = dict_table_get_first_index(sec_index->table); clust_index = dict_table_get_first_index(sec_index->table);

36
storage/innobase/row/row0trunc.cc
View File

@ -96,7 +96,7 @@ public:
for (;;) { for (;;) {
if (!btr_pcur_is_on_user_rec(&m_pcur) if (!btr_pcur_is_on_user_rec(&m_pcur)
|| !callback.match(&m_mtr, &m_pcur)) { || !callback.match(&m_pcur)) {
/* The end of of the index has been reached. */ /* The end of of the index has been reached. */
err = DB_END_OF_INDEX; err = DB_END_OF_INDEX;
@ -195,10 +195,9 @@ public:
} }
/** /**
@param mtr mini-transaction covering the iteration
@param pcur persistent cursor used for iteration @param pcur persistent cursor used for iteration
@return true if the table id column matches. */ @return true if the table id column matches. */
bool match(mtr_t* mtr, btr_pcur_t* pcur) const bool match(btr_pcur_t* pcur) const
{ {
ulint len; ulint len;
const byte* field; const byte* field;
@ -866,15 +865,13 @@ public:
/** /**
Look for table-id in SYS_XXXX tables without loading the table. Look for table-id in SYS_XXXX tables without loading the table.
@param mtr mini-transaction covering the read
@param pcur persistent cursor used for reading @param pcur persistent cursor used for reading
@return DB_SUCCESS or error code */ @return DB_SUCCESS */
dberr_t operator()(mtr_t* mtr, btr_pcur_t* pcur); dberr_t operator()(mtr_t*, btr_pcur_t*)
{
private: m_table_found = true;
// Disably copying return(DB_SUCCESS);
TableLocator(const TableLocator&); }
TableLocator& operator=(const TableLocator&);
private: private:
/** Set to true if table is present */ /** Set to true if table is present */
@ -882,11 +879,10 @@ private:
}; };
/** /**
@param mtr mini-transaction covering the read
@param pcur persistent cursor used for reading @param pcur persistent cursor used for reading
@return DB_SUCCESS or error code */ @return DB_SUCCESS or error code */
dberr_t dberr_t
TruncateLogger::operator()(mtr_t* mtr, btr_pcur_t* pcur) TruncateLogger::operator()(mtr_t*, btr_pcur_t* pcur)
{ {
ulint len; ulint len;
const byte* field; const byte* field;
@ -1088,20 +1084,6 @@ CreateIndex::operator()(mtr_t* mtr, btr_pcur_t* pcur) const
return(DB_SUCCESS); return(DB_SUCCESS);
} }
/**
Look for table-id in SYS_XXXX tables without loading the table.
@param mtr mini-transaction covering the read
@param pcur persistent cursor used for reading
@return DB_SUCCESS */
dberr_t
TableLocator::operator()(mtr_t* mtr, btr_pcur_t* pcur)
{
m_table_found = true;
return(DB_SUCCESS);
}
/** /**
Rollback the transaction and release the index locks. Rollback the transaction and release the index locks.
Drop indexes if table is corrupted so that drop/create Drop indexes if table is corrupted so that drop/create

4
storage/innobase/row/row0vers.cc
View File

@ -750,7 +750,6 @@ func_exit:
@param[in] clust_index cluster index @param[in] clust_index cluster index
@param[in] clust_offsets cluster rec offset @param[in] clust_offsets cluster rec offset
@param[in] index secondary index @param[in] index secondary index
@param[in] ientry secondary index rec
@param[in] roll_ptr roll_ptr for the purge record @param[in] roll_ptr roll_ptr for the purge record
@param[in] trx_id transaction ID on the purging record @param[in] trx_id transaction ID on the purging record
@param[in,out] heap heap memory @param[in,out] heap heap memory
@ -765,7 +764,6 @@ row_vers_build_cur_vrow(
dict_index_t* clust_index, dict_index_t* clust_index,
ulint** clust_offsets, ulint** clust_offsets,
dict_index_t* index, dict_index_t* index,
const dtuple_t* ientry,
roll_ptr_t roll_ptr, roll_ptr_t roll_ptr,
trx_id_t trx_id, trx_id_t trx_id,
mem_heap_t* heap, mem_heap_t* heap,
@ -970,7 +968,7 @@ safe_to_purge:
associated with current cluster index */ associated with current cluster index */
cur_vrow = row_vers_build_cur_vrow( cur_vrow = row_vers_build_cur_vrow(
also_curr, rec, clust_index, &clust_offsets, also_curr, rec, clust_index, &clust_offsets,
index, ientry, roll_ptr, trx_id, heap, v_heap, mtr); index, roll_ptr, trx_id, heap, v_heap, mtr);
} }
version = rec; version = rec;

8
storage/innobase/srv/srv0srv.cc
View File

@ -2095,15 +2095,9 @@ srv_master_do_disabled_loop(void)
/** Disables master thread. It's used by: /** Disables master thread. It's used by:
SET GLOBAL innodb_master_thread_disabled_debug = 1 (0). SET GLOBAL innodb_master_thread_disabled_debug = 1 (0).
@param[in] thd thread handle
@param[in] var pointer to system variable
@param[out] var_ptr where the formal string goes
@param[in] save immediate result from check function */ @param[in] save immediate result from check function */
void void
srv_master_thread_disabled_debug_update( srv_master_thread_disabled_debug_update(THD*, st_mysql_sys_var*, void*,
THD* thd,
struct st_mysql_sys_var* var,
void* var_ptr,
const void* save) const void* save)
{ {
/* This method is protected by mutex, as every SET GLOBAL .. */ /* This method is protected by mutex, as every SET GLOBAL .. */

4
storage/innobase/trx/trx0rec.cc
View File

@ -1929,7 +1929,7 @@ trx_undo_report_rename(trx_t* trx, const dict_table_t* table)
} else { } else {
mtr.commit(); mtr.commit();
mtr.start(); mtr.start();
block = trx_undo_add_page(trx, undo, &mtr); block = trx_undo_add_page(undo, &mtr);
if (!block) { if (!block) {
err = DB_OUT_OF_FILE_SPACE; err = DB_OUT_OF_FILE_SPACE;
break; break;
@ -2104,7 +2104,7 @@ trx_undo_report_row_operation(
mtr.set_log_mode(MTR_LOG_NO_REDO); mtr.set_log_mode(MTR_LOG_NO_REDO);
} }
undo_block = trx_undo_add_page(trx, undo, &mtr); undo_block = trx_undo_add_page(undo, &mtr);
DBUG_EXECUTE_IF("ib_err_ins_undo_page_add_failure", DBUG_EXECUTE_IF("ib_err_ins_undo_page_add_failure",
undo_block = NULL;); undo_block = NULL;);

15
storage/innobase/trx/trx0undo.cc
View File

@ -388,15 +388,10 @@ trx_undo_get_first_rec(
@param[in] ptr log record @param[in] ptr log record
@param[in] end_ptr end of log record buffer @param[in] end_ptr end of log record buffer
@param[in,out] page page or NULL @param[in,out] page page or NULL
@param[in,out] mtr mini-transaction
@return end of log record @return end of log record
@retval NULL if the log record is incomplete */ @retval NULL if the log record is incomplete */
byte* byte*
trx_undo_parse_page_init( trx_undo_parse_page_init(const byte* ptr, const byte* end_ptr, page_t* page)
const byte* ptr,
const byte* end_ptr,
page_t* page,
mtr_t* mtr)
{ {
ulint type = mach_parse_compressed(&ptr, end_ptr); ulint type = mach_parse_compressed(&ptr, end_ptr);
@ -420,14 +415,12 @@ trx_undo_parse_page_init(
@param[in] ptr redo log record @param[in] ptr redo log record
@param[in] end_ptr end of log buffer @param[in] end_ptr end of log buffer
@param[in,out] page undo log page or NULL @param[in,out] page undo log page or NULL
@param[in,out] mtr mini-transaction
@return end of log record or NULL */ @return end of log record or NULL */
byte* byte*
trx_undo_parse_page_header_reuse( trx_undo_parse_page_header_reuse(
const byte* ptr, const byte* ptr,
const byte* end_ptr, const byte* end_ptr,
page_t* undo_page, page_t* undo_page)
mtr_t* mtr)
{ {
trx_id_t trx_id = mach_u64_parse_compressed(&ptr, end_ptr); trx_id_t trx_id = mach_u64_parse_compressed(&ptr, end_ptr);
@ -761,13 +754,11 @@ trx_undo_parse_page_header(
} }
/** Allocate an undo log page. /** Allocate an undo log page.
@param[in,out] trx transaction
@param[in,out] undo undo log @param[in,out] undo undo log
@param[in,out] mtr mini-transaction that does not hold any page latch @param[in,out] mtr mini-transaction that does not hold any page latch
@return X-latched block if success @return X-latched block if success
@retval NULL on failure */ @retval NULL on failure */
buf_block_t* buf_block_t* trx_undo_add_page(trx_undo_t* undo, mtr_t* mtr)
trx_undo_add_page(trx_t* trx, trx_undo_t* undo, mtr_t* mtr)
{ {
trx_rseg_t* rseg = undo->rseg; trx_rseg_t* rseg = undo->rseg;
buf_block_t* new_block = NULL; buf_block_t* new_block = NULL;

26
storage/innobase/ut/ut0ut.cc
View File

@ -526,32 +526,6 @@ ut_copy_file(
} while (len > 0); } while (len > 0);
} }
/** Convert an error number to a human readable text message.
The returned string is static and should not be freed or modified.
@param[in] num InnoDB internal error number
@return string, describing the error */
std::string
ut_get_name(
/*=========*/
const trx_t* trx, /*!< in: transaction (NULL=no quotes) */
ibool table_id,/*!< in: TRUE=print a table name,
FALSE=print other identifier */
const char* name) /*!< in: name to print */
{
/* 2 * NAME_LEN for database and table name,
and some slack for the #mysql50# prefix and quotes */
char buf[3 * NAME_LEN];
const char* bufend;
ulint namelen = strlen(name);
bufend = innobase_convert_name(buf, sizeof buf,
name, namelen,
trx ? trx->mysql_thd : NULL);
buf[bufend-buf]='\0';
std::string str(buf);
return str;
}
/** Convert an error number to a human readable text message. /** Convert an error number to a human readable text message.
The returned string is static and should not be freed or modified. The returned string is static and should not be freed or modified.
@param[in] num InnoDB internal error number @param[in] num InnoDB internal error number