← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_search.c

  • Committer: Brian Aker
  • Date: 2008-08-12 03:12:57 UTC
  • Revision ID: brian@tangent.org-20080812031257-ln3uk87y1r22byeg
First pass of new sql_db.cc work

Show diffs side-by-side

added added

removed removed

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