18#include "myisam_priv.h"
19#include <drizzled/charset.h>
28#define FIX_LENGTH(cs, pos, length, char_length) \
30 if (length > char_length) \
31 char_length= my_charpos(cs, pos, pos+length, char_length); \
32 drizzled::set_if_smaller(char_length,length); \
35static int _mi_put_key_in_record(MI_INFO *info,uint32_t keynr,
unsigned char *record);
52uint32_t _mi_make_key(MI_INFO *info, uint32_t keynr,
unsigned char *key,
53 const unsigned char *record, drizzled::internal::my_off_t filepos)
60 for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
62 enum drizzled::ha_base_keytype
type=(
enum drizzled::ha_base_keytype) keyseg->type;
63 uint32_t length=keyseg->length;
69 if (record[keyseg->null_pos] & keyseg->null_bit)
77 char_length= ((cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
80 pos= (
unsigned char*) record+keyseg->start;
82 if (keyseg->flag & HA_SPACE_PACK)
84 length= cs->cset->lengthsp(cs, (
char*) pos, length);
86 FIX_LENGTH(cs, pos, length, char_length);
87 store_key_length_inc(key,char_length);
88 memcpy(key, pos, char_length);
92 if (keyseg->flag & HA_VAR_LENGTH_PART)
94 uint32_t pack_length= (keyseg->bit_start == 1 ? 1 : 2);
95 uint32_t tmp_length= (pack_length == 1 ? (uint) *(
unsigned char*) pos :
98 drizzled::set_if_smaller(length,tmp_length);
99 FIX_LENGTH(cs, pos, length, char_length);
100 store_key_length_inc(key,char_length);
101 memcpy(key, pos, char_length);
105 else if (keyseg->flag & HA_BLOB_PART)
107 uint32_t tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
108 memcpy(&pos, pos+keyseg->bit_start,
sizeof(
char*));
109 drizzled::set_if_smaller(length,tmp_length);
110 FIX_LENGTH(cs, pos, length, char_length);
111 store_key_length_inc(key,char_length);
112 memcpy(key, pos, char_length);
116 else if (keyseg->flag & HA_SWAP_KEY)
118 if (
type == drizzled::HA_KEYTYPE_DOUBLE)
124 memset(key, 0, length);
136 FIX_LENGTH(cs, pos, length, char_length);
137 memcpy(key, pos, char_length);
138 if (length > char_length)
139 cs->cset->fill(cs, (
char*) key+char_length, length-char_length,
' ');
142 _mi_dpointer(info,key,filepos);
143 return((uint) (key-start));
165uint32_t _mi_pack_key(MI_INFO *info, uint32_t keynr,
unsigned char *key,
unsigned char *old,
166 drizzled::key_part_map keypart_map, HA_KEYSEG **last_used_keyseg)
168 unsigned char *start_key=key;
172 assert(((keypart_map+1) & keypart_map) == 0);
174 for (keyseg= info->s->keyinfo[keynr].seg ; keyseg->type && keypart_map;
175 old+= keyseg->length, keyseg++)
177 enum drizzled::ha_base_keytype
type= (
enum drizzled::ha_base_keytype) keyseg->type;
178 uint32_t length= keyseg->length;
179 uint32_t char_length;
183 if (keyseg->null_bit)
185 if (!(*key++= (
char) 1-*old++))
187 if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
192 char_length= (cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen : length;
194 if (keyseg->flag & HA_SPACE_PACK)
196 unsigned char *end=pos+length;
198 if (
type != drizzled::HA_KEYTYPE_BINARY)
200 while (end > pos && end[-1] ==
' ')
203 length=(uint) (end-pos);
204 FIX_LENGTH(cs, pos, length, char_length);
205 store_key_length_inc(key,char_length);
206 memcpy(key, pos, char_length);
210 else if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
213 uint32_t tmp_length=uint2korr(pos);
215 drizzled::set_if_smaller(length,tmp_length);
216 FIX_LENGTH(cs, pos, length, char_length);
217 store_key_length_inc(key,char_length);
219 memcpy(key, pos, char_length);
223 else if (keyseg->flag & HA_SWAP_KEY)
230 FIX_LENGTH(cs, pos, length, char_length);
231 memcpy(key, pos, char_length);
232 if (length > char_length)
233 cs->cset->fill(cs, (
char*) key+char_length, length-char_length,
' ');
236 if (last_used_keyseg)
237 *last_used_keyseg= keyseg;
239 return((uint) (key-start_key));
263static int _mi_put_key_in_record(MI_INFO *info, uint32_t keynr,
264 unsigned char *record)
267 unsigned char *pos,*key_end;
269 unsigned char *blob_ptr;
271 blob_ptr= (
unsigned char*) info->lastkey2;
272 key=(
unsigned char*) info->lastkey;
273 key_end=key+info->lastkey_length;
274 for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
276 if (keyseg->null_bit)
280 record[keyseg->null_pos]|= keyseg->null_bit;
283 record[keyseg->null_pos]&= ~keyseg->null_bit;
286 if (keyseg->flag & HA_SPACE_PACK)
289 get_key_length(length,key);
291 if (length > keyseg->length || key+length > key_end)
294 pos= record+keyseg->start;
296 memcpy(pos, key, length);
297 keyseg->charset->cset->fill(keyseg->charset,
298 (
char*) pos + length,
299 keyseg->length - length,
305 if (keyseg->flag & HA_VAR_LENGTH_PART)
308 get_key_length(length,key);
310 if (length > keyseg->length || key+length > key_end)
314 if (keyseg->bit_start == 1)
315 *(
unsigned char*) (record+keyseg->start)= (
unsigned char) length;
317 int2store(record+keyseg->start, length);
319 memcpy(record+keyseg->start + keyseg->bit_start, key, length);
322 else if (keyseg->flag & HA_BLOB_PART)
325 get_key_length(length,key);
327 if (length > keyseg->length || key+length > key_end)
330 memcpy(record+keyseg->start+keyseg->bit_start,
331 &blob_ptr,
sizeof(
char*));
332 memcpy(blob_ptr,key,length);
336 info->update&= ~HA_STATE_RNEXT_SAME;
338 _my_store_blob_length(record+keyseg->start,
339 (uint) keyseg->bit_start,length);
342 else if (keyseg->flag & HA_SWAP_KEY)
344 unsigned char *to= record+keyseg->start+keyseg->length;
345 unsigned char *end= key+keyseg->length;
353 }
while (key != end);
359 if (key+keyseg->length > key_end)
362 memcpy(record+keyseg->start, key, keyseg->length);
363 key+= keyseg->length;
375int _mi_read_key_record(MI_INFO *info, drizzled::internal::my_off_t filepos,
unsigned char *buf)
377 fast_mi_writeinfo(info);
378 if (filepos != HA_OFFSET_ERROR)
380 if (info->lastinx >= 0)
382 if (_mi_put_key_in_record(info,(uint) info->lastinx,buf))
384 mi_print_error(info->s, HA_ERR_CRASHED);
385 errno=HA_ERR_CRASHED;
388 info->update|= HA_STATE_AKTIV;
391 errno=HA_ERR_WRONG_INDEX;
414int mi_check_index_cond(MI_INFO *info, uint32_t keynr,
unsigned char *record)
416 if (_mi_put_key_in_record(info, keynr, record))
418 mi_print_error(info->s, HA_ERR_CRASHED);
419 errno=HA_ERR_CRASHED;
422 return info->index_cond_func(info->index_cond_func_arg);
439uint64_t retrieve_auto_increment(MI_INFO *info,
const unsigned char *record)
443 HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
444 const unsigned char *key= (
unsigned char*) record + keyseg->start;
446 switch (keyseg->type) {
447 case drizzled::HA_KEYTYPE_BINARY:
448 value=(uint64_t) *(
unsigned char*) key;
450 case drizzled::HA_KEYTYPE_LONG_INT:
451 s_value= (int64_t) sint4korr(key);
453 case drizzled::HA_KEYTYPE_ULONG_INT:
454 value=(uint64_t) uint4korr(key);
456 case drizzled::HA_KEYTYPE_DOUBLE:
461 value = (f_1 < 0.0) ? 0 : (uint64_t) f_1;
464 case drizzled::HA_KEYTYPE_LONGLONG:
465 s_value= sint8korr(key);
467 case drizzled::HA_KEYTYPE_ULONGLONG:
468 value= uint8korr(key);
481 return (s_value > 0) ? (uint64_t) s_value : value;
Convert from decimal to binary representation.
TODO: Rename this file - func.h is stupid.