hash.c 16.8 KB
Newer Older
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1 2 3 4
/* Copyright (C) 2000 MySQL AB

   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
5
   the Free Software Foundation; version 2 of the License.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6 7

   This program is distributed in the hope that it will be useful,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
9 10 11 12 13 14
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

/* The hash functions used for saveing keys */
/* One of key_length or key_length_offset must be given */
/* Key length of 0 isn't allowed */

#include "mysys_priv.h"
#include <m_string.h>
#include <m_ctype.h>
#include "hash.h"

#define NO_RECORD	((uint) -1)
#define LOWFIND 1
#define LOWUSED 2
#define HIGHFIND 4
#define HIGHUSED 8

31 32 33 34 35
typedef struct st_hash_info {
  uint next;					/* index to next key */
  byte *data;					/* data for current entry */
} HASH_LINK;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
36 37
static uint hash_mask(uint hashnr,uint buffmax,uint maxlength);
static void movelink(HASH_LINK *array,uint pos,uint next_link,uint newlink);
38 39
static int hashcmp(const HASH *hash, HASH_LINK *pos, const byte *key,
                   uint length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
40

41
static uint calc_hash(const HASH *hash, const byte *key, uint length)
42 43
{
  ulong nr1=1, nr2=4;
44
  hash->charset->coll->hash_sort(hash->charset,(uchar*) key,length,&nr1,&nr2);
45 46
  return nr1;
}
47

48
my_bool
monty@hundin.mysql.fi's avatar
merge  
monty@hundin.mysql.fi committed
49
_hash_init(HASH *hash,CHARSET_INFO *charset,
50 51 52
	   uint size,uint key_offset,uint key_length,
	   hash_get_key get_key,
	   void (*free_element)(void*),uint flags CALLER_INFO_PROTO)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
53 54
{
  DBUG_ENTER("hash_init");
55
  DBUG_PRINT("enter",("hash: 0x%lx  size: %d", (long) hash, size));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
56 57

  hash->records=0;
58
  if (my_init_dynamic_array_ci(&hash->array,sizeof(HASH_LINK),size,0))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
59 60
  {
    hash->free=0;				/* Allow call to hash_free */
61
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
62 63 64 65 66 67 68
  }
  hash->key_offset=key_offset;
  hash->key_length=key_length;
  hash->blength=1;
  hash->get_key=get_key;
  hash->free=free_element;
  hash->flags=flags;
69
  hash->charset=charset;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
70 71 72 73
  DBUG_RETURN(0);
}


74 75 76 77 78 79 80 81 82 83 84
/*
  Call hash->free on all elements in hash.

  SYNOPSIS
    hash_free_elements()
    hash   hash table

  NOTES:
    Sets records to 0
*/

85
static inline void hash_free_elements(HASH *hash)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
86 87 88 89
{
  if (hash->free)
  {
    HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
90 91 92
    HASH_LINK *end= data + hash->records;
    while (data < end)
      (*hash->free)((data++)->data);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
93 94
  }
  hash->records=0;
95 96 97 98 99 100 101 102 103 104
}


/*
  Free memory used by hash.

  SYNOPSIS
    hash_free()
    hash   the hash to delete elements of

105
  NOTES: Hash can't be reused without calling hash_init again.
106 107 108 109 110
*/

void hash_free(HASH *hash)
{
  DBUG_ENTER("hash_free");
111
  DBUG_PRINT("enter",("hash: 0x%lxd", (long) hash));
112 113 114 115

  hash_free_elements(hash);
  hash->free= 0;
  delete_dynamic(&hash->array);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
116 117 118
  DBUG_VOID_RETURN;
}

119 120 121 122 123

/*
  Delete all elements from the hash (the hash itself is to be reused).

  SYNOPSIS
124
    my_hash_reset()
125
    hash   the hash to delete elements of
126 127
*/

128
void my_hash_reset(HASH *hash)
129
{
130
  DBUG_ENTER("my_hash_reset");
131
  DBUG_PRINT("enter",("hash: 0x%lxd", (long) hash));
132 133

  hash_free_elements(hash);
134
  reset_dynamic(&hash->array);
135
  /* Set row pointers so that the hash can be reused at once */
136 137 138 139
  hash->blength= 1;
  DBUG_VOID_RETURN;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
140 141
	/* some helper functions */

142 143 144 145 146
/*
  This function is char* instead of byte* as HPUX11 compiler can't
  handle inline functions that are not defined as native types
*/

147
static inline char*
148 149
hash_key(const HASH *hash, const byte *record, uint *length,
         my_bool first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
{
  if (hash->get_key)
    return (*hash->get_key)(record,length,first);
  *length=hash->key_length;
  return (byte*) record+hash->key_offset;
}

	/* Calculate pos according to keys */

static uint hash_mask(uint hashnr,uint buffmax,uint maxlength)
{
  if ((hashnr & (buffmax-1)) < maxlength) return (hashnr & (buffmax-1));
  return (hashnr & ((buffmax >> 1) -1));
}

165 166
static uint hash_rec_mask(const HASH *hash, HASH_LINK *pos,
                          uint buffmax, uint maxlength)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
167 168
{
  uint length;
169
  byte *key= (byte*) hash_key(hash,pos->data,&length,0);
170
  return hash_mask(calc_hash(hash,key,length),buffmax,maxlength);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
171 172
}

173

bk@work.mysql.com's avatar
bk@work.mysql.com committed
174

lenz@mysql.com's avatar
lenz@mysql.com committed
175
/* for compilers which can not handle inline */
176
static
177
#if !defined(__USLC__) && !defined(__sgi)
178 179
inline
#endif
180
unsigned int rec_hashnr(HASH *hash,const byte *record)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
181 182
{
  uint length;
183
  byte *key= (byte*) hash_key(hash,record,&length,0);
184
  return calc_hash(hash,key,length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
185 186 187
}


188 189 190 191 192 193 194 195 196 197 198 199
gptr hash_search(const HASH *hash, const byte *key, uint length)
{
  HASH_SEARCH_STATE state;
  return hash_first(hash, key, length, &state);
}

/*
  Search after a record based on a key

  NOTE
   Assigns the number of the found record to HASH_SEARCH_STATE state
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
200

201 202
gptr hash_first(const HASH *hash, const byte *key, uint length,
                HASH_SEARCH_STATE *current_record)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
203 204 205
{
  HASH_LINK *pos;
  uint flag,idx;
206
  DBUG_ENTER("hash_first");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
207 208 209 210

  flag=1;
  if (hash->records)
  {
211
    idx=hash_mask(calc_hash(hash,key,length ? length : hash->key_length),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
212 213 214 215 216 217 218
		    hash->blength,hash->records);
    do
    {
      pos= dynamic_element(&hash->array,idx,HASH_LINK*);
      if (!hashcmp(hash,pos,key,length))
      {
	DBUG_PRINT("exit",("found key at %d",idx));
219
	*current_record= idx;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
220 221 222 223 224 225 226 227 228 229 230
	DBUG_RETURN (pos->data);
      }
      if (flag)
      {
	flag=0;					/* Reset flag */
	if (hash_rec_mask(hash,pos,hash->blength,hash->records) != idx)
	  break;				/* Wrong link */
      }
    }
    while ((idx=pos->next) != NO_RECORD);
  }
231
  *current_record= NO_RECORD;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
232 233 234 235 236 237
  DBUG_RETURN(0);
}

	/* Get next record with identical key */
	/* Can only be called if previous calls was hash_search */

238 239
gptr hash_next(const HASH *hash, const byte *key, uint length,
               HASH_SEARCH_STATE *current_record)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
240 241 242 243
{
  HASH_LINK *pos;
  uint idx;

244
  if (*current_record != NO_RECORD)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
245 246
  {
    HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
247
    for (idx=data[*current_record].next; idx != NO_RECORD ; idx=pos->next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
248 249 250 251
    {
      pos=data+idx;
      if (!hashcmp(hash,pos,key,length))
      {
252
	*current_record= idx;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
253 254 255
	return pos->data;
      }
    }
256
    *current_record= NO_RECORD;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
  }
  return 0;
}


	/* Change link from pos to new_link */

static void movelink(HASH_LINK *array,uint find,uint next_link,uint newlink)
{
  HASH_LINK *old_link;
  do
  {
    old_link=array+next_link;
  }
  while ((next_link=old_link->next) != find);
  old_link->next= newlink;
  return;
}

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
/*
  Compare a key in a record to a whole key. Return 0 if identical

  SYNOPSIS
    hashcmp()
    hash   hash table
    pos    position of hash record to use in comparison
    key    key for comparison
    length length of key

  NOTES:
    If length is 0, comparison is done using the length of the
    record being compared against.

  RETURN
    = 0  key of record == key
292
    != 0 key of record != key
293
 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
294

295 296
static int hashcmp(const HASH *hash, HASH_LINK *pos, const byte *key,
                   uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
297 298
{
  uint rec_keylength;
299
  byte *rec_key= (byte*) hash_key(hash,pos->data,&rec_keylength,1);
300 301
  return ((length && length != rec_keylength) ||
	  my_strnncoll(hash->charset, (uchar*) rec_key, rec_keylength,
302
		       (uchar*) key, rec_keylength));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
303 304 305 306 307
}


	/* Write a hash-key to the hash-index */

hf@deer.(none)'s avatar
SCRUM  
hf@deer.(none) committed
308
my_bool my_hash_insert(HASH *info,const byte *record)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
{
  int flag;
  uint halfbuff,hash_nr,first_index,idx;
  byte *ptr_to_rec,*ptr_to_rec2;
  HASH_LINK *data,*empty,*gpos,*gpos2,*pos;

  LINT_INIT(gpos); LINT_INIT(gpos2);
  LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2);

  flag=0;
  if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array)))
    return(TRUE);				/* No more memory */

  data=dynamic_element(&info->array,0,HASH_LINK*);
  halfbuff= info->blength >> 1;

  idx=first_index=info->records-halfbuff;
  if (idx != info->records)				/* If some records */
  {
    do
    {
      pos=data+idx;
      hash_nr=rec_hashnr(info,pos->data);
      if (flag == 0)				/* First loop; Check if ok */
	if (hash_mask(hash_nr,info->blength,info->records) != first_index)
	  break;
      if (!(hash_nr & halfbuff))
      {						/* Key will not move */
	if (!(flag & LOWFIND))
	{
	  if (flag & HIGHFIND)
	  {
	    flag=LOWFIND | HIGHFIND;
	    /* key shall be moved to the current empty position */
	    gpos=empty;
	    ptr_to_rec=pos->data;
	    empty=pos;				/* This place is now free */
	  }
	  else
	  {
	    flag=LOWFIND | LOWUSED;		/* key isn't changed */
	    gpos=pos;
	    ptr_to_rec=pos->data;
	  }
	}
	else
	{
	  if (!(flag & LOWUSED))
	  {
	    /* Change link of previous LOW-key */
	    gpos->data=ptr_to_rec;
	    gpos->next=(uint) (pos-data);
	    flag= (flag & HIGHFIND) | (LOWFIND | LOWUSED);
	  }
	  gpos=pos;
	  ptr_to_rec=pos->data;
	}
      }
      else
      {						/* key will be moved */
	if (!(flag & HIGHFIND))
	{
	  flag= (flag & LOWFIND) | HIGHFIND;
	  /* key shall be moved to the last (empty) position */
	  gpos2 = empty; empty=pos;
	  ptr_to_rec2=pos->data;
	}
	else
	{
	  if (!(flag & HIGHUSED))
	  {
	    /* Change link of previous hash-key and save */
	    gpos2->data=ptr_to_rec2;
	    gpos2->next=(uint) (pos-data);
	    flag= (flag & LOWFIND) | (HIGHFIND | HIGHUSED);
	  }
	  gpos2=pos;
	  ptr_to_rec2=pos->data;
	}
      }
    }
    while ((idx=pos->next) != NO_RECORD);

    if ((flag & (LOWFIND | LOWUSED)) == LOWFIND)
    {
      gpos->data=ptr_to_rec;
      gpos->next=NO_RECORD;
    }
    if ((flag & (HIGHFIND | HIGHUSED)) == HIGHFIND)
    {
      gpos2->data=ptr_to_rec2;
      gpos2->next=NO_RECORD;
    }
  }
  /* Check if we are at the empty position */

  idx=hash_mask(rec_hashnr(info,record),info->blength,info->records+1);
  pos=data+idx;
  if (pos == empty)
  {
    pos->data=(byte*) record;
    pos->next=NO_RECORD;
  }
  else
  {
    /* Check if more records in same hash-nr family */
    empty[0]=pos[0];
    gpos=data+hash_rec_mask(info,pos,info->blength,info->records+1);
    if (pos == gpos)
    {
      pos->data=(byte*) record;
      pos->next=(uint) (empty - data);
    }
    else
    {
      pos->data=(byte*) record;
      pos->next=NO_RECORD;
      movelink(data,(uint) (pos-data),(uint) (gpos-data),(uint) (empty-data));
    }
  }
  if (++info->records == info->blength)
    info->blength+= info->blength;
  return(0);
}


/******************************************************************************
** Remove one record from hash-table. The record with the same record
** ptr is removed.
** if there is a free-function it's called for record if found
******************************************************************************/

my_bool hash_delete(HASH *hash,byte *record)
{
  uint blength,pos2,pos_hashnr,lastpos_hashnr,idx,empty_index;
  HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
  DBUG_ENTER("hash_delete");
446 447
  if (!hash->records)
    DBUG_RETURN(1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538

  blength=hash->blength;
  data=dynamic_element(&hash->array,0,HASH_LINK*);
  /* Search after record with key */
  pos=data+ hash_mask(rec_hashnr(hash,record),blength,hash->records);
  gpos = 0;

  while (pos->data != record)
  {
    gpos=pos;
    if (pos->next == NO_RECORD)
      DBUG_RETURN(1);			/* Key not found */
    pos=data+pos->next;
  }

  if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
  lastpos=data+hash->records;

  /* Remove link to record */
  empty=pos; empty_index=(uint) (empty-data);
  if (gpos)
    gpos->next=pos->next;		/* unlink current ptr */
  else if (pos->next != NO_RECORD)
  {
    empty=data+(empty_index=pos->next);
    pos->data=empty->data;
    pos->next=empty->next;
  }

  if (empty == lastpos)			/* last key at wrong pos or no next link */
    goto exit;

  /* Move the last key (lastpos) */
  lastpos_hashnr=rec_hashnr(hash,lastpos->data);
  /* pos is where lastpos should be */
  pos=data+hash_mask(lastpos_hashnr,hash->blength,hash->records);
  if (pos == empty)			/* Move to empty position. */
  {
    empty[0]=lastpos[0];
    goto exit;
  }
  pos_hashnr=rec_hashnr(hash,pos->data);
  /* pos3 is where the pos should be */
  pos3= data+hash_mask(pos_hashnr,hash->blength,hash->records);
  if (pos != pos3)
  {					/* pos is on wrong posit */
    empty[0]=pos[0];			/* Save it here */
    pos[0]=lastpos[0];			/* This should be here */
    movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
    goto exit;
  }
  pos2= hash_mask(lastpos_hashnr,blength,hash->records+1);
  if (pos2 == hash_mask(pos_hashnr,blength,hash->records+1))
  {					/* Identical key-positions */
    if (pos2 != hash->records)
    {
      empty[0]=lastpos[0];
      movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
      goto exit;
    }
    idx= (uint) (pos-data);		/* Link pos->next after lastpos */
  }
  else idx= NO_RECORD;		/* Different positions merge */

  empty[0]=lastpos[0];
  movelink(data,idx,empty_index,pos->next);
  pos->next=empty_index;

exit:
  VOID(pop_dynamic(&hash->array));
  if (hash->free)
    (*hash->free)((byte*) record);
  DBUG_RETURN(0);
}

	/*
	  Update keys when record has changed.
	  This is much more efficent than using a delete & insert.
	  */

my_bool hash_update(HASH *hash,byte *record,byte *old_key,uint old_key_length)
{
  uint idx,new_index,new_pos_index,blength,records,empty;
  HASH_LINK org_link,*data,*previous,*pos;
  DBUG_ENTER("hash_update");

  data=dynamic_element(&hash->array,0,HASH_LINK*);
  blength=hash->blength; records=hash->records;

  /* Search after record with key */

539
  idx=hash_mask(calc_hash(hash, old_key,(old_key_length ?
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
540 541
					      old_key_length :
					      hash->key_length)),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
		  blength,records);
  new_index=hash_mask(rec_hashnr(hash,record),blength,records);
  if (idx == new_index)
    DBUG_RETURN(0);			/* Nothing to do (No record check) */
  previous=0;
  for (;;)
  {

    if ((pos= data+idx)->data == record)
      break;
    previous=pos;
    if ((idx=pos->next) == NO_RECORD)
      DBUG_RETURN(1);			/* Not found in links */
  }
  org_link= *pos;
  empty=idx;

  /* Relink record from current chain */

  if (!previous)
  {
    if (pos->next != NO_RECORD)
    {
      empty=pos->next;
      *pos= data[pos->next];
    }
  }
  else
    previous->next=pos->next;		/* unlink pos */

  /* Move data to correct position */
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
  if (new_index == empty)
  {
    /*
      At this point record is unlinked from the old chain, thus it holds
      random position. By the chance this position is equal to position
      for the first element in the new chain. That means updated record
      is the only record in the new chain.
    */
    if (empty != idx)
    {
      /*
        Record was moved while unlinking it from the old chain.
        Copy data to a new position.
      */
      data[empty]= org_link;
    }
    data[empty].next= NO_RECORD;
    DBUG_RETURN(0);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
  pos=data+new_index;
  new_pos_index=hash_rec_mask(hash,pos,blength,records);
  if (new_index != new_pos_index)
  {					/* Other record in wrong position */
    data[empty] = *pos;
    movelink(data,new_index,new_pos_index,empty);
    org_link.next=NO_RECORD;
    data[new_index]= org_link;
  }
  else
  {					/* Link in chain at right position */
    org_link.next=data[new_index].next;
    data[empty]=org_link;
    data[new_index].next=empty;
  }
  DBUG_RETURN(0);
}


byte *hash_element(HASH *hash,uint idx)
{
  if (idx < hash->records)
    return dynamic_element(&hash->array,idx,HASH_LINK*)->data;
  return 0;
}


monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
619 620 621 622 623
/*
  Replace old row with new row.  This should only be used when key
  isn't changed
*/

624
void hash_replace(HASH *hash, HASH_SEARCH_STATE *current_record, byte *new_row)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
625
{
626 627
  if (*current_record != NO_RECORD)            /* Safety */
    dynamic_element(&hash->array, *current_record, HASH_LINK*)->data= new_row;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
628 629 630
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
#ifndef DBUG_OFF

my_bool hash_check(HASH *hash)
{
  int error;
  uint i,rec_link,found,max_links,seek,links,idx;
  uint records,blength;
  HASH_LINK *data,*hash_info;

  records=hash->records; blength=hash->blength;
  data=dynamic_element(&hash->array,0,HASH_LINK*);
  error=0;

  for (i=found=max_links=seek=0 ; i < records ; i++)
  {
    if (hash_rec_mask(hash,data+i,blength,records) == i)
    {
      found++; seek++; links=1;
      for (idx=data[i].next ;
	   idx != NO_RECORD && found < records + 1;
	   idx=hash_info->next)
      {
	if (idx >= records)
	{
	  DBUG_PRINT("error",
		     ("Found pointer outside array to %d from link starting at %d",
		      idx,i));
	  error=1;
	}
	hash_info=data+idx;
	seek+= ++links;
	if ((rec_link=hash_rec_mask(hash,hash_info,blength,records)) != i)
	{
	  DBUG_PRINT("error",
665 666
		     ("Record in wrong link at %d: Start %d  Record: 0x%lx  Record-link %d",
                      idx, i, (long) hash_info->data, rec_link));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
667 668 669 670 671 672 673 674 675 676
	  error=1;
	}
	else
	  found++;
      }
      if (links > max_links) max_links=links;
    }
  }
  if (found != records)
  {
677
    DBUG_PRINT("error",("Found %u of %u records", found, records));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
678 679 680 681
    error=1;
  }
  if (records)
    DBUG_PRINT("info",
682
	       ("records: %u   seeks: %d   max links: %d   hitrate: %.2f",
bk@work.mysql.com's avatar
bk@work.mysql.com committed
683 684 685 686
		records,seek,max_links,(float) seek / (float) records));
  return error;
}
#endif