16
16
/* key handling functions */
18
18
#include "myisamdef.h"
19
#include <mystrings/m_ctype.h>
20
#include <drizzled/util/test.h>
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);
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)
63
unsigned char *keypos,*maxpos;
64
unsigned char lastkey[MI_MAX_KEY_BUFF],*buff;
62
uchar *keypos,*maxpos;
63
uchar lastkey[MI_MAX_KEY_BUFF],*buff;
66
65
if (pos == HA_OFFSET_ERROR)
114
113
if (pos != info->last_keypage)
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)))))
124
123
if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
126
uint32_t not_used[2];
127
126
if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
128
127
&info->lastkey_length))
166
165
/* ret_pos point to where find or bigger key starts */
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)
173
172
register int start,mid,end,save_end;
175
uint32_t totlength,nod_flag,not_used[2];
174
uint totlength,nod_flag,not_used[2];
177
176
totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
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)
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;
237
236
end= page+mi_getint(page);
238
237
nod_flag=mi_test_if_nod(page);
261
260
} /* _mi_seq_search */
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)
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
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;
285
284
t_buff[0]=0; /* Avoid bugs */
392
391
if (matched >= prefix_len)
394
393
/* We have to compare. But we can still skip part of the key */
396
unsigned char *k=kseg+prefix_len;
395
uchar *k=kseg+prefix_len;
399
398
If prefix_len > cmplen then we are in the end-space comparison
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++) ;
445
444
goto cmp_rest; /* should never happen */
446
if (*k < (unsigned char) ' ')
445
if (*k < (uchar) ' ')
448
447
my_flag= 1; /* Compared string is smaller */
454
453
else if (len > cmplen)
456
unsigned char *vseg_end;
457
456
if ((nextflag & SEARCH_PREFIX) && key_len_left == 0)
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);
466
if (*vseg > (unsigned char) ' ')
465
if (*vseg > (uchar) ' ')
468
467
my_flag= 1; /* Compared string is smaller */
562
561
/* Save pos to a key_block */
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)
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 */
586
585
} /* _mi_kpointer */
589
588
/* Calc pos to a data-record from a key */
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)
595
594
after_key-=(nod_flag + info->s->rec_reflength);
620
619
/* Calc position from a record pointer ( in delete link chain ) */
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)
625
624
switch (s->rec_reflength) {
678
677
/* save position to record */
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)
682
681
if (!(info->s->options &
683
682
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
717
716
/* same as _mi_get_key but used with fixed length keys */
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)
722
memcpy(key, *page, keyinfo->keylength+nod_flag);
721
memcpy((uchar*) key,(uchar*) *page,
722
(size_t) (keyinfo->keylength+nod_flag));
723
723
*page+=keyinfo->keylength+nod_flag;
724
724
return(keyinfo->keylength);
725
725
} /* _mi_get_static_key */
739
739
key_length + length of data pointer
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)
742
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
743
register uchar **page_pos, register uchar *key)
745
745
register HA_KEYSEG *keyseg;
746
unsigned char *start_key,*page=*page_pos;
746
uchar *start_key,*page=*page_pos;
750
750
for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
752
752
if (keyseg->flag & HA_PACK_KEY)
754
754
/* key with length, packed to previous key */
755
unsigned char *start=key;
756
uint32_t packed= *page & 128,tot_length,rest_length;
756
uint packed= *page & 128,tot_length,rest_length;
757
757
if (keyseg->length >= 127)
759
759
length=mi_uint2korr(page) & 32767;
805
805
else if (tot_length < 255 && *start == 255)
807
memcpy(key+1,key+3,length);
807
bmove(key+1,key+3,length);
848
848
if (keyseg->flag &
849
849
(HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
851
unsigned char *tmp=page;
852
852
get_key_length(length,tmp);
853
853
length+=(uint) (tmp-page);
856
856
length=keyseg->length;
858
memcpy(key, page, length);
858
memcpy((uchar*) key,(uchar*) page,(size_t) length);
862
862
length=keyseg->length+nod_flag;
863
memcpy(key,page,length);
863
bmove((uchar*) key,(uchar*) page,length);
864
864
*page_pos= page+length;
865
865
return ((uint) (key-start_key)+keyseg->length);
866
866
} /* _mi_get_pack_key */
870
870
/* key that is packed relatively to previous */
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)
872
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
873
register uchar **page_pos, register uchar *key)
875
875
register HA_KEYSEG *keyseg;
876
unsigned char *start_key,*page,*page_end,*from,*from_end;
876
uchar *start_key,*page,*page_end,*from,*from_end;
880
880
page_end=page+MI_MAX_KEY_BUFF+1;
955
955
from=page; from_end=page_end;
957
memmove(key, from, length);
957
memmove((uchar*) key, (uchar*) from, (size_t) length);
985
985
return(0); /* Error */
987
987
/* Copy data pointer and, if appropriate, key block pointer. */
988
memcpy(key, from, length);
988
memcpy((uchar*) key,(uchar*) from,(size_t) length);
989
989
*page_pos= from+length;
991
991
return((uint) (key-start_key)+keyseg->length);
995
995
/* Get key at position without knowledge of previous key */
996
996
/* Returns pointer to next key */
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)
998
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
999
uchar *key, uchar *keypos, uint *return_key_length)
1003
1003
nod_flag=mi_test_if_nod(page);
1004
1004
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1006
memcpy(key,keypos,keyinfo->keylength+nod_flag);
1006
bmove((uchar*) key,(uchar*) keypos,keyinfo->keylength+nod_flag);
1007
1007
return(keypos+keyinfo->keylength+nod_flag);
1028
1028
/* Get key at position without knowledge of previous key */
1029
1029
/* Returns 0 if ok */
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)
1031
static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
1032
uchar *key, uchar *keypos,
1033
uint *return_key_length)
1037
1037
nod_flag=mi_test_if_nod(page);
1038
1038
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1040
1040
*return_key_length=keyinfo->keylength;
1041
memcpy(key, keypos - *return_key_length-nod_flag, *return_key_length);
1041
bmove((uchar*) key,(uchar*) keypos- *return_key_length-nod_flag,
1042
*return_key_length);
1064
1065
/* Get last key from key-page */
1065
1066
/* Return pointer to where key starts */
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)
1068
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
1069
uchar *lastkey, uchar *endpos, uint *return_key_length)
1071
unsigned char *lastpos;
1073
1074
nod_flag=mi_test_if_nod(page);
1074
1075
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1076
1077
lastpos=endpos-keyinfo->keylength-nod_flag;
1077
1078
*return_key_length=keyinfo->keylength;
1078
1079
if (lastpos > page)
1079
memcpy(lastkey,lastpos,keyinfo->keylength+nod_flag);
1080
bmove((uchar*) lastkey,(uchar*) lastpos,keyinfo->keylength+nod_flag);
1101
1102
/* Calculate length of key */
1103
uint32_t _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
1104
uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
1105
1106
register HA_KEYSEG *keyseg;
1106
unsigned char *start;
1108
1109
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1109
1110
return (keyinfo->keylength);
1135
1136
after '0xDF' but find 'ss'
1138
uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
1139
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
1139
1140
HA_KEYSEG *end)
1141
1142
register HA_KEYSEG *keyseg;
1142
unsigned char *start= key;
1144
1145
for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
1161
1162
/* Move a key */
1163
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
1164
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
1165
register uint32_t length;
1166
length= _mi_keylength(keyinfo, from);
1167
memcpy(to, from, length);
1166
register uint length;
1167
memcpy((uchar*) to, (uchar*) from,
1168
(size_t) (length=_mi_keylength(keyinfo,from)));
1168
1169
return to+length;
1172
1173
/* This can't be used when database is touched after last read */
1174
1175
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)
1176
uchar *key, uint key_length, uint nextflag, my_off_t pos)
1179
unsigned char lastkey[MI_MAX_KEY_BUFF];
1180
uchar lastkey[MI_MAX_KEY_BUFF];
1181
1182
/* Force full read if we are at last key or if we are not on a leaf
1182
1183
and the key tree has changed since we used it last time
1220
1221
else /* Previous key */
1223
1224
/* Find start of previous key */
1224
1225
info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
1225
1226
info->int_keypos, &length);
1292
1293
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1293
1294
register my_off_t pos)
1296
unsigned char *buff,*page;
1298
1299
if (pos == HA_OFFSET_ERROR)
1345
1346
/* Static length key */
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)
1349
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
1350
uchar *next_pos __attribute__((unused)),
1351
uchar *org_key __attribute__((unused)),
1352
uchar *prev_key __attribute__((unused)),
1353
uchar *key, MI_KEY_PARAM *s_temp)
1354
1355
s_temp->key=key;
1355
1356
return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
1358
1359
/* Variable length key */
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)
1362
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
1363
uchar *next_pos __attribute__((unused)),
1364
uchar *org_key __attribute__((unused)),
1365
uchar *prev_key __attribute__((unused)),
1366
uchar *key, MI_KEY_PARAM *s_temp)
1367
1368
s_temp->key=key;
1368
1369
return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
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,
1392
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
1393
uchar *org_key, uchar *prev_key, uchar *key,
1393
1394
MI_KEY_PARAM *s_temp)
1395
1396
register HA_KEYSEG *keyseg;
1397
uint32_t key_length,ref_length,org_key_length=0,
1398
uint key_length,ref_length,org_key_length=0,
1398
1399
length_pack,new_key_length,diff_flag,pack_marker;
1399
unsigned char *start,*end,*key_end,*sort_order;
1400
uchar *start,*end,*key_end,*sort_order;
1401
my_bool same_length;
1402
1403
length_pack=s_temp->ref_length=s_temp->n_ref_length=s_temp->n_length=0;
1403
1404
same_length=0; keyseg=keyinfo->seg;
1512
1513
/* If something after that hasn't length=0, test if we can combine */
1513
1514
if ((s_temp->next_key_pos=next_key))
1515
uint32_t packed,n_length;
1516
uint packed,n_length;
1517
1518
packed = *next_key & 128;
1518
1519
if (diff_flag == 2)
1596
1597
if (ref_length+pack_marker > new_ref_length)
1598
uint32_t new_pack_length=new_ref_length-pack_marker;
1599
uint new_pack_length=new_ref_length-pack_marker;
1599
1600
/* We must copy characters from the original key to the next key */
1600
1601
s_temp->part_of_prev_key= new_ref_length;
1601
1602
s_temp->prev_length= ref_length - new_pack_length;
1660
1661
/* Length of key which is prefix compressed */
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,
1664
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
1665
uchar *org_key, uchar *prev_key, uchar *key,
1665
1666
MI_KEY_PARAM *s_temp)
1667
uint32_t length,key_length,ref_length;
1668
uint length,key_length,ref_length;
1669
1670
s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
1670
1671
#ifdef HAVE_purify
1679
1680
As keys may be identical when running a sort in myisamchk, we
1680
1681
have to guard against the case where keys may be identical
1683
1684
end=key+key_length;
1684
1685
for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
1685
1686
s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
1694
1695
if ((s_temp->next_key_pos=next_key)) /* If another key after */
1696
1697
/* pack key against next key */
1697
uint32_t next_length,next_length_pack;
1698
uint next_length,next_length_pack;
1698
1699
get_key_pack_length(next_length,next_length_pack,next_key);
1700
1701
/* If first key and next key is packed (only on delete) */
1701
1702
if (!prev_key && org_key && next_length)
1704
1705
for (key= s_temp->key, end=key+next_length ;
1705
1706
*key == *org_key && key < end;
1706
1707
key++,org_key++) ;
1742
1743
/* store key without compression */
1744
1745
void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
1745
register unsigned char *key_pos,
1746
register uchar *key_pos,
1746
1747
register MI_KEY_PARAM *s_temp)
1748
memcpy(key_pos, s_temp->key, s_temp->totlength);
1749
memcpy((uchar*) key_pos,(uchar*) s_temp->key,(size_t) s_temp->totlength);
1752
1753
/* store variable length key with prefix compression */
1754
1755
#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); } }
1756
if (test) { *((pos)++) = (uchar) (length); } else \
1757
{ *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length); } }
1759
1760
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo __attribute__((unused)),
1760
register unsigned char *key_pos,
1761
register uchar *key_pos,
1761
1762
register MI_KEY_PARAM *s_temp)
1764
unsigned char *start;
1778
1779
/* Not packed against previous key */
1779
1780
store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->key_length);
1781
assert(key_pos >= start);
1782
length= s_temp->totlength - (key_pos - start);
1783
memcpy(key_pos, s_temp->key, length);
1782
bmove((uchar*) key_pos,(uchar*) s_temp->key,
1783
(length=s_temp->totlength-(uint) (key_pos-start)));
1785
1785
if (!s_temp->next_key_pos) /* No following key */
1821
1821
/* variable length key with prefix compression */
1823
1823
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo __attribute__((unused)),
1824
register unsigned char *key_pos,
1824
register uchar *key_pos,
1825
1825
register MI_KEY_PARAM *s_temp)
1827
assert(s_temp->totlength >= s_temp->ref_length);
1828
1827
store_key_length_inc(key_pos,s_temp->ref_length);
1829
memcpy(key_pos,s_temp->key+s_temp->ref_length,
1830
s_temp->totlength - s_temp->ref_length);
1828
memcpy((char*) key_pos,(char*) s_temp->key+s_temp->ref_length,
1829
(size_t) s_temp->totlength-s_temp->ref_length);
1832
1831
if (s_temp->next_key_pos)
added
removed
storage/myisam/mi_search.c
