Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/ha/ha0ha.c File Reference

#include "ha0ha.h"
#include "buf0buf.h"

Include dependency graph for ha0ha.c:

Go to the source code of this file.

Functions
hash_table_t *	ha_create (ibool in_btr_search, ulint n, ulint n_mutexes, ulint mutex_level)
ibool	ha_insert_for_fold (hash_table_t *table, ulint fold, void *data)
void	ha_delete_hash_node (hash_table_t *table, ha_node_t *del_node)
void	ha_delete (hash_table_t *table, ulint fold, void *data)
void	ha_search_and_update_if_found (hash_table_t *table, ulint fold, void *data, void *new_data)
void	ha_remove_all_nodes_to_page (hash_table_t *table, ulint fold, page_t *page)
ibool	ha_validate (hash_table_t *table, ulint start_index, ulint end_index)
void	ha_print_info (FILE *file, hash_table_t *table)

---

Function Documentation

hash_table_t* ha_create	(	ibool	in_btr_search,
		ulint	n,
		ulint	n_mutexes,
		ulint	mutex_level
	)

Definition at line 21 of file ha0ha.c.

References hash_table_struct::adaptive, FALSE, hash_create(), hash_create_mutexes(), hash_table_struct::heap, hash_table_struct::heaps, mem_alloc, mem_heap_create_in_btr_search, mem_heap_create_in_buffer, TRUE, and ut_a.

Referenced by btr_search_sys_create().

                                           : created table */
        ibool   in_btr_search,  /* in: TRUE if the hash table is used in
                                the btr_search module */
        ulint   n,              /* in: number of array cells */
        ulint   n_mutexes,      /* in: number of mutexes to protect the
                                hash table: must be a power of 2, or 0 */
        ulint   mutex_level)    /* in: level of the mutexes in the latching
                                order: this is used in the debug version */
{
        hash_table_t*   table;
        ulint           i;

        table = hash_create(n);

        if (in_btr_search) {
                table->adaptive = TRUE;
        } else {
                table->adaptive = FALSE;
        }

        /* Creating MEM_HEAP_BTR_SEARCH type heaps can potentially fail,
        but in practise it never should in this case, hence the asserts. */

        if (n_mutexes == 0) {
                if (in_btr_search) {
                        table->heap = mem_heap_create_in_btr_search(4096);
                        ut_a(table->heap);
                } else {
                        table->heap = mem_heap_create_in_buffer(4096);
                }

                return(table);
        }

        hash_create_mutexes(table, n_mutexes, mutex_level);

        table->heaps = mem_alloc(n_mutexes * sizeof(void*));

        for (i = 0; i < n_mutexes; i++) {
                if (in_btr_search) {
                        table->heaps[i] = mem_heap_create_in_btr_search(4096);
                        ut_a(table->heaps[i]);
                } else {
                        table->heaps[i] = mem_heap_create_in_buffer(4096);
                }
        }

        return(table);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ha_delete	(	hash_table_t *	table,
		ulint	fold,
		void *	data
	)

Definition at line 186 of file ha0ha.c.

References ha_delete_hash_node(), hash_get_mutex(), hash_table_struct::mutexes, ut_a, and ut_ad.

                                     : hash table */
        ulint           fold,   /* in: folded value of data */
        void*           data)   /* in: data, must not be NULL and must exist
                                in the hash table */
{
        ha_node_t*      node;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
#endif /* UNIV_SYNC_DEBUG */
        node = ha_search_with_data(table, fold, data);

        ut_a(node);

        ha_delete_hash_node(table, node);
}

Here is the call graph for this function:

void ha_delete_hash_node	(	hash_table_t *	table,
		ha_node_t *	del_node
	)

Definition at line 169 of file ha0ha.c.

References hash_table_struct::adaptive, buf_block_align(), ha_node_struct::data, HASH_DELETE_AND_COMPACT, buf_block_struct::n_pointers, and ut_a.

Referenced by ha_delete(), and ha_remove_all_nodes_to_page().

                                             : hash table */
        ha_node_t*      del_node)       /* in: node to be deleted */
{
        if (table->adaptive) {
                ut_a(buf_block_align(del_node->data)->n_pointers > 0);
                buf_block_align(del_node->data)->n_pointers--;
        }

        HASH_DELETE_AND_COMPACT(ha_node_t, next, table, del_node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibool ha_insert_for_fold	(	hash_table_t *	table,
		ulint	fold,
		void *	data
	)

Definition at line 79 of file ha0ha.c.

References hash_table_struct::adaptive, buf_block_align(), ha_node_struct::data, FALSE, ha_node_struct::fold, hash(), hash_calc_hash(), hash_get_heap(), hash_get_mutex(), hash_get_nth_cell(), mem_heap_alloc(), MEM_HEAP_BTR_SEARCH, hash_table_struct::mutexes, buf_block_struct::n_pointers, ha_node_struct::next, hash_cell_struct::node, NULL, TRUE, ut_a, and ut_ad.

Referenced by btr_search_build_page_hash_index(), btr_search_update_hash_on_insert(), and btr_search_update_hash_ref().

                                      : TRUE if succeed, FALSE if no more
                                memory could be allocated */
        hash_table_t*   table,  /* in: hash table */
        ulint           fold,   /* in: folded value of data; if a node with
                                the same fold value already exists, it is
                                updated to point to the same data, and no new
                                node is created! */
        void*           data)   /* in: data, must not be NULL */
{
        hash_cell_t*    cell;
        ha_node_t*      node;
        ha_node_t*      prev_node;
        buf_block_t*    prev_block;
        ulint           hash;

        ut_ad(table && data);
#ifdef UNIV_SYNC_DEBUG
        ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
#endif /* UNIV_SYNC_DEBUG */
        hash = hash_calc_hash(fold, table);

        cell = hash_get_nth_cell(table, hash);

        prev_node = cell->node;

        while (prev_node != NULL) {
                if (prev_node->fold == fold) {
                        if (table->adaptive) {
                                prev_block = buf_block_align(prev_node->data);
                                ut_a(prev_block->n_pointers > 0);
                                prev_block->n_pointers--;
                                buf_block_align(data)->n_pointers++;
                        }

                        prev_node->data = data;

                        return(TRUE);
                }

                prev_node = prev_node->next;
        }

        /* We have to allocate a new chain node */

        node = mem_heap_alloc(hash_get_heap(table, fold), sizeof(ha_node_t));

        if (node == NULL) {
                /* It was a btr search type memory heap and at the moment
                no more memory could be allocated: return */

                ut_ad(hash_get_heap(table, fold)->type & MEM_HEAP_BTR_SEARCH);

                return(FALSE);
        }

        ha_node_set_data(node, data);

        if (table->adaptive) {
                buf_block_align(data)->n_pointers++;
        }

        node->fold = fold;

        node->next = NULL;

        prev_node = cell->node;

        if (prev_node == NULL) {

                cell->node = node;

                return(TRUE);
        }

        while (prev_node->next != NULL) {

                prev_node = prev_node->next;
        }

        prev_node->next = node;

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ha_print_info	(	FILE *	file,
		hash_table_t *	table
	)

Definition at line 331 of file ha0ha.c.

References hash_get_n_cells(), hash_get_nth_cell(), hash_cell_struct::node, NULL, and UT_LIST_GET_LEN.

Referenced by srv_printf_innodb_monitor().

                                     : file where to print */
        hash_table_t*   table)  /* in: hash table */
{
        hash_cell_t*    cell;
        ulint           cells   = 0;
        ulint           n_bufs;
        ulint           i;

        for (i = 0; i < hash_get_n_cells(table); i++) {

                cell = hash_get_nth_cell(table, i);

                if (cell->node) {

                        cells++;
                }
        }

        fprintf(file,
                "Hash table size %lu, used cells %lu",
                (ulong) hash_get_n_cells(table), (ulong) cells);

        if (table->heaps == NULL && table->heap != NULL) {

                /* This calculation is intended for the adaptive hash
                index: how many buffer frames we have reserved? */

                n_bufs = UT_LIST_GET_LEN(table->heap->base) - 1;

                if (table->heap->free_block) {
                        n_bufs++;
                }

                fprintf(file, ", node heap has %lu buffer(s)\n", (ulong) n_bufs);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ha_remove_all_nodes_to_page	(	hash_table_t *	table,
		ulint	fold,
		page_t *	page
	)

Definition at line 241 of file ha0ha.c.

References buf_frame_align(), ha_delete_hash_node(), hash_get_mutex(), hash_table_struct::mutexes, ut_a, and ut_ad.

Referenced by btr_search_drop_page_hash_index().

                                     : hash table */
        ulint           fold,   /* in: fold value */
        page_t*         page)   /* in: buffer page */
{
        ha_node_t*      node;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
#endif /* UNIV_SYNC_DEBUG */
        node = ha_chain_get_first(table, fold);

        while (node) {
                if (buf_frame_align(ha_node_get_data(node)) == page) {

                        /* Remove the hash node */

                        ha_delete_hash_node(table, node);

                        /* Start again from the first node in the chain
                        because the deletion may compact the heap of
                        nodes and move other nodes! */

                        node = ha_chain_get_first(table, fold);
                } else {
                        node = ha_chain_get_next(node);
                }
        }
#ifdef UNIV_DEBUG
        /* Check that all nodes really got deleted */

        node = ha_chain_get_first(table, fold);

        while (node) {
                ut_a(buf_frame_align(ha_node_get_data(node)) != page);

                node = ha_chain_get_next(node);
        }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ha_search_and_update_if_found	(	hash_table_t *	table,
		ulint	fold,
		void *	data,
		void *	new_data
	)

Definition at line 210 of file ha0ha.c.

References hash_table_struct::adaptive, buf_block_align(), ha_node_struct::data, hash_get_mutex(), hash_table_struct::mutexes, buf_block_struct::n_pointers, ut_a, and ut_ad.

Referenced by btr_search_update_hash_node_on_insert().

                                     : hash table */
        ulint           fold,   /* in: folded value of the searched data */
        void*           data,   /* in: pointer to the data */
        void*           new_data)/* in: new pointer to the data */
{
        ha_node_t*      node;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
#endif /* UNIV_SYNC_DEBUG */

        node = ha_search_with_data(table, fold, data);

        if (node) {
                if (table->adaptive) {
                        ut_a(buf_block_align(node->data)->n_pointers > 0);
                        buf_block_align(node->data)->n_pointers--;
                        buf_block_align(new_data)->n_pointers++;
                }

                node->data = new_data;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibool ha_validate	(	hash_table_t *	table,
		ulint	start_index,
		ulint	end_index
	)

Definition at line 287 of file ha0ha.c.

References FALSE, ha_node_struct::fold, hash_calc_hash(), hash_get_n_cells(), hash_get_nth_cell(), ha_node_struct::next, hash_cell_struct::node, ok(), TRUE, ut_a, and ut_print_timestamp().

Referenced by btr_search_validate().

                                              : TRUE if ok */
        hash_table_t*   table,          /* in: hash table */
        ulint           start_index,    /* in: start index */
        ulint           end_index)      /* in: end index */
{
        hash_cell_t*    cell;
        ha_node_t*      node;
        ibool           ok      = TRUE;
        ulint           i;

        ut_a(start_index <= end_index);
        ut_a(start_index < hash_get_n_cells(table));
        ut_a(end_index < hash_get_n_cells(table));

        for (i = start_index; i <= end_index; i++) {

                cell = hash_get_nth_cell(table, i);

                node = cell->node;

                while (node) {
                        if (hash_calc_hash(node->fold, table) != i) {
                                ut_print_timestamp(stderr);
                                fprintf(stderr,
"InnoDB: Error: hash table node fold value %lu does not\n"
"InnoDB: match with the cell number %lu.\n",
                                        (ulong) node->fold, (ulong) i);

                                ok = FALSE;
                        }

                        node = node->next;
                }
        }

        return(ok);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.