开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_create.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：23k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_create.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* Create a MyISAM table */
  19. #include "ftdefs.h"
  20. #include "sp_defs.h"
  22. #if defined(MSDOS) || defined(__WIN__)
  23. #ifdef __WIN__
  24. #include <fcntl.h>
  25. #else
  26. #include <process.h> /* Prototype for getpid */
  27. #endif
  28. #endif
  29. #include <m_ctype.h>
  31. /*
  32. ** Old options is used when recreating database, from isamchk
  33. */
  35. int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
  36.       uint columns, MI_COLUMNDEF *recinfo,
  37.       uint uniques, MI_UNIQUEDEF *uniquedefs,
  38.       MI_CREATE_INFO *ci,uint flags)
  39. {
  40.   register uint i,j;
  41.   File dfile,file;
  42.   int errpos,save_errno, create_mode= O_RDWR | O_TRUNC;
  43.   myf create_flag;
  44.   uint fields,length,max_key_length,packed,pointer,real_length_diff,
  45.        key_length,info_length,key_segs,options,min_key_length_skip,
  46.        base_pos,varchar_count,long_varchar_count,varchar_length,
  47.        max_key_block_length,unique_key_parts,fulltext_keys,offset;
  48.   ulong reclength, real_reclength,min_pack_length;
  49.   char filename[FN_REFLEN],linkname[FN_REFLEN], *linkname_ptr;
  50.   ulong pack_reclength;
  51.   ulonglong tot_length,max_rows, tmp;
  52.   enum en_fieldtype type;
  53.   MYISAM_SHARE share;
  54.   MI_KEYDEF *keydef,tmp_keydef;
  55.   MI_UNIQUEDEF *uniquedef;
  56.   HA_KEYSEG *keyseg,tmp_keyseg;
  57.   MI_COLUMNDEF *rec;
  58.   ulong *rec_per_key_part;
  59.   my_off_t key_root[MI_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
  60.   MI_CREATE_INFO tmp_create_info;
  61.   DBUG_ENTER("mi_create");
  63.   if (!ci)
  64.   {
  65.     bzero((char*) &tmp_create_info,sizeof(tmp_create_info));
  66.     ci=&tmp_create_info;
  67.   }
  69.   if (keys + uniques > MI_MAX_KEY || columns == 0)
  70.   {
  71.     DBUG_RETURN(my_errno=HA_WRONG_CREATE_OPTION);
  72.   }
  73.   LINT_INIT(dfile);
  74.   LINT_INIT(file);
  75.   pthread_mutex_lock(&THR_LOCK_myisam);
  76.   errpos=0;
  77.   options=0;
  78.   bzero((byte*) &share,sizeof(share));
  80.   if (flags & HA_DONT_TOUCH_DATA)
  81.   {
  82.     if (!(ci->old_options & HA_OPTION_TEMP_COMPRESS_RECORD))
  83.       options=ci->old_options &
  84. (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD |
  85.  HA_OPTION_READ_ONLY_DATA | HA_OPTION_CHECKSUM |
  86.  HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE);
  87.     else
  88.       options=ci->old_options &
  89. (HA_OPTION_CHECKSUM | HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE);
  90.   }
  92.   if (ci->reloc_rows > ci->max_rows)
  93.     ci->reloc_rows=ci->max_rows; /* Check if wrong parameter */
  95.   if (!(rec_per_key_part=
  96. (ulong*) my_malloc((keys + uniques)*MI_MAX_KEY_SEG*sizeof(long),
  97.    MYF(MY_WME | MY_ZEROFILL))))
  98.     DBUG_RETURN(my_errno);
  100. /* Start by checking fields and field-types used */
  102.   reclength=varchar_count=varchar_length=long_varchar_count=packed=
  103.     min_pack_length=pack_reclength=0;
  104.   for (rec=recinfo, fields=0 ;
  105.        fields != columns ;
  106.        rec++,fields++)
  107.   {
  108.     reclength+=rec->length;
  109.     if ((type=(enum en_fieldtype) rec->type) != FIELD_NORMAL &&
  110. type != FIELD_CHECK)
  111.     {
  112.       packed++;
  113.       if (type == FIELD_BLOB)
  114.       {
  115. share.base.blobs++;
  116. if (pack_reclength != INT_MAX32)
  117. {
  118.   if (rec->length == 4+mi_portable_sizeof_char_ptr)
  119.     pack_reclength= INT_MAX32;
  120.   else
  121.     pack_reclength+=(1 << ((rec->length-mi_portable_sizeof_char_ptr)*8)); /* Max blob length */
  122. }
  123.       }
  124.       else if (type == FIELD_SKIP_PRESPACE ||
  125.        type == FIELD_SKIP_ENDSPACE)
  126.       {
  127. if (pack_reclength != INT_MAX32)
  128.   pack_reclength+= rec->length > 255 ? 2 : 1;
  129. min_pack_length++;
  130.       }
  131.       else if (type == FIELD_VARCHAR)
  132.       {
  133. varchar_count++;
  134. varchar_length+=rec->length-2;
  135. packed--;
  136. pack_reclength+=1;
  137. if (test(rec->length > 257))
  138. { /* May be packed on 3 bytes */
  139.   long_varchar_count++;
  140.   pack_reclength+=2;
  141. }
  142.       }
  143.       else if (type != FIELD_SKIP_ZERO)
  144.       {
  145. min_pack_length+=rec->length;
  146. packed--; /* Not a pack record type */
  147.       }
  148.     }
  149.     else /* FIELD_NORMAL */
  150.       min_pack_length+=rec->length;
  151.   }
  152.   if ((packed & 7) == 1)
  153.   { /* Bad packing, try to remove a zero-field */
  154.     while (rec != recinfo)
  155.     {
  156.       rec--;
  157.       if (rec->type == (int) FIELD_SKIP_ZERO && rec->length == 1)
  158.       {
  159. rec->type=(int) FIELD_NORMAL;
  160. packed--;
  161. min_pack_length++;
  162. break;
  163.       }
  164.     }
  165.   }
  167.   if (packed || (flags & HA_PACK_RECORD))
  168.     options|=HA_OPTION_PACK_RECORD; /* Must use packed records */
  169.   /* We can't use checksum with static length rows */
  170.   if (!(options & HA_OPTION_PACK_RECORD))
  171.     options&= ~HA_OPTION_CHECKSUM;
  172.   if (options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
  173.     min_pack_length+=varchar_count; /* Min length to pack */
  174.   else
  175.   {
  176.     min_pack_length+=varchar_length+2*varchar_count;
  177.   }
  178.   if (flags & HA_CREATE_TMP_TABLE)
  179.   {
  180.     options|= HA_OPTION_TMP_TABLE;
  181.     create_mode|= O_EXCL | O_NOFOLLOW;
  182.   }
  183.   if (flags & HA_CREATE_CHECKSUM || (options & HA_OPTION_CHECKSUM))
  184.   {
  185.     options|= HA_OPTION_CHECKSUM;
  186.     min_pack_length++;
  187.   }
  188.   if (flags & HA_CREATE_DELAY_KEY_WRITE)
  189.     options|= HA_OPTION_DELAY_KEY_WRITE;
  191.   packed=(packed+7)/8;
  192.   if (pack_reclength != INT_MAX32)
  193.     pack_reclength+= reclength+packed +
  194.       test(test_all_bits(options, HA_OPTION_CHECKSUM | HA_PACK_RECORD));
  195.   min_pack_length+=packed;
  197.   if (!ci->data_file_length && ci->max_rows)
  198.   {
  199.     if (pack_reclength == INT_MAX32 ||
  200.              (~(ulonglong) 0)/ci->max_rows < (ulonglong) pack_reclength)
  201.       ci->data_file_length= ~(ulonglong) 0;
  202.     else
  203.       ci->data_file_length=(ulonglong) ci->max_rows*pack_reclength;
  204.   }
  205.   else if (!ci->max_rows)
  206.     ci->max_rows=(ha_rows) (ci->data_file_length/(min_pack_length +
  207.  ((options & HA_OPTION_PACK_RECORD) ?
  208.   3 : 0)));
  210.   if (options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD))
  211.     pointer=mi_get_pointer_length(ci->data_file_length,myisam_data_pointer_size);
  212.   else
  213.     pointer=mi_get_pointer_length(ci->max_rows,myisam_data_pointer_size);
  214.   if (!(max_rows=(ulonglong) ci->max_rows))
  215.     max_rows= ((((ulonglong) 1 << (pointer*8)) -1) / min_pack_length);
  218.   real_reclength=reclength;
  219.   if (!(options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD)))
  220.   {
  221.     if (reclength <= pointer)
  222.       reclength=pointer+1; /* reserve place for delete link */
  223.   }
  224.   else
  225.     reclength+=long_varchar_count; /* We need space for this! */
  227.   max_key_length=0; tot_length=0 ; key_segs=0;
  228.   fulltext_keys=0;
  229.   max_key_block_length=0;
  230.   share.state.rec_per_key_part=rec_per_key_part;
  231.   share.state.key_root=key_root;
  232.   share.state.key_del=key_del;
  233.   if (uniques)
  234.   {
  235.     max_key_block_length= myisam_block_size;
  236.     max_key_length=   MI_UNIQUE_HASH_LENGTH + pointer;
  237.   }
  239.   for (i=0, keydef=keydefs ; i < keys ; i++ , keydef++)
  240.   {
  242.     share.state.key_root[i]= HA_OFFSET_ERROR;
  243.     min_key_length_skip=length=real_length_diff=0;
  244.     key_length=pointer;
  245.     if (keydef->flag & HA_SPATIAL)
  246.     {
  247. #ifdef HAVE_SPATIAL
  248.       /* BAR TODO to support 3D and more dimensions in the future */
  249.       uint sp_segs=SPDIMS*2;
  250.       keydef->flag=HA_SPATIAL;
  252.       if (flags & HA_DONT_TOUCH_DATA)
  253.       {
  254.         /*
  255.            called by myisamchk - i.e. table structure was taken from
  256.            MYI file and SPATIAL key *does have* additional sp_segs keysegs.
  257.            keydef->seg here points right at the GEOMETRY segment,
  258.            so we only need to decrease keydef->keysegs.
  259.            (see recreate_table() in mi_check.c)
  260.         */
  261.         keydef->keysegs-=sp_segs-1;
  262.       }
  264.       for (j=0, keyseg=keydef->seg ; (int) j < keydef->keysegs ;
  265.    j++, keyseg++)
  266.       {
  267.         if (keyseg->type != HA_KEYTYPE_BINARY &&
  268.     keyseg->type != HA_KEYTYPE_VARBINARY)
  269.         {
  270.           my_errno=HA_WRONG_CREATE_OPTION;
  271.           goto err;
  272.         }
  273.       }
  274.       keydef->keysegs+=sp_segs;
  275.       key_length+=SPLEN*sp_segs;
  276.       length++;                              /* At least one length byte */
  277.       min_key_length_skip+=SPLEN*2*SPDIMS;
  278. #else
  279.       my_errno= HA_ERR_UNSUPPORTED;
  280.       goto err;
  281. #endif /*HAVE_SPATIAL*/
  282.     }
  283.     else
  284.     if (keydef->flag & HA_FULLTEXT)
  285.     {
  286.       keydef->flag=HA_FULLTEXT | HA_PACK_KEY | HA_VAR_LENGTH_KEY;
  287.       options|=HA_OPTION_PACK_KEYS;             /* Using packed keys */
  289.       for (j=0, keyseg=keydef->seg ; (int) j < keydef->keysegs ;
  290.    j++, keyseg++)
  291.       {
  292.         if (keyseg->type != HA_KEYTYPE_TEXT &&
  293.     keyseg->type != HA_KEYTYPE_VARTEXT)
  294.         {
  295.           my_errno=HA_WRONG_CREATE_OPTION;
  296.           goto err;
  297.         }
  298.       }
  300.       fulltext_keys++;
  301.       key_length+= HA_FT_MAXBYTELEN+HA_FT_WLEN;
  302.       length++;                              /* At least one length byte */
  303.       min_key_length_skip+=HA_FT_MAXBYTELEN;
  304.       real_length_diff=HA_FT_MAXBYTELEN-FT_MAX_WORD_LEN_FOR_SORT;
  305.     }
  306.     else
  307.     {
  308.       /* Test if prefix compression */
  309.       if (keydef->flag & HA_PACK_KEY)
  310.       {
  311. /* Can't use space_compression on number keys */
  312. if ((keydef->seg[0].flag & HA_SPACE_PACK) &&
  313.     keydef->seg[0].type == (int) HA_KEYTYPE_NUM)
  314.   keydef->seg[0].flag&= ~HA_SPACE_PACK;
  316. /* Only use HA_PACK_KEY when first segment is a variable length key */
  317. if (!(keydef->seg[0].flag & (HA_SPACE_PACK | HA_BLOB_PART |
  318.      HA_VAR_LENGTH)))
  319. {
  320.   /* pack relative to previous key */
  321.   keydef->flag&= ~HA_PACK_KEY;
  322.   keydef->flag|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
  323. }
  324. else
  325. {
  326.   keydef->seg[0].flag|=HA_PACK_KEY; /* for easyer intern test */
  327.   keydef->flag|=HA_VAR_LENGTH_KEY;
  328.   options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  329. }
  330.       }
  331.       if (keydef->flag & HA_BINARY_PACK_KEY)
  332. options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  334.       if (keydef->flag & HA_AUTO_KEY && ci->with_auto_increment)
  335. share.base.auto_key=i+1;
  336.       for (j=0, keyseg=keydef->seg ; j < keydef->keysegs ; j++, keyseg++)
  337.       {
  338. /* numbers are stored with high by first to make compression easier */
  339. switch (keyseg->type) {
  340. case HA_KEYTYPE_SHORT_INT:
  341. case HA_KEYTYPE_LONG_INT:
  342. case HA_KEYTYPE_FLOAT:
  343. case HA_KEYTYPE_DOUBLE:
  344. case HA_KEYTYPE_USHORT_INT:
  345. case HA_KEYTYPE_ULONG_INT:
  346. case HA_KEYTYPE_LONGLONG:
  347. case HA_KEYTYPE_ULONGLONG:
  348. case HA_KEYTYPE_INT24:
  349. case HA_KEYTYPE_UINT24:
  350. case HA_KEYTYPE_INT8:
  351.   keyseg->flag|= HA_SWAP_KEY;
  352.   /* fall through */
  353. default:
  354.   break;
  355. }
  356. if (keyseg->flag & HA_SPACE_PACK)
  357. {
  358.   keydef->flag |= HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY;
  359.   options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  360.   length++; /* At least one length byte */
  361.   min_key_length_skip+=keyseg->length;
  362.   if (keyseg->length >= 255)
  363.   { /* prefix may be 3 bytes */
  364.     min_key_length_skip+=2;
  365.     length+=2;
  366.   }
  367. }
  368. if (keyseg->flag & (HA_VAR_LENGTH | HA_BLOB_PART))
  369. {
  370.   keydef->flag|=HA_VAR_LENGTH_KEY;
  371.   length++; /* At least one length byte */
  372.   options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  373.   min_key_length_skip+=keyseg->length;
  374.   if (keyseg->length >= 255)
  375.   { /* prefix may be 3 bytes */
  376.     min_key_length_skip+=2;
  377.     length+=2;
  378.   }
  379. }
  380. key_length+= keyseg->length;
  381. if (keyseg->null_bit)
  382. {
  383.   key_length++;
  384.   options|=HA_OPTION_PACK_KEYS;
  385.   keyseg->flag|=HA_NULL_PART;
  386.   keydef->flag|=HA_VAR_LENGTH_KEY | HA_NULL_PART_KEY;
  387. }
  388.       }
  389.     } /* if HA_FULLTEXT */
  390.     key_segs+=keydef->keysegs;
  391.     if (keydef->keysegs > MI_MAX_KEY_SEG)
  392.     {
  393.       my_errno=HA_WRONG_CREATE_OPTION;
  394.       goto err;
  395.     }
  396.     /*
  397.       key_segs may be 0 in the case when we only want to be able to
  398.       add on row into the table. This can happen with some DISTINCT queries
  399.       in MySQL
  400.     */
  401.     if ((keydef->flag & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME &&
  402. key_segs)
  403.       share.state.rec_per_key_part[key_segs-1]=1L;
  404.     length+=key_length;
  405.     keydef->block_length= MI_BLOCK_SIZE(length-real_length_diff,
  406.                                         pointer,MI_MAX_KEYPTR_SIZE);
  407.     if (keydef->block_length > MI_MAX_KEY_BLOCK_LENGTH ||
  408.         length >= MI_MAX_KEY_BUFF)
  409.     {
  410.       my_errno=HA_WRONG_CREATE_OPTION;
  411.       goto err;
  412.     }
  413.     set_if_bigger(max_key_block_length,keydef->block_length);
  414.     keydef->keylength= (uint16) key_length;
  415.     keydef->minlength= (uint16) (length-min_key_length_skip);
  416.     keydef->maxlength= (uint16) length;
  418.     if (length > max_key_length)
  419.       max_key_length= length;
  420.     tot_length+= (max_rows/(ulong) (((uint) keydef->block_length-5)/
  421.     (length*2)))*
  422.       (ulong) keydef->block_length;
  423.   }
  424.   for (i=max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH ; i-- ; )
  425.     key_del[i]=HA_OFFSET_ERROR;
  427.   unique_key_parts=0;
  428.   offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
  429.   for (i=0, uniquedef=uniquedefs ; i < uniques ; i++ , uniquedef++)
  430.   {
  431.     uniquedef->key=keys+i;
  432.     unique_key_parts+=uniquedef->keysegs;
  433.     share.state.key_root[keys+i]= HA_OFFSET_ERROR;
  434.     tot_length+= (max_rows/(ulong) (((uint) myisam_block_size-5)/
  435.                          ((MI_UNIQUE_HASH_LENGTH + pointer)*2)))*
  436.                          (ulong) myisam_block_size;
  437.   }
  438.   keys+=uniques; /* Each unique has 1 key */
  439.   key_segs+=uniques; /* Each unique has 1 key seg */
  441.   base_pos=(MI_STATE_INFO_SIZE + keys * MI_STATE_KEY_SIZE +
  442.     max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH*
  443.     MI_STATE_KEYBLOCK_SIZE+
  444.     key_segs*MI_STATE_KEYSEG_SIZE);
  445.   info_length=base_pos+(uint) (MI_BASE_INFO_SIZE+
  446.        keys * MI_KEYDEF_SIZE+
  447.        uniques * MI_UNIQUEDEF_SIZE +
  448.        (key_segs + unique_key_parts)*HA_KEYSEG_SIZE+
  449.        columns*MI_COLUMNDEF_SIZE);
  451.   bmove(share.state.header.file_version,(byte*) myisam_file_magic,4);
  452.   ci->old_options=options| (ci->old_options & HA_OPTION_TEMP_COMPRESS_RECORD ?
  453. HA_OPTION_COMPRESS_RECORD |
  454. HA_OPTION_TEMP_COMPRESS_RECORD: 0);
  455.   mi_int2store(share.state.header.options,ci->old_options);
  456.   mi_int2store(share.state.header.header_length,info_length);
  457.   mi_int2store(share.state.header.state_info_length,MI_STATE_INFO_SIZE);
  458.   mi_int2store(share.state.header.base_info_length,MI_BASE_INFO_SIZE);
  459.   mi_int2store(share.state.header.base_pos,base_pos);
  460.   share.state.header.language= (ci->language ?
  461. ci->language : default_charset_info->number);
  462.   share.state.header.max_block_size=max_key_block_length/MI_MIN_KEY_BLOCK_LENGTH;
  464.   share.state.dellink = HA_OFFSET_ERROR;
  465.   share.state.process= (ulong) getpid();
  466.   share.state.unique= (ulong) 0;
  467.   share.state.update_count=(ulong) 0;
  468.   share.state.version= (ulong) time((time_t*) 0);
  469.   share.state.sortkey=  (ushort) ~0;
  470.   share.state.auto_increment=ci->auto_increment;
  471.   share.options=options;
  472.   share.base.rec_reflength=pointer;
  473.   /* Get estimate for index file length (this may be wrong for FT keys) */
  474.   tmp= (tot_length + max_key_block_length * keys *
  475. MI_INDEX_BLOCK_MARGIN) / MI_MIN_KEY_BLOCK_LENGTH;
  476.   /*
  477.     use maximum of key_file_length we calculated and key_file_length value we
  478.     got from MYI file header (see also myisampack.c:save_state)
  479.   */
  480.   share.base.key_reflength=
  481.     mi_get_pointer_length(max(ci->key_file_length,tmp),3);
  482.   share.base.keys= share.state.header.keys= keys;
  483.   share.state.header.uniques= uniques;
  484.   share.state.header.fulltext_keys= fulltext_keys;
  485.   mi_int2store(share.state.header.key_parts,key_segs);
  486.   mi_int2store(share.state.header.unique_key_parts,unique_key_parts);
  488.   share.state.key_map = ((ulonglong) 1 << keys)-1;
  489.   share.base.keystart = share.state.state.key_file_length=
  490.     MY_ALIGN(info_length, myisam_block_size);
  491.   share.base.max_key_block_length=max_key_block_length;
  492.   share.base.max_key_length=ALIGN_SIZE(max_key_length+4);
  493.   share.base.records=ci->max_rows;
  494.   share.base.reloc=  ci->reloc_rows;
  495.   share.base.reclength=real_reclength;
  496.   share.base.pack_reclength=reclength+ test(options & HA_OPTION_CHECKSUM);
  497.   share.base.max_pack_length=pack_reclength;
  498.   share.base.min_pack_length=min_pack_length;
  499.   share.base.pack_bits=packed;
  500.   share.base.fields=fields;
  501.   share.base.pack_fields=packed;
  502. #ifdef USE_RAID
  503.   share.base.raid_type=ci->raid_type;
  504.   share.base.raid_chunks=ci->raid_chunks;
  505.   share.base.raid_chunksize=ci->raid_chunksize;
  506. #endif
  508.   /* max_data_file_length and max_key_file_length are recalculated on open */
  509.   if (options & HA_OPTION_TMP_TABLE)
  510.     share.base.max_data_file_length=(my_off_t) ci->data_file_length;
  512.   share.base.min_block_length=
  513.     (share.base.pack_reclength+3 < MI_EXTEND_BLOCK_LENGTH &&
  514.      ! share.base.blobs) ?
  515.     max(share.base.pack_reclength,MI_MIN_BLOCK_LENGTH) :
  516.     MI_EXTEND_BLOCK_LENGTH;
  517.   if (! (flags & HA_DONT_TOUCH_DATA))
  518.     share.state.create_time= (long) time((time_t*) 0);
  520.   if (ci->index_file_name)
  521.   {
  522.     fn_format(filename, ci->index_file_name,"",MI_NAME_IEXT,4);
  523.     fn_format(linkname,name, "",MI_NAME_IEXT,4);
  524.     linkname_ptr=linkname;
  525.     /*
  526.       Don't create the table if the link or file exists to ensure that one
  527.       doesn't accidently destroy another table.
  528.     */
  529.     create_flag=0;
  530.   }
  531.   else
  532.   {
  533.     fn_format(filename,name,"",MI_NAME_IEXT,(4+ (flags & HA_DONT_TOUCH_DATA) ?
  534.      32 : 0));
  535.     linkname_ptr=0;
  536.     /* Replace the current file */
  537.     create_flag=MY_DELETE_OLD;
  538.   }
  540.   /*
  541.     If a MRG_MyISAM table is in use, the mapped MyISAM tables are open,
  542.     but no entry is made in the table cache for them.
  543.     A TRUNCATE command checks for the table in the cache only and could
  544.     be fooled to believe, the table is not open.
  545.     Pull the emergency brake in this situation. (Bug #8306)
  546.   */
  547.   if (test_if_reopen(filename))
  548.   {
  549.     my_printf_error(0, "MyISAM table '%s' is in use "
  550.                     "(most likely by a MERGE table). Try FLUSH TABLES.",
  551.                     MYF(0), name + dirname_length(name));
  552.     goto err;
  553.   }
  555.   if ((file= my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
  556.     MYF(MY_WME | create_flag))) < 0)
  557.     goto err;
  558.   errpos=1;
  560.   if (!(flags & HA_DONT_TOUCH_DATA))
  561.   {
  562. #ifdef USE_RAID
  563.     if (share.base.raid_type)
  564.     {
  565.       (void) fn_format(filename,name,"",MI_NAME_DEXT,2+4);
  566.       if ((dfile=my_raid_create(filename, 0, create_mode,
  567. share.base.raid_type,
  568. share.base.raid_chunks,
  569. share.base.raid_chunksize,
  570. MYF(MY_WME | MY_RAID))) < 0)
  571. goto err;
  572.     }
  573.     else
  574. #endif
  575.     {
  576.       if (ci->data_file_name)
  577.       {
  578. fn_format(filename, ci->data_file_name,"",MI_NAME_DEXT,4);
  579. fn_format(linkname, name, "",MI_NAME_DEXT,4);
  580. linkname_ptr=linkname;
  581. create_flag=0;
  582.       }
  583.       else
  584.       {
  585. fn_format(filename,name,"",MI_NAME_DEXT,4);
  586. linkname_ptr=0;
  587. create_flag=MY_DELETE_OLD;
  588.       }
  589.       if ((dfile=
  590.    my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
  591.   MYF(MY_WME | create_flag))) < 0)
  592. goto err;
  593.     }
  594.     errpos=3;
  595.   }
  597.   if (mi_state_info_write(file, &share.state, 2) ||
  598.       mi_base_info_write(file, &share.base))
  599.     goto err;
  600. #ifndef DBUG_OFF
  601.   if ((uint) my_tell(file,MYF(0)) != base_pos+ MI_BASE_INFO_SIZE)
  602.   {
  603.     uint pos=(uint) my_tell(file,MYF(0));
  604.     DBUG_PRINT("warning",("base_length: %d  != used_length: %d",
  605.   base_pos+ MI_BASE_INFO_SIZE, pos));
  606.   }
  607. #endif
  609.   /* Write key and keyseg definitions */
  610.   for (i=0 ; i < share.base.keys - uniques; i++)
  611.   {
  612.     uint sp_segs=(keydefs[i].flag & HA_SPATIAL) ? 2*SPDIMS : 0;
  614.     if (mi_keydef_write(file, &keydefs[i]))
  615.       goto err;
  616.     for (j=0 ; j < keydefs[i].keysegs-sp_segs ; j++)
  617.       if (mi_keyseg_write(file, &keydefs[i].seg[j]))
  618.        goto err;
  619. #ifdef HAVE_SPATIAL
  620.     for (j=0 ; j < sp_segs ; j++)
  621.     {
  622.       HA_KEYSEG sseg;
  623.       sseg.type=SPTYPE;
  624.       sseg.language= 7;
  625.       sseg.null_bit=0;
  626.       sseg.bit_start=0;
  627.       sseg.bit_end=0;
  628.       sseg.length=SPLEN;
  629.       sseg.null_pos=0;
  630.       sseg.start=j*SPLEN;
  631.       sseg.flag= HA_SWAP_KEY;
  632.       if (mi_keyseg_write(file, &sseg))
  633.         goto err;
  634.     }
  635. #endif
  636.   }
  637.   /* Create extra keys for unique definitions */
  638.   offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
  639.   bzero((char*) &tmp_keydef,sizeof(tmp_keydef));
  640.   bzero((char*) &tmp_keyseg,sizeof(tmp_keyseg));
  641.   for (i=0; i < uniques ; i++)
  642.   {
  643.     tmp_keydef.keysegs=1;
  644.     tmp_keydef.flag= HA_UNIQUE_CHECK;
  645.     tmp_keydef.block_length= myisam_block_size;
  646.     tmp_keydef.keylength= MI_UNIQUE_HASH_LENGTH + pointer;
  647.     tmp_keydef.minlength=tmp_keydef.maxlength=tmp_keydef.keylength;
  648.     tmp_keyseg.type= MI_UNIQUE_HASH_TYPE;
  649.     tmp_keyseg.length= MI_UNIQUE_HASH_LENGTH;
  650.     tmp_keyseg.start= offset;
  651.     offset+= MI_UNIQUE_HASH_LENGTH;
  652.     if (mi_keydef_write(file,&tmp_keydef) ||
  653. mi_keyseg_write(file,(&tmp_keyseg)))
  654.       goto err;
  655.   }
  657.   /* Save unique definition */
  658.   for (i=0 ; i < share.state.header.uniques ; i++)
  659.   {
  660.     if (mi_uniquedef_write(file, &uniquedefs[i]))
  661.       goto err;
  662.     for (j=0 ; j < uniquedefs[i].keysegs ; j++)
  663.     {
  664.       if (mi_keyseg_write(file, &uniquedefs[i].seg[j]))
  665. goto err;
  666.     }
  667.   }
  668.   for (i=0 ; i < share.base.fields ; i++)
  669.     if (mi_recinfo_write(file, &recinfo[i]))
  670.       goto err;
  672. #ifndef DBUG_OFF
  673.   if ((uint) my_tell(file,MYF(0)) != info_length)
  674.   {
  675.     uint pos= (uint) my_tell(file,MYF(0));
  676.     DBUG_PRINT("warning",("info_length: %d  != used_length: %d",
  677.   info_length, pos));
  678.   }
  679. #endif
  681. /* Enlarge files */
  682.   if (my_chsize(file,(ulong) share.base.keystart,0,MYF(0)))
  683.     goto err;
  685.   if (! (flags & HA_DONT_TOUCH_DATA))
  686.   {
  687. #ifdef USE_RELOC
  688.     if (my_chsize(dfile,share.base.min_pack_length*ci->reloc_rows,0,MYF(0)))
  689.       goto err;
  690. #endif
  691.     errpos=2;
  692.     if (my_close(dfile,MYF(0)))
  693.       goto err;
  694.   }
  695.   errpos=0;
  696.   pthread_mutex_unlock(&THR_LOCK_myisam);
  697.   if (my_close(file,MYF(0)))
  698.     goto err;
  699.   my_free((char*) rec_per_key_part,MYF(0));
  700.   DBUG_RETURN(0);
  702. err:
  703.   pthread_mutex_unlock(&THR_LOCK_myisam);
  704.   save_errno=my_errno;
  705.   switch (errpos) {
  706.   case 3:
  707.     VOID(my_close(dfile,MYF(0)));
  708.     /* fall through */
  709.   case 2:
  710.     /* QQ: T鮪u should add a call to my_raid_delete() here */
  711.   if (! (flags & HA_DONT_TOUCH_DATA))
  712.     my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_DEXT,2+4),
  713.    MYF(0));
  714.     /* fall through */
  715.   case 1:
  716.     VOID(my_close(file,MYF(0)));
  717.     if (! (flags & HA_DONT_TOUCH_DATA))
  718.       my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_IEXT,2+4),
  719.      MYF(0));
  720.   }
  721.   my_free((char*) rec_per_key_part, MYF(0));
  722.   DBUG_RETURN(my_errno=save_errno); /* return the fatal errno */
  723. }
  726. uint mi_get_pointer_length(ulonglong file_length, uint def)
  727. {
  728.   DBUG_ASSERT(def >= 2 && def <= 7);
  729.   if (file_length) /* If not default */
  730.   {
  731. #ifdef NOT_YET_READY_FOR_8_BYTE_POINTERS
  732.     if (file_length >= (longlong) 1 << 56)
  733.       def=8;
  734. #endif
  735.     if (file_length >= (longlong) 1 << 48)
  736.       def=7;
  737.     if (file_length >= (longlong) 1 << 40)
  738.       def=6;
  739.     else if (file_length >= (longlong) 1 << 32)
  740.       def=5;
  741.     else if (file_length >= (1L << 24))
  742.       def=4;
  743.     else if (file_length >= (1L << 16))
  744.       def=3;
  745.     else
  746.       def=2;
  747.   }
  748.   return def;
  749. }