diff options
Diffstat (limited to 'storage/innobase')
92 files changed, 4354 insertions, 2098 deletions
diff --git a/storage/innobase/CMakeLists.txt b/storage/innobase/CMakeLists.txt index 95d695d7fa6..1f75aadd36a 100644 --- a/storage/innobase/CMakeLists.txt +++ b/storage/innobase/CMakeLists.txt @@ -416,6 +416,16 @@ IF(WITH_INNODB) SET(WITH_INNOBASE_STORAGE_ENGINE TRUE) ENDIF() +# On solaris, reduce symbol visibility, so loader does not mix +# the same symbols from builtin innodb and from shared one. +# Only required for old GCC (3.4.3) that does not support hidden visibility +IF(CMAKE_SYSTEM_NAME MATCHES "SunOS" AND CMAKE_COMPILER_IS_GNUCC + AND NOT HAVE_VISIBILITY_HIDDEN) + SET(LINKER_SCRIPT "-Wl,-M${CMAKE_CURRENT_SOURCE_DIR}/plugin_exports") +ELSE() + SET(LINKER_SCRIPT) +ENDIF() + MYSQL_ADD_PLUGIN(innobase ${INNOBASE_SOURCES} STORAGE_ENGINE MODULE_ONLY MODULE_OUTPUT_NAME ha_innodb diff --git a/storage/innobase/api/api0api.cc b/storage/innobase/api/api0api.cc index d2f1a468f25..bb65dd82216 100644 --- a/storage/innobase/api/api0api.cc +++ b/storage/innobase/api/api0api.cc @@ -1489,7 +1489,8 @@ ib_insert_row_with_lock_retry( que_thr_stop_for_mysql(thr); thr->lock_state = QUE_THR_LOCK_ROW; - lock_wait = ib_handle_errors(&err, trx, thr, savept); + lock_wait = static_cast<ib_bool_t>( + ib_handle_errors(&err, trx, thr, savept)); thr->lock_state = QUE_THR_LOCK_NOLOCK; } else { lock_wait = FALSE; @@ -1823,8 +1824,8 @@ ib_update_row_with_lock_retry( if (err != DB_RECORD_NOT_FOUND) { thr->lock_state = QUE_THR_LOCK_ROW; - lock_wait = ib_handle_errors( - &err, trx, thr, savept); + lock_wait = static_cast<ib_bool_t>( + ib_handle_errors(&err, trx, thr, savept)); thr->lock_state = QUE_THR_LOCK_NOLOCK; } else { @@ -1977,7 +1978,8 @@ ib_delete_row( upd = ib_update_vector_create(cursor); - page_format = dict_table_is_comp(index->table); + page_format = static_cast<ib_bool_t>( + dict_table_is_comp(index->table)); ib_read_tuple(rec, page_format, tuple, NULL, NULL); upd->n_fields = ib_tuple_get_n_cols(ib_tpl); @@ -2043,7 +2045,8 @@ ib_cursor_delete_row( ib_bool_t page_format; mtr_t mtr; - page_format = dict_table_is_comp(index->table); + page_format = static_cast<ib_bool_t>( + dict_table_is_comp(index->table)); mtr_start(&mtr); @@ -2116,7 +2119,8 @@ ib_cursor_read_row( const rec_t* rec; ib_bool_t page_format; - page_format = dict_table_is_comp(tuple->index->table); + page_format = static_cast<ib_bool_t>( + dict_table_is_comp(tuple->index->table)); rec = btr_pcur_get_rec(pcur); if (prebuilt->innodb_api_rec && @@ -2360,7 +2364,7 @@ ib_col_set_value( for that. */ if (ib_col_is_capped(dtype)) { - len = ut_min(len, col_len); + len = ut_min(len, static_cast<ib_ulint_t>(col_len)); if (dst == NULL || len > dfield_get_len(dfield)) { dst = mem_heap_alloc(tuple->heap, col_len); @@ -2421,12 +2425,12 @@ ib_col_set_value( ut_a(pad_char != ULINT_UNDEFINED); memset((byte*) dst + len, - pad_char, - col_len - len); + static_cast<int>(pad_char), + static_cast<size_t>(col_len - len)); memcpy(dst, src, len); - len = col_len; + len = static_cast<ib_ulint_t>(col_len); break; } case DATA_BLOB: @@ -2467,7 +2471,7 @@ ib_col_set_value( &error); if (true_len < len) { - len = true_len; + len = static_cast<ib_ulint_t>(true_len); } } } @@ -2508,7 +2512,7 @@ ib_col_set_value( col_len--; } - len = col_len; + len = static_cast<ib_ulint_t>(col_len); } break; } @@ -2544,7 +2548,8 @@ ib_col_get_len( data_len = dfield_get_len(dfield); - return(data_len == UNIV_SQL_NULL ? IB_SQL_NULL : data_len); + return(static_cast<ib_ulint_t>( + data_len == UNIV_SQL_NULL ? IB_SQL_NULL : data_len)); } /*****************************************************************//** @@ -2640,7 +2645,7 @@ ib_col_copy_value_low( data_len = IB_SQL_NULL; } - return(data_len); + return(static_cast<ib_ulint_t>(data_len)); } /*****************************************************************//** @@ -2750,14 +2755,15 @@ ib_col_get_meta_low( ib_col_meta->type = static_cast<ib_col_type_t>( dtype_get_mtype(dfield_get_type(dfield))); - ib_col_meta->type_len = dtype_get_len(dfield_get_type(dfield)); + ib_col_meta->type_len = static_cast<ib_u32_t>( + dtype_get_len(dfield_get_type(dfield))); prtype = (ib_u16_t) dtype_get_prtype(dfield_get_type(dfield)); ib_col_meta->attr = ib_col_get_attr(prtype); ib_col_meta->client_type = prtype & DATA_MYSQL_TYPE_MASK; - return(data_len); + return(static_cast<ib_ulint_t>(data_len)); } /*************************************************************//** @@ -3243,10 +3249,12 @@ ib_tuple_get_n_user_cols( const ib_tuple_t* tuple = (const ib_tuple_t*) ib_tpl; if (tuple->type == TPL_TYPE_ROW) { - return(dict_table_get_n_user_cols(tuple->index->table)); + return(static_cast<ib_ulint_t>( + dict_table_get_n_user_cols(tuple->index->table))); } - return(dict_index_get_n_ordering_defined_by_user(tuple->index)); + return(static_cast<ib_ulint_t>( + dict_index_get_n_ordering_defined_by_user(tuple->index))); } /*****************************************************************//** @@ -3260,7 +3268,7 @@ ib_tuple_get_n_cols( { const ib_tuple_t* tuple = (const ib_tuple_t*) ib_tpl; - return(dtuple_get_n_fields(tuple->ptr)); + return(static_cast<ib_ulint_t>(dtuple_get_n_fields(tuple->ptr))); } /*****************************************************************//** @@ -3563,7 +3571,9 @@ ib_tuple_write_int( return(DB_DATA_MISMATCH); } - return(ib_col_set_value(ib_tpl, col_no, value, type_len, true)); + return(ib_col_set_value( + ib_tpl, static_cast<ib_ulint_t>(col_no), + value, static_cast<ib_ulint_t>(type_len), true)); } /*****************************************************************//** @@ -3870,6 +3880,7 @@ ib_table_truncate( ib_err_t trunc_err; ib_trx_t ib_trx = NULL; ib_crsr_t ib_crsr = NULL; + ib_ulint_t memcached_sync = 0; ib_trx = ib_trx_begin(IB_TRX_SERIALIZABLE, true, false); @@ -3885,6 +3896,14 @@ ib_table_truncate( err = DB_TABLE_NOT_FOUND; } + /* Remember the memcached_sync_count and set it to 0, so the + truncate can be executed. */ + if (table != NULL && err == DB_SUCCESS) { + memcached_sync = static_cast<ib_ulint_t>( + table->memcached_sync_count); + table->memcached_sync_count = 0; + } + dict_mutex_exit_for_mysql(); if (err == DB_SUCCESS) { @@ -3910,6 +3929,15 @@ ib_table_truncate( ut_a(err == DB_SUCCESS); } + /* Set the memcached_sync_count back. */ + if (table != NULL && memcached_sync != 0) { + dict_mutex_enter_for_mysql(); + + table->memcached_sync_count = memcached_sync; + + dict_mutex_exit_for_mysql(); + } + return(trunc_err); } @@ -3972,3 +4000,51 @@ ib_cfg_get_cfg() return(cfg_status); } + +/*****************************************************************//** +Increase/decrease the memcached sync count of table to sync memcached +DML with SQL DDLs. +@return DB_SUCCESS or error number */ +UNIV_INTERN +ib_err_t +ib_cursor_set_memcached_sync( +/*=========================*/ + ib_crsr_t ib_crsr, /*!< in: cursor */ + ib_bool_t flag) /*!< in: true for increase */ +{ + const ib_cursor_t* cursor = (const ib_cursor_t*) ib_crsr; + row_prebuilt_t* prebuilt = cursor->prebuilt; + dict_table_t* table = prebuilt->table; + ib_err_t err = DB_SUCCESS; + + if (table != NULL) { + /* If memcached_sync_count is -1, means table is + doing DDL, we just return error. */ + if (table->memcached_sync_count == DICT_TABLE_IN_DDL) { + return(DB_ERROR); + } + + if (flag) { +#ifdef HAVE_ATOMIC_BUILTINS + os_atomic_increment_lint(&table->memcached_sync_count, 1); +#else + dict_mutex_enter_for_mysql(); + ++table->memcached_sync_count; + dict_mutex_exit_for_mysql(); +#endif + } else { +#ifdef HAVE_ATOMIC_BUILTINS + os_atomic_decrement_lint(&table->memcached_sync_count, 1); +#else + dict_mutex_enter_for_mysql(); + --table->memcached_sync_count; + dict_mutex_exit_for_mysql(); +#endif + ut_a(table->memcached_sync_count >= 0); + } + } else { + err = DB_TABLE_NOT_FOUND; + } + + return(err); +} diff --git a/storage/innobase/btr/btr0cur.cc b/storage/innobase/btr/btr0cur.cc index 7e1483cfe85..1d2f313a07c 100644 --- a/storage/innobase/btr/btr0cur.cc +++ b/storage/innobase/btr/btr0cur.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1994, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1994, 2014, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2008, Google Inc. Copyright (c) 2012, Facebook Inc. @@ -2088,8 +2088,7 @@ btr_cur_optimistic_update( contain trx id and roll ptr fields */ ulint cmpl_info,/*!< in: compiler info on secondary index updates */ - que_thr_t* thr, /*!< in: query thread, or NULL if - appropriate flags are set */ + que_thr_t* thr, /*!< in: query thread */ trx_id_t trx_id, /*!< in: transaction id */ mtr_t* mtr) /*!< in/out: mini-transaction; if this is a secondary index, the caller must @@ -2382,8 +2381,7 @@ btr_cur_pessimistic_update( the values in update vector have no effect */ ulint cmpl_info,/*!< in: compiler info on secondary index updates */ - que_thr_t* thr, /*!< in: query thread, or NULL if - appropriate flags are set */ + que_thr_t* thr, /*!< in: query thread */ trx_id_t trx_id, /*!< in: transaction id */ mtr_t* mtr) /*!< in/out: mini-transaction; must be committed before latching any further pages */ @@ -2921,10 +2919,7 @@ btr_cur_del_mark_set_clust_rec( trx = thr_get_trx(thr); if (dict_index_is_online_ddl(index)) { - row_log_table_delete( - rec, index, offsets, false, - trx_read_trx_id(row_get_trx_id_offset(index, offsets) - + rec)); + row_log_table_delete(rec, index, offsets, NULL); } row_upd_rec_sys_fields(rec, page_zip, index, offsets, trx, roll_ptr); @@ -4508,7 +4503,7 @@ btr_store_big_rec_extern_fields( c_stream.next_in = (Bytef*) big_rec_vec->fields[i].data; - c_stream.avail_in = extern_len; + c_stream.avail_in = static_cast<uInt>(extern_len); } for (;;) { @@ -4599,7 +4594,7 @@ alloc_another: c_stream.next_out = page + FIL_PAGE_DATA; c_stream.avail_out - = page_zip_get_size(page_zip) + = static_cast<uInt>(page_zip_get_size(page_zip)) - FIL_PAGE_DATA; err = deflate(&c_stream, Z_FINISH); @@ -5266,7 +5261,7 @@ btr_copy_zblob_prefix( z_stream d_stream; d_stream.next_out = buf; - d_stream.avail_out = len; + d_stream.avail_out = static_cast<uInt>(len); d_stream.next_in = Z_NULL; d_stream.avail_in = 0; @@ -5328,7 +5323,7 @@ btr_copy_zblob_prefix( } d_stream.next_in = bpage->zip.data + offset; - d_stream.avail_in = zip_size - offset; + d_stream.avail_in = static_cast<uInt>(zip_size - offset); err = inflate(&d_stream, Z_NO_FLUSH); switch (err) { diff --git a/storage/innobase/buf/buf0buddy.cc b/storage/innobase/buf/buf0buddy.cc index ee400fcdf23..958b3b5cfad 100644 --- a/storage/innobase/buf/buf0buddy.cc +++ b/storage/innobase/buf/buf0buddy.cc @@ -131,7 +131,7 @@ buf_buddy_stamp_free( buf_buddy_free_t* buf, /*!< in/out: block to stamp */ ulint i) /*!< in: block size */ { - ut_d(memset(buf, i, BUF_BUDDY_LOW << i)); + ut_d(memset(buf, static_cast<int>(i), BUF_BUDDY_LOW << i)); buf_buddy_mem_invalid(buf, i); mach_write_to_4(buf->stamp.bytes + BUF_BUDDY_STAMP_OFFSET, BUF_BUDDY_STAMP_FREE); @@ -533,7 +533,6 @@ buf_buddy_relocate( { buf_page_t* bpage; const ulint size = BUF_BUDDY_LOW << i; - ib_mutex_t* mutex; ulint space; ulint offset; @@ -556,7 +555,12 @@ buf_buddy_relocate( ut_ad(space != BUF_BUDDY_STAMP_FREE); - bpage = buf_page_hash_get(buf_pool, space, offset); + ulint fold = buf_page_address_fold(space, offset); + rw_lock_t* hash_lock = buf_page_hash_lock_get(buf_pool, fold); + + rw_lock_x_lock(hash_lock); + + bpage = buf_page_hash_get_low(buf_pool, space, offset, fold); if (!bpage || bpage->zip.data != src) { /* The block has probably been freshly @@ -564,6 +568,8 @@ buf_buddy_relocate( added to buf_pool->page_hash yet. Obviously, it cannot be relocated. */ + rw_lock_x_unlock(hash_lock); + return(false); } @@ -573,6 +579,8 @@ buf_buddy_relocate( For the sake of simplicity, give up. */ ut_ad(page_zip_get_size(&bpage->zip) < size); + rw_lock_x_unlock(hash_lock); + return(false); } @@ -580,27 +588,42 @@ buf_buddy_relocate( contain uninitialized data. */ UNIV_MEM_ASSERT_W(src, size); - mutex = buf_page_get_mutex(bpage); + ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); - mutex_enter(mutex); + mutex_enter(block_mutex); if (buf_page_can_relocate(bpage)) { /* Relocate the compressed page. */ - ullint usec = ut_time_us(NULL); + ullint usec = ut_time_us(NULL); + ut_a(bpage->zip.data == src); - memcpy(dst, src, size); - bpage->zip.data = (page_zip_t*) dst; - mutex_exit(mutex); + + /* Note: This is potentially expensive, we need a better + solution here. We go with correctness for now. */ + ::memcpy(dst, src, size); + + bpage->zip.data = reinterpret_cast<page_zip_t*>(dst); + + rw_lock_x_unlock(hash_lock); + + mutex_exit(block_mutex); + buf_buddy_mem_invalid( reinterpret_cast<buf_buddy_free_t*>(src), i); buf_buddy_stat_t* buddy_stat = &buf_pool->buddy_stat[i]; - buddy_stat->relocated++; + + ++buddy_stat->relocated; + buddy_stat->relocated_usec += ut_time_us(NULL) - usec; + return(true); } - mutex_exit(mutex); + rw_lock_x_unlock(hash_lock); + + mutex_exit(block_mutex); + return(false); } diff --git a/storage/innobase/buf/buf0buf.cc b/storage/innobase/buf/buf0buf.cc index a8e833b5fa3..4bae962e7d3 100644 --- a/storage/innobase/buf/buf0buf.cc +++ b/storage/innobase/buf/buf0buf.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2014, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2008, Google Inc. Portions of this file contain modifications contributed and copyrighted by @@ -467,6 +467,26 @@ buf_block_alloc( #endif /* !UNIV_HOTBACKUP */ /********************************************************************//** +Checks if a page is all zeroes. +@return TRUE if the page is all zeroes */ +bool +buf_page_is_zeroes( +/*===============*/ + const byte* read_buf, /*!< in: a database page */ + const ulint zip_size) /*!< in: size of compressed page; + 0 for uncompressed pages */ +{ + const ulint page_size = zip_size ? zip_size : UNIV_PAGE_SIZE; + + for (ulint i = 0; i < page_size; i++) { + if (read_buf[i] != 0) { + return(false); + } + } + return(true); +} + +/********************************************************************//** Checks if a page is corrupt. @return TRUE if corrupted */ UNIV_INTERN @@ -548,8 +568,11 @@ buf_page_is_corrupted( if (checksum_field1 == 0 && checksum_field2 == 0 && mach_read_from_4(read_buf + FIL_PAGE_LSN) == 0) { /* make sure that the page is really empty */ - ut_d(for (ulint i = 0; i < UNIV_PAGE_SIZE; i++) { - ut_a(read_buf[i] == 0); }); + for (ulint i = 0; i < UNIV_PAGE_SIZE; i++) { + if (read_buf[i] != 0) { + return(TRUE); + } + } return(FALSE); } @@ -1269,8 +1292,8 @@ buf_pool_init_instance( /* Number of locks protecting page_hash must be a power of two */ - srv_n_page_hash_locks = - ut_2_power_up(srv_n_page_hash_locks); + srv_n_page_hash_locks = static_cast<ulong>( + ut_2_power_up(srv_n_page_hash_locks)); ut_a(srv_n_page_hash_locks != 0); ut_a(srv_n_page_hash_locks <= MAX_PAGE_HASH_LOCKS); @@ -1601,14 +1624,19 @@ buf_pool_watch_set( bpage = buf_page_hash_get_low(buf_pool, space, offset, fold); - if (UNIV_LIKELY_NULL(bpage)) { + if (bpage != NULL) { page_found: if (!buf_pool_watch_is_sentinel(buf_pool, bpage)) { /* The page was loaded meanwhile. */ return(bpage); } + /* Add to an existing watch. */ - bpage->buf_fix_count++; +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_increment_uint32(&bpage->buf_fix_count, 1); +#else + ++bpage->buf_fix_count; +#endif /* PAGE_ATOMIC_REF_COUNT */ return(NULL); } @@ -1660,8 +1688,8 @@ page_found: buf_block_t::mutex or buf_pool->zip_mutex or both. */ bpage->state = BUF_BLOCK_ZIP_PAGE; - bpage->space = space; - bpage->offset = offset; + bpage->space = static_cast<ib_uint32_t>(space); + bpage->offset = static_cast<ib_uint32_t>(offset); bpage->buf_fix_count = 1; ut_d(bpage->in_page_hash = TRUE); @@ -1736,8 +1764,7 @@ buf_pool_watch_unset( buf_page_t* bpage; buf_pool_t* buf_pool = buf_pool_get(space, offset); ulint fold = buf_page_address_fold(space, offset); - rw_lock_t* hash_lock = buf_page_hash_lock_get(buf_pool, - fold); + rw_lock_t* hash_lock = buf_page_hash_lock_get(buf_pool, fold); /* We only need to have buf_pool mutex in case where we end up calling buf_pool_watch_remove but to obey latching order @@ -1748,22 +1775,24 @@ buf_pool_watch_unset( rw_lock_x_lock(hash_lock); - bpage = buf_page_hash_get_low(buf_pool, space, offset, fold); - /* The page must exist because buf_pool_watch_set() - increments buf_fix_count. */ - ut_a(bpage); + /* The page must exist because buf_pool_watch_set() increments + buf_fix_count. */ - if (UNIV_UNLIKELY(!buf_pool_watch_is_sentinel(buf_pool, bpage))) { - ib_mutex_t* mutex = buf_page_get_mutex(bpage); + bpage = buf_page_hash_get_low(buf_pool, space, offset, fold); - mutex_enter(mutex); - ut_a(bpage->buf_fix_count > 0); - bpage->buf_fix_count--; - mutex_exit(mutex); + if (!buf_pool_watch_is_sentinel(buf_pool, bpage)) { + buf_block_unfix(reinterpret_cast<buf_block_t*>(bpage)); } else { - ut_a(bpage->buf_fix_count > 0); - if (UNIV_LIKELY(!--bpage->buf_fix_count)) { + ut_ad(bpage->buf_fix_count > 0); + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_decrement_uint32(&bpage->buf_fix_count, 1); +#else + --bpage->buf_fix_count; +#endif /* PAGE_ATOMIC_REF_COUNT */ + + if (bpage->buf_fix_count == 0) { buf_pool_watch_remove(buf_pool, fold, bpage); } } @@ -1793,10 +1822,10 @@ buf_pool_watch_occurred( rw_lock_s_lock(hash_lock); - bpage = buf_page_hash_get_low(buf_pool, space, offset, fold); /* The page must exist because buf_pool_watch_set() increments buf_fix_count. */ - ut_a(bpage); + bpage = buf_page_hash_get_low(buf_pool, space, offset, fold); + ret = !buf_pool_watch_is_sentinel(buf_pool, bpage); rw_lock_s_unlock(hash_lock); @@ -2034,27 +2063,32 @@ err_exit: case BUF_BLOCK_READY_FOR_USE: case BUF_BLOCK_MEMORY: case BUF_BLOCK_REMOVE_HASH: - break; + ut_error; + case BUF_BLOCK_ZIP_PAGE: case BUF_BLOCK_ZIP_DIRTY: block_mutex = &buf_pool->zip_mutex; mutex_enter(block_mutex); - bpage->buf_fix_count++; +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_increment_uint32(&bpage->buf_fix_count, 1); +#else + ++bpage->buf_fix_count; +#endif /* PAGE_ATOMIC_REF_COUNT */ goto got_block; case BUF_BLOCK_FILE_PAGE: /* Discard the uncompressed page frame if possible. */ if (!discard_attempted) { rw_lock_s_unlock(hash_lock); - buf_block_try_discard_uncompressed(space, - offset); + buf_block_try_discard_uncompressed(space, offset); discard_attempted = TRUE; goto lookup; } block_mutex = &((buf_block_t*) bpage)->mutex; + mutex_enter(block_mutex); - buf_block_buf_fix_inc((buf_block_t*) bpage, - __FILE__, __LINE__); + + buf_block_buf_fix_inc((buf_block_t*) bpage, __FILE__, __LINE__); goto got_block; } @@ -2067,7 +2101,7 @@ got_block: rw_lock_s_unlock(hash_lock); #if defined UNIV_DEBUG_FILE_ACCESSES || defined UNIV_DEBUG ut_a(!bpage->file_page_was_freed); -#endif +#endif /* defined UNIV_DEBUG_FILE_ACCESSES || defined UNIV_DEBUG */ buf_page_set_accessed(bpage); @@ -2378,7 +2412,7 @@ buf_block_is_uncompressed( const buf_block_t* block) /*!< in: pointer to block, not dereferenced */ { - if (UNIV_UNLIKELY((((ulint) block) % sizeof *block) != 0)) { + if ((((ulint) block) % sizeof *block) != 0) { /* The pointer should be aligned. */ return(FALSE); } @@ -2408,6 +2442,47 @@ buf_debug_execute_is_force_flush() } #endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */ +/** +Wait for the block to be read in. +@param block The block to check */ +static +void +buf_wait_for_read(buf_block_t* block) +{ + /* Note: For the PAGE_ATOMIC_REF_COUNT case: + + We are using the block->lock to check for IO state (and a dirty read). + We set the IO_READ state under the protection of the hash_lock + (and block->mutex). This is safe because another thread can only + access the block (and check for IO state) after the block has been + added to the page hashtable. */ + + if (buf_block_get_io_fix(block) == BUF_IO_READ) { + + /* Wait until the read operation completes */ + + ib_mutex_t* mutex = buf_page_get_mutex(&block->page); + + for (;;) { + buf_io_fix io_fix; + + mutex_enter(mutex); + + io_fix = buf_block_get_io_fix(block); + + mutex_exit(mutex); + + if (io_fix == BUF_IO_READ) { + /* Wait by temporaly s-latch */ + rw_lock_s_lock(&block->lock); + rw_lock_s_unlock(&block->lock); + } else { + break; + } + } + } +} + /********************************************************************//** This is the general function used to get access to a database page. @return pointer to the block or NULL */ @@ -2432,10 +2507,10 @@ buf_page_get_gen( ulint fold; unsigned access_time; ulint fix_type; - ibool must_read; rw_lock_t* hash_lock; - ib_mutex_t* block_mutex; ulint retries = 0; + buf_block_t* fix_block; + ib_mutex_t* fix_mutex = NULL; buf_pool_t* buf_pool = buf_pool_get(space, offset); ut_ad(mtr); @@ -2472,7 +2547,9 @@ loop: block = guess; rw_lock_s_lock(hash_lock); - if (block) { + + if (block != NULL) { + /* If the guess is a compressed page descriptor that has been allocated by buf_page_alloc_descriptor(), it may have been freed by buf_relocate(). */ @@ -2510,10 +2587,10 @@ loop: if (UNIV_LIKELY_NULL(block)) { /* We can release hash_lock after we - acquire block_mutex to make sure that - no state change takes place. */ - block_mutex = buf_page_get_mutex(&block->page); - mutex_enter(block_mutex); + increment the fix count to make + sure that no state change takes place. */ + fix_block = block; + buf_block_fix(fix_block); /* Now safe to release page_hash mutex */ rw_lock_x_unlock(hash_lock); @@ -2568,36 +2645,48 @@ loop: ut_a(++buf_dbg_counter % 5771 || buf_validate()); #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */ goto loop; + } else { + fix_block = block; } - - /* We can release hash_lock after we acquire block_mutex to - make sure that no state change takes place. */ - block_mutex = buf_page_get_mutex(&block->page); - mutex_enter(block_mutex); + buf_block_fix(fix_block); /* Now safe to release page_hash mutex */ rw_lock_s_unlock(hash_lock); got_block: + + fix_mutex = buf_page_get_mutex(&fix_block->page); + ut_ad(page_zip_get_size(&block->page.zip) == zip_size); - ut_ad(mutex_own(block_mutex)); - must_read = buf_block_get_io_fix(block) == BUF_IO_READ; + if (mode == BUF_GET_IF_IN_POOL || mode == BUF_PEEK_IF_IN_POOL) { - if (must_read && (mode == BUF_GET_IF_IN_POOL - || mode == BUF_PEEK_IF_IN_POOL)) { + bool must_read; - /* The page is being read to buffer pool, - but we cannot wait around for the read to - complete. */ -null_exit: - mutex_exit(block_mutex); + { + buf_page_t* fix_page = &fix_block->page; - return(NULL); + mutex_enter(fix_mutex); + + buf_io_fix io_fix = buf_page_get_io_fix(fix_page); + + must_read = (io_fix == BUF_IO_READ); + + mutex_exit(fix_mutex); + } + + if (must_read) { + /* The page is being read to buffer pool, + but we cannot wait around for the read to + complete. */ + buf_block_unfix(fix_block); + + return(NULL); + } } - switch (buf_block_get_state(block)) { + switch(buf_block_get_state(fix_block)) { buf_page_t* bpage; case BUF_BLOCK_FILE_PAGE: @@ -2610,18 +2699,22 @@ null_exit: adaptive hash index. There cannot be an adaptive hash index for a compressed-only page, so do not bother decompressing the page. */ - goto null_exit; + buf_block_unfix(fix_block); + + return(NULL); } bpage = &block->page; - if (bpage->buf_fix_count + /* Note: We have already buffer fixed this block. */ + if (bpage->buf_fix_count > 1 || buf_page_get_io_fix(bpage) != BUF_IO_NONE) { + /* This condition often occurs when the buffer is not buffer-fixed, but I/O-fixed by buf_page_init_for_read(). */ - mutex_exit(block_mutex); -wait_until_unfixed: + buf_block_unfix(fix_block); + /* The block is buffer-fixed or I/O-fixed. Try again later. */ os_thread_sleep(WAIT_FOR_READ); @@ -2632,24 +2725,32 @@ wait_until_unfixed: /* Buffer-fix the block so that it cannot be evicted or relocated while we are attempting to allocate an uncompressed page. */ - bpage->buf_fix_count++; - /* Allocate an uncompressed page. */ - mutex_exit(block_mutex); block = buf_LRU_get_free_block(buf_pool); - ut_a(block); buf_pool_mutex_enter(buf_pool); rw_lock_x_lock(hash_lock); + /* Buffer-fixing prevents the page_hash from changing. */ ut_ad(bpage == buf_page_hash_get_low( buf_pool, space, offset, fold)); - mutex_enter(&block->mutex); + buf_block_mutex_enter(block); + mutex_enter(&buf_pool->zip_mutex); - if (--bpage->buf_fix_count + ut_ad(fix_block->page.buf_fix_count > 0); + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_decrement_uint32(&fix_block->page.buf_fix_count, 1); +#else + --fix_block->page.buf_fix_count; +#endif /* PAGE_ATOMIC_REF_COUNT */ + + fix_block = block; + + if (bpage->buf_fix_count > 0 || buf_page_get_io_fix(bpage) != BUF_IO_NONE) { mutex_exit(&buf_pool->zip_mutex); @@ -2662,23 +2763,31 @@ wait_until_unfixed: buf_LRU_block_free_non_file_page(block); buf_pool_mutex_exit(buf_pool); rw_lock_x_unlock(hash_lock); - mutex_exit(&block->mutex); + buf_block_mutex_exit(block); - goto wait_until_unfixed; + /* Try again */ + goto loop; } /* Move the compressed page from bpage to block, and uncompress it. */ + /* Note: this is the uncompressed block and it is not + accessible by other threads yet because it is not in + any list or hash table */ buf_relocate(bpage, &block->page); + buf_block_init_low(block); + + /* Set after relocate(). */ + block->page.buf_fix_count = 1; + block->lock_hash_val = lock_rec_hash(space, offset); UNIV_MEM_DESC(&block->page.zip.data, - page_zip_get_size(&block->page.zip)); + page_zip_get_size(&block->page.zip)); - if (buf_page_get_state(&block->page) - == BUF_BLOCK_ZIP_PAGE) { + if (buf_page_get_state(&block->page) == BUF_BLOCK_ZIP_PAGE) { #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG UT_LIST_REMOVE(list, buf_pool->zip_clean, &block->page); @@ -2686,8 +2795,7 @@ wait_until_unfixed: ut_ad(!block->page.in_flush_list); } else { /* Relocate buf_pool->flush_list. */ - buf_flush_relocate_on_flush_list(bpage, - &block->page); + buf_flush_relocate_on_flush_list(bpage, &block->page); } /* Buffer-fix, I/O-fix, and X-latch the block @@ -2698,7 +2806,6 @@ wait_until_unfixed: /* Insert at the front of unzip_LRU list */ buf_unzip_LRU_add_block(block, FALSE); - block->page.buf_fix_count = 1; buf_block_set_io_fix(block, BUF_IO_READ); rw_lock_x_lock_inline(&block->lock, 0, file, line); @@ -2706,12 +2813,14 @@ wait_until_unfixed: rw_lock_x_unlock(hash_lock); - buf_pool->n_pend_unzip++; + ++buf_pool->n_pend_unzip; + + mutex_exit(&buf_pool->zip_mutex); buf_pool_mutex_exit(buf_pool); access_time = buf_page_is_accessed(&block->page); - mutex_exit(&block->mutex); - mutex_exit(&buf_pool->zip_mutex); + + buf_block_mutex_exit(block); buf_page_free_descriptor(bpage); @@ -2721,9 +2830,12 @@ wait_until_unfixed: /* Page checksum verification is already done when the page is read from disk. Hence page checksum verification is not necessary when decompressing the page. */ - ut_a(buf_zip_decompress(block, FALSE)); + { + bool success = buf_zip_decompress(block, FALSE); + ut_a(success); + } - if (UNIV_LIKELY(!recv_no_ibuf_operations)) { + if (!recv_no_ibuf_operations) { if (access_time) { #ifdef UNIV_IBUF_COUNT_DEBUG ut_a(ibuf_count_get(space, offset) == 0); @@ -2734,13 +2846,19 @@ wait_until_unfixed: } } - /* Unfix and unlatch the block. */ buf_pool_mutex_enter(buf_pool); - mutex_enter(&block->mutex); - block->page.buf_fix_count--; - buf_block_set_io_fix(block, BUF_IO_NONE); - buf_pool->n_pend_unzip--; + + /* Unfix and unlatch the block. */ + buf_block_mutex_enter(fix_block); + + buf_block_set_io_fix(fix_block, BUF_IO_NONE); + + buf_block_mutex_exit(fix_block); + + --buf_pool->n_pend_unzip; + buf_pool_mutex_exit(buf_pool); + rw_lock_x_unlock(&block->lock); break; @@ -2754,43 +2872,40 @@ wait_until_unfixed: break; } + ut_ad(block == fix_block); + ut_ad(fix_block->page.buf_fix_count > 0); + #ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(hash_lock, RW_LOCK_EX)); ut_ad(!rw_lock_own(hash_lock, RW_LOCK_SHARED)); #endif /* UNIV_SYNC_DEBUG */ - ut_ad(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); + ut_ad(buf_block_get_state(fix_block) == BUF_BLOCK_FILE_PAGE); #if UNIV_WORD_SIZE == 4 /* On 32-bit systems, there is no padding in buf_page_t. On other systems, Valgrind could complain about uninitialized pad bytes. */ - UNIV_MEM_ASSERT_RW(&block->page, sizeof block->page); + UNIV_MEM_ASSERT_RW(&fix_block->page, sizeof(fix_block->page)); #endif #if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG if ((mode == BUF_GET_IF_IN_POOL || mode == BUF_GET_IF_IN_POOL_OR_WATCH) && (ibuf_debug || buf_debug_execute_is_force_flush())) { + /* Try to evict the block from the buffer pool, to use the insert buffer (change buffer) as much as possible. */ - /* To obey the latching order, release the - block->mutex before acquiring buf_pool->mutex. Protect - the block from changes by temporarily buffer-fixing it - for the time we are not holding block->mutex. */ - buf_block_buf_fix_inc(block, file, line); - mutex_exit(&block->mutex); buf_pool_mutex_enter(buf_pool); - mutex_enter(&block->mutex); - buf_block_buf_fix_dec(block); - mutex_exit(&block->mutex); + + buf_block_unfix(fix_block); /* Now we are only holding the buf_pool->mutex, not block->mutex or hash_lock. Blocks cannot be relocated or enter or exit the buf_pool while we are holding the buf_pool->mutex. */ - if (buf_LRU_free_page(&block->page, true)) { + if (buf_LRU_free_page(&fix_block->page, true)) { buf_pool_mutex_exit(buf_pool); rw_lock_x_lock(hash_lock); @@ -2807,7 +2922,7 @@ wait_until_unfixed: rw_lock_x_unlock(hash_lock); - if (UNIV_LIKELY_NULL(block)) { + if (block != NULL) { /* Either the page has been read in or a watch was set on that in the window where we released the buf_pool::mutex @@ -2823,103 +2938,114 @@ wait_until_unfixed: return(NULL); } - mutex_enter(&block->mutex); + mutex_enter(&fix_block->mutex); - if (buf_flush_page_try(buf_pool, block)) { + if (buf_flush_page_try(buf_pool, fix_block)) { fprintf(stderr, "innodb_change_buffering_debug flush %u %u\n", (unsigned) space, (unsigned) offset); - guess = block; + guess = fix_block; goto loop; } + buf_block_mutex_exit(fix_block); + + buf_block_fix(fix_block); + /* Failed to evict the page; change it directly */ buf_pool_mutex_exit(buf_pool); } #endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */ - buf_block_buf_fix_inc(block, file, line); + ut_ad(fix_block->page.buf_fix_count > 0); + +#ifdef UNIV_SYNC_DEBUG + /* We have already buffer fixed the page, and we are committed to + returning this page to the caller. Register for debugging. */ + { + ibool ret; + ret = rw_lock_s_lock_nowait(&fix_block->debug_latch, file, line); + ut_a(ret); + } +#endif /* UNIV_SYNC_DEBUG */ + #if defined UNIV_DEBUG_FILE_ACCESSES || defined UNIV_DEBUG ut_a(mode == BUF_GET_POSSIBLY_FREED - || !block->page.file_page_was_freed); + || !fix_block->page.file_page_was_freed); #endif /* Check if this is the first access to the page */ - access_time = buf_page_is_accessed(&block->page); + access_time = buf_page_is_accessed(&fix_block->page); - buf_page_set_accessed(&block->page); + /* This is a heuristic and we don't care about ordering issues. */ + if (access_time == 0) { + buf_block_mutex_enter(fix_block); - mutex_exit(&block->mutex); + buf_page_set_accessed(&fix_block->page); + + buf_block_mutex_exit(fix_block); + } if (mode != BUF_PEEK_IF_IN_POOL) { - buf_page_make_young_if_needed(&block->page); + buf_page_make_young_if_needed(&fix_block->page); } #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG ut_a(++buf_dbg_counter % 5771 || buf_validate()); - ut_a(block->page.buf_fix_count > 0); - ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); + ut_a(fix_block->page.buf_fix_count > 0); + ut_a(buf_block_get_state(fix_block) == BUF_BLOCK_FILE_PAGE); #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */ +#ifdef PAGE_ATOMIC_REF_COUNT + /* We have to wait here because the IO_READ state was set + under the protection of the hash_lock and the block->mutex + but not the block->lock. */ + buf_wait_for_read(fix_block); +#endif /* PAGE_ATOMIC_REF_COUNT */ + switch (rw_latch) { case RW_NO_LATCH: - if (must_read) { - /* Let us wait until the read operation - completes */ - for (;;) { - enum buf_io_fix io_fix; - - mutex_enter(&block->mutex); - io_fix = buf_block_get_io_fix(block); - mutex_exit(&block->mutex); - - if (io_fix == BUF_IO_READ) { - /* wait by temporaly s-latch */ - rw_lock_s_lock(&(block->lock)); - rw_lock_s_unlock(&(block->lock)); - } else { - break; - } - } - } +#ifndef PAGE_ATOMIC_REF_COUNT + buf_wait_for_read(fix_block); +#endif /* !PAGE_ATOMIC_REF_COUNT */ fix_type = MTR_MEMO_BUF_FIX; break; case RW_S_LATCH: - rw_lock_s_lock_inline(&(block->lock), 0, file, line); + rw_lock_s_lock_inline(&fix_block->lock, 0, file, line); fix_type = MTR_MEMO_PAGE_S_FIX; break; default: ut_ad(rw_latch == RW_X_LATCH); - rw_lock_x_lock_inline(&(block->lock), 0, file, line); + rw_lock_x_lock_inline(&fix_block->lock, 0, file, line); fix_type = MTR_MEMO_PAGE_X_FIX; break; } - mtr_memo_push(mtr, block, fix_type); + mtr_memo_push(mtr, fix_block, fix_type); if (mode != BUF_PEEK_IF_IN_POOL && !access_time) { /* In the case of a first access, try to apply linear read-ahead */ - buf_read_ahead_linear(space, zip_size, offset, - ibuf_inside(mtr)); + buf_read_ahead_linear( + space, zip_size, offset, ibuf_inside(mtr)); } #ifdef UNIV_IBUF_COUNT_DEBUG - ut_a(ibuf_count_get(buf_block_get_space(block), - buf_block_get_page_no(block)) == 0); + ut_a(ibuf_count_get(buf_block_get_space(fix_block), + buf_block_get_page_no(fix_block)) == 0); #endif #ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(hash_lock, RW_LOCK_EX)); ut_ad(!rw_lock_own(hash_lock, RW_LOCK_SHARED)); #endif /* UNIV_SYNC_DEBUG */ - return(block); + return(fix_block); } /********************************************************************//** @@ -2982,9 +3108,7 @@ buf_page_optimistic_get( } if (UNIV_UNLIKELY(!success)) { - mutex_enter(&block->mutex); buf_block_buf_fix_dec(block); - mutex_exit(&block->mutex); return(FALSE); } @@ -2998,9 +3122,7 @@ buf_page_optimistic_get( rw_lock_x_unlock(&(block->lock)); } - mutex_enter(&block->mutex); buf_block_buf_fix_dec(block); - mutex_exit(&block->mutex); return(FALSE); } @@ -3105,9 +3227,7 @@ buf_page_get_known_nowait( } if (!success) { - mutex_enter(&block->mutex); buf_block_buf_fix_dec(block); - mutex_exit(&block->mutex); return(FALSE); } @@ -3206,9 +3326,7 @@ buf_page_try_get_func( } if (!success) { - mutex_enter(&block->mutex); buf_block_buf_fix_dec(block); - mutex_exit(&block->mutex); return(NULL); } @@ -3306,13 +3424,20 @@ buf_page_init( hash_page = buf_page_hash_get_low(buf_pool, space, offset, fold); - if (UNIV_LIKELY(!hash_page)) { + if (hash_page == NULL) { + /* Block not found in the hash table */ } else if (buf_pool_watch_is_sentinel(buf_pool, hash_page)) { - /* Preserve the reference count. */ - ulint buf_fix_count = hash_page->buf_fix_count; + ib_uint32_t buf_fix_count = hash_page->buf_fix_count; + + ut_a(buf_fix_count > 0); + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_increment_uint32( + &block->page.buf_fix_count, buf_fix_count); +#else + block->page.buf_fix_count += ulint(buf_fix_count); +#endif /* PAGE_ATOMIC_REF_COUNT */ - ut_a(buf_fix_count > 0); - block->page.buf_fix_count += buf_fix_count; buf_pool_watch_remove(buf_pool, fold, hash_page); } else { fprintf(stderr, @@ -3335,8 +3460,9 @@ buf_page_init( ut_ad(!block->page.in_zip_hash); ut_ad(!block->page.in_page_hash); ut_d(block->page.in_page_hash = TRUE); - HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, - fold, &block->page); + + HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, fold, &block->page); + if (zip_size) { page_zip_set_size(&block->page.zip, zip_size); } @@ -3446,6 +3572,15 @@ err_exit: ut_ad(buf_pool_from_bpage(bpage) == buf_pool); buf_page_init(buf_pool, space, offset, fold, zip_size, block); + +#ifdef PAGE_ATOMIC_REF_COUNT + /* Note: We set the io state without the protection of + the block->lock. This is because other threads cannot + access this block unless it is in the hash table. */ + + buf_page_set_io_fix(bpage, BUF_IO_READ); +#endif /* PAGE_ATOMIC_REF_COUNT */ + rw_lock_x_unlock(hash_lock); /* The block must be put to the LRU list, to the old blocks */ @@ -3461,7 +3596,10 @@ err_exit: io-handler thread. */ rw_lock_x_lock_gen(&block->lock, BUF_IO_READ); + +#ifndef PAGE_ATOMIC_REF_COUNT buf_page_set_io_fix(bpage, BUF_IO_READ); +#endif /* !PAGE_ATOMIC_REF_COUNT */ if (zip_size) { /* buf_pool->mutex may be released and @@ -3536,8 +3674,8 @@ err_exit: buf_page_init_low(bpage); bpage->state = BUF_BLOCK_ZIP_PAGE; - bpage->space = space; - bpage->offset = offset; + bpage->space = static_cast<ib_uint32_t>(space); + bpage->offset = static_cast<ib_uint32_t>(offset); #ifdef UNIV_DEBUG bpage->in_page_hash = FALSE; @@ -3549,12 +3687,22 @@ err_exit: ut_d(bpage->in_page_hash = TRUE); - if (UNIV_LIKELY_NULL(watch_page)) { + if (watch_page != NULL) { /* Preserve the reference count. */ - ulint buf_fix_count = watch_page->buf_fix_count; + ib_uint32_t buf_fix_count; + + buf_fix_count = watch_page->buf_fix_count; + ut_a(buf_fix_count > 0); + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_increment_uint32( + &bpage->buf_fix_count, buf_fix_count); +#else bpage->buf_fix_count += buf_fix_count; +#endif /* PAGE_ATOMIC_REF_COUNT */ + ut_ad(buf_pool_watch_is_sentinel(buf_pool, watch_page)); buf_pool_watch_remove(buf_pool, fold, watch_page); } @@ -3649,8 +3797,7 @@ buf_page_create( buf_block_free(free_block); - return(buf_page_get_with_no_latch(space, zip_size, - offset, mtr)); + return(buf_page_get_with_no_latch(space, zip_size, offset, mtr)); } /* If we get here, the page was not in buf_pool: init it there */ diff --git a/storage/innobase/buf/buf0dblwr.cc b/storage/innobase/buf/buf0dblwr.cc index 2b2483fde6d..62222993622 100644 --- a/storage/innobase/buf/buf0dblwr.cc +++ b/storage/innobase/buf/buf0dblwr.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -351,13 +351,13 @@ At a database startup initializes the doublewrite buffer memory structure if we already have a doublewrite buffer created in the data files. If we are upgrading to an InnoDB version which supports multiple tablespaces, then this function performs the necessary update operations. If we are in a crash -recovery, this function uses a possible doublewrite buffer to restore -half-written pages in the data files. */ -UNIV_INTERN +recovery, this function loads the pages from double write buffer into memory. */ void -buf_dblwr_init_or_restore_pages( -/*============================*/ - ibool restore_corrupt_pages) /*!< in: TRUE=restore pages */ +buf_dblwr_init_or_load_pages( +/*=========================*/ + os_file_t file, + char* path, + bool load_corrupt_pages) { byte* buf; byte* read_buf; @@ -368,8 +368,9 @@ buf_dblwr_init_or_restore_pages( ibool reset_space_ids = FALSE; byte* doublewrite; ulint space_id; - ulint page_no; ulint i; + ulint block_bytes = 0; + recv_dblwr_t& recv_dblwr = recv_sys->dblwr; /* We do the file i/o past the buffer pool */ @@ -380,9 +381,9 @@ buf_dblwr_init_or_restore_pages( /* Read the trx sys header to check if we are using the doublewrite buffer */ + off_t trx_sys_page = TRX_SYS_PAGE_NO * UNIV_PAGE_SIZE; + os_file_read(file, read_buf, trx_sys_page, UNIV_PAGE_SIZE); - fil_io(OS_FILE_READ, true, TRX_SYS_SPACE, 0, TRX_SYS_PAGE_NO, 0, - UNIV_PAGE_SIZE, read_buf, NULL); doublewrite = read_buf + TRX_SYS_DOUBLEWRITE; if (mach_read_from_4(doublewrite + TRX_SYS_DOUBLEWRITE_MAGIC) @@ -416,13 +417,12 @@ buf_dblwr_init_or_restore_pages( /* Read the pages from the doublewrite buffer to memory */ - fil_io(OS_FILE_READ, true, TRX_SYS_SPACE, 0, block1, 0, - TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE, - buf, NULL); - fil_io(OS_FILE_READ, true, TRX_SYS_SPACE, 0, block2, 0, - TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE, - buf + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE, - NULL); + block_bytes = TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * UNIV_PAGE_SIZE; + + os_file_read(file, buf, block1 * UNIV_PAGE_SIZE, block_bytes); + os_file_read(file, buf + block_bytes, block2 * UNIV_PAGE_SIZE, + block_bytes); + /* Check if any of these pages is half-written in data files, in the intended position */ @@ -431,13 +431,12 @@ buf_dblwr_init_or_restore_pages( for (i = 0; i < TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * 2; i++) { ulint source_page_no; - page_no = mach_read_from_4(page + FIL_PAGE_OFFSET); if (reset_space_ids) { space_id = 0; mach_write_to_4(page - + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, 0); + + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, space_id); /* We do not need to calculate new checksums for the pages because the field .._SPACE_ID does not affect them. Write the page back to where we read it from. */ @@ -449,19 +448,53 @@ buf_dblwr_init_or_restore_pages( + i - TRX_SYS_DOUBLEWRITE_BLOCK_SIZE; } - fil_io(OS_FILE_WRITE, true, 0, 0, source_page_no, 0, - UNIV_PAGE_SIZE, page, NULL); - } else { + os_file_write(path, file, page, + source_page_no * UNIV_PAGE_SIZE, + UNIV_PAGE_SIZE); - space_id = mach_read_from_4( - page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID); + } else if (load_corrupt_pages) { + + recv_dblwr.add(page); } - if (!restore_corrupt_pages) { - /* The database was shut down gracefully: no need to - restore pages */ + page += UNIV_PAGE_SIZE; + } + + if (reset_space_ids) { + os_file_flush(file); + } + +leave_func: + ut_free(unaligned_read_buf); +} + +/****************************************************************//** +Process the double write buffer pages. */ +void +buf_dblwr_process() +/*===============*/ +{ + ulint space_id; + ulint page_no; + ulint page_no_dblwr = 0; + byte* page; + byte* read_buf; + byte* unaligned_read_buf; + recv_dblwr_t& recv_dblwr = recv_sys->dblwr; + + unaligned_read_buf = static_cast<byte*>(ut_malloc(2 * UNIV_PAGE_SIZE)); + + read_buf = static_cast<byte*>( + ut_align(unaligned_read_buf, UNIV_PAGE_SIZE)); + + for (std::list<byte*>::iterator i = recv_dblwr.pages.begin(); + i != recv_dblwr.pages.end(); ++i, ++page_no_dblwr ) { + + page = *i; + page_no = mach_read_from_4(page + FIL_PAGE_OFFSET); + space_id = mach_read_from_4(page + FIL_PAGE_SPACE_ID); - } else if (!fil_tablespace_exists_in_mem(space_id)) { + if (!fil_tablespace_exists_in_mem(space_id)) { /* Maybe we have dropped the single-table tablespace and this page once belonged to it: do nothing */ @@ -472,19 +505,8 @@ buf_dblwr_init_or_restore_pages( "within space bounds; space id %lu " "page number %lu, page %lu in " "doublewrite buf.", - (ulong) space_id, (ulong) page_no, (ulong) i); - - } else if (space_id == TRX_SYS_SPACE - && ((page_no >= block1 - && page_no - < block1 + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) - || (page_no >= block2 - && page_no - < (block2 - + TRX_SYS_DOUBLEWRITE_BLOCK_SIZE)))) { - - /* It is an unwritten doublewrite buffer page: - do nothing */ + (ulong) space_id, (ulong) page_no, + page_no_dblwr); } else { ulint zip_size = fil_space_get_zip_size(space_id); @@ -549,15 +571,28 @@ buf_dblwr_init_or_restore_pages( ib_logf(IB_LOG_LEVEL_INFO, "Recovered the page from" " the doublewrite buffer."); + + } else if (buf_page_is_zeroes(read_buf, zip_size)) { + + if (!buf_page_is_zeroes(page, zip_size) + && !buf_page_is_corrupted(true, page, + zip_size)) { + + /* Database page contained only + zeroes, while a valid copy is + available in dblwr buffer. */ + + fil_io(OS_FILE_WRITE, true, space_id, + zip_size, page_no, 0, + zip_size ? zip_size + : UNIV_PAGE_SIZE, + page, NULL); + } } } - - page += UNIV_PAGE_SIZE; } fil_flush_file_spaces(FIL_TABLESPACE); - -leave_func: ut_free(unaligned_read_buf); } @@ -776,6 +811,7 @@ buf_dblwr_write_block_to_datafile( fil_io(flags, sync, buf_block_get_space(block), 0, buf_block_get_page_no(block), 0, UNIV_PAGE_SIZE, (void*) block->frame, (void*) block); + } /********************************************************************//** diff --git a/storage/innobase/buf/buf0flu.cc b/storage/innobase/buf/buf0flu.cc index 3af434b77f4..3cce75abe74 100644 --- a/storage/innobase/buf/buf0flu.cc +++ b/storage/innobase/buf/buf0flu.cc @@ -502,15 +502,15 @@ buf_flush_ready_for_replace( #ifdef UNIV_DEBUG buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); ut_ad(buf_pool_mutex_own(buf_pool)); -#endif +#endif /* UNIV_DEBUG */ ut_ad(mutex_own(buf_page_get_mutex(bpage))); ut_ad(bpage->in_LRU_list); - if (UNIV_LIKELY(buf_page_in_file(bpage))) { + if (buf_page_in_file(bpage)) { return(bpage->oldest_modification == 0 - && buf_page_get_io_fix(bpage) == BUF_IO_NONE - && bpage->buf_fix_count == 0); + && bpage->buf_fix_count == 0 + && buf_page_get_io_fix(bpage) == BUF_IO_NONE); } ut_print_timestamp(stderr); @@ -553,17 +553,10 @@ buf_flush_ready_for_flush( switch (flush_type) { case BUF_FLUSH_LIST: - return(true); - case BUF_FLUSH_LRU: case BUF_FLUSH_SINGLE_PAGE: - /* Because any thread may call single page flush, even - when owning locks on pages, to avoid deadlocks, we must - make sure that the that it is not buffer fixed. - The same holds true for LRU flush because a user thread - may end up waiting for an LRU flush to end while - holding locks on other pages. */ - return(bpage->buf_fix_count == 0); + return(true); + case BUF_FLUSH_N_TYPES: break; } @@ -757,9 +750,11 @@ buf_flush_update_zip_checksum( { ut_a(zip_size > 0); - ib_uint32_t checksum = page_zip_calc_checksum( - page, zip_size, - static_cast<srv_checksum_algorithm_t>(srv_checksum_algorithm)); + ib_uint32_t checksum = static_cast<ib_uint32_t>( + page_zip_calc_checksum( + page, zip_size, + static_cast<srv_checksum_algorithm_t>( + srv_checksum_algorithm))); mach_write_to_8(page + FIL_PAGE_LSN, lsn); memset(page + FIL_PAGE_FILE_FLUSH_LSN, 0, 8); @@ -991,9 +986,10 @@ NOTE: in simulated aio we must call os_aio_simulated_wake_handler_threads after we have posted a batch of writes! NOTE: buf_pool->mutex and buf_page_get_mutex(bpage) must be held upon entering this function, and they will be released by this -function. */ +function if it returns true. +@return TRUE if the page was flushed */ UNIV_INTERN -void +bool buf_flush_page( /*===========*/ buf_pool_t* buf_pool, /*!< in: buffer pool instance */ @@ -1001,109 +997,84 @@ buf_flush_page( buf_flush_t flush_type, /*!< in: type of flush */ bool sync) /*!< in: true if sync IO request */ { - ib_mutex_t* block_mutex; - ibool is_uncompressed; - ut_ad(flush_type < BUF_FLUSH_N_TYPES); ut_ad(buf_pool_mutex_own(buf_pool)); ut_ad(buf_page_in_file(bpage)); ut_ad(!sync || flush_type == BUF_FLUSH_SINGLE_PAGE); - block_mutex = buf_page_get_mutex(bpage); + ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); + ut_ad(mutex_own(block_mutex)); ut_ad(buf_flush_ready_for_flush(bpage, flush_type)); - buf_page_set_io_fix(bpage, BUF_IO_WRITE); + bool is_uncompressed; - buf_page_set_flush_type(bpage, flush_type); + is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE); + ut_ad(is_uncompressed == (block_mutex != &buf_pool->zip_mutex)); - if (buf_pool->n_flush[flush_type] == 0) { + ibool flush; + rw_lock_t* rw_lock; + bool no_fix_count = bpage->buf_fix_count == 0; - os_event_reset(buf_pool->no_flush[flush_type]); - } + if (!is_uncompressed) { + flush = TRUE; + rw_lock = NULL; - buf_pool->n_flush[flush_type]++; + } else if (!(no_fix_count || flush_type == BUF_FLUSH_LIST)) { + /* This is a heuristic, to avoid expensive S attempts. */ + flush = FALSE; + } else { - is_uncompressed = (buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE); - ut_ad(is_uncompressed == (block_mutex != &buf_pool->zip_mutex)); + rw_lock = &reinterpret_cast<buf_block_t*>(bpage)->lock; - switch (flush_type) { - ibool is_s_latched; - case BUF_FLUSH_LIST: - /* If the simulated aio thread is not running, we must - not wait for any latch, as we may end up in a deadlock: - if buf_fix_count == 0, then we know we need not wait */ - - is_s_latched = (bpage->buf_fix_count == 0); - if (is_s_latched && is_uncompressed) { - rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock, - BUF_IO_WRITE); + if (flush_type != BUF_FLUSH_LIST) { + flush = rw_lock_s_lock_gen_nowait( + rw_lock, BUF_IO_WRITE); + } else { + /* Will S lock later */ + flush = TRUE; } + } - mutex_exit(block_mutex); - buf_pool_mutex_exit(buf_pool); + if (flush) { - /* Even though bpage is not protected by any mutex at - this point, it is safe to access bpage, because it is - io_fixed and oldest_modification != 0. Thus, it - cannot be relocated in the buffer pool or removed from - flush_list or LRU_list. */ + /* We are committed to flushing by the time we get here */ - if (!is_s_latched) { - buf_dblwr_flush_buffered_writes(); + buf_page_set_io_fix(bpage, BUF_IO_WRITE); - if (is_uncompressed) { - rw_lock_s_lock_gen(&((buf_block_t*) bpage) - ->lock, BUF_IO_WRITE); - } - } + buf_page_set_flush_type(bpage, flush_type); - break; + if (buf_pool->n_flush[flush_type] == 0) { - case BUF_FLUSH_LRU: - case BUF_FLUSH_SINGLE_PAGE: - /* VERY IMPORTANT: - Because any thread may call single page flush, even when - owning locks on pages, to avoid deadlocks, we must make - sure that the s-lock is acquired on the page without - waiting: this is accomplished because - buf_flush_ready_for_flush() must hold, and that requires - the page not to be bufferfixed. - The same holds true for LRU flush because a user thread - may end up waiting for an LRU flush to end while - holding locks on other pages. */ - - if (is_uncompressed) { - rw_lock_s_lock_gen(&((buf_block_t*) bpage)->lock, - BUF_IO_WRITE); + os_event_reset(buf_pool->no_flush[flush_type]); } - /* Note that the s-latch is acquired before releasing the - buf_pool mutex: this ensures that the latch is acquired - immediately. */ + ++buf_pool->n_flush[flush_type]; mutex_exit(block_mutex); buf_pool_mutex_exit(buf_pool); - break; - default: - ut_error; - } + if (flush_type == BUF_FLUSH_LIST + && is_uncompressed + && !rw_lock_s_lock_gen_nowait(rw_lock, BUF_IO_WRITE)) { + /* avoiding deadlock possibility involves doublewrite + buffer, should flush it, because it might hold the + another block->lock. */ + buf_dblwr_flush_buffered_writes(); - /* Even though bpage is not protected by any mutex at this - point, it is safe to access bpage, because it is io_fixed and - oldest_modification != 0. Thus, it cannot be relocated in the - buffer pool or removed from flush_list or LRU_list. */ + rw_lock_s_lock_gen(rw_lock, BUF_IO_WRITE); + } -#ifdef UNIV_DEBUG - if (buf_debug_prints) { - fprintf(stderr, - "Flushing %u space %u page %u\n", - flush_type, bpage->space, bpage->offset); - } -#endif /* UNIV_DEBUG */ - buf_flush_write_block_low(bpage, flush_type, sync); + /* Even though bpage is not protected by any mutex at this + point, it is safe to access bpage, because it is io_fixed and + oldest_modification != 0. Thus, it cannot be relocated in the + buffer pool or removed from flush_list or LRU_list. */ + + buf_flush_write_block_low(bpage, flush_type, sync); + } + + return(flush); } # if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG @@ -1130,8 +1101,8 @@ buf_flush_page_try( /* The following call will release the buffer pool and block mutex. */ - buf_flush_page(buf_pool, &block->page, BUF_FLUSH_SINGLE_PAGE, true); - return(TRUE); + return(buf_flush_page( + buf_pool, &block->page, BUF_FLUSH_SINGLE_PAGE, true)); } # endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */ /***********************************************************//** @@ -1203,7 +1174,6 @@ buf_flush_try_neighbors( ulint i; ulint low; ulint high; - ulint count = 0; buf_pool_t* buf_pool = buf_pool_get(space, offset); ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST); @@ -1259,9 +1229,9 @@ buf_flush_try_neighbors( high = fil_space_get_size(space); } - for (i = low; i < high; i++) { + ulint count = 0; - buf_page_t* bpage; + for (i = low; i < high; i++) { if ((count + n_flushed) >= n_to_flush) { @@ -1283,9 +1253,9 @@ buf_flush_try_neighbors( buf_pool_mutex_enter(buf_pool); /* We only want to flush pages from this buffer pool. */ - bpage = buf_page_hash_get(buf_pool, space, i); + buf_page_t* bpage = buf_page_hash_get(buf_pool, space, i); - if (!bpage) { + if (bpage == NULL) { buf_pool_mutex_exit(buf_pool); continue; @@ -1299,30 +1269,24 @@ buf_flush_try_neighbors( if (flush_type != BUF_FLUSH_LRU || i == offset || buf_page_is_old(bpage)) { + ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); mutex_enter(block_mutex); if (buf_flush_ready_for_flush(bpage, flush_type) - && (i == offset || !bpage->buf_fix_count)) { - /* We only try to flush those - neighbors != offset where the buf fix - count is zero, as we then know that we - probably can latch the page without a - semaphore wait. Semaphore waits are - expensive because we must flush the - doublewrite buffer before we start - waiting. */ - - buf_flush_page(buf_pool, bpage, flush_type, false); - ut_ad(!mutex_own(block_mutex)); - ut_ad(!buf_pool_mutex_own(buf_pool)); - count++; + && (i == offset || bpage->buf_fix_count == 0) + && buf_flush_page( + buf_pool, bpage, flush_type, false)) { + + ++count; + continue; - } else { - mutex_exit(block_mutex); } + + mutex_exit(block_mutex); } + buf_pool_mutex_exit(buf_pool); } @@ -1358,8 +1322,8 @@ buf_flush_page_and_try_neighbors( ulint* count) /*!< in/out: number of pages flushed */ { + ibool flushed; ib_mutex_t* block_mutex; - ibool flushed = FALSE; #ifdef UNIV_DEBUG buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); #endif /* UNIV_DEBUG */ @@ -1372,8 +1336,6 @@ buf_flush_page_and_try_neighbors( ut_a(buf_page_in_file(bpage)); if (buf_flush_ready_for_flush(bpage, flush_type)) { - ulint space; - ulint offset; buf_pool_t* buf_pool; buf_pool = buf_pool_from_bpage(bpage); @@ -1382,22 +1344,22 @@ buf_flush_page_and_try_neighbors( /* These fields are protected by both the buffer pool mutex and block mutex. */ - space = buf_page_get_space(bpage); - offset = buf_page_get_page_no(bpage); + ulint space = buf_page_get_space(bpage); + ulint offset = buf_page_get_page_no(bpage); mutex_exit(block_mutex); /* Try to flush also all the neighbors */ - *count += buf_flush_try_neighbors(space, - offset, - flush_type, - *count, - n_to_flush); + *count += buf_flush_try_neighbors( + space, offset, flush_type, *count, n_to_flush); buf_pool_mutex_enter(buf_pool); + flushed = TRUE; + } else { mutex_exit(block_mutex); + flushed = FALSE; } ut_ad(buf_pool_mutex_own(buf_pool)); @@ -1480,8 +1442,8 @@ buf_flush_LRU_list_batch( blocks in the free_list */ { buf_page_t* bpage; - ulint scanned = 0; ulint count = 0; + ulint scanned = 0; ulint free_len = UT_LIST_GET_LEN(buf_pool->free); ulint lru_len = UT_LIST_GET_LEN(buf_pool->LRU); @@ -1520,15 +1482,44 @@ buf_flush_LRU_list_batch( } else { bpage = UT_LIST_GET_PREV(LRU, bpage); } - } else if (buf_flush_page_and_try_neighbors( - bpage, - BUF_FLUSH_LRU, max, &count)) { - - /* buf_pool->mutex was released. - Restart the scan. */ - bpage = UT_LIST_GET_LAST(buf_pool->LRU); } else { - bpage = UT_LIST_GET_PREV(LRU, bpage); + ulint space; + ulint offset; + buf_page_t* prev_bpage; + + prev_bpage = UT_LIST_GET_PREV(LRU, bpage); + + /* Save the previous bpage */ + + if (prev_bpage != NULL) { + space = prev_bpage->space; + offset = prev_bpage->offset; + } else { + space = ULINT_UNDEFINED; + offset = ULINT_UNDEFINED; + } + + if (!buf_flush_page_and_try_neighbors( + bpage, BUF_FLUSH_LRU, max, &count)) { + + bpage = prev_bpage; + } else { + /* buf_pool->mutex was released. + reposition the iterator. Note: the + prev block could have been repositioned + too but that should be rare. */ + + if (prev_bpage != NULL) { + + ut_ad(space != ULINT_UNDEFINED); + ut_ad(offset != ULINT_UNDEFINED); + + prev_bpage = buf_page_hash_get( + buf_pool, space, offset); + } + + bpage = prev_bpage; + } } free_len = UT_LIST_GET_LEN(buf_pool->free); @@ -1836,7 +1827,7 @@ buf_flush_wait_batch_end( } } else { thd_wait_begin(NULL, THD_WAIT_DISKIO); - os_event_wait(buf_pool->no_flush[type]); + os_event_wait(buf_pool->no_flush[type]); thd_wait_end(NULL); } } @@ -1985,9 +1976,6 @@ buf_flush_single_page_from_LRU( { ulint scanned; buf_page_t* bpage; - ib_mutex_t* block_mutex; - ibool freed; - bool evict_zip; buf_pool_mutex_enter(buf_pool); @@ -1995,14 +1983,25 @@ buf_flush_single_page_from_LRU( bpage != NULL; bpage = UT_LIST_GET_PREV(LRU, bpage), ++scanned) { - block_mutex = buf_page_get_mutex(bpage); + ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); + mutex_enter(block_mutex); - if (buf_flush_ready_for_flush(bpage, - BUF_FLUSH_SINGLE_PAGE)) { - /* buf_flush_page() will release the block - mutex */ - break; + + if (buf_flush_ready_for_flush(bpage, BUF_FLUSH_SINGLE_PAGE)) { + + /* The following call will release the buffer pool + and block mutex. */ + + ibool flushed = buf_flush_page( + buf_pool, bpage, BUF_FLUSH_SINGLE_PAGE, true); + + if (flushed) { + /* buf_flush_page() will release the + block mutex */ + break; + } } + mutex_exit(block_mutex); } @@ -2012,15 +2011,14 @@ buf_flush_single_page_from_LRU( MONITOR_LRU_SINGLE_FLUSH_SCANNED_PER_CALL, scanned); - if (!bpage) { + if (bpage == NULL) { /* Can't find a single flushable page. */ buf_pool_mutex_exit(buf_pool); return(FALSE); } - /* The following call will release the buffer pool and - block mutex. */ - buf_flush_page(buf_pool, bpage, BUF_FLUSH_SINGLE_PAGE, true); + + ibool freed = FALSE; /* At this point the page has been written to the disk. As we are not holding buffer pool or block mutex therefore @@ -2035,27 +2033,25 @@ buf_flush_single_page_from_LRU( bpage != NULL; bpage = UT_LIST_GET_PREV(LRU, bpage)) { - ibool ready; + ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); - block_mutex = buf_page_get_mutex(bpage); mutex_enter(block_mutex); - ready = buf_flush_ready_for_replace(bpage); + + ibool ready = buf_flush_ready_for_replace(bpage); + mutex_exit(block_mutex); + if (ready) { - break; - } + bool evict_zip; - } + evict_zip = !buf_LRU_evict_from_unzip_LRU(buf_pool);; - if (!bpage) { - /* Can't find a single replaceable page. */ - buf_pool_mutex_exit(buf_pool); - return(FALSE); - } + freed = buf_LRU_free_page(bpage, evict_zip); - evict_zip = !buf_LRU_evict_from_unzip_LRU(buf_pool);; + break; + } + } - freed = buf_LRU_free_page(bpage, evict_zip); buf_pool_mutex_exit(buf_pool); return(freed); @@ -2328,7 +2324,7 @@ page_cleaner_flush_pages_if_needed(void) } if (last_pages && cur_lsn - last_lsn > lsn_avg_rate / 2) { - age_factor = prev_pages / last_pages; + age_factor = static_cast<int>(prev_pages / last_pages); } MONITOR_SET(MONITOR_FLUSH_N_TO_FLUSH_REQUESTED, n_pages); diff --git a/storage/innobase/buf/buf0lru.cc b/storage/innobase/buf/buf0lru.cc index bc73119c227..ec30c063a72 100644 --- a/storage/innobase/buf/buf0lru.cc +++ b/storage/innobase/buf/buf0lru.cc @@ -473,12 +473,8 @@ buf_flush_or_remove_page( yet; maybe the system is currently reading it in, or flushing the modifications to the file */ return(false); - } - ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); - bool processed = false; - /* We have to release the flush_list_mutex to obey the latching order. We are however guaranteed that the page will stay in the flush_list and won't be relocated because @@ -487,6 +483,9 @@ buf_flush_or_remove_page( buf_flush_list_mutex_exit(buf_pool); + bool processed; + ib_mutex_t* block_mutex = buf_page_get_mutex(bpage); + mutex_enter(block_mutex); ut_ad(bpage->oldest_modification != 0); @@ -494,18 +493,11 @@ buf_flush_or_remove_page( if (!flush) { buf_flush_remove(bpage); - - mutex_exit(block_mutex); - processed = true; - } else if (buf_flush_ready_for_flush(bpage, - BUF_FLUSH_SINGLE_PAGE)) { - - /* The following call will release the buffer pool - and block mutex. */ - buf_flush_page(buf_pool, bpage, BUF_FLUSH_SINGLE_PAGE, false); - ut_ad(!mutex_own(block_mutex)); + } else if (buf_flush_ready_for_flush(bpage, BUF_FLUSH_SINGLE_PAGE) + && buf_flush_page( + buf_pool, bpage, BUF_FLUSH_SINGLE_PAGE, false)) { /* Wake possible simulated aio thread to actually post the writes to the operating system */ @@ -513,15 +505,16 @@ buf_flush_or_remove_page( buf_pool_mutex_enter(buf_pool); - processed = true; + buf_flush_list_mutex_enter(buf_pool); + + return(true); + } else { - /* Not ready for flush. It can't be IO fixed because we - checked for that at the start of the function. It must - be buffer fixed. */ - ut_ad(bpage->buf_fix_count > 0); - mutex_exit(block_mutex); + processed = false; } + mutex_exit(block_mutex); + buf_flush_list_mutex_enter(buf_pool); ut_ad(!mutex_own(block_mutex)); @@ -1269,7 +1262,8 @@ loop: memset(&block->page.zip, 0, sizeof block->page.zip); if (started_monitor) { - srv_print_innodb_monitor = mon_value_was; + srv_print_innodb_monitor = + static_cast<my_bool>(mon_value_was); } return(block); @@ -1684,8 +1678,6 @@ buf_LRU_add_block_low( { buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); - ut_ad(buf_pool); - ut_ad(bpage); ut_ad(buf_pool_mutex_own(buf_pool)); ut_a(buf_page_in_file(bpage)); @@ -1835,7 +1827,7 @@ buf_LRU_free_page( if (!buf_page_can_relocate(bpage)) { - /* Do not free buffer-fixed or I/O-fixed blocks. */ + /* Do not free buffer fixed or I/O-fixed blocks. */ goto func_exit; } @@ -1850,12 +1842,10 @@ buf_LRU_free_page( if (bpage->oldest_modification) { goto func_exit; } - } else if ((bpage->oldest_modification) - && (buf_page_get_state(bpage) - != BUF_BLOCK_FILE_PAGE)) { + } else if (bpage->oldest_modification > 0 + && buf_page_get_state(bpage) != BUF_BLOCK_FILE_PAGE) { - ut_ad(buf_page_get_state(bpage) - == BUF_BLOCK_ZIP_DIRTY); + ut_ad(buf_page_get_state(bpage) == BUF_BLOCK_ZIP_DIRTY); func_exit: rw_lock_x_unlock(hash_lock); @@ -1915,10 +1905,8 @@ func_exit: rw_lock_x_lock(hash_lock); mutex_enter(block_mutex); - ut_a(!buf_page_hash_get_low(buf_pool, - bpage->space, - bpage->offset, - fold)); + ut_a(!buf_page_hash_get_low( + buf_pool, b->space, b->offset, fold)); b->state = b->oldest_modification ? BUF_BLOCK_ZIP_DIRTY @@ -2059,11 +2047,12 @@ func_exit: buf_pool->page_hash, thus inaccessible by any other thread. */ - checksum = page_zip_calc_checksum( - b->zip.data, - page_zip_get_size(&b->zip), - static_cast<srv_checksum_algorithm_t>( - srv_checksum_algorithm)); + checksum = static_cast<ib_uint32_t>( + page_zip_calc_checksum( + b->zip.data, + page_zip_get_size(&b->zip), + static_cast<srv_checksum_algorithm_t>( + srv_checksum_algorithm))); mach_write_to_4(b->zip.data + FIL_PAGE_SPACE_OR_CHKSUM, checksum); @@ -2333,6 +2322,11 @@ buf_LRU_block_remove_hashed( UNIV_PAGE_SIZE); buf_page_set_state(bpage, BUF_BLOCK_REMOVE_HASH); + if (buf_pool->flush_rbt == NULL) { + bpage->space = ULINT32_UNDEFINED; + bpage->offset = ULINT32_UNDEFINED; + } + /* Question: If we release bpage and hash mutex here then what protects us against: 1) Some other thread buffer fixing this page diff --git a/storage/innobase/dict/dict0crea.cc b/storage/innobase/dict/dict0crea.cc index eba5417dc76..ff892749d4f 100644 --- a/storage/innobase/dict/dict0crea.cc +++ b/storage/innobase/dict/dict0crea.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1996, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -270,6 +270,12 @@ dict_build_table_def_step( thr_get_trx(thr)->table_id = table->id; + /* Always set this bit for all new created tables */ + DICT_TF2_FLAG_SET(table, DICT_TF2_FTS_AUX_HEX_NAME); + DBUG_EXECUTE_IF("innodb_test_wrong_fts_aux_table_name", + DICT_TF2_FLAG_UNSET(table, + DICT_TF2_FTS_AUX_HEX_NAME);); + if (use_tablespace) { /* This table will not use the system tablespace. Get a new space id. */ diff --git a/storage/innobase/dict/dict0dict.cc b/storage/innobase/dict/dict0dict.cc index 1769807dd6a..86a903d925e 100644 --- a/storage/innobase/dict/dict0dict.cc +++ b/storage/innobase/dict/dict0dict.cc @@ -121,19 +121,6 @@ UNIV_INTERN mysql_pfs_key_t dict_foreign_err_mutex_key; /** Identifies generated InnoDB foreign key names */ static char dict_ibfk[] = "_ibfk_"; -/** array of rw locks protecting -dict_table_t::stat_initialized -dict_table_t::stat_n_rows (*) -dict_table_t::stat_clustered_index_size -dict_table_t::stat_sum_of_other_index_sizes -dict_table_t::stat_modified_counter (*) -dict_table_t::indexes*::stat_n_diff_key_vals[] -dict_table_t::indexes*::stat_index_size -dict_table_t::indexes*::stat_n_leaf_pages -(*) those are not always protected for performance reasons */ -#define DICT_TABLE_STATS_LATCHES_SIZE 64 -static rw_lock_t dict_table_stats_latches[DICT_TABLE_STATS_LATCHES_SIZE]; - /*******************************************************************//** Tries to find column names for the index and sets the col field of the index. @@ -332,32 +319,31 @@ dict_mutex_exit_for_mysql(void) mutex_exit(&(dict_sys->mutex)); } -/** Get the latch that protects the stats of a given table */ -#define GET_TABLE_STATS_LATCH(table) \ - (&dict_table_stats_latches[ut_fold_ull((ib_uint64_t) table) \ - % DICT_TABLE_STATS_LATCHES_SIZE]) - /**********************************************************************//** -Lock the appropriate latch to protect a given table's statistics. -table->id is used to pick the corresponding latch from a global array of -latches. */ +Lock the appropriate latch to protect a given table's statistics. */ UNIV_INTERN void dict_table_stats_lock( /*==================*/ - const dict_table_t* table, /*!< in: table */ - ulint latch_mode) /*!< in: RW_S_LATCH or - RW_X_LATCH */ + dict_table_t* table, /*!< in: table */ + ulint latch_mode) /*!< in: RW_S_LATCH or RW_X_LATCH */ { ut_ad(table != NULL); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); + if (table->stats_latch == NULL) { + /* This is a dummy table object that is private in the current + thread and is not shared between multiple threads, thus we + skip any locking. */ + return; + } + switch (latch_mode) { case RW_S_LATCH: - rw_lock_s_lock(GET_TABLE_STATS_LATCH(table)); + rw_lock_s_lock(table->stats_latch); break; case RW_X_LATCH: - rw_lock_x_lock(GET_TABLE_STATS_LATCH(table)); + rw_lock_x_lock(table->stats_latch); break; case RW_NO_LATCH: /* fall through */ @@ -372,19 +358,26 @@ UNIV_INTERN void dict_table_stats_unlock( /*====================*/ - const dict_table_t* table, /*!< in: table */ - ulint latch_mode) /*!< in: RW_S_LATCH or + dict_table_t* table, /*!< in: table */ + ulint latch_mode) /*!< in: RW_S_LATCH or RW_X_LATCH */ { ut_ad(table != NULL); ut_ad(table->magic_n == DICT_TABLE_MAGIC_N); + if (table->stats_latch == NULL) { + /* This is a dummy table object that is private in the current + thread and is not shared between multiple threads, thus we + skip any locking. */ + return; + } + switch (latch_mode) { case RW_S_LATCH: - rw_lock_s_unlock(GET_TABLE_STATS_LATCH(table)); + rw_lock_s_unlock(table->stats_latch); break; case RW_X_LATCH: - rw_lock_x_unlock(GET_TABLE_STATS_LATCH(table)); + rw_lock_x_unlock(table->stats_latch); break; case RW_NO_LATCH: /* fall through */ @@ -880,8 +873,6 @@ void dict_init(void) /*===========*/ { - int i; - dict_sys = static_cast<dict_sys_t*>(mem_zalloc(sizeof(*dict_sys))); mutex_create(dict_sys_mutex_key, &dict_sys->mutex, SYNC_DICT); @@ -902,11 +893,6 @@ dict_init(void) mutex_create(dict_foreign_err_mutex_key, &dict_foreign_err_mutex, SYNC_NO_ORDER_CHECK); } - - for (i = 0; i < DICT_TABLE_STATS_LATCHES_SIZE; i++) { - rw_lock_create(dict_table_stats_latch_key, - &dict_table_stats_latches[i], SYNC_INDEX_TREE); - } } /**********************************************************************//** @@ -5990,6 +5976,17 @@ dict_table_check_for_dup_indexes( } #endif /* UNIV_DEBUG */ +/** Auxiliary macro used inside dict_table_schema_check(). */ +#define CREATE_TYPES_NAMES() \ + dtype_sql_name((unsigned) req_schema->columns[i].mtype, \ + (unsigned) req_schema->columns[i].prtype_mask, \ + (unsigned) req_schema->columns[i].len, \ + req_type, sizeof(req_type)); \ + dtype_sql_name(table->cols[j].mtype, \ + table->cols[j].prtype, \ + table->cols[j].len, \ + actual_type, sizeof(actual_type)) + /*********************************************************************//** Checks whether a table exists and whether it has the given structure. The table must have the same number of columns with the same names and @@ -6009,6 +6006,8 @@ dict_table_schema_check( size_t errstr_sz) /*!< in: errstr size */ { char buf[MAX_FULL_NAME_LEN]; + char req_type[64]; + char actual_type[64]; dict_table_t* table; ulint i; @@ -6060,9 +6059,6 @@ dict_table_schema_check( for (i = 0; i < req_schema->n_cols; i++) { ulint j; - char req_type[64]; - char actual_type[64]; - /* check if i'th column is the same in both arrays */ if (innobase_strcasecmp(req_schema->columns[i].name, dict_table_get_col_name(table, i)) == 0) { @@ -6104,19 +6100,11 @@ dict_table_schema_check( /* we found a column with the same name on j'th position, compare column types and flags */ - dtype_sql_name(req_schema->columns[i].mtype, - req_schema->columns[i].prtype_mask, - req_schema->columns[i].len, - req_type, sizeof(req_type)); - - dtype_sql_name(table->cols[j].mtype, - table->cols[j].prtype, - table->cols[j].len, - actual_type, sizeof(actual_type)); - /* check length for exact match */ if (req_schema->columns[i].len != table->cols[j].len) { + CREATE_TYPES_NAMES(); + ut_snprintf(errstr, errstr_sz, "Column %s in table %s is %s " "but should be %s (length mismatch).", @@ -6139,6 +6127,8 @@ dict_table_schema_check( !(req_schema->columns[i].mtype == DATA_INT && table->cols[j].mtype == DATA_FIXBINARY)) { + CREATE_TYPES_NAMES(); + ut_snprintf(errstr, errstr_sz, "Column %s in table %s is %s " "but should be %s (type mismatch).", @@ -6156,6 +6146,8 @@ dict_table_schema_check( & req_schema->columns[i].prtype_mask) != req_schema->columns[i].prtype_mask) { + CREATE_TYPES_NAMES(); + ut_snprintf(errstr, errstr_sz, "Column %s in table %s is %s " "but should be %s (flags mismatch).", @@ -6224,9 +6216,8 @@ dict_fs2utf8( db[db_len] = '\0'; strconvert( - &my_charset_filename, db, db_len, - system_charset_info, db_utf8, db_utf8_size, - &errors); + &my_charset_filename, db, db_len, system_charset_info, + db_utf8, static_cast<uint>(db_utf8_size), &errors); /* convert each # to @0023 in table name and store the result in buf */ const char* table = dict_remove_db_name(db_and_table); @@ -6251,8 +6242,8 @@ dict_fs2utf8( errors = 0; strconvert( - &my_charset_filename, buf, (uint) (buf_p - buf), - system_charset_info, table_utf8, table_utf8_size, + &my_charset_filename, buf, (uint) (buf_p - buf), system_charset_info, + table_utf8, static_cast<uint>(table_utf8_size), &errors); if (errors != 0) { @@ -6314,10 +6305,6 @@ dict_close(void) mem_free(dict_sys); dict_sys = NULL; - - for (i = 0; i < DICT_TABLE_STATS_LATCHES_SIZE; i++) { - rw_lock_free(&dict_table_stats_latches[i]); - } } #ifdef UNIV_DEBUG diff --git a/storage/innobase/dict/dict0load.cc b/storage/innobase/dict/dict0load.cc index 81ab765b524..f18859393ee 100644 --- a/storage/innobase/dict/dict0load.cc +++ b/storage/innobase/dict/dict0load.cc @@ -1065,7 +1065,8 @@ loop: bool is_temp = false; bool discarded = false; - ib_uint32_t flags2 = mach_read_from_4(field); + ib_uint32_t flags2 = static_cast<ib_uint32_t>( + mach_read_from_4(field)); /* Check that the tablespace (the .ibd file) really exists; print a warning to the .err log if not. @@ -1092,10 +1093,34 @@ loop: case DICT_CHECK_ALL_LOADED: /* All tablespaces should have been found in fil_load_single_table_tablespaces(). */ - - fil_space_for_table_exists_in_mem( + if (fil_space_for_table_exists_in_mem( space_id, name, TRUE, !(is_temp || discarded), - false, NULL, 0); + false, NULL, 0) + && !(is_temp || discarded)) { + /* If user changes the path of .ibd files in + *.isl files before doing crash recovery , + then this leads to inconsistency in + SYS_DATAFILES system table because the + tables are loaded from the updated path + but the SYS_DATAFILES still points to the + old path.Therefore after crash recovery + update SYS_DATAFILES with the updated path.*/ + ut_ad(space_id); + ut_ad(recv_needed_recovery); + char *dict_path = dict_get_first_path(space_id, + name); + char *remote_path = fil_read_link_file(name); + if(dict_path && remote_path) { + if(strcmp(dict_path,remote_path)) { + dict_update_filepath(space_id, + remote_path); + } + } + if(dict_path) + mem_free(dict_path); + if(remote_path) + mem_free(remote_path); + } break; case DICT_CHECK_SOME_LOADED: diff --git a/storage/innobase/dict/dict0mem.cc b/storage/innobase/dict/dict0mem.cc index 565a46b1832..60daeea3a96 100644 --- a/storage/innobase/dict/dict0mem.cc +++ b/storage/innobase/dict/dict0mem.cc @@ -95,6 +95,10 @@ dict_mem_table_create( ut_d(table->magic_n = DICT_TABLE_MAGIC_N); + table->stats_latch = new rw_lock_t; + rw_lock_create(dict_table_stats_latch_key, table->stats_latch, + SYNC_INDEX_TREE); + #ifndef UNIV_HOTBACKUP table->autoinc_lock = static_cast<ib_lock_t*>( mem_heap_alloc(heap, lock_get_size())); @@ -149,6 +153,10 @@ dict_mem_table_free( #ifndef UNIV_HOTBACKUP mutex_free(&(table->autoinc_mutex)); #endif /* UNIV_HOTBACKUP */ + + rw_lock_free(table->stats_latch); + delete table->stats_latch; + ut_free(table->name); mem_heap_free(table->heap); } diff --git a/storage/innobase/dict/dict0stats.cc b/storage/innobase/dict/dict0stats.cc index 8bf02f9785c..928bdb3f2ef 100644 --- a/storage/innobase/dict/dict0stats.cc +++ b/storage/innobase/dict/dict0stats.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2009, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2009, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -46,6 +46,7 @@ Created Jan 06, 2010 Vasil Dimov #include "ut0rnd.h" /* ut_rnd_interval() */ #include "ut0ut.h" /* ut_format_name(), ut_time() */ +#include <map> #include <vector> /* Sampling algorithm description @{ @@ -143,6 +144,17 @@ data: b,b,b,b,b,b,g,g,j,j,j, x, y then we would store 5,7,10,11,12 in the array. */ typedef std::vector<ib_uint64_t> boundaries_t; +/* This is used to arrange the index based on the index name. +@return true if index_name1 is smaller than index_name2. */ +struct index_cmp +{ + bool operator()(const char* index_name1, const char* index_name2) const { + return(strcmp(index_name1, index_name2) < 0); + } +}; + +typedef std::map<const char*, dict_index_t*, index_cmp> index_map_t; + /*********************************************************************//** Checks whether an index should be ignored in stats manipulations: * stats fetch @@ -266,22 +278,24 @@ dict_stats_persistent_storage_check( return(true); } -/*********************************************************************//** -Executes a given SQL statement using the InnoDB internal SQL parser -in its own transaction and commits it. +/** Executes a given SQL statement using the InnoDB internal SQL parser. This function will free the pinfo object. +@param[in,out] pinfo pinfo to pass to que_eval_sql() must already +have any literals bound to it +@param[in] sql SQL string to execute +@param[in,out] trx in case of NULL the function will allocate and +free the trx object. If it is not NULL then it will be rolled back +only in the case of error, but not freed. @return DB_SUCCESS or error code */ static dberr_t dict_stats_exec_sql( -/*================*/ - pars_info_t* pinfo, /*!< in/out: pinfo to pass to que_eval_sql() - must already have any literals bound to it */ - const char* sql) /*!< in: SQL string to execute */ + pars_info_t* pinfo, + const char* sql, + trx_t* trx) { - trx_t* trx; dberr_t err; - + bool trx_started = false; #ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_EX)); #endif /* UNIV_SYNC_DEBUG */ @@ -292,11 +306,24 @@ dict_stats_exec_sql( return(DB_STATS_DO_NOT_EXIST); } - trx = trx_allocate_for_background(); - trx_start_if_not_started(trx); + if (trx == NULL) { + trx = trx_allocate_for_background(); + trx_start_if_not_started(trx); + trx_started = true; + } err = que_eval_sql(pinfo, sql, FALSE, trx); /* pinfo is freed here */ + DBUG_EXECUTE_IF("stats_index_error", + if (!trx_started) { + err = DB_STATS_DO_NOT_EXIST; + trx->error_state = DB_STATS_DO_NOT_EXIST; + }); + + if (!trx_started && err == DB_SUCCESS) { + return(DB_SUCCESS); + } + if (err == DB_SUCCESS) { trx_commit_for_mysql(trx); } else { @@ -308,7 +335,9 @@ dict_stats_exec_sql( ut_a(trx->error_state == DB_SUCCESS); } - trx_free_for_background(trx); + if (trx_started) { + trx_free_for_background(trx); + } return(err); } @@ -400,6 +429,11 @@ dict_stats_table_clone_create( t->corrupted = table->corrupted; + /* This private object "t" is not shared with other threads, so + we do not need the stats_latch. The lock/unlock routines will do + nothing if stats_latch is NULL. */ + t->stats_latch = NULL; + UT_LIST_INIT(t->indexes); for (index = dict_table_get_first_index(table); @@ -731,7 +765,7 @@ static dict_table_t* dict_stats_snapshot_create( /*=======================*/ - const dict_table_t* table) /*!< in: table whose stats to copy */ + dict_table_t* table) /*!< in: table whose stats to copy */ { mutex_enter(&dict_sys->mutex); @@ -1583,7 +1617,8 @@ dict_stats_analyze_index_for_n_prefix( == !(REC_INFO_MIN_REC_FLAG & rec_get_info_bits( btr_pcur_get_rec(&pcur), page_is_comp(page)))); - last_idx_on_level = boundaries->at(n_diff_for_this_prefix - 1); + last_idx_on_level = boundaries->at( + static_cast<unsigned int>(n_diff_for_this_prefix - 1)); rec_idx = 0; @@ -1595,7 +1630,7 @@ dict_stats_analyze_index_for_n_prefix( for (i = 0; i < n_recs_to_dive_below; i++) { ib_uint64_t left; ib_uint64_t right; - ulint rnd; + ib_uint64_t rnd; ib_uint64_t dive_below_idx; /* there are n_diff_for_this_prefix elements @@ -1636,9 +1671,11 @@ dict_stats_analyze_index_for_n_prefix( /* we do not pass (left, right) because we do not want to ask ut_rnd_interval() to work with too big numbers since ib_uint64_t could be bigger than ulint */ - rnd = ut_rnd_interval(0, (ulint) (right - left)); + rnd = static_cast<ib_uint64_t>( + ut_rnd_interval(0, static_cast<ulint>(right - left))); - dive_below_idx = boundaries->at(left + rnd); + dive_below_idx = boundaries->at( + static_cast<unsigned int>(left + rnd)); #if 0 DEBUG_PRINTF(" %s(): dive below record with index=" @@ -2079,20 +2116,28 @@ dict_stats_update_persistent( } #include "mysql_com.h" -/*********************************************************************//** -Save an individual index's statistic into the persistent statistics +/** Save an individual index's statistic into the persistent statistics storage. +@param[in] index index to be updated +@param[in] last_update timestamp of the stat +@param[in] stat_name name of the stat +@param[in] stat_value value of the stat +@param[in] sample_size n pages sampled or NULL +@param[in] stat_description description of the stat +@param[in,out] trx in case of NULL the function will +allocate and free the trx object. If it is not NULL then it will be +rolled back only in the case of error, but not freed. @return DB_SUCCESS or error code */ static dberr_t dict_stats_save_index_stat( -/*=======================*/ - dict_index_t* index, /*!< in: index */ - lint last_update, /*!< in: timestamp of the stat */ - const char* stat_name, /*!< in: name of the stat */ - ib_uint64_t stat_value, /*!< in: value of the stat */ - ib_uint64_t* sample_size, /*!< in: n pages sampled or NULL */ - const char* stat_description)/*!< in: description of the stat */ + dict_index_t* index, + lint last_update, + const char* stat_name, + ib_uint64_t stat_value, + ib_uint64_t* sample_size, + const char* stat_description, + trx_t* trx) { pars_info_t* pinfo; dberr_t ret; @@ -2131,8 +2176,16 @@ dict_stats_save_index_stat( ret = dict_stats_exec_sql( pinfo, - "PROCEDURE INDEX_STATS_SAVE_INSERT () IS\n" + "PROCEDURE INDEX_STATS_SAVE () IS\n" "BEGIN\n" + + "DELETE FROM \"" INDEX_STATS_NAME "\"\n" + "WHERE\n" + "database_name = :database_name AND\n" + "table_name = :table_name AND\n" + "index_name = :index_name AND\n" + "stat_name = :stat_name;\n" + "INSERT INTO \"" INDEX_STATS_NAME "\"\n" "VALUES\n" "(\n" @@ -2145,48 +2198,7 @@ dict_stats_save_index_stat( ":sample_size,\n" ":stat_description\n" ");\n" - "END;"); - - if (ret == DB_DUPLICATE_KEY) { - - pinfo = pars_info_create(); - pars_info_add_str_literal(pinfo, "database_name", db_utf8); - pars_info_add_str_literal(pinfo, "table_name", table_utf8); - UNIV_MEM_ASSERT_RW_ABORT(index->name, strlen(index->name)); - pars_info_add_str_literal(pinfo, "index_name", index->name); - UNIV_MEM_ASSERT_RW_ABORT(&last_update, 4); - pars_info_add_int4_literal(pinfo, "last_update", last_update); - UNIV_MEM_ASSERT_RW_ABORT(stat_name, strlen(stat_name)); - pars_info_add_str_literal(pinfo, "stat_name", stat_name); - UNIV_MEM_ASSERT_RW_ABORT(&stat_value, 8); - pars_info_add_ull_literal(pinfo, "stat_value", stat_value); - if (sample_size != NULL) { - UNIV_MEM_ASSERT_RW_ABORT(sample_size, 8); - pars_info_add_ull_literal(pinfo, "sample_size", *sample_size); - } else { - pars_info_add_literal(pinfo, "sample_size", NULL, - UNIV_SQL_NULL, DATA_FIXBINARY, 0); - } - UNIV_MEM_ASSERT_RW_ABORT(stat_description, strlen(stat_description)); - pars_info_add_str_literal(pinfo, "stat_description", - stat_description); - - ret = dict_stats_exec_sql( - pinfo, - "PROCEDURE INDEX_STATS_SAVE_UPDATE () IS\n" - "BEGIN\n" - "UPDATE \"" INDEX_STATS_NAME "\" SET\n" - "last_update = :last_update,\n" - "stat_value = :stat_value,\n" - "sample_size = :sample_size,\n" - "stat_description = :stat_description\n" - "WHERE\n" - "database_name = :database_name AND\n" - "table_name = :table_name AND\n" - "index_name = :index_name AND\n" - "stat_name = :stat_name;\n" - "END;"); - } + "END;", trx); if (ret != DB_SUCCESS) { char buf_table[MAX_FULL_NAME_LEN]; @@ -2205,14 +2217,18 @@ dict_stats_save_index_stat( return(ret); } -/*********************************************************************//** -Save the table's statistics into the persistent statistics storage. +/** Save the table's statistics into the persistent statistics storage. +@param[in] table_orig table whose stats to save +@param[in] only_for_index if this is non-NULL, then stats for indexes +that are not equal to it will not be saved, if NULL, then all +indexes' stats are saved @return DB_SUCCESS or error code */ static dberr_t dict_stats_save( /*============*/ - dict_table_t* table_orig) /*!< in: table */ + dict_table_t* table_orig, + const index_id_t* only_for_index) { pars_info_t* pinfo; lint now; @@ -2234,26 +2250,27 @@ dict_stats_save( lint */ now = (lint) ut_time(); -#define PREPARE_PINFO_FOR_TABLE_SAVE(p, t, n) \ - do { \ - pars_info_add_str_literal((p), "database_name", db_utf8); \ - pars_info_add_str_literal((p), "table_name", table_utf8); \ - pars_info_add_int4_literal((p), "last_update", (n)); \ - pars_info_add_ull_literal((p), "n_rows", (t)->stat_n_rows); \ - pars_info_add_ull_literal((p), "clustered_index_size", \ - (t)->stat_clustered_index_size); \ - pars_info_add_ull_literal((p), "sum_of_other_index_sizes", \ - (t)->stat_sum_of_other_index_sizes); \ - } while(false); - pinfo = pars_info_create(); - PREPARE_PINFO_FOR_TABLE_SAVE(pinfo, table, now); + pars_info_add_str_literal(pinfo, "database_name", db_utf8); + pars_info_add_str_literal(pinfo, "table_name", table_utf8); + pars_info_add_int4_literal(pinfo, "last_update", now); + pars_info_add_ull_literal(pinfo, "n_rows", table->stat_n_rows); + pars_info_add_ull_literal(pinfo, "clustered_index_size", + table->stat_clustered_index_size); + pars_info_add_ull_literal(pinfo, "sum_of_other_index_sizes", + table->stat_sum_of_other_index_sizes); ret = dict_stats_exec_sql( pinfo, - "PROCEDURE TABLE_STATS_SAVE_INSERT () IS\n" + "PROCEDURE TABLE_STATS_SAVE () IS\n" "BEGIN\n" + + "DELETE FROM \"" TABLE_STATS_NAME "\"\n" + "WHERE\n" + "database_name = :database_name AND\n" + "table_name = :table_name;\n" + "INSERT INTO \"" TABLE_STATS_NAME "\"\n" "VALUES\n" "(\n" @@ -2264,28 +2281,7 @@ dict_stats_save( ":clustered_index_size,\n" ":sum_of_other_index_sizes\n" ");\n" - "END;"); - - if (ret == DB_DUPLICATE_KEY) { - pinfo = pars_info_create(); - - PREPARE_PINFO_FOR_TABLE_SAVE(pinfo, table, now); - - ret = dict_stats_exec_sql( - pinfo, - "PROCEDURE TABLE_STATS_SAVE_UPDATE () IS\n" - "BEGIN\n" - "UPDATE \"" TABLE_STATS_NAME "\" SET\n" - "last_update = :last_update,\n" - "n_rows = :n_rows,\n" - "clustered_index_size = :clustered_index_size,\n" - "sum_of_other_index_sizes = " - " :sum_of_other_index_sizes\n" - "WHERE\n" - "database_name = :database_name AND\n" - "table_name = :table_name;\n" - "END;"); - } + "END;", NULL); if (ret != DB_SUCCESS) { char buf[MAX_FULL_NAME_LEN]; @@ -2295,39 +2291,56 @@ dict_stats_save( "%s: %s\n", ut_format_name(table->name, TRUE, buf, sizeof(buf)), ut_strerr(ret)); - goto end; + + mutex_exit(&dict_sys->mutex); + rw_lock_x_unlock(&dict_operation_lock); + + dict_stats_snapshot_free(table); + + return(ret); } + trx_t* trx = trx_allocate_for_background(); + trx_start_if_not_started(trx); + dict_index_t* index; + index_map_t indexes; + + /* Below we do all the modifications in innodb_index_stats in a single + transaction for performance reasons. Modifying more than one row in a + single transaction may deadlock with other transactions if they + lock the rows in different order. Other transaction could be for + example when we DROP a table and do + DELETE FROM innodb_index_stats WHERE database_name = '...' + AND table_name = '...'; which will affect more than one row. To + prevent deadlocks we always lock the rows in the same order - the + order of the PK, which is (database_name, table_name, index_name, + stat_name). This is why below we sort the indexes by name and then + for each index, do the mods ordered by stat_name. */ for (index = dict_table_get_first_index(table); index != NULL; index = dict_table_get_next_index(index)) { - if (dict_stats_should_ignore_index(index)) { - continue; - } + indexes[index->name] = index; + } - ut_ad(!dict_index_is_univ(index)); + index_map_t::const_iterator it; - ret = dict_stats_save_index_stat(index, now, "size", - index->stat_index_size, - NULL, - "Number of pages " - "in the index"); - if (ret != DB_SUCCESS) { - goto end; + for (it = indexes.begin(); it != indexes.end(); ++it) { + + index = it->second; + + if (only_for_index != NULL && index->id != *only_for_index) { + continue; } - ret = dict_stats_save_index_stat(index, now, "n_leaf_pages", - index->stat_n_leaf_pages, - NULL, - "Number of leaf pages " - "in the index"); - if (ret != DB_SUCCESS) { - goto end; + if (dict_stats_should_ignore_index(index)) { + continue; } + ut_ad(!dict_index_is_univ(index)); + for (ulint i = 0; i < index->n_uniq; i++) { char stat_name[16]; @@ -2355,15 +2368,37 @@ dict_stats_save( index, now, stat_name, index->stat_n_diff_key_vals[i], &index->stat_n_sample_sizes[i], - stat_description); + stat_description, trx); if (ret != DB_SUCCESS) { goto end; } } + + ret = dict_stats_save_index_stat(index, now, "n_leaf_pages", + index->stat_n_leaf_pages, + NULL, + "Number of leaf pages " + "in the index", trx); + if (ret != DB_SUCCESS) { + goto end; + } + + ret = dict_stats_save_index_stat(index, now, "size", + index->stat_index_size, + NULL, + "Number of pages " + "in the index", trx); + if (ret != DB_SUCCESS) { + goto end; + } } + trx_commit_for_mysql(trx); + end: + trx_free_for_background(trx); + mutex_exit(&dict_sys->mutex); rw_lock_x_unlock(&dict_operation_lock); @@ -2860,7 +2895,7 @@ dict_stats_update_for_index( dict_table_stats_lock(index->table, RW_X_LATCH); dict_stats_analyze_index(index); dict_table_stats_unlock(index->table, RW_X_LATCH); - dict_stats_save(index->table); + dict_stats_save(index->table, &index->id); DBUG_VOID_RETURN; } /* else */ @@ -2955,7 +2990,7 @@ dict_stats_update( return(err); } - err = dict_stats_save(table); + err = dict_stats_save(table, NULL); return(err); } @@ -2988,7 +3023,7 @@ dict_stats_update( if (dict_stats_persistent_storage_check(false)) { - return(dict_stats_save(table)); + return(dict_stats_save(table, NULL)); } return(DB_STATS_DO_NOT_EXIST); @@ -3178,7 +3213,7 @@ dict_stats_drop_index( "database_name = :database_name AND\n" "table_name = :table_name AND\n" "index_name = :index_name;\n" - "END;\n"); + "END;\n", NULL); mutex_exit(&dict_sys->mutex); rw_lock_x_unlock(&dict_operation_lock); @@ -3246,7 +3281,7 @@ dict_stats_delete_from_table_stats( "DELETE FROM \"" TABLE_STATS_NAME "\" WHERE\n" "database_name = :database_name AND\n" "table_name = :table_name;\n" - "END;\n"); + "END;\n", NULL); return(ret); } @@ -3284,7 +3319,7 @@ dict_stats_delete_from_index_stats( "DELETE FROM \"" INDEX_STATS_NAME "\" WHERE\n" "database_name = :database_name AND\n" "table_name = :table_name;\n" - "END;\n"); + "END;\n", NULL); return(ret); } @@ -3407,7 +3442,7 @@ dict_stats_rename_in_table_stats( "WHERE\n" "database_name = :old_dbname_utf8 AND\n" "table_name = :old_tablename_utf8;\n" - "END;\n"); + "END;\n", NULL); return(ret); } @@ -3453,7 +3488,7 @@ dict_stats_rename_in_index_stats( "WHERE\n" "database_name = :old_dbname_utf8 AND\n" "table_name = :old_tablename_utf8;\n" - "END;\n"); + "END;\n", NULL); return(ret); } @@ -3834,7 +3869,7 @@ test_dict_stats_save() index2_stat_n_sample_sizes[2] = TEST_IDX2_N_DIFF3_SAMPLE_SIZE; index2_stat_n_sample_sizes[3] = TEST_IDX2_N_DIFF4_SAMPLE_SIZE; - ret = dict_stats_save(&table); + ret = dict_stats_save(&table, NULL); ut_a(ret == DB_SUCCESS); diff --git a/storage/innobase/fil/fil0fil.cc b/storage/innobase/fil/fil0fil.cc index 11b28d78f21..81fcba47812 100644 --- a/storage/innobase/fil/fil0fil.cc +++ b/storage/innobase/fil/fil0fil.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -2383,27 +2383,21 @@ fil_op_log_parse_or_replay( break; case MLOG_FILE_RENAME: - /* We do the rename based on space id, not old file name; - this should guarantee that after the log replay each .ibd file - has the correct name for the latest log sequence number; the - proof is left as an exercise :) */ - - if (fil_tablespace_exists_in_mem(space_id)) { + /* In order to replay the rename, the following must hold: + * The new name is not already used. + * A tablespace is open in memory with the old name. + * The space ID for that tablepace matches this log entry. + This will prevent unintended renames during recovery. */ + + if (fil_get_space_id_for_table(new_name) == ULINT_UNDEFINED + && space_id == fil_get_space_id_for_table(name)) { /* Create the database directory for the new name, if it does not exist yet */ fil_create_directory_for_tablename(new_name); - /* Rename the table if there is not yet a tablespace - with the same name */ - - if (fil_get_space_id_for_table(new_name) - == ULINT_UNDEFINED) { - /* We do not care about the old name, that - is why we pass NULL as the first argument. */ - if (!fil_rename_tablespace(NULL, space_id, - new_name, NULL)) { - ut_error; - } + if (!fil_rename_tablespace(name, space_id, + new_name, NULL)) { + ut_error; } } @@ -3605,20 +3599,6 @@ fil_report_bad_tablespace( (ulong) expected_id, (ulong) expected_flags); } -struct fsp_open_info { - ibool success; /*!< Has the tablespace been opened? */ - const char* check_msg; /*!< fil_check_first_page() message */ - ibool valid; /*!< Is the tablespace valid? */ - os_file_t file; /*!< File handle */ - char* filepath; /*!< File path to open */ - lsn_t lsn; /*!< Flushed LSN from header page */ - ulint id; /*!< Space ID */ - ulint flags; /*!< Tablespace flags */ -#ifdef UNIV_LOG_ARCHIVE - ulint arch_log_no; /*!< latest archived log file number */ -#endif /* UNIV_LOG_ARCHIVE */ -}; - /********************************************************************//** Tries to open a single-table tablespace and optionally checks that the space id in it is correct. If this does not succeed, print an error message @@ -4021,6 +4001,175 @@ fil_make_ibbackup_old_name( } #endif /* UNIV_HOTBACKUP */ + +/*******************************************************************//** +Determine the space id of the given file descriptor by reading a few +pages from the beginning of the .ibd file. +@return true if space id was successfully identified, or false. */ +static +bool +fil_user_tablespace_find_space_id( +/*==============================*/ + fsp_open_info* fsp) /* in/out: contains file descriptor, which is + used as input. contains space_id, which is + the output */ +{ + bool st; + os_offset_t file_size; + + file_size = os_file_get_size(fsp->file); + + if (file_size == (os_offset_t) -1) { + ib_logf(IB_LOG_LEVEL_ERROR, "Could not get file size: %s", + fsp->filepath); + return(false); + } + + /* Assuming a page size, read the space_id from each page and store it + in a map. Find out which space_id is agreed on by majority of the + pages. Choose that space_id. */ + for (ulint page_size = UNIV_ZIP_SIZE_MIN; + page_size <= UNIV_PAGE_SIZE_MAX; page_size <<= 1) { + + /* map[space_id] = count of pages */ + std::map<ulint, ulint> verify; + + ulint page_count = 64; + ulint valid_pages = 0; + + /* Adjust the number of pages to analyze based on file size */ + while ((page_count * page_size) > file_size) { + --page_count; + } + + ib_logf(IB_LOG_LEVEL_INFO, "Page size:%lu Pages to analyze:" + "%lu", page_size, page_count); + + byte* buf = static_cast<byte*>(ut_malloc(2*page_size)); + byte* page = static_cast<byte*>(ut_align(buf, page_size)); + + for (ulint j = 0; j < page_count; ++j) { + + st = os_file_read(fsp->file, page, (j* page_size), page_size); + + if (!st) { + ib_logf(IB_LOG_LEVEL_INFO, + "READ FAIL: page_no:%lu", j); + continue; + } + + bool uncompressed_ok = false; + + /* For uncompressed pages, the page size must be equal + to UNIV_PAGE_SIZE. */ + if (page_size == UNIV_PAGE_SIZE) { + uncompressed_ok = !buf_page_is_corrupted( + false, page, 0); + } + + bool compressed_ok = !buf_page_is_corrupted( + false, page, page_size); + + if (uncompressed_ok || compressed_ok) { + + ulint space_id = mach_read_from_4(page + + FIL_PAGE_SPACE_ID); + + if (space_id > 0) { + ib_logf(IB_LOG_LEVEL_INFO, + "VALID: space:%lu " + "page_no:%lu page_size:%lu", + space_id, j, page_size); + verify[space_id]++; + ++valid_pages; + } + } + } + + ut_free(buf); + + ib_logf(IB_LOG_LEVEL_INFO, "Page size: %lu, Possible space_id " + "count:%lu", page_size, (ulint) verify.size()); + + const ulint pages_corrupted = 3; + for (ulint missed = 0; missed <= pages_corrupted; ++missed) { + + for (std::map<ulint, ulint>::iterator + m = verify.begin(); m != verify.end(); ++m ) { + + ib_logf(IB_LOG_LEVEL_INFO, "space_id:%lu, " + "Number of pages matched: %lu/%lu " + "(%lu)", m->first, m->second, + valid_pages, page_size); + + if (m->second == (valid_pages - missed)) { + + ib_logf(IB_LOG_LEVEL_INFO, + "Chosen space:%lu\n", m->first); + + fsp->id = m->first; + return(true); + } + } + + } + } + + return(false); +} + +/*******************************************************************//** +Finds the given page_no of the given space id from the double write buffer, +and copies it to the corresponding .ibd file. +@return true if copy was successful, or false. */ +bool +fil_user_tablespace_restore_page( +/*==============================*/ + fsp_open_info* fsp, /* in: contains space id and .ibd + file information */ + ulint page_no) /* in: page_no to obtain from double + write buffer */ +{ + bool err; + ulint flags; + ulint zip_size; + ulint page_size; + ulint buflen; + byte* page; + + ib_logf(IB_LOG_LEVEL_INFO, "Restoring page %lu of tablespace %lu", + page_no, fsp->id); + + // find if double write buffer has page_no of given space id + page = recv_sys->dblwr.find_page(fsp->id, page_no); + + if (!page) { + ib_logf(IB_LOG_LEVEL_WARN, "Doublewrite does not have " + "page_no=%lu of space: %lu", page_no, fsp->id); + err = false; + goto out; + } + + flags = mach_read_from_4(FSP_HEADER_OFFSET + FSP_SPACE_FLAGS + page); + zip_size = fsp_flags_get_zip_size(flags); + page_size = fsp_flags_get_page_size(flags); + + ut_ad(page_no == page_get_page_no(page)); + + buflen = zip_size ? zip_size: page_size; + + ib_logf(IB_LOG_LEVEL_INFO, "Writing %lu bytes into file: %s", + buflen, fsp->filepath); + + err = os_file_write(fsp->filepath, fsp->file, page, + (zip_size ? zip_size : page_size) * page_no, + buflen); + + os_file_flush(fsp->file); +out: + return(err); +} + /********************************************************************//** Opens an .ibd file and adds the associated single-table tablespace to the InnoDB fil0fil.cc data structures. @@ -4032,6 +4181,10 @@ fil_validate_single_table_tablespace( const char* tablename, /*!< in: database/tablename */ fsp_open_info* fsp) /*!< in/out: tablespace info */ { + bool restore_attempted = false; + +check_first_page: + fsp->success = TRUE; if (const char* check_msg = fil_read_first_page( fsp->file, FALSE, &fsp->flags, &fsp->id, #ifdef UNIV_LOG_ARCHIVE @@ -4042,6 +4195,21 @@ fil_validate_single_table_tablespace( "%s in tablespace %s (table %s)", check_msg, fsp->filepath, tablename); fsp->success = FALSE; + } + + if (!fsp->success) { + if (!restore_attempted) { + if (!fil_user_tablespace_find_space_id(fsp)) { + return; + } + restore_attempted = true; + + if (fsp->id > 0 + && !fil_user_tablespace_restore_page(fsp, 0)) { + return; + } + goto check_first_page; + } return; } @@ -4159,7 +4327,7 @@ fil_load_single_table_tablespace( /* Try to open the tablespace in the datadir. */ def.file = os_file_create_simple_no_error_handling( innodb_file_data_key, def.filepath, OS_FILE_OPEN, - OS_FILE_READ_ONLY, &def.success); + OS_FILE_READ_WRITE, &def.success); /* Read the first page of the remote tablespace */ if (def.success) { diff --git a/storage/innobase/fts/fts0ast.cc b/storage/innobase/fts/fts0ast.cc index 3a03fc63303..d6c19c0050a 100644 --- a/storage/innobase/fts/fts0ast.cc +++ b/storage/innobase/fts/fts0ast.cc @@ -112,9 +112,11 @@ fts_ast_create_node_term( if (str.f_n_char > 0) { /* If the subsequent term (after the first one)'s size - is less than fts_min_token_size, we shall ignore - that. This is to make consistent with MyISAM behavior */ - if (first_node && (str.f_n_char < fts_min_token_size)) { + is less than fts_min_token_size or the term is greater + than fts_max_token_size, we shall ignore that. This is + to make consistent with MyISAM behavior */ + if ((first_node && (str.f_n_char < fts_min_token_size)) + || str.f_n_char > fts_max_token_size) { continue; } @@ -394,6 +396,10 @@ fts_ast_term_set_distance( ulint distance) /*!< in: the text proximity distance */ { + if (node == NULL) { + return; + } + ut_a(node->type == FTS_AST_TEXT); ut_a(node->text.distance == ULINT_UNDEFINED); @@ -551,14 +557,6 @@ fts_ast_visit( break; - case FTS_AST_SUBEXP_LIST: - if (visit_pass != FTS_PASS_FIRST) { - break; - } - - error = fts_ast_visit_sub_exp(node, visitor, arg); - break; - case FTS_AST_OPER: oper = node->oper; oper_node = node; diff --git a/storage/innobase/fts/fts0blex.cc b/storage/innobase/fts/fts0blex.cc index dccedac0212..f83523825d2 100644 --- a/storage/innobase/fts/fts0blex.cc +++ b/storage/innobase/fts/fts0blex.cc @@ -35,7 +35,7 @@ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. + * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 @@ -52,7 +52,7 @@ typedef uint32_t flex_uint32_t; typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; +typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; @@ -184,15 +184,15 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 - #define YY_LESS_LINENO(n) - +#define YY_LESS_LINENO(n) + /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = yyg->yy_hold_char; \ YY_RESTORE_YY_MORE_OFFSET \ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ @@ -245,9 +245,9 @@ struct yy_buffer_state */ int yy_at_bol; - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + /* Whether to try to fill the input buffer when we reach the * end of it. */ @@ -305,18 +305,18 @@ YY_BUFFER_STATE fts0b_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner YY_BUFFER_STATE fts0b_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); YY_BUFFER_STATE fts0b_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); -void *fts0balloc (yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); -void *fts0brealloc (void *,yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); -void fts0bfree (void * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +void *fts0balloc (yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +void *fts0brealloc (void *,yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +void fts0bfree (void * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); #define yy_new_buffer fts0b_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - fts0bensure_buffer_stack (yyscanner); \ + fts0bensure_buffer_stack (yyscanner); \ YY_CURRENT_BUFFER_LVALUE = \ - fts0b_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ + fts0b_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } @@ -324,9 +324,9 @@ void fts0bfree (void * , yyscan_t yyscanner __attribute__((unused)) __attri #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - fts0bensure_buffer_stack (yyscanner); \ + fts0bensure_buffer_stack (yyscanner); \ YY_CURRENT_BUFFER_LVALUE = \ - fts0b_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ + fts0b_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } @@ -347,14 +347,14 @@ typedef int yy_state_type; static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); -static void yy_fatal_error (yyconst char msg[] , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +static void yy_fatal_error (yyconst char msg[] , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ yyg->yytext_ptr = yy_bp; \ - yyleng = (size_t) (yy_cp - yy_bp); \ + yyleng = static_cast<int>(yy_cp - yy_bp); \ yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; @@ -499,37 +499,37 @@ this program; if not, write to the Free Software Foundation, Inc., /* Holds the entire state of the reentrant scanner. */ struct yyguts_t - { - - /* User-defined. Not touched by flex. */ - YY_EXTRA_TYPE yyextra_r; - - /* The rest are the same as the globals declared in the non-reentrant scanner. */ - FILE *yyin_r, *yyout_r; - size_t yy_buffer_stack_top; /**< index of top of stack. */ - size_t yy_buffer_stack_max; /**< capacity of stack. */ - YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ - char yy_hold_char; - int yy_n_chars; - int yyleng_r; - char *yy_c_buf_p; - int yy_init; - int yy_start; - int yy_did_buffer_switch_on_eof; - int yy_start_stack_ptr; - int yy_start_stack_depth; - int *yy_start_stack; - yy_state_type yy_last_accepting_state; - char* yy_last_accepting_cpos; - - int yylineno_r; - int yy_flex_debug_r; - - char *yytext_r; - int yy_more_flag; - int yy_more_len; - - }; /* end struct yyguts_t */ +{ + + /* User-defined. Not touched by flex. */ + YY_EXTRA_TYPE yyextra_r; + + /* The rest are the same as the globals declared in the non-reentrant scanner. */ + FILE *yyin_r, *yyout_r; + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ + char yy_hold_char; + int yy_n_chars; + int yyleng_r; + char *yy_c_buf_p; + int yy_init; + int yy_start; + int yy_did_buffer_switch_on_eof; + int yy_start_stack_ptr; + int yy_start_stack_depth; + int *yy_start_stack; + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + int yylineno_r; + int yy_flex_debug_r; + + char *yytext_r; + int yy_more_flag; + int yy_more_len; + +}; /* end struct yyguts_t */ static int yy_init_globals (yyscan_t yyscanner ); @@ -579,11 +579,11 @@ extern int fts0bwrap (yyscan_t yyscanner ); #endif #ifndef yytext_ptr -static void yy_flex_strncpy (char *,yyconst char *,int , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); +static void yy_flex_strncpy (char *,yyconst char *,int , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); +static int yy_flex_strlen (yyconst char * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); #endif #ifndef YY_NO_INPUT @@ -622,8 +622,8 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ - for ( n = 0; n < max_size && \ + int n; \ + for ( n = 0; n < static_cast<int>(max_size) && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ @@ -635,7 +635,8 @@ static int input (yyscan_t yyscanner ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + while ( (result = static_cast<int>(fread(buf, 1, max_size, yyin))) \ + == 0 && ferror(yyin) ) \ { \ if( errno != EINTR) \ { \ @@ -703,12 +704,12 @@ YY_DECL register yy_state_type yy_current_state; register char *yy_cp, *yy_bp; register int yy_act; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; #line 43 "fts0blex.l" -#line 711 "fts0blex.cc" +#line 712 "fts0blex.cc" if ( !yyg->yy_init ) { @@ -839,7 +840,7 @@ YY_RULE_SETUP #line 73 "fts0blex.l" ECHO; YY_BREAK -#line 842 "fts0blex.cc" +#line 843 "fts0blex.cc" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -982,7 +983,7 @@ case YY_STATE_EOF(INITIAL): */ static int yy_get_next_buffer (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; register char *source = yyg->yytext_ptr; register int number_to_move, i; @@ -1027,8 +1028,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + int num_to_read = static_cast<int>( + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1); while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ @@ -1041,7 +1042,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) if ( b->yy_is_our_buffer ) { - int new_size = b->yy_buf_size * 2; + int new_size = static_cast<int>(b->yy_buf_size * 2); if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1062,8 +1063,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; + num_to_read = static_cast<int>( + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1); } @@ -1072,7 +1073,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - yyg->yy_n_chars, (size_t) num_to_read ); + yyg->yy_n_chars, num_to_read); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } @@ -1115,11 +1116,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* yy_get_previous_state - get the state just before the EOB char was reached */ - static yy_state_type yy_get_previous_state (yyscan_t yyscanner) +static yy_state_type yy_get_previous_state (yyscan_t yyscanner) { register yy_state_type yy_current_state; register char *yy_cp; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_current_state = yyg->yy_start; @@ -1148,10 +1149,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner) * synopsis * next_state = yy_try_NUL_trans( current_state ); */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) +static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) { register int yy_is_jam; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ register char *yy_cp = yyg->yy_c_buf_p; register YY_CHAR yy_c = 1; @@ -1174,14 +1175,14 @@ static int yy_get_next_buffer (yyscan_t yyscanner) #ifndef YY_NO_INPUT #ifdef __cplusplus - static int yyinput (yyscan_t yyscanner) + static int yyinput (yyscan_t yyscanner) #else - static int input (yyscan_t yyscanner) + static int input (yyscan_t yyscanner) #endif { int c; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; *yyg->yy_c_buf_p = yyg->yy_hold_char; @@ -1252,14 +1253,14 @@ static int yy_get_next_buffer (yyscan_t yyscanner) * @param yyscanner The scanner object. * @note This function does not reset the start condition to @c INITIAL . */ - void fts0brestart (FILE * input_file , yyscan_t yyscanner) +void fts0brestart (FILE * input_file , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! YY_CURRENT_BUFFER ){ - fts0bensure_buffer_stack (yyscanner); + fts0bensure_buffer_stack (yyscanner); YY_CURRENT_BUFFER_LVALUE = - fts0b_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); + fts0b_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); } fts0b_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); @@ -1270,15 +1271,15 @@ static int yy_get_next_buffer (yyscan_t yyscanner) * @param new_buffer The new input buffer. * @param yyscanner The scanner object. */ - void fts0b_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +void fts0b_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* TODO. We should be able to replace this entire function body * with * fts0bpop_buffer_state(); * fts0bpush_buffer_state(new_buffer); - */ + */ fts0bensure_buffer_stack (yyscanner); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -1304,7 +1305,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) static void fts0b_load_buffer_state (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; @@ -1317,10 +1318,10 @@ static void fts0b_load_buffer_state (yyscan_t yyscanner) * @param yyscanner The scanner object. * @return the allocated buffer state. */ - YY_BUFFER_STATE fts0b_create_buffer (FILE * file, int size , yyscan_t yyscanner) +YY_BUFFER_STATE fts0b_create_buffer (FILE * file, int size , yyscan_t yyscanner) { YY_BUFFER_STATE b; - + b = (YY_BUFFER_STATE) fts0balloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in fts0b_create_buffer()" ); @@ -1345,9 +1346,9 @@ static void fts0b_load_buffer_state (yyscan_t yyscanner) * @param b a buffer created with fts0b_create_buffer() * @param yyscanner The scanner object. */ - void fts0b_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +void fts0b_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return; @@ -1365,28 +1366,28 @@ static void fts0b_load_buffer_state (yyscan_t yyscanner) * This function is sometimes called more than once on the same buffer, * such as during a fts0brestart() or at EOF. */ - static void fts0b_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) +static void fts0b_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) { int oerrno = errno; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; fts0b_flush_buffer(b ,yyscanner); b->yy_input_file = file; b->yy_fill_buffer = 1; - /* If b is the current buffer, then fts0b_init_buffer was _probably_ - * called from fts0brestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = 0; - + /* If b is the current buffer, then fts0b_init_buffer was _probably_ + * called from fts0brestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = 0; + errno = oerrno; } @@ -1394,9 +1395,9 @@ static void fts0b_load_buffer_state (yyscan_t yyscanner) * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * @param yyscanner The scanner object. */ - void fts0b_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +void fts0b_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return; @@ -1426,7 +1427,7 @@ static void fts0b_load_buffer_state (yyscan_t yyscanner) */ void fts0bpush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (new_buffer == NULL) return; @@ -1457,7 +1458,7 @@ void fts0bpush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) */ void fts0bpop_buffer_state (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!YY_CURRENT_BUFFER) return; @@ -1478,23 +1479,23 @@ void fts0bpop_buffer_state (yyscan_t yyscanner) static void fts0bensure_buffer_stack (yyscan_t yyscanner) { int num_to_alloc; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!yyg->yy_buffer_stack) { /* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. - */ + */ num_to_alloc = 1; yyg->yy_buffer_stack = (struct yy_buffer_state**)fts0balloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); if ( ! yyg->yy_buffer_stack ) YY_FATAL_ERROR( "out of dynamic memory in fts0bensure_buffer_stack()" ); - + memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - + yyg->yy_buffer_stack_max = num_to_alloc; yyg->yy_buffer_stack_top = 0; return; @@ -1505,7 +1506,7 @@ static void fts0bensure_buffer_stack (yyscan_t yyscanner) /* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */; - num_to_alloc = yyg->yy_buffer_stack_max + grow_size; + num_to_alloc = static_cast<int>(yyg->yy_buffer_stack_max + grow_size); yyg->yy_buffer_stack = (struct yy_buffer_state**)fts0brealloc (yyg->yy_buffer_stack, num_to_alloc * sizeof(struct yy_buffer_state*) @@ -1523,12 +1524,12 @@ static void fts0bensure_buffer_stack (yyscan_t yyscanner) * @param base the character buffer * @param size the size in bytes of the character buffer * @param yyscanner The scanner object. - * @return the newly allocated buffer state object. + * @return the newly allocated buffer state object. */ YY_BUFFER_STATE fts0b_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) { YY_BUFFER_STATE b; - + if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) @@ -1543,7 +1544,7 @@ YY_BUFFER_STATE fts0b_scan_buffer (char * base, yy_size_t size , yyscan_t yysc b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = 0; - b->yy_n_chars = b->yy_buf_size; + b->yy_n_chars = static_cast<int>(b->yy_buf_size); b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; @@ -1564,8 +1565,7 @@ YY_BUFFER_STATE fts0b_scan_buffer (char * base, yy_size_t size , yyscan_t yysc */ YY_BUFFER_STATE fts0b_scan_string (yyconst char * yystr , yyscan_t yyscanner) { - - return fts0b_scan_bytes(yystr,strlen(yystr) ,yyscanner); + return fts0b_scan_bytes(yystr,static_cast<int>(strlen(yystr)), yyscanner); } /** Setup the input buffer state to scan the given bytes. The next call to fts0blex() will @@ -1581,7 +1581,7 @@ YY_BUFFER_STATE fts0b_scan_bytes (yyconst char * yybytes, int _yybytes_len , y char *buf; yy_size_t n; int i; - + /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; buf = (char *) fts0balloc(n ,yyscanner ); @@ -1609,9 +1609,9 @@ YY_BUFFER_STATE fts0b_scan_bytes (yyconst char * yybytes, int _yybytes_len , y #define YY_EXIT_FAILURE 2 #endif -static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { - (void) fprintf( stderr, "%s\n", msg ); + (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -1622,8 +1622,8 @@ static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner __attri do \ { \ /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = yyg->yy_hold_char; \ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ yyg->yy_hold_char = *yyg->yy_c_buf_p; \ @@ -1639,8 +1639,8 @@ static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner __attri */ YY_EXTRA_TYPE fts0bget_extra (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyextra; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyextra; } /** Get the current line number. @@ -1648,12 +1648,12 @@ YY_EXTRA_TYPE fts0bget_extra (yyscan_t yyscanner) */ int fts0bget_lineno (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if (! YY_CURRENT_BUFFER) - return 0; - - return yylineno; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yylineno; } /** Get the current column number. @@ -1661,12 +1661,12 @@ int fts0bget_lineno (yyscan_t yyscanner) */ int fts0bget_column (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if (! YY_CURRENT_BUFFER) - return 0; - - return yycolumn; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yycolumn; } /** Get the input stream. @@ -1674,8 +1674,8 @@ int fts0bget_column (yyscan_t yyscanner) */ FILE *fts0bget_in (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyin; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyin; } /** Get the output stream. @@ -1683,8 +1683,8 @@ FILE *fts0bget_in (yyscan_t yyscanner) */ FILE *fts0bget_out (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyout; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyout; } /** Get the length of the current token. @@ -1692,8 +1692,8 @@ FILE *fts0bget_out (yyscan_t yyscanner) */ int fts0bget_leng (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyleng; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyleng; } /** Get the current token. @@ -1702,8 +1702,8 @@ int fts0bget_leng (yyscan_t yyscanner) char *fts0bget_text (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yytext; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yytext; } /** Set the user-defined data. This data is never touched by the scanner. @@ -1712,8 +1712,8 @@ char *fts0bget_text (yyscan_t yyscanner) */ void fts0bset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyextra = user_defined ; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyextra = user_defined ; } /** Set the current line number. @@ -1722,13 +1722,13 @@ void fts0bset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) */ void fts0bset_lineno (int line_number , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* lineno is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + yy_fatal_error( "fts0bset_lineno called with no buffer" , yyscanner); - /* lineno is only valid if an input buffer exists. */ - if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "fts0bset_lineno called with no buffer" , yyscanner); - - yylineno = line_number; + yylineno = line_number; } /** Set the current column. @@ -1737,13 +1737,13 @@ void fts0bset_lineno (int line_number , yyscan_t yyscanner) */ void fts0bset_column (int column_no , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - /* column is only valid if an input buffer exists. */ - if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "fts0bset_column called with no buffer" , yyscanner); - - yycolumn = column_no; + /* column is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + yy_fatal_error( "fts0bset_column called with no buffer" , yyscanner); + + yycolumn = column_no; } /** Set the input stream. This does not discard the current @@ -1754,26 +1754,26 @@ void fts0bset_column (int column_no , yyscan_t yyscanner) */ void fts0bset_in (FILE * in_str , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyin = in_str ; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyin = in_str ; } void fts0bset_out (FILE * out_str , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyout = out_str ; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyout = out_str ; } int fts0bget_debug (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yy_flex_debug; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yy_flex_debug; } void fts0bset_debug (int bdebug , yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yy_flex_debug = bdebug ; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yy_flex_debug = bdebug ; } /* Accessor methods for yylval and yylloc */ @@ -1788,22 +1788,22 @@ void fts0bset_debug (int bdebug , yyscan_t yyscanner) int fts0blex_init(yyscan_t* ptr_yy_globals) { - if (ptr_yy_globals == NULL){ - errno = EINVAL; - return 1; - } + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } - *ptr_yy_globals = (yyscan_t) fts0balloc ( sizeof( struct yyguts_t ), NULL ); + *ptr_yy_globals = (yyscan_t) fts0balloc ( sizeof( struct yyguts_t ), NULL ); - if (*ptr_yy_globals == NULL){ - errno = ENOMEM; - return 1; - } + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } - /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ - memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); - return yy_init_globals ( *ptr_yy_globals ); + return yy_init_globals ( *ptr_yy_globals ); } /* fts0blex_init_extra has the same functionality as fts0blex_init, but follows the @@ -1817,70 +1817,70 @@ int fts0blex_init(yyscan_t* ptr_yy_globals) int fts0blex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) { - struct yyguts_t dummy_yyguts; - - fts0bset_extra (yy_user_defined, &dummy_yyguts); - - if (ptr_yy_globals == NULL){ - errno = EINVAL; - return 1; - } - - *ptr_yy_globals = (yyscan_t) fts0balloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); - - if (*ptr_yy_globals == NULL){ - errno = ENOMEM; - return 1; - } - - /* By setting to 0xAA, we expose bugs in - yy_init_globals. Leave at 0x00 for releases. */ - memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); - - fts0bset_extra (yy_user_defined, *ptr_yy_globals); - - return yy_init_globals ( *ptr_yy_globals ); + struct yyguts_t dummy_yyguts; + + fts0bset_extra (yy_user_defined, &dummy_yyguts); + + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) fts0balloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in + yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + fts0bset_extra (yy_user_defined, *ptr_yy_globals); + + return yy_init_globals ( *ptr_yy_globals ); } static int yy_init_globals (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from fts0blex_destroy(), so don't allocate here. - */ - - yyg->yy_buffer_stack = 0; - yyg->yy_buffer_stack_top = 0; - yyg->yy_buffer_stack_max = 0; - yyg->yy_c_buf_p = (char *) 0; - yyg->yy_init = 0; - yyg->yy_start = 0; - - yyg->yy_start_stack_ptr = 0; - yyg->yy_start_stack_depth = 0; - yyg->yy_start_stack = NULL; - -/* Defined in main.c */ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from fts0blex_destroy(), so don't allocate here. + */ + + yyg->yy_buffer_stack = 0; + yyg->yy_buffer_stack_top = 0; + yyg->yy_buffer_stack_max = 0; + yyg->yy_c_buf_p = (char *) 0; + yyg->yy_init = 0; + yyg->yy_start = 0; + + yyg->yy_start_stack_ptr = 0; + yyg->yy_start_stack_depth = 0; + yyg->yy_start_stack = NULL; + + /* Defined in main.c */ #ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; + yyin = stdin; + yyout = stdout; #else - yyin = (FILE *) 0; - yyout = (FILE *) 0; + yyin = (FILE *) 0; + yyout = (FILE *) 0; #endif - /* For future reference: Set errno on error, since we are called by - * fts0blex_init() - */ - return 0; + /* For future reference: Set errno on error, since we are called by + * fts0blex_init() + */ + return 0; } /* fts0blex_destroy is for both reentrant and non-reentrant scanners. */ int fts0blex_destroy (yyscan_t yyscanner) { - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - /* Pop the buffer stack, destroying each element. */ + /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ fts0b_delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); YY_CURRENT_BUFFER_LVALUE = NULL; @@ -1891,18 +1891,18 @@ int fts0blex_destroy (yyscan_t yyscanner) fts0bfree(yyg->yy_buffer_stack ,yyscanner); yyg->yy_buffer_stack = NULL; - /* Destroy the start condition stack. */ - fts0bfree(yyg->yy_start_stack ,yyscanner ); - yyg->yy_start_stack = NULL; + /* Destroy the start condition stack. */ + fts0bfree(yyg->yy_start_stack ,yyscanner ); + yyg->yy_start_stack = NULL; - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * fts0blex() is called, initialization will occur. */ - yy_init_globals( yyscanner); + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * fts0blex() is called, initialization will occur. */ + yy_init_globals( yyscanner); - /* Destroy the main struct (reentrant only). */ - fts0bfree ( yyscanner , yyscanner ); - yyscanner = NULL; - return 0; + /* Destroy the main struct (reentrant only). */ + fts0bfree ( yyscanner , yyscanner ); + yyscanner = NULL; + return 0; } /* @@ -1910,7 +1910,7 @@ int fts0blex_destroy (yyscan_t yyscanner) */ #ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { register int i; for ( i = 0; i < n; ++i ) @@ -1919,7 +1919,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { register int n; for ( n = 0; s[n]; ++n ) @@ -1929,12 +1929,12 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner __attribu } #endif -void *fts0balloc (yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +void *fts0balloc (yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { return (void *) malloc( size ); } -void *fts0brealloc (void * ptr, yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +void *fts0brealloc (void * ptr, yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those @@ -1946,7 +1946,7 @@ void *fts0brealloc (void * ptr, yy_size_t size , yyscan_t yyscanner __at return (void *) realloc( (char *) ptr, size ); } -void fts0bfree (void * ptr , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +void fts0bfree (void * ptr , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { free( (char *) ptr ); /* see fts0brealloc() for (char *) cast */ } @@ -1955,5 +1955,3 @@ void fts0bfree (void * ptr , yyscan_t yyscanner __attribute__((unused)) __ #line 73 "fts0blex.l" - - diff --git a/storage/innobase/fts/fts0config.cc b/storage/innobase/fts/fts0config.cc index c5cf38ca7f9..5b4ae5c39f7 100644 --- a/storage/innobase/fts/fts0config.cc +++ b/storage/innobase/fts/fts0config.cc @@ -151,7 +151,9 @@ fts_config_create_index_param_name( strcpy(name, param); name[len] = '_'; - fts_write_object_id(index->id, name + len + 1); + fts_write_object_id(index->id, name + len + 1, + DICT_TF2_FLAG_IS_SET(index->table, + DICT_TF2_FTS_AUX_HEX_NAME)); return(name); } diff --git a/storage/innobase/fts/fts0fts.cc b/storage/innobase/fts/fts0fts.cc index 41f20c1dbb9..4a667686795 100644 --- a/storage/innobase/fts/fts0fts.cc +++ b/storage/innobase/fts/fts0fts.cc @@ -1608,7 +1608,8 @@ fts_rename_aux_tables( new_name, old_table_name, trx); DBUG_EXECUTE_IF("fts_rename_failure", - err = DB_DEADLOCK;); + err = DB_DEADLOCK; + fts_sql_rollback(trx);); mem_free(old_table_name); @@ -2018,7 +2019,7 @@ fts_create_index_tables_low( fts_table.index_id = index->id; fts_table.table_id = table_id; fts_table.parent = table_name; - fts_table.table = NULL; + fts_table.table = index->table; #ifdef FTS_DOC_STATS_DEBUG char* sql; @@ -4479,7 +4480,7 @@ fts_sync_table( ut_ad(table->fts); - if (table->fts->cache) { + if (!dict_table_is_discarded(table) && table->fts->cache) { err = fts_sync(table->fts->cache->sync); } @@ -4506,15 +4507,11 @@ fts_process_token( fts_string_t str; ulint offset = 0; fts_doc_t* result_doc; - byte buf[FTS_MAX_WORD_LEN + 1]; - - str.f_str = buf; /* Determine where to save the result. */ result_doc = (result) ? result : doc; /* The length of a string in characters is set here only. */ - ret = innobase_mysql_fts_get_token( doc->charset, doc->text.f_str + start_pos, doc->text.f_str + doc->text.f_len, &str, &offset); @@ -4545,6 +4542,7 @@ fts_process_token( (char*) t_str.f_str, t_str.f_len); t_str.f_len = newlen; + t_str.f_str[newlen] = 0; /* Add the word to the document statistics. If the word hasn't been seen before we create a new entry for it. */ @@ -5797,7 +5795,7 @@ fts_is_aux_table_name( my_name[len] = 0; end = my_name + len; - ptr = static_cast<const char*>(memchr(my_name, '/', len)); + ptr = static_cast<const char*>(memchr(my_name, '/', len)); if (ptr != NULL) { /* We will start the match after the '/' */ @@ -5940,6 +5938,374 @@ fts_read_tables( return(TRUE); } +/******************************************************************//** +Callback that sets a hex formatted FTS table's flags2 in +SYS_TABLES. The flags is stored in MIX_LEN column. +@return FALSE if all OK */ +static +ibool +fts_set_hex_format( +/*===============*/ + void* row, /*!< in: sel_node_t* */ + void* user_arg) /*!< in: bool set/unset flag */ +{ + sel_node_t* node = static_cast<sel_node_t*>(row); + dfield_t* dfield = que_node_get_val(node->select_list); + + ut_ad(dtype_get_mtype(dfield_get_type(dfield)) == DATA_INT); + ut_ad(dfield_get_len(dfield) == sizeof(ib_uint32_t)); + /* There should be at most one matching record. So the value + must be the default value. */ + ut_ad(mach_read_from_4(static_cast<byte*>(user_arg)) + == ULINT32_UNDEFINED); + + ulint flags2 = mach_read_from_4( + static_cast<byte*>(dfield_get_data(dfield))); + + flags2 |= DICT_TF2_FTS_AUX_HEX_NAME; + + mach_write_to_4(static_cast<byte*>(user_arg), flags2); + + return(FALSE); +} + +/*****************************************************************//** +Update the DICT_TF2_FTS_AUX_HEX_NAME flag in SYS_TABLES. +@return DB_SUCCESS or error code. */ +UNIV_INTERN +dberr_t +fts_update_hex_format_flag( +/*=======================*/ + trx_t* trx, /*!< in/out: transaction that + covers the update */ + table_id_t table_id, /*!< in: Table for which we want + to set the root table->flags2 */ + bool dict_locked) /*!< in: set to true if the + caller already owns the + dict_sys_t::mutex. */ +{ + pars_info_t* info; + ib_uint32_t flags2; + + static const char sql[] = + "PROCEDURE UPDATE_HEX_FORMAT_FLAG() IS\n" + "DECLARE FUNCTION my_func;\n" + "DECLARE CURSOR c IS\n" + " SELECT MIX_LEN " + " FROM SYS_TABLES " + " WHERE ID = :table_id FOR UPDATE;" + "\n" + "BEGIN\n" + "OPEN c;\n" + "WHILE 1 = 1 LOOP\n" + " FETCH c INTO my_func();\n" + " IF c % NOTFOUND THEN\n" + " EXIT;\n" + " END IF;\n" + "END LOOP;\n" + "UPDATE SYS_TABLES" + " SET MIX_LEN = :flags2" + " WHERE ID = :table_id;\n" + "CLOSE c;\n" + "END;\n"; + + flags2 = ULINT32_UNDEFINED; + + info = pars_info_create(); + + pars_info_add_ull_literal(info, "table_id", table_id); + pars_info_bind_int4_literal(info, "flags2", &flags2); + + pars_info_bind_function( + info, "my_func", fts_set_hex_format, &flags2); + + if (trx_get_dict_operation(trx) == TRX_DICT_OP_NONE) { + trx_set_dict_operation(trx, TRX_DICT_OP_INDEX); + } + + dberr_t err = que_eval_sql(info, sql, !dict_locked, trx); + + ut_a(flags2 != ULINT32_UNDEFINED); + + return (err); +} + +#ifdef _WIN32 + +/*********************************************************************//** +Rename an aux table to HEX format. It's called when "%016llu" is used +to format an object id in table name, which only happens in Windows. */ +static __attribute__((nonnull, warn_unused_result)) +dberr_t +fts_rename_one_aux_table_to_hex_format( +/*===================================*/ + trx_t* trx, /*!< in: transaction */ + const fts_aux_table_t* aux_table, /*!< in: table info */ + const dict_table_t* parent_table) /*!< in: parent table name */ +{ + const char* ptr; + fts_table_t fts_table; + char* new_name; + dberr_t error; + + ptr = strchr(aux_table->name, '/'); + ut_a(ptr != NULL); + ++ptr; + /* Skip "FTS_", table id and underscore */ + for (ulint i = 0; i < 2; ++i) { + ptr = strchr(ptr, '_'); + ut_a(ptr != NULL); + ++ptr; + } + + fts_table.suffix = NULL; + if (aux_table->index_id == 0) { + fts_table.type = FTS_COMMON_TABLE; + + for (ulint i = 0; fts_common_tables[i] != NULL; ++i) { + if (strcmp(ptr, fts_common_tables[i]) == 0) { + fts_table.suffix = fts_common_tables[i]; + break; + } + } + } else { + fts_table.type = FTS_INDEX_TABLE; + + /* Skip index id and underscore */ + ptr = strchr(ptr, '_'); + ut_a(ptr != NULL); + ++ptr; + + for (ulint i = 0; fts_index_selector[i].value; ++i) { + if (strcmp(ptr, fts_get_suffix(i)) == 0) { + fts_table.suffix = fts_get_suffix(i); + break; + } + } + } + + ut_a(fts_table.suffix != NULL); + + fts_table.parent = parent_table->name; + fts_table.table_id = aux_table->parent_id; + fts_table.index_id = aux_table->index_id; + fts_table.table = parent_table; + + new_name = fts_get_table_name(&fts_table); + ut_ad(strcmp(new_name, aux_table->name) != 0); + + if (trx_get_dict_operation(trx) == TRX_DICT_OP_NONE) { + trx_set_dict_operation(trx, TRX_DICT_OP_INDEX); + } + + error = row_rename_table_for_mysql(aux_table->name, new_name, trx, + FALSE); + + if (error != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, + "Failed to rename aux table \'%s\' to " + "new format \'%s\'. ", + aux_table->name, new_name); + } else { + ib_logf(IB_LOG_LEVEL_INFO, + "Renamed aux table \'%s\' to \'%s\'.", + aux_table->name, new_name); + } + + mem_free(new_name); + + return (error); +} + +/**********************************************************************//** +Rename all aux tables of a parent table to HEX format. Also set aux tables' +flags2 and parent table's flags2 with DICT_TF2_FTS_AUX_HEX_NAME. +It's called when "%016llu" is used to format an object id in table name, +which only happens in Windows. +Note the ids in tables are correct but the names are old ambiguous ones. + +This function should make sure that either all the parent table and aux tables +are set DICT_TF2_FTS_AUX_HEX_NAME with flags2 or none of them are set */ +static __attribute__((nonnull, warn_unused_result)) +dberr_t +fts_rename_aux_tables_to_hex_format( +/*================================*/ + trx_t* trx, /*!< in: transaction */ + dict_table_t* parent_table, /*!< in: parent table */ + ib_vector_t* tables) /*!< in: aux tables to rename. */ +{ + dberr_t error; + ulint count; + + ut_ad(!DICT_TF2_FLAG_IS_SET(parent_table, DICT_TF2_FTS_AUX_HEX_NAME)); + ut_ad(!ib_vector_is_empty(tables)); + + error = fts_update_hex_format_flag(trx, parent_table->id, true); + + if (error != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, + "Setting parent table %s to hex format failed.", + parent_table->name); + + fts_sql_rollback(trx); + return (error); + } + + DICT_TF2_FLAG_SET(parent_table, DICT_TF2_FTS_AUX_HEX_NAME); + + for (count = 0; count < ib_vector_size(tables); ++count) { + dict_table_t* table; + fts_aux_table_t* aux_table; + + aux_table = static_cast<fts_aux_table_t*>( + ib_vector_get(tables, count)); + + table = dict_table_open_on_id(aux_table->id, TRUE, + DICT_TABLE_OP_NORMAL); + + ut_ad(table != NULL); + ut_ad(!DICT_TF2_FLAG_IS_SET(table, DICT_TF2_FTS_AUX_HEX_NAME)); + + /* Set HEX_NAME flag here to make sure we can get correct + new table name in following function */ + DICT_TF2_FLAG_SET(table, DICT_TF2_FTS_AUX_HEX_NAME); + error = fts_rename_one_aux_table_to_hex_format(trx, + aux_table, parent_table); + /* We will rollback the trx if the error != DB_SUCCESS, + so setting the flag here is the same with setting it in + row_rename_table_for_mysql */ + DBUG_EXECUTE_IF("rename_aux_table_fail", error = DB_ERROR;); + + if (error != DB_SUCCESS) { + dict_table_close(table, TRUE, FALSE); + + ib_logf(IB_LOG_LEVEL_WARN, + "Failed to rename one aux table %s " + "Will revert all successful rename " + "operations.", aux_table->name); + + fts_sql_rollback(trx); + break; + } + + error = fts_update_hex_format_flag(trx, aux_table->id, true); + dict_table_close(table, TRUE, FALSE); + + if (error != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, + "Setting aux table %s to hex format failed.", + aux_table->name); + + fts_sql_rollback(trx); + break; + } + } + + if (error != DB_SUCCESS) { + ut_ad(count != ib_vector_size(tables)); + /* If rename fails, thr trx would be rolled back, we can't + use it any more, we'll start a new background trx to do + the reverting. */ + ut_a(trx->state == TRX_STATE_NOT_STARTED); + bool not_rename = false; + + /* Try to revert those succesful rename operations + in order to revert the ibd file rename. */ + for (ulint i = 0; i <= count; ++i) { + dict_table_t* table; + fts_aux_table_t* aux_table; + trx_t* trx_bg; + dberr_t err; + + aux_table = static_cast<fts_aux_table_t*>( + ib_vector_get(tables, i)); + + table = dict_table_open_on_id(aux_table->id, TRUE, + DICT_TABLE_OP_NORMAL); + ut_ad(table != NULL); + + if (not_rename) { + DICT_TF2_FLAG_UNSET(table, + DICT_TF2_FTS_AUX_HEX_NAME); + } + + if (!DICT_TF2_FLAG_IS_SET(table, + DICT_TF2_FTS_AUX_HEX_NAME)) { + dict_table_close(table, TRUE, FALSE); + continue; + } + + trx_bg = trx_allocate_for_background(); + trx_bg->op_info = "Revert half done rename"; + trx_bg->dict_operation_lock_mode = RW_X_LATCH; + trx_start_for_ddl(trx_bg, TRX_DICT_OP_TABLE); + + DICT_TF2_FLAG_UNSET(table, DICT_TF2_FTS_AUX_HEX_NAME); + err = row_rename_table_for_mysql(table->name, + aux_table->name, + trx_bg, FALSE); + + trx_bg->dict_operation_lock_mode = 0; + dict_table_close(table, TRUE, FALSE); + + if (err != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, "Failed to revert " + "table %s. Please revert manually.", + table->name); + fts_sql_rollback(trx_bg); + /* Continue to clear aux tables' flags2 */ + not_rename = true; + continue; + } + + fts_sql_commit(trx_bg); + } + + DICT_TF2_FLAG_UNSET(parent_table, DICT_TF2_FTS_AUX_HEX_NAME); + } + + return (error); +} + +/**********************************************************************//** +Convert an id, which is actually a decimal number but was regard as a HEX +from a string, to its real value. */ +static +ib_id_t +fts_fake_hex_to_dec( +/*================*/ + ib_id_t id) /*!< in: number to convert */ +{ + ib_id_t dec_id = 0; + char tmp_id[FTS_AUX_MIN_TABLE_ID_LENGTH]; + int ret; + + ret = sprintf(tmp_id, UINT64PFx, id); + ut_ad(ret == 16); + ret = sscanf(tmp_id, "%016llu", &dec_id); + ut_ad(ret == 1); + + return dec_id; +} + +/*********************************************************************//** +Compare two fts_aux_table_t parent_ids. +@return < 0 if n1 < n2, 0 if n1 == n2, > 0 if n1 > n2 */ +UNIV_INLINE +int +fts_check_aux_table_parent_id_cmp( +/*==============================*/ + const void* p1, /*!< in: id1 */ + const void* p2) /*!< in: id2 */ +{ + const fts_aux_table_t* fa1 = static_cast<const fts_aux_table_t*>(p1); + const fts_aux_table_t* fa2 = static_cast<const fts_aux_table_t*>(p2); + + return static_cast<int>(fa1->parent_id - fa2->parent_id); +} + +#endif /* _WIN32 */ + /**********************************************************************//** Check and drop all orphaned FTS auxiliary tables, those that don't have a parent table or FTS index defined on them. @@ -5951,18 +6317,75 @@ fts_check_and_drop_orphaned_tables( trx_t* trx, /*!< in: transaction */ ib_vector_t* tables) /*!< in: tables to check */ { +#ifdef _WIN32 + mem_heap_t* heap; + ib_vector_t* aux_tables_to_rename; + ib_alloc_t* heap_alloc; + + heap = mem_heap_create(1024); + heap_alloc = ib_heap_allocator_create(heap); + + /* We store all aux tables belonging to the same parent table here, + and rename all these tables in a batch mode. */ + aux_tables_to_rename = ib_vector_create(heap_alloc, + sizeof(fts_aux_table_t), 128); + + /* Sort by parent_id first, in case rename will fail */ + ib_vector_sort(tables, fts_check_aux_table_parent_id_cmp); +#endif /* _WIN32 */ + for (ulint i = 0; i < ib_vector_size(tables); ++i) { - dict_table_t* table; + dict_table_t* parent_table; fts_aux_table_t* aux_table; bool drop = false; +#ifdef _WIN32 + dict_table_t* table; + fts_aux_table_t* next_aux_table = NULL; + ib_id_t orig_parent_id = 0; + bool rename = false; +#endif /* _WIN32 */ aux_table = static_cast<fts_aux_table_t*>( ib_vector_get(tables, i)); +#ifdef _WIN32 table = dict_table_open_on_id( + aux_table->id, TRUE, DICT_TABLE_OP_NORMAL); + orig_parent_id = aux_table->parent_id; + + if (table == NULL || strcmp(table->name, aux_table->name)) { + /* Skip these aux tables, which are common tables + with wrong table ids */ + if (table) { + dict_table_close(table, TRUE, FALSE); + } + + continue; + + } else if (!DICT_TF2_FLAG_IS_SET(table, + DICT_TF2_FTS_AUX_HEX_NAME)) { + + aux_table->parent_id = fts_fake_hex_to_dec( + aux_table->parent_id); + + if (aux_table->index_id != 0) { + aux_table->index_id = fts_fake_hex_to_dec( + aux_table->index_id); + } + + ut_ad(aux_table->id > aux_table->parent_id); + rename = true; + } + + if (table) { + dict_table_close(table, TRUE, FALSE); + } +#endif /* _WIN32 */ + + parent_table = dict_table_open_on_id( aux_table->parent_id, TRUE, DICT_TABLE_OP_NORMAL); - if (table == NULL || table->fts == NULL) { + if (parent_table == NULL || parent_table->fts == NULL) { drop = true; @@ -5971,7 +6394,7 @@ fts_check_and_drop_orphaned_tables( fts_t* fts; drop = true; - fts = table->fts; + fts = parent_table->fts; id = aux_table->index_id; /* Search for the FT index in the table's list. */ @@ -5979,33 +6402,28 @@ fts_check_and_drop_orphaned_tables( j < ib_vector_size(fts->indexes); ++j) { - const dict_index_t* index; + const dict_index_t* index; index = static_cast<const dict_index_t*>( ib_vector_getp_const(fts->indexes, j)); if (index->id == id) { - drop = false; break; } } } - if (table) { - dict_table_close(table, TRUE, FALSE); - } - if (drop) { ib_logf(IB_LOG_LEVEL_WARN, "Parent table of FTS auxiliary table %s not " "found.", aux_table->name); - dberr_t err = fts_drop_table(trx, aux_table->name); + dberr_t err = fts_drop_table(trx, aux_table->name); if (err == DB_FAIL) { - char* path; + char* path; path = fil_make_ibd_name( aux_table->name, false); @@ -6016,7 +6434,120 @@ fts_check_and_drop_orphaned_tables( mem_free(path); } } +#ifdef _WIN32 + if (!drop && rename) { + ib_vector_push(aux_tables_to_rename, aux_table); + } + + if (i + 1 < ib_vector_size(tables)) { + next_aux_table = static_cast<fts_aux_table_t*>( + ib_vector_get(tables, i + 1)); + } + + if ((next_aux_table == NULL + || orig_parent_id != next_aux_table->parent_id) + && !ib_vector_is_empty(aux_tables_to_rename)) { + /* All aux tables of parent table, whose id is + last_parent_id, have been checked, try to rename + them if necessary. We had better use a new background + trx to rename rather than the original trx, in case + any failure would cause a complete rollback. */ + dberr_t err; + trx_t* trx_rename = trx_allocate_for_background(); + trx_rename->op_info = "Rename aux tables to " + "hex format"; + trx_rename->dict_operation_lock_mode = RW_X_LATCH; + trx_start_for_ddl(trx_rename, TRX_DICT_OP_TABLE); + + err = fts_rename_aux_tables_to_hex_format(trx_rename, + parent_table, aux_tables_to_rename); + + trx_rename->dict_operation_lock_mode = 0; + + if (err != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, + "Rollback operations on all " + "aux tables of table %s. " + "Please check why renaming aux tables " + "failed, and restart the server to " + "upgrade again to " + "get the table work.", + parent_table->name); + + fts_sql_rollback(trx_rename); + } else { + fts_sql_commit(trx_rename); + } + + trx_free_for_background(trx_rename); + ib_vector_reset(aux_tables_to_rename); + } +#else /* _WIN32 */ + if (!drop) { + dict_table_t* table; + + table = dict_table_open_on_id( + aux_table->id, TRUE, DICT_TABLE_OP_NORMAL); + if (table != NULL + && strcmp(table->name, aux_table->name)) { + dict_table_close(table, TRUE, FALSE); + table = NULL; + } + + if (table != NULL + && !DICT_TF2_FLAG_IS_SET( + table, + DICT_TF2_FTS_AUX_HEX_NAME)) { + dberr_t err = fts_update_hex_format_flag( + trx, table->id, true); + + if (err != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, + "Setting aux table %s to hex " + "format failed.", table->name); + } else { + DICT_TF2_FLAG_SET(table, + DICT_TF2_FTS_AUX_HEX_NAME); + } + } + + if (table != NULL) { + dict_table_close(table, TRUE, FALSE); + } + + ut_ad(parent_table != NULL); + if (!DICT_TF2_FLAG_IS_SET(parent_table, + DICT_TF2_FTS_AUX_HEX_NAME)) { + dberr_t err = fts_update_hex_format_flag( + trx, parent_table->id, true); + + if (err != DB_SUCCESS) { + ib_logf(IB_LOG_LEVEL_WARN, + "Setting parent table %s of " + "FTS auxiliary %s to hex " + "format failed.", + parent_table->name, + aux_table->name); + } else { + DICT_TF2_FLAG_SET(parent_table, + DICT_TF2_FTS_AUX_HEX_NAME); + } + } + } + +#endif /* _WIN32 */ + + if (parent_table) { + dict_table_close(parent_table, TRUE, FALSE); + } + } + +#ifdef _WIN32 + /* Free the memory allocated at the beginning */ + if (heap != NULL) { + mem_heap_free(heap); } +#endif /* _WIN32 */ } /**********************************************************************//** @@ -6216,7 +6747,7 @@ fts_valid_stopword_table( return(innobase_get_fts_charset( static_cast<int>(col->prtype & DATA_MYSQL_TYPE_MASK), - static_cast<ulint>(dtype_get_charset_coll(col->prtype)))); + static_cast<uint>(dtype_get_charset_coll(col->prtype)))); } /**********************************************************************//** diff --git a/storage/innobase/fts/fts0opt.cc b/storage/innobase/fts/fts0opt.cc index 7cdad522564..a9f3a25530d 100644 --- a/storage/innobase/fts/fts0opt.cc +++ b/storage/innobase/fts/fts0opt.cc @@ -620,7 +620,7 @@ fts_zip_read_word( zip->zp->avail_in = FTS_MAX_WORD_LEN; } else { - zip->zp->avail_in = zip->block_sz; + zip->zp->avail_in = static_cast<uInt>(zip->block_sz); } ++zip->pos; @@ -721,7 +721,7 @@ fts_fetch_index_words( ib_vector_push(zip->blocks, &block); zip->zp->next_out = block; - zip->zp->avail_out = zip->block_sz; + zip->zp->avail_out = static_cast<uInt>(zip->block_sz); } switch (zip->status = deflate(zip->zp, Z_NO_FLUSH)) { @@ -1099,10 +1099,10 @@ fts_optimize_lookup( doc_id_t last_doc_id) /*!< in: doc id to lookup */ { int pos; - int upper = ib_vector_size(doc_ids); + int upper = static_cast<int>(ib_vector_size(doc_ids)); fts_update_t* array = (fts_update_t*) doc_ids->data; - pos = fts_bsearch(array, lower, upper, first_doc_id); + pos = fts_bsearch(array, static_cast<int>(lower), upper, first_doc_id); ut_a(abs(pos) <= upper + 1); @@ -1624,10 +1624,12 @@ fts_optimize_create( optim->fts_common_table.parent = table->name; optim->fts_common_table.table_id = table->id; optim->fts_common_table.type = FTS_COMMON_TABLE; + optim->fts_common_table.table = table; optim->fts_index_table.parent = table->name; optim->fts_index_table.table_id = table->id; optim->fts_index_table.type = FTS_INDEX_TABLE; + optim->fts_index_table.table = table; /* The common prefix for all this parent table's aux tables. */ optim->name_prefix = fts_get_table_name_prefix( diff --git a/storage/innobase/fts/fts0pars.cc b/storage/innobase/fts/fts0pars.cc index a4009106c83..83d465b0988 100644 --- a/storage/innobase/fts/fts0pars.cc +++ b/storage/innobase/fts/fts0pars.cc @@ -1,19 +1,19 @@ /* A Bison parser, made by GNU Bison 2.5. */ /* Bison implementation for Yacc-like parsers in C - + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. - + 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 Foundation, either version 3 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ @@ -26,7 +26,7 @@ special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. - + This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ @@ -467,9 +467,9 @@ static const yytype_int8 yyrhs[] = /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint8 yyrline[] = { - 0, 79, 79, 85, 89, 99, 111, 115, 124, 128, - 132, 136, 141, 147, 152, 159, 165, 169, 173, 177, - 181, 186, 191, 197, 202 + 0, 79, 79, 85, 89, 99, 111, 119, 129, 133, + 137, 141, 146, 152, 157, 164, 170, 174, 178, 182, + 186, 191, 196, 202, 207 }; #endif @@ -1458,7 +1458,7 @@ yyreduce: (yyval.node) = fts_ast_create_node_list(state, (yyvsp[(1) - (2)].node)); if (!(yyval.node)) { - (yyval.node) = fts_ast_create_node_subexp_list(state, (yyvsp[(2) - (2)].node)); + (yyval.node) = (yyvsp[(2) - (2)].node); } else { fts_ast_add_node((yyval.node), (yyvsp[(2) - (2)].node)); } @@ -1471,18 +1471,23 @@ yyreduce: #line 111 "fts0pars.y" { (yyval.node) = (yyvsp[(2) - (3)].node); + + if ((yyval.node)) { + (yyval.node) = fts_ast_create_node_subexp_list(state, (yyval.node)); + } } break; case 7: /* Line 1806 of yacc.c */ -#line 115 "fts0pars.y" +#line 119 "fts0pars.y" { - (yyval.node) = fts_ast_create_node_subexp_list(state, (yyvsp[(1) - (4)].node)); + (yyval.node) = fts_ast_create_node_list(state, (yyvsp[(1) - (4)].node)); if ((yyvsp[(3) - (4)].node)) { - fts_ast_add_node((yyval.node), (yyvsp[(3) - (4)].node)); + fts_ast_add_node((yyval.node), + fts_ast_create_node_subexp_list(state, (yyvsp[(3) - (4)].node))); } } break; @@ -1490,7 +1495,7 @@ yyreduce: case 8: /* Line 1806 of yacc.c */ -#line 124 "fts0pars.y" +#line 129 "fts0pars.y" { (yyval.node) = (yyvsp[(1) - (1)].node); } @@ -1499,7 +1504,7 @@ yyreduce: case 9: /* Line 1806 of yacc.c */ -#line 128 "fts0pars.y" +#line 133 "fts0pars.y" { (yyval.node) = (yyvsp[(1) - (1)].node); } @@ -1508,7 +1513,7 @@ yyreduce: case 10: /* Line 1806 of yacc.c */ -#line 132 "fts0pars.y" +#line 137 "fts0pars.y" { fts_ast_term_set_wildcard((yyvsp[(1) - (2)].node)); } @@ -1517,7 +1522,7 @@ yyreduce: case 11: /* Line 1806 of yacc.c */ -#line 136 "fts0pars.y" +#line 141 "fts0pars.y" { fts_ast_term_set_distance((yyvsp[(1) - (3)].node), strtoul((yyvsp[(3) - (3)].token), NULL, 10)); free((yyvsp[(3) - (3)].token)); @@ -1527,7 +1532,7 @@ yyreduce: case 12: /* Line 1806 of yacc.c */ -#line 141 "fts0pars.y" +#line 146 "fts0pars.y" { (yyval.node) = fts_ast_create_node_list(state, (yyvsp[(1) - (3)].node)); fts_ast_add_node((yyval.node), (yyvsp[(2) - (3)].node)); @@ -1538,7 +1543,7 @@ yyreduce: case 13: /* Line 1806 of yacc.c */ -#line 147 "fts0pars.y" +#line 152 "fts0pars.y" { (yyval.node) = fts_ast_create_node_list(state, (yyvsp[(1) - (2)].node)); fts_ast_add_node((yyval.node), (yyvsp[(2) - (2)].node)); @@ -1548,7 +1553,7 @@ yyreduce: case 14: /* Line 1806 of yacc.c */ -#line 152 "fts0pars.y" +#line 157 "fts0pars.y" { (yyval.node) = fts_ast_create_node_list(state, (yyvsp[(1) - (4)].node)); fts_ast_add_node((yyval.node), (yyvsp[(2) - (4)].node)); @@ -1560,7 +1565,7 @@ yyreduce: case 15: /* Line 1806 of yacc.c */ -#line 159 "fts0pars.y" +#line 164 "fts0pars.y" { (yyval.node) = fts_ast_create_node_list(state, (yyvsp[(1) - (2)].node)); fts_ast_add_node((yyval.node), (yyvsp[(2) - (2)].node)); @@ -1570,7 +1575,7 @@ yyreduce: case 16: /* Line 1806 of yacc.c */ -#line 165 "fts0pars.y" +#line 170 "fts0pars.y" { (yyval.node) = fts_ast_create_node_oper(state, FTS_IGNORE); } @@ -1579,7 +1584,7 @@ yyreduce: case 17: /* Line 1806 of yacc.c */ -#line 169 "fts0pars.y" +#line 174 "fts0pars.y" { (yyval.node) = fts_ast_create_node_oper(state, FTS_EXIST); } @@ -1588,7 +1593,7 @@ yyreduce: case 18: /* Line 1806 of yacc.c */ -#line 173 "fts0pars.y" +#line 178 "fts0pars.y" { (yyval.node) = fts_ast_create_node_oper(state, FTS_NEGATE); } @@ -1597,7 +1602,7 @@ yyreduce: case 19: /* Line 1806 of yacc.c */ -#line 177 "fts0pars.y" +#line 182 "fts0pars.y" { (yyval.node) = fts_ast_create_node_oper(state, FTS_DECR_RATING); } @@ -1606,7 +1611,7 @@ yyreduce: case 20: /* Line 1806 of yacc.c */ -#line 181 "fts0pars.y" +#line 186 "fts0pars.y" { (yyval.node) = fts_ast_create_node_oper(state, FTS_INCR_RATING); } @@ -1615,7 +1620,7 @@ yyreduce: case 21: /* Line 1806 of yacc.c */ -#line 186 "fts0pars.y" +#line 191 "fts0pars.y" { (yyval.node) = fts_ast_create_node_term(state, (yyvsp[(1) - (1)].token)); free((yyvsp[(1) - (1)].token)); @@ -1625,7 +1630,7 @@ yyreduce: case 22: /* Line 1806 of yacc.c */ -#line 191 "fts0pars.y" +#line 196 "fts0pars.y" { (yyval.node) = fts_ast_create_node_term(state, (yyvsp[(1) - (1)].token)); free((yyvsp[(1) - (1)].token)); @@ -1635,7 +1640,7 @@ yyreduce: case 23: /* Line 1806 of yacc.c */ -#line 197 "fts0pars.y" +#line 202 "fts0pars.y" { (yyval.node) = (yyvsp[(2) - (2)].node); } @@ -1644,7 +1649,7 @@ yyreduce: case 24: /* Line 1806 of yacc.c */ -#line 202 "fts0pars.y" +#line 207 "fts0pars.y" { (yyval.node) = fts_ast_create_node_text(state, (yyvsp[(1) - (1)].token)); free((yyvsp[(1) - (1)].token)); @@ -1654,7 +1659,7 @@ yyreduce: /* Line 1806 of yacc.c */ -#line 1658 "fts0pars.cc" +#line 1663 "fts0pars.cc" default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -1885,7 +1890,7 @@ yyreturn: /* Line 2067 of yacc.c */ -#line 207 "fts0pars.y" +#line 212 "fts0pars.y" /******************************************************************** @@ -1914,14 +1919,20 @@ fts_lexer_create( if (boolean_mode) { fts0blex_init(&fts_lexer->yyscanner); - fts0b_scan_bytes((char*) query, query_len, fts_lexer->yyscanner); - fts_lexer->scanner = (fts_scan) fts_blexer; + fts0b_scan_bytes( + reinterpret_cast<const char*>(query), + static_cast<int>(query_len), + fts_lexer->yyscanner); + fts_lexer->scanner = reinterpret_cast<fts_scan>(fts_blexer); /* FIXME: Debugging */ /* fts0bset_debug(1 , fts_lexer->yyscanner); */ } else { fts0tlex_init(&fts_lexer->yyscanner); - fts0t_scan_bytes((char*) query, query_len, fts_lexer->yyscanner); - fts_lexer->scanner = (fts_scan) fts_tlexer; + fts0t_scan_bytes( + reinterpret_cast<const char*>(query), + static_cast<int>(query_len), + fts_lexer->yyscanner); + fts_lexer->scanner = reinterpret_cast<fts_scan>(fts_tlexer); } return(fts_lexer); diff --git a/storage/innobase/fts/fts0pars.y b/storage/innobase/fts/fts0pars.y index 73d71bc87c5..ff22e9a9873 100644 --- a/storage/innobase/fts/fts0pars.y +++ b/storage/innobase/fts/fts0pars.y @@ -101,7 +101,7 @@ expr_lst: /* Empty */ { $$ = fts_ast_create_node_list(state, $1); if (!$$) { - $$ = fts_ast_create_node_subexp_list(state, $2); + $$ = $2; } else { fts_ast_add_node($$, $2); } @@ -110,13 +110,18 @@ expr_lst: /* Empty */ { sub_expr: '(' expr_lst ')' { $$ = $2; + + if ($$) { + $$ = fts_ast_create_node_subexp_list(state, $$); + } } | prefix '(' expr_lst ')' { - $$ = fts_ast_create_node_subexp_list(state, $1); + $$ = fts_ast_create_node_list(state, $1); if ($3) { - fts_ast_add_node($$, $3); + fts_ast_add_node($$, + fts_ast_create_node_subexp_list(state, $3)); } } ; diff --git a/storage/innobase/fts/fts0que.cc b/storage/innobase/fts/fts0que.cc index a70c742da0c..adbf433e608 100644 --- a/storage/innobase/fts/fts0que.cc +++ b/storage/innobase/fts/fts0que.cc @@ -40,18 +40,14 @@ Completed 2011/7/10 Sunny and Jimmy Yang #include "fts0vlc.ic" #endif -#include <string> #include <vector> -#include <map> #define FTS_ELEM(t, n, i, j) (t[(i) * n + (j)]) #define RANK_DOWNGRADE (-1.0F) #define RANK_UPGRADE (1.0F) -/* Maximum number of words supported in a proximity search. -FIXME, this limitation can be removed easily. Need to see -if we want to enforce such limitation */ +/* Maximum number of words supported in a phrase or proximity search. */ #define MAX_PROXIMITY_ITEM 128 /* Memory used by rbt itself for create and node add */ @@ -66,8 +62,7 @@ static const double FTS_NORMALIZE_COEFF = 0.0115F; // FIXME: Need to have a generic iterator that traverses the ilist. -typedef std::map<std::string, ulint> word_map_t; -typedef std::vector<std::string> word_vector_t; +typedef std::vector<fts_string_t> word_vector_t; struct fts_word_freq_t; @@ -92,7 +87,7 @@ struct fts_query_t { fts_ast_node_t* cur_node; /*!< Current tree node */ - word_map_t* word_map; /*!< Matched word map for + ib_rbt_t* word_map; /*!< Matched word map for searching by word*/ word_vector_t* word_vector; /*!< Matched word vector for @@ -186,6 +181,8 @@ struct fts_select_t { the FTS index */ }; +typedef std::vector<ulint> pos_vector_t; + /** structure defines a set of ranges for original documents, each of which has a minimum position and maximum position. Text in such range should contain all words in the proximity search. We will need to count the @@ -195,9 +192,9 @@ struct fts_proximity_t { ulint n_pos; /*!< number of position set, defines a range (min to max) containing all matching words */ - ulint* min_pos; /*!< the minimum position (in bytes) + pos_vector_t min_pos; /*!< the minimum position (in bytes) of the range */ - ulint* max_pos; /*!< the maximum position (in bytes) + pos_vector_t max_pos; /*!< the maximum position (in bytes) of the range */ }; @@ -229,7 +226,7 @@ struct fts_doc_freq_t { /** To determine the word frequency per document. */ struct fts_word_freq_t { - byte* word; /*!< Word for which we need the freq, + fts_string_t word; /*!< Word for which we need the freq, it's allocated on the query heap */ ib_rbt_t* doc_freqs; /*!< RB Tree for storing per document @@ -257,15 +254,14 @@ static dberr_t fts_query_filter_doc_ids( /*=====================*/ - fts_query_t* query, /*!< in: query instance */ - const byte* word, /*!< in: the current word */ - fts_word_freq_t*word_freq, /*!< in/out: word frequency */ - const fts_node_t* - node, /*!< in: current FTS node */ - void* data, /*!< in: doc id ilist */ - ulint len, /*!< in: doc id ilist size */ - ibool calc_doc_count);/*!< in: whether to remember doc - count */ + fts_query_t* query, /*!< in: query instance */ + const fts_string_t* word, /*!< in: the current word */ + fts_word_freq_t* word_freq, /*!< in/out: word frequency */ + const fts_node_t* node, /*!< in: current FTS node */ + void* data, /*!< in: doc id ilist */ + ulint len, /*!< in: doc id ilist size */ + ibool calc_doc_count);/*!< in: whether to remember doc + count */ #if 0 /*****************************************************************//*** @@ -575,27 +571,41 @@ static void fts_ranking_words_add( /*==================*/ - fts_query_t* query, /*!< in: query instance */ - fts_ranking_t* ranking, /*!< in: ranking instance */ - const char* word) /*!< in: term/word to add */ + fts_query_t* query, /*!< in: query instance */ + fts_ranking_t* ranking, /*!< in: ranking instance */ + const fts_string_t* word) /*!< in: term/word to add */ { ulint pos; ulint byte_offset; ulint bit_offset; - word_map_t::iterator it; - - /* Note: we suppose the word map and vector are append-only */ - /* Check if need to add it to word map */ - it = query->word_map->lower_bound(word); - if (it != query->word_map->end() - && !query->word_map->key_comp()(word, it->first)) { - pos = it->second; + ib_rbt_bound_t parent; + + /* Note: we suppose the word map and vector are append-only. */ + ut_ad(query->word_vector->size() == rbt_size(query->word_map)); + + /* We use ib_rbt to simulate a map, f_n_char means position. */ + if (rbt_search(query->word_map, &parent, word) == 0) { + fts_string_t* result_word; + + result_word = rbt_value(fts_string_t, parent.last); + pos = result_word->f_n_char; + ut_ad(pos < rbt_size(query->word_map)); } else { - pos = query->word_map->size(); - query->word_map->insert(it, - std::pair<std::string, ulint>(word, pos)); + /* Add the word to map. */ + fts_string_t new_word; + + pos = rbt_size(query->word_map); + + new_word.f_str = static_cast<byte*>(mem_heap_alloc(query->heap, + word->f_len + 1)); + memcpy(new_word.f_str, word->f_str, word->f_len); + new_word.f_str[word->f_len] = 0; + new_word.f_len = word->f_len; + new_word.f_n_char = pos; - query->word_vector->push_back(word); + rbt_add_node(query->word_map, &parent, &new_word); + ut_ad(rbt_validate(query->word_map)); + query->word_vector->push_back(new_word); } /* Check words len */ @@ -630,7 +640,7 @@ fts_ranking_words_get_next( const fts_query_t* query, /*!< in: query instance */ fts_ranking_t* ranking,/*!< in: ranking instance */ ulint* pos, /*!< in/out: word start pos */ - byte** word) /*!< in/out: term/word to add */ + fts_string_t* word) /*!< in/out: term/word to add */ { bool ret = false; ulint max_pos = ranking->words_len * CHAR_BIT; @@ -651,7 +661,7 @@ fts_ranking_words_get_next( /* Get next word from word vector */ if (ret) { ut_ad(*pos < query->word_vector->size()); - *word = (byte*)query->word_vector->at((size_t)*pos).c_str(); + *word = query->word_vector->at((size_t)*pos); *pos += 1; } @@ -666,23 +676,22 @@ static fts_word_freq_t* fts_query_add_word_freq( /*====================*/ - fts_query_t* query, /*!< in: query instance */ - const byte* word) /*!< in: term/word to add */ + fts_query_t* query, /*!< in: query instance */ + const fts_string_t* word) /*!< in: term/word to add */ { ib_rbt_bound_t parent; /* Lookup the word in our rb tree and add if it doesn't exist. */ if (rbt_search(query->word_freqs, &parent, word) != 0) { fts_word_freq_t word_freq; - ulint len = ut_strlen((char*) word) + 1; memset(&word_freq, 0, sizeof(word_freq)); - word_freq.word = static_cast<byte*>( - mem_heap_alloc(query->heap, len)); - - /* Need to copy the NUL character too. */ - memcpy(word_freq.word, word, len); + word_freq.word.f_str = static_cast<byte*>( + mem_heap_alloc(query->heap, word->f_len + 1)); + memcpy(word_freq.word.f_str, word->f_str, word->f_len); + word_freq.word.f_str[word->f_len] = 0; + word_freq.word.f_len = word->f_len; word_freq.doc_count = 0; @@ -692,7 +701,7 @@ fts_query_add_word_freq( parent.last = rbt_add_node( query->word_freqs, &parent, &word_freq); - query->total_size += len + query->total_size += word->f_len + SIZEOF_RBT_CREATE + SIZEOF_RBT_NODE_ADD + sizeof(fts_word_freq_t); @@ -749,7 +758,7 @@ fts_query_union_doc_id( fts_update_t* array = (fts_update_t*) query->deleted->doc_ids->data; /* Check if the doc id is deleted and it's not already in our set. */ - if (fts_bsearch(array, 0, size, doc_id) < 0 + if (fts_bsearch(array, 0, static_cast<int>(size), doc_id) < 0 && rbt_search(query->doc_ids, &parent, &doc_id) != 0) { fts_ranking_t ranking; @@ -780,7 +789,7 @@ fts_query_remove_doc_id( fts_update_t* array = (fts_update_t*) query->deleted->doc_ids->data; /* Check if the doc id is deleted and it's in our set. */ - if (fts_bsearch(array, 0, size, doc_id) < 0 + if (fts_bsearch(array, 0, static_cast<int>(size), doc_id) < 0 && rbt_search(query->doc_ids, &parent, &doc_id) == 0) { ut_free(rbt_remove_node(query->doc_ids, parent.last)); @@ -810,7 +819,7 @@ fts_query_change_ranking( fts_update_t* array = (fts_update_t*) query->deleted->doc_ids->data; /* Check if the doc id is deleted and it's in our set. */ - if (fts_bsearch(array, 0, size, doc_id) < 0 + if (fts_bsearch(array, 0, static_cast<int>(size), doc_id) < 0 && rbt_search(query->doc_ids, &parent, &doc_id) == 0) { fts_ranking_t* ranking; @@ -856,7 +865,7 @@ fts_query_intersect_doc_id( if it matches 'b' and it's in doc_ids.(multi_exist = true). */ /* Check if the doc id is deleted and it's in our set */ - if (fts_bsearch(array, 0, size, doc_id) < 0) { + if (fts_bsearch(array, 0, static_cast<int>(size), doc_id) < 0) { fts_ranking_t new_ranking; if (rbt_search(query->doc_ids, &parent, &doc_id) != 0) { @@ -956,7 +965,7 @@ fts_query_add_word_to_document( /*===========================*/ fts_query_t* query, /*!< in: query to update */ doc_id_t doc_id, /*!< in: the document to update */ - const byte* word) /*!< in: the token to add */ + const fts_string_t* word) /*!< in: the token to add */ { ib_rbt_bound_t parent; fts_ranking_t* ranking = NULL; @@ -980,7 +989,7 @@ fts_query_add_word_to_document( } if (ranking != NULL) { - fts_ranking_words_add(query, ranking, (char*)word); + fts_ranking_words_add(query, ranking, word); } } @@ -1010,13 +1019,13 @@ fts_query_check_node( fts_word_freq_t*word_freqs; /* The word must exist. */ - ret = rbt_search(query->word_freqs, &parent, token->f_str); + ret = rbt_search(query->word_freqs, &parent, token); ut_a(ret == 0); word_freqs = rbt_value(fts_word_freq_t, parent.last); query->error = fts_query_filter_doc_ids( - query, token->f_str, word_freqs, node, + query, token, word_freqs, node, node->ilist, ilist_size, TRUE); } } @@ -1073,7 +1082,7 @@ fts_cache_find_wildcard( ret = rbt_search(query->word_freqs, &freq_parent, - srch_text.f_str); + &srch_text); ut_a(ret == 0); @@ -1082,7 +1091,7 @@ fts_cache_find_wildcard( freq_parent.last); query->error = fts_query_filter_doc_ids( - query, srch_text.f_str, + query, &srch_text, word_freqs, node, node->ilist, node->ilist_size, TRUE); @@ -1542,7 +1551,7 @@ fts_merge_doc_ids( for (node = rbt_first(doc_ids); node; node = rbt_next(doc_ids, node)) { fts_ranking_t* ranking; ulint pos = 0; - byte* word = NULL; + fts_string_t word; ranking = rbt_value(fts_ranking_t, node); @@ -1557,7 +1566,7 @@ fts_merge_doc_ids( ut_a(ranking->words); while (fts_ranking_words_get_next(query, ranking, &pos, &word)) { fts_query_add_word_to_document(query, ranking->doc_id, - word); + &word); } } @@ -1696,6 +1705,9 @@ fts_proximity_is_word_in_range( { fts_proximity_t* proximity_pos = phrase->proximity_pos; + ut_ad(proximity_pos->n_pos == proximity_pos->min_pos.size()); + ut_ad(proximity_pos->n_pos == proximity_pos->max_pos.size()); + /* Search each matched position pair (with min and max positions) and count the number of words in the range */ for (ulint i = 0; i < proximity_pos->n_pos; i++) { @@ -1913,6 +1925,7 @@ fts_query_fetch_document( if (cur_len != UNIV_SQL_NULL && cur_len != 0) { if (phrase->proximity_pos) { + ut_ad(prev_len + cur_len <= total_len); memcpy(document_text + prev_len, data, cur_len); } else { /* For phrase search */ @@ -1923,17 +1936,18 @@ fts_query_fetch_document( cur_len, prev_len, phrase->heap); } + + /* Document positions are calculated from the beginning + of the first field, need to save the length for each + searched field to adjust the doc position when search + phrases. */ + prev_len += cur_len + 1; } if (phrase->found) { break; } - /* Document positions are calculated from the beginning - of the first field, need to save the length for each - searched field to adjust the doc position when search - phrases. */ - prev_len += cur_len + 1; exp = que_node_get_next(exp); } @@ -2472,8 +2486,7 @@ fts_query_search_phrase( token = static_cast<fts_string_t*>( ib_vector_get(tokens, z)); fts_query_add_word_to_document( - query, match->doc_id, - token->f_str); + query, match->doc_id, token); } } } @@ -2562,7 +2575,7 @@ fts_query_phrase_search( && result_str.f_n_char <= fts_max_token_size) { /* Add the word to the RB tree so that we can calculate it's frequencey within a document. */ - fts_query_add_word_freq(query, token->f_str); + fts_query_add_word_freq(query, token); } else { ib_vector_pop(tokens); } @@ -2580,6 +2593,11 @@ fts_query_phrase_search( } num_token = ib_vector_size(tokens); + if (num_token > MAX_PROXIMITY_ITEM) { + query->error = DB_FTS_TOO_MANY_WORDS_IN_PHRASE; + goto func_exit; + } + ut_ad(ib_vector_size(orig_tokens) >= num_token); /* Ignore empty strings. */ @@ -2605,7 +2623,7 @@ fts_query_phrase_search( heap_alloc, sizeof(fts_match_t), 64); } else { - ut_a(num_token < MAX_PROXIMITY_ITEM); + ut_a(num_token <= MAX_PROXIMITY_ITEM); query->match_array = (ib_vector_t**) mem_heap_alloc( heap, @@ -2687,7 +2705,7 @@ fts_query_phrase_search( } fts_query_add_word_to_document( - query, match->doc_id, token->f_str); + query, match->doc_id, token); } query->oper = oper; goto func_exit; @@ -2837,6 +2855,8 @@ fts_query_visitor( ut_ad(query->intersection == NULL); query->intersection = rbt_create( sizeof(fts_ranking_t), fts_ranking_doc_id_cmp); + + query->total_size += SIZEOF_RBT_CREATE; } /* Set the current proximity distance. */ @@ -2858,10 +2878,12 @@ fts_query_visitor( break; case FTS_AST_TERM: + token.f_str = node->term.ptr; + token.f_len = ut_strlen(reinterpret_cast<char*>(token.f_str)); /* Add the word to our RB tree that will be used to calculate this terms per document frequency. */ - fts_query_add_word_freq(query, node->term.ptr); + fts_query_add_word_freq(query, &token); ptr = fts_query_get_token(node, &token); query->error = fts_query_execute(query, &token); @@ -2871,6 +2893,10 @@ fts_query_visitor( } break; + case FTS_AST_SUBEXP_LIST: + query->error = fts_ast_visit_sub_exp(node, fts_query_visitor, arg); + break; + default: ut_error; } @@ -2905,13 +2931,7 @@ fts_ast_visit_sub_exp( ut_a(node->type == FTS_AST_SUBEXP_LIST); - node = node->list.head; - - if (!node || !node->next) { - return(error); - } - - cur_oper = node->oper; + cur_oper = query->oper; /* Save current result set */ parent_doc_ids = query->doc_ids; @@ -2927,26 +2947,20 @@ fts_ast_visit_sub_exp( query->multi_exist = false; /* Process nodes in current sub-expression and store its result set in query->doc_ids we created above. */ - error = fts_ast_visit(FTS_NONE, node->next, visitor, + error = fts_ast_visit(FTS_NONE, node, visitor, arg, &will_be_ignored); - /* Reinstate parent node state and prepare for merge. */ + /* Reinstate parent node state */ query->multi_exist = multi_exist; query->oper = cur_oper; - subexpr_doc_ids = query->doc_ids; - - /* Restore current result set. */ - query->doc_ids = parent_doc_ids; /* Merge the sub-expression result with the parent result set. */ + subexpr_doc_ids = query->doc_ids; + query->doc_ids = parent_doc_ids; if (error == DB_SUCCESS && !rbt_empty(subexpr_doc_ids)) { error = fts_merge_doc_ids(query, subexpr_doc_ids); } - if (query->oper == FTS_EXIST) { - query->multi_exist = true; - } - /* Free current result set. Result already merged into parent. */ fts_query_free_doc_ids(query, subexpr_doc_ids); @@ -3033,14 +3047,13 @@ static dberr_t fts_query_filter_doc_ids( /*=====================*/ - fts_query_t* query, /*!< in: query instance */ - const byte* word, /*!< in: the current word */ - fts_word_freq_t*word_freq, /*!< in/out: word frequency */ - const fts_node_t* - node, /*!< in: current FTS node */ - void* data, /*!< in: doc id ilist */ - ulint len, /*!< in: doc id ilist size */ - ibool calc_doc_count) /*!< in: whether to remember doc count */ + fts_query_t* query, /*!< in: query instance */ + const fts_string_t* word, /*!< in: the current word */ + fts_word_freq_t* word_freq, /*!< in/out: word frequency */ + const fts_node_t* node, /*!< in: current FTS node */ + void* data, /*!< in: doc id ilist */ + ulint len, /*!< in: doc id ilist size */ + ibool calc_doc_count) /*!< in: whether to remember doc count */ { byte* ptr = static_cast<byte*>(data); doc_id_t doc_id = 0; @@ -3163,13 +3176,15 @@ fts_query_read_node( ib_rbt_bound_t parent; fts_word_freq_t* word_freq; ibool skip = FALSE; - byte term[FTS_MAX_WORD_LEN + 1]; + fts_string_t term; + byte buf[FTS_MAX_WORD_LEN + 1]; dberr_t error = DB_SUCCESS; ut_a(query->cur_node->type == FTS_AST_TERM || query->cur_node->type == FTS_AST_TEXT); memset(&node, 0, sizeof(node)); + term.f_str = buf; /* Need to consider the wildcard search case, the word frequency is created on the search string not the actual word. So we need @@ -3179,15 +3194,18 @@ fts_query_read_node( /* These cast are safe since we only care about the terminating NUL character as an end of string marker. */ - ut_strcpy((char*) term, (char*) query->cur_node->term.ptr); + term.f_len = ut_strlen(reinterpret_cast<char*> + (query->cur_node->term.ptr)); + ut_ad(FTS_MAX_WORD_LEN >= term.f_len); + memcpy(term.f_str, query->cur_node->term.ptr, term.f_len); } else { - /* Need to copy the NUL character too. */ - memcpy(term, word->f_str, word->f_len); - term[word->f_len] = 0; + term.f_len = word->f_len; + ut_ad(FTS_MAX_WORD_LEN >= word->f_len); + memcpy(term.f_str, word->f_str, word->f_len); } /* Lookup the word in our rb tree, it must exist. */ - ret = rbt_search(query->word_freqs, &parent, term); + ret = rbt_search(query->word_freqs, &parent, &term); ut_a(ret == 0); @@ -3239,7 +3257,7 @@ fts_query_read_node( case 4: /* ILIST */ error = fts_query_filter_doc_ids( - query, word_freq->word, word_freq, + query, &word_freq->word, word_freq, &node, data, len, FALSE); break; @@ -3332,7 +3350,7 @@ fts_query_calculate_idf( if (fts_enable_diag_print) { fprintf(stderr,"'%s' -> " UINT64PF "/" UINT64PF " %6.5lf\n", - word_freq->word, + word_freq->word.f_str, query->total_docs, word_freq->doc_count, word_freq->idf); } @@ -3349,12 +3367,12 @@ fts_query_calculate_ranking( fts_ranking_t* ranking) /*!< in: Document to rank */ { ulint pos = 0; - byte* word = NULL; + fts_string_t word; /* At this stage, ranking->rank should not exceed the 1.0 bound */ ut_ad(ranking->rank <= 1.0 && ranking->rank >= -1.0); - ut_ad(query->word_map->size() == query->word_vector->size()); + ut_ad(rbt_size(query->word_map) == query->word_vector->size()); while (fts_ranking_words_get_next(query, ranking, &pos, &word)) { int ret; @@ -3363,8 +3381,7 @@ fts_query_calculate_ranking( fts_doc_freq_t* doc_freq; fts_word_freq_t* word_freq; - ut_ad(word != NULL); - ret = rbt_search(query->word_freqs, &parent, word); + ret = rbt_search(query->word_freqs, &parent, &word); /* It must exist. */ ut_a(ret == 0); @@ -3490,14 +3507,14 @@ fts_query_prepare_result( doc_freq = rbt_value(fts_doc_freq_t, node); /* Don't put deleted docs into result */ - if (fts_bsearch(array, 0, size, doc_freq->doc_id) + if (fts_bsearch(array, 0, static_cast<int>(size), doc_freq->doc_id) >= 0) { continue; } ranking.doc_id = doc_freq->doc_id; - ranking.rank = doc_freq->freq * word_freq->idf - * word_freq->idf; + ranking.rank = static_cast<fts_rank_t>( + doc_freq->freq * word_freq->idf * word_freq->idf); ranking.words = NULL; fts_query_add_ranking(query, result->rankings_by_id, @@ -3620,18 +3637,18 @@ fts_query_free( ut_a(!query->intersection); - if (query->heap) { - mem_heap_free(query->heap); - } - if (query->word_map) { - delete query->word_map; + rbt_free(query->word_map); } if (query->word_vector) { delete query->word_vector; } + if (query->heap) { + mem_heap_free(query->heap); + } + memset(query, 0, sizeof(*query)); } @@ -3820,6 +3837,7 @@ fts_query( query.fts_common_table.type = FTS_COMMON_TABLE; query.fts_common_table.table_id = index->table->id; query.fts_common_table.parent = index->table->name; + query.fts_common_table.table = index->table; charset = fts_index_get_charset(index); @@ -3828,15 +3846,18 @@ fts_query( query.fts_index_table.table_id = index->table->id; query.fts_index_table.parent = index->table->name; query.fts_index_table.charset = charset; + query.fts_index_table.table = index->table; - query.word_map = new word_map_t; + query.word_map = rbt_create_arg_cmp( + sizeof(fts_string_t), innobase_fts_text_cmp, + (void *) charset); query.word_vector = new word_vector_t; query.error = DB_SUCCESS; /* Setup the RB tree that will be used to collect per term statistics. */ query.word_freqs = rbt_create_arg_cmp( - sizeof(fts_word_freq_t), innobase_fts_string_cmp, + sizeof(fts_word_freq_t), innobase_fts_text_cmp, (void*) charset); query.total_size += SIZEOF_RBT_CREATE; @@ -4061,13 +4082,14 @@ fts_print_doc_id( fts_ranking_t* ranking; ranking = rbt_value(fts_ranking_t, node); - fprintf(stderr, "doc_ids info, doc_id: %ld \n", + ib_logf(IB_LOG_LEVEL_INFO, "doc_ids info, doc_id: %ld \n", (ulint) ranking->doc_id); - ulint pos = 0; - byte* value = NULL; - while (fts_ranking_words_get_next(query, ranking, &pos, &value)) { - fprintf(stderr, "doc_ids info, value: %s \n", value); + ulint pos = 0; + fts_string_t word; + + while (fts_ranking_words_get_next(query, ranking, &pos, &word)) { + ib_logf(IB_LOG_LEVEL_INFO, "doc_ids info, value: %s \n", word.f_str); } } } @@ -4123,7 +4145,7 @@ fts_expand_query( fts_ranking_t* ranking; ulint pos; - byte* word; + fts_string_t word; ulint prev_token_size; ulint estimate_size; @@ -4145,22 +4167,17 @@ fts_expand_query( /* Remove words that have already been searched in the first pass */ pos = 0; - word = NULL; while (fts_ranking_words_get_next(query, ranking, &pos, - &word)) { - fts_string_t str; + &word)) { ibool ret; - /* FIXME: We are discarding a const qualifier here. */ - str.f_str = word; - str.f_len = ut_strlen((const char*) str.f_str); - ret = rbt_delete(result_doc.tokens, &str); + ret = rbt_delete(result_doc.tokens, &word); /* The word must exist in the doc we found */ if (!ret) { - fprintf(stderr, " InnoDB: Error: Did not " + ib_logf(IB_LOG_LEVEL_ERROR, "Did not " "find word %s in doc %ld for query " - "expansion search.\n", str.f_str, + "expansion search.\n", word.f_str, (ulint) ranking->doc_id); } } @@ -4185,7 +4202,8 @@ fts_expand_query( fts_token_t* mytoken; mytoken = rbt_value(fts_token_t, token_node); - fts_query_add_word_freq(query, mytoken->text.f_str); + ut_ad(mytoken->text.f_str[mytoken->text.f_len] == 0); + fts_query_add_word_freq(query, &mytoken->text); error = fts_query_union(query, &mytoken->text); if (error != DB_SUCCESS) { @@ -4230,10 +4248,6 @@ fts_phrase_or_proximity_search( ulint j; ulint k = 0; fts_proximity_t qualified_pos; - ulint qualified_pos_buf[MAX_PROXIMITY_ITEM * 2]; - - qualified_pos.min_pos = &qualified_pos_buf[0]; - qualified_pos.max_pos = &qualified_pos_buf[MAX_PROXIMITY_ITEM]; match[0] = static_cast<fts_match_t*>( ib_vector_get(query->match_array[0], i)); @@ -4324,8 +4338,7 @@ fts_phrase_or_proximity_search( token = static_cast<fts_string_t*>( ib_vector_get(tokens, z)); fts_query_add_word_to_document( - query, match[0]->doc_id, - token->f_str); + query, match[0]->doc_id, token); } } } @@ -4366,7 +4379,7 @@ fts_proximity_get_positions( qualified_pos->n_pos = 0; - ut_a(num_match < MAX_PROXIMITY_ITEM); + ut_a(num_match <= MAX_PROXIMITY_ITEM); /* Each word could appear multiple times in a doc. So we need to walk through each word's position list, and find @@ -4421,8 +4434,8 @@ fts_proximity_get_positions( length encoding, record the min_pos and max_pos, we will need to verify the actual number of characters */ - qualified_pos->min_pos[qualified_pos->n_pos] = min_pos; - qualified_pos->max_pos[qualified_pos->n_pos] = max_pos; + qualified_pos->min_pos.push_back(min_pos); + qualified_pos->max_pos.push_back(max_pos); qualified_pos->n_pos++; } @@ -4431,7 +4444,5 @@ fts_proximity_get_positions( idx[min_idx]++; } - ut_ad(qualified_pos->n_pos <= MAX_PROXIMITY_ITEM); - return(qualified_pos->n_pos != 0); } diff --git a/storage/innobase/fts/fts0sql.cc b/storage/innobase/fts/fts0sql.cc index 03c19d93af6..cb8eff3cacc 100644 --- a/storage/innobase/fts/fts0sql.cc +++ b/storage/innobase/fts/fts0sql.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2007, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2007, 2013, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -61,21 +61,28 @@ fts_get_table_id( long */ { int len; + bool hex_name = DICT_TF2_FLAG_IS_SET(fts_table->table, + DICT_TF2_FTS_AUX_HEX_NAME); + + ut_a(fts_table->table != NULL); switch (fts_table->type) { case FTS_COMMON_TABLE: - len = fts_write_object_id(fts_table->table_id, table_id); + len = fts_write_object_id(fts_table->table_id, table_id, + hex_name); break; case FTS_INDEX_TABLE: - len = fts_write_object_id(fts_table->table_id, table_id); + len = fts_write_object_id(fts_table->table_id, table_id, + hex_name); table_id[len] = '_'; ++len; table_id += len; - len += fts_write_object_id(fts_table->index_id, table_id); + len += fts_write_object_id(fts_table->index_id, table_id, + hex_name); break; default: @@ -110,7 +117,7 @@ fts_get_table_name_prefix( if (slash) { /* Print up to and including the separator. */ - dbname_len = (slash - fts_table->parent) + 1; + dbname_len = static_cast<int>(slash - fts_table->parent) + 1; } len = fts_get_table_id(fts_table, table_id); @@ -145,7 +152,8 @@ fts_get_table_name( prefix_name = fts_get_table_name_prefix(fts_table); - name_len = strlen(prefix_name) + 1 + strlen(fts_table->suffix) + 1; + name_len = static_cast<int>( + strlen(prefix_name) + 1 + strlen(fts_table->suffix) + 1); name = static_cast<char*>(mem_alloc(name_len)); @@ -191,7 +199,7 @@ fts_parse_sql( str = ut_str3cat(fts_sql_begin, str_tmp, fts_sql_end); mem_free(str_tmp); - dict_locked = (fts_table && fts_table->table + dict_locked = (fts_table && fts_table->table->fts && (fts_table->table->fts->fts_status & TABLE_DICT_LOCKED)); diff --git a/storage/innobase/fts/fts0tlex.cc b/storage/innobase/fts/fts0tlex.cc index 717ddb8a77e..ef17ab1acf2 100644 --- a/storage/innobase/fts/fts0tlex.cc +++ b/storage/innobase/fts/fts0tlex.cc @@ -35,7 +35,7 @@ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. + * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 @@ -52,7 +52,7 @@ typedef uint32_t flex_uint32_t; typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; +typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; @@ -185,7 +185,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; #define EOB_ACT_LAST_MATCH 2 #define YY_LESS_LINENO(n) - + /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ @@ -247,7 +247,7 @@ struct yy_buffer_state int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ - + /* Whether to try to fill the input buffer when we reach the * end of it. */ @@ -305,9 +305,9 @@ YY_BUFFER_STATE fts0t_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner YY_BUFFER_STATE fts0t_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); YY_BUFFER_STATE fts0t_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); -void *fts0talloc (yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); -void *fts0trealloc (void *,yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); -void fts0tfree (void * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +void *fts0talloc (yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +void *fts0trealloc (void *,yy_size_t , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +void fts0tfree (void * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); #define yy_new_buffer fts0t_create_buffer @@ -347,14 +347,14 @@ typedef int yy_state_type; static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); -static void yy_fatal_error (yyconst char msg[] , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); +static void yy_fatal_error (yyconst char msg[] , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ yyg->yytext_ptr = yy_bp; \ - yyleng = (size_t) (yy_cp - yy_bp); \ + yyleng = static_cast<int>(yy_cp - yy_bp); \ yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; @@ -575,11 +575,11 @@ extern int fts0twrap (yyscan_t yyscanner ); #endif #ifndef yytext_ptr -static void yy_flex_strncpy (char *,yyconst char *,int , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); +static void yy_flex_strncpy (char *,yyconst char *,int , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); +static int yy_flex_strlen (yyconst char * , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))); #endif #ifndef YY_NO_INPUT @@ -618,8 +618,8 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ - for ( n = 0; n < max_size && \ + int n; \ + for ( n = 0; n < static_cast<int>(max_size) && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ @@ -631,7 +631,8 @@ static int input (yyscan_t yyscanner ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + while ( (result = static_cast<int>(fread(buf, 1, max_size, yyin)))==0 \ + && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1019,8 +1020,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + int num_to_read =static_cast<int>( + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1); while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ @@ -1033,7 +1034,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) if ( b->yy_is_our_buffer ) { - int new_size = b->yy_buf_size * 2; + int new_size = static_cast<int>(b->yy_buf_size * 2); if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1054,8 +1055,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; + num_to_read = static_cast<int>( + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1); } @@ -1064,7 +1065,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - yyg->yy_n_chars, (size_t) num_to_read ); + yyg->yy_n_chars, num_to_read); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } @@ -1312,7 +1313,7 @@ static void fts0t_load_buffer_state (yyscan_t yyscanner) YY_BUFFER_STATE fts0t_create_buffer (FILE * file, int size , yyscan_t yyscanner) { YY_BUFFER_STATE b; - + b = (YY_BUFFER_STATE) fts0talloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in fts0t_create_buffer()" ); @@ -1378,7 +1379,7 @@ static void fts0t_load_buffer_state (yyscan_t yyscanner) } b->yy_is_interactive = 0; - + errno = oerrno; } @@ -1484,9 +1485,9 @@ static void fts0tensure_buffer_stack (yyscan_t yyscanner) , yyscanner); if ( ! yyg->yy_buffer_stack ) YY_FATAL_ERROR( "out of dynamic memory in fts0tensure_buffer_stack()" ); - + memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - + yyg->yy_buffer_stack_max = num_to_alloc; yyg->yy_buffer_stack_top = 0; return; @@ -1497,7 +1498,7 @@ static void fts0tensure_buffer_stack (yyscan_t yyscanner) /* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */; - num_to_alloc = yyg->yy_buffer_stack_max + grow_size; + num_to_alloc = static_cast<int>(yyg->yy_buffer_stack_max + grow_size); yyg->yy_buffer_stack = (struct yy_buffer_state**)fts0trealloc (yyg->yy_buffer_stack, num_to_alloc * sizeof(struct yy_buffer_state*) @@ -1515,12 +1516,12 @@ static void fts0tensure_buffer_stack (yyscan_t yyscanner) * @param base the character buffer * @param size the size in bytes of the character buffer * @param yyscanner The scanner object. - * @return the newly allocated buffer state object. + * @return the newly allocated buffer state object. */ YY_BUFFER_STATE fts0t_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) { YY_BUFFER_STATE b; - + if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) @@ -1535,7 +1536,7 @@ YY_BUFFER_STATE fts0t_scan_buffer (char * base, yy_size_t size , yyscan_t yysc b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = 0; - b->yy_n_chars = b->yy_buf_size; + b->yy_n_chars = static_cast<int>(b->yy_buf_size); b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; @@ -1556,8 +1557,8 @@ YY_BUFFER_STATE fts0t_scan_buffer (char * base, yy_size_t size , yyscan_t yysc */ YY_BUFFER_STATE fts0t_scan_string (yyconst char * yystr , yyscan_t yyscanner) { - - return fts0t_scan_bytes(yystr,strlen(yystr) ,yyscanner); + + return fts0t_scan_bytes(yystr,static_cast<int>(strlen(yystr)) ,yyscanner); } /** Setup the input buffer state to scan the given bytes. The next call to fts0tlex() will @@ -1573,7 +1574,7 @@ YY_BUFFER_STATE fts0t_scan_bytes (yyconst char * yybytes, int _yybytes_len , y char *buf; yy_size_t n; int i; - + /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; buf = (char *) fts0talloc(n ,yyscanner ); @@ -1601,7 +1602,7 @@ YY_BUFFER_STATE fts0t_scan_bytes (yyconst char * yybytes, int _yybytes_len , y #define YY_EXIT_FAILURE 2 #endif -static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); @@ -1641,10 +1642,10 @@ YY_EXTRA_TYPE fts0tget_extra (yyscan_t yyscanner) int fts0tget_lineno (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - + if (! YY_CURRENT_BUFFER) return 0; - + return yylineno; } @@ -1654,10 +1655,10 @@ int fts0tget_lineno (yyscan_t yyscanner) int fts0tget_column (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - + if (! YY_CURRENT_BUFFER) return 0; - + return yycolumn; } @@ -1718,8 +1719,8 @@ void fts0tset_lineno (int line_number , yyscan_t yyscanner) /* lineno is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "fts0tset_lineno called with no buffer" , yyscanner); - + yy_fatal_error( "fts0tset_lineno called with no buffer" , yyscanner); + yylineno = line_number; } @@ -1733,8 +1734,8 @@ void fts0tset_column (int column_no , yyscan_t yyscanner) /* column is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "fts0tset_column called with no buffer" , yyscanner); - + yy_fatal_error( "fts0tset_column called with no buffer" , yyscanner); + yycolumn = column_no; } @@ -1817,20 +1818,20 @@ int fts0tlex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) errno = EINVAL; return 1; } - + *ptr_yy_globals = (yyscan_t) fts0talloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); - + if (*ptr_yy_globals == NULL){ errno = ENOMEM; return 1; } - + /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); - + fts0tset_extra (yy_user_defined, *ptr_yy_globals); - + return yy_init_globals ( *ptr_yy_globals ); } @@ -1902,7 +1903,7 @@ int fts0tlex_destroy (yyscan_t yyscanner) */ #ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { register int i; for ( i = 0; i < n; ++i ) @@ -1911,7 +1912,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { register int n; for ( n = 0; s[n]; ++n ) @@ -1921,12 +1922,12 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner __attribu } #endif -void *fts0talloc (yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +void *fts0talloc (yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { return (void *) malloc( size ); } -void *fts0trealloc (void * ptr, yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +void *fts0trealloc (void * ptr, yy_size_t size , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those @@ -1938,7 +1939,7 @@ void *fts0trealloc (void * ptr, yy_size_t size , yyscan_t yyscanner __at return (void *) realloc( (char *) ptr, size ); } -void fts0tfree (void * ptr , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) +void fts0tfree (void * ptr , yyscan_t yyscanner __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused)) __attribute__((unused))) { free( (char *) ptr ); /* see fts0trealloc() for (char *) cast */ } diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc index b6913bd2e94..6d120adf737 100644 --- a/storage/innobase/handler/ha_innodb.cc +++ b/storage/innobase/handler/ha_innodb.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. +Copyright (c) 2000, 2014, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2008, 2009 Google Inc. Copyright (c) 2009, Percona Inc. Copyright (c) 2012, Facebook Inc. @@ -526,6 +526,7 @@ ib_cb_t innodb_api_cb[] = { (ib_cb_t) ib_cursor_open_index_using_name, (ib_cb_t) ib_close_thd, (ib_cb_t) ib_cfg_get_cfg, + (ib_cb_t) ib_cursor_set_memcached_sync, (ib_cb_t) ib_cursor_set_cluster_access, (ib_cb_t) ib_cursor_commit_trx, (ib_cb_t) ib_cfg_trx_level, @@ -799,6 +800,19 @@ innobase_rollback_to_savepoint( void* savepoint); /*!< in: savepoint data */ /*****************************************************************//** +Check whether innodb state allows to safely release MDL locks after +rollback to savepoint. +@return true if it is safe, false if its not safe. */ +static +bool +innobase_rollback_to_savepoint_can_release_mdl( +/*===========================================*/ + handlerton* hton, /*!< in/out: InnoDB handlerton */ + THD* thd); /*!< in: handle to the MySQL thread of + the user whose XA transaction should + be rolled back to savepoint */ + +/*****************************************************************//** Sets a transaction savepoint. @return always 0, that is, always succeeds */ static @@ -1601,6 +1615,8 @@ convert_error_code_to_mysql( return(HA_ERR_TABLESPACE_EXISTS); case DB_IDENTIFIER_TOO_LONG: return(HA_ERR_INTERNAL_ERROR); + case DB_FTS_TOO_MANY_WORDS_IN_PHRASE: + return(HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE); } } @@ -1707,11 +1723,11 @@ innobase_check_identifier_length( CHARSET_INFO *cs = system_charset_info; DBUG_ENTER("innobase_check_identifier_length"); - uint res = cs->cset->well_formed_len(cs, id, id + strlen(id), - NAME_CHAR_LEN, - &well_formed_error); + size_t len = cs->cset->well_formed_len( + cs, id, id + strlen(id), + NAME_CHAR_LEN, &well_formed_error); - if (well_formed_error || res == NAME_CHAR_LEN) { + if (well_formed_error || len == NAME_CHAR_LEN) { my_error(ER_TOO_LONG_IDENT, MYF(0), id); DBUG_RETURN(true); } @@ -2477,7 +2493,7 @@ innobase_query_caching_of_table_permitted( store a result to the query cache or retrieve it */ 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 */ ulonglong *unused) /*!< unused for this engine */ { @@ -2899,6 +2915,8 @@ innobase_init( innobase_hton->close_connection = innobase_close_connection; innobase_hton->savepoint_set = innobase_savepoint; innobase_hton->savepoint_rollback = innobase_rollback_to_savepoint; + innobase_hton->savepoint_rollback_can_release_mdl = + innobase_rollback_to_savepoint_can_release_mdl; innobase_hton->savepoint_release = innobase_release_savepoint; innobase_hton->prepare_ordered= NULL; innobase_hton->commit_ordered= innobase_commit_ordered; @@ -3019,7 +3037,8 @@ innobase_init( internal_innobase_data_file_path); if (ret == FALSE) { sql_print_error( - "InnoDB: syntax error in innodb_data_file_path"); + "InnoDB: syntax error in innodb_data_file_path" + " or size specified is less than 1 megabyte"); mem_free_and_error: srv_free_paths_and_sizes(); my_free(internal_innobase_data_file_path); @@ -3174,8 +3193,8 @@ innobase_change_buffering_inited_ok: } else { /* The user has not set the value. We should set it based on innodb_io_capacity. */ - srv_max_io_capacity = - ut_max(2 * srv_io_capacity, 2000); + srv_max_io_capacity = static_cast<ulong>( + ut_max(2 * srv_io_capacity, 2000)); } } else if (srv_max_io_capacity < srv_io_capacity) { @@ -3420,8 +3439,8 @@ innobase_change_buffering_inited_ok: /* Adjust the innodb_undo_logs config object */ innobase_undo_logs_init_default_max(); - innobase_old_blocks_pct = buf_LRU_old_ratio_update( - innobase_old_blocks_pct, TRUE); + innobase_old_blocks_pct = static_cast<uint>( + buf_LRU_old_ratio_update(innobase_old_blocks_pct, TRUE)); ibuf_max_size_update(innobase_change_buffer_max_size); @@ -4092,6 +4111,38 @@ innobase_rollback_to_savepoint( } /*****************************************************************//** +Check whether innodb state allows to safely release MDL locks after +rollback to savepoint. +When binlog is on, MDL locks acquired after savepoint unit are not +released if there are any locks held in InnoDB. +@return true if it is safe, false if its not safe. */ +static +bool +innobase_rollback_to_savepoint_can_release_mdl( +/*===========================================*/ + handlerton* hton, /*!< in: InnoDB handlerton */ + THD* thd) /*!< in: handle to the MySQL thread + of the user whose transaction should + be rolled back to savepoint */ +{ + trx_t* trx; + + DBUG_ENTER("innobase_rollback_to_savepoint_can_release_mdl"); + DBUG_ASSERT(hton == innodb_hton_ptr); + + trx = check_trx_exists(thd); + ut_ad(trx); + + /* If transaction has not acquired any locks then it is safe + to release MDL after rollback to savepoint */ + if (!(UT_LIST_GET_LEN(trx->lock.trx_locks))) { + DBUG_RETURN(true); + } + + DBUG_RETURN(false); +} + +/*****************************************************************//** Release transaction savepoint name. @return 0 if success, HA_ERR_NO_SAVEPOINT if no savepoint with the given name */ @@ -5356,7 +5407,7 @@ table_opened: /* Find corresponding cluster index key length in MySQL's key_info[] array */ - for (ulint i = 0; i < table->s->keys; i++) { + for (uint i = 0; i < table->s->keys; i++) { dict_index_t* index; index = innobase_get_index(i); if (dict_index_is_clust(index)) { @@ -5818,8 +5869,9 @@ innobase_fts_text_cmp( const fts_string_t* s1 = (const fts_string_t*) p1; const fts_string_t* s2 = (const fts_string_t*) p2; - return(ha_compare_text(charset, s1->f_str, s1->f_len, - s2->f_str, s2->f_len, 0, 0)); + return(ha_compare_text( + charset, s1->f_str, static_cast<uint>(s1->f_len), + s2->f_str, static_cast<uint>(s2->f_len), 0, 0)); } /******************************************************************//** compare two character string case insensitively according to their charset. */ @@ -5840,8 +5892,9 @@ innobase_fts_text_case_cmp( newlen = strlen((const char*) s2->f_str); - return(ha_compare_text(charset, s1->f_str, s1->f_len, - s2->f_str, newlen, 0, 0)); + return(ha_compare_text( + charset, s1->f_str, static_cast<uint>(s1->f_len), + s2->f_str, static_cast<uint>(newlen), 0, 0)); } /******************************************************************//** Get the first character's code position for FTS index partition. */ @@ -5887,30 +5940,15 @@ innobase_fts_text_cmp_prefix( const fts_string_t* s2 = (const fts_string_t*) p2; int result; - result = ha_compare_text(charset, s2->f_str, s2->f_len, - s1->f_str, s1->f_len, 1, 0); + result = ha_compare_text( + charset, s2->f_str, static_cast<uint>(s2->f_len), + s1->f_str, static_cast<uint>(s1->f_len), 1, 0); /* We switched s1, s2 position in ha_compare_text. So we need to negate the result */ return(-result); } -/******************************************************************//** -compare two character string according to their charset. */ -UNIV_INTERN -int -innobase_fts_string_cmp( -/*====================*/ - const void* cs, /*!< in: Character set */ - const void* p1, /*!< in: key */ - const void* p2) /*!< in: node */ -{ - const CHARSET_INFO* charset = (const CHARSET_INFO*) cs; - uchar* s1 = (uchar*) p1; - uchar* s2 = *(uchar**) p2; - return(ha_compare_text(charset, s1, strlen((const char*) s1), - s2, strlen((const char*) s2), 0, 0)); -} /******************************************************************//** Makes all characters in a string lower case. */ UNIV_INTERN @@ -6732,8 +6770,8 @@ build_template_needs_field( return(field); } - if (bitmap_is_set(table->read_set, sql_idx) - || bitmap_is_set(table->write_set, sql_idx)) { + if (bitmap_is_set(table->read_set, static_cast<uint>(sql_idx)) + || bitmap_is_set(table->write_set, static_cast<uint>(sql_idx))) { /* This field is needed in the query */ return(field); @@ -9761,12 +9799,6 @@ ha_innobase::position( } } -/* limit innodb monitor access to users with PROCESS privilege. -See http://bugs.mysql.com/32710 for expl. why we choose PROCESS. */ -#define IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(table_name, thd) \ - (row_is_magic_monitor_table(table_name) \ - && check_global_access(thd, PROCESS_ACL)) - /*****************************************************************//** Check whether there exist a column named as "FTS_DOC_ID", which is reserved for InnoDB FTS Doc ID @@ -9881,16 +9913,6 @@ create_table_def( DBUG_RETURN(ER_TABLE_NAME); } - /* table_name must contain '/'. Later in the code we assert if it - does not */ - if (strcmp(strchr(table_name, '/') + 1, - "innodb_table_monitor") == 0) { - push_warning( - thd, Sql_condition::WARN_LEVEL_WARN, - HA_ERR_WRONG_COMMAND, - DEPRECATED_MSG_INNODB_TABLE_MONITOR); - } - n_cols = form->s->fields; /* Check whether there already exists a FTS_DOC_ID column */ @@ -9989,7 +10011,7 @@ create_table_def( /* we assume in dtype_form_prtype() that this fits in two bytes */ - ut_a(field->type() <= MAX_CHAR_COLL_NUM); + ut_a(static_cast<uint>(field->type()) <= MAX_CHAR_COLL_NUM); col_len = field->pack_length(); /* The MySQL pack length contains 1 or 2 bytes length field @@ -10810,6 +10832,11 @@ index_bad: *flags2 |= DICT_TF2_USE_TABLESPACE; } + /* Set the flags2 when create table or alter tables */ + *flags2 |= DICT_TF2_FTS_AUX_HEX_NAME; + DBUG_EXECUTE_IF("innodb_test_wrong_fts_aux_table_name", + *flags2 &= ~DICT_TF2_FTS_AUX_HEX_NAME;); + DBUG_RETURN(true); } @@ -10901,8 +10928,23 @@ ha_innobase::create( DBUG_RETURN(-1); } - if (IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(norm_name, thd)) { - DBUG_RETURN(HA_ERR_GENERIC); + if (row_is_magic_monitor_table(norm_name)) { + push_warning_printf(thd, + Sql_condition::WARN_LEVEL_WARN, + HA_ERR_WRONG_COMMAND, + "Using the table name %s to enable " + "diagnostic output is deprecated " + "and may be removed in future releases. " + "Use INFORMATION_SCHEMA or " + "PERFORMANCE_SCHEMA tables or " + "SET GLOBAL innodb_status_output=ON.", + dict_remove_db_name(norm_name)); + + /* Limit innodb monitor access to users with PROCESS privilege. + See http://bugs.mysql.com/32710 why we chose PROCESS. */ + if (check_global_access(thd, PROCESS_ACL)) { + DBUG_RETURN(HA_ERR_GENERIC); + } } /* Get the transaction associated with the current thd, or create one @@ -11346,7 +11388,8 @@ ha_innobase::delete_table( if (srv_read_only_mode) { DBUG_RETURN(HA_ERR_TABLE_READONLY); - } else if (IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(norm_name, thd)) { + } else if (row_is_magic_monitor_table(norm_name) + && check_global_access(thd, PROCESS_ACL)) { DBUG_RETURN(HA_ERR_GENERIC); } @@ -11582,17 +11625,7 @@ innobase_rename_table( } } - if (error != DB_SUCCESS) { - if (!srv_read_only_mode) { - FILE* ef = dict_foreign_err_file; - - fputs("InnoDB: Renaming table ", ef); - ut_print_name(ef, trx, TRUE, norm_from); - fputs(" to ", ef); - ut_print_name(ef, trx, TRUE, norm_to); - fputs(" failed!\n", ef); - } - } else { + if (error == DB_SUCCESS) { #ifndef __WIN__ sql_print_warning("Rename partition table %s " "succeeds after converting to lower " @@ -12575,7 +12608,8 @@ ha_innobase::optimize( calls to OPTIMIZE, which is undesirable. */ if (innodb_optimize_fulltext_only) { - if (prebuilt->table->fts && prebuilt->table->fts->cache) { + if (prebuilt->table->fts && prebuilt->table->fts->cache + && !dict_table_is_discarded(prebuilt->table)) { fts_sync_table(prebuilt->table); fts_optimize_table(prebuilt->table); } @@ -13002,12 +13036,14 @@ get_foreign_key_info( tmp_buff[len] = 0; len = filename_to_tablename(tmp_buff, name_buff, sizeof(name_buff)); - f_key_info.referenced_db = thd_make_lex_string(thd, 0, name_buff, len, 1); + f_key_info.referenced_db = thd_make_lex_string( + thd, 0, name_buff, static_cast<unsigned int>(len), 1); /* Referenced (parent) table name */ ptr = dict_remove_db_name(foreign->referenced_table_name); len = filename_to_tablename(ptr, name_buff, sizeof(name_buff)); - f_key_info.referenced_table = thd_make_lex_string(thd, 0, name_buff, len, 1); + f_key_info.referenced_table = thd_make_lex_string( + thd, 0, name_buff, static_cast<unsigned int>(len), 1); /* Dependent (child) database name */ len = dict_get_db_name_len(foreign->foreign_table_name); @@ -13016,12 +13052,14 @@ get_foreign_key_info( tmp_buff[len] = 0; len = filename_to_tablename(tmp_buff, name_buff, sizeof(name_buff)); - f_key_info.foreign_db = thd_make_lex_string(thd, 0, name_buff, len, 1); + f_key_info.foreign_db = thd_make_lex_string( + thd, 0, name_buff, static_cast<unsigned int>(len), 1); /* Dependent (child) table name */ ptr = dict_remove_db_name(foreign->foreign_table_name); len = filename_to_tablename(ptr, name_buff, sizeof(name_buff)); - f_key_info.foreign_table = thd_make_lex_string(thd, 0, name_buff, len, 1); + f_key_info.foreign_table = thd_make_lex_string( + thd, 0, name_buff, static_cast<unsigned int>(len), 1); do { ptr = foreign->foreign_col_names[i]; @@ -13048,9 +13086,9 @@ get_foreign_key_info( ptr = "RESTRICT"; } - f_key_info.delete_method = thd_make_lex_string(thd, - f_key_info.delete_method, - ptr, len, 1); + f_key_info.delete_method = thd_make_lex_string( + thd, f_key_info.delete_method, ptr, + static_cast<unsigned int>(len), 1); if (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE) { len = 7; @@ -13066,9 +13104,9 @@ get_foreign_key_info( ptr = "RESTRICT"; } - f_key_info.update_method = thd_make_lex_string(thd, - f_key_info.update_method, - ptr, len, 1); + f_key_info.update_method = thd_make_lex_string( + thd, f_key_info.update_method, ptr, + static_cast<unsigned int>(len), 1); if (foreign->referenced_index && foreign->referenced_index->name) { referenced_key_name = thd_make_lex_string(thd, @@ -13850,7 +13888,8 @@ innodb_show_status( memcpy(str + len, truncated_msg, sizeof truncated_msg - 1); len += sizeof truncated_msg - 1; usable_len = (MAX_STATUS_SIZE - 1) - len; - fseek(srv_monitor_file, flen - usable_len, SEEK_SET); + fseek(srv_monitor_file, + static_cast<long>(flen - usable_len), SEEK_SET); len += fread(str + len, 1, usable_len, srv_monitor_file); flen = len; } else { @@ -13860,9 +13899,10 @@ innodb_show_status( mutex_exit(&srv_monitor_file_mutex); - ret_val= stat_print(thd, innobase_hton_name, - (uint) strlen(innobase_hton_name), - STRING_WITH_LEN(""), str, flen); + ret_val= stat_print( + thd, innobase_hton_name, + static_cast<uint>(strlen(innobase_hton_name)), + STRING_WITH_LEN(""), str, static_cast<uint>(flen)); my_free(str); @@ -13969,11 +14009,13 @@ innodb_mutex_show_status( continue; } - buf1len = my_snprintf(buf1, sizeof buf1, "%s:%lu", - innobase_basename(lock->cfile_name), - (ulong) lock->cline); - buf2len = my_snprintf(buf2, sizeof buf2, "os_waits=%lu", - (ulong) lock->count_os_wait); + buf1len = (uint) my_snprintf( + buf1, sizeof buf1, "%s:%lu", + innobase_basename(lock->cfile_name), + static_cast<ulong>(lock->cline)); + buf2len = (uint) my_snprintf( + buf2, sizeof buf2, "os_waits=%lu", + static_cast<ulong>(lock->count_os_wait)); if (stat_print(thd, innobase_hton_name, hton_name_len, buf1, buf1len, @@ -14004,7 +14046,7 @@ innodb_mutex_show_status( mutex_exit(&rw_lock_list_mutex); #ifdef UNIV_DEBUG - buf2len = my_snprintf(buf2, sizeof buf2, + buf2len = static_cast<uint>(my_snprintf(buf2, sizeof buf2, "count=%lu, spin_waits=%lu, spin_rounds=%lu, " "os_waits=%lu, os_yields=%lu, os_wait_times=%lu", (ulong) rw_lock_count, @@ -14012,7 +14054,7 @@ innodb_mutex_show_status( (ulong) rw_lock_count_spin_rounds, (ulong) rw_lock_count_os_wait, (ulong) rw_lock_count_os_yield, - (ulong) (rw_lock_wait_time / 1000)); + (ulong) (rw_lock_wait_time / 1000))); if (stat_print(thd, innobase_hton_name, hton_name_len, STRING_WITH_LEN("rw_lock_mutexes"), buf2, buf2len)) { @@ -14544,6 +14586,21 @@ ha_innobase::get_auto_increment( current = *first_value; + /* If the increment step of the auto increment column + decreases then it is not affecting the immediate + next value in the series. */ + if (prebuilt->autoinc_increment > increment) { + + current = autoinc - prebuilt->autoinc_increment; + + current = innobase_next_autoinc( + current, 1, increment, 1, col_max_value); + + dict_table_autoinc_initialize(prebuilt->table, current); + + *first_value = current; + } + /* Compute the last value in the interval */ next_value = innobase_next_autoinc( current, *nb_reserved_values, increment, offset, @@ -14763,7 +14820,7 @@ my_bool ha_innobase::register_query_cache_table( /*====================================*/ THD* thd, /*!< in: user thread handle */ - char* table_key, /*!< in: normalized path to the + char* table_key, /*!< in: normalized path to the table */ uint key_length, /*!< in: length of the normalized path to the table */ @@ -15692,8 +15749,9 @@ innodb_old_blocks_pct_update( const void* save) /*!< in: immediate result from check function */ { - innobase_old_blocks_pct = buf_LRU_old_ratio_update( - *static_cast<const uint*>(save), TRUE); + innobase_old_blocks_pct = static_cast<uint>( + buf_LRU_old_ratio_update( + *static_cast<const uint*>(save), TRUE)); } /****************************************************************//** @@ -15716,6 +15774,66 @@ innodb_change_buffer_max_size_update( ibuf_max_size_update(innobase_change_buffer_max_size); } +#ifdef UNIV_DEBUG +ulong srv_fil_make_page_dirty_debug = 0; +ulong srv_saved_page_number_debug = 0; + +/****************************************************************//** +Save an InnoDB page number. */ +static +void +innodb_save_page_no( +/*================*/ + 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); + + ib_logf(IB_LOG_LEVEL_INFO, + "Saving InnoDB page number: %lu", + srv_saved_page_number_debug); +} + +/****************************************************************//** +Make the first page of given user tablespace dirty. */ +static +void +innodb_make_page_dirty( +/*===================*/ + 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; + ulong space_id = *static_cast<const ulong*>(save); + + mtr_start(&mtr); + + buf_block_t* block = buf_page_get( + space_id, 0, srv_saved_page_number_debug, RW_X_LATCH, &mtr); + + if (block) { + byte* page = block->frame; + ib_logf(IB_LOG_LEVEL_INFO, + "Dirtying page:%lu of space:%lu", + page_get_page_no(page), + page_get_space_id(page)); + mlog_write_ulint(page + FIL_PAGE_TYPE, + fil_page_get_type(page), + MLOG_2BYTES, &mtr); + } + mtr_commit(&mtr); +} +#endif // UNIV_DEBUG /*************************************************************//** Find the corresponding ibuf_use_t value that indexes into @@ -16621,6 +16739,7 @@ innobase_fts_find_ranking( static my_bool innodb_purge_run_now = TRUE; static my_bool innodb_purge_stop_now = TRUE; static my_bool innodb_log_checkpoint_now = TRUE; +static my_bool innodb_buf_flush_list_now = TRUE; /****************************************************************//** Set the purge state to RUN. If purge is disabled then it @@ -16694,6 +16813,29 @@ checkpoint_now_set( fil_flush_file_spaces(FIL_TABLESPACE); } } + +/****************************************************************//** +Force a dirty pages flush now. */ +static +void +buf_flush_list_now_set( +/*===================*/ + THD* thd /*!< in: thread handle */ + __attribute__((unused)), + struct st_mysql_sys_var* var /*!< in: pointer to system + variable */ + __attribute__((unused)), + void* var_ptr /*!< out: where the formal + string goes */ + __attribute__((unused)), + const void* save) /*!< in: immediate result from + check function */ +{ + if (*(my_bool*) save) { + buf_flush_list(ULINT_MAX, LSN_MAX, NULL); + buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST); + } +} #endif /* UNIV_DEBUG */ /*********************************************************************** @@ -16843,6 +16985,26 @@ buffer_pool_load_abort( } } +/** Update innodb_status_output or innodb_status_output_locks, +which control InnoDB "status monitor" output to the error log. +@param[in] thd thread handle +@param[in] var system variable +@param[out] var_ptr current value +@param[in] save to-be-assigned value */ +static +void +innodb_status_output_update( + 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); + /* The lock timeout monitor thread also takes care of this + output. */ + os_event_set(lock_sys->timeout_event); +} + static SHOW_VAR innodb_status_variables_export[]= { {"Innodb", (char*) &show_innodb_vars, SHOW_FUNC}, {NullS, NullS, SHOW_LONG} @@ -17233,6 +17395,11 @@ static MYSQL_SYSVAR_BOOL(log_checkpoint_now, innodb_log_checkpoint_now, PLUGIN_VAR_OPCMDARG, "Force checkpoint now", NULL, checkpoint_now_set, FALSE); + +static MYSQL_SYSVAR_BOOL(buf_flush_list_now, innodb_buf_flush_list_now, + PLUGIN_VAR_OPCMDARG, + "Force dirty page flush now", + NULL, buf_flush_list_now_set, FALSE); #endif /* UNIV_DEBUG */ static MYSQL_SYSVAR_ULONG(purge_batch_size, srv_purge_batch_size, @@ -17605,7 +17772,7 @@ static MYSQL_SYSVAR_ULONG(ft_total_cache_size, fts_max_total_cache_size, static MYSQL_SYSVAR_ULONG(ft_result_cache_limit, fts_result_cache_limit, PLUGIN_VAR_RQCMDARG, "InnoDB Fulltext search query result cache limit in bytes", - NULL, NULL, 2000000000L, 1000000L, ~0UL, 0); + NULL, NULL, 2000000000L, 1000000L, 4294967295UL, 0); static MYSQL_SYSVAR_ULONG(ft_min_token_size, fts_min_token_size, PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY, @@ -17743,7 +17910,7 @@ static MYSQL_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay, NULL, NULL, 10000L, 0L, - ~0UL, 0); + 1000000L, 0); static MYSQL_SYSVAR_STR(data_file_path, innobase_data_file_path, PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY, @@ -17943,6 +18110,15 @@ static MYSQL_SYSVAR_STR(monitor_reset_all, innobase_reset_all_monitor_counter, innodb_monitor_validate, innodb_reset_all_monitor_update, NULL); +static MYSQL_SYSVAR_BOOL(status_output, srv_print_innodb_monitor, + PLUGIN_VAR_OPCMDARG, "Enable InnoDB monitor output to the error log.", + NULL, innodb_status_output_update, FALSE); + +static MYSQL_SYSVAR_BOOL(status_output_locks, srv_print_innodb_lock_monitor, + PLUGIN_VAR_OPCMDARG, "Enable InnoDB lock monitor output to the error log." + " Requires innodb_status_output=ON.", + NULL, innodb_status_output_update, FALSE); + static MYSQL_SYSVAR_BOOL(print_all_deadlocks, srv_print_all_deadlocks, PLUGIN_VAR_OPCMDARG, "Print all deadlocks to MySQL error log (off by default)", @@ -17989,6 +18165,16 @@ static MYSQL_SYSVAR_BOOL(trx_purge_view_update_only_debug, "It is to create artificially the situation the purge view have been updated " "but the each purges were not done yet.", NULL, NULL, FALSE); + +static MYSQL_SYSVAR_ULONG(fil_make_page_dirty_debug, + srv_fil_make_page_dirty_debug, PLUGIN_VAR_OPCMDARG, + "Make the first page of the given tablespace dirty.", + NULL, innodb_make_page_dirty, 0, 0, UINT_MAX32, 0); + +static MYSQL_SYSVAR_ULONG(saved_page_number_debug, + srv_saved_page_number_debug, PLUGIN_VAR_OPCMDARG, + "An InnoDB page number.", + NULL, innodb_save_page_no, 0, 0, UINT_MAX32, 0); #endif /* UNIV_DEBUG */ static struct st_mysql_sys_var* innobase_system_variables[]= { @@ -18127,11 +18313,14 @@ static struct st_mysql_sys_var* innobase_system_variables[]= { MYSQL_SYSVAR(purge_run_now), MYSQL_SYSVAR(purge_stop_now), MYSQL_SYSVAR(log_checkpoint_now), + MYSQL_SYSVAR(buf_flush_list_now), #endif /* UNIV_DEBUG */ #if defined UNIV_DEBUG || defined UNIV_PERF_DEBUG MYSQL_SYSVAR(page_hash_locks), MYSQL_SYSVAR(doublewrite_batch_size), #endif /* defined UNIV_DEBUG || defined UNIV_PERF_DEBUG */ + MYSQL_SYSVAR(status_output), + MYSQL_SYSVAR(status_output_locks), MYSQL_SYSVAR(print_all_deadlocks), MYSQL_SYSVAR(cmp_per_index_enabled), MYSQL_SYSVAR(undo_logs), @@ -18145,6 +18334,8 @@ static struct st_mysql_sys_var* innobase_system_variables[]= { MYSQL_SYSVAR(trx_rseg_n_slots_debug), MYSQL_SYSVAR(limit_optimistic_insert_debug), MYSQL_SYSVAR(trx_purge_view_update_only_debug), + MYSQL_SYSVAR(fil_make_page_dirty_debug), + MYSQL_SYSVAR(saved_page_number_debug), #endif /* UNIV_DEBUG */ NULL }; @@ -18226,7 +18417,7 @@ innobase_undo_logs_init_default_max() { MYSQL_SYSVAR_NAME(undo_logs).max_val = MYSQL_SYSVAR_NAME(undo_logs).def_val - = srv_available_undo_logs; + = static_cast<unsigned long>(srv_available_undo_logs); } #ifdef UNIV_COMPILE_TEST_FUNCS @@ -18623,7 +18814,8 @@ innobase_convert_to_filename_charset( CHARSET_INFO* cs_to = &my_charset_filename; CHARSET_INFO* cs_from = system_charset_info; - return(strconvert(cs_from, from, strlen(from), cs_to, to, len, &errors)); + return(strconvert( cs_from, from, strlen(from), cs_to, to, + static_cast<uint>(len), &errors)); } /********************************************************************** @@ -18640,6 +18832,7 @@ innobase_convert_to_system_charset( CHARSET_INFO* cs1 = &my_charset_filename; CHARSET_INFO* cs2 = system_charset_info; - return(strconvert(cs1, from, strlen(from), cs2, to, len, errors)); + return(strconvert(cs1, from, strlen(from), cs2, to, + static_cast<uint>(len), errors)); } diff --git a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc index b5c421bc930..24eb37ee776 100644 --- a/storage/innobase/handler/handler0alter.cc +++ b/storage/innobase/handler/handler0alter.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2005, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2005, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -46,12 +46,12 @@ Smart ALTER TABLE #include "srv0mon.h" #include "fts0priv.h" #include "pars0pars.h" - +#include "row0sel.h" +#include "ha_innodb.h" #ifdef WITH_WSREP //#include "wsrep_api.h" #include <sql_acl.h> // PROCESS_ACL #endif -#include "ha_innodb.h" /** Operations for creating secondary indexes (no rebuild needed) */ static const Alter_inplace_info::HA_ALTER_FLAGS INNOBASE_ONLINE_CREATE @@ -69,6 +69,7 @@ static const Alter_inplace_info::HA_ALTER_FLAGS INNOBASE_ALTER_REBUILD | Alter_inplace_info::ALTER_COLUMN_ORDER | Alter_inplace_info::DROP_COLUMN | Alter_inplace_info::ADD_COLUMN + | Alter_inplace_info::RECREATE_TABLE /* | Alter_inplace_info::ALTER_COLUMN_TYPE | Alter_inplace_info::ALTER_COLUMN_EQUAL_PACK_LENGTH @@ -82,6 +83,7 @@ static const Alter_inplace_info::HA_ALTER_FLAGS INNOBASE_ALTER_DATA /** Operations for altering a table that InnoDB does not care about */ static const Alter_inplace_info::HA_ALTER_FLAGS INNOBASE_INPLACE_IGNORE = Alter_inplace_info::ALTER_COLUMN_DEFAULT + | Alter_inplace_info::ALTER_PARTITIONED | Alter_inplace_info::ALTER_COLUMN_COLUMN_FORMAT | Alter_inplace_info::ALTER_COLUMN_STORAGE_TYPE | Alter_inplace_info::ALTER_RENAME; @@ -244,6 +246,7 @@ ha_innobase::check_if_supported_inplace_alter( innobase_get_err_msg(ER_READ_ONLY_MODE); DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED); } else if (srv_created_new_raw || srv_force_recovery) { + ha_alter_info->unsupported_reason = innobase_get_err_msg(ER_READ_ONLY_MODE); DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED); @@ -900,7 +903,7 @@ innobase_get_foreign_key_info( /* Check whether there exist such index in the the index create clause */ if (!index && !innobase_find_equiv_index( - column_names, i, + column_names, static_cast<uint>(i), ha_alter_info->key_info_buffer, ha_alter_info->index_add_buffer, ha_alter_info->index_add_count)) { @@ -1007,6 +1010,12 @@ innobase_get_foreign_key_info( } referenced_num_col = i; + } else { + /* Not possible to add a foreign key without a + referenced column */ + mutex_exit(&dict_sys->mutex); + my_error(ER_CANNOT_ADD_FOREIGN, MYF(0), tbl_namep); + goto err_exit; } if (!innobase_init_foreign( @@ -1126,16 +1135,16 @@ innobase_col_to_mysql( /* These column types should never be shipped to MySQL. */ ut_ad(0); - case DATA_FIXBINARY: case DATA_FLOAT: case DATA_DOUBLE: case DATA_DECIMAL: /* Above are the valid column types for MySQL data. */ ut_ad(flen == len); /* fall through */ + case DATA_FIXBINARY: case DATA_CHAR: /* We may have flen > len when there is a shorter - prefix on a CHAR column. */ + prefix on the CHAR and BINARY column. */ ut_ad(flen >= len); #else /* UNIV_DEBUG */ default: @@ -2535,15 +2544,16 @@ innobase_drop_fts_index_table( /** Get the new column names if any columns were renamed @param ha_alter_info Data used during in-place alter @param altered_table MySQL table that is being altered +@param table MySQL table as it is before the ALTER operation @param user_table InnoDB table as it is before the ALTER operation @param heap Memory heap for the allocation @return array of new column names in rebuilt_table, or NULL if not renamed */ static __attribute__((nonnull, warn_unused_result)) const char** innobase_get_col_names( -/*===================*/ Alter_inplace_info* ha_alter_info, const TABLE* altered_table, + const TABLE* table, const dict_table_t* user_table, mem_heap_t* heap) { @@ -2551,19 +2561,31 @@ innobase_get_col_names( uint i; DBUG_ENTER("innobase_get_col_names"); - DBUG_ASSERT(user_table->n_def > altered_table->s->fields); + DBUG_ASSERT(user_table->n_def > table->s->fields); DBUG_ASSERT(ha_alter_info->handler_flags & Alter_inplace_info::ALTER_COLUMN_NAME); cols = static_cast<const char**>( - mem_heap_alloc(heap, user_table->n_def * sizeof *cols)); + mem_heap_zalloc(heap, user_table->n_def * sizeof *cols)); + + i = 0; + List_iterator_fast<Create_field> cf_it( + ha_alter_info->alter_info->create_list); + while (const Create_field* new_field = cf_it++) { + DBUG_ASSERT(i < altered_table->s->fields); + + for (uint old_i = 0; table->field[old_i]; old_i++) { + if (new_field->field == table->field[old_i]) { + cols[old_i] = new_field->field_name; + break; + } + } - for (i = 0; i < altered_table->s->fields; i++) { - const Field* field = altered_table->field[i]; - cols[i] = field->field_name; + i++; } /* Copy the internal column names. */ + i = table->s->fields; cols[i] = dict_table_get_col_name(user_table, i); while (++i < user_table->n_def) { @@ -3341,6 +3363,9 @@ ha_innobase::prepare_inplace_alter_table( ulint fts_doc_col_no = ULINT_UNDEFINED; bool add_fts_doc_id = false; bool add_fts_doc_id_idx = false; +#ifdef _WIN32 + bool add_fts_idx = false; +#endif /* _WIN32 */ DBUG_ENTER("prepare_inplace_alter_table"); DBUG_ASSERT(!ha_alter_info->handler_ctx); @@ -3485,6 +3510,9 @@ check_if_ok_to_rename: & ~(HA_FULLTEXT | HA_PACK_KEY | HA_BINARY_PACK_KEY))); +#ifdef _WIN32 + add_fts_idx = true; +#endif /* _WIN32 */ continue; } @@ -3495,6 +3523,20 @@ check_if_ok_to_rename: } } +#ifdef _WIN32 + /* We won't be allowed to add fts index to a table with + fts indexes already but without AUX_HEX_NAME set. + This means the aux tables of the table failed to + rename to hex format but new created aux tables + shall be in hex format, which is contradictory. + It's only for Windows. */ + if (!DICT_TF2_FLAG_IS_SET(indexed_table, DICT_TF2_FTS_AUX_HEX_NAME) + && indexed_table->fts != NULL && add_fts_idx) { + my_error(ER_INNODB_FT_AUX_NOT_HEX_ID, MYF(0)); + goto err_exit_no_heap; + } +#endif /* _WIN32 */ + /* Check existing index definitions for too-long column prefixes as well, in case max_col_len shrunk. */ for (const dict_index_t* index @@ -3528,8 +3570,8 @@ check_if_ok_to_rename: if (ha_alter_info->handler_flags & Alter_inplace_info::ALTER_COLUMN_NAME) { col_names = innobase_get_col_names( - ha_alter_info, altered_table, indexed_table, - heap); + ha_alter_info, altered_table, table, + indexed_table, heap); } else { col_names = NULL; } @@ -4599,16 +4641,39 @@ commit_get_autoinc( & Alter_inplace_info::CHANGE_CREATE_OPTION) && (ha_alter_info->create_info->used_fields & HA_CREATE_USED_AUTO)) { - /* An AUTO_INCREMENT value was supplied, but the table - was not rebuilt. Get the user-supplied value or the - last value from the sequence. */ - ut_ad(old_table->found_next_number_field); + /* An AUTO_INCREMENT value was supplied, but the table was not + rebuilt. Get the user-supplied value or the last value from the + sequence. */ + ib_uint64_t max_value_table; + dberr_t err; + + Field* autoinc_field = + old_table->found_next_number_field; + + dict_index_t* index = dict_table_get_index_on_first_col( + ctx->old_table, autoinc_field->field_index); max_autoinc = ha_alter_info->create_info->auto_increment_value; dict_table_autoinc_lock(ctx->old_table); - if (max_autoinc < ctx->old_table->autoinc) { - max_autoinc = ctx->old_table->autoinc; + + err = row_search_max_autoinc( + index, autoinc_field->field_name, &max_value_table); + + if (err != DB_SUCCESS) { + ut_ad(0); + max_autoinc = 0; + } else if (max_autoinc <= max_value_table) { + ulonglong col_max_value; + ulonglong offset; + + col_max_value = innobase_get_int_col_max_value( + old_table->found_next_number_field); + + offset = ctx->prebuilt->autoinc_offset; + max_autoinc = innobase_next_autoinc( + max_value_table, 1, 1, offset, + col_max_value); } dict_table_autoinc_unlock(ctx->old_table); } else { @@ -5328,6 +5393,7 @@ ha_innobase::commit_inplace_alter_table( if (!(ha_alter_info->handler_flags & ~INNOBASE_INPLACE_IGNORE)) { DBUG_ASSERT(!ctx0); MONITOR_ATOMIC_DEC(MONITOR_PENDING_ALTER_TABLE); + ha_alter_info->group_commit_ctx = NULL; DBUG_RETURN(false); } @@ -5336,12 +5402,17 @@ ha_innobase::commit_inplace_alter_table( inplace_alter_handler_ctx** ctx_array; inplace_alter_handler_ctx* ctx_single[2]; + if (ha_alter_info->group_commit_ctx) { + ctx_array = ha_alter_info->group_commit_ctx; + } else { ctx_single[0] = ctx0; ctx_single[1] = NULL; ctx_array = ctx_single; + } DBUG_ASSERT(ctx0 == ctx_array[0]); ut_ad(prebuilt->table == ctx0->old_table); + ha_alter_info->group_commit_ctx = NULL; /* Free the ctx->trx of other partitions, if any. We will only use the ctx0->trx here. Others may have been allocated in diff --git a/storage/innobase/handler/i_s.cc b/storage/innobase/handler/i_s.cc index bd999177806..ca504acf64b 100644 --- a/storage/innobase/handler/i_s.cc +++ b/storage/innobase/handler/i_s.cc @@ -272,7 +272,7 @@ field_store_string( if (str != NULL) { - ret = field->store(str, strlen(str), + ret = field->store(str, static_cast<uint>(strlen(str)), system_charset_info); field->set_notnull(); } else { @@ -309,11 +309,13 @@ field_store_index_name( char buf[NAME_LEN + 1]; buf[0] = '?'; memcpy(buf + 1, index_name + 1, strlen(index_name)); - ret = field->store(buf, strlen(buf), - system_charset_info); + ret = field->store( + buf, static_cast<uint>(strlen(buf)), + system_charset_info); } else { - ret = field->store(index_name, strlen(index_name), - system_charset_info); + ret = field->store( + index_name, static_cast<uint>(strlen(index_name)), + system_charset_info); } field->set_notnull(); @@ -336,7 +338,7 @@ field_store_ulint( if (n != ULINT_UNDEFINED) { - ret = field->store(n); + ret = field->store(static_cast<double>(n)); field->set_notnull(); } else { @@ -642,14 +644,15 @@ fill_innodb_trx_from_cache( /* trx_mysql_thread_id */ OK(fields[IDX_TRX_MYSQL_THREAD_ID]->store( - row->trx_mysql_thread_id)); + static_cast<double>(row->trx_mysql_thread_id))); /* trx_query */ if (row->trx_query) { /* store will do appropriate character set conversion check */ fields[IDX_TRX_QUERY]->store( - row->trx_query, strlen(row->trx_query), + row->trx_query, + static_cast<uint>(strlen(row->trx_query)), row->trx_query_cs); fields[IDX_TRX_QUERY]->set_notnull(); } else { @@ -694,11 +697,11 @@ fill_innodb_trx_from_cache( /* trx_unique_checks */ OK(fields[IDX_TRX_UNIQUE_CHECKS]->store( - row->trx_unique_checks)); + static_cast<double>(row->trx_unique_checks))); /* trx_foreign_key_checks */ OK(fields[IDX_TRX_FOREIGN_KEY_CHECKS]->store( - row->trx_foreign_key_checks)); + static_cast<double>(row->trx_foreign_key_checks))); /* trx_last_foreign_key_error */ OK(field_store_string(fields[IDX_TRX_LAST_FOREIGN_KEY_ERROR], @@ -706,7 +709,7 @@ fill_innodb_trx_from_cache( /* trx_adaptive_hash_latched */ OK(fields[IDX_TRX_ADAPTIVE_HASH_LATCHED]->store( - row->trx_has_search_latch)); + static_cast<double>(row->trx_has_search_latch))); /* trx_adaptive_hash_timeout */ OK(fields[IDX_TRX_ADAPTIVE_HASH_TIMEOUT]->store( @@ -714,11 +717,11 @@ fill_innodb_trx_from_cache( /* trx_is_read_only*/ OK(fields[IDX_TRX_READ_ONLY]->store( - (long) row->trx_is_read_only, true)); + (longlong) row->trx_is_read_only, true)); /* trx_is_autocommit_non_locking */ OK(fields[IDX_TRX_AUTOCOMMIT_NON_LOCKING]->store( - (long) row->trx_is_autocommit_non_locking, + (longlong) row->trx_is_autocommit_non_locking, true)); OK(schema_table_store_record(thd, table)); @@ -958,8 +961,9 @@ fill_innodb_locks_from_cache( row->lock_table, strlen(row->lock_table), thd, TRUE); - OK(fields[IDX_LOCK_TABLE]->store(buf, bufend - buf, - system_charset_info)); + OK(fields[IDX_LOCK_TABLE]->store( + buf, static_cast<uint>(bufend - buf), + system_charset_info)); /* lock_index */ if (row->lock_index != NULL) { @@ -1443,13 +1447,16 @@ i_s_cmp_fill_low( clear it. We could introduce mutex protection, but it could cause a measureable performance hit in page0zip.cc. */ - table->field[1]->store(zip_stat->compressed); - table->field[2]->store(zip_stat->compressed_ok); + table->field[1]->store( + static_cast<double>(zip_stat->compressed)); + table->field[2]->store( + static_cast<double>(zip_stat->compressed_ok)); table->field[3]->store( - (ulong) (zip_stat->compressed_usec / 1000000)); - table->field[4]->store(zip_stat->decompressed); + static_cast<double>(zip_stat->compressed_usec / 1000000)); + table->field[4]->store( + static_cast<double>(zip_stat->decompressed)); table->field[5]->store( - (ulong) (zip_stat->decompressed_usec / 1000000)); + static_cast<double>(zip_stat->decompressed_usec / 1000000)); if (reset) { memset(zip_stat, 0, sizeof *zip_stat); @@ -1776,19 +1783,19 @@ i_s_cmp_per_index_fill_low( } fields[IDX_COMPRESS_OPS]->store( - iter->second.compressed); + static_cast<double>(iter->second.compressed)); fields[IDX_COMPRESS_OPS_OK]->store( - iter->second.compressed_ok); + static_cast<double>(iter->second.compressed_ok)); fields[IDX_COMPRESS_TIME]->store( - (long) (iter->second.compressed_usec / 1000000)); + static_cast<double>(iter->second.compressed_usec / 1000000)); fields[IDX_UNCOMPRESS_OPS]->store( - iter->second.decompressed); + static_cast<double>(iter->second.decompressed)); fields[IDX_UNCOMPRESS_TIME]->store( - (long) (iter->second.decompressed_usec / 1000000)); + static_cast<double>(iter->second.decompressed_usec / 1000000)); if (schema_table_store_record(thd, table)) { status = 1; @@ -2073,15 +2080,17 @@ i_s_cmpmem_fill_low( buddy_stat = &buf_pool->buddy_stat[x]; table->field[0]->store(BUF_BUDDY_LOW << x); - table->field[1]->store(i); - table->field[2]->store(buddy_stat->used); - table->field[3]->store(UNIV_LIKELY(x < BUF_BUDDY_SIZES) + table->field[1]->store(static_cast<double>(i)); + table->field[2]->store(static_cast<double>( + buddy_stat->used)); + table->field[3]->store(static_cast<double>( + (x < BUF_BUDDY_SIZES) ? UT_LIST_GET_LEN(buf_pool->zip_free[x]) - : 0); + : 0)); table->field[4]->store( (longlong) buddy_stat->relocated, true); table->field[5]->store( - (ulong) (buddy_stat->relocated_usec / 1000000)); + static_cast<double>(buddy_stat->relocated_usec / 1000000)); if (reset) { /* This is protected by buf_pool->mutex. */ @@ -2631,8 +2640,8 @@ i_s_metrics_fill( if (time_diff) { OK(fields[METRIC_AVG_VALUE_RESET]->store( - (double )MONITOR_VALUE(count) - / time_diff)); + static_cast<double>( + MONITOR_VALUE(count) / time_diff))); fields[METRIC_AVG_VALUE_RESET]->set_notnull(); } else { fields[METRIC_AVG_VALUE_RESET]->set_null(); @@ -3261,9 +3270,11 @@ i_s_fts_index_cache_fill_one_index( if (index_charset->cset != system_charset_info->cset) { conv_str.f_n_char = my_convert( reinterpret_cast<char*>(conv_str.f_str), - conv_str.f_len, system_charset_info, + static_cast<uint32>(conv_str.f_len), + system_charset_info, reinterpret_cast<char*>(word->text.f_str), - word->text.f_len, index_charset, &dummy_errors); + static_cast<uint32>(word->text.f_len), + index_charset, &dummy_errors); ut_ad(conv_str.f_n_char <= conv_str.f_len); conv_str.f_str[conv_str.f_n_char] = 0; word_str = reinterpret_cast<char*>(conv_str.f_str); @@ -3304,13 +3315,13 @@ i_s_fts_index_cache_fill_one_index( true)); OK(fields[I_S_FTS_DOC_COUNT]->store( - node->doc_count)); + static_cast<double>(node->doc_count))); OK(fields[I_S_FTS_ILIST_DOC_ID]->store( (longlong) doc_id, true)); OK(fields[I_S_FTS_ILIST_DOC_POS]->store( - pos)); + static_cast<double>(pos))); OK(schema_table_store_record( thd, table)); @@ -3613,9 +3624,11 @@ i_s_fts_index_table_fill_one_fetch( if (index_charset->cset != system_charset_info->cset) { conv_str->f_n_char = my_convert( reinterpret_cast<char*>(conv_str->f_str), - conv_str->f_len, system_charset_info, + static_cast<uint32>(conv_str->f_len), + system_charset_info, reinterpret_cast<char*>(word->text.f_str), - word->text.f_len, index_charset, &dummy_errors); + static_cast<uint32>(word->text.f_len), + index_charset, &dummy_errors); ut_ad(conv_str->f_n_char <= conv_str->f_len); conv_str->f_str[conv_str->f_n_char] = 0; word_str = reinterpret_cast<char*>(conv_str->f_str); @@ -3657,13 +3670,13 @@ i_s_fts_index_table_fill_one_fetch( true)); OK(fields[I_S_FTS_DOC_COUNT]->store( - node->doc_count)); + static_cast<double>(node->doc_count))); OK(fields[I_S_FTS_ILIST_DOC_ID]->store( (longlong) doc_id, true)); OK(fields[I_S_FTS_ILIST_DOC_POS]->store( - pos)); + static_cast<double>(pos))); OK(schema_table_store_record( thd, table)); @@ -4387,31 +4400,41 @@ i_s_innodb_stats_fill( fields = table->field; - OK(fields[IDX_BUF_STATS_POOL_ID]->store(info->pool_unique_id)); + OK(fields[IDX_BUF_STATS_POOL_ID]->store( + static_cast<double>(info->pool_unique_id))); - OK(fields[IDX_BUF_STATS_POOL_SIZE]->store(info->pool_size)); + OK(fields[IDX_BUF_STATS_POOL_SIZE]->store( + static_cast<double>(info->pool_size))); - OK(fields[IDX_BUF_STATS_LRU_LEN]->store(info->lru_len)); + OK(fields[IDX_BUF_STATS_LRU_LEN]->store( + static_cast<double>(info->lru_len))); - OK(fields[IDX_BUF_STATS_OLD_LRU_LEN]->store(info->old_lru_len)); + OK(fields[IDX_BUF_STATS_OLD_LRU_LEN]->store( + static_cast<double>(info->old_lru_len))); - OK(fields[IDX_BUF_STATS_FREE_BUFFERS]->store(info->free_list_len)); + OK(fields[IDX_BUF_STATS_FREE_BUFFERS]->store( + static_cast<double>(info->free_list_len))); OK(fields[IDX_BUF_STATS_FLUSH_LIST_LEN]->store( - info->flush_list_len)); + static_cast<double>(info->flush_list_len))); - OK(fields[IDX_BUF_STATS_PENDING_ZIP]->store(info->n_pend_unzip)); + OK(fields[IDX_BUF_STATS_PENDING_ZIP]->store( + static_cast<double>(info->n_pend_unzip))); - OK(fields[IDX_BUF_STATS_PENDING_READ]->store(info->n_pend_reads)); + OK(fields[IDX_BUF_STATS_PENDING_READ]->store( + static_cast<double>(info->n_pend_reads))); - OK(fields[IDX_BUF_STATS_FLUSH_LRU]->store(info->n_pending_flush_lru)); + OK(fields[IDX_BUF_STATS_FLUSH_LRU]->store( + static_cast<double>(info->n_pending_flush_lru))); - OK(fields[IDX_BUF_STATS_FLUSH_LIST]->store(info->n_pending_flush_list)); + OK(fields[IDX_BUF_STATS_FLUSH_LIST]->store( + static_cast<double>(info->n_pending_flush_list))); - OK(fields[IDX_BUF_STATS_PAGE_YOUNG]->store(info->n_pages_made_young)); + OK(fields[IDX_BUF_STATS_PAGE_YOUNG]->store( + static_cast<double>(info->n_pages_made_young))); OK(fields[IDX_BUF_STATS_PAGE_NOT_YOUNG]->store( - info->n_pages_not_made_young)); + static_cast<double>(info->n_pages_not_made_young))); OK(fields[IDX_BUF_STATS_PAGE_YOUNG_RATE]->store( info->page_made_young_rate)); @@ -4419,42 +4442,53 @@ i_s_innodb_stats_fill( OK(fields[IDX_BUF_STATS_PAGE_NOT_YOUNG_RATE]->store( info->page_not_made_young_rate)); - OK(fields[IDX_BUF_STATS_PAGE_READ]->store(info->n_pages_read)); + OK(fields[IDX_BUF_STATS_PAGE_READ]->store( + static_cast<double>(info->n_pages_read))); - OK(fields[IDX_BUF_STATS_PAGE_CREATED]->store(info->n_pages_created)); + OK(fields[IDX_BUF_STATS_PAGE_CREATED]->store( + static_cast<double>(info->n_pages_created))); - OK(fields[IDX_BUF_STATS_PAGE_WRITTEN]->store(info->n_pages_written)); + OK(fields[IDX_BUF_STATS_PAGE_WRITTEN]->store( + static_cast<double>(info->n_pages_written))); - OK(fields[IDX_BUF_STATS_GET]->store(info->n_page_gets)); + OK(fields[IDX_BUF_STATS_GET]->store( + static_cast<double>(info->n_page_gets))); - OK(fields[IDX_BUF_STATS_PAGE_READ_RATE]->store(info->pages_read_rate)); + OK(fields[IDX_BUF_STATS_PAGE_READ_RATE]->store( + info->pages_read_rate)); - OK(fields[IDX_BUF_STATS_PAGE_CREATE_RATE]->store(info->pages_created_rate)); + OK(fields[IDX_BUF_STATS_PAGE_CREATE_RATE]->store( + info->pages_created_rate)); - OK(fields[IDX_BUF_STATS_PAGE_WRITTEN_RATE]->store(info->pages_written_rate)); + OK(fields[IDX_BUF_STATS_PAGE_WRITTEN_RATE]->store( + info->pages_written_rate)); if (info->n_page_get_delta) { OK(fields[IDX_BUF_STATS_HIT_RATE]->store( - 1000 - (1000 * info->page_read_delta - / info->n_page_get_delta))); + static_cast<double>( + 1000 - (1000 * info->page_read_delta + / info->n_page_get_delta)))); OK(fields[IDX_BUF_STATS_MADE_YOUNG_PCT]->store( - 1000 * info->young_making_delta - / info->n_page_get_delta)); + static_cast<double>( + 1000 * info->young_making_delta + / info->n_page_get_delta))); OK(fields[IDX_BUF_STATS_NOT_MADE_YOUNG_PCT]->store( - 1000 * info->not_young_making_delta - / info->n_page_get_delta)); + static_cast<double>( + 1000 * info->not_young_making_delta + / info->n_page_get_delta))); } else { OK(fields[IDX_BUF_STATS_HIT_RATE]->store(0)); OK(fields[IDX_BUF_STATS_MADE_YOUNG_PCT]->store(0)); OK(fields[IDX_BUF_STATS_NOT_MADE_YOUNG_PCT]->store(0)); } - OK(fields[IDX_BUF_STATS_READ_AHREAD]->store(info->n_ra_pages_read)); + OK(fields[IDX_BUF_STATS_READ_AHREAD]->store( + static_cast<double>(info->n_ra_pages_read))); OK(fields[IDX_BUF_STATS_READ_AHEAD_EVICTED]->store( - info->n_ra_pages_evicted)); + static_cast<double>(info->n_ra_pages_evicted))); OK(fields[IDX_BUF_STATS_READ_AHEAD_RATE]->store( info->pages_readahead_rate)); @@ -4462,13 +4496,17 @@ i_s_innodb_stats_fill( OK(fields[IDX_BUF_STATS_READ_AHEAD_EVICT_RATE]->store( info->pages_evicted_rate)); - OK(fields[IDX_BUF_STATS_LRU_IO_SUM]->store(info->io_sum)); + OK(fields[IDX_BUF_STATS_LRU_IO_SUM]->store( + static_cast<double>(info->io_sum))); - OK(fields[IDX_BUF_STATS_LRU_IO_CUR]->store(info->io_cur)); + OK(fields[IDX_BUF_STATS_LRU_IO_CUR]->store( + static_cast<double>(info->io_cur))); - OK(fields[IDX_BUF_STATS_UNZIP_SUM]->store(info->unzip_sum)); + OK(fields[IDX_BUF_STATS_UNZIP_SUM]->store( + static_cast<double>(info->unzip_sum))); - OK(fields[IDX_BUF_STATS_UNZIP_CUR]->store( info->unzip_cur)); + OK(fields[IDX_BUF_STATS_UNZIP_CUR]->store( + static_cast<double>(info->unzip_cur))); DBUG_RETURN(schema_table_store_record(thd, table)); } @@ -4813,13 +4851,17 @@ i_s_innodb_buffer_page_fill( state_str = NULL; - OK(fields[IDX_BUFFER_POOL_ID]->store(page_info->pool_id)); + OK(fields[IDX_BUFFER_POOL_ID]->store( + static_cast<double>(page_info->pool_id))); - OK(fields[IDX_BUFFER_BLOCK_ID]->store(page_info->block_id)); + OK(fields[IDX_BUFFER_BLOCK_ID]->store( + static_cast<double>(page_info->block_id))); - OK(fields[IDX_BUFFER_PAGE_SPACE]->store(page_info->space_id)); + OK(fields[IDX_BUFFER_PAGE_SPACE]->store( + static_cast<double>(page_info->space_id))); - OK(fields[IDX_BUFFER_PAGE_NUM]->store(page_info->page_num)); + OK(fields[IDX_BUFFER_PAGE_NUM]->store( + static_cast<double>(page_info->page_num))); OK(field_store_string( fields[IDX_BUFFER_PAGE_TYPE], @@ -4871,7 +4913,7 @@ i_s_innodb_buffer_page_fill( OK(fields[IDX_BUFFER_PAGE_TABLE_NAME]->store( table_name, - table_name_end - table_name, + static_cast<uint>(table_name_end - table_name), system_charset_info)); fields[IDX_BUFFER_PAGE_TABLE_NAME]->set_notnull(); @@ -5523,23 +5565,27 @@ i_s_innodb_buf_page_lru_fill( page_info = info_array + i; - OK(fields[IDX_BUF_LRU_POOL_ID]->store(page_info->pool_id)); + OK(fields[IDX_BUF_LRU_POOL_ID]->store( + static_cast<double>(page_info->pool_id))); - OK(fields[IDX_BUF_LRU_POS]->store(page_info->block_id)); + OK(fields[IDX_BUF_LRU_POS]->store( + static_cast<double>(page_info->block_id))); - OK(fields[IDX_BUF_LRU_PAGE_SPACE]->store(page_info->space_id)); + OK(fields[IDX_BUF_LRU_PAGE_SPACE]->store( + static_cast<double>(page_info->space_id))); - OK(fields[IDX_BUF_LRU_PAGE_NUM]->store(page_info->page_num)); + OK(fields[IDX_BUF_LRU_PAGE_NUM]->store( + static_cast<double>(page_info->page_num))); OK(field_store_string( fields[IDX_BUF_LRU_PAGE_TYPE], i_s_page_type[page_info->page_type].type_str)); OK(fields[IDX_BUF_LRU_PAGE_FLUSH_TYPE]->store( - page_info->flush_type)); + static_cast<double>(page_info->flush_type))); OK(fields[IDX_BUF_LRU_PAGE_FIX_COUNT]->store( - page_info->fix_count)); + static_cast<double>(page_info->fix_count))); if (page_info->hashed) { OK(field_store_string( @@ -5581,7 +5627,7 @@ i_s_innodb_buf_page_lru_fill( OK(fields[IDX_BUF_LRU_PAGE_TABLE_NAME]->store( table_name, - table_name_end - table_name, + static_cast<uint>(table_name_end - table_name), system_charset_info)); fields[IDX_BUF_LRU_PAGE_TABLE_NAME]->set_notnull(); @@ -5985,7 +6031,8 @@ i_s_dict_fill_sys_tables( OK(field_store_string(fields[SYS_TABLES_ROW_FORMAT], row_format)); - OK(fields[SYS_TABLES_ZIP_PAGE_SIZE]->store(zip_size)); + OK(fields[SYS_TABLES_ZIP_PAGE_SIZE]->store( + static_cast<double>(zip_size))); OK(schema_table_store_record(thd, table_to_fill)); @@ -6255,13 +6302,13 @@ i_s_dict_fill_sys_tablestats( TRUE)); OK(fields[SYS_TABLESTATS_CLUST_SIZE]->store( - table->stat_clustered_index_size)); + static_cast<double>(table->stat_clustered_index_size))); OK(fields[SYS_TABLESTATS_INDEX_SIZE]->store( - table->stat_sum_of_other_index_sizes)); + static_cast<double>(table->stat_sum_of_other_index_sizes))); OK(fields[SYS_TABLESTATS_MODIFIED]->store( - (ulint) table->stat_modified_counter)); + static_cast<double>(table->stat_modified_counter))); } else { OK(field_store_string(fields[SYS_TABLESTATS_INIT], "Uninitialized")); @@ -6280,7 +6327,7 @@ i_s_dict_fill_sys_tablestats( OK(fields[SYS_TABLESTATS_AUTONINC]->store(table->autoinc, TRUE)); OK(fields[SYS_TABLESTATS_TABLE_REF_COUNT]->store( - table->n_ref_count)); + static_cast<double>(table->n_ref_count))); OK(schema_table_store_record(thd, table_to_fill)); @@ -6972,7 +7019,7 @@ i_s_dict_fill_sys_fields( OK(field_store_string(fields[SYS_FIELD_NAME], field->name)); - OK(fields[SYS_FIELD_POS]->store(pos)); + OK(fields[SYS_FIELD_POS]->store(static_cast<double>(pos))); OK(schema_table_store_record(thd, table_to_fill)); @@ -7420,7 +7467,7 @@ i_s_dict_fill_sys_foreign_cols( OK(field_store_string(fields[SYS_FOREIGN_COL_REF_NAME], ref_col_name)); - OK(fields[SYS_FOREIGN_COL_POS]->store(pos)); + OK(fields[SYS_FOREIGN_COL_POS]->store(static_cast<double>(pos))); OK(schema_table_store_record(thd, table_to_fill)); @@ -7671,11 +7718,13 @@ i_s_dict_fill_sys_tablespaces( fields = table_to_fill->field; - OK(fields[SYS_TABLESPACES_SPACE]->store(space)); + OK(fields[SYS_TABLESPACES_SPACE]->store( + static_cast<double>(space))); OK(field_store_string(fields[SYS_TABLESPACES_NAME], name)); - OK(fields[SYS_TABLESPACES_FLAGS]->store(flags)); + OK(fields[SYS_TABLESPACES_FLAGS]->store( + static_cast<double>(flags))); OK(field_store_string(fields[SYS_TABLESPACES_FILE_FORMAT], file_format)); @@ -7683,9 +7732,11 @@ i_s_dict_fill_sys_tablespaces( OK(field_store_string(fields[SYS_TABLESPACES_ROW_FORMAT], row_format)); - OK(fields[SYS_TABLESPACES_PAGE_SIZE]->store(page_size)); + OK(fields[SYS_TABLESPACES_PAGE_SIZE]->store( + static_cast<double>(page_size))); - OK(fields[SYS_TABLESPACES_ZIP_PAGE_SIZE]->store(zip_size)); + OK(fields[SYS_TABLESPACES_ZIP_PAGE_SIZE]->store( + static_cast<double>(zip_size))); OK(schema_table_store_record(thd, table_to_fill)); diff --git a/storage/innobase/ibuf/ibuf0ibuf.cc b/storage/innobase/ibuf/ibuf0ibuf.cc index 1ce5332885a..0bb898dbce5 100644 --- a/storage/innobase/ibuf/ibuf0ibuf.cc +++ b/storage/innobase/ibuf/ibuf0ibuf.cc @@ -2919,7 +2919,8 @@ ibuf_get_volume_buffered_hash( fold = ut_fold_binary(data, len); hash += (fold / (CHAR_BIT * sizeof *hash)) % size; - bitmask = 1 << (fold % (CHAR_BIT * sizeof *hash)); + bitmask = static_cast<ulint>( + 1 << (fold % (CHAR_BIT * sizeof(*hash)))); if (*hash & bitmask) { @@ -3932,7 +3933,7 @@ skip_watch: /********************************************************************//** During merge, inserts to an index page a secondary index entry extracted -from the insert buffer. +from the insert buffer. @return newly inserted record */ static __attribute__((nonnull)) rec_t* diff --git a/storage/innobase/include/api0api.h b/storage/innobase/include/api0api.h index c294e3f34d5..d77d691becc 100644 --- a/storage/innobase/include/api0api.h +++ b/storage/innobase/include/api0api.h @@ -1257,6 +1257,16 @@ ib_cfg_get_cfg(); /*============*/ /*****************************************************************//** +Increase/decrease the memcached sync count of table to sync memcached +DML with SQL DDLs. +@return DB_SUCCESS or error number */ +ib_err_t +ib_cursor_set_memcached_sync( +/*=========================*/ + ib_crsr_t ib_crsr, /*!< in: cursor */ + ib_bool_t flag); /*!< in: true for increasing */ + +/*****************************************************************//** Check whether the table name conforms to our requirements. Currently we only do a simple check for the presence of a '/'. @return DB_SUCCESS or err code */ diff --git a/storage/innobase/include/btr0pcur.h b/storage/innobase/include/btr0pcur.h index fc008cdd185..cfbaacf4de3 100644 --- a/storage/innobase/include/btr0pcur.h +++ b/storage/innobase/include/btr0pcur.h @@ -459,6 +459,13 @@ void btr_pcur_move_to_prev_on_page( /*==========================*/ btr_pcur_t* cursor);/*!< in/out: persistent cursor */ +/*********************************************************//** +Moves the persistent cursor to the infimum record on the same page. */ +UNIV_INLINE +void +btr_pcur_move_before_first_on_page( +/*===============================*/ + btr_pcur_t* cursor); /*!< in/out: persistent cursor */ /** Position state of persistent B-tree cursor. */ enum pcur_pos_t { diff --git a/storage/innobase/include/btr0pcur.ic b/storage/innobase/include/btr0pcur.ic index 29f2fc722a2..7e355d3709d 100644 --- a/storage/innobase/include/btr0pcur.ic +++ b/storage/innobase/include/btr0pcur.ic @@ -588,3 +588,19 @@ btr_pcur_close( cursor->trx_if_known = NULL; } + +/*********************************************************//** +Moves the persistent cursor to the infimum record on the same page. */ +UNIV_INLINE +void +btr_pcur_move_before_first_on_page( +/*===============================*/ + btr_pcur_t* cursor) /*!< in/out: persistent cursor */ +{ + ut_ad(cursor->latch_mode != BTR_NO_LATCHES); + + page_cur_set_before_first(btr_pcur_get_block(cursor), + btr_pcur_get_page_cur(cursor)); + + cursor->old_stored = BTR_PCUR_OLD_NOT_STORED; +} diff --git a/storage/innobase/include/buf0buf.h b/storage/innobase/include/buf0buf.h index 7ad6339e63b..289de8f42ae 100644 --- a/storage/innobase/include/buf0buf.h +++ b/storage/innobase/include/buf0buf.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -607,6 +607,23 @@ buf_block_buf_fix_inc_func( # endif /* UNIV_SYNC_DEBUG */ buf_block_t* block) /*!< in/out: block to bufferfix */ __attribute__((nonnull)); + +/*******************************************************************//** +Increments the bufferfix count. */ +UNIV_INLINE +void +buf_block_fix( +/*===========*/ + buf_block_t* block); /*!< in/out: block to bufferfix */ + +/*******************************************************************//** +Increments the bufferfix count. */ +UNIV_INLINE +void +buf_block_unfix( +/*===========*/ + buf_block_t* block); /*!< in/out: block to bufferfix */ + # ifdef UNIV_SYNC_DEBUG /** Increments the bufferfix count. @param b in/out: block to bufferfix @@ -636,6 +653,15 @@ buf_page_is_corrupted( ulint zip_size) /*!< in: size of compressed page; 0 for uncompressed pages */ __attribute__((nonnull, warn_unused_result)); +/********************************************************************//** +Checks if a page is all zeroes. +@return TRUE if the page is all zeroes */ +bool +buf_page_is_zeroes( +/*===============*/ + const byte* read_buf, /*!< in: a database page */ + const ulint zip_size); /*!< in: size of compressed page; + 0 for uncompressed pages */ #ifndef UNIV_HOTBACKUP /**********************************************************************//** Gets the space id, page offset, and byte offset within page of a @@ -1423,38 +1449,42 @@ struct buf_page_t{ by buf_pool->mutex. */ /* @{ */ - unsigned space:32; /*!< tablespace id; also protected + ib_uint32_t space; /*!< tablespace id; also protected by buf_pool->mutex. */ - unsigned offset:32; /*!< page number; also protected + ib_uint32_t offset; /*!< page number; also protected by buf_pool->mutex. */ + /** count of how manyfold this block is currently bufferfixed */ +#ifdef PAGE_ATOMIC_REF_COUNT + ib_uint32_t buf_fix_count; + /** type of pending I/O operation; also protected by + buf_pool->mutex for writes only @see enum buf_io_fix */ + byte io_fix; + + byte state; +#else + unsigned buf_fix_count:19; + + /** type of pending I/O operation; also protected by + buf_pool->mutex for writes only @see enum buf_io_fix */ + unsigned io_fix:2; + + /*!< state of the control block; also protected by buf_pool->mutex. + State transitions from BUF_BLOCK_READY_FOR_USE to BUF_BLOCK_MEMORY + need not be protected by buf_page_get_mutex(). @see enum buf_page_state. + State changes that are relevant to page_hash are additionally protected + by the appropriate page_hash mutex i.e.: if a page is in page_hash or + is being added to/removed from page_hash then the corresponding changes + must also be protected by page_hash mutex. */ unsigned state:BUF_PAGE_STATE_BITS; - /*!< state of the control block; also - protected by buf_pool->mutex. - State transitions from - BUF_BLOCK_READY_FOR_USE to - BUF_BLOCK_MEMORY need not be - protected by buf_page_get_mutex(). - @see enum buf_page_state. - State changes that are relevant - to page_hash are additionally - protected by the appropriate - page_hash mutex i.e.: if a page - is in page_hash or is being - added to/removed from page_hash - then the corresponding changes - must also be protected by - page_hash mutex. */ + +#endif /* PAGE_ATOMIC_REF_COUNT */ + #ifndef UNIV_HOTBACKUP unsigned flush_type:2; /*!< if this block is currently being flushed to disk, this tells the flush_type. @see buf_flush_t */ - unsigned io_fix:2; /*!< type of pending I/O operation; - also protected by buf_pool->mutex - @see enum buf_io_fix */ - unsigned buf_fix_count:19;/*!< count of how manyfold this block - is currently bufferfixed */ unsigned buf_pool_index:6;/*!< index number of the buffer pool that this block belongs to */ # if MAX_BUFFER_POOLS > 64 @@ -1608,7 +1638,7 @@ struct buf_block_t{ decompressed LRU list; used in debugging */ #endif /* UNIV_DEBUG */ - ib_mutex_t mutex; /*!< mutex protecting this block: + ib_mutex_t mutex; /*!< mutex protecting this block: state (also protected by the buffer pool mutex), io_fix, buf_fix_count, and accessed; we introduce this new @@ -1794,9 +1824,9 @@ struct buf_pool_t{ /** @name General fields */ /* @{ */ - ib_mutex_t mutex; /*!< Buffer pool mutex of this + ib_mutex_t mutex; /*!< Buffer pool mutex of this instance */ - ib_mutex_t zip_mutex; /*!< Zip mutex of this buffer + ib_mutex_t zip_mutex; /*!< Zip mutex of this buffer pool instance, protects compressed only pages (of type buf_page_t, not buf_block_t */ @@ -1850,7 +1880,7 @@ struct buf_pool_t{ /* @{ */ - ib_mutex_t flush_list_mutex;/*!< mutex protecting the + ib_mutex_t flush_list_mutex;/*!< mutex protecting the flush list access. This mutex protects flush_list, flush_rbt and bpage::list pointers when @@ -1968,27 +1998,39 @@ Use these instead of accessing buf_pool->mutex directly. */ /** Test if a buffer pool mutex is owned. */ #define buf_pool_mutex_own(b) mutex_own(&b->mutex) /** Acquire a buffer pool mutex. */ -#define buf_pool_mutex_enter(b) do { \ - ut_ad(!mutex_own(&b->zip_mutex)); \ - mutex_enter(&b->mutex); \ +#define buf_pool_mutex_enter(b) do { \ + ut_ad(!mutex_own(&b->zip_mutex)); \ + mutex_enter(&b->mutex); \ } while (0) /** Test if flush list mutex is owned. */ #define buf_flush_list_mutex_own(b) mutex_own(&b->flush_list_mutex) /** Acquire the flush list mutex. */ -#define buf_flush_list_mutex_enter(b) do { \ - mutex_enter(&b->flush_list_mutex); \ +#define buf_flush_list_mutex_enter(b) do { \ + mutex_enter(&b->flush_list_mutex); \ } while (0) /** Release the flush list mutex. */ -# define buf_flush_list_mutex_exit(b) do { \ - mutex_exit(&b->flush_list_mutex); \ +# define buf_flush_list_mutex_exit(b) do { \ + mutex_exit(&b->flush_list_mutex); \ +} while (0) + +/** Test if block->mutex is owned. */ +#define buf_block_mutex_own(b) mutex_own(&(b)->mutex) + +/** Acquire the block->mutex. */ +#define buf_block_mutex_enter(b) do { \ + mutex_enter(&(b)->mutex); \ } while (0) +/** Release the trx->mutex. */ +#define buf_block_mutex_exit(b) do { \ + mutex_exit(&(b)->mutex); \ +} while (0) /** Get appropriate page_hash_lock. */ -# define buf_page_hash_lock_get(b, f) \ +# define buf_page_hash_lock_get(b, f) \ hash_get_lock(b->page_hash, f) #ifdef UNIV_SYNC_DEBUG diff --git a/storage/innobase/include/buf0buf.ic b/storage/innobase/include/buf0buf.ic index 08b31a59da3..b15a7fb11b6 100644 --- a/storage/innobase/include/buf0buf.ic +++ b/storage/innobase/include/buf0buf.ic @@ -342,15 +342,16 @@ buf_page_get_mutex( /*===============*/ const buf_page_t* bpage) /*!< in: pointer to control block */ { - buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); - switch (buf_page_get_state(bpage)) { case BUF_BLOCK_POOL_WATCH: ut_error; return(NULL); case BUF_BLOCK_ZIP_PAGE: - case BUF_BLOCK_ZIP_DIRTY: + case BUF_BLOCK_ZIP_DIRTY: { + buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); + return(&buf_pool->zip_mutex); + } default: return(&((buf_block_t*) bpage)->mutex); } @@ -404,8 +405,8 @@ buf_block_set_file_page( ulint page_no)/*!< in: page number */ { buf_block_set_state(block, BUF_BLOCK_FILE_PAGE); - block->page.space = space; - block->page.offset = page_no; + block->page.space = static_cast<ib_uint32_t>(space); + block->page.offset = static_cast<ib_uint32_t>(page_no); } /*********************************************************************//** @@ -620,12 +621,13 @@ buf_page_set_accessed( buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); ut_ad(!buf_pool_mutex_own(buf_pool)); ut_ad(mutex_own(buf_page_get_mutex(bpage))); -#endif +#endif /* UNIV_DEBUG */ + ut_a(buf_page_in_file(bpage)); - if (!bpage->access_time) { + if (bpage->access_time == 0) { /* Make this the time of the first access. */ - bpage->access_time = ut_time_ms(); + bpage->access_time = static_cast<uint>(ut_time_ms()); } } @@ -1000,6 +1002,25 @@ buf_block_get_modify_clock( Increments the bufferfix count. */ UNIV_INLINE void +buf_block_fix( +/*===========*/ + buf_block_t* block) /*!< in/out: block to bufferfix */ +{ +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_increment_uint32(&block->page.buf_fix_count, 1); +#else + ib_mutex_t* block_mutex = buf_page_get_mutex(&block->page); + + mutex_enter(block_mutex); + ++block->page.buf_fix_count; + mutex_exit(block_mutex); +#endif /* PAGE_ATOMIC_REF_COUNT */ +} + +/*******************************************************************//** +Increments the bufferfix count. */ +UNIV_INLINE +void buf_block_buf_fix_inc_func( /*=======================*/ #ifdef UNIV_SYNC_DEBUG @@ -1014,9 +1035,35 @@ buf_block_buf_fix_inc_func( ret = rw_lock_s_lock_nowait(&(block->debug_latch), file, line); ut_a(ret); #endif /* UNIV_SYNC_DEBUG */ + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_increment_uint32(&block->page.buf_fix_count, 1); +#else ut_ad(mutex_own(&block->mutex)); - block->page.buf_fix_count++; + ++block->page.buf_fix_count; +#endif /* PAGE_ATOMIC_REF_COUNT */ +} + +/*******************************************************************//** +Decrements the bufferfix count. */ +UNIV_INLINE +void +buf_block_unfix( +/*============*/ + buf_block_t* block) /*!< in/out: block to bufferunfix */ +{ + ut_ad(block->page.buf_fix_count > 0); + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_decrement_uint32(&block->page.buf_fix_count, 1); +#else + ib_mutex_t* block_mutex = buf_page_get_mutex(&block->page); + + mutex_enter(block_mutex); + --block->page.buf_fix_count; + mutex_exit(block_mutex); +#endif /* PAGE_ATOMIC_REF_COUNT */ } /*******************************************************************//** @@ -1027,9 +1074,16 @@ buf_block_buf_fix_dec( /*==================*/ buf_block_t* block) /*!< in/out: block to bufferunfix */ { - ut_ad(mutex_own(&block->mutex)); + ut_ad(block->page.buf_fix_count > 0); + +#ifdef PAGE_ATOMIC_REF_COUNT + os_atomic_decrement_uint32(&block->page.buf_fix_count, 1); +#else + mutex_enter(&block->mutex); + --block->page.buf_fix_count; + mutex_exit(&block->mutex); +#endif /* PAGE_ATOMIC_REF_COUNT */ - block->page.buf_fix_count--; #ifdef UNIV_SYNC_DEBUG rw_lock_s_unlock(&block->debug_latch); #endif @@ -1288,27 +1342,20 @@ buf_page_release_zip( buf_page_t* bpage) /*!< in: buffer block */ { buf_block_t* block; - buf_pool_t* buf_pool = buf_pool_from_bpage(bpage); - ut_ad(bpage); - ut_a(bpage->buf_fix_count > 0); + block = (buf_block_t*) bpage; switch (buf_page_get_state(bpage)) { - case BUF_BLOCK_ZIP_PAGE: - case BUF_BLOCK_ZIP_DIRTY: - mutex_enter(&buf_pool->zip_mutex); - bpage->buf_fix_count--; - mutex_exit(&buf_pool->zip_mutex); - return; case BUF_BLOCK_FILE_PAGE: - block = (buf_block_t*) bpage; - mutex_enter(&block->mutex); #ifdef UNIV_SYNC_DEBUG rw_lock_s_unlock(&block->debug_latch); -#endif - bpage->buf_fix_count--; - mutex_exit(&block->mutex); +#endif /* UNUV_SYNC_DEBUG */ + /* Fall through */ + case BUF_BLOCK_ZIP_PAGE: + case BUF_BLOCK_ZIP_DIRTY: + buf_block_unfix(block); return; + case BUF_BLOCK_POOL_WATCH: case BUF_BLOCK_NOT_USED: case BUF_BLOCK_READY_FOR_USE: @@ -1331,25 +1378,18 @@ buf_page_release( ulint rw_latch) /*!< in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */ { - ut_ad(block); - ut_a(buf_block_get_state(block) == BUF_BLOCK_FILE_PAGE); - ut_a(block->page.buf_fix_count > 0); - - mutex_enter(&block->mutex); #ifdef UNIV_SYNC_DEBUG rw_lock_s_unlock(&(block->debug_latch)); #endif - block->page.buf_fix_count--; - - mutex_exit(&block->mutex); - if (rw_latch == RW_S_LATCH) { rw_lock_s_unlock(&(block->lock)); } else if (rw_latch == RW_X_LATCH) { rw_lock_x_unlock(&(block->lock)); } + + buf_block_unfix(block); } #ifdef UNIV_SYNC_DEBUG @@ -1367,6 +1407,7 @@ buf_block_dbg_add_level( { sync_thread_add_level(&block->lock, level, FALSE); } + #endif /* UNIV_SYNC_DEBUG */ /********************************************************************//** Acquire mutex on all buffer pool instances. */ diff --git a/storage/innobase/include/buf0dblwr.h b/storage/innobase/include/buf0dblwr.h index 1b9336f4002..a62a6400d97 100644 --- a/storage/innobase/include/buf0dblwr.h +++ b/storage/innobase/include/buf0dblwr.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2011, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -29,6 +29,7 @@ Created 2011/12/19 Inaam Rana #include "univ.i" #include "ut0byte.h" #include "log0log.h" +#include "log0recv.h" #ifndef UNIV_HOTBACKUP @@ -44,18 +45,26 @@ UNIV_INTERN void buf_dblwr_create(void); /*==================*/ + /****************************************************************//** At a database startup initializes the doublewrite buffer memory structure if we already have a doublewrite buffer created in the data files. If we are upgrading to an InnoDB version which supports multiple tablespaces, then this function performs the necessary update operations. If we are in a crash -recovery, this function uses a possible doublewrite buffer to restore -half-written pages in the data files. */ -UNIV_INTERN +recovery, this function loads the pages from double write buffer into memory. */ +void +buf_dblwr_init_or_load_pages( +/*=========================*/ + os_file_t file, + char* path, + bool load_corrupt_pages); + +/****************************************************************//** +Process the double write buffer pages. */ void -buf_dblwr_init_or_restore_pages( -/*============================*/ - ibool restore_corrupt_pages); /*!< in: TRUE=restore pages */ +buf_dblwr_process(void); +/*===================*/ + /****************************************************************//** frees doublewrite buffer. */ UNIV_INTERN diff --git a/storage/innobase/include/buf0flu.h b/storage/innobase/include/buf0flu.h index 6fee9afcc91..f116720574b 100644 --- a/storage/innobase/include/buf0flu.h +++ b/storage/innobase/include/buf0flu.h @@ -234,16 +234,16 @@ NOTE: in simulated aio we must call os_aio_simulated_wake_handler_threads after we have posted a batch of writes! NOTE: buf_pool->mutex and buf_page_get_mutex(bpage) must be held upon entering this function, and they will be released by this -function. */ +function if it returns true. +@return TRUE if the page was flushed */ UNIV_INTERN -void +bool buf_flush_page( /*===========*/ buf_pool_t* buf_pool, /*!< in: buffer pool instance */ buf_page_t* bpage, /*!< in: buffer control block */ buf_flush_t flush_type, /*!< in: type of flush */ - bool sync) /*!< in: true if sync IO request */ - __attribute__((nonnull)); + bool sync); /*!< in: true if sync IO request */ /********************************************************************//** Returns true if the block is modified and ready for flushing. @return true if can flush immediately */ diff --git a/storage/innobase/include/buf0types.h b/storage/innobase/include/buf0types.h index 307ef18f0c2..11bbc9b5c8a 100644 --- a/storage/innobase/include/buf0types.h +++ b/storage/innobase/include/buf0types.h @@ -26,6 +26,10 @@ Created 11/17/1995 Heikki Tuuri #ifndef buf0types_h #define buf0types_h +#if defined(INNODB_PAGE_ATOMIC_REF_COUNT) && defined(HAVE_ATOMIC_BUILTINS) +#define PAGE_ATOMIC_REF_COUNT +#endif /* INNODB_PAGE_ATOMIC_REF_COUNT && HAVE_ATOMIC_BUILTINS */ + /** Buffer page (uncompressed or compressed) */ struct buf_page_t; /** Buffer block for which an uncompressed page exists */ diff --git a/storage/innobase/include/db0err.h b/storage/innobase/include/db0err.h index 982bf1943cf..71916cb33f2 100644 --- a/storage/innobase/include/db0err.h +++ b/storage/innobase/include/db0err.h @@ -128,6 +128,8 @@ enum dberr_t { DB_FTS_EXCEED_RESULT_CACHE_LIMIT, /*!< FTS query memory exceeds result cache limit */ DB_TEMP_FILE_WRITE_FAILURE, /*!< Temp file write failure */ + DB_FTS_TOO_MANY_WORDS_IN_PHRASE, + /*< Too many words in a phrase */ /* The following are partial failure codes */ DB_FAIL = 1000, diff --git a/storage/innobase/include/dict0dict.h b/storage/innobase/include/dict0dict.h index f740c427006..ce709a2e912 100644 --- a/storage/innobase/include/dict0dict.h +++ b/storage/innobase/include/dict0dict.h @@ -1443,20 +1443,16 @@ UNIV_INTERN void dict_table_stats_lock( /*==================*/ - const dict_table_t* table, /*!< in: table */ - ulint latch_mode) /*!< in: RW_S_LATCH or - RW_X_LATCH */ - __attribute__((nonnull)); + dict_table_t* table, /*!< in: table */ + ulint latch_mode); /*!< in: RW_S_LATCH or RW_X_LATCH */ /**********************************************************************//** Unlock the latch that has been locked by dict_table_stats_lock() */ UNIV_INTERN void dict_table_stats_unlock( /*====================*/ - const dict_table_t* table, /*!< in: table */ - ulint latch_mode) /*!< in: RW_S_LATCH or - RW_X_LATCH */ - __attribute__((nonnull)); + dict_table_t* table, /*!< in: table */ + ulint latch_mode); /*!< in: RW_S_LATCH or RW_X_LATCH */ /********************************************************************//** Checks if the database name in two table names is the same. @return TRUE if same db name */ @@ -1802,6 +1798,17 @@ const char* dict_tf_to_row_format_string( /*=========================*/ ulint table_flag); /*!< in: row format setting */ +/*****************************************************************//** +Get index by first field of the index +@return index which is having first field matches +with the field present in field_index position of table */ +UNIV_INLINE +dict_index_t* +dict_table_get_index_on_first_col( +/*==============================*/ + const dict_table_t* table, /*!< in: table */ + ulint col_index); /*!< in: position of column + in table */ #endif /* !UNIV_HOTBACKUP */ diff --git a/storage/innobase/include/dict0dict.ic b/storage/innobase/include/dict0dict.ic index 83953c9325a..066ffe47e4a 100644 --- a/storage/innobase/include/dict0dict.ic +++ b/storage/innobase/include/dict0dict.ic @@ -1403,4 +1403,31 @@ dict_table_is_temporary( return(DICT_TF2_FLAG_IS_SET(table, DICT_TF2_TEMPORARY)); } +/**********************************************************************//** +Get index by first field of the index +@return index which is having first field matches +with the field present in field_index position of table */ +UNIV_INLINE +dict_index_t* +dict_table_get_index_on_first_col( +/*==============================*/ + const dict_table_t* table, /*!< in: table */ + ulint col_index) /*!< in: position of column + in table */ +{ + ut_ad(col_index < table->n_cols); + + dict_col_t* column = dict_table_get_nth_col(table, col_index); + + for (dict_index_t* index = dict_table_get_first_index(table); + index != NULL; index = dict_table_get_next_index(index)) { + + if (index->fields[0].col == column) { + return(index); + } + } + ut_error; + return(0); +} + #endif /* !UNIV_HOTBACKUP */ diff --git a/storage/innobase/include/dict0mem.h b/storage/innobase/include/dict0mem.h index 21c1ab71445..c5ed8d92cb0 100644 --- a/storage/innobase/include/dict0mem.h +++ b/storage/innobase/include/dict0mem.h @@ -191,7 +191,7 @@ ROW_FORMAT=REDUNDANT. InnoDB engines do not check these flags for unknown bits in order to protect backward incompatibility. */ /* @{ */ /** Total number of bits in table->flags2. */ -#define DICT_TF2_BITS 6 +#define DICT_TF2_BITS 7 #define DICT_TF2_BIT_MASK ~(~0 << DICT_TF2_BITS) /** TEMPORARY; TRUE for tables from CREATE TEMPORARY TABLE. */ @@ -209,6 +209,10 @@ use its own tablespace instead of the system tablespace. */ /** Set when we discard/detach the tablespace */ #define DICT_TF2_DISCARDED 32 + +/** This bit is set if all aux table names (both common tables and +index tables) of a FTS table are in HEX format. */ +#define DICT_TF2_FTS_AUX_HEX_NAME 64 /* @} */ #define DICT_TF2_FLAG_SET(table, flag) \ @@ -720,6 +724,11 @@ a foreign key constraint is enforced, therefore RESTRICT just means no flag */ #define DICT_FOREIGN_ON_UPDATE_NO_ACTION 32 /*!< ON UPDATE NO ACTION */ /* @} */ +/* This flag is for sync SQL DDL and memcached DML. +if table->memcached_sync_count == DICT_TABLE_IN_DDL means there's DDL running on +the table, DML from memcached will be blocked. */ +#define DICT_TABLE_IN_DDL -1 + /** Data structure for a database table. Most fields will be initialized to 0, NULL or FALSE in dict_mem_table_create(). */ struct dict_table_t{ @@ -833,9 +842,28 @@ struct dict_table_t{ initialized in dict_table_add_to_cache() */ /** Statistics for query optimization */ /* @{ */ + rw_lock_t* stats_latch; /*!< this latch protects: + dict_table_t::stat_initialized + dict_table_t::stat_n_rows (*) + dict_table_t::stat_clustered_index_size + dict_table_t::stat_sum_of_other_index_sizes + dict_table_t::stat_modified_counter (*) + dict_table_t::indexes*::stat_n_diff_key_vals[] + dict_table_t::indexes*::stat_index_size + dict_table_t::indexes*::stat_n_leaf_pages + (*) those are not always protected for + performance reasons */ unsigned stat_initialized:1; /*!< TRUE if statistics have been calculated the first time after database startup or table creation */ +#define DICT_TABLE_IN_USED -1 + lint memcached_sync_count; + /*!< count of how many handles are opened + to this table from memcached; DDL on the + table is NOT allowed until this count + goes to zero. If it's -1, means there's DDL + on the table, DML from memcached will be + blocked. */ ib_time_t stats_last_recalc; /*!< Timestamp of last recalc of the stats */ ib_uint32_t stat_persistent; diff --git a/storage/innobase/include/fil0fil.h b/storage/innobase/include/fil0fil.h index daeca1d8e44..72b4cfd3bfb 100644 --- a/storage/innobase/include/fil0fil.h +++ b/storage/innobase/include/fil0fil.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -127,6 +127,8 @@ extern fil_addr_t fil_addr_null; at least up to this lsn */ #define FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID 34 /*!< starting from 4.1.x this contains the space id of the page */ +#define FIL_PAGE_SPACE_ID FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID + #define FIL_PAGE_DATA 38 /*!< start of the data on the page */ /* @} */ /** File page trailer @{ */ @@ -174,6 +176,20 @@ extern ulint fil_n_pending_tablespace_flushes; /** Number of files currently open */ extern ulint fil_n_file_opened; +struct fsp_open_info { + ibool success; /*!< Has the tablespace been opened? */ + const char* check_msg; /*!< fil_check_first_page() message */ + ibool valid; /*!< Is the tablespace valid? */ + os_file_t file; /*!< File handle */ + char* filepath; /*!< File path to open */ + lsn_t lsn; /*!< Flushed LSN from header page */ + ulint id; /*!< Space ID */ + ulint flags; /*!< Tablespace flags */ +#ifdef UNIV_LOG_ARCHIVE + ulint arch_log_no; /*!< latest archived log file number */ +#endif /* UNIV_LOG_ARCHIVE */ +}; + #ifndef UNIV_HOTBACKUP /*******************************************************************//** Returns the version number of a tablespace, -1 if not found. @@ -985,5 +1001,17 @@ fil_mtr_rename_log( mtr_t* mtr) /*!< in/out: mini-transaction */ __attribute__((nonnull)); +/*******************************************************************//** +Finds the given page_no of the given space id from the double write buffer, +and copies it to the corresponding .ibd file. +@return true if copy was successful, or false. */ +bool +fil_user_tablespace_restore_page( +/*==============================*/ + fsp_open_info* fsp, /* in: contains space id and .ibd + file information */ + ulint page_no); /* in: page_no to obtain from double + write buffer */ + #endif /* !UNIV_INNOCHECKSUM */ #endif /* fil0fil_h */ diff --git a/storage/innobase/include/fts0priv.h b/storage/innobase/include/fts0priv.h index c6aca27f6ec..b4d9e1d41ec 100644 --- a/storage/innobase/include/fts0priv.h +++ b/storage/innobase/include/fts0priv.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2011, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2011, 2013, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -569,7 +569,10 @@ int fts_write_object_id( /*================*/ ib_id_t id, /*!< in: a table/index id */ - char* str) /*!< in: buffer to write the id to */ + char* str, /*!< in: buffer to write the id to */ + bool hex_format __attribute__((unused))) + /*!< in: true for fixed hex format, + false for old ambiguous format */ __attribute__((nonnull)); /******************************************************************//** Read the table id from the string generated by fts_write_object_id(). diff --git a/storage/innobase/include/fts0priv.ic b/storage/innobase/include/fts0priv.ic index 268bb7e2227..8ef877f267e 100644 --- a/storage/innobase/include/fts0priv.ic +++ b/storage/innobase/include/fts0priv.ic @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2011, 2011, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2011, 2013, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -32,9 +32,24 @@ int fts_write_object_id( /*================*/ ib_id_t id, /* in: a table/index id */ - char* str) /* in: buffer to write the id to */ + char* str, /* in: buffer to write the id to */ + bool hex_format __attribute__((unused))) + /* in: true for fixed hex format, + false for old ambiguous format */ { - // FIXME: Use ut_snprintf() +#ifdef _WIN32 + /* Use this to construct old(5.6.14 and 5.7.3) ambiguous + aux table names */ + DBUG_EXECUTE_IF("innodb_test_wrong_fts_aux_table_name", + return(sprintf(str, "%016llu", id));); + + /* As above, but this is only for those tables failing to rename. */ + if (!hex_format) { + // FIXME: Use ut_snprintf(), so does following one. + return(sprintf(str, "%016llu", id)); + } +#endif /* _WIN32 */ + return(sprintf(str, UINT64PFx, id)); } @@ -48,6 +63,9 @@ fts_read_object_id( ib_id_t* id, /* out: an id */ const char* str) /* in: buffer to read from */ { + /* NOTE: this func doesn't care about whether current table + is set with HEX_NAME, the user of the id read here will check + if the id is HEX or DEC and do the right thing with it. */ return(sscanf(str, UINT64PFx, id) == 1); } diff --git a/storage/innobase/include/ha_prototypes.h b/storage/innobase/include/ha_prototypes.h index e2c27acde31..a24a2b1d399 100644 --- a/storage/innobase/include/ha_prototypes.h +++ b/storage/innobase/include/ha_prototypes.h @@ -427,16 +427,6 @@ innobase_fts_text_case_cmp( const void* p1, /*!< in: key */ const void* p2); /*!< in: node */ -/******************************************************************//** -compare two character string according to their charset. */ -UNIV_INTERN -int -innobase_fts_string_cmp( -/*====================*/ - const void* cs, /*!< in: Character set */ - const void* p1, /*!< in: key */ - const void* p2); /*!< in: node */ - /****************************************************************//** Get FTS field charset info from the field's prtype @return charset info */ diff --git a/storage/innobase/include/lock0lock.h b/storage/innobase/include/lock0lock.h index 6ef6685b371..385853bdb68 100644 --- a/storage/innobase/include/lock0lock.h +++ b/storage/innobase/include/lock0lock.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1996, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -892,19 +892,15 @@ lock_trx_has_rec_x_lock( remains set when the waiting lock is granted, or if the lock is inherited to a neighboring record */ -#define LOCK_CONV_BY_OTHER 4096 /*!< this bit is set when the lock is created - by other transaction */ -#if (LOCK_WAIT|LOCK_GAP|LOCK_REC_NOT_GAP|LOCK_INSERT_INTENTION|LOCK_CONV_BY_OTHER)&LOCK_TYPE_MASK + +#if (LOCK_WAIT|LOCK_GAP|LOCK_REC_NOT_GAP|LOCK_INSERT_INTENTION)&LOCK_MODE_MASK +# error +#endif +#if (LOCK_WAIT|LOCK_GAP|LOCK_REC_NOT_GAP|LOCK_INSERT_INTENTION)&LOCK_TYPE_MASK # error #endif /* @} */ -/** Checks if this is a waiting lock created by lock->trx itself. -@param type_mode lock->type_mode -@return whether it is a waiting lock belonging to lock->trx */ -#define lock_is_wait_not_by_other(type_mode) \ - ((type_mode & (LOCK_CONV_BY_OTHER | LOCK_WAIT)) == LOCK_WAIT) - /** Lock operation struct */ struct lock_op_t{ dict_table_t* table; /*!< table to be locked */ diff --git a/storage/innobase/include/log0recv.h b/storage/innobase/include/log0recv.h index dcdd4bdd8aa..8ede49d4ecc 100644 --- a/storage/innobase/include/log0recv.h +++ b/storage/innobase/include/log0recv.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1997, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1997, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -31,6 +31,7 @@ Created 9/20/1997 Heikki Tuuri #include "buf0types.h" #include "hash0hash.h" #include "log0log.h" +#include <list> #ifdef UNIV_HOTBACKUP extern ibool recv_replay_file_ops; @@ -367,6 +368,18 @@ struct recv_addr_t{ hash_node_t addr_hash;/*!< hash node in the hash bucket chain */ }; +struct recv_dblwr_t { + void add(byte* page); + + byte* find_page(ulint space_id, ulint page_no); + + std::list<byte *> pages; /* Pages from double write buffer */ + + void operator() () { + pages.clear(); + } +}; + /** Recovery system data structure */ struct recv_sys_t{ #ifndef UNIV_HOTBACKUP @@ -431,6 +444,8 @@ struct recv_sys_t{ hash_table_t* addr_hash;/*!< hash table of file addresses of pages */ ulint n_addrs;/*!< number of not processed hashed file addresses in the hash table */ + + recv_dblwr_t dblwr; }; /** The recovery system */ diff --git a/storage/innobase/include/mem0mem.h b/storage/innobase/include/mem0mem.h index c36ef06b554..f30034f3074 100644 --- a/storage/innobase/include/mem0mem.h +++ b/storage/innobase/include/mem0mem.h @@ -92,18 +92,35 @@ void mem_close(void); /*===========*/ +#ifdef UNIV_DEBUG /**************************************************************//** Use this macro instead of the corresponding function! Macro for memory heap creation. */ -#define mem_heap_create(N) mem_heap_create_func(\ - (N), MEM_HEAP_DYNAMIC, __FILE__, __LINE__) +# define mem_heap_create(N) mem_heap_create_func( \ + (N), __FILE__, __LINE__, MEM_HEAP_DYNAMIC) /**************************************************************//** Use this macro instead of the corresponding function! Macro for memory heap creation. */ -#define mem_heap_create_typed(N, T) mem_heap_create_func(\ - (N), (T), __FILE__, __LINE__) +# define mem_heap_create_typed(N, T) mem_heap_create_func( \ + (N), __FILE__, __LINE__, (T)) + +#else /* UNIV_DEBUG */ +/**************************************************************//** +Use this macro instead of the corresponding function! Macro for memory +heap creation. */ + +# define mem_heap_create(N) mem_heap_create_func( \ + (N), MEM_HEAP_DYNAMIC) +/**************************************************************//** +Use this macro instead of the corresponding function! Macro for memory +heap creation. */ + +# define mem_heap_create_typed(N, T) mem_heap_create_func( \ + (N), (T)) + +#endif /* UNIV_DEBUG */ /**************************************************************//** Use this macro instead of the corresponding function! Macro for memory heap freeing. */ @@ -124,9 +141,11 @@ mem_heap_create_func( this means that a single user buffer of size n will fit in the block, 0 creates a default size block */ - ulint type, /*!< in: heap type */ +#ifdef UNIV_DEBUG const char* file_name, /*!< in: file name where created */ - ulint line); /*!< in: line where created */ + ulint line, /*!< in: line where created */ +#endif /* UNIV_DEBUG */ + ulint type); /*!< in: heap type */ /*****************************************************************//** NOTE: Use the corresponding macro instead of this function. Frees the space occupied by a memory heap. In the debug version erases the heap memory @@ -218,8 +237,14 @@ Macro for memory buffer allocation */ #define mem_zalloc(N) memset(mem_alloc(N), 0, (N)) -#define mem_alloc(N) mem_alloc_func((N), NULL, __FILE__, __LINE__) -#define mem_alloc2(N,S) mem_alloc_func((N), (S), __FILE__, __LINE__) +#ifdef UNIV_DEBUG +#define mem_alloc(N) mem_alloc_func((N), __FILE__, __LINE__, NULL) +#define mem_alloc2(N,S) mem_alloc_func((N), __FILE__, __LINE__, (S)) +#else /* UNIV_DEBUG */ +#define mem_alloc(N) mem_alloc_func((N), NULL) +#define mem_alloc2(N,S) mem_alloc_func((N), (S)) +#endif /* UNIV_DEBUG */ + /***************************************************************//** NOTE: Use the corresponding macro instead of this function. Allocates a single buffer of memory from the dynamic memory of @@ -231,10 +256,12 @@ void* mem_alloc_func( /*===========*/ ulint n, /*!< in: requested size in bytes */ - ulint* size, /*!< out: allocated size in bytes, - or NULL */ +#ifdef UNIV_DEBUG const char* file_name, /*!< in: file name where created */ - ulint line); /*!< in: line where created */ + ulint line, /*!< in: line where created */ +#endif /* UNIV_DEBUG */ + ulint* size); /*!< out: allocated size in bytes, + or NULL */ /**************************************************************//** Use this macro instead of the corresponding function! @@ -343,8 +370,10 @@ mem_validate_all_blocks(void); /** The info structure stored at the beginning of a heap block */ struct mem_block_info_t { ulint magic_n;/* magic number for debugging */ +#ifdef UNIV_DEBUG char file_name[8];/* file name where the mem heap was created */ ulint line; /*!< line number where the mem heap was created */ +#endif /* UNIV_DEBUG */ UT_LIST_BASE_NODE_T(mem_block_t) base; /* In the first block in the the list this is the base node of the list of blocks; in subsequent blocks this is undefined */ diff --git a/storage/innobase/include/mem0mem.ic b/storage/innobase/include/mem0mem.ic index 7f0e128cc40..0d983d69e1a 100644 --- a/storage/innobase/include/mem0mem.ic +++ b/storage/innobase/include/mem0mem.ic @@ -28,21 +28,34 @@ Created 6/8/1994 Heikki Tuuri # include "mem0pool.h" #endif /* !UNIV_HOTBACKUP */ +#ifdef UNIV_DEBUG +# define mem_heap_create_block(heap, n, type, file_name, line) \ + mem_heap_create_block_func(heap, n, file_name, line, type) +# define mem_heap_create_at(N, file_name, line) \ + mem_heap_create_func(N, file_name, line, MEM_HEAP_DYNAMIC) +#else /* UNIV_DEBUG */ +# define mem_heap_create_block(heap, n, type, file_name, line) \ + mem_heap_create_block_func(heap, n, type) +# define mem_heap_create_at(N, file_name, line) \ + mem_heap_create_func(N, MEM_HEAP_DYNAMIC) +#endif /* UNIV_DEBUG */ /***************************************************************//** Creates a memory heap block where data can be allocated. @return own: memory heap block, NULL if did not succeed (only possible for MEM_HEAP_BTR_SEARCH type heaps) */ UNIV_INTERN mem_block_t* -mem_heap_create_block( -/*==================*/ +mem_heap_create_block_func( +/*=======================*/ mem_heap_t* heap, /*!< in: memory heap or NULL if first block should be created */ ulint n, /*!< in: number of bytes needed for user data */ - ulint type, /*!< in: type of heap: MEM_HEAP_DYNAMIC or - MEM_HEAP_BUFFER */ +#ifdef UNIV_DEBUG const char* file_name,/*!< in: file name where created */ - ulint line); /*!< in: line where created */ + ulint line, /*!< in: line where created */ +#endif /* UNIV_DEBUG */ + ulint type); /*!< in: type of heap: MEM_HEAP_DYNAMIC or + MEM_HEAP_BUFFER */ /******************************************************************//** Frees a block from a memory heap. */ UNIV_INTERN @@ -421,9 +434,11 @@ mem_heap_create_func( this means that a single user buffer of size n will fit in the block, 0 creates a default size block */ - ulint type, /*!< in: heap type */ +#ifdef UNIV_DEBUG const char* file_name, /*!< in: file name where created */ - ulint line) /*!< in: line where created */ + ulint line, /*!< in: line where created */ +#endif /* UNIV_DEBUG */ + ulint type) /*!< in: heap type */ { mem_block_t* block; @@ -509,15 +524,17 @@ void* mem_alloc_func( /*===========*/ ulint n, /*!< in: desired number of bytes */ - ulint* size, /*!< out: allocated size in bytes, - or NULL */ +#ifdef UNIV_DEBUG const char* file_name, /*!< in: file name where created */ - ulint line) /*!< in: line where created */ + ulint line, /*!< in: line where created */ +#endif /* UNIV_DEBUG */ + ulint* size) /*!< out: allocated size in bytes, + or NULL */ { mem_heap_t* heap; void* buf; - heap = mem_heap_create_func(n, MEM_HEAP_DYNAMIC, file_name, line); + heap = mem_heap_create_at(n, file_name, line); /* Note that as we created the first block in the heap big enough for the buffer requested by the caller, the buffer will be in the diff --git a/storage/innobase/include/os0file.h b/storage/innobase/include/os0file.h index f19d61e0137..8e2948e2d68 100644 --- a/storage/innobase/include/os0file.h +++ b/storage/innobase/include/os0file.h @@ -1,6 +1,6 @@ /*********************************************************************** -Copyright (c) 1995, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1995, 2013, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2009, Percona Inc. Portions of this file contain modifications contributed and copyrighted @@ -150,6 +150,10 @@ enum os_file_create_t { #define OS_FILE_INSUFFICIENT_RESOURCE 78 #define OS_FILE_AIO_INTERRUPTED 79 #define OS_FILE_OPERATION_ABORTED 80 + +#define OS_FILE_ACCESS_VIOLATION 81 + +#define OS_FILE_ERROR_MAX 100 /* @} */ /** Types for aio operations @{ */ @@ -381,7 +385,8 @@ enum os_file_type_t { OS_FILE_TYPE_UNKNOWN = 0, OS_FILE_TYPE_FILE, /* regular file */ OS_FILE_TYPE_DIR, /* directory */ - OS_FILE_TYPE_LINK /* symbolic link */ + OS_FILE_TYPE_LINK, /* symbolic link */ + OS_FILE_TYPE_BLOCK /* block device */ }; /* Maximum path string length in bytes when referring to tables with in the diff --git a/storage/innobase/include/os0sync.h b/storage/innobase/include/os0sync.h index d3ce68253ec..9b4ce2343c5 100644 --- a/storage/innobase/include/os0sync.h +++ b/storage/innobase/include/os0sync.h @@ -374,6 +374,9 @@ compare to, new_val is the value to swap in. */ # define os_compare_and_swap_lint(ptr, old_val, new_val) \ os_compare_and_swap(ptr, old_val, new_val) +# define os_compare_and_swap_uint32(ptr, old_val, new_val) \ + os_compare_and_swap(ptr, old_val, new_val) + # ifdef HAVE_IB_ATOMIC_PTHREAD_T_GCC # define os_compare_and_swap_thread_id(ptr, old_val, new_val) \ os_compare_and_swap(ptr, old_val, new_val) @@ -395,6 +398,9 @@ amount of increment. */ # define os_atomic_increment_lint(ptr, amount) \ os_atomic_increment(ptr, amount) +# define os_atomic_increment_uint32(ptr, amount ) \ + os_atomic_increment(ptr, amount) + # define os_atomic_increment_ulint(ptr, amount) \ os_atomic_increment(ptr, amount) @@ -407,6 +413,9 @@ amount to decrement. */ # define os_atomic_decrement(ptr, amount) \ __sync_sub_and_fetch(ptr, amount) +# define os_atomic_decrement_uint32(ptr, amount) \ + os_atomic_decrement(ptr, amount) + # define os_atomic_decrement_lint(ptr, amount) \ os_atomic_decrement(ptr, amount) @@ -439,6 +448,9 @@ intrinsics and running on Solaris >= 10 use Solaris atomics */ Returns true if swapped, ptr is pointer to target, old_val is value to compare to, new_val is the value to swap in. */ +# define os_compare_and_swap_uint32(ptr, old_val, new_val) \ + (atomic_cas_32(ptr, old_val, new_val) == old_val) + # define os_compare_and_swap_ulint(ptr, old_val, new_val) \ (atomic_cas_ulong(ptr, old_val, new_val) == old_val) @@ -467,6 +479,9 @@ compare to, new_val is the value to swap in. */ Returns the resulting value, ptr is pointer to target, amount is the amount of increment. */ +# define os_atomic_increment_uint32(ptr, amount) \ + atomic_add_32_nv(ptr, amount) + # define os_atomic_increment_ulint(ptr, amount) \ atomic_add_long_nv(ptr, amount) @@ -479,6 +494,9 @@ amount of increment. */ /* Returns the resulting value, ptr is pointer to target, amount is the amount to decrement. */ +# define os_atomic_decrement_uint32(ptr, amount) \ + os_atomic_increment_uint32(ptr, -(amount)) + # define os_atomic_decrement_lint(ptr, amount) \ os_atomic_increment_ulint((ulong_t*) ptr, -(amount)) @@ -555,6 +573,9 @@ win_cmp_and_xchg_dword( Returns true if swapped, ptr is pointer to target, old_val is value to compare to, new_val is the value to swap in. */ +# define os_compare_and_swap_uint32(ptr, old_val, new_val) \ + (win_cmp_and_xchg_dword(ptr, new_val, old_val) == old_val) + # define os_compare_and_swap_ulint(ptr, old_val, new_val) \ (win_cmp_and_xchg_ulint(ptr, new_val, old_val) == old_val) @@ -576,6 +597,9 @@ amount of increment. */ # define os_atomic_increment_lint(ptr, amount) \ (win_xchg_and_add(ptr, amount) + amount) +# define os_atomic_increment_uint32(ptr, amount) \ + ((ulint) InterlockedExchangeAdd((long*) ptr, amount)) + # define os_atomic_increment_ulint(ptr, amount) \ ((ulint) (win_xchg_and_add((lint*) ptr, (lint) amount) + amount)) @@ -588,6 +612,9 @@ amount of increment. */ Returns the resulting value, ptr is pointer to target, amount is the amount to decrement. There is no atomic substract function on Windows */ +# define os_atomic_decrement_uint32(ptr, amount) \ + ((ulint) InterlockedExchangeAdd((long*) ptr, (-amount))) + # define os_atomic_decrement_lint(ptr, amount) \ (win_xchg_and_add(ptr, -(lint) amount) - amount) diff --git a/storage/innobase/include/os0sync.ic b/storage/innobase/include/os0sync.ic index 33c238ceb47..9a7e520ece6 100644 --- a/storage/innobase/include/os0sync.ic +++ b/storage/innobase/include/os0sync.ic @@ -112,8 +112,10 @@ pfs_os_fast_mutex_lock( PSI_mutex_locker* locker; PSI_mutex_locker_state state; - locker = PSI_MUTEX_CALL(start_mutex_wait)(&state, fast_mutex->pfs_psi, - PSI_MUTEX_LOCK, file_name, line); + locker = PSI_MUTEX_CALL(start_mutex_wait)( + &state, fast_mutex->pfs_psi, + PSI_MUTEX_LOCK, file_name, + static_cast<uint>(line)); os_fast_mutex_lock_func(&fast_mutex->mutex); diff --git a/storage/innobase/include/page0page.h b/storage/innobase/include/page0page.h index fb21aaec778..b572f7abb49 100644 --- a/storage/innobase/include/page0page.h +++ b/storage/innobase/include/page0page.h @@ -1102,6 +1102,14 @@ page_find_rec_with_heap_no( /*=======================*/ const page_t* page, /*!< in: index page */ ulint heap_no);/*!< in: heap number */ +/** Get the last non-delete-marked record on a page. +@param[in] page index tree leaf page +@return the last record, not delete-marked +@retval infimum record if all records are delete-marked */ + +const rec_t* +page_find_rec_max_not_deleted( + const page_t* page); #ifdef UNIV_MATERIALIZE #undef UNIV_INLINE #define UNIV_INLINE UNIV_INLINE_ORIGINAL diff --git a/storage/innobase/include/page0page.ic b/storage/innobase/include/page0page.ic index 1410f21b670..9b81156708f 100644 --- a/storage/innobase/include/page0page.ic +++ b/storage/innobase/include/page0page.ic @@ -414,6 +414,8 @@ page_rec_is_user_rec( /*=================*/ const rec_t* rec) /*!< in: record */ { + ut_ad(page_rec_check(rec)); + return(page_rec_is_user_rec_low(page_offset(rec))); } @@ -426,6 +428,8 @@ page_rec_is_supremum( /*=================*/ const rec_t* rec) /*!< in: record */ { + ut_ad(page_rec_check(rec)); + return(page_rec_is_supremum_low(page_offset(rec))); } @@ -438,6 +442,8 @@ page_rec_is_infimum( /*================*/ const rec_t* rec) /*!< in: record */ { + ut_ad(page_rec_check(rec)); + return(page_rec_is_infimum_low(page_offset(rec))); } diff --git a/storage/innobase/include/rem0rec.h b/storage/innobase/include/rem0rec.h index fc60965e089..238cb04e1f8 100644 --- a/storage/innobase/include/rem0rec.h +++ b/storage/innobase/include/rem0rec.h @@ -440,13 +440,24 @@ rec_get_offsets_func( ulint n_fields,/*!< in: maximum number of initialized fields (ULINT_UNDEFINED if all fields) */ - mem_heap_t** heap, /*!< in/out: memory heap */ +#ifdef UNIV_DEBUG const char* file, /*!< in: file name where called */ - ulint line) /*!< in: line number where called */ - __attribute__((nonnull(1,2,5,6),warn_unused_result)); + ulint line, /*!< in: line number where called */ +#endif /* UNIV_DEBUG */ + mem_heap_t** heap) /*!< in/out: memory heap */ +#ifdef UNIV_DEBUG + __attribute__((nonnull(1,2,5,7),warn_unused_result)); +#else /* UNIV_DEBUG */ + __attribute__((nonnull(1,2,5),warn_unused_result)); +#endif /* UNIV_DEBUG */ -#define rec_get_offsets(rec,index,offsets,n,heap) \ - rec_get_offsets_func(rec,index,offsets,n,heap,__FILE__,__LINE__) +#ifdef UNIV_DEBUG +# define rec_get_offsets(rec,index,offsets,n,heap) \ + rec_get_offsets_func(rec,index,offsets,n,__FILE__,__LINE__,heap) +#else /* UNIV_DEBUG */ +# define rec_get_offsets(rec, index, offsets, n, heap) \ + rec_get_offsets_func(rec, index, offsets, n, heap) +#endif /* UNIV_DEBUG */ /******************************************************//** The following function determines the offsets to each field diff --git a/storage/innobase/include/row0log.h b/storage/innobase/include/row0log.h index 41dac63963d..62715fe8808 100644 --- a/storage/innobase/include/row0log.h +++ b/storage/innobase/include/row0log.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2011, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2011, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -122,10 +122,9 @@ row_log_table_delete( dict_index_t* index, /*!< in/out: clustered index, S-latched or X-latched */ const ulint* offsets,/*!< in: rec_get_offsets(rec,index) */ - bool purge, /*!< in: true=purging BLOBs */ - trx_id_t trx_id) /*!< in: DB_TRX_ID of the record before - it was deleted */ - UNIV_COLD __attribute__((nonnull)); + const byte* sys) /*!< in: DB_TRX_ID,DB_ROLL_PTR that should + be logged, or NULL to use those in rec */ + UNIV_COLD __attribute__((nonnull(1,2,3))); /******************************************************//** Logs an update operation to a table that is being rebuilt. @@ -158,8 +157,10 @@ row_log_table_get_pk( or X-latched */ const ulint* offsets,/*!< in: rec_get_offsets(rec,index), or NULL */ + byte* sys, /*!< out: DB_TRX_ID,DB_ROLL_PTR for + row_log_table_delete(), or NULL */ mem_heap_t** heap) /*!< in/out: memory heap where allocated */ - UNIV_COLD __attribute__((nonnull(1,2,4), warn_unused_result)); + UNIV_COLD __attribute__((nonnull(1,2,5), warn_unused_result)); /******************************************************//** Logs an insert to a table that is being rebuilt. diff --git a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h index 3101a463158..7922b14cc86 100644 --- a/storage/innobase/include/srv0srv.h +++ b/storage/innobase/include/srv0srv.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved. +Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved. Copyright (c) 2008, 2009, Google Inc. Copyright (c) 2009, Percona Inc. @@ -364,8 +364,8 @@ extern ulong srv_max_purge_lag_delay; extern ulong srv_replication_delay; /*-------------------------------------------*/ -extern ibool srv_print_innodb_monitor; -extern ibool srv_print_innodb_lock_monitor; +extern my_bool srv_print_innodb_monitor; +extern my_bool srv_print_innodb_lock_monitor; extern ibool srv_print_innodb_tablespace_monitor; extern ibool srv_print_verbose_log; #define DEPRECATED_MSG_INNODB_TABLE_MONITOR \ diff --git a/storage/innobase/include/sync0rw.h b/storage/innobase/include/sync0rw.h index c268098d1ea..34cd8ef4bd6 100644 --- a/storage/innobase/include/sync0rw.h +++ b/storage/innobase/include/sync0rw.h @@ -181,6 +181,9 @@ unlocking, not the corresponding function. */ # define rw_lock_s_lock_gen(M, P) \ rw_lock_s_lock_func((M), (P), __FILE__, __LINE__) +# define rw_lock_s_lock_gen_nowait(M, P) \ + rw_lock_s_lock_low((M), (P), __FILE__, __LINE__) + # define rw_lock_s_lock_nowait(M, F, L) \ rw_lock_s_lock_low((M), 0, (F), (L)) @@ -243,6 +246,9 @@ unlocking, not the corresponding function. */ # define rw_lock_s_lock_gen(M, P) \ pfs_rw_lock_s_lock_func((M), (P), __FILE__, __LINE__) +# define rw_lock_s_lock_gen_nowait(M, P) \ + pfs_rw_lock_s_lock_low((M), (P), __FILE__, __LINE__) + # define rw_lock_s_lock_nowait(M, F, L) \ pfs_rw_lock_s_lock_low((M), 0, (F), (L)) diff --git a/storage/innobase/include/sync0rw.ic b/storage/innobase/include/sync0rw.ic index 8786ad84643..467a8b4eb44 100644 --- a/storage/innobase/include/sync0rw.ic +++ b/storage/innobase/include/sync0rw.ic @@ -380,8 +380,6 @@ rw_lock_x_lock_func_nowait( const char* file_name,/*!< in: file name where lock requested */ ulint line) /*!< in: line where requested */ { - os_thread_id_t curr_thread = os_thread_get_curr_id(); - ibool success; #ifdef INNODB_RW_LOCKS_USE_ATOMICS @@ -401,7 +399,8 @@ rw_lock_x_lock_func_nowait( rw_lock_set_writer_id_and_recursion_flag(lock, TRUE); } else if (lock->recursive - && os_thread_eq(lock->writer_thread, curr_thread)) { + && os_thread_eq(lock->writer_thread, + os_thread_get_curr_id())) { /* Relock: this lock_word modification is safe since no other threads can modify (lock, unlock, or reserve) lock_word while there is an exclusive writer and this is the writer thread. */ @@ -582,12 +581,15 @@ pfs_rw_lock_x_lock_func( /* Record the entry of rw x lock request in performance schema */ locker = PSI_RWLOCK_CALL(start_rwlock_wrwait)( - &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK, file_name, line); + &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK, + file_name, static_cast<uint>(line)); - rw_lock_x_lock_func(lock, pass, file_name, line); + rw_lock_x_lock_func( + lock, pass, file_name, static_cast<uint>(line)); - if (locker != NULL) + if (locker != NULL) { PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, 0); + } } else { @@ -618,12 +620,15 @@ pfs_rw_lock_x_lock_func_nowait( /* Record the entry of rw x lock request in performance schema */ locker = PSI_RWLOCK_CALL(start_rwlock_wrwait)( - &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK, file_name, line); + &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK, + file_name, static_cast<uint>(line)); ret = rw_lock_x_lock_func_nowait(lock, file_name, line); - if (locker != NULL) - PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, ret); + if (locker != NULL) { + PSI_RWLOCK_CALL(end_rwlock_wrwait)( + locker, static_cast<int>(ret)); + } } else { @@ -673,12 +678,14 @@ pfs_rw_lock_s_lock_func( /* Instrumented to inform we are aquiring a shared rwlock */ locker = PSI_RWLOCK_CALL(start_rwlock_rdwait)( - &state, lock->pfs_psi, PSI_RWLOCK_READLOCK, file_name, line); + &state, lock->pfs_psi, PSI_RWLOCK_READLOCK, + file_name, static_cast<uint>(line)); rw_lock_s_lock_func(lock, pass, file_name, line); - if (locker != NULL) + if (locker != NULL) { PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, 0); + } } else { @@ -712,12 +719,15 @@ pfs_rw_lock_s_lock_low( /* Instrumented to inform we are aquiring a shared rwlock */ locker = PSI_RWLOCK_CALL(start_rwlock_rdwait)( - &state, lock->pfs_psi, PSI_RWLOCK_READLOCK, file_name, line); + &state, lock->pfs_psi, PSI_RWLOCK_READLOCK, + file_name, static_cast<uint>(line)); ret = rw_lock_s_lock_low(lock, pass, file_name, line); - if (locker != NULL) - PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, ret); + if (locker != NULL) { + PSI_RWLOCK_CALL(end_rwlock_rdwait)( + locker, static_cast<int>(ret)); + } } else { diff --git a/storage/innobase/include/sync0sync.ic b/storage/innobase/include/sync0sync.ic index cc087559fb7..f34f3f90b63 100644 --- a/storage/innobase/include/sync0sync.ic +++ b/storage/innobase/include/sync0sync.ic @@ -243,7 +243,8 @@ pfs_mutex_enter_func( locker = PSI_MUTEX_CALL(start_mutex_wait)( &state, mutex->pfs_psi, - PSI_MUTEX_LOCK, file_name, line); + PSI_MUTEX_LOCK, file_name, + static_cast<uint>(line)); mutex_enter_func(mutex, file_name, line); @@ -278,7 +279,8 @@ pfs_mutex_enter_nowait_func( locker = PSI_MUTEX_CALL(start_mutex_wait)( &state, mutex->pfs_psi, - PSI_MUTEX_TRYLOCK, file_name, line); + PSI_MUTEX_TRYLOCK, file_name, + static_cast<uint>(line)); ret = mutex_enter_nowait_func(mutex, file_name, line); diff --git a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h index 0d3711f567d..a30bbdbebb2 100644 --- a/storage/innobase/include/trx0trx.h +++ b/storage/innobase/include/trx0trx.h @@ -836,8 +836,7 @@ struct trx_t{ when trx->in_rw_trx_list. Initially set to TRX_ID_MAX. */ - time_t start_time; /*!< time the trx object was created - or the state last time became + time_t start_time; /*!< time the trx state last time became TRX_STATE_ACTIVE */ trx_id_t id; /*!< transaction id */ XID xid; /*!< X/Open XA transaction diff --git a/storage/innobase/include/univ.i b/storage/innobase/include/univ.i index 9b5fffe81e8..98c5512bd0b 100644 --- a/storage/innobase/include/univ.i +++ b/storage/innobase/include/univ.i @@ -44,7 +44,7 @@ Created 1/20/1994 Heikki Tuuri #define INNODB_VERSION_MAJOR 5 #define INNODB_VERSION_MINOR 6 -#define INNODB_VERSION_BUGFIX 15 +#define INNODB_VERSION_BUGFIX 17 /* The following is the InnoDB version as shown in SELECT plugin_version FROM information_schema.plugins; @@ -171,7 +171,6 @@ command. Not tested on Windows. */ #define UNIV_COMPILE_TEST_FUNCS */ -#undef UNIV_SYNC_DEBUG #if defined(HAVE_valgrind)&& defined(HAVE_VALGRIND_MEMCHECK_H) # define UNIV_DEBUG_VALGRIND #endif /* HAVE_VALGRIND */ @@ -433,7 +432,7 @@ macro ULINTPF. */ # define UINT32PF "%I32u" # define INT64PF "%I64d" # define UINT64PF "%I64u" -# define UINT64PFx "%016I64u" +# define UINT64PFx "%016I64x" # define DBUG_LSN_PF "%llu" typedef __int64 ib_int64_t; typedef unsigned __int64 ib_uint64_t; diff --git a/storage/innobase/include/ut0ut.h b/storage/innobase/include/ut0ut.h index 1260e0381bf..7d1c3cd4f0b 100644 --- a/storage/innobase/include/ut0ut.h +++ b/storage/innobase/include/ut0ut.h @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1994, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1994, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -51,6 +51,19 @@ Created 1/20/1994 Heikki Tuuri /** Time stamp */ typedef time_t ib_time_t; +/* In order to call a piece of code, when a function returns or when the +scope ends, use this utility class. It will invoke the given function +object in its destructor. */ +template<typename F> +struct ut_when_dtor { + ut_when_dtor(F& p) : f(p) {} + ~ut_when_dtor() { + f(); + } +private: + F& f; +}; + #ifndef UNIV_HOTBACKUP # if defined(HAVE_PAUSE_INSTRUCTION) /* According to the gcc info page, asm volatile means that the diff --git a/storage/innobase/lock/lock0lock.cc b/storage/innobase/lock/lock0lock.cc index ae32738cb17..a9556b49ac6 100644 --- a/storage/innobase/lock/lock0lock.cc +++ b/storage/innobase/lock/lock0lock.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1996, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -858,16 +858,11 @@ lock_reset_lock_and_trx_wait( /*=========================*/ lock_t* lock) /*!< in/out: record lock */ { + ut_ad(lock->trx->lock.wait_lock == lock); ut_ad(lock_get_wait(lock)); ut_ad(lock_mutex_own()); - /* Reset the back pointer in trx to this waiting lock request */ - if (!(lock->type_mode & LOCK_CONV_BY_OTHER)) { - ut_ad(lock->trx->lock.wait_lock == lock); - lock->trx->lock.wait_lock = NULL; - } else { - ut_ad(lock_get_type_low(lock) == LOCK_REC); - } + lock->trx->lock.wait_lock = NULL; lock->type_mode &= ~LOCK_WAIT; } @@ -1550,11 +1545,11 @@ lock_rec_has_expl( if (lock->trx == trx && !lock_rec_get_insert_intention(lock) - && !lock_is_wait_not_by_other(lock->type_mode) && lock_mode_stronger_or_eq( lock_get_mode(lock), static_cast<enum lock_mode>( precise_mode & LOCK_MODE_MASK)) + && !lock_get_wait(lock) && (!lock_rec_get_rec_not_gap(lock) || (precise_mode & LOCK_REC_NOT_GAP) || heap_no == PAGE_HEAP_NO_SUPREMUM) @@ -1802,6 +1797,57 @@ lock_sec_rec_some_has_impl( return(trx_id); } +#ifdef UNIV_DEBUG +/*********************************************************************//** +Checks if some transaction, other than given trx_id, has an explicit +lock on the given rec, in the given precise_mode. +@return the transaction, whose id is not equal to trx_id, that has an +explicit lock on the given rec, in the given precise_mode or NULL.*/ +static +trx_t* +lock_rec_other_trx_holds_expl( +/*==========================*/ + ulint precise_mode, /*!< in: LOCK_S or LOCK_X + possibly ORed to LOCK_GAP or + LOCK_REC_NOT_GAP. */ + trx_id_t trx_id, /*!< in: trx holding implicit + lock on rec */ + const rec_t* rec, /*!< in: user record */ + const buf_block_t* block) /*!< in: buffer block + containing the record */ +{ + trx_t* holds = NULL; + + lock_mutex_enter(); + + if (trx_t *impl_trx = trx_rw_is_active(trx_id, NULL)) { + ulint heap_no = page_rec_get_heap_no(rec); + mutex_enter(&trx_sys->mutex); + + for (trx_t* t = UT_LIST_GET_FIRST(trx_sys->rw_trx_list); + t != NULL; + t = UT_LIST_GET_NEXT(trx_list, t)) { + + lock_t *expl_lock = lock_rec_has_expl( + precise_mode, block, heap_no, t); + + if (expl_lock && expl_lock->trx != impl_trx) { + /* An explicit lock is held by trx other than + the trx holding the implicit lock. */ + holds = expl_lock->trx; + break; + } + } + + mutex_exit(&trx_sys->mutex); + } + + lock_mutex_exit(); + + return(holds); +} +#endif /* UNIV_DEBUG */ + /*********************************************************************//** Return approximate number or record locks (bits set in the bitmap) for this transaction. Since delete-marked records may be removed, the @@ -2022,7 +2068,7 @@ lock_rec_create( } ut_ad(trx_mutex_own(trx)); - if (lock_is_wait_not_by_other(type_mode)) { + if (type_mode & LOCK_WAIT) { lock_set_lock_and_trx_wait(lock, trx); } @@ -2065,12 +2111,11 @@ lock_rec_enqueue_waiting( const buf_block_t* block, /*!< in: buffer block containing the record */ ulint heap_no,/*!< in: heap number of the record */ - lock_t* lock, /*!< in: lock object; NULL if a new - one should be created. */ dict_index_t* index, /*!< in: index of record */ que_thr_t* thr) /*!< in: query thread */ { trx_t* trx; + lock_t* lock; trx_id_t victim_trx_id; ut_ad(lock_mutex_own()); @@ -2108,31 +2153,13 @@ lock_rec_enqueue_waiting( ut_ad(0); } - if (lock == NULL) { - /* Enqueue the lock request that will wait - to be granted, note that we already own - the trx mutex. */ + /* Enqueue the lock request that will wait to be granted, note that + we already own the trx mutex. */ + lock = lock_rec_create( #ifdef WITH_WSREP - if (wsrep_on(trx->mysql_thd) && - trx->lock.was_chosen_as_deadlock_victim) { - return(DB_DEADLOCK); - } - lock = lock_rec_create( - c_lock, thr, - type_mode | LOCK_WAIT, block, heap_no, - index, trx, TRUE); -#else - lock = lock_rec_create( - type_mode | LOCK_WAIT, block, heap_no, - index, trx, TRUE); -#endif /*WITH_WSREP */ - } else { - ut_ad(lock->type_mode & LOCK_WAIT); - ut_ad(lock->type_mode & LOCK_CONV_BY_OTHER); - - lock->type_mode &= ~LOCK_CONV_BY_OTHER; - lock_set_lock_and_trx_wait(lock, trx); - } + c_lock, thr, +#endif /* WITH_WSREP */ + type_mode | LOCK_WAIT, block, heap_no, index, trx, TRUE); /* Release the mutex to obey the latching order. This is safe, because lock_deadlock_check_and_resolve() @@ -2428,7 +2455,6 @@ lock_rec_lock_slow( #ifdef WITH_WSREP lock_t* c_lock(NULL); #endif - lock_t* lock; dberr_t err = DB_SUCCESS; ut_ad(lock_mutex_own()); @@ -2448,26 +2474,7 @@ lock_rec_lock_slow( trx = thr_get_trx(thr); trx_mutex_enter(trx); - lock = lock_rec_has_expl(mode, block, heap_no, trx); - if (lock) { - if (lock->type_mode & LOCK_CONV_BY_OTHER) { - /* This lock or lock waiting was created by the other - transaction, not by the transaction (trx) itself. - So, the transaction (trx) should treat it collectly - according as whether granted or not. */ - - if (lock->type_mode & LOCK_WAIT) { - /* This lock request was not granted yet. - Should wait for granted. */ - - goto enqueue_waiting; - } else { - /* This lock request was already granted. - Just clearing the flag. */ - - lock->type_mode &= ~LOCK_CONV_BY_OTHER; - } - } + if (lock_rec_has_expl(mode, block, heap_no, trx)) { /* The trx already has a strong enough lock on rec: do nothing */ @@ -2486,18 +2493,15 @@ lock_rec_lock_slow( have a lock strong enough already granted on the record, we have to wait. */ - ut_ad(lock == NULL); -enqueue_waiting: #ifdef WITH_WSREP /* c_lock is NULL here if jump to enqueue_waiting happened but it's ok because lock is not NULL in that case and c_lock is not used. */ - err = lock_rec_enqueue_waiting( - c_lock, mode, block, heap_no, - lock, index, thr); + err= + lock_rec_enqueue_waiting(c_lock, mode, block, heap_no, index, thr); #else err = lock_rec_enqueue_waiting( - mode, block, heap_no, lock, index, thr); + mode, block, heap_no, index, thr); #endif /* WITH_WSREP */ } else if (!impl) { @@ -2594,7 +2598,7 @@ lock_rec_has_to_wait_in_queue( heap_no = lock_rec_find_set_bit(wait_lock); bit_offset = heap_no / 8; - bit_mask = 1 << (heap_no % 8); + bit_mask = static_cast<ulint>(1 << (heap_no % 8)); for (lock = lock_rec_get_first_on_page_addr(space, page_no); lock != wait_lock; @@ -2654,8 +2658,7 @@ lock_grant( TRX_QUE_LOCK_WAIT state, and there is no need to end the lock wait for it */ - if (!(lock->type_mode & LOCK_CONV_BY_OTHER) - && lock->trx->lock.que_state == TRX_QUE_LOCK_WAIT) { + if (lock->trx->lock.que_state == TRX_QUE_LOCK_WAIT) { que_thr_t* thr; thr = que_thr_end_lock_wait(lock->trx); @@ -2682,7 +2685,6 @@ lock_rec_cancel( ut_ad(lock_mutex_own()); ut_ad(lock_get_type_low(lock) == LOCK_REC); - ut_ad(!(lock->type_mode & LOCK_CONV_BY_OTHER)); /* Reset the bit (there can be only one set bit) in the lock bitmap */ lock_rec_reset_nth_bit(lock, lock_rec_find_set_bit(lock)); @@ -2849,12 +2851,8 @@ lock_rec_reset_and_release_wait( lock != NULL; lock = lock_rec_get_next(heap_no, lock)) { - if (lock_is_wait_not_by_other(lock->type_mode)) { + if (lock_get_wait(lock)) { lock_rec_cancel(lock); - } else if (lock_get_wait(lock)) { - /* just reset LOCK_WAIT */ - lock_rec_reset_nth_bit(lock, heap_no); - lock_reset_lock_and_trx_wait(lock); } else { lock_rec_reset_nth_bit(lock, heap_no); } @@ -4181,7 +4179,7 @@ lock_deadlock_search( } ut_a(lock == NULL && ctx->depth == 0); - + /* No deadlock found. */ return(0); } @@ -4345,7 +4343,6 @@ lock_table_create( ut_ad(table && trx); ut_ad(lock_mutex_own()); ut_ad(trx_mutex_own(trx)); - ut_ad(!(type_mode & LOCK_CONV_BY_OTHER)); /* Non-locking autocommit read-only transactions should not set any locks. */ @@ -5551,11 +5548,14 @@ lock_print_info_summary( the state of the variable for display. */ switch (purge_sys->state){ - case PURGE_STATE_EXIT: case PURGE_STATE_INIT: /* Should never be in this state while the system is running. */ ut_error; + case PURGE_STATE_EXIT: + fprintf(file, "exited"); + break; + case PURGE_STATE_DISABLED: fprintf(file, "disabled"); break; @@ -6349,11 +6349,11 @@ lock_rec_insert_check_and_lock( #ifdef WITH_WSREP err = lock_rec_enqueue_waiting(c_lock, LOCK_X | LOCK_GAP | LOCK_INSERT_INTENTION, - block, next_rec_heap_no, NULL, index, thr); + block, next_rec_heap_no, index, thr); #else err = lock_rec_enqueue_waiting( LOCK_X | LOCK_GAP | LOCK_INSERT_INTENTION, - block, next_rec_heap_no, NULL, index, thr); + block, next_rec_heap_no, index, thr); #endif /* WITH_WSREP */ trx_mutex_exit(trx); @@ -6432,6 +6432,9 @@ lock_rec_convert_impl_to_expl( /* The transaction can be committed before the trx_is_active(trx_id, NULL) check below, because we are not holding lock_mutex. */ + + ut_ad(!lock_rec_other_trx_holds_expl(LOCK_S | LOCK_REC_NOT_GAP, + trx_id, rec, block)); } if (trx_id != 0) { @@ -6450,29 +6453,10 @@ lock_rec_convert_impl_to_expl( if (impl_trx != NULL && !lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, block, - heap_no, impl_trx)) { + heap_no, impl_trx)) { ulint type_mode = (LOCK_REC | LOCK_X | LOCK_REC_NOT_GAP); - /* If the delete-marked record was locked already, - we should reserve lock waiting for impl_trx as - implicit lock. Because cannot lock at this moment.*/ - - if (rec_get_deleted_flag(rec, rec_offs_comp(offsets)) -#ifdef WITH_WSREP - && !wsrep_thd_is_BF(impl_trx->mysql_thd, FALSE) - /* BF-BF conflict is possible if advancing into - lock_rec_other_has_conflicting*/ -#endif /* WITH_WSREP */ - && lock_rec_other_has_conflicting( - static_cast<enum lock_mode> - (LOCK_X | LOCK_REC_NOT_GAP), block, - heap_no, impl_trx)) { - - type_mode |= (LOCK_WAIT - | LOCK_CONV_BY_OTHER); - } - lock_rec_add_to_queue( type_mode, block, heap_no, index, impl_trx, FALSE); @@ -7120,7 +7104,6 @@ lock_cancel_waiting_and_release( ut_ad(lock_mutex_own()); ut_ad(trx_mutex_own(lock->trx)); - ut_ad(!(lock->type_mode & LOCK_CONV_BY_OTHER)); lock->trx->lock.cancel = TRUE; diff --git a/storage/innobase/log/log0recv.cc b/storage/innobase/log/log0recv.cc index e7a643b516a..a521e098598 100644 --- a/storage/innobase/log/log0recv.cc +++ b/storage/innobase/log/log0recv.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1997, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1997, 2014, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2012, Facebook Inc. This program is free software; you can redistribute it and/or modify it under @@ -24,6 +24,11 @@ Recovery Created 9/20/1997 Heikki Tuuri *******************************************************/ +// First include (the generated) my_config.h, to get correct platform defines. +#include "my_config.h" +#include <stdio.h> // Solaris/x86 header file bug + +#include <vector> #include "log0recv.h" #ifdef UNIV_NONINL @@ -52,6 +57,7 @@ Created 9/20/1997 Heikki Tuuri # include "sync0sync.h" #else /* !UNIV_HOTBACKUP */ + /** This is set to FALSE if the backup was originally taken with the ibbackup --include regexp option: then we do not want to create tables in directories which were not included */ @@ -422,6 +428,9 @@ recv_sys_init( recv_max_page_lsn = 0; + /* Call the constructor for recv_sys_t::dblwr member */ + new (&recv_sys->dblwr) recv_dblwr_t(); + mutex_exit(&(recv_sys->mutex)); } @@ -1311,13 +1320,22 @@ recv_parse_or_apply_log_rec_body( ptr = mlog_parse_string(ptr, end_ptr, page, page_zip); break; case MLOG_FILE_RENAME: - ptr = fil_op_log_parse_or_replay(ptr, end_ptr, type, - space_id, 0); + /* Do not rerun file-based log entries if this is + IO completion from a page read. */ + if (page == NULL) { + ptr = fil_op_log_parse_or_replay(ptr, end_ptr, type, + space_id, 0); + } break; case MLOG_FILE_CREATE: case MLOG_FILE_DELETE: case MLOG_FILE_CREATE2: - ptr = fil_op_log_parse_or_replay(ptr, end_ptr, type, 0, 0); + /* Do not rerun file-based log entries if this is + IO completion from a page read. */ + if (page == NULL) { + ptr = fil_op_log_parse_or_replay(ptr, end_ptr, + type, 0, 0); + } break; case MLOG_ZIP_WRITE_NODE_PTR: ut_ad(!page || page_type == FIL_PAGE_INDEX); @@ -2968,7 +2986,7 @@ recv_init_crash_recovery(void) ib_logf(IB_LOG_LEVEL_INFO, "from the doublewrite buffer..."); - buf_dblwr_init_or_restore_pages(TRUE); + buf_dblwr_process(); /* Spawn the background thread to flush dirty pages from the buffer pools. */ @@ -3008,6 +3026,7 @@ recv_recovery_from_checkpoint_start_func( byte* buf; byte log_hdr_buf[LOG_FILE_HDR_SIZE]; dberr_t err; + ut_when_dtor<recv_dblwr_t> tmp(recv_sys->dblwr); #ifdef UNIV_LOG_ARCHIVE ut_ad(type != LOG_CHECKPOINT || limit_lsn == LSN_MAX); @@ -3022,11 +3041,6 @@ recv_recovery_from_checkpoint_start_func( # define LIMIT_LSN LSN_MAX #endif /* UNIV_LOG_ARCHIVE */ - if (TYPE_CHECKPOINT) { - recv_sys_create(); - recv_sys_init(buf_pool_get_curr_size()); - } - if (srv_force_recovery >= SRV_FORCE_NO_LOG_REDO) { ib_logf(IB_LOG_LEVEL_INFO, @@ -3259,11 +3273,6 @@ recv_recovery_from_checkpoint_start_func( } } } - - if (!recv_needed_recovery && !srv_read_only_mode) { - /* Init the doublewrite buffer memory structure */ - buf_dblwr_init_or_restore_pages(FALSE); - } } /* We currently have only one log group */ @@ -3964,3 +3973,46 @@ recv_recovery_from_archive_finish(void) recv_recovery_from_backup_on = FALSE; } #endif /* UNIV_LOG_ARCHIVE */ + + +void recv_dblwr_t::add(byte* page) +{ + pages.push_back(page); +} + +byte* recv_dblwr_t::find_page(ulint space_id, ulint page_no) +{ + std::vector<byte*> matches; + byte* result = 0; + + for (std::list<byte*>::iterator i = pages.begin(); + i != pages.end(); ++i) { + + if ((page_get_space_id(*i) == space_id) + && (page_get_page_no(*i) == page_no)) { + matches.push_back(*i); + } + } + + if (matches.size() == 1) { + result = matches[0]; + } else if (matches.size() > 1) { + + lsn_t max_lsn = 0; + lsn_t page_lsn = 0; + + for (std::vector<byte*>::iterator i = matches.begin(); + i != matches.end(); ++i) { + + page_lsn = mach_read_from_8(*i + FIL_PAGE_LSN); + + if (page_lsn > max_lsn) { + max_lsn = page_lsn; + result = *i; + } + } + } + + return(result); +} + diff --git a/storage/innobase/mem/mem0mem.cc b/storage/innobase/mem/mem0mem.cc index e0e6220f4d8..e066aff5b30 100644 --- a/storage/innobase/mem/mem0mem.cc +++ b/storage/innobase/mem/mem0mem.cc @@ -299,15 +299,17 @@ Creates a memory heap block where data can be allocated. for MEM_HEAP_BTR_SEARCH type heaps) */ UNIV_INTERN mem_block_t* -mem_heap_create_block( -/*==================*/ +mem_heap_create_block_func( +/*=======================*/ mem_heap_t* heap, /*!< in: memory heap or NULL if first block should be created */ ulint n, /*!< in: number of bytes needed for user data */ - ulint type, /*!< in: type of heap: MEM_HEAP_DYNAMIC or - MEM_HEAP_BUFFER */ +#ifdef UNIV_DEBUG const char* file_name,/*!< in: file name where created */ - ulint line) /*!< in: line where created */ + ulint line, /*!< in: line where created */ +#endif /* UNIV_DEBUG */ + ulint type) /*!< in: type of heap: MEM_HEAP_DYNAMIC or + MEM_HEAP_BUFFER */ { #ifndef UNIV_HOTBACKUP buf_block_t* buf_block = NULL; @@ -368,8 +370,9 @@ mem_heap_create_block( #endif /* !UNIV_HOTBACKUP */ block->magic_n = MEM_BLOCK_MAGIC_N; - ut_strlcpy_rev(block->file_name, file_name, sizeof(block->file_name)); - block->line = line; + ut_d(ut_strlcpy_rev(block->file_name, file_name, + sizeof(block->file_name))); + ut_d(block->line = line); #ifdef MEM_PERIODIC_CHECK mutex_enter(&(mem_comm_pool->mutex)); diff --git a/storage/innobase/os/os0file.cc b/storage/innobase/os/os0file.cc index d07d381fb8f..d3f1980aeed 100644 --- a/storage/innobase/os/os0file.cc +++ b/storage/innobase/os/os0file.cc @@ -465,8 +465,10 @@ os_file_get_last_error_low( return(OS_FILE_INSUFFICIENT_RESOURCE); } else if (err == ERROR_OPERATION_ABORTED) { return(OS_FILE_OPERATION_ABORTED); + } else if (err == ERROR_ACCESS_DENIED) { + return(OS_FILE_ACCESS_VIOLATION); } else { - return(100 + err); + return(OS_FILE_ERROR_MAX + err); } #else int err = errno; @@ -540,8 +542,10 @@ os_file_get_last_error_low( return(OS_FILE_AIO_INTERRUPTED); } break; + case EACCES: + return(OS_FILE_ACCESS_VIOLATION); } - return(100 + err); + return(OS_FILE_ERROR_MAX + err); #endif } @@ -619,6 +623,7 @@ os_file_handle_error_cond_exit( case OS_FILE_PATH_ERROR: case OS_FILE_ALREADY_EXISTS: + case OS_FILE_ACCESS_VIOLATION: return(FALSE); @@ -3166,30 +3171,41 @@ os_file_get_status( return(DB_FAIL); - } else if (S_ISDIR(statinfo.st_mode)) { + } + + switch (statinfo.st_mode & S_IFMT) { + case S_IFDIR: stat_info->type = OS_FILE_TYPE_DIR; - } else if (S_ISLNK(statinfo.st_mode)) { + break; + case S_IFLNK: stat_info->type = OS_FILE_TYPE_LINK; - } else if (S_ISREG(statinfo.st_mode)) { + break; + case S_IFBLK: + stat_info->type = OS_FILE_TYPE_BLOCK; + break; + case S_IFREG: stat_info->type = OS_FILE_TYPE_FILE; + break; + default: + stat_info->type = OS_FILE_TYPE_UNKNOWN; + } - if (check_rw_perm) { - int fh; - int access; - access = !srv_read_only_mode ? O_RDWR : O_RDONLY; + if (check_rw_perm && (stat_info->type == OS_FILE_TYPE_FILE + || stat_info->type == OS_FILE_TYPE_BLOCK)) { + int fh; + int access; - fh = ::open(path, access, os_innodb_umask); + access = !srv_read_only_mode ? O_RDWR : O_RDONLY; - if (fh == -1) { - stat_info->rw_perm = false; - } else { - stat_info->rw_perm = true; - close(fh); - } + fh = ::open(path, access, os_innodb_umask); + + if (fh == -1) { + stat_info->rw_perm = false; + } else { + stat_info->rw_perm = true; + close(fh); } - } else { - stat_info->type = OS_FILE_TYPE_UNKNOWN; } #endif /* _WIN_ */ diff --git a/storage/innobase/os/os0sync.cc b/storage/innobase/os/os0sync.cc index 392dbe0d7a7..e42c5900c0c 100644 --- a/storage/innobase/os/os0sync.cc +++ b/storage/innobase/os/os0sync.cc @@ -644,7 +644,7 @@ os_event_wait_time_low( ut_a(event); if (time_in_usec != OS_SYNC_INFINITE_TIME) { - time_in_ms = time_in_usec / 1000; + time_in_ms = static_cast<DWORD>(time_in_usec / 1000); err = WaitForSingleObject(event->handle, time_in_ms); } else { err = WaitForSingleObject(event->handle, INFINITE); @@ -663,7 +663,7 @@ os_event_wait_time_low( ut_a(sleep_condition_variable != NULL); if (time_in_usec != OS_SYNC_INFINITE_TIME) { - time_in_ms = time_in_usec / 1000; + time_in_ms = static_cast<DWORD>(time_in_usec / 1000); } else { time_in_ms = INFINITE; } diff --git a/storage/innobase/page/page0cur.cc b/storage/innobase/page/page0cur.cc index efce1f10cae..f5f7e1299ce 100644 --- a/storage/innobase/page/page0cur.cc +++ b/storage/innobase/page/page0cur.cc @@ -977,7 +977,8 @@ page_cur_insert_rec_low( == (ibool) !!page_is_comp(page)); ut_ad(fil_page_get_type(page) == FIL_PAGE_INDEX); ut_ad(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID) - == index->id || recv_recovery_is_on() || mtr->inside_ibuf); + == index->id || recv_recovery_is_on() + || (mtr ? mtr->inside_ibuf : dict_index_is_ibuf(index))); ut_ad(!page_rec_is_supremum(current_rec)); @@ -1204,7 +1205,8 @@ page_cur_insert_rec_zip( ut_ad(page_is_comp(page)); ut_ad(fil_page_get_type(page) == FIL_PAGE_INDEX); ut_ad(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID) - == index->id || mtr->inside_ibuf || recv_recovery_is_on()); + == index->id || recv_recovery_is_on() + || (mtr ? mtr->inside_ibuf : dict_index_is_ibuf(index))); ut_ad(!page_cur_is_after_last(cursor)); #ifdef UNIV_ZIP_DEBUG @@ -1977,7 +1979,8 @@ page_cur_delete_rec( const dict_index_t* index, /*!< in: record descriptor */ const ulint* offsets,/*!< in: rec_get_offsets( cursor->rec, index) */ - mtr_t* mtr) /*!< in: mini-transaction handle */ + mtr_t* mtr) /*!< in: mini-transaction handle + or NULL */ { page_dir_slot_t* cur_dir_slot; page_dir_slot_t* prev_slot; @@ -2006,7 +2009,8 @@ page_cur_delete_rec( ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table)); ut_ad(fil_page_get_type(page) == FIL_PAGE_INDEX); ut_ad(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID) - == index->id || mtr->inside_ibuf || recv_recovery_is_on()); + == index->id || recv_recovery_is_on() + || (mtr ? mtr->inside_ibuf : dict_index_is_ibuf(index))); /* The record must not be the supremum or infimum record. */ ut_ad(page_rec_is_user_rec(current_rec)); diff --git a/storage/innobase/page/page0page.cc b/storage/innobase/page/page0page.cc index 2faf804279c..bd5fb36af8f 100644 --- a/storage/innobase/page/page0page.cc +++ b/storage/innobase/page/page0page.cc @@ -2779,3 +2779,35 @@ page_delete_rec( return(no_compress_needed); } +/** Get the last non-delete-marked record on a page. +@param[in] page index tree leaf page +@return the last record, not delete-marked +@retval infimum record if all records are delete-marked */ + +const rec_t* +page_find_rec_max_not_deleted( + const page_t* page) +{ + const rec_t* rec = page_get_infimum_rec(page); + const rec_t* prev_rec = NULL; // remove warning + + /* Because the page infimum is never delete-marked, + prev_rec will always be assigned to it first. */ + ut_ad(!rec_get_deleted_flag(rec, page_rec_is_comp(rec))); + if (page_is_comp(page)) { + do { + if (!rec_get_deleted_flag(rec, true)) { + prev_rec = rec; + } + rec = page_rec_get_next_low(rec, true); + } while (rec != page + PAGE_NEW_SUPREMUM); + } else { + do { + if (!rec_get_deleted_flag(rec, false)) { + prev_rec = rec; + } + rec = page_rec_get_next_low(rec, false); + } while (rec != page + PAGE_OLD_SUPREMUM); + } + return(prev_rec); +} diff --git a/storage/innobase/page/page0zip.cc b/storage/innobase/page/page0zip.cc index 52dcbf64183..ab7a19795a3 100644 --- a/storage/innobase/page/page0zip.cc +++ b/storage/innobase/page/page0zip.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2005, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2005, 2014, Oracle and/or its affiliates. All Rights Reserved. Copyright (c) 2012, Facebook Inc. This program is free software; you can redistribute it and/or modify it under @@ -24,6 +24,9 @@ Compressed page interface Created June 2005 by Marko Makela *******************************************************/ +// First include (the generated) my_config.h, to get correct platform defines. +#include "my_config.h" + #include <map> using namespace std; @@ -168,7 +171,7 @@ page_zip_empty_size( + 1/* end of modification log */ - REC_N_NEW_EXTRA_BYTES/* omitted bytes */) /* subtract the space for page_zip_fields_encode() */ - - compressBound(2 * (n_fields + 1)); + - compressBound(static_cast<uLong>(2 * (n_fields + 1))); return(size > 0 ? (ulint) size : 0); } #endif /* !UNIV_HOTBACKUP */ @@ -849,8 +852,8 @@ page_zip_compress_node_ptrs( rec_offs_extra_size(offsets)); /* Compress the extra bytes. */ - c_stream->avail_in = rec - REC_N_NEW_EXTRA_BYTES - - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + rec - REC_N_NEW_EXTRA_BYTES - c_stream->next_in); if (c_stream->avail_in) { err = deflate(c_stream, Z_NO_FLUSH); @@ -862,8 +865,8 @@ page_zip_compress_node_ptrs( /* Compress the data bytes, except node_ptr. */ c_stream->next_in = (byte*) rec; - c_stream->avail_in = rec_offs_data_size(offsets) - - REC_NODE_PTR_SIZE; + c_stream->avail_in = static_cast<uInt>( + rec_offs_data_size(offsets) - REC_NODE_PTR_SIZE); if (c_stream->avail_in) { err = deflate(c_stream, Z_NO_FLUSH); @@ -904,8 +907,9 @@ page_zip_compress_sec( const rec_t* rec = *recs++; /* Compress everything up to this record. */ - c_stream->avail_in = rec - REC_N_NEW_EXTRA_BYTES - - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + rec - REC_N_NEW_EXTRA_BYTES + - c_stream->next_in); if (UNIV_LIKELY(c_stream->avail_in)) { UNIV_MEM_ASSERT_RW(c_stream->next_in, @@ -970,8 +974,8 @@ page_zip_compress_clust_ext( ut_ad(len == DATA_ROLL_PTR_LEN); /* Compress any preceding bytes. */ - c_stream->avail_in - = src - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + src - c_stream->next_in); if (c_stream->avail_in) { err = deflate(c_stream, Z_NO_FLUSH); @@ -1000,8 +1004,8 @@ page_zip_compress_clust_ext( ut_ad(len >= BTR_EXTERN_FIELD_REF_SIZE); src += len - BTR_EXTERN_FIELD_REF_SIZE; - c_stream->avail_in = src - - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + src - c_stream->next_in); if (UNIV_LIKELY(c_stream->avail_in)) { err = deflate(c_stream, Z_NO_FLUSH); if (UNIV_UNLIKELY(err != Z_OK)) { @@ -1096,8 +1100,9 @@ page_zip_compress_clust( rec_offs_extra_size(offsets)); /* Compress the extra bytes. */ - c_stream->avail_in = rec - REC_N_NEW_EXTRA_BYTES - - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + rec - REC_N_NEW_EXTRA_BYTES + - c_stream->next_in); if (c_stream->avail_in) { err = deflate(c_stream, Z_NO_FLUSH); @@ -1144,7 +1149,8 @@ page_zip_compress_clust( rec_offs_extra_size(offsets)); /* Compress any preceding bytes. */ - c_stream->avail_in = src - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + src - c_stream->next_in); if (c_stream->avail_in) { err = deflate(c_stream, Z_NO_FLUSH); @@ -1171,8 +1177,8 @@ page_zip_compress_clust( } /* Compress the last bytes of the record. */ - c_stream->avail_in = rec + rec_offs_data_size(offsets) - - c_stream->next_in; + c_stream->avail_in = static_cast<uInt>( + rec + rec_offs_data_size(offsets) - c_stream->next_in); if (c_stream->avail_in) { err = deflate(c_stream, Z_NO_FLUSH); @@ -1324,7 +1330,7 @@ page_zip_compress( /* Compress the data payload. */ page_zip_set_alloc(&c_stream, heap); - err = deflateInit2(&c_stream, level, + err = deflateInit2(&c_stream, static_cast<int>(level), Z_DEFLATED, UNIV_PAGE_SIZE_SHIFT, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY); ut_a(err == Z_OK); @@ -1332,7 +1338,8 @@ page_zip_compress( c_stream.next_out = buf; /* Subtract the space reserved for uncompressed data. */ /* Page header and the end marker of the modification log */ - c_stream.avail_out = buf_end - buf - 1; + c_stream.avail_out = static_cast<uInt>(buf_end - buf - 1); + /* Dense page directory and uncompressed columns, if any */ if (page_is_leaf(page)) { if (dict_index_is_clust(index)) { @@ -1361,9 +1368,9 @@ page_zip_compress( goto zlib_error; } - c_stream.avail_out -= n_dense * slot_size; - c_stream.avail_in = page_zip_fields_encode(n_fields, index, - trx_id_col, fields); + c_stream.avail_out -= static_cast<uInt>(n_dense * slot_size); + c_stream.avail_in = static_cast<uInt>( + page_zip_fields_encode(n_fields, index, trx_id_col, fields)); c_stream.next_in = fields; if (UNIV_LIKELY(!trx_id_col)) { trx_id_col = ULINT_UNDEFINED; @@ -1418,9 +1425,9 @@ page_zip_compress( /* Compress any trailing garbage, in case the last record was allocated from an originally longer space on the free list, or the data of the last record from page_zip_compress_sec(). */ - c_stream.avail_in - = page_header_get_field(page, PAGE_HEAP_TOP) - - (c_stream.next_in - page); + c_stream.avail_in = static_cast<uInt>( + page_header_get_field(page, PAGE_HEAP_TOP) + - (c_stream.next_in - page)); ut_a(c_stream.avail_in <= UNIV_PAGE_SIZE - PAGE_ZIP_START - PAGE_DIR); UNIV_MEM_ASSERT_RW(c_stream.next_in, c_stream.avail_in); @@ -1567,9 +1574,8 @@ page_zip_fields_free( dict_table_t* table = index->table; os_fast_mutex_free(&index->zip_pad.mutex); mem_heap_free(index->heap); - mutex_free(&(table->autoinc_mutex)); - ut_free(table->name); - mem_heap_free(table->heap); + + dict_mem_table_free(table); } } @@ -2221,15 +2227,15 @@ page_zip_decompress_node_ptrs( const byte* storage; /* Subtract the space reserved for uncompressed data. */ - d_stream->avail_in -= n_dense - * (PAGE_ZIP_DIR_SLOT_SIZE + REC_NODE_PTR_SIZE); + d_stream->avail_in -= static_cast<uInt>( + n_dense * (PAGE_ZIP_DIR_SLOT_SIZE + REC_NODE_PTR_SIZE)); /* Decompress the records in heap_no order. */ for (slot = 0; slot < n_dense; slot++) { rec_t* rec = recs[slot]; - d_stream->avail_out = rec - REC_N_NEW_EXTRA_BYTES - - d_stream->next_out; + d_stream->avail_out = static_cast<uInt>( + rec - REC_N_NEW_EXTRA_BYTES - d_stream->next_out); ut_ad(d_stream->avail_out < UNIV_PAGE_SIZE - PAGE_ZIP_START - PAGE_DIR); @@ -2265,8 +2271,8 @@ page_zip_decompress_node_ptrs( ut_ad(!rec_offs_any_extern(offsets)); /* Decompress the data bytes, except node_ptr. */ - d_stream->avail_out = rec_offs_data_size(offsets) - - REC_NODE_PTR_SIZE; + d_stream->avail_out =static_cast<uInt>( + rec_offs_data_size(offsets) - REC_NODE_PTR_SIZE); switch (inflate(d_stream, Z_SYNC_FLUSH)) { case Z_STREAM_END: @@ -2295,9 +2301,9 @@ page_zip_decompress_node_ptrs( /* Decompress any trailing garbage, in case the last record was allocated from an originally longer space on the free list. */ - d_stream->avail_out = page_header_get_field(page_zip->data, - PAGE_HEAP_TOP) - - page_offset(d_stream->next_out); + d_stream->avail_out = static_cast<uInt>( + page_header_get_field(page_zip->data, PAGE_HEAP_TOP) + - page_offset(d_stream->next_out)); if (UNIV_UNLIKELY(d_stream->avail_out > UNIV_PAGE_SIZE - PAGE_ZIP_START - PAGE_DIR)) { @@ -2410,14 +2416,15 @@ page_zip_decompress_sec( ut_a(!dict_index_is_clust(index)); /* Subtract the space reserved for uncompressed data. */ - d_stream->avail_in -= n_dense * PAGE_ZIP_DIR_SLOT_SIZE; + d_stream->avail_in -= static_cast<uint>( + n_dense * PAGE_ZIP_DIR_SLOT_SIZE); for (slot = 0; slot < n_dense; slot++) { rec_t* rec = recs[slot]; /* Decompress everything up to this record. */ - d_stream->avail_out = rec - REC_N_NEW_EXTRA_BYTES - - d_stream->next_out; + d_stream->avail_out = static_cast<uint>( + rec - REC_N_NEW_EXTRA_BYTES - d_stream->next_out); if (UNIV_LIKELY(d_stream->avail_out)) { switch (inflate(d_stream, Z_SYNC_FLUSH)) { @@ -2448,9 +2455,9 @@ page_zip_decompress_sec( /* Decompress the data of the last record and any trailing garbage, in case the last record was allocated from an originally longer space on the free list. */ - d_stream->avail_out = page_header_get_field(page_zip->data, - PAGE_HEAP_TOP) - - page_offset(d_stream->next_out); + d_stream->avail_out = static_cast<uInt>( + page_header_get_field(page_zip->data, PAGE_HEAP_TOP) + - page_offset(d_stream->next_out)); if (UNIV_UNLIKELY(d_stream->avail_out > UNIV_PAGE_SIZE - PAGE_ZIP_START - PAGE_DIR)) { @@ -2563,7 +2570,8 @@ page_zip_decompress_clust_ext( return(FALSE); } - d_stream->avail_out = dst - d_stream->next_out; + d_stream->avail_out = static_cast<uInt>( + dst - d_stream->next_out); switch (inflate(d_stream, Z_SYNC_FLUSH)) { case Z_STREAM_END: @@ -2594,7 +2602,8 @@ page_zip_decompress_clust_ext( ut_ad(len >= BTR_EXTERN_FIELD_REF_SIZE); dst += len - BTR_EXTERN_FIELD_REF_SIZE; - d_stream->avail_out = dst - d_stream->next_out; + d_stream->avail_out = static_cast<uInt>( + dst - d_stream->next_out); switch (inflate(d_stream, Z_SYNC_FLUSH)) { case Z_STREAM_END: case Z_OK: @@ -2660,16 +2669,17 @@ page_zip_decompress_clust( ut_a(dict_index_is_clust(index)); /* Subtract the space reserved for uncompressed data. */ - d_stream->avail_in -= n_dense * (PAGE_ZIP_DIR_SLOT_SIZE - + DATA_TRX_ID_LEN - + DATA_ROLL_PTR_LEN); + d_stream->avail_in -= static_cast<uInt>(n_dense) + * (PAGE_ZIP_DIR_SLOT_SIZE + + DATA_TRX_ID_LEN + + DATA_ROLL_PTR_LEN); /* Decompress the records in heap_no order. */ for (slot = 0; slot < n_dense; slot++) { rec_t* rec = recs[slot]; - d_stream->avail_out = rec - REC_N_NEW_EXTRA_BYTES - - d_stream->next_out; + d_stream->avail_out =static_cast<uInt>( + rec - REC_N_NEW_EXTRA_BYTES - d_stream->next_out); ut_ad(d_stream->avail_out < UNIV_PAGE_SIZE - PAGE_ZIP_START - PAGE_DIR); @@ -2727,7 +2737,8 @@ page_zip_decompress_clust( goto zlib_error; } - d_stream->avail_out = dst - d_stream->next_out; + d_stream->avail_out = static_cast<uInt>( + dst - d_stream->next_out); switch (inflate(d_stream, Z_SYNC_FLUSH)) { case Z_STREAM_END: @@ -2756,8 +2767,8 @@ page_zip_decompress_clust( } /* Decompress the last bytes of the record. */ - d_stream->avail_out = rec_get_end(rec, offsets) - - d_stream->next_out; + d_stream->avail_out = static_cast<uInt>( + rec_get_end(rec, offsets) - d_stream->next_out); switch (inflate(d_stream, Z_SYNC_FLUSH)) { case Z_STREAM_END: @@ -2777,9 +2788,9 @@ page_zip_decompress_clust( /* Decompress any trailing garbage, in case the last record was allocated from an originally longer space on the free list. */ - d_stream->avail_out = page_header_get_field(page_zip->data, - PAGE_HEAP_TOP) - - page_offset(d_stream->next_out); + d_stream->avail_out = static_cast<uInt>( + page_header_get_field(page_zip->data, PAGE_HEAP_TOP) + - page_offset(d_stream->next_out)); if (UNIV_UNLIKELY(d_stream->avail_out > UNIV_PAGE_SIZE - PAGE_ZIP_START - PAGE_DIR)) { @@ -3035,7 +3046,8 @@ zlib_error: d_stream.next_in = page_zip->data + PAGE_DATA; /* Subtract the space reserved for the page header and the end marker of the modification log. */ - d_stream.avail_in = page_zip_get_size(page_zip) - (PAGE_DATA + 1); + d_stream.avail_in = static_cast<uInt>( + page_zip_get_size(page_zip) - (PAGE_DATA + 1)); d_stream.next_out = page + PAGE_ZIP_START; d_stream.avail_out = UNIV_PAGE_SIZE - PAGE_ZIP_START; @@ -3494,7 +3506,7 @@ page_zip_write_rec_ext( externs -= blob_no * BTR_EXTERN_FIELD_REF_SIZE; if (create) { - page_zip->n_blobs += n_ext; + page_zip->n_blobs += static_cast<unsigned>(n_ext); ASSERT_ZERO_BLOB(ext_end - n_ext * BTR_EXTERN_FIELD_REF_SIZE); memmove(ext_end - n_ext @@ -4402,7 +4414,7 @@ page_zip_dir_delete( * BTR_EXTERN_FIELD_REF_SIZE; externs -= blob_no * BTR_EXTERN_FIELD_REF_SIZE; - page_zip->n_blobs -= n_ext; + page_zip->n_blobs -= static_cast<unsigned>(n_ext); /* Shift and zero fill the array. */ memmove(ext_end + n_ext * BTR_EXTERN_FIELD_REF_SIZE, ext_end, (page_zip->n_blobs - blob_no) @@ -4857,8 +4869,10 @@ page_zip_calc_checksum( adler = adler32(0L, s + FIL_PAGE_OFFSET, FIL_PAGE_LSN - FIL_PAGE_OFFSET); adler = adler32(adler, s + FIL_PAGE_TYPE, 2); - adler = adler32(adler, s + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, - size - FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID); + adler = adler32( + adler, s + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID, + static_cast<uInt>(size) + - FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID); return((ulint) adler); case SRV_CHECKSUM_ALGORITHM_NONE: @@ -4888,21 +4902,25 @@ page_zip_verify_checksum( ib_uint32_t crc32 = 0 /* silence bogus warning */; ib_uint32_t innodb = 0 /* silence bogus warning */; - stored = mach_read_from_4( - (const unsigned char*) data + FIL_PAGE_SPACE_OR_CHKSUM); + stored = static_cast<ib_uint32_t>(mach_read_from_4( + static_cast<const unsigned char*>(data) + FIL_PAGE_SPACE_OR_CHKSUM)); /* declare empty pages non-corrupted */ if (stored == 0) { /* make sure that the page is really empty */ - ut_d(ulint i; for (i = 0; i < size; i++) { - ut_a(*((const char*) data + i) == 0); }); + ulint i; + for (i = 0; i < size; i++) { + if (*((const char*) data + i) != 0) { + return(FALSE); + } + } return(TRUE); } - calc = page_zip_calc_checksum( + calc = static_cast<ib_uint32_t>(page_zip_calc_checksum( data, size, static_cast<srv_checksum_algorithm_t>( - srv_checksum_algorithm)); + srv_checksum_algorithm))); if (stored == calc) { return(TRUE); @@ -4918,15 +4936,15 @@ page_zip_verify_checksum( return(TRUE); } crc32 = calc; - innodb = page_zip_calc_checksum( - data, size, SRV_CHECKSUM_ALGORITHM_INNODB); + innodb = static_cast<ib_uint32_t>(page_zip_calc_checksum( + data, size, SRV_CHECKSUM_ALGORITHM_INNODB)); break; case SRV_CHECKSUM_ALGORITHM_INNODB: if (stored == BUF_NO_CHECKSUM_MAGIC) { return(TRUE); } - crc32 = page_zip_calc_checksum( - data, size, SRV_CHECKSUM_ALGORITHM_CRC32); + crc32 = static_cast<ib_uint32_t>(page_zip_calc_checksum( + data, size, SRV_CHECKSUM_ALGORITHM_CRC32)); innodb = calc; break; case SRV_CHECKSUM_ALGORITHM_NONE: diff --git a/storage/innobase/pars/lexyy.cc b/storage/innobase/pars/lexyy.cc index 48ab04e1eff..1c01becd9ed 100644 --- a/storage/innobase/pars/lexyy.cc +++ b/storage/innobase/pars/lexyy.cc @@ -35,7 +35,7 @@ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. + * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 @@ -2424,8 +2424,8 @@ static int yy_get_next_buffer (void) else { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + int num_to_read = static_cast<int>( + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1); while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ @@ -2438,7 +2438,7 @@ static int yy_get_next_buffer (void) if ( b->yy_is_our_buffer ) { - int new_size = b->yy_buf_size * 2; + int new_size = static_cast<int>(b->yy_buf_size * 2); if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -2459,8 +2459,9 @@ static int yy_get_next_buffer (void) (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; + num_to_read = static_cast<int>( + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + - number_to_move - 1); } @@ -2643,7 +2644,7 @@ static int yy_get_next_buffer (void) /** Immediately switch to a different input stream. * @param input_file A readable stream. - * + * * @note This function does not reset the start condition to @c INITIAL . */ void yyrestart (FILE * input_file ) @@ -2661,7 +2662,7 @@ static int yy_get_next_buffer (void) /** Switch to a different input buffer. * @param new_buffer The new input buffer. - * + * */ __attribute__((unused)) static void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) { @@ -2705,7 +2706,7 @@ static void yy_load_buffer_state (void) /** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * + * * @return the allocated buffer state. */ static YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) @@ -2734,7 +2735,7 @@ static void yy_load_buffer_state (void) /** Destroy the buffer. * @param b a buffer created with yy_create_buffer() - * + * */ void yy_delete_buffer (YY_BUFFER_STATE b ) { @@ -2759,7 +2760,7 @@ static void yy_load_buffer_state (void) { int oerrno = errno; - + yy_flush_buffer(b ); b->yy_input_file = file; @@ -2775,13 +2776,13 @@ static void yy_load_buffer_state (void) } b->yy_is_interactive = 0; - + errno = oerrno; } /** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * + * */ void yy_flush_buffer (YY_BUFFER_STATE b ) { @@ -2810,7 +2811,7 @@ static void yy_load_buffer_state (void) * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. - * + * */ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) { @@ -2840,7 +2841,7 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) /** Removes and deletes the top of the stack, if present. * The next element becomes the new top. - * + * */ void yypop_buffer_state (void) { @@ -2864,7 +2865,7 @@ void yypop_buffer_state (void) static void yyensure_buffer_stack (void) { int num_to_alloc; - + if (!(yy_buffer_stack)) { /* First allocation is just for 2 elements, since we don't know if this @@ -2890,7 +2891,8 @@ static void yyensure_buffer_stack (void) /* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */; - num_to_alloc = (yy_buffer_stack_max) + grow_size; + num_to_alloc = static_cast<int>( + (yy_buffer_stack_max) + grow_size); (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) @@ -2934,7 +2936,7 @@ static void yy_fatal_error (yyconst char* msg ) /* Accessor methods (get/set functions) to struct members. */ /** Get the current line number. - * + * */ int yyget_lineno (void) { @@ -2943,7 +2945,7 @@ int yyget_lineno (void) } /** Get the input stream. - * + * */ FILE *yyget_in (void) { @@ -2951,7 +2953,7 @@ FILE *yyget_in (void) } /** Get the output stream. - * + * */ FILE *yyget_out (void) { @@ -2959,7 +2961,7 @@ FILE *yyget_out (void) } /** Get the length of the current token. - * + * */ yy_size_t yyget_leng (void) { @@ -2967,7 +2969,7 @@ yy_size_t yyget_leng (void) } /** Get the current token. - * + * */ char *yyget_text (void) @@ -2977,18 +2979,18 @@ char *yyget_text (void) /** Set the current line number. * @param line_number - * + * */ void yyset_lineno (int line_number ) { - + yylineno = line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param in_str A readable stream. - * + * * @see yy_switch_to_buffer */ void yyset_in (FILE * in_str ) @@ -3042,7 +3044,7 @@ static int yy_init_globals (void) /* yylex_destroy is for both reentrant and non-reentrant scanners. */ __attribute__((unused)) static int yylex_destroy (void) { - + /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ yy_delete_buffer(YY_CURRENT_BUFFER ); diff --git a/storage/innobase/pars/pars0pars.cc b/storage/innobase/pars/pars0pars.cc index e0bc00fad0d..655e5ba1324 100644 --- a/storage/innobase/pars/pars0pars.cc +++ b/storage/innobase/pars/pars0pars.cc @@ -1988,6 +1988,12 @@ pars_create_table( } } + /* Set the flags2 when create table or alter tables */ + flags2 |= DICT_TF2_FTS_AUX_HEX_NAME; + DBUG_EXECUTE_IF("innodb_test_wrong_fts_aux_table_name", + flags2 &= ~DICT_TF2_FTS_AUX_HEX_NAME;); + + n_cols = que_node_list_get_len(column_defs); table = dict_mem_table_create( @@ -2154,8 +2160,9 @@ pars_get_lex_chars( { int len; - len = pars_sym_tab_global->string_len - - pars_sym_tab_global->next_char_pos; + len = static_cast<int>( + pars_sym_tab_global->string_len + - pars_sym_tab_global->next_char_pos); if (len == 0) { #ifdef YYDEBUG /* fputs("SQL string ends\n", stderr); */ diff --git a/storage/innobase/plugin_exports b/storage/innobase/plugin_exports new file mode 100644 index 00000000000..235ae3d5e72 --- /dev/null +++ b/storage/innobase/plugin_exports @@ -0,0 +1,14 @@ +{ + global: + _maria_plugin_interface_version_; + _maria_sizeof_struct_st_plugin_; + _maria_plugin_declarations_; + my_snprintf_service; + thd_alloc_service; + thd_autoinc_service; + thd_error_context_service; + thd_kill_statement_service; + thd_wait_service; + local: + *; +}; diff --git a/storage/innobase/rem/rem0cmp.cc b/storage/innobase/rem/rem0cmp.cc index db0fdf3ee21..426cf9e3ac5 100644 --- a/storage/innobase/rem/rem0cmp.cc +++ b/storage/innobase/rem/rem0cmp.cc @@ -316,8 +316,8 @@ cmp_dfield_dfield_like_prefix( dfield_t* dfield1,/* in: data field; must have type field set */ dfield_t* dfield2)/* in: data field */ { - const dtype_t* type; - ulint ret; + const dtype_t* type; + int ret; ut_ad(dfield_check_typed(dfield1)); @@ -325,21 +325,21 @@ cmp_dfield_dfield_like_prefix( if (type->mtype >= DATA_FLOAT) { ret = innobase_mysql_cmp_prefix( - (int)(type->prtype & DATA_MYSQL_TYPE_MASK), - (uint) dtype_get_charset_coll(type->prtype), + static_cast<int>(type->prtype & DATA_MYSQL_TYPE_MASK), + static_cast<uint>(dtype_get_charset_coll(type->prtype)), + static_cast<byte*>(dfield_get_data(dfield1)), + static_cast<uint>(dfield_get_len(dfield1)), + static_cast<byte*>(dfield_get_data(dfield2)), + static_cast<uint>(dfield_get_len(dfield2))); + } else { + ret = (cmp_data_data_like_prefix( static_cast<byte*>(dfield_get_data(dfield1)), dfield_get_len(dfield1), - static_cast<byte*>(dfield_get_data(dfield2)), - dfield_get_len(dfield2)); - } else { - ret = (cmp_data_data_like_prefix( - static_cast<byte*>(dfield_get_data(dfield1)), - dfield_get_len(dfield1), - static_cast<byte*>(dfield_get_data(dfield2)), - dfield_get_len(dfield2))); - } - - return(ret); + static_cast<byte*>(dfield_get_data(dfield2)), + dfield_get_len(dfield2))); + } + + return(ret); } /*************************************************************//** @@ -506,7 +506,8 @@ cmp_data_data_slow_varchar( } } - return(i == lhs_len && i == rhs_len) ? 0 : rhs_len - lhs_len; + return((i == lhs_len && i == rhs_len) ? 0 : + static_cast<int>(rhs_len - lhs_len)); } /***************************************************************** diff --git a/storage/innobase/rem/rem0rec.cc b/storage/innobase/rem/rem0rec.cc index 3be66f68aad..8bcb820553e 100644 --- a/storage/innobase/rem/rem0rec.cc +++ b/storage/innobase/rem/rem0rec.cc @@ -546,9 +546,11 @@ rec_get_offsets_func( ulint n_fields,/*!< in: maximum number of initialized fields (ULINT_UNDEFINED if all fields) */ - mem_heap_t** heap, /*!< in/out: memory heap */ +#ifdef UNIV_DEBUG const char* file, /*!< in: file name where called */ - ulint line) /*!< in: line number where called */ + ulint line, /*!< in: line number where called */ +#endif /* UNIV_DEBUG */ + mem_heap_t** heap) /*!< in/out: memory heap */ { ulint n; ulint size; @@ -593,9 +595,8 @@ rec_get_offsets_func( if (UNIV_UNLIKELY(!offsets) || UNIV_UNLIKELY(rec_offs_get_n_alloc(offsets) < size)) { if (UNIV_UNLIKELY(!*heap)) { - *heap = mem_heap_create_func(size * sizeof(ulint), - MEM_HEAP_DYNAMIC, - file, line); + *heap = mem_heap_create_at(size * sizeof(ulint), + file, line); } offsets = static_cast<ulint*>( mem_heap_alloc(*heap, size * sizeof(ulint))); diff --git a/storage/innobase/row/row0ftsort.cc b/storage/innobase/row/row0ftsort.cc index 087d2152826..94af15dc658 100644 --- a/storage/innobase/row/row0ftsort.cc +++ b/storage/innobase/row/row0ftsort.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2010, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2010, 2013, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -869,7 +869,9 @@ func_exit: mutex_exit(&psort_info->mutex); if (UT_LIST_GET_LEN(psort_info->fts_doc_list) > 0) { - ut_ad(error != DB_SUCCESS); + /* child can exit either with error or told by parent. */ + ut_ad(error != DB_SUCCESS + || psort_info->state == FTS_PARENT_EXITING); } /* Free fts doc list in case of error. */ @@ -1191,7 +1193,7 @@ row_fts_sel_tree_propagate( sel_tree[parent] = selected; - return(parent); + return(static_cast<int>(parent)); } /*********************************************************************//** @@ -1211,8 +1213,8 @@ row_fts_sel_tree_update( ulint i; for (i = 1; i <= height; i++) { - propagated = row_fts_sel_tree_propagate( - propagated, sel_tree, mrec, offsets, index); + propagated = static_cast<ulint>(row_fts_sel_tree_propagate( + static_cast<int>(propagated), sel_tree, mrec, offsets, index)); } return(sel_tree[0]); @@ -1236,8 +1238,8 @@ row_fts_build_sel_tree_level( ulint i; ulint num_item; - start = (1 << level) - 1; - num_item = (1 << level); + start = static_cast<ulint>((1 << level) - 1); + num_item = static_cast<ulint>(1 << level); for (i = 0; i < num_item; i++) { child_left = sel_tree[(start + i) * 2 + 1]; @@ -1312,8 +1314,9 @@ row_fts_build_sel_tree( sel_tree[i + start] = i; } - for (i = treelevel - 1; i >=0; i--) { - row_fts_build_sel_tree_level(sel_tree, i, mrec, offsets, index); + for (i = static_cast<int>(treelevel) - 1; i >= 0; i--) { + row_fts_build_sel_tree_level( + sel_tree, static_cast<ulint>(i), mrec, offsets, index); } return(treelevel); @@ -1431,11 +1434,17 @@ row_fts_merge_insert( ins_ctx.ins_graph = static_cast<que_t**>(mem_heap_alloc(heap, n_bytes)); memset(ins_ctx.ins_graph, 0x0, n_bytes); + /* We should set the flags2 with aux_table_name here, + in order to get the correct aux table names. */ + index->table->flags2 |= DICT_TF2_FTS_AUX_HEX_NAME; + DBUG_EXECUTE_IF("innodb_test_wrong_fts_aux_table_name", + index->table->flags2 &= ~DICT_TF2_FTS_AUX_HEX_NAME;); + ins_ctx.fts_table.type = FTS_INDEX_TABLE; ins_ctx.fts_table.index_id = index->id; ins_ctx.fts_table.table_id = table->id; ins_ctx.fts_table.parent = index->table->name; - ins_ctx.fts_table.table = NULL; + ins_ctx.fts_table.table = index->table; for (i = 0; i < fts_sort_pll_degree; i++) { if (psort_info[i].merge_file[id]->n_rec == 0) { @@ -1492,7 +1501,7 @@ row_fts_merge_insert( mrec[i], mrec[min_rec], offsets[i], offsets[min_rec], index, NULL) < 0) { - min_rec = i; + min_rec = static_cast<int>(i); } } } else { diff --git a/storage/innobase/row/row0ins.cc b/storage/innobase/row/row0ins.cc index 8e60c11c8ca..da75c833c9e 100644 --- a/storage/innobase/row/row0ins.cc +++ b/storage/innobase/row/row0ins.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1996, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -2996,6 +2996,10 @@ row_ins_index_entry( dtuple_t* entry, /*!< in/out: index entry to insert */ que_thr_t* thr) /*!< in: query thread */ { + DBUG_EXECUTE_IF("row_ins_index_entry_timeout", { + DBUG_SET("-d,row_ins_index_entry_timeout"); + return(DB_LOCK_WAIT);}); + if (dict_index_is_clust(index)) { return(row_ins_clust_index_entry(index, entry, thr, 0)); } else { diff --git a/storage/innobase/row/row0log.cc b/storage/innobase/row/row0log.cc index c18ef9ee250..24abd885f60 100644 --- a/storage/innobase/row/row0log.cc +++ b/storage/innobase/row/row0log.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 2011, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2011, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -78,11 +78,12 @@ struct row_log_buf_t { mrec_buf_t buf; /*!< buffer for accessing a record that spans two blocks */ ulint blocks; /*!< current position in blocks */ - ulint bytes; /*!< current position within buf */ + ulint bytes; /*!< current position within block */ ulonglong total; /*!< logical position, in bytes from the start of the row_log_table log; 0 for row_log_online_op() and row_log_apply(). */ + ulint size; /*!< allocated size of block */ }; /** Tracks BLOB allocation during online ALTER TABLE */ @@ -193,9 +194,47 @@ struct row_log_t { or by index->lock X-latch only */ row_log_buf_t head; /*!< reader context; protected by MDL only; modifiable by row_log_apply_ops() */ - ulint size; /*!< allocated size */ }; + +/** Allocate the memory for the log buffer. +@param[in,out] log_buf Buffer used for log operation +@return TRUE if success, false if not */ +static __attribute__((warn_unused_result)) +bool +row_log_block_allocate( + row_log_buf_t& log_buf) +{ + DBUG_ENTER("row_log_block_allocate"); + if (log_buf.block == NULL) { + log_buf.size = srv_sort_buf_size; + log_buf.block = (byte*) os_mem_alloc_large(&log_buf.size); + DBUG_EXECUTE_IF("simulate_row_log_allocation_failure", + if (log_buf.block) + os_mem_free_large(log_buf.block, log_buf.size); + log_buf.block = NULL;); + if (!log_buf.block) { + DBUG_RETURN(false); + } + } + DBUG_RETURN(true); +} + +/** Free the log buffer. +@param[in,out] log_buf Buffer used for log operation */ +static +void +row_log_block_free( + row_log_buf_t& log_buf) +{ + DBUG_ENTER("row_log_block_free"); + if (log_buf.block != NULL) { + os_mem_free_large(log_buf.block, log_buf.size); + log_buf.block = NULL; + } + DBUG_VOID_RETURN; +} + /******************************************************//** Logs an operation to a secondary index that is (or was) being created. */ UNIV_INTERN @@ -247,6 +286,11 @@ row_log_online_op( log->max_trx = trx_id; } + if (!row_log_block_allocate(log->tail)) { + log->error = DB_OUT_OF_MEMORY; + goto err_exit; + } + UNIV_MEM_INVALID(log->tail.buf, sizeof log->tail.buf); ut_ad(log->tail.bytes < srv_sort_buf_size); @@ -318,6 +362,7 @@ write_failed: } UNIV_MEM_INVALID(log->tail.buf, sizeof log->tail.buf); +err_exit: mutex_exit(&log->mutex); } @@ -352,10 +397,16 @@ row_log_table_open( UNIV_MEM_INVALID(log->tail.buf, sizeof log->tail.buf); if (log->error != DB_SUCCESS) { +err_exit: mutex_exit(&log->mutex); return(NULL); } + if (!row_log_block_allocate(log->tail)) { + log->error = DB_OUT_OF_MEMORY; + goto err_exit; + } + ut_ad(log->tail.bytes < srv_sort_buf_size); *avail = srv_sort_buf_size - log->tail.bytes; @@ -441,9 +492,8 @@ row_log_table_delete( dict_index_t* index, /*!< in/out: clustered index, S-latched or X-latched */ const ulint* offsets,/*!< in: rec_get_offsets(rec,index) */ - bool purge, /*!< in: true=purging BLOBs */ - trx_id_t trx_id) /*!< in: DB_TRX_ID of the record before - it was deleted */ + const byte* sys) /*!< in: DB_TRX_ID,DB_ROLL_PTR that should + be logged, or NULL to use those in rec */ { ulint old_pk_extra_size; ulint old_pk_size; @@ -475,22 +525,21 @@ row_log_table_delete( ut_ad(dict_index_is_clust(new_index)); ut_ad(!dict_index_is_online_ddl(new_index)); - /* Create the tuple PRIMARY KEY, DB_TRX_ID in the new_table. */ + /* Create the tuple PRIMARY KEY,DB_TRX_ID,DB_ROLL_PTR in new_table. */ if (index->online_log->same_pk) { - byte* db_trx_id; dtuple_t* tuple; ut_ad(new_index->n_uniq == index->n_uniq); - /* The PRIMARY KEY and DB_TRX_ID are in the first + /* The PRIMARY KEY and DB_TRX_ID,DB_ROLL_PTR are in the first fields of the record. */ heap = mem_heap_create( DATA_TRX_ID_LEN - + DTUPLE_EST_ALLOC(new_index->n_uniq + 1)); - old_pk = tuple = dtuple_create(heap, new_index->n_uniq + 1); + + DTUPLE_EST_ALLOC(new_index->n_uniq + 2)); + old_pk = tuple = dtuple_create(heap, new_index->n_uniq + 2); dict_index_copy_types(tuple, new_index, tuple->n_fields); dtuple_set_n_fields_cmp(tuple, new_index->n_uniq); - for (ulint i = 0; i < new_index->n_uniq; i++) { + for (ulint i = 0; i < dtuple_get_n_fields(tuple); i++) { ulint len; const void* field = rec_get_nth_field( rec, offsets, i, &len); @@ -501,42 +550,33 @@ row_log_table_delete( dfield_set_data(dfield, field, len); } - db_trx_id = static_cast<byte*>( - mem_heap_alloc(heap, DATA_TRX_ID_LEN)); - trx_write_trx_id(db_trx_id, trx_id); - - dfield_set_data(dtuple_get_nth_field(tuple, new_index->n_uniq), - db_trx_id, DATA_TRX_ID_LEN); + if (sys) { + dfield_set_data( + dtuple_get_nth_field(tuple, + new_index->n_uniq), + sys, DATA_TRX_ID_LEN); + dfield_set_data( + dtuple_get_nth_field(tuple, + new_index->n_uniq + 1), + sys + DATA_TRX_ID_LEN, DATA_ROLL_PTR_LEN); + } } else { /* The PRIMARY KEY has changed. Translate the tuple. */ - dfield_t* dfield; - - old_pk = row_log_table_get_pk(rec, index, offsets, &heap); + old_pk = row_log_table_get_pk( + rec, index, offsets, NULL, &heap); if (!old_pk) { ut_ad(index->online_log->error != DB_SUCCESS); + if (heap) { + goto func_exit; + } return; } - - /* Remove DB_ROLL_PTR. */ - ut_ad(dtuple_get_n_fields_cmp(old_pk) - == dict_index_get_n_unique(new_index)); - ut_ad(dtuple_get_n_fields(old_pk) - == dict_index_get_n_unique(new_index) + 2); - const_cast<ulint&>(old_pk->n_fields)--; - - /* Overwrite DB_TRX_ID with the old trx_id. */ - dfield = dtuple_get_nth_field(old_pk, new_index->n_uniq); - ut_ad(dfield_get_type(dfield)->mtype == DATA_SYS); - ut_ad(dfield_get_type(dfield)->prtype - == (DATA_NOT_NULL | DATA_TRX_ID)); - ut_ad(dfield_get_len(dfield) == DATA_TRX_ID_LEN); - dfield_dup(dfield, heap); - trx_write_trx_id(static_cast<byte*>(dfield->data), trx_id); } - ut_ad(dtuple_get_n_fields(old_pk) > 1); ut_ad(DATA_TRX_ID_LEN == dtuple_get_nth_field( + old_pk, old_pk->n_fields - 2)->len); + ut_ad(DATA_ROLL_PTR_LEN == dtuple_get_nth_field( old_pk, old_pk->n_fields - 1)->len); old_pk_size = rec_get_converted_size_temp( new_index, old_pk->fields, old_pk->n_fields, @@ -548,7 +588,7 @@ row_log_table_delete( /* Log enough prefix of the BLOB unless both the old and new table are in COMPACT or REDUNDANT format, which store the prefix in the clustered index record. */ - if (purge && rec_offs_any_extern(offsets) + if (rec_offs_any_extern(offsets) && (dict_table_get_format(index->table) >= UNIV_FORMAT_B || dict_table_get_format(new_table) >= UNIV_FORMAT_B)) { @@ -613,6 +653,7 @@ row_log_table_delete( index->online_log, b, mrec_size, avail_size); } +func_exit: mem_heap_free(heap); } @@ -966,6 +1007,8 @@ row_log_table_get_pk( dict_index_t* index, /*!< in/out: clustered index, S-latched or X-latched */ const ulint* offsets,/*!< in: rec_get_offsets(rec,index) */ + byte* sys, /*!< out: DB_TRX_ID,DB_ROLL_PTR for + row_log_table_delete(), or NULL */ mem_heap_t** heap) /*!< in/out: memory heap where allocated */ { dtuple_t* tuple = NULL; @@ -984,6 +1027,31 @@ row_log_table_get_pk( if (log->same_pk) { /* The PRIMARY KEY columns are unchanged. */ + if (sys) { + /* Store the DB_TRX_ID,DB_ROLL_PTR. */ + ulint trx_id_offs = index->trx_id_offset; + + if (!trx_id_offs) { + ulint pos = dict_index_get_sys_col_pos( + index, DATA_TRX_ID); + ulint len; + ut_ad(pos > 0); + + if (!offsets) { + offsets = rec_get_offsets( + rec, index, NULL, pos + 1, + heap); + } + + trx_id_offs = rec_get_nth_field_offs( + offsets, pos, &len); + ut_ad(len == DATA_TRX_ID_LEN); + } + + memcpy(sys, rec + trx_id_offs, + DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN); + } + return(NULL); } @@ -1093,6 +1161,20 @@ err_exit: const byte* trx_roll = rec + row_get_trx_id_offset(index, offsets); + /* Copy the fields, because the fields will be updated + or the record may be moved somewhere else in the B-tree + as part of the upcoming operation. */ + if (sys) { + memcpy(sys, trx_roll, + DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN); + trx_roll = sys; + } else { + trx_roll = static_cast<const byte*>( + mem_heap_dup( + *heap, trx_roll, + DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN)); + } + dfield_set_data(dtuple_get_nth_field(tuple, new_n_uniq), trx_roll, DATA_TRX_ID_LEN); dfield_set_data(dtuple_get_nth_field(tuple, new_n_uniq + 1), @@ -1211,10 +1293,13 @@ row_log_table_apply_convert_mrec( mem_heap_t* heap, /*!< in/out: memory heap */ trx_id_t trx_id, /*!< in: DB_TRX_ID of mrec */ dberr_t* error) /*!< out: DB_SUCCESS or + DB_MISSING_HISTORY or reason of failure */ { dtuple_t* row; + *error = DB_SUCCESS; + /* This is based on row_build(). */ if (log->add_cols) { row = dtuple_copy(log->add_cols, heap); @@ -1256,7 +1341,7 @@ row_log_table_apply_convert_mrec( dfield_t* dfield = dtuple_get_nth_field(row, col_no); ulint len; - const byte* data= NULL; + const byte* data; if (rec_offs_nth_extern(offsets, i)) { ut_ad(rec_offs_any_extern(offsets)); @@ -1276,29 +1361,26 @@ row_log_table_apply_convert_mrec( && p->second.is_freed(log->head.total)) { /* This BLOB has been freed. We must not access the row. */ - row = NULL; + *error = DB_MISSING_HISTORY; + dfield_set_data(dfield, data, len); + dfield_set_ext(dfield); + goto blob_done; } } - if (row) { - data = btr_rec_copy_externally_stored_field( - mrec, offsets, - dict_table_zip_size(index->table), - i, &len, heap); - ut_a(data); - } - + data = btr_rec_copy_externally_stored_field( + mrec, offsets, + dict_table_zip_size(index->table), + i, &len, heap); + ut_a(data); + dfield_set_data(dfield, data, len); +blob_done: rw_lock_x_unlock(dict_index_get_lock(index)); - - if (!row) { - goto func_exit; - } } else { data = rec_get_nth_field(mrec, offsets, i, &len); + dfield_set_data(dfield, data, len); } - dfield_set_data(dfield, data, len); - /* See if any columns were changed to NULL or NOT NULL. */ const dict_col_t* new_col = dict_table_get_nth_col(log->table, col_no); @@ -1327,8 +1409,6 @@ row_log_table_apply_convert_mrec( dfield_get_type(dfield))); } -func_exit: - *error = DB_SUCCESS; return(row); } @@ -1427,22 +1507,32 @@ row_log_table_apply_insert( const dtuple_t* row = row_log_table_apply_convert_mrec( mrec, dup->index, offsets, log, heap, trx_id, &error); - ut_ad(error == DB_SUCCESS || !row); - /* Handling of duplicate key error requires storing - of offending key in a record buffer. */ - ut_ad(error != DB_DUPLICATE_KEY); - - if (error != DB_SUCCESS) + switch (error) { + case DB_MISSING_HISTORY: + ut_ad(log->blobs); + /* Because some BLOBs are missing, we know that the + transaction was rolled back later (a rollback of + an insert can free BLOBs). + We can simply skip the insert: the subsequent + ROW_T_DELETE will be ignored, or a ROW_T_UPDATE will + be interpreted as ROW_T_INSERT. */ + return(DB_SUCCESS); + case DB_SUCCESS: + ut_ad(row != NULL); + break; + default: + ut_ad(0); + case DB_INVALID_NULL: + ut_ad(row == NULL); return(error); + } - if (row) { - error = row_log_table_apply_insert_low( - thr, row, trx_id, offsets_heap, heap, dup); - if (error != DB_SUCCESS) { - /* Report the erroneous row using the new - version of the table. */ - innobase_row_to_mysql(dup->table, log->table, row); - } + error = row_log_table_apply_insert_low( + thr, row, trx_id, offsets_heap, heap, dup); + if (error != DB_SUCCESS) { + /* Report the erroneous row using the new + version of the table. */ + innobase_row_to_mysql(dup->table, log->table, row); } return(error); } @@ -1561,10 +1651,11 @@ row_log_table_apply_delete( mem_heap_t* offsets_heap, /*!< in/out: memory heap that can be emptied */ mem_heap_t* heap, /*!< in/out: memory heap */ - dict_table_t* new_table, /*!< in: rebuilt table */ + const row_log_t* log, /*!< in: online log */ const row_ext_t* save_ext) /*!< in: saved external field info, or NULL */ { + dict_table_t* new_table = log->table; dict_index_t* index = dict_table_get_first_index(new_table); dtuple_t* old_pk; mtr_t mtr; @@ -1572,15 +1663,14 @@ row_log_table_apply_delete( ulint* offsets; ut_ad(rec_offs_n_fields(moffsets) - == dict_index_get_n_unique(index) + 1); + == dict_index_get_n_unique(index) + 2); ut_ad(!rec_offs_any_extern(moffsets)); /* Convert the row to a search tuple. */ - old_pk = dtuple_create(heap, index->n_uniq + 1); - dict_index_copy_types(old_pk, index, old_pk->n_fields); - dtuple_set_n_fields_cmp(old_pk, index->n_uniq); + old_pk = dtuple_create(heap, index->n_uniq); + dict_index_copy_types(old_pk, index, index->n_uniq); - for (ulint i = 0; i <= index->n_uniq; i++) { + for (ulint i = 0; i < index->n_uniq; i++) { ulint len; const void* field; field = rec_get_nth_field(mrec, moffsets, i, &len); @@ -1614,6 +1704,10 @@ flag_ok: all_done: mtr_commit(&mtr); /* The record was not found. All done. */ + /* This should only happen when an earlier + ROW_T_INSERT was skipped or + ROW_T_UPDATE was interpreted as ROW_T_DELETE + due to BLOBs having been freed by rollback. */ return(DB_SUCCESS); } @@ -1623,19 +1717,38 @@ all_done: ut_a(!rec_offs_any_null_extern(btr_pcur_get_rec(&pcur), offsets)); #endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ - /* Only remove the record if DB_TRX_ID matches what was - buffered. */ + /* Only remove the record if DB_TRX_ID,DB_ROLL_PTR match. */ { ulint len; - const void* mrec_trx_id + const byte* mrec_trx_id = rec_get_nth_field(mrec, moffsets, trx_id_col, &len); ut_ad(len == DATA_TRX_ID_LEN); - const void* rec_trx_id + const byte* rec_trx_id = rec_get_nth_field(btr_pcur_get_rec(&pcur), offsets, trx_id_col, &len); ut_ad(len == DATA_TRX_ID_LEN); - if (memcmp(mrec_trx_id, rec_trx_id, DATA_TRX_ID_LEN)) { + + ut_ad(rec_get_nth_field(mrec, moffsets, trx_id_col + 1, &len) + == mrec_trx_id + DATA_TRX_ID_LEN); + ut_ad(len == DATA_ROLL_PTR_LEN); + ut_ad(rec_get_nth_field(btr_pcur_get_rec(&pcur), offsets, + trx_id_col + 1, &len) + == rec_trx_id + DATA_TRX_ID_LEN); + ut_ad(len == DATA_ROLL_PTR_LEN); + + if (memcmp(mrec_trx_id, rec_trx_id, + DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN)) { + /* The ROW_T_DELETE was logged for a different + PRIMARY KEY,DB_TRX_ID,DB_ROLL_PTR. + This is possible if a ROW_T_INSERT was skipped + or a ROW_T_UPDATE was interpreted as ROW_T_DELETE + because some BLOBs were missing due to + (1) rolling back the initial insert, or + (2) purging the BLOB for a later ROW_T_DELETE + (3) purging 'old values' for a later ROW_T_UPDATE + or ROW_T_DELETE. */ + ut_ad(!log->same_pk); goto all_done; } } @@ -1679,17 +1792,32 @@ row_log_table_apply_update( == dict_index_get_n_unique(index)); ut_ad(dtuple_get_n_fields(old_pk) == dict_index_get_n_unique(index) - + (dup->index->online_log->same_pk ? 0 : 2)); + + (log->same_pk ? 0 : 2)); row = row_log_table_apply_convert_mrec( mrec, dup->index, offsets, log, heap, trx_id, &error); - ut_ad(error == DB_SUCCESS || !row); - /* Handling of duplicate key error requires storing - of offending key in a record buffer. */ - ut_ad(error != DB_DUPLICATE_KEY); - - if (!row) { + switch (error) { + case DB_MISSING_HISTORY: + /* The record contained BLOBs that are now missing. */ + ut_ad(log->blobs); + /* Whether or not we are updating the PRIMARY KEY, we + know that there should be a subsequent + ROW_T_DELETE for rolling back a preceding ROW_T_INSERT, + overriding this ROW_T_UPDATE record. (*1) + + This allows us to interpret this ROW_T_UPDATE + as ROW_T_DELETE. + + When applying the subsequent ROW_T_DELETE, no matching + record will be found. */ + case DB_SUCCESS: + ut_ad(row != NULL); + break; + default: + ut_ad(0); + case DB_INVALID_NULL: + ut_ad(row == NULL); return(error); } @@ -1712,10 +1840,57 @@ row_log_table_apply_update( if (page_rec_is_infimum(btr_pcur_get_rec(&pcur)) || btr_pcur_get_low_match(&pcur) < index->n_uniq) { - ut_ad(0); - error = DB_CORRUPTION; + /* The record was not found. This should only happen + when an earlier ROW_T_INSERT or ROW_T_UPDATE was + diverted because BLOBs were freed when the insert was + later rolled back. */ + + ut_ad(log->blobs); + + if (error == DB_SUCCESS) { + /* An earlier ROW_T_INSERT could have been + skipped because of a missing BLOB, like this: + + BEGIN; + INSERT INTO t SET blob_col='blob value'; + UPDATE t SET blob_col=''; + ROLLBACK; + + This would generate the following records: + ROW_T_INSERT (referring to 'blob value') + ROW_T_UPDATE + ROW_T_UPDATE (referring to 'blob value') + ROW_T_DELETE + [ROLLBACK removes the 'blob value'] + + The ROW_T_INSERT would have been skipped + because of a missing BLOB. Now we are + executing the first ROW_T_UPDATE. + The second ROW_T_UPDATE (for the ROLLBACK) + would be interpreted as ROW_T_DELETE, because + the BLOB would be missing. + + We could probably assume that the transaction + has been rolled back and simply skip the + 'insert' part of this ROW_T_UPDATE record. + However, there might be some complex scenario + that could interfere with such a shortcut. + So, we will insert the row (and risk + introducing a bogus duplicate key error + for the ALTER TABLE), and a subsequent + ROW_T_UPDATE or ROW_T_DELETE will delete it. */ + mtr_commit(&mtr); + error = row_log_table_apply_insert_low( + thr, row, trx_id, offsets_heap, heap, dup); + } else { + /* Some BLOBs are missing, so we are interpreting + this ROW_T_UPDATE as ROW_T_DELETE (see *1). + Because the record was not found, we do nothing. */ + ut_ad(error == DB_MISSING_HISTORY); + error = DB_SUCCESS; func_exit: - mtr_commit(&mtr); + mtr_commit(&mtr); + } func_exit_committed: ut_ad(mtr.state == MTR_COMMITTED); @@ -1728,19 +1903,76 @@ func_exit_committed: return(error); } - /* Update the record. */ + /* Prepare to update (or delete) the record. */ ulint* cur_offsets = rec_get_offsets( btr_pcur_get_rec(&pcur), index, NULL, ULINT_UNDEFINED, &offsets_heap); + if (!log->same_pk) { + /* Only update the record if DB_TRX_ID,DB_ROLL_PTR match what + was buffered. */ + ulint len; + const void* rec_trx_id + = rec_get_nth_field(btr_pcur_get_rec(&pcur), + cur_offsets, index->n_uniq, &len); + ut_ad(len == DATA_TRX_ID_LEN); + ut_ad(dtuple_get_nth_field(old_pk, index->n_uniq)->len + == DATA_TRX_ID_LEN); + ut_ad(dtuple_get_nth_field(old_pk, index->n_uniq + 1)->len + == DATA_ROLL_PTR_LEN); + ut_ad(DATA_TRX_ID_LEN + static_cast<const char*>( + dtuple_get_nth_field(old_pk, + index->n_uniq)->data) + == dtuple_get_nth_field(old_pk, + index->n_uniq + 1)->data); + if (memcmp(rec_trx_id, + dtuple_get_nth_field(old_pk, index->n_uniq)->data, + DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN)) { + /* The ROW_T_UPDATE was logged for a different + DB_TRX_ID,DB_ROLL_PTR. This is possible if an + earlier ROW_T_INSERT or ROW_T_UPDATE was diverted + because some BLOBs were missing due to rolling + back the initial insert or due to purging + the old BLOB values of an update. */ + ut_ad(log->blobs); + if (error != DB_SUCCESS) { + ut_ad(error == DB_MISSING_HISTORY); + /* Some BLOBs are missing, so we are + interpreting this ROW_T_UPDATE as + ROW_T_DELETE (see *1). + Because this is a different row, + we will do nothing. */ + error = DB_SUCCESS; + } else { + /* Because the user record is missing due to + BLOBs that were missing when processing + an earlier log record, we should + interpret the ROW_T_UPDATE as ROW_T_INSERT. + However, there is a different user record + with the same PRIMARY KEY value already. */ + error = DB_DUPLICATE_KEY; + } + + goto func_exit; + } + } + + if (error != DB_SUCCESS) { + ut_ad(error == DB_MISSING_HISTORY); + ut_ad(log->blobs); + /* Some BLOBs are missing, so we are interpreting + this ROW_T_UPDATE as ROW_T_DELETE (see *1). */ + error = row_log_table_apply_delete_low( + &pcur, cur_offsets, NULL, heap, &mtr); + goto func_exit_committed; + } + dtuple_t* entry = row_build_index_entry( row, NULL, index, heap); const upd_t* update = row_upd_build_difference_binary( index, entry, btr_pcur_get_rec(&pcur), cur_offsets, false, NULL, heap); - error = DB_SUCCESS; - if (!update->n_fields) { /* Nothing to do. */ goto func_exit; @@ -1756,7 +1988,7 @@ func_exit_committed: allow purge to free any orphaned externally stored columns. */ - if (pk_updated && dup->index->online_log->same_pk) { + if (pk_updated && log->same_pk) { /* The ROW_T_UPDATE log record should only be written when the PRIMARY KEY fields of the record did not change in the old table. We @@ -1982,7 +2214,7 @@ row_log_table_apply_op( For fixed-length PRIMARY key columns, it is 0. */ mrec += extra_size; - rec_offs_set_n_fields(offsets, new_index->n_uniq + 1); + rec_offs_set_n_fields(offsets, new_index->n_uniq + 2); rec_init_offsets_temp(mrec, new_index, offsets); next_mrec = mrec + rec_offs_data_size(offsets) + ext_size; if (next_mrec > mrec_end) { @@ -2017,7 +2249,7 @@ row_log_table_apply_op( *error = row_log_table_apply_delete( thr, new_trx_id_col, mrec, offsets, offsets_heap, heap, - log->table, ext); + log, ext); break; case ROW_T_UPDATE: @@ -2306,6 +2538,11 @@ all_done: ut_ad(dict_index_is_online_ddl(index)); + if (!row_log_block_allocate(index->online_log->head)) { + error = DB_OUT_OF_MEMORY; + goto func_exit; + } + success = os_file_read_no_error_handling( OS_FILE_FROM_FD(index->online_log->fd), index->online_log->head.block, ofs, @@ -2509,6 +2746,7 @@ func_exit: mem_heap_free(offsets_heap); mem_heap_free(heap); + row_log_block_free(index->online_log->head); ut_free(offsets); return(error); } @@ -2582,9 +2820,7 @@ row_log_allocate( const ulint* col_map)/*!< in: mapping of old column numbers to new ones, or NULL if !table */ { - byte* buf; row_log_t* log; - ulint size; DBUG_ENTER("row_log_allocate"); ut_ad(!dict_index_is_online_ddl(index)); @@ -2596,17 +2832,14 @@ row_log_allocate( #ifdef UNIV_SYNC_DEBUG ut_ad(rw_lock_own(dict_index_get_lock(index), RW_LOCK_EX)); #endif /* UNIV_SYNC_DEBUG */ - size = 2 * srv_sort_buf_size + sizeof *log; - buf = (byte*) os_mem_alloc_large(&size); - if (!buf) { + log = (row_log_t*) ut_malloc(sizeof *log); + if (!log) { DBUG_RETURN(false); } - log = (row_log_t*) &buf[2 * srv_sort_buf_size]; - log->size = size; log->fd = row_merge_file_create_low(); if (log->fd < 0) { - os_mem_free_large(buf, size); + ut_free(log); DBUG_RETURN(false); } mutex_create(index_online_log_key, &log->mutex, @@ -2618,10 +2851,9 @@ row_log_allocate( log->col_map = col_map; log->error = DB_SUCCESS; log->max_trx = 0; - log->head.block = buf; - log->tail.block = buf + srv_sort_buf_size; log->tail.blocks = log->tail.bytes = 0; log->tail.total = 0; + log->tail.block = log->head.block = NULL; log->head.blocks = log->head.bytes = 0; log->head.total = 0; dict_index_set_online_status(index, ONLINE_INDEX_CREATION); @@ -2646,9 +2878,11 @@ row_log_free( MONITOR_ATOMIC_DEC(MONITOR_ONLINE_CREATE_INDEX); delete log->blobs; + row_log_block_free(log->tail); + row_log_block_free(log->head); row_merge_file_destroy_low(log->fd); mutex_free(&log->mutex); - os_mem_free_large(log->head.block, log->size); + ut_free(log); log = 0; } @@ -3074,6 +3308,11 @@ next_block: goto interrupted; } + error = index->online_log->error; + if (error != DB_SUCCESS) { + goto func_exit; + } + if (dict_index_is_corrupted(index)) { error = DB_INDEX_CORRUPT; goto func_exit; @@ -3130,6 +3369,11 @@ all_done: log_free_check(); + if (!row_log_block_allocate(index->online_log->head)) { + error = DB_OUT_OF_MEMORY; + goto func_exit; + } + success = os_file_read_no_error_handling( OS_FILE_FROM_FD(index->online_log->fd), index->online_log->head.block, ofs, @@ -3330,6 +3574,7 @@ func_exit: mem_heap_free(heap); mem_heap_free(offsets_heap); + row_log_block_free(index->online_log->head); ut_free(offsets); return(error); } diff --git a/storage/innobase/row/row0mysql.cc b/storage/innobase/row/row0mysql.cc index 2a60790f29c..93d13ea49ee 100644 --- a/storage/innobase/row/row0mysql.cc +++ b/storage/innobase/row/row0mysql.cc @@ -1277,7 +1277,9 @@ row_insert_for_mysql( " newraw is replaced\n" "InnoDB: with raw, and innodb_force_... is removed.\n", stderr); - + if(srv_force_recovery) { + return(DB_READ_ONLY); + } return(DB_ERROR); } @@ -1662,7 +1664,9 @@ row_update_for_mysql( " is replaced\n" "InnoDB: with raw, and innodb_force_... is removed.\n", stderr); - + if(srv_force_recovery) { + return(DB_READ_ONLY); + } return(DB_ERROR); } @@ -3240,7 +3244,6 @@ row_truncate_table_for_mysql( ut_a(trx->dict_operation_lock_mode == 0); /* Prevent foreign key checks etc. while we are truncating the table */ - row_mysql_lock_data_dictionary(trx); ut_ad(mutex_own(&(dict_sys->mutex))); @@ -3304,6 +3307,25 @@ row_truncate_table_for_mysql( goto funct_exit; } + /* Check if memcached plugin is running on this table. if is, we don't + allow truncate this table. */ + if (table->memcached_sync_count != 0) { + ut_print_timestamp(stderr); + fputs(" InnoDB: Cannot truncate table ", stderr); + ut_print_name(stderr, trx, TRUE, table->name); + fputs(" by DROP+CREATE\n" + "InnoDB: because there are memcached operations" + " running on it.\n", + stderr); + err = DB_ERROR; + + goto funct_exit; + } else { + /* We need to set this counter to -1 for blocking + memcached operations. */ + table->memcached_sync_count = DICT_TABLE_IN_DDL; + } + /* Remove all locks except the table-level X lock. */ lock_remove_all_on_table(table, FALSE); @@ -3487,6 +3509,7 @@ next_rec: fts_table.name = table->name; fts_table.id = new_id; + fts_table.flags2 = table->flags2; err = fts_create_common_tables( trx, &fts_table, table->name, TRUE); @@ -3631,6 +3654,12 @@ next_rec: funct_exit: + if (table->memcached_sync_count == DICT_TABLE_IN_DDL) { + /* We need to set the memcached sync back to 0, unblock + memcached operationse. */ + table->memcached_sync_count = 0; + } + row_mysql_unlock_data_dictionary(trx); dict_stats_update(table, DICT_STATS_EMPTY_TABLE); @@ -4702,6 +4731,9 @@ row_rename_table_for_mysql( " is replaced\n" "InnoDB: with raw, and innodb_force_... is removed.\n", stderr); + if(srv_force_recovery) { + err = DB_READ_ONLY; + } goto funct_exit; } else if (row_mysql_is_system_table(new_name)) { @@ -4975,15 +5007,31 @@ row_rename_table_for_mysql( if (err != DB_SUCCESS && (table->space != 0)) { char* orig_name = table->name; + trx_t* trx_bg = trx_allocate_for_background(); + + /* If the first fts_rename fails, the trx would + be rolled back and committed, we can't use it any more, + so we have to start a new background trx here. */ + ut_a(trx_state_eq(trx, TRX_STATE_NOT_STARTED)); + trx_bg->op_info = "Revert the failing rename " + "for fts aux tables"; + trx_bg->dict_operation_lock_mode = RW_X_LATCH; + trx_start_for_ddl(trx_bg, TRX_DICT_OP_TABLE); /* If rename fails and table has its own tablespace, we need to call fts_rename_aux_tables again to revert the ibd file rename, which is not under the control of trx. Also notice the parent table name - in cache is not changed yet. */ + in cache is not changed yet. If the reverting fails, + the ibd data may be left in the new database, which + can be fixed only manually. */ table->name = const_cast<char*>(new_name); - fts_rename_aux_tables(table, old_name, trx); + fts_rename_aux_tables(table, old_name, trx_bg); table->name = orig_name; + + trx_bg->dict_operation_lock_mode = 0; + trx_commit_for_mysql(trx_bg); + trx_free_for_background(trx_bg); } } diff --git a/storage/innobase/row/row0quiesce.cc b/storage/innobase/row/row0quiesce.cc index a59a6088ad6..1d67d5a9717 100644 --- a/storage/innobase/row/row0quiesce.cc +++ b/storage/innobase/row/row0quiesce.cc @@ -71,7 +71,7 @@ row_quiesce_write_index_fields( } /* Include the NUL byte in the length. */ - ib_uint32_t len = strlen(field->name) + 1; + ib_uint32_t len = static_cast<ib_uint32_t>(strlen(field->name) + 1); ut_a(len > 1); mach_write_to_4(row, len); @@ -180,7 +180,7 @@ row_quiesce_write_indexes( /* Write the length of the index name. NUL byte is included in the length. */ - ib_uint32_t len = strlen(index->name) + 1; + ib_uint32_t len = static_cast<ib_uint32_t>(strlen(index->name) + 1); ut_a(len > 1); mach_write_to_4(row, len); @@ -267,7 +267,7 @@ row_quiesce_write_table( col_name = dict_table_get_col_name(table, dict_col_get_no(col)); /* Include the NUL byte in the length. */ - len = strlen(col_name) + 1; + len = static_cast<ib_uint32_t>(strlen(col_name) + 1); ut_a(len > 1); mach_write_to_4(row, len); @@ -333,7 +333,7 @@ row_quiesce_write_header( } /* The server hostname includes the NUL byte. */ - len = strlen(hostname) + 1; + len = static_cast<ib_uint32_t>(strlen(hostname) + 1); mach_write_to_4(value, len); DBUG_EXECUTE_IF("ib_export_io_write_failure_5", close(fileno(file));); @@ -351,7 +351,7 @@ row_quiesce_write_header( /* The table name includes the NUL byte. */ ut_a(table->name != 0); - len = strlen(table->name) + 1; + len = static_cast<ib_uint32_t>(strlen(table->name) + 1); /* Write the table name. */ mach_write_to_4(value, len); diff --git a/storage/innobase/row/row0sel.cc b/storage/innobase/row/row0sel.cc index 09cf75c1050..359ae3f2c21 100644 --- a/storage/innobase/row/row0sel.cc +++ b/storage/innobase/row/row0sel.cc @@ -5320,25 +5320,40 @@ func_exit: return(value); } -/*******************************************************************//** -Get the last row. -@return current rec or NULL */ +/** Get the maximum and non-delete-marked record in an index. +@param[in] index index tree +@param[in,out] mtr mini-transaction (may be committed and restarted) +@return maximum record, page s-latched in mtr +@retval NULL if there are no records, or if all of them are delete-marked */ static const rec_t* -row_search_autoinc_get_rec( -/*=======================*/ - btr_pcur_t* pcur, /*!< in: the current cursor */ - mtr_t* mtr) /*!< in: mini transaction */ +row_search_get_max_rec( + dict_index_t* index, + mtr_t* mtr) { + btr_pcur_t pcur; + const rec_t* rec; + /* Open at the high/right end (false), and init cursor */ + btr_pcur_open_at_index_side( + false, index, BTR_SEARCH_LEAF, &pcur, true, 0, mtr); + do { - const rec_t* rec = btr_pcur_get_rec(pcur); + const page_t* page; + + page = btr_pcur_get_page(&pcur); + rec = page_find_rec_max_not_deleted(page); if (page_rec_is_user_rec(rec)) { - return(rec); + break; + } else { + rec = NULL; } - } while (btr_pcur_move_to_prev(pcur, mtr)); + btr_pcur_move_before_first_on_page(&pcur); + } while (btr_pcur_move_to_prev(&pcur, mtr)); - return(NULL); + btr_pcur_close(&pcur); + + return(rec); } /*******************************************************************//** @@ -5353,55 +5368,30 @@ row_search_max_autoinc( const char* col_name, /*!< in: name of autoinc column */ ib_uint64_t* value) /*!< out: AUTOINC value read */ { - ulint i; - ulint n_cols; - dict_field_t* dfield = NULL; + dict_field_t* dfield = dict_index_get_nth_field(index, 0); dberr_t error = DB_SUCCESS; - - n_cols = dict_index_get_n_ordering_defined_by_user(index); - - /* Search the index for the AUTOINC column name */ - for (i = 0; i < n_cols; ++i) { - dfield = dict_index_get_nth_field(index, i); - - if (strcmp(col_name, dfield->name) == 0) { - break; - } - } - *value = 0; - /* Must find the AUTOINC column name */ - if (i < n_cols && dfield) { + if (strcmp(col_name, dfield->name) != 0) { + error = DB_RECORD_NOT_FOUND; + } else { mtr_t mtr; - btr_pcur_t pcur; + const rec_t* rec; mtr_start(&mtr); - /* Open at the high/right end (false), and init cursor */ - btr_pcur_open_at_index_side( - false, index, BTR_SEARCH_LEAF, &pcur, true, 0, &mtr); - - if (!page_is_empty(btr_pcur_get_page(&pcur))) { - const rec_t* rec; - - rec = row_search_autoinc_get_rec(&pcur, &mtr); + rec = row_search_get_max_rec(index, &mtr); - if (rec != NULL) { - ibool unsigned_type = ( - dfield->col->prtype & DATA_UNSIGNED); + if (rec != NULL) { + ibool unsigned_type = ( + dfield->col->prtype & DATA_UNSIGNED); - *value = row_search_autoinc_read_column( - index, rec, i, - dfield->col->mtype, unsigned_type); - } + *value = row_search_autoinc_read_column( + index, rec, 0, + dfield->col->mtype, unsigned_type); } - btr_pcur_close(&pcur); - mtr_commit(&mtr); - } else { - error = DB_RECORD_NOT_FOUND; } return(error); diff --git a/storage/innobase/row/row0uins.cc b/storage/innobase/row/row0uins.cc index 7b50d8b62ae..849bf096492 100644 --- a/storage/innobase/row/row0uins.cc +++ b/storage/innobase/row/row0uins.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1997, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1997, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -109,8 +109,7 @@ row_undo_ins_remove_clust_rec( mem_heap_t* heap = NULL; const ulint* offsets = rec_get_offsets( rec, index, NULL, ULINT_UNDEFINED, &heap); - row_log_table_delete( - rec, index, offsets, true, node->trx->id); + row_log_table_delete(rec, index, offsets, NULL); mem_heap_free(heap); } diff --git a/storage/innobase/row/row0umod.cc b/storage/innobase/row/row0umod.cc index efcd63a4d29..e513d3d6d8b 100644 --- a/storage/innobase/row/row0umod.cc +++ b/storage/innobase/row/row0umod.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1997, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1997, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -86,6 +86,8 @@ row_undo_mod_clust_low( before the update, or NULL if the table is not being rebuilt online or the PRIMARY KEY definition does not change */ + byte* sys, /*!< out: DB_TRX_ID, DB_ROLL_PTR + for row_log_table_delete() */ que_thr_t* thr, /*!< in: query thread */ mtr_t* mtr, /*!< in: mtr; must be committed before latching any further pages */ @@ -115,7 +117,7 @@ row_undo_mod_clust_low( && dict_index_is_online_ddl(btr_cur_get_index(btr_cur))) { *rebuilt_old_pk = row_log_table_get_pk( btr_cur_get_rec(btr_cur), - btr_cur_get_index(btr_cur), NULL, &heap); + btr_cur_get_index(btr_cur), NULL, sys, &heap); } else { *rebuilt_old_pk = NULL; } @@ -307,12 +309,13 @@ row_undo_mod_clust( mem_heap_t* offsets_heap = NULL; ulint* offsets = NULL; const dtuple_t* rebuilt_old_pk; + byte sys[DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN]; /* Try optimistic processing of the record, keeping changes within the index page */ err = row_undo_mod_clust_low(node, &offsets, &offsets_heap, - heap, &rebuilt_old_pk, + heap, &rebuilt_old_pk, sys, thr, &mtr, online ? BTR_MODIFY_LEAF | BTR_ALREADY_S_LATCHED : BTR_MODIFY_LEAF); @@ -326,7 +329,8 @@ row_undo_mod_clust( mtr_start(&mtr); err = row_undo_mod_clust_low( - node, &offsets, &offsets_heap, heap, &rebuilt_old_pk, + node, &offsets, &offsets_heap, + heap, &rebuilt_old_pk, sys, thr, &mtr, BTR_MODIFY_TREE); ut_ad(err == DB_SUCCESS || err == DB_OUT_OF_FILE_SPACE); } @@ -352,8 +356,7 @@ row_undo_mod_clust( break; case TRX_UNDO_UPD_DEL_REC: row_log_table_delete( - btr_pcur_get_rec(pcur), index, offsets, - true, node->trx->id); + btr_pcur_get_rec(pcur), index, offsets, sys); break; default: ut_ad(0); diff --git a/storage/innobase/row/row0upd.cc b/storage/innobase/row/row0upd.cc index d34ffdd5f6d..6a727e16812 100644 --- a/storage/innobase/row/row0upd.cc +++ b/storage/innobase/row/row0upd.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1996, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1996, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -2146,9 +2146,7 @@ row_upd_clust_rec_by_insert_inherit_func( data += len - BTR_EXTERN_FIELD_REF_SIZE; /* The pointer must not be zero. */ ut_a(memcmp(data, field_ref_zero, BTR_EXTERN_FIELD_REF_SIZE)); - /* The BLOB must be owned. */ - ut_a(!(data[BTR_EXTERN_LEN] & BTR_EXTERN_OWNER_FLAG)); - + data[BTR_EXTERN_LEN] &= ~BTR_EXTERN_OWNER_FLAG; data[BTR_EXTERN_LEN] |= BTR_EXTERN_INHERITED_FLAG; /* The BTR_EXTERN_INHERITED_FLAG only matters in rollback. Purge will always free the extern fields of @@ -2256,7 +2254,13 @@ err_exit: rec, offsets, entry, node->update); if (change_ownership) { - btr_pcur_store_position(pcur, mtr); + /* The blobs are disowned here, expecting the + insert down below to inherit them. But if the + insert fails, then this disown will be undone + when the operation is rolled back. */ + btr_cur_disown_inherited_fields( + btr_cur_get_page_zip(btr_cur), + rec, index, offsets, node->update, mtr); } } @@ -2310,41 +2314,6 @@ err_exit: ? UPD_NODE_INSERT_BLOB : UPD_NODE_INSERT_CLUSTERED; - if (err == DB_SUCCESS && change_ownership) { - /* Mark the non-updated fields disowned by the old record. */ - - /* NOTE: this transaction has an x-lock on the record - and therefore other transactions cannot modify the - record when we have no latch on the page. In addition, - we assume that other query threads of the same - transaction do not modify the record in the meantime. - Therefore we can assert that the restoration of the - cursor succeeds. */ - - mtr_start(mtr); - - if (!btr_pcur_restore_position(BTR_MODIFY_LEAF, pcur, mtr)) { - ut_error; - } - - rec = btr_cur_get_rec(btr_cur); - offsets = rec_get_offsets(rec, index, offsets, - ULINT_UNDEFINED, &heap); - ut_ad(page_rec_is_user_rec(rec)); - ut_ad(rec_get_deleted_flag(rec, rec_offs_comp(offsets))); - - btr_cur_disown_inherited_fields( - btr_cur_get_page_zip(btr_cur), - rec, index, offsets, node->update, mtr); - - /* It is not necessary to call row_log_table for - this, because during online table rebuild, purge will - not free any BLOBs in the table, whether or not they - are owned by the clustered index record. */ - - mtr_commit(mtr); - } - mem_heap_free(heap); return(err); @@ -2387,7 +2356,7 @@ row_upd_clust_rec( if (dict_index_is_online_ddl(index)) { rebuilt_old_pk = row_log_table_get_pk( - btr_cur_get_rec(btr_cur), index, offsets, &heap); + btr_cur_get_rec(btr_cur), index, offsets, NULL, &heap); } /* Try optimistic updating of the record, keeping changes within diff --git a/storage/innobase/row/row0vers.cc b/storage/innobase/row/row0vers.cc index 2c3191928fd..9dd7b63bcab 100644 --- a/storage/innobase/row/row0vers.cc +++ b/storage/innobase/row/row0vers.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1997, 2012, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 1997, 2014, Oracle and/or its affiliates. All Rights Reserved. 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 @@ -73,6 +73,8 @@ row_vers_impl_x_locked_low( ulint* clust_offsets; mem_heap_t* heap; + DBUG_ENTER("row_vers_impl_x_locked_low"); + ut_ad(rec_offs_validate(rec, index, offsets)); heap = mem_heap_create(1024); @@ -92,7 +94,7 @@ row_vers_impl_x_locked_low( trx_sys_get_max_trx_id()); } mem_heap_free(heap); - return(0); + DBUG_RETURN(0); } comp = page_rec_is_comp(rec); @@ -131,17 +133,37 @@ row_vers_impl_x_locked_low( clust_rec, mtr, version, clust_index, clust_offsets, heap, &prev_version); - /* Free version and clust_offsets. */ + /* The oldest visible clustered index version must not be + delete-marked, because we never start a transaction by + inserting a delete-marked record. */ + ut_ad(prev_version + || !rec_get_deleted_flag(version, comp) + || !trx_rw_is_active(trx_id, NULL)); + /* Free version and clust_offsets. */ mem_heap_free(old_heap); if (prev_version == NULL) { - /* clust_rec should be a fresh insert, because - no previous version was found or the transaction - has committed. The caller has to recheck as the - synopsis of this function states, whether trx_id - is active or not. */ + /* We reached the oldest visible version without + finding an older version of clust_rec that would + match the secondary index record. If the secondary + index record is not delete marked, then clust_rec + is considered the correct match of the secondary + index record and hence holds the implicit lock. */ + + if (rec_del) { + /* The secondary index record is del marked. + So, the implicit lock holder of clust_rec + did not modify the secondary index record yet, + and is not holding an implicit lock on it. + + This assumes that whenever a row is inserted + or updated, the leaf page record always is + created with a clear delete-mark flag. + (We never insert a delete-marked record.) */ + trx_id = 0; + } break; } @@ -237,8 +259,11 @@ row_vers_impl_x_locked_low( } } + DBUG_PRINT("info", ("Implicit lock is held by trx:%lu", + static_cast<unsigned long>(trx_id))); + mem_heap_free(heap); - return(trx_id); + DBUG_RETURN(trx_id); } /*****************************************************************//** diff --git a/storage/innobase/srv/srv0conc.cc b/storage/innobase/srv/srv0conc.cc index 5affd671fbe..cbf81f8e8f7 100644 --- a/storage/innobase/srv/srv0conc.cc +++ b/storage/innobase/srv/srv0conc.cc @@ -290,7 +290,7 @@ srv_conc_enter_innodb_with_atomics( && sleep_in_us > srv_adaptive_max_sleep_delay) { sleep_in_us = srv_adaptive_max_sleep_delay; - srv_thread_sleep_delay = sleep_in_us; + srv_thread_sleep_delay = static_cast<ulong>(sleep_in_us); } os_thread_sleep(sleep_in_us); diff --git a/storage/innobase/srv/srv0srv.cc b/storage/innobase/srv/srv0srv.cc index aab893df09b..6a410285f2b 100644 --- a/storage/innobase/srv/srv0srv.cc +++ b/storage/innobase/srv/srv0srv.cc @@ -386,8 +386,8 @@ UNIV_INTERN ulint srv_available_undo_logs = 0; /* Set the following to 0 if you want InnoDB to write messages on stderr on startup/shutdown. */ UNIV_INTERN ibool srv_print_verbose_log = TRUE; -UNIV_INTERN ibool srv_print_innodb_monitor = FALSE; -UNIV_INTERN ibool srv_print_innodb_lock_monitor = FALSE; +UNIV_INTERN my_bool srv_print_innodb_monitor = FALSE; +UNIV_INTERN my_bool srv_print_innodb_lock_monitor = FALSE; UNIV_INTERN ibool srv_print_innodb_tablespace_monitor = FALSE; UNIV_INTERN ibool srv_print_innodb_table_monitor = FALSE; @@ -2691,7 +2691,8 @@ srv_purge_coordinator_suspend( rw_lock_x_lock(&purge_sys->latch); - stop = (purge_sys->state == PURGE_STATE_STOP); + stop = (srv_shutdown_state == SRV_SHUTDOWN_NONE + && purge_sys->state == PURGE_STATE_STOP); if (!stop) { ut_a(purge_sys->n_stop == 0); @@ -2776,8 +2777,9 @@ DECLARE_THREAD(srv_purge_coordinator_thread)( /* If there are no records to purge or the last purge didn't purge any records then wait for activity. */ - if (purge_sys->state == PURGE_STATE_STOP - || n_total_purged == 0) { + if (srv_shutdown_state == SRV_SHUTDOWN_NONE + && (purge_sys->state == PURGE_STATE_STOP + || n_total_purged == 0)) { srv_purge_coordinator_suspend(slot, rseg_history_len); } diff --git a/storage/innobase/srv/srv0start.cc b/storage/innobase/srv/srv0start.cc index 00604a896ca..0c04fba421a 100644 --- a/storage/innobase/srv/srv0start.cc +++ b/storage/innobase/srv/srv0start.cc @@ -1,6 +1,6 @@ /***************************************************************************** -Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. +Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved. Copyright (c) 2008, Google Inc. Copyright (c) 2009, Percona Inc. @@ -158,7 +158,7 @@ UNIV_INTERN mysql_pfs_key_t srv_purge_thread_key; #endif /* UNIV_PFS_THREAD */ /*********************************************************************//** -Convert a numeric string that optionally ends in G or M, to a number +Convert a numeric string that optionally ends in G or M or K, to a number containing megabytes. @return next character in string */ static @@ -182,6 +182,10 @@ srv_parse_megabytes( case 'M': case 'm': str++; break; + case 'K': case 'k': + size /= 1024; + str++; + break; default: size /= 1024 * 1024; break; @@ -218,7 +222,8 @@ srv_file_check_mode( /* Note: stat.rw_perm is only valid of files */ - if (stat.type == OS_FILE_TYPE_FILE) { + if (stat.type == OS_FILE_TYPE_FILE + || stat.type == OS_FILE_TYPE_BLOCK) { if (!stat.rw_perm) { ib_logf(IB_LOG_LEVEL_ERROR, @@ -980,6 +985,16 @@ size_check: return(DB_ERROR); } skip_size_check: + + /* This is the earliest location where we can load + the double write buffer. */ + if (i == 0) { + buf_dblwr_init_or_load_pages( + files[i], srv_data_file_names[i], true); + } + + bool retry = true; +check_first_page: check_msg = fil_read_first_page( files[i], one_opened, &flags, &space, #ifdef UNIV_LOG_ARCHIVE @@ -988,9 +1003,25 @@ skip_size_check: min_flushed_lsn, max_flushed_lsn); if (check_msg) { + + if (retry) { + fsp_open_info fsp; + const ulint page_no = 0; + + retry = false; + fsp.id = 0; + fsp.filepath = srv_data_file_names[i]; + fsp.file = files[i]; + + if (fil_user_tablespace_restore_page( + &fsp, page_no)) { + goto check_first_page; + } + } + ib_logf(IB_LOG_LEVEL_ERROR, - "%s in data file %s", - check_msg, name); + "%s in data file %s", + check_msg, name); return(DB_ERROR); } @@ -1526,6 +1557,16 @@ innobase_start_or_create_for_mysql(void) # endif /* F_FULLFSYNC */ #endif /* HAVE_DARWIN_THREADS */ + ib_logf(IB_LOG_LEVEL_INFO, + "Using %s to ref count buffer pool pages", +#ifdef PAGE_ATOMIC_REF_COUNT + "atomics" +#else + "mutexes" +#endif /* PAGE_ATOMIC_REF_COUNT */ + ); + + if (sizeof(ulint) != sizeof(void*)) { ut_print_timestamp(stderr); fprintf(stderr, @@ -1999,6 +2040,9 @@ innobase_start_or_create_for_mysql(void) return(DB_ERROR); } + recv_sys_create(); + recv_sys_init(buf_pool_get_curr_size()); + err = open_or_create_data_files(&create_new_db, #ifdef UNIV_LOG_ARCHIVE &min_arch_log_no, &max_arch_log_no, diff --git a/storage/innobase/sync/sync0arr.cc b/storage/innobase/sync/sync0arr.cc index e06bc01c890..2cfb693f8ba 100644 --- a/storage/innobase/sync/sync0arr.cc +++ b/storage/innobase/sync/sync0arr.cc @@ -1010,7 +1010,7 @@ sync_array_print_long_waits( os_thread_sleep(30000000); - srv_print_innodb_monitor = old_val; + srv_print_innodb_monitor = static_cast<my_bool>(old_val); fprintf(stderr, "InnoDB: ###### Diagnostic info printed" " to the standard error stream\n"); diff --git a/storage/innobase/sync/sync0sync.cc b/storage/innobase/sync/sync0sync.cc index 90f16719e20..5ef8a02fb3f 100644 --- a/storage/innobase/sync/sync0sync.cc +++ b/storage/innobase/sync/sync0sync.cc @@ -1137,6 +1137,7 @@ sync_thread_add_level( case SYNC_RECV: case SYNC_FTS_BG_THREADS: case SYNC_WORK_QUEUE: + case SYNC_FTS_TOKENIZE: case SYNC_FTS_OPTIMIZE: case SYNC_FTS_CACHE: case SYNC_FTS_CACHE_INIT: diff --git a/storage/innobase/trx/trx0trx.cc b/storage/innobase/trx/trx0trx.cc index c78f609db45..38b21d8d428 100644 --- a/storage/innobase/trx/trx0trx.cc +++ b/storage/innobase/trx/trx0trx.cc @@ -565,6 +565,13 @@ trx_resurrect_insert( trx->no = TRX_ID_MAX; } + /* trx_start_low() is not called with resurrect, so need to initialize + start time here.*/ + if (trx->state == TRX_STATE_ACTIVE + || trx->state == TRX_STATE_PREPARED) { + trx->start_time = ut_time(); + } + if (undo->dict_operation) { trx_set_dict_operation(trx, TRX_DICT_OP_TABLE); trx->table_id = undo->table_id; @@ -652,6 +659,13 @@ trx_resurrect_update( trx->no = TRX_ID_MAX; } + /* trx_start_low() is not called with resurrect, so need to initialize + start time here.*/ + if (trx->state == TRX_STATE_ACTIVE + || trx->state == TRX_STATE_PREPARED) { + trx->start_time = ut_time(); + } + if (undo->dict_operation) { trx_set_dict_operation(trx, TRX_DICT_OP_TABLE); trx->table_id = undo->table_id; @@ -1827,7 +1841,8 @@ state_ok: } if (trx->mysql_thd != NULL) { - innobase_mysql_print_thd(f, trx->mysql_thd, max_query_len); + innobase_mysql_print_thd( + f, trx->mysql_thd, static_cast<uint>(max_query_len)); } } diff --git a/storage/innobase/ut/ut0ut.cc b/storage/innobase/ut/ut0ut.cc index 939a413b4f3..b273b5a117e 100644 --- a/storage/innobase/ut/ut0ut.cc +++ b/storage/innobase/ut/ut0ut.cc @@ -820,6 +820,8 @@ ut_strerr( return("FTS query exceeds result cache limit"); case DB_TEMP_FILE_WRITE_FAILURE: return("Temp file write failure"); + case DB_FTS_TOO_MANY_WORDS_IN_PHRASE: + return("Too many words in a FTS phrase or proximity search"); /* do not add default: in order to produce a warning if new code is added to the enum but not added here */ |