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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_create.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：19k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_create.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  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.
  12.    
  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 "fulltext.h"
  20. #if defined(MSDOS) || defined(__WIN__)
  21. #ifdef __WIN__
  22. #include <fcntl.h>
  23. #else
  24. #include <process.h> /* Prototype for getpid */
  25. #endif
  26. #endif
  27. #include <m_ctype.h>
  29. /*
  30. ** Old options is used when recreating database, from isamchk
  31. */
  33. int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs,
  34.       uint columns, MI_COLUMNDEF *recinfo,
  35.       uint uniques, MI_UNIQUEDEF *uniquedefs,
  36.       MI_CREATE_INFO *ci,uint flags)
  37. {
  38.   register uint i,j;
  39.   File dfile,file;
  40.   int errpos,save_errno;
  41.   uint fields,length,max_key_length,packed,pointer,
  42.        key_length,info_length,key_segs,options,min_key_length_skipp,
  43.        base_pos,varchar_count,long_varchar_count,varchar_length,
  44.        max_key_block_length,unique_key_parts,offset;
  45.   ulong reclength, real_reclength,min_pack_length;
  46.   char buff[FN_REFLEN];
  47.   ulong pack_reclength;
  48.   ulonglong tot_length,max_rows;
  49.   enum en_fieldtype type;
  50.   MYISAM_SHARE share;
  51.   MI_KEYDEF *keydef,tmp_keydef;
  52.   MI_UNIQUEDEF *uniquedef;
  53.   MI_KEYSEG *keyseg,tmp_keyseg;
  54.   MI_COLUMNDEF *rec;
  55.   ulong *rec_per_key_part;
  56.   my_off_t key_root[MI_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
  57.   MI_CREATE_INFO tmp_create_info;
  58.   DBUG_ENTER("mi_create");
  60.   if (!ci)
  61.   {
  62.     bzero((char*) &tmp_create_info,sizeof(tmp_create_info));
  63.     ci=&tmp_create_info;
  64.   }
  66.   if (keys + uniques > MI_MAX_KEY)
  67.   {
  68.     DBUG_RETURN(my_errno=HA_WRONG_CREATE_OPTION);
  69.   }
  70.   LINT_INIT(dfile);
  71.   LINT_INIT(file);
  72.   pthread_mutex_lock(&THR_LOCK_myisam);
  73.   errpos=0;
  74.   options=0;
  75.   bzero((byte*) &share,sizeof(share));
  77.   if (flags & HA_DONT_TOUCH_DATA)
  78.   {
  79.     if (!(ci->old_options & HA_OPTION_TEMP_COMPRESS_RECORD))
  80.       options=ci->old_options &
  81. (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD |
  82.  HA_OPTION_READ_ONLY_DATA | HA_OPTION_CHECKSUM |
  83.  HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE);
  84.     else
  85.       options=ci->old_options &
  86. (HA_OPTION_CHECKSUM | HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE);
  87.   }
  89.   if (ci->reloc_rows > ci->max_rows)
  90.     ci->reloc_rows=ci->max_rows; /* Check if wrong parameter */
  92.   if (!(rec_per_key_part=
  93. (ulong*) my_malloc((keys + uniques)*MI_MAX_KEY_SEG*sizeof(long),
  94.    MYF(MY_WME | MY_ZEROFILL))))
  95.     DBUG_RETURN(my_errno);
  97. /* Start by checking fields and field-types used */
  99.   reclength=varchar_count=varchar_length=long_varchar_count=packed=
  100.     min_pack_length=pack_reclength=0;
  101.   for (rec=recinfo, fields=0 ;
  102.        fields != columns ;
  103.        rec++,fields++)
  104.   {
  105.     reclength+=rec->length;
  106.     if ((type=(enum en_fieldtype) rec->type) != FIELD_NORMAL &&
  107. type != FIELD_CHECK)
  108.     {
  109.       packed++;
  110.       if (type == FIELD_BLOB)
  111.       {
  112. share.base.blobs++;
  113. if (pack_reclength != INT_MAX32)
  114. {
  115.   if (rec->length == 4+mi_portable_sizeof_char_ptr)
  116.     pack_reclength= INT_MAX32;
  117.   else
  118.     pack_reclength+=(1 << ((rec->length-mi_portable_sizeof_char_ptr)*8)); /* Max blob length */
  119. }
  120.       }
  121.       else if (type == FIELD_SKIPP_PRESPACE ||
  122.        type == FIELD_SKIPP_ENDSPACE)
  123.       {
  124. if (pack_reclength != INT_MAX32)
  125.   pack_reclength+= rec->length > 255 ? 2 : 1;
  126. min_pack_length++;
  127.       }
  128.       else if (type == FIELD_VARCHAR)
  129.       {
  130. varchar_count++;
  131. varchar_length+=rec->length-2;
  132. packed--;
  133. pack_reclength+=1;
  134. if (test(rec->length > 257))
  135. { /* May be packed on 3 bytes */
  136.   long_varchar_count++;
  137.   pack_reclength+=2;
  138. }
  139.       }
  140.       else if (type != FIELD_SKIPP_ZERO)
  141.       {
  142. min_pack_length+=rec->length;
  143. packed--; /* Not a pack record type */
  144.       }
  145.     }
  146.     else /* FIELD_NORMAL */
  147.       min_pack_length+=rec->length;
  148.   }
  149.   if ((packed & 7) == 1)
  150.   { /* Bad packing, try to remove a zero-field */
  151.     while (rec != recinfo)
  152.     {
  153.       rec--;
  154.       if (rec->type == (int) FIELD_SKIPP_ZERO && rec->length == 1)
  155.       {
  156. rec->type=(int) FIELD_NORMAL;
  157. packed--;
  158. min_pack_length++;
  159. break;
  160.       }
  161.     }
  162.   }
  164.   if (packed || (flags & HA_PACK_RECORD))
  165.     options|=HA_OPTION_PACK_RECORD; /* Must use packed records */
  166.   if (options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
  167.     min_pack_length+=varchar_count; /* Min length to pack */
  168.   else
  169.   {
  170.     min_pack_length+=varchar_length+2*varchar_count;
  171.   }
  172.   if (flags & HA_CREATE_TMP_TABLE)
  173.     options|= HA_OPTION_TMP_TABLE;
  174.   if (flags & HA_CREATE_CHECKSUM || (options & HA_OPTION_CHECKSUM))
  175.   {
  176.     options|= HA_OPTION_CHECKSUM;
  177.     min_pack_length++;
  178.   }
  179.   if (flags & HA_CREATE_DELAY_KEY_WRITE)
  180.     options|= HA_OPTION_DELAY_KEY_WRITE;
  182.   packed=(packed+7)/8;
  183.   if (pack_reclength != INT_MAX32)
  184.     pack_reclength+= reclength+packed +
  185.       test(test_all_bits(options, HA_OPTION_CHECKSUM | HA_PACK_RECORD));
  186.   min_pack_length+=packed;
  188.   if (!ci->data_file_length)
  189.   {
  190.     if (ci->max_rows == 0 || pack_reclength == INT_MAX32)
  191.       ci->data_file_length= INT_MAX32-1; /* Should be enough */
  192.     else if ((~(ulonglong) 0)/ci->max_rows < (ulonglong) pack_reclength)
  193.       ci->data_file_length= ~(ulonglong) 0;
  194.     else
  195.       ci->data_file_length=(ulonglong) ci->max_rows*pack_reclength;
  196.   }
  197.   else if (!ci->max_rows)
  198.     ci->max_rows=(ha_rows) (ci->data_file_length/(min_pack_length +
  199.  ((options & HA_OPTION_PACK_RECORD) ?
  200.   3 : 0)));
  202.   if (options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD))
  203.     pointer=mi_get_pointer_length(ci->data_file_length,4);
  204.   else
  205.     pointer=mi_get_pointer_length(ci->max_rows,4);
  206.   if (!(max_rows=(ulonglong) ci->max_rows))
  207.     max_rows= ((((ulonglong) 1 << (pointer*8)) -1) / min_pack_length);
  210.   real_reclength=reclength;
  211.   if (!(options & (HA_OPTION_COMPRESS_RECORD | HA_OPTION_PACK_RECORD)))
  212.   {
  213.     if (reclength <= pointer)
  214.       reclength=pointer+1; /* reserve place for delete link */
  215.   }
  216.   else
  217.     reclength+=long_varchar_count; /* We need space for this! */
  219.   max_key_length=0; tot_length=0 ; key_segs=0;
  220.   max_key_block_length=0;
  221.   share.state.rec_per_key_part=rec_per_key_part;
  222.   share.state.key_root=key_root;
  223.   share.state.key_del=key_del;
  224.   if (uniques)
  225.   {
  226.     max_key_block_length= MI_KEY_BLOCK_LENGTH;
  227.     max_key_length= MI_UNIQUE_HASH_LENGTH;
  228.   }
  230.   for (i=0, keydef=keydefs ; i < keys ; i++ , keydef++)
  231.   {
  232.     share.state.key_root[i]= HA_OFFSET_ERROR;
  234.     min_key_length_skipp=length=0;
  235.     key_length=pointer;
  237.     if (keydef->flag & HA_FULLTEXT)                                 /* SerG */
  238.     {
  239.       keydef->flag=HA_FULLTEXT | HA_PACK_KEY | HA_VAR_LENGTH_KEY;
  240.       options|=HA_OPTION_PACK_KEYS;             /* Using packed keys */
  242.       if (flags & HA_DONT_TOUCH_DATA)
  243.       {
  244.         /* called by myisamchk - i.e. table structure was taken from
  245.            MYI file and FULLTEXT key *do has* additional FT_SEGS keysegs.
  246.            We'd better delete them now
  247.         */
  248.         keydef->keysegs-=FT_SEGS;
  249.       }
  251.       for (j=0, keyseg=keydef->seg ; (int) j < keydef->keysegs ;
  252.    j++, keyseg++)
  253.       {
  254.         if (keyseg->type != HA_KEYTYPE_TEXT &&
  255.     keyseg->type != HA_KEYTYPE_VARTEXT)
  256.         {
  257.           my_errno=HA_WRONG_CREATE_OPTION;
  258.           goto err;
  259.         }
  260.       }
  261.       keydef->keysegs+=FT_SEGS;
  263.       key_length+= HA_FT_MAXLEN+HA_FT_WLEN;
  264. #ifdef EVAL_RUN
  265.       key_length++;
  266. #endif
  268.       length++;                              /* At least one length byte */
  269.       min_key_length_skipp+=HA_FT_MAXLEN;
  270. #if HA_FT_MAXLEN >= 255
  271.       min_key_length_skipp+=2;                  /* prefix may be 3 bytes */
  272.       length+=2;
  273. #endif
  274.     }
  275.     else
  276.     {
  277.       /* Test if prefix compression */
  278.       if (keydef->flag & HA_PACK_KEY)
  279.       {
  280. /* Can't use space_compression on number keys */
  281. if ((keydef->seg[0].flag & HA_SPACE_PACK) &&
  282.     keydef->seg[0].type == (int) HA_KEYTYPE_NUM)
  283.   keydef->seg[0].flag&= ~HA_SPACE_PACK;
  285. /* Only use HA_PACK_KEY if the first segment is a variable length key */
  286. if (!(keydef->seg[0].flag & (HA_SPACE_PACK | HA_BLOB_PART |
  287.      HA_VAR_LENGTH)))
  288. {
  289.   /* pack relative to previous key */
  290.   keydef->flag&= ~HA_PACK_KEY;
  291.   keydef->flag|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
  292. }
  293. else
  294. {
  295.   keydef->seg[0].flag|=HA_PACK_KEY; /* for easyer intern test */
  296.   keydef->flag|=HA_VAR_LENGTH_KEY;
  297.   options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  298. }
  299.       }
  300.       if (keydef->flag & HA_BINARY_PACK_KEY)
  301. options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  303.       if (keydef->flag & HA_AUTO_KEY)
  304. share.base.auto_key=i+1;
  305.       for (j=0, keyseg=keydef->seg ; j < keydef->keysegs ; j++, keyseg++)
  306.       {
  307. /* numbers are stored with high by first to make compression easier */
  308. switch (keyseg->type) {
  309. case HA_KEYTYPE_SHORT_INT:
  310. case HA_KEYTYPE_LONG_INT:
  311. case HA_KEYTYPE_FLOAT:
  312. case HA_KEYTYPE_DOUBLE:
  313. case HA_KEYTYPE_USHORT_INT:
  314. case HA_KEYTYPE_ULONG_INT:
  315. case HA_KEYTYPE_LONGLONG:
  316. case HA_KEYTYPE_ULONGLONG:
  317. case HA_KEYTYPE_INT24:
  318. case HA_KEYTYPE_UINT24:
  319. case HA_KEYTYPE_INT8:
  320.   keyseg->flag|= HA_SWAP_KEY;
  321.   /* fall through */
  322. default:
  323.   break;
  324. }
  325. if (keyseg->flag & HA_SPACE_PACK)
  326. {
  327.   keydef->flag |= HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY;
  328.   options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  329.   length++; /* At least one length byte */
  330.   min_key_length_skipp+=keyseg->length;
  331.   if (keyseg->length >= 255)
  332.   { /* prefix may be 3 bytes */
  333.     min_key_length_skipp+=2;
  334.     length+=2;
  335.   }
  336. }
  337. if (keyseg->flag & (HA_VAR_LENGTH | HA_BLOB_PART))
  338. {
  339.   keydef->flag|=HA_VAR_LENGTH_KEY;
  340.   length++; /* At least one length byte */
  341.   options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  342.   min_key_length_skipp+=keyseg->length;
  343.   if (keyseg->length >= 255)
  344.   { /* prefix may be 3 bytes */
  345.     min_key_length_skipp+=2;
  346.     length+=2;
  347.   }
  348. }
  349. key_length+= keyseg->length;
  350. if (keyseg->null_bit)
  351. {
  352.   key_length++;
  353.   options|=HA_OPTION_PACK_KEYS;
  354.   keyseg->flag|=HA_NULL_PART;
  355.   keydef->flag|=HA_VAR_LENGTH_KEY | HA_NULL_PART_KEY;
  356. }
  357.       }
  358.     } /* if HA_FULLTEXT */
  359.     key_segs+=keydef->keysegs;
  360.     if (keydef->keysegs > MI_MAX_KEY_SEG)
  361.     {
  362.       my_errno=HA_WRONG_CREATE_OPTION;
  363.       goto err;
  364.     }
  365.     if ((keydef->flag & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME)
  366.       share.state.rec_per_key_part[key_segs-1]=1L;
  367.     length+=key_length;
  368.     keydef->block_length= MI_BLOCK_SIZE(length,pointer,MI_MAX_KEYPTR_SIZE);
  369.     if (keydef->block_length/MI_KEY_BLOCK_LENGTH > MI_MAX_KEY_BLOCK_SIZE)
  370.     {
  371.       my_errno=HA_WRONG_CREATE_OPTION;
  372.       goto err;
  373.     }
  374.     set_if_bigger(max_key_block_length,keydef->block_length);
  375.     keydef->keylength= (uint16) key_length;
  376.     keydef->minlength= (uint16) (length-min_key_length_skipp);
  377.     keydef->maxlength= (uint16) length;
  379.     if (length > max_key_length)
  380.       max_key_length= length;
  381.     tot_length+= (max_rows/(ulong) (((uint) keydef->block_length-5)/
  382.     (length*2)))*
  383.       (ulong) keydef->block_length;
  384.   }
  385.   for (i=max_key_block_length/MI_KEY_BLOCK_LENGTH ; i-- ; )
  386.     key_del[i]=HA_OFFSET_ERROR;
  388.   unique_key_parts=0;
  389.   offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
  390.   for (i=0, uniquedef=uniquedefs ; i < uniques ; i++ , uniquedef++)
  391.   {
  392.     uniquedef->key=keys+i;
  393.     unique_key_parts+=uniquedef->keysegs;
  394.     share.state.key_root[keys+i]= HA_OFFSET_ERROR;
  395.   }
  396.   keys+=uniques; /* Each unique has 1 key */
  397.   key_segs+=uniques; /* Each unique has 1 key seg */
  399.   base_pos=(MI_STATE_INFO_SIZE + keys * MI_STATE_KEY_SIZE +
  400.     max_key_block_length/MI_KEY_BLOCK_LENGTH*MI_STATE_KEYBLOCK_SIZE+
  401.     key_segs*MI_STATE_KEYSEG_SIZE);
  402.   info_length=base_pos+(uint) (MI_BASE_INFO_SIZE+
  403.        keys * MI_KEYDEF_SIZE+
  404.        uniques * MI_UNIQUEDEF_SIZE +
  405.        (key_segs + unique_key_parts)*MI_KEYSEG_SIZE+
  406.        columns*MI_COLUMNDEF_SIZE);
  408.   bmove(share.state.header.file_version,(byte*) myisam_file_magic,4);
  409.   ci->old_options=options| (ci->old_options & HA_OPTION_TEMP_COMPRESS_RECORD ?
  410. HA_OPTION_COMPRESS_RECORD |
  411. HA_OPTION_TEMP_COMPRESS_RECORD: 0);
  412.   mi_int2store(share.state.header.options,ci->old_options);
  413.   mi_int2store(share.state.header.header_length,info_length);
  414.   mi_int2store(share.state.header.state_info_length,MI_STATE_INFO_SIZE);
  415.   mi_int2store(share.state.header.base_info_length,MI_BASE_INFO_SIZE);
  416.   mi_int2store(share.state.header.base_pos,base_pos);
  417.   share.state.header.language= (ci->language ?
  418. ci->language : MY_CHARSET_CURRENT);
  419.   share.state.header.max_block_size=max_key_block_length/MI_KEY_BLOCK_LENGTH;
  421.   share.state.dellink = HA_OFFSET_ERROR;
  422.   share.state.process= (ulong) getpid();
  423.   share.state.unique= (ulong) 0;
  424.   share.state.update_count=(ulong) 0;
  425.   share.state.version= (ulong) time((time_t*) 0);
  426.   share.state.sortkey=  (ushort) ~0;
  427.   share.state.auto_increment=ci->auto_increment;
  428.   share.options=options;
  429.   share.base.rec_reflength=pointer;
  430.   share.base.key_reflength=
  431.     mi_get_pointer_length((tot_length + max_key_block_length * keys *
  432.    MI_INDEX_BLOCK_MARGIN) / MI_KEY_BLOCK_LENGTH,
  433.   3);
  434.   share.base.keys= share.state.header.keys = keys;
  435.   share.state.header.uniques= uniques;
  436.   mi_int2store(share.state.header.key_parts,key_segs);
  437.   mi_int2store(share.state.header.unique_key_parts,unique_key_parts);
  439.   share.state.key_map = ((ulonglong) 1 << keys)-1;
  440.   share.base.keystart = share.state.state.key_file_length=
  441.     MY_ALIGN(info_length, myisam_block_size);
  442.   share.base.max_key_block_length=max_key_block_length;
  443.   share.base.max_key_length=ALIGN_SIZE(max_key_length+4);
  444.   share.base.records=ci->max_rows;
  445.   share.base.reloc=  ci->reloc_rows;
  446.   share.base.reclength=real_reclength;
  447.   share.base.pack_reclength=reclength+ test(options & HA_OPTION_CHECKSUM);;
  448.   share.base.max_pack_length=pack_reclength;
  449.   share.base.min_pack_length=min_pack_length;
  450.   share.base.pack_bits=packed;
  451.   share.base.fields=fields;
  452.   share.base.pack_fields=packed;
  453. #ifdef USE_RAID
  454.   share.base.raid_type=ci->raid_type;
  455.   share.base.raid_chunks=ci->raid_chunks;
  456.   share.base.raid_chunksize=ci->raid_chunksize;
  457. #endif
  459.   /* max_data_file_length and max_key_file_length are recalculated on open */
  460.   if (options & HA_OPTION_TMP_TABLE)
  461.     share.base.max_data_file_length=(my_off_t) ci->data_file_length;
  463.   share.base.min_block_length=
  464.     (share.base.pack_reclength+3 < MI_EXTEND_BLOCK_LENGTH &&
  465.      ! share.base.blobs) ?
  466.     max(share.base.pack_reclength,MI_MIN_BLOCK_LENGTH) :
  467.     MI_EXTEND_BLOCK_LENGTH;
  468.   if (! (flags & HA_DONT_TOUCH_DATA))
  469.     share.state.create_time= (long) time((time_t*) 0);
  471.   if ((file = my_create(fn_format(buff,name,"",MI_NAME_IEXT,4),0,
  472. O_RDWR | O_TRUNC,MYF(MY_WME))) < 0)
  473.     goto err;
  474.   errpos=1;
  475.   VOID(fn_format(buff,name,"",MI_NAME_DEXT,2+4));
  476.   if (!(flags & HA_DONT_TOUCH_DATA))
  477.   {
  478. #ifdef USE_RAID
  479.     if (share.base.raid_type)
  480.     {
  481.       if ((dfile=my_raid_create(buff,0,O_RDWR | O_TRUNC,
  482. share.base.raid_type,
  483. share.base.raid_chunks,
  484. share.base.raid_chunksize,
  485. MYF(MY_WME | MY_RAID))) < 0)
  486. goto err;
  487.     }
  488.     else
  489. #endif
  490.     if ((dfile = my_create(buff,0,O_RDWR | O_TRUNC,MYF(MY_WME))) < 0)
  491.       goto err;
  493.     errpos=3;
  494.   }
  496.   if (mi_state_info_write(file, &share.state, 2) ||
  497.       mi_base_info_write(file, &share.base))
  498.     goto err;
  499. #ifndef DBUG_OFF
  500.   if ((uint) my_tell(file,MYF(0)) != base_pos+ MI_BASE_INFO_SIZE)
  501.   {
  502.     uint pos=(uint) my_tell(file,MYF(0));
  503.     DBUG_PRINT("warning",("base_length: %d  != used_length: %d",
  504.   base_pos+ MI_BASE_INFO_SIZE, pos));
  505.   }
  506. #endif
  508.   /* Write key and keyseg definitions */
  509.   for (i=0 ; i < share.base.keys - uniques; i++)
  510.   {
  511.     uint ft_segs=(keydefs[i].flag & HA_FULLTEXT) ? FT_SEGS : 0;    /* SerG */
  513.     if (mi_keydef_write(file, &keydefs[i]))
  514.       goto err;
  515.     for (j=0 ; j < keydefs[i].keysegs-ft_segs ; j++)
  516.       if (mi_keyseg_write(file, &keydefs[i].seg[j]))
  517. goto err;
  518.     for (j=0 ; j < ft_segs ; j++)                                   /* SerG */
  519.     {
  520.       MI_KEYSEG seg=ft_keysegs[j];
  521.       seg.language= keydefs[i].seg[0].language;
  522.       if (mi_keyseg_write(file, &seg))
  523.         goto err;
  524.     }
  525.   }
  526.   /* Create extra keys for unique definitions */
  527.   offset=reclength-uniques*MI_UNIQUE_HASH_LENGTH;
  528.   bzero((char*) &tmp_keydef,sizeof(tmp_keydef));
  529.   bzero((char*) &tmp_keyseg,sizeof(tmp_keyseg));
  530.   for (i=0; i < uniques ; i++)
  531.   {
  532.     tmp_keydef.keysegs=1;
  533.     tmp_keydef.flag= HA_UNIQUE_CHECK;
  534.     tmp_keydef.block_length= MI_KEY_BLOCK_LENGTH;
  535.     tmp_keydef.keylength= MI_UNIQUE_HASH_LENGTH + pointer;
  536.     tmp_keydef.minlength=tmp_keydef.maxlength=tmp_keydef.keylength;
  537.     tmp_keyseg.type=  MI_UNIQUE_HASH_TYPE;
  538.     tmp_keyseg.length=  MI_UNIQUE_HASH_LENGTH;
  539.     tmp_keyseg.start= offset;
  540.     offset+= MI_UNIQUE_HASH_LENGTH;
  541.     if (mi_keydef_write(file,&tmp_keydef) ||
  542. mi_keyseg_write(file,(&tmp_keyseg)))
  543.       goto err;
  544.   }
  546.   /* Save unique definition */
  547.   for (i=0 ; i < share.state.header.uniques ; i++)
  548.   {
  549.     if (mi_uniquedef_write(file, &uniquedefs[i]))
  550.       goto err;
  551.     for (j=0 ; j < uniquedefs[i].keysegs ; j++)
  552.     {
  553.       if (mi_keyseg_write(file, &uniquedefs[i].seg[j]))
  554. goto err;
  555.     }
  556.   }
  557.   for (i=0 ; i < share.base.fields ; i++)
  558.     if (mi_recinfo_write(file, &recinfo[i]))
  559.       goto err;
  561. #ifndef DBUG_OFF
  562.   if ((uint) my_tell(file,MYF(0)) != info_length)
  563.   {
  564.     uint pos= (uint) my_tell(file,MYF(0));
  565.     DBUG_PRINT("warning",("info_length: %d  != used_length: %d",
  566.   info_length, pos));
  567.   }
  568. #endif
  570. /* Enlarge files */
  571.   if (my_chsize(file,(ulong) share.base.keystart,MYF(0)))
  572.     goto err;
  574.   if (! (flags & HA_DONT_TOUCH_DATA))
  575.   {
  576. #ifdef USE_RELOC
  577.     if (my_chsize(dfile,share.base.min_pack_length*ci->reloc_rows,MYF(0)))
  578.       goto err;
  579. #endif
  580.     errpos=2;
  581.     if (my_close(dfile,MYF(0)))
  582.       goto err;
  583.   }
  584.   errpos=0;
  585.   pthread_mutex_unlock(&THR_LOCK_myisam);
  586.   if (my_close(file,MYF(0)))
  587.     goto err;
  588.   my_free((char*) rec_per_key_part,MYF(0));
  589.   DBUG_RETURN(0);
  591. err:
  592.   pthread_mutex_unlock(&THR_LOCK_myisam);
  593.   save_errno=my_errno;
  594.   switch (errpos) {
  595.   case 3:
  596.     VOID(my_close(dfile,MYF(0)));
  597.     /* fall through */
  598.   case 2:
  599.   if (! (flags & HA_DONT_TOUCH_DATA))
  600.   {
  601.     /* QQ: T鮪u should add a call to my_raid_delete() here */
  602.     VOID(fn_format(buff,name,"",MI_NAME_DEXT,2+4));
  603.     my_delete(buff,MYF(0));
  604.   }
  605.     /* fall through */
  606.   case 1:
  607.     VOID(my_close(file,MYF(0)));
  608.     if (! (flags & HA_DONT_TOUCH_DATA))
  609.     {
  610.       VOID(fn_format(buff,name,"",MI_NAME_IEXT,2+4));
  611.       my_delete(buff,MYF(0));
  612.     }
  613.   }
  614.   my_free((char*) rec_per_key_part, MYF(0));
  615.   DBUG_RETURN(my_errno=save_errno); /* return the fatal errno */
  616. }
  619. uint mi_get_pointer_length(ulonglong file_length, uint def)
  620. {
  621.   if (file_length) /* If not default */
  622.   {
  623.     if (file_length >= (longlong) 1 << 56)
  624.       def=8;
  625.     if (file_length >= (longlong) 1 << 48)
  626.       def=7;
  627.     if (file_length >= (longlong) 1 << 40)
  628.       def=6;
  629.     else if (file_length >= (longlong) 1 << 32)
  630.       def=5;
  631.     else if (file_length >= (1L << 24))
  632.       def=4;
  633.     else if (file_length >= (1L << 16))
  634.       def=3;
  635.     else
  636.       def=2;
  637.   }
  638.   return def;
  639. }