diff options
Diffstat (limited to 'storage/maria/ma_open.c')
| -rw-r--r-- | storage/maria/ma_open.c | 653 |
1 files changed, 344 insertions, 309 deletions
diff --git a/storage/maria/ma_open.c b/storage/maria/ma_open.c index 38e71a44f8b..cbc781c589e 100644 --- a/storage/maria/ma_open.c +++ b/storage/maria/ma_open.c @@ -19,6 +19,7 @@ #include "ma_fulltext.h" #include "ma_sp_defs.h" #include "ma_rt_index.h" +#include "ma_blockrec.h" #include <m_ctype.h> #if defined(MSDOS) || defined(__WIN__) @@ -33,6 +34,12 @@ #endif static void setup_key_functions(MARIA_KEYDEF *keyinfo); +static my_bool maria_scan_init_dummy(MARIA_HA *info); +static void maria_scan_end_dummy(MARIA_HA *info); +static my_bool maria_once_init_dummy(MARIA_SHARE *, File); +static my_bool maria_once_end_dummy(MARIA_SHARE *); +static byte *_ma_base_info_read(byte *ptr, MARIA_BASE_INFO *base); + #define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \ pos+=size;} @@ -76,7 +83,7 @@ MARIA_HA *_ma_test_if_reopen(char *filename) MARIA_HA *maria_open(const char *name, int mode, uint open_flags) { int kfile,open_mode,save_errno,have_rtree=0; - uint i,j,len,errpos,head_length,base_pos,offset,info_length,keys, + uint i,j,len,errpos,head_length,base_pos,info_length,keys, key_parts,unique_key_parts,fulltext_keys,uniques; char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN], data_name[FN_REFLEN]; @@ -84,13 +91,13 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) MARIA_HA info,*m_info,*old_info; MARIA_SHARE share_buff,*share; ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*HA_MAX_KEY_SEG]; - my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MARIA_MAX_KEY_BLOCK_SIZE]; + my_off_t key_root[HA_MAX_POSSIBLE_KEY]; ulonglong max_key_file_length, max_data_file_length; DBUG_ENTER("maria_open"); LINT_INIT(m_info); kfile= -1; - errpos=0; + errpos= 0; head_length=sizeof(share_buff.state.header); bzero((byte*) &info,sizeof(info)); @@ -103,7 +110,6 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) bzero((gptr) &share_buff,sizeof(share_buff)); share_buff.state.rec_per_key_part=rec_per_key_part; share_buff.state.key_root=key_root; - share_buff.state.key_del=key_del; share_buff.key_cache= multi_key_cache_search(name_buff, strlen(name_buff), maria_key_cache); @@ -121,7 +127,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) goto err; } share->mode=open_mode; - errpos=1; + errpos= 1; if (my_read(kfile,(char*) share->state.header.file_version,head_length, MYF(MY_NABP))) { @@ -165,17 +171,17 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS); info_length=mi_uint2korr(share->state.header.header_length); - base_pos=mi_uint2korr(share->state.header.base_pos); + base_pos= mi_uint2korr(share->state.header.base_pos); if (!(disk_cache=(char*) my_alloca(info_length+128))) { my_errno=ENOMEM; goto err; } end_pos=disk_cache+info_length; - errpos=2; + errpos= 2; VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0))); - errpos=3; + errpos= 3; if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP))) { my_errno=HA_ERR_CRASHED; @@ -195,15 +201,14 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) } share->state_diff_length=len-MARIA_STATE_INFO_SIZE; - _ma_state_info_read((uchar*) disk_cache, &share->state); + _ma_state_info_read(disk_cache, &share->state); len= mi_uint2korr(share->state.header.base_info_length); if (len != MARIA_BASE_INFO_SIZE) { DBUG_PRINT("warning",("saved_base_info_length: %d base_info_length: %d", len,MARIA_BASE_INFO_SIZE)); } - disk_pos= (char*) - _ma_n_base_info_read((uchar*) disk_cache + base_pos, &share->base); + disk_pos= _ma_base_info_read(disk_cache + base_pos, &share->base); share->state.state_length=base_pos; if (!(open_flags & HA_OPEN_FOR_REPAIR) && @@ -239,6 +244,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) (((ulonglong) 1 << (share->base.rec_reflength*8))-1) : (_ma_safe_mul(share->base.pack_reclength, (ulonglong) 1 << (share->base.rec_reflength*8))-1); + max_key_file_length= _ma_safe_mul(MARIA_MIN_KEY_BLOCK_LENGTH, ((ulonglong) 1 << (share->base.key_reflength*8))-1); @@ -246,25 +252,6 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) set_if_smaller(max_data_file_length, INT_MAX32); set_if_smaller(max_key_file_length, INT_MAX32); #endif -#if USE_RAID && SYSTEM_SIZEOF_OFF_T == 4 - set_if_smaller(max_key_file_length, INT_MAX32); - if (!share->base.raid_type) - { - set_if_smaller(max_data_file_length, INT_MAX32); - } - else - { - set_if_smaller(max_data_file_length, - (ulonglong) share->base.raid_chunks << 31); - } -#elif !defined(USE_RAID) - if (share->base.raid_type) - { - DBUG_PRINT("error",("Table uses RAID but we don't have RAID support")); - my_errno=HA_ERR_UNSUPPORTED; - goto err; - } -#endif share->base.max_data_file_length=(my_off_t) max_data_file_length; share->base.max_key_file_length=(my_off_t) max_key_file_length; @@ -286,29 +273,25 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) &share->index_file_name,strlen(index_name)+1, &share->data_file_name,strlen(data_name)+1, &share->state.key_root,keys*sizeof(my_off_t), - &share->state.key_del, - (share->state.header.max_block_size_index*sizeof(my_off_t)), #ifdef THREAD &share->key_root_lock,sizeof(rw_lock_t)*keys, #endif &share->mmap_lock,sizeof(rw_lock_t), NullS)) goto err; - errpos=4; + errpos= 4; + *share=share_buff; memcpy((char*) share->state.rec_per_key_part, (char*) rec_per_key_part, sizeof(long)*key_parts); memcpy((char*) share->state.key_root, (char*) key_root, sizeof(my_off_t)*keys); - memcpy((char*) share->state.key_del, - (char*) key_del, (sizeof(my_off_t) * - share->state.header.max_block_size_index)); strmov(share->unique_file_name, name_buff); share->unique_name_length= strlen(name_buff); strmov(share->index_file_name, index_name); strmov(share->data_file_name, data_name); - share->blocksize=min(IO_SIZE,maria_block_size); + share->block_size= maria_block_size; { HA_KEYSEG *pos=share->keyparts; for (i=0 ; i < keys ; i++) @@ -319,7 +302,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) end_pos); if (share->keyinfo[i].key_alg == HA_KEY_ALG_RTREE) have_rtree=1; - set_if_smaller(share->blocksize,share->keyinfo[i].block_length); + set_if_smaller(share->block_size,share->keyinfo[i].block_length); share->keyinfo[i].seg=pos; for (j=0 ; j < share->keyinfo[i].keysegs; j++,pos++) { @@ -423,28 +406,43 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) } share->ftparsers= 0; } - - disk_pos_assert(disk_pos + share->base.fields *MARIA_COLUMNDEF_SIZE, end_pos); - for (i=j=offset=0 ; i < share->base.fields ; i++) + share->data_file_type= share->state.header.data_file_type; + share->base_length= (BASE_ROW_HEADER_SIZE + + share->base.is_nulls_extended + + share->base.null_bytes + + share->base.pack_bytes + + test(share->options & HA_OPTION_CHECKSUM)); + if (share->base.transactional) + share->base_length+= TRANS_ROW_EXTRA_HEADER_SIZE; + share->base.default_rec_buff_size= max(share->base.pack_reclength, + share->base.max_key_length); + if (share->data_file_type == DYNAMIC_RECORD) + { + share->base.extra_rec_buff_size= + (ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER) + MARIA_SPLIT_LENGTH + + MARIA_REC_BUFF_OFFSET); + share->base.default_rec_buff_size+= share->base.extra_rec_buff_size; + } + disk_pos_assert(disk_pos + share->base.fields *MARIA_COLUMNDEF_SIZE, + end_pos); + for (i= j= 0 ; i < share->base.fields ; i++) { disk_pos=_ma_recinfo_read(disk_pos,&share->rec[i]); share->rec[i].pack_type=0; share->rec[i].huff_tree=0; - share->rec[i].offset=offset; if (share->rec[i].type == (int) FIELD_BLOB) { share->blobs[j].pack_length= share->rec[i].length-maria_portable_sizeof_char_ptr;; - share->blobs[j].offset=offset; + share->blobs[j].offset= share->rec[i].offset; j++; } - offset+=share->rec[i].length; } share->rec[i].type=(int) FIELD_LAST; /* End marker */ if (_ma_open_datafile(&info, share, -1)) goto err; - errpos=5; + errpos= 5; share->kfile=kfile; share->this_process=(ulong) getpid(); @@ -456,25 +454,12 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) share->rec_reflength=share->base.rec_reflength; /* May be changed */ share->base.margin_key_file_length=(share->base.max_key_file_length - (keys ? MARIA_INDEX_BLOCK_MARGIN * - share->blocksize * keys : 0)); - share->blocksize=min(IO_SIZE,maria_block_size); - share->data_file_type=STATIC_RECORD; - if (share->options & HA_OPTION_COMPRESS_RECORD) - { - share->data_file_type = COMPRESSED_RECORD; - share->options|= HA_OPTION_READ_ONLY_DATA; - info.s=share; - if (_ma_read_pack_info(&info, - (pbool) - test(!(share->options & - (HA_OPTION_PACK_RECORD | - HA_OPTION_TEMP_COMPRESS_RECORD))))) - goto err; - } - else if (share->options & HA_OPTION_PACK_RECORD) - share->data_file_type = DYNAMIC_RECORD; + share->block_size * keys : 0)); + share->block_size= share->base.block_size; my_afree((gptr) disk_cache); _ma_setup_functions(share); + if ((*share->once_init)(share, info.dfile)) + goto err; #ifdef THREAD thr_lock_init(&share->lock); VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST)); @@ -493,6 +478,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) HA_OPTION_COMPRESS_RECORD | HA_OPTION_TEMP_COMPRESS_RECORD)) || (open_flags & HA_OPEN_TMP_TABLE) || + share->data_file_type == BLOCK_RECORD || have_rtree) ? 0 : 1; if (share->concurrent_insert) { @@ -512,9 +498,11 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) my_errno=EACCES; /* Can't open in write mode */ goto err; } - if (_ma_open_datafile(&info, share, old_info->dfile)) + if (share->data_file_type == BLOCK_RECORD) + info.dfile= share->bitmap.file; + else if (_ma_open_datafile(&info, share, old_info->dfile)) goto err; - errpos=5; + errpos= 5; have_rtree= old_info->maria_rtree_recursion_state != NULL; } @@ -530,7 +518,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) &info.maria_rtree_recursion_state,have_rtree ? 1024 : 0, NullS)) goto err; - errpos=6; + errpos= 6; if (!have_rtree) info.maria_rtree_recursion_state= NULL; @@ -540,7 +528,7 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) info.lastkey2=info.lastkey+share->base.max_key_length; info.s=share; - info.lastpos= HA_OFFSET_ERROR; + info.cur_row.lastpos= HA_OFFSET_ERROR; info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND); info.opt_flag=READ_CHECK_USED; info.this_unique= (ulong) info.dfile; /* Uniq number in process */ @@ -557,8 +545,12 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) info.ft1_to_ft2=0; info.errkey= -1; info.page_changed=1; + info.keyread_buff= info.buff + share->base.max_key_block_length; + if ((*share->init)(&info)) + goto err; + pthread_mutex_lock(&share->intern_lock); - info.read_record=share->read_record; + info.read_record= share->read_record; share->reopen++; share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL); if (share->options & HA_OPTION_READ_ONLY_DATA) @@ -570,7 +562,8 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) if ((open_flags & HA_OPEN_TMP_TABLE) || (share->options & HA_OPTION_TMP_TABLE)) { - share->temporary=share->delay_key_write=1; + share->temporary= share->delay_key_write= 1; + share->write_flag=MYF(MY_NABP); share->w_locks++; /* We don't have to update status */ share->tot_locks++; @@ -580,15 +573,17 @@ MARIA_HA *maria_open(const char *name, int mode, uint open_flags) (share->options & HA_OPTION_DELAY_KEY_WRITE)) && maria_delay_key_write) share->delay_key_write=1; + info.state= &share->state.state; /* Change global values by default */ pthread_mutex_unlock(&share->intern_lock); /* Allocate buffer for one record */ - - /* prerequisites: bzero(info) && info->s=share; are met. */ - if (!_ma_alloc_rec_buff(&info, -1, &info.rec_buff)) + /* prerequisites: info->rec_buffer == 0 && info->rec_buff_size == 0 */ + if (_ma_alloc_buffer(&info.rec_buff, &info.rec_buff_size, + share->base.default_rec_buff_size)) goto err; - bzero(info.rec_buff, _ma_get_rec_buff_len(&info, info.rec_buff)); + + bzero(info.rec_buff, share->base.default_rec_buff_size); *m_info=info; #ifdef THREAD @@ -608,12 +603,15 @@ err: _ma_report_error(save_errno, name); switch (errpos) { case 6: + (*share->end)(&info); my_free((gptr) m_info,MYF(0)); /* fall through */ case 5: - VOID(my_close(info.dfile,MYF(0))); + if (share->data_file_type != BLOCK_RECORD) + VOID(my_close(info.dfile,MYF(0))); if (old_info) break; /* Don't remove open table */ + (*share->once_end)(share); /* fall through */ case 4: my_free((gptr) share,MYF(0)); @@ -636,38 +634,23 @@ err: } /* maria_open */ -byte *_ma_alloc_rec_buff(MARIA_HA *info, ulong length, byte **buf) -{ - uint extra; - uint32 old_length; - LINT_INIT(old_length); +/* + Reallocate a buffer, if the current buffer is not large enough +*/ - if (! *buf || length > (old_length=_ma_get_rec_buff_len(info, *buf))) +my_bool _ma_alloc_buffer(byte **old_addr, my_size_t *old_size, + my_size_t new_size) +{ + if (*old_size < new_size) { - byte *newptr = *buf; - - /* to simplify initial init of info->rec_buf in maria_open and maria_extra */ - if (length == (ulong) -1) - { - length= max(info->s->base.pack_reclength, - info->s->base.max_key_length); - /* Avoid unnecessary realloc */ - if (newptr && length == old_length) - return newptr; - } - - extra= ((info->s->options & HA_OPTION_PACK_RECORD) ? - ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER)+MARIA_SPLIT_LENGTH+ - MARIA_REC_BUFF_OFFSET : 0); - if (extra && newptr) - newptr-= MARIA_REC_BUFF_OFFSET; - if (!(newptr=(byte*) my_realloc((gptr)newptr, length+extra+8, - MYF(MY_ALLOW_ZERO_PTR)))) - return newptr; - *((uint32 *) newptr)= (uint32) length; - *buf= newptr+(extra ? MARIA_REC_BUFF_OFFSET : 0); + byte *addr; + if (!(addr= (byte*) my_realloc((gptr) *old_addr, new_size, + MYF(MY_ALLOW_ZERO_PTR)))) + return 1; + *old_addr= addr; + *old_size= new_size; } - return *buf; + return 0; } @@ -684,28 +667,37 @@ ulonglong _ma_safe_mul(ulonglong a, ulonglong b) void _ma_setup_functions(register MARIA_SHARE *share) { - if (share->options & HA_OPTION_COMPRESS_RECORD) - { + share->once_init= maria_once_init_dummy; + share->once_end= maria_once_end_dummy; + share->init= maria_scan_init_dummy; + share->end= maria_scan_end_dummy; + share->scan_init= maria_scan_init_dummy; + share->scan_end= maria_scan_end_dummy; + share->write_record_init= _ma_write_init_default; + share->write_record_abort= _ma_write_abort_default; + + switch (share->data_file_type) { + case COMPRESSED_RECORD: share->read_record= _ma_read_pack_record; - share->read_rnd= _ma_read_rnd_pack_record; - if (!(share->options & HA_OPTION_TEMP_COMPRESS_RECORD)) - share->calc_checksum=0; /* No checksum */ - else if (share->options & HA_OPTION_PACK_RECORD) - share->calc_checksum= _ma_checksum; - else + share->scan= _ma_read_rnd_pack_record; + share->once_init= _ma_once_init_pack_row; + share->once_end= _ma_once_end_pack_row; + /* Calculate checksum according how the original row was stored */ + if (share->state.header.org_data_file_type == STATIC_RECORD) share->calc_checksum= _ma_static_checksum; - } - else if (share->options & HA_OPTION_PACK_RECORD) - { + else + share->calc_checksum= _ma_checksum; + share->calc_write_checksum= share->calc_checksum; + break; + case DYNAMIC_RECORD: share->read_record= _ma_read_dynamic_record; - share->read_rnd= _ma_read_rnd_dynamic_record; + share->scan= _ma_read_rnd_dynamic_record; share->delete_record= _ma_delete_dynamic_record; share->compare_record= _ma_cmp_dynamic_record; share->compare_unique= _ma_cmp_dynamic_unique; - share->calc_checksum= _ma_checksum; - + share->calc_checksum= share->calc_write_checksum= _ma_checksum; /* add bits used to pack data to pack_reclength for faster allocation */ - share->base.pack_reclength+= share->base.pack_bits; + share->base.pack_reclength+= share->base.pack_bytes; if (share->base.blobs) { share->update_record= _ma_update_blob_record; @@ -716,22 +708,42 @@ void _ma_setup_functions(register MARIA_SHARE *share) share->write_record= _ma_write_dynamic_record; share->update_record= _ma_update_dynamic_record; } - } - else - { + break; + case STATIC_RECORD: share->read_record= _ma_read_static_record; - share->read_rnd= _ma_read_rnd_static_record; + share->scan= _ma_read_rnd_static_record; share->delete_record= _ma_delete_static_record; share->compare_record= _ma_cmp_static_record; share->update_record= _ma_update_static_record; share->write_record= _ma_write_static_record; share->compare_unique= _ma_cmp_static_unique; - share->calc_checksum= _ma_static_checksum; + share->calc_checksum= share->calc_write_checksum= _ma_static_checksum; + break; + case BLOCK_RECORD: + share->once_init= _ma_once_init_block_row; + share->once_end= _ma_once_end_block_row; + share->init= _ma_init_block_row; + share->end= _ma_end_block_row; + share->write_record_init= _ma_write_init_block_record; + share->write_record_abort= _ma_write_abort_block_record; + share->scan_init= _ma_scan_init_block_record; + share->scan_end= _ma_scan_end_block_record; + share->read_record= _ma_read_block_record; + share->scan= _ma_scan_block_record; + share->delete_record= _ma_delete_block_record; + share->compare_record= _ma_compare_block_record; + share->update_record= _ma_update_block_record; + share->write_record= _ma_write_block_record; + share->compare_unique= _ma_cmp_block_unique; + share->calc_checksum= _ma_checksum; + share->calc_write_checksum= 0; + break; } share->file_read= _ma_nommap_pread; share->file_write= _ma_nommap_pwrite; - if (!(share->options & HA_OPTION_CHECKSUM)) - share->calc_checksum=0; + if (!(share->options & HA_OPTION_CHECKSUM) && + share->data_file_type != COMPRESSED_RECORD) + share->calc_checksum= share->calc_write_checksum= 0; return; } @@ -798,55 +810,53 @@ uint _ma_state_info_write(File file, MARIA_STATE_INFO *state, uint pWrite) { uchar buff[MARIA_STATE_INFO_SIZE + MARIA_STATE_EXTRA_SIZE]; uchar *ptr=buff; - uint i, keys= (uint) state->header.keys, - key_blocks=state->header.max_block_size_index; + uint i, keys= (uint) state->header.keys; DBUG_ENTER("_ma_state_info_write"); memcpy_fixed(ptr,&state->header,sizeof(state->header)); ptr+=sizeof(state->header); /* open_count must be first because of _ma_mark_file_changed ! */ - mi_int2store(ptr,state->open_count); ptr +=2; - *ptr++= (uchar)state->changed; *ptr++= state->sortkey; - mi_rowstore(ptr,state->state.records); ptr +=8; - mi_rowstore(ptr,state->state.del); ptr +=8; - mi_rowstore(ptr,state->split); ptr +=8; - mi_sizestore(ptr,state->dellink); ptr +=8; - mi_sizestore(ptr,state->state.key_file_length); ptr +=8; - mi_sizestore(ptr,state->state.data_file_length); ptr +=8; - mi_sizestore(ptr,state->state.empty); ptr +=8; - mi_sizestore(ptr,state->state.key_empty); ptr +=8; - mi_int8store(ptr,state->auto_increment); ptr +=8; - mi_int8store(ptr,(ulonglong) state->state.checksum);ptr +=8; - mi_int4store(ptr,state->process); ptr +=4; - mi_int4store(ptr,state->unique); ptr +=4; - mi_int4store(ptr,state->status); ptr +=4; - mi_int4store(ptr,state->update_count); ptr +=4; - - ptr+=state->state_diff_length; + mi_int2store(ptr,state->open_count); ptr+= 2; + *ptr++= (uchar)state->changed; + *ptr++= state->sortkey; + mi_rowstore(ptr,state->state.records); ptr+= 8; + mi_rowstore(ptr,state->state.del); ptr+= 8; + mi_rowstore(ptr,state->split); ptr+= 8; + mi_sizestore(ptr,state->dellink); ptr+= 8; + mi_sizestore(ptr,state->first_bitmap_with_space); ptr+= 8; + mi_sizestore(ptr,state->state.key_file_length); ptr+= 8; + mi_sizestore(ptr,state->state.data_file_length); ptr+= 8; + mi_sizestore(ptr,state->state.empty); ptr+= 8; + mi_sizestore(ptr,state->state.key_empty); ptr+= 8; + mi_int8store(ptr,state->auto_increment); ptr+= 8; + mi_int8store(ptr,(ulonglong) state->state.checksum); ptr+= 8; + mi_int4store(ptr,state->process); ptr+= 4; + mi_int4store(ptr,state->unique); ptr+= 4; + mi_int4store(ptr,state->status); ptr+= 4; + mi_int4store(ptr,state->update_count); ptr+= 4; + + ptr+= state->state_diff_length; for (i=0; i < keys; i++) { - mi_sizestore(ptr,state->key_root[i]); ptr +=8; - } - for (i=0; i < key_blocks; i++) - { - mi_sizestore(ptr,state->key_del[i]); ptr +=8; + mi_sizestore(ptr,state->key_root[i]); ptr+= 8; } - if (pWrite & 2) /* From isamchk */ + mi_sizestore(ptr,state->key_del); ptr+= 8; + if (pWrite & 2) /* From maria_chk */ { uint key_parts= mi_uint2korr(state->header.key_parts); - mi_int4store(ptr,state->sec_index_changed); ptr +=4; - mi_int4store(ptr,state->sec_index_used); ptr +=4; - mi_int4store(ptr,state->version); ptr +=4; - mi_int8store(ptr,state->key_map); ptr +=8; - mi_int8store(ptr,(ulonglong) state->create_time); ptr +=8; - mi_int8store(ptr,(ulonglong) state->recover_time); ptr +=8; - mi_int8store(ptr,(ulonglong) state->check_time); ptr +=8; - mi_sizestore(ptr,state->rec_per_key_rows); ptr+=8; + mi_int4store(ptr,state->sec_index_changed); ptr+= 4; + mi_int4store(ptr,state->sec_index_used); ptr+= 4; + mi_int4store(ptr,state->version); ptr+= 4; + mi_int8store(ptr,state->key_map); ptr+= 8; + mi_int8store(ptr,(ulonglong) state->create_time); ptr+= 8; + mi_int8store(ptr,(ulonglong) state->recover_time); ptr+= 8; + mi_int8store(ptr,(ulonglong) state->check_time); ptr+= 8; + mi_sizestore(ptr,state->rec_per_key_rows); ptr+= 8; for (i=0 ; i < key_parts ; i++) { - mi_int4store(ptr,state->rec_per_key_part[i]); ptr+=4; + mi_int4store(ptr,state->rec_per_key_part[i]); ptr+=4; } } @@ -858,54 +868,51 @@ uint _ma_state_info_write(File file, MARIA_STATE_INFO *state, uint pWrite) } -uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state) +byte *_ma_state_info_read(byte *ptr, MARIA_STATE_INFO *state) { - uint i,keys,key_parts,key_blocks; + uint i,keys,key_parts; memcpy_fixed(&state->header,ptr, sizeof(state->header)); - ptr +=sizeof(state->header); - keys=(uint) state->header.keys; - key_parts=mi_uint2korr(state->header.key_parts); - key_blocks=state->header.max_block_size_index; - - state->open_count = mi_uint2korr(ptr); ptr +=2; - state->changed= (bool) *ptr++; - state->sortkey = (uint) *ptr++; - state->state.records= mi_rowkorr(ptr); ptr +=8; - state->state.del = mi_rowkorr(ptr); ptr +=8; - state->split = mi_rowkorr(ptr); ptr +=8; - state->dellink= mi_sizekorr(ptr); ptr +=8; - state->state.key_file_length = mi_sizekorr(ptr); ptr +=8; - state->state.data_file_length= mi_sizekorr(ptr); ptr +=8; - state->state.empty = mi_sizekorr(ptr); ptr +=8; - state->state.key_empty= mi_sizekorr(ptr); ptr +=8; - state->auto_increment=mi_uint8korr(ptr); ptr +=8; - state->state.checksum=(ha_checksum) mi_uint8korr(ptr); ptr +=8; - state->process= mi_uint4korr(ptr); ptr +=4; - state->unique = mi_uint4korr(ptr); ptr +=4; - state->status = mi_uint4korr(ptr); ptr +=4; - state->update_count=mi_uint4korr(ptr); ptr +=4; + ptr+= sizeof(state->header); + keys= (uint) state->header.keys; + key_parts= mi_uint2korr(state->header.key_parts); + + state->open_count = mi_uint2korr(ptr); ptr+= 2; + state->changed= (my_bool) *ptr++; + state->sortkey= (uint) *ptr++; + state->state.records= mi_rowkorr(ptr); ptr+= 8; + state->state.del = mi_rowkorr(ptr); ptr+= 8; + state->split = mi_rowkorr(ptr); ptr+= 8; + state->dellink= mi_sizekorr(ptr); ptr+= 8; + state->first_bitmap_with_space= mi_sizekorr(ptr); ptr+= 8; + state->state.key_file_length = mi_sizekorr(ptr); ptr+= 8; + state->state.data_file_length= mi_sizekorr(ptr); ptr+= 8; + state->state.empty = mi_sizekorr(ptr); ptr+= 8; + state->state.key_empty= mi_sizekorr(ptr); ptr+= 8; + state->auto_increment=mi_uint8korr(ptr); ptr+= 8; + state->state.checksum=(ha_checksum) mi_uint8korr(ptr);ptr+= 8; + state->process= mi_uint4korr(ptr); ptr+= 4; + state->unique = mi_uint4korr(ptr); ptr+= 4; + state->status = mi_uint4korr(ptr); ptr+= 4; + state->update_count=mi_uint4korr(ptr); ptr+= 4; ptr+= state->state_diff_length; for (i=0; i < keys; i++) { - state->key_root[i]= mi_sizekorr(ptr); ptr +=8; - } - for (i=0; i < key_blocks; i++) - { - state->key_del[i] = mi_sizekorr(ptr); ptr +=8; + state->key_root[i]= mi_sizekorr(ptr); ptr+= 8; } - state->sec_index_changed = mi_uint4korr(ptr); ptr +=4; - state->sec_index_used = mi_uint4korr(ptr); ptr +=4; - state->version = mi_uint4korr(ptr); ptr +=4; - state->key_map = mi_uint8korr(ptr); ptr +=8; - state->create_time = (time_t) mi_sizekorr(ptr); ptr +=8; - state->recover_time =(time_t) mi_sizekorr(ptr); ptr +=8; - state->check_time = (time_t) mi_sizekorr(ptr); ptr +=8; - state->rec_per_key_rows=mi_sizekorr(ptr); ptr +=8; + state->key_del= mi_sizekorr(ptr); ptr+= 8; + state->sec_index_changed = mi_uint4korr(ptr); ptr+= 4; + state->sec_index_used = mi_uint4korr(ptr); ptr+= 4; + state->version = mi_uint4korr(ptr); ptr+= 4; + state->key_map = mi_uint8korr(ptr); ptr+= 8; + state->create_time = (time_t) mi_sizekorr(ptr); ptr+= 8; + state->recover_time =(time_t) mi_sizekorr(ptr); ptr+= 8; + state->check_time = (time_t) mi_sizekorr(ptr); ptr+= 8; + state->rec_per_key_rows=mi_sizekorr(ptr); ptr+= 8; for (i=0 ; i < key_parts ; i++) { - state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4; + state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4; } return ptr; } @@ -924,7 +931,7 @@ uint _ma_state_info_read_dsk(File file, MARIA_STATE_INFO *state, my_bool pRead) } else if (my_read(file, buff, state->state_length,MYF(MY_NABP))) return (MY_FILE_ERROR); - _ma_state_info_read((uchar*) buff, state); + _ma_state_info_read(buff, state); } return 0; } @@ -938,74 +945,84 @@ uint _ma_base_info_write(File file, MARIA_BASE_INFO *base) { uchar buff[MARIA_BASE_INFO_SIZE], *ptr=buff; - mi_sizestore(ptr,base->keystart); ptr +=8; - mi_sizestore(ptr,base->max_data_file_length); ptr +=8; - mi_sizestore(ptr,base->max_key_file_length); ptr +=8; - mi_rowstore(ptr,base->records); ptr +=8; - mi_rowstore(ptr,base->reloc); ptr +=8; - mi_int4store(ptr,base->mean_row_length); ptr +=4; - mi_int4store(ptr,base->reclength); ptr +=4; - mi_int4store(ptr,base->pack_reclength); ptr +=4; - mi_int4store(ptr,base->min_pack_length); ptr +=4; - mi_int4store(ptr,base->max_pack_length); ptr +=4; - mi_int4store(ptr,base->min_block_length); ptr +=4; - mi_int4store(ptr,base->fields); ptr +=4; - mi_int4store(ptr,base->pack_fields); ptr +=4; - *ptr++=base->rec_reflength; - *ptr++=base->key_reflength; - *ptr++=base->keys; - *ptr++=base->auto_key; - mi_int2store(ptr,base->pack_bits); ptr +=2; - mi_int2store(ptr,base->blobs); ptr +=2; - mi_int2store(ptr,base->max_key_block_length); ptr +=2; - mi_int2store(ptr,base->max_key_length); ptr +=2; - mi_int2store(ptr,base->extra_alloc_bytes); ptr +=2; + mi_sizestore(ptr,base->keystart); ptr+= 8; + mi_sizestore(ptr,base->max_data_file_length); ptr+= 8; + mi_sizestore(ptr,base->max_key_file_length); ptr+= 8; + mi_rowstore(ptr,base->records); ptr+= 8; + mi_rowstore(ptr,base->reloc); ptr+= 8; + mi_int4store(ptr,base->mean_row_length); ptr+= 4; + mi_int4store(ptr,base->reclength); ptr+= 4; + mi_int4store(ptr,base->pack_reclength); ptr+= 4; + mi_int4store(ptr,base->min_pack_length); ptr+= 4; + mi_int4store(ptr,base->max_pack_length); ptr+= 4; + mi_int4store(ptr,base->min_block_length); ptr+= 4; + mi_int2store(ptr,base->fields); ptr+= 2; + mi_int2store(ptr,base->fixed_not_null_fields); ptr+= 2; + mi_int2store(ptr,base->fixed_not_null_fields_length); ptr+= 2; + mi_int2store(ptr,base->max_field_lengths); ptr+= 2; + mi_int2store(ptr,base->pack_fields); ptr+= 2; + mi_int2store(ptr,0); ptr+= 2; + mi_int2store(ptr,base->null_bytes); ptr+= 2; + mi_int2store(ptr,base->original_null_bytes); ptr+= 2; + mi_int2store(ptr,base->field_offsets); ptr+= 2; + mi_int2store(ptr,base->min_row_length); ptr+= 2; + mi_int2store(ptr,base->block_size); ptr+= 2; + *ptr++= base->rec_reflength; + *ptr++= base->key_reflength; + *ptr++= base->keys; + *ptr++= base->auto_key; + *ptr++= base->transactional; + *ptr++= 0; /* Reserved */ + mi_int2store(ptr,base->pack_bytes); ptr+= 2; + mi_int2store(ptr,base->blobs); ptr+= 2; + mi_int2store(ptr,base->max_key_block_length); ptr+= 2; + mi_int2store(ptr,base->max_key_length); ptr+= 2; + mi_int2store(ptr,base->extra_alloc_bytes); ptr+= 2; *ptr++= base->extra_alloc_procent; - *ptr++= base->raid_type; - mi_int2store(ptr,base->raid_chunks); ptr +=2; - mi_int4store(ptr,base->raid_chunksize); ptr +=4; - bzero(ptr,6); ptr +=6; /* extra */ + bzero(ptr,16); ptr+= 16; /* extra */ + DBUG_ASSERT((ptr - buff) == MARIA_BASE_INFO_SIZE); return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP)); } -uchar *_ma_n_base_info_read(uchar *ptr, MARIA_BASE_INFO *base) +static byte *_ma_base_info_read(byte *ptr, MARIA_BASE_INFO *base) { - base->keystart = mi_sizekorr(ptr); ptr +=8; - base->max_data_file_length = mi_sizekorr(ptr); ptr +=8; - base->max_key_file_length = mi_sizekorr(ptr); ptr +=8; - base->records = (ha_rows) mi_sizekorr(ptr); ptr +=8; - base->reloc = (ha_rows) mi_sizekorr(ptr); ptr +=8; - base->mean_row_length = mi_uint4korr(ptr); ptr +=4; - base->reclength = mi_uint4korr(ptr); ptr +=4; - base->pack_reclength = mi_uint4korr(ptr); ptr +=4; - base->min_pack_length = mi_uint4korr(ptr); ptr +=4; - base->max_pack_length = mi_uint4korr(ptr); ptr +=4; - base->min_block_length = mi_uint4korr(ptr); ptr +=4; - base->fields = mi_uint4korr(ptr); ptr +=4; - base->pack_fields = mi_uint4korr(ptr); ptr +=4; - - base->rec_reflength = *ptr++; - base->key_reflength = *ptr++; - base->keys= *ptr++; - base->auto_key= *ptr++; - base->pack_bits = mi_uint2korr(ptr); ptr +=2; - base->blobs = mi_uint2korr(ptr); ptr +=2; - base->max_key_block_length= mi_uint2korr(ptr); ptr +=2; - base->max_key_length = mi_uint2korr(ptr); ptr +=2; - base->extra_alloc_bytes = mi_uint2korr(ptr); ptr +=2; - base->extra_alloc_procent = *ptr++; - base->raid_type= *ptr++; - base->raid_chunks= mi_uint2korr(ptr); ptr +=2; - base->raid_chunksize= mi_uint4korr(ptr); ptr +=4; - /* TO BE REMOVED: Fix for old RAID files */ - if (base->raid_type == 0) - { - base->raid_chunks=0; - base->raid_chunksize=0; - } - - ptr+=6; + base->keystart= mi_sizekorr(ptr); ptr+= 8; + base->max_data_file_length= mi_sizekorr(ptr); ptr+= 8; + base->max_key_file_length= mi_sizekorr(ptr); ptr+= 8; + base->records= (ha_rows) mi_sizekorr(ptr); ptr+= 8; + base->reloc= (ha_rows) mi_sizekorr(ptr); ptr+= 8; + base->mean_row_length= mi_uint4korr(ptr); ptr+= 4; + base->reclength= mi_uint4korr(ptr); ptr+= 4; + base->pack_reclength= mi_uint4korr(ptr); ptr+= 4; + base->min_pack_length= mi_uint4korr(ptr); ptr+= 4; + base->max_pack_length= mi_uint4korr(ptr); ptr+= 4; + base->min_block_length= mi_uint4korr(ptr); ptr+= 4; + base->fields= mi_uint2korr(ptr); ptr+= 2; + base->fixed_not_null_fields= mi_uint2korr(ptr); ptr+= 2; + base->fixed_not_null_fields_length= mi_uint2korr(ptr);ptr+= 2; + base->max_field_lengths= mi_uint2korr(ptr); ptr+= 2; + base->pack_fields= mi_uint2korr(ptr); ptr+= 2; + ptr+= 2; + base->null_bytes= mi_uint2korr(ptr); ptr+= 2; + base->original_null_bytes= mi_uint2korr(ptr); ptr+= 2; + base->field_offsets= mi_uint2korr(ptr); ptr+= 2; + base->min_row_length= mi_uint2korr(ptr); ptr+= 2; + base->block_size= mi_uint2korr(ptr); ptr+= 2; + + base->rec_reflength= *ptr++; + base->key_reflength= *ptr++; + base->keys= *ptr++; + base->auto_key= *ptr++; + base->transactional= *ptr++; + ptr++; + base->pack_bytes= mi_uint2korr(ptr); ptr+= 2; + base->blobs= mi_uint2korr(ptr); ptr+= 2; + base->max_key_block_length= mi_uint2korr(ptr); ptr+= 2; + base->max_key_length= mi_uint2korr(ptr); ptr+= 2; + base->extra_alloc_bytes= mi_uint2korr(ptr); ptr+= 2; + base->extra_alloc_procent= *ptr++; + ptr+= 16; return ptr; } @@ -1018,13 +1035,13 @@ uint _ma_keydef_write(File file, MARIA_KEYDEF *keydef) uchar buff[MARIA_KEYDEF_SIZE]; uchar *ptr=buff; - *ptr++ = (uchar) keydef->keysegs; - *ptr++ = keydef->key_alg; /* Rtree or Btree */ - mi_int2store(ptr,keydef->flag); ptr +=2; - mi_int2store(ptr,keydef->block_length); ptr +=2; - mi_int2store(ptr,keydef->keylength); ptr +=2; - mi_int2store(ptr,keydef->minlength); ptr +=2; - mi_int2store(ptr,keydef->maxlength); ptr +=2; + *ptr++= (uchar) keydef->keysegs; + *ptr++= keydef->key_alg; /* Rtree or Btree */ + mi_int2store(ptr,keydef->flag); ptr+= 2; + mi_int2store(ptr,keydef->block_length); ptr+= 2; + mi_int2store(ptr,keydef->keylength); ptr+= 2; + mi_int2store(ptr,keydef->minlength); ptr+= 2; + mi_int2store(ptr,keydef->maxlength); ptr+= 2; return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP)); } @@ -1033,12 +1050,11 @@ char *_ma_keydef_read(char *ptr, MARIA_KEYDEF *keydef) keydef->keysegs = (uint) *ptr++; keydef->key_alg = *ptr++; /* Rtree or Btree */ - keydef->flag = mi_uint2korr(ptr); ptr +=2; - keydef->block_length = mi_uint2korr(ptr); ptr +=2; - keydef->keylength = mi_uint2korr(ptr); ptr +=2; - keydef->minlength = mi_uint2korr(ptr); ptr +=2; - keydef->maxlength = mi_uint2korr(ptr); ptr +=2; - keydef->block_size_index = keydef->block_length/MARIA_MIN_KEY_BLOCK_LENGTH-1; + keydef->flag = mi_uint2korr(ptr); ptr+= 2; + keydef->block_length = mi_uint2korr(ptr); ptr+= 2; + keydef->keylength = mi_uint2korr(ptr); ptr+= 2; + keydef->minlength = mi_uint2korr(ptr); ptr+= 2; + keydef->maxlength = mi_uint2korr(ptr); ptr+= 2; keydef->underflow_block_length=keydef->block_length/3; keydef->version = 0; /* Not saved */ keydef->parser = &ft_default_parser; @@ -1062,9 +1078,9 @@ int _ma_keyseg_write(File file, const HA_KEYSEG *keyseg) *ptr++= keyseg->bit_start; *ptr++= keyseg->bit_end; *ptr++= keyseg->bit_length; - mi_int2store(ptr,keyseg->flag); ptr+=2; - mi_int2store(ptr,keyseg->length); ptr+=2; - mi_int4store(ptr,keyseg->start); ptr+=4; + mi_int2store(ptr,keyseg->flag); ptr+= 2; + mi_int2store(ptr,keyseg->length); ptr+= 2; + mi_int4store(ptr,keyseg->start); ptr+= 4; pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos; mi_int4store(ptr, pos); ptr+=4; @@ -1081,10 +1097,10 @@ char *_ma_keyseg_read(char *ptr, HA_KEYSEG *keyseg) keyseg->bit_start = *ptr++; keyseg->bit_end = *ptr++; keyseg->bit_length = *ptr++; - keyseg->flag = mi_uint2korr(ptr); ptr +=2; - keyseg->length = mi_uint2korr(ptr); ptr +=2; - keyseg->start = mi_uint4korr(ptr); ptr +=4; - keyseg->null_pos = mi_uint4korr(ptr); ptr +=4; + keyseg->flag = mi_uint2korr(ptr); ptr+= 2; + keyseg->length = mi_uint2korr(ptr); ptr+= 2; + keyseg->start = mi_uint4korr(ptr); ptr+= 4; + keyseg->null_pos = mi_uint4korr(ptr); ptr+= 4; keyseg->charset=0; /* Will be filled in later */ if (keyseg->null_bit) keyseg->bit_pos= (uint16)(keyseg->null_pos + (keyseg->null_bit == 7)); @@ -1129,47 +1145,44 @@ uint _ma_recinfo_write(File file, MARIA_COLUMNDEF *recinfo) uchar buff[MARIA_COLUMNDEF_SIZE]; uchar *ptr=buff; - mi_int2store(ptr,recinfo->type); ptr +=2; - mi_int2store(ptr,recinfo->length); ptr +=2; - *ptr++ = recinfo->null_bit; - mi_int2store(ptr,recinfo->null_pos); ptr+= 2; + mi_int6store(ptr,recinfo->offset); ptr+= 6; + mi_int2store(ptr,recinfo->type); ptr+= 2; + mi_int2store(ptr,recinfo->length); ptr+= 2; + mi_int2store(ptr,recinfo->fill_length); ptr+= 2; + mi_int2store(ptr,recinfo->null_pos); ptr+= 2; + mi_int2store(ptr,recinfo->empty_pos); ptr+= 2; + (*ptr++)= recinfo->null_bit; + (*ptr++)= recinfo->empty_bit; return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP)); } char *_ma_recinfo_read(char *ptr, MARIA_COLUMNDEF *recinfo) { - recinfo->type= mi_sint2korr(ptr); ptr +=2; - recinfo->length=mi_uint2korr(ptr); ptr +=2; - recinfo->null_bit= (uint8) *ptr++; - recinfo->null_pos=mi_uint2korr(ptr); ptr +=2; - return ptr; + recinfo->offset= mi_uint6korr(ptr); ptr+= 6; + recinfo->type= mi_sint2korr(ptr); ptr+= 2; + recinfo->length= mi_uint2korr(ptr); ptr+= 2; + recinfo->fill_length= mi_uint2korr(ptr); ptr+= 2; + recinfo->null_pos= mi_uint2korr(ptr); ptr+= 2; + recinfo->empty_pos= mi_uint2korr(ptr); ptr+= 2; + recinfo->null_bit= (uint8) *ptr++; + recinfo->empty_bit= (uint8) *ptr++; + return ptr; } /************************************************************************** -Open data file with or without RAID -We can't use dup() here as the data file descriptors need to have different -active seek-positions. + Open data file + We can't use dup() here as the data file descriptors need to have different + active seek-positions. -The argument file_to_dup is here for the future if there would on some OS -exist a dup()-like call that would give us two different file descriptors. + The argument file_to_dup is here for the future if there would on some OS + exist a dup()-like call that would give us two different file descriptors. *************************************************************************/ -int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share, File file_to_dup __attribute__((unused))) +int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share, + File file_to_dup __attribute__((unused))) { -#ifdef USE_RAID - if (share->base.raid_type) - { - info->dfile=my_raid_open(share->data_file_name, - share->mode | O_SHARE, - share->base.raid_type, - share->base.raid_chunks, - share->base.raid_chunksize, - MYF(MY_WME | MY_RAID)); - } - else -#endif - info->dfile=my_open(share->data_file_name, share->mode | O_SHARE, - MYF(MY_WME)); + info->dfile= my_open(share->data_file_name, share->mode | O_SHARE, + MYF(MY_WME)); return info->dfile >= 0 ? 0 : 1; } @@ -1264,3 +1277,25 @@ int maria_indexes_are_disabled(MARIA_HA *info) return (! maria_is_any_key_active(share->state.key_map) && share->base.keys); } + + +static my_bool maria_scan_init_dummy(MARIA_HA *info __attribute__((unused))) +{ + return 0; +} + +static void maria_scan_end_dummy(MARIA_HA *info __attribute__((unused))) +{ +} + +static my_bool maria_once_init_dummy(MARIA_SHARE *share + __attribute__((unused)), + File dfile __attribute__((unused))) +{ + return 0; +} + +static my_bool maria_once_end_dummy(MARIA_SHARE *share __attribute__((unused))) +{ + return 0; +} |