18 #include "myisam_priv.h"
23 #include <boost/scoped_ptr.hpp>
24 #include <boost/scoped_array.hpp>
26 #include <drizzled/internal/m_string.h>
27 #include <drizzled/util/test.h>
28 #include <drizzled/charset.h>
29 #include <drizzled/memory/multi_malloc.h>
30 #include <drizzled/identifier.h>
36 static void setup_key_functions(
MI_KEYDEF *keyinfo);
37 static unsigned char *mi_keydef_read(
unsigned char *ptr,
MI_KEYDEF *keydef);
38 static unsigned char *mi_keyseg_read(
unsigned char *ptr,
HA_KEYSEG *keyseg);
39 static unsigned char *mi_recinfo_read(
unsigned char *ptr,
MI_COLUMNDEF *recinfo);
40 static uint64_t mi_safe_mul(uint64_t a, uint64_t b);
41 static unsigned char *mi_state_info_read(
unsigned char *ptr,
MI_STATE_INFO *state);
42 static unsigned char *mi_uniquedef_read(
unsigned char *ptr,
MI_UNIQUEDEF *def);
43 static unsigned char *my_n_base_info_read(
unsigned char *ptr,
MI_BASE_INFO *base);
45 #define disk_pos_assert(pos, end_pos) \
48 errno=HA_ERR_CRASHED; \
58 MI_INFO *test_if_reopen(
char *filename)
60 list<MI_INFO *>::iterator it= myisam_open_list.begin();
61 while (it != myisam_open_list.end())
65 if (!strcmp(share->unique_file_name,filename) && share->last_version)
83 int lock_error,kfile,open_mode,save_errno,have_rtree=0;
84 uint32_t i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
85 key_parts,unique_key_parts,uniques;
86 char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
89 unsigned char *disk_cache= NULL;
90 unsigned char *disk_pos, *end_pos;
92 boost::scoped_ptr<MYISAM_SHARE> share_buff_ap(
new MYISAM_SHARE);
95 boost::scoped_array<ulong> rec_per_key_part_ap(
new ulong[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG]);
96 ulong *rec_per_key_part= rec_per_key_part_ap.get();
97 internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
98 uint64_t max_key_file_length, max_data_file_length;
103 head_length=
sizeof(share_buff.state.header);
104 memset(&info, 0,
sizeof(info));
106 (void)internal::fn_format(org_name,
107 identifier.getPath().c_str(),
112 rp_buff = realpath(org_name,NULL);
115 internal::my_load_path(name_buff,org_name, NULL);
117 if (strlen(rp_buff)>=FN_REFLEN) rp_buff[FN_REFLEN-1]=
'\0';
118 strcpy(name_buff,rp_buff);
122 THR_LOCK_myisam.lock();
123 if (!(old_info=test_if_reopen(name_buff)))
126 memset(&share_buff, 0,
sizeof(share_buff));
127 share_buff.state.rec_per_key_part=rec_per_key_part;
128 share_buff.state.key_root=key_root;
129 share_buff.state.key_del=key_del;
131 if ((kfile=internal::my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
133 if ((errno != EROFS && errno != EACCES) ||
135 (kfile=internal::my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
138 share->mode=open_mode;
140 if (internal::my_read(kfile, share->state.header.file_version, head_length,
143 errno= HA_ERR_NOT_A_TABLE;
146 if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
148 errno=HA_ERR_NOT_A_TABLE;
151 share->options= mi_uint2korr(share->state.header.options);
152 static const uint64_t OLD_FILE_OPTIONS= HA_OPTION_PACK_RECORD |
153 HA_OPTION_PACK_KEYS |
154 HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
155 HA_OPTION_TEMP_COMPRESS_RECORD |
157 if (share->options & ~OLD_FILE_OPTIONS)
159 errno=HA_ERR_OLD_FILE;
164 ssize_t sym_link_size= readlink(org_name,index_name,FN_REFLEN-1);
165 if (sym_link_size >= 0 )
166 index_name[sym_link_size]=
'\0';
167 if (!strcmp(name_buff, org_name) || sym_link_size == -1)
168 (void) strcpy(index_name, org_name);
169 *strrchr(org_name,
'.')=
'\0';
170 (void) internal::fn_format(data_name,org_name,
"",MI_NAME_DEXT,
171 MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
173 info_length=mi_uint2korr(share->state.header.header_length);
174 base_pos=mi_uint2korr(share->state.header.base_pos);
175 if (!(disk_cache= (
unsigned char*) malloc(info_length+128)))
180 end_pos=disk_cache+info_length;
183 lseek(kfile,0,SEEK_SET);
185 if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
187 errno=HA_ERR_CRASHED;
190 len=mi_uint2korr(share->state.header.state_info_length);
191 keys= (uint) share->state.header.keys;
192 uniques= (uint) share->state.header.uniques;
193 key_parts= mi_uint2korr(share->state.header.key_parts);
194 unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
195 share->state_diff_length=len-MI_STATE_INFO_SIZE;
197 mi_state_info_read(disk_cache, &share->state);
198 len= mi_uint2korr(share->state.header.base_info_length);
199 disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
200 share->state.state_length=base_pos;
202 if (share->state.changed & STATE_CRASHED)
204 errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
205 HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
210 if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
212 errno=HA_ERR_CRASHED;
216 if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
217 key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
219 errno=HA_ERR_UNSUPPORTED;
224 max_data_file_length=
225 (share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
226 (((uint64_t) 1 << (share->base.rec_reflength*8))-1) :
227 (mi_safe_mul(share->base.pack_reclength,
228 (uint64_t) 1 << (share->base.rec_reflength*8))-1);
230 mi_safe_mul(MI_MIN_KEY_BLOCK_LENGTH,
231 ((uint64_t) 1 << (share->base.key_reflength*8))-1);
232 #if SIZEOF_OFF_T == 4
233 set_if_smaller(max_data_file_length, INT32_MAX);
234 set_if_smaller(max_key_file_length, INT32_MAX);
236 if (share->base.raid_type)
238 errno=HA_ERR_UNSUPPORTED;
241 share->base.max_data_file_length=(internal::my_off_t) max_data_file_length;
242 share->base.max_key_file_length=(internal::my_off_t) max_key_file_length;
244 if (share->options & HA_OPTION_COMPRESS_RECORD)
245 share->base.max_key_length+=2;
248 share->base.max_key_length+= share->base.key_reflength;
250 if (!drizzled::memory::multi_malloc(
false,
251 &share,
sizeof(*share),
252 &share->state.rec_per_key_part,
sizeof(long)*key_parts,
256 (key_parts+unique_key_parts+keys+uniques) *
sizeof(
HA_KEYSEG),
257 &share->rec, (share->base.fields+1)*
sizeof(
MI_COLUMNDEF),
258 &share->blobs,
sizeof(
MI_BLOB)*share->base.blobs,
259 &share->unique_file_name,strlen(name_buff)+1,
260 &share->index_file_name,strlen(index_name)+1,
261 &share->data_file_name,strlen(data_name)+1,
262 &share->state.key_root,keys*
sizeof(uint64_t),
263 &share->state.key_del,
264 (share->state.header.max_block_size_index*
sizeof(uint64_t)),
269 memcpy(share->state.rec_per_key_part, rec_per_key_part,
270 sizeof(
long)*key_parts);
271 memcpy(share->state.key_root, key_root,
272 sizeof(internal::my_off_t)*keys);
273 memcpy(share->state.key_del, key_del,
274 sizeof(internal::my_off_t) * share->state.header.max_block_size_index);
275 strcpy(share->unique_file_name, name_buff);
276 share->unique_name_length= strlen(name_buff);
277 strcpy(share->index_file_name, index_name);
278 strcpy(share->data_file_name, data_name);
280 share->blocksize=min((uint32_t)IO_SIZE,myisam_block_size);
283 for (i=0 ; i < keys ; i++)
285 share->keyinfo[i].share= share;
286 disk_pos=mi_keydef_read(disk_pos, &share->keyinfo[i]);
287 disk_pos_assert(disk_pos + share->keyinfo[i].keysegs * HA_KEYSEG_SIZE,
289 set_if_smaller(share->blocksize,(uint)share->keyinfo[i].block_length);
290 share->keyinfo[i].seg=pos;
291 for (j=0 ; j < share->keyinfo[i].keysegs; j++,pos++)
293 disk_pos=mi_keyseg_read(disk_pos, pos);
294 if (pos->flag & HA_BLOB_PART &&
295 ! (share->options & (HA_OPTION_COMPRESS_RECORD |
296 HA_OPTION_PACK_RECORD)))
298 errno= HA_ERR_CRASHED;
301 if (pos->type == HA_KEYTYPE_TEXT ||
302 pos->type == HA_KEYTYPE_VARTEXT1 ||
303 pos->type == HA_KEYTYPE_VARTEXT2)
306 pos->charset=default_charset_info;
307 else if (!(pos->charset= get_charset(pos->language)))
309 errno=HA_ERR_UNKNOWN_CHARSET;
313 else if (pos->type == HA_KEYTYPE_BINARY)
314 pos->charset= &my_charset_bin;
316 setup_key_functions(share->keyinfo+i);
317 share->keyinfo[i].end=pos;
318 pos->type=HA_KEYTYPE_END;
319 pos->length=share->base.rec_reflength;
324 for (i=0 ; i < uniques ; i++)
326 disk_pos=mi_uniquedef_read(disk_pos, &share->uniqueinfo[i]);
327 disk_pos_assert(disk_pos + share->uniqueinfo[i].keysegs *
328 HA_KEYSEG_SIZE, end_pos);
329 share->uniqueinfo[i].seg=pos;
330 for (j=0 ; j < share->uniqueinfo[i].keysegs; j++,pos++)
332 disk_pos=mi_keyseg_read(disk_pos, pos);
333 if (pos->type == HA_KEYTYPE_TEXT ||
334 pos->type == HA_KEYTYPE_VARTEXT1 ||
335 pos->type == HA_KEYTYPE_VARTEXT2)
338 pos->charset=default_charset_info;
339 else if (!(pos->charset= get_charset(pos->language)))
341 errno=HA_ERR_UNKNOWN_CHARSET;
346 share->uniqueinfo[i].end=pos;
347 pos->type=HA_KEYTYPE_END;
354 disk_pos_assert(disk_pos + share->base.fields *MI_COLUMNDEF_SIZE, end_pos);
355 for (i=j=offset=0 ; i < share->base.fields ; i++)
357 disk_pos=mi_recinfo_read(disk_pos,&share->rec[i]);
358 share->rec[i].pack_type=0;
359 share->rec[i].huff_tree=0;
360 share->rec[i].offset=offset;
361 if (share->rec[i].type == (
int) FIELD_BLOB)
363 share->blobs[j].pack_length=
364 share->rec[i].length-portable_sizeof_char_ptr;
365 share->blobs[j].offset=offset;
368 offset+=share->rec[i].length;
370 share->rec[i].type=(int) FIELD_LAST;
371 if (offset > share->base.reclength)
373 errno= HA_ERR_CRASHED;
382 if (mi_open_datafile(&info, share, -1))
387 share->this_process=(ulong) getpid();
388 share->last_process= share->state.process;
389 share->base.key_parts=key_parts;
390 share->base.all_key_parts=key_parts+unique_key_parts;
391 if (!(share->last_version=share->state.version))
392 share->last_version=1;
393 share->rec_reflength=share->base.rec_reflength;
394 share->base.margin_key_file_length=(share->base.max_key_file_length -
395 (keys ? MI_INDEX_BLOCK_MARGIN *
396 share->blocksize * keys : 0));
397 share->blocksize=min((uint32_t)IO_SIZE,myisam_block_size);
398 share->data_file_type=STATIC_RECORD;
399 if (share->options & HA_OPTION_PACK_RECORD)
400 share->data_file_type = DYNAMIC_RECORD;
403 mi_setup_functions(share);
404 share->is_log_table=
false;
405 if (myisam_concurrent_insert)
407 share->concurrent_insert=
408 ((share->options & (HA_OPTION_READ_ONLY_DATA | HA_OPTION_TMP_TABLE |
409 HA_OPTION_COMPRESS_RECORD |
410 HA_OPTION_TEMP_COMPRESS_RECORD)) ||
411 (open_flags & HA_OPEN_TMP_TABLE) || have_rtree) ? 0 : 1;
412 if (share->concurrent_insert)
421 if (mode == O_RDWR && share->mode == O_RDONLY)
426 if (mi_open_datafile(&info, share, old_info->dfile))
429 have_rtree= old_info->rtree_recursion_state != NULL;
433 if (!drizzled::memory::multi_malloc(MY_WME,
435 &info.blobs,
sizeof(
MI_BLOB)*share->base.blobs,
436 &info.buff,(share->base.max_key_block_length*2+
437 share->base.max_key_length),
438 &info.lastkey,share->base.max_key_length*3+1,
439 &info.first_mbr_key, share->base.max_key_length,
440 &info.filename, identifier.getPath().length()+1,
441 &info.rtree_recursion_state,have_rtree ? 1024 : 0,
447 info.rtree_recursion_state= NULL;
449 strcpy(info.filename, identifier.getPath().c_str());
450 memcpy(info.blobs,share->blobs,
sizeof(
MI_BLOB)*share->base.blobs);
451 info.lastkey2=info.lastkey+share->base.max_key_length;
454 info.lastpos= HA_OFFSET_ERROR;
455 info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND);
456 info.opt_flag=READ_CHECK_USED;
457 info.this_unique= (ulong) info.dfile;
458 if (share->data_file_type == COMPRESSED_RECORD)
459 info.this_unique= share->state.unique;
461 info.last_unique= share->state.unique;
462 info.last_loop= share->state.update_count;
463 if (mode == O_RDONLY)
464 share->options|=HA_OPTION_READ_ONLY_DATA;
465 info.lock_type=F_UNLCK;
470 info.read_record=share->read_record;
472 share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
473 if (share->options & HA_OPTION_READ_ONLY_DATA)
475 info.lock_type=F_RDLCK;
479 if ((open_flags & HA_OPEN_TMP_TABLE) ||
480 (share->options & HA_OPTION_TMP_TABLE))
482 share->temporary=share->delay_key_write=1;
483 share->write_flag=MYF(MY_NABP);
494 info.lock_type=F_WRLCK;
497 share->delay_key_write= 1;
498 info.state= &share->state.state;
503 if (!mi_alloc_rec_buff(&info, SIZE_MAX, &info.rec_buff))
505 memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
508 myisam_open_list.push_front(m_info);
510 THR_LOCK_myisam.unlock();
515 save_errno=errno ? errno : HA_ERR_END_OF_FILE;
516 if ((save_errno == HA_ERR_CRASHED) ||
517 (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
518 (save_errno == HA_ERR_CRASHED_ON_REPAIR))
519 mi_report_error(save_errno, identifier.getPath().c_str());
522 free((
unsigned char*) m_info);
525 internal::my_close(info.dfile,MYF(0));
530 free((
unsigned char*) share);
535 internal::my_close(kfile,MYF(0));
541 THR_LOCK_myisam.unlock();
547 unsigned char *mi_alloc_rec_buff(
MI_INFO *info,
size_t length,
unsigned char **buf)
550 uint32_t old_length= 0;
552 if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
554 unsigned char *newptr = *buf;
557 if (length == SIZE_MAX)
559 if (info->s->options & HA_OPTION_COMPRESS_RECORD)
560 length= max(info->s->base.pack_reclength, info->s->max_pack_length);
562 length= info->s->base.pack_reclength;
563 length= max((uint32_t)length, info->s->base.max_key_length);
565 if (newptr && length == old_length)
569 extra= ((info->s->options & HA_OPTION_PACK_RECORD) ?
570 ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
571 MI_REC_BUFF_OFFSET : 0);
573 newptr-= MI_REC_BUFF_OFFSET;
574 void *tmpnewptr= NULL;
575 if (!(tmpnewptr= realloc(newptr, length+extra+8)))
577 newptr= (
unsigned char *)tmpnewptr;
578 *((uint32_t *) newptr)= (uint32_t) length;
579 *buf= newptr+(extra ? MI_REC_BUFF_OFFSET : 0);
585 static uint64_t mi_safe_mul(uint64_t a, uint64_t b)
587 uint64_t max_val= ~ (uint64_t) 0;
589 if (!a || max_val / a < b)
598 if (share->options & HA_OPTION_PACK_RECORD)
600 share->read_record=_mi_read_dynamic_record;
601 share->read_rnd=_mi_read_rnd_dynamic_record;
602 share->delete_record=_mi_delete_dynamic_record;
603 share->compare_record=_mi_cmp_dynamic_record;
604 share->compare_unique=_mi_cmp_dynamic_unique;
605 share->calc_checksum= mi_checksum;
608 share->base.pack_reclength+= share->base.pack_bits;
609 if (share->base.blobs)
611 share->update_record=_mi_update_blob_record;
612 share->write_record=_mi_write_blob_record;
616 share->write_record=_mi_write_dynamic_record;
617 share->update_record=_mi_update_dynamic_record;
622 share->read_record=_mi_read_static_record;
623 share->read_rnd=_mi_read_rnd_static_record;
624 share->delete_record=_mi_delete_static_record;
625 share->compare_record=_mi_cmp_static_record;
626 share->update_record=_mi_update_static_record;
627 share->write_record=_mi_write_static_record;
628 share->compare_unique=_mi_cmp_static_unique;
629 share->calc_checksum= mi_static_checksum;
631 share->file_read= mi_nommap_pread;
632 share->file_write= mi_nommap_pwrite;
633 share->calc_checksum=0;
637 static void setup_key_functions(
register MI_KEYDEF *keyinfo)
640 keyinfo->ck_insert = _mi_ck_write;
641 keyinfo->ck_delete = _mi_ck_delete;
643 if (keyinfo->flag & HA_BINARY_PACK_KEY)
645 keyinfo->bin_search=_mi_seq_search;
646 keyinfo->get_key=_mi_get_binary_pack_key;
647 keyinfo->pack_key=_mi_calc_bin_pack_key_length;
648 keyinfo->store_key=_mi_store_bin_pack_key;
650 else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
652 keyinfo->get_key= _mi_get_pack_key;
653 if (keyinfo->seg[0].flag & HA_PACK_KEY)
663 if (not keyinfo->seg->charset || keyinfo->seg->charset->use_strnxfrm() ||
664 (keyinfo->seg->flag & HA_NULL_PART) ||
665 (keyinfo->seg->charset->mbminlen > 1))
666 keyinfo->bin_search=_mi_seq_search;
668 keyinfo->bin_search=_mi_prefix_search;
669 keyinfo->pack_key=_mi_calc_var_pack_key_length;
670 keyinfo->store_key=_mi_store_var_pack_key;
674 keyinfo->bin_search=_mi_seq_search;
675 keyinfo->pack_key=_mi_calc_var_key_length;
676 keyinfo->store_key=_mi_store_static_key;
681 keyinfo->bin_search=_mi_bin_search;
682 keyinfo->get_key=_mi_get_static_key;
683 keyinfo->pack_key=_mi_calc_static_key_length;
684 keyinfo->store_key=_mi_store_static_key;
694 uint32_t mi_state_info_write(
int file,
MI_STATE_INFO *state, uint32_t pWrite)
696 unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
697 unsigned char *ptr=buff;
698 uint i, keys= (uint) state->header.keys,
699 key_blocks=state->header.max_block_size_index;
701 memcpy(ptr,&state->header,
sizeof(state->header));
702 ptr+=
sizeof(state->header);
705 mi_int2store(ptr,state->open_count); ptr +=2;
706 *ptr++= (
unsigned char)state->changed; *ptr++= state->sortkey;
707 mi_rowstore(ptr,state->state.records); ptr +=8;
708 mi_rowstore(ptr,state->state.del); ptr +=8;
709 mi_rowstore(ptr,state->split); ptr +=8;
710 mi_sizestore(ptr,state->dellink); ptr +=8;
711 mi_sizestore(ptr,state->state.key_file_length); ptr +=8;
712 mi_sizestore(ptr,state->state.data_file_length); ptr +=8;
713 mi_sizestore(ptr,state->state.empty); ptr +=8;
714 mi_sizestore(ptr,state->state.key_empty); ptr +=8;
715 mi_int8store(ptr,state->auto_increment); ptr +=8;
716 mi_int8store(ptr,(uint64_t) state->state.checksum);ptr +=8;
717 mi_int4store(ptr,state->process); ptr +=4;
718 mi_int4store(ptr,state->unique); ptr +=4;
719 mi_int4store(ptr,state->status); ptr +=4;
720 mi_int4store(ptr,state->update_count); ptr +=4;
722 ptr+=state->state_diff_length;
724 for (i=0; i < keys; i++)
726 mi_sizestore(ptr,state->key_root[i]); ptr +=8;
728 for (i=0; i < key_blocks; i++)
730 mi_sizestore(ptr,state->key_del[i]); ptr +=8;
734 uint32_t key_parts= mi_uint2korr(state->header.key_parts);
735 mi_int4store(ptr,state->sec_index_changed); ptr +=4;
736 mi_int4store(ptr,state->sec_index_used); ptr +=4;
737 mi_int4store(ptr,state->version); ptr +=4;
738 mi_int8store(ptr,state->key_map); ptr +=8;
739 mi_int8store(ptr,(uint64_t) state->create_time); ptr +=8;
740 mi_int8store(ptr,(uint64_t) state->recover_time); ptr +=8;
741 mi_int8store(ptr,(uint64_t) state->check_time); ptr +=8;
742 mi_sizestore(ptr,state->rec_per_key_rows); ptr+=8;
743 for (i=0 ; i < key_parts ; i++)
745 mi_int4store(ptr,state->rec_per_key_part[i]); ptr+=4;
750 return(my_pwrite(file, buff, (
size_t) (ptr-buff), 0L,
751 MYF(MY_NABP | MY_THREADSAFE)) != 0);
752 return(internal::my_write(file, buff, (
size_t) (ptr-buff),
757 static unsigned char *mi_state_info_read(
unsigned char *ptr,
MI_STATE_INFO *state)
759 uint32_t i,keys,key_parts,key_blocks;
760 memcpy(&state->header,ptr,
sizeof(state->header));
761 ptr +=
sizeof(state->header);
762 keys=(uint) state->header.keys;
763 key_parts=mi_uint2korr(state->header.key_parts);
764 key_blocks=state->header.max_block_size_index;
766 state->open_count = mi_uint2korr(ptr); ptr +=2;
767 state->changed= *ptr++;
768 state->sortkey = (uint) *ptr++;
769 state->state.records= mi_rowkorr(ptr); ptr +=8;
770 state->state.del = mi_rowkorr(ptr); ptr +=8;
771 state->split = mi_rowkorr(ptr); ptr +=8;
772 state->dellink= mi_sizekorr(ptr); ptr +=8;
773 state->state.key_file_length = mi_sizekorr(ptr); ptr +=8;
774 state->state.data_file_length= mi_sizekorr(ptr); ptr +=8;
775 state->state.empty = mi_sizekorr(ptr); ptr +=8;
776 state->state.key_empty= mi_sizekorr(ptr); ptr +=8;
777 state->auto_increment=mi_uint8korr(ptr); ptr +=8;
778 state->state.checksum=(ha_checksum) mi_uint8korr(ptr); ptr +=8;
779 state->process= mi_uint4korr(ptr); ptr +=4;
780 state->unique = mi_uint4korr(ptr); ptr +=4;
781 state->status = mi_uint4korr(ptr); ptr +=4;
782 state->update_count=mi_uint4korr(ptr); ptr +=4;
784 ptr+= state->state_diff_length;
786 for (i=0; i < keys; i++)
788 state->key_root[i]= mi_sizekorr(ptr); ptr +=8;
790 for (i=0; i < key_blocks; i++)
792 state->key_del[i] = mi_sizekorr(ptr); ptr +=8;
794 state->sec_index_changed = mi_uint4korr(ptr); ptr +=4;
795 state->sec_index_used = mi_uint4korr(ptr); ptr +=4;
796 state->version = mi_uint4korr(ptr); ptr +=4;
797 state->key_map = mi_uint8korr(ptr); ptr +=8;
798 state->create_time = (time_t) mi_sizekorr(ptr); ptr +=8;
799 state->recover_time =(time_t) mi_sizekorr(ptr); ptr +=8;
800 state->check_time = (time_t) mi_sizekorr(ptr); ptr +=8;
801 state->rec_per_key_rows=mi_sizekorr(ptr); ptr +=8;
802 for (i=0 ; i < key_parts ; i++)
804 state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4;
810 uint32_t mi_state_info_read_dsk(
int file,
MI_STATE_INFO *state,
bool pRead)
812 unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
816 if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
819 else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))
821 mi_state_info_read(buff, state);
831 uint32_t mi_base_info_write(
int file,
MI_BASE_INFO *base)
833 unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
835 mi_sizestore(ptr,base->keystart); ptr +=8;
836 mi_sizestore(ptr,base->max_data_file_length); ptr +=8;
837 mi_sizestore(ptr,base->max_key_file_length); ptr +=8;
838 mi_rowstore(ptr,base->records); ptr +=8;
839 mi_rowstore(ptr,base->reloc); ptr +=8;
840 mi_int4store(ptr,base->mean_row_length); ptr +=4;
841 mi_int4store(ptr,base->reclength); ptr +=4;
842 mi_int4store(ptr,base->pack_reclength); ptr +=4;
843 mi_int4store(ptr,base->min_pack_length); ptr +=4;
844 mi_int4store(ptr,base->max_pack_length); ptr +=4;
845 mi_int4store(ptr,base->min_block_length); ptr +=4;
846 mi_int4store(ptr,base->fields); ptr +=4;
847 mi_int4store(ptr,base->pack_fields); ptr +=4;
848 *ptr++=base->rec_reflength;
849 *ptr++=base->key_reflength;
851 *ptr++=base->auto_key;
852 mi_int2store(ptr,base->pack_bits); ptr +=2;
853 mi_int2store(ptr,base->blobs); ptr +=2;
854 mi_int2store(ptr,base->max_key_block_length); ptr +=2;
855 mi_int2store(ptr,base->max_key_length); ptr +=2;
856 mi_int2store(ptr,base->extra_alloc_bytes); ptr +=2;
857 *ptr++= base->extra_alloc_procent;
860 mi_int2store(ptr,UINT16_C(0)); ptr +=2;
861 mi_int4store(ptr,UINT32_C(0)); ptr +=4;
863 memset(ptr, 0, 6); ptr +=6;
864 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
868 static unsigned char *my_n_base_info_read(
unsigned char *ptr,
MI_BASE_INFO *base)
870 base->keystart = mi_sizekorr(ptr); ptr +=8;
871 base->max_data_file_length = mi_sizekorr(ptr); ptr +=8;
872 base->max_key_file_length = mi_sizekorr(ptr); ptr +=8;
873 base->records = (ha_rows) mi_sizekorr(ptr); ptr +=8;
874 base->reloc = (ha_rows) mi_sizekorr(ptr); ptr +=8;
875 base->mean_row_length = mi_uint4korr(ptr); ptr +=4;
876 base->reclength = mi_uint4korr(ptr); ptr +=4;
877 base->pack_reclength = mi_uint4korr(ptr); ptr +=4;
878 base->min_pack_length = mi_uint4korr(ptr); ptr +=4;
879 base->max_pack_length = mi_uint4korr(ptr); ptr +=4;
880 base->min_block_length = mi_uint4korr(ptr); ptr +=4;
881 base->fields = mi_uint4korr(ptr); ptr +=4;
882 base->pack_fields = mi_uint4korr(ptr); ptr +=4;
884 base->rec_reflength = *ptr++;
885 base->key_reflength = *ptr++;
887 base->auto_key= *ptr++;
888 base->pack_bits = mi_uint2korr(ptr); ptr +=2;
889 base->blobs = mi_uint2korr(ptr); ptr +=2;
890 base->max_key_block_length= mi_uint2korr(ptr); ptr +=2;
891 base->max_key_length = mi_uint2korr(ptr); ptr +=2;
892 base->extra_alloc_bytes = mi_uint2korr(ptr); ptr +=2;
893 base->extra_alloc_procent = *ptr++;
906 uint32_t mi_keydef_write(
int file,
MI_KEYDEF *keydef)
908 unsigned char buff[MI_KEYDEF_SIZE];
909 unsigned char *ptr=buff;
911 *ptr++ = (
unsigned char) keydef->keysegs;
912 *ptr++ = keydef->key_alg;
913 mi_int2store(ptr,keydef->flag); ptr +=2;
914 mi_int2store(ptr,keydef->block_length); ptr +=2;
915 mi_int2store(ptr,keydef->keylength); ptr +=2;
916 mi_int2store(ptr,keydef->minlength); ptr +=2;
917 mi_int2store(ptr,keydef->maxlength); ptr +=2;
918 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
921 static unsigned char *mi_keydef_read(
unsigned char *ptr,
MI_KEYDEF *keydef)
923 keydef->keysegs = (uint) *ptr++;
924 keydef->key_alg = *ptr++;
926 keydef->flag = mi_uint2korr(ptr); ptr +=2;
927 keydef->block_length = mi_uint2korr(ptr); ptr +=2;
928 keydef->keylength = mi_uint2korr(ptr); ptr +=2;
929 keydef->minlength = mi_uint2korr(ptr); ptr +=2;
930 keydef->maxlength = mi_uint2korr(ptr); ptr +=2;
931 keydef->block_size_index= keydef->block_length/MI_MIN_KEY_BLOCK_LENGTH-1;
932 keydef->underflow_block_length=keydef->block_length/3;
941 int mi_keyseg_write(
int file,
const HA_KEYSEG *keyseg)
943 unsigned char buff[HA_KEYSEG_SIZE];
944 unsigned char *ptr=buff;
947 *ptr++= keyseg->type;
948 *ptr++= keyseg->language;
949 *ptr++= keyseg->null_bit;
950 *ptr++= keyseg->bit_start;
951 *ptr++= keyseg->bit_end;
952 *ptr++= keyseg->bit_length;
953 mi_int2store(ptr,keyseg->flag); ptr+=2;
954 mi_int2store(ptr,keyseg->length); ptr+=2;
955 mi_int4store(ptr,keyseg->start); ptr+=4;
956 pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
957 mi_int4store(ptr, pos);
960 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
964 static unsigned char *mi_keyseg_read(
unsigned char *ptr,
HA_KEYSEG *keyseg)
966 keyseg->type = *ptr++;
967 keyseg->language = *ptr++;
968 keyseg->null_bit = *ptr++;
969 keyseg->bit_start = *ptr++;
970 keyseg->bit_end = *ptr++;
971 keyseg->bit_length = *ptr++;
972 keyseg->flag = mi_uint2korr(ptr); ptr +=2;
973 keyseg->length = mi_uint2korr(ptr); ptr +=2;
974 keyseg->start = mi_uint4korr(ptr); ptr +=4;
975 keyseg->null_pos = mi_uint4korr(ptr); ptr +=4;
977 if (keyseg->null_bit)
978 keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
981 keyseg->bit_pos= (uint16_t)keyseg->null_pos;
991 uint32_t mi_uniquedef_write(
int file,
MI_UNIQUEDEF *def)
993 unsigned char buff[MI_UNIQUEDEF_SIZE];
994 unsigned char *ptr=buff;
996 mi_int2store(ptr,def->keysegs); ptr+=2;
997 *ptr++= (
unsigned char) def->key;
998 *ptr++ = (
unsigned char) def->null_are_equal;
1000 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1003 static unsigned char *mi_uniquedef_read(
unsigned char *ptr,
MI_UNIQUEDEF *def)
1005 def->keysegs = mi_uint2korr(ptr);
1007 def->null_are_equal=ptr[3];
1015 uint32_t mi_recinfo_write(
int file,
MI_COLUMNDEF *recinfo)
1017 unsigned char buff[MI_COLUMNDEF_SIZE];
1018 unsigned char *ptr=buff;
1020 mi_int2store(ptr,recinfo->type); ptr +=2;
1021 mi_int2store(ptr,recinfo->length); ptr +=2;
1022 *ptr++ = recinfo->null_bit;
1023 mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
1024 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1027 static unsigned char *mi_recinfo_read(
unsigned char *ptr,
MI_COLUMNDEF *recinfo)
1029 recinfo->type= mi_sint2korr(ptr); ptr +=2;
1030 recinfo->length=mi_uint2korr(ptr); ptr +=2;
1031 recinfo->null_bit= (uint8_t) *ptr++;
1032 recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1048 info->dfile=internal::my_open(share->data_file_name, share->mode,
1050 return info->dfile >= 0 ? 0 : 1;
1056 if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,
1077 int mi_disable_indexes(
MI_INFO *info)
1081 mi_clear_all_keys_active(share->state.key_map);
1105 int mi_enable_indexes(
MI_INFO *info)
1110 if (share->state.state.data_file_length ||
1111 (share->state.state.key_file_length != share->base.keystart))
1113 mi_print_error(info->s, HA_ERR_CRASHED);
1114 error= HA_ERR_CRASHED;
1117 mi_set_all_keys_active(share->state.key_map, share->base.keys);
1138 int mi_indexes_are_disabled(
MI_INFO *info)
1147 if (!share->base.keys ||
1148 (mi_is_all_keys_active(share->state.key_map, share->base.keys)))
1152 if (mi_is_any_key_active(share->state.key_map))
TODO: Rename this file - func.h is stupid.