← 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-10-06 05:57:49 UTC
  • Revision ID: brian@tangent.org-20081006055749-svg700gciuqi0zu1
Remove all of uchar.

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, uchar *page,
22
 
                                uchar *key, uchar *keypos,
 
21
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
 
22
                                unsigned char *key, unsigned char *keypos,
23
23
                                uint *return_key_length);
24
24
 
25
25
        /* Check index */
54
54
        */
55
55
 
56
56
int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
57
 
               uchar *key, uint key_len, uint nextflag, register my_off_t pos)
 
57
               unsigned char *key, uint key_len, uint nextflag, register my_off_t pos)
58
58
{
59
59
  bool last_key;
60
60
  int error,flag;
61
61
  uint nod_flag;
62
 
  uchar *keypos,*maxpos;
63
 
  uchar lastkey[MI_MAX_KEY_BUFF],*buff;
 
62
  unsigned char *keypos,*maxpos;
 
63
  unsigned char 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
 
    uchar *old_buff=buff;
 
115
    unsigned char *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;
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, uchar *page,
169
 
                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
170
 
                   uchar *buff __attribute__((unused)), bool *last_key)
 
168
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
 
169
                   unsigned char *key, uint key_len, uint comp_flag, unsigned char **ret_pos,
 
170
                   unsigned char *buff __attribute__((unused)), bool *last_key)
171
171
{
172
172
  register int start,mid,end,save_end;
173
173
  int flag;
225
225
    < 0         Not found.
226
226
*/
227
227
 
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)
 
228
int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
 
229
                   unsigned char *key, uint key_len, uint comp_flag, unsigned char **ret_pos,
 
230
                   unsigned char *buff, bool *last_key)
231
231
{
232
232
  int flag=0;
233
233
  uint nod_flag,length=0,not_used[2];
234
 
  uchar t_buff[MI_MAX_KEY_BUFF],*end;
 
234
  unsigned char 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, uchar *page,
264
 
                      uchar *key, uint key_len, uint nextflag, uchar **ret_pos,
265
 
                      uchar *buff, bool *last_key)
 
263
int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
 
264
                      unsigned char *key, uint key_len, uint nextflag, unsigned char **ret_pos,
 
265
                      unsigned char *buff, bool *last_key)
266
266
{
267
267
  /*
268
268
    my_flag is raw comparison result to be changed according to
273
273
  uint nod_flag, length=0, len, matched, cmplen, kseg_len;
274
274
  uint prefix_len=0,suffix_len;
275
275
  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;
 
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
280
  uint  saved_length=0, saved_prefix_len=0;
281
281
  uint  length_pack;
282
282
 
355
355
    saved_prefix_len=prefix_len;
356
356
 
357
357
    {
358
 
      uchar *from=vseg+suffix_len;
 
358
      unsigned char *from=vseg+suffix_len;
359
359
      HA_KEYSEG *keyseg;
360
360
      uint l;
361
361
 
392
392
    {
393
393
      /* We have to compare. But we can still skip part of the key */
394
394
      uint  left;
395
 
      uchar *k=kseg+prefix_len;
 
395
      unsigned char *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
 
            uchar *k_end= k+ (cmplen - len);
 
441
            unsigned char *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 < (uchar) ' ')
 
445
            if (*k < (unsigned char) ' ')
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
 
          uchar *vseg_end;
 
455
          unsigned char *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 == (uchar) ' ';
 
461
               vseg < vseg_end && *vseg == (unsigned char) ' ';
462
462
               vseg++, matched++) ;
463
463
          assert(vseg < vseg_end);
464
464
 
465
 
          if (*vseg > (uchar) ' ')
 
465
          if (*vseg > (unsigned char) ' ')
466
466
          {
467
467
            my_flag= 1;                 /* Compared string is smaller */
468
468
            break;
524
524
 
525
525
        /* Get pos to a key_block */
526
526
 
527
 
my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
 
527
my_off_t _mi_kpos(uint nod_flag, unsigned char *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 uchar *buff, my_off_t pos)
 
563
void _mi_kpointer(register MI_INFO *info, register unsigned char *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]= (uchar) pos; break;
 
582
  case 1: buff[0]= (unsigned char) 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, uint nod_flag, uchar *after_key)
 
591
my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, unsigned char *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, uchar *ptr)
 
621
my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
622
622
{
623
623
  my_off_t pos;
624
624
  switch (s->rec_reflength) {
676
676
 
677
677
        /* save position to record */
678
678
 
679
 
void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
 
679
void _mi_dpointer(MI_INFO *info, unsigned char *buff, my_off_t pos)
680
680
{
681
681
  if (!(info->s->options &
682
682
        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
716
716
        /* same as _mi_get_key but used with fixed length keys */
717
717
 
718
718
uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
719
 
                       register uchar **page, register uchar *key)
 
719
                       register unsigned char **page, register unsigned char *key)
720
720
{
721
721
  memcpy(key, *page, keyinfo->keylength+nod_flag);
722
722
  *page+=keyinfo->keylength+nod_flag;
739
739
*/
740
740
 
741
741
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
742
 
                      register uchar **page_pos, register uchar *key)
 
742
                      register unsigned char **page_pos, register unsigned char *key)
743
743
{
744
744
  register HA_KEYSEG *keyseg;
745
 
  uchar *start_key,*page=*page_pos;
 
745
  unsigned char *start_key,*page=*page_pos;
746
746
  uint length;
747
747
 
748
748
  start_key=key;
751
751
    if (keyseg->flag & HA_PACK_KEY)
752
752
    {
753
753
      /* key with length, packed to previous key */
754
 
      uchar *start=key;
 
754
      unsigned char *start=key;
755
755
      uint packed= *page & 128,tot_length,rest_length;
756
756
      if (keyseg->length >= 127)
757
757
      {
847
847
      if (keyseg->flag &
848
848
          (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
849
849
      {
850
 
        uchar *tmp=page;
 
850
        unsigned char *tmp=page;
851
851
        get_key_length(length,tmp);
852
852
        length+=(uint) (tmp-page);
853
853
      }
869
869
/* key that is packed relatively to previous */
870
870
 
871
871
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
872
 
                             register uchar **page_pos, register uchar *key)
 
872
                             register unsigned char **page_pos, register unsigned char *key)
873
873
{
874
874
  register HA_KEYSEG *keyseg;
875
 
  uchar *start_key,*page,*page_end,*from,*from_end;
 
875
  unsigned char *start_key,*page,*page_end,*from,*from_end;
876
876
  uint length,tmp;
877
877
 
878
878
  page= *page_pos;
994
994
        /* Get key at position without knowledge of previous key */
995
995
        /* Returns pointer to next key */
996
996
 
997
 
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
998
 
                   uchar *key, uchar *keypos, uint *return_key_length)
 
997
unsigned char *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
 
998
                   unsigned char *key, unsigned char *keypos, uint *return_key_length)
999
999
{
1000
1000
  uint nod_flag;
1001
1001
 
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, uchar *page,
1031
 
                                uchar *key, uchar *keypos,
 
1030
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
 
1031
                                unsigned char *key, unsigned char *keypos,
1032
1032
                                uint *return_key_length)
1033
1033
{
1034
1034
  uint nod_flag;
1063
1063
        /* Get last key from key-page */
1064
1064
        /* Return pointer to where key starts */
1065
1065
 
1066
 
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
1067
 
                        uchar *lastkey, uchar *endpos, uint *return_key_length)
 
1066
unsigned char *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
 
1067
                        unsigned char *lastkey, unsigned char *endpos, uint *return_key_length)
1068
1068
{
1069
1069
  uint nod_flag;
1070
 
  uchar *lastpos;
 
1070
  unsigned char *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
 
uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
 
1102
uint _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
1103
1103
{
1104
1104
  register HA_KEYSEG *keyseg;
1105
 
  uchar *start;
 
1105
  unsigned char *start;
1106
1106
 
1107
1107
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1108
1108
    return (keyinfo->keylength);
1134
1134
  after '0xDF' but find 'ss'
1135
1135
*/
1136
1136
 
1137
 
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
 
1137
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
1138
1138
                        HA_KEYSEG *end)
1139
1139
{
1140
1140
  register HA_KEYSEG *keyseg;
1141
 
  uchar *start= key;
 
1141
  unsigned char *start= key;
1142
1142
 
1143
1143
  for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
1144
1144
  {
1159
1159
 
1160
1160
        /* Move a key */
1161
1161
 
1162
 
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
 
1162
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
1163
1163
{
1164
1164
  register uint length;
1165
1165
  length= _mi_keylength(keyinfo, from);
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
 
                    uchar *key, uint key_length, uint nextflag, my_off_t pos)
 
1174
                    unsigned char *key, uint key_length, uint nextflag, my_off_t pos)
1175
1175
{
1176
1176
  int error;
1177
1177
  uint nod_flag;
1178
 
  uchar lastkey[MI_MAX_KEY_BUFF];
 
1178
  unsigned char 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
1250
1250
                     register my_off_t pos)
1251
1251
{
1252
1252
  uint nod_flag;
1253
 
  uchar *page;
 
1253
  unsigned char *page;
1254
1254
 
1255
1255
  if (pos == HA_OFFSET_ERROR)
1256
1256
  {
1292
1292
                    register my_off_t pos)
1293
1293
{
1294
1294
  uint nod_flag;
1295
 
  uchar *buff,*page;
 
1295
  unsigned char *buff,*page;
1296
1296
 
1297
1297
  if (pos == HA_OFFSET_ERROR)
1298
1298
  {
1345
1345
 
1346
1346
int
1347
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)
 
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)
1352
1352
{
1353
1353
  s_temp->key=key;
1354
1354
  return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
1358
1358
 
1359
1359
int
1360
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)
 
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)
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,uint nod_flag,uchar *next_key,
1391
 
                             uchar *org_key, uchar *prev_key, uchar *key,
 
1390
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,unsigned char *next_key,
 
1391
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
1392
1392
                             MI_KEY_PARAM *s_temp)
1393
1393
{
1394
1394
  register HA_KEYSEG *keyseg;
1395
1395
  int length;
1396
1396
  uint key_length,ref_length,org_key_length=0,
1397
1397
       length_pack,new_key_length,diff_flag,pack_marker;
1398
 
  uchar *start,*end,*key_end,*sort_order;
 
1398
  unsigned char *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;
1659
1659
/* Length of key which is prefix compressed */
1660
1660
 
1661
1661
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,
 
1662
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,unsigned char *next_key,
 
1663
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
1664
1664
                             MI_KEY_PARAM *s_temp)
1665
1665
{
1666
1666
  uint length,key_length,ref_length;
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
 
    uchar *end;
 
1681
    unsigned char *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);
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
 
      uchar *end;
 
1702
      unsigned char *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 uchar *key_pos,
 
1744
                          register unsigned char *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)++) = (uchar) (length); } else \
1755
 
  { *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length);  } }
 
1754
  if (test) { *((pos)++) = (unsigned char) (length); } else \
 
1755
  { *((pos)++) = (unsigned char) ((length) >> 8); *((pos)++) = (unsigned char) (length);  } }
1756
1756
 
1757
1757
 
1758
1758
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
1759
 
                            register uchar *key_pos,
 
1759
                            register unsigned char *key_pos,
1760
1760
                            register MI_KEY_PARAM *s_temp)
1761
1761
{
1762
1762
  uint length;
1763
 
  uchar *start;
 
1763
  unsigned char *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 uchar *key_pos,
 
1823
                            register unsigned char *key_pos,
1824
1824
                            register MI_KEY_PARAM *s_temp)
1825
1825
{
1826
1826
  assert(s_temp->totlength >= s_temp->ref_length);