/* Create a .frm file */

File create_frm(THD *thd, const char *name, const char *db,

                const char *table, uint reclength, uchar *fileinfo,

          HA_CREATE_INFO *create_info, uint keys, KEY *key_info)

{

  register File file;

  ulong length;

  uchar fill[IO_SIZE];

  int create_flags= O_RDWR | O_TRUNC;

  ulong key_comment_total_bytes= ;

  uint i;

  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)

    create_flags|= O_EXCL | O_NOFOLLOW;

  /* Fix this when we have new .frm files;  Current limit is 4G rows (QQ) */

  if (create_info->max_rows > UINT_MAX32)

    create_info->max_rows= UINT_MAX32;

  if (create_info->min_rows > UINT_MAX32)

    create_info->min_rows= UINT_MAX32;

  if ((file= mysql_file_create(key_file_frm,

                               name, CREATE_MODE, create_flags, MYF())) >= )

  {

    uint key_length, tmp_key_length, tmp, csid;

    bzero((char*) fileinfo,);

    /* header */

    fileinfo[]=(uchar) ;

    fileinfo[]= ;

    fileinfo[]= FRM_VER++ test(create_info->varchar);

    fileinfo[]= (uchar) ha_legacy_type(

          ha_checktype(thd,ha_legacy_type(create_info->db_type),,));

    fileinfo[]=;

    int2store(fileinfo+,IO_SIZE);        /* Next block starts here */

    /*

      Keep in sync with pack_keys() in unireg.cc

      For each key:

      8 bytes for the key header

      9 bytes for each key-part (MAX_REF_PARTS)

      NAME_LEN bytes for the name

      1 byte for the NAMES_SEP_CHAR (before the name)

      For all keys:

      6 bytes for the header

      1 byte for the NAMES_SEP_CHAR (after the last name)

      9 extra bytes (padding for safety? alignment?)

    */

    for (i= ; i < keys; i++)

    {

      DBUG_ASSERT(test(key_info[i].flags & HA_USES_COMMENT) ==

                 (key_info[i].comment.length > ));

      if (key_info[i].flags & HA_USES_COMMENT)

        key_comment_total_bytes +=  + key_info[i].comment.length;

    }

    key_length= keys * ( + MAX_REF_PARTS *  + NAME_LEN + ) +

                + key_comment_total_bytes;

    length= next_io_size((ulong) (IO_SIZE+key_length+reclength+

                                  create_info->extra_size));

    int4store(fileinfo+,length);

    tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff;

    int2store(fileinfo+,tmp_key_length);

    int2store(fileinfo+,reclength);

    int4store(fileinfo+,create_info->max_rows);

    int4store(fileinfo+,create_info->min_rows);

    /* fileinfo[26] is set in mysql_create_frm() */

    fileinfo[]=;                // Use long pack-fields

    /* fileinfo[28 & 29] is set to key_info_length in mysql_create_frm() */

    create_info->table_options|=HA_OPTION_LONG_BLOB_PTR; // Use portable blob pointers

    int2store(fileinfo+,create_info->table_options);

    fileinfo[]=;                // No filename anymore

    fileinfo[]=;                             // Mark for 5.0 frm file

    int4store(fileinfo+,create_info->avg_row_length);

    csid= (create_info->default_table_charset ?

           create_info->default_table_charset->number : );

    fileinfo[]= (uchar) csid;

    /*

      In future versions, we will store in fileinfo[39] the values of the

      TRANSACTIONAL and PAGE_CHECKSUM clauses of CREATE TABLE.

    */

    fileinfo[]= ;

    fileinfo[]= (uchar) create_info->row_type;

    /* Next few bytes where for RAID support */

    fileinfo[]= (uchar) (csid >> );

    fileinfo[]= ;

    fileinfo[]= ;

    fileinfo[]= ;

    fileinfo[]= ;

    fileinfo[]= ;

    int4store(fileinfo+, key_length);

    tmp= MYSQL_VERSION_ID;          // Store to avoid warning from int4store

    int4store(fileinfo+, tmp);

    int4store(fileinfo+, create_info->extra_size);

    /*

      59-60 is reserved for extra_rec_buf_length,

      61 for default_part_db_type

    */

    int2store(fileinfo+, create_info->key_block_size);

    bzero(fill,IO_SIZE);

    for (; length > IO_SIZE ; length-= IO_SIZE)

    {

      if (mysql_file_write(file, fill, IO_SIZE, MYF(MY_WME | MY_NABP)))

      {

        (void) mysql_file_close(file, MYF());

        (void) mysql_file_delete(key_file_frm, name, MYF());

    return(-);

      }

    }

  }

  else

  {

    if (my_errno == ENOENT)

      my_error(ER_BAD_DB_ERROR,MYF(),db);

    else

      my_error(ER_CANT_CREATE_TABLE,MYF(),table,my_errno);

  }

  return (file);

} /* create_frm */

for (i= ; i < keys ; i++, keyinfo++)

  {

    keyinfo->table= ;                           // Updated in open_frm

    if (new_frm_ver >= )

    {

      keyinfo->flags=       (uint) uint2korr(strpos) ^ HA_NOSAME;

      keyinfo->key_length= (uint) uint2korr(strpos+);

      keyinfo->key_parts=  (uint) strpos[];

      keyinfo->algorithm=  (enum ha_key_alg) strpos[];

      keyinfo->block_size= uint2korr(strpos+);

      strpos+=;

    }

    else

    {

      keyinfo->flags=     ((uint) strpos[]) ^ HA_NOSAME;

      keyinfo->key_length= (uint) uint2korr(strpos+);

      keyinfo->key_parts=  (uint) strpos[];

      keyinfo->algorithm= HA_KEY_ALG_UNDEF;

      strpos+=;

    }

    keyinfo->key_part=     key_part;

    keyinfo->rec_per_key= rec_per_key;

    for (j=keyinfo->key_parts ; j-- ; key_part++)

    {

      *rec_per_key++=;

      key_part->fieldnr=    (uint16) (uint2korr(strpos) & FIELD_NR_MASK);

      key_part->offset= (uint) uint2korr(strpos+)-;

      key_part->key_type=    (uint) uint2korr(strpos+);

      // key_part->field=    (Field*) 0;    // Will be fixed later

      if (new_frm_ver >= )

      {

    key_part->key_part_flag= *(strpos+);

    key_part->length=    (uint) uint2korr(strpos+);

    strpos+=;

      }

      else

      {

    key_part->length=    *(strpos+);

    key_part->key_part_flag=;

    if (key_part->length > )

    {

      key_part->length&=;        /* purecov: inspected */

      key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */

    }

    strpos+=;

      }

      key_part->store_length=key_part->length;

    }

  }

  keynames=(char*) key_part;

  strpos+= (strmov(keynames, (char *) strpos) - keynames)+;

  //reading index comments

  for (keyinfo= share->key_info, i=; i < keys; i++, keyinfo++)

  {

    if (keyinfo->flags & HA_USES_COMMENT)

    {

      keyinfo->comment.length= uint2korr(strpos);

      keyinfo->comment.str= strmake_root(&share->mem_root, (char*) strpos+,

                                         keyinfo->comment.length);

      strpos+=  + keyinfo->comment.length;

    }

    DBUG_ASSERT(test(keyinfo->flags & HA_USES_COMMENT) ==

               (keyinfo->comment.length > ));

  }