Adding upstream version 1:10.11.6.upstream/1%10.11.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1259 insertions, 0 deletions

diff --git a/sql/unireg.cc b/sql/unireg.cc
new file mode 100644
index 00000000..ea0b94eb
--- /dev/null
+++ b/sql/unireg.cc
@@ -0,0 +1,1259 @@
+/*
+   Copyright (c) 2000, 2011, Oracle and/or its affiliates.
+   Copyright (c) 2009, 2021, MariaDB Corporation.
+
+   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  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 "mariadb.h"
+#include "sql_priv.h"
+#include "unireg.h"
+#include "sql_partition.h"                      // struct partition_info
+#include "sql_class.h"                  // THD, Internal_error_handler
+#include "create_options.h"
+#include "discover.h"
+#include <m_ctype.h>
+
+#define FCOMP			17		/* Bytes for a packed field */
+
+/* threshold for safe_alloca */
+#define ALLOCA_THRESHOLD       2048
+
+static uint pack_keys(uchar *,uint, KEY *, ulong, uint);
+static bool pack_header(THD *, uchar *, List<Create_field> &, HA_CREATE_INFO *,
+                        ulong, handler *);
+static bool pack_vcols(THD *thd, String *,
+                       List<Create_field> &, List<Virtual_column_info> *);
+static uint get_interval_id(uint *,List<Create_field> &, Create_field *);
+static bool pack_fields(uchar **, List<Create_field> &, HA_CREATE_INFO*,
+                        ulong);
+static size_t packed_fields_length(List<Create_field> &);
+static bool make_empty_rec(THD *, uchar *, uint, List<Create_field> &, uint,
+                           ulong);
+
+/*
+  write the length as
+  if (  0 < length <= 255)      one byte
+  if (256 < length <= 65535)    zero byte, then two bytes, low-endian
+*/
+static uchar *extra2_write_len(uchar *pos, size_t len)
+{
+  DBUG_ASSERT(len);
+  if (len <= 255)
+    *pos++= (uchar)len;
+  else
+  {
+    /*
+      At the moment we support options_len up to 64K.
+      We can easily extend it in the future, if the need arises.
+    */
+    DBUG_ASSERT(len <= 65535);
+    int2store(pos + 1, len);
+    pos+= 3;
+  }
+  return pos;
+}
+
+static uchar* extra2_write_str(uchar *pos, const LEX_CSTRING &str)
+{
+  pos= extra2_write_len(pos, str.length);
+  memcpy(pos, str.str, str.length);
+  return pos + str.length;
+}
+
+static uchar* extra2_write_str(uchar *pos, const Binary_string *str)
+{
+  pos= extra2_write_len(pos, str->length());
+  memcpy(pos, str->ptr(), str->length());
+  return pos + str->length();
+}
+
+static uchar *extra2_write(uchar *pos, enum extra2_frm_value_type type,
+                           const LEX_CSTRING &str)
+{
+  *pos++ = type;
+  return extra2_write_str(pos, str);
+}
+
+static uchar *extra2_write(uchar *pos, enum extra2_frm_value_type type,
+                           const LEX_CUSTRING &str)
+{
+  return extra2_write(pos, type, *reinterpret_cast<const LEX_CSTRING*>(&str));
+}
+
+static uchar *extra2_write_field_properties(uchar *pos,
+                   List<Create_field> &create_fields)
+{
+  List_iterator<Create_field> it(create_fields);
+  *pos++= EXTRA2_FIELD_FLAGS;
+  /*
+   always first 2  for field visibility
+  */
+  pos= extra2_write_len(pos, create_fields.elements);
+  while (Create_field *cf= it++)
+  {
+    uchar flags= cf->invisible;
+    if (cf->flags & VERS_UPDATE_UNVERSIONED_FLAG)
+      flags|= VERS_OPTIMIZED_UPDATE;
+    *pos++= flags;
+  }
+  return pos;
+}
+
+static uchar *extra2_write_index_properties(uchar *pos, const KEY *keyinfo,
+                                            uint keys)
+{
+  *pos++= EXTRA2_INDEX_FLAGS;
+  pos= extra2_write_len(pos, keys);
+  for (uint i=0; i < keys; i++)
+  {
+    *pos++= keyinfo[i].is_ignored ?
+            EXTRA2_IGNORED_KEY :
+            EXTRA2_DEFAULT_INDEX_FLAGS;
+  }
+  return pos;
+}
+
+static field_index_t
+get_fieldno_by_name(HA_CREATE_INFO *create_info,
+                    List<Create_field> &create_fields,
+                    const Lex_ident &field_name)
+{
+  List_iterator<Create_field> it(create_fields);
+  Create_field *sql_field = NULL;
+
+  DBUG_ASSERT(field_name);
+
+  for (field_index_t field_no= 0; (sql_field = it++); ++field_no)
+  {
+    if (field_name.streq(sql_field->field_name))
+    {
+      DBUG_ASSERT(field_no < NO_CACHED_FIELD_INDEX);
+      return field_no;
+    }
+  }
+
+  DBUG_ASSERT(0); /* Not Reachable */
+  return NO_CACHED_FIELD_INDEX;
+}
+
+static inline
+bool has_extra2_field_flags(List<Create_field> &create_fields)
+{
+  List_iterator<Create_field> it(create_fields);
+  while (Create_field *f= it++)
+  {
+    if (f->invisible)
+      return true;
+    if (f->flags & VERS_UPDATE_UNVERSIONED_FLAG)
+      return true;
+  }
+  return false;
+}
+
+static uint gis_field_options_image(uchar *buff,
+                                    List<Create_field> &create_fields)
+{
+  uint image_size= 0;
+  List_iterator<Create_field> it(create_fields);
+  Create_field *field;
+  while ((field= it++))
+  {
+    if (field->real_field_type() != MYSQL_TYPE_GEOMETRY)
+      continue;
+    uchar *cbuf= buff ? buff + image_size : NULL;
+    image_size+= field->type_handler()->
+                   Column_definition_gis_options_image(cbuf, *field);
+  }
+  return image_size;
+}
+
+
+class Field_data_type_info_image: public BinaryStringBuffer<512>
+{
+  static uchar *store_length(uchar *pos, ulonglong length)
+  {
+    return net_store_length(pos, length);
+  }
+  static uchar *store_string(uchar *pos, const Binary_string *str)
+  {
+    pos= store_length(pos, str->length());
+    memcpy(pos, str->ptr(), str->length());
+    return pos + str->length();
+  }
+  static uint store_length_required_length(ulonglong length)
+  {
+    return net_length_size(length);
+  }
+public:
+  Field_data_type_info_image() { }
+  bool append(uint fieldnr, const Column_definition &def)
+  {
+    BinaryStringBuffer<64> type_info;
+    if (def.type_handler()->
+              Column_definition_data_type_info_image(&type_info, def) ||
+        type_info.length() > 0xFFFF/*Some reasonable limit*/)
+      return true; // Error
+    if (!type_info.length())
+      return false;
+    size_t need_length= store_length_required_length(fieldnr) +
+                        store_length_required_length(type_info.length()) +
+                        type_info.length();
+    if (reserve(need_length))
+      return true; // Error
+    uchar *pos= (uchar *) end();
+    pos= store_length(pos, fieldnr);
+    pos= store_string(pos, &type_info);
+    size_t new_length= (const char *) pos - ptr();
+    DBUG_ASSERT(new_length < alloced_length());
+    length((uint32) new_length);
+    return false;
+  }
+  bool append(List<Create_field> &fields)
+  {
+    uint fieldnr= 0;
+    Create_field *field;
+    List_iterator<Create_field> it(fields);
+    for (field= it++; field; field= it++, fieldnr++)
+    {
+      if (append(fieldnr, *field))
+        return true; // Error
+    }
+    return false;
+  }
+};
+
+
+/**
+  Create a frm (table definition) file
+
+  @param thd                    Thread handler
+  @param table                  Name of table
+  @param create_info            create info parameters
+  @param create_fields          Fields to create
+  @param keys                   number of keys to create
+  @param key_info               Keys to create
+  @param db_file                Handler to use.
+
+  @return the generated frm image as a LEX_CUSTRING,
+  or null LEX_CUSTRING (str==0) in case of an error.
+*/
+
+LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING &table,
+                              HA_CREATE_INFO *create_info,
+                              List<Create_field> &create_fields,
+                              uint keys, KEY *key_info, handler *db_file)
+{
+  LEX_CSTRING str_db_type;
+  uint reclength, key_info_length, i;
+  ulong key_buff_length;
+  size_t filepos;
+  ulong data_offset;
+  uint options_len;
+  uint gis_extra2_len= 0;
+  size_t period_info_len= create_info->period_info.name
+                          ? extra2_str_size(create_info->period_info.name.length)
+                            + extra2_str_size(create_info->period_info.constr->name.length)
+                            + 2 * frm_fieldno_size
+                          : 0;
+  size_t without_overlaps_len= frm_keyno_size * (create_info->period_info.unique_keys + 1);
+  uint e_unique_hash_extra_parts= 0;
+  uchar fileinfo[FRM_HEADER_SIZE],forminfo[FRM_FORMINFO_SIZE];
+  const partition_info *part_info= IF_PARTITIONING(thd->work_part_info, 0);
+  bool error;
+  uchar *frm_ptr, *pos;
+  LEX_CUSTRING frm= {0,0};
+  StringBuffer<MAX_FIELD_WIDTH> vcols;
+  Field_data_type_info_image field_data_type_info_image;
+  DBUG_ENTER("build_frm_image");
+
+ /* 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;
+
+  error= pack_vcols(thd, &vcols,
+                    create_fields, create_info->check_constraint_list);
+
+  if (unlikely(error))
+    DBUG_RETURN(frm);
+
+  if (vcols.length())
+    create_info->expression_length= vcols.length() + FRM_VCOL_NEW_BASE_SIZE;
+
+  error= pack_header(thd, forminfo, create_fields, create_info,
+                     (ulong)data_offset, db_file);
+  if (unlikely(error))
+    DBUG_RETURN(frm);
+
+  reclength= uint2korr(forminfo+266);
+
+  /* Calculate extra data segment length */
+  str_db_type= *hton_name(create_info->db_type);
+  /* str_db_type */
+  create_info->extra_size= (uint)(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;
+  if (part_info)
+    create_info->extra_size+= (uint)part_info->part_info_len;
+
+  for (i= 0; i < keys; i++)
+  {
+    if (key_info[i].parser_name)
+      create_info->extra_size+= (uint)key_info[i].parser_name->length + 1;
+  }
+
+  options_len= engine_table_options_frm_length(create_info->option_list,
+                                               create_fields,
+                                               keys, key_info);
+  gis_extra2_len= gis_field_options_image(NULL, create_fields);
+  DBUG_PRINT("info", ("Options length: %u", options_len));
+
+  if (field_data_type_info_image.append(create_fields))
+  {
+    my_printf_error(ER_CANT_CREATE_TABLE,
+                    "Cannot create table %`s: "
+                    "Building the field data type info image failed.",
+                    MYF(0), table.str);
+    DBUG_RETURN(frm);
+  }
+  DBUG_PRINT("info", ("Field data type info length: %u",
+                      (uint) field_data_type_info_image.length()));
+  DBUG_EXECUTE_IF("frm_data_type_info",
+                  push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+                  ER_UNKNOWN_ERROR,
+                  "build_frm_image: Field data type info length: %u",
+                  (uint) field_data_type_info_image.length()););
+
+  if (validate_comment_length(thd, &create_info->comment, TABLE_COMMENT_MAXLEN,
+                              ER_TOO_LONG_TABLE_COMMENT, table.str))
+     DBUG_RETURN(frm);
+  /*
+    If table comment is longer than TABLE_COMMENT_INLINE_MAXLEN bytes,
+    store the comment in an extra segment (up to TABLE_COMMENT_MAXLEN bytes).
+    Pre 5.5, the limit was 60 characters, with no extra segment-handling.
+  */
+  if (create_info->comment.length > TABLE_COMMENT_INLINE_MAXLEN)
+  {
+    forminfo[46]=255;
+    create_info->extra_size+= 2 + (uint)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;
+  }
+
+  if (!create_info->tabledef_version.str)
+  {
+    uchar *to= (uchar*) thd->alloc(MY_UUID_SIZE);
+    if (unlikely(!to))
+      DBUG_RETURN(frm);
+    my_uuid(to);
+    create_info->tabledef_version.str= to;
+    create_info->tabledef_version.length= MY_UUID_SIZE;
+  }
+  DBUG_ASSERT(create_info->tabledef_version.length > 0);
+  DBUG_ASSERT(create_info->tabledef_version.length <= 255);
+
+  prepare_frm_header(thd, reclength, fileinfo, create_info, keys, key_info);
+
+  /* one byte for a type, one or three for a length */
+  size_t extra2_size= 1 + extra2_str_size(create_info->tabledef_version.length);
+  if (options_len)
+    extra2_size+= 1 + extra2_str_size(options_len);
+
+  if (part_info)
+    extra2_size+= 1 + extra2_str_size(hton_name(part_info->default_engine_type)->length);
+
+  if (gis_extra2_len)
+    extra2_size+= 1 + extra2_str_size(gis_extra2_len);
+
+  if (field_data_type_info_image.length())
+    extra2_size+= 1 + extra2_str_size(field_data_type_info_image.length());
+
+  if (create_info->versioned())
+  {
+    extra2_size+= 1 + extra2_str_size(2 * frm_fieldno_size);
+  }
+
+  if (create_info->period_info.name)
+  {
+    extra2_size+= 2 + extra2_str_size(period_info_len)
+                    + extra2_str_size(without_overlaps_len);
+  }
+
+  bool has_extra2_field_flags_= has_extra2_field_flags(create_fields);
+  if (has_extra2_field_flags_)
+  {
+    extra2_size+= 1 + extra2_str_size(create_fields.elements);
+  }
+
+  /*
+    To store the ignorability flag for each key.
+    Here 1 bytes is reserved to store the extra index flags for keys.
+    Currently only 1 bit is used, rest of the bits can be used in the future
+  */
+  if (keys)
+    extra2_size+= 1 + extra2_str_size(keys);
+
+  for (i= 0; i < keys; i++)
+    if (key_info[i].algorithm == HA_KEY_ALG_LONG_HASH)
+      e_unique_hash_extra_parts++;
+  key_buff_length= uint4korr(fileinfo+47);
+
+  frm.length= FRM_HEADER_SIZE;                  // fileinfo;
+  frm.length+= extra2_size + 4;                 // mariadb extra2 frm segment
+
+  int2store(fileinfo+4, extra2_size);
+  int2store(fileinfo+6, frm.length);            // Position to key information
+  frm.length+= key_buff_length;
+  frm.length+= reclength;                       // row with default values
+  frm.length+= create_info->extra_size;
+
+  filepos= frm.length;
+  frm.length+= FRM_FORMINFO_SIZE;               // forminfo
+  frm.length+= packed_fields_length(create_fields);
+  frm.length+= create_info->expression_length;
+
+  if (frm.length > FRM_MAX_SIZE ||
+      create_info->expression_length > UINT_MAX32)
+  {
+    my_error(ER_TABLE_DEFINITION_TOO_BIG, MYF(0), table.str);
+    DBUG_RETURN(frm);
+  }
+
+  frm_ptr= (uchar*) my_malloc(PSI_INSTRUMENT_ME, frm.length,
+                              MYF(MY_WME | MY_ZEROFILL | MY_THREAD_SPECIFIC));
+  if (!frm_ptr)
+    DBUG_RETURN(frm);
+
+  /* write the extra2 segment */
+  pos = frm_ptr + 64;
+  compile_time_assert(EXTRA2_TABLEDEF_VERSION != '/');
+  pos= extra2_write(pos, EXTRA2_TABLEDEF_VERSION,
+                    create_info->tabledef_version);
+
+  if (part_info)
+    pos= extra2_write(pos, EXTRA2_DEFAULT_PART_ENGINE,
+                      *hton_name(part_info->default_engine_type));
+
+  if (options_len)
+  {
+    *pos++= EXTRA2_ENGINE_TABLEOPTS;
+    pos= extra2_write_len(pos, options_len);
+    pos= engine_table_options_frm_image(pos, create_info->option_list,
+                                        create_fields, keys, key_info);
+  }
+
+  if (gis_extra2_len)
+  {
+    *pos= EXTRA2_GIS;
+    pos= extra2_write_len(pos+1, gis_extra2_len);
+    pos+= gis_field_options_image(pos, create_fields);
+  }
+
+  if (field_data_type_info_image.length())
+  {
+    if (field_data_type_info_image.length() > 0xFFFF)
+    {
+      my_printf_error(ER_CANT_CREATE_TABLE,
+                      "Cannot create table %`s: "
+                      "field data type info image is too large. "
+                      "Decrease the number of columns with "
+                      "extended data types.",
+                      MYF(0), table.str);
+      goto err;
+    }
+    *pos= EXTRA2_FIELD_DATA_TYPE_INFO;
+    pos= extra2_write_str(pos + 1, &field_data_type_info_image);
+  }
+
+  // PERIOD
+  if (create_info->period_info.is_set())
+  {
+    *pos++= EXTRA2_APPLICATION_TIME_PERIOD;
+    pos= extra2_write_len(pos, period_info_len);
+    pos= extra2_write_str(pos, create_info->period_info.name);
+    pos= extra2_write_str(pos, create_info->period_info.constr->name);
+
+    store_frm_fieldno(pos, get_fieldno_by_name(create_info, create_fields,
+                                       create_info->period_info.period.start));
+    pos+= frm_fieldno_size;
+    store_frm_fieldno(pos, get_fieldno_by_name(create_info, create_fields,
+                                       create_info->period_info.period.end));
+    pos+= frm_fieldno_size;
+
+    *pos++= EXTRA2_PERIOD_WITHOUT_OVERLAPS;
+    pos= extra2_write_len(pos, without_overlaps_len);
+    store_frm_keyno(pos, create_info->period_info.unique_keys);
+    pos+= frm_keyno_size;
+    for (uint key= 0; key < keys; key++)
+    {
+      if (key_info[key].without_overlaps)
+      {
+        store_frm_keyno(pos, key);
+        pos+= frm_keyno_size;
+      }
+    }
+  }
+
+  if (create_info->versioned())
+  {
+    *pos++= EXTRA2_PERIOD_FOR_SYSTEM_TIME;
+    *pos++= 2 * frm_fieldno_size;
+    store_frm_fieldno(pos, get_fieldno_by_name(create_info, create_fields,
+                                       create_info->vers_info.as_row.start));
+    pos+= frm_fieldno_size;
+    store_frm_fieldno(pos, get_fieldno_by_name(create_info, create_fields,
+                                       create_info->vers_info.as_row.end));
+    pos+= frm_fieldno_size;
+  }
+
+  if (has_extra2_field_flags_)
+    pos= extra2_write_field_properties(pos, create_fields);
+
+
+  if (keys)
+    pos= extra2_write_index_properties(pos, key_info, keys);
+
+  int4store(pos, filepos); // end of the extra2 segment
+  pos+= 4;
+
+  DBUG_ASSERT(pos == frm_ptr + uint2korr(fileinfo+6));
+  key_info_length= pack_keys(pos, keys, key_info, data_offset, e_unique_hash_extra_parts);
+  if (key_info_length > UINT_MAX16)
+  {
+    my_printf_error(ER_CANT_CREATE_TABLE,
+                    "Cannot create table %`s: index information is too long. "
+                    "Decrease number of indexes or use shorter index names or shorter comments.",
+                    MYF(0), table.str);
+    goto err;
+  }
+
+  int2store(forminfo+2, frm.length - filepos);
+  int4store(fileinfo+10, frm.length);
+  fileinfo[26]= (uchar) MY_TEST((create_info->max_rows == 1) &&
+                                (create_info->min_rows == 1) && (keys == 0));
+  int2store(fileinfo+28,key_info_length);
+
+  if (part_info)
+  {
+    fileinfo[61]= (uchar) ha_legacy_type(part_info->default_engine_type);
+    DBUG_PRINT("info", ("part_db_type = %d", fileinfo[61]));
+  }
+
+  memcpy(frm_ptr, fileinfo, FRM_HEADER_SIZE);
+
+  pos+= key_buff_length;
+  if (make_empty_rec(thd, pos, create_info->table_options, create_fields,
+                     reclength, data_offset))
+    goto err;
+
+  pos+= reclength;
+  int2store(pos, create_info->connect_string.length);
+  pos+= 2;
+  if (create_info->connect_string.length)
+    memcpy(pos, create_info->connect_string.str, create_info->connect_string.length);
+  pos+= create_info->connect_string.length;
+  int2store(pos, str_db_type.length);
+  pos+= 2;
+  memcpy(pos, str_db_type.str, str_db_type.length);
+  pos+= str_db_type.length;
+
+  if (part_info)
+  {
+    char auto_partitioned= part_info->is_auto_partitioned ? 1 : 0;
+    int4store(pos, part_info->part_info_len);
+    pos+= 4;
+    memcpy(pos, part_info->part_info_string, part_info->part_info_len + 1);
+    pos+= part_info->part_info_len + 1;
+    *pos++= auto_partitioned;
+  }
+  else
+  {
+    pos+= 6;
+  }
+
+  for (i= 0; i < keys; i++)
+  {
+    if (key_info[i].parser_name)
+    {
+      memcpy(pos, key_info[i].parser_name->str, key_info[i].parser_name->length + 1);
+      pos+= key_info[i].parser_name->length + 1;
+    }
+  }
+  if (forminfo[46] == (uchar)255)       // New style MySQL 5.5 table comment
+  {
+    int2store(pos, create_info->comment.length);
+    pos+=2;
+    memcpy(pos, create_info->comment.str, create_info->comment.length);
+    pos+= create_info->comment.length;
+  }
+
+  memcpy(frm_ptr + filepos, forminfo, FRM_FORMINFO_SIZE);
+  pos= frm_ptr + filepos + FRM_FORMINFO_SIZE;
+  if (pack_fields(&pos, create_fields, create_info, data_offset))
+    goto err;
+
+  if (vcols.length())
+  {
+    /* Store header for packed fields (extra space for future) */
+    bzero(pos, FRM_VCOL_NEW_BASE_SIZE);
+    pos+= FRM_VCOL_NEW_BASE_SIZE;
+    memcpy(pos, vcols.ptr(), vcols.length());
+    pos+= vcols.length();
+  }
+
+  {
+    /* 
+      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;
+      }
+    }
+  }
+
+  frm.str= frm_ptr;
+  DBUG_RETURN(frm);
+
+err:
+  my_free(frm_ptr);
+  DBUG_RETURN(frm);
+}
+
+
+/* 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 e_unique_hash_extra_parts)
+{
+  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->user_defined_key_parts;
+    pos[5]= (uchar) key->algorithm;
+    int2store(pos+6, key->block_size);
+    pos+=8;
+    key_parts+=key->user_defined_key_parts;
+    DBUG_PRINT("loop", ("flags: %lu  key_parts: %d  key_part: %p",
+                        key->flags, key->user_defined_key_parts,
+                        key->key_part));
+
+    /* For SPATIAL, FULLTEXT and HASH indexes (anything other than B-tree),
+       ignore the ASC/DESC attribute of columns. */
+    const uchar ha_reverse_sort=
+      key->algorithm > HA_KEY_ALG_BTREE || key->flags & (HA_FULLTEXT|HA_SPATIAL)
+      ? 0 : HA_REVERSE_SORT;
+
+    for (key_part=key->key_part,key_part_end=key_part+key->user_defined_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);
+      key_part->key_part_flag &= ha_reverse_sort;
+      pos[4]= (uchar)(key_part->key_part_flag);
+      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.str);
+    *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;
+    }
+  }
+
+  key_parts+= e_unique_hash_extra_parts;
+  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 */
+
+
+/**
+   Pack the expression (for GENERATED ALWAYS AS, DEFAULT, CHECK)
+
+   The data is stored as:
+   1 byte      type (enum_vcol_info_type)
+   2 bytes     field_number
+   2 bytes     length of expression
+   1 byte      length of name
+   name
+   next bytes  column expression (text data)
+
+   @return 0 ok
+   @return 1 error (out of memory or wrong characters in expression)
+*/
+
+static bool pack_expression(String *buf, Virtual_column_info *vcol,
+                            uint field_nr, enum_vcol_info_type type)
+{
+  if (buf->reserve(FRM_VCOL_NEW_HEADER_SIZE + vcol->name.length))
+    return 1;
+
+  buf->q_append((char) type);
+  buf->q_append2b(field_nr);
+  size_t len_off= buf->length();
+  buf->q_append2b(0); // to be added later
+  buf->q_append((char)vcol->name.length);
+  buf->q_append(&vcol->name);
+  size_t expr_start= buf->length();
+  vcol->print(buf);
+  size_t expr_len= buf->length() - expr_start;
+  if (expr_len >= 65536)
+  {
+    my_error(ER_EXPRESSION_IS_TOO_BIG, MYF(0), vcol_type_name(type));
+    return 1;
+  }
+  int2store(buf->ptr() + len_off, expr_len);
+  return 0;
+}
+
+
+static bool pack_vcols(THD *thd, String *buf, List<Create_field> &create_fields,
+                       List<Virtual_column_info> *check_constraint_list)
+{
+  Sql_mode_save_for_frm_handling sql_mode_save(thd);
+  List_iterator<Create_field> it(create_fields);
+  Create_field *field;
+
+  for (uint field_nr=0; (field= it++); field_nr++)
+  {
+    if (field->vcol_info && field->vcol_info->expr)
+      if (pack_expression(buf, field->vcol_info, field_nr,
+                          field->vcol_info->stored_in_db
+                          ? VCOL_GENERATED_STORED : VCOL_GENERATED_VIRTUAL))
+        return 1;
+    if (field->has_default_expression() && !field->has_default_now_unireg_check())
+      if (pack_expression(buf, field->default_value, field_nr, VCOL_DEFAULT))
+        return 1;
+    if (field->check_constraint)
+      if (pack_expression(buf, field->check_constraint, field_nr,
+                          VCOL_CHECK_FIELD))
+        return 1;
+  }
+
+  List_iterator<Virtual_column_info> cit(*check_constraint_list);
+  Virtual_column_info *check;
+  while ((check= cit++))
+    if (pack_expression(buf, check, UINT_MAX32, VCOL_CHECK_TABLE))
+      return 1;
+  return 0;
+}
+
+
+static uint typelib_values_packed_length(const TYPELIB *t)
+{
+  uint length= 0;
+  for (uint i= 0; t->type_names[i]; i++)
+  {
+    length+= t->type_lengths[i];
+    length++; /* Separator */
+  }
+  return length;
+}
+
+
+/* Make formheader */
+
+static bool pack_header(THD *thd, uchar *forminfo,
+                        List<Create_field> &create_fields,
+                        HA_CREATE_INFO *create_info, ulong data_offset,
+                        handler *file)
+{
+  uint int_count,int_length, int_parts;
+  uint time_stamp_pos,null_fields;
+  uint table_options= create_info->table_options;
+  size_t length, reclength, totlength, n_length, com_length;
+  DBUG_ENTER("pack_header");
+
+  if (create_fields.elements > MAX_FIELDS)
+  {
+    my_message(ER_TOO_MANY_FIELDS, ER_THD(thd, ER_TOO_MANY_FIELDS), MYF(0));
+    DBUG_RETURN(1);
+  }
+
+  totlength= 0L;
+  reclength= data_offset;
+  int_count=int_parts=int_length=time_stamp_pos=null_fields=0;
+  com_length= 0;
+  n_length=2L;
+  create_info->field_check_constraints= 0;
+
+  /* Check fields */
+  List_iterator<Create_field> it(create_fields);
+  Create_field *field;
+  while ((field=it++))
+  {
+    if (validate_comment_length(thd, &field->comment, COLUMN_COMMENT_MAXLEN,
+                                ER_TOO_LONG_FIELD_COMMENT,
+                                field->field_name.str))
+       DBUG_RETURN(1);
+
+    totlength+= (size_t)field->length;
+    com_length+= field->comment.length;
+    /*
+      We mark first TIMESTAMP field with NOW() in DEFAULT or ON UPDATE
+      as auto-update field.
+    */
+    if (field->real_field_type() == MYSQL_TYPE_TIMESTAMP &&
+        field->unireg_check != Field::NONE &&
+	!time_stamp_pos)
+      time_stamp_pos= (uint) field->offset+ (uint) data_offset + 1;
+    length=field->pack_length;
+    if ((uint) field->offset+ (uint) data_offset+ length > reclength)
+      reclength=(uint) (field->offset+ data_offset + length);
+    n_length+= field->field_name.length + 1;
+    field->interval_id=0;
+    field->save_interval= 0;
+    if (field->interval)
+    {
+      uint old_int_count=int_count;
+
+      if (field->charset->mbminlen > 1)
+      {
+        TYPELIB *tmpint;
+        /* 
+          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.
+        */
+        uint count= field->interval->count;
+        field->save_interval= field->interval;
+        field->interval= tmpint= (TYPELIB*) thd->alloc(sizeof(TYPELIB));
+        *tmpint= *field->save_interval;
+        tmpint->type_names=
+          (const char **) thd->alloc(sizeof(char*) *
+                                     (count + 1));
+        tmpint->type_lengths= (uint *) thd->alloc(sizeof(uint) * (count + 1));
+        tmpint->type_names[count]= 0;
+        tmpint->type_lengths[count]= 0;
+
+        for (uint pos= 0; pos < field->interval->count; pos++)
+        {
+          char *dst;
+          const char *src= field->save_interval->type_names[pos];
+          size_t hex_length;
+          length= field->save_interval->type_lengths[pos];
+          hex_length= length * 2;
+          tmpint->type_lengths[pos]= (uint) hex_length;
+          tmpint->type_names[pos]= dst= (char*) thd->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)
+      {
+        int_length+= typelib_values_packed_length(field->interval);
+        int_parts+= field->interval->count + 1;
+      }
+    }
+    if (f_maybe_null(field->pack_flag))
+      null_fields++;
+    if (field->check_constraint)
+      create_info->field_check_constraints++;
+  }
+  int_length+=int_count*2;			// 255 prefix + 0 suffix
+
+  /* Save values in forminfo */
+  if (reclength > (ulong) file->max_record_length())
+  {
+    my_error(ER_TOO_BIG_ROWSIZE, MYF(0), static_cast<long>(file->max_record_length()));
+    DBUG_RETURN(1);
+  }
+
+  /* Hack to avoid bugs with small static rows in MySQL */
+  reclength= MY_MAX(file->min_record_length(table_options), reclength);
+  length= n_length + create_fields.elements*FCOMP + FRM_FORMINFO_SIZE +
+          int_length + com_length + create_info->expression_length;
+  if (length > 65535L || int_count > 255)
+  {
+    my_message(ER_TOO_MANY_FIELDS, "Table definition is too large", MYF(0));
+    DBUG_RETURN(1);
+  }
+
+  bzero((char*)forminfo,FRM_FORMINFO_SIZE);
+  int2store(forminfo,length);
+  int2store(forminfo+258,create_fields.elements);
+  // bytes 260-261 are unused
+  int2store(forminfo+262,totlength);
+  // bytes 264-265 are unused
+  int2store(forminfo+266,reclength);
+  int2store(forminfo+268,n_length);
+  int2store(forminfo+270,int_count);
+  int2store(forminfo+272,int_parts);
+  int2store(forminfo+274,int_length);
+  int2store(forminfo+276,time_stamp_pos);
+  int2store(forminfo+278,80);			/* Columns needed */
+  int2store(forminfo+280,22);			/* Rows needed */
+  int2store(forminfo+282,null_fields);
+  int2store(forminfo+284,com_length);
+  int2store(forminfo+286,create_info->expression_length);
+  DBUG_RETURN(0);
+} /* pack_header */
+
+
+/* get each unique interval each own id */
+static uint get_interval_id(uint *int_count,List<Create_field> &create_fields,
+			    Create_field *last_field)
+{
+  List_iterator<Create_field> it(create_fields);
+  Create_field *field;
+  const TYPELIB *interval= last_field->interval;
+
+  while ((field=it++) != last_field)
+  {
+    /*
+      ENUM/SET columns with equal value lists share a single
+      copy of the underlying TYPELIB.
+      Fields with different mbminlen can't reuse TYPELIBs, because:
+      - mbminlen==1 are written to FRM as is
+      - mbminlen>1 are written to FRM in hex-encoded format
+    */
+    if (field->interval_id &&
+        field->interval->count == interval->count &&
+        field->charset->mbminlen == last_field->charset->mbminlen)
+    {
+      const char **a,**b;
+      for (a=field->interval->type_names, b=interval->type_names ;
+	   *a && !strcmp(*a,*b);
+	   a++,b++) ;
+
+      if (! *a)
+      {
+	return field->interval_id;		// Re-use last interval
+      }
+    }
+  }
+  return ++*int_count;				// New unique interval
+}
+
+
+static size_t packed_fields_length(List<Create_field> &create_fields)
+{
+  Create_field *field;
+  size_t length= 0;
+  DBUG_ENTER("packed_fields_length");
+
+  List_iterator<Create_field> it(create_fields);
+  uint int_count=0;
+  while ((field=it++))
+  {
+    if (field->interval_id > int_count)
+    {
+      int_count= field->interval_id;
+      length++;
+      length+= typelib_values_packed_length(field->interval);
+      length++;
+    }
+
+    length+= FCOMP;
+    length+= field->field_name.length + 1;
+    length+= field->comment.length;
+  }
+  length+= 2;
+  DBUG_RETURN(length);
+}
+
+/* Save fields, fieldnames and intervals */
+
+static bool pack_fields(uchar **buff_arg, List<Create_field> &create_fields,
+                        HA_CREATE_INFO *create_info,
+                        ulong data_offset)
+{
+  uchar *buff= *buff_arg;
+  uint int_count;
+  size_t comment_length= 0;
+  Create_field *field;
+  DBUG_ENTER("pack_fields");
+
+  /* Write field info */
+  List_iterator<Create_field> it(create_fields);
+  int_count=0;
+  while ((field=it++))
+  {
+    uint recpos;
+    /* The +1 is here becasue the col offset in .frm file have offset 1 */
+    recpos= field->offset+1 + (uint) data_offset;
+    int3store(buff+5,recpos);
+    buff[12]= (uchar) field->interval_id;
+    buff[13]= (uchar) field->type_handler()->real_field_type();
+    field->type_handler()->Column_definition_attributes_frm_pack(field, buff);
+    int2store(buff+15, field->comment.length);
+    comment_length+= field->comment.length;
+    set_if_bigger(int_count,field->interval_id);
+    buff+= FCOMP;
+  }
+
+  /* Write fieldnames */
+  *buff++= NAMES_SEP_CHAR;
+  it.rewind();
+  while ((field=it++))
+  {
+    buff= (uchar*)strmov((char*) buff, field->field_name.str);
+    *buff++=NAMES_SEP_CHAR;
+  }
+  *buff++= 0;
+
+  /* Write intervals */
+  if (int_count)
+  {
+    it.rewind();
+    int_count=0;
+    while ((field=it++))
+    {
+      if (field->interval_id > int_count)
+      {
+        unsigned char  sep= 0;
+        unsigned char  occ[256];
+        uint           i;
+        unsigned char *val= NULL;
+
+        bzero(occ, sizeof(occ));
+
+        for (i=0; (val= (unsigned char*) field->interval->type_names[i]); i++)
+          for (uint j = 0; j < field->interval->type_lengths[i]; j++)
+            occ[(unsigned int) (val[j])]= 1;
+
+        if (!occ[(unsigned char)NAMES_SEP_CHAR])
+          sep= (unsigned char) NAMES_SEP_CHAR;
+        else if (!occ[(unsigned int)','])
+          sep= ',';
+        else
+        {
+          for (uint i=1; i<256; i++)
+          {
+            if(!occ[i])
+            {
+              sep= i;
+              break;
+            }
+          }
+
+          if (!sep)
+          {
+            /* disaster, enum uses all characters, none left as separator */
+            my_message(ER_WRONG_FIELD_TERMINATORS,
+                       ER(ER_WRONG_FIELD_TERMINATORS),
+                       MYF(0));
+            DBUG_RETURN(1);
+          }
+        }
+
+        int_count= field->interval_id;
+        *buff++= sep;
+        for (int i=0; field->interval->type_names[i]; i++)
+        {
+          memcpy(buff, field->interval->type_names[i], field->interval->type_lengths[i]);
+          buff+= field->interval->type_lengths[i];
+          *buff++= sep;
+        }
+        *buff++= 0;
+      }
+    }
+  }
+  if (comment_length)
+  {
+    it.rewind();
+    while ((field=it++))
+    {
+      if (size_t l= field->comment.length)
+      {
+        memcpy(buff, field->comment.str, l);
+        buff+= l;
+      }
+    }
+  }
+  *buff_arg= buff;
+  DBUG_RETURN(0);
+}
+
+
+static bool make_empty_rec_store_default(THD *thd, Field *regfield,
+                                         Create_field *field)
+{
+  Virtual_column_info *default_value= field->default_value;
+  if (!field->vers_sys_field() && default_value && !default_value->flags)
+  {
+    Item *expr= default_value->expr;
+    // may be already fixed if ALTER TABLE
+    if (expr->fix_fields_if_needed(thd, &expr))
+      return true;
+    DBUG_ASSERT(expr == default_value->expr); // Should not change
+    if (regfield->make_empty_rec_store_default_value(thd, expr))
+    {
+      my_error(ER_INVALID_DEFAULT, MYF(0), regfield->field_name.str);
+      return true;
+    }
+    return false;
+  }
+  regfield->make_empty_rec_reset(thd);
+  return false;
+}
+
+
+/* save an empty record on start of formfile */
+
+static bool make_empty_rec(THD *thd, uchar *buff, uint table_options,
+			   List<Create_field> &create_fields,
+			   uint reclength, ulong data_offset)
+{
+  int error= false;
+  uint null_count;
+  uchar *null_pos;
+  TABLE table;
+  TABLE_SHARE share;
+  Create_field *field;
+  Check_level_instant_set old_count_cuted_fields(thd, CHECK_FIELD_WARN);
+  Abort_on_warning_instant_set old_abort_on_warning(thd, 0);
+  DBUG_ENTER("make_empty_rec");
+
+  /* We need a table to generate columns for default values */
+  bzero((char*) &table, sizeof(table));
+  bzero((char*) &share, sizeof(share));
+  table.s= &share;
+
+  table.in_use= thd;
+
+  null_count=0;
+  if (!(table_options & HA_OPTION_PACK_RECORD))
+  {
+    null_count++;			// Need one bit for delete mark
+    *buff|= 1;
+  }
+  null_pos= buff;
+
+  List_iterator<Create_field> it(create_fields);
+  while ((field=it++))
+  {
+    Record_addr addr(buff + field->offset + data_offset,
+                     null_pos + null_count / 8, null_count & 7);
+    Column_definition_attributes tmp(*field);
+    tmp.interval= field->save_interval ?
+                  field->save_interval : field->interval;
+    /* regfield don't have to be deleted as it's allocated on THD::mem_root */
+    Field *regfield= tmp.make_field(&share, thd->mem_root, &addr,
+                                    field->type_handler(),
+                                    &field->field_name,
+                                    field->flags);
+    if (!regfield)
+    {
+      error= true;
+      goto err;                                 // End of memory
+    }
+
+    /* save_in_field() will access regfield->table->in_use */
+    regfield->init(&table);
+
+    if (!(field->flags & NOT_NULL_FLAG))
+    {
+      *regfield->null_ptr|= regfield->null_bit;
+      null_count++;
+    }
+
+    if (field->real_field_type() == MYSQL_TYPE_BIT &&
+        !f_bit_as_char(field->pack_flag))
+      null_count+= field->length & 7;
+
+    error= make_empty_rec_store_default(thd, regfield, field);
+    delete regfield; // Avoid memory leaks
+    if (error)
+      goto err;
+  }
+  DBUG_ASSERT(data_offset == ((null_count + 7) / 8));
+
+  /*
+    We need to set the unused bits to 1. If the number of bits is a multiple
+    of 8 there are no unused bits.
+  */
+  if (null_count & 7)
+    *(null_pos + null_count / 8)|= ~(((uchar) 1 << (null_count & 7)) - 1);
+
+err:
+  DBUG_RETURN(error);
+} /* make_empty_rec */