← 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 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_search.c
20
20
 
21
21
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
22
22
                                unsigned char *key, unsigned char *keypos,
23
 
                                uint *return_key_length);
 
23
                                uint32_t *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, uint key_len, uint nextflag, register my_off_t pos)
 
57
               unsigned char *key, uint32_t key_len, uint32_t nextflag, register my_off_t pos)
58
58
{
59
59
  bool last_key;
60
60
  int error,flag;
61
 
  uint nod_flag;
 
61
  uint32_t nod_flag;
62
62
  unsigned char *keypos,*maxpos;
63
63
  unsigned char lastkey[MI_MAX_KEY_BUFF],*buff;
64
64
 
122
122
 
123
123
  if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
124
124
  {
125
 
    uint not_used[2];
 
125
    uint32_t 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;
166
166
        /* ARGSUSED */
167
167
 
168
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,
 
169
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
170
170
                   unsigned char *buff __attribute__((unused)), bool *last_key)
171
171
{
172
172
  register int start,mid,end,save_end;
173
173
  int flag;
174
 
  uint totlength,nod_flag,not_used[2];
 
174
  uint32_t 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;
226
226
*/
227
227
 
228
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,
 
229
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
230
230
                   unsigned char *buff, bool *last_key)
231
231
{
232
232
  int flag=0;
233
 
  uint nod_flag,length=0,not_used[2];
 
233
  uint32_t nod_flag,length=0,not_used[2];
234
234
  unsigned char t_buff[MI_MAX_KEY_BUFF],*end;
235
235
 
236
236
  end= page+mi_getint(page);
261
261
 
262
262
 
263
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,
 
264
                      unsigned char *key, uint32_t key_len, uint32_t nextflag, unsigned char **ret_pos,
265
265
                      unsigned char *buff, bool *last_key)
266
266
{
267
267
  /*
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
 
  uint nod_flag, length=0, len, matched, cmplen, kseg_len;
274
 
  uint prefix_len=0,suffix_len;
 
273
  uint32_t nod_flag, length=0, len, matched, cmplen, kseg_len;
 
274
  uint32_t prefix_len=0,suffix_len;
275
275
  int key_len_skip, seg_len_pack=0, key_len_left;
276
276
  unsigned char *end, *kseg, *vseg;
277
277
  unsigned char *sort_order=keyinfo->seg->charset->sort_order;
278
278
  unsigned char tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
279
279
  unsigned char *saved_from=NULL, *saved_to=NULL, *saved_vseg=NULL;
280
 
  uint  saved_length=0, saved_prefix_len=0;
281
 
  uint  length_pack;
 
280
  uint32_t  saved_length=0, saved_prefix_len=0;
 
281
  uint32_t  length_pack;
282
282
 
283
283
 
284
284
  t_buff[0]=0;                                  /* Avoid bugs */
312
312
 
313
313
  while (page < end)
314
314
  {
315
 
    uint packed= *page & 128;
 
315
    uint32_t packed= *page & 128;
316
316
 
317
317
    vseg=page;
318
318
    if (keyinfo->seg->length >= 127)
357
357
    {
358
358
      unsigned char *from=vseg+suffix_len;
359
359
      HA_KEYSEG *keyseg;
360
 
      uint l;
 
360
      uint32_t 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
 
      uint  left;
 
394
      uint32_t  left;
395
395
      unsigned char *k=kseg+prefix_len;
396
396
 
397
397
      /*
474
474
      cmp_rest:
475
475
          if (key_len_left>0)
476
476
          {
477
 
            uint not_used[2];
 
477
            uint32_t 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(uint nod_flag, unsigned char *after_key)
 
527
my_off_t _mi_kpos(uint32_t nod_flag, unsigned char *after_key)
528
528
{
529
529
  after_key-=nod_flag;
530
530
  switch (nod_flag) {
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, unsigned char *after_key)
 
591
my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag, unsigned char *after_key)
592
592
{
593
593
  my_off_t pos;
594
594
  after_key-=(nod_flag + info->s->rec_reflength);
715
715
 
716
716
        /* same as _mi_get_key but used with fixed length keys */
717
717
 
718
 
uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
718
uint32_t _mi_get_static_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
719
719
                       register unsigned char **page, register unsigned char *key)
720
720
{
721
721
  memcpy(key, *page, keyinfo->keylength+nod_flag);
738
738
    key_length + length of data pointer
739
739
*/
740
740
 
741
 
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
741
uint32_t _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
742
742
                      register unsigned char **page_pos, register unsigned char *key)
743
743
{
744
744
  register HA_KEYSEG *keyseg;
745
745
  unsigned char *start_key,*page=*page_pos;
746
 
  uint length;
 
746
  uint32_t length;
747
747
 
748
748
  start_key=key;
749
749
  for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
752
752
    {
753
753
      /* key with length, packed to previous key */
754
754
      unsigned char *start=key;
755
 
      uint packed= *page & 128,tot_length,rest_length;
 
755
      uint32_t packed= *page & 128,tot_length,rest_length;
756
756
      if (keyseg->length >= 127)
757
757
      {
758
758
        length=mi_uint2korr(page) & 32767;
868
868
 
869
869
/* key that is packed relatively to previous */
870
870
 
871
 
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
871
uint32_t _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
872
872
                             register unsigned char **page_pos, register unsigned char *key)
873
873
{
874
874
  register HA_KEYSEG *keyseg;
875
875
  unsigned char *start_key,*page,*page_end,*from,*from_end;
876
 
  uint length,tmp;
 
876
  uint32_t length,tmp;
877
877
 
878
878
  page= *page_pos;
879
879
  page_end=page+MI_MAX_KEY_BUFF+1;
995
995
        /* Returns pointer to next key */
996
996
 
997
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)
 
998
                   unsigned char *key, unsigned char *keypos, uint32_t *return_key_length)
999
999
{
1000
 
  uint nod_flag;
 
1000
  uint32_t 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)))
1029
1029
 
1030
1030
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1031
1031
                                unsigned char *key, unsigned char *keypos,
1032
 
                                uint *return_key_length)
 
1032
                                uint32_t *return_key_length)
1033
1033
{
1034
 
  uint nod_flag;
 
1034
  uint32_t 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)))
1064
1064
        /* Return pointer to where key starts */
1065
1065
 
1066
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)
 
1067
                        unsigned char *lastkey, unsigned char *endpos, uint32_t *return_key_length)
1068
1068
{
1069
 
  uint nod_flag;
 
1069
  uint32_t nod_flag;
1070
1070
  unsigned char *lastpos;
1071
1071
 
1072
1072
  nod_flag=mi_test_if_nod(page);
1099
1099
 
1100
1100
        /* Calculate length of key */
1101
1101
 
1102
 
uint _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
 
1102
uint32_t _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
1103
1103
{
1104
1104
  register HA_KEYSEG *keyseg;
1105
1105
  unsigned char *start;
1115
1115
        continue;
1116
1116
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1117
1117
    {
1118
 
      uint length;
 
1118
      uint32_t 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
 
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
 
1137
uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
1138
1138
                        HA_KEYSEG *end)
1139
1139
{
1140
1140
  register HA_KEYSEG *keyseg;
1147
1147
        continue;
1148
1148
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1149
1149
    {
1150
 
      uint length;
 
1150
      uint32_t length;
1151
1151
      get_key_length(length,key);
1152
1152
      key+=length;
1153
1153
    }
1161
1161
 
1162
1162
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
1163
1163
{
1164
 
  register uint length;
 
1164
  register uint32_t 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, uint key_length, uint nextflag, my_off_t pos)
 
1174
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, my_off_t pos)
1175
1175
{
1176
1176
  int error;
1177
 
  uint nod_flag;
 
1177
  uint32_t nod_flag;
1178
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
1218
1218
  }
1219
1219
  else                                                  /* Previous key */
1220
1220
  {
1221
 
    uint length;
 
1221
    uint32_t 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
 
  uint nod_flag;
 
1252
  uint32_t nod_flag;
1253
1253
  unsigned char *page;
1254
1254
 
1255
1255
  if (pos == HA_OFFSET_ERROR)
1291
1291
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1292
1292
                    register my_off_t pos)
1293
1293
{
1294
 
  uint nod_flag;
 
1294
  uint32_t nod_flag;
1295
1295
  unsigned char *buff,*page;
1296
1296
 
1297
1297
  if (pos == HA_OFFSET_ERROR)
1344
1344
/* Static length key */
1345
1345
 
1346
1346
int
1347
 
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
1347
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1348
1348
                           unsigned char *next_pos  __attribute__((unused)),
1349
1349
                           unsigned char *org_key  __attribute__((unused)),
1350
1350
                           unsigned char *prev_key __attribute__((unused)),
1357
1357
/* Variable length key */
1358
1358
 
1359
1359
int
1360
 
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
1360
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1361
1361
                        unsigned char *next_pos  __attribute__((unused)),
1362
1362
                        unsigned char *org_key  __attribute__((unused)),
1363
1363
                        unsigned char *prev_key __attribute__((unused)),
1387
1387
*/
1388
1388
 
1389
1389
int
1390
 
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,unsigned char *next_key,
 
1390
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *next_key,
1391
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
 
  uint key_length,ref_length,org_key_length=0,
 
1396
  uint32_t key_length,ref_length,org_key_length=0,
1397
1397
       length_pack,new_key_length,diff_flag,pack_marker;
1398
1398
  unsigned char *start,*end,*key_end,*sort_order;
1399
1399
  bool same_length;
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
 
    uint packed,n_length;
 
1514
    uint32_t 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
 
      uint next_length_pack, new_ref_length=s_temp->ref_length;
 
1529
      uint32_t 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
 
          uint new_pack_length=new_ref_length-pack_marker;
 
1597
          uint32_t 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
 
        uint tmp_length;
 
1615
        uint32_t 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,uint nod_flag,unsigned char *next_key,
 
1662
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *next_key,
1663
1663
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
1664
1664
                             MI_KEY_PARAM *s_temp)
1665
1665
{
1666
 
  uint length,key_length,ref_length;
 
1666
  uint32_t 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
1693
1693
  if ((s_temp->next_key_pos=next_key))          /* If another key after */
1694
1694
  {
1695
1695
    /* pack key against next key */
1696
 
    uint next_length,next_length_pack;
 
1696
    uint32_t 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) */
1759
1759
                            register unsigned char *key_pos,
1760
1760
                            register MI_KEY_PARAM *s_temp)
1761
1761
{
1762
 
  uint length;
 
1762
  uint32_t length;
1763
1763
  unsigned char *start;
1764
1764
 
1765
1765
  start=key_pos;