← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_search.c

  • Committer: Andy Lester
  • Date: 2008-08-09 05:13:22 UTC
  • mto: (266.1.29 use-replace-funcs)
  • mto: This revision was merged to the branch mainline in revision 287.
  • Revision ID: andy@petdance.com-20080809051322-dzas70no2mv6c9i5
removed incorrect comment

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_search.c
17
17
 
18
18
#include "myisamdef.h"
19
19
#include <mystrings/m_ctype.h>
20
 
#include <drizzled/util/test.h>
21
20
 
22
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
23
 
                                unsigned char *key, unsigned char *keypos,
24
 
                                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);
25
24
 
26
25
        /* Check index */
27
26
 
55
54
        */
56
55
 
57
56
int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
58
 
               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)
59
58
{
60
 
  bool last_key;
 
59
  my_bool last_key;
61
60
  int error,flag;
62
 
  uint32_t nod_flag;
63
 
  unsigned char *keypos,*maxpos;
64
 
  unsigned char lastkey[MI_MAX_KEY_BUFF],*buff;
 
61
  uint nod_flag;
 
62
  uchar *keypos,*maxpos;
 
63
  uchar lastkey[MI_MAX_KEY_BUFF],*buff;
65
64
 
66
65
  if (pos == HA_OFFSET_ERROR)
67
66
  {
113
112
  }
114
113
  if (pos != info->last_keypage)
115
114
  {
116
 
    unsigned char *old_buff=buff;
 
115
    uchar *old_buff=buff;
117
116
    if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,
118
117
                                 test(!(nextflag & SEARCH_SAVE_BUFF)))))
119
118
      goto err;
123
122
 
124
123
  if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
125
124
  {
126
 
    uint32_t not_used[2];
 
125
    uint not_used[2];
127
126
    if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
128
127
                         &info->lastkey_length))
129
128
      goto err;
166
165
        /* ret_pos point to where find or bigger key starts */
167
166
        /* ARGSUSED */
168
167
 
169
 
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
170
 
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
171
 
                   unsigned char *buff __attribute__((unused)), 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)
172
171
{
173
172
  register int start,mid,end,save_end;
174
173
  int flag;
175
 
  uint32_t totlength,nod_flag,not_used[2];
 
174
  uint totlength,nod_flag,not_used[2];
176
175
 
177
176
  totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
178
177
  start=0; mid=1;
226
225
    < 0         Not found.
227
226
*/
228
227
 
229
 
int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
230
 
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
231
 
                   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)
232
231
{
233
232
  int flag=0;
234
 
  uint32_t nod_flag,length=0,not_used[2];
235
 
  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;
236
235
 
237
236
  end= page+mi_getint(page);
238
237
  nod_flag=mi_test_if_nod(page);
261
260
} /* _mi_seq_search */
262
261
 
263
262
 
264
 
int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
265
 
                      unsigned char *key, uint32_t key_len, uint32_t nextflag, unsigned char **ret_pos,
266
 
                      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)
267
266
{
268
267
  /*
269
268
    my_flag is raw comparison result to be changed according to
271
270
    flag is the value returned by ha_key_cmp and as treated as final
272
271
  */
273
272
  int flag=0, my_flag=-1;
274
 
  uint32_t nod_flag, length=0, len, matched, cmplen, kseg_len;
275
 
  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;
276
275
  int key_len_skip, seg_len_pack=0, key_len_left;
277
 
  unsigned char *end, *kseg, *vseg;
278
 
  unsigned char *sort_order=keyinfo->seg->charset->sort_order;
279
 
  unsigned char tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
280
 
  unsigned char *saved_from=NULL, *saved_to=NULL, *saved_vseg=NULL;
281
 
  uint32_t  saved_length=0, saved_prefix_len=0;
282
 
  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;
283
282
 
284
283
 
285
284
  t_buff[0]=0;                                  /* Avoid bugs */
313
312
 
314
313
  while (page < end)
315
314
  {
316
 
    uint32_t packed= *page & 128;
 
315
    uint packed= *page & 128;
317
316
 
318
317
    vseg=page;
319
318
    if (keyinfo->seg->length >= 127)
356
355
    saved_prefix_len=prefix_len;
357
356
 
358
357
    {
359
 
      unsigned char *from=vseg+suffix_len;
 
358
      uchar *from=vseg+suffix_len;
360
359
      HA_KEYSEG *keyseg;
361
 
      uint32_t l;
 
360
      uint l;
362
361
 
363
362
      for (keyseg=keyinfo->seg+1 ; keyseg->type ; keyseg++ )
364
363
      {
392
391
    if (matched >= prefix_len)
393
392
    {
394
393
      /* We have to compare. But we can still skip part of the key */
395
 
      uint32_t  left;
396
 
      unsigned char *k=kseg+prefix_len;
 
394
      uint  left;
 
395
      uchar *k=kseg+prefix_len;
397
396
 
398
397
      /*
399
398
        If prefix_len > cmplen then we are in the end-space comparison
439
438
          else
440
439
          {
441
440
            /* We have to compare k and vseg as if they were space extended */
442
 
            unsigned char *k_end= k+ (cmplen - len);
 
441
            uchar *k_end= k+ (cmplen - len);
443
442
            for ( ; k < k_end && *k == ' '; k++) ;
444
443
            if (k == k_end)
445
444
              goto cmp_rest;            /* should never happen */
446
 
            if (*k < (unsigned char) ' ')
 
445
            if (*k < (uchar) ' ')
447
446
            {
448
447
              my_flag= 1;               /* Compared string is smaller */
449
448
              break;
453
452
        }
454
453
        else if (len > cmplen)
455
454
        {
456
 
          unsigned char *vseg_end;
 
455
          uchar *vseg_end;
457
456
          if ((nextflag & SEARCH_PREFIX) && key_len_left == 0)
458
457
            goto fix_flag;
459
458
 
460
459
          /* We have to compare k and vseg as if they were space extended */
461
460
          for (vseg_end= vseg + (len-cmplen) ;
462
 
               vseg < vseg_end && *vseg == (unsigned char) ' ';
 
461
               vseg < vseg_end && *vseg == (uchar) ' ';
463
462
               vseg++, matched++) ;
464
463
          assert(vseg < vseg_end);
465
464
 
466
 
          if (*vseg > (unsigned char) ' ')
 
465
          if (*vseg > (uchar) ' ')
467
466
          {
468
467
            my_flag= 1;                 /* Compared string is smaller */
469
468
            break;
475
474
      cmp_rest:
476
475
          if (key_len_left>0)
477
476
          {
478
 
            uint32_t not_used[2];
 
477
            uint not_used[2];
479
478
            if ((flag = ha_key_cmp(keyinfo->seg+1,vseg,
480
479
                                   k, key_len_left, nextflag, not_used)) >= 0)
481
480
              break;
525
524
 
526
525
        /* Get pos to a key_block */
527
526
 
528
 
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)
529
528
{
530
529
  after_key-=nod_flag;
531
530
  switch (nod_flag) {
561
560
 
562
561
        /* Save pos to a key_block */
563
562
 
564
 
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)
565
564
{
566
565
  pos/=MI_MIN_KEY_BLOCK_LENGTH;
567
566
  switch (info->s->base.key_reflength) {
580
579
  case 4: mi_int4store(buff,pos); break;
581
580
  case 3: mi_int3store(buff,pos); break;
582
581
  case 2: mi_int2store(buff,(uint) pos); break;
583
 
  case 1: buff[0]= (unsigned char) pos; break;
 
582
  case 1: buff[0]= (uchar) pos; break;
584
583
  default: abort();                             /* impossible */
585
584
  }
586
585
} /* _mi_kpointer */
589
588
        /* Calc pos to a data-record from a key */
590
589
 
591
590
 
592
 
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)
593
592
{
594
593
  my_off_t pos;
595
594
  after_key-=(nod_flag + info->s->rec_reflength);
619
618
 
620
619
/* Calc position from a record pointer ( in delete link chain ) */
621
620
 
622
 
my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
 
621
my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
623
622
{
624
623
  my_off_t pos;
625
624
  switch (s->rec_reflength) {
654
653
#endif
655
654
  case 4:
656
655
    pos= (my_off_t) mi_uint4korr(ptr);
657
 
    if (pos == (my_off_t) UINT32_MAX)
 
656
    if (pos == (my_off_t) (uint32_t) ~0L)
658
657
      return  HA_OFFSET_ERROR;
659
658
    break;
660
659
  case 3:
677
676
 
678
677
        /* save position to record */
679
678
 
680
 
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)
681
680
{
682
681
  if (!(info->s->options &
683
682
        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
716
715
 
717
716
        /* same as _mi_get_key but used with fixed length keys */
718
717
 
719
 
uint32_t _mi_get_static_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
720
 
                       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)
721
720
{
722
721
  memcpy(key, *page, keyinfo->keylength+nod_flag);
723
722
  *page+=keyinfo->keylength+nod_flag;
739
738
    key_length + length of data pointer
740
739
*/
741
740
 
742
 
uint32_t _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
743
 
                      register unsigned char **page_pos, register unsigned char *key)
 
741
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
742
                      register uchar **page_pos, register uchar *key)
744
743
{
745
744
  register HA_KEYSEG *keyseg;
746
 
  unsigned char *start_key,*page=*page_pos;
747
 
  uint32_t length;
 
745
  uchar *start_key,*page=*page_pos;
 
746
  uint length;
748
747
 
749
748
  start_key=key;
750
749
  for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
752
751
    if (keyseg->flag & HA_PACK_KEY)
753
752
    {
754
753
      /* key with length, packed to previous key */
755
 
      unsigned char *start=key;
756
 
      uint32_t packed= *page & 128,tot_length,rest_length;
 
754
      uchar *start=key;
 
755
      uint packed= *page & 128,tot_length,rest_length;
757
756
      if (keyseg->length >= 127)
758
757
      {
759
758
        length=mi_uint2korr(page) & 32767;
848
847
      if (keyseg->flag &
849
848
          (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
850
849
      {
851
 
        unsigned char *tmp=page;
 
850
        uchar *tmp=page;
852
851
        get_key_length(length,tmp);
853
852
        length+=(uint) (tmp-page);
854
853
      }
869
868
 
870
869
/* key that is packed relatively to previous */
871
870
 
872
 
uint32_t _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
873
 
                             register unsigned char **page_pos, register unsigned char *key)
 
871
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
872
                             register uchar **page_pos, register uchar *key)
874
873
{
875
874
  register HA_KEYSEG *keyseg;
876
 
  unsigned char *start_key,*page,*page_end,*from,*from_end;
877
 
  uint32_t length,tmp;
 
875
  uchar *start_key,*page,*page_end,*from,*from_end;
 
876
  uint length,tmp;
878
877
 
879
878
  page= *page_pos;
880
879
  page_end=page+MI_MAX_KEY_BUFF+1;
995
994
        /* Get key at position without knowledge of previous key */
996
995
        /* Returns pointer to next key */
997
996
 
998
 
unsigned char *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
999
 
                   unsigned char *key, unsigned char *keypos, uint32_t *return_key_length)
 
997
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
998
                   uchar *key, uchar *keypos, uint *return_key_length)
1000
999
{
1001
 
  uint32_t nod_flag;
 
1000
  uint nod_flag;
1002
1001
 
1003
1002
  nod_flag=mi_test_if_nod(page);
1004
1003
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1028
1027
        /* Get key at position without knowledge of previous key */
1029
1028
        /* Returns 0 if ok */
1030
1029
 
1031
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1032
 
                                unsigned char *key, unsigned char *keypos,
1033
 
                                uint32_t *return_key_length)
 
1030
static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
1031
                                uchar *key, uchar *keypos,
 
1032
                                uint *return_key_length)
1034
1033
{
1035
 
  uint32_t nod_flag;
 
1034
  uint nod_flag;
1036
1035
 
1037
1036
  nod_flag=mi_test_if_nod(page);
1038
1037
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1064
1063
        /* Get last key from key-page */
1065
1064
        /* Return pointer to where key starts */
1066
1065
 
1067
 
unsigned char *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1068
 
                        unsigned char *lastkey, unsigned char *endpos, uint32_t *return_key_length)
 
1066
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
1067
                        uchar *lastkey, uchar *endpos, uint *return_key_length)
1069
1068
{
1070
 
  uint32_t nod_flag;
1071
 
  unsigned char *lastpos;
 
1069
  uint nod_flag;
 
1070
  uchar *lastpos;
1072
1071
 
1073
1072
  nod_flag=mi_test_if_nod(page);
1074
1073
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1100
1099
 
1101
1100
        /* Calculate length of key */
1102
1101
 
1103
 
uint32_t _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
 
1102
uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
1104
1103
{
1105
1104
  register HA_KEYSEG *keyseg;
1106
 
  unsigned char *start;
 
1105
  uchar *start;
1107
1106
 
1108
1107
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1109
1108
    return (keyinfo->keylength);
1116
1115
        continue;
1117
1116
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1118
1117
    {
1119
 
      uint32_t length;
 
1118
      uint length;
1120
1119
      get_key_length(length,key);
1121
1120
      key+=length;
1122
1121
    }
1135
1134
  after '0xDF' but find 'ss'
1136
1135
*/
1137
1136
 
1138
 
uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
 
1137
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
1139
1138
                        HA_KEYSEG *end)
1140
1139
{
1141
1140
  register HA_KEYSEG *keyseg;
1142
 
  unsigned char *start= key;
 
1141
  uchar *start= key;
1143
1142
 
1144
1143
  for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
1145
1144
  {
1148
1147
        continue;
1149
1148
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1150
1149
    {
1151
 
      uint32_t length;
 
1150
      uint length;
1152
1151
      get_key_length(length,key);
1153
1152
      key+=length;
1154
1153
    }
1160
1159
 
1161
1160
        /* Move a key */
1162
1161
 
1163
 
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
 
1162
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
1164
1163
{
1165
 
  register uint32_t length;
 
1164
  register uint length;
1166
1165
  length= _mi_keylength(keyinfo, from);
1167
1166
  memcpy(to, from, length);
1168
1167
  return to+length;
1172
1171
        /* This can't be used when database is touched after last read */
1173
1172
 
1174
1173
int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1175
 
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, my_off_t pos)
 
1174
                    uchar *key, uint key_length, uint nextflag, my_off_t pos)
1176
1175
{
1177
1176
  int error;
1178
 
  uint32_t nod_flag;
1179
 
  unsigned char lastkey[MI_MAX_KEY_BUFF];
 
1177
  uint nod_flag;
 
1178
  uchar lastkey[MI_MAX_KEY_BUFF];
1180
1179
 
1181
1180
  /* Force full read if we are at last key or if we are not on a leaf
1182
1181
     and the key tree has changed since we used it last time
1219
1218
  }
1220
1219
  else                                                  /* Previous key */
1221
1220
  {
1222
 
    uint32_t length;
 
1221
    uint length;
1223
1222
    /* Find start of previous key */
1224
1223
    info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
1225
1224
                                      info->int_keypos, &length);
1250
1249
int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1251
1250
                     register my_off_t pos)
1252
1251
{
1253
 
  uint32_t nod_flag;
1254
 
  unsigned char *page;
 
1252
  uint nod_flag;
 
1253
  uchar *page;
1255
1254
 
1256
1255
  if (pos == HA_OFFSET_ERROR)
1257
1256
  {
1292
1291
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1293
1292
                    register my_off_t pos)
1294
1293
{
1295
 
  uint32_t nod_flag;
1296
 
  unsigned char *buff,*page;
 
1294
  uint nod_flag;
 
1295
  uchar *buff,*page;
1297
1296
 
1298
1297
  if (pos == HA_OFFSET_ERROR)
1299
1298
  {
1345
1344
/* Static length key */
1346
1345
 
1347
1346
int
1348
 
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1349
 
                           unsigned char *next_pos  __attribute__((unused)),
1350
 
                           unsigned char *org_key  __attribute__((unused)),
1351
 
                           unsigned char *prev_key __attribute__((unused)),
1352
 
                           unsigned char *key, MI_KEY_PARAM *s_temp)
 
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)
1353
1352
{
1354
1353
  s_temp->key=key;
1355
1354
  return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
1358
1357
/* Variable length key */
1359
1358
 
1360
1359
int
1361
 
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1362
 
                        unsigned char *next_pos  __attribute__((unused)),
1363
 
                        unsigned char *org_key  __attribute__((unused)),
1364
 
                        unsigned char *prev_key __attribute__((unused)),
1365
 
                        unsigned char *key, MI_KEY_PARAM *s_temp)
 
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
1365
{
1367
1366
  s_temp->key=key;
1368
1367
  return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
1388
1387
*/
1389
1388
 
1390
1389
int
1391
 
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *next_key,
1392
 
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
 
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,
1393
1392
                             MI_KEY_PARAM *s_temp)
1394
1393
{
1395
1394
  register HA_KEYSEG *keyseg;
1396
1395
  int length;
1397
 
  uint32_t key_length,ref_length,org_key_length=0,
 
1396
  uint key_length,ref_length,org_key_length=0,
1398
1397
       length_pack,new_key_length,diff_flag,pack_marker;
1399
 
  unsigned char *start,*end,*key_end,*sort_order;
1400
 
  bool same_length;
 
1398
  uchar *start,*end,*key_end,*sort_order;
 
1399
  my_bool same_length;
1401
1400
 
1402
1401
  length_pack=s_temp->ref_length=s_temp->n_ref_length=s_temp->n_length=0;
1403
1402
  same_length=0; keyseg=keyinfo->seg;
1512
1511
        /* If something after that hasn't length=0, test if we can combine */
1513
1512
  if ((s_temp->next_key_pos=next_key))
1514
1513
  {
1515
 
    uint32_t packed,n_length;
 
1514
    uint packed,n_length;
1516
1515
 
1517
1516
    packed = *next_key & 128;
1518
1517
    if (diff_flag == 2)
1527
1526
 
1528
1527
    if (n_length || packed)             /* Don't pack 0 length keys */
1529
1528
    {
1530
 
      uint32_t next_length_pack, new_ref_length=s_temp->ref_length;
 
1529
      uint next_length_pack, new_ref_length=s_temp->ref_length;
1531
1530
 
1532
1531
      if (packed)
1533
1532
      {
1595
1594
        }
1596
1595
        if (ref_length+pack_marker > new_ref_length)
1597
1596
        {
1598
 
          uint32_t new_pack_length=new_ref_length-pack_marker;
 
1597
          uint new_pack_length=new_ref_length-pack_marker;
1599
1598
          /* We must copy characters from the original key to the next key */
1600
1599
          s_temp->part_of_prev_key= new_ref_length;
1601
1600
          s_temp->prev_length=      ref_length - new_pack_length;
1613
1612
      }
1614
1613
 
1615
1614
      {
1616
 
        uint32_t tmp_length;
 
1615
        uint tmp_length;
1617
1616
        key=(start+=ref_length);
1618
1617
        if (key+n_length < key_end)             /* Normalize length based */
1619
1618
          key_end=key+n_length;
1660
1659
/* Length of key which is prefix compressed */
1661
1660
 
1662
1661
int
1663
 
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *next_key,
1664
 
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
 
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,
1665
1664
                             MI_KEY_PARAM *s_temp)
1666
1665
{
1667
 
  uint32_t length,key_length,ref_length;
 
1666
  uint length,key_length,ref_length;
1668
1667
 
1669
1668
  s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
1670
1669
#ifdef HAVE_purify
1679
1678
      As keys may be identical when running a sort in myisamchk, we
1680
1679
      have to guard against the case where keys may be identical
1681
1680
    */
1682
 
    unsigned char *end;
 
1681
    uchar *end;
1683
1682
    end=key+key_length;
1684
1683
    for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
1685
1684
    s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
1694
1693
  if ((s_temp->next_key_pos=next_key))          /* If another key after */
1695
1694
  {
1696
1695
    /* pack key against next key */
1697
 
    uint32_t next_length,next_length_pack;
 
1696
    uint next_length,next_length_pack;
1698
1697
    get_key_pack_length(next_length,next_length_pack,next_key);
1699
1698
 
1700
1699
    /* If first key and next key is packed (only on delete) */
1701
1700
    if (!prev_key && org_key && next_length)
1702
1701
    {
1703
 
      unsigned char *end;
 
1702
      uchar *end;
1704
1703
      for (key= s_temp->key, end=key+next_length ;
1705
1704
           *key == *org_key && key < end;
1706
1705
           key++,org_key++) ;
1742
1741
/* store key without compression */
1743
1742
 
1744
1743
void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
1745
 
                          register unsigned char *key_pos,
 
1744
                          register uchar *key_pos,
1746
1745
                          register MI_KEY_PARAM *s_temp)
1747
1746
{
1748
1747
  memcpy(key_pos, s_temp->key, s_temp->totlength);
1752
1751
/* store variable length key with prefix compression */
1753
1752
 
1754
1753
#define store_pack_length(test,pos,length) { \
1755
 
  if (test) { *((pos)++) = (unsigned char) (length); } else \
1756
 
  { *((pos)++) = (unsigned char) ((length) >> 8); *((pos)++) = (unsigned char) (length);  } }
 
1754
  if (test) { *((pos)++) = (uchar) (length); } else \
 
1755
  { *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length);  } }
1757
1756
 
1758
1757
 
1759
1758
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
1760
 
                            register unsigned char *key_pos,
 
1759
                            register uchar *key_pos,
1761
1760
                            register MI_KEY_PARAM *s_temp)
1762
1761
{
1763
 
  uint32_t length;
1764
 
  unsigned char *start;
 
1762
  uint length;
 
1763
  uchar *start;
1765
1764
 
1766
1765
  start=key_pos;
1767
1766
 
1821
1820
/* variable length key with prefix compression */
1822
1821
 
1823
1822
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
1824
 
                            register unsigned char *key_pos,
 
1823
                            register uchar *key_pos,
1825
1824
                            register MI_KEY_PARAM *s_temp)
1826
1825
{
1827
1826
  assert(s_temp->totlength >= s_temp->ref_length);