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>
36static void setup_key_functions(MI_KEYDEF *keyinfo);
37static unsigned char *mi_keydef_read(
unsigned char *ptr, MI_KEYDEF *keydef);
38static unsigned char *mi_keyseg_read(
unsigned char *ptr, HA_KEYSEG *keyseg);
39static unsigned char *mi_recinfo_read(
unsigned char *ptr, MI_COLUMNDEF *recinfo);
40static uint64_t mi_safe_mul(uint64_t a, uint64_t b);
41static unsigned char *mi_state_info_read(
unsigned char *ptr, MI_STATE_INFO *state);
42static unsigned char *mi_uniquedef_read(
unsigned char *ptr, MI_UNIQUEDEF *def);
43static 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; \
58MI_INFO *test_if_reopen(
char *filename)
60 list<MI_INFO *>::iterator it= myisam_open_list.begin();
61 while (it != myisam_open_list.end())
64 MYISAM_SHARE *share=info->s;
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;
91 MI_INFO info= MI_INFO(), *m_info, *old_info;
92 boost::scoped_ptr<MYISAM_SHARE> share_buff_ap(
new MYISAM_SHARE);
93 MYISAM_SHARE &share_buff= *share_buff_ap.get();
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);
105 (void)internal::fn_format(org_name,
106 identifier.getPath().c_str(),
111 rp_buff = realpath(org_name,NULL);
114 internal::my_load_path(name_buff,org_name, NULL);
116 if (strlen(rp_buff)>=FN_REFLEN) rp_buff[FN_REFLEN-1]=
'\0';
117 strcpy(name_buff,rp_buff);
121 THR_LOCK_myisam.lock();
122 if (!(old_info=test_if_reopen(name_buff)))
125 memset(&share_buff, 0,
sizeof(share_buff));
126 share_buff.state.rec_per_key_part=rec_per_key_part;
127 share_buff.state.key_root=key_root;
128 share_buff.state.key_del=key_del;
130 if ((kfile=internal::my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
132 if ((errno != EROFS && errno != EACCES) ||
134 (kfile=internal::my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
137 share->mode=open_mode;
139 if (internal::my_read(kfile, share->state.header.file_version, head_length,
142 errno= HA_ERR_NOT_A_TABLE;
145 if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
147 errno=HA_ERR_NOT_A_TABLE;
150 share->options= mi_uint2korr(share->state.header.options);
151 static const uint64_t OLD_FILE_OPTIONS= HA_OPTION_PACK_RECORD |
152 HA_OPTION_PACK_KEYS |
153 HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
154 HA_OPTION_TEMP_COMPRESS_RECORD |
156 if (share->options & ~OLD_FILE_OPTIONS)
158 errno=HA_ERR_OLD_FILE;
163 ssize_t sym_link_size= readlink(org_name,index_name,FN_REFLEN-1);
164 if (sym_link_size >= 0 )
165 index_name[sym_link_size]=
'\0';
166 if (!strcmp(name_buff, org_name) || sym_link_size == -1)
167 (void) strcpy(index_name, org_name);
168 *strrchr(org_name,
'.')=
'\0';
169 (void) internal::fn_format(data_name,org_name,
"",MI_NAME_DEXT,
170 MY_APPEND_EXT|MY_UNPACK_FILENAME);
172 info_length=mi_uint2korr(share->state.header.header_length);
173 base_pos=mi_uint2korr(share->state.header.base_pos);
174 if (!(disk_cache= (
unsigned char*) malloc(info_length+128)))
179 end_pos=disk_cache+info_length;
182 lseek(kfile,0,SEEK_SET);
184 if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
186 errno=HA_ERR_CRASHED;
189 len=mi_uint2korr(share->state.header.state_info_length);
190 keys= (uint) share->state.header.keys;
191 uniques= (uint) share->state.header.uniques;
192 key_parts= mi_uint2korr(share->state.header.key_parts);
193 unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
194 share->state_diff_length=len-MI_STATE_INFO_SIZE;
196 mi_state_info_read(disk_cache, &share->state);
197 len= mi_uint2korr(share->state.header.base_info_length);
198 disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
199 share->state.state_length=base_pos;
201 if (share->state.changed & STATE_CRASHED)
203 errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
204 HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
209 if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
211 errno=HA_ERR_CRASHED;
215 if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
216 key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
218 errno=HA_ERR_UNSUPPORTED;
223 max_data_file_length=
224 (share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
225 (((uint64_t) 1 << (share->base.rec_reflength*8))-1) :
226 (mi_safe_mul(share->base.pack_reclength,
227 (uint64_t) 1 << (share->base.rec_reflength*8))-1);
229 mi_safe_mul(MI_MIN_KEY_BLOCK_LENGTH,
230 ((uint64_t) 1 << (share->base.key_reflength*8))-1);
232 set_if_smaller(max_data_file_length, INT32_MAX);
233 set_if_smaller(max_key_file_length, INT32_MAX);
235 if (share->base.raid_type)
237 errno=HA_ERR_UNSUPPORTED;
240 share->base.max_data_file_length=(internal::my_off_t) max_data_file_length;
241 share->base.max_key_file_length=(internal::my_off_t) max_key_file_length;
243 if (share->options & HA_OPTION_COMPRESS_RECORD)
244 share->base.max_key_length+=2;
247 share->base.max_key_length+= share->base.key_reflength;
249 if (!drizzled::memory::multi_malloc(
false,
250 &share,
sizeof(*share),
251 &share->state.rec_per_key_part,
sizeof(
long)*key_parts,
252 &share->keyinfo,keys*
sizeof(MI_KEYDEF),
253 &share->uniqueinfo,uniques*
sizeof(MI_UNIQUEDEF),
255 (key_parts+unique_key_parts+keys+uniques) *
sizeof(HA_KEYSEG),
256 &share->rec, (share->base.fields+1)*
sizeof(MI_COLUMNDEF),
257 &share->blobs,
sizeof(MI_BLOB)*share->base.blobs,
258 &share->unique_file_name,strlen(name_buff)+1,
259 &share->index_file_name,strlen(index_name)+1,
260 &share->data_file_name,strlen(data_name)+1,
261 &share->state.key_root,keys*
sizeof(uint64_t),
262 &share->state.key_del,
263 (share->state.header.max_block_size_index*
sizeof(uint64_t)),
268 memcpy(share->state.rec_per_key_part, rec_per_key_part,
269 sizeof(
long)*key_parts);
270 memcpy(share->state.key_root, key_root,
271 sizeof(internal::my_off_t)*keys);
272 memcpy(share->state.key_del, key_del,
273 sizeof(internal::my_off_t) * share->state.header.max_block_size_index);
274 strcpy(share->unique_file_name, name_buff);
275 share->unique_name_length= strlen(name_buff);
276 strcpy(share->index_file_name, index_name);
277 strcpy(share->data_file_name, data_name);
279 share->blocksize=min((uint32_t)IO_SIZE,myisam_block_size);
281 HA_KEYSEG *pos=share->keyparts;
282 for (i=0 ; i < keys ; i++)
284 share->keyinfo[i].share= share;
285 disk_pos=mi_keydef_read(disk_pos, &share->keyinfo[i]);
286 disk_pos_assert(disk_pos + share->keyinfo[i].keysegs * HA_KEYSEG_SIZE,
288 set_if_smaller(share->blocksize,(uint)share->keyinfo[i].block_length);
289 share->keyinfo[i].seg=pos;
290 for (j=0 ; j < share->keyinfo[i].keysegs; j++,pos++)
292 disk_pos=mi_keyseg_read(disk_pos, pos);
293 if (pos->flag & HA_BLOB_PART &&
294 ! (share->options & (HA_OPTION_COMPRESS_RECORD |
295 HA_OPTION_PACK_RECORD)))
297 errno= HA_ERR_CRASHED;
300 if (pos->type == HA_KEYTYPE_TEXT ||
301 pos->type == HA_KEYTYPE_VARTEXT1 ||
302 pos->type == HA_KEYTYPE_VARTEXT2)
305 pos->charset=default_charset_info;
306 else if (!(pos->charset= get_charset(pos->language)))
308 errno=HA_ERR_UNKNOWN_CHARSET;
312 else if (pos->type == HA_KEYTYPE_BINARY)
313 pos->charset= &my_charset_bin;
315 setup_key_functions(share->keyinfo+i);
316 share->keyinfo[i].end=pos;
317 pos->type=HA_KEYTYPE_END;
318 pos->length=share->base.rec_reflength;
323 for (i=0 ; i < uniques ; i++)
325 disk_pos=mi_uniquedef_read(disk_pos, &share->uniqueinfo[i]);
326 disk_pos_assert(disk_pos + share->uniqueinfo[i].keysegs *
327 HA_KEYSEG_SIZE, end_pos);
328 share->uniqueinfo[i].seg=pos;
329 for (j=0 ; j < share->uniqueinfo[i].keysegs; j++,pos++)
331 disk_pos=mi_keyseg_read(disk_pos, pos);
332 if (pos->type == HA_KEYTYPE_TEXT ||
333 pos->type == HA_KEYTYPE_VARTEXT1 ||
334 pos->type == HA_KEYTYPE_VARTEXT2)
337 pos->charset=default_charset_info;
338 else if (!(pos->charset= get_charset(pos->language)))
340 errno=HA_ERR_UNKNOWN_CHARSET;
345 share->uniqueinfo[i].end=pos;
346 pos->type=HA_KEYTYPE_END;
353 disk_pos_assert(disk_pos + share->base.fields *MI_COLUMNDEF_SIZE, end_pos);
354 for (i=j=offset=0 ; i < share->base.fields ; i++)
356 disk_pos=mi_recinfo_read(disk_pos,&share->rec[i]);
357 share->rec[i].pack_type=0;
358 share->rec[i].huff_tree=0;
359 share->rec[i].offset=offset;
360 if (share->rec[i].type == (
int) FIELD_BLOB)
362 share->blobs[j].pack_length=
363 share->rec[i].length-portable_sizeof_char_ptr;
364 share->blobs[j].offset=offset;
367 offset+=share->rec[i].length;
369 share->rec[i].type=(int) FIELD_LAST;
370 if (offset > share->base.reclength)
372 errno= HA_ERR_CRASHED;
381 if (mi_open_datafile(&info, share, -1))
386 share->this_process=(ulong) getpid();
387 share->last_process= share->state.process;
388 share->base.key_parts=key_parts;
389 share->base.all_key_parts=key_parts+unique_key_parts;
390 if (!(share->last_version=share->state.version))
391 share->last_version=1;
392 share->rec_reflength=share->base.rec_reflength;
393 share->base.margin_key_file_length=(share->base.max_key_file_length -
394 (keys ? MI_INDEX_BLOCK_MARGIN *
395 share->blocksize * keys : 0));
396 share->blocksize=min((uint32_t)IO_SIZE,myisam_block_size);
397 share->data_file_type=STATIC_RECORD;
398 if (share->options & HA_OPTION_PACK_RECORD)
399 share->data_file_type = DYNAMIC_RECORD;
402 mi_setup_functions(share);
403 share->is_log_table=
false;
404 if (myisam_concurrent_insert)
406 share->concurrent_insert=
407 ((share->options & (HA_OPTION_READ_ONLY_DATA | HA_OPTION_TMP_TABLE |
408 HA_OPTION_COMPRESS_RECORD |
409 HA_OPTION_TEMP_COMPRESS_RECORD)) ||
410 (open_flags & HA_OPEN_TMP_TABLE) || have_rtree) ? 0 : 1;
411 if (share->concurrent_insert)
420 if (mode == O_RDWR && share->mode == O_RDONLY)
425 if (mi_open_datafile(&info, share, old_info->dfile))
428 have_rtree= old_info->rtree_recursion_state != NULL;
432 if (!drizzled::memory::multi_malloc(MY_WME,
433 &m_info,
sizeof(MI_INFO),
434 &info.blobs,
sizeof(MI_BLOB)*share->base.blobs,
435 &info.buff,(share->base.max_key_block_length*2+
436 share->base.max_key_length),
437 &info.lastkey,share->base.max_key_length*3+1,
438 &info.first_mbr_key, share->base.max_key_length,
439 &info.filename, identifier.getPath().length()+1,
440 &info.rtree_recursion_state,have_rtree ? 1024 : 0,
446 info.rtree_recursion_state= NULL;
448 strcpy(info.filename, identifier.getPath().c_str());
449 memcpy(info.blobs,share->blobs,
sizeof(MI_BLOB)*share->base.blobs);
450 info.lastkey2=info.lastkey+share->base.max_key_length;
453 info.lastpos= HA_OFFSET_ERROR;
454 info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND);
455 info.opt_flag=READ_CHECK_USED;
456 info.this_unique= (ulong) info.dfile;
457 if (share->data_file_type == COMPRESSED_RECORD)
458 info.this_unique= share->state.unique;
460 info.last_unique= share->state.unique;
461 info.last_loop= share->state.update_count;
462 if (mode == O_RDONLY)
463 share->options|=HA_OPTION_READ_ONLY_DATA;
464 info.lock_type=F_UNLCK;
469 info.read_record=share->read_record;
471 share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
472 if (share->options & HA_OPTION_READ_ONLY_DATA)
474 info.lock_type=F_RDLCK;
478 if ((open_flags & HA_OPEN_TMP_TABLE) ||
479 (share->options & HA_OPTION_TMP_TABLE))
481 share->temporary=share->delay_key_write=1;
482 share->write_flag=MYF(MY_NABP);
493 info.lock_type=F_WRLCK;
496 share->delay_key_write= 1;
497 info.state= &share->state.state;
502 if (!mi_alloc_rec_buff(&info, SIZE_MAX, &info.rec_buff))
504 memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
507 myisam_open_list.push_front(m_info);
509 THR_LOCK_myisam.unlock();
514 save_errno=errno ? errno : HA_ERR_END_OF_FILE;
515 if ((save_errno == HA_ERR_CRASHED) ||
516 (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
517 (save_errno == HA_ERR_CRASHED_ON_REPAIR))
518 mi_report_error(save_errno, identifier.getPath().c_str());
521 free((
unsigned char*) m_info);
524 internal::my_close(info.dfile,MYF(0));
529 free((
unsigned char*) share);
534 internal::my_close(kfile,MYF(0));
540 THR_LOCK_myisam.unlock();
546unsigned char *mi_alloc_rec_buff(MI_INFO *info,
size_t length,
unsigned char **buf)
549 uint32_t old_length= 0;
551 if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
553 unsigned char *newptr = *buf;
556 if (length == SIZE_MAX)
558 if (info->s->options & HA_OPTION_COMPRESS_RECORD)
559 length= max(info->s->base.pack_reclength, info->s->max_pack_length);
561 length= info->s->base.pack_reclength;
562 length= max((uint32_t)length, info->s->base.max_key_length);
564 if (newptr && length == old_length)
568 extra= ((info->s->options & HA_OPTION_PACK_RECORD) ?
569 ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
570 MI_REC_BUFF_OFFSET : 0);
572 newptr-= MI_REC_BUFF_OFFSET;
573 void *tmpnewptr= NULL;
574 if (!(tmpnewptr= realloc(newptr, length+extra+8)))
576 newptr= (
unsigned char *)tmpnewptr;
577 *((uint32_t *) newptr)= (uint32_t) length;
578 *buf= newptr+(extra ? MI_REC_BUFF_OFFSET : 0);
584static uint64_t mi_safe_mul(uint64_t a, uint64_t b)
586 uint64_t max_val= ~ (uint64_t) 0;
588 if (!a || max_val / a < b)
595void mi_setup_functions(MYISAM_SHARE *share)
597 if (share->options & HA_OPTION_PACK_RECORD)
599 share->read_record=_mi_read_dynamic_record;
600 share->read_rnd=_mi_read_rnd_dynamic_record;
601 share->delete_record=_mi_delete_dynamic_record;
602 share->compare_record=_mi_cmp_dynamic_record;
603 share->compare_unique=_mi_cmp_dynamic_unique;
604 share->calc_checksum= mi_checksum;
607 share->base.pack_reclength+= share->base.pack_bits;
608 if (share->base.blobs)
610 share->update_record=_mi_update_blob_record;
611 share->write_record=_mi_write_blob_record;
615 share->write_record=_mi_write_dynamic_record;
616 share->update_record=_mi_update_dynamic_record;
621 share->read_record=_mi_read_static_record;
622 share->read_rnd=_mi_read_rnd_static_record;
623 share->delete_record=_mi_delete_static_record;
624 share->compare_record=_mi_cmp_static_record;
625 share->update_record=_mi_update_static_record;
626 share->write_record=_mi_write_static_record;
627 share->compare_unique=_mi_cmp_static_unique;
628 share->calc_checksum= mi_static_checksum;
630 share->file_read= mi_nommap_pread;
631 share->file_write= mi_nommap_pwrite;
632 share->calc_checksum=0;
636static void setup_key_functions(MI_KEYDEF *keyinfo)
639 keyinfo->ck_insert = _mi_ck_write;
640 keyinfo->ck_delete = _mi_ck_delete;
642 if (keyinfo->flag & HA_BINARY_PACK_KEY)
644 keyinfo->bin_search=_mi_seq_search;
645 keyinfo->get_key=_mi_get_binary_pack_key;
646 keyinfo->pack_key=_mi_calc_bin_pack_key_length;
647 keyinfo->store_key=_mi_store_bin_pack_key;
649 else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
651 keyinfo->get_key= _mi_get_pack_key;
652 if (keyinfo->seg[0].flag & HA_PACK_KEY)
662 if (not keyinfo->seg->charset || keyinfo->seg->charset->use_strnxfrm() ||
663 (keyinfo->seg->flag & HA_NULL_PART) ||
664 (keyinfo->seg->charset->mbminlen > 1))
665 keyinfo->bin_search=_mi_seq_search;
667 keyinfo->bin_search=_mi_prefix_search;
668 keyinfo->pack_key=_mi_calc_var_pack_key_length;
669 keyinfo->store_key=_mi_store_var_pack_key;
673 keyinfo->bin_search=_mi_seq_search;
674 keyinfo->pack_key=_mi_calc_var_key_length;
675 keyinfo->store_key=_mi_store_static_key;
680 keyinfo->bin_search=_mi_bin_search;
681 keyinfo->get_key=_mi_get_static_key;
682 keyinfo->pack_key=_mi_calc_static_key_length;
683 keyinfo->store_key=_mi_store_static_key;
693uint32_t mi_state_info_write(
int file, MI_STATE_INFO *state, uint32_t pWrite)
695 unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
696 unsigned char *ptr=buff;
697 uint i, keys= (uint) state->header.keys,
698 key_blocks=state->header.max_block_size_index;
700 memcpy(ptr,&state->header,
sizeof(state->header));
701 ptr+=
sizeof(state->header);
704 mi_int2store(ptr,state->open_count); ptr +=2;
705 *ptr++= (
unsigned char)state->changed; *ptr++= state->sortkey;
706 mi_rowstore(ptr,state->state.records); ptr +=8;
707 mi_rowstore(ptr,state->state.del); ptr +=8;
708 mi_rowstore(ptr,state->split); ptr +=8;
709 mi_sizestore(ptr,state->dellink); ptr +=8;
710 mi_sizestore(ptr,state->state.key_file_length); ptr +=8;
711 mi_sizestore(ptr,state->state.data_file_length); ptr +=8;
712 mi_sizestore(ptr,state->state.empty); ptr +=8;
713 mi_sizestore(ptr,state->state.key_empty); ptr +=8;
714 mi_int8store(ptr,state->auto_increment); ptr +=8;
715 mi_int8store(ptr,(uint64_t) state->state.checksum);ptr +=8;
716 mi_int4store(ptr,state->process); ptr +=4;
717 mi_int4store(ptr,state->unique); ptr +=4;
718 mi_int4store(ptr,state->status); ptr +=4;
719 mi_int4store(ptr,state->update_count); ptr +=4;
721 ptr+=state->state_diff_length;
723 for (i=0; i < keys; i++)
725 mi_sizestore(ptr,state->key_root[i]); ptr +=8;
727 for (i=0; i < key_blocks; i++)
729 mi_sizestore(ptr,state->key_del[i]); ptr +=8;
733 uint32_t key_parts= mi_uint2korr(state->header.key_parts);
734 mi_int4store(ptr,state->sec_index_changed); ptr +=4;
735 mi_int4store(ptr,state->sec_index_used); ptr +=4;
736 mi_int4store(ptr,state->version); ptr +=4;
737 mi_int8store(ptr,state->key_map); ptr +=8;
738 mi_int8store(ptr,(uint64_t) state->create_time); ptr +=8;
739 mi_int8store(ptr,(uint64_t) state->recover_time); ptr +=8;
740 mi_int8store(ptr,(uint64_t) state->check_time); ptr +=8;
741 mi_sizestore(ptr,state->rec_per_key_rows); ptr+=8;
742 for (i=0 ; i < key_parts ; i++)
744 mi_int4store(ptr,state->rec_per_key_part[i]); ptr+=4;
749 return(my_pwrite(file, buff, (
size_t) (ptr-buff), 0L,
750 MYF(MY_NABP | MY_THREADSAFE)) != 0);
751 return(internal::my_write(file, buff, (
size_t) (ptr-buff),
756static unsigned char *mi_state_info_read(
unsigned char *ptr, MI_STATE_INFO *state)
758 uint32_t i,keys,key_parts,key_blocks;
759 memcpy(&state->header,ptr,
sizeof(state->header));
760 ptr +=
sizeof(state->header);
761 keys=(uint) state->header.keys;
762 key_parts=mi_uint2korr(state->header.key_parts);
763 key_blocks=state->header.max_block_size_index;
765 state->open_count = mi_uint2korr(ptr); ptr +=2;
766 state->changed= *ptr++;
767 state->sortkey = (uint) *ptr++;
768 state->state.records= mi_rowkorr(ptr); ptr +=8;
769 state->state.del = mi_rowkorr(ptr); ptr +=8;
770 state->split = mi_rowkorr(ptr); ptr +=8;
771 state->dellink= mi_sizekorr(ptr); ptr +=8;
772 state->state.key_file_length = mi_sizekorr(ptr); ptr +=8;
773 state->state.data_file_length= mi_sizekorr(ptr); ptr +=8;
774 state->state.empty = mi_sizekorr(ptr); ptr +=8;
775 state->state.key_empty= mi_sizekorr(ptr); ptr +=8;
776 state->auto_increment=mi_uint8korr(ptr); ptr +=8;
777 state->state.checksum=(ha_checksum) mi_uint8korr(ptr); ptr +=8;
778 state->process= mi_uint4korr(ptr); ptr +=4;
779 state->unique = mi_uint4korr(ptr); ptr +=4;
780 state->status = mi_uint4korr(ptr); ptr +=4;
781 state->update_count=mi_uint4korr(ptr); ptr +=4;
783 ptr+= state->state_diff_length;
785 for (i=0; i < keys; i++)
787 state->key_root[i]= mi_sizekorr(ptr); ptr +=8;
789 for (i=0; i < key_blocks; i++)
791 state->key_del[i] = mi_sizekorr(ptr); ptr +=8;
793 state->sec_index_changed = mi_uint4korr(ptr); ptr +=4;
794 state->sec_index_used = mi_uint4korr(ptr); ptr +=4;
795 state->version = mi_uint4korr(ptr); ptr +=4;
796 state->key_map = mi_uint8korr(ptr); ptr +=8;
797 state->create_time = (time_t) mi_sizekorr(ptr); ptr +=8;
798 state->recover_time =(time_t) mi_sizekorr(ptr); ptr +=8;
799 state->check_time = (time_t) mi_sizekorr(ptr); ptr +=8;
800 state->rec_per_key_rows=mi_sizekorr(ptr); ptr +=8;
801 for (i=0 ; i < key_parts ; i++)
803 state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4;
809uint32_t mi_state_info_read_dsk(
int file, MI_STATE_INFO *state,
bool pRead)
811 unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
815 if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
818 else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))
820 mi_state_info_read(buff, state);
830uint32_t mi_base_info_write(
int file, MI_BASE_INFO *base)
832 unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
834 mi_sizestore(ptr,base->keystart); ptr +=8;
835 mi_sizestore(ptr,base->max_data_file_length); ptr +=8;
836 mi_sizestore(ptr,base->max_key_file_length); ptr +=8;
837 mi_rowstore(ptr,base->records); ptr +=8;
838 mi_rowstore(ptr,base->reloc); ptr +=8;
839 mi_int4store(ptr,base->mean_row_length); ptr +=4;
840 mi_int4store(ptr,base->reclength); ptr +=4;
841 mi_int4store(ptr,base->pack_reclength); ptr +=4;
842 mi_int4store(ptr,base->min_pack_length); ptr +=4;
843 mi_int4store(ptr,base->max_pack_length); ptr +=4;
844 mi_int4store(ptr,base->min_block_length); ptr +=4;
845 mi_int4store(ptr,base->fields); ptr +=4;
846 mi_int4store(ptr,base->pack_fields); ptr +=4;
847 *ptr++=base->rec_reflength;
848 *ptr++=base->key_reflength;
850 *ptr++=base->auto_key;
851 mi_int2store(ptr,base->pack_bits); ptr +=2;
852 mi_int2store(ptr,base->blobs); ptr +=2;
853 mi_int2store(ptr,base->max_key_block_length); ptr +=2;
854 mi_int2store(ptr,base->max_key_length); ptr +=2;
855 mi_int2store(ptr,base->extra_alloc_bytes); ptr +=2;
856 *ptr++= base->extra_alloc_procent;
859 mi_int2store(ptr,UINT16_C(0)); ptr +=2;
860 mi_int4store(ptr,UINT32_C(0)); ptr +=4;
862 memset(ptr, 0, 6); ptr +=6;
863 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
867static unsigned char *my_n_base_info_read(
unsigned char *ptr, MI_BASE_INFO *base)
869 base->keystart = mi_sizekorr(ptr); ptr +=8;
870 base->max_data_file_length = mi_sizekorr(ptr); ptr +=8;
871 base->max_key_file_length = mi_sizekorr(ptr); ptr +=8;
872 base->records = (ha_rows) mi_sizekorr(ptr); ptr +=8;
873 base->reloc = (ha_rows) mi_sizekorr(ptr); ptr +=8;
874 base->mean_row_length = mi_uint4korr(ptr); ptr +=4;
875 base->reclength = mi_uint4korr(ptr); ptr +=4;
876 base->pack_reclength = mi_uint4korr(ptr); ptr +=4;
877 base->min_pack_length = mi_uint4korr(ptr); ptr +=4;
878 base->max_pack_length = mi_uint4korr(ptr); ptr +=4;
879 base->min_block_length = mi_uint4korr(ptr); ptr +=4;
880 base->fields = mi_uint4korr(ptr); ptr +=4;
881 base->pack_fields = mi_uint4korr(ptr); ptr +=4;
883 base->rec_reflength = *ptr++;
884 base->key_reflength = *ptr++;
886 base->auto_key= *ptr++;
887 base->pack_bits = mi_uint2korr(ptr); ptr +=2;
888 base->blobs = mi_uint2korr(ptr); ptr +=2;
889 base->max_key_block_length= mi_uint2korr(ptr); ptr +=2;
890 base->max_key_length = mi_uint2korr(ptr); ptr +=2;
891 base->extra_alloc_bytes = mi_uint2korr(ptr); ptr +=2;
892 base->extra_alloc_procent = *ptr++;
905uint32_t mi_keydef_write(
int file, MI_KEYDEF *keydef)
907 unsigned char buff[MI_KEYDEF_SIZE];
908 unsigned char *ptr=buff;
910 *ptr++ = (
unsigned char) keydef->keysegs;
911 *ptr++ = keydef->key_alg;
912 mi_int2store(ptr,keydef->flag); ptr +=2;
913 mi_int2store(ptr,keydef->block_length); ptr +=2;
914 mi_int2store(ptr,keydef->keylength); ptr +=2;
915 mi_int2store(ptr,keydef->minlength); ptr +=2;
916 mi_int2store(ptr,keydef->maxlength); ptr +=2;
917 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
920static unsigned char *mi_keydef_read(
unsigned char *ptr, MI_KEYDEF *keydef)
922 keydef->keysegs = (uint) *ptr++;
923 keydef->key_alg = *ptr++;
925 keydef->flag = mi_uint2korr(ptr); ptr +=2;
926 keydef->block_length = mi_uint2korr(ptr); ptr +=2;
927 keydef->keylength = mi_uint2korr(ptr); ptr +=2;
928 keydef->minlength = mi_uint2korr(ptr); ptr +=2;
929 keydef->maxlength = mi_uint2korr(ptr); ptr +=2;
930 keydef->block_size_index= keydef->block_length/MI_MIN_KEY_BLOCK_LENGTH-1;
931 keydef->underflow_block_length=keydef->block_length/3;
940int mi_keyseg_write(
int file,
const HA_KEYSEG *keyseg)
942 unsigned char buff[HA_KEYSEG_SIZE];
943 unsigned char *ptr=buff;
946 *ptr++= keyseg->type;
947 *ptr++= keyseg->language;
948 *ptr++= keyseg->null_bit;
949 *ptr++= keyseg->bit_start;
950 *ptr++= keyseg->bit_end;
951 *ptr++= keyseg->bit_length;
952 mi_int2store(ptr,keyseg->flag); ptr+=2;
953 mi_int2store(ptr,keyseg->length); ptr+=2;
954 mi_int4store(ptr,keyseg->start); ptr+=4;
955 pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
956 mi_int4store(ptr, pos);
959 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
963static unsigned char *mi_keyseg_read(
unsigned char *ptr, HA_KEYSEG *keyseg)
965 keyseg->type = *ptr++;
966 keyseg->language = *ptr++;
967 keyseg->null_bit = *ptr++;
968 keyseg->bit_start = *ptr++;
969 keyseg->bit_end = *ptr++;
970 keyseg->bit_length = *ptr++;
971 keyseg->flag = mi_uint2korr(ptr); ptr +=2;
972 keyseg->length = mi_uint2korr(ptr); ptr +=2;
973 keyseg->start = mi_uint4korr(ptr); ptr +=4;
974 keyseg->null_pos = mi_uint4korr(ptr); ptr +=4;
976 if (keyseg->null_bit)
977 keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
980 keyseg->bit_pos= (uint16_t)keyseg->null_pos;
990uint32_t mi_uniquedef_write(
int file, MI_UNIQUEDEF *def)
992 unsigned char buff[MI_UNIQUEDEF_SIZE];
993 unsigned char *ptr=buff;
995 mi_int2store(ptr,def->keysegs); ptr+=2;
996 *ptr++= (
unsigned char) def->key;
997 *ptr++ = (
unsigned char) def->null_are_equal;
999 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1002static unsigned char *mi_uniquedef_read(
unsigned char *ptr, MI_UNIQUEDEF *def)
1004 def->keysegs = mi_uint2korr(ptr);
1006 def->null_are_equal=ptr[3];
1014uint32_t mi_recinfo_write(
int file, MI_COLUMNDEF *recinfo)
1016 unsigned char buff[MI_COLUMNDEF_SIZE];
1017 unsigned char *ptr=buff;
1019 mi_int2store(ptr,recinfo->type); ptr +=2;
1020 mi_int2store(ptr,recinfo->length); ptr +=2;
1021 *ptr++ = recinfo->null_bit;
1022 mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
1023 return internal::my_write(file, buff, (
size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1026static unsigned char *mi_recinfo_read(
unsigned char *ptr, MI_COLUMNDEF *recinfo)
1028 recinfo->type= mi_sint2korr(ptr); ptr +=2;
1029 recinfo->length=mi_uint2korr(ptr); ptr +=2;
1030 recinfo->null_bit= (uint8_t) *ptr++;
1031 recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1044int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share,
int file_to_dup)
1047 info->dfile=internal::my_open(share->data_file_name, share->mode,
1049 return info->dfile >= 0 ? 0 : 1;
1053int mi_open_keyfile(MYISAM_SHARE *share)
1055 if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,
1076int mi_disable_indexes(MI_INFO *info)
1078 MYISAM_SHARE *share= info->s;
1080 mi_clear_all_keys_active(share->state.key_map);
1104int mi_enable_indexes(MI_INFO *info)
1107 MYISAM_SHARE *share= info->s;
1109 if (share->state.state.data_file_length ||
1110 (share->state.state.key_file_length != share->base.keystart))
1112 mi_print_error(info->s, HA_ERR_CRASHED);
1113 error= HA_ERR_CRASHED;
1116 mi_set_all_keys_active(share->state.key_map, share->base.keys);
1137int mi_indexes_are_disabled(MI_INFO *info)
1139 MYISAM_SHARE *share= info->s;
1146 if (!share->base.keys ||
1147 (mi_is_all_keys_active(share->state.key_map, share->base.keys)))
1151 if (mi_is_any_key_active(share->state.key_map))
TODO: Rename this file - func.h is stupid.