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

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

MySQL数据库

开发平台：

Visual C++

table.cc：源码内容
  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 */
  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,int errortype);
  28. static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
  29.       uint types, char **names);
  30. static uint find_field(TABLE *form,uint start,uint length);
  33. static byte* get_field_name(Field *buff,uint *length,
  34.     my_bool not_used __attribute__((unused)))
  35. {
  36.   *length= (uint) strlen(buff->field_name);
  37.   return (byte*) buff->field_name;
  38. }
  40. /* Open a .frm file */
  42. int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
  43.     uint ha_open_flags, TABLE *outparam)
  44. {
  45.   reg1 uint i;
  46.   reg2 uchar *strpos;
  47.   int  j,error;
  48.   uint  rec_buff_length,n_length,int_length,records,key_parts,keys,
  49.     interval_count,interval_parts,read_length,db_create_options;
  50.   ulong  pos;
  51.   char  index_file[FN_REFLEN], *names,*keynames;
  52.   uchar  head[288],*disk_buff,new_field_pack_flag;
  53.   my_string record;
  54.   const char **int_array;
  55.   bool  new_frm_ver,use_hash, null_field_first;
  56.   File  file;
  57.   Field  **field_ptr,*reg_field;
  58.   KEY  *keyinfo;
  59.   KEY_PART_INFO *key_part;
  60.   uchar *null_pos;
  61.   uint null_bit;
  62.   SQL_CRYPT *crypted=0;
  63.   DBUG_ENTER("openfrm");
  64.   DBUG_PRINT("enter",("name: '%s'  form: %lx",name,outparam));
  66.   bzero((char*) outparam,sizeof(*outparam));
  67.   outparam->blob_ptr_size=sizeof(char*);
  68.   disk_buff=NULL; record= NULL; keynames=NullS;
  69.   outparam->db_stat = db_stat;
  70.   error=1;
  72.   init_sql_alloc(&outparam->mem_root,1024,0);
  73.   MEM_ROOT *old_root=my_pthread_getspecific_ptr(MEM_ROOT*,THR_MALLOC);
  74.   my_pthread_setspecific_ptr(THR_MALLOC,&outparam->mem_root);
  76.   outparam->real_name=strdup_root(&outparam->mem_root,
  77.   name+dirname_length(name));
  78.   *fn_ext(outparam->real_name)=''; // Remove extension
  79.   outparam->table_name=my_strdup(alias,MYF(MY_WME));
  80.   if (!outparam->real_name || !outparam->table_name)
  81.     goto err_end;
  83.   if ((file=my_open(fn_format(index_file,name,"",reg_ext,4),
  84.     O_RDONLY | O_SHARE,
  85.     MYF(0)))
  86.       < 0)
  87.   {
  88.     goto err_end; /* purecov: inspected */
  89.   }
  90.   error=4;
  91.   if (!(outparam->path= strdup_root(&outparam->mem_root,name)))
  92.     goto err_not_open;
  93.   *fn_ext(outparam->path)=''; // Remove extension
  95.   if (my_read(file,(byte*) head,64,MYF(MY_NABP))) goto err_not_open;
  96.   if (head[0] != (uchar) 254 || head[1] != 1 ||
  97.       (head[2] != FRM_VER && head[2] != FRM_VER+1))
  98.     goto err_not_open; /* purecov: inspected */
  99.   new_field_pack_flag=head[27];
  100.   new_frm_ver= (head[2] == FRM_VER+1);
  102.   error=3;
  103.   if (!(pos=get_form_pos(file,head,(TYPELIB*) 0)))
  104.     goto err_not_open; /* purecov: inspected */
  105.   *fn_ext(index_file)=''; // Remove .frm extension
  107.   outparam->db_type=ha_checktype((enum db_type) (uint) *(head+3));
  108.   outparam->db_create_options=db_create_options=uint2korr(head+30);
  109.   outparam->db_options_in_use=outparam->db_create_options;
  110.   null_field_first=0;
  111.   if (!head[32]) // New frm file in 3.23
  112.   {
  113.     outparam->avg_row_length=uint4korr(head+34);
  114.     outparam->row_type=(row_type) head[40];
  115.     outparam->raid_type=   head[41];
  116.     outparam->raid_chunks= head[42];
  117.     outparam->raid_chunksize= uint4korr(head+43);
  118.     null_field_first=1;
  119.   }
  120.   outparam->db_record_offset=1;
  121.   if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
  122.     outparam->blob_ptr_size=portable_sizeof_char_ptr;
  123.   outparam->db_low_byte_first=test(outparam->db_type == DB_TYPE_MYISAM ||
  124.    outparam->db_type == DB_TYPE_BERKELEY_DB ||
  125.    outparam->db_type == DB_TYPE_HEAP);
  127.   error=4;
  128.   outparam->max_rows=uint4korr(head+18);
  129.   outparam->min_rows=uint4korr(head+22);
  131.   /* Read keyinformation */
  132.   VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
  133.   if (read_string(file,(gptr*) &disk_buff,(uint) uint2korr(head+28)))
  134.     goto err_not_open; /* purecov: inspected */
  135.   outparam->keys=keys=disk_buff[0];
  136.   outparam->keys_in_use= (((key_map) 1) << keys)- (key_map) 1;
  138.   outparam->key_parts=key_parts=disk_buff[1];
  139.   n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
  140.   if (!(keyinfo = (KEY*) alloc_root(&outparam->mem_root,
  141.     n_length+uint2korr(disk_buff+4))))
  142.     goto err_not_open; /* purecov: inspected */
  143.   bzero((char*) keyinfo,n_length);
  144.   outparam->key_info=keyinfo;
  145.   outparam->max_key_length=0;
  146.   key_part= (KEY_PART_INFO*) (keyinfo+keys);
  147.   strpos=disk_buff+6;
  149.   ulong *rec_per_key;
  150.   if (!(rec_per_key= (ulong*) alloc_root(&outparam->mem_root,
  151.  sizeof(ulong*)*key_parts)))
  152.     goto err_not_open;
  154.   for (i=0 ; i < keys ; i++, keyinfo++)
  155.   {
  156.     keyinfo->flags=  ((uint) strpos[0]) ^ HA_NOSAME;
  157.     keyinfo->key_length= (uint) uint2korr(strpos+1);
  158.     keyinfo->key_parts=  (uint) strpos[3];  strpos+=4;
  159.     keyinfo->key_part=  key_part;
  160.     keyinfo->rec_per_key= rec_per_key;
  161.     for (j=keyinfo->key_parts ; j-- ; key_part++)
  162.     {
  163.       *rec_per_key++=0;
  164.       key_part->fieldnr= (uint16) (uint2korr(strpos) & FIELD_NR_MASK);
  165.       key_part->offset= (uint) uint2korr(strpos+2)-1;
  166.       key_part->key_type= (uint) uint2korr(strpos+5);
  167.       // key_part->field= (Field*) 0; // Will be fixed later
  168.       if (new_frm_ver)
  169.       {
  170. key_part->key_part_flag= *(strpos+4);
  171. key_part->length= (uint) uint2korr(strpos+7);
  172. strpos+=9;
  173.       }
  174.       else
  175.       {
  176. key_part->length= *(strpos+4);
  177. key_part->key_part_flag=0;
  178. if (key_part->length > 128)
  179. {
  180.   key_part->length&=127; /* purecov: inspected */
  181.   key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */
  182. }
  183. strpos+=7;
  184.       }
  185.       key_part->store_length=key_part->length;
  186.     }
  187.     set_if_bigger(outparam->max_key_length,keyinfo->key_length+
  188.   keyinfo->key_parts);
  189.     if (keyinfo->flags & HA_NOSAME)
  190.       set_if_bigger(outparam->max_unique_length,keyinfo->key_length);
  191.   }
  193.   (void) strmov(keynames= (char *) key_part,(char *) strpos);
  194.   outparam->reclength = uint2korr((head+16));
  195.   if (*(head+26) == 1)
  196.     outparam->system=1; /* one-record-database */
  197. #ifdef HAVE_CRYPTED_FRM
  198.   else if (*(head+26) == 2)
  199.   {
  200.     extern SQL_CRYPT *get_crypt_for_frm(void);
  201.     my_pthread_setspecific_ptr(THR_MALLOC,old_root);
  202.     crypted=get_crypt_for_frm();
  203.     my_pthread_setspecific_ptr(THR_MALLOC,&outparam->mem_root);
  204.     outparam->crypted=1;
  205.   }
  206. #endif
  208.   /* Allocate handler */
  209.   if (!(outparam->file= get_new_handler(outparam,outparam->db_type)))
  210.     goto err_not_open;
  212.   error=4;
  213.   outparam->reginfo.lock_type= TL_UNLOCK;
  214.   outparam->current_lock=F_UNLCK;
  215.   if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN)) records=2;
  216.   else records=1;
  217.   if (prgflag & (READ_ALL+EXTRA_RECORD)) records++;
  218.   /* QQ: TODO, remove the +1 from below */
  219.   rec_buff_length=ALIGN_SIZE(outparam->reclength+1+
  220.      outparam->file->extra_rec_buf_length());
  221.   if (!(outparam->record[0]= (byte*)
  222. (record = (char *) alloc_root(&outparam->mem_root,
  223.       rec_buff_length * records))))
  224.     goto err_not_open; /* purecov: inspected */
  225.   record[outparam->reclength]=0; // For purify and ->c_ptr()
  226.   outparam->rec_buff_length=rec_buff_length;
  227.   if (my_pread(file,(byte*) record,(uint) outparam->reclength,
  228.        (ulong) (uint2korr(head+6)+uint2korr(head+14)),
  229.        MYF(MY_NABP)))
  230.     goto err_not_open; /* purecov: inspected */
  231.   for (i=0 ; i < records ; i++, record+=rec_buff_length)
  232.   {
  233.     outparam->record[i]=(byte*) record;
  234.     if (i)
  235.       memcpy(record,record-rec_buff_length,(uint) outparam->reclength);
  236.   }
  238.   if (records == 2)
  239.   { /* fix for select */
  240.     outparam->record[2]=outparam->record[1];
  241.     if (db_stat & HA_READ_ONLY)
  242.       outparam->record[1]=outparam->record[0]; /* purecov: inspected */
  243.   }
  245.   VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
  246.   if (my_read(file,(byte*) head,288,MYF(MY_NABP))) goto err_not_open;
  247.   if (crypted)
  248.   {
  249.     crypted->decode((char*) head+256,288-256);
  250.     if (sint2korr(head+284) != 0) // Should be 0
  251.       goto err_not_open; // Wrong password
  252.   }
  254.   outparam->fields= uint2korr(head+258);
  255.   pos=uint2korr(head+260); /* Length of all screens */
  256.   n_length=uint2korr(head+268);
  257.   interval_count=uint2korr(head+270);
  258.   interval_parts=uint2korr(head+272);
  259.   int_length=uint2korr(head+274);
  260.   outparam->null_fields=uint2korr(head+282);
  261.   outparam->comment=strdup_root(&outparam->mem_root,
  262. (char*) head+47);
  264.   DBUG_PRINT("form",("i_count: %d  i_parts: %d  index: %d  n_length: %d  int_length: %d", interval_count,interval_parts, outparam->keys,n_length,int_length));
  266.   if (!(field_ptr = (Field **)
  267. alloc_root(&outparam->mem_root,
  268.    (uint) ((outparam->fields+1)*sizeof(Field*)+
  269.    interval_count*sizeof(TYPELIB)+
  270.    (outparam->fields+interval_parts+
  271.     keys+3)*sizeof(my_string)+
  272.    (n_length+int_length)))))
  273.     goto err_not_open; /* purecov: inspected */
  275.   outparam->field=field_ptr;
  276.   read_length=((uint) (outparam->fields*11)+pos+
  277.        (uint) (n_length+int_length));
  278.   if (read_string(file,(gptr*) &disk_buff,read_length))
  279.     goto err_not_open; /* purecov: inspected */
  280.   if (crypted)
  281.   {
  282.     crypted->decode((char*) disk_buff,read_length);
  283.     delete crypted;
  284.     crypted=0;
  285.   }
  286.   strpos= disk_buff+pos;
  288.   outparam->intervals= (TYPELIB*) (field_ptr+outparam->fields+1);
  289.   int_array= (const char **) (outparam->intervals+interval_count);
  290.   names= (char*) (int_array+outparam->fields+interval_parts+keys+3);
  291.   if (!interval_count)
  292.     outparam->intervals=0; // For better debugging
  293.   memcpy((char*) names, strpos+(outparam->fields*11),
  294.  (uint) (n_length+int_length));
  296.   fix_type_pointers(&int_array,&outparam->fieldnames,1,&names);
  297.   fix_type_pointers(&int_array,outparam->intervals,interval_count,
  298.     &names);
  299.   if (keynames)
  300.     fix_type_pointers(&int_array,&outparam->keynames,1,&keynames);
  301.   VOID(my_close(file,MYF(MY_WME)));
  302.   file= -1;
  304.   record=(char*) outparam->record[0]-1; /* Fieldstart = 1 */
  305.   if (null_field_first)
  306.   {
  307.     outparam->null_flags=null_pos=(uchar*) record+1;
  308.     null_bit= (db_create_options & HA_OPTION_PACK_RECORD) ? 1 : 2;
  309.     outparam->null_bytes=(outparam->null_fields+null_bit+6)/8;
  310.   }
  311.   else
  312.   {
  313.     outparam->null_bytes=(outparam->null_fields+7)/8;
  314.     outparam->null_flags=null_pos=
  315.       (uchar*) (record+1+outparam->reclength-outparam->null_bytes);
  316.     null_bit=1;
  317.   }
  319.   use_hash= outparam->fields >= MAX_FIELDS_BEFORE_HASH;
  320.   if (use_hash)
  321.     use_hash= !hash_init(&outparam->name_hash,
  322.  outparam->fields,0,0,
  323.  (hash_get_key) get_field_name,0,
  324.  HASH_CASE_INSENSITIVE);
  326.   for (i=0 ; i < outparam->fields; i++, strpos+= 11, field_ptr++)
  327.   {
  328.     uint pack_flag= uint2korr(strpos+6);
  329.     uint interval_nr= (uint) strpos[10];
  331.     *field_ptr=reg_field=
  332.       make_field(record+uint2korr(strpos+4),
  333.  (uint32) strpos[3], // field_length
  334.  null_pos,null_bit,
  335.  pack_flag,
  336.  (Field::utype) MTYP_TYPENR((uint) strpos[8]),
  337.  (interval_nr ?
  338.   outparam->intervals+interval_nr-1 :
  339.   (TYPELIB*) 0),
  340.  outparam->fieldnames.type_names[i],
  341.  outparam);
  342.     if (!(reg_field->flags & NOT_NULL_FLAG))
  343.     {
  344.       if ((null_bit<<=1) == 256)
  345.       {
  346. null_pos++;
  347. null_bit=1;
  348.       }
  349.     }
  350.     if (reg_field->unireg_check == Field::NEXT_NUMBER)
  351.     {
  352.       if ((int) (outparam->next_number_index= (uint)
  353.  find_ref_key(outparam,reg_field,
  354.       &outparam->next_number_key_offset)) < 0)
  355. reg_field->unireg_check=Field::NONE; /* purecov: inspected */
  356.       else
  357.       {
  358. outparam->found_next_number_field=reg_field;
  359. reg_field->flags|=AUTO_INCREMENT_FLAG;
  360.       }
  361.     }
  362.     if (outparam->timestamp_field == reg_field)
  363.       outparam->timestamp_field_offset=i;
  364.     if (use_hash)
  365.       (void) hash_insert(&outparam->name_hash,(byte*) *field_ptr); // Will never fail
  366.   }
  367.   *field_ptr=0; // End marker
  369.   /* Fix key->name and key_part->field */
  370.   if (key_parts)
  371.   {
  372.     uint primary_key=(uint) (find_type((char*) "PRIMARY",&outparam->keynames,
  373.        3)-1);
  374.     uint ha_option=outparam->file->option_flag();
  375.     keyinfo=outparam->key_info;
  376.     key_part=keyinfo->key_part;
  378.     for (uint key=0 ; key < outparam->keys ; key++,keyinfo++)
  379.     {
  380.       uint usable_parts=0;
  381.       keyinfo->name=(char*) outparam->keynames.type_names[key];
  382.       if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
  383.       {
  384. /*
  385.   If the UNIQUE key don't have NULL columns, declare this as
  386.   a primary key.
  387. */
  388. primary_key=key;
  389. for (i=0 ; i < keyinfo->key_parts ;i++)
  390. {
  391.   if (!key_part[i].fieldnr ||
  392.       outparam->field[key_part[i].fieldnr-1]->null_ptr)
  393.   {
  394.     primary_key=MAX_KEY; // Can't be used
  395.     break;
  396.   }
  397. }
  398.       }
  400.       for (i=0 ; i < keyinfo->key_parts ; key_part++,i++)
  401.       {
  402. if (new_field_pack_flag <= 1)
  403.   key_part->fieldnr=(uint16) find_field(outparam,
  404. (uint) key_part->offset,
  405. (uint) key_part->length);
  406. #ifdef EXTRA_DEBUG
  407. if (key_part->fieldnr > outparam->fields)
  408.   goto err_not_open; // sanity check
  409. #endif
  410. if (key_part->fieldnr)
  411. { // Should always be true !
  412.   Field *field=key_part->field=outparam->field[key_part->fieldnr-1];
  413.   if (field->null_ptr)
  414.   {
  415.     key_part->null_offset=(uint) ((byte*) field->null_ptr -
  416.   outparam->record[0]);
  417.     key_part->null_bit= field->null_bit;
  418.     key_part->store_length+=HA_KEY_NULL_LENGTH;
  419.     keyinfo->flags|=HA_NULL_PART_KEY;
  420.     keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
  421.     keyinfo->key_length+= HA_KEY_NULL_LENGTH;
  422.   }
  423.   if (field->type() == FIELD_TYPE_BLOB ||
  424.       field->real_type() == FIELD_TYPE_VAR_STRING)
  425.   {
  426.     if (field->type() == FIELD_TYPE_BLOB)
  427.       key_part->key_part_flag|= HA_BLOB_PART;
  428.     keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
  429.     key_part->store_length+=HA_KEY_BLOB_LENGTH;
  430.     keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
  431.   }
  432.   if (i == 0 && key != primary_key)
  433.     field->flags |=
  434.       ((keyinfo->flags & HA_NOSAME) &&
  435.        field->key_length() ==
  436.        keyinfo->key_length ? UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
  437.   if (i == 0)
  438.     field->key_start|= ((key_map) 1 << key);
  439.   if ((ha_option & HA_HAVE_KEY_READ_ONLY) &&
  440.       field->key_length() == key_part->length &&
  441.       field->type() != FIELD_TYPE_BLOB)
  442.   {
  443.     if (field->key_type() != HA_KEYTYPE_TEXT ||
  444. (!(ha_option & HA_KEY_READ_WRONG_STR) &&
  445.  !(keyinfo->flags & HA_FULLTEXT)))
  446.       field->part_of_key|= ((key_map) 1 << key);
  447.     if (field->key_type() != HA_KEYTYPE_TEXT ||
  448. !(keyinfo->flags & HA_FULLTEXT))
  449.       field->part_of_sortkey|= ((key_map) 1 << key);
  450.   }
  451.   if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
  452.       usable_parts == i)
  453.     usable_parts++; // For FILESORT
  454.   field->flags|= PART_KEY_FLAG;
  455.   if (key == primary_key)
  456.   {
  457.     field->flags|= PRI_KEY_FLAG;
  458.     if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
  459.       field->part_of_key|= ((key_map) 1 << primary_key);
  460.   }
  461.   if (field->key_length() != key_part->length)
  462.   {
  463.     key_part->key_part_flag|= HA_PART_KEY;
  464.     if (field->type() != FIELD_TYPE_BLOB)
  465.     { // Create a new field
  466.       field=key_part->field=field->new_field(outparam);
  467.       field->field_length=key_part->length;
  468.     }
  469.   }
  470. }
  471. else
  472. { // Error: shorten key
  473.   keyinfo->key_parts=usable_parts;
  474.   keyinfo->flags=0;
  475. }
  476.       }
  477.       keyinfo->usable_key_parts=usable_parts; // Filesort
  478.     }
  479.     if (primary_key < MAX_KEY && 
  480. (outparam->keys_in_use & ((key_map) 1 << primary_key)))
  481.     {
  482.       outparam->primary_key=primary_key;
  483.       if (outparam->file->option_flag() & HA_PRIMARY_KEY_IN_READ_INDEX)
  484. outparam->ref_primary_key= (key_map) 1 << primary_key;
  485.       /*
  486. If we are using an integer as the primary key then allow the user to
  487. refer to it as '_rowid'
  488.       */
  489.       if (outparam->key_info[primary_key].key_parts == 1)
  490.       {
  491. Field *field= outparam->key_info[primary_key].key_part[0].field;
  492. if (field && field->result_type() == INT_RESULT)
  493.   outparam->rowid_field=field;
  494.       }
  495.     }
  496.     else
  497.       outparam->primary_key = MAX_KEY; // we do not have a primary key
  498.   }
  499.   else
  500.     outparam->primary_key= MAX_KEY;
  501.   x_free((gptr) disk_buff);
  502.   disk_buff=0;
  503.   if (new_field_pack_flag <= 1)
  504.   { /* Old file format with default null */
  505.     uint null_length=(outparam->null_fields+7)/8;
  506.     bfill(outparam->null_flags,null_length,255);
  507.     bfill(outparam->null_flags+outparam->rec_buff_length,null_length,255);
  508.     if (records > 2)
  509.       bfill(outparam->null_flags+outparam->rec_buff_length*2,null_length,255);
  510.   }
  512.   if (outparam->blob_fields)
  513.   {
  514.     Field **ptr;
  515.     Field_blob **save;
  517.     if (!(outparam->blob_field=save=
  518.   (Field_blob**) alloc_root(&outparam->mem_root,
  519.     (uint) (outparam->blob_fields+1)*
  520.     sizeof(Field_blob*))))
  521.       goto err_not_open;
  522.     for (ptr=outparam->field ; *ptr ; ptr++)
  523.     {
  524.       if ((*ptr)->flags & BLOB_FLAG)
  525. (*save++)= (Field_blob*) *ptr;
  526.     }
  527.     *save=0; // End marker
  528.   }
  529.   else
  530.     outparam->blob_field=
  531.       (Field_blob**) (outparam->field+outparam->fields); // Point at null ptr
  533.   /* The table struct is now initialzed;  Open the table */
  534.   error=2;
  535.   if (db_stat)
  536.   {
  537.     int err;
  538.     if ((err=(outparam->file->
  539.       ha_open(unpack_filename(index_file,index_file),
  540.       (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
  541.       (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
  542.        ((db_stat & HA_WAIT_IF_LOCKED) ||
  543. (specialflag & SPECIAL_WAIT_IF_LOCKED)) ?
  544.        HA_OPEN_WAIT_IF_LOCKED :
  545.        (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
  546.        HA_OPEN_ABORT_IF_LOCKED :
  547.        HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
  548.     {
  549.       /* Set a flag if the table is crashed and it can be auto. repaired */
  550.       outparam->crashed=((err == HA_ERR_CRASHED_ON_USAGE) &&
  551.  outparam->file->auto_repair() &&
  552.  !(ha_open_flags & HA_OPEN_FOR_REPAIR));
  553.       goto err_not_open; /* purecov: inspected */
  554.     }
  555.   }
  556.   outparam->db_low_byte_first=outparam->file->low_byte_first();
  558.   my_pthread_setspecific_ptr(THR_MALLOC,old_root);
  559.   opened_tables++;
  560. #ifndef DBUG_OFF
  561.   if (use_hash)
  562.     (void) hash_check(&outparam->name_hash);
  563. #endif
  564.   DBUG_RETURN (0);
  566.  err_not_open:
  567.   x_free((gptr) disk_buff);
  568.   if (file > 0)
  569.     VOID(my_close(file,MYF(MY_WME)));
  571.  err_end: /* Here when no file */
  572.   delete crypted;
  573.   my_pthread_setspecific_ptr(THR_MALLOC,old_root);
  574.   frm_error(error,outparam,name,ME_ERROR+ME_WAITTANG);
  575.   delete outparam->file;
  576.   outparam->file=0; // For easyer errorchecking
  577.   outparam->db_stat=0;
  578.   free_root(&outparam->mem_root,MYF(0));
  579.   my_free(outparam->table_name,MYF(MY_ALLOW_ZERO_PTR));
  580.   DBUG_RETURN (error);
  581. } /* openfrm */
  584. /* close a .frm file and it's tables */
  586. int closefrm(register TABLE *table)
  587. {
  588.   int error=0;
  589.   DBUG_ENTER("closefrm");
  590.   if (table->db_stat)
  591.     error=table->file->close();
  592.   if (table->table_name)
  593.   {
  594.     my_free(table->table_name,MYF(0));
  595.     table->table_name=0;
  596.   }
  597.   if (table->fields)
  598.   {
  599.     for (Field **ptr=table->field ; *ptr ; ptr++)
  600.       delete *ptr;
  601.     table->fields=0;
  602.   }
  603.   delete table->file;
  604.   table->file=0; /* For easyer errorchecking */
  605.   hash_free(&table->name_hash);
  606.   free_root(&table->mem_root,MYF(0));
  607.   DBUG_RETURN(error);
  608. }
  611. /* Deallocate temporary blob storage */
  613. void free_blobs(register TABLE *table)
  614. {
  615.   for (Field_blob **ptr=table->blob_field ; *ptr ; ptr++)
  616.     (*ptr)->free();
  617. }
  620. /* Find where a form starts */
  621. /* if formname is NullS then only formnames is read */
  623. ulong get_form_pos(File file, uchar *head, TYPELIB *save_names)
  624. {
  625.   uint a_length,names,length;
  626.   uchar *pos,*buf;
  627.   ulong ret_value=0;
  628.   DBUG_ENTER("get_form_pos");
  630.   names=uint2korr(head+8);
  631.   a_length=(names+2)*sizeof(my_string); /* Room for two extra */
  633.   if (!save_names)
  634.     a_length=0;
  635.   else
  636.     save_names->type_names=0; /* Clear if error */
  638.   if (names)
  639.   {
  640.     length=uint2korr(head+4);
  641.     VOID(my_seek(file,64L,MY_SEEK_SET,MYF(0)));
  642.     if (!(buf= (uchar*) my_malloc((uint) length+a_length+names*4,
  643.   MYF(MY_WME))) ||
  644. my_read(file,(byte*) buf+a_length,(uint) (length+names*4),
  645. MYF(MY_NABP)))
  646.     { /* purecov: inspected */
  647.       x_free((gptr) buf); /* purecov: inspected */
  648.       DBUG_RETURN(0L); /* purecov: inspected */
  649.     }
  650.     pos= buf+a_length+length;
  651.     ret_value=uint4korr(pos);
  652.   }
  653.   if (! save_names)
  654.     my_free((gptr) buf,MYF(0));
  655.   else if (!names)
  656.     bzero((char*) save_names,sizeof(save_names));
  657.   else
  658.   {
  659.     char *str;
  660.     str=(char *) (buf+a_length);
  661.     fix_type_pointers((const char ***) &buf,save_names,1,&str);
  662.   }
  663.   DBUG_RETURN(ret_value);
  664. }
  667. /* Read string from a file with malloc */
  669. int read_string(File file, gptr *to, uint length)
  670. {
  671.   DBUG_ENTER("read_string");
  673.   x_free((gptr) *to);
  674.   if (!(*to= (gptr) my_malloc(length+1,MYF(MY_WME))) ||
  675.       my_read(file,(byte*) *to,length,MYF(MY_NABP)))
  676.   {
  677.     x_free((gptr) *to); /* purecov: inspected */
  678.     *to= 0; /* purecov: inspected */
  679.     DBUG_RETURN(1); /* purecov: inspected */
  680.   }
  681.   *((char*) *to+length)= '';
  682.   DBUG_RETURN (0);
  683. } /* read_string */
  686. /* Add a new form to a form file */
  688. ulong make_new_entry(File file, uchar *fileinfo, TYPELIB *formnames,
  689.      const char *newname)
  690. {
  691.   uint i,bufflength,maxlength,n_length,length,names;
  692.   ulong endpos,newpos;
  693.   char buff[IO_SIZE];
  694.   uchar *pos;
  695.   DBUG_ENTER("make_new_entry");
  697.   length=(uint) strlen(newname)+1;
  698.   n_length=uint2korr(fileinfo+4);
  699.   maxlength=uint2korr(fileinfo+6);
  700.   names=uint2korr(fileinfo+8);
  701.   newpos=uint4korr(fileinfo+10);
  703.   if (64+length+n_length+(names+1)*4 > maxlength)
  704.   { /* Expand file */
  705.     newpos+=IO_SIZE;
  706.     int4store(fileinfo+10,newpos);
  707.     endpos=(ulong) my_seek(file,0L,MY_SEEK_END,MYF(0));/* Copy from file-end */
  708.     bufflength= (uint) (endpos & (IO_SIZE-1)); /* IO_SIZE is a power of 2 */
  710.     while (endpos > maxlength)
  711.     {
  712.       VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));
  713.       if (my_read(file,(byte*) buff,bufflength,MYF(MY_NABP+MY_WME)))
  714. DBUG_RETURN(0L);
  715.       VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
  716.    MYF(0)));
  717.       if ((my_write(file,(byte*) buff,bufflength,MYF(MY_NABP+MY_WME))))
  718. DBUG_RETURN(0);
  719.       endpos-=bufflength; bufflength=IO_SIZE;
  720.     }
  721.     bzero(buff,IO_SIZE); /* Null new block */
  722.     VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
  723.     if (my_write(file,(byte*) buff,bufflength,MYF(MY_NABP+MY_WME)))
  724. DBUG_RETURN(0L);
  725.     maxlength+=IO_SIZE; /* Fix old ref */
  726.     int2store(fileinfo+6,maxlength);
  727.     for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;
  728.  pos+=4)
  729.     {
  730.       endpos=uint4korr(pos)+IO_SIZE;
  731.       int4store(pos,endpos);
  732.     }
  733.   }
  735.   if (n_length == 1 )
  736.   { /* First name */
  737.     length++;
  738.     VOID(strxmov(buff,"/",newname,"/",NullS));
  739.   }
  740.   else
  741.     VOID(strxmov(buff,newname,"/",NullS)); /* purecov: inspected */
  742.   VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
  743.   if (my_write(file,(byte*) buff,(uint) length+1,MYF(MY_NABP+MY_WME)) ||
  744.       (names && my_write(file,(byte*) (*formnames->type_names+n_length-1),
  745.  names*4, MYF(MY_NABP+MY_WME))) ||
  746.       my_write(file,(byte*) fileinfo+10,(uint) 4,MYF(MY_NABP+MY_WME)))
  747.     DBUG_RETURN(0L); /* purecov: inspected */
  749.   int2store(fileinfo+8,names+1);
  750.   int2store(fileinfo+4,n_length+length);
  751.   VOID(my_chsize(file,newpos,MYF(MY_WME))); /* Append file with '' */
  752.   DBUG_RETURN(newpos);
  753. } /* make_new_entry */
  756. /* error message when opening a form file */
  758. static void frm_error(int error, TABLE *form, const char *name, myf errortype)
  759. {
  760.   int err_no;
  761.   char buff[FN_REFLEN];
  762.   const char *form_dev="",*datext;
  763.   DBUG_ENTER("frm_error");
  765.   switch (error) {
  766.   case 1:
  767.     if (my_errno == ENOENT)
  768.     {
  769.       char *db;
  770.       uint length=dirname_part(buff,name);
  771.       buff[length-1]=0;
  772.       db=buff+dirname_length(buff);
  773.       my_error(ER_NO_SUCH_TABLE,MYF(0),db,form->real_name);
  774.     }
  775.     else
  776.       my_error(ER_FILE_NOT_FOUND,errortype,
  777.        fn_format(buff,name,form_dev,reg_ext,0),my_errno);
  778.     break;
  779.   case 2:
  780.   {
  781.     datext=form->file ? *form->file->bas_ext() : "";
  782.     err_no= (my_errno == ENOENT) ? ER_FILE_NOT_FOUND : (my_errno == EAGAIN) ?
  783.       ER_FILE_USED : ER_CANT_OPEN_FILE;
  784.     my_error(err_no,errortype,
  785.      fn_format(buff,form->real_name,form_dev,datext,2),my_errno);
  786.     break;
  787.   }
  788.   default: /* Better wrong error than none */
  789.   case 4:
  790.     my_error(ER_NOT_FORM_FILE,errortype,
  791.      fn_format(buff,name,form_dev,reg_ext,0));
  792.     break;
  793.   }
  794.   DBUG_VOID_RETURN;
  795. } /* frm_error */
  798. /*
  799. ** fix a str_type to a array type
  800. ** typeparts sepearated with some char. differents types are separated
  801. ** with a ''
  802. */
  804. static void
  805. fix_type_pointers(const char ***array, TYPELIB *point_to_type, uint types,
  806.   char **names)
  807. {
  808.   char *type_name, *ptr;
  809.   char chr;
  811.   ptr= *names;
  812.   while (types--)
  813.   {
  814.     point_to_type->name=0;
  815.     point_to_type->type_names= *array;
  817.     if ((chr= *ptr)) /* Test if empty type */
  818.     {
  819.       while ((type_name=strchr(ptr+1,chr)) != NullS)
  820.       {
  821. *((*array)++) = ptr+1;
  822. *type_name= ''; /* End string */
  823. ptr=type_name;
  824.       }
  825.       ptr+=2; /* Skipp end mark and last 0 */
  826.     }
  827.     else
  828.       ptr++;
  829.     point_to_type->count= (uint) (*array - point_to_type->type_names);
  830.     point_to_type++;
  831.     *((*array)++)= NullS; /* End of type */
  832.   }
  833.   *names=ptr; /* Update end */
  834.   return;
  835. } /* fix_type_pointers */
  838. TYPELIB *typelib(List<String> &strings)
  839. {
  840.   TYPELIB *result=(TYPELIB*) sql_alloc(sizeof(TYPELIB));
  841.   if (!result)
  842.     return 0;
  843.   result->count=strings.elements;
  844.   result->name="";
  845.   if (!(result->type_names=(const char **) sql_alloc(sizeof(char *)*
  846.      (result->count+1))))
  847.     return 0;
  848.   List_iterator<String> it(strings);
  849.   String *tmp;
  850.   for (uint i=0; (tmp=it++) ; i++)
  851.     result->type_names[i]=tmp->ptr();
  852.   result->type_names[result->count]=0; // End marker
  853.   return result;
  854. }
  857. /*
  858. ** Search after a field with given start & length
  859. ** If an exact field isn't found, return longest field with starts
  860. ** at right position.
  861. ** Return 0 on error, else field number+1
  862. ** This is needed because in some .frm fields 'fieldnr' was saved wrong
  863. */
  865. static uint find_field(TABLE *form,uint start,uint length)
  866. {
  867.   Field **field;
  868.   uint i,pos;
  870.   pos=0;
  872.   for (field=form->field, i=1 ; i<= form->fields ; i++,field++)
  873.   {
  874.     if ((*field)->offset() == start)
  875.     {
  876.       if ((*field)->key_length() == length)
  877. return (i);
  878.       if (!pos || form->field[pos-1]->pack_length() <
  879.   (*field)->pack_length())
  880. pos=i;
  881.     }
  882.   }
  883.   return (pos);
  884. }
  887. /* Check that the integer is in the internvall */
  889. int set_zone(register int nr, int min_zone, int max_zone)
  890. {
  891.   if (nr<=min_zone)
  892.     return (min_zone);
  893.   if (nr>=max_zone)
  894.     return (max_zone);
  895.   return (nr);
  896. } /* set_zone */
  898. /* Adjust number to next larger disk buffer */
  900. ulong next_io_size(register ulong pos)
  901. {
  902.   reg2 ulong offset;
  903.   if ((offset= pos & (IO_SIZE-1)))
  904.     return pos-offset+IO_SIZE;
  905.   return pos;
  906. } /* next_io_size */
  909. void append_unescaped(String *res,const char *pos)
  910. {
  911.   for ( ; *pos ; pos++)
  912.   {
  913.     switch (*pos) {
  914.     case 0: /* Must be escaped for 'mysql' */
  915.       res->append('\');
  916.       res->append('0');
  917.       break;
  918.     case 'n': /* Must be escaped for logs */
  919.       res->append('\');
  920.       res->append('n');
  921.       break;
  922.     case 'r':
  923.       res->append('\'); /* This gives better readbility */
  924.       res->append('r');
  925.       break;
  926.     case '\':
  927.       res->append('\'); /* Because of the sql syntax */
  928.       res->append('\');
  929.       break;
  930.     case ''':
  931.       res->append('''); /* Because of the sql syntax */
  932.       res->append(''');
  933.       break;
  934.     default:
  935.       res->append(*pos);
  936.       break;
  937.     }
  938.   }
  939. }
  941. /* Create a .frm file */
  943. File create_frm(register my_string name, uint reclength, uchar *fileinfo,
  944. HA_CREATE_INFO *create_info, uint keys)
  945. {
  946.   register File file;
  947.   uint key_length;
  948.   ulong length;
  949.   char fill[IO_SIZE];
  951. #if SIZEOF_OFF_T > 4
  952.   /* Fix this in MySQL 4.0;  The current limit is 4G rows (QQ) */
  953.   if (create_info->max_rows > ~(ulong) 0)
  954.     create_info->max_rows= ~(ulong) 0;
  955.   if (create_info->min_rows > ~(ulong) 0)
  956.     create_info->min_rows= ~(ulong) 0;
  957. #endif
  959.   if ((file=my_create(name,CREATE_MODE,O_RDWR | O_TRUNC,MYF(MY_WME))) >= 0)
  960.   {
  961.     bzero((char*) fileinfo,64);
  962.     fileinfo[0]=(uchar) 254; fileinfo[1]= 1; fileinfo[2]= FRM_VER+1; // Header
  963.     fileinfo[3]= (uchar) ha_checktype(create_info->db_type);
  964.     fileinfo[4]=1;
  965.     int2store(fileinfo+6,IO_SIZE); /* Next block starts here */
  966.     key_length=keys*(7+NAME_LEN+MAX_REF_PARTS*9)+16;
  967.     length=(ulong) next_io_size((ulong) (IO_SIZE+key_length+reclength));
  968.     int4store(fileinfo+10,length);
  969.     int2store(fileinfo+14,key_length);
  970.     int2store(fileinfo+16,reclength);
  971.     int4store(fileinfo+18,create_info->max_rows);
  972.     int4store(fileinfo+22,create_info->min_rows);
  973.     fileinfo[27]=2; // Use long pack-fields
  974.     create_info->table_options|=HA_OPTION_LONG_BLOB_PTR; // Use portable blob pointers
  975.     int2store(fileinfo+30,create_info->table_options);
  976.     fileinfo[32]=0; // No filename anymore
  977.     int4store(fileinfo+34,create_info->avg_row_length);
  978.     fileinfo[40]= (uchar) create_info->row_type;
  979.     fileinfo[41]= (uchar) create_info->raid_type;
  980.     fileinfo[42]= (uchar) create_info->raid_chunks;
  981.     int4store(fileinfo+43,create_info->raid_chunksize);
  982.     bzero(fill,IO_SIZE);
  983.     for (; length > IO_SIZE ; length-= IO_SIZE)
  984.     {
  985.       if (my_write(file,(byte*) fill,IO_SIZE,MYF(MY_WME | MY_NABP)))
  986.       {
  987. VOID(my_close(file,MYF(0)));
  988. VOID(my_delete(name,MYF(0)));
  989. return(-1);
  990.       }
  991.     }
  992.   }
  993.   return (file);
  994. } /* create_frm */
  997. void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
  998. {
  999.   create_info->max_rows=table->max_rows;
  1000.   create_info->min_rows=table->min_rows;
  1001.   create_info->table_options=table->db_create_options;
  1002.   create_info->avg_row_length=table->avg_row_length;
  1003.   create_info->row_type=table->row_type;
  1004.   create_info->raid_type=table->raid_type;
  1005.   create_info->raid_chunks=table->raid_chunks;
  1006.   create_info->raid_chunksize=table->raid_chunksize;
  1007. }  
  1009. int
  1010. rename_file_ext(const char * from,const char * to,const char * ext)
  1011. {
  1012.   char from_b[FN_REFLEN],to_b[FN_REFLEN];
  1013.   VOID(strxmov(from_b,from,ext,NullS));
  1014.   VOID(strxmov(to_b,to,ext,NullS));
  1015.   return (my_rename(from_b,to_b,MYF(MY_WME)));
  1016. }
  1019. /*
  1020.   Alloc a value as a string and return it
  1021.   If field is empty, return NULL
  1022. */
  1024. char *get_field(MEM_ROOT *mem, TABLE *table, uint fieldnr)
  1025. {
  1026.   Field *field=table->field[fieldnr];
  1027.   char buff[MAX_FIELD_WIDTH];
  1028.   String str(buff,sizeof(buff));
  1029.   field->val_str(&str,&str);
  1030.   uint length=str.length();
  1031.   if (!length)
  1032.     return NullS;
  1033.   char *to= (char*) alloc_root(mem,length+1);
  1034.   memcpy(to,str.ptr(),(uint) length);
  1035.   to[length]=0;
  1036.   return to;
  1037. }
  1039. bool check_db_name(const char *name)
  1040. {
  1041.   const char *start=name;
  1042.   while (*name)
  1043.   {
  1044. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1045.     if (use_mb(default_charset_info))
  1046.     {
  1047.       int len=my_ismbchar(default_charset_info, name, name+MBMAXLEN);
  1048.       if (len)
  1049.       {
  1050.         name += len;
  1051.         continue;
  1052.       }
  1053.     }
  1054. #endif
  1055.     if (*name == '/' || *name == FN_LIBCHAR)
  1056.       return 1;
  1057.     name++;
  1058.   }
  1059.   return (uint) (name - start) > NAME_LEN;
  1060. }
  1063. /*
  1064.   Allow anything as a table name, as long as it doesn't contain an
  1065.   a '/', or a '.' character
  1066.   returns 1 on error
  1067. */
  1070. bool check_table_name(const char *name, uint length)
  1071. {
  1072.   const char *end= name+length;
  1074.   while (name != end)
  1075.   {
  1076. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1077.     if (use_mb(default_charset_info))
  1078.     {
  1079.       int len=my_ismbchar(default_charset_info, name, end);
  1080.       if (len)
  1081.       {
  1082.         name += len;
  1083.         continue;
  1084.       }
  1085.     }
  1086. #endif
  1087.     if (*name == '/' || *name == FN_LIBCHAR || *name == FN_EXTCHAR)
  1088.       return 1;
  1089.     name++;
  1090.   }
  1091.   return 0;
  1092. }
  1094. bool check_column_name(const char *name)
  1095. {
  1096.   while (*name)
  1097.   {
  1098. #if defined(USE_MB) && defined(USE_MB_IDENT)
  1099.     if (use_mb(default_charset_info))
  1100.     {
  1101.       int len=my_ismbchar(default_charset_info, name, name+MBMAXLEN);
  1102.       if (len)
  1103.       {
  1104.         name += len;
  1105.         continue;
  1106.       }
  1107.     }
  1108. #endif
  1109.     if (*name == NAMES_SEP_CHAR)
  1110.       return 1;
  1111.     name++;
  1112.   }
  1113.   return 0;
  1114. }
  1116. /*
  1117. ** Get type of table from .frm file
  1118. */
  1120. db_type get_table_type(const char *name)
  1121. {
  1122.   File  file;
  1123.   uchar head[4];
  1124.   int error;
  1125.   DBUG_ENTER("get_table_type");
  1126.   DBUG_PRINT("enter",("name: '%s'",name));
  1128.   if ((file=my_open(name,O_RDONLY, MYF(0))) < 0)
  1129.     DBUG_RETURN(DB_TYPE_UNKNOWN);
  1130.   error=my_read(file,(byte*) head,4,MYF(MY_NABP));
  1131.   my_close(file,MYF(0));
  1132.   if (error || head[0] != (uchar) 254 || head[1] != 1 ||
  1133.       (head[2] != FRM_VER && head[2] != FRM_VER+1))
  1134.     DBUG_RETURN(DB_TYPE_UNKNOWN);
  1135.   DBUG_RETURN(ha_checktype((enum db_type) (uint) *(head+3)));
  1136. }
  1139. /*****************************************************************************
  1140. ** Instansiate templates
  1141. *****************************************************************************/
  1143. #ifdef __GNUC__
  1144. template class List<String>;
  1145. template class List_iterator<String>;
  1146. #endif