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, 10579 insertions, 0 deletions

diff --git a/sql/table.cc b/sql/table.cc
new file mode 100644
index 00000000..b85d23b2
--- /dev/null
+++ b/sql/table.cc
@@ -0,0 +1,10579 @@
+/* Copyright (c) 2000, 2017, Oracle and/or its affiliates.
+   Copyright (c) 2008, 2022, MariaDB
+
+   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 Street, Fifth Floor, Boston, MA  02110-1335  USA */
+
+
+/* Some general useful functions */
+
+#include "mariadb.h"                 /* NO_EMBEDDED_ACCESS_CHECKS */
+#include "sql_priv.h"
+#include "table.h"
+#include "key.h"                                // find_ref_key
+#include "sql_table.h"                          // build_table_filename,
+                                                // primary_key_name
+#include "sql_parse.h"                          // free_items
+#include "strfunc.h"                            // unhex_type2
+#include "ha_partition.h"        // PART_EXT
+                                 // mysql_unpack_partition,
+                                 // fix_partition_func, partition_info
+#include "sql_base.h"
+#include "create_options.h"
+#include "sql_trigger.h"
+#include <m_ctype.h>
+#include "my_md5.h"
+#include "my_bit.h"
+#include "sql_select.h"
+#include "sql_derived.h"
+#include "sql_statistics.h"
+#include "discover.h"
+#include "mdl.h"                 // MDL_wait_for_graph_visitor
+#include "sql_view.h"
+#include "rpl_filter.h"
+#include "sql_cte.h"
+#include "ha_sequence.h"
+#include "sql_show.h"
+#include "opt_trace.h"
+#include "sql_db.h"              // get_default_db_collation
+#ifdef WITH_WSREP
+#include "wsrep_schema.h"
+#endif
+
+/* For MySQL 5.7 virtual fields */
+#define MYSQL57_GENERATED_FIELD 128
+#define MYSQL57_GCOL_HEADER_SIZE 4
+
+bool TABLE::init_expr_arena(MEM_ROOT *mem_root)
+{
+  /*
+    We need to use CONVENTIONAL_EXECUTION here to ensure that
+    any new items created by fix_fields() are not reverted.
+  */
+  expr_arena= new (alloc_root(mem_root, sizeof(Query_arena)))
+                Query_arena(mem_root, Query_arena::STMT_CONVENTIONAL_EXECUTION);
+  return expr_arena == NULL;
+}
+
+struct extra2_fields
+{
+  LEX_CUSTRING version;
+  LEX_CUSTRING options;
+  Lex_ident engine;
+  LEX_CUSTRING gis;
+  LEX_CUSTRING field_flags;
+  LEX_CUSTRING system_period;
+  LEX_CUSTRING application_period;
+  LEX_CUSTRING field_data_type_info;
+  LEX_CUSTRING without_overlaps;
+  LEX_CUSTRING index_flags;
+  void reset()
+  { bzero((void*)this, sizeof(*this)); }
+};
+
+static Virtual_column_info * unpack_vcol_info_from_frm(THD *,
+              TABLE *, String *, Virtual_column_info **, bool *);
+
+/* INFORMATION_SCHEMA name */
+LEX_CSTRING INFORMATION_SCHEMA_NAME= {STRING_WITH_LEN("information_schema")};
+
+/* PERFORMANCE_SCHEMA name */
+LEX_CSTRING PERFORMANCE_SCHEMA_DB_NAME= {STRING_WITH_LEN("performance_schema")};
+
+/* MYSQL_SCHEMA name */
+LEX_CSTRING MYSQL_SCHEMA_NAME= {STRING_WITH_LEN("mysql")};
+
+/* GENERAL_LOG name */
+LEX_CSTRING GENERAL_LOG_NAME= {STRING_WITH_LEN("general_log")};
+
+/* SLOW_LOG name */
+LEX_CSTRING SLOW_LOG_NAME= {STRING_WITH_LEN("slow_log")};
+
+LEX_CSTRING TRANSACTION_REG_NAME= {STRING_WITH_LEN("transaction_registry")};
+LEX_CSTRING MYSQL_PROC_NAME= {STRING_WITH_LEN("proc")};
+
+/* 
+  Keyword added as a prefix when parsing the defining expression for a
+  virtual column read from the column definition saved in the frm file
+*/
+static LEX_CSTRING parse_vcol_keyword= { STRING_WITH_LEN("PARSE_VCOL_EXPR ") };
+
+static std::atomic<ulong> last_table_id;
+
+	/* Functions defined in this file */
+
+static bool fix_type_pointers(const char ***typelib_value_names,
+                              uint **typelib_value_lengths,
+                              TYPELIB *point_to_type, uint types,
+                              char *names, size_t names_length);
+
+static field_index_t find_field(Field **fields, uchar *record, uint start,
+                                uint length);
+
+inline bool is_system_table_name(const char *name, size_t length);
+
+/**************************************************************************
+  Object_creation_ctx implementation.
+**************************************************************************/
+
+Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
+{
+  Object_creation_ctx *backup_ctx;
+  DBUG_ENTER("Object_creation_ctx::set_n_backup");
+
+  backup_ctx= create_backup_ctx(thd);
+  change_env(thd);
+
+  DBUG_RETURN(backup_ctx);
+}
+
+void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)
+{
+  if (!backup_ctx)
+    return;
+
+  backup_ctx->change_env(thd);
+
+  delete backup_ctx;
+}
+
+/**************************************************************************
+  Default_object_creation_ctx implementation.
+**************************************************************************/
+
+Default_object_creation_ctx::Default_object_creation_ctx(THD *thd)
+  : m_client_cs(thd->variables.character_set_client),
+    m_connection_cl(thd->variables.collation_connection)
+{ }
+
+Default_object_creation_ctx::Default_object_creation_ctx(
+  CHARSET_INFO *client_cs, CHARSET_INFO *connection_cl)
+  : m_client_cs(client_cs),
+    m_connection_cl(connection_cl)
+{ }
+
+Object_creation_ctx *
+Default_object_creation_ctx::create_backup_ctx(THD *thd) const
+{
+  return new Default_object_creation_ctx(thd);
+}
+
+void Default_object_creation_ctx::change_env(THD *thd) const
+{
+  thd->update_charset(m_client_cs, m_connection_cl);
+}
+
+/**************************************************************************
+  View_creation_ctx implementation.
+**************************************************************************/
+
+View_creation_ctx *View_creation_ctx::create(THD *thd)
+{
+  View_creation_ctx *ctx= new (thd->mem_root) View_creation_ctx(thd);
+
+  return ctx;
+}
+
+/*************************************************************************/
+
+View_creation_ctx * View_creation_ctx::create(THD *thd,
+                                              TABLE_LIST *view)
+{
+  View_creation_ctx *ctx= new (thd->mem_root) View_creation_ctx(thd);
+
+  /* Throw a warning if there is NULL cs name. */
+
+  if (!view->view_client_cs_name.str ||
+      !view->view_connection_cl_name.str)
+  {
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+                        ER_VIEW_NO_CREATION_CTX,
+                        ER_THD(thd, ER_VIEW_NO_CREATION_CTX),
+                        view->db.str,
+                        view->table_name.str);
+
+    ctx->m_client_cs= system_charset_info;
+    ctx->m_connection_cl= system_charset_info;
+
+    return ctx;
+  }
+
+  /* Resolve cs names. Throw a warning if there is unknown cs name. */
+
+  bool invalid_creation_ctx;
+  myf utf8_flag= thd->get_utf8_flag();
+  invalid_creation_ctx= resolve_charset(view->view_client_cs_name.str,
+                                        system_charset_info,
+                                        &ctx->m_client_cs, MYF(utf8_flag));
+
+  invalid_creation_ctx= resolve_collation(view->view_connection_cl_name.str,
+                                          system_charset_info,
+                                          &ctx->m_connection_cl, MYF(utf8_flag)) ||
+                        invalid_creation_ctx;
+
+  if (invalid_creation_ctx)
+  {
+    sql_print_warning("View '%s'.'%s': there is unknown charset/collation "
+                      "names (client: '%s'; connection: '%s').",
+                      view->db.str,
+                      view->table_name.str,
+                      (const char *) view->view_client_cs_name.str,
+                      (const char *) view->view_connection_cl_name.str);
+
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+                        ER_VIEW_INVALID_CREATION_CTX,
+                        ER_THD(thd, ER_VIEW_INVALID_CREATION_CTX),
+                        view->db.str,
+                        view->table_name.str);
+  }
+
+  return ctx;
+}
+
+/*************************************************************************/
+
+/* Get column name from column hash */
+
+static uchar *get_field_name(Field **buff, size_t *length,
+                             my_bool not_used __attribute__((unused)))
+{
+  *length= (uint) (*buff)->field_name.length;
+  return (uchar*) (*buff)->field_name.str;
+}
+
+
+/*
+  Returns pointer to '.frm' extension of the file name.
+
+  SYNOPSIS
+    fn_frm_ext()
+    name       file name
+
+  DESCRIPTION
+    Checks file name part starting with the rightmost '.' character,
+    and returns it if it is equal to '.frm'. 
+
+  RETURN VALUES
+    Pointer to the '.frm' extension or NULL if not a .frm file
+*/
+
+const char *fn_frm_ext(const char *name)
+{
+  const char *res= strrchr(name, '.');
+  if (res && !strcmp(res, reg_ext))
+    return res;
+  return 0;
+}
+
+
+TABLE_CATEGORY get_table_category(const LEX_CSTRING *db,
+                                  const LEX_CSTRING *name)
+{
+  DBUG_ASSERT(db != NULL);
+  DBUG_ASSERT(name != NULL);
+
+#ifdef WITH_WSREP
+  if (db->str &&
+      my_strcasecmp(system_charset_info, db->str, WSREP_SCHEMA) == 0)
+  {
+    if ((my_strcasecmp(system_charset_info, name->str, WSREP_STREAMING_TABLE) == 0 ||
+         my_strcasecmp(system_charset_info, name->str, WSREP_CLUSTER_TABLE) == 0 ||
+         my_strcasecmp(system_charset_info, name->str, WSREP_MEMBERS_TABLE) == 0))
+    {
+      return TABLE_CATEGORY_INFORMATION;
+    }
+  }
+#endif /* WITH_WSREP */
+  if (is_infoschema_db(db))
+    return TABLE_CATEGORY_INFORMATION;
+
+  if (is_perfschema_db(db))
+    return TABLE_CATEGORY_PERFORMANCE;
+
+  if (lex_string_eq(&MYSQL_SCHEMA_NAME, db))
+  {
+    if (is_system_table_name(name->str, name->length))
+      return TABLE_CATEGORY_SYSTEM;
+
+    if (lex_string_eq(&GENERAL_LOG_NAME, name))
+      return TABLE_CATEGORY_LOG;
+
+    if (lex_string_eq(&SLOW_LOG_NAME, name))
+      return TABLE_CATEGORY_LOG;
+
+    if (lex_string_eq(&TRANSACTION_REG_NAME, name))
+      return TABLE_CATEGORY_LOG;
+  }
+
+  return TABLE_CATEGORY_USER;
+}
+
+
+/*
+  Allocate and setup a TABLE_SHARE structure
+
+  SYNOPSIS
+    alloc_table_share()
+    db                  Database name
+    table_name          Table name
+    key			Table cache key (db \0 table_name \0...)
+    key_length		Length of key
+
+  RETURN
+    0  Error (out of memory)
+    #  Share
+*/
+
+TABLE_SHARE *alloc_table_share(const char *db, const char *table_name,
+                               const char *key, uint key_length)
+{
+  MEM_ROOT mem_root;
+  TABLE_SHARE *share;
+  char *key_buff, *path_buff;
+  char path[FN_REFLEN];
+  uint path_length;
+  DBUG_ENTER("alloc_table_share");
+  DBUG_PRINT("enter", ("table: '%s'.'%s'", db, table_name));
+
+  path_length= build_table_filename(path, sizeof(path) - 1,
+                                    db, table_name, "", 0);
+  init_sql_alloc(key_memory_table_share, &mem_root, TABLE_ALLOC_BLOCK_SIZE, 0,
+                 MYF(0));
+  if (multi_alloc_root(&mem_root,
+                       &share, sizeof(*share),
+                       &key_buff, key_length,
+                       &path_buff, path_length + 1,
+                       NULL))
+  {
+    bzero((char*) share, sizeof(*share));
+
+    share->set_table_cache_key(key_buff, key, key_length);
+
+    share->path.str= path_buff;
+    share->path.length= path_length;
+    strmov(path_buff, path);
+    share->normalized_path.str=    share->path.str;
+    share->normalized_path.length= path_length;
+    share->table_category= get_table_category(& share->db, & share->table_name);
+    share->open_errno= ENOENT;
+    /* The following will be updated in open_table_from_share */
+    share->can_do_row_logging= 1;
+    if (share->table_category == TABLE_CATEGORY_LOG)
+      share->no_replicate= 1;
+    if (key_length > 6 &&
+        table_alias_charset->strnncoll(key, 6, "mysql", 6) == 0)
+      share->not_usable_by_query_cache= 1;
+
+    memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
+    mysql_mutex_init(key_TABLE_SHARE_LOCK_share,
+                     &share->LOCK_share, MY_MUTEX_INIT_SLOW);
+    mysql_mutex_init(key_TABLE_SHARE_LOCK_ha_data,
+                     &share->LOCK_ha_data, MY_MUTEX_INIT_FAST);
+    mysql_mutex_init(key_TABLE_SHARE_LOCK_statistics,
+                     &share->LOCK_statistics, MY_MUTEX_INIT_SLOW);
+
+    DBUG_EXECUTE_IF("simulate_big_table_id",
+                    if (last_table_id < UINT_MAX32)
+                      last_table_id= UINT_MAX32 - 1;);
+    /*
+      There is one reserved number that cannot be used. Remember to
+      change this when 6-byte global table id's are introduced.
+    */
+    do
+    {
+      share->table_map_id=
+        last_table_id.fetch_add(1, std::memory_order_relaxed);
+    } while (unlikely(share->table_map_id == ~0UL ||
+                      share->table_map_id == 0));
+  }
+  DBUG_RETURN(share);
+}
+
+
+/*
+  Initialize share for temporary tables
+
+  SYNOPSIS
+    init_tmp_table_share()
+    thd         thread handle
+    share	Share to fill
+    key		Table_cache_key, as generated from tdc_create_key.
+		must start with db name.
+    key_length	Length of key
+    table_name	Table name
+    path	Path to file (possible in lower case) without .frm
+
+  NOTES
+    This is different from alloc_table_share() because temporary tables
+    don't have to be shared between threads or put into the table def
+    cache, so we can do some things notable simpler and faster
+
+    If table is not put in thd->temporary_tables (happens only when
+    one uses OPEN TEMPORARY) then one can specify 'db' as key and
+    use key_length= 0 as neither table_cache_key or key_length will be used).
+*/
+
+void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
+                          uint key_length, const char *table_name,
+                          const char *path)
+{
+  DBUG_ENTER("init_tmp_table_share");
+  DBUG_PRINT("enter", ("table: '%s'.'%s'", key, table_name));
+
+  bzero((char*) share, sizeof(*share));
+  /*
+    This can't be MY_THREAD_SPECIFIC for slaves as they are freed
+    during cleanup() from Relay_log_info::close_temporary_tables()
+  */
+  init_sql_alloc(key_memory_table_share, &share->mem_root,
+                 TABLE_ALLOC_BLOCK_SIZE, 0,
+                 MYF(thd->slave_thread ? 0 : MY_THREAD_SPECIFIC));
+  share->table_category=         TABLE_CATEGORY_TEMPORARY;
+  share->tmp_table=              INTERNAL_TMP_TABLE;
+  share->db.str=                 (char*) key;
+  share->db.length=		 strlen(key);
+  share->table_cache_key.str=    (char*) key;
+  share->table_cache_key.length= key_length;
+  share->table_name.str=         (char*) table_name;
+  share->table_name.length=      strlen(table_name);
+  share->path.str=               (char*) path;
+  share->normalized_path.str=    (char*) path;
+  share->path.length= share->normalized_path.length= strlen(path);
+  share->frm_version= 		 FRM_VER_CURRENT;
+  share->not_usable_by_query_cache= 1;
+  share->can_do_row_logging= 0;           // No row logging
+
+  /*
+    table_map_id is also used for MERGE tables to suppress repeated
+    compatibility checks.
+  */
+  share->table_map_id= (ulong) thd->query_id;
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Release resources (plugins) used by the share and free its memory.
+  TABLE_SHARE is self-contained -- it's stored in its own MEM_ROOT.
+  Free this MEM_ROOT.
+*/
+
+void TABLE_SHARE::destroy()
+{
+  uint idx;
+  KEY *info_it;
+  DBUG_ENTER("TABLE_SHARE::destroy");
+  DBUG_PRINT("info", ("db: %s table: %s", db.str, table_name.str));
+
+  if (ha_share)
+  {
+    delete ha_share;
+    ha_share= NULL;                             // Safety
+  }
+
+  if (stats_cb)
+  {
+    stats_cb->usage_count--;
+    delete stats_cb;
+  }
+  delete sequence;
+
+  /* The mutexes are initialized only for shares that are part of the TDC */
+  if (tmp_table == NO_TMP_TABLE)
+  {
+    mysql_mutex_destroy(&LOCK_share);
+    mysql_mutex_destroy(&LOCK_ha_data);
+    mysql_mutex_destroy(&LOCK_statistics);
+  }
+  my_hash_free(&name_hash);
+
+  plugin_unlock(NULL, db_plugin);
+  db_plugin= NULL;
+
+  /* Release fulltext parsers */
+  info_it= key_info;
+  for (idx= keys; idx; idx--, info_it++)
+  {
+    if (info_it->flags & HA_USES_PARSER)
+    {
+      plugin_unlock(NULL, info_it->parser);
+      info_it->flags= 0;
+    }
+  }
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  plugin_unlock(NULL, default_part_plugin);
+#endif /* WITH_PARTITION_STORAGE_ENGINE */
+
+  PSI_CALL_release_table_share(m_psi);
+
+  /*
+    Make a copy since the share is allocated in its own root,
+    and free_root() updates its argument after freeing the memory.
+  */
+  MEM_ROOT own_root= mem_root;
+  free_root(&own_root, MYF(0));
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Free table share and memory used by it
+
+  SYNOPSIS
+    free_table_share()
+    share		Table share
+*/
+
+void free_table_share(TABLE_SHARE *share)
+{
+  DBUG_ENTER("free_table_share");
+  DBUG_PRINT("enter", ("table: %s.%s", share->db.str, share->table_name.str));
+  share->destroy();
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Return TRUE if a table name matches one of the system table names.
+  Currently these are:
+
+  help_category, help_keyword, help_relation, help_topic,
+  proc, event
+  time_zone, time_zone_leap_second, time_zone_name, time_zone_transition,
+  time_zone_transition_type
+
+  This function trades accuracy for speed, so may return false
+  positives. Presumably mysql.* database is for internal purposes only
+  and should not contain user tables.
+*/
+
+inline bool is_system_table_name(const char *name, size_t length)
+{
+  CHARSET_INFO *ci= system_charset_info;
+
+  return (
+          /* mysql.proc table */
+          (length == 4 &&
+           my_tolower(ci, name[0]) == 'p' && 
+           my_tolower(ci, name[1]) == 'r' &&
+           my_tolower(ci, name[2]) == 'o' &&
+           my_tolower(ci, name[3]) == 'c') ||
+
+          (length > 4 &&
+           (
+            /* one of mysql.help* tables */
+            (my_tolower(ci, name[0]) == 'h' &&
+             my_tolower(ci, name[1]) == 'e' &&
+             my_tolower(ci, name[2]) == 'l' &&
+             my_tolower(ci, name[3]) == 'p') ||
+
+            /* one of mysql.time_zone* tables */
+            (my_tolower(ci, name[0]) == 't' &&
+             my_tolower(ci, name[1]) == 'i' &&
+             my_tolower(ci, name[2]) == 'm' &&
+             my_tolower(ci, name[3]) == 'e') ||
+
+            /* one of mysql.*_stat tables, but not mysql.innodb* tables*/
+            ((my_tolower(ci, name[length-5]) == 's' &&
+              my_tolower(ci, name[length-4]) == 't' &&
+              my_tolower(ci, name[length-3]) == 'a' &&
+              my_tolower(ci, name[length-2]) == 't' &&
+              my_tolower(ci, name[length-1]) == 's') &&
+             !(my_tolower(ci, name[0]) == 'i' &&
+               my_tolower(ci, name[1]) == 'n' &&
+               my_tolower(ci, name[2]) == 'n' &&
+               my_tolower(ci, name[3]) == 'o')) ||
+
+            /* mysql.event table */
+            (my_tolower(ci, name[0]) == 'e' &&
+             my_tolower(ci, name[1]) == 'v' &&
+             my_tolower(ci, name[2]) == 'e' &&
+             my_tolower(ci, name[3]) == 'n' &&
+             my_tolower(ci, name[4]) == 't')
+            )
+           )
+         );
+}
+
+
+/*
+  Read table definition from a binary / text based .frm file
+  
+  SYNOPSIS
+  open_table_def()
+  thd		  Thread handler
+  share		Fill this with table definition
+  flags	  Bit mask of the following flags: OPEN_VIEW
+
+  NOTES
+    This function is called when the table definition is not cached in
+    table definition cache
+    The data is returned in 'share', which is allocated by
+    alloc_table_share().. The code assumes that share is initialized.
+*/
+
+enum open_frm_error open_table_def(THD *thd, TABLE_SHARE *share, uint flags)
+{
+  bool error_given= false;
+  File file;
+  uchar *buf;
+  uchar head[FRM_HEADER_SIZE];
+  char	path[FN_REFLEN];
+  size_t frmlen, read_length;
+  uint length;
+  DBUG_ENTER("open_table_def");
+  DBUG_PRINT("enter", ("table: '%s'.'%s'  path: '%s'", share->db.str,
+                       share->table_name.str, share->normalized_path.str));
+
+  share->error= OPEN_FRM_OPEN_ERROR;
+
+  length=(uint) (strxmov(path, share->normalized_path.str, reg_ext, NullS) -
+                 path);
+  if (flags & GTS_FORCE_DISCOVERY)
+  {
+    const char *path2= share->normalized_path.str;
+    DBUG_ASSERT(flags & GTS_TABLE);
+    DBUG_ASSERT(flags & GTS_USE_DISCOVERY);
+    /* Delete .frm and .par files */
+    mysql_file_delete_with_symlink(key_file_frm, path2, reg_ext, MYF(0));
+    mysql_file_delete_with_symlink(key_file_partition_ddl_log, path2, PAR_EXT,
+                                   MYF(0));
+    file= -1;
+  }
+  else
+    file= mysql_file_open(key_file_frm, path, O_RDONLY | O_SHARE, MYF(0));
+
+  if (file < 0)
+  {
+    if ((flags & GTS_TABLE) && (flags & GTS_USE_DISCOVERY))
+    {
+      ha_discover_table(thd, share);
+      error_given= true;
+    }
+    goto err_not_open;
+  }
+
+  if (mysql_file_read(file, head, sizeof(head), MYF(MY_NABP)))
+  {
+    share->error = my_errno == HA_ERR_FILE_TOO_SHORT
+                      ? OPEN_FRM_CORRUPTED : OPEN_FRM_READ_ERROR;
+    goto err;
+  }
+
+  if (memcmp(head, STRING_WITH_LEN("TYPE=VIEW\n")) == 0)
+  {
+    share->is_view= 1;
+    if (flags & GTS_VIEW)
+    {
+      LEX_CSTRING pathstr= { path, length };
+      /*
+        Create view file parser and hold it in TABLE_SHARE member
+        view_def.
+      */
+      share->view_def= sql_parse_prepare(&pathstr, &share->mem_root, true);
+      if (!share->view_def)
+        share->error= OPEN_FRM_ERROR_ALREADY_ISSUED;
+      else
+      {
+        share->error= OPEN_FRM_OK;
+        if (mariadb_view_version_get(share))
+          share->error= OPEN_FRM_ERROR_ALREADY_ISSUED;
+      }
+    }
+    else
+      share->error= OPEN_FRM_NOT_A_TABLE;
+    goto err;
+  }
+  if (!is_binary_frm_header(head))
+  {
+    /* No handling of text based files yet */
+    share->error = OPEN_FRM_CORRUPTED;
+    goto err;
+  }
+  if (!(flags & GTS_TABLE))
+  {
+    share->error = OPEN_FRM_NOT_A_VIEW;
+    goto err;
+  }
+
+  frmlen= uint4korr(head+10);
+  set_if_smaller(frmlen, FRM_MAX_SIZE); // safety
+
+  if (!(buf= (uchar*)my_malloc(PSI_INSTRUMENT_ME, frmlen,
+                               MYF(MY_THREAD_SPECIFIC|MY_WME))))
+    goto err;
+
+  memcpy(buf, head, sizeof(head));
+
+  read_length= mysql_file_read(file, buf + sizeof(head),
+                               frmlen - sizeof(head), MYF(MY_WME));
+  if (read_length == 0 || read_length == (size_t)-1)
+  {
+    share->error = OPEN_FRM_READ_ERROR;
+    my_free(buf);
+    goto err;
+  }
+  mysql_file_close(file, MYF(MY_WME));
+
+  frmlen= read_length + sizeof(head);
+
+  share->init_from_binary_frm_image(thd, false, buf, frmlen);
+  /*
+    Don't give any additional errors. If there would be a problem,
+    init_from_binary_frm_image would call my_error() itself.
+  */
+  error_given= true;
+  my_free(buf);
+
+  goto err_not_open;
+
+err:
+  mysql_file_close(file, MYF(MY_WME));
+
+err_not_open:
+  /* Mark that table was created earlier and thus should have been logged */
+  share->table_creation_was_logged= 1;
+
+  if (unlikely(share->error && !error_given))
+  {
+    share->open_errno= my_errno;
+    open_table_error(share, share->error, share->open_errno);
+  }
+
+  DBUG_RETURN(share->error);
+}
+
+static bool create_key_infos(const uchar *strpos, const uchar *frm_image_end,
+                             uint keys, KEY *keyinfo,
+                             uint new_frm_ver, uint *ext_key_parts,
+                             TABLE_SHARE *share, uint len,
+                             KEY *first_keyinfo,
+                             LEX_STRING *keynames)
+{
+  uint i, j, n_length;
+  KEY_PART_INFO *key_part= NULL;
+  ulong *rec_per_key= NULL;
+  KEY_PART_INFO *first_key_part= NULL;
+  uint first_key_parts= 0;
+
+  if (!keys)
+  {  
+    if (!(keyinfo = (KEY*) alloc_root(&share->mem_root, len)))
+      return 1;
+    bzero((char*) keyinfo, len);
+    key_part= reinterpret_cast<KEY_PART_INFO*> (keyinfo);
+  }
+
+  /*
+    If share->use_ext_keys is set to TRUE we assume that any key
+    can be extended by the components of the primary key whose
+    definition is read first from the frm file.
+    For each key only those fields of the assumed primary key are
+    added that are not included in the proper key definition. 
+    If after all it turns out that there is no primary key the
+    added components are removed from each key.
+
+    When in the future we support others schemes of extending of
+    secondary keys with components of the primary key we'll have
+    to change the type of this flag for an enumeration type.
+  */
+
+  for (i=0 ; i < keys ; i++, keyinfo++)
+  {
+    if (new_frm_ver >= 3)
+    {
+      if (strpos + 8 >= frm_image_end)
+        return 1;
+      keyinfo->flags=	   (uint) uint2korr(strpos) ^ HA_NOSAME;
+      keyinfo->key_length= (uint) uint2korr(strpos+2);
+      keyinfo->user_defined_key_parts=  (uint) strpos[4];
+      keyinfo->algorithm=  (enum ha_key_alg) strpos[5];
+      keyinfo->block_size= uint2korr(strpos+6);
+      strpos+=8;
+    }
+    else
+    {
+      if (strpos + 4 >= frm_image_end)
+        return 1;
+      keyinfo->flags=	 ((uint) strpos[0]) ^ HA_NOSAME;
+      keyinfo->key_length= (uint) uint2korr(strpos+1);
+      keyinfo->user_defined_key_parts=  (uint) strpos[3];
+      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
+      strpos+=4;
+    }
+
+    if (i == 0)
+    {
+      (*ext_key_parts)+= (share->use_ext_keys ? first_keyinfo->user_defined_key_parts*(keys-1) : 0); 
+      n_length=keys * sizeof(KEY) + *ext_key_parts * sizeof(KEY_PART_INFO);
+      if (!(keyinfo= (KEY*) alloc_root(&share->mem_root,
+				       n_length + len)))
+        return 1;
+      bzero((char*) keyinfo,n_length);
+      share->key_info= keyinfo;
+      key_part= reinterpret_cast<KEY_PART_INFO*> (keyinfo + keys);
+
+      if (!(rec_per_key= (ulong*) alloc_root(&share->mem_root,
+                                             sizeof(ulong) * *ext_key_parts)))
+        return 1;
+      first_key_part= key_part;
+      first_key_parts= first_keyinfo->user_defined_key_parts;
+      keyinfo->flags= first_keyinfo->flags;
+      keyinfo->key_length= first_keyinfo->key_length;
+      keyinfo->user_defined_key_parts= first_keyinfo->user_defined_key_parts;
+      keyinfo->algorithm= first_keyinfo->algorithm;
+      if (new_frm_ver >= 3)
+        keyinfo->block_size= first_keyinfo->block_size;
+    }
+
+    keyinfo->key_part=	 key_part;
+    keyinfo->rec_per_key= rec_per_key;
+    for (j=keyinfo->user_defined_key_parts ; j-- ; key_part++)
+    {
+      if (strpos + (new_frm_ver >= 1 ? 9 : 7) >= frm_image_end)
+        return 1;
+      if (!(keyinfo->algorithm == HA_KEY_ALG_LONG_HASH))
+        *rec_per_key++=0;
+      key_part->fieldnr=	(uint16) (uint2korr(strpos) & FIELD_NR_MASK);
+      key_part->offset= (uint) uint2korr(strpos+2)-1;
+      key_part->key_type=	(uint) uint2korr(strpos+5);
+      // key_part->field=	(Field*) 0;	// Will be fixed later
+      if (new_frm_ver >= 1)
+      {
+	key_part->key_part_flag= *(strpos+4);
+	key_part->length=	(uint) uint2korr(strpos+7);
+	strpos+=9;
+      }
+      else
+      {
+	key_part->length=	*(strpos+4);
+	key_part->key_part_flag=0;
+	if (key_part->length > 128)
+	{
+	  key_part->length&=127;		/* purecov: inspected */
+	  key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */
+	}
+	strpos+=7;
+      }
+      key_part->store_length=key_part->length;
+    }
+    if (keyinfo->algorithm == HA_KEY_ALG_LONG_HASH)
+    {
+      keyinfo->key_length= HA_HASH_KEY_LENGTH_WITHOUT_NULL;
+      key_part++; // reserved for the hash value
+      *rec_per_key++=0;
+    }
+
+    /*
+      Add primary key to end of extended keys for non unique keys for
+      storage engines that supports it.
+    */
+    keyinfo->ext_key_parts= keyinfo->user_defined_key_parts;
+    keyinfo->ext_key_flags= keyinfo->flags;
+    keyinfo->ext_key_part_map= 0;
+    if (share->use_ext_keys && i && !(keyinfo->flags & HA_NOSAME))
+    {
+      for (j= 0; 
+           j < first_key_parts && keyinfo->ext_key_parts < MAX_REF_PARTS;
+           j++)
+      {
+        uint key_parts= keyinfo->user_defined_key_parts;
+        KEY_PART_INFO* curr_key_part= keyinfo->key_part;
+        KEY_PART_INFO* curr_key_part_end= curr_key_part+key_parts;
+        for ( ; curr_key_part < curr_key_part_end; curr_key_part++)
+        {
+          if (curr_key_part->fieldnr == first_key_part[j].fieldnr)
+            break;
+        }
+        if (curr_key_part == curr_key_part_end)
+        {
+          *key_part++= first_key_part[j];
+          *rec_per_key++= 0;
+          keyinfo->ext_key_parts++;
+          keyinfo->ext_key_part_map|= 1 << j;
+        }
+      }
+      if (j == first_key_parts)
+        keyinfo->ext_key_flags= keyinfo->flags | HA_EXT_NOSAME;
+    }
+    if (keyinfo->algorithm == HA_KEY_ALG_LONG_HASH)
+      share->ext_key_parts++;
+    share->ext_key_parts+= keyinfo->ext_key_parts;
+  }
+  keynames->str= (char*) key_part;
+  keynames->length= strnmov(keynames->str, (char *) strpos,
+                            frm_image_end - strpos) - keynames->str;
+  strpos+= keynames->length;
+  if (*strpos++) // key names are \0-terminated
+    return 1;
+  keynames->length++; // Include '\0', to make fix_type_pointers() happy.
+
+  //reading index comments
+  for (keyinfo= share->key_info, i=0; i < keys; i++, keyinfo++)
+  {
+    if (keyinfo->flags & HA_USES_COMMENT)
+    {
+      if (strpos + 2 >= frm_image_end)
+        return 1;
+      keyinfo->comment.length= uint2korr(strpos);
+      strpos+= 2;
+
+      if (strpos + keyinfo->comment.length >= frm_image_end)
+        return 1;
+      keyinfo->comment.str= strmake_root(&share->mem_root, (char*) strpos,
+                                         keyinfo->comment.length);
+      strpos+= keyinfo->comment.length;
+    } 
+    DBUG_ASSERT(MY_TEST(keyinfo->flags & HA_USES_COMMENT) ==
+                (keyinfo->comment.length > 0));
+  }
+
+  share->keys= keys; // do it *after* all key_info's are initialized
+
+  return 0;
+}
+
+
+/** ensures that the enum value (read from frm) is within limits
+
+    if not - issues a warning and resets the value to 0
+    (that is, 0 is assumed to be a default value)
+*/
+
+static uint enum_value_with_check(THD *thd, TABLE_SHARE *share,
+                                  const char *name, uint value, uint limit)
+{
+  if (value < limit)
+    return value;
+
+  sql_print_warning("%s.frm: invalid value %d for the field %s",
+                share->normalized_path.str, value, name);
+  return 0;
+}
+
+
+void Column_definition_attributes::frm_pack_basic(uchar *buff) const
+{
+  int2store(buff + 3, length);
+  int2store(buff + 8, pack_flag);
+  buff[10]= (uchar) unireg_check;
+}
+
+
+void Column_definition_attributes::frm_unpack_basic(const uchar *buff)
+{
+  length=       uint2korr(buff + 3);
+  pack_flag=    uint2korr(buff + 8);
+  unireg_check= (Field::utype) MTYP_TYPENR((uint) buff[10]);
+}
+
+
+void Column_definition_attributes::frm_pack_numeric_with_dec(uchar *buff) const
+{
+  DBUG_ASSERT(f_decimals(pack_flag) == 0);
+  uint tmp_pack_flag= pack_flag | (decimals << FIELDFLAG_DEC_SHIFT);
+  int2store(buff + 3, length);
+  int2store(buff + 8, tmp_pack_flag);
+  buff[10]= (uchar) unireg_check;
+}
+
+
+bool
+Column_definition_attributes::frm_unpack_numeric_with_dec(TABLE_SHARE *share,
+                                                          const uchar *buff)
+{
+  frm_unpack_basic(buff);
+  decimals= f_decimals(pack_flag);
+  pack_flag&= ~FIELDFLAG_DEC_MASK;
+  return frm_unpack_charset(share, buff);
+}
+
+
+bool
+Column_definition_attributes::frm_unpack_temporal_with_dec(TABLE_SHARE *share,
+                                                           uint intlen,
+                                                           const uchar *buff)
+{
+  frm_unpack_basic(buff);
+  decimals= temporal_dec(intlen);
+  return frm_unpack_charset(share, buff);
+}
+
+
+void Column_definition_attributes::frm_pack_charset(uchar *buff) const
+{
+  buff[11]= (uchar) (charset->number >> 8);
+  buff[14]= (uchar) charset->number;
+}
+
+
+bool Column_definition_attributes::frm_unpack_charset(TABLE_SHARE *share,
+                                                      const uchar *buff)
+{
+  uint cs_org= buff[14] + (((uint) buff[11]) << 8);
+  uint cs_new= Charset::upgrade_collation_id(share->mysql_version, cs_org);
+  if (cs_org != cs_new)
+    share->incompatible_version|= HA_CREATE_USED_CHARSET;
+  if (cs_new && !(charset= get_charset(cs_new, MYF(0))))
+  {
+    const char *csname= get_charset_name((uint) cs_new);
+    char tmp[10];
+    if (!csname || csname[0] =='?')
+    {
+      my_snprintf(tmp, sizeof(tmp), "#%u", cs_new);
+      csname= tmp;
+    }
+    my_printf_error(ER_UNKNOWN_COLLATION,
+                    "Unknown collation '%s' in table '%-.64s' definition",
+                    MYF(0), csname, share->table_name.str);
+    return true;
+  }
+  return false;
+}
+
+
+/*
+  In MySQL 5.7 the null bits for not stored virtual fields are last.
+  Calculate the position for these bits
+*/
+
+static void mysql57_calculate_null_position(TABLE_SHARE *share,
+                                            uchar **null_pos,
+                                            uint *null_bit_pos,
+                                            const uchar *strpos,
+                                            const uchar *vcol_screen_pos)
+{
+  uint field_pack_length= 17;
+
+  for (uint i=0 ; i < share->fields; i++, strpos+= field_pack_length)
+  {
+    uint field_length, pack_flag;
+    enum_field_types field_type;
+
+    if ((strpos[10] & MYSQL57_GENERATED_FIELD))
+    {
+      /* Skip virtual (not stored) generated field */
+      bool stored_in_db= vcol_screen_pos[3];
+      vcol_screen_pos+= (uint2korr(vcol_screen_pos + 1) +
+                         MYSQL57_GCOL_HEADER_SIZE);
+      if (! stored_in_db)
+        continue;
+    }
+    field_length= uint2korr(strpos+3);
+    pack_flag=    uint2korr(strpos+8);
+    field_type=   (enum_field_types) (uint) strpos[13];
+    if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
+    {
+      if (((*null_bit_pos)+= field_length & 7) > 7)
+      {
+        (*null_pos)++;
+        (*null_bit_pos)-= 8;
+      }
+    }
+    if (f_maybe_null(pack_flag))
+    {
+      if (!((*null_bit_pos)= ((*null_bit_pos) + 1) & 7))
+        (*null_pos)++;
+    }
+  }
+}
+
+
+Item_func_hash *TABLE_SHARE::make_long_hash_func(THD *thd,
+                                                 MEM_ROOT *mem_root,
+                                                 List<Item> *field_list)
+                                                 const
+{
+  if (old_long_hash_function())
+    return new (mem_root) Item_func_hash_mariadb_100403(thd, *field_list);
+  return new (mem_root) Item_func_hash(thd, *field_list);
+}
+
+
+/** Parse TABLE_SHARE::vcol_defs
+
+  unpack_vcol_info_from_frm
+  5.7
+    byte 1      = 1
+    byte 2,3    = expr length
+    byte 4      = stored_in_db
+    expression
+  10.1-
+    byte 1     = 1 | 2
+    byte 2     = sql_type       ; but  TABLE::init_from_binary_frm_image()
+    byte 3     = stored_in_db   ; has put expr_length here
+    [byte 4]   = optional interval_id for sql_type (if byte 1 == 2)
+    expression
+  10.2+
+    byte 1     = type
+    byte 2,3   = field_number
+    byte 4,5   = length of expression
+    byte 6     = length of name
+    name
+    expression
+*/
+bool parse_vcol_defs(THD *thd, MEM_ROOT *mem_root, TABLE *table,
+                     bool *error_reported, vcol_init_mode mode)
+{
+  struct check_vcol_forward_refs
+  {
+    static bool check(Field *field, Virtual_column_info *vcol)
+    {
+      return vcol &&
+             vcol->expr->walk(&Item::check_field_expression_processor, 0, field);
+    }
+    static bool check(Field *field)
+    {
+      if (check(field, field->vcol_info) ||
+          check(field, field->default_value))
+        return true;
+      return false;
+    }
+  };
+  CHARSET_INFO *save_character_set_client= thd->variables.character_set_client;
+  CHARSET_INFO *save_collation= thd->variables.collation_connection;
+  Query_arena  *backup_stmt_arena_ptr= thd->stmt_arena;
+  const uchar *pos= table->s->vcol_defs.str;
+  const uchar *end= pos + table->s->vcol_defs.length;
+  Field **field_ptr= table->field - 1;
+  Field **vfield_ptr= table->vfield;
+  Field **dfield_ptr= table->default_field;
+  Virtual_column_info **check_constraint_ptr= table->check_constraints;
+  Sql_mode_save_for_frm_handling sql_mode_save(thd);
+  Query_arena backup_arena;
+  Virtual_column_info *vcol= 0;
+  StringBuffer<MAX_FIELD_WIDTH> expr_str;
+  bool res= 1;
+  DBUG_ENTER("parse_vcol_defs");
+
+  if (check_constraint_ptr)
+    memcpy(table->check_constraints + table->s->field_check_constraints,
+           table->s->check_constraints,
+           table->s->table_check_constraints * sizeof(Virtual_column_info*));
+
+  DBUG_ASSERT(table->expr_arena == NULL);
+
+  if (table->init_expr_arena(mem_root))
+    DBUG_RETURN(1);
+
+  thd->set_n_backup_active_arena(table->expr_arena, &backup_arena);
+  thd->stmt_arena= table->expr_arena;
+  thd->update_charset(&my_charset_utf8mb4_general_ci, table->s->table_charset);
+  expr_str.append(&parse_vcol_keyword);
+
+  while (pos < end)
+  {
+    uint type, expr_length;
+    if (table->s->frm_version >= FRM_VER_EXPRESSSIONS)
+    {
+      uint field_nr, name_length;
+      /* see pack_expression() for how data is stored */
+      type= pos[0];
+      field_nr= uint2korr(pos+1);
+      expr_length= uint2korr(pos+3);
+      name_length= pos[5];
+      pos+= FRM_VCOL_NEW_HEADER_SIZE + name_length;
+      field_ptr= table->field + field_nr;
+    }
+    else
+    {
+      /*
+        see below in ::init_from_binary_frm_image for how data is stored
+        in versions below 10.2 (that includes 5.7 too)
+      */
+      while (*++field_ptr && !(*field_ptr)->vcol_info) /* no-op */;
+      if (!*field_ptr)
+      {
+        open_table_error(table->s, OPEN_FRM_CORRUPTED, 1);
+        goto end;
+      }
+      type= (*field_ptr)->vcol_info->stored_in_db
+            ? VCOL_GENERATED_STORED : VCOL_GENERATED_VIRTUAL;
+      expr_length= uint2korr(pos+1);
+      if (table->s->mysql_version > 50700 && table->s->mysql_version < 100000)
+      {
+        table->s->keep_original_mysql_version= 1;
+        pos+= 4;                        // MySQL from 5.7
+      }
+      else
+        pos+= pos[0] == 2 ? 4 : 3;      // MariaDB from 5.2 to 10.1
+    }
+
+    expr_str.length(parse_vcol_keyword.length);
+    expr_str.append((char*)pos, expr_length);
+    thd->where= vcol_type_name(static_cast<enum_vcol_info_type>(type));
+
+    switch (type) {
+    case VCOL_GENERATED_VIRTUAL:
+    case VCOL_GENERATED_STORED:
+      vcol= unpack_vcol_info_from_frm(thd, table, &expr_str,
+                                    &((*field_ptr)->vcol_info), error_reported);
+      *(vfield_ptr++)= *field_ptr;
+      DBUG_ASSERT(table->map == 0);
+      /*
+        We need Item_field::const_item() to return false, so
+        datetime_precision() and time_precision() do not try to calculate
+        field values, e.g. val_str().
+        Set table->map to non-zero temporarily.
+      */
+      table->map= 1;
+      if (vcol && field_ptr[0]->check_vcol_sql_mode_dependency(thd, mode))
+      {
+        DBUG_ASSERT(thd->is_error());
+        *error_reported= true;
+        goto end;
+      }
+      table->map= 0;
+      break;
+    case VCOL_DEFAULT:
+      vcol= unpack_vcol_info_from_frm(thd, table, &expr_str,
+                                      &((*field_ptr)->default_value),
+                                      error_reported);
+      *(dfield_ptr++)= *field_ptr;
+      if (vcol && (vcol->flags & (VCOL_NON_DETERMINISTIC | VCOL_SESSION_FUNC)))
+        table->s->non_determinstic_insert= true;
+      break;
+    case VCOL_CHECK_FIELD:
+      vcol= unpack_vcol_info_from_frm(thd, table, &expr_str,
+                                      &((*field_ptr)->check_constraint),
+                                      error_reported);
+      *check_constraint_ptr++= (*field_ptr)->check_constraint;
+      break;
+    case VCOL_CHECK_TABLE:
+      vcol= unpack_vcol_info_from_frm(thd, table, &expr_str,
+                                      check_constraint_ptr, error_reported);
+      check_constraint_ptr++;
+      break;
+    }
+    if (!vcol)
+      goto end;
+    pos+= expr_length;
+  }
+
+  /* Now, initialize CURRENT_TIMESTAMP and UNIQUE_INDEX_HASH_FIELD fields */
+  for (field_ptr= table->field; *field_ptr; field_ptr++)
+  {
+    Field *field= *field_ptr;
+    if (field->flags & LONG_UNIQUE_HASH_FIELD)
+    {
+      List<Item> *field_list= new (mem_root) List<Item>();
+      Item *list_item;
+      KEY *key= 0;
+      uint key_index, parts= 0;
+      for (key_index= 0; key_index < table->s->keys; key_index++)
+      {
+        key=table->key_info + key_index;
+          parts= key->user_defined_key_parts;
+        if (key->key_part[parts].fieldnr == field->field_index + 1)
+            break;
+        }
+      if (!key || key->algorithm != HA_KEY_ALG_LONG_HASH)
+        goto end;
+      KEY_PART_INFO *keypart;
+      for (uint i=0; i < parts; i++)
+      {
+        keypart= key->key_part + i;
+        if (keypart->key_part_flag & HA_PART_KEY_SEG)
+        {
+          int length= keypart->length/keypart->field->charset()->mbmaxlen;
+          list_item= new (mem_root) Item_func_left(thd,
+                       new (mem_root) Item_field(thd, keypart->field),
+                       new (mem_root) Item_int(thd, length));
+          list_item->fix_fields(thd, NULL);
+          keypart->field->vcol_info=
+            table->field[keypart->field->field_index]->vcol_info;
+        }
+        else
+          list_item= new (mem_root) Item_field(thd, keypart->field);
+        field_list->push_back(list_item, mem_root);
+      }
+
+      Item_func_hash *hash_item= table->s->make_long_hash_func(thd, mem_root,
+                                                               field_list);
+
+      Virtual_column_info *v= new (mem_root) Virtual_column_info();
+      field->vcol_info= v;
+      field->vcol_info->expr= hash_item;
+      field->vcol_info->set_vcol_type(VCOL_USING_HASH);
+      if (v->fix_and_check_expr(thd, table))
+        goto end;
+      key->user_defined_key_parts= key->ext_key_parts= key->usable_key_parts= 1;
+      key->key_part+= parts;
+
+      if (key->flags & HA_NULL_PART_KEY)
+        key->key_length= HA_HASH_KEY_LENGTH_WITH_NULL;
+      else
+        key->key_length= HA_HASH_KEY_LENGTH_WITHOUT_NULL;
+
+      *(vfield_ptr++)= *field_ptr;
+    }
+    if (field->has_default_now_unireg_check())
+    {
+      expr_str.length(parse_vcol_keyword.length);
+      expr_str.append(STRING_WITH_LEN("current_timestamp("));
+      expr_str.append_ulonglong(field->decimals());
+      expr_str.append(')');
+      vcol= unpack_vcol_info_from_frm(thd, table, &expr_str,
+                                      &((*field_ptr)->default_value),
+                                      error_reported);
+      *(dfield_ptr++)= *field_ptr;
+      if (!field->default_value->expr)
+        goto end;
+    }
+    else if (field->has_update_default_function() && !field->default_value)
+      *(dfield_ptr++)= *field_ptr;
+  }
+
+  if (vfield_ptr)
+    *vfield_ptr= 0;
+
+  if (dfield_ptr)
+    *dfield_ptr= 0;
+
+  if (check_constraint_ptr)
+    *check_constraint_ptr= 0;
+
+  /* Check that expressions aren't referring to not yet initialized fields */
+  for (field_ptr= table->field; *field_ptr; field_ptr++)
+  {
+    if (check_vcol_forward_refs::check(*field_ptr))
+    {
+      *error_reported= true;
+      goto end;
+    }
+    if ((*field_ptr)->check_constraint)
+        (*field_ptr)->check_constraint->expr->
+          walk(&Item::update_func_default_processor, 0, *field_ptr);
+  }
+
+  table->find_constraint_correlated_indexes();
+
+  res=0;
+end:
+  thd->restore_active_arena(table->expr_arena, &backup_arena);
+  thd->stmt_arena= backup_stmt_arena_ptr;
+  if (save_character_set_client)
+    thd->update_charset(save_character_set_client, save_collation);
+  DBUG_RETURN(res);
+}
+
+
+static const Type_handler *old_frm_type_handler(uint pack_flag,
+                                                uint interval_nr)
+{
+  enum_field_types field_type= (enum_field_types) f_packtype(pack_flag);
+  DBUG_ASSERT(field_type < 16);
+
+  if (!f_is_alpha(pack_flag))
+    return Type_handler::get_handler_by_real_type(field_type);
+
+  if (!f_is_packed(pack_flag))
+  {
+    if (field_type == MYSQL_TYPE_DECIMAL)  // 3.23 or 4.0 string
+      return &type_handler_string;
+    if (field_type == MYSQL_TYPE_VARCHAR)  // Since mysql-5.0
+      return &type_handler_varchar;
+    return NULL;  // Error (bad frm?)
+  }
+
+  if (f_is_blob(pack_flag))
+    return &type_handler_blob; // QQ: exact type??
+
+  if (interval_nr)
+  {
+    if (f_is_enum(pack_flag))
+      return &type_handler_enum;
+    return &type_handler_set;
+  }
+  return Type_handler::get_handler_by_real_type(field_type);
+}
+
+/* Set overlapped bitmaps for each index */
+
+void TABLE_SHARE::set_overlapped_keys()
+{
+  KEY *key1= key_info;
+  for (uint i= 0; i < keys; i++, key1++)
+  {
+    key1->overlapped.clear_all();
+    key1->overlapped.set_bit(i);
+  }
+  key1= key_info;
+  for (uint i= 0; i < keys; i++, key1++)
+  {
+    KEY *key2= key1 + 1;
+    for (uint j= i+1; j < keys; j++, key2++)
+    {
+      KEY_PART_INFO *key_part1= key1->key_part;
+      uint n1= key1->user_defined_key_parts;
+      uint n2= key2->user_defined_key_parts;
+      for (uint k= 0; k < n1; k++, key_part1++)
+      {
+        KEY_PART_INFO *key_part2= key2->key_part;
+        for (uint l= 0; l < n2; l++, key_part2++)
+	{
+          if (key_part1->fieldnr == key_part2->fieldnr)
+	  {
+            key1->overlapped.set_bit(j);
+            key2->overlapped.set_bit(i);
+            goto end_checking_overlap;
+          }
+        }
+      }
+    end_checking_overlap:
+      ;
+    }
+  }
+}
+
+
+/*
+  @brief
+    Set of indexes that are marked as IGNORE.
+*/
+
+void TABLE_SHARE::set_ignored_indexes()
+{
+  KEY *keyinfo= key_info;
+  for (uint i= 0; i < keys; i++, keyinfo++)
+  {
+    if (keyinfo->is_ignored)
+      ignored_indexes.set_bit(i);
+  }
+}
+
+
+/*
+  @brief
+    Set of indexes that the optimizer may use when creating an execution plan.
+*/
+
+key_map TABLE_SHARE::usable_indexes(THD *thd)
+{
+  key_map usable_indexes(keys_in_use);
+  usable_indexes.subtract(ignored_indexes);
+  return usable_indexes;
+}
+
+
+bool Item_field::check_index_dependence(void *arg)
+{
+  TABLE *table= (TABLE *)arg;
+
+  KEY *key= table->key_info;
+  for (uint j= 0; j < table->s->keys; j++, key++)
+  {
+    if (table->constraint_dependent_keys.is_set(j))
+      continue;
+
+    KEY_PART_INFO *key_part= key->key_part;
+    uint n= key->user_defined_key_parts;
+
+    for (uint k= 0; k < n; k++, key_part++)
+    {
+      if (this->field == key_part->field)
+      {
+        table->constraint_dependent_keys.set_bit(j);
+        break;
+      }
+    }
+  }
+  return false;
+}
+
+
+/**
+  @brief
+    Find keys that occur in the same constraint on this table
+
+  @details
+    Constraints on this table are checked only.
+
+    The method goes through constraints list trying to find at
+    least two keys which parts participate in some constraint.
+    These keys are called constraint correlated.
+
+    Each key has its own key map with the information about with
+    which keys it is constraint correlated. Bit in this map is set
+    only if keys are constraint correlated.
+    This method fills each keys constraint correlated key map.
+*/
+
+void TABLE::find_constraint_correlated_indexes()
+{
+  if (s->keys == 0)
+    return;
+
+  KEY *key= key_info;
+  for (uint i= 0; i < s->keys; i++, key++)
+  {
+    key->constraint_correlated.clear_all();
+    key->constraint_correlated.set_bit(i);
+  }
+
+  if (!check_constraints)
+    return;
+
+  for (Virtual_column_info **chk= check_constraints ; *chk ; chk++)
+  {
+    constraint_dependent_keys.clear_all();
+    (*chk)->expr->walk(&Item::check_index_dependence, 0, this);
+
+    if (constraint_dependent_keys.bits_set() <= 1)
+      continue;
+
+    uint key_no= 0;
+    key_map::Iterator ki(constraint_dependent_keys);
+    while ((key_no= ki++) != key_map::Iterator::BITMAP_END)
+      key_info[key_no].constraint_correlated.merge(constraint_dependent_keys);
+  }
+}
+
+
+bool TABLE_SHARE::init_period_from_extra2(period_info_t *period,
+                                          const uchar *data, const uchar *end)
+{
+  if (data + 2*frm_fieldno_size > end)
+    return 1;
+  period->start_fieldno= read_frm_fieldno(data);
+  period->end_fieldno= read_frm_fieldno(data + frm_fieldno_size);
+  return period->start_fieldno >= fields || period->end_fieldno >= fields;
+}
+
+
+static
+bool read_extra2_section_once(const uchar *extra2, size_t len, LEX_CUSTRING *section)
+{
+  if (section->str)
+    return true;
+  *section= {extra2, len};
+  return false;
+}
+
+static
+bool read_extra2(const uchar *frm_image, size_t len, extra2_fields *fields)
+{
+  const uchar *extra2= frm_image + 64;
+
+  DBUG_ENTER("read_extra2");
+
+  fields->reset();
+
+  if (*extra2 != '/')   // old frm had '/' there
+  {
+    const uchar *e2end= extra2 + len;
+    while (extra2 + 3 <= e2end)
+    {
+      extra2_frm_value_type type= (extra2_frm_value_type)*extra2++;
+      size_t length= extra2_read_len(&extra2, e2end);
+      if (!length)
+        DBUG_RETURN(true);
+
+      bool fail= false;
+      switch (type) {
+        case EXTRA2_TABLEDEF_VERSION:
+          if (fields->version.str) // see init_from_sql_statement_string()
+          {
+            if (length != fields->version.length)
+              DBUG_RETURN(true);
+          }
+          else
+          {
+            fields->version.str= extra2;
+            fields->version.length= length;
+          }
+          break;
+        case EXTRA2_ENGINE_TABLEOPTS:
+          fail= read_extra2_section_once(extra2, length, &fields->options);
+          break;
+        case EXTRA2_DEFAULT_PART_ENGINE:
+          fields->engine.set((const char*)extra2, length);
+          break;
+        case EXTRA2_GIS:
+          fail= read_extra2_section_once(extra2, length, &fields->gis);
+          break;
+        case EXTRA2_PERIOD_FOR_SYSTEM_TIME:
+          fail= read_extra2_section_once(extra2, length, &fields->system_period)
+                  || length != 2 * frm_fieldno_size;
+          break;
+        case EXTRA2_FIELD_FLAGS:
+          fail= read_extra2_section_once(extra2, length, &fields->field_flags);
+          break;
+        case EXTRA2_APPLICATION_TIME_PERIOD:
+          fail= read_extra2_section_once(extra2, length, &fields->application_period);
+          break;
+        case EXTRA2_PERIOD_WITHOUT_OVERLAPS:
+          fail= read_extra2_section_once(extra2, length, &fields->without_overlaps);
+          break;
+        case EXTRA2_FIELD_DATA_TYPE_INFO:
+          fail= read_extra2_section_once(extra2, length, &fields->field_data_type_info);
+          break;
+        case EXTRA2_INDEX_FLAGS:
+          fail= read_extra2_section_once(extra2, length, &fields->index_flags);
+          break;
+        default:
+          /* abort frm parsing if it's an unknown but important extra2 value */
+          if (type >= EXTRA2_ENGINE_IMPORTANT)
+            DBUG_RETURN(true);
+      }
+      if (fail)
+        DBUG_RETURN(true);
+
+      extra2+= length;
+    }
+    if (extra2 != e2end)
+      DBUG_RETURN(true);
+  }
+  DBUG_RETURN(false);
+}
+
+
+class Field_data_type_info_array
+{
+public:
+  class Elem
+  {
+    LEX_CSTRING m_type_info;
+  public:
+    void set(const LEX_CSTRING &type_info)
+    {
+      m_type_info= type_info;
+    }
+    const LEX_CSTRING &type_info() const
+    {
+      return m_type_info;
+    }
+  };
+private:
+  Elem *m_array;
+  uint m_count;
+  bool alloc(MEM_ROOT *root, uint count)
+  {
+    DBUG_ASSERT(!m_array);
+    DBUG_ASSERT(!m_count);
+    size_t nbytes= sizeof(Elem) * count;
+    if (!(m_array= (Elem*) alloc_root(root, nbytes)))
+      return true;
+    m_count= count;
+    bzero((void*) m_array, nbytes);
+    return false;
+  }
+  static uint32 read_length(uchar **pos, const uchar *end)
+  {
+    ulonglong num= safe_net_field_length_ll(pos, end - *pos);
+    if (num > UINT_MAX32)
+      return 0;
+    return (uint32) num;
+  }
+  static bool read_string(LEX_CSTRING *to, uchar **pos, const uchar *end)
+  {
+    to->length= read_length(pos, end);
+    if (*pos + to->length > end)
+      return true; // Not enough data
+    to->str= (const char *) *pos;
+    *pos+= to->length;
+    return false;
+  }
+public:
+  Field_data_type_info_array()
+   :m_array(NULL), m_count(0)
+  { }
+  uint count() const
+  {
+    return m_count;
+  }
+  const Elem& element(uint i) const
+  {
+    DBUG_ASSERT(i < m_count);
+    return m_array[i];
+  }
+  bool parse(MEM_ROOT *root, uint count, LEX_CUSTRING &image)
+  {
+    const uchar *pos= image.str;
+    const uchar *end= pos + image.length;
+    if (alloc(root, count))
+      return true;
+    for (uint i= 0; i < count && pos < end; i++)
+    {
+      LEX_CSTRING type_info;
+      uint fieldnr= read_length((uchar**) &pos, end);
+      if ((fieldnr == 0 && i > 0) || fieldnr >= count)
+        return true; // Bad data
+      if (read_string(&type_info, (uchar**) &pos, end) || type_info.length == 0)
+        return true; // Bad data
+      m_array[fieldnr].set(type_info);
+    }
+    return pos < end; // Error if some data is still left
+  }
+};
+
+
+/*
+  Change to use the partition storage engine
+*/
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+static bool change_to_partiton_engine(LEX_CSTRING *name,
+                                      plugin_ref *se_plugin)
+{
+  /*
+    Use partition handler
+    tmp_plugin is locked with a local lock.
+    we unlock the old value of se_plugin before
+    replacing it with a globally locked version of tmp_plugin
+  */
+  /* Check if the partitioning engine is ready */
+  if (!plugin_is_ready(name, MYSQL_STORAGE_ENGINE_PLUGIN))
+  {
+    my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0),
+             "--skip-partition");
+    return 1;
+  }
+  plugin_unlock(NULL, *se_plugin);
+  *se_plugin= ha_lock_engine(NULL, partition_hton);
+  return 0;
+}
+#endif /* WITH_PARTITION_STORAGE_ENGINE */
+
+/**
+  Read data from a binary .frm file image into a TABLE_SHARE
+
+  @param write   Write the .frm and .par file.  These are not created if
+                 the function returns an error.
+
+  @note
+  frm bytes at the following offsets are unused in MariaDB 10.0:
+
+  8..9    (used to be the number of "form names")
+  28..29  (used to be key_info_length)
+
+  They're still set, for compatibility reasons, but never read.
+
+  42..46 are unused since 5.0 (were for RAID support)
+  Also, there're few unused bytes in forminfo.
+*/
+
+int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
+                                            const uchar *frm_image,
+                                            size_t frm_length,
+                                            const uchar *par_image,
+                                            size_t par_length)
+{
+  TABLE_SHARE *share= this;
+  uint new_frm_ver, field_pack_length, new_field_pack_flag;
+  uint interval_count, interval_parts, read_length, int_length;
+  uint total_typelib_value_count;
+  uint db_create_options, keys, key_parts, n_length;
+  uint com_length, null_bit_pos, UNINIT_VAR(mysql57_vcol_null_bit_pos), bitmap_count;
+  uint i, hash_fields= 0;
+  bool use_hash, mysql57_null_bits= 0;
+  LEX_STRING keynames= {NULL, 0};
+  char *names, *comment_pos;
+  const uchar *forminfo;
+  const uchar *frm_image_end = frm_image + frm_length;
+  uchar *record, *null_flags, *null_pos, *UNINIT_VAR(mysql57_vcol_null_pos);
+  const uchar *disk_buff, *strpos;
+  ulong pos, record_offset;
+  ulong rec_buff_length;
+  handler *handler_file= 0;
+  KEY	*keyinfo;
+  KEY_PART_INFO *key_part= NULL;
+  Field  **field_ptr, *reg_field;
+  const char **interval_array;
+  uint *typelib_value_lengths= NULL;
+  enum legacy_db_type legacy_db_type;
+  my_bitmap_map *bitmaps;
+  bool null_bits_are_used;
+  uint vcol_screen_length;
+  uchar *vcol_screen_pos;
+  LEX_CUSTRING options;
+  LEX_CSTRING se_name= empty_clex_str;
+  KEY first_keyinfo;
+  uint len;
+  uint ext_key_parts= 0;
+  plugin_ref se_plugin= 0;
+  bool vers_can_native= false, frm_created= 0;
+  Field_data_type_info_array field_data_type_info_array;
+  MEM_ROOT *old_root= thd->mem_root;
+  Virtual_column_info **table_check_constraints;
+  bool *interval_unescaped= NULL;
+  extra2_fields extra2;
+  bool extra_index_flags_present= FALSE;
+  DBUG_ENTER("TABLE_SHARE::init_from_binary_frm_image");
+
+  keyinfo= &first_keyinfo;
+  thd->mem_root= &share->mem_root;
+
+  if (frm_length < FRM_HEADER_SIZE + FRM_FORMINFO_SIZE)
+    goto err;
+
+  if (write)
+  {
+    frm_created= 1;
+    if (write_frm_image(frm_image, frm_length))
+      goto err;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+    if (par_image)
+      if (write_par_image(par_image, par_length))
+        goto err;
+#endif
+  }
+
+  share->frm_version= frm_image[2];
+  /*
+    Check if .frm file created by MySQL 5.0. In this case we want to
+    display CHAR fields as CHAR and not as VARCHAR.
+    We do it this way as we want to keep the old frm version to enable
+    MySQL 4.1 to read these files.
+  */
+  if (share->frm_version == FRM_VER_TRUE_VARCHAR -1 && frm_image[33] == 5)
+    share->frm_version= FRM_VER_TRUE_VARCHAR;
+
+  new_field_pack_flag= frm_image[27];
+  new_frm_ver= (frm_image[2] - FRM_VER);
+  field_pack_length= new_frm_ver < 2 ? 11 : 17;
+
+  /* Length of the MariaDB extra2 segment in the form file. */
+  len = uint2korr(frm_image+4);
+
+  if (read_extra2(frm_image, len, &extra2))
+    goto err;
+
+  tabledef_version.length= extra2.version.length;
+  tabledef_version.str= (uchar*)memdup_root(&mem_root, extra2.version.str,
+                                                       extra2.version.length);
+  if (!tabledef_version.str)
+    goto err;
+
+  /* remember but delay parsing until we have read fields and keys */
+  options= extra2.options;
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (extra2.engine)
+  {
+    share->default_part_plugin= ha_resolve_by_name(NULL, &extra2.engine, false);
+    if (!share->default_part_plugin)
+      goto err;
+  }
+#endif
+
+  if (frm_length < FRM_HEADER_SIZE + len ||
+      !(pos= uint4korr(frm_image + FRM_HEADER_SIZE + len)))
+    goto err;
+
+  forminfo= frm_image + pos;
+  if (forminfo + FRM_FORMINFO_SIZE >= frm_image_end)
+    goto err;
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (frm_image[61] && !share->default_part_plugin)
+  {
+    enum legacy_db_type db_type= (enum legacy_db_type) (uint) frm_image[61];
+    share->default_part_plugin= ha_lock_engine(NULL, ha_checktype(thd, db_type, 1));
+    if (!share->default_part_plugin)
+      goto err;
+  }
+#endif
+  legacy_db_type= (enum legacy_db_type) (uint) frm_image[3];
+  /*
+    if the storage engine is dynamic, no point in resolving it by its
+    dynamically allocated legacy_db_type. We will resolve it later by name.
+  */
+  if (legacy_db_type > DB_TYPE_UNKNOWN && 
+      legacy_db_type < DB_TYPE_FIRST_DYNAMIC)
+    se_plugin= ha_lock_engine(NULL, ha_checktype(thd, legacy_db_type));
+  share->db_create_options= db_create_options= uint2korr(frm_image+30);
+  share->db_options_in_use= share->db_create_options;
+  share->mysql_version= uint4korr(frm_image+51);
+  share->table_type= TABLE_TYPE_NORMAL;
+  share->null_field_first= 0;
+  if (!frm_image[32])				// New frm file in 3.23
+  {
+    uint cs_org= (((uint) frm_image[41]) << 8) + (uint) frm_image[38];
+    uint cs_new= Charset::upgrade_collation_id(share->mysql_version, cs_org);
+    if (cs_org != cs_new)
+      share->incompatible_version|= HA_CREATE_USED_CHARSET;
+
+    share->avg_row_length= uint4korr(frm_image+34);
+    share->transactional= (ha_choice)
+      enum_value_with_check(thd, share, "transactional", frm_image[39] & 3, HA_CHOICE_MAX);
+    share->page_checksum= (ha_choice)
+      enum_value_with_check(thd, share, "page_checksum", (frm_image[39] >> 2) & 3, HA_CHOICE_MAX);
+    if (((ha_choice) enum_value_with_check(thd, share, "sequence",
+                                           (frm_image[39] >> 4) & 3,
+                                           HA_CHOICE_MAX)) == HA_CHOICE_YES)
+    {
+      share->table_type= TABLE_TYPE_SEQUENCE;
+      share->sequence= new (&share->mem_root) SEQUENCE();
+      share->non_determinstic_insert= true;
+    }
+    share->row_type= (enum row_type)
+      enum_value_with_check(thd, share, "row_format", frm_image[40], ROW_TYPE_MAX);
+
+    if (cs_new && !(share->table_charset= get_charset(cs_new, MYF(MY_WME))))
+      goto err;
+    share->null_field_first= 1;
+    share->stats_sample_pages= uint2korr(frm_image+42);
+    share->stats_auto_recalc= (enum_stats_auto_recalc)(frm_image[44]);
+    share->table_check_constraints= uint2korr(frm_image+45);
+  }
+  if (!share->table_charset)
+  {
+    const CHARSET_INFO *cs= thd->variables.collation_database;
+    /* unknown charset in frm_image[38] or pre-3.23 frm */
+    if (cs->use_mb())
+    {
+      /* Warn that we may be changing the size of character columns */
+      sql_print_warning("'%s' had no or invalid character set, "
+                        "and default character set is multi-byte, "
+                        "so character column sizes may have changed",
+                        share->path.str);
+    }
+    share->table_charset= cs;
+  }
+
+  share->db_record_offset= 1;
+  share->max_rows= uint4korr(frm_image+18);
+  share->min_rows= uint4korr(frm_image+22);
+
+  /* Read keyinformation */
+  disk_buff= frm_image + uint2korr(frm_image+6);
+
+  if (disk_buff + 6 >= frm_image_end)
+    goto err;
+
+  if (disk_buff[0] & 0x80)
+  {
+    keys=      (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
+    share->key_parts= key_parts= uint2korr(disk_buff+2);
+  }
+  else
+  {
+    keys=      disk_buff[0];
+    share->key_parts= key_parts= disk_buff[1];
+  }
+  share->keys_for_keyread.init(0);
+  share->ignored_indexes.init(0);
+  share->keys_in_use.init(keys);
+  ext_key_parts= key_parts;
+
+  if (extra2.index_flags.str && extra2.index_flags.length != keys)
+    goto err;
+
+  len= (uint) uint2korr(disk_buff+4);
+
+  share->reclength = uint2korr(frm_image+16);
+  share->stored_rec_length= share->reclength;
+  if (frm_image[26] == 1)
+    share->system= 1;				/* one-record-database */
+
+  record_offset= (ulong) (uint2korr(frm_image+6)+
+                          ((uint2korr(frm_image+14) == 0xffff ?
+                            uint4korr(frm_image+47) : uint2korr(frm_image+14))));
+
+  if (record_offset + share->reclength >= frm_length)
+    goto err;
+ 
+  if ((n_length= uint4korr(frm_image+55)))
+  {
+    /* Read extra data segment */
+    const uchar *next_chunk, *buff_end;
+    DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));
+    next_chunk= frm_image + record_offset + share->reclength;
+    buff_end= next_chunk + n_length;
+
+    if (buff_end >= frm_image_end)
+      goto err;
+
+    share->connect_string.length= uint2korr(next_chunk);
+    if (!(share->connect_string.str= strmake_root(&share->mem_root,
+                                                  (char*) next_chunk + 2,
+                                                  share->connect_string.
+                                                  length)))
+    {
+      goto err;
+    }
+    next_chunk+= share->connect_string.length + 2;
+    if (next_chunk + 2 < buff_end)
+    {
+      uint str_db_type_length= uint2korr(next_chunk);
+      se_name.str= (char*) next_chunk + 2;
+      se_name.length= str_db_type_length;
+
+      plugin_ref tmp_plugin= ha_resolve_by_name(thd, &se_name, false);
+      if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, se_plugin) &&
+          legacy_db_type != DB_TYPE_S3)
+      {
+        if (se_plugin)
+        {
+          /* bad file, legacy_db_type did not match the name */
+          sql_print_warning("%s.frm is inconsistent: engine typecode %d, engine name %s (%d)",
+                        share->normalized_path.str, legacy_db_type,
+                        plugin_name(tmp_plugin)->str,
+                        ha_legacy_type(plugin_data(tmp_plugin, handlerton *)));
+        }
+        /*
+          tmp_plugin is locked with a local lock.
+          we unlock the old value of se_plugin before
+          replacing it with a globally locked version of tmp_plugin
+        */
+        plugin_unlock(NULL, se_plugin);
+        se_plugin= plugin_lock(NULL, tmp_plugin);
+      }
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+      else if (str_db_type_length == 9 &&
+               !strncmp((char *) next_chunk + 2, "partition", 9))
+      {
+        if (change_to_partiton_engine(&se_name, &se_plugin))
+          goto err;
+      }
+#endif
+      else if (!tmp_plugin)
+      {
+        /* purecov: begin inspected */
+        ((char*) se_name.str)[se_name.length]=0;
+        my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), se_name.str);
+        goto err;
+        /* purecov: end */
+      }
+      next_chunk+= str_db_type_length + 2;
+    }
+
+    share->set_use_ext_keys_flag(plugin_hton(se_plugin)->flags & HTON_SUPPORTS_EXTENDED_KEYS);
+
+    if (create_key_infos(disk_buff + 6, frm_image_end, keys, keyinfo,
+                         new_frm_ver, &ext_key_parts,
+                         share, len, &first_keyinfo, &keynames))
+      goto err;
+
+    if (next_chunk + 5 < buff_end)
+    {
+      uint32 partition_info_str_len = uint4korr(next_chunk);
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+      if ((share->partition_info_buffer_size=
+             share->partition_info_str_len= partition_info_str_len))
+      {
+        if (!(share->partition_info_str= (char*)
+              memdup_root(&share->mem_root, next_chunk + 4,
+                          partition_info_str_len + 1)))
+        {
+          goto err;
+        }
+        if (plugin_data(se_plugin, handlerton*) != partition_hton &&
+            share->mysql_version >= 50600 && share->mysql_version <= 50799)
+        {
+          share->keep_original_mysql_version= 1;
+          if (change_to_partiton_engine(&se_name, &se_plugin))
+            goto err;
+        }
+      }
+#else
+      if (partition_info_str_len)
+      {
+        DBUG_PRINT("info", ("WITH_PARTITION_STORAGE_ENGINE is not defined"));
+        goto err;
+      }
+#endif
+      next_chunk+= 5 + partition_info_str_len;
+    }
+    if (share->mysql_version >= 50110 && next_chunk < buff_end)
+    {
+      /* New auto_partitioned indicator introduced in 5.1.11 */
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+      share->auto_partitioned= *next_chunk;
+#endif
+      next_chunk++;
+    }
+    keyinfo= share->key_info;
+    for (i= 0; i < keys; i++, keyinfo++)
+    {
+      if (keyinfo->flags & HA_USES_PARSER)
+      {
+        LEX_CSTRING parser_name;
+        if (next_chunk >= buff_end)
+        {
+          DBUG_PRINT("error",
+                     ("fulltext key uses parser that is not defined in .frm"));
+          goto err;
+        }
+        parser_name.str= (char*) next_chunk;
+        parser_name.length= strlen((char*) next_chunk);
+        next_chunk+= parser_name.length + 1;
+        keyinfo->parser= my_plugin_lock_by_name(NULL, &parser_name,
+                                                MYSQL_FTPARSER_PLUGIN);
+        if (! keyinfo->parser)
+        {
+          my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), parser_name.str);
+          goto err;
+        }
+      }
+    }
+
+    if (forminfo[46] == (uchar)255)
+    {
+      //reading long table comment
+      if (next_chunk + 2 > buff_end)
+      {
+          DBUG_PRINT("error",
+                     ("long table comment is not defined in .frm"));
+          goto err;
+      }
+      share->comment.length = uint2korr(next_chunk);
+      if (! (share->comment.str= strmake_root(&share->mem_root,
+             (char*)next_chunk + 2, share->comment.length)))
+      {
+          goto err;
+      }
+      next_chunk+= 2 + share->comment.length;
+    }
+
+    DBUG_ASSERT(next_chunk <= buff_end);
+
+    if (share->db_create_options & HA_OPTION_TEXT_CREATE_OPTIONS_legacy)
+    {
+      if (options.str)
+        goto err;
+      options.length= uint4korr(next_chunk);
+      options.str= next_chunk + 4;
+      next_chunk+= options.length + 4;
+    }
+    DBUG_ASSERT(next_chunk <= buff_end);
+  }
+  else
+  {
+    if (create_key_infos(disk_buff + 6, frm_image_end, keys, keyinfo,
+                         new_frm_ver, &ext_key_parts,
+                         share, len, &first_keyinfo, &keynames))
+      goto err;
+  }
+  share->key_block_size= uint2korr(frm_image+62);
+  keyinfo= share->key_info;
+
+
+  if (extra2.index_flags.str)
+    extra_index_flags_present= TRUE;
+
+  for (uint i= 0; i < share->keys; i++, keyinfo++)
+  {
+    if (extra_index_flags_present)
+    {
+      uchar flags= *extra2.index_flags.str++;
+      keyinfo->is_ignored= (flags & EXTRA2_IGNORED_KEY);
+    }
+    else
+      keyinfo->is_ignored= FALSE;
+
+    if (keyinfo->algorithm == HA_KEY_ALG_LONG_HASH)
+      hash_fields++;
+  }
+
+  share->set_ignored_indexes();
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (par_image && plugin_data(se_plugin, handlerton*) == partition_hton)
+  {
+    /*
+      Discovery returned a partition plugin. Change to use it. The partition
+      engine will then use discovery to find the rest of the plugin tables,
+      which may be in the original engine used for discovery
+    */
+    share->db_plugin= se_plugin;
+  }
+#endif
+  if (share->db_plugin && !plugin_equals(share->db_plugin, se_plugin))
+    goto err; // wrong engine (someone changed the frm under our feet?)
+
+  rec_buff_length= ALIGN_SIZE(share->reclength + 1);
+  share->rec_buff_length= rec_buff_length;
+  if (!(record= (uchar *) alloc_root(&share->mem_root, rec_buff_length)))
+    goto err;                          /* purecov: inspected */
+  /* Mark bytes after record as not accessable to catch overrun bugs */
+  MEM_NOACCESS(record + share->reclength, rec_buff_length - share->reclength);
+  share->default_values= record;
+  memcpy(record, frm_image + record_offset, share->reclength);
+
+  disk_buff= frm_image + pos + FRM_FORMINFO_SIZE;
+  share->fields= uint2korr(forminfo+258);
+  if (extra2.field_flags.str && extra2.field_flags.length != share->fields)
+    goto err;
+  pos= uint2korr(forminfo+260);   /* Length of all screens */
+  n_length= uint2korr(forminfo+268);
+  interval_count= uint2korr(forminfo+270);
+  interval_parts= uint2korr(forminfo+272);
+  int_length= uint2korr(forminfo+274);
+  share->null_fields= uint2korr(forminfo+282);
+  com_length= uint2korr(forminfo+284);
+  vcol_screen_length= uint2korr(forminfo+286);
+  share->virtual_fields= share->default_expressions=
+    share->field_check_constraints= share->default_fields= 0;
+  share->visible_fields= 0;
+  share->stored_fields= share->fields;
+  if (forminfo[46] != (uchar)255)
+  {
+    share->comment.length=  (int) (forminfo[46]);
+    share->comment.str= strmake_root(&share->mem_root, (char*) forminfo+47,
+                                     share->comment.length);
+  }
+
+  DBUG_PRINT("info",("i_count: %d  i_parts: %d  index: %d  n_length: %d  int_length: %d  com_length: %d  vcol_screen_length: %d", interval_count,interval_parts, keys,n_length,int_length, com_length, vcol_screen_length));
+
+  /*
+    We load the following things into TYPELIBs:
+    - One TYPELIB for field names
+    - interval_count TYPELIBs for ENUM/SET values
+    - One TYPELIB for key names
+    Every TYPELIB requires one extra value with a NULL pointer and zero length,
+    which is the end-of-values marker.
+    TODO-10.5+:
+    Note, we should eventually reuse this total_typelib_value_count
+    to allocate interval_array. The below code reserves less space
+    than total_typelib_value_count pointers. So it seems `interval_array`
+    and `names` overlap in the memory. Too dangerous to fix in 10.1.
+  */
+  total_typelib_value_count=
+    (share->fields  +              1/*end-of-values marker*/) +
+    (interval_parts + interval_count/*end-of-values markers*/) +
+    (keys           +              1/*end-of-values marker*/);
+
+  if (!multi_alloc_root(&share->mem_root,
+                        &share->field, (uint)(share->fields+1)*sizeof(Field*),
+                        &share->intervals, (uint)interval_count*sizeof(TYPELIB),
+                        &share->check_constraints, (uint) share->table_check_constraints * sizeof(Virtual_column_info*),
+                        /*
+                           This looks wrong: shouldn't it be (+2+interval_count)
+                           instread of (+3) ?
+                        */
+                        &interval_array, (uint) (share->fields+interval_parts+ keys+3)*sizeof(char *),
+                        &typelib_value_lengths, total_typelib_value_count * sizeof(uint *),
+                        &names, (uint) (n_length+int_length),
+                        &comment_pos, (uint) com_length,
+                        &vcol_screen_pos, vcol_screen_length,
+                        NullS))
+
+    goto err;
+
+  if (interval_count)
+  {
+    if (!(interval_unescaped= (bool*) my_alloca(interval_count * sizeof(bool))))
+      goto err;
+    bzero(interval_unescaped, interval_count * sizeof(bool));
+  }
+
+  field_ptr= share->field;
+  table_check_constraints= share->check_constraints;
+  read_length=(uint) (share->fields * field_pack_length +
+		      pos+ (uint) (n_length+int_length+com_length+
+		                   vcol_screen_length));
+  strpos= disk_buff+pos;
+
+  if (!interval_count)
+    share->intervals= 0;			// For better debugging
+
+  share->vcol_defs.str= vcol_screen_pos;
+  share->vcol_defs.length= vcol_screen_length;
+
+  memcpy(names, strpos+(share->fields*field_pack_length), n_length+int_length);
+  memcpy(comment_pos, disk_buff+read_length-com_length-vcol_screen_length, 
+         com_length);
+  memcpy(vcol_screen_pos, disk_buff+read_length-vcol_screen_length, 
+         vcol_screen_length);
+
+  if (fix_type_pointers(&interval_array, &typelib_value_lengths,
+                        &share->fieldnames, 1, names, n_length) ||
+      share->fieldnames.count != share->fields)
+    goto err;
+
+  if (fix_type_pointers(&interval_array, &typelib_value_lengths,
+                        share->intervals, interval_count,
+                        names + n_length, int_length))
+    goto err;
+
+  if (keynames.length &&
+      (fix_type_pointers(&interval_array, &typelib_value_lengths,
+                         &share->keynames, 1, keynames.str, keynames.length) ||
+      share->keynames.count != keys))
+    goto err;
+
+ /* Allocate handler */
+  if (!(handler_file= get_new_handler(share, thd->mem_root,
+                                      plugin_hton(se_plugin))))
+    goto err;
+
+  if (handler_file->set_ha_share_ref(&share->ha_share))
+    goto err;
+
+  record= share->default_values-1;              /* Fieldstart = 1 */
+  null_bits_are_used= share->null_fields != 0;
+  if (share->null_field_first)
+  {
+    null_flags= null_pos= record+1;
+    null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1;
+    /*
+      null_bytes below is only correct under the condition that
+      there are no bit fields.  Correct values is set below after the
+      table struct is initialized
+    */
+    share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8;
+  }
+#ifndef WE_WANT_TO_SUPPORT_VERY_OLD_FRM_FILES
+  else
+  {
+    share->null_bytes= (share->null_fields+7)/8;
+    null_flags= null_pos= record + 1 + share->reclength - share->null_bytes;
+    null_bit_pos= 0;
+  }
+#endif
+
+  use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
+  if (use_hash)
+    use_hash= !my_hash_init(PSI_INSTRUMENT_ME, &share->name_hash,
+                            system_charset_info, share->fields, 0, 0,
+                            (my_hash_get_key) get_field_name, 0, 0);
+
+  if (share->mysql_version >= 50700 && share->mysql_version < 100000 &&
+      vcol_screen_length)
+  {
+    share->keep_original_mysql_version= 1;
+    /*
+      MySQL 5.7 stores the null bits for not stored fields last.
+      Calculate the position for them.
+    */
+    mysql57_null_bits= 1;
+    mysql57_vcol_null_pos= null_pos;
+    mysql57_vcol_null_bit_pos= null_bit_pos;
+    mysql57_calculate_null_position(share, &mysql57_vcol_null_pos,
+                                    &mysql57_vcol_null_bit_pos,
+                                    strpos, vcol_screen_pos);
+  }
+
+  /* Set system versioning information. */
+  vers.name= Lex_ident(STRING_WITH_LEN("SYSTEM_TIME"));
+  if (extra2.system_period.str == NULL)
+  {
+    versioned= VERS_UNDEFINED;
+    vers.start_fieldno= 0;
+    vers.end_fieldno= 0;
+  }
+  else
+  {
+    DBUG_PRINT("info", ("Setting system versioning information"));
+    if (init_period_from_extra2(&vers, extra2.system_period.str,
+                  extra2.system_period.str + extra2.system_period.length))
+      goto err;
+    DBUG_PRINT("info", ("Columns with system versioning: [%d, %d]",
+                        vers.start_fieldno, vers.end_fieldno));
+    versioned= VERS_TIMESTAMP;
+    vers_can_native= handler_file->vers_can_native(thd);
+    status_var_increment(thd->status_var.feature_system_versioning);
+  } // if (system_period == NULL)
+
+  if (extra2.application_period.str)
+  {
+    const uchar *pos= extra2.application_period.str;
+    const uchar *end= pos + extra2.application_period.length;
+    period.name.length= extra2_read_len(&pos, end);
+    period.name.str= strmake_root(&mem_root, (char*)pos, period.name.length);
+    pos+= period.name.length;
+
+    period.constr_name.length= extra2_read_len(&pos, end);
+    period.constr_name.str= strmake_root(&mem_root, (char*)pos,
+                                         period.constr_name.length);
+    pos+= period.constr_name.length;
+
+    if (init_period_from_extra2(&period, pos, end))
+      goto err;
+    if (extra2_str_size(period.name.length)
+         + extra2_str_size(period.constr_name.length)
+         + 2 * frm_fieldno_size
+        != extra2.application_period.length)
+      goto err;
+    status_var_increment(thd->status_var.feature_application_time_periods);
+  }
+
+  if (extra2.without_overlaps.str)
+  {
+    if (extra2.application_period.str == NULL)
+      goto err;
+    const uchar *key_pos= extra2.without_overlaps.str;
+    period.unique_keys= read_frm_keyno(key_pos);
+    for (uint k= 0; k < period.unique_keys; k++)
+    {
+      key_pos+= frm_keyno_size;
+      uint key_nr= read_frm_keyno(key_pos);
+      key_info[key_nr].without_overlaps= true;
+    }
+
+    if ((period.unique_keys + 1) * frm_keyno_size
+        != extra2.without_overlaps.length)
+      goto err;
+  }
+
+  if (extra2.field_data_type_info.length &&
+      field_data_type_info_array.parse(old_root, share->fields,
+                                       extra2.field_data_type_info))
+    goto err;
+
+  for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++)
+  {
+    uint interval_nr= 0, recpos;
+    LEX_CSTRING comment;
+    LEX_CSTRING name;
+    Virtual_column_info *vcol_info= 0;
+    const Type_handler *handler;
+    uint32 flags= 0;
+    Column_definition_attributes attr;
+
+    if (new_frm_ver >= 3)
+    {
+      /* new frm file in 4.1 */
+      recpos=	    uint3korr(strpos+5);
+      uint comment_length=uint2korr(strpos+15);
+
+      if (!comment_length)
+      {
+	comment.str= (char*) "";
+	comment.length=0;
+      }
+      else
+      {
+	comment.str=    (char*) comment_pos;
+	comment.length= comment_length;
+	comment_pos+=   comment_length;
+      }
+
+      if (strpos[13] == MYSQL_TYPE_VIRTUAL &&
+          (share->mysql_version < 50600 || share->mysql_version >= 100000))
+      {
+        /*
+          MariaDB 5.5 or 10.0 version.
+          The interval_id byte in the .frm file stores the length of the
+          expression statement for a virtual column.
+        */
+        uint vcol_info_length= (uint) strpos[12];
+
+        if (!vcol_info_length) // Expect non-null expression
+          goto err;
+
+        attr.frm_unpack_basic(strpos);
+        if (attr.frm_unpack_charset(share, strpos))
+          goto err;
+        /*
+          Old virtual field information before 10.2
+
+          Get virtual column data stored in the .frm file as follows:
+          byte 1      = 1 | 2
+          byte 2      = sql_type
+          byte 3      = flags. 1 for stored_in_db
+          [byte 4]    = optional interval_id for sql_type (if byte 1 == 2)
+          next byte ...  = virtual column expression (text data)
+        */
+
+        vcol_info= new (&share->mem_root) Virtual_column_info();
+        bool opt_interval_id= (uint)vcol_screen_pos[0] == 2;
+        enum_field_types ftype= (enum_field_types) (uchar) vcol_screen_pos[1];
+        if (!(handler= Type_handler::get_handler_by_real_type(ftype)))
+          goto err;
+        if (opt_interval_id)
+          interval_nr= (uint)vcol_screen_pos[3];
+        else if ((uint)vcol_screen_pos[0] != 1)
+          goto err;
+        bool stored= vcol_screen_pos[2] & 1;
+        vcol_info->stored_in_db= stored;
+        vcol_info->set_vcol_type(stored ? VCOL_GENERATED_STORED : VCOL_GENERATED_VIRTUAL);
+        uint vcol_expr_length= vcol_info_length -
+                              (uint)(FRM_VCOL_OLD_HEADER_SIZE(opt_interval_id));
+        vcol_info->utf8= 0; // before 10.2.1 the charset was unknown
+        int2store(vcol_screen_pos+1, vcol_expr_length); // for parse_vcol_defs()
+        vcol_screen_pos+= vcol_info_length;
+        share->virtual_fields++;
+      }
+      else
+      {
+        interval_nr=  (uint) strpos[12];
+        enum_field_types field_type= (enum_field_types) strpos[13];
+        if (!(handler= Type_handler::get_handler_by_real_type(field_type)))
+        {
+          if (field_type == 245 &&
+              share->mysql_version >= 50700) // a.k.a MySQL 5.7 JSON
+          {
+            share->incompatible_version|= HA_CREATE_USED_ENGINE;
+            const LEX_CSTRING mysql_json{STRING_WITH_LEN("MYSQL_JSON")};
+            handler= Type_handler::handler_by_name_or_error(thd, mysql_json);
+          }
+
+          if (!handler)
+            goto err; // Not supported field type
+        }
+        handler= handler->type_handler_frm_unpack(strpos);
+        if (handler->Column_definition_attributes_frm_unpack(&attr, share,
+                                                             strpos,
+                                                             &extra2.gis))
+          goto err;
+
+        if (field_data_type_info_array.count())
+        {
+          const LEX_CSTRING &info= field_data_type_info_array.
+                                     element(i).type_info();
+          DBUG_EXECUTE_IF("frm_data_type_info",
+            push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+            ER_UNKNOWN_ERROR, "DBUG: [%u] name='%s' type_info='%.*s'",
+            i, share->fieldnames.type_names[i],
+            (uint) info.length, info.str););
+
+          if (info.length)
+          {
+            const Type_handler *h= Type_handler::handler_by_name_or_error(thd,
+                                                                          info);
+            /*
+              This code will eventually be extended here:
+              - If the handler was not found by name, we could
+                still open the table using the fallback type handler "handler",
+                at least for a limited set of commands.
+              - If the handler was found by name, we could check
+                that "h" and "handler" have the same type code
+                (and maybe some other properties) to make sure
+                that the FRM data is consistent.
+            */
+            if (!h)
+              goto err;
+            handler= h;
+          }
+        }
+      }
+
+      if (((uint) strpos[10]) & MYSQL57_GENERATED_FIELD)
+      {
+        attr.unireg_check= Field::NONE;
+
+        /*
+          MySQL 5.7 generated fields
+
+          byte 1        = 1
+          byte 2,3      = expr length
+          byte 4        = stored_in_db
+          byte 5..      = expr
+        */
+        if ((uint)(vcol_screen_pos)[0] != 1)
+          goto err;
+        vcol_info= new (&share->mem_root) Virtual_column_info();
+        uint vcol_info_length= uint2korr(vcol_screen_pos + 1);
+        if (!vcol_info_length) // Expect non-empty expression
+          goto err;
+        vcol_info->stored_in_db= vcol_screen_pos[3];
+        vcol_info->utf8= 0;
+        vcol_screen_pos+= vcol_info_length + MYSQL57_GCOL_HEADER_SIZE;;
+        share->virtual_fields++;
+      }
+    }
+    else
+    {
+      attr.length= (uint) strpos[3];
+      recpos=	    uint2korr(strpos+4),
+      attr.pack_flag=    uint2korr(strpos+6);
+      if (f_is_num(attr.pack_flag))
+      {
+        attr.decimals= f_decimals(attr.pack_flag);
+        attr.pack_flag&= ~FIELDFLAG_DEC_MASK;
+      }
+      attr.pack_flag&=   ~FIELDFLAG_NO_DEFAULT;     // Safety for old files
+      attr.unireg_check=  (Field::utype) MTYP_TYPENR((uint) strpos[8]);
+      interval_nr=  (uint) strpos[10];
+
+      /* old frm file */
+      enum_field_types ftype= (enum_field_types) f_packtype(attr.pack_flag);
+      if (!(handler= Type_handler::get_handler_by_real_type(ftype)))
+        goto err; // Not supported field type
+
+      if (f_is_binary(attr.pack_flag))
+      {
+        /*
+          Try to choose the best 4.1 type:
+          - for 4.0 "CHAR(N) BINARY" or "VARCHAR(N) BINARY" 
+           try to find a binary collation for character set.
+          - for other types (e.g. BLOB) just use my_charset_bin. 
+        */
+        if (!f_is_blob(attr.pack_flag))
+        {
+          // 3.23 or 4.0 string
+          myf utf8_flag= thd->get_utf8_flag();
+          if (!(attr.charset= get_charset_by_csname(share->table_charset->
+                                                    cs_name.str,
+                                                    MY_CS_BINSORT,
+                                                    MYF(utf8_flag))))
+            attr.charset= &my_charset_bin;
+        }
+      }
+      else
+        attr.charset= share->table_charset;
+      bzero((char*) &comment, sizeof(comment));
+      if ((!(handler= old_frm_type_handler(attr.pack_flag, interval_nr))))
+        goto err; // Not supported field type
+    }
+
+    /* Remove >32 decimals from old files */
+    if (share->mysql_version < 100200 &&
+        (attr.pack_flag & FIELDFLAG_LONG_DECIMAL))
+    {
+      share->keep_original_mysql_version= 1;
+      attr.pack_flag&= ~FIELDFLAG_LONG_DECIMAL;
+    }
+
+    if (interval_nr && attr.charset->mbminlen > 1 &&
+        !interval_unescaped[interval_nr - 1])
+    {
+      /*
+        Unescape UCS2/UTF16/UTF32 intervals from HEX notation.
+        Note, ENUM/SET columns with equal value list share a single
+        copy of TYPELIB. Unescape every TYPELIB only once.
+      */
+      TYPELIB *interval= share->intervals + interval_nr - 1;
+      unhex_type2(interval);
+      interval_unescaped[interval_nr - 1]= true;
+    }
+
+#ifndef TO_BE_DELETED_ON_PRODUCTION
+    if (handler->real_field_type() == MYSQL_TYPE_NEWDECIMAL &&
+        !share->mysql_version)
+    {
+      /*
+        Fix pack length of old decimal values from 5.0.3 -> 5.0.4
+        The difference is that in the old version we stored precision
+        in the .frm table while we now store the display_length
+      */
+      uint decimals= f_decimals(attr.pack_flag);
+      attr.length=
+        my_decimal_precision_to_length((uint) attr.length, decimals,
+                                       f_is_dec(attr.pack_flag) == 0);
+      sql_print_error("Found incompatible DECIMAL field '%s' in %s; "
+                      "Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
+                      share->fieldnames.type_names[i], share->table_name.str,
+                      share->table_name.str);
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_CRASHED_ON_USAGE,
+                          "Found incompatible DECIMAL field '%s' in %s; "
+                          "Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
+                          share->fieldnames.type_names[i],
+                          share->table_name.str,
+                          share->table_name.str);
+      share->crashed= 1;                        // Marker for CHECK TABLE
+    }
+#endif
+
+    if (mysql57_null_bits && vcol_info && !vcol_info->stored_in_db)
+    {
+      swap_variables(uchar*, null_pos, mysql57_vcol_null_pos);
+      swap_variables(uint, null_bit_pos, mysql57_vcol_null_bit_pos);
+    }
+
+    if (versioned)
+    {
+      if (i == vers.start_fieldno)
+        flags|= VERS_ROW_START;
+      else if (i == vers.end_fieldno)
+        flags|= VERS_ROW_END;
+
+      if (flags & VERS_SYSTEM_FIELD)
+      {
+        auto field_type= handler->real_field_type();
+
+        DBUG_EXECUTE_IF("error_vers_wrong_type", field_type= MYSQL_TYPE_BLOB;);
+
+        switch (field_type) {
+        case MYSQL_TYPE_TIMESTAMP2:
+          break;
+        case MYSQL_TYPE_LONGLONG:
+          if (vers_can_native)
+          {
+            versioned= VERS_TRX_ID;
+            break;
+          }
+          /* Fallthrough */
+        default:
+          my_error(ER_VERS_FIELD_WRONG_TYPE,
+                   (field_type == MYSQL_TYPE_LONGLONG ?
+                    MYF(0) : MYF(ME_WARNING)),
+                   fieldnames.type_names[i],
+                   (versioned == VERS_TIMESTAMP ?
+                    "TIMESTAMP(6)" : "BIGINT(20) UNSIGNED"),
+                   table_name.str);
+          goto err;
+        }
+      }
+    }
+
+    /* Convert pre-10.2.2 timestamps to use Field::default_value */
+    name.str= fieldnames.type_names[i];
+    name.length= strlen(name.str);
+    attr.interval= interval_nr ? share->intervals + interval_nr - 1 : NULL;
+    Record_addr addr(record + recpos, null_pos, null_bit_pos);
+    *field_ptr= reg_field=
+      attr.make_field(share, &share->mem_root, &addr, handler, &name, flags);
+    if (!reg_field)				// Not supported field type
+      goto err;
+
+    if (attr.unireg_check == Field::TIMESTAMP_DNUN_FIELD ||
+        attr.unireg_check == Field::TIMESTAMP_DN_FIELD)
+    {
+      reg_field->default_value= new (&share->mem_root) Virtual_column_info();
+      reg_field->default_value->set_vcol_type(VCOL_DEFAULT);
+      reg_field->default_value->stored_in_db= 1;
+      share->default_expressions++;
+    }
+
+    reg_field->field_index= i;
+    reg_field->comment=comment;
+    reg_field->vcol_info= vcol_info;
+    reg_field->flags|= flags;
+    if (extra2.field_flags.str)
+    {
+      uchar flags= *extra2.field_flags.str++;
+      if (flags & VERS_OPTIMIZED_UPDATE)
+        reg_field->flags|= VERS_UPDATE_UNVERSIONED_FLAG;
+
+      reg_field->invisible= f_visibility(flags);
+    }
+    if (reg_field->invisible == INVISIBLE_USER)
+      status_var_increment(thd->status_var.feature_invisible_columns);
+    if (!reg_field->invisible)
+      share->visible_fields++;
+    if (handler->real_field_type() == MYSQL_TYPE_BIT &&
+        !f_bit_as_char(attr.pack_flag))
+    {
+      null_bits_are_used= 1;
+      if ((null_bit_pos+= (uint) (attr.length & 7)) > 7)
+      {
+        null_pos++;
+        null_bit_pos-= 8;
+      }
+    }
+    if (!(reg_field->flags & NOT_NULL_FLAG))
+    {
+      if (!(null_bit_pos= (null_bit_pos + 1) & 7))
+        null_pos++;
+    }
+
+    if (vcol_info)
+    {
+      vcol_info->name= reg_field->field_name;
+      if (mysql57_null_bits && !vcol_info->stored_in_db)
+      {
+        /* MySQL 5.7 has null bits last */
+        swap_variables(uchar*, null_pos, mysql57_vcol_null_pos);
+        swap_variables(uint, null_bit_pos, mysql57_vcol_null_bit_pos);
+      }
+    }
+
+    if (f_no_default(attr.pack_flag))
+      reg_field->flags|= NO_DEFAULT_VALUE_FLAG;
+
+    if (reg_field->unireg_check == Field::NEXT_NUMBER)
+      share->found_next_number_field= field_ptr;
+
+    if (use_hash && my_hash_insert(&share->name_hash, (uchar*) field_ptr))
+      goto err;
+    if (!reg_field->stored_in_db())
+    {
+      share->stored_fields--;
+      if (share->stored_rec_length>=recpos)
+        share->stored_rec_length= recpos-1;
+    }
+    if (reg_field->has_update_default_function())
+    {
+      has_update_default_function= 1;
+      if (!reg_field->default_value)
+        share->default_fields++;
+    }
+  }
+  *field_ptr=0;					// End marker
+  /* Sanity checks: */
+  DBUG_ASSERT(share->fields>=share->stored_fields);
+  DBUG_ASSERT(share->reclength>=share->stored_rec_length);
+
+  if (mysql57_null_bits)
+  {
+    /* We want to store the value for the last bits */
+    swap_variables(uchar*, null_pos, mysql57_vcol_null_pos);
+    swap_variables(uint, null_bit_pos, mysql57_vcol_null_bit_pos);
+    DBUG_ASSERT((null_pos + (null_bit_pos + 7) / 8) <= share->field[0]->ptr);
+  }
+
+  /* Fix key->name and key_part->field */
+  if (key_parts)
+  {
+    keyinfo= share->key_info;
+    uint hash_field_used_no= share->fields - hash_fields;
+    KEY_PART_INFO *hash_keypart;
+    Field *hash_field;
+    uint offset= share->reclength - HA_HASH_FIELD_LENGTH * hash_fields;
+    for (uint i= 0; i < share->keys; i++, keyinfo++)
+    {
+      /* We need set value in hash key_part */
+      if (keyinfo->algorithm == HA_KEY_ALG_LONG_HASH)
+      {
+        share->long_unique_table= 1;
+        hash_keypart= keyinfo->key_part + keyinfo->user_defined_key_parts;
+        hash_keypart->length= HA_HASH_KEY_LENGTH_WITHOUT_NULL;
+        hash_keypart->store_length= hash_keypart->length;
+        hash_keypart->type= HA_KEYTYPE_ULONGLONG;
+        hash_keypart->key_part_flag= 0;
+        hash_keypart->key_type= 32834;
+        /* Last n fields are unique_index_hash fields*/
+        hash_keypart->offset= offset;
+        hash_keypart->fieldnr= hash_field_used_no + 1;
+        hash_field= share->field[hash_field_used_no];
+        hash_field->flags|= LONG_UNIQUE_HASH_FIELD;//Used in parse_vcol_defs
+        keyinfo->flags|= HA_NOSAME;
+        share->virtual_fields++;
+        share->stored_fields--;
+        if (record + share->stored_rec_length >= hash_field->ptr)
+          share->stored_rec_length= (ulong)(hash_field->ptr - record - 1);
+        hash_field_used_no++;
+        offset+= HA_HASH_FIELD_LENGTH;
+      }
+    }
+    uint add_first_key_parts= 0;
+    longlong ha_option= handler_file->ha_table_flags();
+    keyinfo= share->key_info;
+    uint primary_key= my_strcasecmp(system_charset_info,
+                                    share->keynames.type_names[0],
+                                    primary_key_name.str) ? MAX_KEY : 0;
+    KEY* key_first_info= NULL;
+
+    if (primary_key >= MAX_KEY && keyinfo->flags & HA_NOSAME &&
+        keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
+    {
+      /*
+        If the UNIQUE key doesn't have NULL columns and is not a part key
+        declare this as a primary key.
+      */
+      primary_key= 0;
+      key_part= keyinfo->key_part;
+      for (i=0 ; i < keyinfo->user_defined_key_parts ;i++)
+      {
+        DBUG_ASSERT(key_part[i].fieldnr > 0);
+        // Table field corresponding to the i'th key part.
+        Field *table_field= share->field[key_part[i].fieldnr - 1];
+
+        /*
+          If the key column is of NOT NULL BLOB type, then it
+          will definitly have key prefix. And if key part prefix size
+          is equal to the BLOB column max size, then we can promote
+          it to primary key.
+        */
+        if (!table_field->real_maybe_null() &&
+            table_field->type() == MYSQL_TYPE_BLOB &&
+            table_field->field_length == key_part[i].length)
+          continue;
+
+        if (table_field->real_maybe_null() ||
+            table_field->key_length() != key_part[i].length)
+        {
+          primary_key= MAX_KEY;		// Can't be used
+          break;
+        }
+      }
+    }
+
+    /*
+      Make sure that the primary key is not marked as IGNORE
+      This can happen in the case
+        1) when IGNORE is mentioned in the Key specification
+        2) When a unique NON-NULLABLE key is promted to a primary key.
+           The unqiue key could have been marked as IGNORE when there
+           was a primary key in the table.
+
+           Eg:
+            CREATE TABLE t1(a INT NOT NULL, primary key(a), UNIQUE key1(a))
+             so for this table when we try to IGNORE key1
+             then we run:
+                ALTER TABLE t1 ALTER INDEX key1 IGNORE
+              this runs successsfully and key1 is marked as IGNORE.
+
+              But lets say then we drop the primary key
+               ALTER TABLE t1 DROP PRIMARY
+              then the UNIQUE key will be promoted to become the primary key
+              but then the UNIQUE key cannot be marked as IGNORE, so an
+              error is thrown
+    */
+    if (primary_key != MAX_KEY && keyinfo && keyinfo->is_ignored)
+    {
+        my_error(ER_PK_INDEX_CANT_BE_IGNORED, MYF(0));
+        goto err;
+    }
+
+    if (share->use_ext_keys)
+    {
+      if (primary_key >= MAX_KEY)
+      {
+        add_first_key_parts= 0;
+        share->set_use_ext_keys_flag(FALSE);
+      }
+      else
+      {
+        add_first_key_parts= first_keyinfo.user_defined_key_parts;
+        /* 
+          Do not add components of the primary key starting from
+          the major component defined over the beginning of a field.
+	*/
+	for (i= 0; i < first_keyinfo.user_defined_key_parts; i++)
+	{
+          uint fieldnr= keyinfo[0].key_part[i].fieldnr;
+          if (share->field[fieldnr-1]->key_length() !=
+              keyinfo[0].key_part[i].length)
+	  {
+            add_first_key_parts= i;
+            break;
+          }
+        }
+      }   
+    }
+
+    key_first_info= keyinfo;
+    for (uint key=0 ; key < keys ; key++,keyinfo++)
+    {
+      uint usable_parts= 0;
+      keyinfo->name.str=    share->keynames.type_names[key];
+      keyinfo->name.length= strlen(keyinfo->name.str);
+      keyinfo->cache_name=
+        (uchar*) alloc_root(&share->mem_root,
+                            share->table_cache_key.length+
+                            keyinfo->name.length + 1);
+      if (keyinfo->cache_name)           // If not out of memory
+      {
+        uchar *pos= keyinfo->cache_name;
+        memcpy(pos, share->table_cache_key.str, share->table_cache_key.length);
+        memcpy(pos + share->table_cache_key.length, keyinfo->name.str,
+               keyinfo->name.length+1);
+      }
+
+      if (ext_key_parts > share->key_parts && key)
+      {
+        KEY_PART_INFO *new_key_part= (keyinfo-1)->key_part +
+                                     (keyinfo-1)->ext_key_parts;
+        uint add_keyparts_for_this_key= add_first_key_parts;
+        uint len_null_byte= 0, ext_key_length= 0;
+        Field *field;
+
+        if ((keyinfo-1)->algorithm == HA_KEY_ALG_LONG_HASH)
+          new_key_part++; // reserved for the hash value
+
+        /* 
+          Do not extend the key that contains a component
+          defined over the beginning of a field.
+	*/ 
+        for (i= 0; i < keyinfo->user_defined_key_parts; i++)
+        {
+          uint length_bytes= 0;
+          uint fieldnr= keyinfo->key_part[i].fieldnr;
+          field= share->field[fieldnr-1];
+
+          if (field->null_ptr)
+            len_null_byte= HA_KEY_NULL_LENGTH;
+
+          if (keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
+            length_bytes= field->key_part_length_bytes();
+
+          ext_key_length+= keyinfo->key_part[i].length + len_null_byte
+                            + length_bytes;
+          if (field->key_length() != keyinfo->key_part[i].length)
+	  {
+            add_keyparts_for_this_key= 0;
+            break;
+          }
+        }
+
+        if (add_keyparts_for_this_key)
+        {
+          for (i= 0; i < add_keyparts_for_this_key; i++)
+          {
+            uint pk_part_length= key_first_info->key_part[i].store_length;
+            if (keyinfo->ext_key_part_map & 1<<i)
+            {
+              if (ext_key_length + pk_part_length > MAX_DATA_LENGTH_FOR_KEY)
+              {
+                add_keyparts_for_this_key= i;
+                break;
+              }
+              ext_key_length+= pk_part_length;
+            }
+          }
+        }
+
+        if (add_keyparts_for_this_key < keyinfo->ext_key_parts -
+                                        keyinfo->user_defined_key_parts)
+        {
+          share->ext_key_parts-= keyinfo->ext_key_parts;
+          key_part_map ext_key_part_map= keyinfo->ext_key_part_map;
+          keyinfo->ext_key_parts= keyinfo->user_defined_key_parts;
+          keyinfo->ext_key_flags= keyinfo->flags;
+	  keyinfo->ext_key_part_map= 0; 
+          for (i= 0; i < add_keyparts_for_this_key; i++)
+	  {
+            if (ext_key_part_map & 1<<i)
+	    {
+              keyinfo->ext_key_part_map|= 1<<i;
+	      keyinfo->ext_key_parts++;
+            }
+          }
+          share->ext_key_parts+= keyinfo->ext_key_parts;
+        }
+        if (new_key_part != keyinfo->key_part)
+	{
+          memmove(new_key_part, keyinfo->key_part,
+                  sizeof(KEY_PART_INFO) * keyinfo->ext_key_parts);
+          keyinfo->key_part= new_key_part;
+        }
+      }
+ 
+      /* Fix fulltext keys for old .frm files */
+      if (share->key_info[key].flags & HA_FULLTEXT)
+	share->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT;
+
+      key_part= keyinfo->key_part;
+      uint key_parts= share->use_ext_keys ? keyinfo->ext_key_parts :
+	                                    keyinfo->user_defined_key_parts;
+      if (keyinfo->algorithm == HA_KEY_ALG_LONG_HASH)
+        key_parts++;
+      for (i=0; i < key_parts; key_part++, i++)
+      {
+        Field *field;
+	if (new_field_pack_flag <= 1)
+	  key_part->fieldnr= find_field(share->field,
+                                        share->default_values,
+                                        (uint) key_part->offset,
+                                        (uint) key_part->length);
+	if (!key_part->fieldnr)
+          goto err;
+
+        field= key_part->field= share->field[key_part->fieldnr-1];
+        if (Charset::collation_changed_order(share->mysql_version,
+                                             field->charset()->number))
+          share->incompatible_version|= HA_CREATE_USED_CHARSET;
+        key_part->type= field->key_type();
+
+        if (field->invisible > INVISIBLE_USER && !field->vers_sys_field())
+          if (keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
+            keyinfo->flags |= HA_INVISIBLE_KEY;
+        if (field->null_ptr)
+        {
+          key_part->null_offset=(uint) ((uchar*) field->null_ptr -
+                                        share->default_values);
+          key_part->null_bit= field->null_bit;
+          key_part->store_length+=HA_KEY_NULL_LENGTH;
+          keyinfo->flags|=HA_NULL_PART_KEY;
+          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
+        }
+
+        key_part->key_part_flag|= field->key_part_flag();
+        uint16 key_part_length_bytes= field->key_part_length_bytes();
+        key_part->store_length+= key_part_length_bytes;
+        if (i < keyinfo->user_defined_key_parts)
+          keyinfo->key_length+= key_part_length_bytes;
+
+        if (i == 0 && key != primary_key)
+          field->flags |= (((keyinfo->flags & HA_NOSAME ||
+                            keyinfo->algorithm == HA_KEY_ALG_LONG_HASH) &&
+                           (keyinfo->user_defined_key_parts == 1)) ?
+                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
+        if (i == 0)
+          field->key_start.set_bit(key);
+        if (field->key_length() == key_part->length &&
+            !(field->flags & BLOB_FLAG) &&
+            keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
+        {
+          if (handler_file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
+          {
+            share->keys_for_keyread.set_bit(key);
+            field->part_of_key.set_bit(key);
+            if (i < keyinfo->user_defined_key_parts)
+              field->part_of_key_not_clustered.set_bit(key);
+          }
+          if (handler_file->index_flags(key, i, 1) & HA_READ_ORDER)
+            field->part_of_sortkey.set_bit(key);
+        }
+        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
+            usable_parts == i)
+          usable_parts++;			// For FILESORT
+        field->flags|= PART_KEY_FLAG;
+        if (key == primary_key)
+        {
+          field->flags|= PRI_KEY_FLAG;
+          /*
+            If this field is part of the primary key and all keys contains
+            the primary key, then we can use any key to find this column
+          */
+          if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
+          {
+            if (field->key_length() == key_part->length &&
+                !(field->flags & BLOB_FLAG))
+              field->part_of_key= share->keys_in_use;
+            if (field->part_of_sortkey.is_set(key))
+              field->part_of_sortkey= share->keys_in_use;
+          }
+        }
+        if (field->key_length() != key_part->length)
+        {
+#ifndef TO_BE_DELETED_ON_PRODUCTION
+          if (field->type() == MYSQL_TYPE_NEWDECIMAL &&
+              keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
+          {
+            /*
+              Fix a fatal error in decimal key handling that causes crashes
+              on Innodb. We fix it by reducing the key length so that
+              InnoDB never gets a too big key when searching.
+              This allows the end user to do an ALTER TABLE to fix the
+              error.
+            */
+            keyinfo->key_length-= (key_part->length - field->key_length());
+            key_part->store_length-= (uint16)(key_part->length -
+                                              field->key_length());
+            key_part->length= (uint16)field->key_length();
+            sql_print_error("Found wrong key definition in %s; "
+                            "Please do \"ALTER TABLE '%s' FORCE \" to fix it!",
+                            share->table_name.str,
+                            share->table_name.str);
+            push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                                ER_CRASHED_ON_USAGE,
+                                "Found wrong key definition in %s; "
+                                "Please do \"ALTER TABLE '%s' FORCE\" to fix "
+                                "it!",
+                                share->table_name.str,
+                                share->table_name.str);
+            share->crashed= 1;                // Marker for CHECK TABLE
+            continue;
+          }
+#endif
+          key_part->key_part_flag|= HA_PART_KEY_SEG;
+        }
+        if (field->real_maybe_null())
+          key_part->key_part_flag|= HA_NULL_PART;
+        /*
+          Sometimes we can compare key parts for equality with memcmp.
+          But not always.
+        */
+        if (!(key_part->key_part_flag & (HA_BLOB_PART | HA_VAR_LENGTH_PART |
+                                         HA_BIT_PART)) &&
+            key_part->type != HA_KEYTYPE_FLOAT &&
+            key_part->type == HA_KEYTYPE_DOUBLE &&
+            keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
+          key_part->key_part_flag|= HA_CAN_MEMCMP;
+      }
+      keyinfo->usable_key_parts= usable_parts; // Filesort
+
+      set_if_bigger(share->max_key_length,keyinfo->key_length+
+                    keyinfo->user_defined_key_parts);
+      /*
+        MERGE tables do not have unique indexes. But every key could be
+        an unique index on the underlying MyISAM table. (Bug #10400)
+      */
+      if ((keyinfo->flags & HA_NOSAME) ||
+          (ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
+        set_if_bigger(share->max_unique_length,keyinfo->key_length);
+    }
+    if (primary_key < MAX_KEY &&
+	(share->keys_in_use.is_set(primary_key)))
+    {
+      share->primary_key= primary_key;
+      /*
+	If we are using an integer as the primary key then allow the user to
+	refer to it as '_rowid'
+      */
+      if (share->key_info[primary_key].user_defined_key_parts == 1)
+      {
+	Field *field= share->key_info[primary_key].key_part[0].field;
+	if (field && field->result_type() == INT_RESULT)
+        {
+          /* note that fieldnr here (and rowid_field_offset) starts from 1 */
+	  share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
+                                      fieldnr);
+        }
+      }
+    }
+    else
+      share->primary_key = MAX_KEY; // we do not have a primary key
+  }
+  else
+    share->primary_key= MAX_KEY;
+  if (new_field_pack_flag <= 1)
+  {
+    /* Old file format with default as not null */
+    uint null_length= (share->null_fields+7)/8;
+    bfill(share->default_values + (null_flags - (uchar*) record),
+          null_length, 255);
+  }
+
+  set_overlapped_keys();
+
+  /* Handle virtual expressions */
+  if (vcol_screen_length && share->frm_version >= FRM_VER_EXPRESSSIONS)
+  {
+    uchar *vcol_screen_end= vcol_screen_pos + vcol_screen_length;
+
+    /* Skip header */
+    vcol_screen_pos+= FRM_VCOL_NEW_BASE_SIZE;
+    share->vcol_defs.str+= FRM_VCOL_NEW_BASE_SIZE;
+    share->vcol_defs.length-= FRM_VCOL_NEW_BASE_SIZE;
+
+    /*
+      Read virtual columns, default values and check constraints
+      See pack_expression() for how data is stored
+    */
+    while (vcol_screen_pos < vcol_screen_end)
+    {
+      Virtual_column_info *vcol_info;
+      uint type=         (uint) vcol_screen_pos[0];
+      uint field_nr=     uint2korr(vcol_screen_pos+1);
+      uint expr_length=  uint2korr(vcol_screen_pos+3);
+      uint name_length=  (uint) vcol_screen_pos[5];
+
+      if (!(vcol_info=   new (&share->mem_root) Virtual_column_info()))
+        goto err;
+
+      /* The following can only be true for check_constraints */
+
+      if (field_nr != UINT_MAX16)
+      {
+        DBUG_ASSERT(field_nr < share->fields);
+        reg_field= share->field[field_nr];
+      }
+      else
+      {
+        reg_field= 0;
+        DBUG_ASSERT(name_length);
+      }
+
+      vcol_screen_pos+= FRM_VCOL_NEW_HEADER_SIZE;
+      vcol_info->set_vcol_type((enum_vcol_info_type) type);
+      if (name_length)
+      {
+        vcol_info->name.str= strmake_root(&share->mem_root,
+                                          (char*)vcol_screen_pos, name_length);
+        vcol_info->name.length= name_length;
+      }
+      else
+        vcol_info->name= reg_field->field_name;
+      vcol_screen_pos+= name_length + expr_length;
+
+      switch (type) {
+      case VCOL_GENERATED_VIRTUAL:
+      {
+        uint recpos;
+        reg_field->vcol_info= vcol_info;
+        share->virtual_fields++;
+        share->stored_fields--;
+        if (reg_field->flags & BLOB_FLAG)
+          share->virtual_not_stored_blob_fields++;
+        if (reg_field->flags & PART_KEY_FLAG)
+          vcol_info->set_vcol_type(VCOL_GENERATED_VIRTUAL_INDEXED);
+        /* Correct stored_rec_length as non stored fields are last */
+        recpos= (uint) (reg_field->ptr - record);
+        if (share->stored_rec_length >= recpos)
+          share->stored_rec_length= recpos-1;
+        break;
+      }
+      case VCOL_GENERATED_STORED:
+        vcol_info->stored_in_db= 1;
+        DBUG_ASSERT(!reg_field->vcol_info);
+        reg_field->vcol_info= vcol_info;
+        share->virtual_fields++;
+        break;
+      case VCOL_DEFAULT:
+        vcol_info->stored_in_db= 1;
+        DBUG_ASSERT(!reg_field->default_value);
+        reg_field->default_value=    vcol_info;
+        share->default_expressions++;
+        break;
+      case VCOL_CHECK_FIELD:
+        DBUG_ASSERT(!reg_field->check_constraint);
+        reg_field->check_constraint= vcol_info;
+        share->field_check_constraints++;
+        break;
+      case VCOL_CHECK_TABLE:
+        *(table_check_constraints++)= vcol_info;
+        break;
+      }
+    }
+  }
+  DBUG_ASSERT((uint) (table_check_constraints - share->check_constraints) ==
+              (uint) (share->table_check_constraints -
+                      share->field_check_constraints));
+
+  if (options.str)
+  {
+    DBUG_ASSERT(options.length);
+    if (engine_table_options_frm_read(options.str, options.length, share))
+      goto err;
+  }
+  if (parse_engine_table_options(thd, handler_file->partition_ht(), share))
+    goto err;
+
+  if (share->found_next_number_field)
+  {
+    reg_field= *share->found_next_number_field;
+    if ((int) (share->next_number_index= (uint)
+	       find_ref_key(share->key_info, keys,
+                            share->default_values, reg_field,
+			    &share->next_number_key_offset,
+                            &share->next_number_keypart)) < 0)
+      goto err; // Wrong field definition
+    reg_field->flags |= AUTO_INCREMENT_FLAG;
+  }
+
+  if (share->blob_fields)
+  {
+    Field **ptr;
+    uint k, *save;
+
+    /* Store offsets to blob fields to find them fast */
+    if (!(share->blob_field= save=
+	  (uint*) alloc_root(&share->mem_root,
+                             (uint) (share->blob_fields* sizeof(uint)))))
+      goto err;
+    for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
+    {
+      if ((*ptr)->flags & BLOB_FLAG)
+	(*save++)= k;
+    }
+  }
+
+  /*
+    the correct null_bytes can now be set, since bitfields have been taken
+    into account
+  */
+  share->null_bytes= (uint)(null_pos - (uchar*) null_flags +
+                      (null_bit_pos + 7) / 8);
+  share->last_null_bit_pos= null_bit_pos;
+  share->null_bytes_for_compare= null_bits_are_used ? share->null_bytes : 0;
+  share->can_cmp_whole_record= (share->blob_fields == 0 &&
+                                share->varchar_fields == 0);
+
+  share->column_bitmap_size= bitmap_buffer_size(share->fields);
+
+  bitmap_count= 1;
+  if (share->table_check_constraints)
+  {
+    feature_check_constraint++;
+    if (!(share->check_set= (MY_BITMAP*)
+          alloc_root(&share->mem_root, sizeof(*share->check_set))))
+      goto err;
+    bitmap_count++;
+  }
+  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
+                                             share->column_bitmap_size *
+                                             bitmap_count)))
+    goto err;
+  my_bitmap_init(&share->all_set, bitmaps, share->fields);
+  bitmap_set_all(&share->all_set);
+  if (share->check_set)
+  {
+    /*
+      Bitmap for fields used by CHECK constraint. Will be filled up
+      at first usage of table.
+    */
+    my_bitmap_init(share->check_set,
+                   (my_bitmap_map*) ((uchar*) bitmaps +
+                                     share->column_bitmap_size),
+                   share->fields);
+    bitmap_clear_all(share->check_set);
+  }
+
+#ifndef DBUG_OFF
+  if (use_hash)
+    (void) my_hash_check(&share->name_hash);
+#endif
+
+  share->db_plugin= se_plugin;
+  delete handler_file;
+
+  share->error= OPEN_FRM_OK;
+  thd->status_var.opened_shares++;
+  thd->mem_root= old_root;
+  my_afree(interval_unescaped);
+  DBUG_RETURN(0);
+
+err:
+  if (frm_created)
+  {
+    char path[FN_REFLEN+1];
+    strxnmov(path, FN_REFLEN, normalized_path.str, reg_ext, NullS);
+    my_delete(path, MYF(0));
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+    if (par_image)
+    {
+      strxnmov(path, FN_REFLEN, normalized_path.str, PAR_EXT, NullS);
+      my_delete(path, MYF(0));
+    }
+#endif
+  }
+  share->db_plugin= NULL;
+  share->error= OPEN_FRM_CORRUPTED;
+  share->open_errno= my_errno;
+  delete handler_file;
+  plugin_unlock(0, se_plugin);
+  my_hash_free(&share->name_hash);
+
+  if (!thd->is_error())
+    open_table_error(share, OPEN_FRM_CORRUPTED, share->open_errno);
+
+  thd->mem_root= old_root;
+  my_afree(interval_unescaped);
+  DBUG_RETURN(HA_ERR_NOT_A_TABLE);
+}
+
+
+static bool sql_unusable_for_discovery(THD *thd, handlerton *engine,
+                                       const char *sql)
+{
+  LEX *lex= thd->lex;
+  HA_CREATE_INFO *create_info= &lex->create_info;
+
+  // ... not CREATE TABLE
+  if (lex->sql_command != SQLCOM_CREATE_TABLE &&
+      lex->sql_command != SQLCOM_CREATE_SEQUENCE)
+    return 1;
+  // ... create like
+  if (lex->create_info.like())
+    return 1;
+  // ... create select
+  if (lex->first_select_lex()->item_list.elements)
+    return 1;
+  // ... temporary
+  if (create_info->tmp_table())
+    return 1;
+  // ... if exists
+  if (lex->create_info.if_not_exists())
+    return 1;
+
+  // XXX error out or rather ignore the following:
+  // ... partitioning
+  if (lex->part_info)
+    return 1;
+  // ... union
+  if (create_info->used_fields & HA_CREATE_USED_UNION)
+    return 1;
+  // ... index/data directory
+  if (create_info->data_file_name || create_info->index_file_name)
+    return 1;
+  // ... engine
+  DBUG_ASSERT(lex->m_sql_cmd);
+  if (lex->create_info.used_fields & HA_CREATE_USED_ENGINE)
+  {
+    /*
+      TODO: we could just compare engine names here, without resolving.
+      But this optimization is too late for 10.1.
+    */
+    Storage_engine_name *opt= lex->m_sql_cmd->option_storage_engine_name();
+    DBUG_ASSERT(opt); // lex->m_sql_cmd must be an Sql_cmd_create_table instance
+    if (opt->resolve_storage_engine_with_error(thd, &create_info->db_type,
+                                               false) ||
+        (create_info->db_type && create_info->db_type != engine))
+      return 1;
+  }
+  // ... WITH SYSTEM VERSIONING
+  if (create_info->versioned())
+    return 1;
+
+  return 0;
+}
+
+int TABLE_SHARE::init_from_sql_statement_string(THD *thd, bool write,
+                                        const char *sql, size_t sql_length)
+{
+  CHARSET_INFO *old_cs= thd->variables.character_set_client;
+  Parser_state parser_state;
+  bool error;
+  char *sql_copy;
+  handler *file;
+  LEX *old_lex;
+  LEX tmp_lex;
+  KEY *unused1;
+  uint unused2;
+  handlerton *hton= plugin_hton(db_plugin);
+  LEX_CUSTRING frm= {0,0};
+  LEX_CSTRING db_backup= thd->db;
+  DBUG_ENTER("TABLE_SHARE::init_from_sql_statement_string");
+
+  /*
+    Ouch. Parser may *change* the string it's working on.
+    Currently (2013-02-26) it is used to permanently disable
+    conditional comments.
+    Anyway, let's copy the caller's string...
+  */
+  if (!(sql_copy= thd->strmake(sql, sql_length)))
+    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+
+  if (parser_state.init(thd, sql_copy, sql_length))
+    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+
+  Sql_mode_instant_set sms(thd, MODE_NO_ENGINE_SUBSTITUTION | MODE_NO_DIR_IN_CREATE);
+  thd->variables.character_set_client= system_charset_info;
+  tmp_disable_binlog(thd);
+  old_lex= thd->lex;
+  thd->lex= &tmp_lex;
+
+
+  /*
+    THD::reset_db() does not set THD::db_charset,
+    so it keeps pointing to the character set and collation
+    of the current database, rather than the database of the
+    new initialized table. After reset_db() the result of
+    get_default_db_collation() can be wrong. The latter is
+    used inside charset_collation_context_create_table_in_db().
+    Let's initialize ctx before calling reset_db().
+    This makes sure the db.opt file to be loaded properly when needed.
+  */
+  Charset_collation_context
+    ctx(thd->charset_collation_context_create_table_in_db(db.str));
+
+  thd->reset_db(&db);
+  lex_start(thd);
+
+  if (unlikely((error= parse_sql(thd, & parser_state, NULL) ||
+                sql_unusable_for_discovery(thd, hton, sql_copy))))
+    goto ret;
+
+  if (thd->lex->create_info.resolve_to_charset_collation_context(thd, ctx))
+    DBUG_RETURN(true);
+
+  tmp_lex.create_info.db_type= hton;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  thd->work_part_info= 0;                       // For partitioning
+#endif
+
+  if (tabledef_version.str)
+    tmp_lex.create_info.tabledef_version= tabledef_version;
+
+  tmp_lex.alter_info.db= db;
+  tmp_lex.alter_info.table_name= table_name;
+  promote_first_timestamp_column(&tmp_lex.alter_info.create_list);
+  file= mysql_create_frm_image(thd, &tmp_lex.create_info, &tmp_lex.alter_info,
+                               C_ORDINARY_CREATE, &unused1, &unused2, &frm);
+  error|= file == 0;
+  delete file;
+
+  if (frm.str)
+  {
+    option_list= 0;             // cleanup existing options ...
+    option_struct= 0;           // ... if it's an assisted discovery
+    error= init_from_binary_frm_image(thd, write, frm.str, frm.length);
+  }
+
+ret:
+  my_free(const_cast<uchar*>(frm.str));
+  lex_end(&tmp_lex);
+  thd->reset_db(&db_backup);
+  thd->lex= old_lex;
+  reenable_binlog(thd);
+  thd->variables.character_set_client= old_cs;
+  if (unlikely(thd->is_error() || error))
+  {
+    thd->clear_error();
+    my_error(ER_SQL_DISCOVER_ERROR, MYF(0), hton_name(hton)->str,
+             db.str, table_name.str, sql_copy);
+    DBUG_RETURN(HA_ERR_GENERIC);
+  }
+  /* Treat the table as normal table from binary logging point of view */
+  table_creation_was_logged= 1;
+  DBUG_RETURN(0);
+}
+
+bool TABLE_SHARE::write_frm_image(const uchar *frm, size_t len)
+{
+  char file_name[FN_REFLEN+1];
+  strxnmov(file_name, sizeof(file_name)-1, normalized_path.str, reg_ext,
+           NullS);
+  return writefile(file_name, db.str, table_name.str, false,
+                   frm, len);
+}
+
+bool TABLE_SHARE::write_par_image(const uchar *par, size_t len)
+{
+  char file_name[FN_REFLEN+1];
+  strxnmov(file_name, sizeof(file_name)-1, normalized_path.str, PAR_EXT,
+           NullS);
+  return writefile(file_name, db.str, table_name.str, false, par, len);
+}
+
+
+bool TABLE_SHARE::read_frm_image(const uchar **frm, size_t *len)
+{
+  if (IF_PARTITIONING(partition_info_str, 0))   // cannot discover a partition
+  {
+    DBUG_ASSERT(db_type()->discover_table == 0);
+    return 1;
+  }
+
+  if (frm_image)
+  {
+    *frm= frm_image->str;
+    *len= frm_image->length;
+    frm_image->str= 0; // pass the ownership to the caller
+    frm_image= 0;
+    return 0;
+  }
+  return readfrm(normalized_path.str, frm, len);
+}
+
+
+void TABLE_SHARE::free_frm_image(const uchar *frm)
+{
+  if (frm)
+    my_free(const_cast<uchar*>(frm));
+}
+
+
+bool Virtual_column_info::fix_expr(THD *thd)
+{
+  DBUG_ENTER("fix_vcol_expr");
+
+  const enum enum_column_usage saved_column_usage= thd->column_usage;
+  thd->column_usage= COLUMNS_WRITE;
+
+  int error= expr->fix_fields(thd, &expr);
+
+  thd->column_usage= saved_column_usage;
+
+  if (unlikely(error))
+  {
+    StringBuffer<MAX_FIELD_WIDTH> str;
+    print(&str);
+    my_error(ER_ERROR_EVALUATING_EXPRESSION, MYF(0), str.c_ptr_safe());
+    DBUG_RETURN(1);
+  }
+
+  DBUG_RETURN(0);
+}
+
+/** rerun fix_fields for vcols that returns time- or session- dependent values
+
+    @note this is done for all vcols for INSERT/UPDATE/DELETE,
+    and only as needed for SELECTs.
+*/
+bool Virtual_column_info::fix_session_expr(THD *thd)
+{
+  if (!need_refix())
+    return false;
+
+  DBUG_ASSERT(!expr->fixed());
+  return fix_expr(thd);
+}
+
+
+bool Virtual_column_info::cleanup_session_expr()
+{
+  DBUG_ASSERT(need_refix());
+  return expr->walk(&Item::cleanup_excluding_fields_processor, 0, 0);
+}
+
+
+
+class Vcol_expr_context
+{
+  bool inited;
+  THD *thd;
+  TABLE *table;
+  Query_arena backup_arena, *stmt_arena;
+  table_map old_map;
+  Security_context *save_security_ctx;
+  sql_mode_t save_sql_mode;
+
+public:
+  Vcol_expr_context(THD *_thd, TABLE *_table) :
+    inited(false),
+    thd(_thd),
+    table(_table),
+    stmt_arena(thd->stmt_arena),
+    old_map(table->map),
+    save_security_ctx(thd->security_ctx),
+    save_sql_mode(thd->variables.sql_mode) {}
+  bool init();
+
+  ~Vcol_expr_context();
+};
+
+
+bool Vcol_expr_context::init()
+{
+  thd->variables.sql_mode= 0;
+
+  TABLE_LIST const *tl= table->pos_in_table_list;
+  DBUG_ASSERT(table->pos_in_table_list);
+
+  if (table->pos_in_table_list->security_ctx)
+    thd->security_ctx= tl->security_ctx;
+
+  thd->set_n_backup_active_arena(table->expr_arena, &backup_arena);
+  thd->stmt_arena= thd;
+
+  inited= true;
+  return false;
+}
+
+Vcol_expr_context::~Vcol_expr_context()
+{
+  if (!inited)
+    return;
+  table->map= old_map;
+  thd->security_ctx= save_security_ctx;
+  thd->restore_active_arena(table->expr_arena, &backup_arena);
+  thd->variables.sql_mode= save_sql_mode;
+  thd->stmt_arena= stmt_arena;
+}
+
+
+bool TABLE::vcol_fix_expr(THD *thd)
+{
+  if (pos_in_table_list->placeholder() || vcol_refix_list.is_empty())
+    return false;
+
+  if (!thd->stmt_arena->is_conventional() &&
+      vcol_refix_list.head()->expr->fixed())
+  {
+    /* NOTE: Under trigger we already have fixed expressions */
+    return false;
+  }
+
+  Vcol_expr_context expr_ctx(thd, this);
+  if (expr_ctx.init())
+    return true;
+
+  List_iterator_fast<Virtual_column_info> it(vcol_refix_list);
+  while (Virtual_column_info *vcol= it++)
+    if (vcol->fix_session_expr(thd))
+      goto error;
+
+  return false;
+
+error:
+  DBUG_ASSERT(thd->get_stmt_da()->is_error());
+  return true;
+}
+
+
+bool TABLE::vcol_cleanup_expr(THD *thd)
+{
+  if (vcol_refix_list.is_empty())
+    return false;
+
+  List_iterator<Virtual_column_info> it(vcol_refix_list);
+  bool result= false;
+
+  while (Virtual_column_info *vcol= it++)
+    result|= vcol->cleanup_session_expr();
+
+  DBUG_ASSERT(!result || thd->get_stmt_da()->is_error());
+  return result;
+}
+
+
+/*
+  @brief 
+    Perform semantic analysis of the defining expression for a virtual column
+
+  @param thd        The thread object
+  @param table      The table containing the virtual column
+  @param field	    Field if this is a DEFAULT or AS, otherwise NULL
+  @param vcol       The Virtual_column object
+
+
+  @details
+    The function performs semantic analysis of the defining expression for
+    the virtual column vcol_field. The expression is used to compute the
+    values of this column.
+
+  @retval
+    TRUE           An error occurred, something was wrong with the function
+  @retval
+    FALSE          Otherwise
+*/
+
+bool Virtual_column_info::fix_and_check_expr(THD *thd, TABLE *table)
+{
+  DBUG_ENTER("Virtual_column_info::fix_and_check_expr");
+  DBUG_PRINT("info", ("vcol: %p", this));
+  DBUG_ASSERT(expr);
+
+  /* NOTE: constants are fixed when constructed */
+  if (expr->fixed())
+    DBUG_RETURN(0); // nothing to do
+
+  if (fix_expr(thd))
+    DBUG_RETURN(1);
+
+  if (flags)
+    DBUG_RETURN(0); // already checked, no need to do it again
+
+
+  /* this was checked in check_expression(), but the frm could be mangled... */
+  if (unlikely(expr->result_type() == ROW_RESULT))
+  {
+    my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
+    DBUG_RETURN(1);
+  }
+
+  /*
+    Walk through the Item tree checking if all items are valid
+    to be part of the virtual column
+  */
+  Item::vcol_func_processor_result res;
+
+  int error= expr->walk(&Item::check_vcol_func_processor, 0, &res);
+  if (unlikely(error || (res.errors & VCOL_IMPOSSIBLE)))
+  {
+    // this can only happen if the frm was corrupted
+    my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), res.name,
+             get_vcol_type_name(), name.str);
+    DBUG_RETURN(1);
+  }
+  else if (res.errors & VCOL_AUTO_INC && vcol_type != VCOL_GENERATED_VIRTUAL)
+  {
+    /*
+      An auto_increment field may not be used in an expression for
+      a check constraint, a default value or a generated column
+
+      Note that this error condition is not detected during parsing
+      of the statement because the field item does not have a field
+      pointer at that time
+    */
+    myf warn= table->s->frm_version < FRM_VER_EXPRESSSIONS ? ME_WARNING : 0;
+    my_error(ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(warn),
+             "AUTO_INCREMENT", get_vcol_type_name(), res.name);
+    if (!warn)
+      DBUG_RETURN(1);
+  }
+  else if (vcol_type != VCOL_GENERATED_VIRTUAL && vcol_type != VCOL_DEFAULT &&
+           res.errors & VCOL_NOT_STRICTLY_DETERMINISTIC)
+  {
+    my_error(ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0),
+             res.name, get_vcol_type_name(), name.str);
+    DBUG_RETURN(1);
+  }
+  flags= res.errors;
+
+  if (!table->s->tmp_table && need_refix())
+    table->vcol_refix_list.push_back(this, &table->mem_root);
+
+  DBUG_RETURN(0);
+}
+
+
+/*
+  @brief
+    Unpack the definition of a virtual column from its linear representation
+
+  @param thd             The thread object
+  @param mem_root        Where to allocate memory
+  @param table           The table containing the virtual column
+  @param field           Field if this is a DEFAULT or AS, otherwise NULL
+  @param vcol            The Virtual_column object
+  @param[out] error_reported   Flag to inform the caller that no
+                               other error messages are to be generated
+
+  @details
+
+    The function takes string expression from the 'vcol' object of the
+    table 'table' and parses it, building an item object for it. The
+    pointer to this item is placed into in a Virtual_column_info object
+    that is created. After this the function performs
+    semantic analysis of the item by calling the the function
+    fix_and_check_vcol_expr().  Since the defining expression is part of the table
+    definition the item for it is created in table->memroot within the
+    special arena TABLE::expr_arena or in the thd memroot for INSERT DELAYED
+
+  @note
+    Before passing 'vcol_expr' to the parser the function wraps it in
+    parentheses and prepends a special keyword.
+  
+   @retval Virtual_column_info*   Success
+   @retval NULL                   Error
+*/
+
+static Virtual_column_info *
+unpack_vcol_info_from_frm(THD *thd, TABLE *table,
+                          String *expr_str, Virtual_column_info **vcol_ptr,
+                          bool *error_reported)
+{
+  Create_field vcol_storage; // placeholder for vcol_info
+  Parser_state parser_state;
+  Virtual_column_info *vcol= *vcol_ptr, *vcol_info= 0;
+  LEX *old_lex= thd->lex;
+  LEX lex;
+  bool error;
+  DBUG_ENTER("unpack_vcol_info_from_frm");
+
+  DBUG_ASSERT(vcol->expr == NULL);
+  
+  if (parser_state.init(thd, expr_str->c_ptr_safe(), expr_str->length()))
+    goto end;
+
+  if (init_lex_with_single_table(thd, table, &lex))
+    goto end;
+
+  lex.parse_vcol_expr= true;
+  lex.last_field= &vcol_storage;
+
+  error= parse_sql(thd, &parser_state, NULL);
+  if (unlikely(error))
+    goto end;
+
+  if (lex.current_select->table_list.first[0].next_global)
+  {
+    /* We are using NEXT VALUE FOR sequence. Remember table name for open */
+    TABLE_LIST *sequence= lex.current_select->table_list.first[0].next_global;
+    sequence->next_global= table->internal_tables;
+    table->internal_tables= sequence;
+  }
+
+  vcol_storage.vcol_info->set_vcol_type(vcol->get_vcol_type());
+  vcol_storage.vcol_info->stored_in_db=      vcol->stored_in_db;
+  vcol_storage.vcol_info->name=              vcol->name;
+  vcol_storage.vcol_info->utf8=              vcol->utf8;
+  if (!vcol_storage.vcol_info->fix_and_check_expr(thd, table))
+  {
+    *vcol_ptr= vcol_info= vcol_storage.vcol_info;   // Expression ok
+    DBUG_ASSERT(vcol_info->expr);
+    goto end;
+  }
+  *error_reported= TRUE;
+
+end:
+  end_lex_with_single_table(thd, table, old_lex);
+
+  DBUG_RETURN(vcol_info);
+}
+
+#ifndef DBUG_OFF
+static void print_long_unique_table(TABLE *table)
+{
+  char buff[256];
+  String str;
+  KEY *key_info_table, *key_info_share;
+  KEY_PART_INFO *key_part;
+  Field *field;
+  my_snprintf(buff, sizeof(buff), "Printing Table state, It will print table fields,"
+          " fields->offset,field->null_bit, field->null_pos and key_info ... \n"
+          "\nPrinting  Table  keyinfo\n");
+  str.append(buff, strlen(buff));
+  my_snprintf(buff, sizeof(buff), "\ntable->s->reclength %d\n"
+          "table->s->fields %d\n",
+          table->s->reclength, table->s->fields);
+  str.append(buff, strlen(buff));
+  for (uint i= 0; i < table->s->keys; i++)
+  {
+    key_info_table= table->key_info + i;
+    key_info_share= table->s->key_info + i;
+    my_snprintf(buff, sizeof(buff), "\ntable->key_info[%d] user_defined_key_parts = %d\n"
+                                    "table->key_info[%d] algorithm == HA_KEY_ALG_LONG_HASH = %d\n"
+                                    "table->key_info[%d] flags & HA_NOSAME = %d\n",
+                                   i, key_info_table->user_defined_key_parts,
+                                   i, key_info_table->algorithm == HA_KEY_ALG_LONG_HASH,
+                                   i, key_info_table->flags & HA_NOSAME);
+    str.append(buff, strlen(buff));
+    my_snprintf(buff, sizeof(buff), "\ntable->s->key_info[%d] user_defined_key_parts = %d\n"
+                                    "table->s->key_info[%d] algorithm == HA_KEY_ALG_LONG_HASH = %d\n"
+                                    "table->s->key_info[%d] flags & HA_NOSAME = %d\n",
+                                   i, key_info_share->user_defined_key_parts,
+                                   i, key_info_share->algorithm == HA_KEY_ALG_LONG_HASH,
+                                   i, key_info_share->flags & HA_NOSAME);
+    str.append(buff, strlen(buff));
+    key_part = key_info_table->key_part;
+    my_snprintf(buff, sizeof(buff), "\nPrinting table->key_info[%d].key_part[0] info\n"
+            "key_part->offset = %d\n"
+            "key_part->field_name = %s\n"
+            "key_part->length = %d\n"
+            "key_part->null_bit = %d\n"
+            "key_part->null_offset = %d\n",
+            i, key_part->offset, key_part->field->field_name.str, key_part->length,
+            key_part->null_bit, key_part->null_offset);
+    str.append(buff, strlen(buff));
+
+    for (uint j= 0; j < key_info_share->user_defined_key_parts; j++)
+    {
+      key_part= key_info_share->key_part + j;
+      my_snprintf(buff, sizeof(buff), "\nPrinting share->key_info[%d].key_part[%d] info\n"
+            "key_part->offset = %d\n"
+            "key_part->field_name = %s\n"
+            "key_part->length = %d\n"
+            "key_part->null_bit = %d\n"
+            "key_part->null_offset = %d\n",
+            i,j,key_part->offset, key_part->field->field_name.str, key_part->length,
+            key_part->null_bit, key_part->null_offset);
+      str.append(buff, strlen(buff));
+    }
+  }
+  my_snprintf(buff, sizeof(buff), "\nPrinting table->fields\n");
+  str.append(buff, strlen(buff));
+  for(uint i= 0; i < table->s->fields; i++)
+  {
+    field= table->field[i];
+    my_snprintf(buff, sizeof(buff), "\ntable->field[%d]->field_name %s\n"
+            "table->field[%d]->offset = %d\n"
+            "table->field[%d]->field_length = %d\n"
+            "table->field[%d]->null_pos wrt to record 0 = %d\n"
+            "table->field[%d]->null_bit_pos = %d\n",
+            i, field->field_name.str,
+            i, field->ptr- table->record[0],
+            i, field->pack_length(),
+            i, field->null_bit ? field->null_ptr - table->record[0] : -1,
+            i, field->null_bit);
+    str.append(buff, strlen(buff));
+  }
+  (*error_handler_hook)(1, str.ptr(), ME_NOTE);
+}
+#endif
+
+bool copy_keys_from_share(TABLE *outparam, MEM_ROOT *root)
+{
+  TABLE_SHARE *share= outparam->s;
+  if (share->key_parts)
+  {
+    KEY	*key_info, *key_info_end;
+    KEY_PART_INFO *key_part;
+
+    if (!multi_alloc_root(root, &key_info, share->keys*sizeof(KEY),
+                          &key_part, share->ext_key_parts*sizeof(KEY_PART_INFO),
+                          NullS))
+      return 1;
+
+    outparam->key_info= key_info;
+
+    memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
+    memcpy(key_part, key_info->key_part, sizeof(*key_part)*share->ext_key_parts);
+
+    my_ptrdiff_t adjust_ptrs= PTR_BYTE_DIFF(key_part, key_info->key_part);
+    for (key_info_end= key_info + share->keys ;
+         key_info < key_info_end ;
+         key_info++)
+    {
+      key_info->table= outparam;
+      key_info->key_part= reinterpret_cast<KEY_PART_INFO*>
+        (reinterpret_cast<char*>(key_info->key_part) + adjust_ptrs);
+      if (key_info->algorithm == HA_KEY_ALG_LONG_HASH)
+        key_info->flags&= ~HA_NOSAME;
+    }
+    for (KEY_PART_INFO *key_part_end= key_part+share->ext_key_parts;
+         key_part < key_part_end;
+         key_part++)
+    {
+      Field *field= key_part->field= outparam->field[key_part->fieldnr - 1];
+      if (field->key_length() != key_part->length &&
+          !(field->flags & BLOB_FLAG))
+      {
+        /*
+          We are using only a prefix of the column as a key:
+          Create a new field for the key part that matches the index
+        */
+        field= key_part->field=field->make_new_field(root, outparam, 0);
+        field->field_length= key_part->length;
+      }
+    }
+  }
+  return 0;
+}
+
+/*
+  Open a table based on a TABLE_SHARE
+
+  SYNOPSIS
+    open_table_from_share()
+    thd			Thread handler
+    share		Table definition
+    alias       	Alias for table
+    db_stat		open flags (for example HA_OPEN_KEYFILE|
+    			HA_OPEN_RNDFILE..) can be 0 (example in
+                        ha_example_table)
+    prgflag   		READ_ALL etc..
+    ha_open_flags	HA_OPEN_ABORT_IF_LOCKED etc..
+    outparam       	result table
+    partitions_to_open  open only these partitions.
+
+  RETURN VALUES
+   0	ok
+   1	Error (see open_table_error)
+   2    Error (see open_table_error)
+   3    Wrong data in .frm file
+   4    Error (see open_table_error)
+   5    Error (see open_table_error: charset unavailable)
+   7    Table definition has changed in engine
+*/
+
+enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
+                       const LEX_CSTRING *alias, uint db_stat, uint prgflag,
+                       uint ha_open_flags, TABLE *outparam,
+                       bool is_create_table, List<String> *partitions_to_open)
+{
+  enum open_frm_error error;
+  uint records, i, bitmap_size, bitmap_count;
+  const char *tmp_alias;
+  bool error_reported= FALSE;
+  uchar *record, *bitmaps;
+  Field **field_ptr;
+  uint8 save_context_analysis_only= thd->lex->context_analysis_only;
+  TABLE_SHARE::enum_v_keys check_set_initialized= share->check_set_initialized;
+  DBUG_ENTER("open_table_from_share");
+  DBUG_PRINT("enter",("name: '%s.%s'  form: %p", share->db.str,
+                      share->table_name.str, outparam));
+
+  thd->lex->context_analysis_only&= ~CONTEXT_ANALYSIS_ONLY_VIEW; // not a view
+
+  error= OPEN_FRM_ERROR_ALREADY_ISSUED; // for OOM errors below
+  bzero((char*) outparam, sizeof(*outparam));
+  outparam->in_use= thd;
+  outparam->s= share;
+  outparam->db_stat= db_stat;
+  outparam->status= STATUS_NO_RECORD;
+
+  if (share->incompatible_version &&
+      !(ha_open_flags & (HA_OPEN_FOR_ALTER | HA_OPEN_FOR_REPAIR |
+                         HA_OPEN_FOR_FLUSH)))
+  {
+    /* one needs to run mysql_upgrade on the table */
+    error= OPEN_FRM_NEEDS_REBUILD;
+    goto err;
+  }
+  init_sql_alloc(key_memory_TABLE, &outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE,
+                 0, MYF(0));
+
+  /*
+    We have to store the original alias in mem_root as constraints and virtual
+    functions may store pointers to it
+  */
+  if (!(tmp_alias= strmake_root(&outparam->mem_root, alias->str, alias->length)))
+    goto err;
+
+  outparam->alias.set(tmp_alias, alias->length, table_alias_charset);
+  outparam->vcol_refix_list.empty();
+
+  /* Allocate handler */
+  outparam->file= 0;
+  if (!(prgflag & OPEN_FRM_FILE_ONLY))
+  {
+    if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
+                                          share->db_type())))
+      goto err;
+
+    if (outparam->file->set_ha_share_ref(&share->ha_share))
+      goto err;
+  }
+  else
+  {
+    DBUG_ASSERT(!db_stat);
+  }
+
+  if (share->sequence && outparam->file)
+  {
+    ha_sequence *file;
+    /* SEQUENCE table. Create a sequence handler over the original handler */
+    if (!(file= (ha_sequence*) sql_sequence_hton->create(sql_sequence_hton, share,
+                                                     &outparam->mem_root)))
+      goto err;
+    file->register_original_handler(outparam->file);
+    outparam->file= file;
+  }
+
+  outparam->reginfo.lock_type= TL_UNLOCK;
+  outparam->reginfo.skip_locked= false;
+  outparam->current_lock= F_UNLCK;
+  records=0;
+  if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
+    records=1;
+  if (prgflag & (READ_ALL + EXTRA_RECORD))
+  {
+    records++;
+    if (share->versioned || share->period.name)
+      records++;
+  }
+
+  if (records == 0)
+  {
+    /* We are probably in hard repair, and the buffers should not be used */
+    record= share->default_values;
+  }
+  else
+  {
+    if (!(record= (uchar*) alloc_root(&outparam->mem_root,
+                                      share->rec_buff_length * records)))
+      goto err;                                   /* purecov: inspected */
+  }
+
+  for (i= 0; i < 3;)
+  {
+    outparam->record[i]= record;
+    if (++i < records)
+      record+= share->rec_buff_length;
+  }
+  /* Mark bytes between records as not accessable to catch overrun bugs */
+  for (i= 0; i < records; i++)
+    MEM_NOACCESS(outparam->record[i] + share->reclength,
+                 share->rec_buff_length - share->reclength);
+
+  if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
+                                          (uint) ((share->fields+1)*
+                                                  sizeof(Field*)))))
+    goto err;                                   /* purecov: inspected */
+
+  /* Allocate storage for range optimizer */
+  if (!multi_alloc_root(&outparam->mem_root,
+                        &outparam->opt_range,
+                        share->keys * sizeof(TABLE::OPT_RANGE),
+                        &outparam->const_key_parts,
+                        share->keys * sizeof(key_part_map),
+                        NullS))
+    goto err;
+
+  outparam->field= field_ptr;
+
+  record= (uchar*) outparam->record[0]-1;	/* Fieldstart = 1 */
+  if (share->null_field_first)
+    outparam->null_flags= (uchar*) record+1;
+  else
+    outparam->null_flags= (uchar*) (record+ 1+ share->reclength -
+                                    share->null_bytes);
+
+  /* Setup copy of fields from share, but use the right alias and record */
+  for (i=0 ; i < share->fields; i++, field_ptr++)
+  {
+    if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
+      goto err;
+  }
+  (*field_ptr)= 0;                              // End marker
+
+  DEBUG_SYNC(thd, "TABLE_after_field_clone");
+
+  outparam->vers_write= share->versioned;
+
+  if (share->found_next_number_field)
+    outparam->found_next_number_field=
+      outparam->field[(uint) (share->found_next_number_field - share->field)];
+
+  if (copy_keys_from_share(outparam, &outparam->mem_root))
+    goto err;
+
+  /*
+    Process virtual and default columns, if any.
+  */
+  if (share->virtual_fields || share->default_fields ||
+      share->default_expressions || share->table_check_constraints)
+  {
+    Field **vfield_ptr, **dfield_ptr;
+    Virtual_column_info **check_constraint_ptr;
+
+    if (!multi_alloc_root(&outparam->mem_root,
+                          &vfield_ptr, (uint) ((share->virtual_fields + 1)*
+                                               sizeof(Field*)),
+                          &dfield_ptr, (uint) ((share->default_fields +
+                                                share->default_expressions +1)*
+                                               sizeof(Field*)),
+                          &check_constraint_ptr,
+                          (uint) ((share->table_check_constraints +
+                                   share->field_check_constraints + 1)*
+                                  sizeof(Virtual_column_info*)),
+                          NullS))
+      goto err;
+    if (share->virtual_fields)
+      outparam->vfield= vfield_ptr;
+    if (share->default_fields + share->default_expressions)
+      outparam->default_field= dfield_ptr;
+    if (share->table_check_constraints || share->field_check_constraints)
+      outparam->check_constraints= check_constraint_ptr;
+
+    vcol_init_mode mode= VCOL_INIT_DEPENDENCY_FAILURE_IS_WARNING;
+    switch (thd->lex->sql_command)
+    {
+    case SQLCOM_CREATE_TABLE:
+      mode= VCOL_INIT_DEPENDENCY_FAILURE_IS_ERROR;
+      break;
+    case SQLCOM_ALTER_TABLE:
+    case SQLCOM_CREATE_INDEX:
+    case SQLCOM_DROP_INDEX:
+      if ((ha_open_flags & HA_OPEN_FOR_ALTER) == 0)
+        mode= VCOL_INIT_DEPENDENCY_FAILURE_IS_ERROR;
+      break;
+    default:
+      break;
+    }
+
+    if (parse_vcol_defs(thd, &outparam->mem_root, outparam,
+                        &error_reported, mode))
+    {
+      error= OPEN_FRM_CORRUPTED;
+      goto err;
+    }
+
+    /* Update to use trigger fields */
+    switch_defaults_to_nullable_trigger_fields(outparam);
+
+    for (uint k= 0; k < share->keys; k++)
+    {
+      KEY &key_info= outparam->key_info[k];
+      uint parts = (share->use_ext_keys ? key_info.ext_key_parts :
+                    key_info.user_defined_key_parts);
+      for (uint p= 0; p < parts; p++)
+      {
+        KEY_PART_INFO &kp= key_info.key_part[p];
+        if (kp.field != outparam->field[kp.fieldnr - 1])
+        {
+          kp.field->vcol_info = outparam->field[kp.fieldnr - 1]->vcol_info;
+        }
+      }
+    }
+  }
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  bool work_part_info_used;
+  if (share->partition_info_str_len && outparam->file)
+  {
+  /*
+    In this execution we must avoid calling thd->change_item_tree since
+    we might release memory before statement is completed. We do this
+    by changing to a new statement arena. As part of this arena we also
+    set the memory root to be the memory root of the table since we
+    call the parser and fix_fields which both can allocate memory for
+    item objects. We keep the arena to ensure that we can release the
+    free_list when closing the table object.
+    SEE Bug #21658
+  */
+
+    Query_arena *backup_stmt_arena_ptr= thd->stmt_arena;
+    Query_arena backup_arena;
+    Query_arena part_func_arena(&outparam->mem_root,
+                                Query_arena::STMT_INITIALIZED);
+    thd->set_n_backup_active_arena(&part_func_arena, &backup_arena);
+    thd->stmt_arena= &part_func_arena;
+    bool tmp;
+
+    tmp= mysql_unpack_partition(thd, share->partition_info_str,
+                                share->partition_info_str_len,
+                                outparam, is_create_table,
+                                plugin_hton(share->default_part_plugin),
+                                &work_part_info_used);
+    if (tmp)
+    {
+      thd->stmt_arena= backup_stmt_arena_ptr;
+      thd->restore_active_arena(&part_func_arena, &backup_arena);
+      goto partititon_err;
+    }
+    if (parse_engine_part_options(thd, outparam))
+      goto err;
+    outparam->part_info->is_auto_partitioned= share->auto_partitioned;
+    DBUG_PRINT("info", ("autopartitioned: %u", share->auto_partitioned));
+    /* 
+      We should perform the fix_partition_func in either local or
+      caller's arena depending on work_part_info_used value.
+    */
+    if (!work_part_info_used)
+      tmp= fix_partition_func(thd, outparam, is_create_table);
+    thd->stmt_arena= backup_stmt_arena_ptr;
+    thd->restore_active_arena(&part_func_arena, &backup_arena);
+    if (!tmp)
+    {
+      if (work_part_info_used)
+        tmp= fix_partition_func(thd, outparam, is_create_table);
+    }
+    outparam->part_info->item_free_list= part_func_arena.free_list;
+partititon_err:
+    if (tmp)
+    {
+      if (is_create_table)
+      {
+        /*
+          During CREATE/ALTER TABLE it is ok to receive errors here.
+          It is not ok if it happens during the opening of an frm
+          file as part of a normal query.
+        */
+        error_reported= TRUE;
+      }
+      goto err;
+    }
+  }
+#endif
+
+  /* Check virtual columns against table's storage engine. */
+  if (share->virtual_fields &&
+        (outparam->file && 
+          !(outparam->file->ha_table_flags() & HA_CAN_VIRTUAL_COLUMNS)))
+  {
+    my_error(ER_UNSUPPORTED_ENGINE_FOR_VIRTUAL_COLUMNS, MYF(0),
+             plugin_name(share->db_plugin)->str);
+    error_reported= TRUE;
+    goto err;
+  }
+
+  /* Allocate bitmaps */
+
+  bitmap_size= share->column_bitmap_size;
+  bitmap_count= 7;
+  if (share->virtual_fields)
+    bitmap_count++;
+
+  if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root,
+                                     bitmap_size * bitmap_count)))
+    goto err;
+
+  my_bitmap_init(&outparam->def_read_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  bitmaps+= bitmap_size;
+  my_bitmap_init(&outparam->def_write_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  bitmaps+= bitmap_size;
+
+  my_bitmap_init(&outparam->has_value_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  bitmaps+= bitmap_size;
+  my_bitmap_init(&outparam->tmp_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  bitmaps+= bitmap_size;
+  my_bitmap_init(&outparam->eq_join_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  bitmaps+= bitmap_size;
+  my_bitmap_init(&outparam->cond_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  bitmaps+= bitmap_size;
+  my_bitmap_init(&outparam->def_rpl_write_set,
+                 (my_bitmap_map*) bitmaps, share->fields);
+  outparam->default_column_bitmaps();
+
+  outparam->cond_selectivity= 1.0;
+
+  /* The table struct is now initialized;  Open the table */
+  if (db_stat)
+  {
+    if (specialflag & SPECIAL_WAIT_IF_LOCKED)
+      ha_open_flags|= HA_OPEN_WAIT_IF_LOCKED;
+    else
+      ha_open_flags|= HA_OPEN_IGNORE_IF_LOCKED;
+
+    int ha_err= outparam->file->ha_open(outparam, share->normalized_path.str,
+                                 (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
+                                 ha_open_flags, 0, partitions_to_open);
+    if (ha_err)
+    {
+      share->open_errno= ha_err;
+      /* Set a flag if the table is crashed and it can be auto. repaired */
+      share->crashed= (outparam->file->auto_repair(ha_err) &&
+                       !(ha_open_flags & HA_OPEN_FOR_REPAIR));
+      if (!thd->is_error())
+        outparam->file->print_error(ha_err, MYF(0));
+      error_reported= TRUE;
+
+      if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
+        error= OPEN_FRM_DISCOVER;
+
+      /*
+        We're here, because .frm file was successfully opened.
+
+        But if the table doesn't exist in the engine and the engine
+        supports discovery, we force rediscover to discover
+        the fact that table doesn't in fact exist and remove
+        the stray .frm file.
+      */
+      if (outparam->file->partition_ht()->discover_table &&
+          (ha_err == ENOENT || ha_err == HA_ERR_NO_SUCH_TABLE))
+        error= OPEN_FRM_DISCOVER;
+
+      goto err;
+    }
+  }
+
+  outparam->mark_columns_used_by_virtual_fields();
+  if (!check_set_initialized &&
+      share->check_set_initialized == TABLE_SHARE::V_KEYS)
+  {
+    // copy PART_INDIRECT_KEY_FLAG that was set meanwhile by *some* thread
+    for (uint i= 0 ; i < share->fields ; i++)
+    {
+      if (share->field[i]->flags & PART_INDIRECT_KEY_FLAG)
+        outparam->field[i]->flags|= PART_INDIRECT_KEY_FLAG;
+    }
+  }
+
+  if (db_stat)
+  {
+    /* Set some flags in share on first open of the table */
+    handler::Table_flags flags= outparam->file->ha_table_flags();
+    if (! MY_TEST(flags & (HA_BINLOG_STMT_CAPABLE |
+                           HA_BINLOG_ROW_CAPABLE)) ||
+        MY_TEST(flags & HA_HAS_OWN_BINLOGGING))
+      share->no_replicate= TRUE;
+    if (outparam->file->table_cache_type() & HA_CACHE_TBL_NOCACHE)
+      share->not_usable_by_query_cache= TRUE;
+    if (outparam->file->ha_table_flags() & HA_CAN_ONLINE_BACKUPS)
+      share->online_backup= 1;
+  }
+
+  if (share->no_replicate || !binlog_filter->db_ok(share->db.str))
+    share->can_do_row_logging= 0;   // No row based replication
+
+  /* Increment the opened_tables counter, only when open flags set. */
+  if (db_stat)
+    thd->status_var.opened_tables++;
+
+  thd->lex->context_analysis_only= save_context_analysis_only;
+  DBUG_EXECUTE_IF("print_long_unique_internal_state",
+   print_long_unique_table(outparam););
+  DBUG_RETURN (OPEN_FRM_OK);
+
+ err:
+  if (! error_reported)
+    open_table_error(share, error, my_errno);
+  delete outparam->file;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (outparam->part_info)
+    free_items(outparam->part_info->item_free_list);
+#endif
+  outparam->file= 0;				// For easier error checking
+  outparam->db_stat=0;
+  thd->lex->context_analysis_only= save_context_analysis_only;
+  if (outparam->expr_arena)
+    outparam->expr_arena->free_items();
+  free_root(&outparam->mem_root, MYF(0));       // Safe to call on bzero'd root
+  outparam->alias.free();
+  DBUG_RETURN (error);
+}
+
+
+/**
+  Free engine stats
+
+  This is only called from closefrm() when the TABLE object is destroyed
+**/
+
+void TABLE::free_engine_stats()
+{
+  bool free_stats= 0;
+  TABLE_STATISTICS_CB *stats= stats_cb;
+  mysql_mutex_lock(&s->LOCK_share);
+  free_stats= --stats->usage_count == 0;
+  mysql_mutex_unlock(&s->LOCK_share);
+  if (free_stats)
+    delete stats;
+}
+
+
+/*
+  Use engine stats from table_share if table_share has been updated
+*/
+
+void TABLE::update_engine_independent_stats()
+{
+  bool free_stats= 0;
+  TABLE_STATISTICS_CB *org_stats= stats_cb;
+  DBUG_ASSERT(stats_cb != s->stats_cb);
+
+  if (stats_cb != s->stats_cb)
+  {
+    mysql_mutex_lock(&s->LOCK_share);
+    if (org_stats)
+      free_stats= --org_stats->usage_count == 0;
+    if ((stats_cb= s->stats_cb))
+      stats_cb->usage_count++;
+    mysql_mutex_unlock(&s->LOCK_share);
+    if (free_stats)
+      delete org_stats;
+  }
+}
+
+
+/*
+  Update engine stats in table share to use new stats
+*/
+
+void
+TABLE_SHARE::update_engine_independent_stats(TABLE_STATISTICS_CB *new_stats)
+{
+  TABLE_STATISTICS_CB *free_stats= 0;
+  DBUG_ASSERT(new_stats->usage_count == 0);
+
+  mysql_mutex_lock(&LOCK_share);
+  if (stats_cb)
+  {
+    if (!--stats_cb->usage_count)
+      free_stats= stats_cb;
+  }
+  stats_cb= new_stats;
+  new_stats->usage_count++;
+  mysql_mutex_unlock(&LOCK_share);
+  if (free_stats)
+    delete free_stats;
+}
+
+
+/* Check if we have statistics for histograms */
+
+bool TABLE_SHARE::histograms_exists()
+{
+  bool res= 0;
+  if (stats_cb)
+  {
+    mysql_mutex_lock(&LOCK_share);
+    if (stats_cb)
+      res= stats_cb->histograms_exists();
+    mysql_mutex_unlock(&LOCK_share);
+  }
+  return res;
+}
+
+
+/*
+  Free information allocated by openfrm
+
+  SYNOPSIS
+    closefrm()
+    table		TABLE object to free
+*/
+
+int closefrm(TABLE *table)
+{
+  int error=0;
+  DBUG_ENTER("closefrm");
+  DBUG_PRINT("enter", ("table: %p", table));
+
+  if (table->db_stat)
+    error=table->file->ha_close();
+  table->alias.free();
+  if (table->expr_arena)
+    table->expr_arena->free_items();
+  if (table->field)
+  {
+    for (Field **ptr=table->field ; *ptr ; ptr++)
+    {
+      delete *ptr;
+    }
+    table->field= 0;
+  }
+  delete table->file;
+  table->file= 0;				/* For easier errorchecking */
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  if (table->part_info)
+  {
+    /* Allocated through table->mem_root, freed below */
+    free_items(table->part_info->item_free_list);
+    table->part_info->item_free_list= 0;
+    table->part_info= 0;
+  }
+#endif
+  if (table->stats_cb)
+  {
+    DBUG_ASSERT(table->s->tmp_table == NO_TMP_TABLE);
+    table->free_engine_stats();
+  }
+
+  free_root(&table->mem_root, MYF(0));
+  DBUG_RETURN(error);
+}
+
+
+/* Deallocate temporary blob storage */
+
+void free_blobs(TABLE *table)
+{
+  uint *ptr, *end;
+  for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
+       ptr != end ;
+       ptr++)
+  {
+    /*
+      Reduced TABLE objects which are used by row-based replication for
+      type conversion might have some fields missing. Skip freeing BLOB
+      buffers for such missing fields.
+    */
+    if (table->field[*ptr])
+      ((Field_blob*) table->field[*ptr])->free();
+  }
+}
+
+
+/**
+  Reclaim temporary blob storage which is bigger than 
+  a threshold.
+ 
+  @param table A handle to the TABLE object containing blob fields
+  @param size The threshold value.
+ 
+*/
+
+void free_field_buffers_larger_than(TABLE *table, uint32 size)
+{
+  uint *ptr, *end;
+  for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
+       ptr != end ;
+       ptr++)
+  {
+    Field_blob *blob= (Field_blob*) table->field[*ptr];
+    if (blob->get_field_buffer_size() > size)
+        blob->free();
+  }
+}
+
+/* error message when opening a form file */
+
+void open_table_error(TABLE_SHARE *share, enum open_frm_error error,
+                      int db_errno)
+{
+  char buff[FN_REFLEN];
+  const myf errortype= ME_ERROR_LOG;  // Write fatals error to log
+  DBUG_ENTER("open_table_error");
+  DBUG_PRINT("info", ("error: %d  db_errno: %d", error, db_errno));
+
+  switch (error) {
+  case OPEN_FRM_OPEN_ERROR:
+    /*
+      Test if file didn't exists. We have to also test for EINVAL as this
+      may happen on windows when opening a file with a not legal file name
+    */
+    if (db_errno == ENOENT || db_errno == EINVAL)
+      my_error(ER_NO_SUCH_TABLE, MYF(0), share->db.str, share->table_name.str);
+    else
+    {
+      strxmov(buff, share->normalized_path.str, reg_ext, NullS);
+      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
+               errortype, buff, db_errno);
+    }
+    break;
+  case OPEN_FRM_OK:
+    DBUG_ASSERT(0); // open_table_error() is never called for this one
+    break;
+  case OPEN_FRM_ERROR_ALREADY_ISSUED:
+    break;
+  case OPEN_FRM_NOT_A_VIEW:
+    my_error(ER_WRONG_OBJECT, MYF(0), share->db.str,
+             share->table_name.str, "VIEW");
+    break;
+  case OPEN_FRM_NOT_A_TABLE:
+    my_error(ER_WRONG_OBJECT, MYF(0), share->db.str,
+             share->table_name.str, "TABLE");
+    break;
+  case OPEN_FRM_DISCOVER:
+    DBUG_ASSERT(0); // open_table_error() is never called for this one
+    break;
+  case OPEN_FRM_CORRUPTED:
+    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
+    my_error(ER_NOT_FORM_FILE, errortype, buff);
+    break;
+  case OPEN_FRM_READ_ERROR:
+    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
+    my_error(ER_ERROR_ON_READ, errortype, buff, db_errno);
+    break;
+  case OPEN_FRM_NEEDS_REBUILD:
+    strxnmov(buff, sizeof(buff)-1,
+             share->db.str, ".", share->table_name.str, NullS);
+    my_error(ER_TABLE_NEEDS_REBUILD, errortype, buff);
+    break;
+  }
+  DBUG_VOID_RETURN;
+} /* open_table_error */
+
+
+	/*
+	** fix a str_type to a array type
+	** typeparts separated with some char. differents types are separated
+	** with a '\0'
+	*/
+
+static bool
+fix_type_pointers(const char ***typelib_value_names,
+                  uint **typelib_value_lengths,
+                  TYPELIB *point_to_type, uint types,
+                  char *ptr, size_t length)
+{
+  const char *end= ptr + length;
+
+  while (types--)
+  {
+    char sep;
+    point_to_type->name=0;
+    point_to_type->type_names= *typelib_value_names;
+    point_to_type->type_lengths= *typelib_value_lengths;
+
+    /*
+      Typelib can be encoded as:
+      1) 0x00                     - empty typelib
+      2) 0xFF 0x00                - empty typelib (index names)
+      3) sep (value sep)... 0x00  - non-empty typelib (where sep is a separator)
+    */
+    if (length == 2 && ptr[0] == (char) 0xFF && ptr[1] == '\0')
+    {
+      /*
+        This is a special case #2.
+        If there are no indexes at all, index names can be encoded
+        as a two byte sequence: 0xFF 0x00
+        TODO: Check if it's a bug in the FRM packing routine.
+        It should probably write just 0x00 instead of 0xFF00.
+      */
+      ptr+= 2;
+    }
+    else if ((sep= *ptr++))            // A non-empty typelib
+    {
+      for ( ; ptr < end; )
+      {
+        // Now scan the next value+sep pair
+        char *vend= (char*) memchr(ptr, sep, end - ptr);
+        if (!vend)
+          return true;            // Bad format
+        *((*typelib_value_names)++)= ptr;
+        *((*typelib_value_lengths)++)= (uint) (vend - ptr);
+        *vend= '\0';              // Change sep to '\0'
+        ptr= vend + 1;            // Shift from sep to the next byte
+        /*
+          Now we can have either:
+          - the end-of-typelib marker (0x00)
+          - more value+sep pairs
+        */
+        if (!*ptr)
+        {
+          /*
+            We have an ambiguity here. 0x00 can be an end-of-typelib marker,
+            but it can also be a part of the next value:
+              CREATE TABLE t1 (a ENUM(0x61, 0x0062) CHARACTER SET BINARY);
+            If this is the last ENUM/SET in the table and there is still more
+            packed data left after 0x00, then we know for sure that 0x00
+            is a part of the next value.
+            TODO-10.5+: we should eventually introduce a new unambiguous
+            typelib encoding for FRM.
+          */
+          if (!types && ptr + 1 < end)
+            continue;           // A binary value starting with 0x00
+          ptr++;                // Consume the end-of-typelib marker
+          break;                // End of the current typelib
+        }
+      }
+    }
+    point_to_type->count= (uint) (*typelib_value_names -
+                                  point_to_type->type_names);
+    point_to_type++;
+    *((*typelib_value_names)++)= NullS; /* End of type */
+    *((*typelib_value_lengths)++)= 0;   /* End of type */
+  }
+  return ptr != end;
+} /* fix_type_pointers */
+
+
+/*
+ Search after a field with given start & length
+ If an exact field isn't found, return longest field with starts
+ at right position.
+ 
+ NOTES
+   This is needed because in some .frm fields 'fieldnr' was saved wrong
+
+ RETURN
+   0  error
+   #  field number +1
+*/
+
+static field_index_t find_field(Field **fields, uchar *record, uint start,
+                                uint length)
+{
+  Field **field;
+  field_index_t i, pos;
+
+  pos= 0;
+  for (field= fields, i=1 ; *field ; i++,field++)
+  {
+    if ((*field)->offset(record) == start)
+    {
+      if ((*field)->key_length() == length)
+	return (i);
+      if (!pos || fields[pos-1]->pack_length() <
+	  (*field)->pack_length())
+	pos= i;
+    }
+  }
+  return (pos);
+}
+
+
+/*
+  Store an SQL quoted string.
+
+  SYNOPSIS  
+    append_unescaped()
+    res		result String
+    pos		string to be quoted
+    length	it's length
+
+  NOTE
+    This function works correctly with utf8 or single-byte charset strings.
+    May fail with some multibyte charsets though.
+*/
+
+void append_unescaped(String *res, const char *pos, size_t length)
+{
+  const char *end= pos+length;
+  res->append('\'');
+
+  for (; pos != end ; pos++)
+  {
+    switch (*pos) {
+    case 0:				/* Must be escaped for 'mysql' */
+      res->append('\\');
+      res->append('0');
+      break;
+    case '\n':				/* Must be escaped for logs */
+      res->append('\\');
+      res->append('n');
+      break;
+    case '\r':
+      res->append('\\');		/* This gives better readability */
+      res->append('r');
+      break;
+    case '\\':
+      res->append('\\');		/* Because of the sql syntax */
+      res->append('\\');
+      break;
+    case '\'':
+      res->append('\'');		/* Because of the sql syntax */
+      res->append('\'');
+      break;
+    default:
+      res->append(*pos);
+      break;
+    }
+  }
+  res->append('\'');
+}
+
+
+void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo,
+                        HA_CREATE_INFO *create_info, uint keys, KEY *key_info)
+{
+  size_t key_comment_total_bytes= 0;
+  uint i;
+  uchar frm_format= create_info->expression_length ? FRM_VER_EXPRESSSIONS
+                                                   : FRM_VER_TRUE_VARCHAR;
+  DBUG_ENTER("prepare_frm_header");
+
+  /* Fix this when we have new .frm files;  Current limit is 4G rows (TODO) */
+  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;
+
+  /*
+    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= 0; i < keys; i++)
+  {
+    DBUG_ASSERT(MY_TEST(key_info[i].flags & HA_USES_COMMENT) ==
+                (key_info[i].comment.length > 0));
+    if (key_info[i].flags & HA_USES_COMMENT)
+      key_comment_total_bytes += 2 + key_info[i].comment.length;
+    if (key_info[i].algorithm == HA_KEY_ALG_LONG_HASH)
+      frm_format= FRM_VER_EXPRESSSIONS;
+  }
+
+  size_t key_length, tmp_key_length, tmp, csid;
+  bzero((char*) fileinfo, FRM_HEADER_SIZE);
+  /* header */
+  fileinfo[0]=(uchar) 254;
+  fileinfo[1]= 1;
+  fileinfo[2]= frm_format;
+
+  DBUG_ASSERT(ha_storage_engine_is_enabled(create_info->db_type));
+  fileinfo[3]= (uchar) ha_legacy_type(create_info->db_type);
+
+  key_length= keys * (8 + MAX_REF_PARTS * 9 + NAME_LEN + 1) + 16
+              + key_comment_total_bytes;
+
+  int2store(fileinfo+8,1);
+  tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff;
+  int2store(fileinfo+14,tmp_key_length);
+  int2store(fileinfo+16,reclength);
+  int4store(fileinfo+18,create_info->max_rows);
+  int4store(fileinfo+22,create_info->min_rows);
+  /* fileinfo[26] is set in mysql_create_frm() */
+  fileinfo[27]=2;				// 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+30,create_info->table_options);
+  fileinfo[32]=0;				// No filename anymore
+  fileinfo[33]=5;                             // Mark for 5.0 frm file
+  int4store(fileinfo+34,create_info->avg_row_length);
+  csid= (create_info->default_table_charset ?
+         create_info->default_table_charset->number : 0);
+  fileinfo[38]= (uchar) csid;
+  fileinfo[39]= (uchar) ((uint) create_info->transactional |
+                         ((uint) create_info->page_checksum << 2) |
+                         ((create_info->sequence ? HA_CHOICE_YES : 0) << 4));
+  fileinfo[40]= (uchar) create_info->row_type;
+  /* Bytes 41-46 were for RAID support; now reused for other purposes */
+  fileinfo[41]= (uchar) (csid >> 8);
+  int2store(fileinfo+42, create_info->stats_sample_pages & 0xffff);
+  fileinfo[44]= (uchar)  create_info->stats_auto_recalc;
+  int2store(fileinfo+45, (create_info->check_constraint_list->elements+
+                          create_info->field_check_constraints));
+  int4store(fileinfo+47, key_length);
+  tmp= MYSQL_VERSION_ID;          // Store to avoid warning from int4store
+  int4store(fileinfo+51, tmp);
+  int4store(fileinfo+55, create_info->extra_size);
+  /*
+    59-60 is unused since 10.2.4
+    61 for default_part_db_type
+  */
+  int2store(fileinfo+62, create_info->key_block_size);
+  DBUG_VOID_RETURN;
+} /* prepare_fileinfo */
+
+
+void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
+{
+  TABLE_SHARE *share= table->s;
+  DBUG_ENTER("update_create_info_from_table");
+
+  create_info->max_rows= share->max_rows;
+  create_info->min_rows= share->min_rows;
+  create_info->table_options= share->db_create_options;
+  create_info->avg_row_length= share->avg_row_length;
+  create_info->row_type= share->row_type;
+  create_info->key_block_size= share->key_block_size;
+  create_info->default_table_charset= share->table_charset;
+  create_info->alter_table_convert_to_charset= 0;
+  create_info->comment= share->comment;
+  create_info->transactional= share->transactional;
+  create_info->page_checksum= share->page_checksum;
+  create_info->option_list= share->option_list;
+  create_info->sequence= MY_TEST(share->sequence);
+
+  DBUG_VOID_RETURN;
+}
+
+int
+rename_file_ext(const char * from,const char * to,const char * ext)
+{
+  /* Reserve space for ./databasename/tablename.frm + NUL byte */
+  char from_b[2 + FN_REFLEN + 4 + 1], to_b[2 + FN_REFLEN + 4 + 1];
+  (void) strxmov(from_b,from,ext,NullS);
+  (void) strxmov(to_b,to,ext,NullS);
+  return mysql_file_rename(key_file_frm, from_b, to_b, MYF(0));
+}
+
+
+/*
+  Allocate string field in MEM_ROOT and return it as String
+
+  SYNOPSIS
+    get_field()
+    mem   	MEM_ROOT for allocating
+    field 	Field for retrieving of string
+    res         result String
+
+  RETURN VALUES
+    1   string is empty
+    0	all ok
+*/
+
+bool get_field(MEM_ROOT *mem, Field *field, String *res)
+{
+  const char *to;
+  StringBuffer<MAX_FIELD_WIDTH> str;
+  bool rc;
+  THD *thd= field->get_thd();
+  Sql_mode_instant_remove sms(thd, MODE_PAD_CHAR_TO_FULL_LENGTH);
+
+  field->val_str(&str);
+  if ((rc= !str.length() ||
+           !(to= strmake_root(mem, str.ptr(), str.length()))))
+  {
+    res->length(0);
+    return rc;
+  }
+  res->set(to, str.length(), field->charset());
+  return false;
+}
+
+
+/*
+  Allocate string field in MEM_ROOT and return it as NULL-terminated string
+
+  SYNOPSIS
+    get_field()
+    mem   	MEM_ROOT for allocating
+    field 	Field for retrieving of string
+
+  RETURN VALUES
+    NullS  string is empty
+    #      pointer to NULL-terminated string value of field
+*/
+
+char *get_field(MEM_ROOT *mem, Field *field)
+{
+  String str;
+  bool rc= get_field(mem, field, &str);
+  DBUG_ASSERT(rc || str.ptr()[str.length()] == '\0');
+  return  rc ? NullS : (char *) str.ptr();
+}
+
+/*
+  DESCRIPTION
+    given a buffer with a key value, and a map of keyparts
+    that are present in this value, returns the length of the value
+*/
+uint calculate_key_len(TABLE *table, uint key, const uchar *buf,
+                       key_part_map keypart_map)
+{
+  /* works only with key prefixes */
+  DBUG_ASSERT(((keypart_map + 1) & keypart_map) == 0);
+
+  KEY *key_info= table->key_info+key;
+  KEY_PART_INFO *key_part= key_info->key_part;
+  KEY_PART_INFO *end_key_part= key_part + table->actual_n_key_parts(key_info);
+  uint length= 0;
+
+  while (key_part < end_key_part && keypart_map)
+  {
+    length+= key_part->store_length;
+    keypart_map >>= 1;
+    key_part++;
+  }
+  return length;
+}
+
+#ifndef DBUG_OFF
+/**
+  Verifies that database/table name is in lowercase, when it should be
+
+  This is supposed to be used only inside DBUG_ASSERT()
+*/
+bool ok_for_lower_case_names(const char *name)
+{
+  if (!lower_case_table_names || !name)
+    return true;
+
+  char buf[SAFE_NAME_LEN];
+  strmake_buf(buf, name);
+  my_casedn_str(files_charset_info, buf);
+  return strcmp(name, buf) == 0;
+}
+#endif
+
+/*
+  Check if database name is valid
+
+  SYNPOSIS
+    check_db_name()
+    org_name		Name of database
+
+  NOTES
+    If lower_case_table_names is set to 1 then database name is converted
+    to lower case
+
+  RETURN
+    0	ok
+    1   error
+*/
+
+bool check_db_name(LEX_STRING *org_name)
+{
+  char *name= org_name->str;
+  size_t name_length= org_name->length;
+  bool check_for_path_chars;
+
+  if ((check_for_path_chars= check_mysql50_prefix(name)))
+  {
+    name+= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
+    name_length-= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
+  }
+
+  if (!name_length || name_length > NAME_LEN)
+    return 1;
+
+  if (lower_case_table_names == 1 && name != any_db.str)
+  {
+    org_name->length= name_length= my_casedn_str(files_charset_info, name);
+    if (check_for_path_chars)
+      org_name->length+= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
+  }
+  if (db_name_is_in_ignore_db_dirs_list(name))
+    return 1;
+
+  return check_table_name(name, name_length, check_for_path_chars);
+}
+
+
+/*
+  Allow anything as a table name, as long as it doesn't contain an
+  ' ' at the end
+  returns 1 on error
+*/
+
+bool check_table_name(const char *name, size_t length, bool check_for_path_chars)
+{
+  // name length in symbols
+  size_t name_length= 0;
+  const char *end= name+length;
+
+  if (!check_for_path_chars &&
+      (check_for_path_chars= check_mysql50_prefix(name)))
+  {
+    name+= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
+    length-= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
+  }
+
+  if (!length || length > NAME_LEN)
+    return 1;
+#if defined(USE_MB) && defined(USE_MB_IDENT)
+  bool last_char_is_space= FALSE;
+#else
+  if (name[length-1]==' ')
+    return 1;
+#endif
+
+  while (name != end)
+  {
+#if defined(USE_MB) && defined(USE_MB_IDENT)
+    last_char_is_space= my_isspace(system_charset_info, *name);
+    if (system_charset_info->use_mb())
+    {
+      int len=my_ismbchar(system_charset_info, name, end);
+      if (len)
+      {
+        name+= len;
+        name_length++;
+        continue;
+      }
+    }
+#endif
+    if (check_for_path_chars &&
+        (*name == '/' || *name == '\\' || *name == '~' || *name == FN_EXTCHAR))
+      return 1;
+    /*
+      We don't allow zero byte in table/schema names:
+      - Some code still uses NULL-terminated strings.
+        Zero bytes will confuse this code.
+      - There is a little practical use of zero bytes in names anyway.
+      Note, if the string passed as "name" comes here
+      from the parser as an identifier, it does not contain zero bytes,
+      as the parser rejects zero bytes in identifiers.
+      But "name" can also come here from queries like this:
+        SELECT * FROM I_S.TABLES WHERE TABLE_NAME='str';
+      In this case "name" is a general string expression
+      and it can have any arbitrary bytes, including zero bytes.
+    */
+    if (*name == 0x00)
+      return 1;
+    name++;
+    name_length++;
+  }
+#if defined(USE_MB) && defined(USE_MB_IDENT)
+  return last_char_is_space || (name_length > NAME_CHAR_LEN);
+#else
+  return FALSE;
+#endif
+}
+
+
+bool check_column_name(const char *name)
+{
+  // name length in symbols
+  size_t name_length= 0;
+  bool last_char_is_space= TRUE;
+
+  while (*name)
+  {
+#if defined(USE_MB) && defined(USE_MB_IDENT)
+    last_char_is_space= my_isspace(system_charset_info, *name);
+    if (system_charset_info->use_mb())
+    {
+      int len=my_ismbchar(system_charset_info, name, 
+                          name+system_charset_info->mbmaxlen);
+      if (len)
+      {
+        name += len;
+        name_length++;
+        continue;
+      }
+    }
+#else
+    last_char_is_space= *name==' ';
+    if (*name == '\377')
+      return 1;
+#endif
+    name++;
+    name_length++;
+  }
+  /* Error if empty or too long column name */
+  return last_char_is_space || (name_length > NAME_CHAR_LEN);
+}
+
+
+bool check_period_name(const char *name)
+{
+  return check_column_name(name);
+}
+
+
+/**
+  Checks whether a table is intact. Should be done *just* after the table has
+  been opened.
+
+  @param[in] table             The table to check
+  @param[in] table_def         Expected structure of the table (column name
+                               and type)
+
+  @retval  FALSE  OK
+  @retval  TRUE   There was an error. An error message is output
+                  to the error log.  We do not push an error
+                  message into the error stack because this
+                  function is currently only called at start up,
+                  and such errors never reach the user.
+*/
+
+bool
+Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
+{
+  uint i;
+  my_bool error= FALSE;
+  const TABLE_FIELD_TYPE *field_def= table_def->field;
+  DBUG_ENTER("table_check_intact");
+  DBUG_PRINT("info",("table: %s  expected_count: %d",
+                     table->alias.c_ptr(), table_def->count));
+
+  /* Whether the table definition has already been validated. */
+  if (table->s->table_field_def_cache == table_def)
+    goto end;
+
+  if (table->s->fields != table_def->count)
+  {
+    THD *thd= current_thd;
+    DBUG_PRINT("info", ("Column count has changed, checking the definition"));
+
+    /* previous MySQL version */
+    if (MYSQL_VERSION_ID > table->s->mysql_version)
+    {
+      report_error(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE,
+                   ER_THD(thd, ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),
+                   table->alias.c_ptr(), table_def->count, table->s->fields,
+                   static_cast<int>(table->s->mysql_version),
+                   MYSQL_VERSION_ID);
+      DBUG_RETURN(TRUE);
+    }
+    else if (MYSQL_VERSION_ID == table->s->mysql_version)
+    {
+      report_error(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2,
+                   ER_THD(thd, ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2),
+                   table->s->db.str, table->s->table_name.str,
+                   table_def->count, table->s->fields);
+      DBUG_RETURN(TRUE);
+    }
+    /*
+      Something has definitely changed, but we're running an older
+      version of MySQL with new system tables.
+      Let's check column definitions. If a column was added at
+      the end of the table, then we don't care much since such change
+      is backward compatible.
+    */
+  }
+  else
+  {
+  StringBuffer<1024> sql_type(system_charset_info);
+  sql_type.extra_allocation(256); // Allocate min 256 characters at once
+  for (i=0 ; i < table_def->count; i++, field_def++)
+  {
+    sql_type.length(0);
+    if (i < table->s->fields)
+    {
+      Field *field= table->field[i];
+
+      if (strncmp(field->field_name.str, field_def->name.str,
+                  field_def->name.length))
+      {
+        /*
+          Name changes are not fatal, we use ordinal numbers to access columns.
+          Still this can be a sign of a tampered table, output an error
+          to the error log.
+        */
+        report_error(0, "Incorrect definition of table %s.%s: "
+                     "expected column '%s' at position %d, found '%s'.",
+                     table->s->db.str, table->alias.c_ptr(),
+                     field_def->name.str, i,
+                     field->field_name.str);
+      }
+      field->sql_type(sql_type);
+      /*
+        Generally, if column types don't match, then something is
+        wrong.
+
+        However, we only compare column definitions up to the
+        length of the original definition, since we consider the
+        following definitions compatible:
+
+        1. DATETIME and DATETIM
+        2. INT(11) and INT(11
+        3. SET('one', 'two') and SET('one', 'two', 'more')
+
+        For SETs or ENUMs, if the same prefix is there it's OK to
+        add more elements - they will get higher ordinal numbers and
+        the new table definition is backward compatible with the
+        original one.
+       */
+      if (strncmp(sql_type.c_ptr_safe(), field_def->type.str,
+                  field_def->type.length - 1))
+      {
+        report_error(0, "Incorrect definition of table %s.%s: "
+                     "expected column '%s' at position %d to have type "
+                     "%s, found type %s.", table->s->db.str,
+                     table->alias.c_ptr(),
+                     field_def->name.str, i, field_def->type.str,
+                     sql_type.c_ptr_safe());
+        error= TRUE;
+      }
+      else if (field_def->cset.str && !field->has_charset())
+      {
+        report_error(0, "Incorrect definition of table %s.%s: "
+                     "expected the type of column '%s' at position %d "
+                     "to have character set '%s' but the type has no "
+                     "character set.", table->s->db.str,
+                     table->alias.c_ptr(),
+                     field_def->name.str, i, field_def->cset.str);
+        error= TRUE;
+      }
+      else if (field_def->cset.str &&
+               strncmp(field->charset()->cs_name.str, field_def->cset.str,
+                       field_def->cset.length))
+      {
+        report_error(0, "Incorrect definition of table %s.%s: "
+                     "expected the type of column '%s' at position %d "
+                     "to have character set '%s' but found "
+                     "character set '%s'.", table->s->db.str,
+                     table->alias.c_ptr(),
+                     field_def->name.str, i, field_def->cset.str,
+                     field->charset()->cs_name.str);
+        error= TRUE;
+      }
+    }
+    else
+    {
+      report_error(0, "Incorrect definition of table %s.%s: "
+                   "expected column '%s' at position %d to have type %s "
+                   " but the column is not found.",
+                   table->s->db.str, table->alias.c_ptr(),
+                   field_def->name.str, i, field_def->type.str);
+      error= TRUE;
+    }
+  }
+  }
+
+  if (table_def->primary_key_parts)
+  {
+    if (table->s->primary_key == MAX_KEY)
+    {
+      report_error(0, "Incorrect definition of table %s.%s: "
+                   "missing primary key.", table->s->db.str,
+                   table->alias.c_ptr());
+      error= TRUE;
+    }
+    else
+    {
+      KEY *pk= &table->s->key_info[table->s->primary_key];
+      if (pk->user_defined_key_parts != table_def->primary_key_parts)
+      {
+        report_error(0, "Incorrect definition of table %s.%s: "
+                     "Expected primary key to have %u columns, but instead "
+                     "found %u columns.", table->s->db.str,
+                     table->alias.c_ptr(), table_def->primary_key_parts,
+                     pk->user_defined_key_parts);
+        error= TRUE;
+      }
+      else
+      {
+        for (i= 0; i < pk->user_defined_key_parts; ++i)
+        {
+          if (table_def->primary_key_columns[i] + 1 != pk->key_part[i].fieldnr)
+          {
+            report_error(0, "Incorrect definition of table %s.%s: Expected "
+                         "primary key part %u to refer to column %u, but "
+                         "instead found column %u.", table->s->db.str,
+                         table->alias.c_ptr(), i + 1,
+                         table_def->primary_key_columns[i] + 1,
+                         pk->key_part[i].fieldnr);
+            error= TRUE;
+          }
+        }
+      }
+    }
+  }
+
+  if (likely(! error))
+    table->s->table_field_def_cache= table_def;
+
+end:
+
+  if (has_keys && !error && !table->key_info)
+  {
+    report_error(0, "Incorrect definition of table %s.%s: "
+                 "indexes are missing",
+                 table->s->db.str, table->alias.c_ptr());
+    error= TRUE;
+  }
+
+  DBUG_RETURN(error);
+}
+
+
+void Table_check_intact_log_error::report_error(uint, const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  error_log_print(ERROR_LEVEL, fmt, args);
+  va_end(args);
+}
+
+
+/**
+  Traverse portion of wait-for graph which is reachable through edge
+  represented by this flush ticket in search for deadlocks.
+
+  @retval TRUE  A deadlock is found. A victim is remembered
+                by the visitor.
+  @retval FALSE Success, no deadlocks.
+*/
+
+bool Wait_for_flush::accept_visitor(MDL_wait_for_graph_visitor *gvisitor)
+{
+  return m_share->visit_subgraph(this, gvisitor);
+}
+
+
+uint Wait_for_flush::get_deadlock_weight() const
+{
+  return m_deadlock_weight;
+}
+
+
+/**
+  Traverse portion of wait-for graph which is reachable through this
+  table share in search for deadlocks.
+
+  @param waiting_ticket  Ticket representing wait for this share.
+  @param dvisitor        Deadlock detection visitor.
+
+  @retval TRUE  A deadlock is found. A victim is remembered
+                by the visitor.
+  @retval FALSE No deadlocks, it's OK to begin wait.
+*/
+
+bool TABLE_SHARE::visit_subgraph(Wait_for_flush *wait_for_flush,
+                                 MDL_wait_for_graph_visitor *gvisitor)
+{
+  TABLE *table;
+  MDL_context *src_ctx= wait_for_flush->get_ctx();
+  bool result= TRUE;
+
+  /*
+    To protect all_tables list from being concurrently modified
+    while we are iterating through it we increment tdc.all_tables_refs.
+    This does not introduce deadlocks in the deadlock detector
+    because we won't try to acquire tdc.LOCK_table_share while
+    holding a write-lock on MDL_lock::m_rwlock.
+  */
+  mysql_mutex_lock(&tdc->LOCK_table_share);
+  tdc->all_tables_refs++;
+  mysql_mutex_unlock(&tdc->LOCK_table_share);
+
+  All_share_tables_list::Iterator tables_it(tdc->all_tables);
+
+  /*
+    In case of multiple searches running in parallel, avoid going
+    over the same loop twice and shortcut the search.
+    Do it after taking the lock to weed out unnecessary races.
+  */
+  if (src_ctx->m_wait.get_status() != MDL_wait::EMPTY)
+  {
+    result= FALSE;
+    goto end;
+  }
+
+  if (gvisitor->enter_node(src_ctx))
+    goto end;
+
+  while ((table= tables_it++))
+  {
+    DBUG_ASSERT(table->in_use && tdc->flushed);
+    if (gvisitor->inspect_edge(&table->in_use->mdl_context))
+    {
+      goto end_leave_node;
+    }
+  }
+
+  tables_it.rewind();
+  while ((table= tables_it++))
+  {
+    DBUG_ASSERT(table->in_use && tdc->flushed);
+    if (table->in_use->mdl_context.visit_subgraph(gvisitor))
+    {
+      goto end_leave_node;
+    }
+  }
+
+  result= FALSE;
+
+end_leave_node:
+  gvisitor->leave_node(src_ctx);
+
+end:
+  mysql_mutex_lock(&tdc->LOCK_table_share);
+  if (!--tdc->all_tables_refs)
+    mysql_cond_broadcast(&tdc->COND_release);
+  mysql_mutex_unlock(&tdc->LOCK_table_share);
+
+  return result;
+}
+
+
+/**
+  Wait until the subject share is removed from the table
+  definition cache and make sure it's destroyed.
+
+  @param mdl_context     MDL context for thread which is going to wait.
+  @param abstime         Timeout for waiting as absolute time value.
+  @param deadlock_weight Weight of this wait for deadlock detector.
+
+  @pre LOCK_table_share is locked, the share is marked for flush and
+       this connection does not reference the share.
+       LOCK_table_share will be unlocked temporarily during execution.
+
+  It may happen that another FLUSH TABLES thread marked this share
+  for flush, but didn't yet purge it from table definition cache.
+  In this case we may start waiting for a table share that has no
+  references (ref_count == 0). We do this with assumption that this
+  another FLUSH TABLES thread is about to purge this share.
+
+  @retval FALSE - Success.
+  @retval TRUE  - Error (OOM, deadlock, timeout, etc...).
+*/
+
+bool TABLE_SHARE::wait_for_old_version(THD *thd, struct timespec *abstime,
+                                       uint deadlock_weight)
+{
+  MDL_context *mdl_context= &thd->mdl_context;
+  Wait_for_flush ticket(mdl_context, this, deadlock_weight);
+  MDL_wait::enum_wait_status wait_status;
+
+  mysql_mutex_assert_owner(&tdc->LOCK_table_share);
+  DBUG_ASSERT(tdc->flushed);
+
+  tdc->m_flush_tickets.push_front(&ticket);
+
+  mdl_context->m_wait.reset_status();
+
+  mysql_mutex_unlock(&tdc->LOCK_table_share);
+
+  mdl_context->will_wait_for(&ticket);
+
+  mdl_context->find_deadlock();
+
+  wait_status= mdl_context->m_wait.timed_wait(thd, abstime, TRUE,
+                                              &stage_waiting_for_table_flush);
+
+  mdl_context->done_waiting_for();
+
+  mysql_mutex_lock(&tdc->LOCK_table_share);
+  tdc->m_flush_tickets.remove(&ticket);
+  mysql_cond_broadcast(&tdc->COND_release);
+  mysql_mutex_unlock(&tdc->LOCK_table_share);
+
+
+  /*
+    In cases when our wait was aborted by KILL statement,
+    a deadlock or a timeout, the share might still be referenced,
+    so we don't delete it. Note, that we can't determine this
+    condition by checking wait_status alone, since, for example,
+    a timeout can happen after all references to the table share
+    were released, but before the share is removed from the
+    cache and we receive the notification. This is why
+    we first destroy the share, and then look at
+    wait_status.
+  */
+  switch (wait_status)
+  {
+  case MDL_wait::GRANTED:
+    return FALSE;
+  case MDL_wait::VICTIM:
+    my_error(ER_LOCK_DEADLOCK, MYF(0));
+    return TRUE;
+  case MDL_wait::TIMEOUT:
+    my_error(ER_LOCK_WAIT_TIMEOUT, MYF(0));
+    return TRUE;
+  case MDL_wait::KILLED:
+    return TRUE;
+  default:
+    DBUG_ASSERT(0);
+    return TRUE;
+  }
+}
+
+
+/**
+  Initialize TABLE instance (newly created, or coming either from table
+  cache or THD::temporary_tables list) and prepare it for further use
+  during statement execution. Set the 'alias' attribute from the specified
+  TABLE_LIST element. Remember the TABLE_LIST element in the
+  TABLE::pos_in_table_list member.
+
+  @param thd  Thread context.
+  @param tl   TABLE_LIST element.
+*/
+
+void TABLE::init(THD *thd, TABLE_LIST *tl)
+{
+  DBUG_ASSERT(s->tmp_table != NO_TMP_TABLE || s->tdc->ref_count > 0);
+
+  if (thd->lex->need_correct_ident())
+    alias_name_used= my_strcasecmp(table_alias_charset,
+                                   s->table_name.str,
+                                   tl->alias.str);
+  /* Fix alias if table name changes. */
+  if (!alias.alloced_length() || strcmp(alias.c_ptr(), tl->alias.str))
+    alias.copy(tl->alias.str, tl->alias.length, alias.charset());
+
+  tablenr= thd->current_tablenr++;
+  used_fields= 0;
+  const_table= 0;
+  null_row= 0;
+  maybe_null= 0;
+  force_index= 0;
+  force_index_order= 0;
+  force_index_group= 0;
+  status= STATUS_NO_RECORD;
+  insert_values= 0;
+  fulltext_searched= 0;
+  file->ft_handler= 0;
+  reginfo.impossible_range= 0;
+  reginfo.join_tab= NULL;
+  reginfo.not_exists_optimize= FALSE;
+  reginfo.skip_locked= false;
+  created= TRUE;
+  cond_selectivity= 1.0;
+  cond_selectivity_sampling_explain= NULL;
+  range_rowid_filter_cost_info_elems= 0;
+  range_rowid_filter_cost_info_ptr= NULL;
+  range_rowid_filter_cost_info= NULL;
+  vers_write= s->versioned;
+  opt_range_condition_rows=0;
+  no_cache= false;
+  initialize_opt_range_structures();
+#ifdef HAVE_REPLICATION
+  /* used in RBR Triggers */
+  master_had_triggers= 0;
+#endif
+  /* Catch wrong handling of the auto_increment_field_not_null. */
+  DBUG_ASSERT(!auto_increment_field_not_null);
+  auto_increment_field_not_null= FALSE;
+
+  pos_in_table_list= tl;
+
+  clear_column_bitmaps();
+  for (Field **f_ptr= field ; *f_ptr ; f_ptr++)
+  {
+    (*f_ptr)->next_equal_field= NULL;
+    (*f_ptr)->cond_selectivity= 1.0;
+  }
+
+  /* enable and clear or disable engine query statistics */
+  if (thd->should_collect_handler_stats())
+    file->ha_handler_stats_reset();
+  else
+    file->ha_handler_stats_disable();
+
+  notnull_cond= 0;
+  DBUG_ASSERT(!file->keyread_enabled());
+
+  restore_record(this, s->default_values);
+
+  /* Tables may be reused in a sub statement. */
+  DBUG_ASSERT(!file->extra(HA_EXTRA_IS_ATTACHED_CHILDREN));
+}
+
+
+/*
+  Create Item_field for each column in the table.
+
+  SYNPOSIS
+    TABLE::fill_item_list()
+      item_list          a pointer to an empty list used to store items
+
+  DESCRIPTION
+    Create Item_field object for each column in the table and
+    initialize it with the corresponding Field. New items are
+    created in the current THD memory root.
+
+  RETURN VALUE
+    0                    success
+    1                    out of memory
+*/
+
+bool TABLE::fill_item_list(List<Item> *item_list) const
+{
+  /*
+    All Item_field's created using a direct pointer to a field
+    are fixed in Item_field constructor.
+  */
+  for (Field **ptr= field; *ptr; ptr++)
+  {
+    Item_field *item= new (in_use->mem_root) Item_field(in_use, *ptr);
+    if (!item || item_list->push_back(item))
+      return TRUE;
+  }
+  return FALSE;
+}
+
+/*
+  Reset an existing list of Item_field items to point to the
+  Fields of this table.
+
+  SYNPOSIS
+    TABLE::fill_item_list()
+      item_list          a non-empty list with Item_fields
+
+  DESCRIPTION
+    This is a counterpart of fill_item_list used to redirect
+    Item_fields to the fields of a newly created table.
+    The caller must ensure that number of items in the item_list
+    is the same as the number of columns in the table.
+*/
+
+void TABLE::reset_item_list(List<Item> *item_list, uint skip) const
+{
+  List_iterator_fast<Item> it(*item_list);
+  Field **ptr= field;
+  for ( ; skip && *ptr; skip--)
+    ptr++;
+  for (; *ptr; ptr++)
+  {
+    Item_field *item_field= (Item_field*) it++;
+    DBUG_ASSERT(item_field != 0);
+    item_field->reset_field(*ptr);
+  }
+}
+
+/*
+  calculate md5 of query
+
+  SYNOPSIS
+    TABLE_LIST::calc_md5()
+    buffer	buffer for md5 writing
+*/
+
+void  TABLE_LIST::calc_md5(char *buffer)
+{
+  uchar digest[16];
+  compute_md5_hash(digest, select_stmt.str,
+                   select_stmt.length);
+  sprintf(buffer,
+	    "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+	    digest[0], digest[1], digest[2], digest[3],
+	    digest[4], digest[5], digest[6], digest[7],
+	    digest[8], digest[9], digest[10], digest[11],
+	    digest[12], digest[13], digest[14], digest[15]);
+}
+
+
+/**
+  @brief
+  Create field translation for mergeable derived table/view.
+
+  @param thd  Thread handle
+
+  @details
+  Create field translation for mergeable derived table/view.
+
+  @return FALSE ok.
+  @return TRUE an error occur.
+*/
+
+bool TABLE_LIST::create_field_translation(THD *thd)
+{
+  Item *item;
+  Field_translator *transl;
+  SELECT_LEX *select= get_single_select();
+  List_iterator_fast<Item> it(select->item_list);
+  uint field_count= 0;
+  Query_arena *arena, backup;
+  bool res= FALSE;
+  DBUG_ENTER("TABLE_LIST::create_field_translation");
+  DBUG_PRINT("enter", ("Alias: '%s'  Unit: %p",
+                      (alias.str ? alias.str : "<NULL>"),
+                       get_unit()));
+
+  if (thd->stmt_arena->is_conventional() ||
+      thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
+  {
+    /* initialize lists */
+    used_items.empty();
+    persistent_used_items.empty();
+  }
+  else
+  {
+    /*
+      Copy the list created by natural join procedure because the procedure
+      will not be repeated.
+    */
+    used_items= persistent_used_items;
+  }
+
+  if (field_translation)
+  {
+    /*
+      Update items in the field translation after view have been prepared.
+      It's needed because some items in the select list, like IN subselects,
+      might be substituted for optimized ones.
+    */
+    if (is_view() && get_unit()->prepared && !field_translation_updated)
+    {
+      field_translation_updated= TRUE;
+      if (static_cast<uint>(field_translation_end - field_translation) <
+          select->item_list.elements)
+        goto allocate;
+      while ((item= it++))
+      {
+        field_translation[field_count++].item= item;
+      }
+    }
+
+    DBUG_RETURN(FALSE);
+  }
+
+allocate:
+  arena= thd->activate_stmt_arena_if_needed(&backup);
+
+  /* Create view fields translation table */
+
+  if (!(transl=
+        (Field_translator*)(thd->stmt_arena->
+                            alloc(select->item_list.elements *
+                                  sizeof(Field_translator)))))
+  {
+    res= TRUE;
+    goto exit;
+  }
+
+  while ((item= it++))
+  {
+    DBUG_ASSERT(item->name.str && item->name.str[0]);
+    transl[field_count].name.str=    thd->strmake(item->name.str, item->name.length);
+    transl[field_count].name.length= item->name.length;
+    transl[field_count++].item= item;
+  }
+  field_translation= transl;
+  field_translation_end= transl + field_count;
+  /* It's safe to cache this table for prepared statements */
+  cacheable_table= 1;
+
+exit:
+  if (arena)
+    thd->restore_active_arena(arena, &backup);
+
+  DBUG_RETURN(res);
+}
+
+
+/**
+  @brief
+  Create field translation for mergeable derived table/view.
+
+  @param thd  Thread handle
+
+  @details
+  Create field translation for mergeable derived table/view.
+
+  @return FALSE ok.
+  @return TRUE an error occur.
+*/
+
+bool TABLE_LIST::setup_underlying(THD *thd)
+{
+  DBUG_ENTER("TABLE_LIST::setup_underlying");
+
+  if (!view || (!field_translation && merge_underlying_list))
+  {
+    SELECT_LEX *select= get_single_select();
+
+    if (create_field_translation(thd))
+      DBUG_RETURN(TRUE);
+
+    /* full text function moving to current select */
+    if (select->ftfunc_list->elements)
+    {
+      Item_func_match *ifm;
+      SELECT_LEX *current_select= thd->lex->current_select;
+      List_iterator_fast<Item_func_match>
+        li(*(select_lex->ftfunc_list));
+      while ((ifm= li++))
+        current_select->ftfunc_list->push_front(ifm);
+    }
+  }
+  DBUG_RETURN(FALSE);
+}
+
+
+/*
+   Prepare where expression of derived table/view
+
+  SYNOPSIS
+    TABLE_LIST::prep_where()
+    thd             - thread handler
+    conds           - condition of this JOIN
+    no_where_clause - do not build WHERE or ON outer qwery do not need it
+                      (it is INSERT), we do not need conds if this flag is set
+
+  NOTE: have to be called befor CHECK OPTION preparation, because it makes
+  fix_fields for view WHERE clause
+
+  RETURN
+    FALSE - OK
+    TRUE  - error
+*/
+
+bool TABLE_LIST::prep_where(THD *thd, Item **conds,
+                               bool no_where_clause)
+{
+  DBUG_ENTER("TABLE_LIST::prep_where");
+  bool res= FALSE;
+
+  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
+  {
+    if (tbl->is_view_or_derived() &&
+        tbl->prep_where(thd, conds, no_where_clause))
+    {
+      DBUG_RETURN(TRUE);
+    }
+  }
+
+  if (where)
+  {
+    if (where->fixed())
+      where->update_used_tables();
+    else if (where->fix_fields(thd, &where))
+      DBUG_RETURN(TRUE);
+
+    /*
+      check that it is not VIEW in which we insert with INSERT SELECT
+      (in this case we can't add view WHERE condition to main SELECT_LEX)
+    */
+    if (!no_where_clause && !where_processed)
+    {
+      TABLE_LIST *tbl= this;
+      Query_arena *arena= thd->stmt_arena, backup;
+      arena= thd->activate_stmt_arena_if_needed(&backup);  // For easier test
+
+      /* Go up to join tree and try to find left join */
+      for (; tbl; tbl= tbl->embedding)
+      {
+        if (tbl->outer_join)
+        {
+          /*
+            Store WHERE condition to ON expression for outer join, because
+            we can't use WHERE to correctly execute left joins on VIEWs and
+            this expression will not be moved to WHERE condition (i.e. will
+            be clean correctly for PS/SP)
+          */
+          tbl->on_expr= and_conds(thd, tbl->on_expr,
+                                  where->copy_andor_structure(thd));
+          break;
+        }
+      }
+      if (tbl == 0)
+      {
+        if (*conds)
+          res= (*conds)->fix_fields_if_needed_for_bool(thd, conds);
+        if (!res)
+          *conds= and_conds(thd, *conds, where->copy_andor_structure(thd));
+        if (*conds && !res)
+          res= (*conds)->fix_fields_if_needed_for_bool(thd, conds);
+      }
+      if (arena)
+        thd->restore_active_arena(arena, &backup);
+      where_processed= TRUE;
+    }
+  }
+
+  DBUG_RETURN(res);
+}
+
+/**
+  Check that table/view is updatable and if it has single
+  underlying tables/views it is also updatable
+
+  @return Result of the check.
+*/
+
+bool TABLE_LIST::single_table_updatable()
+{
+  if (!updatable)
+    return false;
+  if (view && view->first_select_lex()->table_list.elements == 1)
+  {
+    /*
+      We need to check deeply only single table views. Multi-table views
+      will be turned to multi-table updates and then checked by leaf tables
+    */
+    return (((TABLE_LIST *)view->first_select_lex()->table_list.first)->
+            single_table_updatable());
+  }
+  return true;
+}
+
+
+/*
+  Merge ON expressions for a view
+
+  SYNOPSIS
+    merge_on_conds()
+    thd             thread handle
+    table           table for the VIEW
+    is_cascaded     TRUE <=> merge ON expressions from underlying views
+
+  DESCRIPTION
+    This function returns the result of ANDing the ON expressions
+    of the given view and all underlying views. The ON expressions
+    of the underlying views are added only if is_cascaded is TRUE.
+
+  RETURN
+    Pointer to the built expression if there is any.
+    Otherwise and in the case of a failure NULL is returned.
+*/
+
+static Item *
+merge_on_conds(THD *thd, TABLE_LIST *table, bool is_cascaded)
+{
+  DBUG_ENTER("merge_on_conds");
+
+  Item *cond= NULL;
+  DBUG_PRINT("info", ("alias: %s", table->alias.str));
+  if (table->on_expr)
+    cond= table->on_expr->copy_andor_structure(thd);
+  if (!table->view)
+    DBUG_RETURN(cond);
+  for (TABLE_LIST *tbl=
+         (TABLE_LIST*)table->view->first_select_lex()->table_list.first;
+       tbl;
+       tbl= tbl->next_local)
+  {
+    if (tbl->view && !is_cascaded)
+      continue;
+    cond= and_conds(thd, cond, merge_on_conds(thd, tbl, is_cascaded));
+  }
+  DBUG_RETURN(cond);
+}
+
+
+/*
+  Prepare check option expression of table
+
+  SYNOPSIS
+    TABLE_LIST::prep_check_option()
+    thd             - thread handler
+    check_opt_type  - WITH CHECK OPTION type (VIEW_CHECK_NONE,
+                      VIEW_CHECK_LOCAL, VIEW_CHECK_CASCADED)
+                      we use this parameter instead of direct check of
+                      effective_with_check to change type of underlying
+                      views to VIEW_CHECK_CASCADED if outer view have
+                      such option and prevent processing of underlying
+                      view check options if outer view have just
+                      VIEW_CHECK_LOCAL option.
+
+  NOTE
+    This method builds check option condition to use it later on
+    every call (usual execution or every SP/PS call).
+    This method have to be called after WHERE preparation
+    (TABLE_LIST::prep_where)
+
+  RETURN
+    FALSE - OK
+    TRUE  - error
+*/
+
+bool TABLE_LIST::prep_check_option(THD *thd, uint8 check_opt_type)
+{
+  DBUG_ENTER("TABLE_LIST::prep_check_option");
+  bool is_cascaded= check_opt_type == VIEW_CHECK_CASCADED;
+  TABLE_LIST *merge_underlying_list= view->first_select_lex()->get_table_list();
+  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
+  {
+    /* see comment of check_opt_type parameter */
+    if (tbl->view && tbl->prep_check_option(thd, (is_cascaded ?
+                                                  VIEW_CHECK_CASCADED :
+                                                  VIEW_CHECK_NONE)))
+      DBUG_RETURN(TRUE);
+  }
+
+  if (check_opt_type && !check_option_processed)
+  {
+    Query_arena *arena= thd->stmt_arena, backup;
+    arena= thd->activate_stmt_arena_if_needed(&backup);  // For easier test
+
+    if (where)
+    {
+      check_option= where->copy_andor_structure(thd);
+    }
+    if (is_cascaded)
+    {
+      for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
+      {
+        if (tbl->check_option)
+          check_option= and_conds(thd, check_option, tbl->check_option);
+      }
+    }
+    check_option= and_conds(thd, check_option,
+                            merge_on_conds(thd, this, is_cascaded));
+
+    if (arena)
+      thd->restore_active_arena(arena, &backup);
+    check_option_processed= TRUE;
+
+  }
+
+  if (check_option)
+  {
+    const char *save_where= thd->where;
+    thd->where= "check option";
+    if (check_option->fix_fields_if_needed_for_bool(thd, &check_option))
+      DBUG_RETURN(TRUE);
+    thd->where= save_where;
+  }
+  DBUG_RETURN(FALSE);
+}
+
+
+/**
+  Hide errors which show view underlying table information. 
+  There are currently two mechanisms at work that handle errors for views,
+  this one and a more general mechanism based on an Internal_error_handler,
+  see Show_create_error_handler. The latter handles errors encountered during
+  execution of SHOW CREATE VIEW, while the mechanism using this method is
+  handles SELECT from views. The two methods should not clash.
+
+  @param[in,out]  thd     thread handler
+
+  @pre This method can be called only if there is an error.
+*/
+
+void TABLE_LIST::hide_view_error(THD *thd)
+{
+  if ((thd->killed && !thd->is_error())|| thd->get_internal_handler())
+    return;
+  /* Hide "Unknown column" or "Unknown function" error */
+  DBUG_ASSERT(thd->is_error());
+  switch (thd->get_stmt_da()->sql_errno()) {
+    case ER_BAD_FIELD_ERROR:
+    case ER_SP_DOES_NOT_EXIST:
+    case ER_FUNC_INEXISTENT_NAME_COLLISION:
+    case ER_PROCACCESS_DENIED_ERROR:
+    case ER_COLUMNACCESS_DENIED_ERROR:
+    case ER_TABLEACCESS_DENIED_ERROR:
+    case ER_TABLE_NOT_LOCKED:
+    case ER_NO_SUCH_TABLE:
+    {
+      TABLE_LIST *top= top_table();
+      thd->clear_error();
+      my_error(ER_VIEW_INVALID, MYF(0),
+               top->view_db.str, top->view_name.str);
+      break;
+    }
+
+    case ER_NO_DEFAULT_FOR_FIELD:
+    {
+      TABLE_LIST *top= top_table();
+      thd->clear_error();
+      // TODO: make correct error message
+      my_error(ER_NO_DEFAULT_FOR_VIEW_FIELD, MYF(0),
+               top->view_db.str, top->view_name.str);
+      break;
+    }
+  }
+}
+
+
+/*
+  Find underlying base tables (TABLE_LIST) which represent given
+  table_to_find (TABLE)
+
+  SYNOPSIS
+    TABLE_LIST::find_underlying_table()
+    table_to_find table to find
+
+  RETURN
+    0  table is not found
+    found table reference
+*/
+
+TABLE_LIST *TABLE_LIST::find_underlying_table(TABLE *table_to_find)
+{
+  /* is this real table and table which we are looking for? */
+  if (table == table_to_find && view == 0)
+    return this;
+  if (!view)
+    return 0;
+
+  for (TABLE_LIST *tbl= view->first_select_lex()->get_table_list();
+       tbl;
+       tbl= tbl->next_local)
+  {
+    TABLE_LIST *result;
+    if ((result= tbl->find_underlying_table(table_to_find)))
+      return result;
+  }
+  return 0;
+}
+
+/*
+  cleanup items belonged to view fields translation table
+
+  SYNOPSIS
+    TABLE_LIST::cleanup_items()
+*/
+
+void TABLE_LIST::cleanup_items()
+{
+  if (!field_translation)
+    return;
+
+  for (Field_translator *transl= field_translation;
+       transl < field_translation_end;
+       transl++)
+    transl->item->walk(&Item::cleanup_processor, 0, 0);
+}
+
+
+/*
+  check CHECK OPTION condition both for view and underlying table
+
+  SYNOPSIS
+    TABLE_LIST::view_check_option()
+    ignore_failure ignore check option fail
+
+  RETURN
+    VIEW_CHECK_OK     OK
+    VIEW_CHECK_ERROR  FAILED
+    VIEW_CHECK_SKIP   FAILED, but continue
+*/
+
+
+int TABLE_LIST::view_check_option(THD *thd, bool ignore_failure)
+{
+  if (check_option)
+  {
+    /* VIEW's CHECK OPTION CLAUSE */
+    Counting_error_handler ceh;
+    thd->push_internal_handler(&ceh);
+    bool res= check_option->val_int() == 0;
+    thd->pop_internal_handler();
+    if (ceh.errors)
+      return(VIEW_CHECK_ERROR);
+    if (res)
+    {
+      TABLE_LIST *main_view= top_table();
+      const char *name_db= (main_view->view ? main_view->view_db.str :
+                            main_view->db.str);
+      const char *name_table= (main_view->view ? main_view->view_name.str :
+                               main_view->table_name.str);
+      my_error(ER_VIEW_CHECK_FAILED, MYF(ignore_failure ? ME_WARNING : 0),
+               name_db, name_table);
+      return ignore_failure ? VIEW_CHECK_SKIP : VIEW_CHECK_ERROR;
+    }
+  }
+  return table->verify_constraints(ignore_failure);
+}
+
+
+int TABLE::verify_constraints(bool ignore_failure)
+{
+  /*
+    We have to check is_error() first as we are checking it for each
+    constraint to catch fatal warnings.
+  */
+  if (in_use->is_error())
+    return (VIEW_CHECK_ERROR);
+
+  /* go trough check option clauses for fields and table */
+  if (check_constraints &&
+      !(in_use->variables.option_bits & OPTION_NO_CHECK_CONSTRAINT_CHECKS))
+  {
+    if (versioned() && !vers_end_field()->is_max())
+      return VIEW_CHECK_OK;
+
+    StringBuffer<MAX_FIELD_WIDTH> field_error(system_charset_info);
+    for (Virtual_column_info **chk= check_constraints ; *chk ; chk++)
+    {
+      /*
+        yes! NULL is ok.
+        see 4.23.3.4 Table check constraints, part 2, SQL:2016
+      */
+      if (((*chk)->expr->val_int() == 0 && !(*chk)->expr->null_value) ||
+          in_use->is_error())
+      {
+        enum_vcol_info_type vcol_type= (*chk)->get_vcol_type();
+        DBUG_ASSERT(vcol_type == VCOL_CHECK_TABLE ||
+                    vcol_type == VCOL_CHECK_FIELD);
+
+        field_error.set_buffer_if_not_allocated(system_charset_info);
+        field_error.length(0);
+
+        if (vcol_type == VCOL_CHECK_FIELD)
+        {
+          field_error.append(s->table_name);
+          field_error.append('.');
+        }
+        field_error.append((*chk)->name);
+        my_error(ER_CONSTRAINT_FAILED,
+                 MYF(ignore_failure ? ME_WARNING : 0), field_error.c_ptr(),
+                 s->db.str, s->table_name.str);
+        return ignore_failure ? VIEW_CHECK_SKIP : VIEW_CHECK_ERROR;
+      }
+    }
+  }
+  /*
+    We have to check in_use() as checking constraints may have generated
+    warnings that should be treated as errors
+  */
+  return(!in_use->is_error() ? VIEW_CHECK_OK : VIEW_CHECK_ERROR);
+}
+
+/*
+  Find table in underlying tables by mask and check that only this
+  table belong to given mask
+
+  SYNOPSIS
+    TABLE_LIST::check_single_table()
+    table_arg	reference on variable where to store found table
+		(should be 0 on call, to find table, or point to table for
+		unique test)
+    map         bit mask of tables
+    view_arg    view for which we are looking table
+
+  RETURN
+    FALSE table not found or found only one
+    TRUE  found several tables
+*/
+
+bool TABLE_LIST::check_single_table(TABLE_LIST **table_arg,
+                                       table_map map,
+                                       TABLE_LIST *view_arg)
+{
+  if (!select_lex)
+    return FALSE;
+  DBUG_ASSERT(is_merged_derived());
+  for (TABLE_LIST *tbl= get_single_select()->get_table_list();
+       tbl;
+       tbl= tbl->next_local)
+  {
+    /*
+      Merged view has also temporary table attached (in 5.2 if it has table
+      then it was real table), so we have filter such temporary tables out
+      by checking that it is not merged view
+    */
+    if (tbl->table &&
+        !(tbl->is_view() &&
+          tbl->is_merged_derived()))
+    {
+      if (tbl->table->map & map)
+      {
+	if (*table_arg)
+	  return TRUE;
+        *table_arg= tbl;
+        tbl->check_option= view_arg->check_option;
+      }
+    }
+    else if (tbl->check_single_table(table_arg, map, view_arg))
+      return TRUE;
+  }
+  return FALSE;
+}
+
+
+/*
+  Set insert_values buffer
+
+  SYNOPSIS
+    set_insert_values()
+    mem_root   memory pool for allocating
+
+  RETURN
+    FALSE - OK
+    TRUE  - out of memory
+*/
+
+bool TABLE_LIST::set_insert_values(MEM_ROOT *mem_root)
+{
+  DBUG_ENTER("set_insert_values");
+  if (table)
+  {
+    DBUG_PRINT("info", ("setting insert_value for table"));
+    if (!table->insert_values &&
+        !(table->insert_values= (uchar *)alloc_root(mem_root,
+                                                   table->s->rec_buff_length)))
+      DBUG_RETURN(TRUE);
+  }
+  else
+  {
+    DBUG_PRINT("info", ("setting insert_value for view"));
+    DBUG_ASSERT(is_view_or_derived() && is_merged_derived());
+    for (TABLE_LIST *tbl=
+           (TABLE_LIST*)view->first_select_lex()->table_list.first;
+         tbl;
+         tbl= tbl->next_local)
+      if (tbl->set_insert_values(mem_root))
+        DBUG_RETURN(TRUE);
+  }
+  DBUG_RETURN(FALSE);
+}
+
+
+/*
+  Test if this is a leaf with respect to name resolution.
+
+  SYNOPSIS
+    TABLE_LIST::is_leaf_for_name_resolution()
+
+  DESCRIPTION
+    A table reference is a leaf with respect to name resolution if
+    it is either a leaf node in a nested join tree (table, view,
+    schema table, subquery), or an inner node that represents a
+    NATURAL/USING join, or a nested join with materialized join
+    columns.
+
+  RETURN
+    TRUE if a leaf, FALSE otherwise.
+*/
+bool TABLE_LIST::is_leaf_for_name_resolution()
+{
+  return (is_merged_derived() || is_natural_join || is_join_columns_complete ||
+          !nested_join);
+}
+
+
+/*
+  Retrieve the first (left-most) leaf in a nested join tree with
+  respect to name resolution.
+
+  SYNOPSIS
+    TABLE_LIST::first_leaf_for_name_resolution()
+
+  DESCRIPTION
+    Given that 'this' is a nested table reference, recursively walk
+    down the left-most children of 'this' until we reach a leaf
+    table reference with respect to name resolution.
+
+  IMPLEMENTATION
+    The left-most child of a nested table reference is the last element
+    in the list of children because the children are inserted in
+    reverse order.
+
+  RETURN
+    If 'this' is a nested table reference - the left-most child of
+      the tree rooted in 'this',
+    else return 'this'
+*/
+
+TABLE_LIST *TABLE_LIST::first_leaf_for_name_resolution()
+{
+  TABLE_LIST *UNINIT_VAR(cur_table_ref);
+  NESTED_JOIN *cur_nested_join;
+
+  if (is_leaf_for_name_resolution())
+    return this;
+  DBUG_ASSERT(nested_join);
+
+  for (cur_nested_join= nested_join;
+       cur_nested_join;
+       cur_nested_join= cur_table_ref->nested_join)
+  {
+    List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
+    cur_table_ref= it++;
+    /*
+      If the current nested join is a RIGHT JOIN, the operands in
+      'join_list' are in reverse order, thus the first operand is
+      already at the front of the list. Otherwise the first operand
+      is in the end of the list of join operands.
+    */
+    if (!(cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
+    {
+      TABLE_LIST *next;
+      while ((next= it++))
+        cur_table_ref= next;
+    }
+    if (cur_table_ref->is_leaf_for_name_resolution())
+      break;
+  }
+  return cur_table_ref;
+}
+
+
+/*
+  Retrieve the last (right-most) leaf in a nested join tree with
+  respect to name resolution.
+
+  SYNOPSIS
+    TABLE_LIST::last_leaf_for_name_resolution()
+
+  DESCRIPTION
+    Given that 'this' is a nested table reference, recursively walk
+    down the right-most children of 'this' until we reach a leaf
+    table reference with respect to name resolution.
+
+  IMPLEMENTATION
+    The right-most child of a nested table reference is the first
+    element in the list of children because the children are inserted
+    in reverse order.
+
+  RETURN
+    - If 'this' is a nested table reference - the right-most child of
+      the tree rooted in 'this',
+    - else - 'this'
+*/
+
+TABLE_LIST *TABLE_LIST::last_leaf_for_name_resolution()
+{
+  TABLE_LIST *cur_table_ref= this;
+  NESTED_JOIN *cur_nested_join;
+
+  if (is_leaf_for_name_resolution())
+    return this;
+  DBUG_ASSERT(nested_join);
+
+  for (cur_nested_join= nested_join;
+       cur_nested_join;
+       cur_nested_join= cur_table_ref->nested_join)
+  {
+    cur_table_ref= cur_nested_join->join_list.head();
+    /*
+      If the current nested is a RIGHT JOIN, the operands in
+      'join_list' are in reverse order, thus the last operand is in the
+      end of the list.
+    */
+    if ((cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
+    {
+      List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
+      TABLE_LIST *next;
+      cur_table_ref= it++;
+      while ((next= it++))
+        cur_table_ref= next;
+    }
+    if (cur_table_ref->is_leaf_for_name_resolution())
+      break;
+  }
+  return cur_table_ref;
+}
+
+
+/*
+  Register access mode which we need for underlying tables
+
+  SYNOPSIS
+    register_want_access()
+    want_access          Acess which we require
+*/
+
+void TABLE_LIST::register_want_access(privilege_t want_access)
+{
+  /* Remove SHOW_VIEW_ACL, because it will be checked during making view */
+  want_access&= ~SHOW_VIEW_ACL;
+  if (belong_to_view)
+  {
+    grant.want_privilege= want_access;
+    if (table)
+      table->grant.want_privilege= want_access;
+  }
+  if (!view)
+    return;
+  for (TABLE_LIST *tbl= view->first_select_lex()->get_table_list();
+       tbl;
+       tbl= tbl->next_local)
+    tbl->register_want_access(want_access);
+}
+
+
+/*
+  Load security context information for this view
+
+  SYNOPSIS
+    TABLE_LIST::prepare_view_security_context()
+    thd                  [in] thread handler
+
+  RETURN
+    FALSE  OK
+    TRUE   Error
+*/
+
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+bool TABLE_LIST::prepare_view_security_context(THD *thd, bool upgrade_check)
+{
+  DBUG_ENTER("TABLE_LIST::prepare_view_security_context");
+  DBUG_PRINT("enter", ("table: %s", alias.str));
+
+  DBUG_ASSERT(!prelocking_placeholder && view);
+  if (view_suid)
+  {
+    DBUG_PRINT("info", ("This table is suid view => load contest"));
+    DBUG_ASSERT(view && view_sctx);
+    if (acl_getroot(view_sctx, definer.user.str, definer.host.str,
+                                definer.host.str, thd->db.str))
+    {
+      if ((thd->lex->sql_command == SQLCOM_SHOW_CREATE) ||
+          (thd->lex->sql_command == SQLCOM_SHOW_FIELDS))
+      {
+        push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE, 
+                            ER_NO_SUCH_USER, 
+                            ER_THD(thd, ER_NO_SUCH_USER),
+                            definer.user.str, definer.host.str);
+      }
+      else
+      {
+        if (thd->security_ctx->master_access & PRIV_REVEAL_MISSING_DEFINER)
+        {
+          my_error(ER_NO_SUCH_USER, MYF(upgrade_check ? ME_WARNING: 0),
+                   definer.user.str, definer.host.str);
+        }
+        else
+        {
+          if (thd->password == 2)
+            my_error(ER_ACCESS_DENIED_NO_PASSWORD_ERROR, MYF(0),
+                     thd->security_ctx->priv_user,
+                     thd->security_ctx->priv_host);
+          else
+            my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
+                     thd->security_ctx->priv_user,
+                     thd->security_ctx->priv_host,
+                     (thd->password ?  ER_THD(thd, ER_YES) :
+                      ER_THD(thd, ER_NO)));
+        }
+        DBUG_RETURN(TRUE);
+      }
+    }
+  }
+  DBUG_RETURN(FALSE);
+
+}
+#endif
+
+
+/*
+  Find security context of current view
+
+  SYNOPSIS
+    TABLE_LIST::find_view_security_context()
+    thd                  [in] thread handler
+
+*/
+
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+Security_context *TABLE_LIST::find_view_security_context(THD *thd)
+{
+  Security_context *sctx;
+  TABLE_LIST *upper_view= this;
+  DBUG_ENTER("TABLE_LIST::find_view_security_context");
+
+  DBUG_ASSERT(view);
+  while (upper_view && !upper_view->view_suid)
+  {
+    DBUG_ASSERT(!upper_view->prelocking_placeholder);
+    upper_view= upper_view->referencing_view;
+  }
+  if (upper_view)
+  {
+    DBUG_PRINT("info", ("Securety context of view %s will be used",
+                        upper_view->alias.str));
+    sctx= upper_view->view_sctx;
+    DBUG_ASSERT(sctx);
+  }
+  else
+  {
+    DBUG_PRINT("info", ("Current global context will be used"));
+    sctx= thd->security_ctx;
+  }
+  DBUG_RETURN(sctx);
+}
+#endif
+
+
+/*
+  Prepare security context and load underlying tables priveleges for view
+
+  SYNOPSIS
+    TABLE_LIST::prepare_security()
+    thd                  [in] thread handler
+
+  RETURN
+    FALSE  OK
+    TRUE   Error
+*/
+
+bool TABLE_LIST::prepare_security(THD *thd)
+{
+  List_iterator_fast<TABLE_LIST> tb(*view_tables);
+  TABLE_LIST *tbl;
+  DBUG_ENTER("TABLE_LIST::prepare_security");
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+  /*
+    Check if we are running REPAIR VIEW FOR UPGRADE
+    In this case we are probably comming from mysql_upgrade and
+    should not get an error for mysql.user table we just created.
+  */
+  bool upgrade_check= (thd->lex->sql_command == SQLCOM_REPAIR &&
+                       (thd->lex->check_opt.sql_flags &
+                        (TT_FOR_UPGRADE | TT_FROM_MYSQL)) &&
+                       (thd->security_ctx->master_access &
+                        PRIV_REVEAL_MISSING_DEFINER));
+  Security_context *save_security_ctx= thd->security_ctx;
+
+  DBUG_ASSERT(!prelocking_placeholder);
+  if (prepare_view_security_context(thd, upgrade_check))
+  {
+    if (upgrade_check)
+    {
+      /* REPAIR needs SELECT_ACL */
+      while ((tbl= tb++))
+      {
+        tbl->grant.privilege= SELECT_ACL;
+        tbl->security_ctx= save_security_ctx;
+      }
+      DBUG_RETURN(FALSE);
+    }
+    DBUG_RETURN(TRUE);                          // Fatal
+  }
+  thd->security_ctx= find_view_security_context(thd);
+  opt_trace_disable_if_no_security_context_access(thd);
+  while ((tbl= tb++))
+  {
+    DBUG_ASSERT(tbl->referencing_view);
+    const char *local_db, *local_table_name;
+    if (tbl->view)
+    {
+      local_db= tbl->view_db.str;
+      local_table_name= tbl->view_name.str;
+    }
+    else
+    {
+      local_db= tbl->db.str;
+      local_table_name= tbl->table_name.str;
+    }
+    fill_effective_table_privileges(thd, &tbl->grant, local_db,
+                                    local_table_name);
+    if (tbl->table)
+      tbl->table->grant= grant;
+  }
+  thd->security_ctx= save_security_ctx;
+#else
+  while ((tbl= tb++))
+    tbl->grant.privilege= ALL_KNOWN_ACL;
+#endif /* NO_EMBEDDED_ACCESS_CHECKS */
+  DBUG_RETURN(FALSE);
+}
+
+#ifndef DBUG_OFF
+void TABLE_LIST::set_check_merged()
+{
+  if (is_view())
+    return;
+
+  DBUG_ASSERT(derived);
+  /*
+    It is not simple to check all, but at least this should be checked:
+    this select is not excluded or the exclusion came from above.
+  */
+  DBUG_ASSERT(derived->is_excluded() ||
+              !derived->first_select()->exclude_from_table_unique_test ||
+              derived->outer_select()->
+              exclude_from_table_unique_test);
+}
+#endif
+
+void TABLE_LIST::set_check_materialized()
+{
+  DBUG_ENTER("TABLE_LIST::set_check_materialized");
+  SELECT_LEX_UNIT *derived= this->derived;
+  if (view)
+    derived= this->derived= &view->unit;
+  DBUG_ASSERT(derived);
+  DBUG_ASSERT(!derived->is_excluded());
+  if (!derived->first_select()->exclude_from_table_unique_test)
+    derived->set_unique_exclude();
+  else
+  {
+    /*
+      The subtree should be already excluded
+    */
+    DBUG_ASSERT(!derived->first_select()->first_inner_unit() ||
+                derived->first_select()->first_inner_unit()->with_element ||
+                derived->first_select()->first_inner_unit()->first_select()->
+                exclude_from_table_unique_test);
+  }
+  DBUG_VOID_RETURN;
+}
+
+TABLE *TABLE_LIST::get_real_join_table()
+{
+  TABLE_LIST *tbl= this;
+  while (tbl->table == NULL || tbl->table->reginfo.join_tab == NULL)
+  {
+    if ((tbl->view == NULL && tbl->derived == NULL) ||
+        tbl->is_materialized_derived())
+      break;
+    /* we do not support merging of union yet */
+    DBUG_ASSERT(tbl->view == NULL ||
+               tbl->view->first_select_lex()->next_select() == NULL);
+    DBUG_ASSERT(tbl->derived == NULL ||
+               tbl->derived->first_select()->next_select() == NULL);
+
+    {
+      List_iterator_fast<TABLE_LIST>
+        ti(tbl->view != NULL ?
+           tbl->view->first_select_lex()->top_join_list :
+           tbl->derived->first_select()->top_join_list);
+      for (;;)
+      {
+        tbl= NULL;
+        /*
+          Find left table in outer join on this level
+          (the list is reverted).
+        */
+        for (TABLE_LIST *t= ti++; t; t= ti++)
+          tbl= t;
+        if (!tbl)
+          return NULL; // view/derived with no tables
+        if (!tbl->nested_join)
+          break;
+        /* go deeper if we've found nested join */
+        ti= tbl->nested_join->join_list;
+      }
+    }
+  }
+
+  return tbl->table;
+}
+
+
+Natural_join_column::Natural_join_column(Field_translator *field_param,
+                                         TABLE_LIST *tab)
+{
+  DBUG_ASSERT(tab->field_translation);
+  view_field= field_param;
+  table_field= NULL;
+  table_ref= tab;
+  is_common= FALSE;
+}
+
+
+Natural_join_column::Natural_join_column(Item_field *field_param,
+                                         TABLE_LIST *tab)
+{
+  DBUG_ASSERT(tab->table == field_param->field->table);
+  table_field= field_param;
+  view_field= NULL;
+  table_ref= tab;
+  is_common= FALSE;
+}
+
+
+LEX_CSTRING *Natural_join_column::name()
+{
+  if (view_field)
+  {
+    DBUG_ASSERT(table_field == NULL);
+    return &view_field->name;
+  }
+
+  return &table_field->field_name;
+}
+
+
+Item *Natural_join_column::create_item(THD *thd)
+{
+  if (view_field)
+  {
+    DBUG_ASSERT(table_field == NULL);
+    return create_view_field(thd, table_ref, &view_field->item,
+                             &view_field->name);
+  }
+  return table_field;
+}
+
+
+Field *Natural_join_column::field()
+{
+  if (view_field)
+  {
+    DBUG_ASSERT(table_field == NULL);
+    return NULL;
+  }
+  return table_field->field;
+}
+
+
+const char *Natural_join_column::safe_table_name()
+{
+  DBUG_ASSERT(table_ref);
+  return table_ref->alias.str ? table_ref->alias.str : "";
+}
+
+
+const char *Natural_join_column::safe_db_name()
+{
+  if (view_field)
+    return table_ref->view_db.str ? table_ref->view_db.str : "";
+
+  /*
+    Test that TABLE_LIST::db is the same as TABLE_SHARE::db to
+    ensure consistency. An exception are I_S schema tables, which
+    are inconsistent in this respect.
+  */
+  DBUG_ASSERT(!cmp(&table_ref->db, &table_ref->table->s->db) ||
+              table_ref->table_function ||
+              (table_ref->schema_table &&
+               is_infoschema_db(&table_ref->table->s->db)) ||
+              table_ref->is_materialized_derived());
+  return table_ref->db.str ? table_ref->db.str : "";
+}
+
+
+GRANT_INFO *Natural_join_column::grant()
+{
+/*  if (view_field)
+    return &(table_ref->grant);
+  return &(table_ref->table->grant);*/
+  /*
+    Have to check algorithm because merged derived also has
+    field_translation.
+  */
+//if (table_ref->effective_algorithm == DTYPE_ALGORITHM_MERGE)
+  if (table_ref->is_merged_derived())
+    return &(table_ref->grant);
+  return &(table_ref->table->grant);
+}
+
+
+void Field_iterator_view::set(TABLE_LIST *table)
+{
+  DBUG_ASSERT(table->field_translation);
+  view= table;
+  ptr= table->field_translation;
+  array_end= table->field_translation_end;
+}
+
+
+LEX_CSTRING *Field_iterator_table::name()
+{
+  return &(*ptr)->field_name;
+}
+
+
+Item *Field_iterator_table::create_item(THD *thd)
+{
+  SELECT_LEX *select= thd->lex->current_select;
+
+  Item_field *item= new (thd->mem_root) Item_field(thd, &select->context, *ptr);
+  DBUG_ASSERT(strlen(item->name.str) == item->name.length);
+  if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
+      !thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS &&
+      select->join)
+  {
+    select->join->non_agg_fields.push_back(item);
+    item->marker= select->cur_pos_in_select_list;
+    select->set_non_agg_field_used(true);
+  }
+  return item;
+}
+
+
+LEX_CSTRING *Field_iterator_view::name()
+{
+  return &ptr->name;
+}
+
+
+Item *Field_iterator_view::create_item(THD *thd)
+{
+  return create_view_field(thd, view, &ptr->item, &ptr->name);
+}
+
+Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
+                        LEX_CSTRING *name)
+{
+  bool save_wrapper= thd->lex->current_select->no_wrap_view_item;
+  Item *field= *field_ref;
+  DBUG_ENTER("create_view_field");
+
+  if (view->schema_table_reformed)
+  {
+    /*
+      Translation table items are always Item_fields and already fixed
+      ('mysql_schema_table' function). So we can return directly the
+      field. This case happens only for 'show & where' commands.
+    */
+    DBUG_ASSERT(field && field->fixed());
+    DBUG_RETURN(field);
+  }
+
+  DBUG_ASSERT(field);
+  thd->lex->current_select->no_wrap_view_item= TRUE;
+  if (!field->fixed())
+  {
+    if (field->fix_fields(thd, field_ref))
+    {
+      thd->lex->current_select->no_wrap_view_item= save_wrapper;
+      DBUG_RETURN(0);
+    }
+    field= *field_ref;
+  }
+  thd->lex->current_select->no_wrap_view_item= save_wrapper;
+  if (save_wrapper)
+  {
+    DBUG_RETURN(field);
+  }
+  Name_resolution_context *context= (view->view ?
+                                     &view->view->first_select_lex()->context:
+                                     &thd->lex->first_select_lex()->context);
+  Item *item= (new (thd->mem_root)
+               Item_direct_view_ref(thd, context, field_ref, view->alias,
+                                    *name, view));
+  if (!item)
+    return NULL;
+  /*
+    Force creation of nullable item for the result tmp table for outer joined
+    views/derived tables.
+  */
+  if (view->table && view->table->maybe_null)
+    item->set_maybe_null();
+  /* Save item in case we will need to fall back to materialization. */
+  view->used_items.push_front(item, thd->mem_root);
+  /*
+    If we create this reference on persistent memory then it should be
+    present in persistent list
+  */
+  if (thd->mem_root == thd->stmt_arena->mem_root)
+    view->persistent_used_items.push_front(item, thd->mem_root);
+  DBUG_RETURN(item);
+}
+
+
+void Field_iterator_natural_join::set(TABLE_LIST *table_ref)
+{
+  DBUG_ASSERT(table_ref->join_columns);
+  column_ref_it.init(*(table_ref->join_columns));
+  cur_column_ref= column_ref_it++;
+}
+
+
+void Field_iterator_natural_join::next()
+{
+  cur_column_ref= column_ref_it++;
+  DBUG_ASSERT(!cur_column_ref || ! cur_column_ref->table_field ||
+              cur_column_ref->table_ref->table ==
+              cur_column_ref->table_field->field->table);
+}
+
+
+void Field_iterator_table_ref::set_field_iterator()
+{
+  DBUG_ENTER("Field_iterator_table_ref::set_field_iterator");
+  /*
+    If the table reference we are iterating over is a natural join, or it is
+    an operand of a natural join, and TABLE_LIST::join_columns contains all
+    the columns of the join operand, then we pick the columns from
+    TABLE_LIST::join_columns, instead of the  orginial container of the
+    columns of the join operator.
+  */
+  if (table_ref->is_join_columns_complete)
+  {
+    /* Necesary, but insufficient conditions. */
+    DBUG_ASSERT(table_ref->is_natural_join ||
+                table_ref->nested_join ||
+                (table_ref->join_columns &&
+                 /* This is a merge view. */
+                 ((table_ref->field_translation &&
+                   table_ref->join_columns->elements ==
+                   (ulong)(table_ref->field_translation_end -
+                           table_ref->field_translation)) ||
+                  /* This is stored table or a tmptable view. */
+                  (!table_ref->field_translation &&
+                   table_ref->join_columns->elements ==
+                   table_ref->table->s->fields))));
+    field_it= &natural_join_it;
+    DBUG_PRINT("info",("field_it for '%s' is Field_iterator_natural_join",
+                       table_ref->alias.str));
+  }
+  /* This is a merge view, so use field_translation. */
+  else if (table_ref->is_merged_derived() && table_ref->field_translation)
+  {
+    field_it= &view_field_it;
+    DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_view",
+                        table_ref->alias.str));
+  }
+  /* This is a base table or stored view. */
+  else
+  {
+    DBUG_ASSERT(table_ref->table || table_ref->view);
+    field_it= &table_field_it;
+    DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_table",
+                        table_ref->alias.str));
+  }
+  field_it->set(table_ref);
+  DBUG_VOID_RETURN;
+}
+
+
+void Field_iterator_table_ref::set(TABLE_LIST *table)
+{
+  DBUG_ASSERT(table);
+  first_leaf= table->first_leaf_for_name_resolution();
+  last_leaf=  table->last_leaf_for_name_resolution();
+  DBUG_ASSERT(first_leaf && last_leaf);
+  table_ref= first_leaf;
+  set_field_iterator();
+}
+
+
+void Field_iterator_table_ref::next()
+{
+  /* Move to the next field in the current table reference. */
+  field_it->next();
+  /*
+    If all fields of the current table reference are exhausted, move to
+    the next leaf table reference.
+  */
+  if (field_it->end_of_fields() && table_ref != last_leaf)
+  {
+    table_ref= table_ref->next_name_resolution_table;
+    DBUG_ASSERT(table_ref);
+    set_field_iterator();
+  }
+}
+
+
+const char *Field_iterator_table_ref::get_table_name()
+{
+  if (table_ref->view)
+    return table_ref->view_name.str;
+  if (table_ref->is_derived())
+    return table_ref->table->s->table_name.str;
+  else if (table_ref->is_natural_join)
+    return natural_join_it.column_ref()->safe_table_name();
+
+  DBUG_ASSERT(!strcmp(table_ref->table_name.str,
+                      table_ref->table->s->table_name.str) ||
+              table_ref->schema_table || table_ref->table_function);
+  return table_ref->table_name.str;
+}
+
+
+const char *Field_iterator_table_ref::get_db_name()
+{
+  if (table_ref->view)
+    return table_ref->view_db.str;
+  else if (table_ref->is_natural_join)
+    return natural_join_it.column_ref()->safe_db_name();
+
+  /*
+    Test that TABLE_LIST::db is the same as TABLE_SHARE::db to
+    ensure consistency. An exception are I_S schema tables, which
+    are inconsistent in this respect.
+  */
+  DBUG_ASSERT(!cmp(&table_ref->db, &table_ref->table->s->db) ||
+              (table_ref->schema_table &&
+               is_infoschema_db(&table_ref->table->s->db)) ||
+               table_ref->table_function);
+
+  return table_ref->db.str;
+}
+
+
+GRANT_INFO *Field_iterator_table_ref::grant()
+{
+  if (table_ref->view)
+    return &(table_ref->grant);
+  else if (table_ref->is_natural_join)
+    return natural_join_it.column_ref()->grant();
+  return &(table_ref->table->grant);
+}
+
+
+/*
+  Create new or return existing column reference to a column of a
+  natural/using join.
+
+  SYNOPSIS
+    Field_iterator_table_ref::get_or_create_column_ref()
+    parent_table_ref  the parent table reference over which the
+                      iterator is iterating
+
+  DESCRIPTION
+    Create a new natural join column for the current field of the
+    iterator if no such column was created, or return an already
+    created natural join column. The former happens for base tables or
+    views, and the latter for natural/using joins. If a new field is
+    created, then the field is added to 'parent_table_ref' if it is
+    given, or to the original table referene of the field if
+    parent_table_ref == NULL.
+
+  NOTES
+    This method is designed so that when a Field_iterator_table_ref
+    walks through the fields of a table reference, all its fields
+    are created and stored as follows:
+    - If the table reference being iterated is a stored table, view or
+      natural/using join, store all natural join columns in a list
+      attached to that table reference.
+    - If the table reference being iterated is a nested join that is
+      not natural/using join, then do not materialize its result
+      fields. This is OK because for such table references
+      Field_iterator_table_ref iterates over the fields of the nested
+      table references (recursively). In this way we avoid the storage
+      of unnecessay copies of result columns of nested joins.
+
+  RETURN
+    #     Pointer to a column of a natural join (or its operand)
+    NULL  No memory to allocate the column
+*/
+
+Natural_join_column *
+Field_iterator_table_ref::get_or_create_column_ref(THD *thd, TABLE_LIST *parent_table_ref)
+{
+  Natural_join_column *nj_col;
+  bool is_created= TRUE;
+  uint UNINIT_VAR(field_count);
+  TABLE_LIST *add_table_ref= parent_table_ref ?
+                             parent_table_ref : table_ref;
+
+  if (field_it == &table_field_it)
+  {
+    /* The field belongs to a stored table. */
+    Field *tmp_field= table_field_it.field();
+    Item_field *tmp_item=
+      new (thd->mem_root) Item_field(thd, &thd->lex->current_select->context, tmp_field);
+    if (!tmp_item)
+      return NULL;
+    nj_col= new Natural_join_column(tmp_item, table_ref);
+    field_count= table_ref->table->s->fields;
+  }
+  else if (field_it == &view_field_it)
+  {
+    /* The field belongs to a merge view or information schema table. */
+    Field_translator *translated_field= view_field_it.field_translator();
+    nj_col= new Natural_join_column(translated_field, table_ref);
+    field_count= (uint)(table_ref->field_translation_end -
+                 table_ref->field_translation);
+  }
+  else
+  {
+    /*
+      The field belongs to a NATURAL join, therefore the column reference was
+      already created via one of the two constructor calls above. In this case
+      we just return the already created column reference.
+    */
+    DBUG_ASSERT(table_ref->is_join_columns_complete);
+    is_created= FALSE;
+    nj_col= natural_join_it.column_ref();
+    DBUG_ASSERT(nj_col);
+  }
+  DBUG_ASSERT(!nj_col->table_field || !nj_col->table_field->field ||
+              nj_col->table_ref->table == nj_col->table_field->field->table);
+
+  /*
+    If the natural join column was just created add it to the list of
+    natural join columns of either 'parent_table_ref' or to the table
+    reference that directly contains the original field.
+  */
+  if (is_created)
+  {
+    /* Make sure not all columns were materialized. */
+    DBUG_ASSERT(!add_table_ref->is_join_columns_complete);
+    if (!add_table_ref->join_columns)
+    {
+      /* Create a list of natural join columns on demand. */
+      if (!(add_table_ref->join_columns= new List<Natural_join_column>))
+        return NULL;
+      add_table_ref->is_join_columns_complete= FALSE;
+    }
+    add_table_ref->join_columns->push_back(nj_col);
+    /*
+      If new fields are added to their original table reference, mark if
+      all fields were added. We do it here as the caller has no easy way
+      of knowing when to do it.
+      If the fields are being added to parent_table_ref, then the caller
+      must take care to mark when all fields are created/added.
+    */
+    if (!parent_table_ref &&
+        add_table_ref->join_columns->elements == field_count)
+      add_table_ref->is_join_columns_complete= TRUE;
+  }
+
+  return nj_col;
+}
+
+
+/*
+  Return an existing reference to a column of a natural/using join.
+
+  SYNOPSIS
+    Field_iterator_table_ref::get_natural_column_ref()
+
+  DESCRIPTION
+    The method should be called in contexts where it is expected that
+    all natural join columns are already created, and that the column
+    being retrieved is a Natural_join_column.
+
+  RETURN
+    #     Pointer to a column of a natural join (or its operand)
+    NULL  We didn't originally have memory to allocate the column
+*/
+
+Natural_join_column *
+Field_iterator_table_ref::get_natural_column_ref()
+{
+  Natural_join_column *nj_col;
+
+  DBUG_ASSERT(field_it == &natural_join_it);
+  /*
+    The field belongs to a NATURAL join, therefore the column reference was
+    already created via one of the two constructor calls above. In this case
+    we just return the already created column reference.
+  */
+  nj_col= natural_join_it.column_ref();
+  DBUG_ASSERT(nj_col &&
+              (!nj_col->table_field || !nj_col->table_field->field ||
+               nj_col->table_ref->table == nj_col->table_field->field->table));
+  return nj_col;
+}
+
+/*****************************************************************************
+  Functions to handle column usage bitmaps (read_set, write_set etc...)
+*****************************************************************************/
+
+/* Reset all columns bitmaps */
+
+void TABLE::clear_column_bitmaps()
+{
+  /*
+    Reset column read/write usage. It's identical to:
+    bitmap_clear_all(&table->def_read_set);
+    bitmap_clear_all(&table->def_write_set);
+    The code assumes that the bitmaps are allocated after each other, as
+    guaranteed by open_table_from_share()
+  */
+  bzero((char*) def_read_set.bitmap,
+        s->column_bitmap_size * (s->virtual_fields ? 3 : 2));
+  column_bitmaps_set(&def_read_set, &def_write_set);
+  rpl_write_set= 0;                             // Safety
+}
+
+
+/*
+  Tell handler we are going to call position() and rnd_pos() later.
+  
+  NOTES:
+  This is needed for handlers that uses the primary key to find the
+  row. In this case we have to extend the read bitmap with the primary
+  key fields.
+*/
+
+void TABLE::prepare_for_position()
+{
+  DBUG_ENTER("TABLE::prepare_for_position");
+
+  if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
+      s->primary_key < MAX_KEY)
+  {
+    mark_index_columns_for_read(s->primary_key);
+    /* signal change */
+    file->column_bitmaps_signal();
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+MY_BITMAP *TABLE::prepare_for_keyread(uint index, MY_BITMAP *map)
+{
+  MY_BITMAP *backup= read_set;
+  DBUG_ENTER("TABLE::prepare_for_keyread");
+  if (!no_keyread)
+    file->ha_start_keyread(index);
+  if (map != read_set || !(file->index_flags(index, 0, 1) & HA_CLUSTERED_INDEX))
+  {
+    mark_index_columns(index, map);
+    column_bitmaps_set(map);
+  }
+  DBUG_RETURN(backup);
+}
+
+
+/*
+  Mark that only fields from one key is used. Useful before keyread.
+*/
+
+void TABLE::mark_index_columns(uint index, MY_BITMAP *bitmap)
+{
+  DBUG_ENTER("TABLE::mark_index_columns");
+
+  bitmap_clear_all(bitmap);
+  mark_index_columns_no_reset(index, bitmap);
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Restore to use normal column maps after key read
+
+  NOTES
+    This reverse the change done by mark_index_columns
+
+  WARNING
+    For this to work, one must have the normal table maps in place
+    when calling mark_index_columns
+*/
+
+void TABLE::restore_column_maps_after_keyread(MY_BITMAP *backup)
+{
+  DBUG_ENTER("TABLE::restore_column_maps_after_mark_index");
+  file->ha_end_keyread();
+  read_set= backup;
+  file->column_bitmaps_signal();
+  DBUG_VOID_RETURN;
+}
+
+static void do_mark_index_columns(TABLE *table, uint index,
+                                  MY_BITMAP *bitmap, bool read)
+{
+  KEY_PART_INFO *key_part= table->key_info[index].key_part;
+  uint key_parts= table->key_info[index].user_defined_key_parts;
+  for (uint k= 0; k < key_parts; k++)
+    if (read)
+      key_part[k].field->register_field_in_read_map();
+    else
+      bitmap_set_bit(bitmap, key_part[k].fieldnr-1);
+  if (table->file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX &&
+      table->s->primary_key != MAX_KEY && table->s->primary_key != index)
+    do_mark_index_columns(table, table->s->primary_key, bitmap, read);
+
+}
+/*
+  mark columns used by key, but don't reset other fields
+*/
+
+inline void TABLE::mark_index_columns_no_reset(uint index, MY_BITMAP *bitmap)
+{
+  do_mark_index_columns(this, index, bitmap, false);
+}
+
+
+inline void TABLE::mark_index_columns_for_read(uint index)
+{
+  do_mark_index_columns(this, index, read_set, true);
+}
+
+/*
+  Mark auto-increment fields as used fields in both read and write maps
+
+  NOTES
+    This is needed in insert & update as the auto-increment field is
+    always set and sometimes read.
+*/
+
+void TABLE::mark_auto_increment_column()
+{
+  DBUG_ASSERT(found_next_number_field);
+  /*
+    We must set bit in read set as update_auto_increment() is using the
+    store() to check overflow of auto_increment values
+  */
+  bitmap_set_bit(read_set, found_next_number_field->field_index);
+  bitmap_set_bit(write_set, found_next_number_field->field_index);
+  if (s->next_number_keypart)
+    mark_index_columns_for_read(s->next_number_index);
+  file->column_bitmaps_signal();
+}
+
+
+/*
+  Mark columns needed for doing an delete of a row
+
+  DESCRIPTON
+    Some table engines don't have a cursor on the retrieve rows
+    so they need either to use the primary key or all columns to
+    be able to delete a row.
+
+    If the engine needs this, the function works as follows:
+    - If primary key exits, mark the primary key columns to be read.
+    - If not, mark all columns to be read
+
+    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
+    mark all key columns as 'to-be-read'. This allows the engine to
+    loop over the given record to find all keys and doesn't have to
+    retrieve the row again.
+*/
+
+void TABLE::mark_columns_needed_for_delete()
+{
+  bool need_signal= false;
+  mark_columns_per_binlog_row_image();
+
+  if (triggers)
+    triggers->mark_fields_used(TRG_EVENT_DELETE);
+  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
+  {
+    Field **reg_field;
+    for (reg_field= field ; *reg_field ; reg_field++)
+    {
+      if ((*reg_field)->flags & (PART_KEY_FLAG | PART_INDIRECT_KEY_FLAG))
+        mark_column_with_deps(*reg_field);
+    }
+    need_signal= true;
+  }
+  if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE)
+  {
+    /*
+      If the handler has no cursor capabilites, we have to read either
+      the primary key, the hidden primary key or all columns to be
+      able to do an delete
+    */
+    if (s->primary_key == MAX_KEY)
+      file->use_hidden_primary_key();
+    else
+    {
+      mark_index_columns_for_read(s->primary_key);
+      need_signal= true;
+    }
+  }
+
+  if (s->versioned)
+  {
+    bitmap_set_bit(read_set, s->vers.start_fieldno);
+    bitmap_set_bit(read_set, s->vers.end_fieldno);
+    bitmap_set_bit(write_set, s->vers.end_fieldno);
+    need_signal= true;
+  }
+
+  if (need_signal)
+    file->column_bitmaps_signal();
+}
+
+
+/*
+  Mark columns needed for doing an update of a row
+
+  DESCRIPTON
+    Some engines needs to have all columns in an update (to be able to
+    build a complete row). If this is the case, we mark all not
+    updated columns to be read.
+
+    If this is no the case, we do like in the delete case and mark
+    if needed, either the primary key column or all columns to be read.
+    (see mark_columns_needed_for_delete() for details)
+
+    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
+    mark all USED key columns as 'to-be-read'. This allows the engine to
+    loop over the given record to find all changed keys and doesn't have to
+    retrieve the row again.
+*/
+
+void TABLE::mark_columns_needed_for_update()
+{
+  DBUG_ENTER("TABLE::mark_columns_needed_for_update");
+  bool need_signal= false;
+
+
+  if (triggers)
+    triggers->mark_fields_used(TRG_EVENT_UPDATE);
+  if (default_field)
+    mark_default_fields_for_write(FALSE);
+  if (vfield)
+    need_signal|= mark_virtual_columns_for_write(FALSE);
+  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
+  {
+    KEY *end= key_info + s->keys;
+    for (KEY *k= key_info; k < end; k++)
+    {
+      KEY_PART_INFO *kpend= k->key_part + k->ext_key_parts;
+      int any_written= 0, all_read= 1;
+      for (KEY_PART_INFO *kp= k->key_part; kp < kpend; kp++)
+      {
+        int idx= kp->fieldnr - 1;
+        any_written|= bitmap_is_set(write_set, idx);
+        all_read&= bitmap_is_set(read_set, idx);
+      }
+      if (any_written && !all_read)
+      {
+        for (KEY_PART_INFO *kp= k->key_part; kp < kpend; kp++)
+          mark_column_with_deps(field[kp->fieldnr - 1]);
+      }
+    }
+    need_signal= true;
+  }
+  else
+  {
+    if (found_next_number_field)
+      mark_auto_increment_column();
+  }
+
+  if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE)
+  {
+    /*
+      If the handler has no cursor capabilites, we have to read either
+      the primary key, the hidden primary key or all columns to be
+      able to do an update
+    */
+    if (s->primary_key == MAX_KEY)
+      file->use_hidden_primary_key();
+    else
+    {
+      mark_index_columns_for_read(s->primary_key);
+      need_signal= true;
+    }
+  }
+  if (s->versioned)
+  {
+    bitmap_set_bit(write_set, s->vers.start_fieldno);
+    bitmap_set_bit(write_set, s->vers.end_fieldno);
+    /*
+      For System Versioning we have to read all columns since we store
+      a copy of previous row with modified row_end back to a table.
+    */
+    bitmap_union(read_set, &s->all_set);
+    need_signal= true;
+  }
+  if (check_constraints)
+  {
+    mark_check_constraint_columns_for_read();
+    need_signal= true;
+  }
+
+  /*
+    If a timestamp field settable on UPDATE is present then to avoid wrong
+    update force the table handler to retrieve write-only fields to be able
+    to compare records and detect data change.
+  */
+  if ((file->ha_table_flags() & HA_PARTIAL_COLUMN_READ) &&
+      default_field && s->has_update_default_function)
+  {
+    bitmap_union(read_set, write_set);
+    need_signal= true;
+  }
+  mark_columns_per_binlog_row_image();
+  if (need_signal)
+    file->column_bitmaps_signal();
+  DBUG_VOID_RETURN;
+}
+
+
+/*
+  Mark columns the handler needs for doing an insert
+
+  For now, this is used to mark fields used by the trigger
+  as changed.
+*/
+
+void TABLE::mark_columns_needed_for_insert()
+{
+  DBUG_ENTER("mark_columns_needed_for_insert");
+
+  if (triggers)
+  {
+    /*
+      We don't need to mark columns which are used by ON DELETE and
+      ON UPDATE triggers, which may be invoked in case of REPLACE or
+      INSERT ... ON DUPLICATE KEY UPDATE, since before doing actual
+      row replacement or update write_record() will mark all table
+      fields as used.
+    */
+    triggers->mark_fields_used(TRG_EVENT_INSERT);
+  }
+  if (found_next_number_field)
+    mark_auto_increment_column();
+  if (default_field)
+    mark_default_fields_for_write(TRUE);
+  if (s->versioned)
+  {
+    bitmap_set_bit(write_set, s->vers.start_fieldno);
+    bitmap_set_bit(write_set, s->vers.end_fieldno);
+    bitmap_set_bit(read_set, s->vers.end_fieldno);
+  }
+  /* Mark virtual columns for insert */
+  if (vfield)
+    mark_virtual_columns_for_write(TRUE);
+  mark_columns_per_binlog_row_image();
+  if (check_constraints)
+    mark_check_constraint_columns_for_read();
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Mark columns according the binlog row image option.
+
+  Columns to be written are stored in 'rpl_write_set'
+
+  When logging in RBR, the user can select whether to
+  log partial or full rows, depending on the table
+  definition, and the value of binlog_row_image.
+
+  Semantics of the binlog_row_image are the following
+  (PKE - primary key equivalent, ie, PK fields if PK
+  exists, all fields otherwise):
+
+  binlog_row_image= MINIMAL
+    - This marks the PKE fields in the read_set
+    - This marks all fields where a value was specified
+      in the rpl_write_set
+
+  binlog_row_image= NOBLOB
+    - This marks PKE + all non-blob fields in the read_set
+    - This marks all fields where a value was specified
+      and all non-blob fields in the rpl_write_set
+
+  binlog_row_image= FULL
+    - all columns in the read_set
+    - all columns in the rpl_write_set
+
+  This marking is done without resetting the original
+  bitmaps. This means that we will strip extra fields in
+  the read_set at binlogging time (for those cases that
+  we only want to log a PK and we needed other fields for
+  execution).
+*/
+
+void TABLE::mark_columns_per_binlog_row_image()
+{
+  THD *thd= in_use;
+  DBUG_ENTER("mark_columns_per_binlog_row_image");
+  DBUG_ASSERT(read_set->bitmap);
+  DBUG_ASSERT(write_set->bitmap);
+
+  /* If not using row format */
+  rpl_write_set= write_set;
+
+  /**
+    If in RBR we may need to mark some extra columns,
+    depending on the binlog-row-image command line argument.
+   */
+  if (file->row_logging &&
+      !ha_check_storage_engine_flag(s->db_type(), HTON_NO_BINLOG_ROW_OPT))
+  {
+    /* if there is no PK, then mark all columns for the BI. */
+    if (s->primary_key >= MAX_KEY)
+    {
+      bitmap_set_all(read_set);
+      rpl_write_set= read_set;
+    }
+    else
+    {
+      switch (thd->variables.binlog_row_image) {
+      case BINLOG_ROW_IMAGE_FULL:
+        bitmap_set_all(read_set);
+        /* Set of columns that should be written (all) */
+        rpl_write_set= read_set;
+        break;
+      case BINLOG_ROW_IMAGE_NOBLOB:
+        /* Only write changed columns + not blobs */
+        rpl_write_set= &def_rpl_write_set;
+        bitmap_copy(rpl_write_set, write_set);
+
+        /*
+          for every field that is not set, mark it unless it is a blob or
+          part of a primary key
+        */
+        for (Field **ptr=field ; *ptr ; ptr++)
+        {
+          Field *my_field= *ptr;
+          /*
+            bypass blob fields. These can be set or not set, we don't care.
+            Later, at binlogging time, if we don't need them in the before
+            image, we will discard them.
+
+            If set in the AI, then the blob is really needed, there is
+            nothing we can do about it.
+          */
+          if ((my_field->flags & PRI_KEY_FLAG) ||
+              (my_field->type() != MYSQL_TYPE_BLOB))
+          {
+            my_field->register_field_in_read_map();
+            bitmap_set_bit(rpl_write_set, my_field->field_index);
+          }
+        }
+        break;
+      case BINLOG_ROW_IMAGE_MINIMAL:
+        /*
+          mark the primary key in the read set so that we can find the row
+          that is updated / deleted.
+          We don't need to mark the primary key in the rpl_write_set as the
+          binary log will include all columns read anyway.
+        */
+        mark_index_columns_for_read(s->primary_key);
+        if (versioned())
+        {
+          // TODO: After MDEV-18432 we don't pass history rows, so remove this:
+          rpl_write_set= &s->all_set;
+        }
+        else
+        {
+          /* Only write columns that have changed */
+          rpl_write_set= write_set;
+        }
+        break;
+
+      default:
+        DBUG_ASSERT(FALSE);
+      }
+    }
+    file->column_bitmaps_signal();
+  }
+
+  DBUG_VOID_RETURN;
+}
+
+
+/* 
+  @brief Mark virtual columns for update/insert commands
+
+  @param insert_fl    true if virtual columns are marked for insert command
+                      For the moment this is not used, may be used in future.
+
+  @details
+    The function marks virtual columns used in a update/insert commands
+    in the vcol_set bitmap.
+    For an insert command a virtual column is always marked in write_set if
+    it is a stored column.
+    If a virtual column is from write_set it is always marked in vcol_set.
+    If a stored virtual column is not from write_set but it is computed
+    through columns from write_set it is also marked in vcol_set, and,
+    besides, it is added to write_set. 
+
+  @return whether a bitmap was updated
+
+  @note
+    Let table t1 have columns a,b,c and let column c be a stored virtual 
+    column computed through columns a and b. Then for the query
+      UPDATE t1 SET a=1
+    column c will be placed into vcol_set and into write_set while
+    column b will be placed into read_set.
+    If column c was a virtual column, but not a stored virtual column
+    then it would not be added to any of the sets. Column b would not
+    be added to read_set either.
+*/
+
+bool TABLE::mark_virtual_columns_for_write(bool insert_fl
+                                           __attribute__((unused)))
+{
+  Field **vfield_ptr, *tmp_vfield;
+  bool bitmap_updated= false;
+  DBUG_ENTER("mark_virtual_columns_for_write");
+
+  for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+  {
+    tmp_vfield= *vfield_ptr;
+    if (bitmap_is_set(write_set, tmp_vfield->field_index))
+      bitmap_updated|= mark_virtual_column_with_deps(tmp_vfield);
+    else if (tmp_vfield->vcol_info->stored_in_db ||
+             (tmp_vfield->flags & (PART_KEY_FLAG | FIELD_IN_PART_FUNC_FLAG |
+                                   PART_INDIRECT_KEY_FLAG)))
+    {
+      bitmap_set_bit(write_set, tmp_vfield->field_index);
+      mark_virtual_column_with_deps(tmp_vfield);
+      bitmap_updated= true;
+    }
+  }
+  if (bitmap_updated)
+    file->column_bitmaps_signal();
+  DBUG_RETURN(bitmap_updated);
+}
+
+
+/**
+   Check if a virtual not stored column field is in read set
+
+   @retval FALSE  No virtual not stored column is used
+   @retval TRUE   At least one virtual not stored column is used
+*/
+
+bool TABLE::check_virtual_columns_marked_for_read()
+{
+  if (vfield)
+  {
+    Field **vfield_ptr;
+    for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+    {
+      Field *tmp_vfield= *vfield_ptr;
+      if (bitmap_is_set(read_set, tmp_vfield->field_index) &&
+          !tmp_vfield->vcol_info->stored_in_db)
+        return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+
+/**
+   Check if a stored virtual column field is marked for write
+
+   This can be used to check if any column that is part of a virtual
+   stored column is changed
+
+   @retval FALSE  No stored virtual column is used
+   @retval TRUE   At least one stored virtual column is used
+*/
+
+bool TABLE::check_virtual_columns_marked_for_write()
+{
+  if (vfield)
+  {
+    Field **vfield_ptr;
+    for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+    {
+      Field *tmp_vfield= *vfield_ptr;
+      if (bitmap_is_set(write_set, tmp_vfield->field_index) &&
+                        tmp_vfield->vcol_info->stored_in_db)
+        return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+
+/*
+  Mark fields used by check constraints into s->check_set.
+  Mark all fields used in an expression that is part of an index
+  with PART_INDIRECT_KEY_FLAG
+
+  This is done once for the TABLE_SHARE the first time the table is opened.
+  The marking must be done non-destructively to handle the case when
+  this could be run in parallely by two threads
+*/
+
+void TABLE::mark_columns_used_by_virtual_fields(void)
+{
+  MY_BITMAP *save_read_set;
+  Field **vfield_ptr;
+  TABLE_SHARE::enum_v_keys v_keys= TABLE_SHARE::NO_V_KEYS;
+
+  /* If there is virtual fields are already initialized */
+  if (s->check_set_initialized)
+    return;
+
+  if (s->tmp_table == NO_TMP_TABLE)
+    mysql_mutex_lock(&s->LOCK_share);
+  if (s->check_set)
+  {
+    /* Mark fields used by check constraint */
+    save_read_set= read_set;
+    read_set= s->check_set;
+
+    for (Virtual_column_info **chk= check_constraints ; *chk ; chk++)
+      (*chk)->expr->walk(&Item::register_field_in_read_map, 1, 0);
+    read_set= save_read_set;
+  }
+
+  /*
+    mark all fields that part of a virtual indexed field with
+    PART_INDIRECT_KEY_FLAG. This is used to ensure that all fields
+    that are part of an index exits before write/delete/update.
+
+    As this code is only executed once per open share, it's reusing
+    existing functionality instead of adding an extra argument to
+    add_field_to_set_processor or adding another processor.
+  */
+  if (vfield)
+  {
+    for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+    {
+      if ((*vfield_ptr)->flags & PART_KEY_FLAG)
+        (*vfield_ptr)->vcol_info->expr->walk(&Item::add_field_to_set_processor,
+                                             1, this);
+    }
+    for (uint i= 0 ; i < s->fields ; i++)
+    {
+      if (bitmap_is_set(&tmp_set, i))
+      {
+        s->field[i]->flags|= PART_INDIRECT_KEY_FLAG;
+        v_keys= TABLE_SHARE::V_KEYS;
+      }
+    }
+    bitmap_clear_all(&tmp_set);
+  }
+  s->check_set_initialized= v_keys;
+  if (s->tmp_table == NO_TMP_TABLE)
+    mysql_mutex_unlock(&s->LOCK_share);
+}
+
+/* Add fields used by CHECK CONSTRAINT to read map */
+
+void TABLE::mark_check_constraint_columns_for_read(void)
+{
+  bitmap_union(read_set, s->check_set);
+}
+
+
+/**
+  Add all fields that have a default function to the table write set.
+*/
+
+void TABLE::mark_default_fields_for_write(bool is_insert)
+{
+  DBUG_ENTER("mark_default_fields_for_write");
+  Field **field_ptr, *field;
+  for (field_ptr= default_field; *field_ptr; field_ptr++)
+  {
+    field= (*field_ptr);
+    if (is_insert && field->default_value)
+    {
+      bitmap_set_bit(write_set, field->field_index);
+      field->default_value->expr->
+        walk(&Item::register_field_in_read_map, 1, 0);
+    }
+    else if (!is_insert && field->has_update_default_function())
+      bitmap_set_bit(write_set, field->field_index);
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+void TABLE::move_fields(Field **ptr, const uchar *to, const uchar *from)
+{
+  my_ptrdiff_t diff= to - from;
+  if (diff)
+  {
+    do
+    {
+      (*ptr)->move_field_offset(diff);
+    } while (*(++ptr));
+  }
+}
+
+
+/*
+  Store all allocated virtual fields blob values
+  Used by InnoDB when calculating virtual fields for it's own internal
+  records
+*/
+
+void TABLE::remember_blob_values(String *blob_storage)
+{
+  Field **vfield_ptr;
+  for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+  {
+    if ((*vfield_ptr)->type() == MYSQL_TYPE_BLOB &&
+        !(*vfield_ptr)->vcol_info->stored_in_db)
+    {
+      Field_blob *blob= ((Field_blob*) *vfield_ptr);
+      memcpy((void*) blob_storage, (void*) &blob->value, sizeof(blob->value));
+      blob_storage++;
+      blob->value.release();
+    }
+  }
+}
+
+
+/*
+  Restore all allocated virtual fields blob values
+  Used by InnoDB when calculating virtual fields for it's own internal
+  records
+*/
+
+void TABLE::restore_blob_values(String *blob_storage)
+{
+  Field **vfield_ptr;
+  for (vfield_ptr= vfield; *vfield_ptr; vfield_ptr++)
+  {
+    if ((*vfield_ptr)->type() == MYSQL_TYPE_BLOB &&
+        !(*vfield_ptr)->vcol_info->stored_in_db)
+    {
+      Field_blob *blob= ((Field_blob*) *vfield_ptr);
+      blob->value.free();
+      memcpy((void*) &blob->value, (void*) blob_storage, sizeof(blob->value));
+      blob_storage++;
+    }
+  }
+}
+
+
+/**
+  @brief
+  Allocate space for keys
+
+  @param key_count  number of keys to allocate additionally
+
+  @details
+  The function allocates memory  to fit additionally 'key_count' keys 
+  for this table.
+
+  @return FALSE   space was successfully allocated
+  @return TRUE    an error occur
+*/
+
+bool TABLE::alloc_keys(uint key_count)
+{
+  KEY *new_key_info;
+  key_part_map *new_const_key_parts;
+  DBUG_ASSERT(s->tmp_table == INTERNAL_TMP_TABLE);
+
+  if (!multi_alloc_root(&mem_root,
+                        &new_key_info, sizeof(*key_info)*(s->keys+key_count),
+                        &new_const_key_parts,
+                        sizeof(*new_const_key_parts)*(s->keys+key_count),
+                        NullS))
+    return TRUE;
+  if (s->keys)
+  {
+    memmove(new_key_info, s->key_info, sizeof(*key_info) * s->keys);
+    memmove(new_const_key_parts, const_key_parts,
+            s->keys * sizeof(const_key_parts));
+  }
+  s->key_info= key_info= new_key_info;
+  const_key_parts= new_const_key_parts;
+  bzero((char*) (const_key_parts + s->keys),
+        sizeof(*const_key_parts) * key_count);
+  max_keys= s->keys+key_count;
+  return FALSE;
+}
+
+
+/**
+  @brief
+  Populate a KEY_PART_INFO structure with the data related to a field entry.
+
+  @param key_part_info  The structure to fill.
+  @param field          The field entry that represents the key part.
+  @param fleldnr        The number of the field, count starting from 1.
+
+  TODO: This method does not make use of any table specific fields. It
+  could be refactored to act as a constructor for KEY_PART_INFO instead.
+*/
+
+void TABLE::create_key_part_by_field(KEY_PART_INFO *key_part_info,
+                                     Field *field, uint fieldnr)
+{
+  DBUG_ASSERT(field->field_index + 1 == (int)fieldnr);
+  key_part_info->null_bit= field->null_bit;
+  key_part_info->null_offset= (uint) (field->null_ptr -
+                                      (uchar*) record[0]);
+  key_part_info->field= field;
+  key_part_info->fieldnr= fieldnr;
+  key_part_info->offset= field->offset(record[0]);
+  /*
+     field->key_length() accounts for the raw length of the field, excluding
+     any metadata such as length of field or the NULL flag.
+  */
+  key_part_info->length= (uint16) field->key_length();
+  key_part_info->key_part_flag= 0;
+  /* TODO:
+    The below method of computing the key format length of the
+    key part is a copy/paste from opt_range.cc, and table.cc.
+    This should be factored out, e.g. as a method of Field.
+    In addition it is not clear if any of the Field::*_length
+    methods is supposed to compute the same length. If so, it
+    might be reused.
+  */
+  key_part_info->store_length= key_part_info->length;
+  /*
+    For BIT fields null_bit is not set to 0 even if the field is defined
+    as NOT NULL, look at Field_bit::Field_bit
+  */
+  if (!field->real_maybe_null())
+  {
+    key_part_info->null_bit= 0;
+  }
+
+  /*
+     The total store length of the key part is the raw length of the field +
+     any metadata information, such as its length for strings and/or the null
+     flag.
+  */
+  if (field->real_maybe_null())
+  {
+    key_part_info->store_length+= HA_KEY_NULL_LENGTH;
+  }
+
+  key_part_info->key_part_flag|= field->key_part_flag();
+  key_part_info->store_length+= field->key_part_length_bytes();
+
+  key_part_info->type=     (uint8) field->key_type();
+  key_part_info->key_type =
+    ((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
+    (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
+    (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
+    0 : FIELDFLAG_BINARY;
+}
+
+
+/**
+  @brief
+  Check validity of a possible key for the derived table
+
+  @param key            the number of the key
+  @param key_parts      number of components of the key
+  @param next_field_no  the call-back function that returns the number of
+                        the field used as the next component of the key
+  @param arg            the argument for the above function
+
+  @details
+  The function checks whether a possible key satisfies the constraints
+  imposed on the keys of any temporary table.
+
+  We need to filter out BLOB columns here, because ref access optimizer creates
+  KEYUSE objects for equalities for non-key columns for two puproses:
+  1. To discover possible keys for derived_with_keys optimization
+  2. To do hash joins
+  For the purpose of #1, KEYUSE objects are not created for "blob_column=..." .
+  However, they might be created for #2. In order to catch that case, we filter
+  them out here.
+
+  @return TRUE if the key is valid
+  @return FALSE otherwise
+*/
+
+bool TABLE::check_tmp_key(uint key, uint key_parts,
+                          uint (*next_field_no) (uchar *), uchar *arg)
+{
+  Field **reg_field;
+  uint i;
+  uint key_len= 0;
+
+  for (i= 0; i < key_parts; i++)
+  {
+    uint fld_idx= next_field_no(arg);
+    reg_field= field + fld_idx;
+    if ((*reg_field)->type() == MYSQL_TYPE_BLOB)
+      return FALSE;
+    uint fld_store_len= (uint16) (*reg_field)->key_length();
+    if ((*reg_field)->real_maybe_null())
+      fld_store_len+= HA_KEY_NULL_LENGTH;
+    if ((*reg_field)->real_type() == MYSQL_TYPE_VARCHAR ||
+        (*reg_field)->type() == MYSQL_TYPE_GEOMETRY)
+      fld_store_len+= HA_KEY_BLOB_LENGTH;
+    key_len+= fld_store_len;
+  }
+  /*
+    We use MI_MAX_KEY_LENGTH (myisam's default) below because it is
+    smaller than MAX_KEY_LENGTH (heap's default) and it's unknown whether
+    myisam or heap will be used for the temporary table.
+  */
+  return key_len <= MI_MAX_KEY_LENGTH;
+}
+
+/**
+  @brief
+  Add one key to a temporary table
+
+  @param key            the number of the key
+  @param key_parts      number of components of the key
+  @param next_field_no  the call-back function that returns the number of
+                        the field used as the next component of the key
+  @param arg            the argument for the above function
+  @param unique         TRUE <=> it is a unique index
+
+  @details
+  The function adds a new key to the table that is assumed to be a temporary
+  table. At each its invocation the call-back function must return
+  the number of the field that is used as the next component of this key.
+
+  @return FALSE is a success
+  @return TRUE if a failure
+
+*/
+
+bool TABLE::add_tmp_key(uint key, uint key_parts,
+                        uint (*next_field_no) (uchar *), uchar *arg,
+                        bool unique)
+{
+  DBUG_ASSERT(key < max_keys);
+
+  char buf[NAME_CHAR_LEN];
+  KEY* keyinfo;
+  Field **reg_field;
+  uint i;
+
+  bool key_start= TRUE;
+  KEY_PART_INFO* key_part_info=
+      (KEY_PART_INFO*) alloc_root(&mem_root, sizeof(KEY_PART_INFO)*key_parts);
+  if (!key_part_info)
+    return TRUE;
+  keyinfo= key_info + key;
+  keyinfo->key_part= key_part_info;
+  keyinfo->usable_key_parts= keyinfo->user_defined_key_parts = key_parts;
+  keyinfo->ext_key_parts= keyinfo->user_defined_key_parts;
+  keyinfo->key_length=0;
+  keyinfo->algorithm= HA_KEY_ALG_UNDEF;
+  keyinfo->flags= HA_GENERATED_KEY;
+  keyinfo->ext_key_flags= keyinfo->flags;
+  keyinfo->is_statistics_from_stat_tables= FALSE;
+  if (unique)
+    keyinfo->flags|= HA_NOSAME;
+  sprintf(buf, "key%i", key);
+  keyinfo->name.length= strlen(buf);
+  if (!(keyinfo->name.str= strmake_root(&mem_root, buf, keyinfo->name.length)))
+    return TRUE;
+  keyinfo->rec_per_key= (ulong*) alloc_root(&mem_root,
+                                            sizeof(ulong)*key_parts);
+  if (!keyinfo->rec_per_key)
+    return TRUE;
+  bzero(keyinfo->rec_per_key, sizeof(ulong)*key_parts);
+  keyinfo->read_stats= NULL;
+  keyinfo->collected_stats= NULL;
+
+  for (i= 0; i < key_parts; i++)
+  {
+    uint fld_idx= next_field_no(arg); 
+    reg_field= field + fld_idx;
+    if (key_start)
+      (*reg_field)->key_start.set_bit(key);
+    (*reg_field)->part_of_key.set_bit(key);
+    create_key_part_by_field(key_part_info, *reg_field, fld_idx+1);
+    keyinfo->key_length += key_part_info->store_length;
+    (*reg_field)->flags|= PART_KEY_FLAG;
+    key_start= FALSE;
+    key_part_info++;
+  }
+
+  /*
+    For the case when there is a derived table that would give distinct rows,
+    the index statistics are passed to the join optimizer to tell that a ref
+    access to all the fields of the derived table will produce only one row.
+  */
+
+  st_select_lex_unit* derived= pos_in_table_list ?
+                               pos_in_table_list->derived: NULL;
+  if (derived)
+  {
+    st_select_lex* first= derived->first_select();
+    uint select_list_items= first->get_item_list()->elements;
+    if (key_parts == select_list_items)
+    {
+      if ((!first->is_part_of_union() && (first->options & SELECT_DISTINCT)) ||
+          derived->check_distinct_in_union())
+        keyinfo->rec_per_key[key_parts - 1]= 1;
+    }
+  }
+
+  set_if_bigger(s->max_key_length, keyinfo->key_length);
+  s->keys++;
+  return FALSE;
+}
+
+/*
+  @brief
+  Drop all indexes except specified one.
+
+  @param key_to_save the key to save
+
+  @details
+  Drop all indexes on this table except 'key_to_save'. The saved key becomes
+  key #0. Memory occupied by key parts of dropped keys are freed.
+  If the 'key_to_save' is negative then all keys are freed.
+*/
+
+void TABLE::use_index(int key_to_save)
+{
+  uint i= 1;
+  DBUG_ASSERT(!created && key_to_save < (int)s->keys);
+  if (key_to_save >= 0)
+    /* Save the given key. */
+    memmove(key_info, key_info + key_to_save, sizeof(KEY));
+  else
+    /* Drop all keys; */
+    i= 0;
+
+  s->keys= i;
+}
+
+/*
+  Return TRUE if the table is filled at execution phase 
+  
+  (and so, the optimizer must not do anything that depends on the contents of
+   the table, like range analysis or constant table detection)
+*/
+
+bool TABLE::is_filled_at_execution()
+{ 
+  /*
+    pos_in_table_list == NULL for internal temporary tables because they
+    do not have a corresponding table reference. Such tables are filled
+    during execution.
+  */
+  return MY_TEST(!pos_in_table_list ||
+                 pos_in_table_list->jtbm_subselect ||
+                 pos_in_table_list->is_active_sjm() ||
+                 pos_in_table_list->table_function);
+}
+
+
+/**
+  @brief
+  Get actual number of key components
+
+  @param keyinfo
+
+  @details
+  The function calculates actual number of key components, possibly including
+  components of extended keys, taken into consideration by the optimizer for the
+  key described by the parameter keyinfo.
+
+  @return number of considered key components
+*/ 
+
+uint TABLE::actual_n_key_parts(KEY *keyinfo)
+{
+  return optimizer_flag(in_use, OPTIMIZER_SWITCH_EXTENDED_KEYS) ?
+           keyinfo->ext_key_parts : keyinfo->user_defined_key_parts;
+}
+
+ 
+/**
+  @brief
+  Get actual key flags for a table key 
+
+  @param keyinfo
+
+  @details
+  The function finds out actual key flags taken into consideration by the
+  optimizer for the key described by the parameter keyinfo.
+
+  @return actual key flags
+*/ 
+
+ulong TABLE::actual_key_flags(KEY *keyinfo)
+{
+  return optimizer_flag(in_use, OPTIMIZER_SWITCH_EXTENDED_KEYS) ?
+           keyinfo->ext_key_flags : keyinfo->flags;
+} 
+
+
+/*
+  Cleanup this table for re-execution.
+
+  SYNOPSIS
+    TABLE_LIST::reinit_before_use()
+*/
+
+void TABLE_LIST::reinit_before_use(THD *thd)
+{
+  /*
+    Reset old pointers to TABLEs: they are not valid since the tables
+    were closed in the end of previous prepare or execute call.
+  */
+  table= 0;
+  /* Reset is_schema_table_processed value(needed for I_S tables */
+  schema_table_state= NOT_PROCESSED;
+
+  TABLE_LIST *embedded; /* The table at the current level of nesting. */
+  TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */
+  do
+  {
+    embedded= parent_embedding;
+    if (embedded->prep_on_expr)
+      embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);
+    parent_embedding= embedded->embedding;
+  }
+  while (parent_embedding &&
+         parent_embedding->nested_join->join_list.head() == embedded);
+
+  mdl_request.ticket= NULL;
+}
+
+
+/*
+  Return subselect that contains the FROM list this table is taken from
+
+  SYNOPSIS
+    TABLE_LIST::containing_subselect()
+ 
+  RETURN
+    Subselect item for the subquery that contains the FROM list
+    this table is taken from if there is any
+    0 - otherwise
+
+*/
+
+Item_subselect *TABLE_LIST::containing_subselect()
+{
+  return (select_lex ? select_lex->master_unit()->item : 0);
+}
+
+/*
+  Compiles the tagged hints list and fills up the bitmasks.
+
+  SYNOPSIS
+    process_index_hints()
+      table         the TABLE to operate on.
+
+  DESCRIPTION
+    The parser collects the index hints for each table in a "tagged list" 
+    (TABLE_LIST::index_hints). Using the information in this tagged list
+    this function sets the members TABLE::keys_in_use_for_query,
+    TABLE::keys_in_use_for_group_by, TABLE::keys_in_use_for_order_by,
+    TABLE::force_index, TABLE::force_index_order,
+    TABLE::force_index_group and TABLE::covering_keys.
+
+    Current implementation of the runtime does not allow mixing FORCE INDEX
+    and USE INDEX, so this is checked here. Then the FORCE INDEX list 
+    (if non-empty) is appended to the USE INDEX list and a flag is set.
+
+    Multiple hints of the same kind are processed so that each clause 
+    is applied to what is computed in the previous clause.
+    For example:
+        USE INDEX (i1) USE INDEX (i2)
+    is equivalent to
+        USE INDEX (i1,i2)
+    and means "consider only i1 and i2".
+
+    Similarly
+        USE INDEX () USE INDEX (i1)
+    is equivalent to
+        USE INDEX (i1)
+    and means "consider only the index i1"
+
+    It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
+    not an error.
+
+    Different kind of hints (USE/FORCE/IGNORE) are processed in the following
+    order:
+      1. All indexes in USE (or FORCE) INDEX are added to the mask.
+      2. All IGNORE INDEX
+
+    e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
+    as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".
+
+    As an optimization if there is a covering index, and we have 
+    IGNORE INDEX FOR GROUP/ORDER, and this index is used for the JOIN part, 
+    then we have to ignore the IGNORE INDEX FROM GROUP/ORDER.
+
+  RETURN VALUE
+    FALSE                no errors found
+    TRUE                 found and reported an error.
+*/
+bool TABLE_LIST::process_index_hints(TABLE *tbl)
+{
+  /* initialize the result variables */
+  tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by= 
+    tbl->keys_in_use_for_order_by= tbl->s->usable_indexes(tbl->in_use);
+
+  /* index hint list processing */
+  if (index_hints)
+  {
+    key_map index_join[INDEX_HINT_FORCE + 1];
+    key_map index_order[INDEX_HINT_FORCE + 1];
+    key_map index_group[INDEX_HINT_FORCE + 1];
+    Index_hint *hint;
+    int type;
+    bool have_empty_use_join= FALSE, have_empty_use_order= FALSE, 
+         have_empty_use_group= FALSE;
+    List_iterator <Index_hint> iter(*index_hints);
+
+    /* initialize temporary variables used to collect hints of each kind */
+    for (type= INDEX_HINT_IGNORE; type <= INDEX_HINT_FORCE; type++)
+    {
+      index_join[type].clear_all();
+      index_order[type].clear_all();
+      index_group[type].clear_all();
+    }
+
+    /* iterate over the hints list */
+    while ((hint= iter++))
+    {
+      uint pos;
+
+      /* process empty USE INDEX () */
+      if (hint->type == INDEX_HINT_USE && !hint->key_name.str)
+      {
+        if (hint->clause & INDEX_HINT_MASK_JOIN)
+        {
+          index_join[hint->type].clear_all();
+          have_empty_use_join= TRUE;
+        }
+        if (hint->clause & INDEX_HINT_MASK_ORDER)
+        {
+          index_order[hint->type].clear_all();
+          have_empty_use_order= TRUE;
+        }
+        if (hint->clause & INDEX_HINT_MASK_GROUP)
+        {
+          index_group[hint->type].clear_all();
+          have_empty_use_group= TRUE;
+        }
+        continue;
+      }
+
+      /* 
+        Check if an index with the given name exists and get his offset in 
+        the keys bitmask for the table 
+      */
+      if (tbl->s->keynames.type_names == 0 ||
+          (pos= find_type(&tbl->s->keynames, hint->key_name.str,
+                          hint->key_name.length, 1)) <= 0 ||
+          (tbl->s->key_info[pos - 1].is_ignored))
+      {
+        my_error(ER_KEY_DOES_NOT_EXISTS, MYF(0), hint->key_name.str, alias.str);
+        return 1;
+      }
+
+      pos--;
+
+      /* add to the appropriate clause mask */
+      if (hint->clause & INDEX_HINT_MASK_JOIN)
+        index_join[hint->type].set_bit (pos);
+      if (hint->clause & INDEX_HINT_MASK_ORDER)
+        index_order[hint->type].set_bit (pos);
+      if (hint->clause & INDEX_HINT_MASK_GROUP)
+        index_group[hint->type].set_bit (pos);
+    }
+
+    /* cannot mix USE INDEX and FORCE INDEX */
+    if ((!index_join[INDEX_HINT_FORCE].is_clear_all() ||
+         !index_order[INDEX_HINT_FORCE].is_clear_all() ||
+         !index_group[INDEX_HINT_FORCE].is_clear_all()) &&
+        (!index_join[INDEX_HINT_USE].is_clear_all() ||  have_empty_use_join ||
+         !index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order ||
+         !index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group))
+    {
+      my_error(ER_WRONG_USAGE, MYF(0), index_hint_type_name[INDEX_HINT_USE],
+               index_hint_type_name[INDEX_HINT_FORCE]);
+      return 1;
+    }
+
+    /* process FORCE INDEX as USE INDEX with a flag */
+    if (!index_order[INDEX_HINT_FORCE].is_clear_all())
+    {
+      tbl->force_index_order= TRUE;
+      index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
+    }
+
+    if (!index_group[INDEX_HINT_FORCE].is_clear_all())
+    {
+      tbl->force_index_group= TRUE;
+      index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
+    }
+
+    /*
+      TODO: get rid of tbl->force_index (on if any FORCE INDEX is specified)
+      and create tbl->force_index_join instead.
+      Then use the correct force_index_XX instead of the global one.
+    */
+    if (!index_join[INDEX_HINT_FORCE].is_clear_all() ||
+        tbl->force_index_group || tbl->force_index_order)
+    {
+      tbl->force_index= TRUE;
+      index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
+    }
+
+    /* apply USE INDEX */
+    if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
+      tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
+    if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
+      tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
+    if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
+      tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
+
+    /* apply IGNORE INDEX */
+    tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
+    tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
+    tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
+  }
+
+  /* make sure covering_keys don't include indexes disabled with a hint */
+  tbl->covering_keys.intersect(tbl->keys_in_use_for_query);
+  return 0;
+}
+
+
+size_t max_row_length(TABLE *table, MY_BITMAP const *cols, const uchar *data)
+{
+  TABLE_SHARE *table_s= table->s;
+  size_t length= table_s->reclength + 2 * table_s->fields;
+  uint *const beg= table_s->blob_field;
+  uint *const end= beg + table_s->blob_fields;
+  my_ptrdiff_t const rec_offset= (my_ptrdiff_t) (data - table->record[0]);
+  DBUG_ENTER("max_row_length");
+
+  for (uint *ptr= beg ; ptr != end ; ++ptr)
+  {
+    Field * const field= table->field[*ptr];
+    if (bitmap_is_set(cols, field->field_index) &&
+        !field->is_null(rec_offset))
+    {
+      Field_blob * const blob= (Field_blob*) field;
+      length+= blob->get_length(rec_offset) + 8; /* max blob store length */
+    }
+  }
+  DBUG_PRINT("exit", ("length: %lld", (longlong) length));
+  DBUG_RETURN(length);
+}
+
+
+/**
+   Helper function which allows to allocate metadata lock request
+   objects for all elements of table list.
+*/
+
+void init_mdl_requests(TABLE_LIST *table_list)
+{
+  for ( ; table_list ; table_list= table_list->next_global)
+    MDL_REQUEST_INIT(&table_list->mdl_request, MDL_key::TABLE,
+                     table_list->db.str, table_list->table_name.str,
+                     table_list->lock_type >= TL_FIRST_WRITE
+                     ? MDL_SHARED_WRITE : MDL_SHARED_READ, MDL_TRANSACTION);
+}
+
+
+/**
+  Update TABLE::const_key_parts for single table UPDATE/DELETE query
+
+  @param conds               WHERE clause expression
+
+  @retval TRUE   error (OOM)
+  @retval FALSE  success
+
+  @note
+    Set const_key_parts bits if key fields are equal to constants in
+    the WHERE expression.
+*/
+
+bool TABLE::update_const_key_parts(COND *conds)
+{
+  bzero((char*) const_key_parts, sizeof(key_part_map) * s->keys);
+
+  if (conds == NULL)
+    return FALSE;
+
+  for (uint index= 0; index < s->keys; index++)
+  {
+    KEY_PART_INFO *keyinfo= key_info[index].key_part;
+    KEY_PART_INFO *keyinfo_end= keyinfo + key_info[index].user_defined_key_parts;
+
+    for (key_part_map part_map= (key_part_map)1; 
+        keyinfo < keyinfo_end;
+        keyinfo++, part_map<<= 1)
+    {
+      if (const_expression_in_where(conds, NULL, keyinfo->field))
+        const_key_parts[index]|= part_map;
+    }
+  }
+  return FALSE;
+}
+
+/**
+  Test if the order list consists of simple field expressions
+
+  @param order                Linked list of ORDER BY arguments
+
+  @return TRUE if @a order is empty or consist of simple field expressions
+*/
+
+bool is_simple_order(ORDER *order)
+{
+  for (ORDER *ord= order; ord; ord= ord->next)
+  {
+    if (ord->item[0]->real_item()->type() != Item::FIELD_ITEM)
+      return FALSE;
+  }
+  return TRUE;
+}
+
+/*
+  to satisfy marked_for_write_or_computed() Field's assert we temporarily
+  mark field for write before storing the generated value in it
+*/
+#ifdef DBUG_ASSERT_EXISTS
+#define DBUG_FIX_WRITE_SET(f) bool _write_set_fixed= !bitmap_fast_test_and_set(write_set, (f)->field_index)
+#define DBUG_RESTORE_WRITE_SET(f) if (_write_set_fixed) bitmap_clear_bit(write_set, (f)->field_index)
+#else
+#define DBUG_FIX_WRITE_SET(f)
+#define DBUG_RESTORE_WRITE_SET(f)
+#endif
+
+
+/*
+  @brief Compute values for virtual columns used in query
+
+  @param  update_mode Specifies what virtual column are computed
+  
+  @details
+    The function computes the values of the virtual columns of the table and
+    stores them in the table record buffer.
+    This will be done even if is_error() is set either when function was called
+    or by calculating the virtual function, as most calls to this
+    function doesn't check the result. We also want to ensure that as many
+    fields as possible has the right value so that we can optionally
+    return the partly-faulty-row from a storage engine with a virtual
+    field that gives an error on storage for an existing row.
+
+  @todo
+    Ensure that all caller checks the value of this function and
+    either properly ignores it (and resets the error) or sends the
+    error forward to the caller.
+
+  @retval
+    0    Success
+  @retval
+    >0   Error occurred when storing a virtual field value or potentially
+         is_error() was set when function was called.
+*/
+
+int TABLE::update_virtual_fields(handler *h, enum_vcol_update_mode update_mode)
+{
+  DBUG_ENTER("TABLE::update_virtual_fields");
+  DBUG_PRINT("enter", ("update_mode: %d  is_error: %d", update_mode,
+                       in_use->is_error()));
+  Field **vfield_ptr, *vf;
+  Query_arena backup_arena;
+  Turn_errors_to_warnings_handler Suppress_errors;
+  bool handler_pushed= 0, update_all_columns= 1;
+  DBUG_ASSERT(vfield);
+
+  if (h->keyread_enabled())
+    DBUG_RETURN(0);
+  /*
+    TODO: this imposes memory leak until table flush when save_in_field()
+          does expr_arena allocation. F.ex. case in
+          gcol.gcol_supported_sql_funcs_innodb (see CONVERT_TZ):
+
+          create table t1 (
+            a datetime, b datetime generated always as
+            (convert_tz(a, 'MET', 'UTC')) virtual);
+          insert into t1 values ('2008-08-31', default);
+  */
+  in_use->set_n_backup_active_arena(expr_arena, &backup_arena);
+
+  /* When reading or deleting row, ignore errors from virtual columns */
+  if (update_mode == VCOL_UPDATE_FOR_READ ||
+      update_mode == VCOL_UPDATE_FOR_DELETE ||
+      update_mode == VCOL_UPDATE_INDEXED)
+  {
+    in_use->push_internal_handler(&Suppress_errors);
+    handler_pushed= 1;
+  }
+  else if (update_mode == VCOL_UPDATE_FOR_REPLACE &&
+           in_use->is_current_stmt_binlog_format_row() &&
+           in_use->variables.binlog_row_image != BINLOG_ROW_IMAGE_MINIMAL)
+  {
+    /*
+      If we are doing a replace with not minimal binary logging, we have to
+      calculate all virtual columns.
+    */
+    update_all_columns= 1;
+  }
+
+  /* Iterate over virtual fields in the table */
+  for (vfield_ptr= vfield; *vfield_ptr ; vfield_ptr++)
+  {
+    vf= (*vfield_ptr);
+    Virtual_column_info *vcol_info= vf->vcol_info;
+    DBUG_ASSERT(vcol_info);
+    DBUG_ASSERT(vcol_info->expr);
+
+    bool update= 0, swap_values= 0;
+    switch (update_mode) {
+    case VCOL_UPDATE_FOR_READ:
+      update= (!vcol_info->stored_in_db &&
+               bitmap_is_set(read_set, vf->field_index));
+      swap_values= 1;
+      break;
+    case VCOL_UPDATE_FOR_DELETE:
+    case VCOL_UPDATE_FOR_WRITE:
+      update= bitmap_is_set(read_set, vf->field_index);
+      break;
+    case VCOL_UPDATE_FOR_REPLACE:
+      update= ((!vcol_info->stored_in_db &&
+                (vf->flags & (PART_KEY_FLAG | PART_INDIRECT_KEY_FLAG)) &&
+                bitmap_is_set(read_set, vf->field_index)) ||
+               update_all_columns);
+      if (update && (vf->flags & BLOB_FLAG))
+      {
+        /*
+          The row has been read into record[1] and Field_blob::value
+          contains the value for record[0].  Swap value and read_value
+          to ensure that the virtual column data for the read row will
+          be in read_value at the end of this function
+        */
+        ((Field_blob*) vf)->swap_value_and_read_value();
+        /* Ensure we call swap_value_and_read_value() after update */
+        swap_values= 1;
+      }
+      break;
+    case VCOL_UPDATE_INDEXED:
+    case VCOL_UPDATE_INDEXED_FOR_UPDATE:
+      /* Read indexed fields that was not updated in VCOL_UPDATE_FOR_READ */
+      update= (!vcol_info->stored_in_db &&
+               (vf->flags & (PART_KEY_FLAG | PART_INDIRECT_KEY_FLAG)) &&
+               !bitmap_is_set(read_set, vf->field_index));
+      swap_values= 1;
+      break;
+    }
+
+    if (update)
+    {
+      /* Compute the actual value of the virtual fields */
+      DBUG_FIX_WRITE_SET(vf);
+# ifdef DBUG_TRACE
+      int field_error=
+# endif
+      vcol_info->expr->save_in_field(vf, 0);
+      DBUG_RESTORE_WRITE_SET(vf);
+      DBUG_PRINT("info", ("field '%s' - updated  error: %d",
+                          vf->field_name.str, field_error));
+      if (swap_values && (vf->flags & BLOB_FLAG))
+      {
+        /*
+          Remember the read value to allow other update_virtual_field() calls
+          for the same blob field for the row to be updated.
+          Field_blob->read_value always contains the virtual column data for
+          any read row.
+        */
+        ((Field_blob*) vf)->swap_value_and_read_value();
+      }
+    }
+    else
+    {
+      DBUG_PRINT("info", ("field '%s' - skipped", vf->field_name.str));
+    }
+  }
+  if (handler_pushed)
+    in_use->pop_internal_handler();
+  in_use->restore_active_arena(expr_arena, &backup_arena);
+  
+  /* Return 1 only of we got a fatal error, not a warning */
+  DBUG_RETURN(in_use->is_error());
+}
+
+/*
+  Calculate the virtual field value for a specified field.
+  @param vf                     A field to calculate
+  @param ignore_warnings        Ignore the warnings and also make the
+                                calculations permissive. This usually means
+                                that a calculation is internal and is not
+                                expected to fail.
+*/
+int TABLE::update_virtual_field(Field *vf, bool ignore_warnings)
+{
+  DBUG_ENTER("TABLE::update_virtual_field");
+  Query_arena backup_arena;
+  Counting_error_handler count_errors;
+  Suppress_warnings_error_handler warning_handler;
+  in_use->push_internal_handler(&count_errors);
+  bool abort_on_warning= ignore_warnings;
+  if (ignore_warnings)
+  {
+    abort_on_warning= in_use->abort_on_warning;
+    in_use->abort_on_warning= false;
+    in_use->push_internal_handler(&warning_handler);
+  }
+  /*
+    TODO: this may impose memory leak until table flush.
+          See comment in
+          TABLE::update_virtual_fields(handler *, enum_vcol_update_mode).
+  */
+  in_use->set_n_backup_active_arena(expr_arena, &backup_arena);
+  bitmap_clear_all(&tmp_set);
+  vf->vcol_info->expr->walk(&Item::update_vcol_processor, 0, &tmp_set);
+  DBUG_FIX_WRITE_SET(vf);
+  vf->vcol_info->expr->save_in_field(vf, 0);
+  DBUG_RESTORE_WRITE_SET(vf);
+  in_use->restore_active_arena(expr_arena, &backup_arena);
+  in_use->pop_internal_handler();
+  if (ignore_warnings)
+  {
+    in_use->abort_on_warning= abort_on_warning;
+    in_use->pop_internal_handler();
+    // This is an internal calculation, we expect it to always succeed
+    DBUG_ASSERT(count_errors.errors == 0);
+  }
+  DBUG_RETURN(count_errors.errors);
+}
+
+
+/**
+  Update all DEFAULT and/or ON INSERT fields.
+
+  @details
+    Compute and set the default value of all fields with a default function.
+    There are two kinds of default functions - one is used for INSERT-like
+    operations, the other for UPDATE-like operations. Depending on the field
+    definition and the current operation one or the other kind of update
+    function is evaluated.
+
+  @param update_command   True if command was an update else insert
+  @param ignore_errors    True if we should ignore errors
+
+  @retval
+    0    Success
+  @retval
+    >0   Error occurred when storing a virtual field value and
+         ignore_errors == 0. If set then an error was generated.
+*/
+
+int TABLE::update_default_fields(bool ignore_errors)
+{
+  Query_arena backup_arena;
+  Field **field_ptr;
+  int res= 0;
+  DBUG_ENTER("TABLE::update_default_fields");
+  DBUG_ASSERT(default_field);
+
+  /*
+    TODO: this may impose memory leak until table flush.
+          See comment in
+          TABLE::update_virtual_fields(handler *, enum_vcol_update_mode).
+  */
+  in_use->set_n_backup_active_arena(expr_arena, &backup_arena);
+
+  /* Iterate over fields with default functions in the table */
+  for (field_ptr= default_field; *field_ptr ; field_ptr++)
+  {
+    Field *field= (*field_ptr);
+    /*
+      If an explicit default value for a field overrides the default,
+      do not update the field with its automatic default value.
+    */
+    if (!field->has_explicit_value())
+    {
+      if (field->default_value &&
+          (field->default_value->flags || field->flags & BLOB_FLAG))
+        res|= (field->default_value->expr->save_in_field(field, 0) < 0);
+      if (!ignore_errors && res)
+      {
+        my_error(ER_CALCULATING_DEFAULT_VALUE, MYF(0), field->field_name.str);
+        break;
+      }
+      res= 0;
+    }
+  }
+  in_use->restore_active_arena(expr_arena, &backup_arena);
+  DBUG_RETURN(res);
+}
+
+int TABLE::update_generated_fields()
+{
+  int res= 0;
+  if (found_next_number_field)
+  {
+    next_number_field= found_next_number_field;
+    res= found_next_number_field->set_default();
+    if (likely(!res))
+      res= file->update_auto_increment();
+    next_number_field= NULL;
+  }
+
+  if (likely(!res) && vfield)
+    res= update_virtual_fields(file, VCOL_UPDATE_FOR_WRITE);
+  if (likely(!res) && versioned())
+    vers_update_fields();
+  if (likely(!res))
+    res= verify_constraints(false) == VIEW_CHECK_ERROR;
+  return res;
+}
+
+int TABLE::period_make_insert(Item *src, Field *dst)
+{
+  THD *thd= in_use;
+
+  ulonglong prev_insert_id= file->next_insert_id;
+  store_record(this, record[1]);
+  int res= src->save_in_field(dst, true);
+
+  if (likely(!res))
+    res= update_generated_fields();
+
+  if (likely(!res) && triggers)
+    res= triggers->process_triggers(thd, TRG_EVENT_INSERT,
+                                    TRG_ACTION_BEFORE, true);
+
+  if (likely(!res))
+    res = file->ha_write_row(record[0]);
+
+  if (likely(!res) && triggers)
+    res= triggers->process_triggers(thd, TRG_EVENT_INSERT,
+                                    TRG_ACTION_AFTER, true);
+
+  restore_record(this, record[1]);
+  if (res)
+    file->restore_auto_increment(prev_insert_id);
+  return res;
+}
+
+int TABLE::insert_portion_of_time(THD *thd,
+                                  const vers_select_conds_t &period_conds,
+                                  ha_rows *rows_inserted)
+{
+  bool lcond= period_conds.field_start->val_datetime_packed(thd)
+              < period_conds.start.item->val_datetime_packed(thd);
+  bool rcond= period_conds.field_end->val_datetime_packed(thd)
+              > period_conds.end.item->val_datetime_packed(thd);
+
+  int res= 0;
+  if (lcond)
+  {
+    res= period_make_insert(period_conds.start.item,
+                            field[s->period.end_fieldno]);
+    if (likely(!res))
+      ++*rows_inserted;
+  }
+  if (likely(!res) && rcond)
+  {
+    res= period_make_insert(period_conds.end.item,
+                            field[s->period.start_fieldno]);
+    if (likely(!res))
+      ++*rows_inserted;
+  }
+
+  return res;
+}
+
+void TABLE::evaluate_update_default_function()
+{
+  DBUG_ENTER("TABLE::evaluate_update_default_function");
+
+  if (s->has_update_default_function)
+    for (Field **field_ptr= default_field; *field_ptr ; field_ptr++)
+    {
+      Field *field= (*field_ptr);
+      if (!field->has_explicit_value() && field->has_update_default_function())
+        field->set_time();
+    }
+  DBUG_VOID_RETURN;
+}
+
+/**
+  Compare two records by a specific key (that has WITHOUT OVERLAPS clause)
+
+  @return  true,     key values are equal and periods overlap
+           false,    either key values differ or periods don't overlap
+ */
+bool TABLE::check_period_overlaps(const KEY &key,
+                                 const uchar *lhs, const uchar *rhs)
+{
+  DBUG_ASSERT(key.without_overlaps);
+  uint base_part_nr= key.user_defined_key_parts - 2;
+  for (uint part_nr= 0; part_nr < base_part_nr; part_nr++)
+  {
+    Field *f= key.key_part[part_nr].field;
+    if (key.key_part[part_nr].null_bit)
+      if (f->is_null_in_record(lhs) || f->is_null_in_record(rhs))
+        return false;
+    uint kp_len= key.key_part[part_nr].length;
+    if (f->cmp_prefix(f->ptr_in_record(lhs), f->ptr_in_record(rhs),
+                      kp_len / f->charset()->mbmaxlen) != 0)
+      return false;
+  }
+
+  uint period_start= key.user_defined_key_parts - 1;
+  uint period_end= key.user_defined_key_parts - 2;
+  const Field *fs= key.key_part[period_start].field;
+  const Field *fe= key.key_part[period_end].field;
+
+  if (fs->cmp(fe->ptr_in_record(lhs), fs->ptr_in_record(rhs)) <= 0)
+    return false;
+  if (fs->cmp(fs->ptr_in_record(lhs), fe->ptr_in_record(rhs)) >= 0)
+    return false;
+  return true;
+}
+
+/* returns true if vers_end_field was updated */
+bool TABLE::vers_update_fields()
+{
+  bool res= false;
+  if (versioned(VERS_TIMESTAMP) && !vers_start_field()->has_explicit_value())
+  {
+    if (vers_start_field()->set_time())
+      DBUG_ASSERT(0);
+  }
+
+  if (!versioned(VERS_TIMESTAMP) || !vers_end_field()->has_explicit_value())
+  {
+    vers_end_field()->set_max();
+    res= true;
+  }
+
+  if (vfield)
+    update_virtual_fields(file, VCOL_UPDATE_FOR_READ);
+  return res;
+}
+
+
+void TABLE::vers_update_end()
+{
+  if (vers_end_field()->store_timestamp(in_use->query_start(),
+                                        in_use->query_start_sec_part()))
+    DBUG_ASSERT(0);
+}
+
+/**
+   Reset markers that fields are being updated
+*/
+
+void TABLE::reset_default_fields()
+{
+  DBUG_ENTER("reset_default_fields");
+  bitmap_clear_all(&has_value_set);
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Prepare triggers  for INSERT-like statement.
+
+  SYNOPSIS
+    prepare_triggers_for_insert_stmt_or_event()
+
+  NOTE
+    Prepare triggers for INSERT-like statement by marking fields
+    used by triggers and inform handlers that batching of UPDATE/DELETE 
+    cannot be done if there are BEFORE UPDATE/DELETE triggers.
+*/
+
+void TABLE::prepare_triggers_for_insert_stmt_or_event()
+{
+  if (triggers)
+  {
+    if (triggers->has_triggers(TRG_EVENT_DELETE,
+                               TRG_ACTION_AFTER))
+    {
+      /*
+        The table has AFTER DELETE triggers that might access to
+        subject table and therefore might need delete to be done
+        immediately. So we turn-off the batching.
+      */
+      (void) file->extra(HA_EXTRA_DELETE_CANNOT_BATCH);
+    }
+    if (triggers->has_triggers(TRG_EVENT_UPDATE,
+                               TRG_ACTION_AFTER))
+    {
+      /*
+        The table has AFTER UPDATE triggers that might access to subject
+        table and therefore might need update to be done immediately.
+        So we turn-off the batching.
+      */
+      (void) file->extra(HA_EXTRA_UPDATE_CANNOT_BATCH);
+    }
+  }
+}
+
+
+bool TABLE::prepare_triggers_for_delete_stmt_or_event()
+{
+  if (triggers &&
+      triggers->has_triggers(TRG_EVENT_DELETE,
+                             TRG_ACTION_AFTER))
+  {
+    /*
+      The table has AFTER DELETE triggers that might access to subject table
+      and therefore might need delete to be done immediately. So we turn-off
+      the batching.
+    */
+    (void) file->extra(HA_EXTRA_DELETE_CANNOT_BATCH);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+
+bool TABLE::prepare_triggers_for_update_stmt_or_event()
+{
+  if (triggers &&
+      triggers->has_triggers(TRG_EVENT_UPDATE,
+                             TRG_ACTION_AFTER))
+  {
+    /*
+      The table has AFTER UPDATE triggers that might access to subject
+      table and therefore might need update to be done immediately.
+      So we turn-off the batching.
+    */ 
+    (void) file->extra(HA_EXTRA_UPDATE_CANNOT_BATCH);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+
+/**
+  Validates default value of fields which are not specified in
+  the column list of INSERT/LOAD statement.
+
+  @Note s->default_values should be properly populated
+        before calling this function.
+
+  @param thd              thread context
+  @param record           the record to check values in
+
+  @return
+    @retval false Success.
+    @retval true  Failure.
+*/
+
+bool TABLE::validate_default_values_of_unset_fields(THD *thd) const
+{
+  DBUG_ENTER("TABLE::validate_default_values_of_unset_fields");
+  for (Field **fld= field; *fld; fld++)
+  {
+    if (!bitmap_is_set(write_set, (*fld)->field_index) &&
+        !((*fld)->flags & (NO_DEFAULT_VALUE_FLAG | VERS_SYSTEM_FIELD)))
+    {
+      if (!(*fld)->is_null_in_record(s->default_values) &&
+          (*fld)->validate_value_in_record_with_warn(thd, s->default_values) &&
+          thd->is_error())
+      {
+        /*
+          We're here if:
+          - validate_value_in_record_with_warn() failed and
+            strict mo validate_default_values_of_unset_fieldsde converted WARN to ERROR
+          - or the connection was killed, or closed unexpectedly
+        */
+        DBUG_RETURN(true);
+      }
+    }
+  }
+  DBUG_RETURN(false);
+}
+
+
+/*
+  Check assignment compatibility of a value list against an explicitly
+  specified field list, e.g.
+    INSERT INTO t1 (a,b) VALUES (1,2);
+*/
+bool TABLE::check_assignability_explicit_fields(List<Item> fields,
+                                                List<Item> values,
+                                                bool ignore)
+{
+  DBUG_ENTER("TABLE::check_assignability_explicit_fields");
+  DBUG_ASSERT(fields.elements == values.elements);
+
+  List_iterator<Item> fi(fields);
+  List_iterator<Item> vi(values);
+  Item *f, *value;
+  while ((f= fi++) && (value= vi++))
+  {
+    Item_field *item_field= f->field_for_view_update();
+    if (!item_field)
+    {
+      /*
+        A non-updatable field of a view found.
+        This scenario is caught later and an error is raised.
+        We could eventually move error reporting here. For now just continue.
+      */
+      continue;
+    }
+    if (value->check_assignability_to(item_field->field, ignore))
+      DBUG_RETURN(true);
+  }
+  DBUG_RETURN(false);
+}
+
+
+/*
+  Check assignment compatibility for a value list against
+  all visible fields of the table, e.g.
+    INSERT INTO t1 VALUES (1,2);
+*/
+bool TABLE::check_assignability_all_visible_fields(List<Item> &values,
+                                                   bool ignore) const
+{
+  DBUG_ENTER("TABLE::check_assignability_all_visible_fields");
+  DBUG_ASSERT(s->visible_fields == values.elements);
+
+  List_iterator<Item> vi(values);
+  for (uint i= 0; i < s->fields; i++)
+  {
+    if (!field[i]->invisible &&
+        (vi++)->check_assignability_to(field[i], ignore))
+      DBUG_RETURN(true);
+  }
+  DBUG_RETURN(false);
+}
+
+
+bool TABLE::insert_all_rows_into_tmp_table(THD *thd,
+                                           TABLE *tmp_table,
+                                           TMP_TABLE_PARAM *tmp_table_param,
+                                           bool with_cleanup)
+{
+  int write_err= 0;
+
+  DBUG_ENTER("TABLE::insert_all_rows_into_tmp_table");
+
+  if (with_cleanup)
+  {
+   if ((write_err= tmp_table->file->ha_delete_all_rows()))
+      goto err;
+  }
+   
+  if (file->indexes_are_disabled())
+    tmp_table->file->ha_disable_indexes(HA_KEY_SWITCH_ALL);
+  file->ha_index_or_rnd_end();
+
+  if (unlikely(file->ha_rnd_init_with_error(1)))
+    DBUG_RETURN(1);
+
+  if (tmp_table->no_rows)
+    tmp_table->file->extra(HA_EXTRA_NO_ROWS);
+  else
+  {
+    /* update table->file->stats.records */
+    file->info(HA_STATUS_VARIABLE);
+    tmp_table->file->ha_start_bulk_insert(file->stats.records);
+  }
+
+  while (likely(!file->ha_rnd_next(tmp_table->record[0])))
+  {
+    write_err= tmp_table->file->ha_write_tmp_row(tmp_table->record[0]);
+    if (unlikely(write_err))
+    {
+      bool is_duplicate;
+      if (tmp_table->file->is_fatal_error(write_err, HA_CHECK_DUP) &&
+          create_internal_tmp_table_from_heap(thd, tmp_table,
+                                              tmp_table_param->start_recinfo, 
+                                              &tmp_table_param->recinfo,
+                                              write_err, 1, &is_duplicate))
+	DBUG_RETURN(1);
+       
+    }  
+    if (unlikely(thd->check_killed()))
+      goto err_killed;
+  }
+  if (!tmp_table->no_rows && tmp_table->file->ha_end_bulk_insert())
+    goto err;
+  DBUG_RETURN(0);
+
+err:
+  DBUG_PRINT("error",("Got error: %d",write_err));
+  file->print_error(write_err, MYF(0));
+err_killed:
+  (void) file->ha_rnd_end();
+  DBUG_RETURN(1);
+}
+
+
+
+/*
+  @brief Reset const_table flag
+
+  @detail
+  Reset const_table flag for this table. If this table is a merged derived
+  table/view the flag is recursively reseted for all tables of the underlying
+  select.
+*/
+
+void TABLE_LIST::reset_const_table()
+{
+  table->const_table= 0;
+  if (is_merged_derived())
+  {
+    SELECT_LEX *select_lex= get_unit()->first_select();
+    TABLE_LIST *tl;
+    List_iterator<TABLE_LIST> ti(select_lex->leaf_tables);
+    while ((tl= ti++))
+      tl->reset_const_table();
+  }
+}
+
+
+/*
+  @brief Run derived tables/view handling phases on underlying select_lex.
+
+  @param lex    LEX for this thread
+  @param phases derived tables/views handling phases to run
+                (set of DT_XXX constants)
+  @details
+  This function runs this derived table through specified 'phases'.
+  Underlying tables of this select are handled prior to this derived.
+  'lex' is passed as an argument to called functions.
+
+  @return TRUE on error
+  @return FALSE ok
+*/
+
+bool TABLE_LIST::handle_derived(LEX *lex, uint phases)
+{
+  SELECT_LEX_UNIT *unit= get_unit();
+  DBUG_ENTER("handle_derived");
+  DBUG_PRINT("enter", ("phases: 0x%x", phases));
+
+  if (unit)
+  {
+    if (!is_with_table_recursive_reference())
+    {
+      for (SELECT_LEX *sl= unit->first_select(); sl; sl= sl->next_select())
+        if (sl->handle_derived(lex, phases))
+          DBUG_RETURN(TRUE);
+    }
+    if (mysql_handle_single_derived(lex, this, phases))
+      DBUG_RETURN(TRUE);
+  }
+  DBUG_RETURN(FALSE);
+}
+
+/**
+  @brief
+  Return unit of this derived table/view
+
+  @return reference to a unit  if it's a derived table/view.
+  @return 0                    when it's not a derived table/view.
+*/
+
+st_select_lex_unit *TABLE_LIST::get_unit()
+{
+  return (view ? &view->unit : derived);
+}
+
+
+/**
+  @brief
+  Return select_lex of this derived table/view
+
+  @return select_lex of this derived table/view.
+  @return 0          when it's not a derived table.
+*/
+
+st_select_lex *TABLE_LIST::get_single_select()
+{
+  SELECT_LEX_UNIT *unit= get_unit();
+  return (unit ? unit->first_select() : 0);
+}
+
+
+/**
+  @brief
+  Attach a join table list as a nested join to this TABLE_LIST.
+
+  @param join_list join table list to attach
+
+  @details
+  This function wraps 'join_list' into a nested_join of this table, thus
+  turning it to a nested join leaf.
+*/
+
+void TABLE_LIST::wrap_into_nested_join(List<TABLE_LIST> &join_list)
+{
+  TABLE_LIST *tl;
+  /*
+    Walk through derived table top list and set 'embedding' to point to
+    the nesting table.
+  */
+  nested_join->join_list.empty();
+  List_iterator_fast<TABLE_LIST> li(join_list);
+  nested_join->join_list= join_list;
+  while ((tl= li++))
+  {
+    tl->embedding= this;
+    tl->join_list= &nested_join->join_list;
+  }
+}
+
+
+/**
+  Check whether optimization has been performed and a derived table either
+  been merged to upper select level or materialized.
+
+  @param table  a TABLE_LIST object containing a derived table
+
+  @return true in case the derived table has been merged to surrounding select,
+          false otherwise
+*/
+
+static inline bool derived_table_optimization_done(TABLE_LIST *table)
+{
+  SELECT_LEX_UNIT *derived= (table->derived ?
+                             table->derived :
+                             (table->view ?
+                              &table->view->unit:
+                              NULL));
+  return derived &&
+      (derived->is_excluded() ||
+       table->is_materialized_derived());
+}
+
+
+/**
+  @brief
+  Initialize this derived table/view
+
+  @param thd  Thread handle
+
+  @details
+  This function makes initial preparations of this derived table/view for
+  further processing:
+    if it's a derived table this function marks it either as mergeable or
+      materializable
+    creates temporary table for name resolution purposes
+    creates field translation for mergeable derived table/view
+
+  @return TRUE  an error occur
+  @return FALSE ok
+*/
+
+bool TABLE_LIST::init_derived(THD *thd, bool init_view)
+{
+  SELECT_LEX *first_select= get_single_select();
+  SELECT_LEX_UNIT *unit= get_unit();
+
+  if (!unit)
+    return FALSE;
+  /*
+    Check whether we can merge this derived table into main select.
+    Depending on the result field translation will or will not
+    be created.
+  */
+  TABLE_LIST *first_table= (TABLE_LIST *) first_select->table_list.first;
+  if (first_select->table_list.elements > 1 ||
+      (first_table && first_table->is_multitable()))
+    set_multitable();
+
+  if (!unit->derived)
+    unit->derived= this;
+  else if (!is_with_table_recursive_reference() && unit->derived != this)
+  {
+    if (unit->derived->is_with_table_recursive_reference())
+      unit->derived= this;
+    else if (vers_conditions.eq(unit->derived->vers_conditions))
+      vers_conditions.empty();
+    else
+    {
+      my_error(ER_CONFLICTING_FOR_SYSTEM_TIME, MYF(0));
+      return TRUE;
+    }
+  }
+
+  if (init_view && !view &&
+      !derived_table_optimization_done(this))
+  {
+    /* This is all what we can do for a derived table for now. */
+    set_derived();
+  }
+
+  if (!derived_table_optimization_done(this))
+  {
+    /* A subquery might be forced to be materialized due to a side-effect. */
+    if (!is_materialized_derived() && unit->can_be_merged() &&
+        /*
+          Following is special case of
+          SELECT * FROM (<limited-select>) WHERE ROWNUM() <= nnn
+        */
+        (unit->outer_select() &&
+         !(unit->outer_select()->with_rownum &&
+           unit->outer_select()->table_list.elements == 1 &&
+           (thd->lex->sql_command == SQLCOM_SELECT ||
+            !unit->outer_select()->is_query_topmost(thd)) &&
+           !is_view())) &&
+
+        (!thd->lex->with_rownum ||
+         (!first_select->group_list.elements &&
+          !first_select->order_list.elements)) &&
+        (is_view() ||
+         optimizer_flag(thd, OPTIMIZER_SWITCH_DERIVED_MERGE)) &&
+          !thd->lex->can_not_use_merged() &&
+        !((thd->lex->sql_command == SQLCOM_UPDATE_MULTI ||
+           thd->lex->sql_command == SQLCOM_DELETE_MULTI) && !is_view()) &&
+        !is_recursive_with_table())
+      set_merged_derived();
+    else
+      set_materialized_derived();
+  }
+  /*
+    Derived tables/view are materialized prior to UPDATE, thus we can skip
+    them from table uniqueness check
+  */
+  if (is_materialized_derived())
+  {
+    set_check_materialized();
+  }
+
+  /*
+    Create field translation for mergeable derived tables/views.
+    For derived tables field translation can be created only after
+    unit is prepared so all '*' are get unrolled.
+  */
+  if (is_merged_derived())
+  {
+    if (is_view() ||
+        (unit->prepared &&
+	!(thd->lex->context_analysis_only & CONTEXT_ANALYSIS_ONLY_VIEW)))
+      create_field_translation(thd);
+  }
+
+  return FALSE;
+}
+
+
+/**
+  @brief
+  Retrieve number of rows in the table
+
+  @details
+  Retrieve number of rows in the table referred by this TABLE_LIST and
+  store it in the table's stats.records variable. If this TABLE_LIST refers
+  to a materialized derived table/view then the estimated number of rows of
+  the derived table/view is used instead.
+
+  @return 0          ok
+  @return non zero   error
+*/
+
+int TABLE_LIST::fetch_number_of_rows()
+{
+  int error= 0;
+  if (jtbm_subselect)
+  {
+    if (jtbm_subselect->is_jtbm_merged)
+    {
+      table->file->stats.records= (ha_rows)jtbm_subselect->jtbm_record_count;
+      set_if_bigger(table->file->stats.records, 2);
+      table->used_stat_records= table->file->stats.records;
+    }
+    return 0;
+  }
+  if (is_materialized_derived() && !fill_me)
+  {
+    table->file->stats.records= get_unit()->result->est_records;
+    set_if_bigger(table->file->stats.records, 2);
+    table->used_stat_records= table->file->stats.records;
+  }
+  else
+    error= table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
+  return error;
+}
+
+/*
+  Procedure of keys generation for result tables of materialized derived
+  tables/views.
+
+  A key is generated for each equi-join pair derived table-another table.
+  Each generated key consists of fields of derived table used in equi-join.
+  Example:
+
+    SELECT * FROM (SELECT * FROM t1 GROUP BY 1) tt JOIN
+                  t1 ON tt.f1=t1.f3 and tt.f2.=t1.f4;
+  In this case for the derived table tt one key will be generated. It will
+  consist of two parts f1 and f2.
+  Example:
+
+    SELECT * FROM (SELECT * FROM t1 GROUP BY 1) tt JOIN
+                  t1 ON tt.f1=t1.f3 JOIN
+                  t2 ON tt.f2=t2.f4;
+  In this case for the derived table tt two keys will be generated.
+  One key over f1 field, and another key over f2 field.
+  Currently optimizer may choose to use only one such key, thus the second
+  one will be dropped after range optimizer is finished.
+  See also JOIN::drop_unused_derived_keys function.
+  Example:
+
+    SELECT * FROM (SELECT * FROM t1 GROUP BY 1) tt JOIN
+                  t1 ON tt.f1=a_function(t1.f3);
+  In this case for the derived table tt one key will be generated. It will
+  consist of one field - f1.
+*/
+
+
+
+/*
+  @brief
+  Change references to underlying items of a merged derived table/view
+  for fields in derived table's result table.
+
+  @return FALSE ok
+  @return TRUE  Out of memory
+*/
+bool TABLE_LIST::change_refs_to_fields()
+{
+  List_iterator<Item> li(used_items);
+  Item_direct_ref *ref;
+  Field_iterator_view field_it;
+  Name_resolution_context *ctx;
+  THD *thd= table->in_use;
+  Item **materialized_items;
+  DBUG_ASSERT(is_merged_derived());
+
+  if (!used_items.elements)
+    return FALSE;
+
+  materialized_items= (Item **)thd->calloc(sizeof(void *) * table->s->fields);
+  ctx= new (thd->mem_root) Name_resolution_context(this);
+  if (!materialized_items || !ctx)
+    return TRUE;
+
+  while ((ref= (Item_direct_ref*)li++))
+  {
+    uint idx;
+    Item *orig_item= *ref->ref;
+    field_it.set(this);
+    for (idx= 0; !field_it.end_of_fields(); field_it.next(), idx++)
+    {
+      if (field_it.item() == orig_item)
+        break;
+    }
+    DBUG_ASSERT(!field_it.end_of_fields());
+    if (!materialized_items[idx])
+    {
+      materialized_items[idx]=
+        new (thd->mem_root) Item_field(thd, ctx, table->field[idx]);
+      if (!materialized_items[idx])
+        return TRUE;
+    }
+    /*
+      We need to restore the pointers after the execution of the
+      prepared statement.
+    */
+    thd->change_item_tree((Item **)&ref->ref,
+                          (Item*)(materialized_items + idx));
+    /* Inform Item_direct_ref that what it points to has changed */
+    ref->ref_changed();
+  }
+
+  return FALSE;
+}
+
+
+void TABLE_LIST::set_lock_type(THD *thd, enum thr_lock_type lock)
+{
+  if (check_stack_overrun(thd, STACK_MIN_SIZE, (uchar *)&lock))
+    return;
+  /* we call it only when table is opened and it is "leaf" table*/
+  DBUG_ASSERT(table);
+  lock_type= lock;
+  /* If not derived tables */
+  if (table->file && table->file->is_open())
+    table->file->set_lock_type(lock);
+  if (is_merged_derived())
+  {
+    for (TABLE_LIST *table= get_single_select()->get_table_list();
+         table;
+         table= table->next_local)
+    {
+      table->set_lock_type(thd, lock);
+    }
+  }
+}
+
+bool TABLE_LIST::is_with_table()
+{
+  return derived && derived->with_element;
+}
+
+
+/**
+  Check if the definition are the same.
+
+  If versions do not match it check definitions (with checking and setting
+  trigger definition versions (times)
+
+  @param[in]  view                TABLE_LIST of the view
+  @param[in]  share               Share object of view
+
+  @return false on error or different definitions.
+
+  @sa check_and_update_table_version()
+*/
+
+bool TABLE_LIST::is_the_same_definition(THD* thd, TABLE_SHARE *s)
+{
+  enum enum_table_ref_type tp= s->get_table_ref_type();
+  if (m_table_ref_type == tp)
+  {
+    /*
+      Cache have not changed which means that definition was not changed
+      including triggers
+    */
+    if (m_table_ref_version == s->get_table_ref_version())
+      return TRUE;
+
+    /*
+      If cache changed then check content version
+    */
+    if ((tabledef_version.length &&
+         tabledef_version.length == s->tabledef_version.length &&
+         memcmp(tabledef_version.str, s->tabledef_version.str,
+                tabledef_version.length) == 0))
+    {
+      // Definition have not changed, let's check if triggers changed.
+      if (table && table->triggers)
+      {
+
+        my_hrtime_t hr_stmt_prepare= thd->hr_prepare_time;
+        if (hr_stmt_prepare.val)
+          for(uint i= 0; i < TRG_EVENT_MAX; i++)
+            for (uint j= 0; j < TRG_ACTION_MAX; j++)
+            {
+              Trigger *tr=
+                table->triggers->get_trigger((trg_event_type)i,
+                                             (trg_action_time_type)j);
+              if (tr)
+                if (hr_stmt_prepare.val <= tr->hr_create_time.val)
+                {
+                  set_tabledef_version(s);
+                  return FALSE;
+                }
+            }
+      }
+      set_table_id(s);
+      return TRUE;
+    }
+    else
+      tabledef_version.length= 0;
+  }
+  else
+    set_tabledef_version(s);
+  return FALSE;
+}
+
+
+uint TABLE_SHARE::actual_n_key_parts(THD *thd)
+{
+  return use_ext_keys &&
+         optimizer_flag(thd, OPTIMIZER_SWITCH_EXTENDED_KEYS) ?
+           ext_key_parts : key_parts;
+}  
+
+
+double KEY::actual_rec_per_key(uint i)
+{ 
+  if (rec_per_key == 0)
+    return 0;
+  return (is_statistics_from_stat_tables ?
+          read_stats->get_avg_frequency(i) : (double) rec_per_key[i]);
+}
+
+/*
+   find total number of field in hash expr
+*/
+int fields_in_hash_keyinfo(KEY *keyinfo)
+{
+  Item_func_hash * temp= (Item_func_hash *)
+                     keyinfo->key_part->field->vcol_info->expr;
+  return temp->argument_count();
+}
+/*
+  setup_keyinfo_hash changes the key_info->key_part
+  to be same as defined by user
+ */
+void setup_keyinfo_hash(KEY *key_info)
+{
+  DBUG_ASSERT(key_info->algorithm == HA_KEY_ALG_LONG_HASH);
+  DBUG_ASSERT(key_info->key_part->field->flags & LONG_UNIQUE_HASH_FIELD);
+  uint no_of_keyparts= fields_in_hash_keyinfo(key_info);
+  key_info->key_part-= no_of_keyparts;
+  key_info->user_defined_key_parts= key_info->usable_key_parts=
+               key_info->ext_key_parts= no_of_keyparts;
+  key_info->flags|= HA_NOSAME;
+}
+/*
+  re_setup_keyinfo_hash reverts th setup_keyinfo_hash and this type of
+  arrangement is expected by storage engine
+ */
+
+void re_setup_keyinfo_hash(KEY *key_info)
+{
+  DBUG_ASSERT(key_info->algorithm == HA_KEY_ALG_LONG_HASH);
+  DBUG_ASSERT(!(key_info->key_part->field->flags & LONG_UNIQUE_HASH_FIELD));
+  while(!(key_info->key_part->field->flags & LONG_UNIQUE_HASH_FIELD))
+    key_info->key_part++;
+  key_info->user_defined_key_parts= key_info->usable_key_parts=
+               key_info->ext_key_parts= 1;
+  key_info->flags&= ~HA_NOSAME;
+}
+
+LEX_CSTRING *fk_option_name(enum_fk_option opt)
+{
+  static LEX_CSTRING names[]=
+  {
+    { STRING_WITH_LEN("???") },
+    { STRING_WITH_LEN("RESTRICT") },
+    { STRING_WITH_LEN("NO ACTION") },
+    { STRING_WITH_LEN("CASCADE") },
+    { STRING_WITH_LEN("SET NULL") },
+    { STRING_WITH_LEN("SET DEFAULT") }
+  };
+  return names + opt;
+}
+
+enum TR_table::enabled TR_table::use_transaction_registry= TR_table::MAYBE;
+
+TR_table::TR_table(THD* _thd, bool rw) :
+  thd(_thd), open_tables_backup(NULL)
+{
+  init_one_table(&MYSQL_SCHEMA_NAME, &TRANSACTION_REG_NAME,
+                 NULL, rw ? TL_WRITE : TL_READ);
+}
+
+bool TR_table::open()
+{
+  DBUG_ASSERT(!table);
+  open_tables_backup= new Open_tables_backup;
+  if (!open_tables_backup)
+  {
+    my_error(ER_OUT_OF_RESOURCES, MYF(0));
+    return true;
+  }
+
+  All_tmp_tables_list *temporary_tables= thd->temporary_tables;
+  bool error= !open_log_table(thd, this, open_tables_backup);
+  thd->temporary_tables= temporary_tables;
+
+  if (use_transaction_registry == MAYBE)
+    error= check(error);
+
+  use_transaction_registry= error ? NO : YES;
+
+  return error;
+}
+
+TR_table::~TR_table()
+{
+  if (table)
+  {
+    thd->temporary_tables= NULL;
+    close_log_table(thd, open_tables_backup);
+  }
+  delete open_tables_backup;
+}
+
+void TR_table::store(uint field_id, ulonglong val)
+{
+  table->field[field_id]->store(val, true);
+  table->field[field_id]->set_notnull();
+}
+
+void TR_table::store(uint field_id, timeval ts)
+{
+  table->field[field_id]->store_timestamp(ts.tv_sec, ts.tv_usec);
+  table->field[field_id]->set_notnull();
+}
+
+enum_tx_isolation TR_table::iso_level() const
+{
+  enum_tx_isolation res= (enum_tx_isolation) ((*this)[FLD_ISO_LEVEL]->val_int() - 1);
+  DBUG_ASSERT(res <= ISO_SERIALIZABLE);
+  return res;
+}
+
+bool TR_table::update(ulonglong start_id, ulonglong end_id)
+{
+  if (!table && open())
+    return true;
+
+  store(FLD_BEGIN_TS, thd->transaction_time());
+  thd->set_time();
+  timeval end_time= {thd->query_start(), int(thd->query_start_sec_part())};
+  store(FLD_TRX_ID, start_id);
+  store(FLD_COMMIT_ID, end_id);
+  store(FLD_COMMIT_TS, end_time);
+  store_iso_level(thd->tx_isolation);
+
+  int error= table->file->ha_write_row(table->record[0]);
+  if (unlikely(error))
+    table->file->print_error(error, MYF(0));
+  /* extra() is used to apply the bulk insert operation
+  on mysql/transaction_registry table */
+  return error;
+}
+
+#define newx new (thd->mem_root)
+bool TR_table::query(ulonglong trx_id)
+{
+  if (!table && open())
+    return false;
+  SQL_SELECT_auto select;
+  READ_RECORD info;
+  int error;
+  List<TABLE_LIST> dummy;
+  SELECT_LEX &slex= *(thd->lex->first_select_lex());
+  Name_resolution_context_backup backup(slex.context, *this);
+  Item *field= newx Item_field(thd, &slex.context, (*this)[FLD_TRX_ID]);
+  Item *value= newx Item_int(thd, trx_id);
+  COND *conds= newx Item_func_eq(thd, field, value);
+  if (unlikely((error= setup_conds(thd, this, dummy, &conds))))
+    return false;
+  select= make_select(table, 0, 0, conds, NULL, 0, &error);
+  if (unlikely(error || !select))
+  {
+    my_error(ER_OUT_OF_RESOURCES, MYF(0));
+    return false;
+  }
+  // FIXME: (performance) force index 'transaction_id'
+  error= init_read_record(&info, thd, table, select, NULL,
+                          1 /* use_record_cache */, true /* print_error */,
+                          false /* disable_rr_cache */);
+  while (!(error= info.read_record()) && !thd->killed && !thd->is_error())
+  {
+    if (select->skip_record(thd) > 0)
+      return true;
+  }
+  my_error(ER_VERS_NO_TRX_ID, MYF(0), (longlong) trx_id);
+  return false;
+}
+
+bool TR_table::query(MYSQL_TIME &commit_time, bool backwards)
+{
+  if (!table && open())
+    return false;
+  SQL_SELECT_auto select;
+  READ_RECORD info;
+  int error;
+  List<TABLE_LIST> dummy;
+  SELECT_LEX &slex= *(thd->lex->first_select_lex());
+  Name_resolution_context_backup backup(slex.context, *this);
+  Item *field= newx Item_field(thd, &slex.context, (*this)[FLD_COMMIT_TS]);
+  Datetime dt(&commit_time);
+  Item *value= newx Item_datetime_literal(thd, &dt, 6);
+  COND *conds;
+  if (backwards)
+    conds= newx Item_func_ge(thd, field, value);
+  else
+    conds= newx Item_func_le(thd, field, value);
+  if (unlikely((error= setup_conds(thd, this, dummy, &conds))))
+    return false;
+  // FIXME: (performance) force index 'commit_timestamp'
+  select= make_select(table, 0, 0, conds, NULL, 0, &error);
+  if (unlikely(error || !select))
+    return false;
+  error= init_read_record(&info, thd, table, select, NULL,
+                          1 /* use_record_cache */, true /* print_error */,
+                          false /* disable_rr_cache */);
+
+  // With PK by transaction_id the records are ordered by PK, so we have to
+  // scan TRT fully and collect min (backwards == true)
+  // or max (backwards == false) stats.
+  bool found= false;
+  MYSQL_TIME found_ts;
+  while (!(error= info.read_record()) && !thd->killed && !thd->is_error())
+  {
+    int res= select->skip_record(thd);
+    if (res > 0)
+    {
+      MYSQL_TIME commit_ts;
+      if ((*this)[FLD_COMMIT_TS]->get_date(&commit_ts, date_mode_t(0)))
+      {
+        found= false;
+        break;
+      }
+      int c;
+      if (!found || ((c= my_time_compare(&commit_ts, &found_ts)) &&
+        (backwards ? c < 0 : c > 0)))
+      {
+        found_ts= commit_ts;
+        found= true;
+        // TODO: (performance) make ORDER DESC and break after first found.
+        // Otherwise it is O(n) scan (+copy)!
+        store_record(table, record[1]);
+      }
+    }
+    else if (res < 0)
+    {
+      found= false;
+      break;
+    }
+ }
+  if (found)
+    restore_record(table, record[1]);
+  return found;
+}
+#undef newx
+
+bool TR_table::query_sees(bool &result, ulonglong trx_id1, ulonglong trx_id0,
+                          ulonglong commit_id1, enum_tx_isolation iso_level1,
+                          ulonglong commit_id0)
+{
+  if (trx_id1 == trx_id0)
+  {
+    return false;
+  }
+
+  if (trx_id1 == ULONGLONG_MAX || trx_id0 == 0)
+  {
+    result= true;
+    return false;
+  }
+
+  if (trx_id0 == ULONGLONG_MAX || trx_id1 == 0)
+  {
+    result= false;
+    return false;
+  }
+
+  if (!commit_id1)
+  {
+    if (!query(trx_id1))
+      return true;
+
+    commit_id1= (*this)[FLD_COMMIT_ID]->val_int();
+    iso_level1= iso_level();
+  }
+
+  if (!commit_id0)
+  {
+    if (!query(trx_id0))
+      return true;
+
+    commit_id0= (*this)[FLD_COMMIT_ID]->val_int();
+  }
+
+  // Trivial case: TX1 started after TX0 committed
+  if (trx_id1 > commit_id0
+      // Concurrent transactions: TX1 committed after TX0 and TX1 is read (un)committed
+      || (commit_id1 > commit_id0 && iso_level1 < ISO_REPEATABLE_READ))
+  {
+    result= true;
+  }
+  else // All other cases: TX1 does not see TX0
+  {
+    result= false;
+  }
+
+  return false;
+}
+
+void TR_table::warn_schema_incorrect(const char *reason)
+{
+  if (MYSQL_VERSION_ID == table->s->mysql_version)
+  {
+    sql_print_error("%`s.%`s schema is incorrect: %s.",
+                    db.str, table_name.str, reason);
+  }
+  else
+  {
+    sql_print_error("%`s.%`s schema is incorrect: %s. Created with MariaDB %d, "
+                    "now running %d.",
+                    db.str, table_name.str, reason, MYSQL_VERSION_ID,
+                    static_cast<int>(table->s->mysql_version));
+  }
+}
+
+bool TR_table::check(bool error)
+{
+  if (error)
+  {
+    sql_print_warning("%`s.%`s does not exist (open failed).", db.str,
+                      table_name.str);
+    return true;
+  }
+
+  if (table->file->ht->db_type != DB_TYPE_INNODB)
+  {
+    warn_schema_incorrect("Wrong table engine (expected InnoDB)");
+    return true;
+  }
+
+#define WARN_SCHEMA(...) \
+  char reason[128]; \
+  snprintf(reason, 128, __VA_ARGS__); \
+  warn_schema_incorrect(reason);
+
+  if (table->s->fields != FIELD_COUNT)
+  {
+    WARN_SCHEMA("Wrong field count (expected %d)", FIELD_COUNT);
+    return true;
+  }
+
+  if (table->field[FLD_TRX_ID]->type() != MYSQL_TYPE_LONGLONG)
+  {
+    WARN_SCHEMA("Wrong field %d type (expected BIGINT UNSIGNED)", FLD_TRX_ID);
+    return true;
+  }
+
+  if (table->field[FLD_COMMIT_ID]->type() != MYSQL_TYPE_LONGLONG)
+  {
+    WARN_SCHEMA("Wrong field %d type (expected BIGINT UNSIGNED)", FLD_COMMIT_ID);
+    return true;
+  }
+
+  if (table->field[FLD_BEGIN_TS]->type() != MYSQL_TYPE_TIMESTAMP)
+  {
+    WARN_SCHEMA("Wrong field %d type (expected TIMESTAMP(6))", FLD_BEGIN_TS);
+    return true;
+  }
+
+  if (table->field[FLD_COMMIT_TS]->type() != MYSQL_TYPE_TIMESTAMP)
+  {
+    WARN_SCHEMA("Wrong field %d type (expected TIMESTAMP(6))", FLD_COMMIT_TS);
+    return true;
+  }
+
+  if (table->field[FLD_ISO_LEVEL]->type() != MYSQL_TYPE_STRING ||
+      !(table->field[FLD_ISO_LEVEL]->flags & ENUM_FLAG))
+  {
+  wrong_enum:
+    WARN_SCHEMA("Wrong field %d type (expected ENUM('READ-UNCOMMITTED', "
+                "'READ-COMMITTED', 'REPEATABLE-READ', 'SERIALIZABLE'))",
+                FLD_ISO_LEVEL);
+    return true;
+  }
+
+  Field_enum *iso_level= static_cast<Field_enum *>(table->field[FLD_ISO_LEVEL]);
+  const st_typelib *typelib= iso_level->typelib;
+
+  if (typelib->count != 4)
+    goto wrong_enum;
+
+  if (strcmp(typelib->type_names[0], "READ-UNCOMMITTED") ||
+      strcmp(typelib->type_names[1], "READ-COMMITTED") ||
+      strcmp(typelib->type_names[2], "REPEATABLE-READ") ||
+      strcmp(typelib->type_names[3], "SERIALIZABLE"))
+  {
+    goto wrong_enum;
+  }
+
+  if (!table->key_info || !table->key_info->key_part)
+    goto wrong_pk;
+
+  if (strcmp(table->key_info->key_part->field->field_name.str, "transaction_id"))
+  {
+  wrong_pk:
+    WARN_SCHEMA("Wrong PRIMARY KEY (expected `transaction_id`)");
+    return true;
+  }
+
+  return false;
+}
+
+bool vers_select_conds_t::check_units(THD *thd)
+{
+  DBUG_ASSERT(type != SYSTEM_TIME_UNSPECIFIED);
+  DBUG_ASSERT(start.item);
+  return start.check_unit(thd) ||
+         end.check_unit(thd);
+}
+
+bool vers_select_conds_t::eq(const vers_select_conds_t &conds) const
+{
+  if (type != conds.type)
+    return false;
+  switch (type) {
+  case SYSTEM_TIME_UNSPECIFIED:
+  case SYSTEM_TIME_ALL:
+    return true;
+  case SYSTEM_TIME_BEFORE:
+    break;
+  case SYSTEM_TIME_HISTORY:
+    break;
+  case SYSTEM_TIME_AS_OF:
+    return start.eq(conds.start);
+  case SYSTEM_TIME_FROM_TO:
+  case SYSTEM_TIME_BETWEEN:
+    return start.eq(conds.start) && end.eq(conds.end);
+  }
+  DBUG_ASSERT(0);
+  return false;
+}
+
+
+bool Vers_history_point::check_unit(THD *thd)
+{
+  if (!item)
+    return false;
+  if (item->fix_fields_if_needed(thd, &item))
+    return true;
+  const Type_handler *t= item->this_item()->real_type_handler();
+  DBUG_ASSERT(t);
+  if (!t->vers())
+  {
+    my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0),
+             t->name().ptr(), "FOR SYSTEM_TIME");
+    return true;
+  }
+  return false;
+}
+
+
+void Vers_history_point::fix_item()
+{
+  if (item && item->decimals == 0 && item->type() == Item::FUNC_ITEM &&
+      ((Item_func*)item)->functype() == Item_func::NOW_FUNC)
+    item->decimals= 6;
+}
+
+
+bool Vers_history_point::eq(const vers_history_point_t &point) const
+{
+  return unit == point.unit && item->eq(point.item, false);
+}
+
+void Vers_history_point::print(String *str, enum_query_type query_type,
+                               const char *prefix, size_t plen) const
+{
+  const static LEX_CSTRING unit_type[]=
+  {
+    { STRING_WITH_LEN("") },
+    { STRING_WITH_LEN("TIMESTAMP ") },
+    { STRING_WITH_LEN("TRANSACTION ") }
+  };
+  str->append(prefix, plen);
+  str->append(unit_type + unit);
+  item->print(str, query_type);
+}
+
+Field *TABLE::find_field_by_name(LEX_CSTRING *str) const
+{
+  Field **tmp;
+  size_t length= str->length;
+  if (s->name_hash.records)
+  {
+    tmp= (Field**) my_hash_search(&s->name_hash, (uchar*) str->str, length);
+    return tmp ? field[tmp - s->field] : NULL;
+  }
+  else
+  {
+    for (tmp= field; *tmp; tmp++)
+    {
+      if ((*tmp)->field_name.length == length &&
+          !lex_string_cmp(system_charset_info, &(*tmp)->field_name, str))
+        return *tmp;
+    }
+  }
+  return NULL;
+}
+
+
+bool TABLE::export_structure(THD *thd, Row_definition_list *defs)
+{
+  for (Field **src= field; *src; src++)
+  {
+    uint offs;
+    if (defs->find_row_field_by_name(&src[0]->field_name, &offs))
+    {
+      my_error(ER_DUP_FIELDNAME, MYF(0), src[0]->field_name.str);
+      return true;
+    }
+    Spvar_definition *def= new (thd->mem_root) Spvar_definition(thd, *src);
+    if (!def)
+      return true;
+    def->flags&= (uint) ~NOT_NULL_FLAG;
+    if ((def->sp_prepare_create_field(thd, thd->mem_root)) ||
+        (defs->push_back(def, thd->mem_root)))
+      return true;
+  }
+  return false;
+}
+
+/**
+  @brief
+    Initialize all the opt_range structures that are used to stored the
+    estimates when the range optimizer is run.
+    As these are initialized by the range optimizer for all index
+    marked in opt_range_keys, we only mark the memory as undefined
+    to be able to find wrong usage of data with valgrind or MSAN.
+*/
+
+inline void TABLE::initialize_opt_range_structures()
+{
+  TRASH_ALLOC((void*)&opt_range_keys, sizeof(opt_range_keys));
+  TRASH_ALLOC(opt_range, s->keys * sizeof(*opt_range));
+  TRASH_ALLOC(const_key_parts, s->keys * sizeof(*const_key_parts));
+}
+
+/*
+  Mark table to be reopened after query
+*/
+
+void TABLE::mark_table_for_reopen()
+{
+  THD *thd= in_use;
+  DBUG_ASSERT(thd);
+  thd->locked_tables_list.mark_table_for_reopen(this);
+}