~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2006 MySQL AB

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/*

  Functions to create a unireg form-file from a FIELD and a fieldname-fieldinfo

  struct.

  In the following functions FIELD * is an ordinary field-structure with

  the following exeptions:

    sc_length,typepos,row,kol,dtype,regnr and field need not to be set.

    str is a (long) to record position where 0 is the first position.

*/

#include "mysql_priv.h"

#include <m_ctype.h>

#include <assert.h>

#define FCOMP			17		/* Bytes for a packed field */

static uchar * pack_screens(List<Create_field> &create_fields,

			    uint *info_length, uint *screens, bool small_file);

static uint pack_keys(uchar *keybuff,uint key_count, KEY *key_info,

                      ulong data_offset);

static bool pack_header(uchar *forminfo,enum legacy_db_type table_type,

			List<Create_field> &create_fields,

			uint info_length, uint screens, uint table_options,

			ulong data_offset, handler *file);

static uint get_interval_id(uint *int_count,List<Create_field> &create_fields,

			    Create_field *last_field);

static bool pack_fields(File file, List<Create_field> &create_fields,

                        ulong data_offset);

static bool make_empty_rec(THD *thd, int file, enum legacy_db_type table_type,

			   uint table_options,

			   List<Create_field> &create_fields,

			   uint reclength, ulong data_offset,

                           handler *handler);

/**

  An interceptor to hijack ER_TOO_MANY_FIELDS error from

  pack_screens and retry again without UNIREG screens.

  XXX: what is a UNIREG  screen?

*/

struct Pack_header_error_handler: public Internal_error_handler

{

  virtual bool handle_error(uint sql_errno,

                            const char *message,

                            MYSQL_ERROR::enum_warning_level level,

                            THD *thd);

  bool is_handled;

  Pack_header_error_handler() :is_handled(FALSE) {}

};

bool

Pack_header_error_handler::

handle_error(uint sql_errno,

             const char * /* message */,

             MYSQL_ERROR::enum_warning_level /* level */,

             THD * /* thd */)

{

  is_handled= (sql_errno == ER_TOO_MANY_FIELDS);

  return is_handled;

}

/*

  Create a frm (table definition) file

  SYNOPSIS

    mysql_create_frm()

    thd			Thread handler

    file_name		Path for file (including database and .frm)

    db                  Name of database

    table               Name of table

    create_info		create info parameters

    create_fields	Fields to create

    keys		number of keys to create

    key_info		Keys to create

    db_file		Handler to use. May be zero, in which case we use

			create_info->db_type

  RETURN

    0  ok

    1  error

*/

bool mysql_create_frm(THD *thd, const char *file_name,

                      const char *db, const char *table,

		      HA_CREATE_INFO *create_info,

		      List<Create_field> &create_fields,

		      uint keys, KEY *key_info,

		      handler *db_file)

{

  LEX_STRING str_db_type;

  uint reclength, info_length, screens, key_info_length, maxlength, tmp_len;

  ulong key_buff_length;

  File file;

  ulong filepos, data_offset;

  uchar fileinfo[64],forminfo[288],*keybuff;

  TYPELIB formnames;

  uchar *screen_buff;

  char buff[128];

  const uint format_section_header_size= 8;

  uint format_section_len;

  uint tablespace_len= 0;

  Pack_header_error_handler pack_header_error_handler;

  int error;

  DBUG_ENTER("mysql_create_frm");

  DBUG_ASSERT(*fn_rext((char*)file_name)); // Check .frm extension

  formnames.type_names=0;

  if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,0)))

    DBUG_RETURN(1);

  DBUG_ASSERT(db_file != NULL);

 /* If fixed row records, we need one bit to check for deleted rows */

  if (!(create_info->table_options & HA_OPTION_PACK_RECORD))

    create_info->null_bits++;

  data_offset= (create_info->null_bits + 7) / 8;

  thd->push_internal_handler(&pack_header_error_handler);

  error= pack_header(forminfo, ha_legacy_type(create_info->db_type),

                     create_fields,info_length,

                     screens, create_info->table_options,

                     data_offset, db_file);

  thd->pop_internal_handler();

  if (error)

  {

    my_free(screen_buff, MYF(0));

    if (! pack_header_error_handler.is_handled)

      DBUG_RETURN(1);

    // Try again without UNIREG screens (to get more columns)

    if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,1)))

      DBUG_RETURN(1);

    if (pack_header(forminfo, ha_legacy_type(create_info->db_type),

                    create_fields,info_length,

		    screens, create_info->table_options, data_offset, db_file))

    {

      my_free(screen_buff, MYF(0));

      DBUG_RETURN(1);

    }

  }

  reclength=uint2korr(forminfo+266);

  /* Calculate extra data segment length */

  str_db_type.str= (char *) ha_resolve_storage_engine_name(create_info->db_type);

  str_db_type.length= strlen(str_db_type.str);

  /* str_db_type */

  create_info->extra_size= (2 + str_db_type.length +

                            2 + create_info->connect_string.length);

  /*

    Partition:

      Length of partition info = 4 byte

      Potential NULL byte at end of partition info string = 1 byte

      Indicator if auto-partitioned table = 1 byte

      => Total 6 byte

  */

  create_info->extra_size+= 6;

  /* Add space for storage type and field format array of fields */

  if (create_info->tablespace)

    tablespace_len= strlen(create_info->tablespace);

  format_section_len=

    format_section_header_size +

    tablespace_len + 1 +

    create_fields.elements;

  create_info->extra_size+= format_section_len;

  tmp_len= system_charset_info->cset->charpos(system_charset_info,

                                              create_info->comment.str,

                                              create_info->comment.str +

                                              create_info->comment.length, 

                                              TABLE_COMMENT_MAXLEN);

  if (tmp_len < create_info->comment.length)

  {

    my_error(ER_WRONG_STRING_LENGTH, MYF(0),

             create_info->comment.str,"TABLE COMMENT",

             (uint) TABLE_COMMENT_MAXLEN);

    my_free(screen_buff,MYF(0));

    DBUG_RETURN(1);

  }

  //if table comment is larger than 180 bytes, store into extra segment.

  if (create_info->comment.length > 180)

  {

    forminfo[46]=255;

    create_info->extra_size+= 2 + create_info->comment.length;

  }

  else{

    strmake((char*) forminfo+47, create_info->comment.str ?

            create_info->comment.str : "", create_info->comment.length);

    forminfo[46]=(uchar) create_info->comment.length;

#ifdef EXTRA_DEBUG

    /*

      EXTRA_DEBUG causes strmake() to initialize its buffer behind the

      payload with a magic value to detect wrong buffer-sizes. We

      explicitly zero that segment again.

    */

    memset((char*) forminfo+47 + forminfo[46], 0, 61 - forminfo[46]);

#endif

  }

  if ((file=create_frm(thd, file_name, db, table, reclength, fileinfo,

		       create_info, keys, key_info)) < 0)

  {

    my_free(screen_buff, MYF(0));

    DBUG_RETURN(1);

  }

  key_buff_length= uint4korr(fileinfo+47);

  keybuff=(uchar*) my_malloc(key_buff_length, MYF(0));

  key_info_length= pack_keys(keybuff, keys, key_info, data_offset);

  VOID(get_form_pos(file,fileinfo,&formnames));

  if (!(filepos=make_new_entry(file,fileinfo,&formnames,"")))

    goto err;

  maxlength=(uint) next_io_size((ulong) (uint2korr(forminfo)+1000));

  int2store(forminfo+2,maxlength);

  int4store(fileinfo+10,(ulong) (filepos+maxlength));

  fileinfo[26]= (uchar) test((create_info->max_rows == 1) &&

			     (create_info->min_rows == 1) && (keys == 0));

  int2store(fileinfo+28,key_info_length);

  int2store(fileinfo+59,db_file->extra_rec_buf_length());

  if (my_pwrite(file, fileinfo, 64, 0L, MYF_RW) ||

      my_pwrite(file, keybuff, key_info_length,

		(ulong) uint2korr(fileinfo+6),MYF_RW))

    goto err;

  VOID(my_seek(file,

	       (ulong) uint2korr(fileinfo+6)+ (ulong) key_buff_length,

	       MY_SEEK_SET,MYF(0)));

  if (make_empty_rec(thd,file,ha_legacy_type(create_info->db_type),

                     create_info->table_options,

		     create_fields,reclength, data_offset, db_file))

    goto err;

  int2store(buff, create_info->connect_string.length);

  if (my_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||

      my_write(file, (const uchar*)create_info->connect_string.str,

               create_info->connect_string.length, MYF(MY_NABP)))

      goto err;

  int2store(buff, str_db_type.length);

  if (my_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||

      my_write(file, (const uchar*)str_db_type.str,

               str_db_type.length, MYF(MY_NABP)))

    goto err;

  {

    bzero((uchar*) buff, 6);

    if (my_write(file, (uchar*) buff, 6, MYF_RW))

      goto err;

  }

  if (forminfo[46] == (uchar)255)

  {

    uchar comment_length_buff[2];

    int2store(comment_length_buff,create_info->comment.length);

    if (my_write(file, comment_length_buff, 2, MYF(MY_NABP)) ||

        my_write(file, (uchar*)create_info->comment.str,

                  create_info->comment.length, MYF(MY_NABP)))

      goto err;

  }

  /* Store storage type and field format array of fields */

  {

    /* prepare header */

    {

      uint flags= 0;

      flags|= create_info->default_storage_media; //3 bits

      bzero(buff, format_section_header_size);

      /* length of section 2 bytes*/

      int2store(buff+0, format_section_len);

      /* flags of section 4 bytes*/

      int4store(buff+2, flags);

      /* 2 bytes left for future use */

    }

    /* write header */

    if (my_write(file, (const uchar*)buff, format_section_header_size, MYF_RW))

      goto err;

    /* write tablespace name */

    if (tablespace_len > 0)

      if (my_write(file, (const uchar*)create_info->tablespace, tablespace_len, MYF_RW))

        goto err;

    buff[0]= 0;

    if (my_write(file, (const uchar*)buff, 1, MYF_RW))

      goto err;

    /* write column info, 1 byte per column */

    {

      List_iterator<Create_field> it(create_fields);

      Create_field *field;

      uchar storage_type, column_format, write_byte;

      while ((field=it++))

      {

        storage_type= (uchar)field->field_storage_type();

        column_format= (uchar)field->column_format();

        write_byte= storage_type + (column_format << COLUMN_FORMAT_SHIFT);

        if (my_write(file, &write_byte, 1, MYF_RW))

          goto err;

      }

    }

  }

  VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));

  if (my_write(file, forminfo, 288, MYF_RW) ||

      my_write(file, screen_buff, info_length, MYF_RW) ||

      pack_fields(file, create_fields, data_offset))

    goto err;

  my_free(screen_buff,MYF(0));

  my_free(keybuff, MYF(0));

  if (opt_sync_frm && !(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&

      (my_sync(file, MYF(MY_WME)) ||

       my_sync_dir_by_file(file_name, MYF(MY_WME))))

      goto err2;

  if (my_close(file,MYF(MY_WME)))

    goto err3;

  {

    /* 

      Restore all UCS2 intervals.

      HEX representation of them is not needed anymore.

    */

    List_iterator<Create_field> it(create_fields);

    Create_field *field;

    while ((field=it++))

    {

      if (field->save_interval)

      {

        field->interval= field->save_interval;

        field->save_interval= 0;

      }

    }

  }

  DBUG_RETURN(0);

err:

  my_free(screen_buff, MYF(0));

  my_free(keybuff, MYF(0));

err2:

  VOID(my_close(file,MYF(MY_WME)));

err3:

  my_delete(file_name,MYF(0));

  DBUG_RETURN(1);

} /* mysql_create_frm */

/*

  Create a frm (table definition) file and the tables

  SYNOPSIS

    rea_create_table()

    thd			Thread handler

    path		Name of file (including database, without .frm)

    db			Data base name

    table_name		Table name

    create_info		create info parameters

    create_fields	Fields to create

    keys		number of keys to create

    key_info		Keys to create

    file		Handler to use

  RETURN

    0  ok

    1  error

*/

int rea_create_table(THD *thd, const char *path,

                     const char *db, const char *table_name,

                     HA_CREATE_INFO *create_info,

                     List<Create_field> &create_fields,

                     uint keys, KEY *key_info, handler *file)

{

  DBUG_ENTER("rea_create_table");

  char frm_name[FN_REFLEN];

  strxmov(frm_name, path, reg_ext, NullS);

  if (mysql_create_frm(thd, frm_name, db, table_name, create_info,

                       create_fields, keys, key_info, file))

    DBUG_RETURN(1);

  // Make sure mysql_create_frm din't remove extension

  DBUG_ASSERT(*fn_rext(frm_name));

  if (thd->variables.keep_files_on_create)

    create_info->options|= HA_CREATE_KEEP_FILES;

  if (file->ha_create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info))

    goto err_handler;

  if (!create_info->frm_only && ha_create_table(thd, path, db, table_name,

                                                create_info,0))

    goto err_handler;

  DBUG_RETURN(0);

err_handler:

  VOID(file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));

  my_delete(frm_name, MYF(0));

  DBUG_RETURN(1);

} /* rea_create_table */

	/* Pack screens to a screen for save in a form-file */

static uchar *pack_screens(List<Create_field> &create_fields,

                           uint *info_length, uint *screens,

                           bool small_file)

{

  register uint i;

  uint row,start_row,end_row,fields_on_screen;

  uint length,cols;

  uchar *info,*pos,*start_screen;

  uint fields=create_fields.elements;

  List_iterator<Create_field> it(create_fields);

  DBUG_ENTER("pack_screens");

  start_row=4; end_row=22; cols=80; fields_on_screen=end_row+1-start_row;

  *screens=(fields-1)/fields_on_screen+1;

  length= (*screens) * (SC_INFO_LENGTH+ (cols>> 1)+4);

  Create_field *field;

  while ((field=it++))

    length+=(uint) strlen(field->field_name)+1+TE_INFO_LENGTH+cols/2;

  if (!(info=(uchar*) my_malloc(length,MYF(MY_WME))))

    DBUG_RETURN(0);

  start_screen=0;

  row=end_row;

  pos=info;

  it.rewind();

  for (i=0 ; i < fields ; i++)

  {

    Create_field *cfield=it++;

    if (row++ == end_row)

    {

      if (i)

      {

	length=(uint) (pos-start_screen);

	int2store(start_screen,length);

	start_screen[2]=(uchar) (fields_on_screen+1);

	start_screen[3]=(uchar) (fields_on_screen);

      }

      row=start_row;

      start_screen=pos;

      pos+=4;

      pos[0]= (uchar) start_row-2;	/* Header string */

      pos[1]= (uchar) (cols >> 2);

      pos[2]= (uchar) (cols >> 1) +1;

      strfill((char *) pos+3,(uint) (cols >> 1),' ');

      pos+=(cols >> 1)+4;

    }

    length=(uint) strlen(cfield->field_name);

    if (length > cols-3)

      length=cols-3;

    if (!small_file)

    {

      pos[0]=(uchar) row;

      pos[1]=0;

      pos[2]=(uchar) (length+1);

      pos=(uchar*) strmake((char*) pos+3,cfield->field_name,length)+1;

    }

    cfield->row=(uint8) row;

    cfield->col=(uint8) (length+1);

    cfield->sc_length=(uint8) min(cfield->length,cols-(length+2));

  }

  length=(uint) (pos-start_screen);

  int2store(start_screen,length);

  start_screen[2]=(uchar) (row-start_row+2);

  start_screen[3]=(uchar) (row-start_row+1);

  *info_length=(uint) (pos-info);

  DBUG_RETURN(info);

} /* pack_screens */

	/* Pack keyinfo and keynames to keybuff for save in form-file. */

static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo,

                      ulong data_offset)

{

  uint key_parts,length;

  uchar *pos, *keyname_pos;

  KEY *key,*end;

  KEY_PART_INFO *key_part,*key_part_end;

  DBUG_ENTER("pack_keys");

  pos=keybuff+6;

  key_parts=0;

  for (key=keyinfo,end=keyinfo+key_count ; key != end ; key++)

  {

    int2store(pos, (key->flags ^ HA_NOSAME));

    int2store(pos+2,key->key_length);

    pos[4]= (uchar) key->key_parts;

    pos[5]= (uchar) key->algorithm;

    int2store(pos+6, key->block_size);

    pos+=8;

    key_parts+=key->key_parts;

    DBUG_PRINT("loop", ("flags: %lu  key_parts: %d at 0x%lx",

                        key->flags, key->key_parts,

                        (long) key->key_part));

    for (key_part=key->key_part,key_part_end=key_part+key->key_parts ;

	 key_part != key_part_end ;

	 key_part++)

    {

      uint offset;

      DBUG_PRINT("loop",("field: %d  startpos: %lu  length: %d",

			 key_part->fieldnr, key_part->offset + data_offset,

                         key_part->length));

      int2store(pos,key_part->fieldnr+1+FIELD_NAME_USED);

      offset= (uint) (key_part->offset+data_offset+1);

      int2store(pos+2, offset);

      pos[4]=0;					// Sort order

      int2store(pos+5,key_part->key_type);

      int2store(pos+7,key_part->length);

      pos+=9;

    }

  }

	/* Save keynames */

  keyname_pos=pos;

  *pos++=(uchar) NAMES_SEP_CHAR;

  for (key=keyinfo ; key != end ; key++)

  {

    uchar *tmp=(uchar*) strmov((char*) pos,key->name);

    *tmp++= (uchar) NAMES_SEP_CHAR;

    *tmp=0;

    pos=tmp;

  }

  *(pos++)=0;

  for (key=keyinfo,end=keyinfo+key_count ; key != end ; key++)

  {

    if (key->flags & HA_USES_COMMENT)

    {

      int2store(pos, key->comment.length);

      uchar *tmp= (uchar*)strnmov((char*) pos+2,key->comment.str,key->comment.length);

      pos= tmp;

    }

  }

  if (key_count > 127 || key_parts > 127)

  {

    keybuff[0]= (key_count & 0x7f) | 0x80;

    keybuff[1]= key_count >> 7;

    int2store(keybuff+2,key_parts);

  }

  else

  {

    keybuff[0]=(uchar) key_count;

    keybuff[1]=(uchar) key_parts;

    keybuff[2]= keybuff[3]= 0;

  }

  length=(uint) (pos-keyname_pos);

  int2store(keybuff+4,length);

  DBUG_RETURN((uint) (pos-keybuff));

} /* pack_keys */

	/* Make formheader */

static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,

			List<Create_field> &create_fields,

                        uint info_length, uint screens, uint table_options,

                        ulong data_offset, handler *file)

{

  uint length,int_count,int_length,no_empty, int_parts;

  uint time_stamp_pos,null_fields;

  ulong reclength, totlength, n_length, com_length;

  DBUG_ENTER("pack_header");

  if (create_fields.elements > MAX_FIELDS)

  {

    my_message(ER_TOO_MANY_FIELDS, ER(ER_TOO_MANY_FIELDS), MYF(0));

    DBUG_RETURN(1);

  }

  totlength= 0L;

  reclength= data_offset;

  no_empty=int_count=int_parts=int_length=time_stamp_pos=null_fields=

    com_length=0;

  n_length=2L;

	/* Check fields */

  List_iterator<Create_field> it(create_fields);

  Create_field *field;

  while ((field=it++))

  {

    uint tmp_len= system_charset_info->cset->charpos(system_charset_info,

                                                     field->comment.str,

                                                     field->comment.str +

                                                     field->comment.length,

                                                     COLUMN_COMMENT_MAXLEN);

    if (tmp_len < field->comment.length)

    {

      my_error(ER_WRONG_STRING_LENGTH, MYF(0),

               field->comment.str,"COLUMN COMMENT",

               (uint) COLUMN_COMMENT_MAXLEN);

      DBUG_RETURN(1);

    }

    totlength+= field->length;

    com_length+= field->comment.length;

    if (MTYP_TYPENR(field->unireg_check) == Field::NOEMPTY ||

	field->unireg_check & MTYP_NOEMPTY_BIT)

    {

      field->unireg_check= (Field::utype) ((uint) field->unireg_check |

					   MTYP_NOEMPTY_BIT);

      no_empty++;

    }

    /* 

      We mark first TIMESTAMP field with NOW() in DEFAULT or ON UPDATE 

      as auto-update field.

    */

    if (field->sql_type == MYSQL_TYPE_TIMESTAMP &&

        MTYP_TYPENR(field->unireg_check) != Field::NONE &&

	!time_stamp_pos)

      time_stamp_pos= (uint) field->offset+ (uint) data_offset + 1;

    length=field->pack_length;

    /* Ensure we don't have any bugs when generating offsets */

    DBUG_ASSERT(reclength == field->offset + data_offset);

    if ((uint) field->offset+ (uint) data_offset+ length > reclength)

      reclength=(uint) (field->offset+ data_offset + length);

    n_length+= (ulong) strlen(field->field_name)+1;

    field->interval_id=0;

    field->save_interval= 0;

    if (field->interval)

    {

      uint old_int_count=int_count;

      if (field->charset->mbminlen > 1)

      {

        /* 

          Escape UCS2 intervals using HEX notation to avoid

          problems with delimiters between enum elements.

          As the original representation is still needed in 

          the function make_empty_rec to create a record of

          filled with default values it is saved in save_interval

          The HEX representation is created from this copy.

        */

        field->save_interval= field->interval;

        field->interval= (TYPELIB*) sql_alloc(sizeof(TYPELIB));

        *field->interval= *field->save_interval; 

        field->interval->type_names= 

          (const char **) sql_alloc(sizeof(char*) * 

				    (field->interval->count+1));

        field->interval->type_names[field->interval->count]= 0;

        field->interval->type_lengths=

          (uint *) sql_alloc(sizeof(uint) * field->interval->count);

        for (uint pos= 0; pos < field->interval->count; pos++)

        {

          char *dst;

          const char *src= field->save_interval->type_names[pos];

          uint hex_length;

          length= field->save_interval->type_lengths[pos];

          hex_length= length * 2;

          field->interval->type_lengths[pos]= hex_length;

          field->interval->type_names[pos]= dst= (char*) sql_alloc(hex_length +

                                                                   1);

          octet2hex(dst, src, length);

        }

      }

      field->interval_id=get_interval_id(&int_count,create_fields,field);

      if (old_int_count != int_count)

      {

	for (const char **pos=field->interval->type_names ; *pos ; pos++)

	  int_length+=(uint) strlen(*pos)+1;	// field + suffix prefix

	int_parts+=field->interval->count+1;

      }

    }

    if (f_maybe_null(field->pack_flag))

      null_fields++;

  }

  int_length+=int_count*2;			// 255 prefix + 0 suffix

	/* Save values in forminfo */

  if (reclength > (ulong) file->max_record_length())