18#include "myisam_priv.h"
19#include <drizzled/internal/my_bit.h>
20#include <drizzled/internal/my_sys.h>
22#include <drizzled/util/test.h>
23#include <drizzled/charset.h>
24#include <drizzled/error.h>
51static inline uint32_t my_round_up_to_next_power(uint32_t v)
66int mi_create(
const char *name,uint32_t keys,MI_KEYDEF *keydefs,
67 uint32_t columns, MI_COLUMNDEF *recinfo,
68 uint32_t uniques, MI_UNIQUEDEF *uniquedefs,
69 MI_CREATE_INFO *ci,uint32_t flags)
72 int dfile= 0, file= 0;
73 int errpos,save_errno, create_mode= O_RDWR | O_TRUNC;
75 uint32_t fields,length,max_key_length,packed,pointer,real_length_diff,
76 key_length,info_length,key_segs,options,min_key_length_skip,
77 base_pos,long_varchar_count,varchar_length,
78 max_key_block_length,unique_key_parts,fulltext_keys,offset;
79 uint32_t aligned_key_start, block_length;
80 ulong reclength, real_reclength,min_pack_length;
81 char filename[FN_REFLEN],linkname[FN_REFLEN], *linkname_ptr;
83 uint64_t tot_length,max_rows, tmp;
84 enum en_fieldtype
type;
86 MI_KEYDEF *keydef,tmp_keydef;
87 MI_UNIQUEDEF *uniquedef;
88 HA_KEYSEG *keyseg,tmp_keyseg;
90 ulong *rec_per_key_part;
91 internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
92 MI_CREATE_INFO tmp_create_info;
99 if (keys + uniques > MI_MAX_KEY || columns == 0)
101 return(errno=HA_WRONG_CREATE_OPTION);
105 memset(&share, 0,
sizeof(share));
107 if (flags & HA_DONT_TOUCH_DATA)
109 if (!(ci->old_options & HA_OPTION_TEMP_COMPRESS_RECORD))
110 options=ci->old_options &
111 (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD |
112 HA_OPTION_READ_ONLY_DATA |
113 HA_OPTION_TMP_TABLE );
115 options=ci->old_options &
116 (HA_OPTION_TMP_TABLE );
119 if (ci->reloc_rows > ci->max_rows)
120 ci->reloc_rows=ci->max_rows;
122 if (!(rec_per_key_part=
123 (ulong*) malloc((keys + uniques)*MI_MAX_KEY_SEG*
sizeof(
long))))
125 memset(rec_per_key_part, 0, (keys + uniques)*MI_MAX_KEY_SEG*
sizeof(
long));
129 reclength=varchar_length=long_varchar_count=packed=
130 min_pack_length=pack_reclength=0;
131 for (rec=recinfo, fields=0 ;
135 reclength+=rec->length;
136 if ((
type=(
enum en_fieldtype) rec->type) != FIELD_NORMAL &&
140 if (
type == FIELD_BLOB)
143 if (pack_reclength != INT32_MAX)
145 if (rec->length == 4+portable_sizeof_char_ptr)
146 pack_reclength= INT32_MAX;
148 pack_reclength+=(1 << ((rec->length-portable_sizeof_char_ptr)*8));
151 else if (
type == FIELD_SKIP_PRESPACE ||
152 type == FIELD_SKIP_ENDSPACE)
154 if (pack_reclength != INT32_MAX)
155 pack_reclength+= rec->length > 255 ? 2 : 1;
158 else if (
type == FIELD_VARCHAR)
160 varchar_length+= rec->length-1;
165 if (test(rec->length >= 257))
167 long_varchar_count++;
171 else if (
type != FIELD_SKIP_ZERO)
173 min_pack_length+=rec->length;
178 min_pack_length+=rec->length;
180 if ((packed & 7) == 1)
182 while (rec != recinfo)
185 if (rec->type == (
int) FIELD_SKIP_ZERO && rec->length == 1)
191 rec->type=(int) FIELD_NORMAL;
199 if (packed || (flags & HA_PACK_RECORD))
200 options|=HA_OPTION_PACK_RECORD;
201 if (!(options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)))
202 min_pack_length+= varchar_length;
203 if (flags & HA_CREATE_TMP_TABLE)
205 options|= HA_OPTION_TMP_TABLE;
206 create_mode|= O_EXCL;
210 if (pack_reclength != INT32_MAX)
211 pack_reclength+= reclength+packed +
212 test(test_all_bits(options,
213 uint32_t(HA_PACK_RECORD)));
214 min_pack_length+=packed;
216 if (!ci->data_file_length && ci->max_rows)
218 if (pack_reclength == INT32_MAX ||
219 (~(uint64_t) 0)/ci->max_rows < (uint64_t) pack_reclength)
220 ci->data_file_length= ~(uint64_t) 0;
222 ci->data_file_length=(uint64_t) ci->max_rows*pack_reclength;
224 else if (!ci->max_rows)
225 ci->max_rows=(ha_rows) (ci->data_file_length/(min_pack_length +
226 ((options & HA_OPTION_PACK_RECORD) ?
229 if (options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD))
230 pointer=mi_get_pointer_length(ci->data_file_length, data_pointer_size);
232 pointer=mi_get_pointer_length(ci->max_rows, data_pointer_size);
233 if (!(max_rows=(uint64_t) ci->max_rows))
234 max_rows= ((((uint64_t) 1 << (pointer*8)) -1) / min_pack_length);
237 real_reclength=reclength;
238 if (!(options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD)))
240 if (reclength <= pointer)
244 reclength+= long_varchar_count;
246 max_key_length=0; tot_length=0 ; key_segs=0;
248 max_key_block_length=0;
249 share.state.rec_per_key_part=rec_per_key_part;
250 share.state.key_root=key_root;
251 share.state.key_del=key_del;
254 max_key_block_length= myisam_block_size;
255 max_key_length= MI_UNIQUE_HASH_LENGTH + pointer;
258 for (i=0, keydef=keydefs ; i < keys ; i++ , keydef++)
261 share.state.key_root[i]= HA_OFFSET_ERROR;
262 min_key_length_skip=length=real_length_diff=0;
266 if (keydef->flag & HA_PACK_KEY)
269 if (!(keydef->seg[0].flag & (HA_SPACE_PACK | HA_BLOB_PART |
270 HA_VAR_LENGTH_PART)))
273 keydef->flag&= ~HA_PACK_KEY;
274 keydef->flag|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
278 keydef->seg[0].flag|=HA_PACK_KEY;
279 keydef->flag|=HA_VAR_LENGTH_KEY;
280 options|=HA_OPTION_PACK_KEYS;
283 if (keydef->flag & HA_BINARY_PACK_KEY)
284 options|=HA_OPTION_PACK_KEYS;
286 if (keydef->flag & HA_AUTO_KEY && ci->with_auto_increment)
287 share.base.auto_key=i+1;
288 for (j=0, keyseg=keydef->seg ; j < keydef->keysegs ; j++, keyseg++)
291 switch (keyseg->type) {
292 case HA_KEYTYPE_LONG_INT:
293 case HA_KEYTYPE_DOUBLE:
294 case HA_KEYTYPE_ULONG_INT:
295 case HA_KEYTYPE_LONGLONG:
296 case HA_KEYTYPE_ULONGLONG:
297 keyseg->flag|= HA_SWAP_KEY;
299 case HA_KEYTYPE_VARTEXT1:
300 case HA_KEYTYPE_VARTEXT2:
301 case HA_KEYTYPE_VARBINARY1:
302 case HA_KEYTYPE_VARBINARY2:
303 if (!(keyseg->flag & HA_BLOB_PART))
306 keyseg->flag|= HA_VAR_LENGTH_PART;
308 keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1 ||
309 keyseg->type == HA_KEYTYPE_VARBINARY1) ?
316 if (keyseg->flag & HA_SPACE_PACK)
318 assert(!(keyseg->flag & HA_VAR_LENGTH_PART));
319 keydef->flag |= HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY;
320 options|=HA_OPTION_PACK_KEYS;
322 min_key_length_skip+=keyseg->length;
323 if (keyseg->length >= 255)
325 min_key_length_skip+=2;
329 if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
331 assert(!test_all_bits(keyseg->flag,
332 (HA_VAR_LENGTH_PART | HA_BLOB_PART)));
333 keydef->flag|=HA_VAR_LENGTH_KEY;
335 options|=HA_OPTION_PACK_KEYS;
336 min_key_length_skip+=keyseg->length;
337 if (keyseg->length >= 255)
339 min_key_length_skip+=2;
343 key_length+= keyseg->length;
344 if (keyseg->null_bit)
347 options|=HA_OPTION_PACK_KEYS;
348 keyseg->flag|=HA_NULL_PART;
349 keydef->flag|=HA_VAR_LENGTH_KEY | HA_NULL_PART_KEY;
353 key_segs+=keydef->keysegs;
354 if (keydef->keysegs > MI_MAX_KEY_SEG)
356 errno=HA_WRONG_CREATE_OPTION;
364 if ((keydef->flag & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME &&
366 share.state.rec_per_key_part[key_segs-1]=1L;
369 block_length= (keydef->block_length ?
370 my_round_up_to_next_power(keydef->block_length) :
372 block_length= max(block_length, (uint32_t)MI_MIN_KEY_BLOCK_LENGTH);
373 block_length= min(block_length, (uint32_t)MI_MAX_KEY_BLOCK_LENGTH);
375 keydef->block_length= (uint16_t) MI_BLOCK_SIZE(length-real_length_diff,
376 pointer,MI_MAX_KEYPTR_SIZE,
378 if (keydef->block_length > MI_MAX_KEY_BLOCK_LENGTH ||
379 length >= MI_MAX_KEY_BUFF)
381 errno=HA_WRONG_CREATE_OPTION;
384 set_if_bigger(max_key_block_length,(uint32_t)keydef->block_length);
385 keydef->keylength= (uint16_t) key_length;
386 keydef->minlength= (uint16_t) (length-min_key_length_skip);
387 keydef->maxlength= (uint16_t) length;
389 if (length > max_key_length)
390 max_key_length= length;
391 tot_length+= (max_rows/(ulong) (((uint) keydef->block_length-5)/
393 (ulong) keydef->block_length;
395 for (i=max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH ; i-- ; )
396 key_del[i]=HA_OFFSET_ERROR;
399 offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
400 for (i=0, uniquedef=uniquedefs ; i < uniques ; i++ , uniquedef++)
402 uniquedef->key=keys+i;
403 unique_key_parts+=uniquedef->keysegs;
404 share.state.key_root[keys+i]= HA_OFFSET_ERROR;
405 tot_length+= (max_rows/(ulong) (((uint) myisam_block_size-5)/
406 ((MI_UNIQUE_HASH_LENGTH + pointer)*2)))*
407 (ulong) myisam_block_size;
412 base_pos=(MI_STATE_INFO_SIZE + keys * MI_STATE_KEY_SIZE +
413 max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH*
414 MI_STATE_KEYBLOCK_SIZE+
415 key_segs*MI_STATE_KEYSEG_SIZE);
416 info_length=base_pos+(uint) (MI_BASE_INFO_SIZE+
417 keys * MI_KEYDEF_SIZE+
418 uniques * MI_UNIQUEDEF_SIZE +
419 (key_segs + unique_key_parts)*HA_KEYSEG_SIZE+
420 columns*MI_COLUMNDEF_SIZE);
422 if (info_length > 65535)
424 my_printf_error(EE_OK,
"MyISAM table '%s' has too many columns and/or "
425 "indexes and/or unique constraints.",
426 MYF(0), name + internal::dirname_length(name));
427 errno= HA_WRONG_CREATE_OPTION;
431 memmove(share.state.header.file_version,myisam_file_magic,4);
432 ci->old_options=options| (ci->old_options & HA_OPTION_TEMP_COMPRESS_RECORD ?
433 HA_OPTION_COMPRESS_RECORD |
434 HA_OPTION_TEMP_COMPRESS_RECORD: 0);
435 mi_int2store(share.state.header.options,ci->old_options);
436 mi_int2store(share.state.header.header_length,info_length);
437 mi_int2store(share.state.header.state_info_length,MI_STATE_INFO_SIZE);
438 mi_int2store(share.state.header.base_info_length,MI_BASE_INFO_SIZE);
439 mi_int2store(share.state.header.base_pos,base_pos);
440 share.state.header.language= (ci->language ?
441 ci->language : default_charset_info->number);
442 share.state.header.max_block_size_index= max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH;
444 share.state.dellink = HA_OFFSET_ERROR;
445 share.state.process= (ulong) getpid();
446 share.state.unique= (ulong) 0;
447 share.state.update_count=(ulong) 0;
448 share.state.version= (ulong) time((time_t*) 0);
449 share.state.sortkey= UINT16_MAX;
450 share.state.auto_increment=ci->auto_increment;
451 share.options=options;
452 share.base.rec_reflength=pointer;
454 tmp= (tot_length + max_key_block_length * keys *
455 MI_INDEX_BLOCK_MARGIN) / MI_MIN_KEY_BLOCK_LENGTH;
460 share.base.key_reflength=
461 mi_get_pointer_length(max(ci->key_file_length,tmp),3);
462 share.base.keys= share.state.header.keys= keys;
463 share.state.header.uniques= uniques;
464 share.state.header.fulltext_keys= fulltext_keys;
465 mi_int2store(share.state.header.key_parts,key_segs);
466 mi_int2store(share.state.header.unique_key_parts,unique_key_parts);
468 mi_set_all_keys_active(share.state.key_map, keys);
469 aligned_key_start= my_round_up_to_next_power(max_key_block_length ?
470 max_key_block_length :
473 share.base.keystart= share.state.state.key_file_length=
474 MY_ALIGN(info_length, aligned_key_start);
475 share.base.max_key_block_length=max_key_block_length;
476 share.base.max_key_length=ALIGN_SIZE(max_key_length+4);
477 share.base.records=ci->max_rows;
478 share.base.reloc= ci->reloc_rows;
479 share.base.reclength=real_reclength;
480 share.base.pack_reclength=reclength;
481 share.base.max_pack_length=pack_reclength;
482 share.base.min_pack_length=min_pack_length;
483 share.base.pack_bits=packed;
484 share.base.fields=fields;
485 share.base.pack_fields=packed;
488 if (options & HA_OPTION_TMP_TABLE)
489 share.base.max_data_file_length=(internal::my_off_t) ci->data_file_length;
491 share.base.min_block_length=
492 (share.base.pack_reclength+3 < MI_EXTEND_BLOCK_LENGTH &&
493 ! share.base.blobs) ?
494 max(share.base.pack_reclength,(ulong)MI_MIN_BLOCK_LENGTH) :
495 MI_EXTEND_BLOCK_LENGTH;
496 if (! (flags & HA_DONT_TOUCH_DATA))
497 share.state.create_time= (long) time((time_t*) 0);
499 THR_LOCK_myisam.lock();
505 if (ci->index_file_name)
507 char *iext= strrchr((
char *)ci->index_file_name,
'.');
508 int have_iext= iext && !strcmp(iext, MI_NAME_IEXT);
509 if (options & HA_OPTION_TMP_TABLE)
513 if ((path= strrchr((
char *)ci->index_file_name, FN_LIBCHAR)))
515 internal::fn_format(filename, name, ci->index_file_name, MI_NAME_IEXT,
516 MY_REPLACE_DIR | MY_UNPACK_FILENAME |
517 MY_RETURN_REAL_PATH | MY_APPEND_EXT);
521 internal::fn_format(filename, ci->index_file_name,
"", MI_NAME_IEXT,
522 MY_UNPACK_FILENAME | MY_RETURN_REAL_PATH |
523 (have_iext ? MY_REPLACE_EXT : MY_APPEND_EXT));
525 internal::fn_format(linkname, name,
"", MI_NAME_IEXT,
526 MY_UNPACK_FILENAME|MY_APPEND_EXT);
527 linkname_ptr=linkname;
536 char *iext= strrchr((
char *)name,
'.');
537 int have_iext= iext && !strcmp(iext, MI_NAME_IEXT);
538 internal::fn_format(filename, name,
"", MI_NAME_IEXT,
539 MY_UNPACK_FILENAME | MY_RETURN_REAL_PATH |
540 (have_iext ? MY_REPLACE_EXT : MY_APPEND_EXT));
543 create_flag=(flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
556 if (test_if_reopen(filename))
558 my_printf_error(EE_OK,
"MyISAM table '%s' is in use "
559 "(most likely by a MERGE table). Try FLUSH TABLES.",
560 MYF(0), name + internal::dirname_length(name));
561 errno= HA_ERR_TABLE_EXIST;
565 if ((file= internal::my_create_with_symlink(linkname_ptr,
569 MYF(MY_WME | create_flag))) < 0)
573 if (!(flags & HA_DONT_TOUCH_DATA))
576 if (ci->data_file_name)
578 char *dext= strrchr((
char *)ci->data_file_name,
'.');
579 int have_dext= dext && !strcmp(dext, MI_NAME_DEXT);
581 if (options & HA_OPTION_TMP_TABLE)
585 if ((path= strrchr((
char *)ci->data_file_name, FN_LIBCHAR)))
587 internal::fn_format(filename, name, ci->data_file_name, MI_NAME_DEXT,
588 MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_APPEND_EXT);
592 internal::fn_format(filename, ci->data_file_name,
"", MI_NAME_DEXT,
594 (have_dext ? MY_REPLACE_EXT : MY_APPEND_EXT));
597 internal::fn_format(linkname, name,
"",MI_NAME_DEXT,
598 MY_UNPACK_FILENAME | MY_APPEND_EXT);
599 linkname_ptr=linkname;
604 internal::fn_format(filename,name,
"", MI_NAME_DEXT,
605 MY_UNPACK_FILENAME | MY_APPEND_EXT);
607 create_flag=(flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
609 if ((dfile= internal::my_create_with_symlink(linkname_ptr,
610 filename, 0, create_mode,
611 MYF(MY_WME | create_flag))) < 0)
617 if (mi_state_info_write(file, &share.state, 2) ||
618 mi_base_info_write(file, &share.base))
622 for (i=0 ; i < share.base.keys - uniques; i++)
626 if (mi_keydef_write(file, &keydefs[i]))
628 for (j=0 ; j < keydefs[i].keysegs-sp_segs ; j++)
629 if (mi_keyseg_write(file, &keydefs[i].seg[j]))
633 offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
634 memset(&tmp_keydef, 0,
sizeof(tmp_keydef));
635 memset(&tmp_keyseg, 0,
sizeof(tmp_keyseg));
636 for (i=0; i < uniques ; i++)
638 tmp_keydef.keysegs=1;
639 tmp_keydef.flag= HA_UNIQUE_CHECK;
640 tmp_keydef.block_length= (uint16_t)myisam_block_size;
641 tmp_keydef.keylength= MI_UNIQUE_HASH_LENGTH + pointer;
642 tmp_keydef.minlength=tmp_keydef.maxlength=tmp_keydef.keylength;
643 tmp_keyseg.type= MI_UNIQUE_HASH_TYPE;
644 tmp_keyseg.length= MI_UNIQUE_HASH_LENGTH;
645 tmp_keyseg.start= offset;
646 offset+= MI_UNIQUE_HASH_LENGTH;
647 if (mi_keydef_write(file,&tmp_keydef) ||
648 mi_keyseg_write(file,(&tmp_keyseg)))
653 for (i=0 ; i < share.state.header.uniques ; i++)
655 HA_KEYSEG *keyseg_end;
656 keyseg= uniquedefs[i].seg;
657 if (mi_uniquedef_write(file, &uniquedefs[i]))
659 for (keyseg= uniquedefs[i].seg, keyseg_end= keyseg+ uniquedefs[i].keysegs;
663 switch (keyseg->type) {
664 case HA_KEYTYPE_VARTEXT1:
665 case HA_KEYTYPE_VARTEXT2:
666 case HA_KEYTYPE_VARBINARY1:
667 case HA_KEYTYPE_VARBINARY2:
668 if (!(keyseg->flag & HA_BLOB_PART))
670 keyseg->flag|= HA_VAR_LENGTH_PART;
671 keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1 ||
672 keyseg->type == HA_KEYTYPE_VARBINARY1) ?
679 if (mi_keyseg_write(file, keyseg))
683 for (i=0 ; i < share.base.fields ; i++)
684 if (mi_recinfo_write(file, &recinfo[i]))
688 if (ftruncate(file, (off_t) share.base.keystart))
691 if (! (flags & HA_DONT_TOUCH_DATA))
694 if (ftruncate(dfile,share.base.min_pack_length*ci->reloc_rows,))
698 if (internal::my_close(dfile,MYF(0)))
702 THR_LOCK_myisam.unlock();
703 if (internal::my_close(file,MYF(0)))
705 free((
char*) rec_per_key_part);
709 THR_LOCK_myisam.unlock();
713 internal::my_close(dfile,MYF(0));
716 if (! (flags & HA_DONT_TOUCH_DATA))
717 internal::my_delete_with_symlink(internal::fn_format(filename,name,
"",MI_NAME_DEXT,
718 MY_UNPACK_FILENAME | MY_APPEND_EXT),
722 internal::my_close(file,MYF(0));
723 if (! (flags & HA_DONT_TOUCH_DATA))
724 internal::my_delete_with_symlink(internal::fn_format(filename,name,
"",MI_NAME_IEXT,
725 MY_UNPACK_FILENAME | MY_APPEND_EXT),
728 free((
char*) rec_per_key_part);
729 return(errno=save_errno);
733uint32_t mi_get_pointer_length(uint64_t file_length, uint32_t def)
735 assert(def >= 2 && def <= 7);
738#ifdef NOT_YET_READY_FOR_8_BYTE_POINTERS
739 if (file_length >= 1ULL << 56)
743 if (file_length >= 1ULL << 48)
745 else if (file_length >= 1ULL << 40)
747 else if (file_length >= 1ULL << 32)
749 else if (file_length >= 1ULL << 24)
751 else if (file_length >= 1ULL << 16)
Convert from decimal to binary representation.
TODO: Rename this file - func.h is stupid.