← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_search.cc

  • Committer: Brian Aker
  • Date: 2009-04-17 01:45:33 UTC
  • Revision ID: brian@gaz-20090417014533-exdrtriab9zecqs2
Refactor get_variable to session

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_search.cc
17
17
 
18
18
#include "myisamdef.h"
19
19
#include <mystrings/m_ctype.h>
 
20
#include <mystrings/m_string.h>
 
21
#include <drizzled/util/test.h>
20
22
 
21
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
22
 
                                uchar *key, uchar *keypos,
23
 
                                uint *return_key_length);
 
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);
24
26
 
25
27
        /* Check index */
26
28
 
54
56
        */
55
57
 
56
58
int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
57
 
               uchar *key, uint key_len, uint nextflag, register my_off_t pos)
 
59
               unsigned char *key, uint32_t key_len, uint32_t nextflag, register my_off_t pos)
58
60
{
59
61
  bool last_key;
60
62
  int error,flag;
61
 
  uint nod_flag;
62
 
  uchar *keypos,*maxpos;
63
 
  uchar lastkey[MI_MAX_KEY_BUFF],*buff;
 
63
  uint32_t nod_flag;
 
64
  unsigned char *keypos,*maxpos;
 
65
  unsigned char lastkey[MI_MAX_KEY_BUFF],*buff;
64
66
 
65
67
  if (pos == HA_OFFSET_ERROR)
66
68
  {
112
114
  }
113
115
  if (pos != info->last_keypage)
114
116
  {
115
 
    uchar *old_buff=buff;
 
117
    unsigned char *old_buff=buff;
116
118
    if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,
117
119
                                 test(!(nextflag & SEARCH_SAVE_BUFF)))))
118
120
      goto err;
122
124
 
123
125
  if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
124
126
  {
125
 
    uint not_used[2];
 
127
    uint32_t not_used[2];
126
128
    if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
127
129
                         &info->lastkey_length))
128
130
      goto err;
165
167
        /* ret_pos point to where find or bigger key starts */
166
168
        /* ARGSUSED */
167
169
 
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)), bool *last_key)
 
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)
171
173
{
 
174
  (void)buff;
172
175
  register int start,mid,end,save_end;
173
176
  int flag;
174
 
  uint totlength,nod_flag,not_used[2];
 
177
  uint32_t totlength,nod_flag,not_used[2];
175
178
 
176
179
  totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
177
180
  start=0; mid=1;
225
228
    < 0         Not found.
226
229
*/
227
230
 
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, bool *last_key)
 
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)
231
234
{
232
235
  int flag=0;
233
 
  uint nod_flag,length=0,not_used[2];
234
 
  uchar t_buff[MI_MAX_KEY_BUFF],*end;
 
236
  uint32_t nod_flag,length=0,not_used[2];
 
237
  unsigned char t_buff[MI_MAX_KEY_BUFF],*end;
235
238
 
236
239
  end= page+mi_getint(page);
237
240
  nod_flag=mi_test_if_nod(page);
260
263
} /* _mi_seq_search */
261
264
 
262
265
 
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, bool *last_key)
 
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)
266
269
{
267
270
  /*
268
271
    my_flag is raw comparison result to be changed according to
270
273
    flag is the value returned by ha_key_cmp and as treated as final
271
274
  */
272
275
  int flag=0, my_flag=-1;
273
 
  uint nod_flag, length=0, len, matched, cmplen, kseg_len;
274
 
  uint prefix_len=0,suffix_len;
 
276
  uint32_t nod_flag, length=0, len, matched, cmplen, kseg_len;
 
277
  uint32_t prefix_len=0,suffix_len;
275
278
  int key_len_skip, seg_len_pack=0, key_len_left;
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;
 
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;
282
285
 
283
286
 
284
287
  t_buff[0]=0;                                  /* Avoid bugs */
312
315
 
313
316
  while (page < end)
314
317
  {
315
 
    uint packed= *page & 128;
 
318
    uint32_t packed= *page & 128;
316
319
 
317
320
    vseg=page;
318
321
    if (keyinfo->seg->length >= 127)
355
358
    saved_prefix_len=prefix_len;
356
359
 
357
360
    {
358
 
      uchar *from=vseg+suffix_len;
 
361
      unsigned char *from=vseg+suffix_len;
359
362
      HA_KEYSEG *keyseg;
360
 
      uint l;
 
363
      uint32_t l;
361
364
 
362
365
      for (keyseg=keyinfo->seg+1 ; keyseg->type ; keyseg++ )
363
366
      {
391
394
    if (matched >= prefix_len)
392
395
    {
393
396
      /* We have to compare. But we can still skip part of the key */
394
 
      uint  left;
395
 
      uchar *k=kseg+prefix_len;
 
397
      uint32_t  left;
 
398
      unsigned char *k=kseg+prefix_len;
396
399
 
397
400
      /*
398
401
        If prefix_len > cmplen then we are in the end-space comparison
438
441
          else
439
442
          {
440
443
            /* We have to compare k and vseg as if they were space extended */
441
 
            uchar *k_end= k+ (cmplen - len);
 
444
            unsigned char *k_end= k+ (cmplen - len);
442
445
            for ( ; k < k_end && *k == ' '; k++) ;
443
446
            if (k == k_end)
444
447
              goto cmp_rest;            /* should never happen */
445
 
            if (*k < (uchar) ' ')
 
448
            if (*k < (unsigned char) ' ')
446
449
            {
447
450
              my_flag= 1;               /* Compared string is smaller */
448
451
              break;
452
455
        }
453
456
        else if (len > cmplen)
454
457
        {
455
 
          uchar *vseg_end;
 
458
          unsigned char *vseg_end;
456
459
          if ((nextflag & SEARCH_PREFIX) && key_len_left == 0)
457
460
            goto fix_flag;
458
461
 
459
462
          /* We have to compare k and vseg as if they were space extended */
460
463
          for (vseg_end= vseg + (len-cmplen) ;
461
 
               vseg < vseg_end && *vseg == (uchar) ' ';
 
464
               vseg < vseg_end && *vseg == (unsigned char) ' ';
462
465
               vseg++, matched++) ;
463
466
          assert(vseg < vseg_end);
464
467
 
465
 
          if (*vseg > (uchar) ' ')
 
468
          if (*vseg > (unsigned char) ' ')
466
469
          {
467
470
            my_flag= 1;                 /* Compared string is smaller */
468
471
            break;
474
477
      cmp_rest:
475
478
          if (key_len_left>0)
476
479
          {
477
 
            uint not_used[2];
 
480
            uint32_t not_used[2];
478
481
            if ((flag = ha_key_cmp(keyinfo->seg+1,vseg,
479
482
                                   k, key_len_left, nextflag, not_used)) >= 0)
480
483
              break;
524
527
 
525
528
        /* Get pos to a key_block */
526
529
 
527
 
my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
 
530
my_off_t _mi_kpos(uint32_t nod_flag, unsigned char *after_key)
528
531
{
529
532
  after_key-=nod_flag;
530
533
  switch (nod_flag) {
560
563
 
561
564
        /* Save pos to a key_block */
562
565
 
563
 
void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
 
566
void _mi_kpointer(register MI_INFO *info, register unsigned char *buff, my_off_t pos)
564
567
{
565
568
  pos/=MI_MIN_KEY_BLOCK_LENGTH;
566
569
  switch (info->s->base.key_reflength) {
579
582
  case 4: mi_int4store(buff,pos); break;
580
583
  case 3: mi_int3store(buff,pos); break;
581
584
  case 2: mi_int2store(buff,(uint) pos); break;
582
 
  case 1: buff[0]= (uchar) pos; break;
 
585
  case 1: buff[0]= (unsigned char) pos; break;
583
586
  default: abort();                             /* impossible */
584
587
  }
585
588
} /* _mi_kpointer */
588
591
        /* Calc pos to a data-record from a key */
589
592
 
590
593
 
591
 
my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, uchar *after_key)
 
594
my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag, unsigned char *after_key)
592
595
{
593
596
  my_off_t pos;
594
597
  after_key-=(nod_flag + info->s->rec_reflength);
618
621
 
619
622
/* Calc position from a record pointer ( in delete link chain ) */
620
623
 
621
 
my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
 
624
my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
622
625
{
623
626
  my_off_t pos;
624
627
  switch (s->rec_reflength) {
653
656
#endif
654
657
  case 4:
655
658
    pos= (my_off_t) mi_uint4korr(ptr);
656
 
    if (pos == (my_off_t) (uint32_t) ~0L)
 
659
    if (pos == (my_off_t) UINT32_MAX)
657
660
      return  HA_OFFSET_ERROR;
658
661
    break;
659
662
  case 3:
676
679
 
677
680
        /* save position to record */
678
681
 
679
 
void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
 
682
void _mi_dpointer(MI_INFO *info, unsigned char *buff, my_off_t pos)
680
683
{
681
684
  if (!(info->s->options &
682
685
        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
715
718
 
716
719
        /* same as _mi_get_key but used with fixed length keys */
717
720
 
718
 
uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
719
 
                       register uchar **page, register uchar *key)
 
721
uint32_t _mi_get_static_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
 
722
                       register unsigned char **page, register unsigned char *key)
720
723
{
721
724
  memcpy(key, *page, keyinfo->keylength+nod_flag);
722
725
  *page+=keyinfo->keylength+nod_flag;
738
741
    key_length + length of data pointer
739
742
*/
740
743
 
741
 
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
742
 
                      register uchar **page_pos, register uchar *key)
 
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)
743
746
{
744
747
  register HA_KEYSEG *keyseg;
745
 
  uchar *start_key,*page=*page_pos;
746
 
  uint length;
 
748
  unsigned char *start_key,*page=*page_pos;
 
749
  uint32_t length;
747
750
 
748
751
  start_key=key;
749
752
  for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
751
754
    if (keyseg->flag & HA_PACK_KEY)
752
755
    {
753
756
      /* key with length, packed to previous key */
754
 
      uchar *start=key;
755
 
      uint packed= *page & 128,tot_length,rest_length;
 
757
      unsigned char *start=key;
 
758
      uint32_t packed= *page & 128,tot_length,rest_length;
756
759
      if (keyseg->length >= 127)
757
760
      {
758
761
        length=mi_uint2korr(page) & 32767;
803
806
        }
804
807
        else if (tot_length < 255 && *start == 255)
805
808
        {
806
 
          memcpy(key+1,key+3,length);
 
809
          memmove(key+1,key+3,length);
807
810
          *key=tot_length;
808
811
          key+=1+length;
809
812
        }
847
850
      if (keyseg->flag &
848
851
          (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
849
852
      {
850
 
        uchar *tmp=page;
 
853
        unsigned char *tmp=page;
851
854
        get_key_length(length,tmp);
852
855
        length+=(uint) (tmp-page);
853
856
      }
859
862
    page+=length;
860
863
  }
861
864
  length=keyseg->length+nod_flag;
862
 
  memcpy(key,page,length);
 
865
  memmove(key,page,length);
863
866
  *page_pos= page+length;
864
867
  return ((uint) (key-start_key)+keyseg->length);
865
868
} /* _mi_get_pack_key */
868
871
 
869
872
/* key that is packed relatively to previous */
870
873
 
871
 
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
872
 
                             register uchar **page_pos, register uchar *key)
 
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)
873
876
{
874
877
  register HA_KEYSEG *keyseg;
875
 
  uchar *start_key,*page,*page_end,*from,*from_end;
876
 
  uint length,tmp;
 
878
  unsigned char *start_key,*page,*page_end,*from,*from_end;
 
879
  uint32_t length,tmp;
877
880
 
878
881
  page= *page_pos;
879
882
  page_end=page+MI_MAX_KEY_BUFF+1;
994
997
        /* Get key at position without knowledge of previous key */
995
998
        /* Returns pointer to next key */
996
999
 
997
 
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
998
 
                   uchar *key, uchar *keypos, uint *return_key_length)
 
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)
999
1002
{
1000
 
  uint nod_flag;
 
1003
  uint32_t nod_flag;
1001
1004
 
1002
1005
  nod_flag=mi_test_if_nod(page);
1003
1006
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1004
1007
  {
1005
 
    memcpy(key,keypos,keyinfo->keylength+nod_flag);
 
1008
    memmove(key,keypos,keyinfo->keylength+nod_flag);
1006
1009
    return(keypos+keyinfo->keylength+nod_flag);
1007
1010
  }
1008
1011
  else
1027
1030
        /* Get key at position without knowledge of previous key */
1028
1031
        /* Returns 0 if ok */
1029
1032
 
1030
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
1031
 
                                uchar *key, uchar *keypos,
1032
 
                                uint *return_key_length)
 
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)
1033
1036
{
1034
 
  uint nod_flag;
 
1037
  uint32_t nod_flag;
1035
1038
 
1036
1039
  nod_flag=mi_test_if_nod(page);
1037
1040
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1038
1041
  {
1039
1042
    *return_key_length=keyinfo->keylength;
1040
 
    memcpy(key, keypos - *return_key_length-nod_flag, *return_key_length);
 
1043
    memmove(key, keypos - *return_key_length-nod_flag, *return_key_length);
1041
1044
    return(0);
1042
1045
  }
1043
1046
  else
1063
1066
        /* Get last key from key-page */
1064
1067
        /* Return pointer to where key starts */
1065
1068
 
1066
 
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
1067
 
                        uchar *lastkey, uchar *endpos, uint *return_key_length)
 
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
1071
{
1069
 
  uint nod_flag;
1070
 
  uchar *lastpos;
 
1072
  uint32_t nod_flag;
 
1073
  unsigned char *lastpos;
1071
1074
 
1072
1075
  nod_flag=mi_test_if_nod(page);
1073
1076
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1075
1078
    lastpos=endpos-keyinfo->keylength-nod_flag;
1076
1079
    *return_key_length=keyinfo->keylength;
1077
1080
    if (lastpos > page)
1078
 
      memcpy(lastkey,lastpos,keyinfo->keylength+nod_flag);
 
1081
      memmove(lastkey,lastpos,keyinfo->keylength+nod_flag);
1079
1082
  }
1080
1083
  else
1081
1084
  {
1099
1102
 
1100
1103
        /* Calculate length of key */
1101
1104
 
1102
 
uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
 
1105
uint32_t _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
1103
1106
{
1104
1107
  register HA_KEYSEG *keyseg;
1105
 
  uchar *start;
 
1108
  unsigned char *start;
1106
1109
 
1107
1110
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1108
1111
    return (keyinfo->keylength);
1115
1118
        continue;
1116
1119
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1117
1120
    {
1118
 
      uint length;
 
1121
      uint32_t length;
1119
1122
      get_key_length(length,key);
1120
1123
      key+=length;
1121
1124
    }
1134
1137
  after '0xDF' but find 'ss'
1135
1138
*/
1136
1139
 
1137
 
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
 
1140
uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
1138
1141
                        HA_KEYSEG *end)
1139
1142
{
1140
1143
  register HA_KEYSEG *keyseg;
1141
 
  uchar *start= key;
 
1144
  unsigned char *start= key;
1142
1145
 
1143
1146
  for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
1144
1147
  {
1147
1150
        continue;
1148
1151
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1149
1152
    {
1150
 
      uint length;
 
1153
      uint32_t length;
1151
1154
      get_key_length(length,key);
1152
1155
      key+=length;
1153
1156
    }
1159
1162
 
1160
1163
        /* Move a key */
1161
1164
 
1162
 
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
 
1165
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
1163
1166
{
1164
 
  register uint length;
 
1167
  register uint32_t length;
1165
1168
  length= _mi_keylength(keyinfo, from);
1166
1169
  memcpy(to, from, length);
1167
1170
  return to+length;
1171
1174
        /* This can't be used when database is touched after last read */
1172
1175
 
1173
1176
int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1174
 
                    uchar *key, uint key_length, uint nextflag, my_off_t pos)
 
1177
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, my_off_t pos)
1175
1178
{
1176
1179
  int error;
1177
 
  uint nod_flag;
1178
 
  uchar lastkey[MI_MAX_KEY_BUFF];
 
1180
  uint32_t nod_flag;
 
1181
  unsigned char lastkey[MI_MAX_KEY_BUFF];
1179
1182
 
1180
1183
  /* Force full read if we are at last key or if we are not on a leaf
1181
1184
     and the key tree has changed since we used it last time
1218
1221
  }
1219
1222
  else                                                  /* Previous key */
1220
1223
  {
1221
 
    uint length;
 
1224
    uint32_t length;
1222
1225
    /* Find start of previous key */
1223
1226
    info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
1224
1227
                                      info->int_keypos, &length);
1249
1252
int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1250
1253
                     register my_off_t pos)
1251
1254
{
1252
 
  uint nod_flag;
1253
 
  uchar *page;
 
1255
  uint32_t nod_flag;
 
1256
  unsigned char *page;
1254
1257
 
1255
1258
  if (pos == HA_OFFSET_ERROR)
1256
1259
  {
1291
1294
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1292
1295
                    register my_off_t pos)
1293
1296
{
1294
 
  uint nod_flag;
1295
 
  uchar *buff,*page;
 
1297
  uint32_t nod_flag;
 
1298
  unsigned char *buff,*page;
1296
1299
 
1297
1300
  if (pos == HA_OFFSET_ERROR)
1298
1301
  {
1344
1347
/* Static length key */
1345
1348
 
1346
1349
int
1347
 
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
1348
 
                           uchar *next_pos  __attribute__((unused)),
1349
 
                           uchar *org_key  __attribute__((unused)),
1350
 
                           uchar *prev_key __attribute__((unused)),
1351
 
                           uchar *key, MI_KEY_PARAM *s_temp)
 
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)
1352
1355
{
 
1356
  (void)next_pos;
 
1357
  (void)org_key;
 
1358
  (void)prev_key;
1353
1359
  s_temp->key=key;
1354
1360
  return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
1355
1361
}
1357
1363
/* Variable length key */
1358
1364
 
1359
1365
int
1360
 
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
1361
 
                        uchar *next_pos  __attribute__((unused)),
1362
 
                        uchar *org_key  __attribute__((unused)),
1363
 
                        uchar *prev_key __attribute__((unused)),
1364
 
                        uchar *key, MI_KEY_PARAM *s_temp)
 
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)
1365
1371
{
 
1372
  (void)next_pos;
 
1373
  (void)org_key;
 
1374
  (void)prev_key;
1366
1375
  s_temp->key=key;
1367
1376
  return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
1368
1377
}
1387
1396
*/
1388
1397
 
1389
1398
int
1390
 
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
1391
 
                             uchar *org_key, uchar *prev_key, uchar *key,
 
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
1404
                             MI_KEY_PARAM *s_temp)
1393
1405
{
1394
1406
  register HA_KEYSEG *keyseg;
1395
1407
  int length;
1396
 
  uint key_length,ref_length,org_key_length=0,
 
1408
  uint32_t key_length,ref_length,org_key_length=0,
1397
1409
       length_pack,new_key_length,diff_flag,pack_marker;
1398
 
  uchar *start,*end,*key_end,*sort_order;
 
1410
  unsigned char *start,*end,*key_end,*sort_order;
1399
1411
  bool same_length;
1400
1412
 
1401
1413
  length_pack=s_temp->ref_length=s_temp->n_ref_length=s_temp->n_length=0;
1511
1523
        /* If something after that hasn't length=0, test if we can combine */
1512
1524
  if ((s_temp->next_key_pos=next_key))
1513
1525
  {
1514
 
    uint packed,n_length;
 
1526
    uint32_t packed,n_length;
1515
1527
 
1516
1528
    packed = *next_key & 128;
1517
1529
    if (diff_flag == 2)
1526
1538
 
1527
1539
    if (n_length || packed)             /* Don't pack 0 length keys */
1528
1540
    {
1529
 
      uint next_length_pack, new_ref_length=s_temp->ref_length;
 
1541
      uint32_t next_length_pack, new_ref_length=s_temp->ref_length;
1530
1542
 
1531
1543
      if (packed)
1532
1544
      {
1594
1606
        }
1595
1607
        if (ref_length+pack_marker > new_ref_length)
1596
1608
        {
1597
 
          uint new_pack_length=new_ref_length-pack_marker;
 
1609
          uint32_t new_pack_length=new_ref_length-pack_marker;
1598
1610
          /* We must copy characters from the original key to the next key */
1599
1611
          s_temp->part_of_prev_key= new_ref_length;
1600
1612
          s_temp->prev_length=      ref_length - new_pack_length;
1612
1624
      }
1613
1625
 
1614
1626
      {
1615
 
        uint tmp_length;
 
1627
        uint32_t tmp_length;
1616
1628
        key=(start+=ref_length);
1617
1629
        if (key+n_length < key_end)             /* Normalize length based */
1618
1630
          key_end=key+n_length;
1659
1671
/* Length of key which is prefix compressed */
1660
1672
 
1661
1673
int
1662
 
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
1663
 
                             uchar *org_key, uchar *prev_key, uchar *key,
 
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
1676
                             MI_KEY_PARAM *s_temp)
1665
1677
{
1666
 
  uint length,key_length,ref_length;
 
1678
  uint32_t length,key_length,ref_length;
1667
1679
 
1668
1680
  s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
1669
1681
#ifdef HAVE_purify
1678
1690
      As keys may be identical when running a sort in myisamchk, we
1679
1691
      have to guard against the case where keys may be identical
1680
1692
    */
1681
 
    uchar *end;
 
1693
    unsigned char *end;
1682
1694
    end=key+key_length;
1683
1695
    for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
1684
1696
    s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
1693
1705
  if ((s_temp->next_key_pos=next_key))          /* If another key after */
1694
1706
  {
1695
1707
    /* pack key against next key */
1696
 
    uint next_length,next_length_pack;
 
1708
    uint32_t next_length,next_length_pack;
1697
1709
    get_key_pack_length(next_length,next_length_pack,next_key);
1698
1710
 
1699
1711
    /* If first key and next key is packed (only on delete) */
1700
1712
    if (!prev_key && org_key && next_length)
1701
1713
    {
1702
 
      uchar *end;
 
1714
      unsigned char *end;
1703
1715
      for (key= s_temp->key, end=key+next_length ;
1704
1716
           *key == *org_key && key < end;
1705
1717
           key++,org_key++) ;
1740
1752
 
1741
1753
/* store key without compression */
1742
1754
 
1743
 
void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
1744
 
                          register uchar *key_pos,
 
1755
void _mi_store_static_key(MI_KEYDEF *keyinfo,
 
1756
                          register unsigned char *key_pos,
1745
1757
                          register MI_KEY_PARAM *s_temp)
1746
1758
{
 
1759
  (void)keyinfo;
1747
1760
  memcpy(key_pos, s_temp->key, s_temp->totlength);
1748
1761
}
1749
1762
 
1751
1764
/* store variable length key with prefix compression */
1752
1765
 
1753
1766
#define store_pack_length(test,pos,length) { \
1754
 
  if (test) { *((pos)++) = (uchar) (length); } else \
1755
 
  { *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length);  } }
1756
 
 
1757
 
 
1758
 
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
1759
 
                            register uchar *key_pos,
 
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,
1760
1773
                            register MI_KEY_PARAM *s_temp)
1761
1774
{
1762
 
  uint length;
1763
 
  uchar *start;
 
1775
  (void)keyinfo;
 
1776
  uint32_t length;
 
1777
  unsigned char *start;
1764
1778
 
1765
1779
  start=key_pos;
1766
1780
 
1779
1793
  }
1780
1794
  assert(key_pos >= start);
1781
1795
  length= s_temp->totlength - (key_pos - start);
1782
 
  memcpy(key_pos, s_temp->key, length);
 
1796
  memmove(key_pos, s_temp->key, length);
1783
1797
 
1784
1798
  if (!s_temp->next_key_pos)                    /* No following key */
1785
1799
    return;
1819
1833
 
1820
1834
/* variable length key with prefix compression */
1821
1835
 
1822
 
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
1823
 
                            register uchar *key_pos,
 
1836
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,
 
1837
                            register unsigned char *key_pos,
1824
1838
                            register MI_KEY_PARAM *s_temp)
1825
1839
{
 
1840
  (void)keyinfo;
1826
1841
  assert(s_temp->totlength >= s_temp->ref_length);
1827
1842
  store_key_length_inc(key_pos,s_temp->ref_length);
1828
1843
  memcpy(key_pos,s_temp->key+s_temp->ref_length,