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

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

MySQL数据库

开发平台：

Visual C++

table.cpp：源码内容
  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 */
  18. /* Some general useful functions */
  20. #include "mysql_priv.h"
  21. #include <errno.h>
  22. #include <m_ctype.h>
  25. /* Functions defined in this file */
  27. static void frm_error(int error,TABLE *form,const char *name,
  28.                       int errortype, int errarg);
  29. static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
  30.       uint types, char **names);
  31. static uint find_field(TABLE *form,uint start,uint length);
  34. static byte* get_field_name(Field **buff,uint *length,
  35.     my_bool not_used __attribute__((unused)))
  36. {
  37.   *length= (uint) strlen((*buff)->field_name);
  38.   return (byte*) (*buff)->field_name;
  39. }
  41. /*
  42.   Open a .frm file 
  44.   SYNOPSIS
  45.     openfrm()
  47.     name           path to table-file "db/name"
  48.     alias          alias for table
  49.     db_stat        open flags (for example HA_OPEN_KEYFILE|HA_OPEN_RNDFILE..)
  50.                    can be 0 (example in ha_example_table)
  51.     prgflag        READ_ALL etc..
  52.     ha_open_flags  HA_OPEN_ABORT_IF_LOCKED etc..
  53.     outparam       result table
  55.   RETURN VALUES
  56.    0 ok
  57.    1 Error (see frm_error)
  58.    2    Error (see frm_error)
  59.    3    Wrong data in .frm file
  60.    4    Error (see frm_error)
  61.    5    Error (see frm_error: charset unavailable)
  62.    6    Unknown .frm version
  63. */
  65. int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
  66.     uint ha_open_flags, TABLE *outparam)
  67. {
  68.   reg1 uint i;
  69.   reg2 uchar *strpos;
  70.   int  j,error, errarg= 0;
  71.   uint  rec_buff_length,n_length,int_length,records,key_parts,keys,
  72.          interval_count,interval_parts,read_length,db_create_options;
  73.   uint  key_info_length, com_length;
  74.   ulong  pos;
  75.   char  index_file[FN_REFLEN], *names, *keynames, *comment_pos;
  76.   uchar  head[288],*disk_buff,new_field_pack_flag;
  77.   my_string record;
  78.   const char **int_array;
  79.   bool  use_hash, null_field_first;
  80.   File  file;
  81.   Field  **field_ptr,*reg_field;
  82.   KEY  *keyinfo;
  83.   KEY_PART_INFO *key_part;
  84.   uchar *null_pos;
  85.   uint null_bit, new_frm_ver, field_pack_length;
  86.   SQL_CRYPT *crypted=0;
  87.   MEM_ROOT **root_ptr, *old_root;
  88.   DBUG_ENTER("openfrm");
  89.   DBUG_PRINT("enter",("name: '%s'  form: %lx",name,outparam));
  91.   bzero((char*) outparam,sizeof(*outparam));
  92.   outparam->blob_ptr_size=sizeof(char*);
  93.   disk_buff=NULL; record= NULL; keynames=NullS;
  94.   outparam->db_stat = db_stat;
  95.   error=1;
  97.   init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
  98.   root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
  99.   old_root= *root_ptr;
  100.   *root_ptr= &outparam->mem_root;
  102.   outparam->real_name=strdup_root(&outparam->mem_root,
  103.                                   name+dirname_length(name));
  104.   outparam->table_name=my_strdup(alias,MYF(MY_WME));
  105.   if (!outparam->real_name || !outparam->table_name)
  106.     goto err_end;
  107.   *fn_ext(outparam->real_name)=''; // Remove extension
  109.   if ((file=my_open(fn_format(index_file,name,"",reg_ext,MY_UNPACK_FILENAME),
  110.     O_RDONLY | O_SHARE,
  111.     MYF(0)))
  112.       < 0)
  113.   {
  114.     goto err_end; /* purecov: inspected */
  115.   }
  116.   error=4;
  117.   if (!(outparam->path= strdup_root(&outparam->mem_root,name)))
  118.     goto err_not_open;
  119.   *fn_ext(outparam->path)=''; // Remove extension
  121.   if (my_read(file,(byte*) head,64,MYF(MY_NABP))) goto err_not_open;
  122.   if (head[0] != (uchar) 254 || head[1] != 1)
  123.     goto err_not_open; /* purecov: inspected */
  124.   if (head[2] != FRM_VER && head[2] != FRM_VER+1 && head[2] != FRM_VER+3)
  125.   {
  126.     error= 6;
  127.     goto err_not_open; /* purecov: inspected */
  128.   }
  129.   new_field_pack_flag=head[27];
  130.   new_frm_ver= (head[2] - FRM_VER);
  131.   field_pack_length= new_frm_ver < 2 ? 11 : 17;
  133.   error=3;
  134.   if (!(pos=get_form_pos(file,head,(TYPELIB*) 0)))
  135.     goto err_not_open; /* purecov: inspected */
  136.   *fn_ext(index_file)=''; // Remove .frm extension
  138.   outparam->frm_version= head[2];
  139.   outparam->db_type=ha_checktype((enum db_type) (uint) *(head+3));
  140.   outparam->db_create_options=db_create_options=uint2korr(head+30);
  141.   outparam->db_options_in_use=outparam->db_create_options;
  142.   null_field_first=0;
  143.   if (!head[32]) // New frm file in 3.23
  144.   {
  145.     outparam->avg_row_length=uint4korr(head+34);
  146.     outparam->row_type=(row_type) head[40];
  147.     outparam->raid_type=   head[41];
  148.     outparam->raid_chunks= head[42];
  149.     outparam->raid_chunksize= uint4korr(head+43);
  150.     outparam->table_charset=get_charset((uint) head[38],MYF(0));
  151.     null_field_first=1;
  152.   }
  153.   if (!outparam->table_charset)
  154.   {
  155.     /* unknown charset in head[38] or pre-3.23 frm */
  156.     if (use_mb(default_charset_info))
  157.     {
  158.       /* Warn that we may be changing the size of character columns */
  159.       sql_print_warning("'%s' had no or invalid character set, "
  160.                         "and default character set is multi-byte, "
  161.                         "so character column sizes may have changed",
  162.                         name);
  163.     }
  164.     outparam->table_charset=default_charset_info;
  165.   }
  166.   outparam->db_record_offset=1;
  167.   if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
  168.     outparam->blob_ptr_size=portable_sizeof_char_ptr;
  169.   /* Set temporaryly a good value for db_low_byte_first */
  170.   outparam->db_low_byte_first=test(outparam->db_type != DB_TYPE_ISAM);
  171.   error=4;
  172.   outparam->max_rows=uint4korr(head+18);
  173.   outparam->min_rows=uint4korr(head+22);
  175.   /* Read keyinformation */
  176.   key_info_length= (uint) uint2korr(head+28);
  177.   VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
  178.   if (read_string(file,(gptr*) &disk_buff,key_info_length))
  179.     goto err_not_open; /* purecov: inspected */
  180.   if (disk_buff[0] & 0x80)
  181.   {
  182.     outparam->keys=      keys=      (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
  183.     outparam->key_parts= key_parts= uint2korr(disk_buff+2);
  184.   }
  185.   else
  186.   {
  187.     outparam->keys=      keys=      disk_buff[0];
  188.     outparam->key_parts= key_parts= disk_buff[1];
  189.   }
  190.   outparam->keys_for_keyread.init(0);
  191.   outparam->keys_in_use.init(keys);
  192.   outparam->read_only_keys.init(keys);
  193.   outparam->quick_keys.init();
  194.   outparam->used_keys.init();
  195.   outparam->keys_in_use_for_query.init();
  197.   n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
  198.   if (!(keyinfo = (KEY*) alloc_root(&outparam->mem_root,
  199.     n_length+uint2korr(disk_buff+4))))
  200.     goto err_not_open; /* purecov: inspected */
  201.   bzero((char*) keyinfo,n_length);
  202.   outparam->key_info=keyinfo;
  203.   key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
  204.   strpos=disk_buff+6;
  206.   ulong *rec_per_key;
  207.   if (!(rec_per_key= (ulong*) alloc_root(&outparam->mem_root,
  208.  sizeof(ulong*)*key_parts)))
  209.     goto err_not_open;
  211.   for (i=0 ; i < keys ; i++, keyinfo++)
  212.   {
  213.     if (new_frm_ver == 3)
  214.     {
  215.       keyinfo->flags=    (uint) uint2korr(strpos) ^ HA_NOSAME;
  216.       keyinfo->key_length= (uint) uint2korr(strpos+2);
  217.       keyinfo->key_parts=  (uint) strpos[4];
  218.       keyinfo->algorithm=  (enum ha_key_alg) strpos[5];
  219.       strpos+=8;
  220.     }
  221.     else
  222.     {
  223.       keyinfo->flags=  ((uint) strpos[0]) ^ HA_NOSAME;
  224.       keyinfo->key_length= (uint) uint2korr(strpos+1);
  225.       keyinfo->key_parts=  (uint) strpos[3];
  226.       keyinfo->algorithm= HA_KEY_ALG_UNDEF;
  227.       strpos+=4;
  228.     }
  230.     keyinfo->key_part=  key_part;
  231.     keyinfo->rec_per_key= rec_per_key;
  232.     for (j=keyinfo->key_parts ; j-- ; key_part++)
  233.     {
  234.       *rec_per_key++=0;
  235.       key_part->fieldnr= (uint16) (uint2korr(strpos) & FIELD_NR_MASK);
  236.       key_part->offset= (uint) uint2korr(strpos+2)-1;
  237.       key_part->key_type= (uint) uint2korr(strpos+5);
  238.       // key_part->field= (Field*) 0; // Will be fixed later
  239.       if (new_frm_ver >= 1)
  240.       {
  241. key_part->key_part_flag= *(strpos+4);
  242. key_part->length= (uint) uint2korr(strpos+7);
  243. strpos+=9;
  244.       }
  245.       else
  246.       {
  247. key_part->length= *(strpos+4);
  248. key_part->key_part_flag=0;
  249. if (key_part->length > 128)
  250. {
  251.   key_part->length&=127; /* purecov: inspected */
  252.   key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */
  253. }
  254. strpos+=7;
  255.       }
  256.       key_part->store_length=key_part->length;
  257.     }
  258.   }
  259.   keynames=(char*) key_part;
  260.   strpos+= (strmov(keynames, (char *) strpos) - keynames)+1;
  262.   outparam->reclength = uint2korr((head+16));
  263.   if (*(head+26) == 1)
  264.     outparam->system=1; /* one-record-database */
  265. #ifdef HAVE_CRYPTED_FRM
  266.   else if (*(head+26) == 2)
  267.   {
  268.     *root_ptr= old_root
  269.     crypted=get_crypt_for_frm();
  270.     *root_ptr= &outparam->mem_root;
  271.     outparam->crypted=1;
  272.   }
  273. #endif
  275.   /* Allocate handler */
  276.   if (!(outparam->file= get_new_handler(outparam,outparam->db_type)))
  277.     goto err_not_open;
  279.   error=4;
  280.   outparam->reginfo.lock_type= TL_UNLOCK;
  281.   outparam->current_lock=F_UNLCK;
  282.   if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN)) records=2;
  283.   else records=1;
  284.   if (prgflag & (READ_ALL+EXTRA_RECORD)) records++;
  285.   /* QQ: TODO, remove the +1 from below */
  286.   rec_buff_length=ALIGN_SIZE(outparam->reclength+1+
  287.      outparam->file->extra_rec_buf_length());
  288.   if (!(outparam->record[0]= (byte*)
  289. (record = (char *) alloc_root(&outparam->mem_root,
  290.       rec_buff_length * records))))
  291.     goto err_not_open; /* purecov: inspected */
  292.   record[outparam->reclength]=0; // For purify and ->c_ptr()
  293.   outparam->rec_buff_length=rec_buff_length;
  294.   if (my_pread(file,(byte*) record,(uint) outparam->reclength,
  295.        (ulong) (uint2korr(head+6)+
  296.                         ((uint2korr(head+14) == 0xffff ?
  297.                             uint4korr(head+47) : uint2korr(head+14)))),
  298.        MYF(MY_NABP)))
  299.     goto err_not_open; /* purecov: inspected */
  300.   /* HACK: table->record[2] is used instead of table->default_values here */
  301.   for (i=0 ; i < records ; i++, record+=rec_buff_length)
  302.   {
  303.     outparam->record[i]=(byte*) record;
  304.     if (i)
  305.       memcpy(record,record-rec_buff_length,(uint) outparam->reclength);
  306.   }
  308.   if (records == 2)
  309.   { /* fix for select */
  310.     outparam->default_values=outparam->record[1];
  311.     if (db_stat & HA_READ_ONLY)
  312.       outparam->record[1]=outparam->record[0]; /* purecov: inspected */
  313.   }
  314.   outparam->insert_values=0;                   /* for INSERT ... UPDATE */
  316.   VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
  317.   if (my_read(file,(byte*) head,288,MYF(MY_NABP))) goto err_not_open;
  318. #ifdef HAVE_CRYPTED_FRM
  319.   if (crypted)
  320.   {
  321.     crypted->decode((char*) head+256,288-256);
  322.     if (sint2korr(head+284) != 0) // Should be 0
  323.       goto err_not_open; // Wrong password
  324.   }
  325. #endif
  327.   outparam->fields= uint2korr(head+258);
  328.   pos=uint2korr(head+260); /* Length of all screens */
  329.   n_length=uint2korr(head+268);
  330.   interval_count=uint2korr(head+270);
  331.   interval_parts=uint2korr(head+272);
  332.   int_length=uint2korr(head+274);
  333.   outparam->null_fields=uint2korr(head+282);
  334.   com_length=uint2korr(head+284);
  335.   outparam->comment=strdup_root(&outparam->mem_root,
  336. (char*) head+47);
  338.   DBUG_PRINT("info",("i_count: %d  i_parts: %d  index: %d  n_length: %d  int_length: %d  com_length: %d", interval_count,interval_parts, outparam->keys,n_length,int_length, com_length));
  340.   if (!(field_ptr = (Field **)
  341. alloc_root(&outparam->mem_root,
  342.    (uint) ((outparam->fields+1)*sizeof(Field*)+
  343.    interval_count*sizeof(TYPELIB)+
  344.    (outparam->fields+interval_parts+
  345.     keys+3)*sizeof(my_string)+
  346.    (n_length+int_length+com_length)))))
  347.     goto err_not_open; /* purecov: inspected */
  349.   outparam->field=field_ptr;
  350.   read_length=(uint) (outparam->fields * field_pack_length +
  351.       pos+ (uint) (n_length+int_length+com_length));
  352.   if (read_string(file,(gptr*) &disk_buff,read_length))
  353.     goto err_not_open; /* purecov: inspected */
  354. #ifdef HAVE_CRYPTED_FRM
  355.   if (crypted)
  356.   {
  357.     crypted->decode((char*) disk_buff,read_length);
  358.     delete crypted;
  359.     crypted=0;
  360.   }
  361. #endif
  362.   strpos= disk_buff+pos;
  364.   outparam->intervals= (TYPELIB*) (field_ptr+outparam->fields+1);
  365.   int_array= (const char **) (outparam->intervals+interval_count);
  366.   names= (char*) (int_array+outparam->fields+interval_parts+keys+3);
  367.   if (!interval_count)
  368.     outparam->intervals=0; // For better debugging
  369.   memcpy((char*) names, strpos+(outparam->fields*field_pack_length),
  370.  (uint) (n_length+int_length));
  371.   comment_pos=names+(n_length+int_length);
  372.   memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
  374.   fix_type_pointers(&int_array,&outparam->fieldnames,1,&names);
  375.   fix_type_pointers(&int_array,outparam->intervals,interval_count,
  376.     &names);
  378.   {
  379.     /* Set ENUM and SET lengths */
  380.     TYPELIB *interval;
  381.     for (interval= outparam->intervals;
  382.          interval < outparam->intervals + interval_count;
  383.          interval++)
  384.     {
  385.       uint count= (uint) (interval->count + 1) * sizeof(uint);
  386.       if (!(interval->type_lengths= (uint *) alloc_root(&outparam->mem_root,
  387.                                                         count)))
  388.         goto err_not_open;
  389.       for (count= 0; count < interval->count; count++)
  390.         interval->type_lengths[count]= strlen(interval->type_names[count]);
  391.       interval->type_lengths[count]= 0;
  392.     }
  393.   }
  395.   if (keynames)
  396.     fix_type_pointers(&int_array,&outparam->keynames,1,&keynames);
  397.   VOID(my_close(file,MYF(MY_WME)));
  398.   file= -1;
  400.   record=(char*) outparam->record[0]-1; /* Fieldstart = 1 */
  401.   if (null_field_first)
  402.   {
  403.     outparam->null_flags=null_pos=(uchar*) record+1;
  404.     null_bit= (db_create_options & HA_OPTION_PACK_RECORD) ? 1 : 2;
  405.     outparam->null_bytes=(outparam->null_fields+null_bit+6)/8;
  406.   }
  407.   else
  408.   {
  409.     outparam->null_bytes=(outparam->null_fields+7)/8;
  410.     outparam->null_flags=null_pos=
  411.       (uchar*) (record+1+outparam->reclength-outparam->null_bytes);
  412.     null_bit=1;
  413.   }
  415.   use_hash= outparam->fields >= MAX_FIELDS_BEFORE_HASH;
  416.   if (use_hash)
  417.     use_hash= !hash_init(&outparam->name_hash,
  418.  system_charset_info,
  419.  outparam->fields,0,0,
  420.  (hash_get_key) get_field_name,0,0);
  422.   for (i=0 ; i < outparam->fields; i++, strpos+=field_pack_length, field_ptr++)
  423.   {
  424.     uint pack_flag, interval_nr, unireg_type, recpos, field_length;
  425.     enum_field_types field_type;
  426.     CHARSET_INFO *charset=NULL;
  427.     Field::geometry_type geom_type= Field::GEOM_GEOMETRY;
  428.     LEX_STRING comment;
  430.     if (new_frm_ver == 3)
  431.     {
  432.       /* new frm file in 4.1 */
  433.       field_length= uint2korr(strpos+3);
  434.       recpos=     uint3korr(strpos+5);
  435.       pack_flag=    uint2korr(strpos+8);
  436.       unireg_type=  (uint) strpos[10];
  437.       interval_nr=  (uint) strpos[12];
  439.       uint comment_length=uint2korr(strpos+15);
  440.       field_type=(enum_field_types) (uint) strpos[13];
  442.       // charset and geometry_type share the same byte in frm
  443.       if (field_type == FIELD_TYPE_GEOMETRY)
  444.       {
  445. #ifdef HAVE_SPATIAL
  446. geom_type= (Field::geometry_type) strpos[14];
  447. charset= &my_charset_bin;
  448. #else
  449. error= 4;  // unsupported field type
  450. goto err_not_open;
  451. #endif
  452.       }
  453.       else
  454.       {
  455.         if (!strpos[14])
  456.           charset= &my_charset_bin;
  457.         else if (!(charset=get_charset((uint) strpos[14], MYF(0))))
  458.         {
  459.           error= 5; // Unknown or unavailable charset
  460.           errarg= (int) strpos[14];
  461.           goto err_not_open;
  462.         }
  463.       }
  464.       if (!comment_length)
  465.       {
  466. comment.str= (char*) "";
  467. comment.length=0;
  468.       }
  469.       else
  470.       {
  471. comment.str=    (char*) comment_pos;
  472. comment.length= comment_length;
  473. comment_pos+=   comment_length;
  474.       }
  475.     }
  476.     else
  477.     {
  478.       field_length= (uint) strpos[3];
  479.       recpos=     uint2korr(strpos+4),
  480.       pack_flag=    uint2korr(strpos+6);
  481.       unireg_type=  (uint) strpos[8];
  482.       interval_nr=  (uint) strpos[10];
  484.       /* old frm file */
  485.       field_type= (enum_field_types) f_packtype(pack_flag);
  486.       if (f_is_binary(pack_flag))
  487.       {
  488.         /*
  489.           Try to choose the best 4.1 type:
  490.           - for 4.0 "CHAR(N) BINARY" or "VARCHAR(N) BINARY" 
  491.             try to find a binary collation for character set.
  492.           - for other types (e.g. BLOB) just use my_charset_bin. 
  493.         */
  494.         if (!f_is_blob(pack_flag))
  495.         {
  496.           // 3.23 or 4.0 string
  497.           if (!(charset= get_charset_by_csname(outparam->table_charset->csname,
  498.                                                MY_CS_BINSORT, MYF(0))))
  499.             charset= &my_charset_bin;
  500.         }
  501.         else
  502.           charset= &my_charset_bin;
  503.       }
  504.       else
  505.         charset= outparam->table_charset;
  506.       bzero((char*) &comment, sizeof(comment));
  507.     }
  509.     if (interval_nr && charset->mbminlen > 1)
  510.     {
  511.       /* Unescape UCS2 intervals from HEX notation */
  512.       TYPELIB *interval= outparam->intervals + interval_nr - 1;
  513.       unhex_type2(interval);
  514.     }
  515.     
  516.     *field_ptr=reg_field=
  517.       make_field(record+recpos,
  518.  (uint32) field_length,
  519.  null_pos,null_bit,
  520.  pack_flag,
  521.  field_type,
  522.  charset,
  523.  geom_type,
  524.  (Field::utype) MTYP_TYPENR(unireg_type),
  525.  (interval_nr ?
  526.   outparam->intervals+interval_nr-1 :
  527.   (TYPELIB*) 0),
  528.  outparam->fieldnames.type_names[i],
  529.  outparam);
  530.     if (!reg_field) // Not supported field type
  531.     {
  532.       error= 4;
  533.       goto err_not_open; /* purecov: inspected */
  534.     }
  535.     reg_field->comment=comment;
  536.     if (!(reg_field->flags & NOT_NULL_FLAG))
  537.     {
  538.       if ((null_bit<<=1) == 256)
  539.       {
  540. null_pos++;
  541. null_bit=1;
  542.       }
  543.     }
  544.     if (reg_field->unireg_check == Field::NEXT_NUMBER)
  545.       outparam->found_next_number_field= reg_field;
  546.     if (outparam->timestamp_field == reg_field)
  547.       outparam->timestamp_field_offset=i;
  548.     if (use_hash)
  549.       (void) my_hash_insert(&outparam->name_hash,(byte*) field_ptr); // Will never fail
  550.   }
  551.   *field_ptr=0; // End marker
  553.   /* Fix key->name and key_part->field */
  554.   if (key_parts)
  555.   {
  556.     uint primary_key=(uint) (find_type((char*) primary_key_name,
  557.        &outparam->keynames, 3) - 1);
  558.     uint ha_option=outparam->file->table_flags();
  559.     keyinfo=outparam->key_info;
  560.     key_part=keyinfo->key_part;
  562.     for (uint key=0 ; key < outparam->keys ; key++,keyinfo++)
  563.     {
  564.       uint usable_parts=0;
  565.       keyinfo->name=(char*) outparam->keynames.type_names[key];
  566.       /* Fix fulltext keys for old .frm files */
  567.       if (outparam->key_info[key].flags & HA_FULLTEXT)
  568. outparam->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT;
  570.       if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
  571.       {
  572. /*
  573.   If the UNIQUE key doesn't have NULL columns and is not a part key
  574.   declare this as a primary key.
  575. */
  576. primary_key=key;
  577. for (i=0 ; i < keyinfo->key_parts ;i++)
  578. {
  579.   uint fieldnr= key_part[i].fieldnr;
  580.   if (!fieldnr ||
  581.       outparam->field[fieldnr-1]->null_ptr ||
  582.       outparam->field[fieldnr-1]->key_length() !=
  583.       key_part[i].length)
  584.   {
  585.     primary_key=MAX_KEY; // Can't be used
  586.     break;
  587.   }
  588. }
  589.       }
  591.       for (i=0 ; i < keyinfo->key_parts ; key_part++,i++)
  592.       {
  593. if (new_field_pack_flag <= 1)
  594.   key_part->fieldnr=(uint16) find_field(outparam,
  595. (uint) key_part->offset,
  596. (uint) key_part->length);
  597. #ifdef EXTRA_DEBUG
  598. if (key_part->fieldnr > outparam->fields)
  599.   goto err_not_open; // sanity check
  600. #endif
  601. if (key_part->fieldnr)
  602. { // Should always be true !
  603.   Field *field=key_part->field=outparam->field[key_part->fieldnr-1];
  604.   if (field->null_ptr)
  605.   {
  606.     key_part->null_offset=(uint) ((byte*) field->null_ptr -
  607.   outparam->record[0]);
  608.     key_part->null_bit= field->null_bit;
  609.     key_part->store_length+=HA_KEY_NULL_LENGTH;
  610.     keyinfo->flags|=HA_NULL_PART_KEY;
  611.     keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
  612.     keyinfo->key_length+= HA_KEY_NULL_LENGTH;
  613.   }
  614.   if (field->type() == FIELD_TYPE_BLOB ||
  615.       field->real_type() == FIELD_TYPE_VAR_STRING)
  616.   {
  617.     if (field->type() == FIELD_TYPE_BLOB)
  618.       key_part->key_part_flag|= HA_BLOB_PART;
  619.     keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
  620.     key_part->store_length+=HA_KEY_BLOB_LENGTH;
  621.     keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
  622.     /*
  623.       Mark that there may be many matching values for one key
  624.       combination ('a', 'a ', 'a  '...)
  625.     */
  626.     if (!(field->flags & BINARY_FLAG))
  627.       keyinfo->flags|= HA_END_SPACE_KEY;
  628.   }
  629.   if (i == 0 && key != primary_key)
  630.     field->flags |=
  631.       ((keyinfo->flags & HA_NOSAME) &&
  632.        field->key_length() ==
  633.        keyinfo->key_length ? UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
  634.   if (i == 0)
  635.     field->key_start.set_bit(key);
  636.   if (field->key_length() == key_part->length &&
  637.       !(field->flags & BLOB_FLAG))
  638.   {
  639.             if (outparam->file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
  640.             {
  641.               outparam->read_only_keys.clear_bit(key);
  642.               outparam->keys_for_keyread.set_bit(key);
  643.       field->part_of_key.set_bit(key);
  644.             }
  645.     if (outparam->file->index_flags(key, i, 1) & HA_READ_ORDER)
  646.       field->part_of_sortkey.set_bit(key);
  647.   }
  648.   if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
  649.       usable_parts == i)
  650.     usable_parts++; // For FILESORT
  651.   field->flags|= PART_KEY_FLAG;
  652.   if (key == primary_key)
  653.   {
  654.     field->flags|= PRI_KEY_FLAG;
  655.     /*
  656.       If this field is part of the primary key and all keys contains
  657.       the primary key, then we can use any key to find this column
  658.     */
  659.     if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
  660.       field->part_of_key= outparam->keys_in_use;
  661.   }
  662.   if (field->key_length() != key_part->length)
  663.   {
  664.     key_part->key_part_flag|= HA_PART_KEY_SEG;
  665.     if (!(field->flags & BLOB_FLAG))
  666.     { // Create a new field
  667.       field=key_part->field=field->new_field(&outparam->mem_root,
  668.      outparam);
  669.       field->field_length=key_part->length;
  670.     }
  671.   }
  672.   /*
  673.     If the field can be NULL, don't optimize away the test
  674.     key_part_column = expression from the WHERE clause
  675.     as we need to test for NULL = NULL.
  676.   */
  677.   if (field->real_maybe_null())
  678.     key_part->key_part_flag|= HA_PART_KEY_SEG;
  679. }
  680. else
  681. { // Error: shorten key
  682.   keyinfo->key_parts=usable_parts;
  683.   keyinfo->flags=0;
  684. }
  685.       }
  686.       keyinfo->usable_key_parts=usable_parts; // Filesort
  688.       set_if_bigger(outparam->max_key_length,keyinfo->key_length+
  689.     keyinfo->key_parts);
  690.       outparam->total_key_length+= keyinfo->key_length;
  691.       /*
  692.         MERGE tables do not have unique indexes. But every key could be
  693.         an unique index on the underlying MyISAM table. (Bug #10400)
  694.       */
  695.       if ((keyinfo->flags & HA_NOSAME) ||
  696.           (ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
  697.         set_if_bigger(outparam->max_unique_length,keyinfo->key_length);
  698.     }
  699.     if (primary_key < MAX_KEY &&
  700. (outparam->keys_in_use.is_set(primary_key)))
  701.     {
  702.       outparam->primary_key=primary_key;
  703.       /*
  704. If we are using an integer as the primary key then allow the user to
  705. refer to it as '_rowid'
  706.       */
  707.       if (outparam->key_info[primary_key].key_parts == 1)
  708.       {
  709. Field *field= outparam->key_info[primary_key].key_part[0].field;
  710. if (field && field->result_type() == INT_RESULT)
  711.   outparam->rowid_field=field;
  712.       }
  713.     }
  714.     else
  715.       outparam->primary_key = MAX_KEY; // we do not have a primary key
  716.   }
  717.   else
  718.     outparam->primary_key= MAX_KEY;
  719.   x_free((gptr) disk_buff);
  720.   disk_buff=0;
  721.   if (new_field_pack_flag <= 1)
  722.   { /* Old file format with default null */
  723.     uint null_length=(outparam->null_fields+7)/8;
  724.     bfill(outparam->null_flags,null_length,255);
  725.     bfill(outparam->null_flags+outparam->rec_buff_length,null_length,255);
  726.     if (records > 2)
  727.       bfill(outparam->null_flags+outparam->rec_buff_length*2,null_length,255);
  728.   }
  731.   if ((reg_field=outparam->found_next_number_field))
  732.   {
  733.     if ((int) (outparam->next_number_index= (uint)
  734.        find_ref_key(outparam,reg_field,
  735.     &outparam->next_number_key_offset)) < 0)
  736.     {
  737.       reg_field->unireg_check=Field::NONE; /* purecov: inspected */
  738.       outparam->found_next_number_field=0;
  739.     }
  740.     else
  741.       reg_field->flags|=AUTO_INCREMENT_FLAG;
  742.   }
  744.   if (outparam->blob_fields)
  745.   {
  746.     Field **ptr;
  747.     Field_blob **save;
  749.     if (!(outparam->blob_field=save=
  750.   (Field_blob**) alloc_root(&outparam->mem_root,
  751.     (uint) (outparam->blob_fields+1)*
  752.     sizeof(Field_blob*))))
  753.       goto err_not_open;
  754.     for (ptr=outparam->field ; *ptr ; ptr++)
  755.     {
  756.       if ((*ptr)->flags & BLOB_FLAG)
  757. (*save++)= (Field_blob*) *ptr;
  758.     }
  759.     *save=0; // End marker
  760.   }
  761.   else
  762.     outparam->blob_field=
  763.       (Field_blob**) (outparam->field+outparam->fields); // Point at null ptr
  765.   /* The table struct is now initialzed;  Open the table */
  766.   error=2;
  767.   if (db_stat)
  768.   {
  769.     int err;
  770.     unpack_filename(index_file,index_file);
  771.     if ((err=(outparam->file->
  772.       ha_open(index_file,
  773.       (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
  774.       (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
  775.        ((db_stat & HA_WAIT_IF_LOCKED) ||
  776. (specialflag & SPECIAL_WAIT_IF_LOCKED)) ?
  777.        HA_OPEN_WAIT_IF_LOCKED :
  778.        (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
  779.        HA_OPEN_ABORT_IF_LOCKED :
  780.        HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
  781.     {
  782.       /* Set a flag if the table is crashed and it can be auto. repaired */
  783.       outparam->crashed=((err == HA_ERR_CRASHED_ON_USAGE) &&
  784.  outparam->file->auto_repair() &&
  785.  !(ha_open_flags & HA_OPEN_FOR_REPAIR));
  787.       if (err==HA_ERR_NO_SUCH_TABLE)
  788.       {
  789. /* The table did not exists in storage engine, use same error message
  790.    as if the .frm file didn't exist */
  791. error= 1;
  792. my_errno= ENOENT;
  793.       }
  794.       goto err_not_open; /* purecov: inspected */
  795.     }
  796.   }
  797.   outparam->db_low_byte_first=outparam->file->low_byte_first();
  799.   *root_ptr= old_root;
  800.   opened_tables++;
  801. #ifndef DBUG_OFF
  802.   if (use_hash)
  803.     (void) hash_check(&outparam->name_hash);
  804. #endif
  805.   DBUG_RETURN (0);
  807.  err_not_open:
  808.   x_free((gptr) disk_buff);
  809.   if (file > 0)
  810.     VOID(my_close(file,MYF(MY_WME)));
  812.  err_end: /* Here when no file */
  813.   delete crypted;
  814.   *root_ptr= old_root;
  815.   frm_error(error, outparam, name, ME_ERROR + ME_WAITTANG, errarg);
  816.   delete outparam->file;
  817.   outparam->file=0; // For easyer errorchecking
  818.   outparam->db_stat=0;
  819.   hash_free(&outparam->name_hash);
  820.   free_root(&outparam->mem_root,MYF(0));
  821.   my_free(outparam->table_name,MYF(MY_ALLOW_ZERO_PTR));
  822.   DBUG_RETURN (error);
  823. } /* openfrm */
  826. /* close a .frm file and it's tables */
  828. int closefrm(register TABLE *table)
  829. {
  830.   int error=0;
  831.   DBUG_ENTER("closefrm");
  832.   if (table->db_stat)
  833.     error=table->file->close();
  834.   if (table->table_name)
  835.   {
  836.     my_free(table->table_name,MYF(0));
  837.     table->table_name=0;
  838.   }
  839.   if (table->fields)
  840.   {
  841.     for (Field **ptr=table->field ; *ptr ; ptr++)
  842.       delete *ptr;
  843.     table->fields=0;
  844.   }
  845.   delete table->file;
  846.   table->file=0; /* For easyer errorchecking */
  847.   hash_free(&table->name_hash);
  848.   free_root(&table->mem_root,MYF(0));
  849.   DBUG_RETURN(error);
  850. }
  853. /* Deallocate temporary blob storage */
  855. void free_blobs(register TABLE *table)
  856. {
  857.   for (Field_blob **ptr=table->blob_field ; *ptr ; ptr++)
  858.     (*ptr)->free();
  859. }
  862. /* Find where a form starts */
  863. /* if formname is NullS then only formnames is read */
  865. ulong get_form_pos(File file, uchar *head, TYPELIB *save_names)
  866. {
  867.   uint a_length,names,length;
  868.   uchar *pos,*buf;
  869.   ulong ret_value=0;
  870.   DBUG_ENTER("get_form_pos");
  872.   names=uint2korr(head+8);
  873.   a_length=(names+2)*sizeof(my_string); /* Room for two extra */
  875.   if (!save_names)
  876.     a_length=0;
  877.   else
  878.     save_names->type_names=0; /* Clear if error */
  880.   if (names)
  881.   {
  882.     length=uint2korr(head+4);
  883.     VOID(my_seek(file,64L,MY_SEEK_SET,MYF(0)));
  884.     if (!(buf= (uchar*) my_malloc((uint) length+a_length+names*4,
  885.   MYF(MY_WME))) ||
  886. my_read(file,(byte*) buf+a_length,(uint) (length+names*4),
  887. MYF(MY_NABP)))
  888.     { /* purecov: inspected */
  889.       x_free((gptr) buf); /* purecov: inspected */
  890.       DBUG_RETURN(0L); /* purecov: inspected */
  891.     }
  892.     pos= buf+a_length+length;
  893.     ret_value=uint4korr(pos);
  894.   }
  895.   if (! save_names)
  896.     my_free((gptr) buf,MYF(0));
  897.   else if (!names)
  898.     bzero((char*) save_names,sizeof(save_names));
  899.   else
  900.   {
  901.     char *str;
  902.     str=(char *) (buf+a_length);
  903.     fix_type_pointers((const char ***) &buf,save_names,1,&str);
  904.   }
  905.   DBUG_RETURN(ret_value);
  906. }
  909. /* Read string from a file with malloc */
  911. int read_string(File file, gptr *to, uint length)
  912. {
  913.   DBUG_ENTER("read_string");
  915.   x_free((gptr) *to);
  916.   if (!(*to= (gptr) my_malloc(length+1,MYF(MY_WME))) ||
  917.       my_read(file,(byte*) *to,length,MYF(MY_NABP)))
  918.   {
  919.     x_free((gptr) *to); /* purecov: inspected */
  920.     *to= 0; /* purecov: inspected */
  921.     DBUG_RETURN(1); /* purecov: inspected */
  922.   }
  923.   *((char*) *to+length)= '';
  924.   DBUG_RETURN (0);
  925. } /* read_string */
  928. /* Add a new form to a form file */
  930. ulong make_new_entry(File file, uchar *fileinfo, TYPELIB *formnames,
  931.      const char *newname)
  932. {
  933.   uint i,bufflength,maxlength,n_length,length,names;
  934.   ulong endpos,newpos;
  935.   char buff[IO_SIZE];
  936.   uchar *pos;
  937.   DBUG_ENTER("make_new_entry");
  939.   length=(uint) strlen(newname)+1;
  940.   n_length=uint2korr(fileinfo+4);
  941.   maxlength=uint2korr(fileinfo+6);
  942.   names=uint2korr(fileinfo+8);
  943.   newpos=uint4korr(fileinfo+10);
  945.   if (64+length+n_length+(names+1)*4 > maxlength)
  946.   { /* Expand file */
  947.     newpos+=IO_SIZE;
  948.     int4store(fileinfo+10,newpos);
  949.     endpos=(ulong) my_seek(file,0L,MY_SEEK_END,MYF(0));/* Copy from file-end */
  950.     bufflength= (uint) (endpos & (IO_SIZE-1)); /* IO_SIZE is a power of 2 */
  952.     while (endpos > maxlength)
  953.     {
  954.       VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));
  955.       if (my_read(file,(byte*) buff,bufflength,MYF(MY_NABP+MY_WME)))
  956. DBUG_RETURN(0L);
  957.       VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
  958.    MYF(0)));
  959.       if ((my_write(file,(byte*) buff,bufflength,MYF(MY_NABP+MY_WME))))
  960. DBUG_RETURN(0);
  961.       endpos-=bufflength; bufflength=IO_SIZE;
  962.     }
  963.     bzero(buff,IO_SIZE); /* Null new block */
  964.     VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
  965.     if (my_write(file,(byte*) buff,bufflength,MYF(MY_NABP+MY_WME)))
  966. DBUG_RETURN(0L);
  967.     maxlength+=IO_SIZE; /* Fix old ref */
  968.     int2store(fileinfo+6,maxlength);
  969.     for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;
  970.  pos+=4)
  971.     {
  972.       endpos=uint4korr(pos)+IO_SIZE;
  973.       int4store(pos,endpos);
  974.     }
  975.   }
  977.   if (n_length == 1 )
  978.   { /* First name */
  979.     length++;
  980.     VOID(strxmov(buff,"/",newname,"/",NullS));
  981.   }
  982.   else
  983.     VOID(strxmov(buff,newname,"/",NullS)); /* purecov: inspected */
  984.   VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
  985.   if (my_write(file,(byte*) buff,(uint) length+1,MYF(MY_NABP+MY_WME)) ||
  986.       (names && my_write(file,(byte*) (*formnames->type_names+n_length-1),
  987.  names*4, MYF(MY_NABP+MY_WME))) ||
  988.       my_write(file,(byte*) fileinfo+10,(uint) 4,MYF(MY_NABP+MY_WME)))
  989.     DBUG_RETURN(0L); /* purecov: inspected */
  991.   int2store(fileinfo+8,names+1);
  992.   int2store(fileinfo+4,n_length+length);
  993.   VOID(my_chsize(file, newpos, 0, MYF(MY_WME)));/* Append file with '' */
  994.   DBUG_RETURN(newpos);
  995. } /* make_new_entry */
  998. /* error message when opening a form file */
  1000. static void frm_error(int error, TABLE *form, const char *name,
  1001.                       myf errortype, int errarg)
  1002. {
  1003.   int err_no;
  1004.   char buff[FN_REFLEN];
  1005.   const char *form_dev="",*datext;
  1006.   DBUG_ENTER("frm_error");
  1008.   switch (error) {
  1009.   case 1:
  1010.     if (my_errno == ENOENT)
  1011.     {
  1012.       char *db;
  1013.       uint length=dirname_part(buff,name);
  1014.       buff[length-1]=0;
  1015.       db=buff+dirname_length(buff);
  1016.       my_error(ER_NO_SUCH_TABLE,MYF(0),db,form->real_name);
  1017.     }
  1018.     else
  1019.       my_error(ER_FILE_NOT_FOUND,errortype,
  1020.        fn_format(buff,name,form_dev,reg_ext,0),my_errno);
  1021.     break;
  1022.   case 2:
  1023.   {
  1024.     datext= form->file ? *form->file->bas_ext() : "";
  1025.     datext= datext==NullS ? "" : datext;
  1026.     err_no= (my_errno == ENOENT) ? ER_FILE_NOT_FOUND : (my_errno == EAGAIN) ?
  1027.       ER_FILE_USED : ER_CANT_OPEN_FILE;
  1028.     my_error(err_no,errortype,
  1029.      fn_format(buff,form->real_name,form_dev,datext,2),my_errno);
  1030.     break;
  1031.   }
  1032.   case 5:
  1033.   {
  1034.     const char *csname= get_charset_name((uint) errarg);
  1035.     char tmp[10];
  1036.     if (!csname || csname[0] =='?')
  1037.     {
  1038.       my_snprintf(tmp, sizeof(tmp), "#%d", errarg);
  1039.       csname= tmp;
  1040.     }
  1041.     my_printf_error(ER_UNKNOWN_COLLATION,
  1042.                     "Unknown collation '%s' in table '%-.64s' definition", 
  1043.                     MYF(0), csname, form->real_name);
  1044.     break;
  1045.   }
  1046.   case 6:
  1047.     my_printf_error(ER_NOT_FORM_FILE,
  1048.                     "Table '%-.64s' was created with a different version "
  1049.                     "of MySQL and cannot be read",
  1050.                     MYF(0), name);
  1051.     break;
  1052.   default: /* Better wrong error than none */
  1053.   case 4:
  1054.     my_error(ER_NOT_FORM_FILE,errortype,
  1055.      fn_format(buff,name,form_dev,reg_ext,0));
  1056.     break;
  1057.   }
  1058.   DBUG_VOID_RETURN;
  1059. } /* frm_error */
  1062. /*
  1063. ** fix a str_type to a array type
  1064. ** typeparts sepearated with some char. differents types are separated
  1065. ** with a ''
  1066. */
  1068. static void
  1069. fix_type_pointers(const char ***array, TYPELIB *point_to_type, uint types,
  1070.   char **names)
  1071. {
  1072.   char *type_name, *ptr;
  1073.   char chr;
  1075.   ptr= *names;
  1076.   while (types--)
  1077.   {
  1078.     point_to_type->name=0;
  1079.     point_to_type->type_names= *array;
  1081.     if ((chr= *ptr)) /* Test if empty type */
  1082.     {
  1083.       while ((type_name=strchr(ptr+1,chr)) != NullS)
  1084.       {
  1085. *((*array)++) = ptr+1;
  1086. *type_name= ''; /* End string */
  1087. ptr=type_name;
  1088.       }
  1089.       ptr+=2; /* Skip end mark and last 0 */
  1090.     }
  1091.     else
  1092.       ptr++;
  1093.     point_to_type->count= (uint) (*array - point_to_type->type_names);
  1094.     point_to_type++;
  1095.     *((*array)++)= NullS; /* End of type */
  1096.   }
  1097.   *names=ptr; /* Update end */
  1098.   return;
  1099. } /* fix_type_pointers */
  1102. TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
  1103. {
  1104.   TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
  1105.   if (!result)
  1106.     return 0;
  1107.   result->count=strings.elements;
  1108.   result->name="";
  1109.   uint nbytes= (sizeof(char*) + sizeof(uint)) * (result->count + 1);
  1110.   if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
  1111.     return 0;
  1112.   result->type_lengths= (uint*) (result->type_names + result->count + 1);
  1113.   List_iterator<String> it(strings);
  1114.   String *tmp;
  1115.   for (uint i=0; (tmp=it++) ; i++)
  1116.   {
  1117.     result->type_names[i]= tmp->ptr();
  1118.     result->type_lengths[i]= tmp->length();
  1119.   }
  1120.   result->type_names[result->count]= 0; // End marker
  1121.   result->type_lengths[result->count]= 0;
  1122.   return result;
  1123. }
  1126. /*
  1127. ** Search after a field with given start & length
  1128. ** If an exact field isn't found, return longest field with starts
  1129. ** at right position.
  1130. ** Return 0 on error, else field number+1
  1131. ** This is needed because in some .frm fields 'fieldnr' was saved wrong
  1132. */
  1134. static uint find_field(TABLE *form,uint start,uint length)
  1135. {
  1136.   Field **field;
  1137.   uint i,pos;
  1139.   pos=0;
  1141.   for (field=form->field, i=1 ; i<= form->fields ; i++,field++)
  1142.   {
  1143.     if ((*field)->offset() == start)
  1144.     {
  1145.       if ((*field)->key_length() == length)
  1146. return (i);
  1147.       if (!pos || form->field[pos-1]->pack_length() <
  1148.   (*field)->pack_length())
  1149. pos=i;
  1150.     }
  1151.   }
  1152.   return (pos);
  1153. }
  1156. /* Check that the integer is in the internvall */
  1158. int set_zone(register int nr, int min_zone, int max_zone)
  1159. {
  1160.   if (nr<=min_zone)
  1161.     return (min_zone);
  1162.   if (nr>=max_zone)
  1163.     return (max_zone);
  1164.   return (nr);
  1165. } /* set_zone */
  1167. /* Adjust number to next larger disk buffer */
  1169. ulong next_io_size(register ulong pos)
  1170. {
  1171.   reg2 ulong offset;
  1172.   if ((offset= pos & (IO_SIZE-1)))
  1173.     return pos-offset+IO_SIZE;
  1174.   return pos;
  1175. } /* next_io_size */
  1178. /*
  1179.   Store an SQL quoted string.
  1181.   SYNOPSIS  
  1182.     append_unescaped()
  1183.     res result String
  1184.     pos string to be quoted
  1185.     length it's length
  1187.   NOTE
  1188.     This function works correctly with utf8 or single-byte charset strings.
  1189.     May fail with some multibyte charsets though.
  1190. */
  1192. void append_unescaped(String *res, const char *pos, uint length)
  1193. {
  1194.   const char *end= pos+length;
  1195.   res->append(''');
  1197.   for (; pos != end ; pos++)
  1198.   {
  1199. #if defined(USE_MB) && MYSQL_VERSION_ID < 40100
  1200.     uint mblen;
  1201.     if (use_mb(default_charset_info) &&
  1202.         (mblen= my_ismbchar(default_charset_info, pos, end)))
  1203.     {
  1204.       res->append(pos, mblen);
  1205.       pos+= mblen;
  1206.       continue;
  1207.     }
  1208. #endif
  1210.     switch (*pos) {
  1211.     case 0: /* Must be escaped for 'mysql' */
  1212.       res->append('\');
  1213.       res->append('0');
  1214.       break;
  1215.     case 'n': /* Must be escaped for logs */
  1216.       res->append('\');
  1217.       res->append('n');
  1218.       break;
  1219.     case 'r':
  1220.       res->append('\'); /* This gives better readbility */
  1221.       res->append('r');
  1222.       break;
  1223.     case '\':
  1224.       res->append('\'); /* Because of the sql syntax */
  1225.       res->append('\');
  1226.       break;
  1227.     case ''':
  1228.       res->append('''); /* Because of the sql syntax */
  1229.       res->append(''');
  1230.       break;
  1231.     default:
  1232.       res->append(*pos);
  1233.       break;
  1234.     }
  1235.   }
  1236.   res->append(''');
  1237. }
  1239. /* Create a .frm file */
  1241. File create_frm(register my_string name,  const char *db, const char *table,
  1242.                 uint reclength, uchar *fileinfo,
  1243. HA_CREATE_INFO *create_info, uint keys)
  1244. {
  1245.   register File file;
  1246.   uint key_length;
  1247.   ulong length;
  1248.   char fill[IO_SIZE];
  1249.   int create_flags= O_RDWR | O_TRUNC;
  1251.   if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
  1252.     create_flags|= O_EXCL | O_NOFOLLOW;
  1254. #if SIZEOF_OFF_T > 4
  1255.   /* Fix this when we have new .frm files;  Current limit is 4G rows (QQ) */
  1256.   if (create_info->max_rows > ~(ulong) 0)
  1257.     create_info->max_rows= ~(ulong) 0;
  1258.   if (create_info->min_rows > ~(ulong) 0)
  1259.     create_info->min_rows= ~(ulong) 0;
  1260. #endif
  1261.   /*
  1262.     Ensure that raid_chunks can't be larger than 255, as this would cause
  1263.     problems with drop database
  1264.   */
  1265.   set_if_smaller(create_info->raid_chunks, 255);
  1267.   if ((file= my_create(name, CREATE_MODE, create_flags, MYF(0))) >= 0)
  1268.   {
  1269.     bzero((char*) fileinfo,64);
  1270.     fileinfo[0]=(uchar) 254; fileinfo[1]= 1; fileinfo[2]= FRM_VER+3; // Header
  1271.     fileinfo[3]= (uchar) ha_checktype(create_info->db_type);
  1272.     fileinfo[4]=1;
  1273.     int2store(fileinfo+6,IO_SIZE); /* Next block starts here */
  1274.     key_length=keys*(7+NAME_LEN+MAX_REF_PARTS*9)+16;
  1275.     length=(ulong) next_io_size((ulong) (IO_SIZE+key_length+reclength));
  1276.     int4store(fileinfo+10,length);
  1277.     if (key_length > 0xffff) key_length=0xffff;
  1278.     int2store(fileinfo+14,key_length);
  1279.     int2store(fileinfo+16,reclength);
  1280.     int4store(fileinfo+18,create_info->max_rows);
  1281.     int4store(fileinfo+22,create_info->min_rows);
  1282.     fileinfo[27]=2; // Use long pack-fields
  1283.     create_info->table_options|=HA_OPTION_LONG_BLOB_PTR; // Use portable blob pointers
  1284.     int2store(fileinfo+30,create_info->table_options);
  1285.     fileinfo[32]=0; // No filename anymore
  1286.     int4store(fileinfo+34,create_info->avg_row_length);
  1287.     fileinfo[38]= (create_info->default_table_charset ?
  1288.    create_info->default_table_charset->number : 0);
  1289.     fileinfo[40]= (uchar) create_info->row_type;
  1290.     fileinfo[41]= (uchar) create_info->raid_type;
  1291.     fileinfo[42]= (uchar) create_info->raid_chunks;
  1292.     int4store(fileinfo+43,create_info->raid_chunksize);
  1293.     bzero(fill,IO_SIZE);
  1294.     for (; length > IO_SIZE ; length-= IO_SIZE)
  1295.     {
  1296.       if (my_write(file,(byte*) fill,IO_SIZE,MYF(MY_WME | MY_NABP)))
  1297.       {
  1298. VOID(my_close(file,MYF(0)));
  1299. VOID(my_delete(name,MYF(0)));
  1300. return(-1);
  1301.       }
  1302.     }
  1303.   }
  1304.   else
  1305.   {
  1306.     if (my_errno == ENOENT)
  1307.       my_error(ER_BAD_DB_ERROR,MYF(0),db);
  1308.     else
  1309.       my_error(ER_CANT_CREATE_TABLE,MYF(0),table,my_errno);
  1310.   }
  1311.   return (file);
  1312. } /* create_frm */
  1315. void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
  1316. {
  1317.   DBUG_ENTER("update_create_info_from_table");
  1318.   create_info->max_rows=table->max_rows;
  1319.   create_info->min_rows=table->min_rows;
  1320.   create_info->table_options=table->db_create_options;
  1321.   create_info->avg_row_length=table->avg_row_length;
  1322.   create_info->row_type=table->row_type;
  1323.   create_info->raid_type=table->raid_type;
  1324.   create_info->raid_chunks=table->raid_chunks;
  1325.   create_info->raid_chunksize=table->raid_chunksize;
  1326.   create_info->default_table_charset=table->table_charset;
  1327.   create_info->table_charset= 0;
  1328.   DBUG_VOID_RETURN;
  1329. }
  1331. int
  1332. rename_file_ext(const char * from,const char * to,const char * ext)
  1333. {
  1334.   char from_b[FN_REFLEN],to_b[FN_REFLEN];
  1335.   VOID(strxmov(from_b,from,ext,NullS));
  1336.   VOID(strxmov(to_b,to,ext,NullS));
  1337.   return (my_rename(from_b,to_b,MYF(MY_WME)));
  1338. }
  1341. /*
  1342.   Allocate string field in MEM_ROOT and return it as String
  1344.   SYNOPSIS
  1345.     get_field()
  1346.     mem    MEM_ROOT for allocating
  1347.     field  Field for retrieving of string
  1348.     res         result String
  1350.   RETURN VALUES
  1351.     1   string is empty
  1352.     0 all ok
  1353. */
  1355. bool get_field(MEM_ROOT *mem, Field *field, String *res)
  1356. {
  1357.   char buff[MAX_FIELD_WIDTH], *to;
  1358.   String str(buff,sizeof(buff),&my_charset_bin);
  1359.   uint length;
  1361.   field->val_str(&str);
  1362.   if (!(length= str.length()))
  1363.     return 1;
  1364.   to= strmake_root(mem, str.ptr(), length);
  1365.   res->set(to, length, ((Field_str*)field)->charset());
  1366.   return 0;
  1367. }
  1370. /*
  1371.   Allocate string field in MEM_ROOT and return it as NULL-terminated string
  1373.   SYNOPSIS
  1374.     get_field()
  1375.     mem    MEM_ROOT for allocating
  1376.     field  Field for retrieving of string
  1378.   RETURN VALUES
  1379.     NullS  string is empty
  1380.     #      pointer to NULL-terminated string value of field
  1381. */
  1383. char *get_field(MEM_ROOT *mem, Field *field)
  1384. {
  1385.   char buff[MAX_FIELD_WIDTH], *to;
  1386.   String str(buff,sizeof(buff),&my_charset_bin);
  1387.   uint length;
  1389.   field->val_str(&str);
  1390.   length= str.length();
  1391.   if (!length || !(to= (char*) alloc_root(mem,length+1)))
  1392.     return NullS;
  1393.   memcpy(to,str.ptr(),(uint) length);
  1394.   to[length]=0;
  1395.   return to;
  1396. }
  1399. /*
  1400.   Check if database name is valid
  1402.   SYNPOSIS
  1403.     check_db_name()
  1404.     name Name of database
  1406.   NOTES
  1407.     If lower_case_table_names is set then database is converted to lower case
  1409.   RETURN
  1410.     0 ok
  1411.     1   error
  1412. */
  1414. bool check_db_name(char *name)
  1415. {
  1416.   char *start=name;
  1417.   /* Used to catch empty names and names with end space */
  1418.   bool last_char_is_space= TRUE;
  1420.   if (lower_case_table_names && name != any_db)
  1421.     my_casedn_str(files_charset_info, name);
  1423.   while (*name)
  1424.   {
  1425. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1426.     last_char_is_space= my_isspace(default_charset_info, *name);
  1427.     if (use_mb(system_charset_info))
  1428.     {
  1429.       int len=my_ismbchar(system_charset_info, name, 
  1430. name+system_charset_info->mbmaxlen);
  1431.       if (len)
  1432.       {
  1433.         name += len;
  1434.         continue;
  1435.       }
  1436.     }
  1437. #else
  1438.     last_char_is_space= *name==' ';
  1439. #endif
  1440.     if (*name == '/' || *name == '\' || *name == FN_LIBCHAR ||
  1441. *name == FN_EXTCHAR)
  1442.       return 1;
  1443.     name++;
  1444.   }
  1445.   return last_char_is_space || (uint) (name - start) > NAME_LEN;
  1446. }
  1449. /*
  1450.   Allow anything as a table name, as long as it doesn't contain an
  1451.   a '/', or a '.' character
  1452.   or ' ' at the end
  1453.   returns 1 on error
  1454. */
  1457. bool check_table_name(const char *name, uint length)
  1458. {
  1459.   const char *end= name+length;
  1460.   if (!length || length > NAME_LEN)
  1461.     return 1;
  1462. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1463.   bool last_char_is_space= FALSE;
  1464. #else
  1465.   if (name[length-1]==' ')
  1466.     return 1;
  1467. #endif
  1469.   while (name != end)
  1470.   {
  1471. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1472.     last_char_is_space= my_isspace(default_charset_info, *name);
  1473.     if (use_mb(system_charset_info))
  1474.     {
  1475.       int len=my_ismbchar(system_charset_info, name, end);
  1476.       if (len)
  1477.       {
  1478.         name += len;
  1479.         continue;
  1480.       }
  1481.     }
  1482. #endif
  1483.     if (*name == '/' || *name == '\' || *name == FN_EXTCHAR)
  1484.       return 1;
  1485.     name++;
  1486.   }
  1487. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1488.   return last_char_is_space;
  1489. #else
  1490.   return 0;
  1491. #endif
  1492. }
  1495. bool check_column_name(const char *name)
  1496. {
  1497.   const char *start= name;
  1498.   bool last_char_is_space= TRUE;
  1500.   while (*name)
  1501.   {
  1502. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1503.     last_char_is_space= my_isspace(default_charset_info, *name);
  1504.     if (use_mb(system_charset_info))
  1505.     {
  1506.       int len=my_ismbchar(system_charset_info, name, 
  1507. name+system_charset_info->mbmaxlen);
  1508.       if (len)
  1509.       {
  1510.         name += len;
  1511.         continue;
  1512.       }
  1513.     }
  1514. #else
  1515.     last_char_is_space= *name==' ';
  1516. #endif
  1517.     if (*name == NAMES_SEP_CHAR)
  1518.       return 1;
  1519.     name++;
  1520.   }
  1521.   /* Error if empty or too long column name */
  1522.   return last_char_is_space || (uint) (name - start) > NAME_LEN;
  1523. }
  1525. /*
  1526. ** Get type of table from .frm file
  1527. */
  1529. db_type get_table_type(const char *name)
  1530. {
  1531.   File  file;
  1532.   uchar head[4];
  1533.   int error;
  1534.   DBUG_ENTER("get_table_type");
  1535.   DBUG_PRINT("enter",("name: '%s'",name));
  1537.   if ((file=my_open(name,O_RDONLY, MYF(0))) < 0)
  1538.     DBUG_RETURN(DB_TYPE_UNKNOWN);
  1539.   error=my_read(file,(byte*) head,4,MYF(MY_NABP));
  1540.   my_close(file,MYF(0));
  1541.   if (error || head[0] != (uchar) 254 || head[1] != 1 ||
  1542.       (head[2] != FRM_VER && head[2] != FRM_VER+1 && head[2] != FRM_VER+3))
  1543.     DBUG_RETURN(DB_TYPE_UNKNOWN);
  1544.   DBUG_RETURN(ha_checktype((enum db_type) (uint) *(head+3)));
  1545. }
  1548. /*****************************************************************************
  1549. ** Instansiate templates
  1550. *****************************************************************************/
  1552. #ifdef __GNUC__
  1553. template class List<String>;
  1554. template class List_iterator<String>;
  1555. #endif