ha0ha.ic
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:5k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. The hash table with external chains
  3. (c) 1994-1997 Innobase Oy
  4. Created 8/18/1994 Heikki Tuuri
  5. *************************************************************************/
  6. #include "ut0rnd.h"
  7. #include "mem0mem.h"
  8. /***************************************************************
  9. Deletes a hash node. */
  10. void
  11. ha_delete_hash_node(
  12. /*================*/
  13. hash_table_t* table, /* in: hash table */
  14. ha_node_t* del_node); /* in: node to be deleted */
  15. /**********************************************************************
  16. Gets a hash node data. */
  17. UNIV_INLINE
  18. void*
  19. ha_node_get_data(
  20. /*=============*/
  21. /* out: pointer to the data */
  22. ha_node_t* node) /* in: hash chain node */
  23. {
  24. return(node->data);
  25. }
  26. /**********************************************************************
  27. Sets hash node data. */
  28. UNIV_INLINE
  29. void
  30. ha_node_set_data(
  31. /*=============*/
  32. ha_node_t* node, /* in: hash chain node */
  33. void* data) /* in: pointer to the data */
  34. {
  35. node->data = data;
  36. }
  37. /**********************************************************************
  38. Gets the next node in a hash chain. */
  39. UNIV_INLINE
  40. ha_node_t*
  41. ha_chain_get_next(
  42. /*==============*/
  43. /* out: next node, NULL if none */
  44. ha_node_t* node) /* in: hash chain node */
  45. {
  46. return(node->next);
  47. }
  48. /**********************************************************************
  49. Gets the first node in a hash chain. */
  50. UNIV_INLINE
  51. ha_node_t*
  52. ha_chain_get_first(
  53. /*===============*/
  54. /* out: first node, NULL if none */
  55. hash_table_t* table, /* in: hash table */
  56. ulint fold) /* in: fold value determining the chain */
  57. {
  58. return(hash_get_nth_cell(table, hash_calc_hash(fold, table))->node);
  59. }
  60. /*****************************************************************
  61. Looks for an element in a hash table. */
  62. UNIV_INLINE
  63. ha_node_t*
  64. ha_search(
  65. /*======*/
  66. /* out: pointer to the first hash table node
  67. in chain having the fold number, NULL if not
  68. found */
  69. hash_table_t* table, /* in: hash table */
  70. ulint fold) /* in: folded value of the searched data */
  71. {
  72. ha_node_t* node;
  73. #ifdef UNIV_SYNC_DEBUG
  74. ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
  75. #endif /* UNIV_SYNC_DEBUG */
  76. node = ha_chain_get_first(table, fold);
  77. while (node) {
  78. if (node->fold == fold) {
  79. return(node);
  80. }
  81. node = ha_chain_get_next(node);
  82. }
  83. return(NULL);
  84. }
  85. /*****************************************************************
  86. Looks for an element in a hash table. */
  87. UNIV_INLINE
  88. void*
  89. ha_search_and_get_data(
  90. /*===================*/
  91. /* out: pointer to the data of the first hash
  92. table node in chain having the fold number,
  93. NULL if not found */
  94. hash_table_t* table, /* in: hash table */
  95. ulint fold) /* in: folded value of the searched data */
  96. {
  97. ha_node_t* node;
  98. #ifdef UNIV_SYNC_DEBUG
  99. ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
  100. #endif /* UNIV_SYNC_DEBUG */
  101. node = ha_chain_get_first(table, fold);
  102. while (node) {
  103. if (node->fold == fold) {
  104. return(node->data);
  105. }
  106. node = ha_chain_get_next(node);
  107. }
  108. return(NULL);
  109. }
  110. /*************************************************************
  111. Looks for an element when we know the pointer to the data. */
  112. UNIV_INLINE
  113. ha_node_t*
  114. ha_search_with_data(
  115. /*================*/
  116. /* out: pointer to the hash table node, NULL
  117. if not found in the table */
  118. hash_table_t* table, /* in: hash table */
  119. ulint fold, /* in: folded value of the searched data */
  120. void* data) /* in: pointer to the data */
  121. {
  122. ha_node_t* node;
  123. #ifdef UNIV_SYNC_DEBUG
  124. ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
  125. #endif /* UNIV_SYNC_DEBUG */
  126. node = ha_chain_get_first(table, fold);
  127. while (node) {
  128. if (node->data == data) {
  129. return(node);
  130. }
  131. node = ha_chain_get_next(node);
  132. }
  133. return(NULL);
  134. }
  135. /*************************************************************
  136. Looks for an element when we know the pointer to the data, and deletes
  137. it from the hash table, if found. */
  138. UNIV_INLINE
  139. ibool
  140. ha_search_and_delete_if_found(
  141. /*==========================*/
  142. /* out: TRUE if found */
  143. hash_table_t* table, /* in: hash table */
  144. ulint fold, /* in: folded value of the searched data */
  145. void* data) /* in: pointer to the data */
  146. {
  147. ha_node_t* node;
  148. #ifdef UNIV_SYNC_DEBUG
  149. ut_ad(!table->mutexes || mutex_own(hash_get_mutex(table, fold)));
  150. #endif /* UNIV_SYNC_DEBUG */
  151. node = ha_search_with_data(table, fold, data);
  152. if (node) {
  153. ha_delete_hash_node(table, node);
  154. return(TRUE);
  155. }
  156. return(FALSE);
  157. }
  158. /*****************************************************************
  159. Reserves the necessary hash table mutex and inserts an entry into the hash
  160. table. */
  161. UNIV_INLINE
  162. ibool
  163. ha_insert_for_fold_mutex(
  164. /*=====================*/
  165. /* out: TRUE if succeed, FALSE if no more
  166. memory could be allocated */
  167. hash_table_t* table, /* in: hash table */
  168. ulint fold, /* in: folded value of data; if a node with
  169. the same fold value already exists, it is
  170. updated to point to the same data, and no new
  171. node is created! */
  172. void* data) /* in: data, must not be NULL */
  173. {
  174. ibool ret;
  175. hash_mutex_enter(table, fold);
  176. ret = ha_insert_for_fold(table, fold, data);
  177. hash_mutex_exit(table, fold);
  178. return(ret);
  179. }