mirror of
https://github.com/MariaDB/server.git
synced 2025-01-18 21:12:26 +01:00
b4a25f462e
called on any table. This patch fixes this by only doing this full check in debug versions. bug#55716 rb://423 approved by: Marko
320 lines
11 KiB
C
320 lines
11 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1996, 2009, Innobase Oy. 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
|
|
Foundation; version 2 of the License.
|
|
|
|
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, write to the Free Software Foundation, Inc., 59 Temple
|
|
Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/********************************************************************//**
|
|
@file include/btr0sea.h
|
|
The index tree adaptive search
|
|
|
|
Created 2/17/1996 Heikki Tuuri
|
|
*************************************************************************/
|
|
|
|
#ifndef btr0sea_h
|
|
#define btr0sea_h
|
|
|
|
#include "univ.i"
|
|
|
|
#include "rem0rec.h"
|
|
#include "dict0dict.h"
|
|
#include "btr0types.h"
|
|
#include "mtr0mtr.h"
|
|
#include "ha0ha.h"
|
|
|
|
/*****************************************************************//**
|
|
Creates and initializes the adaptive search system at a database start. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_sys_create(
|
|
/*==================*/
|
|
ulint hash_size); /*!< in: hash index hash table size */
|
|
/*****************************************************************//**
|
|
Frees the adaptive search system at a database shutdown. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_sys_free(void);
|
|
/*=====================*/
|
|
|
|
/********************************************************************//**
|
|
Disable the adaptive hash search system and empty the index. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_disable(void);
|
|
/*====================*/
|
|
/********************************************************************//**
|
|
Enable the adaptive hash search system. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_enable(void);
|
|
/*====================*/
|
|
|
|
/********************************************************************//**
|
|
Returns search info for an index.
|
|
@return search info; search mutex reserved */
|
|
UNIV_INLINE
|
|
btr_search_t*
|
|
btr_search_get_info(
|
|
/*================*/
|
|
dict_index_t* index); /*!< in: index */
|
|
/*****************************************************************//**
|
|
Creates and initializes a search info struct.
|
|
@return own: search info struct */
|
|
UNIV_INTERN
|
|
btr_search_t*
|
|
btr_search_info_create(
|
|
/*===================*/
|
|
mem_heap_t* heap); /*!< in: heap where created */
|
|
/*****************************************************************//**
|
|
Returns the value of ref_count. The value is protected by
|
|
btr_search_latch.
|
|
@return ref_count value. */
|
|
UNIV_INTERN
|
|
ulint
|
|
btr_search_info_get_ref_count(
|
|
/*==========================*/
|
|
btr_search_t* info); /*!< in: search info. */
|
|
/*********************************************************************//**
|
|
Updates the search info. */
|
|
UNIV_INLINE
|
|
void
|
|
btr_search_info_update(
|
|
/*===================*/
|
|
dict_index_t* index, /*!< in: index of the cursor */
|
|
btr_cur_t* cursor);/*!< in: cursor which was just positioned */
|
|
/******************************************************************//**
|
|
Tries to guess the right search position based on the hash search info
|
|
of the index. Note that if mode is PAGE_CUR_LE, which is used in inserts,
|
|
and the function returns TRUE, then cursor->up_match and cursor->low_match
|
|
both have sensible values.
|
|
@return TRUE if succeeded */
|
|
UNIV_INTERN
|
|
ibool
|
|
btr_search_guess_on_hash(
|
|
/*=====================*/
|
|
dict_index_t* index, /*!< in: index */
|
|
btr_search_t* info, /*!< in: index search info */
|
|
const dtuple_t* tuple, /*!< in: logical record */
|
|
ulint mode, /*!< in: PAGE_CUR_L, ... */
|
|
ulint latch_mode, /*!< in: BTR_SEARCH_LEAF, ... */
|
|
btr_cur_t* cursor, /*!< out: tree cursor */
|
|
ulint has_search_latch,/*!< in: latch mode the caller
|
|
currently has on btr_search_latch:
|
|
RW_S_LATCH, RW_X_LATCH, or 0 */
|
|
mtr_t* mtr); /*!< in: mtr */
|
|
/********************************************************************//**
|
|
Moves or deletes hash entries for moved records. If new_page is already hashed,
|
|
then the hash index for page, if any, is dropped. If new_page is not hashed,
|
|
and page is hashed, then a new hash index is built to new_page with the same
|
|
parameters as page (this often happens when a page is split). */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_move_or_delete_hash_entries(
|
|
/*===================================*/
|
|
buf_block_t* new_block, /*!< in: records are copied
|
|
to this page */
|
|
buf_block_t* block, /*!< in: index page from which
|
|
records were copied, and the
|
|
copied records will be deleted
|
|
from this page */
|
|
dict_index_t* index); /*!< in: record descriptor */
|
|
/********************************************************************//**
|
|
Drops a page hash index. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_drop_page_hash_index(
|
|
/*============================*/
|
|
buf_block_t* block); /*!< in: block containing index page,
|
|
s- or x-latched, or an index page
|
|
for which we know that
|
|
block->buf_fix_count == 0 */
|
|
/********************************************************************//**
|
|
Drops a page hash index when a page is freed from a fseg to the file system.
|
|
Drops possible hash index if the page happens to be in the buffer pool. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_drop_page_hash_when_freed(
|
|
/*=================================*/
|
|
ulint space, /*!< in: space id */
|
|
ulint zip_size, /*!< in: compressed page size in bytes
|
|
or 0 for uncompressed pages */
|
|
ulint page_no); /*!< in: page number */
|
|
/********************************************************************//**
|
|
Updates the page hash index when a single record is inserted on a page. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_update_hash_node_on_insert(
|
|
/*==================================*/
|
|
btr_cur_t* cursor);/*!< in: cursor which was positioned to the
|
|
place to insert using btr_cur_search_...,
|
|
and the new record has been inserted next
|
|
to the cursor */
|
|
/********************************************************************//**
|
|
Updates the page hash index when a single record is inserted on a page. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_update_hash_on_insert(
|
|
/*=============================*/
|
|
btr_cur_t* cursor);/*!< in: cursor which was positioned to the
|
|
place to insert using btr_cur_search_...,
|
|
and the new record has been inserted next
|
|
to the cursor */
|
|
/********************************************************************//**
|
|
Updates the page hash index when a single record is deleted from a page. */
|
|
UNIV_INTERN
|
|
void
|
|
btr_search_update_hash_on_delete(
|
|
/*=============================*/
|
|
btr_cur_t* cursor);/*!< in: cursor which was positioned on the
|
|
record to delete using btr_cur_search_...,
|
|
the record is not yet deleted */
|
|
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
|
|
/********************************************************************//**
|
|
Validates the search system.
|
|
@return TRUE if ok */
|
|
UNIV_INTERN
|
|
ibool
|
|
btr_search_validate(void);
|
|
/*======================*/
|
|
#else
|
|
# define btr_search_validate() TRUE
|
|
#endif /* defined UNIV_AHI_DEBUG || defined UNIV_DEBUG */
|
|
|
|
/** Flag: has the search system been enabled?
|
|
Protected by btr_search_latch and btr_search_enabled_mutex. */
|
|
extern char btr_search_enabled;
|
|
|
|
/** Flag: whether the search system has completed its disabling process,
|
|
It is set to TRUE right after buf_pool_drop_hash_index() in
|
|
btr_search_disable(), indicating hash index entries are cleaned up.
|
|
Protected by btr_search_latch and btr_search_enabled_mutex. */
|
|
extern ibool btr_search_fully_disabled;
|
|
|
|
/** The search info struct in an index */
|
|
struct btr_search_struct{
|
|
ulint ref_count; /*!< Number of blocks in this index tree
|
|
that have search index built
|
|
i.e. block->index points to this index.
|
|
Protected by btr_search_latch except
|
|
when during initialization in
|
|
btr_search_info_create(). */
|
|
|
|
/* @{ The following fields are not protected by any latch.
|
|
Unfortunately, this means that they must be aligned to
|
|
the machine word, i.e., they cannot be turned into bit-fields. */
|
|
buf_block_t* root_guess;/*!< the root page frame when it was last time
|
|
fetched, or NULL */
|
|
ulint hash_analysis; /*!< when this exceeds
|
|
BTR_SEARCH_HASH_ANALYSIS, the hash
|
|
analysis starts; this is reset if no
|
|
success noticed */
|
|
ibool last_hash_succ; /*!< TRUE if the last search would have
|
|
succeeded, or did succeed, using the hash
|
|
index; NOTE that the value here is not exact:
|
|
it is not calculated for every search, and the
|
|
calculation itself is not always accurate! */
|
|
ulint n_hash_potential;
|
|
/*!< number of consecutive searches
|
|
which would have succeeded, or did succeed,
|
|
using the hash index;
|
|
the range is 0 .. BTR_SEARCH_BUILD_LIMIT + 5 */
|
|
/* @} */
|
|
/*---------------------- @{ */
|
|
ulint n_fields; /*!< recommended prefix length for hash search:
|
|
number of full fields */
|
|
ulint n_bytes; /*!< recommended prefix: number of bytes in
|
|
an incomplete field
|
|
@see BTR_PAGE_MAX_REC_SIZE */
|
|
ibool left_side; /*!< TRUE or FALSE, depending on whether
|
|
the leftmost record of several records with
|
|
the same prefix should be indexed in the
|
|
hash index */
|
|
/*---------------------- @} */
|
|
#ifdef UNIV_SEARCH_PERF_STAT
|
|
ulint n_hash_succ; /*!< number of successful hash searches thus
|
|
far */
|
|
ulint n_hash_fail; /*!< number of failed hash searches */
|
|
ulint n_patt_succ; /*!< number of successful pattern searches thus
|
|
far */
|
|
ulint n_searches; /*!< number of searches */
|
|
#endif /* UNIV_SEARCH_PERF_STAT */
|
|
#ifdef UNIV_DEBUG
|
|
ulint magic_n; /*!< magic number @see BTR_SEARCH_MAGIC_N */
|
|
/** value of btr_search_struct::magic_n, used in assertions */
|
|
# define BTR_SEARCH_MAGIC_N 1112765
|
|
#endif /* UNIV_DEBUG */
|
|
};
|
|
|
|
/** The hash index system */
|
|
typedef struct btr_search_sys_struct btr_search_sys_t;
|
|
|
|
/** The hash index system */
|
|
struct btr_search_sys_struct{
|
|
hash_table_t* hash_index; /*!< the adaptive hash index,
|
|
mapping dtuple_fold values
|
|
to rec_t pointers on index pages */
|
|
};
|
|
|
|
/** The adaptive hash index */
|
|
extern btr_search_sys_t* btr_search_sys;
|
|
|
|
/** @brief The latch protecting the adaptive search system
|
|
|
|
This latch protects the
|
|
(1) hash index;
|
|
(2) columns of a record to which we have a pointer in the hash index;
|
|
|
|
but does NOT protect:
|
|
|
|
(3) next record offset field in a record;
|
|
(4) next or previous records on the same page.
|
|
|
|
Bear in mind (3) and (4) when using the hash index.
|
|
*/
|
|
extern rw_lock_t* btr_search_latch_temp;
|
|
|
|
/** The latch protecting the adaptive search system */
|
|
#define btr_search_latch (*btr_search_latch_temp)
|
|
|
|
#ifdef UNIV_SEARCH_PERF_STAT
|
|
/** Number of successful adaptive hash index lookups */
|
|
extern ulint btr_search_n_succ;
|
|
/** Number of failed adaptive hash index lookups */
|
|
extern ulint btr_search_n_hash_fail;
|
|
#endif /* UNIV_SEARCH_PERF_STAT */
|
|
|
|
/** After change in n_fields or n_bytes in info, this many rounds are waited
|
|
before starting the hash analysis again: this is to save CPU time when there
|
|
is no hope in building a hash index. */
|
|
#define BTR_SEARCH_HASH_ANALYSIS 17
|
|
|
|
/** Limit of consecutive searches for trying a search shortcut on the search
|
|
pattern */
|
|
#define BTR_SEARCH_ON_PATTERN_LIMIT 3
|
|
|
|
/** Limit of consecutive searches for trying a search shortcut using
|
|
the hash index */
|
|
#define BTR_SEARCH_ON_HASH_LIMIT 3
|
|
|
|
/** We do this many searches before trying to keep the search latch
|
|
over calls from MySQL. If we notice someone waiting for the latch, we
|
|
again set this much timeout. This is to reduce contention. */
|
|
#define BTR_SEA_TIMEOUT 10000
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "btr0sea.ic"
|
|
#endif
|
|
|
|
#endif
|