sl@0: /*
sl@0: ** 2001 September 22
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This is the implementation of generic hash-tables
sl@0: ** used in SQLite.
sl@0: **
sl@0: ** $Id: hash.c,v 1.31 2008/10/10 17:41:29 drh Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #include <assert.h>
sl@0: 
sl@0: /* Turn bulk memory into a hash table object by initializing the
sl@0: ** fields of the Hash structure.
sl@0: **
sl@0: ** "pNew" is a pointer to the hash table that is to be initialized.
sl@0: ** "copyKey" is true if the hash table should make its own private
sl@0: ** copy of keys and false if it should just use the supplied pointer.
sl@0: */
sl@0: void sqlite3HashInit(Hash *pNew, int copyKey){
sl@0:   assert( pNew!=0 );
sl@0:   pNew->copyKey = copyKey!=0;
sl@0:   pNew->first = 0;
sl@0:   pNew->count = 0;
sl@0:   pNew->htsize = 0;
sl@0:   pNew->ht = 0;
sl@0: }
sl@0: 
sl@0: /* Remove all entries from a hash table.  Reclaim all memory.
sl@0: ** Call this routine to delete a hash table or to reset a hash table
sl@0: ** to the empty state.
sl@0: */
sl@0: void sqlite3HashClear(Hash *pH){
sl@0:   HashElem *elem;         /* For looping over all elements of the table */
sl@0: 
sl@0:   assert( pH!=0 );
sl@0:   elem = pH->first;
sl@0:   pH->first = 0;
sl@0:   sqlite3_free(pH->ht);
sl@0:   pH->ht = 0;
sl@0:   pH->htsize = 0;
sl@0:   while( elem ){
sl@0:     HashElem *next_elem = elem->next;
sl@0:     if( pH->copyKey && elem->pKey ){
sl@0:       sqlite3_free(elem->pKey);
sl@0:     }
sl@0:     sqlite3_free(elem);
sl@0:     elem = next_elem;
sl@0:   }
sl@0:   pH->count = 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Hash and comparison functions when the mode is SQLITE_HASH_STRING
sl@0: */
sl@0: static int strHash(const void *pKey, int nKey){
sl@0:   const char *z = (const char *)pKey;
sl@0:   int h = 0;
sl@0:   if( nKey<=0 ) nKey = strlen(z);
sl@0:   while( nKey > 0  ){
sl@0:     h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++];
sl@0:     nKey--;
sl@0:   }
sl@0:   return h & 0x7fffffff;
sl@0: }
sl@0: static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){
sl@0:   if( n1!=n2 ) return 1;
sl@0:   return sqlite3StrNICmp((const char*)pKey1,(const char*)pKey2,n1);
sl@0: }
sl@0: 
sl@0: 
sl@0: /* Link an element into the hash table
sl@0: */
sl@0: static void insertElement(
sl@0:   Hash *pH,              /* The complete hash table */
sl@0:   struct _ht *pEntry,    /* The entry into which pNew is inserted */
sl@0:   HashElem *pNew         /* The element to be inserted */
sl@0: ){
sl@0:   HashElem *pHead;       /* First element already in pEntry */
sl@0:   pHead = pEntry->chain;
sl@0:   if( pHead ){
sl@0:     pNew->next = pHead;
sl@0:     pNew->prev = pHead->prev;
sl@0:     if( pHead->prev ){ pHead->prev->next = pNew; }
sl@0:     else             { pH->first = pNew; }
sl@0:     pHead->prev = pNew;
sl@0:   }else{
sl@0:     pNew->next = pH->first;
sl@0:     if( pH->first ){ pH->first->prev = pNew; }
sl@0:     pNew->prev = 0;
sl@0:     pH->first = pNew;
sl@0:   }
sl@0:   pEntry->count++;
sl@0:   pEntry->chain = pNew;
sl@0: }
sl@0: 
sl@0: 
sl@0: /* Resize the hash table so that it cantains "new_size" buckets.
sl@0: ** "new_size" must be a power of 2.  The hash table might fail 
sl@0: ** to resize if sqlite3_malloc() fails.
sl@0: */
sl@0: static void rehash(Hash *pH, int new_size){
sl@0:   struct _ht *new_ht;            /* The new hash table */
sl@0:   HashElem *elem, *next_elem;    /* For looping over existing elements */
sl@0: 
sl@0: #ifdef SQLITE_MALLOC_SOFT_LIMIT
sl@0:   if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
sl@0:     new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
sl@0:   }
sl@0:   if( new_size==pH->htsize ) return;
sl@0: #endif
sl@0: 
sl@0:   /* There is a call to sqlite3_malloc() inside rehash(). If there is
sl@0:   ** already an allocation at pH->ht, then if this malloc() fails it
sl@0:   ** is benign (since failing to resize a hash table is a performance
sl@0:   ** hit only, not a fatal error).
sl@0:   */
sl@0:   if( pH->htsize>0 ) sqlite3BeginBenignMalloc();
sl@0:   new_ht = (struct _ht *)sqlite3MallocZero( new_size*sizeof(struct _ht) );
sl@0:   if( pH->htsize>0 ) sqlite3EndBenignMalloc();
sl@0: 
sl@0:   if( new_ht==0 ) return;
sl@0:   sqlite3_free(pH->ht);
sl@0:   pH->ht = new_ht;
sl@0:   pH->htsize = new_size;
sl@0:   for(elem=pH->first, pH->first=0; elem; elem = next_elem){
sl@0:     int h = strHash(elem->pKey, elem->nKey) & (new_size-1);
sl@0:     next_elem = elem->next;
sl@0:     insertElement(pH, &new_ht[h], elem);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /* This function (for internal use only) locates an element in an
sl@0: ** hash table that matches the given key.  The hash for this key has
sl@0: ** already been computed and is passed as the 4th parameter.
sl@0: */
sl@0: static HashElem *findElementGivenHash(
sl@0:   const Hash *pH,     /* The pH to be searched */
sl@0:   const void *pKey,   /* The key we are searching for */
sl@0:   int nKey,
sl@0:   int h               /* The hash for this key. */
sl@0: ){
sl@0:   HashElem *elem;                /* Used to loop thru the element list */
sl@0:   int count;                     /* Number of elements left to test */
sl@0: 
sl@0:   if( pH->ht ){
sl@0:     struct _ht *pEntry = &pH->ht[h];
sl@0:     elem = pEntry->chain;
sl@0:     count = pEntry->count;
sl@0:     while( count-- && elem ){
sl@0:       if( strCompare(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
sl@0:         return elem;
sl@0:       }
sl@0:       elem = elem->next;
sl@0:     }
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /* Remove a single entry from the hash table given a pointer to that
sl@0: ** element and a hash on the element's key.
sl@0: */
sl@0: static void removeElementGivenHash(
sl@0:   Hash *pH,         /* The pH containing "elem" */
sl@0:   HashElem* elem,   /* The element to be removed from the pH */
sl@0:   int h             /* Hash value for the element */
sl@0: ){
sl@0:   struct _ht *pEntry;
sl@0:   if( elem->prev ){
sl@0:     elem->prev->next = elem->next; 
sl@0:   }else{
sl@0:     pH->first = elem->next;
sl@0:   }
sl@0:   if( elem->next ){
sl@0:     elem->next->prev = elem->prev;
sl@0:   }
sl@0:   pEntry = &pH->ht[h];
sl@0:   if( pEntry->chain==elem ){
sl@0:     pEntry->chain = elem->next;
sl@0:   }
sl@0:   pEntry->count--;
sl@0:   if( pEntry->count<=0 ){
sl@0:     pEntry->chain = 0;
sl@0:   }
sl@0:   if( pH->copyKey ){
sl@0:     sqlite3_free(elem->pKey);
sl@0:   }
sl@0:   sqlite3_free( elem );
sl@0:   pH->count--;
sl@0:   if( pH->count<=0 ){
sl@0:     assert( pH->first==0 );
sl@0:     assert( pH->count==0 );
sl@0:     sqlite3HashClear(pH);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /* Attempt to locate an element of the hash table pH with a key
sl@0: ** that matches pKey,nKey.  Return a pointer to the corresponding 
sl@0: ** HashElem structure for this element if it is found, or NULL
sl@0: ** otherwise.
sl@0: */
sl@0: HashElem *sqlite3HashFindElem(const Hash *pH, const void *pKey, int nKey){
sl@0:   int h;             /* A hash on key */
sl@0:   HashElem *elem;    /* The element that matches key */
sl@0: 
sl@0:   if( pH==0 || pH->ht==0 ) return 0;
sl@0:   h = strHash(pKey,nKey);
sl@0:   elem = findElementGivenHash(pH,pKey,nKey, h % pH->htsize);
sl@0:   return elem;
sl@0: }
sl@0: 
sl@0: /* Attempt to locate an element of the hash table pH with a key
sl@0: ** that matches pKey,nKey.  Return the data for this element if it is
sl@0: ** found, or NULL if there is no match.
sl@0: */
sl@0: void *sqlite3HashFind(const Hash *pH, const void *pKey, int nKey){
sl@0:   HashElem *elem;    /* The element that matches key */
sl@0:   elem = sqlite3HashFindElem(pH, pKey, nKey);
sl@0:   return elem ? elem->data : 0;
sl@0: }
sl@0: 
sl@0: /* Insert an element into the hash table pH.  The key is pKey,nKey
sl@0: ** and the data is "data".
sl@0: **
sl@0: ** If no element exists with a matching key, then a new
sl@0: ** element is created.  A copy of the key is made if the copyKey
sl@0: ** flag is set.  NULL is returned.
sl@0: **
sl@0: ** If another element already exists with the same key, then the
sl@0: ** new data replaces the old data and the old data is returned.
sl@0: ** The key is not copied in this instance.  If a malloc fails, then
sl@0: ** the new data is returned and the hash table is unchanged.
sl@0: **
sl@0: ** If the "data" parameter to this function is NULL, then the
sl@0: ** element corresponding to "key" is removed from the hash table.
sl@0: */
sl@0: void *sqlite3HashInsert(Hash *pH, const void *pKey, int nKey, void *data){
sl@0:   int hraw;             /* Raw hash value of the key */
sl@0:   int h;                /* the hash of the key modulo hash table size */
sl@0:   HashElem *elem;       /* Used to loop thru the element list */
sl@0:   HashElem *new_elem;   /* New element added to the pH */
sl@0: 
sl@0:   assert( pH!=0 );
sl@0:   hraw = strHash(pKey, nKey);
sl@0:   if( pH->htsize ){
sl@0:     h = hraw % pH->htsize;
sl@0:     elem = findElementGivenHash(pH,pKey,nKey,h);
sl@0:     if( elem ){
sl@0:       void *old_data = elem->data;
sl@0:       if( data==0 ){
sl@0:         removeElementGivenHash(pH,elem,h);
sl@0:       }else{
sl@0:         elem->data = data;
sl@0:         if( !pH->copyKey ){
sl@0:           elem->pKey = (void *)pKey;
sl@0:         }
sl@0:         assert(nKey==elem->nKey);
sl@0:       }
sl@0:       return old_data;
sl@0:     }
sl@0:   }
sl@0:   if( data==0 ) return 0;
sl@0:   new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) );
sl@0:   if( new_elem==0 ) return data;
sl@0:   if( pH->copyKey && pKey!=0 ){
sl@0:     new_elem->pKey = sqlite3Malloc( nKey );
sl@0:     if( new_elem->pKey==0 ){
sl@0:       sqlite3_free(new_elem);
sl@0:       return data;
sl@0:     }
sl@0:     memcpy((void*)new_elem->pKey, pKey, nKey);
sl@0:   }else{
sl@0:     new_elem->pKey = (void*)pKey;
sl@0:   }
sl@0:   new_elem->nKey = nKey;
sl@0:   pH->count++;
sl@0:   if( pH->htsize==0 ){
sl@0:     rehash(pH, 128/sizeof(pH->ht[0]));
sl@0:     if( pH->htsize==0 ){
sl@0:       pH->count = 0;
sl@0:       if( pH->copyKey ){
sl@0:         sqlite3_free(new_elem->pKey);
sl@0:       }
sl@0:       sqlite3_free(new_elem);
sl@0:       return data;
sl@0:     }
sl@0:   }
sl@0:   if( pH->count > pH->htsize ){
sl@0:     rehash(pH,pH->htsize*2);
sl@0:   }
sl@0:   assert( pH->htsize>0 );
sl@0:   h = hraw % pH->htsize;
sl@0:   insertElement(pH, &pH->ht[h], new_elem);
sl@0:   new_elem->data = data;
sl@0:   return 0;
sl@0: }