← 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
95
95
        /* next_flag:  Search=0, next=1, prev =2, same =3 */
96
96
 
97
97
unsigned char *hp_search(HP_INFO *info, HP_KEYDEF *keyinfo, const unsigned char *key,
98
 
                uint nextflag)
 
98
                uint32_t nextflag)
99
99
{
100
100
  register HASH_INFO *pos,*prev_ptr;
101
101
  int flag;
102
 
  uint old_nextflag;
 
102
  uint32_t old_nextflag;
103
103
  HP_SHARE *share=info->s;
104
104
  old_nextflag=nextflag;
105
105
  flag=1;
255
255
    if (seg->type == HA_KEYTYPE_TEXT)
256
256
    {
257
257
       const CHARSET_INFO * const cs= seg->charset;
258
 
       uint length= seg->length;
 
258
       uint32_t length= seg->length;
259
259
       if (cs->mbmaxlen > 1)
260
260
       {
261
 
         uint char_length;
 
261
         uint32_t char_length;
262
262
         char_length= my_charpos(cs, pos, pos + length, length/cs->mbmaxlen);
263
263
         set_if_smaller(length, char_length);
264
264
       }
267
267
    else if (seg->type == HA_KEYTYPE_VARTEXT1)  /* Any VARCHAR segments */
268
268
    {
269
269
       const CHARSET_INFO * const cs= seg->charset;
270
 
       uint pack_length= 2;                     /* Key packing is constant */
271
 
       uint length= uint2korr(pos);
 
270
       uint32_t pack_length= 2;                     /* Key packing is constant */
 
271
       uint32_t length= uint2korr(pos);
272
272
       if (cs->mbmaxlen > 1)
273
273
       {
274
 
         uint char_length;
 
274
         uint32_t char_length;
275
275
         char_length= my_charpos(cs, pos +pack_length,
276
276
                                 pos +pack_length + length,
277
277
                                 seg->length/cs->mbmaxlen);
313
313
    if (seg->type == HA_KEYTYPE_TEXT)
314
314
    {
315
315
      const CHARSET_INFO * const cs= seg->charset;
316
 
      uint char_length= seg->length;
 
316
      uint32_t char_length= seg->length;
317
317
      if (cs->mbmaxlen > 1)
318
318
      {
319
319
        char_length= my_charpos(cs, pos, pos + char_length,
325
325
    else if (seg->type == HA_KEYTYPE_VARTEXT1)  /* Any VARCHAR segments */
326
326
    {
327
327
      const CHARSET_INFO * const cs= seg->charset;
328
 
      uint pack_length= seg->bit_start;
329
 
      uint length= (pack_length == 1 ? (uint) *(unsigned char*) pos : uint2korr(pos));
 
328
      uint32_t pack_length= seg->bit_start;
 
329
      uint32_t length= (pack_length == 1 ? (uint) *(unsigned char*) pos : uint2korr(pos));
330
330
      if (cs->mbmaxlen > 1)
331
331
      {
332
 
        uint char_length;
 
332
        uint32_t char_length;
333
333
        char_length= my_charpos(cs, pos + pack_length,
334
334
                                pos + pack_length + length,
335
335
                                seg->length/cs->mbmaxlen);
401
401
    }
402
402
    else if (seg->type == HA_KEYTYPE_VARTEXT1)  /* Any VARCHAR segments */
403
403
    {
404
 
      uint pack_length= 2;                      /* Key packing is constant */
405
 
      uint length= uint2korr(pos);
 
404
      uint32_t pack_length= 2;                      /* Key packing is constant */
 
405
      uint32_t length= uint2korr(pos);
406
406
      seg->charset->coll->hash_sort(seg->charset, pos+pack_length, length,
407
407
                                    &nr, &nr2);
408
408
      key+= pack_length;
439
439
    }
440
440
    if (seg->type == HA_KEYTYPE_TEXT)
441
441
    {
442
 
      uint char_length= seg->length; /* TODO: fix to use my_charpos() */
 
442
      uint32_t char_length= seg->length; /* TODO: fix to use my_charpos() */
443
443
      seg->charset->coll->hash_sort(seg->charset, pos, char_length,
444
444
                                    &nr, &nr2);
445
445
    }
446
446
    else if (seg->type == HA_KEYTYPE_VARTEXT1)  /* Any VARCHAR segments */
447
447
    {
448
 
      uint pack_length= seg->bit_start;
449
 
      uint length= (pack_length == 1 ? (uint) *(unsigned char*) pos : uint2korr(pos));
 
448
      uint32_t pack_length= seg->bit_start;
 
449
      uint32_t length= (pack_length == 1 ? (uint) *(unsigned char*) pos : uint2korr(pos));
450
450
      seg->charset->coll->hash_sort(seg->charset, pos+pack_length,
451
451
                                    length, &nr, &nr2);
452
452
    }
504
504
    if (seg->type == HA_KEYTYPE_TEXT)
505
505
    {
506
506
      const CHARSET_INFO * const cs= seg->charset;
507
 
      uint char_length1;
508
 
      uint char_length2;
 
507
      uint32_t char_length1;
 
508
      uint32_t char_length2;
509
509
      unsigned char *pos1= (unsigned char*)rec1 + seg->start;
510
510
      unsigned char *pos2= (unsigned char*)rec2 + seg->start;
511
511
      if (cs->mbmaxlen > 1)
512
512
      {
513
 
        uint char_length= seg->length / cs->mbmaxlen;
 
513
        uint32_t char_length= seg->length / cs->mbmaxlen;
514
514
        char_length1= my_charpos(cs, pos1, pos1 + seg->length, char_length);
515
515
        set_if_smaller(char_length1, seg->length);
516
516
        char_length2= my_charpos(cs, pos2, pos2 + seg->length, char_length);
529
529
    {
530
530
      unsigned char *pos1= (unsigned char*) rec1 + seg->start;
531
531
      unsigned char *pos2= (unsigned char*) rec2 + seg->start;
532
 
      uint char_length1, char_length2;
533
 
      uint pack_length= seg->bit_start;
 
532
      uint32_t char_length1, char_length2;
 
533
      uint32_t pack_length= seg->bit_start;
534
534
      const CHARSET_INFO * const cs= seg->charset;
535
535
      if (pack_length == 1)
536
536
      {
546
546
      }
547
547
      if (cs->mbmaxlen > 1)
548
548
      {
549
 
        uint safe_length1= char_length1;
550
 
        uint safe_length2= char_length2;
551
 
        uint char_length= seg->length / cs->mbmaxlen;
 
549
        uint32_t safe_length1= char_length1;
 
550
        uint32_t safe_length2= char_length2;
 
551
        uint32_t char_length= seg->length / cs->mbmaxlen;
552
552
        char_length1= my_charpos(cs, pos1, pos1 + char_length1, char_length);
553
553
        set_if_smaller(char_length1, safe_length1);
554
554
        char_length2= my_charpos(cs, pos2, pos2 + char_length2, char_length);
597
597
    if (seg->type == HA_KEYTYPE_TEXT)
598
598
    {
599
599
      const CHARSET_INFO * const cs= seg->charset;
600
 
      uint char_length_key;
601
 
      uint char_length_rec;
 
600
      uint32_t char_length_key;
 
601
      uint32_t char_length_rec;
602
602
      unsigned char *pos= (unsigned char*) rec + seg->start;
603
603
      if (cs->mbmaxlen > 1)
604
604
      {
605
 
        uint char_length= seg->length / cs->mbmaxlen;
 
605
        uint32_t char_length= seg->length / cs->mbmaxlen;
606
606
        char_length_key= my_charpos(cs, key, key + seg->length, char_length);
607
607
        set_if_smaller(char_length_key, seg->length);
608
608
        char_length_rec= my_charpos(cs, pos, pos + seg->length, char_length);
623
623
    {
624
624
      unsigned char *pos= (unsigned char*) rec + seg->start;
625
625
      const CHARSET_INFO * const cs= seg->charset;
626
 
      uint pack_length= seg->bit_start;
627
 
      uint char_length_rec= (pack_length == 1 ? (uint) *(unsigned char*) pos :
 
626
      uint32_t pack_length= seg->bit_start;
 
627
      uint32_t char_length_rec= (pack_length == 1 ? (uint) *(unsigned char*) pos :
628
628
                             uint2korr(pos));
629
629
      /* Key segments are always packed with 2 bytes */
630
 
      uint char_length_key= uint2korr(key);
 
630
      uint32_t char_length_key= uint2korr(key);
631
631
      pos+= pack_length;
632
632
      key+= 2;                                  /* skip key pack length */
633
633
      if (cs->mbmaxlen > 1)
634
634
      {
635
 
        uint char_length1, char_length2;
 
635
        uint32_t char_length1, char_length2;
636
636
        char_length1= char_length2= seg->length / cs->mbmaxlen; 
637
637
        char_length1= my_charpos(cs, key, key + char_length_key, char_length1);
638
638
        set_if_smaller(char_length_key, char_length1);
664
664
  for (seg=keydef->seg,endseg=seg+keydef->keysegs ; seg < endseg ; seg++)
665
665
  {
666
666
    const CHARSET_INFO * const cs= seg->charset;
667
 
    uint char_length= seg->length;
 
667
    uint32_t char_length= seg->length;
668
668
    unsigned char *pos= (unsigned char*) rec + seg->start;
669
669
    if (seg->null_bit)
670
670
      *key++= test(rec[seg->null_pos] & seg->null_bit);
689
689
  } while(0)
690
690
 
691
691
 
692
 
uint hp_rb_make_key(HP_KEYDEF *keydef, unsigned char *key, 
 
692
uint32_t hp_rb_make_key(HP_KEYDEF *keydef, unsigned char *key, 
693
693
                    const unsigned char *rec, unsigned char *recpos)
694
694
{
695
695
  unsigned char *start_key= key;
697
697
 
698
698
  for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
699
699
  {
700
 
    uint char_length;
 
700
    uint32_t char_length;
701
701
    if (seg->null_bit)
702
702
    {
703
703
      if (!(*key++= 1 - test(rec[seg->null_pos] & seg->null_bit)))
705
705
    }
706
706
    if (seg->flag & HA_SWAP_KEY)
707
707
    {
708
 
      uint length= seg->length;
 
708
      uint32_t length= seg->length;
709
709
      unsigned char *pos= (unsigned char*) rec + seg->start;
710
710
      
711
711
#ifdef HAVE_ISNAN
744
744
    if (seg->flag & HA_VAR_LENGTH_PART)
745
745
    {
746
746
      unsigned char *pos=      (unsigned char*) rec + seg->start;
747
 
      uint length=     seg->length;
748
 
      uint pack_length= seg->bit_start;
749
 
      uint tmp_length= (pack_length == 1 ? (uint) *(unsigned char*) pos :
 
747
      uint32_t length=     seg->length;
 
748
      uint32_t pack_length= seg->bit_start;
 
749
      uint32_t tmp_length= (pack_length == 1 ? (uint) *(unsigned char*) pos :
750
750
                        uint2korr(pos));
751
751
      const CHARSET_INFO * const cs= seg->charset;
752
752
      char_length= length/cs->mbmaxlen;
779
779
}
780
780
 
781
781
 
782
 
uint hp_rb_pack_key(HP_KEYDEF *keydef, unsigned char *key, const unsigned char *old,
 
782
uint32_t hp_rb_pack_key(HP_KEYDEF *keydef, unsigned char *key, const unsigned char *old,
783
783
                    key_part_map keypart_map)
784
784
{
785
785
  HA_KEYSEG *seg, *endseg;
788
788
  for (seg= keydef->seg, endseg= seg + keydef->keysegs;
789
789
       seg < endseg && keypart_map; old+= seg->length, seg++)
790
790
  {
791
 
    uint char_length;
 
791
    uint32_t char_length;
792
792
    keypart_map>>= 1;
793
793
    if (seg->null_bit)
794
794
    {
797
797
      }
798
798
    if (seg->flag & HA_SWAP_KEY)
799
799
    {
800
 
      uint length= seg->length;
 
800
      uint32_t length= seg->length;
801
801
      unsigned char *pos= (unsigned char*) old + length;
802
802
      
803
803
      while (length--)
809
809
    if (seg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
810
810
    {
811
811
      /* Length of key-part used with heap_rkey() always 2 */
812
 
      uint tmp_length=uint2korr(old);
813
 
      uint length= seg->length;
 
812
      uint32_t tmp_length=uint2korr(old);
 
813
      uint32_t length= seg->length;
814
814
      const CHARSET_INFO * const cs= seg->charset;
815
815
      char_length= length/cs->mbmaxlen;
816
816
 
839
839
}
840
840
 
841
841
 
842
 
uint hp_rb_key_length(HP_KEYDEF *keydef, 
 
842
uint32_t hp_rb_key_length(HP_KEYDEF *keydef, 
843
843
                      const unsigned char *key __attribute__((unused)))
844
844
{
845
845
  return keydef->length;
846
846
}
847
847
 
848
848
 
849
 
uint hp_rb_null_key_length(HP_KEYDEF *keydef, const unsigned char *key)
 
849
uint32_t hp_rb_null_key_length(HP_KEYDEF *keydef, const unsigned char *key)
850
850
{
851
851
  const unsigned char *start_key= key;
852
852
  HA_KEYSEG *seg, *endseg;
861
861
}
862
862
                  
863
863
 
864
 
uint hp_rb_var_key_length(HP_KEYDEF *keydef, const unsigned char *key)
 
864
uint32_t hp_rb_var_key_length(HP_KEYDEF *keydef, const unsigned char *key)
865
865
{
866
866
  const unsigned char *start_key= key;
867
867
  HA_KEYSEG *seg, *endseg;
868
868
  
869
869
  for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
870
870
  {
871
 
    uint length= seg->length;
 
871
    uint32_t length= seg->length;
872
872
    if (seg->null_bit && !*key++)
873
873
      continue;
874
874
    if (seg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))