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

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* The hash functions used for saveing keys */
  14. /* One of key_length or key_length_offset must be given */
  15. /* Key length of 0 isn't allowed */
  16. #include "mysys_priv.h"
  17. #include <m_string.h>
  18. #include <m_ctype.h>
  19. #include "hash.h"
  20. #define NO_RECORD ((uint) -1)
  21. #define LOWFIND 1
  22. #define LOWUSED 2
  23. #define HIGHFIND 4
  24. #define HIGHUSED 8
  25. typedef struct st_hash_info {
  26.   uint next; /* index to next key */
  27.   byte *data; /* data for current entry */
  28. } HASH_LINK;
  29. static uint hash_mask(uint hashnr,uint buffmax,uint maxlength);
  30. static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
  31. static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length);
  32. static uint calc_hash(HASH *hash,const byte *key,uint length)
  33. {
  34.   ulong nr1=1, nr2=4;
  35.   hash->charset->coll->hash_sort(hash->charset,(uchar*) key,length,&nr1,&nr2);
  36.   return nr1;
  37. }
  38. my_bool
  39. _hash_init(HASH *hash,CHARSET_INFO *charset,
  40.    uint size,uint key_offset,uint key_length,
  41.    hash_get_key get_key,
  42.    void (*free_element)(void*),uint flags CALLER_INFO_PROTO)
  43. {
  44.   DBUG_ENTER("hash_init");
  45.   DBUG_PRINT("enter",("hash: 0x%lx  size: %d",hash,size));
  46.   hash->records=0;
  47.   if (my_init_dynamic_array_ci(&hash->array,sizeof(HASH_LINK),size,0))
  48.   {
  49.     hash->free=0; /* Allow call to hash_free */
  50.     DBUG_RETURN(1);
  51.   }
  52.   hash->key_offset=key_offset;
  53.   hash->key_length=key_length;
  54.   hash->blength=1;
  55.   hash->current_record= NO_RECORD; /* For the future */
  56.   hash->get_key=get_key;
  57.   hash->free=free_element;
  58.   hash->flags=flags;
  59.   hash->charset=charset;
  60.   DBUG_RETURN(0);
  61. }
  62. /*
  63.   Call hash->free on all elements in hash.
  64.   SYNOPSIS
  65.     hash_free_elements()
  66.     hash   hash table
  67.   NOTES:
  68.     Sets records to 0
  69. */
  70. static inline void hash_free_elements(HASH *hash)
  71. {
  72.   if (hash->free)
  73.   {
  74.     HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
  75.     HASH_LINK *end= data + hash->records;
  76.     while (data < end)
  77.       (*hash->free)((data++)->data);
  78.   }
  79.   hash->records=0;
  80. }
  81. /*
  82.   Free memory used by hash.
  83.   SYNOPSIS
  84.     hash_free()
  85.     hash   the hash to delete elements of
  86.   NOTES: Hash can't be reused wuthing calling hash_init again.
  87. */
  88. void hash_free(HASH *hash)
  89. {
  90.   DBUG_ENTER("hash_free");
  91.   DBUG_PRINT("enter",("hash: 0x%lxd",hash));
  92.   hash_free_elements(hash);
  93.   hash->free= 0;
  94.   delete_dynamic(&hash->array);
  95.   DBUG_VOID_RETURN;
  96. }
  97. /*
  98.   Delete all elements from the hash (the hash itself is to be reused).
  99.   SYNOPSIS
  100.     my_hash_reset()
  101.     hash   the hash to delete elements of
  102. */
  103. void my_hash_reset(HASH *hash)
  104. {
  105.   DBUG_ENTER("my_hash_reset");
  106.   DBUG_PRINT("enter",("hash: 0x%lxd",hash));
  107.   hash_free_elements(hash);
  108.   reset_dynamic(&hash->array);
  109.   /* Set row pointers so that the hash can be reused at once */
  110.   hash->blength= 1;
  111.   hash->current_record= NO_RECORD;
  112.   DBUG_VOID_RETURN;
  113. }
  114. /* some helper functions */
  115. /*
  116.   This function is char* instead of byte* as HPUX11 compiler can't
  117.   handle inline functions that are not defined as native types
  118. */
  119. static inline char*
  120. hash_key(HASH *hash,const byte *record,uint *length,my_bool first)
  121. {
  122.   if (hash->get_key)
  123.     return (*hash->get_key)(record,length,first);
  124.   *length=hash->key_length;
  125.   return (byte*) record+hash->key_offset;
  126. }
  127. /* Calculate pos according to keys */
  128. static uint hash_mask(uint hashnr,uint buffmax,uint maxlength)
  129. {
  130.   if ((hashnr & (buffmax-1)) < maxlength) return (hashnr & (buffmax-1));
  131.   return (hashnr & ((buffmax >> 1) -1));
  132. }
  133. static uint hash_rec_mask(HASH *hash,HASH_LINK *pos,uint buffmax,
  134.   uint maxlength)
  135. {
  136.   uint length;
  137.   byte *key= (byte*) hash_key(hash,pos->data,&length,0);
  138.   return hash_mask(calc_hash(hash,key,length),buffmax,maxlength);
  139. }
  140. /* for compilers which can not handle inline */
  141. static
  142. #if !defined(__USLC__) && !defined(__sgi)
  143. inline
  144. #endif
  145. unsigned int rec_hashnr(HASH *hash,const byte *record)
  146. {
  147.   uint length;
  148.   byte *key= (byte*) hash_key(hash,record,&length,0);
  149.   return calc_hash(hash,key,length);
  150. }
  151. /* Search after a record based on a key */
  152. /* Sets info->current_ptr to found record */
  153. gptr hash_search(HASH *hash,const byte *key,uint length)
  154. {
  155.   HASH_LINK *pos;
  156.   uint flag,idx;
  157.   DBUG_ENTER("hash_search");
  158.   flag=1;
  159.   if (hash->records)
  160.   {
  161.     idx=hash_mask(calc_hash(hash,key,length ? length : hash->key_length),
  162.     hash->blength,hash->records);
  163.     do
  164.     {
  165.       pos= dynamic_element(&hash->array,idx,HASH_LINK*);
  166.       if (!hashcmp(hash,pos,key,length))
  167.       {
  168. DBUG_PRINT("exit",("found key at %d",idx));
  169. hash->current_record= idx;
  170. DBUG_RETURN (pos->data);
  171.       }
  172.       if (flag)
  173.       {
  174. flag=0; /* Reset flag */
  175. if (hash_rec_mask(hash,pos,hash->blength,hash->records) != idx)
  176.   break; /* Wrong link */
  177.       }
  178.     }
  179.     while ((idx=pos->next) != NO_RECORD);
  180.   }
  181.   hash->current_record= NO_RECORD;
  182.   DBUG_RETURN(0);
  183. }
  184. /* Get next record with identical key */
  185. /* Can only be called if previous calls was hash_search */
  186. gptr hash_next(HASH *hash,const byte *key,uint length)
  187. {
  188.   HASH_LINK *pos;
  189.   uint idx;
  190.   if (hash->current_record != NO_RECORD)
  191.   {
  192.     HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
  193.     for (idx=data[hash->current_record].next; idx != NO_RECORD ; idx=pos->next)
  194.     {
  195.       pos=data+idx;
  196.       if (!hashcmp(hash,pos,key,length))
  197.       {
  198. hash->current_record= idx;
  199. return pos->data;
  200.       }
  201.     }
  202.     hash->current_record=NO_RECORD;
  203.   }
  204.   return 0;
  205. }
  206. /* Change link from pos to new_link */
  207. static void movelink(HASH_LINK *array,uint find,uint next_link,uint newlink)
  208. {
  209.   HASH_LINK *old_link;
  210.   do
  211.   {
  212.     old_link=array+next_link;
  213.   }
  214.   while ((next_link=old_link->next) != find);
  215.   old_link->next= newlink;
  216.   return;
  217. }
  218. /*
  219.   Compare a key in a record to a whole key. Return 0 if identical
  220.   SYNOPSIS
  221.     hashcmp()
  222.     hash   hash table
  223.     pos    position of hash record to use in comparison
  224.     key    key for comparison
  225.     length length of key
  226.   NOTES:
  227.     If length is 0, comparison is done using the length of the
  228.     record being compared against.
  229.   RETURN
  230.     < 0  key of record <  key
  231.     = 0  key of record == key
  232.     > 0  key of record >  key
  233.  */
  234. static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
  235. {
  236.   uint rec_keylength;
  237.   byte *rec_key= (byte*) hash_key(hash,pos->data,&rec_keylength,1);
  238.   return ((length && length != rec_keylength) ||
  239.   my_strnncoll(hash->charset, (uchar*) rec_key, rec_keylength,
  240.        (uchar*) key, rec_keylength));
  241. }
  242. /* Write a hash-key to the hash-index */
  243. my_bool my_hash_insert(HASH *info,const byte *record)
  244. {
  245.   int flag;
  246.   uint halfbuff,hash_nr,first_index,idx;
  247.   byte *ptr_to_rec,*ptr_to_rec2;
  248.   HASH_LINK *data,*empty,*gpos,*gpos2,*pos;
  249.   LINT_INIT(gpos); LINT_INIT(gpos2);
  250.   LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2);
  251.   flag=0;
  252.   if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array)))
  253.     return(TRUE); /* No more memory */
  254.   info->current_record= NO_RECORD;
  255.   data=dynamic_element(&info->array,0,HASH_LINK*);
  256.   halfbuff= info->blength >> 1;
  257.   idx=first_index=info->records-halfbuff;
  258.   if (idx != info->records) /* If some records */
  259.   {
  260.     do
  261.     {
  262.       pos=data+idx;
  263.       hash_nr=rec_hashnr(info,pos->data);
  264.       if (flag == 0) /* First loop; Check if ok */
  265. if (hash_mask(hash_nr,info->blength,info->records) != first_index)
  266.   break;
  267.       if (!(hash_nr & halfbuff))
  268.       { /* Key will not move */
  269. if (!(flag & LOWFIND))
  270. {
  271.   if (flag & HIGHFIND)
  272.   {
  273.     flag=LOWFIND | HIGHFIND;
  274.     /* key shall be moved to the current empty position */
  275.     gpos=empty;
  276.     ptr_to_rec=pos->data;
  277.     empty=pos; /* This place is now free */
  278.   }
  279.   else
  280.   {
  281.     flag=LOWFIND | LOWUSED; /* key isn't changed */
  282.     gpos=pos;
  283.     ptr_to_rec=pos->data;
  284.   }
  285. }
  286. else
  287. {
  288.   if (!(flag & LOWUSED))
  289.   {
  290.     /* Change link of previous LOW-key */
  291.     gpos->data=ptr_to_rec;
  292.     gpos->next=(uint) (pos-data);
  293.     flag= (flag & HIGHFIND) | (LOWFIND | LOWUSED);
  294.   }
  295.   gpos=pos;
  296.   ptr_to_rec=pos->data;
  297. }
  298.       }
  299.       else
  300.       { /* key will be moved */
  301. if (!(flag & HIGHFIND))
  302. {
  303.   flag= (flag & LOWFIND) | HIGHFIND;
  304.   /* key shall be moved to the last (empty) position */
  305.   gpos2 = empty; empty=pos;
  306.   ptr_to_rec2=pos->data;
  307. }
  308. else
  309. {
  310.   if (!(flag & HIGHUSED))
  311.   {
  312.     /* Change link of previous hash-key and save */
  313.     gpos2->data=ptr_to_rec2;
  314.     gpos2->next=(uint) (pos-data);
  315.     flag= (flag & LOWFIND) | (HIGHFIND | HIGHUSED);
  316.   }
  317.   gpos2=pos;
  318.   ptr_to_rec2=pos->data;
  319. }
  320.       }
  321.     }
  322.     while ((idx=pos->next) != NO_RECORD);
  323.     if ((flag & (LOWFIND | LOWUSED)) == LOWFIND)
  324.     {
  325.       gpos->data=ptr_to_rec;
  326.       gpos->next=NO_RECORD;
  327.     }
  328.     if ((flag & (HIGHFIND | HIGHUSED)) == HIGHFIND)
  329.     {
  330.       gpos2->data=ptr_to_rec2;
  331.       gpos2->next=NO_RECORD;
  332.     }
  333.   }
  334.   /* Check if we are at the empty position */
  335.   idx=hash_mask(rec_hashnr(info,record),info->blength,info->records+1);
  336.   pos=data+idx;
  337.   if (pos == empty)
  338.   {
  339.     pos->data=(byte*) record;
  340.     pos->next=NO_RECORD;
  341.   }
  342.   else
  343.   {
  344.     /* Check if more records in same hash-nr family */
  345.     empty[0]=pos[0];
  346.     gpos=data+hash_rec_mask(info,pos,info->blength,info->records+1);
  347.     if (pos == gpos)
  348.     {
  349.       pos->data=(byte*) record;
  350.       pos->next=(uint) (empty - data);
  351.     }
  352.     else
  353.     {
  354.       pos->data=(byte*) record;
  355.       pos->next=NO_RECORD;
  356.       movelink(data,(uint) (pos-data),(uint) (gpos-data),(uint) (empty-data));
  357.     }
  358.   }
  359.   if (++info->records == info->blength)
  360.     info->blength+= info->blength;
  361.   return(0);
  362. }
  363. /******************************************************************************
  364. ** Remove one record from hash-table. The record with the same record
  365. ** ptr is removed.
  366. ** if there is a free-function it's called for record if found
  367. ******************************************************************************/
  368. my_bool hash_delete(HASH *hash,byte *record)
  369. {
  370.   uint blength,pos2,pos_hashnr,lastpos_hashnr,idx,empty_index;
  371.   HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
  372.   DBUG_ENTER("hash_delete");
  373.   if (!hash->records)
  374.     DBUG_RETURN(1);
  375.   blength=hash->blength;
  376.   data=dynamic_element(&hash->array,0,HASH_LINK*);
  377.   /* Search after record with key */
  378.   pos=data+ hash_mask(rec_hashnr(hash,record),blength,hash->records);
  379.   gpos = 0;
  380.   while (pos->data != record)
  381.   {
  382.     gpos=pos;
  383.     if (pos->next == NO_RECORD)
  384.       DBUG_RETURN(1); /* Key not found */
  385.     pos=data+pos->next;
  386.   }
  387.   if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
  388.   hash->current_record= NO_RECORD;
  389.   lastpos=data+hash->records;
  390.   /* Remove link to record */
  391.   empty=pos; empty_index=(uint) (empty-data);
  392.   if (gpos)
  393.     gpos->next=pos->next; /* unlink current ptr */
  394.   else if (pos->next != NO_RECORD)
  395.   {
  396.     empty=data+(empty_index=pos->next);
  397.     pos->data=empty->data;
  398.     pos->next=empty->next;
  399.   }
  400.   if (empty == lastpos) /* last key at wrong pos or no next link */
  401.     goto exit;
  402.   /* Move the last key (lastpos) */
  403.   lastpos_hashnr=rec_hashnr(hash,lastpos->data);
  404.   /* pos is where lastpos should be */
  405.   pos=data+hash_mask(lastpos_hashnr,hash->blength,hash->records);
  406.   if (pos == empty) /* Move to empty position. */
  407.   {
  408.     empty[0]=lastpos[0];
  409.     goto exit;
  410.   }
  411.   pos_hashnr=rec_hashnr(hash,pos->data);
  412.   /* pos3 is where the pos should be */
  413.   pos3= data+hash_mask(pos_hashnr,hash->blength,hash->records);
  414.   if (pos != pos3)
  415.   { /* pos is on wrong posit */
  416.     empty[0]=pos[0]; /* Save it here */
  417.     pos[0]=lastpos[0]; /* This should be here */
  418.     movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
  419.     goto exit;
  420.   }
  421.   pos2= hash_mask(lastpos_hashnr,blength,hash->records+1);
  422.   if (pos2 == hash_mask(pos_hashnr,blength,hash->records+1))
  423.   { /* Identical key-positions */
  424.     if (pos2 != hash->records)
  425.     {
  426.       empty[0]=lastpos[0];
  427.       movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
  428.       goto exit;
  429.     }
  430.     idx= (uint) (pos-data); /* Link pos->next after lastpos */
  431.   }
  432.   else idx= NO_RECORD; /* Different positions merge */
  433.   empty[0]=lastpos[0];
  434.   movelink(data,idx,empty_index,pos->next);
  435.   pos->next=empty_index;
  436. exit:
  437.   VOID(pop_dynamic(&hash->array));
  438.   if (hash->free)
  439.     (*hash->free)((byte*) record);
  440.   DBUG_RETURN(0);
  441. }
  442. /*
  443.   Update keys when record has changed.
  444.   This is much more efficent than using a delete & insert.
  445.   */
  446. my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
  447. {
  448.   uint idx,new_index,new_pos_index,blength,records,empty;
  449.   HASH_LINK org_link,*data,*previous,*pos;
  450.   DBUG_ENTER("hash_update");
  451.   data=dynamic_element(&hash->array,0,HASH_LINK*);
  452.   blength=hash->blength; records=hash->records;
  453.   /* Search after record with key */
  454.   idx=hash_mask(calc_hash(hash, old_key,(old_key_length ?
  455.       old_key_length :
  456.       hash->key_length)),
  457.   blength,records);
  458.   new_index=hash_mask(rec_hashnr(hash,record),blength,records);
  459.   if (idx == new_index)
  460.     DBUG_RETURN(0); /* Nothing to do (No record check) */
  461.   previous=0;
  462.   for (;;)
  463.   {
  464.     if ((pos= data+idx)->data == record)
  465.       break;
  466.     previous=pos;
  467.     if ((idx=pos->next) == NO_RECORD)
  468.       DBUG_RETURN(1); /* Not found in links */
  469.   }
  470.   hash->current_record= NO_RECORD;
  471.   org_link= *pos;
  472.   empty=idx;
  473.   /* Relink record from current chain */
  474.   if (!previous)
  475.   {
  476.     if (pos->next != NO_RECORD)
  477.     {
  478.       empty=pos->next;
  479.       *pos= data[pos->next];
  480.     }
  481.   }
  482.   else
  483.     previous->next=pos->next; /* unlink pos */
  484.   /* Move data to correct position */
  485.   pos=data+new_index;
  486.   new_pos_index=hash_rec_mask(hash,pos,blength,records);
  487.   if (new_index != new_pos_index)
  488.   { /* Other record in wrong position */
  489.     data[empty] = *pos;
  490.     movelink(data,new_index,new_pos_index,empty);
  491.     org_link.next=NO_RECORD;
  492.     data[new_index]= org_link;
  493.   }
  494.   else
  495.   { /* Link in chain at right position */
  496.     org_link.next=data[new_index].next;
  497.     data[empty]=org_link;
  498.     data[new_index].next=empty;
  499.   }
  500.   DBUG_RETURN(0);
  501. }
  502. byte *hash_element(HASH *hash,uint idx)
  503. {
  504.   if (idx < hash->records)
  505.     return dynamic_element(&hash->array,idx,HASH_LINK*)->data;
  506.   return 0;
  507. }
  508. /*
  509.   Replace old row with new row.  This should only be used when key
  510.   isn't changed
  511. */
  512. void hash_replace(HASH *hash, uint idx, byte *new_row)
  513. {
  514.   if (idx != NO_RECORD) /* Safety */
  515.     dynamic_element(&hash->array,idx,HASH_LINK*)->data=new_row;
  516. }
  517. #ifndef DBUG_OFF
  518. my_bool hash_check(HASH *hash)
  519. {
  520.   int error;
  521.   uint i,rec_link,found,max_links,seek,links,idx;
  522.   uint records,blength;
  523.   HASH_LINK *data,*hash_info;
  524.   records=hash->records; blength=hash->blength;
  525.   data=dynamic_element(&hash->array,0,HASH_LINK*);
  526.   error=0;
  527.   for (i=found=max_links=seek=0 ; i < records ; i++)
  528.   {
  529.     if (hash_rec_mask(hash,data+i,blength,records) == i)
  530.     {
  531.       found++; seek++; links=1;
  532.       for (idx=data[i].next ;
  533.    idx != NO_RECORD && found < records + 1;
  534.    idx=hash_info->next)
  535.       {
  536. if (idx >= records)
  537. {
  538.   DBUG_PRINT("error",
  539.      ("Found pointer outside array to %d from link starting at %d",
  540.       idx,i));
  541.   error=1;
  542. }
  543. hash_info=data+idx;
  544. seek+= ++links;
  545. if ((rec_link=hash_rec_mask(hash,hash_info,blength,records)) != i)
  546. {
  547.   DBUG_PRINT("error",
  548.      ("Record in wrong link at %d: Start %d  Record: 0x%lx  Record-link %d", idx,i,hash_info->data,rec_link));
  549.   error=1;
  550. }
  551. else
  552.   found++;
  553.       }
  554.       if (links > max_links) max_links=links;
  555.     }
  556.   }
  557.   if (found != records)
  558.   {
  559.     DBUG_PRINT("error",("Found %ld of %ld records"));
  560.     error=1;
  561.   }
  562.   if (records)
  563.     DBUG_PRINT("info",
  564.        ("records: %ld   seeks: %d   max links: %d   hitrate: %.2f",
  565. records,seek,max_links,(float) seek / (float) records));
  566.   return error;
  567. }
  568. #endif