← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_search.c

  • Committer: Monty Taylor
  • Date: 2008-08-01 22:33:44 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080801223344-vzhlflfmtijp1imv
First pass at gettexizing the error messages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_search.c
15
15
 
16
16
/* key handling functions */
17
17
 
18
 
#include "myisam_priv.h"
19
 
#include "drizzled/charset_info.h"
20
 
#include "drizzled/internal/m_string.h"
21
 
#include <drizzled/util/test.h>
 
18
#include "myisamdef.h"
 
19
#include <mystrings/m_ctype.h>
22
20
 
23
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
24
 
                                unsigned char *key, unsigned char *keypos,
25
 
                                uint32_t *return_key_length);
 
21
static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
22
                                uchar *key, uchar *keypos,
 
23
                                uint *return_key_length);
26
24
 
27
25
        /* Check index */
28
26
 
32
30
    inx=info->lastinx;
33
31
  if (inx < 0 || ! mi_is_key_active(info->s->state.key_map, inx))
34
32
  {
35
 
    errno=HA_ERR_WRONG_INDEX;
 
33
    my_errno=HA_ERR_WRONG_INDEX;
36
34
    return -1;
37
35
  }
38
36
  if (info->lastinx != inx)             /* Index changed */
56
54
        */
57
55
 
58
56
int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
59
 
               unsigned char *key, uint32_t key_len, uint32_t nextflag, register my_off_t pos)
 
57
               uchar *key, uint key_len, uint nextflag, register my_off_t pos)
60
58
{
61
 
  bool last_key;
 
59
  my_bool last_key;
62
60
  int error,flag;
63
 
  uint32_t nod_flag;
64
 
  unsigned char *keypos,*maxpos;
65
 
  unsigned char lastkey[MI_MAX_KEY_BUFF],*buff;
 
61
  uint nod_flag;
 
62
  uchar *keypos,*maxpos;
 
63
  uchar lastkey[MI_MAX_KEY_BUFF],*buff;
66
64
 
67
65
  if (pos == HA_OFFSET_ERROR)
68
66
  {
69
 
    errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
 
67
    my_errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
70
68
    info->lastpos= HA_OFFSET_ERROR;
71
69
    if (!(nextflag & (SEARCH_SMALLER | SEARCH_BIGGER | SEARCH_LAST)))
72
70
      return(-1);                          /* Not found ; return error */
107
105
    {
108
106
      if ((error=_mi_search(info,keyinfo,key,key_len,SEARCH_FIND,
109
107
                            _mi_kpos(nod_flag,keypos))) >= 0 ||
110
 
          errno != HA_ERR_KEY_NOT_FOUND)
 
108
          my_errno != HA_ERR_KEY_NOT_FOUND)
111
109
        return(error);
112
110
      info->last_keypage= HA_OFFSET_ERROR;              /* Buffer not in mem */
113
111
    }
114
112
  }
115
113
  if (pos != info->last_keypage)
116
114
  {
117
 
    unsigned char *old_buff=buff;
 
115
    uchar *old_buff=buff;
118
116
    if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,
119
117
                                 test(!(nextflag & SEARCH_SAVE_BUFF)))))
120
118
      goto err;
124
122
 
125
123
  if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
126
124
  {
127
 
    uint32_t not_used[2];
 
125
    uint not_used[2];
128
126
    if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
129
127
                         &info->lastkey_length))
130
128
      goto err;
132
130
        ha_key_cmp(keyinfo->seg, info->lastkey, key, key_len, SEARCH_FIND,
133
131
                   not_used))
134
132
    {
135
 
      errno=HA_ERR_KEY_NOT_FOUND;                    /* Didn't find key */
 
133
      my_errno=HA_ERR_KEY_NOT_FOUND;                    /* Didn't find key */
136
134
      goto err;
137
135
    }
138
136
  }
167
165
        /* ret_pos point to where find or bigger key starts */
168
166
        /* ARGSUSED */
169
167
 
170
 
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
171
 
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
172
 
                   unsigned char *buff, bool *last_key)
 
168
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 
169
                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
 
170
                   uchar *buff __attribute__((unused)), my_bool *last_key)
173
171
{
174
 
  (void)buff;
175
172
  register int start,mid,end,save_end;
176
173
  int flag;
177
 
  uint32_t totlength,nod_flag,not_used[2];
 
174
  uint totlength,nod_flag,not_used[2];
178
175
 
179
176
  totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
180
177
  start=0; mid=1;
228
225
    < 0         Not found.
229
226
*/
230
227
 
231
 
int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
232
 
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
233
 
                   unsigned char *buff, bool *last_key)
 
228
int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 
229
                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
 
230
                   uchar *buff, my_bool *last_key)
234
231
{
235
232
  int flag=0;
236
 
  uint32_t nod_flag,length=0,not_used[2];
237
 
  unsigned char t_buff[MI_MAX_KEY_BUFF],*end;
 
233
  uint nod_flag,length=0,not_used[2];
 
234
  uchar t_buff[MI_MAX_KEY_BUFF],*end;
238
235
 
239
236
  end= page+mi_getint(page);
240
237
  nod_flag=mi_test_if_nod(page);
247
244
    if (length == 0 || page > end)
248
245
    {
249
246
      mi_print_error(info->s, HA_ERR_CRASHED);
250
 
      errno=HA_ERR_CRASHED;
 
247
      my_errno=HA_ERR_CRASHED;
251
248
      return(MI_FOUND_WRONG_KEY);
252
249
    }
253
250
    if ((flag=ha_key_cmp(keyinfo->seg,t_buff,key,key_len,comp_flag,
263
260
} /* _mi_seq_search */
264
261
 
265
262
 
266
 
int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
267
 
                      unsigned char *key, uint32_t key_len, uint32_t nextflag, unsigned char **ret_pos,
268
 
                      unsigned char *buff, bool *last_key)
 
263
int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 
264
                      uchar *key, uint key_len, uint nextflag, uchar **ret_pos,
 
265
                      uchar *buff, my_bool *last_key)
269
266
{
270
267
  /*
271
268
    my_flag is raw comparison result to be changed according to
273
270
    flag is the value returned by ha_key_cmp and as treated as final
274
271
  */
275
272
  int flag=0, my_flag=-1;
276
 
  uint32_t nod_flag, length=0, len, matched, cmplen, kseg_len;
277
 
  uint32_t prefix_len=0,suffix_len;
 
273
  uint nod_flag, length=0, len, matched, cmplen, kseg_len;
 
274
  uint prefix_len=0,suffix_len;
278
275
  int key_len_skip, seg_len_pack=0, key_len_left;
279
 
  unsigned char *end, *kseg, *vseg;
280
 
  unsigned char *sort_order=keyinfo->seg->charset->sort_order;
281
 
  unsigned char tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
282
 
  unsigned char *saved_from=NULL, *saved_to=NULL, *saved_vseg=NULL;
283
 
  uint32_t  saved_length=0, saved_prefix_len=0;
284
 
  uint32_t  length_pack;
 
276
  uchar *end, *kseg, *vseg;
 
277
  uchar *sort_order=keyinfo->seg->charset->sort_order;
 
278
  uchar tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
 
279
  uchar *saved_from=NULL, *saved_to=NULL, *saved_vseg=NULL;
 
280
  uint  saved_length=0, saved_prefix_len=0;
 
281
  uint  length_pack;
285
282
 
286
283
 
287
284
  t_buff[0]=0;                                  /* Avoid bugs */
315
312
 
316
313
  while (page < end)
317
314
  {
318
 
    uint32_t packed= *page & 128;
 
315
    uint packed= *page & 128;
319
316
 
320
317
    vseg=page;
321
318
    if (keyinfo->seg->length >= 127)
358
355
    saved_prefix_len=prefix_len;
359
356
 
360
357
    {
361
 
      unsigned char *from=vseg+suffix_len;
 
358
      uchar *from=vseg+suffix_len;
362
359
      HA_KEYSEG *keyseg;
363
 
      uint32_t l;
 
360
      uint l;
364
361
 
365
362
      for (keyseg=keyinfo->seg+1 ; keyseg->type ; keyseg++ )
366
363
      {
387
384
    if (page > end)
388
385
    {
389
386
      mi_print_error(info->s, HA_ERR_CRASHED);
390
 
      errno=HA_ERR_CRASHED;
 
387
      my_errno=HA_ERR_CRASHED;
391
388
      return(MI_FOUND_WRONG_KEY);
392
389
    }
393
390
 
394
391
    if (matched >= prefix_len)
395
392
    {
396
393
      /* We have to compare. But we can still skip part of the key */
397
 
      uint32_t  left;
398
 
      unsigned char *k=kseg+prefix_len;
 
394
      uint  left;
 
395
      uchar *k=kseg+prefix_len;
399
396
 
400
397
      /*
401
398
        If prefix_len > cmplen then we are in the end-space comparison
441
438
          else
442
439
          {
443
440
            /* We have to compare k and vseg as if they were space extended */
444
 
            unsigned char *k_end= k+ (cmplen - len);
 
441
            uchar *k_end= k+ (cmplen - len);
445
442
            for ( ; k < k_end && *k == ' '; k++) ;
446
443
            if (k == k_end)
447
444
              goto cmp_rest;            /* should never happen */
448
 
            if (*k < (unsigned char) ' ')
 
445
            if (*k < (uchar) ' ')
449
446
            {
450
447
              my_flag= 1;               /* Compared string is smaller */
451
448
              break;
455
452
        }
456
453
        else if (len > cmplen)
457
454
        {
458
 
          unsigned char *vseg_end;
 
455
          uchar *vseg_end;
459
456
          if ((nextflag & SEARCH_PREFIX) && key_len_left == 0)
460
457
            goto fix_flag;
461
458
 
462
459
          /* We have to compare k and vseg as if they were space extended */
463
460
          for (vseg_end= vseg + (len-cmplen) ;
464
 
               vseg < vseg_end && *vseg == (unsigned char) ' ';
 
461
               vseg < vseg_end && *vseg == (uchar) ' ';
465
462
               vseg++, matched++) ;
466
463
          assert(vseg < vseg_end);
467
464
 
468
 
          if (*vseg > (unsigned char) ' ')
 
465
          if (*vseg > (uchar) ' ')
469
466
          {
470
467
            my_flag= 1;                 /* Compared string is smaller */
471
468
            break;
477
474
      cmp_rest:
478
475
          if (key_len_left>0)
479
476
          {
480
 
            uint32_t not_used[2];
 
477
            uint not_used[2];
481
478
            if ((flag = ha_key_cmp(keyinfo->seg+1,vseg,
482
479
                                   k, key_len_left, nextflag, not_used)) >= 0)
483
480
              break;
527
524
 
528
525
        /* Get pos to a key_block */
529
526
 
530
 
my_off_t _mi_kpos(uint32_t nod_flag, unsigned char *after_key)
 
527
my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
531
528
{
532
529
  after_key-=nod_flag;
533
530
  switch (nod_flag) {
563
560
 
564
561
        /* Save pos to a key_block */
565
562
 
566
 
void _mi_kpointer(register MI_INFO *info, register unsigned char *buff, my_off_t pos)
 
563
void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
567
564
{
568
565
  pos/=MI_MIN_KEY_BLOCK_LENGTH;
569
566
  switch (info->s->base.key_reflength) {
582
579
  case 4: mi_int4store(buff,pos); break;
583
580
  case 3: mi_int3store(buff,pos); break;
584
581
  case 2: mi_int2store(buff,(uint) pos); break;
585
 
  case 1: buff[0]= (unsigned char) pos; break;
 
582
  case 1: buff[0]= (uchar) pos; break;
586
583
  default: abort();                             /* impossible */
587
584
  }
588
585
} /* _mi_kpointer */
591
588
        /* Calc pos to a data-record from a key */
592
589
 
593
590
 
594
 
my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag, unsigned char *after_key)
 
591
my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, uchar *after_key)
595
592
{
596
593
  my_off_t pos;
597
594
  after_key-=(nod_flag + info->s->rec_reflength);
621
618
 
622
619
/* Calc position from a record pointer ( in delete link chain ) */
623
620
 
624
 
my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
 
621
my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
625
622
{
626
623
  my_off_t pos;
627
624
  switch (s->rec_reflength) {
656
653
#endif
657
654
  case 4:
658
655
    pos= (my_off_t) mi_uint4korr(ptr);
659
 
    if (pos == (my_off_t) UINT32_MAX)
 
656
    if (pos == (my_off_t) (uint32_t) ~0L)
660
657
      return  HA_OFFSET_ERROR;
661
658
    break;
662
659
  case 3:
679
676
 
680
677
        /* save position to record */
681
678
 
682
 
void _mi_dpointer(MI_INFO *info, unsigned char *buff, my_off_t pos)
 
679
void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
683
680
{
684
681
  if (!(info->s->options &
685
682
        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
718
715
 
719
716
        /* same as _mi_get_key but used with fixed length keys */
720
717
 
721
 
uint32_t _mi_get_static_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
722
 
                       register unsigned char **page, register unsigned char *key)
 
718
uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
719
                       register uchar **page, register uchar *key)
723
720
{
724
 
  memcpy(key, *page, keyinfo->keylength+nod_flag);
 
721
  memcpy((uchar*) key,(uchar*) *page,
 
722
         (size_t) (keyinfo->keylength+nod_flag));
725
723
  *page+=keyinfo->keylength+nod_flag;
726
724
  return(keyinfo->keylength);
727
725
} /* _mi_get_static_key */
741
739
    key_length + length of data pointer
742
740
*/
743
741
 
744
 
uint32_t _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
745
 
                      register unsigned char **page_pos, register unsigned char *key)
 
742
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
743
                      register uchar **page_pos, register uchar *key)
746
744
{
747
745
  register HA_KEYSEG *keyseg;
748
 
  unsigned char *start_key,*page=*page_pos;
749
 
  uint32_t length;
 
746
  uchar *start_key,*page=*page_pos;
 
747
  uint length;
750
748
 
751
749
  start_key=key;
752
750
  for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
754
752
    if (keyseg->flag & HA_PACK_KEY)
755
753
    {
756
754
      /* key with length, packed to previous key */
757
 
      unsigned char *start=key;
758
 
      uint32_t packed= *page & 128,tot_length,rest_length;
 
755
      uchar *start=key;
 
756
      uint packed= *page & 128,tot_length,rest_length;
759
757
      if (keyseg->length >= 127)
760
758
      {
761
759
        length=mi_uint2korr(page) & 32767;
769
767
        if (length > (uint) keyseg->length)
770
768
        {
771
769
          mi_print_error(keyinfo->share, HA_ERR_CRASHED);
772
 
          errno=HA_ERR_CRASHED;
 
770
          my_errno=HA_ERR_CRASHED;
773
771
          return 0;                             /* Error */
774
772
        }
775
773
        if (length == 0)                        /* Same key */
781
779
          if (length > keyseg->length)
782
780
          {
783
781
            mi_print_error(keyinfo->share, HA_ERR_CRASHED);
784
 
            errno=HA_ERR_CRASHED;
 
782
            my_errno=HA_ERR_CRASHED;
785
783
            return 0;
786
784
          }
787
785
          continue;
806
804
        }
807
805
        else if (tot_length < 255 && *start == 255)
808
806
        {
809
 
          memmove(key+1,key+3,length);
 
807
          memcpy(key+1,key+3,length);
810
808
          *key=tot_length;
811
809
          key+=1+length;
812
810
        }
835
833
      if (length > (uint) keyseg->length)
836
834
      {
837
835
        mi_print_error(keyinfo->share, HA_ERR_CRASHED);
838
 
        errno=HA_ERR_CRASHED;
 
836
        my_errno=HA_ERR_CRASHED;
839
837
        return 0;                               /* Error */
840
838
      }
841
839
      store_key_length_inc(key,length);
850
848
      if (keyseg->flag &
851
849
          (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
852
850
      {
853
 
        unsigned char *tmp=page;
 
851
        uchar *tmp=page;
854
852
        get_key_length(length,tmp);
855
853
        length+=(uint) (tmp-page);
856
854
      }
857
855
      else
858
856
        length=keyseg->length;
859
857
    }
860
 
    memcpy(key, page, length);
 
858
    memcpy((uchar*) key,(uchar*) page,(size_t) length);
861
859
    key+=length;
862
860
    page+=length;
863
861
  }
864
862
  length=keyseg->length+nod_flag;
865
 
  memmove(key,page,length);
 
863
  memcpy((uchar*) key,(uchar*) page,length);
866
864
  *page_pos= page+length;
867
865
  return ((uint) (key-start_key)+keyseg->length);
868
866
} /* _mi_get_pack_key */
871
869
 
872
870
/* key that is packed relatively to previous */
873
871
 
874
 
uint32_t _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
875
 
                             register unsigned char **page_pos, register unsigned char *key)
 
872
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
873
                             register uchar **page_pos, register uchar *key)
876
874
{
877
875
  register HA_KEYSEG *keyseg;
878
 
  unsigned char *start_key,*page,*page_end,*from,*from_end;
879
 
  uint32_t length,tmp;
 
876
  uchar *start_key,*page,*page_end,*from,*from_end;
 
877
  uint length,tmp;
880
878
 
881
879
  page= *page_pos;
882
880
  page_end=page+MI_MAX_KEY_BUFF+1;
902
900
    if (length > keyinfo->maxlength)
903
901
    {
904
902
      mi_print_error(keyinfo->share, HA_ERR_CRASHED);
905
 
      errno=HA_ERR_CRASHED;
 
903
      my_errno=HA_ERR_CRASHED;
906
904
      return(0);                                 /* Wrong key */
907
905
    }
908
906
    /* Key is packed against prev key, take prefix from prev key. */
956
954
      length-=tmp;
957
955
      from=page; from_end=page_end;
958
956
    }
959
 
    memmove(key, from, length);
 
957
    memmove((uchar*) key, (uchar*) from, (size_t) length);
960
958
    key+=length;
961
959
    from+=length;
962
960
  }
983
981
    if (from_end != page_end)
984
982
    {
985
983
      mi_print_error(keyinfo->share, HA_ERR_CRASHED);
986
 
      errno=HA_ERR_CRASHED;
 
984
      my_errno=HA_ERR_CRASHED;
987
985
      return(0);                                 /* Error */
988
986
    }
989
987
    /* Copy data pointer and, if appropriate, key block pointer. */
990
 
    memcpy(key, from, length);
 
988
    memcpy((uchar*) key,(uchar*) from,(size_t) length);
991
989
    *page_pos= from+length;
992
990
  }
993
991
  return((uint) (key-start_key)+keyseg->length);
997
995
        /* Get key at position without knowledge of previous key */
998
996
        /* Returns pointer to next key */
999
997
 
1000
 
unsigned char *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1001
 
                   unsigned char *key, unsigned char *keypos, uint32_t *return_key_length)
 
998
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
999
                   uchar *key, uchar *keypos, uint *return_key_length)
1002
1000
{
1003
 
  uint32_t nod_flag;
 
1001
  uint nod_flag;
1004
1002
 
1005
1003
  nod_flag=mi_test_if_nod(page);
1006
1004
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1007
1005
  {
1008
 
    memmove(key,keypos,keyinfo->keylength+nod_flag);
 
1006
    memcpy((uchar*) key,(uchar*) keypos,keyinfo->keylength+nod_flag);
1009
1007
    return(keypos+keyinfo->keylength+nod_flag);
1010
1008
  }
1011
1009
  else
1018
1016
      if (*return_key_length == 0)
1019
1017
      {
1020
1018
        mi_print_error(info->s, HA_ERR_CRASHED);
1021
 
        errno=HA_ERR_CRASHED;
 
1019
        my_errno=HA_ERR_CRASHED;
1022
1020
        return(0);
1023
1021
      }
1024
1022
    }
1030
1028
        /* Get key at position without knowledge of previous key */
1031
1029
        /* Returns 0 if ok */
1032
1030
 
1033
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1034
 
                                unsigned char *key, unsigned char *keypos,
1035
 
                                uint32_t *return_key_length)
 
1031
static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
1032
                                uchar *key, uchar *keypos,
 
1033
                                uint *return_key_length)
1036
1034
{
1037
 
  uint32_t nod_flag;
 
1035
  uint nod_flag;
1038
1036
 
1039
1037
  nod_flag=mi_test_if_nod(page);
1040
1038
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1041
1039
  {
1042
1040
    *return_key_length=keyinfo->keylength;
1043
 
    memmove(key, keypos - *return_key_length-nod_flag, *return_key_length);
 
1041
    memcpy((uchar*) key,(uchar*) keypos- *return_key_length-nod_flag,
 
1042
           *return_key_length);
1044
1043
    return(0);
1045
1044
  }
1046
1045
  else
1053
1052
      if (*return_key_length == 0)
1054
1053
      {
1055
1054
        mi_print_error(info->s, HA_ERR_CRASHED);
1056
 
        errno=HA_ERR_CRASHED;
 
1055
        my_errno=HA_ERR_CRASHED;
1057
1056
        return(1);
1058
1057
      }
1059
1058
    }
1066
1065
        /* Get last key from key-page */
1067
1066
        /* Return pointer to where key starts */
1068
1067
 
1069
 
unsigned char *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1070
 
                        unsigned char *lastkey, unsigned char *endpos, uint32_t *return_key_length)
 
1068
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
1069
                        uchar *lastkey, uchar *endpos, uint *return_key_length)
1071
1070
{
1072
 
  uint32_t nod_flag;
1073
 
  unsigned char *lastpos;
 
1071
  uint nod_flag;
 
1072
  uchar *lastpos;
1074
1073
 
1075
1074
  nod_flag=mi_test_if_nod(page);
1076
1075
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1078
1077
    lastpos=endpos-keyinfo->keylength-nod_flag;
1079
1078
    *return_key_length=keyinfo->keylength;
1080
1079
    if (lastpos > page)
1081
 
      memmove(lastkey,lastpos,keyinfo->keylength+nod_flag);
 
1080
      memcpy((uchar*) lastkey,(uchar*) lastpos,keyinfo->keylength+nod_flag);
1082
1081
  }
1083
1082
  else
1084
1083
  {
1091
1090
      if (*return_key_length == 0)
1092
1091
      {
1093
1092
        mi_print_error(info->s, HA_ERR_CRASHED);
1094
 
        errno=HA_ERR_CRASHED;
 
1093
        my_errno=HA_ERR_CRASHED;
1095
1094
        return(0);
1096
1095
      }
1097
1096
    }
1102
1101
 
1103
1102
        /* Calculate length of key */
1104
1103
 
1105
 
uint32_t _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
 
1104
uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
1106
1105
{
1107
1106
  register HA_KEYSEG *keyseg;
1108
 
  unsigned char *start;
 
1107
  uchar *start;
1109
1108
 
1110
1109
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1111
1110
    return (keyinfo->keylength);
1118
1117
        continue;
1119
1118
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1120
1119
    {
1121
 
      uint32_t length;
 
1120
      uint length;
1122
1121
      get_key_length(length,key);
1123
1122
      key+=length;
1124
1123
    }
1137
1136
  after '0xDF' but find 'ss'
1138
1137
*/
1139
1138
 
1140
 
uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
 
1139
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
1141
1140
                        HA_KEYSEG *end)
1142
1141
{
1143
1142
  register HA_KEYSEG *keyseg;
1144
 
  unsigned char *start= key;
 
1143
  uchar *start= key;
1145
1144
 
1146
1145
  for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
1147
1146
  {
1150
1149
        continue;
1151
1150
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1152
1151
    {
1153
 
      uint32_t length;
 
1152
      uint length;
1154
1153
      get_key_length(length,key);
1155
1154
      key+=length;
1156
1155
    }
1162
1161
 
1163
1162
        /* Move a key */
1164
1163
 
1165
 
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
 
1164
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
1166
1165
{
1167
 
  register uint32_t length;
1168
 
  length= _mi_keylength(keyinfo, from);
1169
 
  memcpy(to, from, length);
 
1166
  register uint length;
 
1167
  memcpy((uchar*) to, (uchar*) from,
 
1168
         (size_t) (length=_mi_keylength(keyinfo,from)));
1170
1169
  return to+length;
1171
1170
}
1172
1171
 
1174
1173
        /* This can't be used when database is touched after last read */
1175
1174
 
1176
1175
int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1177
 
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, my_off_t pos)
 
1176
                    uchar *key, uint key_length, uint nextflag, my_off_t pos)
1178
1177
{
1179
1178
  int error;
1180
 
  uint32_t nod_flag;
1181
 
  unsigned char lastkey[MI_MAX_KEY_BUFF];
 
1179
  uint nod_flag;
 
1180
  uchar lastkey[MI_MAX_KEY_BUFF];
1182
1181
 
1183
1182
  /* Force full read if we are at last key or if we are not on a leaf
1184
1183
     and the key tree has changed since we used it last time
1221
1220
  }
1222
1221
  else                                                  /* Previous key */
1223
1222
  {
1224
 
    uint32_t length;
 
1223
    uint length;
1225
1224
    /* Find start of previous key */
1226
1225
    info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
1227
1226
                                      info->int_keypos, &length);
1252
1251
int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1253
1252
                     register my_off_t pos)
1254
1253
{
1255
 
  uint32_t nod_flag;
1256
 
  unsigned char *page;
 
1254
  uint nod_flag;
 
1255
  uchar *page;
1257
1256
 
1258
1257
  if (pos == HA_OFFSET_ERROR)
1259
1258
  {
1260
 
    errno=HA_ERR_KEY_NOT_FOUND;
 
1259
    my_errno=HA_ERR_KEY_NOT_FOUND;
1261
1260
    info->lastpos= HA_OFFSET_ERROR;
1262
1261
    return(-1);
1263
1262
  }
1294
1293
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1295
1294
                    register my_off_t pos)
1296
1295
{
1297
 
  uint32_t nod_flag;
1298
 
  unsigned char *buff,*page;
 
1296
  uint nod_flag;
 
1297
  uchar *buff,*page;
1299
1298
 
1300
1299
  if (pos == HA_OFFSET_ERROR)
1301
1300
  {
1302
 
    errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
 
1301
    my_errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
1303
1302
    info->lastpos= HA_OFFSET_ERROR;
1304
1303
    return(-1);
1305
1304
  }
1347
1346
/* Static length key */
1348
1347
 
1349
1348
int
1350
 
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1351
 
                           unsigned char *next_pos,
1352
 
                           unsigned char *org_key,
1353
 
                           unsigned char *prev_key,
1354
 
                           unsigned char *key, MI_KEY_PARAM *s_temp)
 
1349
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
1350
                           uchar *next_pos  __attribute__((unused)),
 
1351
                           uchar *org_key  __attribute__((unused)),
 
1352
                           uchar *prev_key __attribute__((unused)),
 
1353
                           uchar *key, MI_KEY_PARAM *s_temp)
1355
1354
{
1356
 
  (void)next_pos;
1357
 
  (void)org_key;
1358
 
  (void)prev_key;
1359
1355
  s_temp->key=key;
1360
1356
  return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
1361
1357
}
1363
1359
/* Variable length key */
1364
1360
 
1365
1361
int
1366
 
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1367
 
                        unsigned char *next_pos,
1368
 
                        unsigned char *org_key,
1369
 
                        unsigned char *prev_key,
1370
 
                        unsigned char *key, MI_KEY_PARAM *s_temp)
 
1362
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
1363
                        uchar *next_pos  __attribute__((unused)),
 
1364
                        uchar *org_key  __attribute__((unused)),
 
1365
                        uchar *prev_key __attribute__((unused)),
 
1366
                        uchar *key, MI_KEY_PARAM *s_temp)
1371
1367
{
1372
 
  (void)next_pos;
1373
 
  (void)org_key;
1374
 
  (void)prev_key;
1375
1368
  s_temp->key=key;
1376
1369
  return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
1377
1370
}
1396
1389
*/
1397
1390
 
1398
1391
int
1399
 
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1400
 
                             unsigned char *next_key,
1401
 
                             unsigned char *org_key,
1402
 
                             unsigned char *prev_key,
1403
 
                             unsigned char *key,
 
1392
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
 
1393
                             uchar *org_key, uchar *prev_key, uchar *key,
1404
1394
                             MI_KEY_PARAM *s_temp)
1405
1395
{
1406
1396
  register HA_KEYSEG *keyseg;
1407
1397
  int length;
1408
 
  uint32_t key_length,ref_length,org_key_length=0,
 
1398
  uint key_length,ref_length,org_key_length=0,
1409
1399
       length_pack,new_key_length,diff_flag,pack_marker;
1410
 
  unsigned char *start,*end,*key_end,*sort_order;
1411
 
  bool same_length;
 
1400
  uchar *start,*end,*key_end,*sort_order;
 
1401
  my_bool same_length;
1412
1402
 
1413
1403
  length_pack=s_temp->ref_length=s_temp->n_ref_length=s_temp->n_length=0;
1414
1404
  same_length=0; keyseg=keyinfo->seg;
1523
1513
        /* If something after that hasn't length=0, test if we can combine */
1524
1514
  if ((s_temp->next_key_pos=next_key))
1525
1515
  {
1526
 
    uint32_t packed,n_length;
 
1516
    uint packed,n_length;
1527
1517
 
1528
1518
    packed = *next_key & 128;
1529
1519
    if (diff_flag == 2)
1538
1528
 
1539
1529
    if (n_length || packed)             /* Don't pack 0 length keys */
1540
1530
    {
1541
 
      uint32_t next_length_pack, new_ref_length=s_temp->ref_length;
 
1531
      uint next_length_pack, new_ref_length=s_temp->ref_length;
1542
1532
 
1543
1533
      if (packed)
1544
1534
      {
1606
1596
        }
1607
1597
        if (ref_length+pack_marker > new_ref_length)
1608
1598
        {
1609
 
          uint32_t new_pack_length=new_ref_length-pack_marker;
 
1599
          uint new_pack_length=new_ref_length-pack_marker;
1610
1600
          /* We must copy characters from the original key to the next key */
1611
1601
          s_temp->part_of_prev_key= new_ref_length;
1612
1602
          s_temp->prev_length=      ref_length - new_pack_length;
1624
1614
      }
1625
1615
 
1626
1616
      {
1627
 
        uint32_t tmp_length;
 
1617
        uint tmp_length;
1628
1618
        key=(start+=ref_length);
1629
1619
        if (key+n_length < key_end)             /* Normalize length based */
1630
1620
          key_end=key+n_length;
1671
1661
/* Length of key which is prefix compressed */
1672
1662
 
1673
1663
int
1674
 
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *next_key,
1675
 
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
 
1664
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
 
1665
                             uchar *org_key, uchar *prev_key, uchar *key,
1676
1666
                             MI_KEY_PARAM *s_temp)
1677
1667
{
1678
 
  uint32_t length,key_length,ref_length;
 
1668
  uint length,key_length,ref_length;
1679
1669
 
1680
1670
  s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
1681
1671
#ifdef HAVE_purify
1690
1680
      As keys may be identical when running a sort in myisamchk, we
1691
1681
      have to guard against the case where keys may be identical
1692
1682
    */
1693
 
    unsigned char *end;
 
1683
    uchar *end;
1694
1684
    end=key+key_length;
1695
1685
    for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
1696
1686
    s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
1705
1695
  if ((s_temp->next_key_pos=next_key))          /* If another key after */
1706
1696
  {
1707
1697
    /* pack key against next key */
1708
 
    uint32_t next_length,next_length_pack;
 
1698
    uint next_length,next_length_pack;
1709
1699
    get_key_pack_length(next_length,next_length_pack,next_key);
1710
1700
 
1711
1701
    /* If first key and next key is packed (only on delete) */
1712
1702
    if (!prev_key && org_key && next_length)
1713
1703
    {
1714
 
      unsigned char *end;
 
1704
      uchar *end;
1715
1705
      for (key= s_temp->key, end=key+next_length ;
1716
1706
           *key == *org_key && key < end;
1717
1707
           key++,org_key++) ;
1752
1742
 
1753
1743
/* store key without compression */
1754
1744
 
1755
 
void _mi_store_static_key(MI_KEYDEF *keyinfo,
1756
 
                          register unsigned char *key_pos,
 
1745
void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
 
1746
                          register uchar *key_pos,
1757
1747
                          register MI_KEY_PARAM *s_temp)
1758
1748
{
1759
 
  (void)keyinfo;
1760
 
  memcpy(key_pos, s_temp->key, s_temp->totlength);
 
1749
  memcpy((uchar*) key_pos,(uchar*) s_temp->key,(size_t) s_temp->totlength);
1761
1750
}
1762
1751
 
1763
1752
 
1764
1753
/* store variable length key with prefix compression */
1765
1754
 
1766
1755
#define store_pack_length(test,pos,length) { \
1767
 
  if (test) { *((pos)++) = (unsigned char) (length); } else \
1768
 
  { *((pos)++) = (unsigned char) ((length) >> 8); *((pos)++) = (unsigned char) (length);  } }
1769
 
 
1770
 
 
1771
 
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo,
1772
 
                            register unsigned char *key_pos,
 
1756
  if (test) { *((pos)++) = (uchar) (length); } else \
 
1757
  { *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length);  } }
 
1758
 
 
1759
 
 
1760
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
 
1761
                            register uchar *key_pos,
1773
1762
                            register MI_KEY_PARAM *s_temp)
1774
1763
{
1775
 
  (void)keyinfo;
1776
 
  uint32_t length;
1777
 
  unsigned char *start;
 
1764
  uint length;
 
1765
  uchar *start;
1778
1766
 
1779
1767
  start=key_pos;
1780
1768
 
1791
1779
    /* Not packed against previous key */
1792
1780
    store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->key_length);
1793
1781
  }
1794
 
  assert(key_pos >= start);
1795
 
  length= s_temp->totlength - (key_pos - start);
1796
 
  memmove(key_pos, s_temp->key, length);
 
1782
  memcpy((uchar*) key_pos,(uchar*) s_temp->key,
 
1783
         (length=s_temp->totlength-(uint) (key_pos-start)));
1797
1784
 
1798
1785
  if (!s_temp->next_key_pos)                    /* No following key */
1799
1786
    return;
1833
1820
 
1834
1821
/* variable length key with prefix compression */
1835
1822
 
1836
 
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,
1837
 
                            register unsigned char *key_pos,
 
1823
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
 
1824
                            register uchar *key_pos,
1838
1825
                            register MI_KEY_PARAM *s_temp)
1839
1826
{
1840
 
  (void)keyinfo;
1841
 
  assert(s_temp->totlength >= s_temp->ref_length);
1842
1827
  store_key_length_inc(key_pos,s_temp->ref_length);
1843
 
  memcpy(key_pos,s_temp->key+s_temp->ref_length,
1844
 
         s_temp->totlength - s_temp->ref_length);
 
1828
  memcpy((char*) key_pos,(char*) s_temp->key+s_temp->ref_length,
 
1829
          (size_t) s_temp->totlength-s_temp->ref_length);
1845
1830
 
1846
1831
  if (s_temp->next_key_pos)
1847
1832
  {