drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
mi_create.cc
1/* Copyright (C) 2000-2006 MySQL AB
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 of the License.
6
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
11
12 You should have received a copy of the GNU General Public License
13 along with this program; if not, write to the Free Software
14 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
15
16/* Create a MyISAM table */
17
18#include "myisam_priv.h"
19#include <drizzled/internal/my_bit.h>
20#include <drizzled/internal/my_sys.h>
21
22#include <drizzled/util/test.h>
23#include <drizzled/charset.h>
24#include <drizzled/error.h>
25
26#include <cassert>
27#include <algorithm>
28
29using namespace std;
30using namespace drizzled;
31
32/*
33 Next highest power of two
34
35 SYNOPSIS
36 my_round_up_to_next_power()
37 v Value to check
38
39 RETURN
40 Next or equal power of 2
41 Note: 0 will return 0
42
43 NOTES
44 Algorithm by Sean Anderson, according to:
45 http://graphics.stanford.edu/~seander/bithacks.html
46 (Orignal code public domain)
47
48 Comments shows how this works with 01100000000000000000000000001011
49*/
50
51static inline uint32_t my_round_up_to_next_power(uint32_t v)
52{
53 v--; /* 01100000000000000000000000001010 */
54 v|= v >> 1; /* 01110000000000000000000000001111 */
55 v|= v >> 2; /* 01111100000000000000000000001111 */
56 v|= v >> 4; /* 01111111110000000000000000001111 */
57 v|= v >> 8; /* 01111111111111111100000000001111 */
58 v|= v >> 16; /* 01111111111111111111111111111111 */
59 return v+1; /* 10000000000000000000000000000000 */
60}
61
62/*
63 Old options is used when recreating database, from myisamchk
64*/
65
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)
70{
71 uint32_t i, j;
72 int dfile= 0, file= 0;
73 int errpos,save_errno, create_mode= O_RDWR | O_TRUNC;
74 myf create_flag;
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;
82 ulong pack_reclength;
83 uint64_t tot_length,max_rows, tmp;
84 enum en_fieldtype type;
85 MYISAM_SHARE share;
86 MI_KEYDEF *keydef,tmp_keydef;
87 MI_UNIQUEDEF *uniquedef;
88 HA_KEYSEG *keyseg,tmp_keyseg;
89 MI_COLUMNDEF *rec;
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;
93
94 if (!ci)
95 {
96 ci=&tmp_create_info;
97 }
98
99 if (keys + uniques > MI_MAX_KEY || columns == 0)
100 {
101 return(errno=HA_WRONG_CREATE_OPTION);
102 }
103 errpos= 0;
104 options= 0;
105 memset(&share, 0, sizeof(share));
106
107 if (flags & HA_DONT_TOUCH_DATA)
108 {
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 );
114 else
115 options=ci->old_options &
116 (HA_OPTION_TMP_TABLE );
117 }
118
119 if (ci->reloc_rows > ci->max_rows)
120 ci->reloc_rows=ci->max_rows; /* Check if wrong parameter */
121
122 if (!(rec_per_key_part=
123 (ulong*) malloc((keys + uniques)*MI_MAX_KEY_SEG*sizeof(long))))
124 return(errno);
125 memset(rec_per_key_part, 0, (keys + uniques)*MI_MAX_KEY_SEG*sizeof(long));
126
127 /* Start by checking fields and field-types used */
128
129 reclength=varchar_length=long_varchar_count=packed=
130 min_pack_length=pack_reclength=0;
131 for (rec=recinfo, fields=0 ;
132 fields != columns ;
133 rec++,fields++)
134 {
135 reclength+=rec->length;
136 if ((type=(enum en_fieldtype) rec->type) != FIELD_NORMAL &&
137 type != FIELD_CHECK)
138 {
139 packed++;
140 if (type == FIELD_BLOB)
141 {
142 share.base.blobs++;
143 if (pack_reclength != INT32_MAX)
144 {
145 if (rec->length == 4+portable_sizeof_char_ptr)
146 pack_reclength= INT32_MAX;
147 else
148 pack_reclength+=(1 << ((rec->length-portable_sizeof_char_ptr)*8)); /* Max blob length */
149 }
150 }
151 else if (type == FIELD_SKIP_PRESPACE ||
152 type == FIELD_SKIP_ENDSPACE)
153 {
154 if (pack_reclength != INT32_MAX)
155 pack_reclength+= rec->length > 255 ? 2 : 1;
156 min_pack_length++;
157 }
158 else if (type == FIELD_VARCHAR)
159 {
160 varchar_length+= rec->length-1; /* Used for min_pack_length */
161 packed--;
162 pack_reclength++;
163 min_pack_length++;
164 /* We must test for 257 as length includes pack-length */
165 if (test(rec->length >= 257))
166 {
167 long_varchar_count++;
168 pack_reclength+= 2; /* May be packed on 3 bytes */
169 }
170 }
171 else if (type != FIELD_SKIP_ZERO)
172 {
173 min_pack_length+=rec->length;
174 packed--; /* Not a pack record type */
175 }
176 }
177 else /* FIELD_NORMAL */
178 min_pack_length+=rec->length;
179 }
180 if ((packed & 7) == 1)
181 { /* Bad packing, try to remove a zero-field */
182 while (rec != recinfo)
183 {
184 rec--;
185 if (rec->type == (int) FIELD_SKIP_ZERO && rec->length == 1)
186 {
187 /*
188 NOTE1: here we change a field type FIELD_SKIP_ZERO ->
189 FIELD_NORMAL
190 */
191 rec->type=(int) FIELD_NORMAL;
192 packed--;
193 min_pack_length++;
194 break;
195 }
196 }
197 }
198
199 if (packed || (flags & HA_PACK_RECORD))
200 options|=HA_OPTION_PACK_RECORD; /* Must use packed records */
201 if (!(options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)))
202 min_pack_length+= varchar_length;
203 if (flags & HA_CREATE_TMP_TABLE)
204 {
205 options|= HA_OPTION_TMP_TABLE;
206 create_mode|= O_EXCL;
207 }
208
209 packed=(packed+7)/8;
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;
215
216 if (!ci->data_file_length && ci->max_rows)
217 {
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;
221 else
222 ci->data_file_length=(uint64_t) ci->max_rows*pack_reclength;
223 }
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) ?
227 3 : 0)));
228
229 if (options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD))
230 pointer=mi_get_pointer_length(ci->data_file_length, data_pointer_size);
231 else
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);
235
236
237 real_reclength=reclength;
238 if (!(options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD)))
239 {
240 if (reclength <= pointer)
241 reclength=pointer+1; /* reserve place for delete link */
242 }
243 else
244 reclength+= long_varchar_count; /* We need space for varchar! */
245
246 max_key_length=0; tot_length=0 ; key_segs=0;
247 fulltext_keys=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;
252 if (uniques)
253 {
254 max_key_block_length= myisam_block_size;
255 max_key_length= MI_UNIQUE_HASH_LENGTH + pointer;
256 }
257
258 for (i=0, keydef=keydefs ; i < keys ; i++ , keydef++)
259 {
260
261 share.state.key_root[i]= HA_OFFSET_ERROR;
262 min_key_length_skip=length=real_length_diff=0;
263 key_length=pointer;
264 {
265 /* Test if prefix compression */
266 if (keydef->flag & HA_PACK_KEY)
267 {
268 /* Only use HA_PACK_KEY when first segment is a variable length key */
269 if (!(keydef->seg[0].flag & (HA_SPACE_PACK | HA_BLOB_PART |
270 HA_VAR_LENGTH_PART)))
271 {
272 /* pack relative to previous key */
273 keydef->flag&= ~HA_PACK_KEY;
274 keydef->flag|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
275 }
276 else
277 {
278 keydef->seg[0].flag|=HA_PACK_KEY; /* for easyer intern test */
279 keydef->flag|=HA_VAR_LENGTH_KEY;
280 options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
281 }
282 }
283 if (keydef->flag & HA_BINARY_PACK_KEY)
284 options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
285
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++)
289 {
290 /* numbers are stored with high by first to make compression easier */
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;
298 break;
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))
304 {
305 /* Make a flag that this is a VARCHAR */
306 keyseg->flag|= HA_VAR_LENGTH_PART;
307 /* Store in bit_start number of bytes used to pack the length */
308 keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1 ||
309 keyseg->type == HA_KEYTYPE_VARBINARY1) ?
310 1 : 2);
311 }
312 break;
313 default:
314 break;
315 }
316 if (keyseg->flag & HA_SPACE_PACK)
317 {
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; /* Using packed keys */
321 length++; /* At least one length byte */
322 min_key_length_skip+=keyseg->length;
323 if (keyseg->length >= 255)
324 { /* prefix may be 3 bytes */
325 min_key_length_skip+=2;
326 length+=2;
327 }
328 }
329 if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
330 {
331 assert(!test_all_bits(keyseg->flag,
332 (HA_VAR_LENGTH_PART | HA_BLOB_PART)));
333 keydef->flag|=HA_VAR_LENGTH_KEY;
334 length++; /* At least one length byte */
335 options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
336 min_key_length_skip+=keyseg->length;
337 if (keyseg->length >= 255)
338 { /* prefix may be 3 bytes */
339 min_key_length_skip+=2;
340 length+=2;
341 }
342 }
343 key_length+= keyseg->length;
344 if (keyseg->null_bit)
345 {
346 key_length++;
347 options|=HA_OPTION_PACK_KEYS;
348 keyseg->flag|=HA_NULL_PART;
349 keydef->flag|=HA_VAR_LENGTH_KEY | HA_NULL_PART_KEY;
350 }
351 }
352 } /* if HA_FULLTEXT */
353 key_segs+=keydef->keysegs;
354 if (keydef->keysegs > MI_MAX_KEY_SEG)
355 {
356 errno=HA_WRONG_CREATE_OPTION;
357 goto err;
358 }
359 /*
360 key_segs may be 0 in the case when we only want to be able to
361 add on row into the table. This can happen with some DISTINCT queries
362 in MySQL
363 */
364 if ((keydef->flag & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME &&
365 key_segs)
366 share.state.rec_per_key_part[key_segs-1]=1L;
367 length+=key_length;
368 /* Get block length for key, if defined by user */
369 block_length= (keydef->block_length ?
370 my_round_up_to_next_power(keydef->block_length) :
371 myisam_block_size);
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);
374
375 keydef->block_length= (uint16_t) MI_BLOCK_SIZE(length-real_length_diff,
376 pointer,MI_MAX_KEYPTR_SIZE,
377 block_length);
378 if (keydef->block_length > MI_MAX_KEY_BLOCK_LENGTH ||
379 length >= MI_MAX_KEY_BUFF)
380 {
381 errno=HA_WRONG_CREATE_OPTION;
382 goto err;
383 }
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;
388
389 if (length > max_key_length)
390 max_key_length= length;
391 tot_length+= (max_rows/(ulong) (((uint) keydef->block_length-5)/
392 (length*2)))*
393 (ulong) keydef->block_length;
394 }
395 for (i=max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH ; i-- ; )
396 key_del[i]=HA_OFFSET_ERROR;
397
398 unique_key_parts=0;
399 offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
400 for (i=0, uniquedef=uniquedefs ; i < uniques ; i++ , uniquedef++)
401 {
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;
408 }
409 keys+=uniques; /* Each unique has 1 key */
410 key_segs+=uniques; /* Each unique has 1 key seg */
411
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);
421 /* There are only 16 bits for the total header length. */
422 if (info_length > 65535)
423 {
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;
428 goto err;
429 }
430
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;
443
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;
453 /* Get estimate for index file length (this may be wrong for FT keys) */
454 tmp= (tot_length + max_key_block_length * keys *
455 MI_INDEX_BLOCK_MARGIN) / MI_MIN_KEY_BLOCK_LENGTH;
456 /*
457 use maximum of key_file_length we calculated and key_file_length value we
458 got from MYI file header (see also myisampack.c:save_state)
459 */
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);
467
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 :
471 myisam_block_size);
472
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;
486
487 /* max_data_file_length and max_key_file_length are recalculated on open */
488 if (options & HA_OPTION_TMP_TABLE)
489 share.base.max_data_file_length=(internal::my_off_t) ci->data_file_length;
490
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);
498
499 THR_LOCK_myisam.lock();
500
501 /*
502 NOTE: For test_if_reopen() we need a real path name. Hence we need
503 MY_RETURN_REAL_PATH for every internal::fn_format(filename, ...).
504 */
505 if (ci->index_file_name)
506 {
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)
510 {
511 char *path;
512 /* chop off the table name, tempory tables use generated name */
513 if ((path= strrchr((char *)ci->index_file_name, FN_LIBCHAR)))
514 *path= '\0';
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);
518 }
519 else
520 {
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));
524 }
525 internal::fn_format(linkname, name, "", MI_NAME_IEXT,
526 MY_UNPACK_FILENAME|MY_APPEND_EXT);
527 linkname_ptr=linkname;
528 /*
529 Don't create the table if the link or file exists to ensure that one
530 doesn't accidently destroy another table.
531 */
532 create_flag=0;
533 }
534 else
535 {
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));
541 linkname_ptr=0;
542 /* Replace the current file */
543 create_flag=(flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
544 }
545
546 /*
547 If a MRG_MyISAM table is in use, the mapped MyISAM tables are open,
548 but no entry is made in the table cache for them.
549 A TRUNCATE command checks for the table in the cache only and could
550 be fooled to believe, the table is not open.
551 Pull the emergency brake in this situation. (Bug #8306)
552
553 NOTE: The filename is compared against unique_file_name of every
554 open table. Hence we need a real path here.
555 */
556 if (test_if_reopen(filename))
557 {
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;
562 goto err;
563 }
564
565 if ((file= internal::my_create_with_symlink(linkname_ptr,
566 filename,
567 0,
568 create_mode,
569 MYF(MY_WME | create_flag))) < 0)
570 goto err;
571 errpos=1;
572
573 if (!(flags & HA_DONT_TOUCH_DATA))
574 {
575 {
576 if (ci->data_file_name)
577 {
578 char *dext= strrchr((char *)ci->data_file_name, '.');
579 int have_dext= dext && !strcmp(dext, MI_NAME_DEXT);
580
581 if (options & HA_OPTION_TMP_TABLE)
582 {
583 char *path;
584 /* chop off the table name, tempory tables use generated name */
585 if ((path= strrchr((char *)ci->data_file_name, FN_LIBCHAR)))
586 *path= '\0';
587 internal::fn_format(filename, name, ci->data_file_name, MI_NAME_DEXT,
588 MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_APPEND_EXT);
589 }
590 else
591 {
592 internal::fn_format(filename, ci->data_file_name, "", MI_NAME_DEXT,
593 MY_UNPACK_FILENAME |
594 (have_dext ? MY_REPLACE_EXT : MY_APPEND_EXT));
595 }
596
597 internal::fn_format(linkname, name, "",MI_NAME_DEXT,
598 MY_UNPACK_FILENAME | MY_APPEND_EXT);
599 linkname_ptr=linkname;
600 create_flag=0;
601 }
602 else
603 {
604 internal::fn_format(filename,name,"", MI_NAME_DEXT,
605 MY_UNPACK_FILENAME | MY_APPEND_EXT);
606 linkname_ptr=0;
607 create_flag=(flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
608 }
609 if ((dfile= internal::my_create_with_symlink(linkname_ptr,
610 filename, 0, create_mode,
611 MYF(MY_WME | create_flag))) < 0)
612 goto err;
613 }
614 errpos=3;
615 }
616
617 if (mi_state_info_write(file, &share.state, 2) ||
618 mi_base_info_write(file, &share.base))
619 goto err;
620
621 /* Write key and keyseg definitions */
622 for (i=0 ; i < share.base.keys - uniques; i++)
623 {
624 uint32_t sp_segs= 0;
625
626 if (mi_keydef_write(file, &keydefs[i]))
627 goto err;
628 for (j=0 ; j < keydefs[i].keysegs-sp_segs ; j++)
629 if (mi_keyseg_write(file, &keydefs[i].seg[j]))
630 goto err;
631 }
632 /* Create extra keys for unique definitions */
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++)
637 {
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)))
649 goto err;
650 }
651
652 /* Save unique definition */
653 for (i=0 ; i < share.state.header.uniques ; i++)
654 {
655 HA_KEYSEG *keyseg_end;
656 keyseg= uniquedefs[i].seg;
657 if (mi_uniquedef_write(file, &uniquedefs[i]))
658 goto err;
659 for (keyseg= uniquedefs[i].seg, keyseg_end= keyseg+ uniquedefs[i].keysegs;
660 keyseg < keyseg_end;
661 keyseg++)
662 {
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))
669 {
670 keyseg->flag|= HA_VAR_LENGTH_PART;
671 keyseg->bit_start= ((keyseg->type == HA_KEYTYPE_VARTEXT1 ||
672 keyseg->type == HA_KEYTYPE_VARBINARY1) ?
673 1 : 2);
674 }
675 break;
676 default:
677 break;
678 }
679 if (mi_keyseg_write(file, keyseg))
680 goto err;
681 }
682 }
683 for (i=0 ; i < share.base.fields ; i++)
684 if (mi_recinfo_write(file, &recinfo[i]))
685 goto err;
686
687 /* Enlarge files */
688 if (ftruncate(file, (off_t) share.base.keystart))
689 goto err;
690
691 if (! (flags & HA_DONT_TOUCH_DATA))
692 {
693#ifdef USE_RELOC
694 if (ftruncate(dfile,share.base.min_pack_length*ci->reloc_rows,))
695 goto err;
696#endif
697 errpos=2;
698 if (internal::my_close(dfile,MYF(0)))
699 goto err;
700 }
701 errpos=0;
702 THR_LOCK_myisam.unlock();
703 if (internal::my_close(file,MYF(0)))
704 goto err;
705 free((char*) rec_per_key_part);
706 return(0);
707
708err:
709 THR_LOCK_myisam.unlock();
710 save_errno=errno;
711 switch (errpos) {
712 case 3:
713 internal::my_close(dfile,MYF(0));
714 /* fall through */
715 case 2:
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),
719 MYF(0));
720 /* fall through */
721 case 1:
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),
726 MYF(0));
727 }
728 free((char*) rec_per_key_part);
729 return(errno=save_errno); /* return the fatal errno */
730}
731
732
733uint32_t mi_get_pointer_length(uint64_t file_length, uint32_t def)
734{
735 assert(def >= 2 && def <= 7);
736 if (file_length) /* If not default */
737 {
738#ifdef NOT_YET_READY_FOR_8_BYTE_POINTERS
739 if (file_length >= 1ULL << 56)
740 def=8;
741 else
742#endif
743 if (file_length >= 1ULL << 48)
744 def=7;
745 else if (file_length >= 1ULL << 40)
746 def=6;
747 else if (file_length >= 1ULL << 32)
748 def=5;
749 else if (file_length >= 1ULL << 24)
750 def=4;
751 else if (file_length >= 1ULL << 16)
752 def=3;
753 else
754 def=2;
755 }
756 return def;
757}
Convert from decimal to binary representation.
Definition common_fwd.h:215
TODO: Rename this file - func.h is stupid.
STL namespace.