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

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

MySQL数据库

开发平台：

Visual C++

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. /* Skapar en isam-databas */
  19. #include "isamdef.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
  28. /*
  29. ** Old options is used when recreating database, from isamchk
  30. ** Note that the minimun reclength that MySQL allows for static rows
  31. ** are 5.  (Will be fixed in the next generation)
  32. */
  34. int nisam_create(const char *name,uint keys,N_KEYDEF *keyinfo,
  35.  N_RECINFO *recinfo,
  36.  ulong records,ulong reloc, uint flags,uint old_options,
  37.  ulong data_file_length)
  38. {
  39.   register uint i,j;
  40.   File dfile,file;
  41.   int errpos,save_errno;
  42.   uint fields,length,max_key_length,packed,pointer,reclength,min_pack_length,
  43.        key_length,info_length,key_segs,options,min_key_length_skipp,max_block,
  44.        base_pos;
  45.   char buff[max(FN_REFLEN,512)];
  46.   ulong tot_length,pack_reclength;
  47.   enum en_fieldtype type;
  48.   ISAM_SHARE share;
  49.   N_KEYDEF *keydef;
  50.   N_KEYSEG *keyseg;
  51.   N_RECINFO *rec;
  52.   DBUG_ENTER("nisam_create");
  54.   LINT_INIT(dfile);
  55.   pthread_mutex_lock(&THR_LOCK_isam);
  56.   errpos=0;
  57.   options=0;
  58.   base_pos=512; /* Enough for N_STATE_INFO */
  59.   bzero((byte*) &share,sizeof(share));
  60.   if ((file = my_create(fn_format(buff,name,"",N_NAME_IEXT,4),0,
  61.        O_RDWR | O_EXCL | O_NOFOLLOW,MYF(MY_WME))) < 0)
  62.     goto err;
  63.   errpos=1;
  64.   VOID(fn_format(buff,name,"",N_NAME_DEXT,2+4));
  65.   if (!(flags & HA_DONT_TOUCH_DATA))
  66.   {
  67.     if ((dfile = my_create(buff,0,O_RDWR | O_EXCL | O_NOFOLLOW,
  68.                            MYF(MY_WME))) < 0)
  69.       goto err;
  70.     errpos=2;
  71.   }
  72.   else if (!(old_options & HA_OPTION_TEMP_COMPRESS_RECORD))
  73.     options=old_options & (HA_OPTION_COMPRESS_RECORD |
  74.    HA_OPTION_READ_ONLY_DATA | HA_OPTION_PACK_RECORD);
  75.   if (reloc > records)
  76.     reloc=records; /* Check if wrong parameter */
  78. /* Start by checking fields and field-types used */
  79.   reclength=0;
  80.   for (rec=recinfo, fields=packed=min_pack_length=0, pack_reclength=0L;
  81.        rec->base.type != (int) FIELD_LAST;
  82.        rec++,fields++)
  83.   {
  84.     reclength+=rec->base.length;
  85.     if ((type=(enum en_fieldtype) rec->base.type))
  86.     {
  87.       packed++;
  88.       if (type == FIELD_BLOB)
  89.       {
  90. share.base.blobs++;
  91. rec->base.length-= sizeof(char*); /* Don't calc pointer */
  92. if (pack_reclength != NI_POS_ERROR)
  93. {
  94.   if (rec->base.length == 4)
  95.     pack_reclength= (ulong) NI_POS_ERROR;
  96.   else
  97.     pack_reclength+=sizeof(char*)+(1 << (rec->base.length*8));
  98. }
  99.       }
  100.       else if (type == FIELD_SKIP_PRESPACE ||
  101.        type == FIELD_SKIP_ENDSPACE)
  102.       {
  103. if (pack_reclength != NI_POS_ERROR)
  104.   pack_reclength+= rec->base.length > 255 ? 2 : 1;
  105. min_pack_length++;
  106.       }
  107.       else if (type == FIELD_ZERO)
  108. packed--;
  109.       else if (type != FIELD_SKIP_ZERO)
  110.       {
  111. min_pack_length+=rec->base.length;
  112. packed--; /* Not a pack record type */
  113.       }
  114.     }
  115.     else
  116.       min_pack_length+=rec->base.length;
  117.   }
  118.   if ((packed & 7) == 1)
  119.   { /* Bad packing, try to remove a zero-field */
  120.     while (rec != recinfo)
  121.     {
  122.       rec--;
  123.       if (rec->base.type == (int) FIELD_SKIP_ZERO && rec->base.length == 1)
  124.       {
  125. rec->base.type=(int) FIELD_NORMAL;
  126. packed--;
  127. min_pack_length++;
  128. break;
  129.       }
  130.     }
  131.   }
  132.   if (packed && !(options & HA_OPTION_COMPRESS_RECORD))
  133.     options|=HA_OPTION_PACK_RECORD; /* Must use packed records */
  135.   packed=(packed+7)/8;
  136.   if (pack_reclength != NI_POS_ERROR)
  137.     pack_reclength+= reclength+packed;
  138.   min_pack_length+=packed;
  140.   if (options & HA_OPTION_COMPRESS_RECORD)
  141.   {
  142.     if (data_file_length >= (1L << 24))
  143.       pointer=4;
  144.     else if (data_file_length >= (1L << 16))
  145.       pointer=3;
  146.     else
  147.       pointer=2;
  148.   }
  149.   else if (((records == 0L && pack_reclength < 255) ||
  150.     options & HA_OPTION_PACK_RECORD) ||
  151.    records >= (ulong) 16000000L ||
  152.    pack_reclength == (ulong) NI_POS_ERROR ||
  153.    ((options & HA_OPTION_PACK_RECORD) &&
  154.     pack_reclength+4 >= (ulong) 14000000L/records))
  155.     pointer=4;
  156.   else if (records == 0L || records >= (ulong) 65000L ||
  157.    ((options & HA_OPTION_PACK_RECORD) &&
  158.     pack_reclength+4 >= (ulong) 60000L/records))
  159.     pointer=3;
  160.   else
  161.     pointer=2;
  163.   max_block=max_key_length=0; tot_length=key_segs=0;
  164.   for (i=0, keydef=keyinfo ; i < keys ; i++ , keydef++)
  165.   {
  166.     share.state.key_root[i]= share.state.key_del[i]= NI_POS_ERROR;
  167.     share.base.rec_per_key[i]= (keydef->base.flag & HA_NOSAME) ? 1L : 0L;
  168.     min_key_length_skipp=length=0;
  169.     key_length=pointer;
  171.     if (keydef->base.flag & HA_PACK_KEY &&
  172. keydef->seg[0].base.length > 127)
  173.       keydef->base.flag&= ~HA_PACK_KEY; /* Can't pack long keys */
  174.     if (keydef->base.flag & HA_PACK_KEY)
  175.     {
  176.       if ((keydef->seg[0].base.flag & HA_SPACE_PACK) &&
  177.   keydef->seg[0].base.type == (int) HA_KEYTYPE_NUM)
  178. keydef->seg[0].base.flag&= ~HA_SPACE_PACK;
  179.       if (!(keydef->seg[0].base.flag & HA_SPACE_PACK))
  180. length++;
  181.       keydef->seg[0].base.flag|=HA_PACK_KEY; /* for easyer intern test */
  182.       options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  183.       if (!(keydef->seg[0].base.flag & HA_SPACE_PACK))
  184. min_key_length_skipp+=keydef->seg[0].base.length;
  185.     }
  186.     keydef->base.keysegs=0;
  187.     for (keyseg=keydef->seg ; keyseg->base.type ; keyseg++)
  188.     {
  189.       keydef->base.keysegs++;
  190.       if (keyseg->base.length > 127)
  191. keyseg->base.flag&= ~(HA_SPACE_PACK | HA_PACK_KEY);
  192.       if (keyseg->base.flag & HA_SPACE_PACK)
  193.       {
  194. keydef->base.flag |= HA_SPACE_PACK_USED;
  195. options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
  196. length++;
  197. min_key_length_skipp+=keyseg->base.length;
  198.       }
  199.       key_length+= keyseg->base.length;
  200.     }
  201.     bzero((gptr) keyseg,sizeof(keyseg[0]));
  202.     keyseg->base.length=(uint16) pointer; /* Last key part is pointer */
  203.     key_segs+=keydef->base.keysegs;
  204.     length+=key_length;
  205.     keydef->base.block_length=nisam_block_size;
  206.     keydef->base.keylength= (uint16) key_length;
  207.     keydef->base.minlength= (uint16) (length-min_key_length_skipp);
  208.     keydef->base.maxlength= (uint16) length;
  210.     if ((uint) keydef->base.block_length > max_block)
  211.       max_block=(uint) keydef->base.block_length;
  212.     if (length > max_key_length)
  213.       max_key_length= length;
  214.     tot_length+= (records/(ulong) (((uint) keydef->base.block_length-5)/
  215.    (length*2)))*
  216.       (ulong) keydef->base.block_length;
  217.   }
  218.   info_length=(uint) (base_pos+sizeof(N_BASE_INFO)+keys*sizeof(N_SAVE_KEYDEF)+
  219.       (keys+key_segs)*sizeof(N_SAVE_KEYSEG)+
  220.       fields*sizeof(N_SAVE_RECINFO));
  222.   bmove(share.state.header.file_version,(byte*) nisam_file_magic,4);
  223.   old_options=options| (old_options & HA_OPTION_TEMP_COMPRESS_RECORD ?
  224. HA_OPTION_COMPRESS_RECORD |
  225. HA_OPTION_TEMP_COMPRESS_RECORD: 0);
  226.   int2store(share.state.header.options,old_options);
  227.   int2store(share.state.header.header_length,info_length);
  228.   int2store(share.state.header.state_info_length,sizeof(N_STATE_INFO));
  229.   int2store(share.state.header.base_info_length,sizeof(N_BASE_INFO));
  230.   int2store(share.state.header.base_pos,base_pos);
  232.   share.state.dellink = NI_POS_ERROR;
  233.   share.state.process= (ulong) getpid();
  234.   share.state.uniq= (ulong) file;
  235.   share.state.loop= 0;
  236.   share.state.version= (ulong) time((time_t*) 0);
  237.   share.base.options=options;
  238.   share.base.rec_reflength=pointer;
  239.   share.base.key_reflength=((!tot_length || tot_length > 30000000L) ? 3 :
  240.    tot_length > 120000L ? 2 : 1);
  241.   share.base.keys= share.state.keys = keys;
  242.   share.base.keystart = share.state.key_file_length=MY_ALIGN(info_length,
  243.   nisam_block_size);
  244.   share.base.max_block=max_block;
  245.   share.base.max_key_length=(uint) ALIGN_SIZE(max_key_length+4);
  246.   share.base.records=records;
  247.   share.base.reloc=reloc;
  248.   share.base.reclength=reclength;
  249.   share.base.pack_reclength=
  250.     (uint) (reclength+packed-share.base.blobs*sizeof(char*));
  251.   share.base.max_pack_length=pack_reclength;
  252.   share.base.min_pack_length=min_pack_length;
  253.   share.base.pack_bits=packed;
  254.   share.base.fields=fields;
  255.   share.base.pack_fields=packed;
  256.   share.base.sortkey= (ushort) ~0;
  257.   share.base.max_data_file_length= (pointer == 4) ? (ulong) ~0L :
  258.     (options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
  259.     (ulong) (1L << (pointer*8)) :
  260.     (pointer == 3 && reclength >= 256L) ? (ulong) NI_POS_ERROR :
  261.     ((ulong) reclength * (1L << (pointer*8)));
  262.   share.base.max_key_file_length= (share.base.key_reflength == 3 ?
  263.    NI_POS_ERROR :
  264.    (ulong)
  265.    (1L << (share.base.key_reflength*8))*512);
  266.   share.base.min_block_length=
  267.     (share.base.pack_reclength+3 < N_EXTEND_BLOCK_LENGTH &&
  268.      ! share.base.blobs) ?
  269.     max(share.base.pack_reclength,N_MIN_BLOCK_LENGTH) :
  270.     N_EXTEND_BLOCK_LENGTH;
  271.   if (! (flags & HA_DONT_TOUCH_DATA))
  272.     share.base.create_time= (long) time((time_t*) 0);
  274.   bzero(buff,base_pos);
  275.   if (my_write(file,(char*) &share.state,sizeof(N_STATE_INFO),MYF(MY_NABP)) ||
  276.       my_write(file,buff,base_pos-sizeof(N_STATE_INFO),MYF(MY_NABP)) ||
  277.       my_write(file,(char*) &share.base,sizeof(N_BASE_INFO),MYF(MY_NABP)))
  278.     goto err;
  280.   for (i=0 ; i < share.base.keys ; i++)
  281.   {
  282.     if (my_write(file,(char*) &keyinfo[i].base,sizeof(N_SAVE_KEYDEF),
  283.  MYF(MY_NABP)))
  284.       goto err;
  285.     for (j=0 ; j <= keyinfo[i].base.keysegs ; j++)
  286.     {
  287.       if (my_write(file,(char*) &keyinfo[i].seg[j].base,sizeof(N_SAVE_KEYSEG),
  288.    MYF(MY_NABP)))
  289. goto err;
  290.     }
  291.   }
  292.   for (i=0 ; i < share.base.fields ; i++)
  293.     if (my_write(file,(char*) &recinfo[i].base, (uint) sizeof(N_SAVE_RECINFO),
  294.  MYF(MY_NABP)))
  295.       goto err;
  297. /* Enlarge files */
  298.   if (my_chsize(file, (ulong) share.base.keystart, 0, MYF(0)))
  299.     goto err;
  301.   if (! (flags & HA_DONT_TOUCH_DATA))
  302.   {
  303. #ifdef USE_RELOC
  304.     if (my_chsize(dfile, share.base.min_pack_length*reloc, 0, MYF(0)))
  305.       goto err;
  306. #endif
  307.     errpos=1;
  308.     if (my_close(dfile,MYF(0)))
  309.       goto err;
  310.   }
  311.   errpos=0;
  312.   pthread_mutex_unlock(&THR_LOCK_isam);
  313.   if (my_close(file,MYF(0)))
  314.     goto err;
  315.   DBUG_RETURN(0);
  317. err:
  318.   pthread_mutex_unlock(&THR_LOCK_isam);
  319.   save_errno=my_errno;
  320.   switch (errpos) {
  321.   case 2:
  322.     VOID(my_close(dfile,MYF(0)));
  323.     /* fall through */
  324.   case 1:
  325.     VOID(my_close(file,MYF(0)));
  326.   }
  327.   my_errno=save_errno; /* R{tt felkod tillbaka */
  328.   DBUG_RETURN(-1);
  329. } /* nisam_create */