← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/heap/hp_hash.c

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/heap/hp_hash.c
16
16
/* The hash functions used for saveing keys */
17
17
 
18
18
#include "heapdef.h"
19
 
 
20
19
#include <mystrings/m_ctype.h>
21
 
#include <drizzled/util/test.h>
22
 
 
23
 
#include <string.h>
 
20
 
 
21
 
24
22
 
25
23
/*
26
24
  Find out how many rows there is in the given range
161
159
 
162
160
  if (old_nextflag && nextflag)
163
161
    my_errno=HA_ERR_RECORD_CHANGED;             /* Didn't find old record */
164
 
  info->current_hash_ptr=0;
 
162
  info->current_hash_ptr=0;  
165
163
  return((info->current_ptr= 0));
166
164
}
167
165
 
195
193
      hashnr     Hash value
196
194
      buffmax    Value such that
197
195
                 2^(n-1) < maxlength <= 2^n = buffmax
198
 
      maxlength
199
 
 
 
196
      maxlength  
 
197
  
200
198
  RETURN
201
199
    Array index, in [0..maxlength)
202
200
*/
233
231
 
234
232
uint32_t hp_hashnr(register HP_KEYDEF *keydef, register const unsigned char *key)
235
233
{
236
 
  /*register*/
 
234
  /*register*/ 
237
235
  uint32_t nr=1, nr2=4;
238
236
  HA_KEYSEG *seg,*endseg;
239
237
 
320
318
      {
321
319
        char_length= my_charpos(cs, pos, pos + char_length,
322
320
                                char_length / cs->mbmaxlen);
323
 
        set_if_smaller(char_length, (uint32_t)seg->length); /* QQ: ok to remove? */
 
321
        set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
324
322
      }
325
323
      cs->coll->hash_sort(cs, pos, char_length, &nr, &nr2);
326
324
    }
413
411
    {
414
412
      for ( ; pos < (unsigned char*) key ; pos++)
415
413
      {
416
 
        nr *=16777619;
 
414
        nr *=16777619; 
417
415
        nr ^=(uint) *pos;
418
416
      }
419
417
    }
457
455
      unsigned char *end= pos+seg->length;
458
456
      for ( ; pos < end ; pos++)
459
457
      {
460
 
        nr *=16777619;
 
458
        nr *=16777619; 
461
459
        nr ^=(uint) *pos;
462
460
      }
463
461
    }
477
475
    rec1                Record to compare
478
476
    rec2                Other record to compare
479
477
    diff_if_only_endspace_difference
480
 
                        Different number of end space is significant
 
478
                        Different number of end space is significant    
481
479
 
482
480
  NOTES
483
481
    diff_if_only_endspace_difference is used to allow us to insert
514
512
      {
515
513
        uint32_t char_length= seg->length / cs->mbmaxlen;
516
514
        char_length1= my_charpos(cs, pos1, pos1 + seg->length, char_length);
517
 
        set_if_smaller(char_length1, (uint32_t)seg->length);
 
515
        set_if_smaller(char_length1, seg->length);
518
516
        char_length2= my_charpos(cs, pos2, pos2 + seg->length, char_length);
519
 
        set_if_smaller(char_length2, (uint32_t)seg->length);
 
517
        set_if_smaller(char_length2, seg->length);
520
518
      }
521
519
      else
522
520
      {
606
604
      {
607
605
        uint32_t char_length= seg->length / cs->mbmaxlen;
608
606
        char_length_key= my_charpos(cs, key, key + seg->length, char_length);
609
 
        set_if_smaller(char_length_key, (uint32_t)seg->length);
 
607
        set_if_smaller(char_length_key, seg->length);
610
608
        char_length_rec= my_charpos(cs, pos, pos + seg->length, char_length);
611
 
        set_if_smaller(char_length_rec, (uint32_t)seg->length);
 
609
        set_if_smaller(char_length_rec, seg->length);
612
610
      }
613
611
      else
614
612
      {
615
613
        char_length_key= seg->length;
616
614
        char_length_rec= seg->length;
617
615
      }
618
 
 
 
616
      
619
617
      if (seg->charset->coll->strnncollsp(seg->charset,
620
618
                                          (unsigned char*) pos, char_length_rec,
621
619
                                          (unsigned char*) key, char_length_key, 0))
635
633
      if (cs->mbmaxlen > 1)
636
634
      {
637
635
        uint32_t char_length1, char_length2;
638
 
        char_length1= char_length2= seg->length / cs->mbmaxlen;
 
636
        char_length1= char_length2= seg->length / cs->mbmaxlen; 
639
637
        char_length1= my_charpos(cs, key, key + char_length_key, char_length1);
640
638
        set_if_smaller(char_length_key, char_length1);
641
639
        char_length2= my_charpos(cs, pos, pos + char_length_rec, char_length2);
674
672
    {
675
673
      char_length= my_charpos(cs, pos, pos + seg->length,
676
674
                              char_length / cs->mbmaxlen);
677
 
      set_if_smaller(char_length, (uint32_t)seg->length); /* QQ: ok to remove? */
 
675
      set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
678
676
    }
679
677
    if (seg->type == HA_KEYTYPE_VARTEXT1)
680
678
      char_length+= seg->bit_start;             /* Copy also length */
691
689
  } while(0)
692
690
 
693
691
 
694
 
uint32_t hp_rb_make_key(HP_KEYDEF *keydef, unsigned char *key,
 
692
uint32_t hp_rb_make_key(HP_KEYDEF *keydef, unsigned char *key, 
695
693
                    const unsigned char *rec, unsigned char *recpos)
696
694
{
697
695
  unsigned char *start_key= key;
709
707
    {
710
708
      uint32_t length= seg->length;
711
709
      unsigned char *pos= (unsigned char*) rec + seg->start;
712
 
 
 
710
      
713
711
#ifdef HAVE_ISNAN
714
712
      if (seg->type == HA_KEYTYPE_FLOAT)
715
713
      {
765
763
    char_length= seg->length;
766
764
    if (seg->charset->mbmaxlen > 1)
767
765
    {
768
 
      char_length= my_charpos(seg->charset,
 
766
      char_length= my_charpos(seg->charset, 
769
767
                              rec + seg->start, rec + seg->start + char_length,
770
768
                              char_length / seg->charset->mbmaxlen);
771
 
      set_if_smaller(char_length, (uint32_t)seg->length); /* QQ: ok to remove? */
 
769
      set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
772
770
      if (char_length < seg->length)
773
771
        seg->charset->cset->fill(seg->charset, (char*) key + char_length,
774
772
                                 seg->length - char_length, ' ');
777
775
    key+= seg->length;
778
776
  }
779
777
  memcpy(key, &recpos, sizeof(unsigned char*));
780
 
  return (uint32_t) (key - start_key);
 
778
  return (uint) (key - start_key);
781
779
}
782
780
 
783
781
 
801
799
    {
802
800
      uint32_t length= seg->length;
803
801
      unsigned char *pos= (unsigned char*) old + length;
804
 
 
 
802
      
805
803
      while (length--)
806
804
      {
807
805
        *key++= *--pos;
829
827
    {
830
828
      char_length= my_charpos(seg->charset, old, old+char_length,
831
829
                              char_length / seg->charset->mbmaxlen);
832
 
      set_if_smaller(char_length, (uint32_t)seg->length); /* QQ: ok to remove? */
 
830
      set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
833
831
      if (char_length < seg->length)
834
 
        seg->charset->cset->fill(seg->charset, (char*) key + char_length,
 
832
        seg->charset->cset->fill(seg->charset, (char*) key + char_length, 
835
833
                                 seg->length - char_length, ' ');
836
834
    }
837
835
    memcpy(key, old, (size_t) char_length);
841
839
}
842
840
 
843
841
 
844
 
uint32_t hp_rb_key_length(HP_KEYDEF *keydef, const unsigned char *not_used)
 
842
uint32_t hp_rb_key_length(HP_KEYDEF *keydef, 
 
843
                      const unsigned char *key __attribute__((unused)))
845
844
{
846
 
  (void)not_used;
847
845
  return keydef->length;
848
846
}
849
847
 
852
850
{
853
851
  const unsigned char *start_key= key;
854
852
  HA_KEYSEG *seg, *endseg;
855
 
 
 
853
  
856
854
  for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
857
855
  {
858
856
    if (seg->null_bit && !*key++)
861
859
  }
862
860
  return (uint) (key - start_key);
863
861
}
864
 
 
 
862
                  
865
863
 
866
864
uint32_t hp_rb_var_key_length(HP_KEYDEF *keydef, const unsigned char *key)
867
865
{
868
866
  const unsigned char *start_key= key;
869
867
  HA_KEYSEG *seg, *endseg;
870
 
 
 
868
  
871
869
  for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
872
870
  {
873
871
    uint32_t length= seg->length;