ha0ha.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 1994, 2011, 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
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.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/**************************************************/
#ifndef ha0ha_h
#define ha0ha_h

#include "univ.i"

#include "hash0hash.h"
#include "page0types.h"
#include "buf0types.h"
#include "rem0types.h"

/*************************************************************/
UNIV_INLINE
const rec_t*
ha_search_and_get_data(
/*===================*/
        hash_table_t*   table,  
        ulint           fold);  
/*********************************************************/
UNIV_INTERN
ibool
ha_search_and_update_if_found_func(
/*===============================*/
        hash_table_t*   table,  
        ulint           fold,   
        const rec_t*    data,   
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
        buf_block_t*    new_block,
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
        const rec_t*    new_data);
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG

# define ha_search_and_update_if_found(table,fold,data,new_block,new_data) \
        ha_search_and_update_if_found_func(table,fold,data,new_block,new_data)
#else /* UNIV_AHI_DEBUG || UNIV_DEBUG */

# define ha_search_and_update_if_found(table,fold,data,new_block,new_data) \
        ha_search_and_update_if_found_func(table,fold,data,new_data)
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
/*************************************************************/
UNIV_INTERN
hash_table_t*
ha_create_func(
/*===========*/
        ulint   n,              
#ifdef UNIV_SYNC_DEBUG
        ulint   mutex_level,    
#endif /* UNIV_SYNC_DEBUG */
        ulint   n_mutexes,      
        ulint   type);          
#ifdef UNIV_SYNC_DEBUG

# define ha_create(n_c,n_m,type,level) ha_create_func(n_c,level,n_m,type)
#else /* UNIV_SYNC_DEBUG */

# define ha_create(n_c,n_m,type,level) ha_create_func(n_c,n_m,type)
#endif /* UNIV_SYNC_DEBUG */

/*************************************************************/
UNIV_INTERN
void
ha_clear(
/*=====*/
        hash_table_t*   table); 
/*************************************************************/
UNIV_INTERN
ibool
ha_insert_for_fold_func(
/*====================*/
        hash_table_t*   table,  
        ulint           fold,   
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
        buf_block_t*    block,  
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
        const rec_t*    data);  
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG

# define ha_insert_for_fold(t,f,b,d)    do {            \
        ha_insert_for_fold_func(t,f,b,d);               \
        MONITOR_INC(MONITOR_ADAPTIVE_HASH_ROW_ADDED);   \
} while(0)
#else /* UNIV_AHI_DEBUG || UNIV_DEBUG */

# define ha_insert_for_fold(t,f,b,d)    do {            \
        ha_insert_for_fold_func(t,f,d);                 \
        MONITOR_INC(MONITOR_ADAPTIVE_HASH_ROW_ADDED);   \
} while (0)
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */

/*********************************************************/
UNIV_INLINE
ibool
ha_search_and_delete_if_found(
/*==========================*/
        hash_table_t*   table,  
        ulint           fold,   
        const rec_t*    data);  
#ifndef UNIV_HOTBACKUP
/*****************************************************************/
UNIV_INTERN
void
ha_remove_all_nodes_to_page(
/*========================*/
        hash_table_t*   table,  
        ulint           fold,   
        const page_t*   page);  
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
/*************************************************************/
UNIV_INTERN
ibool
ha_validate(
/*========*/
        hash_table_t*   table,          
        ulint           start_index,    
        ulint           end_index);     
#endif /* defined UNIV_AHI_DEBUG || defined UNIV_DEBUG */
/*************************************************************/
UNIV_INTERN
void
ha_print_info(
/*==========*/
        FILE*           file,   
        hash_table_t*   table); 
#endif /* !UNIV_HOTBACKUP */

struct ha_node_t {
        ha_node_t*      next;   
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
        buf_block_t*    block;  
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
        const rec_t*    data;   
        ulint           fold;   
};

#ifdef UNIV_DEBUG
/********************************************************************/
UNIV_INLINE
void
hash_assert_can_modify(
/*===================*/
        hash_table_t*   table,  
        ulint           fold);  
/********************************************************************/
UNIV_INLINE
void
hash_assert_can_search(
/*===================*/
        hash_table_t*   table,  
        ulint           fold);  
#else /* UNIV_DEBUG */
#define hash_assert_can_modify(t, f)
#define hash_assert_can_search(t, f)
#endif /* UNIV_DEBUG */


#ifndef UNIV_NONINL
#include "ha0ha.ic"
#endif

#endif