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

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

MySQL数据库

开发平台：

Visual C++

unireg.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. /*
  19.   Functions to create a unireg form-file from a FIELD and a fieldname-fieldinfo
  20.   struct.
  21.   In the following functions FIELD * is an ordinary field-structure with
  22.   the following exeptions:
  23.     sc_length,typepos,row,kol,dtype,regnr and field need not to be set.
  24.     str is a (long) to record position where 0 is the first position.
  25. */
  27. #define USES_TYPES
  28. #include "mysql_priv.h"
  29. #include <m_ctype.h>
  30. #include <assert.h>
  32. #define FCOMP 17 /* Bytes for a packed field */
  34. static uchar * pack_screens(List<create_field> &create_fields,
  35.     uint *info_length, uint *screens, bool small_file);
  36. static uint pack_keys(uchar *keybuff,uint key_count, KEY *key_info,
  37.                       ulong data_offset);
  38. static bool pack_header(uchar *forminfo,enum db_type table_type,
  39. List<create_field> &create_fields,
  40. uint info_length, uint screens, uint table_options,
  41. ulong data_offset, handler *file);
  42. static uint get_interval_id(uint *int_count,List<create_field> &create_fields,
  43.     create_field *last_field);
  44. static bool pack_fields(File file, List<create_field> &create_fields,
  45.                         ulong data_offset);
  46. static bool make_empty_rec(int file, enum db_type table_type,
  47.    uint table_options,
  48.    List<create_field> &create_fields,
  49.    uint reclength, uint null_fields,
  50.                            ulong data_offset);
  52. /*
  53.   Create a frm (table definition) file
  55.   SYNOPSIS
  56.     mysql_create_frm()
  57.     thd Thread handler
  58.     file_name Name of file (including database and .frm)
  59.     db                  Name of database
  60.     table               Name of table
  61.     create_info create info parameters
  62.     create_fields Fields to create
  63.     keys number of keys to create
  64.     key_info Keys to create
  65.     db_file Handler to use. May be zero, in which case we use
  66.      create_info->db_type
  67.   RETURN
  68.     0  ok
  69.     1  error
  70. */
  72. bool mysql_create_frm(THD *thd, my_string file_name,
  73.                       const char *db, const char *table,
  74.       HA_CREATE_INFO *create_info,
  75.       List<create_field> &create_fields,
  76.       uint keys, KEY *key_info,
  77.       handler *db_file)
  78. {
  79.   uint reclength,info_length,screens,key_info_length,maxlength,null_fields;
  80.   File file;
  81.   ulong filepos, data_offset;
  82.   uchar fileinfo[64],forminfo[288],*keybuff;
  83.   TYPELIB formnames;
  84.   uchar *screen_buff;
  85.   DBUG_ENTER("mysql_create_frm");
  87.   formnames.type_names=0;
  88.   if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,0)))
  89.     DBUG_RETURN(1);
  90.   if (db_file == NULL)
  91.     db_file= get_new_handler((TABLE*) 0, create_info->db_type);
  93.  /* If fixed row records, we need one bit to check for deleted rows */
  94.   if (!(create_info->table_options & HA_OPTION_PACK_RECORD))
  95.     create_info->null_bits++;
  96.   data_offset= (create_info->null_bits + 7) / 8;
  98.   if (pack_header(forminfo, create_info->db_type,create_fields,info_length,
  99.   screens, create_info->table_options,
  100.                   data_offset, db_file))
  101.   {
  102.     my_free((gptr) screen_buff,MYF(0));
  103.     if (thd->net.last_errno != ER_TOO_MANY_FIELDS)
  104.       DBUG_RETURN(1);
  106.     // Try again without UNIREG screens (to get more columns)
  107.     thd->net.last_error[0]=0;
  108.     if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,1)))
  109.       DBUG_RETURN(1);
  110.     if (pack_header(forminfo, create_info->db_type, create_fields,info_length,
  111.     screens, create_info->table_options, data_offset, db_file))
  112.     {
  113.       my_free((gptr) screen_buff,MYF(0));
  114.       DBUG_RETURN(1);
  115.     }
  116.   }
  117.   reclength=uint2korr(forminfo+266);
  118.   null_fields=uint2korr(forminfo+282);
  120.   if ((file=create_frm(file_name, db, table, reclength, fileinfo,
  121.        create_info, keys)) < 0)
  122.   {
  123.     my_free((gptr) screen_buff,MYF(0));
  124.     DBUG_RETURN(1);
  125.   }
  127.   uint key_buff_length=keys*(7+NAME_LEN+MAX_REF_PARTS*9)+16;
  128.   keybuff=(uchar*) my_malloc(key_buff_length, MYF(0));
  129.   key_info_length= pack_keys(keybuff, keys, key_info, data_offset);
  130.   VOID(get_form_pos(file,fileinfo,&formnames));
  131.   if (!(filepos=make_new_entry(file,fileinfo,&formnames,"")))
  132.     goto err;
  133.   maxlength=(uint) next_io_size((ulong) (uint2korr(forminfo)+1000));
  134.   int2store(forminfo+2,maxlength);
  135.   int4store(fileinfo+10,(ulong) (filepos+maxlength));
  136.   int4store(fileinfo+47,key_buff_length);
  137.   fileinfo[26]= (uchar) test((create_info->max_rows == 1) &&
  138.      (create_info->min_rows == 1) && (keys == 0));
  139.   int2store(fileinfo+28,key_info_length);
  140.   strmake((char*) forminfo+47,create_info->comment ? create_info->comment : "",
  141.   60);
  142.   forminfo[46]=(uchar) strlen((char*)forminfo+47); // Length of comment
  144.   if (my_pwrite(file,(byte*) fileinfo,64,0L,MYF_RW) ||
  145.       my_pwrite(file,(byte*) keybuff,key_info_length,
  146. (ulong) uint2korr(fileinfo+6),MYF_RW))
  147.     goto err;
  148.   VOID(my_seek(file,
  149.        (ulong) uint2korr(fileinfo+6)+ (ulong) key_buff_length,
  150.        MY_SEEK_SET,MYF(0)));
  151.   if (make_empty_rec(file,create_info->db_type,create_info->table_options,
  152.      create_fields,reclength, null_fields, data_offset))
  153.     goto err;
  155.   VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
  156.   if (my_write(file,(byte*) forminfo,288,MYF_RW) ||
  157.       my_write(file,(byte*) screen_buff,info_length,MYF_RW) ||
  158.       pack_fields(file, create_fields, data_offset))
  159.     goto err;
  161. #ifdef HAVE_CRYPTED_FRM
  162.   if (create_info->password)
  163.   {
  164.     char tmp=2,*disk_buff=0;
  165.     SQL_CRYPT *crypted=new SQL_CRYPT(create_info->password);
  166.     if (!crypted || my_pwrite(file,&tmp,1,26,MYF_RW)) // Mark crypted
  167.       goto err;
  168.     uint read_length=uint2korr(forminfo)-256;
  169.     VOID(my_seek(file,filepos+256,MY_SEEK_SET,MYF(0)));
  170.     if (read_string(file,(gptr*) &disk_buff,read_length))
  171.       goto err;
  172.     crypted->encode(disk_buff,read_length);
  173.     delete crypted;
  174.     if (my_pwrite(file,disk_buff,read_length,filepos+256,MYF_RW))
  175.     {
  176.       my_free(disk_buff,MYF(0));
  177.       goto err;
  178.     }
  179.     my_free(disk_buff,MYF(0));
  180.   }
  181. #endif
  183.   my_free((gptr) screen_buff,MYF(0));
  184.   my_free((gptr) keybuff, MYF(0));
  186.   if (opt_sync_frm && !(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
  187.       my_sync(file, MYF(MY_WME)))
  188.     goto err2;
  189.   if (my_close(file,MYF(MY_WME)))
  190.     goto err3;
  192.   {
  193.     /* Unescape all UCS2 intervals: were escaped in pack_headers */
  194.     List_iterator<create_field> it(create_fields);
  195.     create_field *field;
  196.     while ((field=it++))
  197.     {
  198.       if (field->interval && field->charset->mbminlen > 1)
  199.         unhex_type2(field->interval);
  200.     }
  201.   }
  202.   DBUG_RETURN(0);
  204. err:
  205.   my_free((gptr) screen_buff,MYF(0));
  206.   my_free((gptr) keybuff, MYF(0));
  207. err2:
  208.   VOID(my_close(file,MYF(MY_WME)));
  209. err3:
  210.   my_delete(file_name,MYF(0));
  211.   DBUG_RETURN(1);
  212. } /* mysql_create_frm */
  215. /*
  216.   Create a frm (table definition) file and the tables
  218.   SYNOPSIS
  219.     rea_create_table()
  220.     thd Thread handler
  221.     file_name Name of file (including database and .frm)
  222.     db                  Name of database
  223.     table               Name of table
  224.     create_info create info parameters
  225.     create_fields Fields to create
  226.     keys number of keys to create
  227.     key_info Keys to create
  228.     db_file Handler to use. May be zero, in which case we use
  229.      create_info->db_type
  230.   RETURN
  231.     0  ok
  232.     1  error
  233. */
  235. int rea_create_table(THD *thd, my_string file_name,
  236.                      const char *db, const char *table,
  237.      HA_CREATE_INFO *create_info,
  238.      List<create_field> &create_fields,
  239.      uint keys, KEY *key_info)
  240. {
  241.   DBUG_ENTER("rea_create_table");
  243.   if (mysql_create_frm(thd, file_name, db, table, create_info,
  244.           create_fields, keys, key_info, NULL))
  245.     DBUG_RETURN(1);
  246.   if (ha_create_table(file_name,create_info,0))
  247.   {
  248.     my_delete(file_name,MYF(0));    
  249.     DBUG_RETURN(1);
  250.   }
  251.   DBUG_RETURN(0);
  252. } /* rea_create_table */
  255. /* Pack screens to a screen for save in a form-file */
  257. static uchar * pack_screens(List<create_field> &create_fields,
  258.     uint *info_length, uint *screens,
  259.     bool small_file)
  260. {
  261.   reg1 uint i;
  262.   uint row,start_row,end_row,fields_on_screen;
  263.   uint length,cols;
  264.   uchar *info,*pos,*start_screen;
  265.   uint fields=create_fields.elements;
  266.   List_iterator<create_field> it(create_fields);
  267.   DBUG_ENTER("pack_screens");
  269.   start_row=4; end_row=22; cols=80; fields_on_screen=end_row+1-start_row;
  271.   *screens=(fields-1)/fields_on_screen+1;
  272.   length= (*screens) * (SC_INFO_LENGTH+ (cols>> 1)+4);
  274.   create_field *field;
  275.   while ((field=it++))
  276.     length+=(uint) strlen(field->field_name)+1+TE_INFO_LENGTH+cols/2;
  278.   if (!(info=(uchar*) my_malloc(length,MYF(MY_WME))))
  279.     DBUG_RETURN(0);
  281.   start_screen=0;
  282.   row=end_row;
  283.   pos=info;
  284.   it.rewind();
  285.   for (i=0 ; i < fields ; i++)
  286.   {
  287.     create_field *cfield=it++;
  288.     if (row++ == end_row)
  289.     {
  290.       if (i)
  291.       {
  292. length=(uint) (pos-start_screen);
  293. int2store(start_screen,length);
  294. start_screen[2]=(uchar) (fields_on_screen+1);
  295. start_screen[3]=(uchar) (fields_on_screen);
  296.       }
  297.       row=start_row;
  298.       start_screen=pos;
  299.       pos+=4;
  300.       pos[0]= (uchar) start_row-2; /* Header string */
  301.       pos[1]= (uchar) (cols >> 2);
  302.       pos[2]= (uchar) (cols >> 1) +1;
  303.       strfill((my_string) pos+3,(uint) (cols >> 1),' ');
  304.       pos+=(cols >> 1)+4;
  305.     }
  306.     length=(uint) strlen(cfield->field_name);
  307.     if (length > cols-3)
  308.       length=cols-3;
  310.     if (!small_file)
  311.     {
  312.       pos[0]=(uchar) row;
  313.       pos[1]=0;
  314.       pos[2]=(uchar) (length+1);
  315.       pos=(uchar*) strmake((char*) pos+3,cfield->field_name,length)+1;
  316.     }
  317.     cfield->row=(uint8) row;
  318.     cfield->col=(uint8) (length+1);
  319.     cfield->sc_length=(uint8) min(cfield->length,cols-(length+2));
  320.   }
  321.   length=(uint) (pos-start_screen);
  322.   int2store(start_screen,length);
  323.   start_screen[2]=(uchar) (row-start_row+2);
  324.   start_screen[3]=(uchar) (row-start_row+1);
  326.   *info_length=(uint) (pos-info);
  327.   DBUG_RETURN(info);
  328. } /* pack_screens */
  331. /* Pack keyinfo and keynames to keybuff for save in form-file. */
  333. static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo,
  334.                       ulong data_offset)
  335. {
  336.   uint key_parts,length;
  337.   uchar *pos, *keyname_pos;
  338.   KEY *key,*end;
  339.   KEY_PART_INFO *key_part,*key_part_end;
  340.   DBUG_ENTER("pack_keys");
  342.   pos=keybuff+6;
  343.   key_parts=0;
  344.   for (key=keyinfo,end=keyinfo+key_count ; key != end ; key++)
  345.   {
  346.     int2store(pos, (key->flags ^ HA_NOSAME));
  347.     int2store(pos+2,key->key_length);
  348.     pos[4]= (uchar) key->key_parts;
  349.     pos[5]= (uchar) key->algorithm;
  350.     pos[6]=pos[7]=0; // For the future
  351.     pos+=8;
  352.     key_parts+=key->key_parts;
  353.     DBUG_PRINT("loop",("flags: %d  key_parts: %d at %lx",
  354.        key->flags,key->key_parts,
  355.        key->key_part));
  356.     for (key_part=key->key_part,key_part_end=key_part+key->key_parts ;
  357.  key_part != key_part_end ;
  358.  key_part++)
  360.     {
  361.       uint offset;
  362.       DBUG_PRINT("loop",("field: %d  startpos: %lu  length: %ld",
  363.  key_part->fieldnr, key_part->offset + data_offset,
  364.                          key_part->length));
  365.       int2store(pos,key_part->fieldnr+1+FIELD_NAME_USED);
  366.       offset= (uint) (key_part->offset+data_offset+1);
  367.       int2store(pos+2, offset);
  368.       pos[4]=0; // Sort order
  369.       int2store(pos+5,key_part->key_type);
  370.       int2store(pos+7,key_part->length);
  371.       pos+=9;
  372.     }
  373.   }
  374. /* Save keynames */
  375.   keyname_pos=pos;
  376.   *pos++=(uchar) NAMES_SEP_CHAR;
  377.   for (key=keyinfo ; key != end ; key++)
  378.   {
  379.     uchar *tmp=(uchar*) strmov((char*) pos,key->name);
  380.     *tmp++= (uchar) NAMES_SEP_CHAR;
  381.     *tmp=0;
  382.     pos=tmp;
  383.   }
  384.   *(pos++)=0;
  386.   if (key_count > 127 || key_parts > 127)
  387.   {
  388.     keybuff[0]= (key_count & 0x7f) | 0x80;
  389.     keybuff[1]= key_count >> 7;
  390.     int2store(keybuff+2,key_parts);
  391.   }
  392.   else
  393.   {
  394.     keybuff[0]=(uchar) key_count;
  395.     keybuff[1]=(uchar) key_parts;
  396.     keybuff[2]= keybuff[3]= 0;
  397.   }
  398.   length=(uint) (pos-keyname_pos);
  399.   int2store(keybuff+4,length);
  400.   DBUG_RETURN((uint) (pos-keybuff));
  401. } /* pack_keys */
  404. /* Make formheader */
  406. static bool pack_header(uchar *forminfo, enum db_type table_type,
  407. List<create_field> &create_fields,
  408.                         uint info_length, uint screens, uint table_options,
  409.                         ulong data_offset, handler *file)
  410. {
  411.   uint length,int_count,int_length,no_empty, int_parts;
  412.   uint time_stamp_pos,null_fields;
  413.   ulong reclength, totlength, n_length, com_length;
  414.   DBUG_ENTER("pack_header");
  416.   if (create_fields.elements > MAX_FIELDS)
  417.   {
  418.     my_error(ER_TOO_MANY_FIELDS,MYF(0));
  419.     DBUG_RETURN(1);
  420.   }
  422.   totlength=reclength=0L;
  423.   no_empty=int_count=int_parts=int_length=time_stamp_pos=null_fields=
  424.     com_length=0;
  425.   n_length=2L;
  427. /* Check fields */
  429.   List_iterator<create_field> it(create_fields);
  430.   create_field *field;
  431.   while ((field=it++))
  432.   {
  433.     totlength+= field->length;
  434.     com_length+= field->comment.length;
  435.     if (MTYP_TYPENR(field->unireg_check) == Field::NOEMPTY ||
  436. field->unireg_check & MTYP_NOEMPTY_BIT)
  437.     {
  438.       field->unireg_check= (Field::utype) ((uint) field->unireg_check |
  439.    MTYP_NOEMPTY_BIT);
  440.       no_empty++;
  441.     }
  442.     /* 
  443.       We mark first TIMESTAMP field with NOW() in DEFAULT or ON UPDATE 
  444.       as auto-update field.
  445.     */
  446.     if (field->sql_type == FIELD_TYPE_TIMESTAMP &&
  447.         MTYP_TYPENR(field->unireg_check) != Field::NONE &&
  448. !time_stamp_pos)
  449.       time_stamp_pos= (uint) field->offset+ (uint) data_offset + 1;
  450.     length=field->pack_length;
  451.     if ((uint) field->offset+ (uint) data_offset+ length > reclength)
  452.       reclength=(uint) (field->offset+ data_offset + length);
  453.     n_length+= (ulong) strlen(field->field_name)+1;
  454.     field->interval_id=0;
  455.     if (field->interval)
  456.     {
  457.       uint old_int_count=int_count;
  459.       if (field->charset->mbminlen > 1)
  460.       {
  461.         /* Escape UCS2 intervals using HEX notation */
  462.         for (uint pos= 0; pos < field->interval->count; pos++)
  463.         {
  464.           char *dst;
  465.           uint length= field->interval->type_lengths[pos], hex_length;
  466.           const char *src= field->interval->type_names[pos];
  467.           const char *srcend= src + length;
  468.           hex_length= length * 2;
  469.           field->interval->type_lengths[pos]= hex_length;
  470.           field->interval->type_names[pos]= dst= sql_alloc(hex_length + 1);
  471.           for ( ; src < srcend; src++)
  472.           {
  473.             *dst++= _dig_vec_upper[((uchar) *src) >> 4];
  474.             *dst++= _dig_vec_upper[((uchar) *src) & 15];
  475.           }
  476.           *dst= '';
  477.         }
  478.       }
  480.       field->interval_id=get_interval_id(&int_count,create_fields,field);
  481.       if (old_int_count != int_count)
  482.       {
  483. for (const char **pos=field->interval->type_names ; *pos ; pos++)
  484.   int_length+=(uint) strlen(*pos)+1; // field + suffix prefix
  485. int_parts+=field->interval->count+1;
  486.       }
  487.     }
  488.     if (f_maybe_null(field->pack_flag))
  489.       null_fields++;
  490.   }
  491.   int_length+=int_count*2; // 255 prefix + 0 suffix
  493. /* Save values in forminfo */
  495.   if (reclength > (ulong) file->max_record_length())
  496.   {
  497.     my_error(ER_TOO_BIG_ROWSIZE, MYF(0), (uint) file->max_record_length());
  498.     DBUG_RETURN(1);
  499.   }
  500.   /* Hack to avoid bugs with small static rows in MySQL */
  501.   reclength=max(file->min_record_length(table_options),reclength);
  502.   if (info_length+(ulong) create_fields.elements*FCOMP+288+
  503.       n_length+int_length+com_length > 65535L || int_count > 255)
  504.   {
  505.     my_error(ER_TOO_MANY_FIELDS,MYF(0));
  506.     DBUG_RETURN(1);
  507.   }
  509.   bzero((char*)forminfo,288);
  510.   length=(info_length+create_fields.elements*FCOMP+288+n_length+int_length+
  511.   com_length);
  512.   int2store(forminfo,length);
  513.   forminfo[256] = (uint8) screens;
  514.   int2store(forminfo+258,create_fields.elements);
  515.   int2store(forminfo+260,info_length);
  516.   int2store(forminfo+262,totlength);
  517.   int2store(forminfo+264,no_empty);
  518.   int2store(forminfo+266,reclength);
  519.   int2store(forminfo+268,n_length);
  520.   int2store(forminfo+270,int_count);
  521.   int2store(forminfo+272,int_parts);
  522.   int2store(forminfo+274,int_length);
  523.   int2store(forminfo+276,time_stamp_pos);
  524.   int2store(forminfo+278,80); /* Columns needed */
  525.   int2store(forminfo+280,22); /* Rows needed */
  526.   int2store(forminfo+282,null_fields);
  527.   int2store(forminfo+284,com_length);
  528.   DBUG_RETURN(0);
  529. } /* pack_header */
  532. /* get each unique interval each own id */
  534. static uint get_interval_id(uint *int_count,List<create_field> &create_fields,
  535.     create_field *last_field)
  536. {
  537.   List_iterator<create_field> it(create_fields);
  538.   create_field *field;
  539.   TYPELIB *interval=last_field->interval;
  541.   while ((field=it++) != last_field)
  542.   {
  543.     if (field->interval_id && field->interval->count == interval->count)
  544.     {
  545.       const char **a,**b;
  546.       for (a=field->interval->type_names, b=interval->type_names ;
  547.    *a && !strcmp(*a,*b);
  548.    a++,b++) ;
  550.       if (! *a)
  551.       {
  552. return field->interval_id; // Re-use last interval
  553.       }
  554.     }
  555.   }
  556.   return ++*int_count; // New unique interval
  557. }
  560. /* Save fields, fieldnames and intervals */
  562. static bool pack_fields(File file, List<create_field> &create_fields,
  563.                         ulong data_offset)
  564. {
  565.   reg2 uint i;
  566.   uint int_count, comment_length=0;
  567.   uchar buff[MAX_FIELD_WIDTH];
  568.   create_field *field;
  569.   DBUG_ENTER("pack_fields");
  571. /* Write field info */
  573.   List_iterator<create_field> it(create_fields);
  575.   int_count=0;
  576.   while ((field=it++))
  577.   {
  578.     uint recpos;
  579.     buff[0]= (uchar) field->row;
  580.     buff[1]= (uchar) field->col;
  581.     buff[2]= (uchar) field->sc_length;
  582.     int2store(buff+3, field->length);
  583.     /* The +1 is here becasue the col offset in .frm file have offset 1 */
  584.     recpos= field->offset+1 + (uint) data_offset;
  585.     int3store(buff+5,recpos);
  586.     int2store(buff+8,field->pack_flag);
  587.     int2store(buff+10,field->unireg_check);
  588.     buff[12]= (uchar) field->interval_id;
  589.     buff[13]= (uchar) field->sql_type; 
  590.     if (field->sql_type == FIELD_TYPE_GEOMETRY)
  591.     {
  592.       buff[14]= (uchar) field->geom_type;
  593. #ifndef HAVE_SPATIAL
  594.       DBUG_ASSERT(0);                           // Should newer happen
  595. #endif
  596.     }
  597.     else if (field->charset) 
  598.       buff[14]= (uchar) field->charset->number;
  599.     else
  600.       buff[14]= 0; // Numerical
  601.     int2store(buff+15, field->comment.length);
  602.     comment_length+= field->comment.length;
  603.     set_if_bigger(int_count,field->interval_id);
  604.     if (my_write(file,(byte*) buff,FCOMP,MYF_RW))
  605.       DBUG_RETURN(1);
  606.   }
  608. /* Write fieldnames */
  609.   buff[0]=(uchar) NAMES_SEP_CHAR;
  610.   if (my_write(file,(byte*) buff,1,MYF_RW))
  611.     DBUG_RETURN(1);
  612.   i=0;
  613.   it.rewind();
  614.   while ((field=it++))
  615.   {
  616.     char *pos= strmov((char*) buff,field->field_name);
  617.     *pos++=NAMES_SEP_CHAR;
  618.     if (i == create_fields.elements-1)
  619.       *pos++=0;
  620.     if (my_write(file,(byte*) buff,(uint) (pos-(char*) buff),MYF_RW))
  621.       DBUG_RETURN(1);
  622.     i++;
  623.   }
  625. /* Write intervals */
  626.   if (int_count)
  627.   {
  628.     String tmp((char*) buff,sizeof(buff), &my_charset_bin);
  629.     tmp.length(0);
  630.     it.rewind();
  631.     int_count=0;
  632.     while ((field=it++))
  633.     {
  634.       if (field->interval_id > int_count)
  635.       {
  636. int_count=field->interval_id;
  637. tmp.append(NAMES_SEP_CHAR);
  638. for (const char **pos=field->interval->type_names ; *pos ; pos++)
  639. {
  640.   tmp.append(*pos);
  641.   tmp.append(NAMES_SEP_CHAR);
  642. }
  643. tmp.append(''); // End of intervall
  644.       }
  645.     }
  646.     if (my_write(file,(byte*) tmp.ptr(),tmp.length(),MYF_RW))
  647.       DBUG_RETURN(1);
  648.   }
  649.   if (comment_length)
  650.   {
  651.     it.rewind();
  652.     int_count=0;
  653.     while ((field=it++))
  654.     {
  655.       if (field->comment.length)
  656. if (my_write(file, (byte*) field->comment.str, field->comment.length,
  657.      MYF_RW))
  658.   DBUG_RETURN(1);
  659.     }
  660.   }
  661.   DBUG_RETURN(0);
  662. }
  665. /* save an empty record on start of formfile */
  667. static bool make_empty_rec(File file,enum db_type table_type,
  668.    uint table_options,
  669.    List<create_field> &create_fields,
  670.    uint reclength, uint null_fields,
  671.                            ulong data_offset)
  672. {
  673.   int error;
  674.   Field::utype type;
  675.   uint firstpos,null_count;
  676.   uchar *buff,*null_pos;
  677.   TABLE table;
  678.   create_field *field;
  679.   handler *handler;
  680.   DBUG_ENTER("make_empty_rec");
  682.   /* We need a table to generate columns for default values */
  683.   bzero((char*) &table,sizeof(table));
  684.   handler= get_new_handler((TABLE*) 0, table_type);
  686.   if (!handler ||
  687.       !(buff=(uchar*) my_malloc((uint) reclength,MYF(MY_WME | MY_ZEROFILL))))
  688.   {
  689.     delete handler;
  690.     DBUG_RETURN(1);
  691.   }
  693.   table.in_use= current_thd;
  694.   table.db_low_byte_first= handler->low_byte_first();
  695.   table.blob_ptr_size=portable_sizeof_char_ptr;
  697.   firstpos=reclength;
  698.   null_count=0;
  699.   if (!(table_options & HA_OPTION_PACK_RECORD))
  700.     null_count++; // Need one bit for delete mark
  701.   DBUG_ASSERT(data_offset == ((null_fields + null_count + 7) / 8));
  702.   bfill(buff, (uint) data_offset, 255);
  703.   null_pos=buff;
  705.   List_iterator<create_field> it(create_fields);
  706.   while ((field=it++))
  707.   {
  708.     Field *regfield=make_field((char*) buff+field->offset + data_offset,
  709.                                field->length,
  710.        field->flags & NOT_NULL_FLAG ? 0:
  711.        null_pos+null_count/8,
  712.        1 << (null_count & 7),
  713.        field->pack_flag,
  714.        field->sql_type,
  715.        field->charset,
  716.        field->geom_type,
  717.        field->unireg_check,
  718.        field->interval,
  719.        field->field_name,
  720.        &table);
  722.     if (!(field->flags & NOT_NULL_FLAG))
  723.       null_count++;
  725.     if ((uint) (field->offset + data_offset) < firstpos &&
  726. regfield->type() != FIELD_TYPE_NULL)
  727.       firstpos= field->offset + data_offset;
  729.     type= (Field::utype) MTYP_TYPENR(field->unireg_check);
  731.     if (field->def &&
  732. (regfield->real_type() != FIELD_TYPE_YEAR ||
  733.  field->def->val_int() != 0))
  734.       (void) field->def->save_in_field(regfield, 1);
  735.     else if (regfield->real_type() == FIELD_TYPE_ENUM &&
  736.      (field->flags & NOT_NULL_FLAG))
  737.     {
  738.       regfield->set_notnull();
  739.       regfield->store((longlong) 1);
  740.     }
  741.     else if (type == Field::YES) // Old unireg type
  742.       regfield->store(ER(ER_YES),(uint) strlen(ER(ER_YES)),system_charset_info);
  743.     else if (type == Field::NO) // Old unireg type
  744.       regfield->store(ER(ER_NO), (uint) strlen(ER(ER_NO)),system_charset_info);
  745.     else
  746.       regfield->reset();
  747.     delete regfield;
  748.   }
  750.   /* Fill not used startpos */
  751.   bfill((byte*) buff+data_offset, firstpos- (uint) data_offset, 255);
  752.   error=(int) my_write(file,(byte*) buff, (uint) reclength,MYF_RW);
  753.   my_free((gptr) buff,MYF(MY_FAE));
  754.   delete handler;
  755.   DBUG_RETURN(error);
  756. } /* make_empty_rec */