10.0-base merge

122 files changed, 7171 insertions, 5452 deletions

diff --git a/sql/CMakeLists.txt b/sql/CMakeLists.txt
index 8c2b6c81755..aa916a3725a 100644
--- a/sql/CMakeLists.txt
+++ b/sql/CMakeLists.txt
@@ -189,9 +189,12 @@ INSTALL_DEBUG_TARGET(mysqld
   PDB_DESTINATION ${INSTALL_SBINDIR}/debug
   RENAME mysqld-debug)
 
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/bison.cmake)
+
 # Handle out-of-source build from source package with possibly broken 
 # bison. Copy bison output to from source to build directory, if not already 
 # there
+IF (NOT BISON_USABLE)
 IF (NOT ${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
   IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/sql_yacc.cc)
     IF(NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/sql_yacc.cc)
@@ -202,9 +205,8 @@ IF (NOT ${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
     ENDIF()
   ENDIF()
 ENDIF()
+ENDIF()
 
-
-INCLUDE(${CMAKE_SOURCE_DIR}/cmake/bison.cmake)
 RUN_BISON(
   ${CMAKE_CURRENT_SOURCE_DIR}/sql_yacc.yy 
   ${CMAKE_CURRENT_BINARY_DIR}/sql_yacc.cc
diff --git a/sql/create_options.cc b/sql/create_options.cc
index 5cedfa03a63..f12120bd0a1 100644
--- a/sql/create_options.cc
+++ b/sql/create_options.cc
@@ -21,6 +21,7 @@
 
 #include "create_options.h"
 #include <my_getopt.h>
+#include "set_var.h"
 
 #define FRM_QUOTED_VALUE 0x8000
 
@@ -74,7 +75,7 @@ void engine_option_value::link(engine_option_value **start,
 }
 
 static bool report_wrong_value(THD *thd, const char *name, const char *val,
-                               my_bool suppress_warning)
+                               bool suppress_warning)
 {
   if (suppress_warning)
     return 0;
@@ -92,7 +93,7 @@ static bool report_wrong_value(THD *thd, const char *name, const char *val,
 }
 
 static bool report_unknown_option(THD *thd, engine_option_value *val,
-                                  my_bool suppress_warning)
+                                  bool suppress_warning)
 {
   DBUG_ENTER("report_unknown_option");
 
@@ -115,8 +116,8 @@ static bool report_unknown_option(THD *thd, engine_option_value *val,
 }
 
 static bool set_one_value(ha_create_table_option *opt,
-                          THD *thd, LEX_STRING *value, void *base,
-                          my_bool suppress_warning,
+                          THD *thd, const LEX_STRING *value, void *base,
+                          bool suppress_warning,
                           MEM_ROOT *root)
 {
   DBUG_ENTER("set_one_value");
@@ -126,6 +127,8 @@ static bool set_one_value(ha_create_table_option *opt,
                        (value->str ? value->str : "<DEFAULT>")));
   switch (opt->type)
   {
+  case HA_OPTION_TYPE_SYSVAR:
+    DBUG_ASSERT(0); // HA_OPTION_TYPE_SYSVAR's are replaced in resolve_sysvars()
   case HA_OPTION_TYPE_ULL:
     {
       ulonglong *val= (ulonglong*)((char*)base + opt->offset);
@@ -257,52 +260,92 @@ static const size_t ha_option_type_sizeof[]=
   @retval FALSE OK
 */
 
-my_bool parse_option_list(THD* thd, void *option_struct_arg,
-                          engine_option_value *option_list,
-                          ha_create_table_option *rules,
-                          my_bool suppress_warning,
-                          MEM_ROOT *root)
+bool parse_option_list(THD* thd, handlerton *hton, void *option_struct_arg,
+                       engine_option_value **option_list,
+                       ha_create_table_option *rules,
+                       bool suppress_warning, MEM_ROOT *root)
 {
   ha_create_table_option *opt;
   size_t option_struct_size= 0;
-  engine_option_value *val= option_list;
+  engine_option_value *val, *last;
   void **option_struct= (void**)option_struct_arg;
   DBUG_ENTER("parse_option_list");
   DBUG_PRINT("enter",
-             ("struct: 0x%lx list: 0x%lx rules: 0x%lx suppres %u root 0x%lx",
-              (ulong) *option_struct, (ulong)option_list, (ulong)rules,
-              (uint) suppress_warning, (ulong) root));
+             ("struct: %p list: %p rules: %p suppress_warning: %u root: %p",
+              *option_struct, *option_list, rules,
+              (uint) suppress_warning, root));
 
   if (rules)
   {
-    LEX_STRING default_val= {NULL, 0};
     for (opt= rules; opt->name; opt++)
       set_if_bigger(option_struct_size, opt->offset +
                     ha_option_type_sizeof[opt->type]);
 
     *option_struct= alloc_root(root, option_struct_size);
-
-    /* set all values to default */
-    for (opt= rules; opt->name; opt++)
-      set_one_value(opt, thd, &default_val, *option_struct,
-                    suppress_warning, root);
   }
 
-  for (; val; val= val->next)
+  for (opt= rules; opt && opt->name; opt++)
   {
-    for (opt= rules; opt && opt->name; opt++)
+    bool seen=false;
+    for (val= *option_list; val; val= val->next)
     {
+      last= val;
       if (my_strnncoll(system_charset_info,
                        (uchar*)opt->name, opt->name_length,
                        (uchar*)val->name.str, val->name.length))
         continue;
 
+      seen=true;
+
+      if (val->parsed && !val->value.str)
+        continue;
+
       if (set_one_value(opt, thd, &val->value,
                         *option_struct, suppress_warning || val->parsed, root))
         DBUG_RETURN(TRUE);
       val->parsed= true;
       break;
     }
+    if (!seen)
+    {
+      LEX_STRING default_val= null_lex_str;
+
+      /*
+        If it's CREATE/ALTER TABLE parsing mode (options are created in the
+        transient thd->mem_root, not in the long living TABLE_SHARE::mem_root),
+        and variable-backed option was not explicitly set.
+
+        If it's not create, but opening of the existing frm (that was,
+        probably, created with the older version of the storage engine and
+        does not have this option stored), we take the *default* value of the
+        sysvar, not the *current* value. Because we don't want to have
+        different option values for the same table if it's opened many times.
+      */
+      if (root == thd->mem_root && opt->var)
+      {
+        // take a value from the variable and add it to the list
+        sys_var *sysvar= find_hton_sysvar(hton, opt->var);
+        DBUG_ASSERT(sysvar);
+
+        char buf[256];
+        String sbuf(buf, sizeof(buf), system_charset_info), *str;
+        if ((str= sysvar->val_str(&sbuf, thd, OPT_SESSION, 0)))
+        {
+          LEX_STRING name= { const_cast<char*>(opt->name), opt->name_length };
+          default_val.str= strmake_root(root, str->ptr(), str->length());
+          default_val.length= str->length();
+          val= new (root) engine_option_value(name, default_val, true,
+                                              option_list, &last);
+          val->parsed= true;
+        }
+      }
+      set_one_value(opt, thd, &default_val, *option_struct,
+                    suppress_warning, root);
+    }
+  }
+
+  for (val= *option_list; val; val= val->next)
+  {
     if (report_unknown_option(thd, val, suppress_warning))
       DBUG_RETURN(TRUE);
     val->parsed= true;
@@ -313,6 +356,102 @@ my_bool parse_option_list(THD* thd, void *option_struct_arg,
 
 
 /**
+  Resolves all HA_OPTION_TYPE_SYSVAR elements.
+
+  This is done when an engine is loaded.
+*/
+static bool resolve_sysvars(handlerton *hton, ha_create_table_option *rules)
+{
+  for (ha_create_table_option *opt= rules; opt && opt->name; opt++)
+  {
+    if (opt->type == HA_OPTION_TYPE_SYSVAR)
+    {
+      struct my_option optp;
+      plugin_opt_set_limits(&optp, opt->var);
+      switch(optp.var_type) {
+      case GET_ULL:
+      case GET_ULONG:
+      case GET_UINT:
+        opt->type= HA_OPTION_TYPE_ULL;
+        opt->def_value= (ulonglong)optp.def_value;
+        opt->min_value= (ulonglong)optp.min_value;
+        opt->max_value= (ulonglong)optp.max_value;
+        opt->block_size= (ulonglong)optp.block_size;
+        break;
+      case GET_STR:
+      case GET_STR_ALLOC:
+        opt->type= HA_OPTION_TYPE_STRING;
+        break;
+      case GET_BOOL:
+        opt->type= HA_OPTION_TYPE_BOOL;
+        opt->def_value= optp.def_value;
+        break;
+      case GET_ENUM:
+      {
+        opt->type= HA_OPTION_TYPE_ENUM;
+        opt->def_value= optp.def_value;
+
+        char buf[256];
+        String str(buf, sizeof(buf), system_charset_info);
+        for (const char **s= optp.typelib->type_names; *s; s++)
+        {
+          if (str.append(*s) || str.append(','))
+            return 1;
+        }
+        DBUG_ASSERT(str.length());
+        opt->values= my_strndup(str.ptr(), str.length()-1, MYF(MY_WME));
+        if (!opt->values)
+          return 1;
+        break;
+      }
+      default:
+        DBUG_ASSERT(0);
+      }
+    }
+  }
+  return 0;
+}
+
+bool resolve_sysvar_table_options(handlerton *hton)
+{
+  return resolve_sysvars(hton, hton->table_options) ||
+         resolve_sysvars(hton, hton->field_options) ||
+         resolve_sysvars(hton, hton->index_options);
+}
+
+/*
+  Restore HA_OPTION_TYPE_SYSVAR options back as they were
+  before resolve_sysvars().
+
+  This is done when the engine is unloaded, so that we could
+  call resolve_sysvars() if the engine is installed again.
+*/
+static void free_sysvars(handlerton *hton, ha_create_table_option *rules)
+{
+  for (ha_create_table_option *opt= rules; opt && opt->name; opt++)
+  {
+    if (opt->var)
+    {
+      my_free(const_cast<char*>(opt->values));
+      opt->type= HA_OPTION_TYPE_SYSVAR;
+      opt->def_value= 0;
+      opt->min_value= 0;
+      opt->max_value= 0;
+      opt->block_size= 0;
+      opt->values= 0;
+    }
+  }
+}
+
+void free_sysvar_table_options(handlerton *hton)
+{
+  free_sysvars(hton, hton->table_options);
+  free_sysvars(hton, hton->field_options);
+  free_sysvars(hton, hton->index_options);
+}
+
+
+/**
   Parses all table/fields/keys options
 
   @param thd             thread handler
@@ -323,27 +462,27 @@ my_bool parse_option_list(THD* thd, void *option_struct_arg,
   @retval FALSE OK
 */
 
-my_bool parse_engine_table_options(THD *thd, handlerton *ht,
-                                   TABLE_SHARE *share)
+bool parse_engine_table_options(THD *thd, handlerton *ht, TABLE_SHARE *share)
 {
   MEM_ROOT *root= &share->mem_root;
   DBUG_ENTER("parse_engine_table_options");
 
-  if (parse_option_list(thd, &share->option_struct, share->option_list,
+  if (parse_option_list(thd, ht, &share->option_struct, & share->option_list,
                         ht->table_options, TRUE, root))
     DBUG_RETURN(TRUE);
 
   for (Field **field= share->field; *field; field++)
   {
-    if (parse_option_list(thd, &(*field)->option_struct, (*field)->option_list,
+    if (parse_option_list(thd, ht, &(*field)->option_struct,
+                          & (*field)->option_list,
                           ht->field_options, TRUE, root))
       DBUG_RETURN(TRUE);
   }
 
   for (uint index= 0; index < share->keys; index ++)
   {
-    if (parse_option_list(thd, &share->key_info[index].option_struct,
-                          share->key_info[index].option_list,
+    if (parse_option_list(thd, ht, &share->key_info[index].option_struct,
+                          & share->key_info[index].option_list,
                           ht->index_options, TRUE, root))
       DBUG_RETURN(TRUE);
   }
@@ -543,8 +682,8 @@ uchar *engine_option_value::frm_read(const uchar *buff, engine_option_value **st
   @retval FALSE OK
 */
 
-my_bool engine_table_options_frm_read(const uchar *buff, uint length,
-                                      TABLE_SHARE *share)
+bool engine_table_options_frm_read(const uchar *buff, uint length,
+                                   TABLE_SHARE *share)
 {
   const uchar *buff_end= buff + length;
   engine_option_value *UNINIT_VAR(end);
diff --git a/sql/create_options.h b/sql/create_options.h
index ae918f6cea1..ea05bf75fac 100644
--- a/sql/create_options.h
+++ b/sql/create_options.h
@@ -69,16 +69,15 @@ class engine_option_value: public Sql_alloc
 typedef struct st_key KEY;
 class Create_field;
 
-my_bool parse_engine_table_options(THD *thd, handlerton *ht,
+bool resolve_sysvar_table_options(handlerton *hton);
+void free_sysvar_table_options(handlerton *hton);
+bool parse_engine_table_options(THD *thd, handlerton *ht, TABLE_SHARE *share);
+bool parse_option_list(THD* thd, handlerton *hton, void *option_struct,
+                       engine_option_value **option_list,
+                       ha_create_table_option *rules,
+                       bool suppress_warning, MEM_ROOT *root);
+bool engine_table_options_frm_read(const uchar *buff, uint length,
                                    TABLE_SHARE *share);
-my_bool parse_option_list(THD* thd, void *option_struct,
-                          engine_option_value *option_list,
-                          ha_create_table_option *rules,
-                          my_bool suppress_warning,
-                          MEM_ROOT *root);
-my_bool engine_table_options_frm_read(const uchar *buff,
-                                      uint length,
-                                      TABLE_SHARE *share);
 engine_option_value *merge_engine_table_options(engine_option_value *source,
                                                 engine_option_value *changes,
                                                 MEM_ROOT *root);
diff --git a/sql/datadict.cc b/sql/datadict.cc
index e3f679cc7ec..4bc74af7bdb 100644
--- a/sql/datadict.cc
+++ b/sql/datadict.cc
@@ -55,11 +55,14 @@ frm_type_enum dd_frm_type(THD *thd, char *path, enum legacy_db_type *dbt)
     if the following test is true (arg #3). This should not have effect
     on return value from this function (default FRMTYPE_TABLE)
   */
-  if (header[0] != (uchar) 254 || header[1] != 1 ||
-      (header[2] != FRM_VER && header[2] != FRM_VER+1 &&
-       (header[2] < FRM_VER+3 || header[2] > FRM_VER+4)))
+  if (!is_binary_frm_header(header))
     DBUG_RETURN(FRMTYPE_TABLE);
 
+  /*
+    XXX this is a bug.
+    if header[3] is > DB_TYPE_FIRST_DYNAMIC, then the complete
+    storage engine name must be read from the frm
+  */
   *dbt= (enum legacy_db_type) (uint) *(header + 3);
 
   /* Probably a table. */
@@ -67,117 +70,44 @@ frm_type_enum dd_frm_type(THD *thd, char *path, enum legacy_db_type *dbt)
 }
 
 
-/**
-  Given a table name, check type of .frm and legacy table type.
-
-  @param[in]   thd          The current session.
-  @param[in]   db           Table schema.
-  @param[in]   table_name   Table database.
-  @param[out]  table_type   handlerton of the table if FRMTYPE_TABLE,
-                            otherwise undefined.
-
-  @return FALSE if FRMTYPE_TABLE and storage engine found. TRUE otherwise.
-*/
-
-bool dd_frm_storage_engine(THD *thd, const char *db, const char *table_name,
-                           handlerton **table_type)
-{
-  char path[FN_REFLEN + 1];
-  enum legacy_db_type db_type;
-  LEX_STRING db_name = {(char *) db, strlen(db)};
-
-  /* There should be at least some lock on the table.  */
-  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db,
-                                             table_name, MDL_SHARED));
-
-  if (check_db_name(&db_name))
-  {
-    my_error(ER_WRONG_DB_NAME, MYF(0), db_name.str);
-    return TRUE;
-  }
-
-  if (check_table_name(table_name, strlen(table_name), FALSE))
-  {
-    my_error(ER_WRONG_TABLE_NAME, MYF(0), table_name);
-    return TRUE;
-  }
-
-  (void) build_table_filename(path, sizeof(path) - 1, db,
-                              table_name, reg_ext, 0);
-
-  dd_frm_type(thd, path, &db_type);
-
-  /* Type is unknown if the object is not found or is not a table. */
-  if (db_type == DB_TYPE_UNKNOWN ||
-      !(*table_type= ha_resolve_by_legacy_type(thd, db_type)))
-  {
-    my_error(ER_NO_SUCH_TABLE, MYF(0), db, table_name);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-
-/**
-  Given a table name, check if the storage engine for the
-  table referred by this name supports an option 'flag'.
-  Return an error if the table does not exist or is not a
-  base table.
-
-  @pre Any metadata lock on the table.
-
-  @param[in]    thd         The current session.
-  @param[in]    db          Table schema.
-  @param[in]    table_name  Table database.
-  @param[in]    flag        The option to check.
-  @param[out]   yes_no      The result. Undefined if error.
-*/
-
-bool dd_check_storage_engine_flag(THD *thd,
-                                  const char *db, const char *table_name,
-                                  uint32 flag, bool *yes_no)
-{
-  handlerton *table_type;
-
-  if (dd_frm_storage_engine(thd, db, table_name, &table_type))
-    return TRUE;
-
-  *yes_no= ha_check_storage_engine_flag(table_type, flag);
-
-  return FALSE;
-}
-
-
 /*
   Regenerate a metadata locked table.
 
   @param  thd   Thread context.
   @param  db    Name of the database to which the table belongs to.
   @param  name  Table name.
+  @param  path  For temporary tables only - path to table files.
+                Otherwise NULL (the path is calculated from db and table names).
 
   @retval  FALSE  Success.
   @retval  TRUE   Error.
 */
 
-bool dd_recreate_table(THD *thd, const char *db, const char *table_name)
+bool dd_recreate_table(THD *thd, const char *db, const char *table_name,
+                       const char *path)
 {
   bool error= TRUE;
   HA_CREATE_INFO create_info;
-  char path[FN_REFLEN + 1];
+  char path_buf[FN_REFLEN + 1];
   DBUG_ENTER("dd_recreate_table");
 
-  /* There should be a exclusive metadata lock on the table. */
-  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db, table_name,
-                                             MDL_EXCLUSIVE));
-
   memset(&create_info, 0, sizeof(create_info));
 
-  /* Create a path to the table, but without a extension. */
-  build_table_filename(path, sizeof(path) - 1, db, table_name, "", 0);
+  if (path)
+    create_info.options|= HA_LEX_CREATE_TMP_TABLE;
+  else
+  {
+    build_table_filename(path_buf, sizeof(path_buf) - 1,
+                         db, table_name, "", 0);
+    path= path_buf;
+
+    /* There should be a exclusive metadata lock on the table. */
+    DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db, table_name,
+                                               MDL_EXCLUSIVE));
+  }
 
   /* Attempt to reconstruct the table. */
-  error= ha_create_table(thd, path, db, table_name, &create_info, TRUE);
+  error= ha_create_table(thd, path, db, table_name, &create_info, NULL);
 
   DBUG_RETURN(error);
 }
diff --git a/sql/datadict.h b/sql/datadict.h
index f852b02f52c..dd80942daca 100644
--- a/sql/datadict.h
+++ b/sql/datadict.h
@@ -28,14 +28,22 @@ enum frm_type_enum
   FRMTYPE_VIEW
 };
 
+/*
+  Take extra care when using dd_frm_type() - it only checks the .frm file,
+  and it won't work for any engine that supports discovery.
+
+  Prefer to use ha_table_exists() instead.
+  To check whether it's an frm of a view, use dd_frm_is_view().
+*/
 frm_type_enum dd_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
 
-bool dd_frm_storage_engine(THD *thd, const char *db, const char *table_name,
-                           handlerton **table_type);
-bool dd_check_storage_engine_flag(THD *thd,
-                                  const char *db, const char *table_name,
-                                  uint32 flag,
-                                  bool *yes_no);
-bool dd_recreate_table(THD *thd, const char *db, const char *table_name);
+static inline bool dd_frm_is_view(THD *thd, char *path)
+{
+  enum legacy_db_type not_used;
+  return dd_frm_type(thd, path, &not_used) == FRMTYPE_VIEW;
+}
+
+bool dd_recreate_table(THD *thd, const char *db, const char *table_name,
+                       const char *path = NULL);
 
 #endif // DATADICT_INCLUDED
diff --git a/sql/discover.cc b/sql/discover.cc
index b9dba92a780..4224e8ce0b0 100644
--- a/sql/discover.cc
+++ b/sql/discover.cc
@@ -45,7 +45,7 @@
     3    Could not allocate data for read.  Could not read file
 */
 
-int readfrm(const char *name, uchar **frmdata, size_t *len)
+int readfrm(const char *name, const uchar **frmdata, size_t *len)
 {
   int    error;
   char	 index_file[FN_REFLEN];
@@ -70,13 +70,17 @@ int readfrm(const char *name, uchar **frmdata, size_t *len)
   error= 2;
   if (mysql_file_fstat(file, &state, MYF(0)))
     goto err;
-  read_len= (size_t)state.st_size;  
+  read_len= (size_t)min(FRM_MAX_SIZE, state.st_size); // safety
 
   // Read whole frm file
   error= 3;
-  read_data= 0;                                 // Nothing to free
-  if (read_string(file, &read_data, read_len))
+  if (!(read_data= (uchar*)my_malloc(read_len, MYF(MY_WME))))
     goto err;
+  if (mysql_file_read(file, read_data, read_len, MYF(MY_NABP)))
+  {
+    my_free(read_data);
+    goto err;
+  }
 
   // Setup return data
   *frmdata= (uchar*) read_data;
@@ -96,7 +100,7 @@ int readfrm(const char *name, uchar **frmdata, size_t *len)
   Write the content of a frm data pointer 
   to a frm file.
 
-  @param name           path to table-file "db/name"
+  @param path           path to table-file "db/name"
   @param frmdata        frm data
   @param len            length of the frmdata
 
@@ -106,29 +110,167 @@ int readfrm(const char *name, uchar **frmdata, size_t *len)
     2    Could not write file
 */
 
-int writefrm(const char *name, const uchar *frmdata, size_t len)
+int writefrm(const char *path, const char *db, const char *table,
+             bool tmp_table, const uchar *frmdata, size_t len)
 {
-  File file;
-  char	 index_file[FN_REFLEN];
+  char	 file_name[FN_REFLEN+1];
   int error;
+  int create_flags= O_RDWR | O_TRUNC;
   DBUG_ENTER("writefrm");
-  DBUG_PRINT("enter",("name: '%s' len: %lu ",name, (ulong) len));
+  DBUG_PRINT("enter",("name: '%s' len: %lu ",path, (ulong) len));
 
-  error= 0;
-  if ((file= mysql_file_create(key_file_frm,
-                               fn_format(index_file, name, "", reg_ext,
-                                         MY_UNPACK_FILENAME | MY_APPEND_EXT),
-                               CREATE_MODE, O_RDWR | O_TRUNC,
-                               MYF(MY_WME))) >= 0)
+  if (tmp_table)
+    create_flags|= O_EXCL | O_NOFOLLOW;
+
+  strxnmov(file_name, sizeof(file_name)-1, path, reg_ext, NullS);
+
+  File file= mysql_file_create(key_file_frm, file_name,
+                               CREATE_MODE, create_flags, MYF(0));
+
+  if ((error= file < 0))
   {
-    if (mysql_file_write(file, frmdata, len, MYF(MY_WME | MY_NABP)))
-      error= 2;
-    (void) mysql_file_close(file, MYF(0));
+    if (my_errno == ENOENT)
+      my_error(ER_BAD_DB_ERROR, MYF(0), db);
+    else
+      my_error(ER_CANT_CREATE_TABLE, MYF(0), db, table, my_errno);
+  }
+  else
+  {
+    error= mysql_file_write(file, frmdata, len, MYF(MY_WME | MY_NABP));
+
+    if (!error && !tmp_table && opt_sync_frm)
+        error= mysql_file_sync(file, MYF(MY_WME)) ||
+             my_sync_dir_by_file(file_name, MYF(MY_WME));
+
+    error|= mysql_file_close(file, MYF(MY_WME));
   }
   DBUG_RETURN(error);
 } /* writefrm */
 
+static inline void advance(FILEINFO* &from, FILEINFO* &to,
+                           FILEINFO* cur, bool &skip)
+{
+  if (skip)                   // if not copying
+    from= cur;                //   just advance the start pointer
+  else                        // if copying
+    if (to == from)           //   but to the same place (not shifting the data)
+      from= to= cur;          //     advance both pointers
+    else                      //   otherwise
+      while (from < cur)      //     have to copy [from...cur) to [to...)
+        *to++ = *from++;
+  skip= false;
+}
 
+/**
+  Go through the directory listing looking for files with a specified
+  extension and add them to the result list
+
+  @details
+  This function may be called many times on the same directory listing
+  but with different extensions. To avoid discovering the same table twice,
+  whenever a table file is discovered, all files with the same name
+  (independently from the extensions) are removed from the list.
 
+  Example: the list contained
+     { "db.opt", "t1.MYD", "t1.MYI", "t1.frm", "t2.ARZ", "t3.ARZ", "t3.frm" }
+  on discovering all ".frm" files, tables "t1" and "t3" will be found,
+  and list will become
+     { "db.opt", "t2.ARZ" }
+  and now ".ARZ" discovery can discover the table "t2"
 
+  @note
+  This function assumes that the directory listing is sorted alphabetically.
+
+  @note  Partitioning makes this more complicated. A partitioned table t1 might
+  have files, like t1.frm, t1#P#part1.ibd, t1#P#foo.ibd, etc.
+  That means we need to compare file names only up to the first '#' or '.'
+  whichever comes first.
+*/
+int extension_based_table_discovery(MY_DIR *dirp, const char *ext_meta,
+                                    handlerton::discovered_list *result)
+{
+  CHARSET_INFO *cs= character_set_filesystem;
+  size_t ext_meta_len= strlen(ext_meta);
+  FILEINFO *from, *to, *cur, *end;
+  bool skip= false;
+  
+  from= to= cur= dirp->dir_entry;
+  end= cur + dirp->number_of_files;
+  while (cur < end)
+  {
+    char *octothorp= strrchr(cur->name, '#');
+    char *ext= strchr(octothorp ? octothorp : cur->name, FN_EXTCHAR);
+
+    if (ext && octothorp != cur->name)
+    {
+      size_t len= (octothorp ? octothorp : ext) - cur->name;
+      if (from != cur &&
+          (my_strnncoll(cs, (uchar*)from->name, len, (uchar*)cur->name, len) ||
+           (from->name[len] != FN_EXTCHAR && from->name[len] != '#')))
+        advance(from, to, cur, skip);
+
+      if (my_strnncoll(cs, (uchar*)ext, strlen(ext),
+                           (uchar*)ext_meta, ext_meta_len) == 0)
+      {
+        *ext = 0;
+        if (result->add_file(cur->name))
+          return 1;
+        *ext = FN_EXTCHAR;
+        skip= true; // table discovered, skip all files with the same name
+      }
+    }
+    else
+    {
+      advance(from, to, cur, skip);
+      from++;
+    }
+
+    cur++;
+  }
+  advance(from, to, cur, skip);
+  dirp->number_of_files= to - dirp->dir_entry;
+  return 0;
+}
+
+/**
+  Simple, not reusable file-based table discovery
+
+  @details
+  simplified version of extension_based_table_discovery(), that does not
+  modify the list of files. It cannot be called many times for the same
+  directory listing, otherwise it'll produce duplicate results.
+
+  @note
+  For backward compatibility reasons, this will find tables with names,
+  starting from '#', as long as they don't start from '#sql-'.
+  These names are invalid since 5.0, and the compex discovery function
+  will ignore them. Anyone still having these files, should disable
+  discovering engines, and rename these invalid table files.
+*/
+int ext_table_discovery_simple(MY_DIR *dirp,
+                               handlerton::discovered_list *result)
+{
+  CHARSET_INFO *cs= character_set_filesystem;
+  FILEINFO *cur, *end;
+  
+  cur= dirp->dir_entry;
+  end= cur + dirp->number_of_files;
+  while (cur < end)
+  {
+    char *ext= strrchr(cur->name, FN_EXTCHAR);
+
+    if (ext && !is_prefix(cur->name, tmp_file_prefix))
+    {
+      if (my_strnncoll(cs, (uchar*)ext, strlen(ext),
+                           (uchar*)reg_ext, reg_ext_length) == 0)
+      {
+        *ext = 0;
+        if (result->add_file(cur->name))
+          return 1;
+      }
+    }
+    cur++;
+  }
+  return 0;
+}
 
diff --git a/sql/discover.h b/sql/discover.h
index a663e44128d..fbf94891c74 100644
--- a/sql/discover.h
+++ b/sql/discover.h
@@ -18,7 +18,16 @@
 
 #include "my_global.h"                          /* uchar */
 
-int readfrm(const char *name, uchar **data, size_t *length);
-int writefrm(const char* name, const uchar* data, size_t len);
+int extension_based_table_discovery(MY_DIR *dirp, const char *ext,
+                                    handlerton::discovered_list *tl);
+
+#ifdef MYSQL_SERVER
+int readfrm(const char *name, const uchar **data, size_t *length);
+int writefrm(const char *path, const char *db, const char *table,
+             bool tmp_table, const uchar *frmdata, size_t len);
+
+int ext_table_discovery_simple(MY_DIR *dirp,
+                               handlerton::discovered_list *result);
+#endif
 
 #endif /* DISCOVER_INCLUDED */
diff --git a/sql/event_scheduler.cc b/sql/event_scheduler.cc
index ec96ca45a0e..6317af1eac3 100644
--- a/sql/event_scheduler.cc
+++ b/sql/event_scheduler.cc
@@ -132,11 +132,11 @@ post_init_event_thread(THD *thd)
     return TRUE;
   }
 
+  thread_safe_increment32(&thread_count, &thread_count_lock);
   mysql_mutex_lock(&LOCK_thread_count);
   threads.append(thd);
-  thread_count++;
-  inc_thread_running();
   mysql_mutex_unlock(&LOCK_thread_count);
+  inc_thread_running();
   return FALSE;
 }
 
@@ -154,12 +154,8 @@ deinit_event_thread(THD *thd)
 {
   thd->proc_info= "Clearing";
   DBUG_PRINT("exit", ("Event thread finishing"));
-  mysql_mutex_lock(&LOCK_thread_count);
-  thread_count--;
-  dec_thread_running();
-  delete thd;
-  mysql_cond_broadcast(&COND_thread_count);
-  mysql_mutex_unlock(&LOCK_thread_count);
+
+  delete_running_thd(thd);
 }
 
 
@@ -440,12 +436,7 @@ Event_scheduler::start()
     ret= TRUE;
 
     new_thd->proc_info= "Clearing";
-    mysql_mutex_lock(&LOCK_thread_count);
-    thread_count--;
-    dec_thread_running();
-    delete new_thd;
-    mysql_cond_broadcast(&COND_thread_count);
-    mysql_mutex_unlock(&LOCK_thread_count);
+    delete_running_thd(new_thd);
   }
 end:
   UNLOCK_DATA();
@@ -574,12 +565,7 @@ error:
   if (new_thd)
   {
     new_thd->proc_info= "Clearing";
-    mysql_mutex_lock(&LOCK_thread_count);
-    thread_count--;
-    dec_thread_running();
-    delete new_thd;
-    mysql_cond_broadcast(&COND_thread_count);
-    mysql_mutex_unlock(&LOCK_thread_count);
+    delete_running_thd(new_thd);
   }
   delete event_name;
   DBUG_RETURN(TRUE);
diff --git a/sql/field.cc b/sql/field.cc
index 1769e4e55cb..460a3bd514b 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2008, 2011, Monty Program Ab
+   Copyright (c) 2008, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -68,7 +68,7 @@ const char field_separator=',';
 #define LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE 128
 #define DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE 128
 #define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
-((ulong) ((LL(1) << min(arg, 4) * 8) - LL(1)))
+((ulong) ((1LL << min(arg, 4) * 8) - 1))
 
 #define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index)))
 #define ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED DBUG_ASSERT(is_stat_field || !table || (!table->write_set || bitmap_is_set(table->write_set, field_index) || bitmap_is_set(table->vcol_set, field_index)))
@@ -199,7 +199,7 @@ static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
     MYSQL_TYPE_LONG,         MYSQL_TYPE_VARCHAR,
   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
-    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
+    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONG,
   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
     MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
@@ -230,7 +230,7 @@ static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_VARCHAR,
   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
-    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_INT24,
+    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_FLOAT,
   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
     MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
@@ -261,7 +261,7 @@ static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VARCHAR,
   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
-    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_INT24,
+    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
     MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
@@ -292,7 +292,7 @@ static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
     MYSQL_TYPE_NULL,        MYSQL_TYPE_TIMESTAMP,
   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
-    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
+    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONGLONG,
   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
     MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_TIME,
   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
@@ -3643,7 +3643,7 @@ int Field_long::store(longlong nr, bool unsigned_val)
       res=0;
       error= 1;
     }
-    else if ((ulonglong) nr >= (LL(1) << 32))
+    else if ((ulonglong) nr >= (1LL << 32))
     {
       res=(int32) (uint32) ~0L;
       error= 1;
@@ -4577,7 +4577,7 @@ int Field_timestamp::store(longlong nr, bool unsigned_val)
   longlong tmp= number_to_datetime(nr, 0, &l_time, (thd->variables.sql_mode &
                                                  MODE_NO_ZERO_DATE) |
                                    MODE_NO_ZERO_IN_DATE, &error);
-  return store_TIME_with_warning(thd, &l_time, &str, error, tmp != LL(-1));
+  return store_TIME_with_warning(thd, &l_time, &str, error, tmp != -1);
 }
 
 
@@ -5793,8 +5793,8 @@ String *Field_datetime::val_str(String *val_buffer,
     Avoid problem with slow longlong arithmetic and sprintf
   */
 
-  part1=(long) (tmp/LL(1000000));
-  part2=(long) (tmp - (ulonglong) part1*LL(1000000));
+  part1=(long) (tmp/1000000LL);
+  part2=(long) (tmp - (ulonglong) part1*1000000LL);
 
   pos=(char*) val_buffer->ptr() + MAX_DATETIME_WIDTH;
   *pos--=0;
@@ -5825,8 +5825,8 @@ bool Field_datetime::get_date(MYSQL_TIME *ltime, ulonglong fuzzydate)
 {
   longlong tmp=Field_datetime::val_int();
   uint32 part1,part2;
-  part1=(uint32) (tmp/LL(1000000));
-  part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
+  part1=(uint32) (tmp/1000000LL);
+  part2=(uint32) (tmp - (ulonglong) part1*1000000LL);
 
   ltime->time_type=	MYSQL_TIMESTAMP_DATETIME;
   ltime->neg=		0;
@@ -7617,6 +7617,19 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
     if (wkb_type < (uint32) Geometry::wkb_point ||
 	wkb_type > (uint32) Geometry::wkb_last)
       goto err;
+
+    if (geom_type != Field::GEOM_GEOMETRY && 
+        geom_type != Field::GEOM_GEOMETRYCOLLECTION &&
+        (uint32) geom_type != wkb_type)
+    {
+      my_printf_error(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
+          ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD), MYF(0),
+          Geometry::ci_collection[geom_type]->m_name.str,
+          Geometry::ci_collection[wkb_type]->m_name.str, field_name,
+          (ulong) table->in_use->warning_info->current_row_for_warning());
+      goto err_exit;
+    }
+
     Field_blob::store_length(length);
     if (table->copy_blobs || length <= MAX_FIELD_WIDTH)
     {						// Must make a copy
@@ -7628,9 +7641,10 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
   return 0;
 
 err:
-  bzero(ptr, Field_blob::pack_length());  
   my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
              ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
+err_exit:
+  bzero(ptr, Field_blob::pack_length());  
   return -1;
 }
 
@@ -7893,7 +7907,7 @@ int Field_set::store(longlong nr, bool unsigned_val)
   if (sizeof(ulonglong)*8 <= typelib->count)
     max_nr= ULONGLONG_MAX;
   else
-    max_nr= (ULL(1) << typelib->count) - 1;
+    max_nr= (1ULL << typelib->count) - 1;
 
   if ((ulonglong) nr > max_nr)
   {
@@ -8870,6 +8884,7 @@ void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
                        FLAGSTR(pack_flag, FIELDFLAG_DECIMAL),
                        f_packtype(pack_flag)));
   vcol_info= 0;
+  create_if_not_exists= FALSE;
   stored_in_db= TRUE;
 
   DBUG_VOID_RETURN;
@@ -8907,7 +8922,7 @@ bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
                         char *fld_change, List<String> *fld_interval_list,
                         CHARSET_INFO *fld_charset, uint fld_geom_type,
 			Virtual_column_info *fld_vcol_info,
-                        engine_option_value *create_opt)
+                        engine_option_value *create_opt, bool check_exists)
 {
   uint sign_len, allowed_type_modifier= 0;
   ulong max_field_charlength= MAX_FIELD_CHARLENGTH;
@@ -8961,6 +8976,7 @@ bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
 
   comment= *fld_comment;
   vcol_info= fld_vcol_info;
+  create_if_not_exists= check_exists;
   stored_in_db= TRUE;
 
   /* Initialize data for a computed field */
@@ -9567,6 +9583,7 @@ Create_field::Create_field(Field *old_field,Field *orig_field)
   comment=    old_field->comment;
   decimals=   old_field->decimals();
   vcol_info=  old_field->vcol_info;
+  create_if_not_exists= FALSE;
   stored_in_db= old_field->stored_in_db;
   option_list= old_field->option_list;
   option_struct= old_field->option_struct;
diff --git a/sql/field.h b/sql/field.h
index e832928b114..d03479bbd06 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -2151,6 +2151,7 @@ public:
   bool has_charset(void) const { return TRUE; }
   /* enum and set are sorted as integers */
   CHARSET_INFO *sort_charset(void) const { return &my_charset_bin; }
+  uint decimals() const { return 0; }
 
   virtual uchar *pack(uchar *to, const uchar *from, uint max_length);
   virtual const uchar *unpack(uchar *to, const uchar *from,
@@ -2382,10 +2383,11 @@ public:
   /** structure with parsed options (for comparing fields in ALTER TABLE) */
   ha_field_option_struct *option_struct;
 
-  uint8 row,col,sc_length,interval_id;	// For rea_create_table
+  uint8 interval_id;                    // For rea_create_table
   uint	offset,pack_flag;
+  bool create_if_not_exists;            // Used in ALTER TABLE IF NOT EXISTS
 
-    /* 
+  /* 
     This is additinal data provided for any computed(virtual) field.
     In particular it includes a pointer to the item by  which this field
     can be computed from other fields.
@@ -2398,7 +2400,8 @@ public:
   */
   bool stored_in_db;
 
-  Create_field() :after(0), option_list(NULL), option_struct(NULL)
+  Create_field() :after(0), option_list(NULL), option_struct(NULL),
+                  create_if_not_exists(FALSE)
   {}
   Create_field(Field *field, Field *orig_field);
   /* Used to make a clone of this object for ALTER/CREATE TABLE */
@@ -2416,7 +2419,7 @@ public:
             Item *on_update_value, LEX_STRING *comment, char *change,
             List<String> *interval_list, CHARSET_INFO *cs,
             uint uint_geom_type, Virtual_column_info *vcol_info,
-            engine_option_value *option_list);
+            engine_option_value *option_list, bool check_exists);
 
   bool field_flags_are_binary()
   {
diff --git a/sql/filesort.cc b/sql/filesort.cc
index 49aaa0af574..6f8867e8d64 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -952,7 +952,10 @@ static void make_sortkey(register Sort_param *param,
           {
             MYSQL_TIME buf;
             if (item->get_date_result(&buf, TIME_FUZZY_DATE | TIME_INVALID_DATES))
-              DBUG_ASSERT(maybe_null && item->null_value);
+            {
+              DBUG_ASSERT(maybe_null);
+              DBUG_ASSERT(item->null_value);
+            }
             else
               value= pack_time(&buf);
           }
diff --git a/sql/frm_crypt.cc b/sql/frm_crypt.cc
deleted file mode 100644
index 5612908aea5..00000000000
--- a/sql/frm_crypt.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
-
-
-/*
-** change the following to the output of password('our password')
-** split into 2 parts of 8 characters each.
-** This is done to make it impossible to search after a text string in the
-** mysql binary.
-*/
-
-#include "sql_priv.h"
-#include "frm_crypt.h"
-
-#ifdef HAVE_CRYPTED_FRM
-
-/* password('test') */
-ulong password_seed[2]={0x378b243e, 0x220ca493};
-
-SQL_CRYPT *get_crypt_for_frm(void)
-{
-  return new SQL_CRYPT(password_seed);
-}
-
-#endif
diff --git a/sql/frm_crypt.h b/sql/frm_crypt.h
deleted file mode 100644
index 0605644b3e0..00000000000
--- a/sql/frm_crypt.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
-
-#ifndef FRM_CRYPT_INCLUDED
-#define FRM_CRYPT_INCLUDED
-
-class SQL_CRYPT;
-
-SQL_CRYPT *get_crypt_for_frm(void);
-
-#endif /* FRM_CRYPT_INCLUDED */
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index 148a2329660..bd08cd2dc32 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -78,6 +78,17 @@ static handler *partition_create_handler(handlerton *hton,
 static uint partition_flags();
 static uint alter_table_flags(uint flags);
 
+/*
+  If frm_error() is called then we will use this to to find out what file
+  extensions exist for the storage engine. This is also used by the default
+  rename_table and delete_table method in handler.cc.
+*/
+
+static const char *ha_partition_ext[]=
+{
+  ha_par_ext, NullS
+};
+
 
 static int partition_initialize(void *p)
 {
@@ -93,6 +104,7 @@ static int partition_initialize(void *p)
   partition_hton->flags= HTON_NOT_USER_SELECTABLE |
                          HTON_HIDDEN |
                          HTON_TEMPORARY_NOT_SUPPORTED;
+  partition_hton->tablefile_extensions= ha_partition_ext;
 
   return 0;
 }
@@ -499,7 +511,7 @@ int ha_partition::rename_table(const char *from, const char *to)
   Create the handler file (.par-file)
 
   SYNOPSIS
-    create_handler_files()
+    create_partitioning_metadata()
     name                              Full path of table name
     create_info                       Create info generated for CREATE TABLE
 
@@ -508,19 +520,18 @@ int ha_partition::rename_table(const char *from, const char *to)
     0                         Success
 
   DESCRIPTION
-    create_handler_files is called to create any handler specific files
+    create_partitioning_metadata is called to create any handler specific files
     before opening the file with openfrm to later call ::create on the
     file object.
     In the partition handler this is used to store the names of partitions
     and types of engines in the partitions.
 */
 
-int ha_partition::create_handler_files(const char *path,
+int ha_partition::create_partitioning_metadata(const char *path,
                                        const char *old_path,
-                                       int action_flag,
-                                       HA_CREATE_INFO *create_info)
+                                       int action_flag)
 {
-  DBUG_ENTER("ha_partition::create_handler_files()");
+  DBUG_ENTER("ha_partition::create_partitioning_metadata()");
 
   /*
     We need to update total number of parts since we might write the handler
@@ -3830,6 +3841,7 @@ int ha_partition::truncate_partition(Alter_info *alter_info, bool *binlog_stmt)
                               part, sub_elem->partition_name));
           if ((error= m_file[part]->ha_truncate()))
             break;
+          sub_elem->part_state= PART_NORMAL;
         } while (++j < num_subparts);
       }
       else
@@ -4428,6 +4440,7 @@ bool ha_partition::init_record_priority_queue()
     {
       if (bitmap_is_set(&m_part_info->used_partitions, i))
       {
+        DBUG_PRINT("info", ("init rec-buf for part %u", i));
         int2store(ptr, i);
         ptr+= m_rec_length + PARTITION_BYTES_IN_POS;
       }
@@ -5322,11 +5335,27 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
   m_top_entry= NO_CURRENT_PART_ID;
   queue_remove_all(&m_queue);
 
-  DBUG_PRINT("info", ("m_part_spec.start_part %d", m_part_spec.start_part));
-  for (i= m_part_spec.start_part; i <= m_part_spec.end_part; i++)
+  /*
+    Position part_rec_buf_ptr to point to the first used partition >=
+    start_part. There may be partitions marked by used_partitions,
+    but is before start_part. These partitions has allocated record buffers
+    but is dynamically pruned, so those buffers must be skipped.
+  */
+  uint first_used_part= bitmap_get_first_set(&m_part_info->used_partitions);
+  for (; first_used_part < m_part_spec.start_part; first_used_part++)
+  {
+    if (bitmap_is_set(&(m_part_info->used_partitions), first_used_part))
+      part_rec_buf_ptr+= m_rec_length + PARTITION_BYTES_IN_POS;
+  }
+  DBUG_PRINT("info", ("m_part_spec.start_part %u first_used_part %u",
+                      m_part_spec.start_part, first_used_part));
+  for (i= first_used_part; i <= m_part_spec.end_part; i++)
   {
     if (!(bitmap_is_set(&(m_part_info->used_partitions), i)))
       continue;
+    DBUG_PRINT("info", ("reading from part %u (scan_type: %u)",
+                        i, m_index_scan_type));
+    DBUG_ASSERT(i == uint2korr(part_rec_buf_ptr));
     uchar *rec_buf_ptr= part_rec_buf_ptr + PARTITION_BYTES_IN_POS;
     int error;
     handler *file= m_file[i];
@@ -7322,21 +7351,6 @@ int ha_partition::final_drop_index(TABLE *table_arg)
 }
 
 
-/*
-  If frm_error() is called then we will use this to to find out what file
-  extensions exist for the storage engine. This is also used by the default
-  rename_table and delete_table method in handler.cc.
-*/
-
-static const char *ha_partition_ext[]=
-{
-  ha_par_ext, NullS
-};
-
-const char **ha_partition::bas_ext() const
-{ return ha_partition_ext; }
-
-
 uint ha_partition::min_of_the_max_uint(
                        uint (handler::*operator_func)(void) const) const
 {
diff --git a/sql/ha_partition.h b/sql/ha_partition.h
index 96e47d3d676..55f199401f3 100644
--- a/sql/ha_partition.h
+++ b/sql/ha_partition.h
@@ -229,7 +229,7 @@ public:
     chance for the handler to add any interesting comments to the table
     comments not provided by the users comment.
 
-    create_handler_files is called before opening a new handler object
+    create_partitioning_metadata is called before opening a new handler object
     with openfrm to call create. It is used to create any local handler
     object needed in opening the object in openfrm
     -------------------------------------------------------------------------
@@ -238,9 +238,8 @@ public:
   virtual int rename_table(const char *from, const char *to);
   virtual int create(const char *name, TABLE *form,
 		     HA_CREATE_INFO *create_info);
-  virtual int create_handler_files(const char *name,
-                                   const char *old_name, int action_flag,
-                                   HA_CREATE_INFO *create_info);
+  virtual int create_partitioning_metadata(const char *name,
+                                   const char *old_name, int action_flag);
   virtual void update_create_info(HA_CREATE_INFO *create_info);
   virtual char *update_table_comment(const char *comment);
   virtual int change_partitions(HA_CREATE_INFO *create_info,
@@ -885,10 +884,6 @@ public:
   */
   virtual uint alter_table_flags(uint flags);
   /*
-     extensions of table handler files
-  */
-  virtual const char **bas_ext() const;
-  /*
     unireg.cc will call the following to make sure that the storage engine
     can handle the data it is about to send.
 
diff --git a/sql/handler.cc b/sql/handler.cc
index 5297a8e8cfc..398b6b5c8b1 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -30,7 +30,7 @@
 #include "sql_parse.h"                          // check_stack_overrun
 #include "sql_acl.h"            // SUPER_ACL
 #include "sql_base.h"           // free_io_cache
-#include "discover.h"           // writefrm
+#include "discover.h"           // extension_based_table_discovery, etc
 #include "log_event.h"          // *_rows_log_event
 #include "create_options.h"
 #include "rpl_filter.h"
@@ -229,13 +229,6 @@ handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
 
   (void) RUN_HOOK(transaction, after_rollback, (thd, FALSE));
 
-  switch (database_type) {
-  case DB_TYPE_MRG_ISAM:
-    return ha_resolve_by_legacy_type(thd, DB_TYPE_MRG_MYISAM);
-  default:
-    break;
-  }
-
   return ha_default_handlerton(thd);
 } /* ha_checktype */
 
@@ -388,6 +381,34 @@ static int ha_finish_errors(void)
   return 0;
 }
 
+static volatile int32 need_full_discover_for_existence= 0;
+static volatile int32 engines_with_discover_table_names= 0;
+
+static int full_discover_for_existence(handlerton *, const char *, const char *)
+{ return 1; }
+
+static int ext_based_existence(handlerton *, const char *, const char *)
+{ return 1; }
+
+static int hton_ext_based_table_discovery(handlerton *hton, LEX_STRING *db,
+                             MY_DIR *dir, handlerton::discovered_list *result)
+{
+  /*
+    tablefile_extensions[0] is the metadata file, see
+    the comment above tablefile_extensions declaration
+  */
+  return extension_based_table_discovery(dir, hton->tablefile_extensions[0],
+                                         result);
+}
+
+static void update_discovery_counters(handlerton *hton, int val)
+{
+  if (hton->discover_table_existence == full_discover_for_existence)
+    my_atomic_add32(&need_full_discover_for_existence,  val);
+
+  if (hton->discover_table_names)
+    my_atomic_add32(&engines_with_discover_table_names, val);
+}
 
 int ha_finalize_handlerton(st_plugin_int *plugin)
 {
@@ -425,6 +446,9 @@ int ha_finalize_handlerton(st_plugin_int *plugin)
     }
   }
 
+  free_sysvar_table_options(hton);
+  update_discovery_counters(hton, -1);
+
   /*
     In case a plugin is uninstalled and re-installed later, it should
     reuse an array slot. Otherwise the number of uninstall/install
@@ -448,12 +472,12 @@ int ha_finalize_handlerton(st_plugin_int *plugin)
 int ha_initialize_handlerton(st_plugin_int *plugin)
 {
   handlerton *hton;
+  static const char *no_exts[]= { 0 };
   DBUG_ENTER("ha_initialize_handlerton");
   DBUG_PRINT("plugin", ("initialize plugin: '%s'", plugin->name.str));
 
   hton= (handlerton *)my_malloc(sizeof(handlerton),
                                 MYF(MY_WME | MY_ZEROFILL));
-
   if (hton == NULL)
   {
     sql_print_error("Unable to allocate memory for plugin '%s' handlerton.",
@@ -461,6 +485,9 @@ int ha_initialize_handlerton(st_plugin_int *plugin)
     goto err_no_hton_memory;
   }
 
+  hton->tablefile_extensions= no_exts;
+  hton->discover_table_names= hton_ext_based_table_discovery;
+
   hton->slot= HA_SLOT_UNDEF;
   /* Historical Requirement */
   plugin->data= hton; // shortcut for the future
@@ -471,6 +498,21 @@ int ha_initialize_handlerton(st_plugin_int *plugin)
     goto err;
   }
 
+  // hton_ext_based_table_discovery() works only when discovery
+  // is supported and the engine if file-based.
+  if (hton->discover_table_names == hton_ext_based_table_discovery &&
+      (!hton->discover_table || !hton->tablefile_extensions[0]))
+    hton->discover_table_names= NULL;
+
+  // default discover_table_existence implementation
+  if (!hton->discover_table_existence && hton->discover_table)
+  {
+    if (hton->tablefile_extensions[0])
+      hton->discover_table_existence= ext_based_existence;
+    else
+      hton->discover_table_existence= full_discover_for_existence;
+  }
+
   /*
     the switch below and hton->state should be removed when
     command-line options for plugins will be implemented
@@ -560,6 +602,9 @@ int ha_initialize_handlerton(st_plugin_int *plugin)
     break;
   };
 
+  resolve_sysvar_table_options(hton);
+  update_discovery_counters(hton, 1);
+
   DBUG_RETURN(0);
 
 err_deinit:
@@ -1096,7 +1141,8 @@ int ha_prepare(THD *thd)
       else
       {
         push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
+                            ER_GET_ERRNO, ER(ER_GET_ERRNO),
+                            HA_ERR_WRONG_COMMAND,
                             ha_resolve_storage_engine_name(ht));
       }
     }
@@ -1967,7 +2013,7 @@ int ha_savepoint(THD *thd, SAVEPOINT *sv)
     }
     if ((err= ht->savepoint_set(ht, thd, (uchar *)(sv+1)+ht->savepoint_offset)))
     { // cannot happen
-      my_error(ER_GET_ERRNO, MYF(0), err);
+      my_error(ER_GET_ERRNO, MYF(0), err, hton_name(ht)->str);
       error=1;
     }
     status_var_increment(thd->status_var.ha_savepoint_count);
@@ -1998,7 +2044,7 @@ int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
     if ((err= ht->savepoint_release(ht, thd,
                                     (uchar *)(sv+1) + ht->savepoint_offset)))
     { // cannot happen
-      my_error(ER_GET_ERRNO, MYF(0), err);
+      my_error(ER_GET_ERRNO, MYF(0), err, hton_name(ht)->str);
       error=1;
     }
   }
@@ -2172,15 +2218,15 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
   TABLE_SHARE dummy_share;
   DBUG_ENTER("ha_delete_table");
 
+  /* table_type is NULL in ALTER TABLE when renaming only .frm files */
+  if (table_type == NULL || table_type == view_pseudo_hton ||
+      ! (file=get_new_handler((TABLE_SHARE*)0, thd->mem_root, table_type)))
+    DBUG_RETURN(HA_ERR_NO_SUCH_TABLE);
+
   bzero((char*) &dummy_table, sizeof(dummy_table));
   bzero((char*) &dummy_share, sizeof(dummy_share));
   dummy_table.s= &dummy_share;
 
-  /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
-  if (table_type == NULL ||
-      ! (file=get_new_handler((TABLE_SHARE*)0, thd->mem_root, table_type)))
-    DBUG_RETURN(ENOENT);
-
   path= get_canonical_filename(file, path, tmp_path);
   if ((error= file->ha_delete_table(path)) && generate_warning)
   {
@@ -2195,6 +2241,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
     /* Fill up strucutures that print_error may need */
     dummy_share.path.str= (char*) path;
     dummy_share.path.length= strlen(path);
+    dummy_share.normalized_path= dummy_share.path;
     dummy_share.db.str= (char*) db;
     dummy_share.db.length= strlen(db);
     dummy_share.table_name.str= (char*) alias;
@@ -3122,7 +3169,7 @@ void handler::print_error(int error, myf errflag)
   DBUG_ENTER("handler::print_error");
   DBUG_PRINT("enter",("error: %d",error));
 
-  int textno=ER_GET_ERRNO;
+  int textno= -1; // impossible value
   switch (error) {
   case EACCES:
     textno=ER_OPEN_AS_READONLY;
@@ -3235,7 +3282,9 @@ void handler::print_error(int error, myf errflag)
     textno=ER_OUT_OF_RESOURCES;
     break;
   case HA_ERR_WRONG_COMMAND:
-    textno=ER_ILLEGAL_HA;
+    my_error(ER_ILLEGAL_HA, MYF(0), table_type(), table_share->db.str,
+             table_share->table_name.str);
+    DBUG_VOID_RETURN;
     break;
   case HA_ERR_OLD_FILE:
     textno=ER_OLD_KEYFILE;
@@ -3354,10 +3403,11 @@ void handler::print_error(int error, myf errflag)
         }
       }
       else
-	my_error(ER_GET_ERRNO,errflag,error);
+	my_error(ER_GET_ERRNO, errflag, error, table_type());
       DBUG_VOID_RETURN;
     }
   }
+  DBUG_ASSERT(textno > 0);
   if (fatal_error)
   {
     /* Ensure this becomes a true error */
@@ -3371,7 +3421,17 @@ void handler::print_error(int error, myf errflag)
       errflag|= ME_NOREFRESH;
     }
   }    
-  my_error(textno, errflag, table_share->table_name.str, error);
+
+  /* if we got an OS error from a file-based engine, specify a path of error */
+  if (error < HA_ERR_FIRST && bas_ext()[0])
+  {
+    char buff[FN_REFLEN];
+    strxnmov(buff, sizeof(buff),
+             table_share->normalized_path.str, bas_ext()[0], NULL);
+    my_error(textno, errflag, buff, error);
+  }
+  else
+    my_error(textno, errflag, table_share->table_name.str, error);
   DBUG_VOID_RETURN;
 }
 
@@ -3573,9 +3633,14 @@ int handler::delete_table(const char *name)
 {
   int saved_error= 0;
   int error= 0;
-  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
+  int enoent_or_zero;
   char buff[FN_REFLEN];
 
+  if (ht->discover_table)
+    enoent_or_zero= 0; // the table may not exist in the engine, it's ok
+  else
+    enoent_or_zero= ENOENT;  // the first file of bas_ext() *must* exist
+
   for (const char **ext=bas_ext(); *ext ; ext++)
   {
     fn_format(buff, name, "", *ext, MY_UNPACK_FILENAME|MY_APPEND_EXT);
@@ -3959,16 +4024,16 @@ handler::ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info)
 /**
   Create handler files for CREATE TABLE: public interface.
 
-  @sa handler::create_handler_files()
+  @sa handler::create_partitioning_metadata()
 */
 
 int
-handler::ha_create_handler_files(const char *name, const char *old_name,
-                        int action_flag, HA_CREATE_INFO *info)
+handler::ha_create_partitioning_metadata(const char *name, const char *old_name,
+                                         int action_flag)
 {
   mark_trx_read_write();
 
-  return create_handler_files(name, old_name, action_flag, info);
+  return create_partitioning_metadata(name, old_name, action_flag);
 }
 
 
@@ -4256,154 +4321,69 @@ end:
 */
 int ha_create_table(THD *thd, const char *path,
                     const char *db, const char *table_name,
-                    HA_CREATE_INFO *create_info,
-		    bool update_create_info)
+                    HA_CREATE_INFO *create_info, LEX_CUSTRING *frm)
 {
   int error= 1;
   TABLE table;
   char name_buff[FN_REFLEN];
   const char *name;
   TABLE_SHARE share;
+  bool temp_table __attribute__((unused)) = create_info->tmp_table() ||
+                                is_prefix(table_name, tmp_file_prefix);
   DBUG_ENTER("ha_create_table");
-#ifdef HAVE_PSI_TABLE_INTERFACE
-  my_bool temp_table= (my_bool)is_prefix(table_name, tmp_file_prefix) ||
-               (create_info->options & HA_LEX_CREATE_TMP_TABLE ? TRUE : FALSE);
-#endif
   
   init_tmp_table_share(thd, &share, db, 0, table_name, path);
-  if (open_table_def(thd, &share, 0))
-    goto err;
+
+  if (frm)
+  {
+    bool write_frm_now= !create_info->db_type->discover_table &&
+                        !create_info->tmp_table();
+
+    share.frm_image= frm;
+
+    // open an frm image
+    if (share.init_from_binary_frm_image(thd, write_frm_now,
+                                         frm->str, frm->length))
+      goto err;
+  }
+  else
+  {
+    // open an frm file
+    share.db_plugin= ha_lock_engine(thd, create_info->db_type);
+
+    if (open_table_def(thd, &share))
+      goto err;
+  }
 
 #ifdef HAVE_PSI_TABLE_INTERFACE
   share.m_psi= PSI_CALL(get_table_share)(temp_table, &share);
 #endif
-  if (open_table_from_share(thd, &share, "", 0, (uint) READ_ALL, 0, &table,
-                            TRUE))
+
+  if (open_table_from_share(thd, &share, "", 0, READ_ALL, 0, &table, true))
     goto err;
 
-  if (update_create_info)
-    update_create_info_from_table(create_info, &table);
+  update_create_info_from_table(create_info, &table);
 
   name= get_canonical_filename(table.file, share.path.str, name_buff);
 
   error= table.file->ha_create(name, &table, create_info);
+
   (void) closefrm(&table, 0);
+
   if (error)
   {
-    strxmov(name_buff, db, ".", table_name, NullS);
-    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name_buff, error);
+    my_error(ER_CANT_CREATE_TABLE, MYF(0), db, table_name, error);
 #ifdef HAVE_PSI_TABLE_INTERFACE
-    PSI_CALL(drop_table_share)(temp_table, db, strlen(db), table_name,
-                               strlen(table_name));
+    PSI_CALL(drop_table_share)(temp_table, share.db.str, share.db.length,
+                               share.table_name.str, share.table_name.length);
 #endif
   }
+ 
 err:
   free_table_share(&share);
   DBUG_RETURN(error != 0);
 }
 
-/**
-  Try to discover table from engine.
-
-  @note
-    If found, write the frm file to disk.
-
-  @retval
-  -1    Table did not exists
-  @retval
-   0    Table created ok
-  @retval
-   > 0  Error, table existed but could not be created
-*/
-int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
-{
-  int error;
-  uchar *frmblob;
-  size_t frmlen;
-  char path[FN_REFLEN + 1];
-  HA_CREATE_INFO create_info;
-  TABLE table;
-  TABLE_SHARE share;
-  DBUG_ENTER("ha_create_table_from_engine");
-  DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
-
-  bzero((uchar*) &create_info,sizeof(create_info));
-  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
-  {
-    /* Table could not be discovered and thus not created */
-    DBUG_RETURN(error);
-  }
-
-  /*
-    Table exists in handler and could be discovered
-    frmblob and frmlen are set, write the frm to disk
-  */
-
-  build_table_filename(path, sizeof(path) - 1, db, name, "", 0);
-  // Save the frm file
-  error= writefrm(path, frmblob, frmlen);
-  my_free(frmblob);
-  if (error)
-    DBUG_RETURN(2);
-
-  init_tmp_table_share(thd, &share, db, 0, name, path);
-  if (open_table_def(thd, &share, 0))
-  {
-    DBUG_RETURN(3);
-  }
-
-#ifdef HAVE_PSI_TABLE_INTERFACE
-  /*
-    Table discovery is not instrumented.
-    Once discovered, the table will be opened normally,
-    and instrumented normally.
-  */
-#endif
-
-  if (open_table_from_share(thd, &share, "" ,0, 0, 0, &table, FALSE))
-  {
-    free_table_share(&share);
-    DBUG_RETURN(3);
-  }
-
-  update_create_info_from_table(&create_info, &table);
-  create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
-
-  get_canonical_filename(table.file, path, path);
-  error=table.file->ha_create(path, &table, &create_info);
-  (void) closefrm(&table, 1);
-
-  DBUG_RETURN(error != 0);
-}
-
-
-/**
-  Try to find a table in a storage engine. 
-
-  @param db   Normalized table schema name
-  @param name Normalized table name.
-  @param[out] exists Only valid if the function succeeded.
-
-  @retval TRUE   An error is found
-  @retval FALSE  Success, check *exists
-*/
-
-bool
-ha_check_if_table_exists(THD* thd, const char *db, const char *name,
-                         bool *exists)
-{
-  uchar *frmblob= NULL;
-  size_t frmlen;
-  DBUG_ENTER("ha_check_if_table_exists");
-
-  *exists= ! ha_discover(thd, db, name, &frmblob, &frmlen);
-  if (*exists)
-    my_free(frmblob);
-
-  DBUG_RETURN(FALSE);
-}
-
-
 void st_ha_check_opt::init()
 {
   flags= sql_flags= 0;
@@ -4526,149 +4506,348 @@ int ha_change_key_cache(KEY_CACHE *old_key_cache,
 }
 
 
-/**
-  Try to discover one table from handler(s).
-
-  @retval
-    -1   Table did not exists
-  @retval
-    0   OK. In this case *frmblob and *frmlen are set
-  @retval
-    >0   error.  frmblob and frmlen may not be set
-*/
-struct st_discover_args
-{
-  const char *db;
-  const char *name;
-  uchar **frmblob; 
-  size_t *frmlen;
-};
-
 static my_bool discover_handlerton(THD *thd, plugin_ref plugin,
                                    void *arg)
 {
-  st_discover_args *vargs= (st_discover_args *)arg;
+  TABLE_SHARE *share= (TABLE_SHARE *)arg;
   handlerton *hton= plugin_data(plugin, handlerton *);
-  if (hton->state == SHOW_OPTION_YES && hton->discover &&
-      (!(hton->discover(hton, thd, vargs->db, vargs->name, 
-                        vargs->frmblob, 
-                        vargs->frmlen))))
-    return TRUE;
+  if (hton->state == SHOW_OPTION_YES && hton->discover_table)
+  {
+    share->db_plugin= plugin;
+    int error= hton->discover_table(hton, thd, share);
+    if (error != HA_ERR_NO_SUCH_TABLE)
+    {
+      if (error)
+      {
+        DBUG_ASSERT(share->error); // MUST be always set for get_cached_table_share to work
+        my_error(ER_GET_ERRNO, MYF(0), error, plugin_name(plugin)->str);
+        share->db_plugin= 0;
+      }
+      else
+        share->error= OPEN_FRM_OK;
 
-  return FALSE;
+      status_var_increment(thd->status_var.ha_discover_count);
+      return TRUE; // abort the search
+    }
+    share->db_plugin= 0;
+  }
+
+  DBUG_ASSERT(share->error == OPEN_FRM_OPEN_ERROR);
+  return FALSE;    // continue with the next engine
 }
 
-int ha_discover(THD *thd, const char *db, const char *name,
-		uchar **frmblob, size_t *frmlen)
+int ha_discover_table(THD *thd, TABLE_SHARE *share)
 {
-  int error= -1; // Table does not exist in any handler
-  DBUG_ENTER("ha_discover");
-  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
-  st_discover_args args= {db, name, frmblob, frmlen};
+  DBUG_ENTER("ha_discover_table");
+  int found;
 
-  if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
-    DBUG_RETURN(error);
+  DBUG_ASSERT(share->error == OPEN_FRM_OPEN_ERROR);   // share is not OK yet
 
-  if (plugin_foreach(thd, discover_handlerton,
-                 MYSQL_STORAGE_ENGINE_PLUGIN, &args))
-    error= 0;
+  if (share->db_plugin)
+    found= discover_handlerton(thd, share->db_plugin, share);
+  else
+    found= plugin_foreach(thd, discover_handlerton,
+                        MYSQL_STORAGE_ENGINE_PLUGIN, share);
+  
+  if (!found)
+    open_table_error(share, OPEN_FRM_OPEN_ERROR, ENOENT); // not found
 
-  if (!error)
-    status_var_increment(thd->status_var.ha_discover_count);
-  DBUG_RETURN(error);
+  DBUG_RETURN(share->error != OPEN_FRM_OK);
 }
 
+static my_bool file_ext_exists(char *path, size_t path_len, const char *ext)
+{
+  strmake(path + path_len, ext, FN_REFLEN - path_len);
+  return !access(path, F_OK);
+}
 
-/**
-  Call this function in order to give the handler the possiblity
-  to ask engine if there are any new tables that should be written to disk
-  or any dropped tables that need to be removed from disk
-*/
-struct st_find_files_args
+struct st_discover_existence_args
 {
-  const char *db;
-  const char *path;
-  const char *wild;
-  bool dir;
-  List<LEX_STRING> *files;
+  char *path;
+  size_t  path_len;
+  const char *db, *table_name;
+  handlerton *hton;
 };
 
-static my_bool find_files_handlerton(THD *thd, plugin_ref plugin,
-                                   void *arg)
+static my_bool discover_existence(THD *thd, plugin_ref plugin,
+                                  void *arg)
 {
-  st_find_files_args *vargs= (st_find_files_args *)arg;
-  handlerton *hton= plugin_data(plugin, handlerton *);
+  st_discover_existence_args *args= (st_discover_existence_args*)arg;
+  handlerton *ht= plugin_data(plugin, handlerton *);
+  if (ht->state != SHOW_OPTION_YES || !ht->discover_table_existence)
+    return FALSE;
 
+  args->hton= ht;
 
-  if (hton->state == SHOW_OPTION_YES && hton->find_files)
-      if (hton->find_files(hton, thd, vargs->db, vargs->path, vargs->wild, 
-                          vargs->dir, vargs->files))
-        return TRUE;
+  if (ht->discover_table_existence == ext_based_existence)
+    return file_ext_exists(args->path, args->path_len,
+                           ht->tablefile_extensions[0]);
 
-  return FALSE;
+  return ht->discover_table_existence(ht, args->db, args->table_name);
 }
 
-int
-ha_find_files(THD *thd,const char *db,const char *path,
-	      const char *wild, bool dir, List<LEX_STRING> *files)
+class Table_exists_error_handler : public Internal_error_handler
 {
-  int error= 0;
-  DBUG_ENTER("ha_find_files");
-  DBUG_PRINT("enter", ("db: '%s'  path: '%s'  wild: '%s'  dir: %d", 
-		       db, path, wild, dir));
-  st_find_files_args args= {db, path, wild, dir, files};
-
-  plugin_foreach(thd, find_files_handlerton,
-                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
-  /* The return value is not currently used */
-  DBUG_RETURN(error);
+public:
+  Table_exists_error_handler()
+    : m_handled_errors(0), m_unhandled_errors(0)
+  {}
+
+  bool handle_condition(THD *thd,
+                        uint sql_errno,
+                        const char* sqlstate,
+                        MYSQL_ERROR::enum_warning_level level,
+                        const char* msg,
+                        MYSQL_ERROR ** cond_hdl)
+  {
+    *cond_hdl= NULL;
+    if (sql_errno == ER_NO_SUCH_TABLE ||
+        sql_errno == ER_NO_SUCH_TABLE_IN_ENGINE ||
+        sql_errno == ER_WRONG_OBJECT)
+    {
+      m_handled_errors++;
+      return TRUE;
+    }
+
+    if (level == MYSQL_ERROR::WARN_LEVEL_ERROR)
+      m_unhandled_errors++;
+    return FALSE;
+  }
+
+  bool safely_trapped_errors()
+  {
+    return ((m_handled_errors > 0) && (m_unhandled_errors == 0));
+  }
+
+private:
+  int m_handled_errors;
+  int m_unhandled_errors;
+};
+
+/**
+  Check if a given table exists, without doing a full discover, if possible
+
+  If the 'hton' is not NULL, it's set to the handlerton of the storage engine
+  of this table, or to view_pseudo_hton if the frm belongs to a view.
+
+
+  @retval true    Table exists (even if the error occurred, like bad frm)
+  @retval false   Table does not exist (one can do CREATE TABLE table_name)
+*/
+bool ha_table_exists(THD *thd, const char *db, const char *table_name,
+                     handlerton **hton)
+{
+  DBUG_ENTER("ha_table_exists");
+
+  if (hton)
+    *hton= 0;
+
+  if (need_full_discover_for_existence)
+  {
+    TABLE_LIST table;
+    uint flags = GTS_TABLE | GTS_VIEW;
+
+    if (!hton)
+      flags|= GTS_NOLOCK;
+
+    Table_exists_error_handler no_such_table_handler;
+    thd->push_internal_handler(&no_such_table_handler);
+    TABLE_SHARE *share= get_table_share(thd, db, table_name, flags);
+    thd->pop_internal_handler();
+
+    if (hton && share)
+    {
+      *hton= share->db_type();
+      mysql_mutex_lock(&LOCK_open);
+      release_table_share(share);
+      mysql_mutex_unlock(&LOCK_open);
+    }
+
+    // the table doesn't exist if we've caught ER_NO_SUCH_TABLE and nothing else
+    DBUG_RETURN(!no_such_table_handler.safely_trapped_errors());
+  }
+
+  mysql_mutex_lock(&LOCK_open);
+  TABLE_SHARE *share= get_cached_table_share(db, table_name);
+  if (hton && share)
+    *hton= share->db_type();
+  mysql_mutex_unlock(&LOCK_open);
+
+  if (share)
+    DBUG_RETURN(TRUE);
+
+  char path[FN_REFLEN + 1];
+  size_t path_len = build_table_filename(path, sizeof(path) - 1,
+                                         db, table_name, "", 0);
+
+  if (file_ext_exists(path, path_len, reg_ext))
+  {
+    if (hton)
+    {
+      enum legacy_db_type db_type;
+      if (dd_frm_type(thd, path, &db_type) != FRMTYPE_VIEW)
+        *hton= ha_resolve_by_legacy_type(thd, db_type);
+      else
+        *hton= view_pseudo_hton;
+    }
+    DBUG_RETURN(TRUE);
+  }
+
+  st_discover_existence_args args= {path, path_len, db, table_name, 0};
+
+  if (plugin_foreach(thd, discover_existence, MYSQL_STORAGE_ENGINE_PLUGIN,
+                     &args))
+  {
+    if (hton)
+      *hton= args.hton;
+    DBUG_RETURN(TRUE);
+  }
+
+  DBUG_RETURN(FALSE);
 }
 
 /**
-  Ask handler if the table exists in engine.
-  @retval
-    HA_ERR_NO_SUCH_TABLE     Table does not exist
-  @retval
-    HA_ERR_TABLE_EXIST       Table exists
-  @retval
-    \#                  Error code
+  Discover all table names in a given database
 */
-struct st_table_exists_in_engine_args
+extern "C" {
+
+static int cmp_file_names(const void *a, const void *b)
 {
-  const char *db;
-  const char *name;
-  int err;
-};
+  CHARSET_INFO *cs= character_set_filesystem;
+  char *aa= ((FILEINFO *)a)->name;
+  char *bb= ((FILEINFO *)b)->name;
+  return my_strnncoll(cs, (uchar*)aa, strlen(aa), (uchar*)bb, strlen(bb));
+}
 
-static my_bool table_exists_in_engine_handlerton(THD *thd, plugin_ref plugin,
-                                   void *arg)
+static int cmp_table_names(LEX_STRING * const *a, LEX_STRING * const *b)
 {
-  st_table_exists_in_engine_args *vargs= (st_table_exists_in_engine_args *)arg;
-  handlerton *hton= plugin_data(plugin, handlerton *);
+  return my_strnncoll(&my_charset_bin, (uchar*)((*a)->str), (*a)->length,
+                                       (uchar*)((*b)->str), (*b)->length);
+}
 
-  int err= HA_ERR_NO_SUCH_TABLE;
+}
 
-  if (hton->state == SHOW_OPTION_YES && hton->table_exists_in_engine)
-    err = hton->table_exists_in_engine(hton, thd, vargs->db, vargs->name);
+Discovered_table_list::Discovered_table_list(THD *thd_arg,
+                 Dynamic_array<LEX_STRING*> *tables_arg,
+                 const LEX_STRING *wild_arg)
+{
+  thd= thd_arg;
+  tables= tables_arg;
+  if (wild_arg->str && wild_arg->str[0])
+  {
+    wild= wild_arg->str;
+    wend= wild + wild_arg->length;
+  }
+  else
+    wild= 0;
+}
 
-  vargs->err = err;
-  if (vargs->err == HA_ERR_TABLE_EXIST)
-    return TRUE;
+bool Discovered_table_list::add_table(const char *tname, size_t tlen)
+{
+  if (wild && my_wildcmp(files_charset_info, tname, tname + tlen, wild, wend,
+                         wild_prefix, wild_one, wild_many))
+      return 0;
 
-  return FALSE;
+  LEX_STRING *name= thd->make_lex_string(tname, tlen);
+  if (!name || tables->append(name))
+    return 1;
+  return 0;
+}
+
+bool Discovered_table_list::add_file(const char *fname)
+{
+  char tname[SAFE_NAME_LEN + 1];
+  size_t tlen= filename_to_tablename(fname, tname, sizeof(tname));
+  return add_table(tname, tlen);
+}
+
+
+void Discovered_table_list::sort()
+{
+  tables->sort(cmp_table_names);
+}
+
+void Discovered_table_list::remove_duplicates()
+{
+  LEX_STRING **src= tables->front();
+  LEX_STRING **dst= src;
+  while (++dst < tables->back())
+  {
+    LEX_STRING *s= *src, *d= *dst;
+    DBUG_ASSERT(strncmp(s->str, d->str, min(s->length, d->length)) <= 0);
+    if ((s->length != d->length || strncmp(s->str, d->str, d->length)))
+    {
+      src++;
+      if (src != dst)
+        *src= *dst;
+    }
+  }
+  tables->set_elements(src - tables->front() + 1);
+}
+
+struct st_discover_names_args
+{
+  LEX_STRING *db;
+  MY_DIR *dirp;
+  Discovered_table_list *result;
+  uint possible_duplicates;
+};
+
+static my_bool discover_names(THD *thd, plugin_ref plugin,
+                              void *arg)
+{
+  st_discover_names_args *args= (st_discover_names_args *)arg;
+  handlerton *ht= plugin_data(plugin, handlerton *);
+
+  if (ht->state == SHOW_OPTION_YES && ht->discover_table_names)
+  {
+    uint old_elements= args->result->tables->elements();
+    if (ht->discover_table_names(ht, args->db, args->dirp, args->result))
+      return 1;
+
+    /*
+      hton_ext_based_table_discovery never discovers a table that has
+      a corresponding .frm file; but custom engine discover methods might
+    */
+    if (ht->discover_table_names != hton_ext_based_table_discovery)
+      args->possible_duplicates+= args->result->tables->elements() - old_elements;
+  }
+
+  return 0;
 }
 
-int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
+int ha_discover_table_names(THD *thd, LEX_STRING *db, MY_DIR *dirp,
+                            Discovered_table_list *result)
 {
-  DBUG_ENTER("ha_table_exists_in_engine");
-  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
-  st_table_exists_in_engine_args args= {db, name, HA_ERR_NO_SUCH_TABLE};
-  plugin_foreach(thd, table_exists_in_engine_handlerton,
-                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
-  DBUG_PRINT("exit", ("error: %d", args.err));
-  DBUG_RETURN(args.err);
+  int error;
+  DBUG_ENTER("ha_discover_table_names");
+
+  if (engines_with_discover_table_names == 0)
+  {
+    error= ext_table_discovery_simple(dirp, result);
+    result->sort();
+  }
+  else
+  {
+    st_discover_names_args args= {db, dirp, result, 0};
+
+    /* extension_based_table_discovery relies on dirp being sorted */
+    my_qsort(dirp->dir_entry, dirp->number_of_files,
+             sizeof(FILEINFO), cmp_file_names);
+
+    error= extension_based_table_discovery(dirp, reg_ext, result) ||
+           plugin_foreach(thd, discover_names,
+                            MYSQL_STORAGE_ENGINE_PLUGIN, &args);
+    result->sort();
+
+    if (args.possible_duplicates > 0)
+      result->remove_duplicates();
+  }
+
+  DBUG_RETURN(error);
 }
 
+
 #ifdef HAVE_NDB_BINLOG
 /*
   TODO: change this into a dynamic struct
@@ -5017,26 +5196,20 @@ static my_bool exts_handlerton(THD *unused, plugin_ref plugin,
 {
   List<char> *found_exts= (List<char> *) arg;
   handlerton *hton= plugin_data(plugin, handlerton *);
-  handler *file;
-  if (hton->state == SHOW_OPTION_YES && hton->create &&
-      (file= hton->create(hton, (TABLE_SHARE*) 0, current_thd->mem_root)))
-  {
-    List_iterator_fast<char> it(*found_exts);
-    const char **ext, *old_ext;
+  List_iterator_fast<char> it(*found_exts);
+  const char **ext, *old_ext;
 
-    for (ext= file->bas_ext(); *ext; ext++)
+  for (ext= hton->tablefile_extensions; *ext; ext++)
+  {
+    while ((old_ext= it++))
     {
-      while ((old_ext= it++))
-      {
-        if (!strcmp(old_ext, *ext))
-	  break;
-      }
-      if (!old_ext)
-        found_exts->push_back((char *) *ext);
-
-      it.rewind();
+      if (!strcmp(old_ext, *ext))
+        break;
     }
-    delete file;
+    if (!old_ext)
+      found_exts->push_back((char *) *ext);
+
+    it.rewind();
   }
   return FALSE;
 }
@@ -5137,7 +5310,7 @@ bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
   if (!result && !thd->is_error())
     my_eof(thd);
   else if (!thd->is_error())
-    my_error(ER_GET_ERRNO, MYF(0), errno);
+    my_error(ER_GET_ERRNO, MYF(0), errno, hton_name(db_type)->str);
   return result;
 }
 
diff --git a/sql/handler.h b/sql/handler.h
index 8ee1044f10c..44d86e5ec97 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -2,7 +2,7 @@
 #define HANDLER_INCLUDED
 /*
    Copyright (c) 2000, 2011, Oracle and/or its affiliates.
-   Copyright (c) 2009-2011 Monty Program Ab
+   Copyright (c) 2009, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -31,6 +31,7 @@
 #include "thr_lock.h"          /* thr_lock_type, THR_LOCK_DATA */
 #include "sql_cache.h"
 #include "structs.h"                            /* SHOW_COMP_OPTION */
+#include "sql_array.h"          /* Dynamic_array<> */
 
 #include <my_compare.h>
 #include <ft_global.h>
@@ -59,9 +60,9 @@
 
 /* Bits in table_flags() to show what database can do */
 
-#define HA_NO_TRANSACTIONS     (1 << 0) /* Doesn't support transactions */
-#define HA_PARTIAL_COLUMN_READ (1 << 1) /* read may not return all columns */
-#define HA_TABLE_SCAN_ON_INDEX (1 << 2) /* No separate data/index file */
+#define HA_NO_TRANSACTIONS     (1ULL << 0) /* Doesn't support transactions */
+#define HA_PARTIAL_COLUMN_READ (1ULL << 1) /* read may not return all columns */
+#define HA_TABLE_SCAN_ON_INDEX (1ULL << 2) /* No separate data/index file */
 /*
   The following should be set if the following is not true when scanning
   a table with rnd_next()
@@ -70,37 +71,37 @@
   If this flag is not set, filesort will do a position() call for each matched
   row to be able to find the row later.
 */
-#define HA_REC_NOT_IN_SEQ      (1 << 3)
-#define HA_CAN_GEOMETRY        (1 << 4)
+#define HA_REC_NOT_IN_SEQ      (1ULL << 3)
+#define HA_CAN_GEOMETRY        (1ULL << 4)
 /*
   Reading keys in random order is as fast as reading keys in sort order
   (Used in records.cc to decide if we should use a record cache and by
   filesort to decide if we should sort key + data or key + pointer-to-row
 */
-#define HA_FAST_KEY_READ       (1 << 5)
+#define HA_FAST_KEY_READ       (1ULL << 5)
 /*
   Set the following flag if we on delete should force all key to be read
   and on update read all keys that changes
 */
-#define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1 << 6)
-#define HA_NULL_IN_KEY         (1 << 7) /* One can have keys with NULL */
-#define HA_DUPLICATE_POS       (1 << 8)    /* ha_position() gives dup row */
-#define HA_NO_BLOBS            (1 << 9) /* Doesn't support blobs */
-#define HA_CAN_INDEX_BLOBS     (1 << 10)
-#define HA_AUTO_PART_KEY       (1 << 11) /* auto-increment in multi-part key */
-#define HA_REQUIRE_PRIMARY_KEY (1 << 12) /* .. and can't create a hidden one */
-#define HA_STATS_RECORDS_IS_EXACT (1 << 13) /* stats.records is exact */
+#define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1ULL << 6)
+#define HA_NULL_IN_KEY         (1ULL << 7) /* One can have keys with NULL */
+#define HA_DUPLICATE_POS       (1ULL << 8)    /* ha_position() gives dup row */
+#define HA_NO_BLOBS            (1ULL << 9) /* Doesn't support blobs */
+#define HA_CAN_INDEX_BLOBS     (1ULL << 10)
+#define HA_AUTO_PART_KEY       (1ULL << 11) /* auto-increment in multi-part key */
+#define HA_REQUIRE_PRIMARY_KEY (1ULL << 12) /* .. and can't create a hidden one */
+#define HA_STATS_RECORDS_IS_EXACT (1ULL << 13) /* stats.records is exact */
 /*
   INSERT_DELAYED only works with handlers that uses MySQL internal table
   level locks
 */
-#define HA_CAN_INSERT_DELAYED  (1 << 14)
+#define HA_CAN_INSERT_DELAYED  (1ULL << 14)
 /*
   If we get the primary key columns for free when we do an index read
   It also implies that we have to retrive the primary key when using
   position() and rnd_pos().
 */
-#define HA_PRIMARY_KEY_IN_READ_INDEX (1 << 15)
+#define HA_PRIMARY_KEY_IN_READ_INDEX (1ULL << 15)
 /*
   If HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is set, it means that to position()
   uses a primary key given by the record argument.
@@ -108,36 +109,36 @@
   If not set, the position is returned as the current rows position
   regardless of what argument is given.
 */ 
-#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION (1 << 16) 
-#define HA_CAN_RTREEKEYS       (1 << 17)
-#define HA_NOT_DELETE_WITH_CACHE (1 << 18)
+#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION (1ULL << 16) 
+#define HA_CAN_RTREEKEYS       (1ULL << 17)
+#define HA_NOT_DELETE_WITH_CACHE (1ULL << 18)
 /*
   The following is we need to a primary key to delete (and update) a row.
   If there is no primary key, all columns needs to be read on update and delete
 */
-#define HA_PRIMARY_KEY_REQUIRED_FOR_DELETE (1 << 19)
-#define HA_NO_PREFIX_CHAR_KEYS (1 << 20)
-#define HA_CAN_FULLTEXT        (1 << 21)
-#define HA_CAN_SQL_HANDLER     (1 << 22)
-#define HA_NO_AUTO_INCREMENT   (1 << 23)
+#define HA_PRIMARY_KEY_REQUIRED_FOR_DELETE (1ULL << 19)
+#define HA_NO_PREFIX_CHAR_KEYS (1ULL << 20)
+#define HA_CAN_FULLTEXT        (1ULL << 21)
+#define HA_CAN_SQL_HANDLER     (1ULL << 22)
+#define HA_NO_AUTO_INCREMENT   (1ULL << 23)
 /* Has automatic checksums and uses the old checksum format */
-#define HA_HAS_OLD_CHECKSUM    (1 << 24)
+#define HA_HAS_OLD_CHECKSUM    (1ULL << 24)
 /* Table data are stored in separate files (for lower_case_table_names) */
-#define HA_FILE_BASED	       (1 << 26)
-#define HA_NO_VARCHAR	       (1 << 27)
-#define HA_CAN_BIT_FIELD       (1 << 28) /* supports bit fields */
-#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */
-#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
-#define HA_NO_COPY_ON_ALTER    (LL(1) << 31)
-#define HA_HAS_RECORDS	       (LL(1) << 32) /* records() gives exact count*/
+#define HA_FILE_BASED	       (1ULL << 26)
+#define HA_NO_VARCHAR	       (1ULL << 27)
+#define HA_CAN_BIT_FIELD       (1ULL << 28) /* supports bit fields */
+#define HA_NEED_READ_RANGE_BUFFER (1ULL << 29) /* for read_multi_range */
+#define HA_ANY_INDEX_MAY_BE_UNIQUE (1ULL << 30)
+#define HA_NO_COPY_ON_ALTER    (1ULL << 31)
+#define HA_HAS_RECORDS	       (1ULL << 32) /* records() gives exact count*/
 /* Has it's own method of binlog logging */
-#define HA_HAS_OWN_BINLOGGING  (LL(1) << 33)
+#define HA_HAS_OWN_BINLOGGING  (1ULL << 33)
 /*
   Engine is capable of row-format and statement-format logging,
   respectively
 */
-#define HA_BINLOG_ROW_CAPABLE  (LL(1) << 34)
-#define HA_BINLOG_STMT_CAPABLE (LL(1) << 35)
+#define HA_BINLOG_ROW_CAPABLE  (1ULL << 34)
+#define HA_BINLOG_STMT_CAPABLE (1ULL << 35)
 /*
     When a multiple key conflict happens in a REPLACE command mysql
     expects the conflicts to be reported in the ascending order of
@@ -160,20 +161,20 @@
     This flag helps the underlying SE to inform the server that the keys are not
     ordered.
 */
-#define HA_DUPLICATE_KEY_NOT_IN_ORDER    (LL(1) << 36)
+#define HA_DUPLICATE_KEY_NOT_IN_ORDER    (1ULL << 36)
 
 /*
   Engine supports REPAIR TABLE. Used by CHECK TABLE FOR UPGRADE if an
   incompatible table is detected. If this flag is set, CHECK TABLE FOR UPGRADE
   will report ER_TABLE_NEEDS_UPGRADE, otherwise ER_TABLE_NEED_REBUILD.
 */
-#define HA_CAN_REPAIR                    (LL(1) << 37)
+#define HA_CAN_REPAIR                    (1ULL << 37)
 
 /* Has automatic checksums and uses the new checksum format */
-#define HA_HAS_NEW_CHECKSUM    (LL(1) << 38)
-#define HA_CAN_VIRTUAL_COLUMNS (LL(1) << 39)
-#define HA_MRR_CANT_SORT       (LL(1) << 40)
-#define HA_RECORD_MUST_BE_CLEAN_ON_WRITE (LL(1) << 41)
+#define HA_HAS_NEW_CHECKSUM    (1ULL << 38)
+#define HA_CAN_VIRTUAL_COLUMNS (1ULL << 39)
+#define HA_MRR_CANT_SORT       (1ULL << 40)
+#define HA_RECORD_MUST_BE_CLEAN_ON_WRITE (1ULL << 41)
 
 /*
   Table condition pushdown must be performed regardless of
@@ -186,7 +187,7 @@
   then the "query=..." condition must be always pushed down into storage
   engine.
 */
-#define HA_MUST_USE_TABLE_CONDITION_PUSHDOWN (LL(1) << 42)
+#define HA_MUST_USE_TABLE_CONDITION_PUSHDOWN (1ULL << 42)
 
 /*
   Set of all binlog flags. Currently only contain the capabilities
@@ -352,25 +353,23 @@ static const uint MYSQL_START_TRANS_OPT_READ_WRITE         = 4;
 
 enum legacy_db_type
 {
-  DB_TYPE_UNKNOWN=0,DB_TYPE_DIAB_ISAM=1,
-  DB_TYPE_HASH,DB_TYPE_MISAM,DB_TYPE_PISAM,
-  DB_TYPE_RMS_ISAM, DB_TYPE_HEAP, DB_TYPE_ISAM,
-  DB_TYPE_MRG_ISAM, DB_TYPE_MYISAM, DB_TYPE_MRG_MYISAM,
-  DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB,
-  DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER,
-  DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB,
-  DB_TYPE_FEDERATED_DB,
-  DB_TYPE_BLACKHOLE_DB,
-  DB_TYPE_PARTITION_DB,
-  DB_TYPE_BINLOG,
-  DB_TYPE_SOLID,
-  DB_TYPE_PBXT,
-  DB_TYPE_TABLE_FUNCTION,
-  DB_TYPE_MEMCACHE,
-  DB_TYPE_FALCON,
-  DB_TYPE_MARIA,
-  /** Performance schema engine. */
-  DB_TYPE_PERFORMANCE_SCHEMA,
+  /* note these numerical values are fixed and can *not* be changed */
+  DB_TYPE_UNKNOWN=0,
+  DB_TYPE_HEAP=6,
+  DB_TYPE_MYISAM=9,
+  DB_TYPE_MRG_MYISAM=10,
+  DB_TYPE_INNODB=12,
+  DB_TYPE_NDBCLUSTER=14,
+  DB_TYPE_EXAMPLE_DB=15,
+  DB_TYPE_ARCHIVE_DB=16,
+  DB_TYPE_CSV_DB=17,
+  DB_TYPE_FEDERATED_DB=18,
+  DB_TYPE_BLACKHOLE_DB=19,
+  DB_TYPE_PARTITION_DB=20,
+  DB_TYPE_BINLOG=21,
+  DB_TYPE_PBXT=23,
+  DB_TYPE_MARIA=27,
+  DB_TYPE_PERFORMANCE_SCHEMA=28,
   DB_TYPE_FIRST_DYNAMIC=42,
   DB_TYPE_DEFAULT=127 // Must be last
 };
@@ -627,6 +626,7 @@ enum enum_schema_tables
   SCH_PARAMETERS,
   SCH_PARTITIONS,
   SCH_PLUGINS,
+  SCH_ALL_PLUGINS,
   SCH_PROCESSLIST,
   SCH_PROFILES,
   SCH_REFERENTIAL_CONSTRAINTS,
@@ -651,6 +651,7 @@ enum enum_schema_tables
 };
 
 struct TABLE_SHARE;
+struct HA_CREATE_INFO;
 struct st_foreign_key_info;
 typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
 typedef bool (stat_print_fn)(THD *thd, const char *type, uint type_len,
@@ -730,22 +731,26 @@ struct ha_index_option_struct;
 enum ha_option_type { HA_OPTION_TYPE_ULL,    /* unsigned long long */
                       HA_OPTION_TYPE_STRING, /* char * */
                       HA_OPTION_TYPE_ENUM,   /* uint */
-                      HA_OPTION_TYPE_BOOL};  /* bool */
+                      HA_OPTION_TYPE_BOOL,   /* bool */
+                      HA_OPTION_TYPE_SYSVAR};/* type of the sysval */
 
 #define HA_xOPTION_NUMBER(name, struc, field, def, min, max, blk_siz)   \
   { HA_OPTION_TYPE_ULL, name, sizeof(name)-1,                        \
-    offsetof(struc, field), def, min, max, blk_siz, 0 }
+    offsetof(struc, field), def, min, max, blk_siz, 0, 0 }
 #define HA_xOPTION_STRING(name, struc, field)                        \
   { HA_OPTION_TYPE_STRING, name, sizeof(name)-1,                     \
-    offsetof(struc, field), 0, 0, 0, 0, 0 }
+    offsetof(struc, field), 0, 0, 0, 0, 0, 0}
 #define HA_xOPTION_ENUM(name, struc, field, values, def)             \
   { HA_OPTION_TYPE_ENUM, name, sizeof(name)-1,                       \
     offsetof(struc, field), def, 0,                                  \
-    sizeof(values)-1, 0, values }
+    sizeof(values)-1, 0, values, 0 }
 #define HA_xOPTION_BOOL(name, struc, field, def)                     \
   { HA_OPTION_TYPE_BOOL, name, sizeof(name)-1,                       \
-    offsetof(struc, field), def, 0, 1, 0, 0 }
-#define HA_xOPTION_END { HA_OPTION_TYPE_ULL, 0, 0, 0, 0, 0, 0, 0, 0 }
+    offsetof(struc, field), def, 0, 1, 0, 0, 0 }
+#define HA_xOPTION_SYSVAR(name, struc, field, sysvar)                \
+  { HA_OPTION_TYPE_SYSVAR, name, sizeof(name)-1,                     \
+    offsetof(struc, field), 0, 0, 0, 0, 0, MYSQL_SYSVAR(sysvar) }
+#define HA_xOPTION_END { HA_OPTION_TYPE_ULL, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 
 #define HA_TOPTION_NUMBER(name, field, def, min, max, blk_siz)          \
   HA_xOPTION_NUMBER(name, ha_table_option_struct, field, def, min, max, blk_siz)
@@ -755,6 +760,8 @@ enum ha_option_type { HA_OPTION_TYPE_ULL,    /* unsigned long long */
   HA_xOPTION_ENUM(name, ha_table_option_struct, field, values, def)
 #define HA_TOPTION_BOOL(name, field, def)                            \
   HA_xOPTION_BOOL(name, ha_table_option_struct, field, def)
+#define HA_TOPTION_SYSVAR(name, field, sysvar)                       \
+  HA_xOPTION_SYSVAR(name, ha_table_option_struct, field, sysvar)
 #define HA_TOPTION_END HA_xOPTION_END
 
 #define HA_FOPTION_NUMBER(name, field, def, min, max, blk_siz)          \
@@ -765,6 +772,8 @@ enum ha_option_type { HA_OPTION_TYPE_ULL,    /* unsigned long long */
   HA_xOPTION_ENUM(name, ha_field_option_struct, field, values, def)
 #define HA_FOPTION_BOOL(name, field, def)                            \
   HA_xOPTION_BOOL(name, ha_field_option_struct, field, def)
+#define HA_FOPTION_SYSVAR(name, field, sysvar)                       \
+  HA_xOPTION_SYSVAR(name, ha_field_option_struct, field, sysvar)
 #define HA_FOPTION_END HA_xOPTION_END
 
 #define HA_IOPTION_NUMBER(name, field, def, min, max, blk_siz)          \
@@ -775,6 +784,8 @@ enum ha_option_type { HA_OPTION_TYPE_ULL,    /* unsigned long long */
   HA_xOPTION_ENUM(name, ha_index_option_struct, field, values, def)
 #define HA_IOPTION_BOOL(name, field, values, def)                    \
   HA_xOPTION_BOOL(name, ha_index_option_struct, field, values, def)
+#define HA_IOPTION_SYSVAR(name, field, sysvar)                       \
+  HA_xOPTION_SYSVAR(name, ha_index_option_struct, field, sysvar)
 #define HA_IOPTION_END HA_xOPTION_END
 
 typedef struct st_ha_create_table_option {
@@ -785,6 +796,7 @@ typedef struct st_ha_create_table_option {
   ulonglong def_value;
   ulonglong min_value, max_value, block_size;
   const char *values;
+  struct st_mysql_sys_var *var;
 } ha_create_table_option;
 
 enum handler_iterator_type
@@ -1093,18 +1105,6 @@ struct handlerton
    enum handler_create_iterator_result
      (*create_iterator)(handlerton *hton, enum handler_iterator_type type,
                         struct handler_iterator *fill_this_in);
-   int (*discover)(handlerton *hton, THD* thd, const char *db, 
-                   const char *name,
-                   uchar **frmblob, 
-                   size_t *frmlen);
-   int (*find_files)(handlerton *hton, THD *thd,
-                     const char *db,
-                     const char *path,
-                     const char *wild, bool dir, List<LEX_STRING> *files);
-   int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db,
-                                 const char *name);
-
-   uint32 license; /* Flag for Engine License */
    /*
      Optional clauses in the CREATE/ALTER TABLE
    */
@@ -1112,14 +1112,124 @@ struct handlerton
    ha_create_table_option *field_options; // these are specified per field
    ha_create_table_option *index_options; // these are specified per index
 
+   /**
+     The list of extensions of files created for a single table in the
+     database directory (datadir/db_name/).
+
+     Used by open_table_error(), by the default rename_table and delete_table
+     handler methods, and by the default discovery implementation.
+  
+     For engines that have more than one file name extentions (separate
+     metadata, index, and/or data files), the order of elements is relevant.
+     First element of engine file name extentions array should be metadata
+     file extention. This is implied by the open_table_error()
+     and the default discovery implementation.
+     
+     Second element - data file extention. This is implied
+     assumed by REPAIR TABLE ... USE_FRM implementation.
+   */
+   const char **tablefile_extensions; // by default - empty list
+
+   /*********************************************************************
+     Table discovery API.
+     It allows the server to "discover" tables that exist in the storage
+     engine, without user issuing an explicit CREATE TABLE statement.
+   **********************************************************************/
+
+   /*
+     This method is required for any engine that supports automatic table
+     discovery, there is no default implementation.
+
+     Given a TABLE_SHARE discover_table() fills it in with a correct table
+     structure using one of the TABLE_SHARE::init_from_* methods.
+
+     Returns HA_ERR_NO_SUCH_TABLE if the table did not exist in the engine,
+     zero if the table was discovered successfully, or any other
+     HA_ERR_* error code as appropriate if the table existed, but the
+     discovery failed.
+   */
+   int (*discover_table)(handlerton *hton, THD* thd, TABLE_SHARE *share);
+
+   /*
+     The discover_table_names method tells the server
+     about all tables in the specified database that the engine
+     knows about. Tables (or file names of tables) are added to
+     the provided discovered_list collector object using
+     add_table() or add_file() methods.
+   */
+   class discovered_list
+   {
+     public:
+     virtual bool add_table(const char *tname, size_t tlen) = 0;
+     virtual bool add_file(const char *fname) = 0;
+     protected: virtual ~discovered_list() {}
+   };
+
+   /*
+     By default (if not implemented by the engine, but the discovery_table() is
+     implemented) it will perform a file-based discovery:
+
+     - if tablefile_extensions[0] is not null, this will discovers all tables
+       with the tablefile_extensions[0] extension.
+
+     Returns 0 on success and 1 on error.
+   */
+   int (*discover_table_names)(handlerton *hton, LEX_STRING *db, MY_DIR *dir,
+                               discovered_list *result);
+
+   /*
+     This is a method that allows to server to check if a table exists without
+     an overhead of the complete discovery.
+
+     By default (if not implemented by the engine, but the discovery_table() is
+     implemented) it will try to perform a file-based discovery:
+
+     - if tablefile_extensions[0] is not null this will look for a file name
+       with the tablefile_extensions[0] extension.
+
+     - if tablefile_extensions[0] is null, this will resort to discover_table().
+
+     Note that resorting to discover_table() is slow and the engine
+     should probably implement its own discover_table_existence() method,
+     if its tablefile_extensions[0] is null.
+
+     Returns 1 if the table exists and 0 if it does not.
+   */
+   int (*discover_table_existence)(handlerton *hton, const char *db,
+                                   const char *table_name);
+
+   /*
+     This is the assisted table discovery method. Unlike the fully
+     automatic discovery as above, here a user is expected to issue an
+     explicit CREATE TABLE with the appropriate table attributes to
+     "assist" the discovery of a table. But this "discovering" CREATE TABLE
+     statement will not specify the table structure - the engine discovers
+     it using this method. For example, FederatedX uses it in
+
+      CREATE TABLE t1 ENGINE=FEDERATED CONNECTION="mysql://foo/bar/t1";
+
+     Given a TABLE_SHARE discover_table_structure() fills it in with a correct
+     table structure using one of the TABLE_SHARE::init_from_* methods.
+
+     Assisted discovery works independently from the automatic discover.
+     An engine is allowed to support only assisted discovery and not
+     support automatic one. Or vice versa.
+   */
+   int (*discover_table_structure)(handlerton *hton, THD* thd,
+                                   TABLE_SHARE *share, HA_CREATE_INFO *info);
 };
 
 
-inline LEX_STRING *hton_name(const handlerton *hton)
+static inline LEX_STRING *hton_name(const handlerton *hton)
 {
   return &(hton2plugin[hton->slot]->name);
 }
 
+static inline sys_var *find_hton_sysvar(handlerton *hton, st_mysql_sys_var *var)
+{
+  return find_plugin_sysvar(hton2plugin[hton->slot], var);
+}
+
 
 /* Possible flags of a handlerton (there can be 32 of them) */
 #define HTON_NO_FLAGS                 0
@@ -1315,9 +1425,10 @@ struct st_partition_iter;
 
 enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES };
 
-typedef struct st_ha_create_information
+struct HA_CREATE_INFO
 {
   CHARSET_INFO *table_charset, *default_table_charset;
+  LEX_CUSTRING tabledef_version;
   LEX_STRING connect_string;
   const char *password, *tablespace;
   LEX_STRING comment;
@@ -1346,16 +1457,18 @@ typedef struct st_ha_create_information
   uint merge_insert_method;
   uint extra_size;                      /* length of extra data segment */
   enum ha_choice transactional;
-  bool frm_only;                        ///< 1 if no ha_create_table()
   bool varchar;                         ///< 1 if table has a VARCHAR
   enum ha_storage_media storage_media;  ///< DEFAULT, DISK or MEMORY
   enum ha_choice page_checksum;         ///< If we have page_checksums
   engine_option_value *option_list;     ///< list of table create options
+
   /* the following three are only for ALTER TABLE, check_if_incompatible_data() */
   ha_table_option_struct *option_struct;           ///< structure with parsed table options
   ha_field_option_struct **fields_option_struct;   ///< array of field option structures
   ha_index_option_struct **indexes_option_struct;  ///< array of index option structures
-} HA_CREATE_INFO;
+
+  bool tmp_table() { return options & HA_LEX_CREATE_TMP_TABLE; }
+};
 
 
 typedef struct st_key_create_information
@@ -2046,8 +2159,8 @@ public:
 
   int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info);
 
-  int ha_create_handler_files(const char *name, const char *old_name,
-                              int action_flag, HA_CREATE_INFO *info);
+  int ha_create_partitioning_metadata(const char *name, const char *old_name,
+                                      int action_flag);
 
   int ha_change_partitions(HA_CREATE_INFO *create_info,
                            const char *path,
@@ -2494,18 +2607,7 @@ public:
   virtual void free_foreign_key_create_info(char* str) {}
   /** The following can be called without an open handler */
   const char *table_type() const { return hton_name(ht)->str; }
-  /**
-    If frm_error() is called then we will use this to find out what file
-    extentions exist for the storage engine. This is also used by the default
-    rename_table and delete_table method in handler.cc.
-
-    For engines that have two file name extentions (separate meta/index file
-    and data file), the order of elements is relevant. First element of engine
-    file name extentions array should be meta/index file extention. Second
-    element - data file extention. This order is assumed by
-    prepare_for_repair() when REPAIR TABLE ... USE_FRM is issued.
-  */
-  virtual const char **bas_ext() const =0;
+  const char **bas_ext() const { return ht->tablefile_extensions; }
 
   virtual int get_default_no_partitions(HA_CREATE_INFO *create_info)
   { return 1;}
@@ -3020,8 +3122,8 @@ private:
   virtual void drop_table(const char *name);
   virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
 
-  virtual int create_handler_files(const char *name, const char *old_name,
-                                   int action_flag, HA_CREATE_INFO *info)
+  virtual int create_partitioning_metadata(const char *name, const char *old_name,
+                                   int action_flag)
   { return FALSE; }
 
   virtual int change_partitions(HA_CREATE_INFO *create_info,
@@ -3091,6 +3193,8 @@ static inline bool ha_storage_engine_is_enabled(const handlerton *db_type)
          (db_type->state == SHOW_OPTION_YES) : FALSE;
 }
 
+#define view_pseudo_hton ((handlerton *)1)
+
 /* basic stuff */
 int ha_init_errors(void);
 int ha_init(void);
@@ -3108,8 +3212,7 @@ void ha_checkpoint_state(bool disable);
 void ha_commit_checkpoint_request(void *cookie, void (*pre_hook)(void *));
 int ha_create_table(THD *thd, const char *path,
                     const char *db, const char *table_name,
-                    HA_CREATE_INFO *create_info,
-		    bool update_create_info);
+                    HA_CREATE_INFO *create_info, LEX_CUSTRING *frm);
 int ha_delete_table(THD *thd, handlerton *db_type, const char *path,
                     const char *db, const char *alias, bool generate_warning);
 
@@ -3117,14 +3220,31 @@ int ha_delete_table(THD *thd, handlerton *db_type, const char *path,
 bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat);
 
 /* discovery */
-int ha_create_table_from_engine(THD* thd, const char *db, const char *name);
-bool ha_check_if_table_exists(THD* thd, const char *db, const char *name,
-                             bool *exists);
-int ha_discover(THD* thd, const char* dbname, const char* name,
-                uchar** frmblob, size_t* frmlen);
-int ha_find_files(THD *thd,const char *db,const char *path,
-                  const char *wild, bool dir, List<LEX_STRING>* files);
-int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
+#ifdef MYSQL_SERVER
+class Discovered_table_list: public handlerton::discovered_list
+{
+  THD *thd;
+  const char *wild, *wend;
+public:
+  Dynamic_array<LEX_STRING*> *tables;
+
+  Discovered_table_list(THD *thd_arg, Dynamic_array<LEX_STRING*> *tables_arg,
+                        const LEX_STRING *wild_arg);
+  ~Discovered_table_list() {}
+
+  bool add_table(const char *tname, size_t tlen);
+  bool add_file(const char *fname);
+
+  void sort();
+  void remove_duplicates(); // assumes that the list is sorted
+};
+
+int ha_discover_table(THD *thd, TABLE_SHARE *share);
+int ha_discover_table_names(THD *thd, LEX_STRING *db, MY_DIR *dirp,
+                            Discovered_table_list *result);
+bool ha_table_exists(THD *thd, const char *db, const char *table_name,
+                     handlerton **hton= 0);
+#endif
 
 /* key cache */
 extern "C" int ha_init_key_cache(const char *name, KEY_CACHE *key_cache, void *);
diff --git a/sql/innodb_priv.h b/sql/innodb_priv.h
index 5406c292b18..24ee848bed1 100644
--- a/sql/innodb_priv.h
+++ b/sql/innodb_priv.h
@@ -25,7 +25,7 @@ class THD;
 int get_quote_char_for_identifier(THD *thd, const char *name, uint length);
 bool schema_table_store_record(THD *thd, TABLE *table);
 void localtime_to_TIME(MYSQL_TIME *to, struct tm *from);
-bool check_global_access(THD *thd, ulong want_access);
+bool check_global_access(THD *thd, ulong want_access, bool no_errors=false);
 uint strconvert(CHARSET_INFO *from_cs, const char *from,
                 CHARSET_INFO *to_cs, char *to, uint to_length,
                 uint *errors);
diff --git a/sql/item.cc b/sql/item.cc
index 665521c641e..ecc7917022e 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2010, 2012, Monty Program Ab
+   Copyright (c) 2010, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -198,7 +198,7 @@ Hybrid_type_traits_integer::fix_length_and_dec(Item *item, Item *arg) const
 
 void item_init(void)
 {
-  item_user_lock_init();
+  item_func_sleep_init();
   uuid_short_init();
 }
 
@@ -807,10 +807,15 @@ bool Item_ident::remove_dependence_processor(uchar * arg)
 bool Item_ident::collect_outer_ref_processor(uchar *param)
 {
   Collect_deps_prm *prm= (Collect_deps_prm *)param;
-  if (depended_from && 
+  if (depended_from &&
       depended_from->nest_level_base == prm->nest_level_base &&
       depended_from->nest_level < prm->nest_level)
-    prm->parameters->add_unique(this, &cmp_items);
+  {
+    if (prm->collect)
+      prm->parameters->add_unique(this, &cmp_items);
+    else
+      prm->count++;
+  }
   return FALSE;
 }
 
@@ -1272,11 +1277,15 @@ bool Item::get_date(MYSQL_TIME *ltime,ulonglong fuzzydate)
     DBUG_ASSERT(0);
   }
 
-  return 0;
+  return null_value= 0;
 
 err:
+  /*
+    if the item was not null and convertion failed, we return a zero date
+    if allowed, otherwise - null.
+  */
   bzero((char*) ltime,sizeof(*ltime));
-  return 1;
+  return null_value|= (fuzzydate & (TIME_NO_ZERO_DATE|TIME_NO_ZERO_IN_DATE));
 }
 
 bool Item::get_seconds(ulonglong *sec, ulong *sec_part)
@@ -4001,8 +4010,8 @@ double Item_copy_string::val_real()
 longlong Item_copy_string::val_int()
 {
   int err;
-  return null_value ? LL(0) : my_strntoll(str_value.charset(),str_value.ptr(),
-                                          str_value.length(),10, (char**) 0,
+  return null_value ? 0 : my_strntoll(str_value.charset(),str_value.ptr(),
+                                          str_value.length(), 10, (char**) 0,
                                           &err); 
 }
 
@@ -4172,7 +4181,7 @@ double Item_copy_decimal::val_real()
 longlong Item_copy_decimal::val_int()
 {
   if (null_value)
-    return LL(0);
+    return 0;
   else
   {
     longlong result;
@@ -6478,6 +6487,13 @@ Item* Item::cache_const_expr_transformer(uchar *arg)
   return this;
 }
 
+/**
+  Find Item by reference in the expression
+*/
+bool Item::find_item_processor(uchar *arg)
+{
+  return (this == ((Item *) arg));
+}
 
 bool Item_field::send(Protocol *protocol, String *buffer)
 {
@@ -8090,7 +8106,7 @@ bool Item_default_value::fix_fields(THD *thd, Item **items)
   }
   if (!(def_field= (Field*) sql_alloc(field_arg->field->size_of())))
     goto error;
-  memcpy(def_field, field_arg->field, field_arg->field->size_of());
+  memcpy((void *)def_field, (void *)field_arg->field, field_arg->field->size_of());
   def_field->move_field_offset((my_ptrdiff_t)
                                (def_field->table->s->default_values -
                                 def_field->table->record[0]));
@@ -8226,7 +8242,7 @@ bool Item_insert_value::fix_fields(THD *thd, Item **items)
     Field *def_field= (Field*) sql_alloc(field_arg->field->size_of());
     if (!def_field)
       return TRUE;
-    memcpy(def_field, field_arg->field, field_arg->field->size_of());
+    memcpy((void *)def_field, (void *)field_arg->field, field_arg->field->size_of());
     def_field->move_field_offset((my_ptrdiff_t)
                                  (def_field->table->insert_values -
                                   def_field->table->record[0]));
@@ -8640,7 +8656,7 @@ int stored_field_cmp_to_item(THD *thd, Field *field, Item *item)
 
 Item_cache* Item_cache::get_cache(const Item *item)
 {
-  return get_cache(item, item->result_type());
+  return get_cache(item, item->cmp_type());
 }
 
 
diff --git a/sql/item.h b/sql/item.h
index 8ec701e0255..6f1b6801669 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -553,6 +553,8 @@ class COND_EQUAL;
 
 class st_select_lex_unit;
 
+class Item_func_not;
+
 class Item {
   Item(const Item &);			/* Prevent use of these */
   void operator=(Item &);
@@ -1153,6 +1155,7 @@ public:
   virtual bool collect_item_field_processor(uchar * arg) { return 0; }
   virtual bool add_field_to_set_processor(uchar * arg) { return 0; }
   virtual bool find_item_in_field_list_processor(uchar *arg) { return 0; }
+  virtual bool find_item_processor(uchar *arg);
   virtual bool change_context_processor(uchar *context) { return 0; }
   virtual bool reset_query_id_processor(uchar *query_id_arg) { return 0; }
   virtual bool is_expensive_processor(uchar *arg) { return 0; }
@@ -1167,9 +1170,10 @@ public:
   virtual bool eval_not_null_tables(uchar *opt_arg) { return 0; }
   virtual bool is_subquery_processor (uchar *opt_arg) { return 0; }
   virtual bool limit_index_condition_pushdown_processor(uchar *opt_arg)
-  { 
+  {
     return FALSE;
   }
+  virtual bool exists2in_processor(uchar *opt_arg) { return 0; }
 
   /* To call bool function for all arguments */
   struct bool_func_call_args
@@ -1186,6 +1190,7 @@ public:
     return FALSE;
   }
 
+
   /*
     The next function differs from the previous one that a bitmap to be updated
     is passed as uchar *arg.
@@ -1315,7 +1320,9 @@ public:
     List<Item> *parameters;
     /* unit from which we count nest_level */
     st_select_lex_unit *nest_level_base;
+    uint count;
     int nest_level;
+    bool collect;
   };
   /**
     Collect outer references
@@ -1478,6 +1485,15 @@ public:
   virtual void get_cache_parameters(List<Item> &parameters) { };
 
   virtual void mark_as_condition_AND_part(TABLE_LIST *embedding) {};
+
+  /* how much position should be reserved for Exists2In transformation */
+  virtual uint exists2in_reserved_items() { return 0; };
+
+  /**
+    Inform the item that it is located under a NOT, which is a top-level item.
+  */
+  virtual void under_not(Item_func_not * upper
+                         __attribute__((unused))) {};
 };
 
 
@@ -2982,6 +2998,13 @@ public:
               alias_name_used_arg)
   {}
 
+  bool fix_fields(THD *thd, Item **it)
+  {
+    if ((!(*ref)->fixed && (*ref)->fix_fields(thd, ref)) ||
+        (*ref)->check_cols(1))
+      return TRUE;
+    return Item_ref::fix_fields(thd, it);
+  }
   void save_val(Field *to);
   double val_real();
   longlong val_int();
@@ -3201,7 +3224,7 @@ public:
   bool subst_argument_checker(uchar **arg);
   Item *equal_fields_propagator(uchar *arg);
   Item *replace_equal_field(uchar *arg);
-  table_map used_tables() const;	
+  table_map used_tables() const;
   table_map not_null_tables() const;
   void update_used_tables();
   bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
@@ -3568,7 +3591,7 @@ public:
   }
   virtual longlong val_int()
   {
-    return null_value ? LL(0) : cached_value;
+    return null_value ? 0 : cached_value;
   }
   virtual void copy();
 };
@@ -4029,6 +4052,7 @@ public:
   bool cache_value();
   bool get_date(MYSQL_TIME *ltime, ulonglong fuzzydate);
   int save_in_field(Field *field, bool no_conversions);
+  Item_result cmp_type() const { return TIME_RESULT; }
   void store_packed(longlong val_arg, Item *example);
   /*
     Having a clone_item method tells optimizer that this object
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 3b09da68927..6f10e84a5f5 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -241,15 +241,15 @@ static uint collect_cmp_types(Item **items, uint nitems, bool skip_nulls= FALSE)
          items[i]->cmp_type() == ROW_RESULT) &&
         cmp_row_type(items[0], items[i]))
       return 0;
-    found_types|= 1<< (uint)item_cmp_type(left_result,
-                                           items[i]->cmp_type());
+    found_types|= 1U << (uint)item_cmp_type(left_result,
+                                            items[i]->cmp_type());
   }
   /*
    Even if all right-hand items are NULLs and we are skipping them all, we need
    at least one type bit in the found_type bitmask.
   */
   if (skip_nulls && !found_types)
-    found_types= 1 << (uint)left_result;
+    found_types= 1U << (uint)left_result;
   return found_types;
 }
 
@@ -906,7 +906,8 @@ get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg,
   }
   if ((*is_null= item->null_value))
     return ~(ulonglong) 0;
-  if (cache_arg && item->const_item() && item->type() != Item::CACHE_ITEM)
+  if (cache_arg && item->const_item() &&
+      !(item->type() == Item::CACHE_ITEM && item->cmp_type() == TIME_RESULT))
   {
     Query_arena backup;
     Query_arena *save_arena= thd->switch_to_arena_for_cached_items(&backup);
@@ -1434,7 +1435,7 @@ bool Item_in_optimizer::eval_not_null_tables(uchar *opt_arg)
   return FALSE;
 }
 
-bool Item_in_optimizer::fix_left(THD *thd, Item **ref)
+bool Item_in_optimizer::fix_left(THD *thd)
 {
   if ((!args[0]->fixed && args[0]->fix_fields(thd, args)) ||
       (!cache && !(cache= Item_cache::get_cache(args[0]))))
@@ -1482,6 +1483,13 @@ bool Item_in_optimizer::fix_left(THD *thd, Item **ref)
     cache->store(args[0]);
     cache->cache_value();
   }
+  if (args[1]->fixed)
+  {
+    /* to avoid overriding is called to update left expression */
+    used_tables_cache|= args[1]->used_tables();
+    with_sum_func= with_sum_func || args[1]->with_sum_func;
+    const_item_cache= const_item_cache && args[1]->const_item();
+  }
   return 0;
 }
 
@@ -1489,15 +1497,17 @@ bool Item_in_optimizer::fix_left(THD *thd, Item **ref)
 bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
 {
   DBUG_ASSERT(fixed == 0);
-  if (fix_left(thd, ref))
+  if (fix_left(thd))
     return TRUE;
   if (args[0]->maybe_null)
     maybe_null=1;
 
   if (!args[1]->fixed && args[1]->fix_fields(thd, args+1))
     return TRUE;
+
   Item_in_subselect * sub= (Item_in_subselect *)args[1];
-  if (args[0]->cols() != sub->engine->cols())
+  if (!invisible_mode() &&
+      args[0]->cols() != sub->engine->cols())
   {
     my_error(ER_OPERAND_COLUMNS, MYF(0), args[0]->cols());
     return TRUE;
@@ -1513,6 +1523,30 @@ bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
   return FALSE;
 }
 
+/**
+  Check if Item_in_optimizer should work as a pass-through item for its 
+  arguments.
+
+  @note 
+   Item_in_optimizer should work as pass-through for
+    - subqueries that were processed by ALL/ANY->MIN/MAX rewrite
+    - subqueries taht were originally EXISTS subqueries (and were coverted by
+      the EXISTS->IN rewrite)
+
+   When Item_in_optimizer is not not working as a pass-through, it
+    - caches its "left argument", args[0].
+    - makes adjustments to subquery item's return value for proper NULL
+      value handling
+*/
+
+bool Item_in_optimizer::invisible_mode()
+{
+  /* MAX/MIN transformed or EXISTS->IN prepared => do nothing */
+ return (args[1]->type() != Item::SUBSELECT_ITEM ||
+         ((Item_subselect *)args[1])->substype() ==
+         Item_subselect::EXISTS_SUBS);
+}
+
 
 /**
   Add an expression cache for this subquery if it is needed
@@ -1536,8 +1570,9 @@ Item *Item_in_optimizer::expr_cache_insert_transformer(uchar *thd_arg)
 {
   THD *thd= (THD*) thd_arg;
   DBUG_ENTER("Item_in_optimizer::expr_cache_insert_transformer");
-  if (args[1]->type() != Item::SUBSELECT_ITEM)
-    DBUG_RETURN(this); // MAX/MIN transformed => do nothing
+
+  if (invisible_mode())
+    DBUG_RETURN(this);
 
   if (expr_cache)
     DBUG_RETURN(expr_cache);
@@ -1560,13 +1595,16 @@ Item *Item_in_optimizer::expr_cache_insert_transformer(uchar *thd_arg)
 void Item_in_optimizer::get_cache_parameters(List<Item> &parameters)
 {
   /* Add left expression to the list of the parameters of the subquery */
-  if (args[0]->cols() == 1)
-    parameters.add_unique(args[0], &cmp_items);
-  else
+  if (!invisible_mode())
   {
-    for (uint i= 0; i < args[0]->cols(); i++)
+    if (args[0]->cols() == 1)
+      parameters.add_unique(args[0], &cmp_items);
+    else
     {
-      parameters.add_unique(args[0]->element_index(i), &cmp_items);
+      for (uint i= 0; i < args[0]->cols(); i++)
+      {
+        parameters.add_unique(args[0]->element_index(i), &cmp_items);
+      }
     }
   }
   args[1]->get_cache_parameters(parameters);
@@ -1649,17 +1687,19 @@ longlong Item_in_optimizer::val_int()
   DBUG_ASSERT(fixed == 1);
   cache->store(args[0]);
   cache->cache_value();
+  DBUG_ENTER(" Item_in_optimizer::val_int");
 
-  if (args[1]->type() != Item::SUBSELECT_ITEM)
+  if (invisible_mode())
   {
-    /* MAX/MIN transformed => pass through */
     longlong res= args[1]->val_int();
     null_value= args[1]->null_value;
-    return (res);
+    DBUG_PRINT("info", ("pass trough"));
+    DBUG_RETURN(res);
   }
 
   if (cache->null_value)
   {
+     DBUG_PRINT("info", ("Left NULL..."));
     /*
       We're evaluating 
       "<outer_value_list> [NOT] IN (SELECT <inner_value_list>...)" 
@@ -1731,11 +1771,11 @@ longlong Item_in_optimizer::val_int()
       for (uint i= 0; i < ncols; i++)
         item_subs->set_cond_guard_var(i, TRUE);
     }
-    return 0;
+    DBUG_RETURN(0);
   }
   tmp= args[1]->val_bool_result();
   null_value= args[1]->null_value;
-  return tmp;
+  DBUG_RETURN(tmp);
 }
 
 
@@ -1786,7 +1826,8 @@ bool Item_in_optimizer::is_null()
     @retval NULL if an error occurred
 */
 
-Item *Item_in_optimizer::transform(Item_transformer transformer, uchar *argument)
+Item *Item_in_optimizer::transform(Item_transformer transformer,
+                                   uchar *argument)
 {
   Item *new_item;
 
@@ -1806,7 +1847,7 @@ Item *Item_in_optimizer::transform(Item_transformer transformer, uchar *argument
   if ((*args) != new_item)
     current_thd->change_item_tree(args, new_item);
 
-  if (args[1]->type() != Item::SUBSELECT_ITEM)
+  if (invisible_mode())
   {
     /* MAX/MIN transformed => pass through */
     new_item= args[1]->transform(transformer, argument);
@@ -2824,12 +2865,12 @@ Item *Item_func_case::find_item(String *str)
       cmp_type= item_cmp_type(left_result_type, args[i]->cmp_type());
       DBUG_ASSERT(cmp_type != ROW_RESULT);
       DBUG_ASSERT(cmp_items[(uint)cmp_type]);
-      if (!(value_added_map & (1<<(uint)cmp_type)))
+      if (!(value_added_map & (1U << (uint)cmp_type)))
       {
         cmp_items[(uint)cmp_type]->store_value(args[first_expr_num]);
         if ((null_value=args[first_expr_num]->null_value))
           return else_expr_num != -1 ? args[else_expr_num] : 0;
-        value_added_map|= 1<<(uint)cmp_type;
+        value_added_map|= 1U << (uint)cmp_type;
       }
       if (!cmp_items[(uint)cmp_type]->cmp(args[i]) && !args[i]->null_value)
         return args[i + 1];
@@ -3036,10 +3077,10 @@ void Item_func_case::fix_length_and_dec()
       return;
 
     Item *date_arg= 0;
-    if (found_types & (1 << TIME_RESULT))
+    if (found_types & (1U << TIME_RESULT))
       date_arg= find_date_time_item(args, arg_count, 0);
 
-    if (found_types & (1 << STRING_RESULT))
+    if (found_types & (1U << STRING_RESULT))
     {
       /*
         If we'll do string comparison, we also need to aggregate
@@ -3080,7 +3121,7 @@ void Item_func_case::fix_length_and_dec()
 
     for (i= 0; i <= (uint)TIME_RESULT; i++)
     {
-      if (found_types & (1 << i) && !cmp_items[i])
+      if (found_types & (1U << i) && !cmp_items[i])
       {
         DBUG_ASSERT((Item_result)i != ROW_RESULT);
 
@@ -3936,7 +3977,7 @@ void Item_func_in::fix_length_and_dec()
   }
   for (i= 0; i <= (uint)TIME_RESULT; i++)
   {
-    if (found_types & 1 << i)
+    if (found_types & (1U << i))
     {
       (type_cnt)++;
       cmp_type= (Item_result) i;
@@ -4063,14 +4104,14 @@ void Item_func_in::fix_length_and_dec()
   }
   else
   {
-    if (found_types & (1 << TIME_RESULT))
+    if (found_types & (1U << TIME_RESULT))
       date_arg= find_date_time_item(args, arg_count, 0);
-    if (found_types & (1 << STRING_RESULT) &&
+    if (found_types & (1U << STRING_RESULT) &&
         agg_arg_charsets_for_comparison(cmp_collation, args, arg_count))
       return;
     for (i= 0; i <= (uint) TIME_RESULT; i++)
     {
-      if (found_types & (1 << i) && !cmp_items[i])
+      if (found_types & (1U << i) && !cmp_items[i])
       {
         if (!cmp_items[i] && !(cmp_items[i]=
             cmp_item::get_comparator((Item_result)i, date_arg,
@@ -4156,12 +4197,12 @@ longlong Item_func_in::val_int()
     Item_result cmp_type= item_cmp_type(left_result_type, args[i]->cmp_type());
     in_item= cmp_items[(uint)cmp_type];
     DBUG_ASSERT(in_item);
-    if (!(value_added_map & (1 << (uint)cmp_type)))
+    if (!(value_added_map & (1U << (uint)cmp_type)))
     {
       in_item->store_value(args[0]);
       if ((null_value= args[0]->null_value))
         return 0;
-      value_added_map|= 1 << (uint)cmp_type;
+      value_added_map|= 1U << (uint)cmp_type;
     }
     if (!in_item->cmp(args[i]) && !args[i]->null_value)
       return (longlong) (!negated);
@@ -5350,6 +5391,7 @@ Item *Item_func_not::neg_transformer(THD *thd)	/* NOT(x)  ->  x */
 
 bool Item_func_not::fix_fields(THD *thd, Item **ref)
 {
+  args[0]->under_not(this);
   if (args[0]->type() == FIELD_ITEM)
   {
     /* replace  "NOT <field>" with "<filed> == 0" */
@@ -5533,6 +5575,7 @@ Item_equal::Item_equal(Item *f1, Item *f2, bool with_const_item)
   equal_items.push_back(f1);
   equal_items.push_back(f2);
   compare_as_dates= with_const_item && f2->cmp_type() == TIME_RESULT;
+  upper_levels= NULL;  
 }
 
 
@@ -5561,10 +5604,11 @@ Item_equal::Item_equal(Item_equal *item_equal)
   with_const= item_equal->with_const;
   compare_as_dates= item_equal->compare_as_dates;
   cond_false= item_equal->cond_false;
+  upper_levels= item_equal->upper_levels;
 }
 
 
-/*
+/**
   @brief
   Add a constant item to the Item_equal object
 
@@ -5618,6 +5662,7 @@ void Item_equal::add_const(Item *c, Item *f)
     const_item_cache= 1;
 }
 
+
 /**
   @brief
   Check whether a field is referred to in the multiple equality
@@ -5686,6 +5731,87 @@ void Item_equal::merge(Item_equal *item)
 
 /**
   @brief
+  Merge members of another Item_equal object into this one
+  
+  @param item    multiple equality whose members are to be merged
+
+  @details
+  If the Item_equal 'item' happened to have some elements of the list
+  of equal items belonging to 'this' object then the function merges
+  the equal items from 'item' into this list.
+  If both lists contains constants and they are different then
+  the value of the cond_false flag is set to TRUE.
+
+  @retval
+    1    the lists of equal items in 'item' and 'this' contain common elements 
+  @retval
+    0    otherwise 
+
+  @notes
+  The method 'merge' just joins the list of equal items belonging to 'item'
+  to the list of equal items belonging to this object assuming that the lists
+  are disjoint. It would be more correct to call the method 'join'.
+  The method 'merge_with_check' really merges two lists of equal items if they
+  have common members.  
+*/
+  
+bool Item_equal::merge_with_check(Item_equal *item)
+{
+  bool intersected= FALSE;
+  Item_equal_fields_iterator_slow fi(*this);
+  while (fi++)
+  {
+    if (item->contains(fi.get_curr_field()))
+    {
+      fi.remove();
+      intersected= TRUE;
+    }
+  }
+  if (intersected)
+    item->merge(this);
+  return intersected;
+}
+
+
+/**
+  @brief
+  Merge this object into a list of Item_equal objects 
+  
+  @param list   the list of Item_equal objects to merge into
+
+  @details
+  If the list of equal items from 'this' object contains common members
+  with the lists of equal items belonging to Item_equal objects from 'list'
+  then all involved Item_equal objects e1,...,ek are merged into one 
+  Item equal that replaces e1,...,ek in the 'list'. Otherwise this
+  Item_equal is joined to the 'list'.
+*/
+
+void Item_equal::merge_into_list(List<Item_equal> *list)
+{
+  Item_equal *item;
+  List_iterator<Item_equal> it(*list);
+  Item_equal *merge_into= NULL;
+  while((item= it++))
+  {
+    if (!merge_into)
+    {
+      if (merge_with_check(item))
+        merge_into= item;
+    }
+    else
+    {
+      if (item->merge_with_check(merge_into))
+        it.remove();
+    }
+  }
+  if (!merge_into)
+    list->push_back(this);
+}
+
+
+/**
+  @brief
   Order equal items of the  multiple equality according to a sorting criteria
 
   @param compare      function to compare items from the equal_items list
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index afb7bf005bb..4ca31e01df9 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -246,12 +246,12 @@ protected:
   */
   int result_for_null_param;
 public:
-  Item_in_optimizer(Item *a, Item_in_subselect *b):
-    Item_bool_func(a, reinterpret_cast<Item *>(b)), cache(0), expr_cache(0),
+  Item_in_optimizer(Item *a, Item *b):
+    Item_bool_func(a, b), cache(0), expr_cache(0),
     save_cache(0), result_for_null_param(UNKNOWN)
   { with_subselect= true; }
   bool fix_fields(THD *, Item **);
-  bool fix_left(THD *thd, Item **ref);
+  bool fix_left(THD *thd);
   table_map not_null_tables() const { return 0; }
   bool is_null();
   longlong val_int();
@@ -269,6 +269,8 @@ public:
   bool is_top_level_item();
   bool eval_not_null_tables(uchar *opt_arg);
   void fix_after_pullout(st_select_lex *new_parent, Item **ref);
+  bool invisible_mode();
+  void reset_cache() { cache= NULL; }
 };
 
 class Comp_creator
@@ -436,8 +438,11 @@ public:
 
 class Item_func_not :public Item_bool_func
 {
+  bool abort_on_null;
 public:
-  Item_func_not(Item *a) :Item_bool_func(a) {}
+  Item_func_not(Item *a) :Item_bool_func(a), abort_on_null(FALSE) {}
+  virtual void top_level_item() { abort_on_null= 1; }
+  bool is_top_level_item() { return abort_on_null; }
   longlong val_int();
   enum Functype functype() const { return NOT_FUNC; }
   const char *func_name() const { return "not"; }
@@ -495,16 +500,13 @@ class Item_func_not_all :public Item_func_not
   Item_sum_hybrid *test_sum_item;
   Item_maxmin_subselect *test_sub_item;
 
-  bool abort_on_null;
 public:
   bool show;
 
   Item_func_not_all(Item *a)
-    :Item_func_not(a), test_sum_item(0), test_sub_item(0), abort_on_null(0),
+    :Item_func_not(a), test_sum_item(0), test_sub_item(0),
      show(0)
     {}
-  virtual void top_level_item() { abort_on_null= 1; }
-  bool is_top_level_item() { return abort_on_null; }
   table_map not_null_tables() const { return 0; }
   longlong val_int();
   enum Functype functype() const { return NOT_ALL_FUNC; }
@@ -550,6 +552,7 @@ public:
     - Otherwise, UINT_MAX
   */
   uint in_equality_no;
+  virtual uint exists2in_reserved_items() { return 1; };
 };
 
 class Item_func_equal :public Item_bool_rowready_func2
@@ -1575,6 +1578,11 @@ public:
     DBUG_ASSERT(nlist->elements);
     list.prepand(nlist);
   }
+  void add_at_end(List<Item> *nlist)
+  {
+    DBUG_ASSERT(nlist->elements);
+    list.concat(nlist);
+  }
   bool fix_fields(THD *, Item **ref);
   void fix_after_pullout(st_select_lex *new_parent, Item **ref);
 
@@ -1600,6 +1608,7 @@ public:
   bool eval_not_null_tables(uchar *opt_arg);
 };
 
+template <template<class> class LI, class T> class Item_equal_iterator;
 
 /*
   The class Item_equal is used to represent conjunctions of equality
@@ -1727,7 +1736,11 @@ class Item_equal: public Item_bool_func
     used in the original equality.
   */
   Item_field *context_field;
+
 public:
+
+  COND_EQUAL *upper_levels;       /* multiple equalities of upper and levels */
+
   inline Item_equal()
     : Item_bool_func(), with_const(FALSE), eval_item(0), cond_false(0),
       context_field(NULL)
@@ -1744,6 +1757,8 @@ public:
   /** Get number of field items / references to field items in this object */   
   uint n_field_items() { return equal_items.elements-test(with_const); }
   void merge(Item_equal *item);
+  bool merge_with_check(Item_equal *equal_item);
+  void merge_into_list(List<Item_equal> *list);
   void update_const();
   enum Functype functype() const { return MULT_EQUAL_FUNC; }
   longlong val_int(); 
@@ -1759,7 +1774,8 @@ public:
   CHARSET_INFO *compare_collation();
 
   void set_context_field(Item_field *ctx_field) { context_field= ctx_field; }
-  friend class Item_equal_fields_iterator;
+  friend class Item_equal_iterator<List_iterator_fast,Item>;
+  friend class Item_equal_iterator<List_iterator,Item>;
   friend Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,
                            Item_equal *item_equal);
   friend bool setup_sj_materialization_part1(struct st_join_table *tab);
@@ -1778,43 +1794,55 @@ public:
   { 
     upper_levels= 0;
   }
+  void copy(COND_EQUAL &cond_equal)
+  {
+    max_members= cond_equal.max_members;
+    upper_levels= cond_equal.upper_levels;
+    if (cond_equal.current_level.is_empty())
+      current_level.empty();
+    else
+      current_level= cond_equal.current_level;
+  }
 };
 
 
 /* 
-  The class Item_equal_fields_iterator is used to iterate over references
-  to table/view columns from a list of equal items.
+  The template Item_equal_iterator is used to define classes
+  Item_equal_fields_iterator and Item_equal_fields_iterator_slow.
+  These are helper classes for the class Item equal
+  Both classes are used to iterate over references to table/view columns
+  from the list of equal items that included in an Item_equal object. 
+  The second class supports the operation of removal of the current member
+  from the list when performing an iteration.
 */ 
 
-class Item_equal_fields_iterator : public List_iterator_fast<Item>
+template <template<class> class LI, typename T> class Item_equal_iterator
+  : public LI<T>
 {
+protected:
   Item_equal *item_equal;
   Item *curr_item;
 public:
-  Item_equal_fields_iterator(Item_equal &item_eq) 
-    :List_iterator_fast<Item> (item_eq.equal_items)
+  Item_equal_iterator<LI,T>(Item_equal &item_eq) 
+    :LI<T> (item_eq.equal_items)
   {
     curr_item= NULL;
     item_equal= &item_eq;
     if (item_eq.with_const)
     {
-      List_iterator_fast<Item> *list_it= this;
+      LI<T> *list_it= this;
       curr_item=  (*list_it)++;
     }
   }
   Item* operator++(int)
   { 
-    List_iterator_fast<Item> *list_it= this;
+    LI<T> *list_it= this;
     curr_item= (*list_it)++;
     return curr_item;
   }
-  Item ** ref()
-  {
-    return List_iterator_fast<Item>::ref();
-  }
   void rewind(void) 
   { 
-    List_iterator_fast<Item> *list_it= this;
+    LI<T> *list_it= this;
     list_it->rewind();
     if (item_equal->with_const)
       curr_item= (*list_it)++;
@@ -1826,6 +1854,36 @@ public:
   }  
 };
 
+typedef  Item_equal_iterator<List_iterator_fast,Item >  Item_equal_iterator_fast;
+
+class Item_equal_fields_iterator
+  :public Item_equal_iterator_fast
+{
+public:
+  Item_equal_fields_iterator(Item_equal &item_eq) 
+    :Item_equal_iterator_fast(item_eq)
+  { }
+  Item ** ref()
+  {
+    return List_iterator_fast<Item>::ref();
+  }
+};
+
+typedef Item_equal_iterator<List_iterator,Item > Item_equal_iterator_iterator_slow;
+
+class Item_equal_fields_iterator_slow
+  :public Item_equal_iterator_iterator_slow
+{
+public:
+  Item_equal_fields_iterator_slow(Item_equal &item_eq) 
+    :Item_equal_iterator_iterator_slow(item_eq)
+  { }
+  void remove()
+  {
+    List_iterator<Item>::remove();
+  }
+};
+
 
 class Item_cond_and :public Item_cond
 {
@@ -1851,6 +1909,7 @@ public:
   }
   Item *neg_transformer(THD *thd);
   void mark_as_condition_AND_part(TABLE_LIST *embedding);
+  virtual uint exists2in_reserved_items() { return list.elements; };
 };
 
 inline bool is_cond_and(Item *item)
diff --git a/sql/item_create.cc b/sql/item_create.cc
index fc31b074055..ba6eb7ff603 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -4453,8 +4453,7 @@ Create_func_make_set::create_native(THD *thd, LEX_STRING name,
     return NULL;
   }
 
-  Item *param_1= item_list->pop();
-  return new (thd->mem_root) Item_func_make_set(param_1, *item_list);
+  return new (thd->mem_root) Item_func_make_set(*item_list);
 }
 
 
diff --git a/sql/item_func.cc b/sql/item_func.cc
index ed457adcff9..4df7638370a 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -769,13 +769,14 @@ void Item_num_op::find_num_type(void)
   {
     hybrid_type= DECIMAL_RESULT;
     result_precision();
+    fix_decimals();
   }
   else
   {
     DBUG_ASSERT(r0 == INT_RESULT && r1 == INT_RESULT);
-    decimals= 0;
     hybrid_type=INT_RESULT;
     result_precision();
+    decimals= 0;
   }
   DBUG_PRINT("info", ("Type: %s",
              (hybrid_type == REAL_RESULT ? "REAL_RESULT" :
@@ -1706,6 +1707,7 @@ void Item_func_div::fix_length_and_dec()
     break;
   case DECIMAL_RESULT:
     result_precision();
+    fix_decimals();
     break;
   case STRING_RESULT:
   case ROW_RESULT:
@@ -1905,6 +1907,16 @@ longlong Item_func_neg::int_op()
   if (args[0]->unsigned_flag &&
       (ulonglong) value > (ulonglong) LONGLONG_MAX + 1)
     return raise_integer_overflow();
+
+  if (value == LONGLONG_MIN)
+  {
+    if (args[0]->unsigned_flag != unsigned_flag)
+      /* negation of LONGLONG_MIN is LONGLONG_MIN. */
+      return LONGLONG_MIN; 
+    else
+      return raise_integer_overflow();
+  }
+
   return check_integer_overflow(-value, !args[0]->unsigned_flag && value < 0);
 }
 
@@ -2201,7 +2213,7 @@ longlong Item_func_shift_left::val_int()
     return 0;
   }
   null_value=0;
-  return (shift < sizeof(longlong)*8 ? (longlong) res : LL(0));
+  return (shift < sizeof(longlong)*8 ? (longlong) res : 0);
 }
 
 longlong Item_func_shift_right::val_int()
@@ -2216,7 +2228,7 @@ longlong Item_func_shift_right::val_int()
     return 0;
   }
   null_value=0;
-  return (shift < sizeof(longlong)*8 ? (longlong) res : LL(0));
+  return (shift < sizeof(longlong)*8 ? (longlong) res : 0);
 }
 
 
@@ -3149,7 +3161,7 @@ void Item_func_find_in_set::fix_length_and_dec()
 			      find->length(), 0);
 	enum_bit=0;
 	if (enum_value)
-	  enum_bit=LL(1) << (enum_value-1);
+	  enum_bit=1LL << (enum_value-1);
       }
     }
   }
@@ -3230,7 +3242,7 @@ longlong Item_func_find_in_set::val_int()
                wc == (my_wc_t) separator)
         return (longlong) ++position;
       else
-        return LL(0);
+        return 0;
     }
   }
   return 0;
@@ -3736,120 +3748,6 @@ udf_handler::~udf_handler()
 bool udf_handler::get_arguments() { return 0; }
 #endif /* HAVE_DLOPEN */
 
-/*
-** User level locks
-*/
-
-mysql_mutex_t LOCK_user_locks;
-static HASH hash_user_locks;
-
-class User_level_lock
-{
-  uchar *key;
-  size_t key_length;
-
-public:
-  int count;
-  bool locked;
-  mysql_cond_t cond;
-  my_thread_id thread_id;
-  void set_thread(THD *thd) { thread_id= thd->thread_id; }
-
-  User_level_lock(const uchar *key_arg,uint length, ulong id) 
-    :key_length(length),count(1),locked(1), thread_id(id)
-  {
-    key= (uchar*) my_memdup(key_arg,length,MYF(0));
-    mysql_cond_init(key_user_level_lock_cond, &cond, NULL);
-    if (key)
-    {
-      if (my_hash_insert(&hash_user_locks,(uchar*) this))
-      {
-	my_free(key);
-	key=0;
-      }
-    }
-  }
-  ~User_level_lock()
-  {
-    if (key)
-    {
-      my_hash_delete(&hash_user_locks,(uchar*) this);
-      my_free(key);
-    }
-    mysql_cond_destroy(&cond);
-  }
-  inline bool initialized() { return key != 0; }
-  friend void item_user_lock_release(User_level_lock *ull);
-  friend uchar *ull_get_key(const User_level_lock *ull, size_t *length,
-                            my_bool not_used);
-};
-
-uchar *ull_get_key(const User_level_lock *ull, size_t *length,
-                   my_bool not_used __attribute__((unused)))
-{
-  *length= ull->key_length;
-  return ull->key;
-}
-
-#ifdef HAVE_PSI_INTERFACE
-static PSI_mutex_key key_LOCK_user_locks;
-
-static PSI_mutex_info all_user_mutexes[]=
-{
-  { &key_LOCK_user_locks, "LOCK_user_locks", PSI_FLAG_GLOBAL}
-};
-
-static void init_user_lock_psi_keys(void)
-{
-  const char* category= "sql";
-  int count;
-
-  if (PSI_server == NULL)
-    return;
-
-  count= array_elements(all_user_mutexes);
-  PSI_server->register_mutex(category, all_user_mutexes, count);
-}
-#endif
-
-static bool item_user_lock_inited= 0;
-
-void item_user_lock_init(void)
-{
-#ifdef HAVE_PSI_INTERFACE
-  init_user_lock_psi_keys();
-#endif
-
-  mysql_mutex_init(key_LOCK_user_locks, &LOCK_user_locks, MY_MUTEX_INIT_SLOW);
-  my_hash_init(&hash_user_locks,system_charset_info,
-	    16,0,0,(my_hash_get_key) ull_get_key,NULL,0);
-  item_user_lock_inited= 1;
-}
-
-void item_user_lock_free(void)
-{
-  if (item_user_lock_inited)
-  {
-    item_user_lock_inited= 0;
-    my_hash_free(&hash_user_locks);
-    mysql_mutex_destroy(&LOCK_user_locks);
-  }
-}
-
-void item_user_lock_release(User_level_lock *ull)
-{
-  ull->locked=0;
-  ull->thread_id= 0;
-  if (--ull->count)
-    mysql_cond_signal(&ull->cond);
-  else
-    delete ull;
-}
-
-/**
-  Wait until we are at or past the given position in the master binlog
-  on the slave.
-*/
 
 longlong Item_master_pos_wait::val_int()
 {
@@ -3951,7 +3849,7 @@ class Interruptible_wait
 
 
 /** Time to wait before polling the connection status. */
-const ulonglong Interruptible_wait::m_interrupt_interval= 5 * ULL(1000000000);
+const ulonglong Interruptible_wait::m_interrupt_interval= 5 * 1000000000ULL;
 
 
 /**
@@ -3996,7 +3894,136 @@ int Interruptible_wait::wait(mysql_cond_t *cond, mysql_mutex_t *mutex)
 
 
 /**
-  Get a user level lock.  If the thread has an old lock this is first released.
+  For locks with EXPLICIT duration, MDL returns a new ticket
+  every time a lock is granted. This allows to implement recursive
+  locks without extra allocation or additional data structures, such
+  as below. However, if there are too many tickets in the same
+  MDL_context, MDL_context::find_ticket() is getting too slow,
+  since it's using a linear search.
+  This is why a separate structure is allocated for a user
+  level lock, and before requesting a new lock from MDL,
+  GET_LOCK() checks thd->ull_hash if such lock is already granted,
+  and if so, simply increments a reference counter.
+*/
+
+class User_level_lock
+{
+public:
+  MDL_ticket *lock;
+  int refs;
+};
+
+
+/** Extract a hash key from User_level_lock. */
+
+uchar *ull_get_key(const uchar *ptr, size_t *length,
+                   my_bool not_used __attribute__((unused)))
+{
+  User_level_lock *ull = (User_level_lock*) ptr;
+  MDL_key *key = ull->lock->get_key();
+  *length= key->length();
+  return (uchar*) key->ptr();
+}
+
+
+/**
+  Release all user level locks for this THD.
+*/
+
+void mysql_ull_cleanup(THD *thd)
+{
+  User_level_lock *ull;
+  DBUG_ENTER("mysql_ull_cleanup");
+
+  for (uint i= 0; i < thd->ull_hash.records; i++)
+  {
+    ull = (User_level_lock*) my_hash_element(&thd->ull_hash, i);
+    thd->mdl_context.release_lock(ull->lock);
+    my_free(ull);
+  }
+
+  my_hash_free(&thd->ull_hash);
+
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Set explicit duration for metadata locks corresponding to
+  user level locks to protect them from being released at the end
+  of transaction.
+*/
+
+void mysql_ull_set_explicit_lock_duration(THD *thd)
+{
+  User_level_lock *ull;
+  DBUG_ENTER("mysql_ull_set_explicit_lock_duration");
+
+  for (uint i= 0; i < thd->ull_hash.records; i++)
+  {
+    ull= (User_level_lock*) my_hash_element(&thd->ull_hash, i);
+    thd->mdl_context.set_lock_duration(ull->lock, MDL_EXPLICIT);
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  When MDL detects a lock wait timeout, it pushes
+  an error into the statement diagnostics area.
+  For GET_LOCK(), lock wait timeout is not an error,
+  but a special return value (0). NULL is returned in
+  case of error.
+  Capture and suppress lock wait timeout.
+*/
+
+class Lock_wait_timeout_handler: public Internal_error_handler
+{
+public:
+  Lock_wait_timeout_handler() :m_lock_wait_timeout(false) {}
+
+  bool m_lock_wait_timeout;
+
+  bool handle_condition(THD * /* thd */, uint sql_errno,
+                        const char * /* sqlstate */,
+                        MYSQL_ERROR::enum_warning_level /* level */,
+                        const char *message,
+                        MYSQL_ERROR ** /* cond_hdl */);
+};
+
+bool
+Lock_wait_timeout_handler::
+handle_condition(THD * /* thd */, uint sql_errno,
+                 const char * /* sqlstate */,
+                 MYSQL_ERROR::enum_warning_level /* level */,
+                 const char *message,
+                 MYSQL_ERROR ** /* cond_hdl */)
+{
+  if (sql_errno == ER_LOCK_WAIT_TIMEOUT)
+  {
+    m_lock_wait_timeout= true;
+    return true;                                /* condition handled */
+  }
+  return false;
+}
+
+
+static int ull_name_ok(String *name)
+{
+  if (!name || !name->length())
+    return 0;
+
+  if (name->length() > NAME_LEN)
+  {
+    my_error(ER_TOO_LONG_IDENT, MYF(0), name->c_ptr_safe());
+    return 0;
+  }
+  return 1;
+}
+
+
+/**
+  Get a user level lock.
 
   @retval
     1    : Got lock
@@ -4009,14 +4036,13 @@ int Interruptible_wait::wait(mysql_cond_t *cond, mysql_mutex_t *mutex)
 longlong Item_func_get_lock::val_int()
 {
   DBUG_ASSERT(fixed == 1);
-  String *res=args[0]->val_str(&value);
+  String *res= args[0]->val_str(&value);
   ulonglong timeout= args[1]->val_int();
-  THD *thd=current_thd;
+  THD *thd= current_thd;
   User_level_lock *ull;
-  int error;
-  Interruptible_wait timed_cond(thd);
   DBUG_ENTER("Item_func_get_lock::val_int");
 
+  null_value= 1;
   /*
     In slave thread no need to get locks, everything is serialized. Anyway
     there is no way to make GET_LOCK() work on slave like it did on master
@@ -4025,103 +4051,70 @@ longlong Item_func_get_lock::val_int()
     it's not guaranteed to be same as on master.
   */
   if (thd->slave_thread)
+  {
+    null_value= 0;
     DBUG_RETURN(1);
+  }
 
-  mysql_mutex_lock(&LOCK_user_locks);
-
-  if (!res || !res->length())
-  {
-    mysql_mutex_unlock(&LOCK_user_locks);
-    null_value=1;
+  if (!ull_name_ok(res))
     DBUG_RETURN(0);
-  }
+
   DBUG_PRINT("info", ("lock %.*s, thd=%ld", res->length(), res->ptr(),
                       (long) thd->real_id));
-  null_value=0;
-
-  if (thd->ull)
+  /* HASH entries are of type User_level_lock. */
+  if (! my_hash_inited(&thd->ull_hash) &&
+        my_hash_init(&thd->ull_hash, &my_charset_bin,
+                     16 /* small hash */, 0, 0, ull_get_key, NULL, 0))
   {
-    item_user_lock_release(thd->ull);
-    thd->ull=0;
-  }
-
-  if (!(ull= ((User_level_lock *) my_hash_search(&hash_user_locks,
-                                                 (uchar*) res->ptr(),
-                                                 (size_t) res->length()))))
-  {
-    ull= new User_level_lock((uchar*) res->ptr(), (size_t) res->length(),
-                             thd->thread_id);
-    if (!ull || !ull->initialized())
-    {
-      delete ull;
-      mysql_mutex_unlock(&LOCK_user_locks);
-      null_value=1;				// Probably out of memory
-      DBUG_RETURN(0);
-    }
-    ull->set_thread(thd);
-    thd->ull=ull;
-    mysql_mutex_unlock(&LOCK_user_locks);
-    DBUG_PRINT("info", ("made new lock"));
-    DBUG_RETURN(1);				// Got new lock
+    DBUG_RETURN(0);
   }
-  ull->count++;
-  DBUG_PRINT("info", ("ull->count=%d", ull->count));
 
-  /*
-    Structure is now initialized.  Try to get the lock.
-    Set up control struct to allow others to abort locks.
-  */
-  THD_STAGE_INFO(thd, stage_user_lock);
-  thd->mysys_var->current_mutex= &LOCK_user_locks;
-  thd->mysys_var->current_cond=  &ull->cond;
+  MDL_request ull_request;
+  ull_request.init(MDL_key::USER_LOCK, res->c_ptr_safe(), "",
+                   MDL_SHARED_NO_WRITE, MDL_EXPLICIT);
+  MDL_key *ull_key = &ull_request.key;
 
-  timed_cond.set_timeout(timeout * ULL(1000000000));
 
-  error= 0;
-  thd_wait_begin(thd, THD_WAIT_USER_LOCK);
-  while (ull->locked && !thd->killed)
+  if ((ull= (User_level_lock*)
+       my_hash_search(&thd->ull_hash, ull_key->ptr(), ull_key->length())))
   {
-    DBUG_PRINT("info", ("waiting on lock"));
-    error= timed_cond.wait(&ull->cond, &LOCK_user_locks);
-    if (error == ETIMEDOUT || error == ETIME)
-    {
-      DBUG_PRINT("info", ("lock wait timeout"));
-      break;
-    }
-    error= 0;
+    /* Recursive lock */
+    ull->refs++;
+    null_value = 0;
+    DBUG_RETURN(1);
   }
-  thd_wait_end(thd);
 
-  if (ull->locked)
+  Lock_wait_timeout_handler lock_wait_timeout_handler;
+  thd->push_internal_handler(&lock_wait_timeout_handler);
+  bool error= thd->mdl_context.acquire_lock(&ull_request, timeout);
+  (void) thd->pop_internal_handler();
+  if (error)
   {
-    if (!--ull->count)
-    {
-      DBUG_ASSERT(0);
-      delete ull;				// Should never happen
-    }
-    if (!error)                                 // Killed (thd->killed != 0)
-    {
-      error=1;
-      null_value=1;				// Return NULL
-    }
+    if (lock_wait_timeout_handler.m_lock_wait_timeout)
+      null_value= 0;
+    DBUG_RETURN(0);
   }
-  else                                          // We got the lock
+
+  ull= (User_level_lock*) my_malloc(sizeof(User_level_lock),
+                                    MYF(MY_WME|MY_THREAD_SPECIFIC));
+  if (ull == NULL)
   {
-    ull->locked=1;
-    ull->set_thread(thd);
-    ull->thread_id= thd->thread_id;
-    thd->ull=ull;
-    error=0;
-    DBUG_PRINT("info", ("got the lock"));
+    thd->mdl_context.release_lock(ull_request.ticket);
+    DBUG_RETURN(0);
   }
-  mysql_mutex_unlock(&LOCK_user_locks);
 
-  mysql_mutex_lock(&thd->mysys_var->mutex);
-  thd->mysys_var->current_mutex= 0;
-  thd->mysys_var->current_cond=  0;
-  mysql_mutex_unlock(&thd->mysys_var->mutex);
+  ull->lock= ull_request.ticket;
+  ull->refs= 1;
+
+  if (my_hash_insert(&thd->ull_hash, (uchar*) ull))
+  {
+    thd->mdl_context.release_lock(ull->lock);
+    my_free(ull);
+    DBUG_RETURN(0);
+  }
+  null_value= 0;
 
-  DBUG_RETURN(!error ? 1 : 0);
+  DBUG_RETURN(1);
 }
 
 
@@ -4136,43 +4129,86 @@ longlong Item_func_get_lock::val_int()
 longlong Item_func_release_lock::val_int()
 {
   DBUG_ASSERT(fixed == 1);
-  String *res=args[0]->val_str(&value);
-  User_level_lock *ull;
-  longlong result;
-  THD *thd=current_thd;
+  String *res= args[0]->val_str(&value);
+  THD *thd= current_thd;
   DBUG_ENTER("Item_func_release_lock::val_int");
-  if (!res || !res->length())
-  {
-    null_value=1;
+  null_value= 1;
+
+  if (!ull_name_ok(res))
     DBUG_RETURN(0);
-  }
+
   DBUG_PRINT("info", ("lock %.*s", res->length(), res->ptr()));
-  null_value=0;
 
-  result=0;
-  mysql_mutex_lock(&LOCK_user_locks);
-  if (!(ull= ((User_level_lock*) my_hash_search(&hash_user_locks,
-                                                (const uchar*) res->ptr(),
-                                                (size_t) res->length()))))
+  MDL_key ull_key;
+  ull_key.mdl_key_init(MDL_key::USER_LOCK, res->c_ptr_safe(), "");
+
+  User_level_lock *ull;
+
+  if (!(ull=
+        (User_level_lock*) my_hash_search(&thd->ull_hash,
+                                          ull_key.ptr(), ull_key.length())))
   {
-    null_value=1;
+    null_value= thd->mdl_context.get_lock_owner(&ull_key) == 0;
+    DBUG_RETURN(0);
   }
-  else
+  null_value= 0;
+  if (--ull->refs == 0)
   {
-    DBUG_PRINT("info", ("ull->locked=%d ull->thread=%lu thd=%lu", 
-                        (int) ull->locked,
-                        (long)ull->thread_id,
-                        (long)thd->thread_id));
-    if (ull->locked && current_thd->thread_id == ull->thread_id)
-    {
-      DBUG_PRINT("info", ("release lock"));
-      result=1;					// Release is ok
-      item_user_lock_release(ull);
-      thd->ull=0;
-    }
+    my_hash_delete(&thd->ull_hash, (uchar*) ull);
+    thd->mdl_context.release_lock(ull->lock);
+    my_free(ull);
   }
-  mysql_mutex_unlock(&LOCK_user_locks);
-  DBUG_RETURN(result);
+  DBUG_RETURN(1);
+}
+
+
+/**
+  Check a user level lock.
+
+  Sets null_value=TRUE on error.
+
+  @retval
+    1		Available
+  @retval
+    0		Already taken, or error
+*/
+
+longlong Item_func_is_free_lock::val_int()
+{
+  DBUG_ASSERT(fixed == 1);
+  String *res= args[0]->val_str(&value);
+  THD *thd= current_thd;
+  null_value= 1;
+
+  if (!ull_name_ok(res))
+    return 0;
+
+  MDL_key ull_key;
+  ull_key.mdl_key_init(MDL_key::USER_LOCK, res->c_ptr_safe(), "");
+
+  null_value= 0;
+  return thd->mdl_context.get_lock_owner(&ull_key) == 0;
+}
+
+
+longlong Item_func_is_used_lock::val_int()
+{
+  DBUG_ASSERT(fixed == 1);
+  String *res= args[0]->val_str(&value);
+  THD *thd= current_thd;
+  null_value= 1;
+
+  if (!ull_name_ok(res))
+    return 0;
+
+  MDL_key ull_key;
+  ull_key.mdl_key_init(MDL_key::USER_LOCK, res->c_ptr_safe(), "");
+  ulong thread_id = thd->mdl_context.get_lock_owner(&ull_key);
+  if (thread_id == 0)
+    return 0;
+
+  null_value= 0;
+  return thread_id;
 }
 
 
@@ -4273,6 +4309,54 @@ void Item_func_benchmark::print(String *str, enum_query_type query_type)
 }
 
 
+mysql_mutex_t LOCK_item_func_sleep;
+
+#ifdef HAVE_PSI_INTERFACE
+static PSI_mutex_key key_LOCK_item_func_sleep;
+
+static PSI_mutex_info item_func_sleep_mutexes[]=
+{
+  { &key_LOCK_item_func_sleep, "LOCK_user_locks", PSI_FLAG_GLOBAL}
+};
+
+
+static void init_item_func_sleep_psi_keys(void)
+{
+  const char* category= "sql";
+  int count;
+
+  if (PSI_server == NULL)
+    return;
+
+  count= array_elements(item_func_sleep_mutexes);
+  PSI_server->register_mutex(category, item_func_sleep_mutexes, count);
+}
+#endif
+
+static bool item_func_sleep_inited= 0;
+
+
+void item_func_sleep_init(void)
+{
+#ifdef HAVE_PSI_INTERFACE
+  init_item_func_sleep_psi_keys();
+#endif
+
+  mysql_mutex_init(key_LOCK_item_func_sleep, &LOCK_item_func_sleep, MY_MUTEX_INIT_SLOW);
+  item_func_sleep_inited= 1;
+}
+
+
+void item_func_sleep_free(void)
+{
+  if (item_func_sleep_inited)
+  {
+    item_func_sleep_inited= 0;
+    mysql_mutex_destroy(&LOCK_item_func_sleep);
+  }
+}
+
+
 /** This function is just used to create tests with time gaps. */
 
 longlong Item_func_sleep::val_int()
@@ -4301,23 +4385,23 @@ longlong Item_func_sleep::val_int()
   timed_cond.set_timeout((ulonglong) (timeout * 1000000000.0));
 
   mysql_cond_init(key_item_func_sleep_cond, &cond, NULL);
-  mysql_mutex_lock(&LOCK_user_locks);
+  mysql_mutex_lock(&LOCK_item_func_sleep);
 
   THD_STAGE_INFO(thd, stage_user_sleep);
-  thd->mysys_var->current_mutex= &LOCK_user_locks;
+  thd->mysys_var->current_mutex= &LOCK_item_func_sleep;
   thd->mysys_var->current_cond=  &cond;
 
   error= 0;
   thd_wait_begin(thd, THD_WAIT_SLEEP);
   while (!thd->killed)
   {
-    error= timed_cond.wait(&cond, &LOCK_user_locks);
+    error= timed_cond.wait(&cond, &LOCK_item_func_sleep);
     if (error == ETIMEDOUT || error == ETIME)
       break;
     error= 0;
   }
   thd_wait_end(thd);
-  mysql_mutex_unlock(&LOCK_user_locks);
+  mysql_mutex_unlock(&LOCK_item_func_sleep);
   mysql_mutex_lock(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond=  0;
@@ -4653,7 +4737,7 @@ double user_var_entry::val_real(bool *null_value)
 longlong user_var_entry::val_int(bool *null_value) const
 {
   if ((*null_value= (value == 0)))
-    return LL(0);
+    return 0;
 
   switch (type) {
   case REAL_RESULT:
@@ -4677,7 +4761,7 @@ longlong user_var_entry::val_int(bool *null_value) const
     DBUG_ASSERT(0);				// Impossible
     break;
   }
-  return LL(0);					// Impossible
+  return 0;					// Impossible
 }
 
 
@@ -4815,7 +4899,7 @@ void Item_func_set_user_var::save_item_result(Item *item)
 {
   DBUG_ENTER("Item_func_set_user_var::save_item_result");
 
-  switch (cached_result_type) {
+  switch (args[0]->result_type()) {
   case REAL_RESULT:
     save_result.vreal= item->val_result();
     break;
@@ -5170,7 +5254,7 @@ longlong Item_func_get_user_var::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   if (!var_entry)
-    return LL(0);				// No such variable
+    return 0;				// No such variable
   return (var_entry->val_int(&null_value));
 }
 
@@ -5652,24 +5736,6 @@ enum_field_types Item_func_get_system_var::field_type() const
 }
 
 
-/*
-  Uses var, var_type, component, cache_present, used_query_id, thd,
-  cached_llval, null_value, cached_null_value
-*/
-#define get_sys_var_safe(type) \
-do { \
-  type value; \
-  mysql_mutex_lock(&LOCK_global_system_variables); \
-  value= *(type*) var->value_ptr(thd, var_type, &component); \
-  mysql_mutex_unlock(&LOCK_global_system_variables); \
-  cache_present |= GET_SYS_VAR_CACHE_LONG; \
-  used_query_id= thd->query_id; \
-  cached_llval= null_value ? 0 : (longlong) value; \
-  cached_null_value= null_value; \
-  return cached_llval; \
-} while (0)
-
-
 longlong Item_func_get_system_var::val_int()
 {
   THD *thd= current_thd;
@@ -5703,51 +5769,11 @@ longlong Item_func_get_system_var::val_int()
     }
   }
 
-  switch (var->show_type())
-  {
-    case SHOW_SINT:     get_sys_var_safe (int);
-    case SHOW_SLONG:    get_sys_var_safe (long);
-    case SHOW_SLONGLONG:get_sys_var_safe (longlong);
-    case SHOW_UINT:     get_sys_var_safe (uint);
-    case SHOW_ULONG:    get_sys_var_safe (ulong);
-    case SHOW_ULONGLONG:get_sys_var_safe (ulonglong);
-    case SHOW_HA_ROWS:  get_sys_var_safe (ha_rows);
-    case SHOW_BOOL:     get_sys_var_safe (bool);
-    case SHOW_MY_BOOL:  get_sys_var_safe (my_bool);
-    case SHOW_DOUBLE:
-      {
-        double dval= val_real();
-
-        used_query_id= thd->query_id;
-        cached_llval= (longlong) dval;
-        cache_present|= GET_SYS_VAR_CACHE_LONG;
-        return cached_llval;
-      }
-    case SHOW_CHAR:
-    case SHOW_CHAR_PTR:
-    case SHOW_LEX_STRING:
-      {
-        String *str_val= val_str(NULL);
-
-        if (str_val && str_val->length())
-          cached_llval= longlong_from_string_with_check (system_charset_info,
-                                                          str_val->c_ptr(), 
-                                                          str_val->c_ptr() + 
-                                                          str_val->length());
-        else
-        {
-          null_value= TRUE;
-          cached_llval= 0;
-        }
-
-        cache_present|= GET_SYS_VAR_CACHE_LONG;
-        return cached_llval;
-      }
-
-    default:            
-      my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str); 
-      return 0;                               // keep the compiler happy
-  }
+  cached_llval= var->val_int(&null_value, thd, var_type, &component);
+  cache_present |= GET_SYS_VAR_CACHE_LONG;
+  used_query_id= thd->query_id;
+  cached_null_value= null_value;
+  return cached_llval;
 }
 
 
@@ -5780,61 +5806,10 @@ String* Item_func_get_system_var::val_str(String* str)
     }
   }
 
-  str= &cached_strval;
-  switch (var->show_type())
-  {
-    case SHOW_CHAR:
-    case SHOW_CHAR_PTR:
-    case SHOW_LEX_STRING:
-    {
-      mysql_mutex_lock(&LOCK_global_system_variables);
-      char *cptr= var->show_type() == SHOW_CHAR ? 
-        (char*) var->value_ptr(thd, var_type, &component) :
-        *(char**) var->value_ptr(thd, var_type, &component);
-      if (cptr)
-      {
-        size_t len= var->show_type() == SHOW_LEX_STRING ?
-          ((LEX_STRING*)(var->value_ptr(thd, var_type, &component)))->length :
-          strlen(cptr);
-        if (str->copy(cptr, len, collation.collation))
-        {
-          null_value= TRUE;
-          str= NULL;
-        }
-      }
-      else
-      {
-        null_value= TRUE;
-        str= NULL;
-      }
-      mysql_mutex_unlock(&LOCK_global_system_variables);
-      break;
-    }
-
-    case SHOW_SINT:
-    case SHOW_SLONG:
-    case SHOW_SLONGLONG:
-    case SHOW_UINT:
-    case SHOW_ULONG:
-    case SHOW_ULONGLONG:
-    case SHOW_HA_ROWS:
-    case SHOW_BOOL:
-    case SHOW_MY_BOOL:
-      str->set (val_int(), collation.collation);
-      break;
-    case SHOW_DOUBLE:
-      str->set_real (val_real(), decimals, collation.collation);
-      break;
-
-    default:
-      my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str);
-      str= NULL;
-      break;
-  }
-
+  str= var->val_str(&cached_strval, thd, var_type, &component);
   cache_present|= GET_SYS_VAR_CACHE_STRING;
   used_query_id= thd->query_id;
-  cached_null_value= null_value;
+  cached_null_value= null_value= !str;
   return str;
 }
 
@@ -5872,58 +5847,11 @@ double Item_func_get_system_var::val_real()
     }
   }
 
-  switch (var->show_type())
-  {
-    case SHOW_DOUBLE:
-      mysql_mutex_lock(&LOCK_global_system_variables);
-      cached_dval= *(double*) var->value_ptr(thd, var_type, &component);
-      mysql_mutex_unlock(&LOCK_global_system_variables);
-      used_query_id= thd->query_id;
-      cached_null_value= null_value;
-      if (null_value)
-        cached_dval= 0;
-      cache_present|= GET_SYS_VAR_CACHE_DOUBLE;
-      return cached_dval;
-    case SHOW_CHAR:
-    case SHOW_LEX_STRING:
-    case SHOW_CHAR_PTR:
-      {
-        mysql_mutex_lock(&LOCK_global_system_variables);
-        char *cptr= var->show_type() == SHOW_CHAR ? 
-          (char*) var->value_ptr(thd, var_type, &component) :
-          *(char**) var->value_ptr(thd, var_type, &component);
-        if (cptr)
-          cached_dval= double_from_string_with_check (system_charset_info, 
-                                                cptr, cptr + strlen (cptr));
-        else
-        {
-          null_value= TRUE;
-          cached_dval= 0;
-        }
-        mysql_mutex_unlock(&LOCK_global_system_variables);
-        used_query_id= thd->query_id;
-        cached_null_value= null_value;
-        cache_present|= GET_SYS_VAR_CACHE_DOUBLE;
-        return cached_dval;
-      }
-    case SHOW_SINT:
-    case SHOW_SLONG:
-    case SHOW_SLONGLONG:
-    case SHOW_UINT:
-    case SHOW_ULONG:
-    case SHOW_ULONGLONG:
-    case SHOW_HA_ROWS:
-    case SHOW_BOOL:
-    case SHOW_MY_BOOL:
-        cached_dval= (double) val_int();
-        cache_present|= GET_SYS_VAR_CACHE_DOUBLE;
-        used_query_id= thd->query_id;
-        cached_null_value= null_value;
-        return cached_dval;
-    default:
-      my_error(ER_VAR_CANT_BE_READ, MYF(0), var->name.str);
-      return 0;
-  }
+  cached_dval= var->val_real(&null_value, thd, var_type, &component);
+  cache_present |= GET_SYS_VAR_CACHE_DOUBLE;
+  used_query_id= thd->query_id;
+  cached_null_value= null_value;
+  return cached_dval;
 }
 
 
@@ -6009,15 +5937,12 @@ void Item_func_match::init_search(bool no_order)
 {
   DBUG_ENTER("Item_func_match::init_search");
 
+  if (!table->file->get_table()) // the handler isn't opened yet
+    DBUG_VOID_RETURN;
+
   /* Check if init_search() has been called before */
   if (ft_handler)
   {
-    /*
-      We should reset ft_handler as it is cleaned up
-      on destruction of FT_SELECT object
-      (necessary in case of re-execution of subquery).
-      TODO: FT_SELECT should not clean up ft_handler.
-    */
     if (join_key)
       table->file->ft_handler= ft_handler;
     DBUG_VOID_RETURN;
@@ -6026,10 +5951,10 @@ void Item_func_match::init_search(bool no_order)
   if (key == NO_SUCH_KEY)
   {
     List<Item> fields;
-    fields.push_back(new Item_string(" ",1, cmp_collation.collation));
-    for (uint i=1; i < arg_count; i++)
+    fields.push_back(new Item_string(" ", 1, cmp_collation.collation));
+    for (uint i= 1; i < arg_count; i++)
       fields.push_back(args[i]);
-    concat_ws=new Item_func_concat_ws(fields);
+    concat_ws= new Item_func_concat_ws(fields);
     /*
       Above function used only to get value and do not need fix_fields for it:
       Item_string - basic constant
@@ -6041,10 +5966,10 @@ void Item_func_match::init_search(bool no_order)
 
   if (master)
   {
-    join_key=master->join_key=join_key|master->join_key;
+    join_key= master->join_key= join_key | master->join_key;
     master->init_search(no_order);
-    ft_handler=master->ft_handler;
-    join_key=master->join_key;
+    ft_handler= master->ft_handler;
+    join_key= master->join_key;
     DBUG_VOID_RETURN;
   }
 
@@ -6054,7 +5979,7 @@ void Item_func_match::init_search(bool no_order)
   if (!(ft_tmp=key_item()->val_str(&value)))
   {
     ft_tmp= &value;
-    value.set("",0,cmp_collation.collation);
+    value.set("", 0, cmp_collation.collation);
   }
 
   if (ft_tmp->charset() != cmp_collation.collation)
@@ -6067,7 +5992,11 @@ void Item_func_match::init_search(bool no_order)
 
   if (join_key && !no_order)
     flags|=FT_SORTED;
-  ft_handler=table->file->ft_init_ext(flags, key, ft_tmp);
+
+  if (key != NO_SUCH_KEY)
+    THD_STAGE_INFO(table->in_use, stage_fulltext_initialization);
+
+  ft_handler= table->file->ft_init_ext(flags, key, ft_tmp);
 
   if (join_key)
     table->file->ft_handler=ft_handler;
@@ -6127,7 +6056,7 @@ bool Item_func_match::fix_fields(THD *thd, Item **ref)
   table=((Item_field *)item)->field->table;
   if (!(table->file->ha_table_flags() & HA_CAN_FULLTEXT))
   {
-    my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
+    my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0), table->file->table_type());
     return 1;
   }
   table->fulltext_searched=1;
@@ -6348,61 +6277,6 @@ Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
 }
 
 
-/**
-  Check a user level lock.
-
-  Sets null_value=TRUE on error.
-
-  @retval
-    1		Available
-  @retval
-    0		Already taken, or error
-*/
-
-longlong Item_func_is_free_lock::val_int()
-{
-  DBUG_ASSERT(fixed == 1);
-  String *res=args[0]->val_str(&value);
-  User_level_lock *ull;
-
-  null_value=0;
-  if (!res || !res->length())
-  {
-    null_value=1;
-    return 0;
-  }
-  
-  mysql_mutex_lock(&LOCK_user_locks);
-  ull= (User_level_lock *) my_hash_search(&hash_user_locks, (uchar*) res->ptr(),
-                                          (size_t) res->length());
-  mysql_mutex_unlock(&LOCK_user_locks);
-  if (!ull || !ull->locked)
-    return 1;
-  return 0;
-}
-
-longlong Item_func_is_used_lock::val_int()
-{
-  DBUG_ASSERT(fixed == 1);
-  String *res=args[0]->val_str(&value);
-  User_level_lock *ull;
-
-  null_value=1;
-  if (!res || !res->length())
-    return 0;
-  
-  mysql_mutex_lock(&LOCK_user_locks);
-  ull= (User_level_lock *) my_hash_search(&hash_user_locks, (uchar*) res->ptr(),
-                                          (size_t) res->length());
-  mysql_mutex_unlock(&LOCK_user_locks);
-  if (!ull || !ull->locked)
-    return 0;
-
-  null_value=0;
-  return ull->thread_id;
-}
-
-
 longlong Item_func_row_count::val_int()
 {
   DBUG_ASSERT(fixed == 1);
diff --git a/sql/item_func.h b/sql/item_func.h
index f562c87fe1c..ab6ec706248 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -431,6 +431,13 @@ public:
   void fix_num_length_and_dec();
   virtual void find_num_type()= 0; /* To be called from fix_length_and_dec */
 
+  inline void fix_decimals()
+  {
+    DBUG_ASSERT(result_type() == DECIMAL_RESULT);
+    if (decimals == NOT_FIXED_DEC)
+      set_if_smaller(decimals, max_length - 1);
+  }
+
   double val_real();
   longlong val_int();
   my_decimal *val_decimal(my_decimal *);
@@ -1250,6 +1257,9 @@ public:
 };
 
 
+void item_func_sleep_init(void);
+void item_func_sleep_free(void);
+
 class Item_func_sleep :public Item_int_func
 {
 public:
@@ -1499,14 +1509,8 @@ public:
 
 #endif /* HAVE_DLOPEN */
 
-/*
-** User level locks
-*/
-
-class User_level_lock;
-void item_user_lock_init(void);
-void item_user_lock_release(User_level_lock *ull);
-void item_user_lock_free(void);
+void mysql_ull_cleanup(THD *thd);
+void mysql_ull_set_explicit_lock_duration(THD *thd);
 
 class Item_func_get_lock :public Item_int_func
 {
diff --git a/sql/item_geofunc.cc b/sql/item_geofunc.cc
index e3e80bdf59f..0a7f18e6546 100644
--- a/sql/item_geofunc.cc
+++ b/sql/item_geofunc.cc
@@ -561,8 +561,8 @@ longlong Item_func_spatial_mbr_rel::val_int()
 	args[1]->null_value ||
 	!(g1= Geometry::construct(&buffer1, res1->ptr(), res1->length())) ||
 	!(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())) ||
-	g1->get_mbr(&mbr1, &dummy) ||
-	g2->get_mbr(&mbr2, &dummy))))
+	g1->get_mbr(&mbr1, &dummy) || !mbr1.valid() ||
+	g2->get_mbr(&mbr2, &dummy) || !mbr2.valid())))
    return 0;
 
   switch (spatial_rel) {
@@ -687,12 +687,11 @@ longlong Item_func_spatial_rel::val_int()
   if ((null_value=
        (args[0]->null_value || args[1]->null_value ||
 	!(g1= Geometry::construct(&buffer1, res1->ptr(), res1->length())) ||
-	!(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())))))
+	!(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())) ||
+        g1->get_mbr(&mbr1, &c_end) || !mbr1.valid() ||
+        g2->get_mbr(&mbr2, &c_end) || !mbr2.valid())))
     goto exit;
 
-  g1->get_mbr(&mbr1, &c_end);
-  g2->get_mbr(&mbr2, &c_end);
-
   umbr= mbr1;
   umbr.add_mbr(&mbr2);
   collector.set_extent(umbr.xmin, umbr.xmax, umbr.ymin, umbr.ymax);
@@ -826,14 +825,14 @@ String *Item_func_spatial_operation::val_str(String *str_value)
   if ((null_value=
        (args[0]->null_value || args[1]->null_value ||
 	!(g1= Geometry::construct(&buffer1, res1->ptr(), res1->length())) ||
-	!(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())))))
+	!(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())) ||
+        g1->get_mbr(&mbr1, &c_end) || !mbr1.valid() ||
+        g2->get_mbr(&mbr2, &c_end) || !mbr2.valid())))
   {
     str_value= 0;
     goto exit;
   }
 
-  g1->get_mbr(&mbr1, &c_end);
-  g2->get_mbr(&mbr2, &c_end);
   mbr1.add_mbr(&mbr2);
   collector.set_extent(mbr1.xmin, mbr1.xmax, mbr1.ymin, mbr1.ymax);
   
@@ -1358,11 +1357,11 @@ longlong Item_func_issimple::val_int()
   DBUG_ENTER("Item_func_issimple::val_int");
   DBUG_ASSERT(fixed == 1);
   
-  if ((null_value= args[0]->null_value) ||
-      !(g= Geometry::construct(&buffer, swkb->ptr(), swkb->length())))
+  if ((null_value= (args[0]->null_value ||
+          !(g= Geometry::construct(&buffer, swkb->ptr(), swkb->length())) ||
+          g->get_mbr(&mbr, &c_end))))
     DBUG_RETURN(0);
 
-  g->get_mbr(&mbr, &c_end);
   collector.set_extent(mbr.xmin, mbr.xmax, mbr.ymin, mbr.ymax);
 
   if (g->get_class_info()->m_type_id == Geometry::wkb_point)
@@ -1598,11 +1597,11 @@ double Item_func_distance::val_real()
 
   if ((null_value= (args[0]->null_value || args[1]->null_value ||
           !(g1= Geometry::construct(&buffer1, res1->ptr(), res1->length())) ||
-          !(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())))))
+          !(g2= Geometry::construct(&buffer2, res2->ptr(), res2->length())) ||
+          g1->get_mbr(&mbr1, &c_end) ||
+          g2->get_mbr(&mbr2, &c_end))))
     goto mem_error;
 
-  g1->get_mbr(&mbr1, &c_end);
-  g2->get_mbr(&mbr2, &c_end);
   mbr1.add_mbr(&mbr2);
   collector.set_extent(mbr1.xmin, mbr1.xmax, mbr1.ymin, mbr1.ymax);
 
diff --git a/sql/item_row.cc b/sql/item_row.cc
index ee7bd837553..03b460e3ada 100644
--- a/sql/item_row.cc
+++ b/sql/item_row.cc
@@ -47,13 +47,13 @@ Item_row::Item_row(List<Item> &arg):
     items= (Item**) sql_alloc(sizeof(Item*)*arg_count);
   else
     items= 0;
-  List_iterator<Item> li(arg);
+  List_iterator_fast<Item> li(arg);
   uint i= 0;
   Item *item;
   while ((item= li++))
   {
     items[i]= item;
-    i++;    
+    i++;
   }
 }
 
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index 5071e494f04..3df03e63297 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -2460,38 +2460,16 @@ String *Item_func_elt::val_str(String *str)
 }
 
 
-void Item_func_make_set::split_sum_func(THD *thd, Item **ref_pointer_array,
-					List<Item> &fields)
-{
-  item->split_sum_func2(thd, ref_pointer_array, fields, &item, TRUE);
-  Item_str_func::split_sum_func(thd, ref_pointer_array, fields);
-}
-
-
 void Item_func_make_set::fix_length_and_dec()
 {
-  uint32 char_length= arg_count - 1; /* Separators */
+  uint32 char_length= arg_count - 2; /* Separators */
 
-  if (agg_arg_charsets_for_string_result(collation, args, arg_count))
+  if (agg_arg_charsets_for_string_result(collation, args + 1, arg_count - 1))
     return;
   
-  for (uint i=0 ; i < arg_count ; i++)
+  for (uint i=1 ; i < arg_count ; i++)
     char_length+= args[i]->max_char_length();
   fix_char_length(char_length);
-  used_tables_cache|=	  item->used_tables();
-  not_null_tables_cache&= item->not_null_tables();
-  const_item_cache&=	  item->const_item();
-  with_sum_func= with_sum_func || item->with_sum_func;
-  with_field= with_field || item->with_field;
-}
-
-
-void Item_func_make_set::update_used_tables()
-{
-  Item_func::update_used_tables();
-  item->update_used_tables();
-  used_tables_cache|=item->used_tables();
-  const_item_cache&=item->const_item();
 }
 
 
@@ -2500,15 +2478,15 @@ String *Item_func_make_set::val_str(String *str)
   DBUG_ASSERT(fixed == 1);
   ulonglong bits;
   bool first_found=0;
-  Item **ptr=args;
+  Item **ptr=args+1;
   String *result=&my_empty_string;
 
-  bits=item->val_int();
-  if ((null_value=item->null_value))
+  bits=args[0]->val_int();
+  if ((null_value=args[0]->null_value))
     return NULL;
 
-  if (arg_count < 64)
-    bits &= ((ulonglong) 1 << arg_count)-1;
+  if (arg_count < 65)
+    bits &= ((ulonglong) 1 << (arg_count-1))-1;
 
   for (; bits; bits >>= 1, ptr++)
   {
@@ -2548,39 +2526,6 @@ String *Item_func_make_set::val_str(String *str)
 }
 
 
-Item *Item_func_make_set::transform(Item_transformer transformer, uchar *arg)
-{
-  DBUG_ASSERT(!current_thd->stmt_arena->is_stmt_prepare());
-
-  Item *new_item= item->transform(transformer, arg);
-  if (!new_item)
-    return 0;
-
-  /*
-    THD::change_item_tree() should be called only if the tree was
-    really transformed, i.e. when a new item has been created.
-    Otherwise we'll be allocating a lot of unnecessary memory for
-    change records at each execution.
-  */
-  if (item != new_item)
-    current_thd->change_item_tree(&item, new_item);
-  return Item_str_func::transform(transformer, arg);
-}
-
-
-void Item_func_make_set::print(String *str, enum_query_type query_type)
-{
-  str->append(STRING_WITH_LEN("make_set("));
-  item->print(str, query_type);
-  if (arg_count)
-  {
-    str->append(',');
-    print_args(str, 0, query_type);
-  }
-  str->append(')');
-}
-
-
 String *Item_func_char::val_str(String *str)
 {
   DBUG_ASSERT(fixed == 1);
@@ -2987,7 +2932,7 @@ String *Item_func_conv_charset::val_str(String *str)
     return null_value ? 0 : &str_value;
   String *arg= args[0]->val_str(str);
   uint dummy_errors;
-  if (!arg)
+  if (args[0]->null_value)
   {
     null_value=1;
     return 0;
@@ -3414,7 +3359,7 @@ String* Item_func_inet_ntoa::val_str(String* str)
 
     Also return null if n > 255.255.255.255
   */
-  if ((null_value= (args[0]->null_value || n > (ulonglong) LL(4294967295))))
+  if ((null_value= (args[0]->null_value || n > 0xffffffff)))
     return 0;					// Null value
 
   str->set_charset(collation.collation);
@@ -4671,11 +4616,16 @@ null:
 
 void Item_dyncol_get::print(String *str, enum_query_type query_type)
 {
+  /* see create_func_dyncol_get */
+  DBUG_ASSERT(str->length() >= 5);
+  DBUG_ASSERT(strncmp(str->ptr() + str->length() - 5, "cast(", 5) == 0);
+
+  str->length(str->length() - 5);    // removing "cast("
   str->append(STRING_WITH_LEN("column_get("));
   args[0]->print(str, query_type);
   str->append(',');
   args[1]->print(str, query_type);
-  str->append(')');
+  /* let the parent cast item add " as <type>)" */
 }
 
 
diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h
index 486b7cf36ef..00863e9af2b 100644
--- a/sql/item_strfunc.h
+++ b/sql/item_strfunc.h
@@ -544,31 +544,13 @@ public:
 
 class Item_func_make_set :public Item_str_func
 {
-  Item *item;
   String tmp_str;
 
 public:
-  Item_func_make_set(Item *a,List<Item> &list) :Item_str_func(list),item(a) {}
+  Item_func_make_set(List<Item> &list) :Item_str_func(list) {}
   String *val_str(String *str);
-  bool fix_fields(THD *thd, Item **ref)
-  {
-    DBUG_ASSERT(fixed == 0);
-    return ((!item->fixed && item->fix_fields(thd, &item)) ||
-	    item->check_cols(1) ||
-	    Item_func::fix_fields(thd, ref));
-  }
-  void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
   void fix_length_and_dec();
-  void update_used_tables();
   const char *func_name() const { return "make_set"; }
-
-  bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
-  {
-    return item->walk(processor, walk_subquery, arg) ||
-      Item_str_func::walk(processor, walk_subquery, arg);
-  }
-  Item *transform(Item_transformer transformer, uchar *arg);
-  virtual void print(String *str, enum_query_type query_type);
 };
 
 
@@ -859,25 +841,37 @@ public:
   {
     if (args[0]->result_type() == STRING_RESULT)
       return Item_str_func::val_int();
-    return args[0]->val_int();
+    longlong res= args[0]->val_int();
+    if ((null_value= args[0]->null_value))
+      return 0;
+    return res;
   }
   double val_real()
   {
     if (args[0]->result_type() == STRING_RESULT)
       return Item_str_func::val_real();
-    return args[0]->val_real();
+    double res= args[0]->val_real();
+    if ((null_value= args[0]->null_value))
+      return 0;
+    return res;
   }
   my_decimal *val_decimal(my_decimal *d)
   {
     if (args[0]->result_type() == STRING_RESULT)
       return Item_str_func::val_decimal(d);
-    return args[0]->val_decimal(d);
+    my_decimal *res= args[0]->val_decimal(d);
+    if ((null_value= args[0]->null_value))
+      return NULL;
+    return res;
   }
   bool get_date(MYSQL_TIME *ltime, ulonglong fuzzydate)
   {
     if (args[0]->result_type() == STRING_RESULT)
       return Item_str_func::get_date(ltime, fuzzydate);
-    return args[0]->get_date(ltime, fuzzydate);
+    bool res= args[0]->get_date(ltime, fuzzydate);
+    if ((null_value= args[0]->null_value))
+      return 1;
+    return res;
   }
   void fix_length_and_dec();
   const char *func_name() const { return "convert"; }
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 87e96da8f62..2128de391e0 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -43,6 +43,9 @@
 
 double get_post_group_estimate(JOIN* join, double join_op_rows);
 
+const char *exists_outer_expr_name= "<exists outer expr>";
+
+int check_and_do_in_subquery_rewrites(JOIN *join);
 
 Item_subselect::Item_subselect():
   Item_result_field(), value_assigned(0), own_engine(0), thd(0), old_engine(0), 
@@ -83,15 +86,24 @@ void Item_subselect::init(st_select_lex *select_lex,
 
   if (unit->item)
   {
-    /*
-      Item can be changed in JOIN::prepare while engine in JOIN::optimize
-      => we do not copy old_engine here
-    */
     engine= unit->item->engine;
-    own_engine= FALSE;
     parsing_place= unit->item->parsing_place;
-    thd->change_item_tree((Item**)&unit->item, this);
-    engine->change_result(this, result, TRUE);
+    if (unit->item->substype() == EXISTS_SUBS &&
+        ((Item_exists_subselect *)unit->item)->exists_transformed)
+    {
+      /* it is permanent transformation of EXISTS to IN */
+      unit->item= this;
+      engine->change_result(this, result, FALSE);
+    }
+    else
+    {
+      /*
+        Item can be changed in JOIN::prepare while engine in JOIN::optimize
+        => we do not copy old_engine here
+      */
+      thd->change_item_tree((Item**)&unit->item, this);
+      engine->change_result(this, result, TRUE);
+    }
   }
   else
   {
@@ -462,7 +474,7 @@ public:
 void Item_subselect::recalc_used_tables(st_select_lex *new_parent, 
                                         bool after_pullout)
 {
-  List_iterator<Ref_to_outside> it(upper_refs);
+  List_iterator_fast<Ref_to_outside> it(upper_refs);
   Ref_to_outside *upper;
   
   used_tables_cache= 0;
@@ -547,8 +559,19 @@ bool Item_subselect::is_expensive()
     if (!cur_join)
       continue;
 
-    /* If a subquery is not optimized we cannot estimate its cost. */
-    if (!cur_join->join_tab)
+    /*
+      Subqueries whose result is known after optimization are not expensive.
+      Such subqueries have all tables optimized away, thus have no join plan.
+    */
+    if (cur_join->optimized &&
+        (cur_join->zero_result_cause || !cur_join->tables_list))
+      return false;
+
+    /*
+      If a subquery is not optimized we cannot estimate its cost. A subquery is
+      considered optimized if it has a join plan.
+    */
+    if (!(cur_join->optimized && cur_join->join_tab))
       return true;
 
     if (sl->first_inner_unit())
@@ -661,9 +684,12 @@ bool Item_subselect::exec()
 
 void Item_subselect::get_cache_parameters(List<Item> &parameters)
 {
-  Collect_deps_prm prm= {&parameters,
-    unit->first_select()->nest_level_base,
-    unit->first_select()->nest_level};
+  Collect_deps_prm prm= {&parameters,      // parameters
+    unit->first_select()->nest_level_base, // nest_level_base
+    0,                                     // count
+    unit->first_select()->nest_level,      // nest_level
+    TRUE                                   // collect
+  };
   walk(&Item::collect_outer_ref_processor, TRUE, (uchar*)&prm);
 }
 
@@ -1087,6 +1113,11 @@ enum Item_result Item_singlerow_subselect::result_type() const
   return engine->type();
 }
 
+enum Item_result Item_singlerow_subselect::cmp_type() const
+{
+  return engine->cmptype();
+}
+
 /* 
  Don't rely on the result type to calculate field type. 
  Ask the engine instead.
@@ -1298,10 +1329,12 @@ bool Item_singlerow_subselect::get_date(MYSQL_TIME *ltime,ulonglong fuzzydate)
 
 
 Item_exists_subselect::Item_exists_subselect(st_select_lex *select_lex):
-  Item_subselect()
+  Item_subselect(), upper_not(NULL), abort_on_null(0),
+  emb_on_expr_nest(NULL), optimizer(0), exists_transformed(0)
 {
   DBUG_ENTER("Item_exists_subselect::Item_exists_subselect");
   bool val_bool();
+
   init(select_lex, new select_exists_subselect(this));
   max_columns= UINT_MAX;
   null_value= FALSE; //can't be NULL
@@ -1335,21 +1368,19 @@ bool Item_in_subselect::test_limit(st_select_lex_unit *unit_arg)
 
 Item_in_subselect::Item_in_subselect(Item * left_exp,
 				     st_select_lex *select_lex):
-  Item_exists_subselect(), 
-  left_expr_cache(0), first_execution(TRUE), in_strategy(SUBS_NOT_TRANSFORMED),
-  optimizer(0), pushed_cond_guards(NULL), emb_on_expr_nest(NULL),
-  is_jtbm_merged(FALSE), is_jtbm_const_tab(FALSE), 
-  is_flattenable_semijoin(FALSE),
-  is_registered_semijoin(FALSE), 
+  Item_exists_subselect(), left_expr_cache(0), first_execution(TRUE),
+  in_strategy(SUBS_NOT_TRANSFORMED),
+  pushed_cond_guards(NULL), is_jtbm_merged(FALSE), is_jtbm_const_tab(FALSE),
+  is_flattenable_semijoin(FALSE), is_registered_semijoin(FALSE),
   upper_item(0)
 {
   DBUG_ENTER("Item_in_subselect::Item_in_subselect");
+  DBUG_PRINT("info", ("in_strategy: %u", (uint)in_strategy));
   left_expr= left_exp;
   func= &eq_creator;
   init(select_lex, new select_exists_subselect(this));
   max_columns= UINT_MAX;
   maybe_null= 1;
-  abort_on_null= 0;
   reset();
   //if test_limit will fail then error will be reported to client
   test_limit(select_lex->master_unit());
@@ -1745,8 +1776,7 @@ Item_in_subselect::single_value_transformer(JOIN *join)
     SELECT_LEX *current= thd->lex->current_select;
 
     thd->lex->current_select= current->return_after_parsing();
-    //optimizer never use Item **ref => we can pass 0 as parameter
-    if (!optimizer || optimizer->fix_left(thd, 0))
+    if (!optimizer || optimizer->fix_left(thd))
     {
       thd->lex->current_select= current;
       DBUG_RETURN(true);
@@ -1852,7 +1882,8 @@ bool Item_allany_subselect::transform_into_max_min(JOIN *join)
                  print_where(item, "rewrite with MIN/MAX", QT_ORDINARY););
 
     save_allow_sum_func= thd->lex->allow_sum_func;
-    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
+    thd->lex->allow_sum_func|=
+        (nesting_map)1 << thd->lex->current_select->nest_level;
     /*
       Item_sum_(max|min) can't substitute other item => we can use 0 as
       reference, also Item_sum_(max|min) can't be fixed after creation, so
@@ -2125,8 +2156,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
 
     SELECT_LEX *current= thd->lex->current_select;
     thd->lex->current_select= current->return_after_parsing();
-    //optimizer never use Item **ref => we can pass 0 as parameter
-    if (!optimizer || optimizer->fix_left(thd, 0))
+    if (!optimizer || optimizer->fix_left(thd))
     {
       thd->lex->current_select= current;
       DBUG_RETURN(true);
@@ -2370,6 +2400,12 @@ Item_in_subselect::select_transformer(JOIN *join)
   return select_in_like_transformer(join);
 }
 
+bool
+Item_exists_subselect::select_transformer(JOIN *join)
+{
+  return select_prepare_to_be_in();
+}
+
 
 /**
   Create the predicates needed to transform an IN/ALL/ANY subselect into a
@@ -2505,6 +2541,437 @@ bool Item_in_subselect::inject_in_to_exists_cond(JOIN *join_arg)
 }
 
 
+/*
+  If this select can potentially be converted by EXISTS->IN conversion, wrap it
+  in an Item_in_optimizer object. Final decision whether to do the conversion
+  is done at a later phase.
+*/
+
+bool Item_exists_subselect::select_prepare_to_be_in()
+{
+  bool trans_res= FALSE;
+  DBUG_ENTER("Item_exists_subselect::select_prepare_to_be_in");
+  if (!optimizer &&
+      thd->lex->sql_command == SQLCOM_SELECT &&
+      !unit->first_select()->is_part_of_union() &&
+      optimizer_flag(thd, OPTIMIZER_SWITCH_EXISTS_TO_IN) &&
+      (is_top_level_item() ||
+       (upper_not && upper_not->is_top_level_item())))
+  {
+    Query_arena *arena, backup;
+    bool result;
+    arena= thd->activate_stmt_arena_if_needed(&backup);
+    result= (!(optimizer= new Item_in_optimizer(new Item_int(1), this)));
+    if (arena)
+      thd->restore_active_arena(arena, &backup);
+    if (result)
+      trans_res= TRUE;
+    else
+      substitution= optimizer;
+  }
+  DBUG_RETURN(trans_res);
+}
+
+/**
+  Check if 'func' is an equality in form "inner_table.column = outer_expr"
+
+  @param func              Expression to check
+  @param local_field  OUT  Return "inner_table.column" here
+  @param outer_expr   OUT  Return outer_expr here
+
+  @return true - 'func' is an Equality.
+*/
+
+static bool check_equality_for_exist2in(Item_func *func,
+                                        Item_ident **local_field,
+                                        Item **outer_exp)
+{
+  Item **args;
+  if (func->functype() != Item_func::EQ_FUNC)
+    return FALSE;
+  DBUG_ASSERT(func->arg_count == 2);
+  args= func->arguments();
+  if (args[0]->real_type() == Item::FIELD_ITEM &&
+      args[0]->all_used_tables() != OUTER_REF_TABLE_BIT &&
+      args[1]->all_used_tables() == OUTER_REF_TABLE_BIT)
+  {
+    /* It is Item_field or Item_direct_view_ref) */
+    DBUG_ASSERT(args[0]->type() == Item::FIELD_ITEM ||
+                args[0]->type() == Item::REF_ITEM);
+    *local_field= (Item_ident *)args[0];
+    *outer_exp= args[1];
+    return TRUE;
+  }
+  else if (args[1]->real_type() == Item::FIELD_ITEM &&
+           args[1]->all_used_tables() != OUTER_REF_TABLE_BIT &&
+           args[0]->all_used_tables() == OUTER_REF_TABLE_BIT)
+  {
+    /* It is Item_field or Item_direct_view_ref) */
+    DBUG_ASSERT(args[0]->type() == Item::FIELD_ITEM ||
+                args[0]->type() == Item::REF_ITEM);
+    *local_field= (Item_ident *)args[1];
+    *outer_exp= args[0];
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+typedef struct st_eq_field_outer
+{
+  Item_func **eq_ref;
+  Item_ident *local_field;
+  Item *outer_exp;
+} EQ_FIELD_OUTER;
+
+
+/**
+  Check if 'conds' is a set of AND-ed outer_expr=inner_table.col equalities
+
+  @detail
+    Check if 'conds' has form
+
+    outer1=inner_tbl1.col1 AND ... AND outer2=inner_tbl1.col2 AND remainder_cond
+
+  @param  conds    Condition to be checked
+  @parm   result   Array to collect EQ_FIELD_OUTER elements describing
+                   inner-vs-outer equalities the function has found.
+  @return
+    false - some inner-vs-outer equalities were found
+    true  - otherwise.
+*/
+
+static bool find_inner_outer_equalities(Item **conds,
+                                        Dynamic_array<EQ_FIELD_OUTER> &result)
+{
+  bool found=  FALSE;
+  EQ_FIELD_OUTER element;
+  if (is_cond_and(*conds))
+  {
+    List_iterator<Item> li(*((Item_cond*)*conds)->argument_list());
+    Item *item;
+    while ((item= li++))
+    {
+      if (item->type() == Item::FUNC_ITEM &&
+          check_equality_for_exist2in((Item_func *)item,
+                                      &element.local_field,
+                                      &element.outer_exp))
+      {
+        found= TRUE;
+        element.eq_ref= (Item_func **)li.ref();
+        if (result.append(element))
+          goto alloc_err;
+      }
+    }
+  }
+  else if ((*conds)->type() == Item::FUNC_ITEM &&
+           check_equality_for_exist2in((Item_func *)*conds,
+                                       &element.local_field,
+                                       &element.outer_exp))
+  {
+    found= TRUE;
+    element.eq_ref= (Item_func **)conds;
+    if (result.append(element))
+      goto alloc_err;
+  }
+
+  return !found;
+alloc_err:
+  return TRUE;
+}
+
+/**
+  Converts EXISTS subquery to IN subquery if it is possible and has sense
+
+  @param opt_arg         Pointer on THD
+
+  @return TRUE in case of error and FALSE otherwise.
+*/
+
+bool Item_exists_subselect::exists2in_processor(uchar *opt_arg)
+{
+  THD *thd= (THD *)opt_arg;
+  SELECT_LEX *first_select=unit->first_select(), *save_select;
+  JOIN *join= first_select->join;
+  Item_func *eq= NULL, **eq_ref= NULL;
+  Item_ident *local_field= NULL;
+  Item *outer_exp= NULL;
+  Item *left_exp= NULL; Item_in_subselect *in_subs;
+  Query_arena *arena= NULL, backup;
+  int res= FALSE;
+  List<Item> outer;
+  Dynamic_array<EQ_FIELD_OUTER> eqs(5, 5);
+  bool will_be_correlated;
+  DBUG_ENTER("Item_exists_subselect::exists2in_processor");
+
+  if (!optimizer ||
+      !optimizer_flag(thd, OPTIMIZER_SWITCH_EXISTS_TO_IN) ||
+      (!is_top_level_item() && (!upper_not ||
+                                !upper_not->is_top_level_item())) ||
+      first_select->is_part_of_union() ||
+      first_select->group_list.elements ||
+      first_select->order_list.elements ||
+      join->having ||
+      first_select->with_sum_func ||
+      !first_select->leaf_tables.elements||
+      !join->conds)
+    DBUG_RETURN(FALSE);
+
+  DBUG_ASSERT(first_select->order_list.elements == 0 &&
+              first_select->group_list.elements == 0 &&
+              first_select->having == NULL);
+
+  if (find_inner_outer_equalities(&join->conds, eqs))
+    DBUG_RETURN(FALSE);
+
+  DBUG_ASSERT(eqs.elements() != 0);
+
+  save_select= thd->lex->current_select;
+  thd->lex->current_select= first_select;
+
+  /* check that the subquery has only dependencies we are going pull out */
+  {
+    List<Item> unused;
+    Collect_deps_prm prm= {&unused,          // parameters
+      unit->first_select()->nest_level_base, // nest_level_base
+      0,                                     // count
+      unit->first_select()->nest_level,      // nest_level
+      FALSE                                  // collect
+    };
+    walk(&Item::collect_outer_ref_processor, TRUE, (uchar*)&prm);
+    DBUG_ASSERT(prm.count > 0);
+    DBUG_ASSERT(prm.count >= (uint)eqs.elements());
+    will_be_correlated= prm.count > (uint)eqs.elements();
+    if (upper_not && will_be_correlated)
+      goto out;
+  }
+
+  if ((uint)eqs.elements() > (first_select->item_list.elements +
+                              first_select->select_n_reserved))
+    goto out;
+  /* It is simple query */
+  DBUG_ASSERT(first_select->join->all_fields.elements ==
+              first_select->item_list.elements);
+
+  arena= thd->activate_stmt_arena_if_needed(&backup);
+
+  while (first_select->item_list.elements > (uint)eqs.elements())
+  {
+    first_select->item_list.pop();
+    first_select->join->all_fields.elements--;
+  }
+  {
+    List_iterator<Item> it(first_select->item_list);
+
+    for (uint i= 0; i < (uint)eqs.elements(); i++)
+    {
+      Item *item= it++;
+      eq_ref= eqs.at(i).eq_ref;
+      eq= *eq_ref;
+      local_field= eqs.at(i).local_field;
+      outer_exp= eqs.at(i).outer_exp;
+      /* Add the field to the SELECT_LIST */
+      if (item)
+        it.replace(local_field);
+      else
+      {
+        first_select->item_list.push_back(local_field);
+        first_select->join->all_fields.elements++;
+      }
+      first_select->ref_pointer_array[i]= (Item *)local_field;
+
+      /* remove the parts from condition */
+      if (!upper_not || !local_field->maybe_null)
+      {
+        eq->arguments()[0]= new Item_int(1);
+        eq->arguments()[1]= new Item_int(1);
+      }
+      else
+      {
+        *eq_ref= new Item_func_isnotnull(
+          new Item_field(thd,
+                         ((Item_field*)(local_field->real_item()))->context,
+                         ((Item_field*)(local_field->real_item()))->field));
+        if((*eq_ref)->fix_fields(thd, (Item **)eq_ref))
+        {
+          res= TRUE;
+          goto out;
+        }
+      }
+      outer_exp->fix_after_pullout(unit->outer_select(), &outer_exp);
+      outer_exp->update_used_tables();
+      outer.push_back(outer_exp);
+    }
+  }
+
+  join->conds->update_used_tables();
+
+  /* make IN SUBQUERY and put outer_exp as left part */
+  if (eqs.elements() == 1)
+    left_exp= outer_exp;
+  else
+  {
+    if (!(left_exp= new Item_row(outer)))
+    {
+      res= TRUE;
+      goto out;
+    }
+  }
+
+  /* make EXISTS->IN permanet (see Item_subselect::init()) */
+  set_exists_transformed();
+
+  first_select->select_limit= NULL;
+  if (!(in_subs= new Item_in_subselect(left_exp, first_select)))
+  {
+    res= TRUE;
+    goto out;
+  }
+  in_subs->set_exists_transformed();
+  optimizer->arguments()[0]= left_exp;
+  optimizer->arguments()[1]= in_subs;
+  in_subs->optimizer= optimizer;
+  DBUG_ASSERT(is_top_level_item() ||
+              (upper_not && upper_not->is_top_level_item()));
+  in_subs->top_level_item();
+  {
+    SELECT_LEX *current= thd->lex->current_select;
+    optimizer->reset_cache(); // renew cache, and we will not keep it
+    thd->lex->current_select= unit->outer_select();
+    DBUG_ASSERT(optimizer);
+    if (optimizer->fix_left(thd))
+    {
+      res= TRUE;
+      /*
+        We should not restore thd->lex->current_select because it will be
+        reset on exit from this procedure
+      */
+      goto out;
+    }
+    /*
+      As far as  Item_ref_in_optimizer do not substitute itself on fix_fields
+      we can use same item for all selects.
+    */
+    in_subs->expr= new Item_direct_ref(&first_select->context,
+                                       (Item**)optimizer->get_cache(),
+                                       (char *)"<no matter>",
+                                       (char *)in_left_expr_name);
+    if (in_subs->fix_fields(thd, optimizer->arguments() + 1))
+    {
+      res= TRUE;
+      /*
+        We should not restore thd->lex->current_select because it will be
+        reset on exit from this procedure
+      */
+      goto out;
+    }
+    {
+      /* Move dependence list */
+      List_iterator_fast<Ref_to_outside> it(upper_refs);
+      Ref_to_outside *upper;
+      while ((upper= it++))
+      {
+        uint i;
+        for (i= 0; i < (uint)eqs.elements(); i++)
+          if (eqs.at(i).outer_exp->
+              walk(&Item::find_item_processor, TRUE, (uchar*)upper->item))
+            break;
+        if (i == (uint)eqs.elements() &&
+            (in_subs->upper_refs.push_back(upper, thd->stmt_arena->mem_root)))
+          goto out;
+      }
+    }
+    in_subs->update_used_tables();
+    /*
+      The engine of the subquery is fixed so above fix_fields() is not
+      complete and should be fixed
+    */
+    in_subs->upper_refs= upper_refs;
+    upper_refs.empty();
+    thd->lex->current_select= current;
+  }
+
+  DBUG_ASSERT(unit->item == in_subs);
+  DBUG_ASSERT(join == first_select->join);
+  /*
+    Fix dependency info
+  */
+  in_subs->is_correlated= will_be_correlated;
+  if (!will_be_correlated)
+  {
+    first_select->uncacheable&= ~UNCACHEABLE_DEPENDENT_GENERATED;
+    unit->uncacheable&= ~UNCACHEABLE_DEPENDENT_GENERATED;
+  }
+  /*
+    set possible optimization strategies
+  */
+  in_subs->emb_on_expr_nest= emb_on_expr_nest;
+  res= check_and_do_in_subquery_rewrites(join);
+  first_select->join->prepare_stage2();
+
+  first_select->fix_prepare_information(thd, &join->conds, &join->having);
+
+  if (upper_not)
+  {
+    Item *exp;
+    if (eqs.elements() == 1)
+    {
+      exp= (optimizer->arguments()[0]->maybe_null ?
+            (Item*)
+            new Item_cond_and(
+              new Item_func_isnotnull(
+                new Item_direct_ref(&unit->outer_select()->context,
+                                    optimizer->arguments(),
+                                    (char *)"<no matter>",
+                                    (char *)exists_outer_expr_name)),
+              optimizer) :
+            (Item *)optimizer);
+    }
+    else
+    {
+      List<Item> *and_list= new List<Item>;
+      if (!and_list)
+      {
+        res= TRUE;
+        goto out;
+      }
+      for (size_t i= 0; i < eqs.elements(); i++)
+      {
+        if (optimizer->arguments()[0]->maybe_null)
+        {
+          and_list->
+            push_front(
+              new Item_func_isnotnull(
+                new Item_direct_ref(&unit->outer_select()->context,
+                                    optimizer->arguments()[0]->addr(i),
+                                    (char *)"<no matter>",
+                                    (char *)exists_outer_expr_name)));
+        }
+      }
+      if (and_list->elements > 0)
+      {
+        and_list->push_front(optimizer);
+        exp= new Item_cond_and(*and_list);
+      }
+      else
+        exp= optimizer;
+    }
+    upper_not->arguments()[0]= exp;
+    if (!exp->fixed && exp->fix_fields(thd, upper_not->arguments()))
+    {
+      res= TRUE;
+      goto out;
+    }
+  }
+
+out:
+  thd->lex->current_select= save_select;
+  if (arena)
+    thd->restore_active_arena(arena, &backup);
+  DBUG_RETURN(res);
+}
+
+
 /**
   Prepare IN/ALL/ANY/SOME subquery transformation and call the appropriate
   transformation function.
@@ -2621,14 +3088,23 @@ void Item_in_subselect::print(String *str, enum_query_type query_type)
   Item_subselect::print(str, query_type);
 }
 
+bool Item_exists_subselect::fix_fields(THD *thd_arg, Item **ref)
+{
+  DBUG_ENTER("Item_exists_subselect::fix_fields");
+  if (exists_transformed)
+    DBUG_RETURN( !( (*ref)= new Item_int(1)));
+  DBUG_RETURN(Item_subselect::fix_fields(thd_arg, ref));
+}
+
 
 bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
 {
   uint outer_cols_num;
   List<Item> *inner_cols;
+  DBUG_ENTER("Item_in_subselect::fix_fields");
 
   if (test_strategy(SUBS_SEMI_JOIN))
-    return !( (*ref)= new Item_int(1));
+    DBUG_RETURN( !( (*ref)= new Item_int(1)) );
 
   /*
     Check if the outer and inner IN operands match in those cases when we
@@ -2660,7 +3136,7 @@ bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
     if (outer_cols_num != inner_cols->elements)
     {
       my_error(ER_OPERAND_COLUMNS, MYF(0), outer_cols_num);
-      return TRUE;
+      DBUG_RETURN(TRUE);
     }
     if (outer_cols_num > 1)
     {
@@ -2670,7 +3146,7 @@ bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
       {
         inner_col= inner_col_it++;
         if (inner_col->check_cols(left_expr->element_index(i)->cols()))
-          return TRUE;
+          DBUG_RETURN(TRUE);
       }
     }
   }
@@ -2678,12 +3154,12 @@ bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
   if (thd_arg->lex->is_view_context_analysis() &&
       left_expr && !left_expr->fixed &&
       left_expr->fix_fields(thd_arg, &left_expr))
-    return TRUE;
+    DBUG_RETURN(TRUE);
   else
   if (Item_subselect::fix_fields(thd_arg, ref))
-    return TRUE;
+    DBUG_RETURN(TRUE);
   fixed= TRUE;
-  return FALSE;
+  DBUG_RETURN(FALSE);
 }
 
 
@@ -3044,12 +3520,13 @@ void subselect_engine::set_row(List<Item> &item_list, Item_cache **row)
 {
   Item *sel_item;
   List_iterator_fast<Item> li(item_list);
-  res_type= STRING_RESULT;
+  cmp_type= res_type= STRING_RESULT;
   res_field_type= MYSQL_TYPE_VAR_STRING;
   for (uint i= 0; (sel_item= li++); i++)
   {
     item->max_length= sel_item->max_length;
     res_type= sel_item->result_type();
+    cmp_type= sel_item->cmp_type();
     res_field_type= sel_item->field_type();
     item->decimals= sel_item->decimals;
     item->unsigned_flag= sel_item->unsigned_flag;
@@ -3060,7 +3537,7 @@ void subselect_engine::set_row(List<Item> &item_list, Item_cache **row)
  //psergey-backport-timours:   row[i]->store(sel_item);
   }
   if (item_list.elements > 1)
-    res_type= ROW_RESULT;
+    cmp_type= res_type= ROW_RESULT;
 }
 
 void subselect_single_select_engine::fix_length_and_dec(Item_cache **row)
@@ -3811,6 +4288,7 @@ subselect_single_select_engine::change_result(Item_subselect *si,
                                               select_result_interceptor *res,
                                               bool temp)
 {
+  DBUG_ENTER("subselect_single_select_engine::change_result");
   item= si;
   if (temp)
   {
@@ -3831,7 +4309,7 @@ subselect_single_select_engine::change_result(Item_subselect *si,
     that would not require a lot of extra code that would be harder to manage
     than the current code.
   */
-  return select_lex->join->change_result(res);
+  DBUG_RETURN(select_lex->join->change_result(res));
 }
 
 
diff --git a/sql/item_subselect.h b/sql/item_subselect.h
index 1da129380e7..e806f45041a 100644
--- a/sql/item_subselect.h
+++ b/sql/item_subselect.h
@@ -244,6 +244,7 @@ public:
   virtual bool expr_cache_is_needed(THD *);
   virtual void get_cache_parameters(List<Item> &parameters);
   virtual bool is_subquery_processor (uchar *opt_arg) { return 1; }
+  bool exists2in_processor(uchar *opt_arg) { return 0; }
   bool limit_index_condition_pushdown_processor(uchar *opt_arg) 
   {
     return TRUE;
@@ -286,6 +287,7 @@ public:
   bool val_bool();
   bool get_date(MYSQL_TIME *ltime, ulonglong fuzzydate);
   enum Item_result result_type() const;
+  enum Item_result cmp_type() const;
   enum_field_types field_type() const;
   void fix_length_and_dec();
 
@@ -338,13 +340,35 @@ public:
 class Item_exists_subselect :public Item_subselect
 {
 protected:
+  Item_func_not *upper_not;
   bool value; /* value of this item (boolean: exists/not-exists) */
+  bool abort_on_null;
 
   void init_length_and_dec();
+  bool select_prepare_to_be_in();
 
 public:
+  /*
+    Used by subquery optimizations to keep track about in which clause this
+    subquery predicate is located: 
+      NO_JOIN_NEST      - the predicate is an AND-part of the WHERE
+      join nest pointer - the predicate is an AND-part of ON expression
+                          of a join nest   
+      NULL              - for all other locations
+  */
+  TABLE_LIST *emb_on_expr_nest;
+  /**
+    Reference on the Item_in_optimizer wrapper of this subquery
+  */
+  Item_in_optimizer *optimizer;
+  /* true if we got this from EXISTS or to IN */
+  bool exists_transformed;
+
   Item_exists_subselect(st_select_lex *select_lex);
-  Item_exists_subselect(): Item_subselect() {}
+  Item_exists_subselect()
+    :Item_subselect(), upper_not(NULL),abort_on_null(0),
+    emb_on_expr_nest(NULL), optimizer(0), exists_transformed(0)
+  {}
 
   subs_type substype() { return EXISTS_SUBS; }
   void reset() 
@@ -360,11 +384,24 @@ public:
   String *val_str(String*);
   my_decimal *val_decimal(my_decimal *);
   bool val_bool();
+  bool fix_fields(THD *thd, Item **ref);
   void fix_length_and_dec();
   virtual void print(String *str, enum_query_type query_type);
+  bool select_transformer(JOIN *join);
+  void top_level_item() { abort_on_null=1; }
+  inline bool is_top_level_item() { return abort_on_null; }
+  bool exists2in_processor(uchar *opt_arg);
 
   Item* expr_cache_insert_transformer(uchar *thd_arg);
 
+  void mark_as_condition_AND_part(TABLE_LIST *embedding)
+  {
+    emb_on_expr_nest= embedding;
+  }
+  virtual void under_not(Item_func_not *upper) { upper_not= upper; };
+
+  void set_exists_transformed() { exists_transformed= TRUE; }
+
   friend class select_exists_subselect;
   friend class subselect_uniquesubquery_engine;
   friend class subselect_indexsubquery_engine;
@@ -424,11 +461,8 @@ protected:
   */
   Item *expr;
   bool was_null;
-  bool abort_on_null;
   /* A bitmap of possible execution strategies for an IN predicate. */
   uchar in_strategy;
-public:
-  Item_in_optimizer *optimizer;
 protected:
   /* Used to trigger on/off conditions that were pushed down to subselect */
   bool *pushed_cond_guards;
@@ -451,15 +485,6 @@ public:
   /* Priority of this predicate in the convert-to-semi-join-nest process. */
   int sj_convert_priority;
   /*
-    Used by subquery optimizations to keep track about in which clause this
-    subquery predicate is located: 
-      NO_JOIN_NEST      - the predicate is an AND-part of the WHERE
-      join nest pointer - the predicate is an AND-part of ON expression
-                          of a join nest   
-      NULL              - for all other locations
-  */
-  TABLE_LIST *emb_on_expr_nest;
-  /*
     Types of left_expr and subquery's select list allow to perform subquery
     materialization. Currently, we set this to FALSE when it as well could
     be TRUE. This is to be properly addressed with fix for BUG#36752.
@@ -527,7 +552,9 @@ public:
   */
   Item *original_item()
   {
-    return is_flattenable_semijoin ? (Item*)this : (Item*)optimizer;
+    return (is_flattenable_semijoin && !exists_transformed ?
+            (Item*)this :
+            (Item*)optimizer);
   }
   
   bool *get_cond_guard(int i)
@@ -546,11 +573,9 @@ public:
   Item_in_subselect(Item * left_expr, st_select_lex *select_lex);
   Item_in_subselect()
     :Item_exists_subselect(), left_expr_cache(0), first_execution(TRUE),
-     abort_on_null(0), in_strategy(SUBS_NOT_TRANSFORMED), optimizer(0),
-    pushed_cond_guards(NULL), func(NULL), emb_on_expr_nest(NULL), 
-    is_jtbm_merged(FALSE), is_jtbm_const_tab(FALSE),
-    upper_item(0)
-    {}
+    in_strategy(SUBS_NOT_TRANSFORMED),
+    pushed_cond_guards(NULL), func(NULL), is_jtbm_merged(FALSE),
+    is_jtbm_const_tab(FALSE), upper_item(0) {}
   void cleanup();
   subs_type substype() { return IN_SUBS; }
   void reset() 
@@ -571,8 +596,6 @@ public:
   my_decimal *val_decimal(my_decimal *);
   void update_null_value () { (void) val_bool(); }
   bool val_bool();
-  void top_level_item() { abort_on_null=1; }
-  inline bool is_top_level_item() { return abort_on_null; }
   bool test_limit(st_select_lex_unit *unit);
   virtual void print(String *str, enum_query_type query_type);
   bool fix_fields(THD *thd, Item **ref);
@@ -589,19 +612,14 @@ public:
   void set_first_execution() { if (first_execution) first_execution= FALSE; }
   bool expr_cache_is_needed(THD *thd);
   inline bool left_expr_has_null();
-  
+
   int optimize(double *out_rows, double *cost);
-  /* 
+  /*
     Return the identifier that we could use to identify the subquery for the
     user.
   */
   int get_identifier();
 
-  void mark_as_condition_AND_part(TABLE_LIST *embedding)
-  {
-    emb_on_expr_nest= embedding;
-  }
-
   bool test_strategy(uchar strategy)
   { return test(in_strategy & strategy); }
 
@@ -630,6 +648,9 @@ public:
 
   void add_strategy (uchar strategy)
   {
+    DBUG_ENTER("Item_in_subselect::add_strategy");
+    DBUG_PRINT("enter", ("current: %u  add: %u",
+                         (uint) in_strategy, (uint) strategy));
     DBUG_ASSERT(strategy != SUBS_NOT_TRANSFORMED);
     DBUG_ASSERT(!(strategy & SUBS_STRATEGY_CHOSEN));
     /*
@@ -639,16 +660,25 @@ public:
       DBUG_ASSERT(!(in_strategy & SUBS_STRATEGY_CHOSEN));
     */
     in_strategy|= strategy;
+    DBUG_VOID_RETURN;
   }
 
   void reset_strategy(uchar strategy)
   {
+    DBUG_ENTER("Item_in_subselect::reset_strategy");
+    DBUG_PRINT("enter", ("current: %u  new: %u",
+                         (uint) in_strategy, (uint) strategy));
     DBUG_ASSERT(strategy != SUBS_NOT_TRANSFORMED);
     in_strategy= strategy;
+    DBUG_VOID_RETURN;
   }
 
   void set_strategy(uchar strategy)
   {
+    DBUG_ENTER("Item_in_subselect::set_strategy");
+    DBUG_PRINT("enter", ("current: %u  set: %u",
+                         (uint) in_strategy,
+                         (uint) (SUBS_STRATEGY_CHOSEN | strategy)));
     /* Check that only one strategy is set for execution. */
     DBUG_ASSERT(strategy == SUBS_SEMI_JOIN ||
                 strategy == SUBS_IN_TO_EXISTS ||
@@ -658,7 +688,12 @@ public:
                 strategy == SUBS_MAXMIN_INJECTED ||
                 strategy == SUBS_MAXMIN_ENGINE);
     in_strategy= (SUBS_STRATEGY_CHOSEN | strategy);
+    DBUG_VOID_RETURN;
   }
+  bool exists2in_processor(uchar *opt_arg __attribute__((unused)))
+  {
+    return 0;
+  };
 
   friend class Item_ref_null_helper;
   friend class Item_is_not_null_test;
@@ -666,6 +701,7 @@ public:
   friend class subselect_indexsubquery_engine;
   friend class subselect_hash_sj_engine;
   friend class subselect_partial_match_engine;
+  friend class Item_exists_subselect;
 };
 
 
@@ -698,6 +734,7 @@ protected:
   THD *thd; /* pointer to current THD */
   Item_subselect *item; /* item, that use this engine */
   enum Item_result res_type; /* type of results */
+  enum Item_result cmp_type; /* how to compare the results */
   enum_field_types res_field_type; /* column type of the results */
   bool maybe_null; /* may be null (first item in select) */
 public:
@@ -712,7 +749,7 @@ public:
   {
     result= res;
     item= si;
-    res_type= STRING_RESULT;
+    cmp_type= res_type= STRING_RESULT;
     res_field_type= MYSQL_TYPE_VAR_STRING;
     maybe_null= 0;
     set_thd(thd_arg);
@@ -752,6 +789,7 @@ public:
   virtual uint cols()= 0; /* return number of columns in select */
   virtual uint8 uncacheable()= 0; /* query is uncacheable */
   enum Item_result type() { return res_type; }
+  enum Item_result cmptype() { return cmp_type; }
   enum_field_types field_type() { return res_field_type; }
   virtual void exclude()= 0;
   virtual bool may_be_null() { return maybe_null; };
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 8816e1352a9..03afd1a4365 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -152,9 +152,10 @@ bool Item_sum::check_sum_func(THD *thd, Item **ref)
       If it is there under a construct where it is not allowed 
       we report an error. 
     */ 
-    invalid= !(allow_sum_func & (1 << max_arg_level));
+    invalid= !(allow_sum_func & ((nesting_map)1 << max_arg_level));
   }
-  else if (max_arg_level >= 0 || !(allow_sum_func & (1 << nest_level)))
+  else if (max_arg_level >= 0 ||
+           !(allow_sum_func & ((nesting_map)1 << nest_level)))
   {
     /*
       The set function can be aggregated only in outer subqueries.
@@ -163,7 +164,8 @@ bool Item_sum::check_sum_func(THD *thd, Item **ref)
     */
     if (register_sum_func(thd, ref))
       return TRUE;
-    invalid= aggr_level < 0 && !(allow_sum_func & (1 << nest_level));
+    invalid= aggr_level < 0 &&
+             !(allow_sum_func & ((nesting_map)1 << nest_level));
     if (!invalid && thd->variables.sql_mode & MODE_ANSI)
       invalid= aggr_level < 0 && max_arg_level < nest_level;
   }
@@ -311,14 +313,15 @@ bool Item_sum::register_sum_func(THD *thd, Item **ref)
        sl && sl->nest_level > max_arg_level;
        sl= sl->master_unit()->outer_select() )
   {
-    if (aggr_level < 0 && (allow_sum_func & (1 << sl->nest_level)))
+    if (aggr_level < 0 &&
+        (allow_sum_func & ((nesting_map)1 << sl->nest_level)))
     {
       /* Found the most nested subquery where the function can be aggregated */
       aggr_level= sl->nest_level;
       aggr_sel= sl;
     }
   }
-  if (sl && (allow_sum_func & (1 << sl->nest_level)))
+  if (sl && (allow_sum_func & ((nesting_map)1 << sl->nest_level)))
   {
     /* 
       We reached the subquery of level max_arg_level and checked
@@ -375,7 +378,12 @@ bool Item_sum::collect_outer_ref_processor(uchar *param)
   if ((ds= depended_from()) &&
       ds->nest_level_base == prm->nest_level_base &&
       ds->nest_level < prm->nest_level)
-    prm->parameters->add_unique(this, &cmp_items);
+  {
+    if (prm->collect)
+      prm->parameters->add_unique(this, &cmp_items);
+    else
+      prm->count++;
+  }
   return FALSE;
 }
 
@@ -559,7 +567,7 @@ void Item_sum::update_used_tables ()
       used_tables_cache&= PSEUDO_TABLE_BITS;
 
       // the aggregate function is aggregated into its local context
-      used_tables_cache |=  (1 << aggr_sel->join->table_count) - 1;
+      used_tables_cache|= ((table_map)1 << aggr_sel->join->tables) - 1;
       
       } because if we do it, table elimination will assume that
         - constructs like "COUNT(*)" use columns from all tables
@@ -727,7 +735,15 @@ int simple_raw_key_cmp(void* arg, const void* key1, const void* key2)
 }
 
 
-int item_sum_distinct_walk(void *element, element_count num_of_dups,
+static int item_sum_distinct_walk_for_count(void *element, 
+                                            element_count num_of_dups,
+                                            void *item)
+{
+  return ((Aggregator_distinct*) (item))->unique_walk_function_for_count(element);
+}
+ 
+
+static int item_sum_distinct_walk(void *element, element_count num_of_dups,
                                   void *item)
 {
   return ((Aggregator_distinct*) (item))->unique_walk_function(element);
@@ -1097,7 +1113,12 @@ void Aggregator_distinct::endup()
   {
     /* go over the tree of distinct keys and calculate the aggregate value */
     use_distinct_values= TRUE;
-    tree->walk(table, item_sum_distinct_walk, (void*) this);
+    tree_walk_action func;
+    if (item_sum->sum_func() == Item_sum::COUNT_DISTINCT_FUNC)
+      func= item_sum_distinct_walk_for_count;
+    else
+      func= item_sum_distinct_walk;
+    tree->walk(table, func, (void*) this);
     use_distinct_values= FALSE;
   }
   /* prevent consecutive recalculations */
@@ -1474,6 +1495,22 @@ bool Aggregator_distinct::unique_walk_function(void *element)
 }
 
 
+/*
+  A variant of unique_walk_function() that is to be used with Item_sum_count.
+
+  COUNT is a special aggregate function: it doesn't need the values, it only
+  needs to count them. COUNT needs to know the values are not NULLs, but NULL
+  values are not put into the Unique, so we don't need to check for NULLs here.
+*/
+
+bool Aggregator_distinct::unique_walk_function_for_count(void *element)
+{
+  Item_sum_count *sum= (Item_sum_count *)item_sum;
+  sum->count++;
+  return 0;
+}
+
+
 Aggregator_distinct::~Aggregator_distinct()
 {
   if (tree)
@@ -1589,9 +1626,10 @@ void Item_sum_avg::fix_length_and_dec()
     f_scale=  args[0]->decimals;
     dec_bin_size= my_decimal_get_binary_size(f_precision, f_scale);
   }
-  else {
+  else
+  {
     decimals= min(args[0]->decimals + prec_increment, NOT_FIXED_DEC);
-    max_length= args[0]->max_length + prec_increment;
+    max_length= min(args[0]->max_length + prec_increment, float_length(decimals));
   }
 }
 
diff --git a/sql/item_sum.h b/sql/item_sum.h
index 40a28d8beae..6769c47a411 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -1,7 +1,7 @@
 #ifndef ITEM_SUM_INCLUDED
 #define ITEM_SUM_INCLUDED
 /* Copyright (c) 2000, 2011 Oracle and/or its affiliates.
-   Copyright (c) 2008-2011 Monty Program Ab
+   Copyright (c) 2008, 2013 Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -642,6 +642,7 @@ public:
   virtual bool arg_is_null();
 
   bool unique_walk_function(void *element);
+  bool unique_walk_function_for_count(void *element);
   static int composite_key_cmp(void* arg, uchar* key1, uchar* key2);
 };
 
@@ -1119,7 +1120,7 @@ public:
 class Item_sum_or :public Item_sum_bit
 {
 public:
-  Item_sum_or(Item *item_par) :Item_sum_bit(item_par,LL(0)) {}
+  Item_sum_or(Item *item_par) :Item_sum_bit(item_par, 0) {}
   Item_sum_or(THD *thd, Item_sum_or *item) :Item_sum_bit(thd, item) {}
   bool add();
   const char *func_name() const { return "bit_or("; }
@@ -1140,7 +1141,7 @@ class Item_sum_and :public Item_sum_bit
 class Item_sum_xor :public Item_sum_bit
 {
   public:
-  Item_sum_xor(Item *item_par) :Item_sum_bit(item_par,LL(0)) {}
+  Item_sum_xor(Item *item_par) :Item_sum_bit(item_par, 0) {}
   Item_sum_xor(THD *thd, Item_sum_xor *item) :Item_sum_bit(thd, item) {}
   bool add();
   const char *func_name() const { return "bit_xor("; }
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index 02a7b8511af..f43a4e79431 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -709,8 +709,8 @@ static bool get_interval_info(const char *str,uint length,CHARSET_INFO *cs,
   {
     longlong value;
     const char *start= str;
-    for (value=0; str != end && my_isdigit(cs,*str) ; str++)
-      value= value*LL(10) + (longlong) (*str - '0');
+    for (value=0; str != end && my_isdigit(cs, *str) ; str++)
+      value= value*10 + *str - '0';
     msec_length= 6 - (str - start);
     values[i]= value;
     while (str != end && !my_isdigit(cs,*str))
@@ -923,16 +923,14 @@ longlong Item_func_dayofmonth::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   MYSQL_TIME ltime;
-  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
-  return (longlong) ltime.day;
+  return get_arg0_date(&ltime, TIME_FUZZY_DATE) ? 0 : (longlong) ltime.day;
 }
 
 longlong Item_func_month::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   MYSQL_TIME ltime;
-  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
-  return (longlong) ltime.month;
+  return get_arg0_date(&ltime, TIME_FUZZY_DATE) ? 0 : (longlong) ltime.month;
 }
 
 
@@ -983,16 +981,14 @@ longlong Item_func_hour::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   MYSQL_TIME ltime;
-  (void) get_arg0_time(&ltime);
-  return ltime.hour;
+  return get_arg0_time(&ltime) ? 0 : ltime.hour;
 }
 
 longlong Item_func_minute::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   MYSQL_TIME ltime;
-  (void) get_arg0_time(&ltime);
-  return ltime.minute;
+  return get_arg0_time(&ltime) ? 0 : ltime.minute;
 }
 
 /**
@@ -1002,8 +998,7 @@ longlong Item_func_second::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   MYSQL_TIME ltime;
-  (void) get_arg0_time(&ltime);
-  return ltime.second;
+  return get_arg0_time(&ltime) ? 0 : ltime.second;
 }
 
 
@@ -1120,8 +1115,7 @@ longlong Item_func_year::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   MYSQL_TIME ltime;
-  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
-  return (longlong) ltime.year;
+  return get_arg0_date(&ltime, TIME_FUZZY_DATE) ? 0 : (longlong) ltime.year;
 }
 
 
diff --git a/sql/item_timefunc.h b/sql/item_timefunc.h
index 3e3cd698efc..9b2db9e816e 100644
--- a/sql/item_timefunc.h
+++ b/sql/item_timefunc.h
@@ -491,6 +491,7 @@ public:
   enum Item_result result_type () const { return STRING_RESULT; }
   CHARSET_INFO *charset_for_protocol(void) const { return &my_charset_bin; }
   enum_field_types field_type() const { return MYSQL_TYPE_DATETIME; }
+  Item_result cmp_type() const { return TIME_RESULT; }
   String *val_str(String *str);
   longlong val_int();
   double val_real();
diff --git a/sql/item_xmlfunc.cc b/sql/item_xmlfunc.cc
index 5a824e48b7b..723429f107a 100644
--- a/sql/item_xmlfunc.cc
+++ b/sql/item_xmlfunc.cc
@@ -2704,8 +2704,12 @@ int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
 
   node.parent= data->parent; // Set parent for the new node to old parent
   data->parent= numnodes;    // Remember current node as new parent
+  DBUG_ASSERT(data->level <= MAX_LEVEL);
   data->pos[data->level]= numnodes;
-  node.level= data->level++;
+  if (data->level < MAX_LEVEL)
+    node.level= data->level++;
+  else
+    return MY_XML_ERROR;
   node.type= st->current_node_type; // TAG or ATTR
   node.beg= attr;
   node.end= attr + len;
diff --git a/sql/lock.cc b/sql/lock.cc
index bf53a925424..67c8b240c6f 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -93,7 +93,7 @@ extern HASH open_cache;
 
 static int lock_external(THD *thd, TABLE **table,uint count);
 static int unlock_external(THD *thd, TABLE **table,uint count);
-static void print_lock_error(int error, const char *);
+static void print_lock_error(int error, TABLE *);
 
 /* Map the return value of thr_lock to an error from errmsg.txt */
 static int thr_lock_errno_to_mysql[]=
@@ -356,7 +356,7 @@ static int lock_external(THD *thd, TABLE **tables, uint count)
 
     if ((error=(*tables)->file->ha_external_lock(thd,lock_type)))
     {
-      print_lock_error(error, (*tables)->file->table_type());
+      print_lock_error(error, *tables);
       while (--i)
       {
         tables--;
@@ -671,7 +671,7 @@ static int unlock_external(THD *thd, TABLE **table,uint count)
       if ((error=(*table)->file->ha_external_lock(thd, F_UNLCK)))
       {
 	error_code=error;
-	print_lock_error(error_code, (*table)->file->table_type());
+	print_lock_error(error_code, *table);
       }
     }
     table++;
@@ -894,7 +894,7 @@ bool lock_object_name(THD *thd, MDL_key::enum_mdl_namespace mdl_type,
 }
 
 
-static void print_lock_error(int error, const char *table)
+static void print_lock_error(int error, TABLE *table)
 {
   int textno;
   DBUG_ENTER("print_lock_error");
@@ -910,17 +910,15 @@ static void print_lock_error(int error, const char *table)
     textno=ER_LOCK_DEADLOCK;
     break;
   case HA_ERR_WRONG_COMMAND:
-    textno=ER_ILLEGAL_HA;
-    break;
+    my_error(ER_ILLEGAL_HA, MYF(0), table->file->table_type(),
+             table->s->db.str, table->s->table_name.str);
+    DBUG_VOID_RETURN;
   default:
     textno=ER_CANT_LOCK;
     break;
   }
 
-  if ( textno == ER_ILLEGAL_HA )
-    my_error(textno, MYF(ME_BELL+ME_OLDWIN+ME_WAITTANG), table);
-  else
-    my_error(textno, MYF(ME_BELL+ME_OLDWIN+ME_WAITTANG), error);
+  my_error(textno, MYF(0), error);
 
   DBUG_VOID_RETURN;
 }
diff --git a/sql/log.cc b/sql/log.cc
index 254449da05a..088816d7954 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -2290,7 +2290,7 @@ static int find_uniq_filename(char *name)
     DBUG_RETURN(1);
   }
   file_info= dir_info->dir_entry;
-  for (i= dir_info->number_off_files ; i-- ; file_info++)
+  for (i= dir_info->number_of_files ; i-- ; file_info++)
   {
     if (memcmp(file_info->name, start, length) == 0 &&
 	test_if_number(file_info->name+length, &number,0))
@@ -2301,7 +2301,7 @@ static int find_uniq_filename(char *name)
   my_dirend(dir_info);
 
   /* check if reached the maximum possible extension number */
-  if ((max_found == MAX_LOG_UNIQUE_FN_EXT))
+  if (max_found == MAX_LOG_UNIQUE_FN_EXT)
   {
     sql_print_error("Log filename extension number exhausted: %06lu. \
 Please fix this by archiving old logs and \
@@ -2965,6 +2965,19 @@ void MYSQL_BIN_LOG::cleanup()
   {
     xid_count_per_binlog *b;
 
+    /* Wait for the binlog background thread to stop. */
+    if (!is_relay_log && binlog_background_thread_started)
+    {
+      mysql_mutex_lock(&LOCK_binlog_background_thread);
+      binlog_background_thread_stop= true;
+      mysql_cond_signal(&COND_binlog_background_thread);
+      while (binlog_background_thread_stop)
+        mysql_cond_wait(&COND_binlog_background_thread_end,
+                        &LOCK_binlog_background_thread);
+      mysql_mutex_unlock(&LOCK_binlog_background_thread);
+      binlog_background_thread_started= false;
+    }
+
     inited= 0;
     close(LOG_CLOSE_INDEX|LOG_CLOSE_STOP_EVENT);
     delete description_event_for_queue;
@@ -2981,19 +2994,6 @@ void MYSQL_BIN_LOG::cleanup()
       my_free(b);
     }
 
-    /* Wait for the binlog background thread to stop. */
-    if (!is_relay_log && binlog_background_thread_started)
-    {
-      mysql_mutex_lock(&LOCK_binlog_background_thread);
-      binlog_background_thread_stop= true;
-      mysql_cond_signal(&COND_binlog_background_thread);
-      while (binlog_background_thread_stop)
-        mysql_cond_wait(&COND_binlog_background_thread_end,
-                        &LOCK_binlog_background_thread);
-      mysql_mutex_unlock(&LOCK_binlog_background_thread);
-      binlog_background_thread_started= false;
-    }
-
     mysql_mutex_destroy(&LOCK_log);
     mysql_mutex_destroy(&LOCK_index);
     mysql_mutex_destroy(&LOCK_xid_list);
@@ -3715,17 +3715,10 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd, bool create_new_log)
 
     /* Now wait for all checkpoint requests and pending unlog() to complete. */
     mysql_mutex_lock(&LOCK_xid_list);
-    xid_count_per_binlog *b;
     for (;;)
     {
-      I_List_iterator<xid_count_per_binlog> it(binlog_xid_count_list);
-      while ((b= it++))
-      {
-        if (b->xid_count > 0)
-          break;
-      }
-      if (!b)
-        break;                                  /* No more pending XIDs */
+      if (is_xidlist_idle_nolock())
+        break;
       /*
         Wait until signalled that one more binlog dropped to zero, then check
         again.
@@ -4503,6 +4496,32 @@ MYSQL_BIN_LOG::can_purge_log(const char *log_file_name)
 #endif /* HAVE_REPLICATION */
 
 
+bool
+MYSQL_BIN_LOG::is_xidlist_idle()
+{
+  bool res;
+  mysql_mutex_lock(&LOCK_xid_list);
+  res= is_xidlist_idle_nolock();
+  mysql_mutex_unlock(&LOCK_xid_list);
+  return res;
+}
+
+
+bool
+MYSQL_BIN_LOG::is_xidlist_idle_nolock()
+{
+  xid_count_per_binlog *b;
+
+  I_List_iterator<xid_count_per_binlog> it(binlog_xid_count_list);
+  while ((b= it++))
+  {
+    if (b->xid_count > 0)
+      return false;
+  }
+  return true;
+}
+
+
 /**
   Create a new log file name.
 
@@ -8228,6 +8247,13 @@ binlog_background_thread(void *arg __attribute__((unused)))
     {
       stop= binlog_background_thread_stop;
       queue= binlog_background_thread_queue;
+      if (stop && !mysql_bin_log.is_xidlist_idle())
+      {
+        /*
+          Delay stop until all pending binlog checkpoints have been processed.
+        */
+        stop= false;
+      }
       if (stop || queue)
         break;
       mysql_cond_wait(&mysql_bin_log.COND_binlog_background_thread,
@@ -8238,9 +8264,18 @@ binlog_background_thread(void *arg __attribute__((unused)))
     mysql_mutex_unlock(&mysql_bin_log.LOCK_binlog_background_thread);
 
     /* Process any incoming commit_checkpoint_notify() calls. */
+    DBUG_EXECUTE_IF("inject_binlog_background_thread_before_mark_xid_done",
+      DBUG_ASSERT(!debug_sync_set_action(
+        thd,
+        STRING_WITH_LEN("binlog_background_thread_before_mark_xid_done "
+                        "SIGNAL injected_binlog_background_thread "
+                        "WAIT_FOR something_that_will_never_happen "
+                        "TIMEOUT 2")));
+      );
     while (queue)
     {
       THD_STAGE_INFO(thd, stage_binlog_processing_checkpoint_notify);
+      DEBUG_SYNC(current_thd, "binlog_background_thread_before_mark_xid_done");
       /* Grab next pointer first, as mark_xid_done() may free the element. */
       next= queue->next_in_queue;
       mysql_bin_log.mark_xid_done(queue->binlog_id, true);
diff --git a/sql/log.h b/sql/log.h
index 80fe34b5ff2..da8faa36a00 100644
--- a/sql/log.h
+++ b/sql/log.h
@@ -526,6 +526,7 @@ class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG
   int write_transaction_or_stmt(group_commit_entry *entry);
   bool write_transaction_to_binlog_events(group_commit_entry *entry);
   void trx_group_commit_leader(group_commit_entry *leader);
+  bool is_xidlist_idle_nolock();
 
 public:
   /*
@@ -771,6 +772,7 @@ public:
   inline IO_CACHE *get_index_file() { return &index_file;}
   inline uint32 get_open_count() { return open_count; }
   void set_status_variables(THD *thd);
+  bool is_xidlist_idle();
 };
 
 class Log_event_handler
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 7de72338d97..ccfbd621c04 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -577,7 +577,7 @@ static void cleanup_load_tmpdir()
   *(p++)= '-';
   *p= 0;
 
-  for (i=0 ; i < (uint)dirp->number_off_files; i++)
+  for (i=0 ; i < (uint)dirp->number_of_files; i++)
   {
     file=dirp->dir_entry+i;
     if (is_prefix(file->name, prefbuf))
@@ -1370,7 +1370,7 @@ failed my_b_read"));
   Log_event *res=  0;
 #ifndef max_allowed_packet
   THD *thd=current_thd;
-  uint max_allowed_packet= thd ? slave_max_allowed_packet:~(ulong)0;
+  uint max_allowed_packet= thd ? slave_max_allowed_packet:~(uint)0;
 #endif
 
   if (data_len > max_allowed_packet)
@@ -1808,6 +1808,7 @@ void Log_event::print_header(IO_CACHE* file,
 /**
   Prints a quoted string to io cache.
   Control characters are displayed as hex sequence, e.g. \x00
+  Single-quote and backslash characters are escaped with a \
   
   @param[in] file              IO cache
   @param[in] prt               Pointer to string
@@ -1823,6 +1824,10 @@ my_b_write_quoted(IO_CACHE *file, const uchar *ptr, uint length)
   {
     if (*s > 0x1F)
       my_b_write(file, s, 1);
+    else if (*s == '\'')
+      my_b_write(file, "\\'", 2);
+    else if (*s == '\\')
+      my_b_write(file, "\\\\", 2);
     else
     {
       uchar hex[10];
@@ -4563,109 +4568,6 @@ Format_description_log_event(const char* buf,
     checksum_alg= (uint8) BINLOG_CHECKSUM_ALG_UNDEF;
   }
 
-  /*
-    In some previous versions, the events were given other event type
-    id numbers than in the present version. When replicating from such
-    a version, we therefore set up an array that maps those id numbers
-    to the id numbers of the present server.
-
-    If post_header_len is null, it means malloc failed, and is_valid
-    will fail, so there is no need to do anything.
-
-    The trees in which events have wrong id's are:
-
-    mysql-5.1-wl1012.old mysql-5.1-wl2325-5.0-drop6p13-alpha
-    mysql-5.1-wl2325-5.0-drop6 mysql-5.1-wl2325-5.0
-    mysql-5.1-wl2325-no-dd
-
-    (this was found by grepping for two lines in sequence where the
-    first matches "FORMAT_DESCRIPTION_EVENT," and the second matches
-    "TABLE_MAP_EVENT," in log_event.h in all trees)
-
-    In these trees, the following server_versions existed since
-    TABLE_MAP_EVENT was introduced:
-
-    5.1.1-a_drop5p3   5.1.1-a_drop5p4        5.1.1-alpha
-    5.1.2-a_drop5p10  5.1.2-a_drop5p11       5.1.2-a_drop5p12
-    5.1.2-a_drop5p13  5.1.2-a_drop5p14       5.1.2-a_drop5p15
-    5.1.2-a_drop5p16  5.1.2-a_drop5p16b      5.1.2-a_drop5p16c
-    5.1.2-a_drop5p17  5.1.2-a_drop5p4        5.1.2-a_drop5p5
-    5.1.2-a_drop5p6   5.1.2-a_drop5p7        5.1.2-a_drop5p8
-    5.1.2-a_drop5p9   5.1.3-a_drop5p17       5.1.3-a_drop5p17b
-    5.1.3-a_drop5p17c 5.1.4-a_drop5p18       5.1.4-a_drop5p19
-    5.1.4-a_drop5p20  5.1.4-a_drop6p0        5.1.4-a_drop6p1
-    5.1.4-a_drop6p2   5.1.5-a_drop5p20       5.2.0-a_drop6p3
-    5.2.0-a_drop6p4   5.2.0-a_drop6p5        5.2.0-a_drop6p6
-    5.2.1-a_drop6p10  5.2.1-a_drop6p11       5.2.1-a_drop6p12
-    5.2.1-a_drop6p6   5.2.1-a_drop6p7        5.2.1-a_drop6p8
-    5.2.2-a_drop6p13  5.2.2-a_drop6p13-alpha 5.2.2-a_drop6p13b
-    5.2.2-a_drop6p13c
-
-    (this was found by grepping for "mysql," in all historical
-    versions of configure.in in the trees listed above).
-
-    There are 5.1.1-alpha versions that use the new event id's, so we
-    do not test that version string.  So replication from 5.1.1-alpha
-    with the other event id's to a new version does not work.
-    Moreover, we can safely ignore the part after drop[56].  This
-    allows us to simplify the big list above to the following regexes:
-
-    5\.1\.[1-5]-a_drop5.*
-    5\.1\.4-a_drop6.*
-    5\.2\.[0-2]-a_drop6.*
-
-    This is what we test for in the 'if' below.
-  */
-  if (post_header_len &&
-      server_version[0] == '5' && server_version[1] == '.' &&
-      server_version[3] == '.' &&
-      strncmp(server_version + 5, "-a_drop", 7) == 0 &&
-      ((server_version[2] == '1' &&
-        server_version[4] >= '1' && server_version[4] <= '5' &&
-        server_version[12] == '5') ||
-       (server_version[2] == '1' &&
-        server_version[4] == '4' &&
-        server_version[12] == '6') ||
-       (server_version[2] == '2' &&
-        server_version[4] >= '0' && server_version[4] <= '2' &&
-        server_version[12] == '6')))
-  {
-    if (number_of_event_types != 22)
-    {
-      DBUG_PRINT("info", (" number_of_event_types=%d",
-                          number_of_event_types));
-      /* this makes is_valid() return false. */
-      my_free(post_header_len);
-      post_header_len= NULL;
-      DBUG_VOID_RETURN;
-    }
-    static const uint8 perm[23]=
-      {
-        UNKNOWN_EVENT, START_EVENT_V3, QUERY_EVENT, STOP_EVENT, ROTATE_EVENT,
-        INTVAR_EVENT, LOAD_EVENT, SLAVE_EVENT, CREATE_FILE_EVENT,
-        APPEND_BLOCK_EVENT, EXEC_LOAD_EVENT, DELETE_FILE_EVENT,
-        NEW_LOAD_EVENT,
-        RAND_EVENT, USER_VAR_EVENT,
-        FORMAT_DESCRIPTION_EVENT,
-        TABLE_MAP_EVENT,
-        PRE_GA_WRITE_ROWS_EVENT,
-        PRE_GA_UPDATE_ROWS_EVENT,
-        PRE_GA_DELETE_ROWS_EVENT,
-        XID_EVENT,
-        BEGIN_LOAD_QUERY_EVENT,
-        EXECUTE_LOAD_QUERY_EVENT,
-      };
-    event_type_permutation= perm;
-    /*
-      Since we use (permuted) event id's to index the post_header_len
-      array, we need to permute the post_header_len array too.
-    */
-    uint8 post_header_len_temp[23];
-    for (int i= 1; i < 23; i++)
-      post_header_len_temp[perm[i] - 1]= post_header_len[i - 1];
-    for (int i= 0; i < 22; i++)
-      post_header_len[i] = post_header_len_temp[i];
-  }
   DBUG_VOID_RETURN;
 }
 
@@ -4828,10 +4730,21 @@ do_server_version_split(char* version,
   for (uint i= 0; i<=2; i++)
   {
     number= strtoul(p, &r, 10);
-    split_versions->ver[i]= (uchar) number;
-    DBUG_ASSERT(number < 256); // fit in uchar
+    /*
+      It is an invalid version if any version number greater than 255 or
+      first number is not followed by '.'.
+    */
+    if (number < 256 && (*r == '.' || i != 0))
+      split_versions->ver[i]= (uchar) number;
+    else
+    {
+      split_versions->ver[0]= 0;
+      split_versions->ver[1]= 0;
+      split_versions->ver[2]= 0;
+      break;
+    }
+
     p= r;
-    DBUG_ASSERT(!((i == 0) && (*r != '.'))); // should be true in practice
     if (*r == '.')
       p++; // skip the dot
   }
@@ -4849,7 +4762,6 @@ do_server_version_split(char* version,
    into 'server_version_split':
    X.Y.Zabc (X,Y,Z numbers, a not a digit) -> {X,Y,Z}
    X.Yabc -> {X,Y,0}
-   Xabc -> {X,0,0}
    'server_version_split' is then used for lookups to find if the server which
    created this event has some known bug.
 */
diff --git a/sql/log_event.h b/sql/log_event.h
index ff13cab9cd5..be63304b529 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -1,4 +1,5 @@
 /* Copyright (c) 2000, 2012, Oracle and/or its affiliates.
+   Copyright (c) 2009, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -551,7 +552,7 @@ struct sql_ex_info
 
 /* Shouldn't be defined before */
 #define EXPECTED_OPTIONS \
-  ((ULL(1) << 14) | (ULL(1) << 26) | (ULL(1) << 27) | (ULL(1) << 19))
+  ((1ULL << 14) | (1ULL << 26) | (1ULL << 27) | (1ULL << 19))
 
 #if OPTIONS_WRITTEN_TO_BIN_LOG != EXPECTED_OPTIONS
 #error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values!
@@ -1127,7 +1128,7 @@ public:
     return thd ? thd->db : 0;
   }
 #else
-  Log_event() : temp_buf(0) {}
+  Log_event() : temp_buf(0), flags(0) {}
     /* avoid having to link mysqlbinlog against libpthread */
   static Log_event* read_log_event(IO_CACHE* file,
                                    const Format_description_log_event
@@ -2464,12 +2465,26 @@ public:
 #ifdef MYSQL_SERVER
   bool write(IO_CACHE* file);
 #endif
-  bool is_valid() const
+  bool header_is_valid() const
   {
     return ((common_header_len >= ((binlog_version==1) ? OLD_HEADER_LEN :
                                    LOG_EVENT_MINIMAL_HEADER_LEN)) &&
             (post_header_len != NULL));
   }
+
+  bool version_is_valid() const
+  {
+    /* It is invalid only when all version numbers are 0 */
+    return !(server_version_split.ver[0] == 0 &&
+             server_version_split.ver[1] == 0 &&
+             server_version_split.ver[2] == 0);
+  }
+
+  bool is_valid() const
+  {
+    return header_is_valid() && version_is_valid();
+  }
+
   int get_data_size()
   {
     /*
diff --git a/sql/mdl.cc b/sql/mdl.cc
index a18df0fede1..9402de02c36 100644
--- a/sql/mdl.cc
+++ b/sql/mdl.cc
@@ -85,7 +85,8 @@ PSI_stage_info MDL_key::m_namespace_to_wait_state_name[NAMESPACE_END]=
   {0, "Waiting for stored procedure metadata lock", 0},
   {0, "Waiting for trigger metadata lock", 0},
   {0, "Waiting for event metadata lock", 0},
-  {0, "Waiting for commit lock", 0}
+  {0, "Waiting for commit lock", 0},
+  {0, "User lock"} /* Be compatible with old status. */
 };
 
 #ifdef HAVE_PSI_INTERFACE
@@ -124,6 +125,7 @@ public:
   void init();
   void destroy();
   MDL_lock *find_or_insert(const MDL_key *key);
+  unsigned long get_lock_owner(const MDL_key *key);
   void remove(MDL_lock *lock);
 private:
   bool move_from_hash_to_lock_mutex(MDL_lock *lock);
@@ -399,6 +401,7 @@ public:
                       bool ignore_lock_priority) const;
 
   inline static MDL_lock *create(const MDL_key *key);
+  inline unsigned long get_lock_owner() const;
 
   void reschedule_waiters();
 
@@ -874,6 +877,43 @@ bool MDL_map::move_from_hash_to_lock_mutex(MDL_lock *lock)
 
 
 /**
+ * Return thread id of the owner of the lock, if it is owned.
+ */
+
+unsigned long
+MDL_map::get_lock_owner(const MDL_key *mdl_key)
+{
+  MDL_lock *lock;
+  unsigned long res= 0;
+
+  if (mdl_key->mdl_namespace() == MDL_key::GLOBAL ||
+      mdl_key->mdl_namespace() == MDL_key::COMMIT)
+  {
+    lock= (mdl_key->mdl_namespace() == MDL_key::GLOBAL) ? m_global_lock :
+                                                          m_commit_lock;
+    mysql_prlock_rdlock(&lock->m_rwlock);
+    res= lock->get_lock_owner();
+    mysql_prlock_unlock(&lock->m_rwlock);
+  }
+  else
+  {
+    my_hash_value_type hash_value= my_calc_hash(&m_locks,
+                                                mdl_key->ptr(),
+                                                mdl_key->length());
+    mysql_mutex_lock(&m_mutex);
+    lock= (MDL_lock*) my_hash_search_using_hash_value(&m_locks,
+                                                    hash_value,
+                                                    mdl_key->ptr(),
+                                                    mdl_key->length());
+    if (lock)
+      res= lock->get_lock_owner();
+    mysql_mutex_unlock(&m_mutex);
+  }
+  return res;
+}
+
+
+/**
   Destroy MDL_lock object or delegate this responsibility to
   whatever thread that holds the last outstanding reference to
   it.
@@ -1638,6 +1678,23 @@ MDL_lock::can_grant_lock(enum_mdl_type type_arg,
 }
 
 
+/**
+  Return thread id of the thread to which the first ticket was
+  granted.
+*/
+
+inline unsigned long
+MDL_lock::get_lock_owner() const
+{
+  Ticket_iterator it(m_granted);
+  MDL_ticket *ticket;
+
+  if ((ticket= it++))
+    return thd_get_thread_id(ticket->get_ctx()->get_thd());
+  return 0;
+}
+
+
 /** Remove a ticket from waiting or pending queue and wakeup up waiters. */
 
 void MDL_lock::remove_ticket(Ticket_list MDL_lock::*list, MDL_ticket *ticket)
@@ -2111,31 +2168,37 @@ MDL_context::acquire_lock(MDL_request *mdl_request, ulong lock_wait_timeout)
 
   find_deadlock();
 
-  if (lock->needs_notification(ticket))
+  struct timespec abs_shortwait;
+  set_timespec(abs_shortwait, 1);
+  wait_status= MDL_wait::EMPTY;
+
+  while (cmp_timespec(abs_shortwait, abs_timeout) <= 0)
   {
-    struct timespec abs_shortwait;
-    set_timespec(abs_shortwait, 1);
-    wait_status= MDL_wait::EMPTY;
+    /* abs_timeout is far away. Wait a short while and notify locks. */
+    wait_status= m_wait.timed_wait(m_thd, &abs_shortwait, FALSE,
+                                   mdl_request->key.get_wait_state_name());
 
-    while (cmp_timespec(abs_shortwait, abs_timeout) <= 0)
+    if (wait_status != MDL_wait::EMPTY)
+      break;
+    /* Check if the client is gone while we were waiting. */
+    if (! thd_is_connected(m_thd))
     {
-      /* abs_timeout is far away. Wait a short while and notify locks. */
-      wait_status= m_wait.timed_wait(m_thd, &abs_shortwait, FALSE,
-                                     mdl_request->key.get_wait_state_name());
-
-      if (wait_status != MDL_wait::EMPTY)
-        break;
+      /*
+       * The client is disconnected. Don't wait forever:
+       * assume it's the same as a wait timeout, this
+       * ensures all error handling is correct.
+       */
+      wait_status= MDL_wait::TIMEOUT;
+      break;
+    }
 
-      mysql_prlock_wrlock(&lock->m_rwlock);
+    mysql_prlock_wrlock(&lock->m_rwlock);
+    if (lock->needs_notification(ticket))
       lock->notify_conflicting_locks(this);
-      mysql_prlock_unlock(&lock->m_rwlock);
-      set_timespec(abs_shortwait, 1);
-    }
-    if (wait_status == MDL_wait::EMPTY)
-      wait_status= m_wait.timed_wait(m_thd, &abs_timeout, TRUE,
-                                     mdl_request->key.get_wait_state_name());
+    mysql_prlock_unlock(&lock->m_rwlock);
+    set_timespec(abs_shortwait, 1);
   }
-  else
+  if (wait_status == MDL_wait::EMPTY)
     wait_status= m_wait.timed_wait(m_thd, &abs_timeout, TRUE,
                                    mdl_request->key.get_wait_state_name());
 
@@ -2630,7 +2693,7 @@ void MDL_context::release_lock(MDL_ticket *ticket)
   the corresponding lists, i.e. stored in reverse temporal order.
   This allows to employ this function to:
   - back off in case of a lock conflict.
-  - release all locks in the end of a statment or transaction
+  - release all locks in the end of a statement or transaction
   - rollback to a savepoint.
 */
 
@@ -2742,6 +2805,22 @@ MDL_context::is_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
 
 
 /**
+  Return thread id of the owner of the lock or 0 if
+  there is no owner.
+  @note: Lock type is not considered at all, the function
+  simply checks that there is some lock for the given key.
+
+  @return  thread id of the owner of the lock or 0
+*/
+
+unsigned long
+MDL_context::get_lock_owner(MDL_key *key)
+{
+  return mdl_locks.get_lock_owner(key);
+}
+
+
+/**
   Check if we have any pending locks which conflict with existing shared lock.
 
   @pre The ticket must match an acquired lock.
@@ -2754,6 +2833,11 @@ bool MDL_ticket::has_pending_conflicting_lock() const
   return m_lock->has_pending_conflicting_lock(m_type);
 }
 
+/** Return a key identifying this lock. */
+MDL_key *MDL_ticket::get_key() const
+{
+        return &m_lock->key;
+}
 
 /**
   Releases metadata locks that were acquired after a specific savepoint.
diff --git a/sql/mdl.h b/sql/mdl.h
index 477f4df7807..944c6bb6349 100644
--- a/sql/mdl.h
+++ b/sql/mdl.h
@@ -234,6 +234,7 @@ public:
                             TRIGGER,
                             EVENT,
                             COMMIT,
+                            USER_LOCK,           /* user level locks. */
                             /* This should be the last ! */
                             NAMESPACE_END };
 
@@ -264,8 +265,14 @@ public:
                     const char *db, const char *name)
   {
     m_ptr[0]= (char) mdl_namespace;
-    m_db_name_length= (uint16) (strmov(m_ptr + 1, db) - m_ptr - 1);
-    m_length= (uint16) (strmov(m_ptr + m_db_name_length + 2, name) - m_ptr + 1);
+    /*
+      It is responsibility of caller to ensure that db and object names
+      are not longer than NAME_LEN. Still we play safe and try to avoid
+      buffer overruns.
+    */
+    m_db_name_length= (uint16) (strmake(m_ptr + 1, db, NAME_LEN) - m_ptr - 1);
+    m_length= (uint16) (strmake(m_ptr + m_db_name_length + 2, name, NAME_LEN) -
+                        m_ptr + 1);
   }
   void mdl_key_init(const MDL_key *rhs)
   {
@@ -508,6 +515,7 @@ public:
   }
   enum_mdl_type get_type() const { return m_type; }
   MDL_lock *get_lock() const { return m_lock; }
+  MDL_key *get_key() const;
   void downgrade_exclusive_lock(enum_mdl_type type);
 
   bool has_stronger_or_equal_type(enum_mdl_type type) const;
@@ -671,6 +679,7 @@ public:
   bool is_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
                      const char *db, const char *name,
                      enum_mdl_type mdl_type);
+  unsigned long get_lock_owner(MDL_key *mdl_key);
 
   bool has_lock(const MDL_savepoint &mdl_savepoint, MDL_ticket *mdl_ticket);
 
@@ -739,9 +748,9 @@ private:
     Lists of MDL tickets:
     ---------------------
     The entire set of locks acquired by a connection can be separated
-    in three subsets according to their: locks released at the end of
-    statement, at the end of transaction and locks are released
-    explicitly.
+    in three subsets according to their duration: locks released at
+    the end of statement, at the end of transaction and locks are
+    released explicitly.
 
     Statement and transactional locks are locks with automatic scope.
     They are accumulated in the course of a transaction, and released
@@ -750,11 +759,12 @@ private:
     locks). They must not be (and never are) released manually,
     i.e. with release_lock() call.
 
-    Locks with explicit duration are taken for locks that span
+    Tickets with explicit duration are taken for locks that span
     multiple transactions or savepoints.
     These are: HANDLER SQL locks (HANDLER SQL is
     transaction-agnostic), LOCK TABLES locks (you can COMMIT/etc
-    under LOCK TABLES, and the locked tables stay locked), and
+    under LOCK TABLES, and the locked tables stay locked), user level
+    locks (GET_LOCK()/RELEASE_LOCK() functions) and
     locks implementing "global read lock".
 
     Statement/transactional locks are always prepended to the
@@ -763,20 +773,19 @@ private:
     a savepoint, we start popping and releasing tickets from the
     front until we reach the last ticket acquired after the savepoint.
 
-    Locks with explicit duration stored are not stored in any
+    Locks with explicit duration are not stored in any
     particular order, and among each other can be split into
-    three sets:
+    four sets:
 
-    [LOCK TABLES locks] [HANDLER locks] [GLOBAL READ LOCK locks]
+    [LOCK TABLES locks] [USER locks] [HANDLER locks] [GLOBAL READ LOCK locks]
 
     The following is known about these sets:
 
-    * GLOBAL READ LOCK locks are always stored after LOCK TABLES
-      locks and after HANDLER locks. This is because one can't say
-      SET GLOBAL read_only=1 or FLUSH TABLES WITH READ LOCK
-      if one has locked tables. One can, however, LOCK TABLES
-      after having entered the read only mode. Note, that
-      subsequent LOCK TABLES statement will unlock the previous
+    * GLOBAL READ LOCK locks are always stored last.
+      This is because one can't say SET GLOBAL read_only=1 or
+      FLUSH TABLES WITH READ LOCK if one has locked tables. One can,
+      however, LOCK TABLES after having entered the read only mode.
+      Note, that subsequent LOCK TABLES statement will unlock the previous
       set of tables, but not the GRL!
       There are no HANDLER locks after GRL locks because
       SET GLOBAL read_only performs a FLUSH TABLES WITH
@@ -863,6 +872,17 @@ void mdl_destroy();
 
 extern bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use,
                                                    bool needs_thr_lock_abort);
+extern "C" unsigned long thd_get_thread_id(const MYSQL_THD thd);
+
+/**
+  Check if a connection in question is no longer connected.
+
+  @details
+  Replication apply thread is always connected. Otherwise,
+  does a poll on the associated socket to check if the client
+  is gone.
+*/
+extern "C" int thd_is_connected(MYSQL_THD thd);
 
 #ifndef DBUG_OFF
 extern mysql_mutex_t LOCK_open;
diff --git a/sql/multi_range_read.cc b/sql/multi_range_read.cc
index e6cbed7eb13..b6133eac3ae 100644
--- a/sql/multi_range_read.cc
+++ b/sql/multi_range_read.cc
@@ -1648,7 +1648,7 @@ int DsMrr_impl::dsmrr_explain_info(uint mrr_mode, char *str, size_t size)
 
     uint used_str_len= strlen(used_str);
     uint copy_len= min(used_str_len, size);
-    memcpy(str, used_str, size);
+    memcpy(str, used_str, copy_len);
     return copy_len;
   }
   return 0;
diff --git a/sql/my_apc.cc b/sql/my_apc.cc
index 5d1adb6bca7..755b3890433 100644
--- a/sql/my_apc.cc
+++ b/sql/my_apc.cc
@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2011 - 2012, Monty Program Ab
+   Copyright (c) 2011, 2013 Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -17,7 +17,6 @@
 
 #ifndef MY_APC_STANDALONE
 
-#include "sql_priv.h"
 #include "sql_class.h"
 
 #endif
diff --git a/sql/my_apc.h b/sql/my_apc.h
index 7f19809c082..c84074b2da5 100644
--- a/sql/my_apc.h
+++ b/sql/my_apc.h
@@ -1,7 +1,7 @@
-#ifndef INCLUDES_MY_APC_H
-#define INCLUDES_MY_APC_H
+#ifndef SQL_MY_APC_INCLUDED
+#define SQL_MY_APC_INCLUDED
 /*
-   Copyright (c) 2011 - 2012, Monty Program Ab
+   Copyright (c) 2011, 2013 Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -134,5 +134,5 @@ private:
 void init_show_explain_psi_keys(void);
 #endif
 
-#endif //INCLUDES_MY_APC_H
+#endif //SQL_MY_APC_INCLUDED
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 8e97861bbad..35f57bebd02 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -469,7 +469,7 @@ ulong delay_key_write_options;
 uint protocol_version;
 uint lower_case_table_names;
 ulong tc_heuristic_recover= 0;
-uint volatile thread_count;
+int32 thread_count;
 int32 thread_running;
 ulong thread_created;
 ulong back_log, connect_timeout, concurrency, server_id;
@@ -493,6 +493,7 @@ ulong executed_events=0;
 query_id_t global_query_id;
 my_atomic_rwlock_t global_query_id_lock;
 my_atomic_rwlock_t thread_running_lock;
+my_atomic_rwlock_t thread_count_lock;
 my_atomic_rwlock_t statistics_lock;
 ulong aborted_threads, aborted_connects;
 ulong delayed_insert_timeout, delayed_insert_limit, delayed_queue_size;
@@ -667,7 +668,7 @@ SHOW_COMP_OPTION have_openssl;
 
 pthread_key(MEM_ROOT**,THR_MALLOC);
 pthread_key(THD*, THR_THD);
-mysql_mutex_t LOCK_thread_count;
+mysql_mutex_t LOCK_thread_count, LOCK_thread_cache;
 mysql_mutex_t
   LOCK_status, LOCK_error_log, LOCK_short_uuid_generator,
   LOCK_delayed_insert, LOCK_delayed_status, LOCK_delayed_create,
@@ -835,7 +836,8 @@ PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_xid_list,
   key_relay_log_info_sleep_lock,
   key_relay_log_info_log_space_lock, key_relay_log_info_run_lock,
   key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data,
-  key_LOCK_error_messages, key_LOG_INFO_lock, key_LOCK_thread_count,
+  key_LOCK_error_messages, key_LOG_INFO_lock,
+  key_LOCK_thread_count, key_LOCK_thread_cache,
   key_PARTITION_LOCK_auto_inc;
 PSI_mutex_key key_RELAYLOG_LOCK_index;
 
@@ -906,6 +908,7 @@ static PSI_mutex_info all_server_mutexes[]=
   { &key_LOCK_commit_ordered, "LOCK_commit_ordered", PSI_FLAG_GLOBAL},
   { &key_LOG_INFO_lock, "LOG_INFO::lock", 0},
   { &key_LOCK_thread_count, "LOCK_thread_count", PSI_FLAG_GLOBAL},
+  { &key_LOCK_thread_cache, "LOCK_thread_cache", PSI_FLAG_GLOBAL},
   { &key_PARTITION_LOCK_auto_inc, "HA_DATA_PARTITION::LOCK_auto_inc", 0}
 };
 
@@ -1409,6 +1412,7 @@ static void clean_up(bool print_message);
 static int test_if_case_insensitive(const char *dir_name);
 
 #ifndef EMBEDDED_LIBRARY
+static bool pid_file_created= false;
 static void usage(void);
 static void start_signal_handler(void);
 static void close_server_sock();
@@ -1417,6 +1421,7 @@ static void wait_for_signal_thread_to_end(void);
 static void create_pid_file();
 static void mysqld_exit(int exit_code) __attribute__((noreturn));
 #endif
+static void delete_pid_file(myf flags);
 static void end_ssl();
 
 
@@ -1574,7 +1579,7 @@ static void close_connections(void)
   end_slave();
 
   /* Give threads time to die. */
-  for (int i= 0; thread_count && i < 100; i++)
+  for (int i= 0; *(volatile int32*) &thread_count && i < 100; i++)
     my_sleep(20000);
 
   /*
@@ -1915,10 +1920,9 @@ void clean_up(bool print_message)
 #endif
   query_cache_destroy();
   hostname_cache_free();
-  item_user_lock_free();
+  item_func_sleep_free();
   lex_free();				/* Free some memory */
   item_create_cleanup();
-  free_charsets();
   if (!opt_noacl)
   {
 #ifdef HAVE_DLOPEN
@@ -1965,10 +1969,8 @@ void clean_up(bool print_message)
   debug_sync_end();
 #endif /* defined(ENABLED_DEBUG_SYNC) */
 
-#if !defined(EMBEDDED_LIBRARY)
-  if (!opt_bootstrap)
-    mysql_file_delete(key_file_pid, pidfile_name, MYF(0)); // This may not always exist
-#endif
+  delete_pid_file(MYF(0));
+
   if (print_message && my_default_lc_messages && server_start_time)
     sql_print_information(ER_DEFAULT(ER_SHUTDOWN_COMPLETE),my_progname);
   cleanup_errmsgs();
@@ -1982,7 +1984,9 @@ void clean_up(bool print_message)
   sys_var_end();
   my_atomic_rwlock_destroy(&global_query_id_lock);
   my_atomic_rwlock_destroy(&thread_running_lock);
+  my_atomic_rwlock_destroy(&thread_count_lock);
   my_atomic_rwlock_destroy(&statistics_lock); 
+  free_charsets();
   mysql_mutex_lock(&LOCK_thread_count);
   DBUG_PRINT("quit", ("got thread count lock"));
   ready_to_exit=1;
@@ -2026,6 +2030,7 @@ static void clean_up_mutexes()
   DBUG_ENTER("clean_up_mutexes");
   mysql_rwlock_destroy(&LOCK_grant);
   mysql_mutex_destroy(&LOCK_thread_count);
+  mysql_mutex_destroy(&LOCK_thread_cache);
   mysql_mutex_destroy(&LOCK_status);
   mysql_mutex_destroy(&LOCK_delayed_insert);
   mysql_mutex_destroy(&LOCK_delayed_status);
@@ -2276,8 +2281,27 @@ static MYSQL_SOCKET activate_tcp_port(uint port)
   {
     ip_sock= mysql_socket_socket(key_socket_tcpip, a->ai_family,
                                  a->ai_socktype, a->ai_protocol);
-    if (mysql_socket_getfd(ip_sock) != INVALID_SOCKET)
+
+    char ip_addr[INET6_ADDRSTRLEN];
+    if (vio_get_normalized_ip_string(a->ai_addr, a->ai_addrlen,
+                                     ip_addr, sizeof (ip_addr)))
+    {
+      ip_addr[0]= 0;
+    }
+
+    if (mysql_socket_getfd(ip_sock) == INVALID_SOCKET)
+    {
+      sql_print_error("Failed to create a socket for %s '%s': errno: %d.",
+                      (a->ai_family == AF_INET) ? "IPv4" : "IPv6",
+                      (const char *) ip_addr,
+                      (int) socket_errno);
+    }
+    else 
+    {
+      sql_print_information("Server socket created on IP: '%s'.",
+                          (const char *) ip_addr);
       break;
+    }
   }
 
   if (mysql_socket_getfd(ip_sock) == INVALID_SOCKET)
@@ -2514,7 +2538,7 @@ void close_connection(THD *thd, uint sql_errno)
   {
     sleep(0); /* Workaround to avoid tailcall optimisation */
   }
-  MYSQL_AUDIT_NOTIFY_CONNECTION_DISCONNECT(thd, sql_errno);
+  mysql_audit_notify_connection_disconnect(thd, sql_errno);
   DBUG_VOID_RETURN;
 }
 #endif /* EMBEDDED_LIBRARY */
@@ -2561,6 +2585,28 @@ void dec_connection_count(THD *thd)
 
 
 /*
+  Delete THD and decrement thread counters, including thread_running
+*/
+
+void delete_running_thd(THD *thd)
+{
+  mysql_mutex_lock(&LOCK_thread_count);
+  thd->unlink();
+  mysql_mutex_unlock(&LOCK_thread_count);
+
+  delete thd;
+  dec_thread_running();
+  thread_safe_decrement32(&thread_count, &thread_count_lock);
+  if (!thread_count)
+  {
+    mysql_mutex_lock(&LOCK_thread_count);
+    mysql_cond_broadcast(&COND_thread_count);
+    mysql_mutex_unlock(&LOCK_thread_count);
+  }
+}
+
+
+/*
   Unlink thd from global list of available connections and free thd
 
   SYNOPSIS
@@ -2584,7 +2630,6 @@ void unlink_thd(THD *thd)
   mysql_mutex_unlock(&LOCK_status);
 
   mysql_mutex_lock(&LOCK_thread_count);
-  thread_count--;
   thd->unlink();
   /*
     Used by binlog_reset_master.  It would be cleaner to use
@@ -2592,13 +2637,11 @@ void unlink_thd(THD *thd)
     sync feature has been shut down at this point.
   */
   DBUG_EXECUTE_IF("sleep_after_lock_thread_count_before_delete_thd", sleep(5););
-  /*
-    We must delete thd inside the lock to ensure that we don't start cleanup
-    before THD is deleted
-  */
-  delete thd;
   mysql_mutex_unlock(&LOCK_thread_count);
 
+  delete thd;
+  thread_safe_decrement32(&thread_count, &thread_count_lock);
+
   DBUG_VOID_RETURN;
 }
 
@@ -2610,7 +2653,7 @@ void unlink_thd(THD *thd)
     cache_thread()
 
   NOTES
-    LOCK_thread_count has to be locked
+    LOCK_thread_cache is used to protect the cache variables
 
   RETURN
     0  Thread was not put in cache
@@ -2621,7 +2664,9 @@ void unlink_thd(THD *thd)
 
 static bool cache_thread()
 {
-  mysql_mutex_assert_owner(&LOCK_thread_count);
+  DBUG_ENTER("cache_thread");
+
+  mysql_mutex_lock(&LOCK_thread_cache);
   if (cached_thread_count < thread_cache_size &&
       ! abort_loop && !kill_cached_threads)
   {
@@ -2638,7 +2683,7 @@ static bool cache_thread()
 #endif
 
     while (!abort_loop && ! wake_thread && ! kill_cached_threads)
-      mysql_cond_wait(&COND_thread_cache, &LOCK_thread_count);
+      mysql_cond_wait(&COND_thread_cache, &LOCK_thread_cache);
     cached_thread_count--;
     if (kill_cached_threads)
       mysql_cond_signal(&COND_flush_thread_cache);
@@ -2647,6 +2692,8 @@ static bool cache_thread()
       THD *thd;
       wake_thread--;
       thd= thread_cache.get();
+      mysql_mutex_unlock(&LOCK_thread_cache);
+
       thd->thread_stack= (char*) &thd;          // For store_globals
       (void) thd->store_globals();
 
@@ -2668,11 +2715,16 @@ static bool cache_thread()
       thd->mysys_var->abort= 0;
       thd->thr_create_utime= microsecond_interval_timer();
       thd->start_utime= thd->thr_create_utime;
+
+      /* Link thd into list of all active threads (THD's) */
+      mysql_mutex_lock(&LOCK_thread_count);
       threads.append(thd);
-      return(1);
+      mysql_mutex_unlock(&LOCK_thread_count);
+      DBUG_RETURN(1);
     }
   }
-  return(0);
+  mysql_mutex_unlock(&LOCK_thread_cache);
+  DBUG_RETURN(0);
 }
 
 
@@ -2701,19 +2753,22 @@ bool one_thread_per_connection_end(THD *thd, bool put_in_cache)
   unlink_thd(thd);
   /* Mark that current_thd is not valid anymore */
   set_current_thd(0);
-  if (put_in_cache)
+  if (put_in_cache && cache_thread())
+    DBUG_RETURN(0);                             // Thread is reused
+
+  /*
+    It's safe to check for thread_count outside of the mutex
+    as we are only interested to see if it was counted to 0 by the
+    above unlink_thd() call. We should only signal COND_thread_count if
+    thread_count is likely to be 0. (false positives are ok)
+  */
+  if (!thread_count)
   {
     mysql_mutex_lock(&LOCK_thread_count);
-    put_in_cache= cache_thread();
+    DBUG_PRINT("signal", ("Broadcasting COND_thread_count"));
+    mysql_cond_broadcast(&COND_thread_count);
     mysql_mutex_unlock(&LOCK_thread_count);
-    if (put_in_cache)
-      DBUG_RETURN(0);                             // Thread is reused
   }
-
-  /* It's safe to broadcast outside a lock (COND... is not deleted here) */
-  DBUG_PRINT("signal", ("Broadcasting COND_thread_count"));
-  mysql_cond_broadcast(&COND_thread_count);
-
   DBUG_LEAVE;                                   // Must match DBUG_ENTER()
   my_thread_end();
 
@@ -2724,15 +2779,17 @@ bool one_thread_per_connection_end(THD *thd, bool put_in_cache)
 
 void flush_thread_cache()
 {
-  mysql_mutex_lock(&LOCK_thread_count);
+  DBUG_ENTER("flush_thread_cache");
+  mysql_mutex_lock(&LOCK_thread_cache);
   kill_cached_threads++;
   while (cached_thread_count)
   {
     mysql_cond_broadcast(&COND_thread_cache);
-    mysql_cond_wait(&COND_flush_thread_cache, &LOCK_thread_count);
+    mysql_cond_wait(&COND_flush_thread_cache, &LOCK_thread_cache);
   }
   kill_cached_threads--;
-  mysql_mutex_unlock(&LOCK_thread_count);
+  mysql_mutex_unlock(&LOCK_thread_cache);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -3322,14 +3379,7 @@ pthread_handler_t handle_shutdown(void *arg)
 }
 #endif
 
-const char *load_default_groups[]= {
-#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
-"mysql_cluster",
-#endif
-"mysqld", "server", MYSQL_BASE_VERSION,
-"mariadb", MARIADB_BASE_VERSION,
-"client-server",
-0, 0};
+#include <mysqld_default_groups.h>
 
 #if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
 static const int load_default_groups_sz=
@@ -4136,6 +4186,7 @@ static int init_thread_environment()
 {
   DBUG_ENTER("init_thread_environment");
   mysql_mutex_init(key_LOCK_thread_count, &LOCK_thread_count, MY_MUTEX_INIT_FAST);
+  mysql_mutex_init(key_LOCK_thread_cache, &LOCK_thread_cache, MY_MUTEX_INIT_FAST);
   mysql_mutex_init(key_LOCK_status, &LOCK_status, MY_MUTEX_INIT_FAST);
   mysql_mutex_init(key_LOCK_delayed_insert,
                    &LOCK_delayed_insert, MY_MUTEX_INIT_FAST);
@@ -5149,9 +5200,7 @@ int mysqld_main(int argc, char **argv)
 
     (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
 
-
-    if (!opt_bootstrap)
-      mysql_file_delete(key_file_pid, pidfile_name, MYF(MY_WME)); // Not needed anymore
+    delete_pid_file(MYF(MY_WME));
 
     if (mysql_socket_getfd(unix_sock) != INVALID_SOCKET)
       unlink(mysqld_unix_port);
@@ -5537,7 +5586,7 @@ static void bootstrap(MYSQL_FILE *file)
   thd->max_client_packet_length= thd->net.max_packet;
   thd->security_ctx->master_access= ~(ulong)0;
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
-  thread_count++;
+  thread_count++;                        // Safe as only one thread running
   in_bootstrap= TRUE;
 
   bootstrap_file=file;
@@ -5618,54 +5667,69 @@ void handle_connection_in_main_thread(THD *thd)
 
 void create_thread_to_handle_connection(THD *thd)
 {
+  DBUG_ENTER("create_thread_to_handle_connection");
+  mysql_mutex_assert_owner(&LOCK_thread_count);
+
+  /* Check if we can get thread from the cache */
   if (cached_thread_count > wake_thread)
   {
-    /* Get thread from cache */
-    thread_cache.push_back(thd);
-    wake_thread++;
-    mysql_cond_signal(&COND_thread_cache);
-  }
-  else
-  {
-    char error_message_buff[MYSQL_ERRMSG_SIZE];
-    /* Create new thread to handle connection */
-    int error;
-    thread_created++;
-    threads.append(thd);
-    DBUG_PRINT("info",(("creating thread %lu"), thd->thread_id));
-    thd->prior_thr_create_utime= microsecond_interval_timer();
-    if ((error= mysql_thread_create(key_thread_one_connection,
-                                    &thd->real_id, &connection_attrib,
-                                    handle_one_connection,
-                                    (void*) thd)))
+    mysql_mutex_lock(&LOCK_thread_cache);
+    /* Recheck condition when we have the lock */
+    if (cached_thread_count > wake_thread)
     {
-      /* purecov: begin inspected */
-      DBUG_PRINT("error",
-                 ("Can't create thread to handle request (error %d)",
-                  error));
-      thread_count--;
-      thd->killed= KILL_CONNECTION;             // Safety
       mysql_mutex_unlock(&LOCK_thread_count);
+      /* Get thread from cache */
+      thread_cache.push_back(thd);
+      wake_thread++;
+      mysql_cond_signal(&COND_thread_cache);
+      mysql_mutex_unlock(&LOCK_thread_cache);
+      DBUG_PRINT("info",("Thread created"));
+      DBUG_VOID_RETURN;
+    }
+    mysql_mutex_unlock(&LOCK_thread_cache);
+  }
 
-      mysql_mutex_lock(&LOCK_connection_count);
-      (*thd->scheduler->connection_count)--;
-      mysql_mutex_unlock(&LOCK_connection_count);
+  char error_message_buff[MYSQL_ERRMSG_SIZE];
+  /* Create new thread to handle connection */
+  int error;
+  thread_created++;
+  threads.append(thd);
+  DBUG_PRINT("info",(("creating thread %lu"), thd->thread_id));
+  thd->prior_thr_create_utime= microsecond_interval_timer();
+  if ((error= mysql_thread_create(key_thread_one_connection,
+                                  &thd->real_id, &connection_attrib,
+                                  handle_one_connection,
+                                  (void*) thd)))
+  {
+    /* purecov: begin inspected */
+    DBUG_PRINT("error",
+               ("Can't create thread to handle request (error %d)",
+                error));
+    thd->killed= KILL_CONNECTION;             // Safety
+    mysql_mutex_unlock(&LOCK_thread_count);
 
-      statistic_increment(aborted_connects,&LOCK_status);
-      /* Can't use my_error() since store_globals has not been called. */
-      my_snprintf(error_message_buff, sizeof(error_message_buff),
-                  ER_THD(thd, ER_CANT_CREATE_THREAD), error);
-      net_send_error(thd, ER_CANT_CREATE_THREAD, error_message_buff, NULL);
-      close_connection(thd, ER_OUT_OF_RESOURCES);
-      mysql_mutex_lock(&LOCK_thread_count);
-      delete thd;
-      mysql_mutex_unlock(&LOCK_thread_count);
-      return;
-      /* purecov: end */
-    }
+    mysql_mutex_lock(&LOCK_connection_count);
+    (*thd->scheduler->connection_count)--;
+    mysql_mutex_unlock(&LOCK_connection_count);
+
+    statistic_increment(aborted_connects,&LOCK_status);
+    /* Can't use my_error() since store_globals has not been called. */
+    my_snprintf(error_message_buff, sizeof(error_message_buff),
+                ER_THD(thd, ER_CANT_CREATE_THREAD), error);
+    net_send_error(thd, ER_CANT_CREATE_THREAD, error_message_buff, NULL);
+    close_connection(thd, ER_OUT_OF_RESOURCES);
+
+    mysql_mutex_lock(&LOCK_thread_count);
+    thd->unlink();
+    mysql_mutex_unlock(&LOCK_thread_count);
+    delete thd;
+    thread_safe_decrement32(&thread_count, &thread_count_lock);
+    return;
+    /* purecov: end */
   }
   mysql_mutex_unlock(&LOCK_thread_count);
   DBUG_PRINT("info",("Thread created"));
+  DBUG_VOID_RETURN;
 }
 
 
@@ -5712,10 +5776,10 @@ static void create_new_thread(THD *thd)
 
   mysql_mutex_unlock(&LOCK_connection_count);
 
-  /* Start a new thread to handle connection. */
+  thread_safe_increment32(&thread_count, &thread_count_lock);
 
+  /* Start a new thread to handle connection. */
   mysql_mutex_lock(&LOCK_thread_count);
-
   /*
     The initialization of thread_id is done in create_embedded_thd() for
     the embedded library.
@@ -5723,8 +5787,6 @@ static void create_new_thread(THD *thd)
   */
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
 
-  thread_count++;
-
   MYSQL_CALLBACK(thd->scheduler, add_connection, (thd));
 
   DBUG_VOID_RETURN;
@@ -5941,21 +6003,6 @@ void handle_connections_sockets()
     }
 #endif /* HAVE_LIBWRAP */
 
-    {
-      size_socket dummyLen;
-      struct sockaddr_storage dummy;
-      dummyLen = sizeof(dummy);
-      if (getsockname(mysql_socket_getfd(new_sock),
-                      (struct sockaddr *)&dummy, 
-                      (SOCKET_SIZE_TYPE *)&dummyLen) < 0  )
-      {
-	sql_perror("Error on new connection socket");
-	(void) mysql_socket_shutdown(new_sock, SHUT_RDWR);
-	(void) mysql_socket_close(new_sock);
-	continue;
-      }
-    }
-
     /*
     ** Don't allow too many connections
     */
@@ -7376,8 +7423,8 @@ SHOW_VAR status_vars[]= {
   {"Feature_locale",           (char*) offsetof(STATUS_VAR, feature_locale), SHOW_LONG_STATUS},
   {"Feature_subquery",         (char*) offsetof(STATUS_VAR, feature_subquery), SHOW_LONG_STATUS},
   {"Feature_timezone",         (char*) offsetof(STATUS_VAR, feature_timezone), SHOW_LONG_STATUS},
-  {"Feature_trigger",         (char*) offsetof(STATUS_VAR, feature_trigger), SHOW_LONG_STATUS},
-  {"Feature_xml",             (char*) offsetof(STATUS_VAR, feature_xml), SHOW_LONG_STATUS},
+  {"Feature_trigger",          (char*) offsetof(STATUS_VAR, feature_trigger), SHOW_LONG_STATUS},
+  {"Feature_xml",              (char*) offsetof(STATUS_VAR, feature_xml), SHOW_LONG_STATUS},
   {"Flush_commands",           (char*) &refresh_version,        SHOW_LONG_NOFLUSH},
   {"Handler_commit",           (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},
   {"Handler_delete",           (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},
@@ -7386,8 +7433,8 @@ SHOW_VAR status_vars[]= {
   {"Handler_icp_attempts",     (char*) offsetof(STATUS_VAR, ha_icp_attempts), SHOW_LONG_STATUS},
   {"Handler_icp_match",        (char*) offsetof(STATUS_VAR, ha_icp_match), SHOW_LONG_STATUS},
   {"Handler_mrr_init",         (char*) offsetof(STATUS_VAR, ha_mrr_init_count),  SHOW_LONG_STATUS},
-  {"Handler_mrr_key_refills",   (char*) offsetof(STATUS_VAR, ha_mrr_key_refills_count), SHOW_LONG_STATUS},
-  {"Handler_mrr_rowid_refills", (char*) offsetof(STATUS_VAR, ha_mrr_rowid_refills_count), SHOW_LONG_STATUS},
+  {"Handler_mrr_key_refills",  (char*) offsetof(STATUS_VAR, ha_mrr_key_refills_count), SHOW_LONG_STATUS},
+  {"Handler_mrr_rowid_refills",(char*) offsetof(STATUS_VAR, ha_mrr_rowid_refills_count), SHOW_LONG_STATUS},
   {"Handler_prepare",          (char*) offsetof(STATUS_VAR, ha_prepare_count),  SHOW_LONG_STATUS},
   {"Handler_read_first",       (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},
   {"Handler_read_key",         (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},
@@ -7414,9 +7461,10 @@ SHOW_VAR status_vars[]= {
   {"Open_table_definitions",   (char*) &show_table_definitions, SHOW_SIMPLE_FUNC},
   {"Open_tables",              (char*) &show_open_tables,       SHOW_SIMPLE_FUNC},
   {"Opened_files",             (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},
+  {"Opened_plugin_libraries",  (char*) &dlopen_count, SHOW_LONG},
   {"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},
   {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
-  {"Opened_views",            (char*) offsetof(STATUS_VAR, opened_views), SHOW_LONG_STATUS},
+  {"Opened_views",             (char*) offsetof(STATUS_VAR, opened_views), SHOW_LONG_STATUS},
   {"Prepared_stmt_count",      (char*) &show_prepared_stmt_count, SHOW_SIMPLE_FUNC},
   {"Rows_sent",                (char*) offsetof(STATUS_VAR, rows_sent), SHOW_LONGLONG_STATUS},
   {"Rows_read",                (char*) offsetof(STATUS_VAR, rows_read), SHOW_LONGLONG_STATUS},
@@ -7710,12 +7758,13 @@ static int mysql_init_variables(void)
   log_error_file_ptr= log_error_file;
   protocol_version= PROTOCOL_VERSION;
   what_to_log= ~ (1L << (uint) COM_TIME);
-  refresh_version= 1L;	/* Increments on each reload */
+  refresh_version= 2L;	/* Increments on each reload. 0 and 1 are reserved */
   denied_connections= 0;
   executed_events= 0;
   global_query_id= thread_id= 1L;
   my_atomic_rwlock_init(&global_query_id_lock);
   my_atomic_rwlock_init(&thread_running_lock);
+  my_atomic_rwlock_init(&thread_count_lock);
   my_atomic_rwlock_init(&statistics_lock);
   strmov(server_version, MYSQL_SERVER_VERSION);
   threads.empty();
@@ -8084,28 +8133,6 @@ mysqld_get_one_option(int optid,
   case (int) OPT_WANT_CORE:
     test_flags |= TEST_CORE_ON_SIGNAL;
     break;
-  case (int) OPT_BIND_ADDRESS:
-    {
-      struct addrinfo *res_lst, hints;    
-
-      bzero(&hints, sizeof(struct addrinfo));
-      hints.ai_socktype= SOCK_STREAM;
-      hints.ai_protocol= IPPROTO_TCP;
-
-      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0) 
-      {
-        sql_print_error("Can't start server: cannot resolve hostname!");
-        return 1;
-      }
-
-      if (res_lst->ai_next)
-      {
-        sql_print_error("Can't start server: bind-address refers to multiple interfaces!");
-        return 1;
-      }
-      freeaddrinfo(res_lst);
-    }
-    break;
   case OPT_CONSOLE:
     if (opt_console)
       opt_error_log= 0;			// Force logs to stdout
@@ -8418,7 +8445,7 @@ static int get_options(int *argc_ptr, char ***argv_ptr)
 
   global_system_variables.sql_mode=
     expand_sql_mode(global_system_variables.sql_mode);
-#if defined(HAVE_BROKEN_REALPATH)
+#if !defined(HAVE_REALPATH) || defined(HAVE_BROKEN_REALPATH)
   my_use_symdir=0;
   my_disable_symlinks=1;
   have_symlink=SHOW_OPTION_NO;
@@ -8805,13 +8832,14 @@ static void create_pid_file()
   if ((file= mysql_file_create(key_file_pid, pidfile_name, 0664,
                                O_WRONLY | O_TRUNC, MYF(MY_WME))) >= 0)
   {
-    char buff[21], *end;
+    char buff[MAX_BIGINT_WIDTH + 1], *end;
     end= int10_to_str((long) getpid(), buff, 10);
     *end++= '\n';
     if (!mysql_file_write(file, (uchar*) buff, (uint) (end-buff),
                           MYF(MY_WME | MY_NABP)))
     {
       mysql_file_close(file, MYF(0));
+      pid_file_created= true;
       return;
     }
     mysql_file_close(file, MYF(0));
@@ -8821,6 +8849,26 @@ static void create_pid_file()
 }
 #endif /* EMBEDDED_LIBRARY */
 
+
+/**
+  Remove the process' pid file.
+  
+  @param  flags  file operation flags
+*/
+
+static void delete_pid_file(myf flags)
+{
+#ifndef EMBEDDED_LIBRARY
+  if (pid_file_created)
+  {
+    mysql_file_delete(key_file_pid, pidfile_name, flags);
+    pid_file_created= false;
+  }
+#endif /* EMBEDDED_LIBRARY */
+  return;
+}
+
+
 /** Clear most status variables. */
 void refresh_status(THD *thd)
 {
@@ -8844,13 +8892,9 @@ void refresh_status(THD *thd)
 
   /*
     Set max_used_connections to the number of currently open
-    connections.  Lock LOCK_thread_count out of LOCK_status to avoid
-    deadlocks.  Status reset becomes not atomic, but status data is
-    not exact anyway.
+    connections.  This is not perfect, but status data is not exact anyway.
   */
-  mysql_mutex_lock(&LOCK_thread_count);
   max_used_connections= thread_count-delayed_insert_threads;
-  mysql_mutex_unlock(&LOCK_thread_count);
 }
 
 #ifdef HAVE_PSI_INTERFACE
diff --git a/sql/mysqld.h b/sql/mysqld.h
index 716423f9bd2..7e4295365ce 100644
--- a/sql/mysqld.h
+++ b/sql/mysqld.h
@@ -57,6 +57,7 @@ void kill_mysql(void);
 void close_connection(THD *thd, uint sql_errno= 0);
 void handle_connection_in_main_thread(THD *thd);
 void create_thread_to_handle_connection(THD *thd);
+void delete_running_thd(THD *thd);
 void unlink_thd(THD *thd);
 bool one_thread_per_connection_end(THD *thd, bool put_in_cache);
 void flush_thread_cache();
@@ -90,7 +91,6 @@ extern bool opt_ignore_builtin_innodb;
 extern my_bool opt_character_set_client_handshake;
 extern bool volatile abort_loop;
 extern bool in_bootstrap;
-extern uint volatile thread_count;
 extern uint connection_count;
 extern my_bool opt_safe_user_create;
 extern my_bool opt_safe_show_db, opt_local_infile, opt_myisam_use_mmap;
@@ -466,7 +466,7 @@ extern MYSQL_PLUGIN_IMPORT key_map key_map_full;          /* Should be threaded
   Server mutex locks and condition variables.
  */
 extern mysql_mutex_t
-       LOCK_user_locks, LOCK_status,
+       LOCK_item_func_sleep, LOCK_status,
        LOCK_error_log, LOCK_delayed_insert, LOCK_short_uuid_generator,
        LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,
        LOCK_slave_list, LOCK_active_mi, LOCK_manager,
@@ -483,7 +483,8 @@ extern mysql_rwlock_t LOCK_system_variables_hash;
 extern mysql_cond_t COND_thread_count;
 extern mysql_cond_t COND_manager;
 extern int32 thread_running;
-extern my_atomic_rwlock_t thread_running_lock;
+extern int32 thread_count;
+extern my_atomic_rwlock_t thread_running_lock, thread_count_lock;
 
 extern char *opt_ssl_ca, *opt_ssl_capath, *opt_ssl_cert, *opt_ssl_cipher,
   *opt_ssl_key, *opt_ssl_crl, *opt_ssl_crlpath;
@@ -585,7 +586,7 @@ inline query_id_t next_query_id()
   my_atomic_rwlock_wrlock(&global_query_id_lock);
   id= my_atomic_add64(&global_query_id, 1);
   my_atomic_rwlock_wrunlock(&global_query_id_lock);
-  return (id+1);
+  return (id);
 }
 
 inline query_id_t get_query_id()
@@ -615,42 +616,30 @@ inline void table_case_convert(char * name, uint length)
                                      name, length, name, length);
 }
 
-inline ulong sql_rnd_with_mutex()
+inline void thread_safe_increment32(int32 *value, my_atomic_rwlock_t *lock)
 {
-  mysql_mutex_lock(&LOCK_thread_count);
-  ulong tmp=(ulong) (my_rnd(&sql_rand) * 0xffffffff); /* make all bits random */
-  mysql_mutex_unlock(&LOCK_thread_count);
-  return tmp;
+  my_atomic_rwlock_wrlock(lock);
+  (void) my_atomic_add32(value, 1);
+  my_atomic_rwlock_wrunlock(lock);
 }
 
-inline int32
-inc_thread_running()
+inline void thread_safe_decrement32(int32 *value, my_atomic_rwlock_t *lock)
 {
-  int32 num_thread_running;
-  my_atomic_rwlock_wrlock(&thread_running_lock);
-  num_thread_running= my_atomic_add32(&thread_running, 1);
-  my_atomic_rwlock_wrunlock(&thread_running_lock);
-  return (num_thread_running+1);
+  my_atomic_rwlock_wrlock(lock);
+  (void) my_atomic_add32(value, -1);
+  my_atomic_rwlock_wrunlock(lock);
 }
 
-inline int32
-dec_thread_running()
+inline void
+inc_thread_running()
 {
-  int32 num_thread_running;
-  my_atomic_rwlock_wrlock(&thread_running_lock);
-  num_thread_running= my_atomic_add32(&thread_running, -1);
-  my_atomic_rwlock_wrunlock(&thread_running_lock);
-  return (num_thread_running-1);
+  thread_safe_increment32(&thread_running, &thread_running_lock);
 }
 
-inline int32
-get_thread_running()
+inline void
+dec_thread_running()
 {
-  int32 num_thread_running;
-  my_atomic_rwlock_wrlock(&thread_running_lock);
-  num_thread_running= my_atomic_load32(&thread_running);
-  my_atomic_rwlock_wrunlock(&thread_running_lock);
-  return num_thread_running;
+  thread_safe_decrement32(&thread_running, &thread_running_lock);
 }
 
 void set_server_version(void);
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 2205d2fcab4..96354f05110 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -132,7 +132,12 @@
 
 static int sel_cmp(Field *f,uchar *a,uchar *b,uint8 a_flag,uint8 b_flag);
 
-static uchar is_null_string[2]= {1,0};
+/*
+  this should be long enough so that any memcmp with a string that
+  starts from '\0' won't cross is_null_string boundaries, even
+  if the memcmp is optimized to compare 4- 8- or 16- bytes at once
+*/
+static uchar is_null_string[20]= {1,0};
 
 class RANGE_OPT_PARAM;
 /*
@@ -2000,7 +2005,7 @@ int QUICK_ROR_INTERSECT_SELECT::init()
     1  error
 */
 
-int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler)
+int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler, MEM_ROOT *alloc)
 {
   handler *save_file= file, *org_file;
   my_bool org_key_read;
@@ -2028,7 +2033,7 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler)
     DBUG_RETURN(0);
   }
 
-  if (!(file= head->file->clone(head->s->normalized_path.str, thd->mem_root)))
+  if (!(file= head->file->clone(head->s->normalized_path.str, alloc)))
   {
     /* 
       Manually set the error flag. Note: there seems to be quite a few
@@ -2129,7 +2134,8 @@ failure:
     0     OK
     other error code
 */
-int QUICK_ROR_INTERSECT_SELECT::init_ror_merged_scan(bool reuse_handler)
+int QUICK_ROR_INTERSECT_SELECT::init_ror_merged_scan(bool reuse_handler, 
+                                                     MEM_ROOT *alloc)
 {
   List_iterator_fast<QUICK_SELECT_WITH_RECORD> quick_it(quick_selects);
   QUICK_SELECT_WITH_RECORD *cur;
@@ -2146,7 +2152,7 @@ int QUICK_ROR_INTERSECT_SELECT::init_ror_merged_scan(bool reuse_handler)
       There is no use of this->file. Use it for the first of merged range
       selects.
     */
-    int error= quick->init_ror_merged_scan(TRUE);
+    int error= quick->init_ror_merged_scan(TRUE, alloc);
     if (error)
       DBUG_RETURN(error);
     quick->file->extra(HA_EXTRA_KEYREAD_PRESERVE_FIELDS);
@@ -2158,7 +2164,7 @@ int QUICK_ROR_INTERSECT_SELECT::init_ror_merged_scan(bool reuse_handler)
     const MY_BITMAP * const save_read_set= quick->head->read_set;
     const MY_BITMAP * const save_write_set= quick->head->write_set;
 #endif
-    if (quick->init_ror_merged_scan(FALSE))
+    if (quick->init_ror_merged_scan(FALSE, alloc))
       DBUG_RETURN(1);
     quick->file->extra(HA_EXTRA_KEYREAD_PRESERVE_FIELDS);
 
@@ -2192,7 +2198,7 @@ int QUICK_ROR_INTERSECT_SELECT::init_ror_merged_scan(bool reuse_handler)
 int QUICK_ROR_INTERSECT_SELECT::reset()
 {
   DBUG_ENTER("QUICK_ROR_INTERSECT_SELECT::reset");
-  if (!scans_inited && init_ror_merged_scan(TRUE))
+  if (!scans_inited && init_ror_merged_scan(TRUE, &alloc))
     DBUG_RETURN(1);
   scans_inited= TRUE;
   List_iterator_fast<QUICK_SELECT_WITH_RECORD> it(quick_selects);
@@ -2329,7 +2335,7 @@ int QUICK_ROR_UNION_SELECT::reset()
     List_iterator_fast<QUICK_SELECT_I> it(quick_selects);
     while ((quick= it++))
     {
-      if (quick->init_ror_merged_scan(FALSE))
+      if (quick->init_ror_merged_scan(FALSE, &alloc))
         DBUG_RETURN(1);
     }
     scans_inited= TRUE;
@@ -7373,8 +7379,10 @@ static SEL_TREE *get_mm_tree(RANGE_OPT_PARAM *param,COND *cond)
     DBUG_RETURN(tree);
   }
   /* Here when simple cond */
-  if (cond->const_item() && !cond->is_expensive())
+  if (cond->const_item())
   {
+    if (cond->is_expensive())
+      DBUG_RETURN(0);
     /*
       During the cond->val_int() evaluation we can come across a subselect 
       item which may allocate memory on the thd->mem_root and assumes 
@@ -11691,7 +11699,8 @@ static bool get_constant_key_infix(KEY *index_info, SEL_ARG *index_range_tree,
                        KEY_PART_INFO **first_non_infix_part);
 static bool
 check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
-                               Field::imagetype image_type);
+                               Field::imagetype image_type,
+                               bool *has_min_max_fld, bool *has_other_fld);
 
 static void
 cost_group_min_max(TABLE* table, KEY *index_info, uint used_key_parts,
@@ -12031,6 +12040,13 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree, double read_time)
         else
           goto next_index;
       }
+      /*
+        This function is called on the precondition that the index is covering.
+        Therefore if the GROUP BY list contains more elements than the index,
+        these are duplicates. The GROUP BY list cannot be a prefix of the index.
+      */
+      if (cur_part == end_part && tmp_group)
+        goto next_index;
     }
     /*
       Check (GA2) if this is a DISTINCT query.
@@ -12084,7 +12100,7 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree, double read_time)
         cur_parts have bits set for only used keyparts.
       */
       ulonglong all_parts, cur_parts;
-      all_parts= (1<<max_key_part) - 1;
+      all_parts= (1ULL << max_key_part) - 1;
       cur_parts= used_key_parts_map.to_ulonglong() >> 1;
       if (all_parts != cur_parts)
         goto next_index;
@@ -12241,10 +12257,12 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree, double read_time)
     DBUG_RETURN(NULL);
 
   /* Check (SA3) for the where clause. */
+  bool has_min_max_fld= false, has_other_fld= false;
   if (join->conds && min_max_arg_item &&
       !check_group_min_max_predicates(join->conds, min_max_arg_item,
                                       (index_info->flags & HA_SPATIAL) ?
-                                      Field::itMBR : Field::itRAW))
+                                      Field::itMBR : Field::itRAW,
+                                      &has_min_max_fld, &has_other_fld))
     DBUG_RETURN(NULL);
 
   /*
@@ -12292,16 +12310,24 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree, double read_time)
 
   SYNOPSIS
     check_group_min_max_predicates()
-    cond              tree (or subtree) describing all or part of the WHERE
-                      clause being analyzed
-    min_max_arg_item  the field referenced by the MIN/MAX function(s)
-    min_max_arg_part  the keypart of the MIN/MAX argument if any
+    cond        [in]  the expression tree being analyzed
+    min_max_arg [in]  the field referenced by the MIN/MAX function(s)
+    image_type  [in]
+    has_min_max_arg [out] true if the subtree being analyzed references min_max_arg
+    has_other_arg   [out] true if the subtree being analyzed references a column
+                          other min_max_arg
 
   DESCRIPTION
     The function walks recursively over the cond tree representing a WHERE
     clause, and checks condition (SA3) - if a field is referenced by a MIN/MAX
     aggregate function, it is referenced only by one of the following
-    predicates: {=, !=, <, <=, >, >=, between, is null, is not null}.
+    predicates $FUNC$:
+    {=, !=, <, <=, >, >=, between, is [not] null, multiple equal}.
+    In addition the function checks that the WHERE condition is equivalent to
+    "cond1 AND cond2" where :
+    cond1 - does not use min_max_column at all.
+    cond2 - is an AND/OR tree with leaves in form
+    "$FUNC$(min_max_column[, const])".
 
   RETURN
     TRUE  if cond passes the test
@@ -12310,7 +12336,8 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree, double read_time)
 
 static bool
 check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
-                               Field::imagetype image_type)
+                               Field::imagetype image_type,
+                               bool *has_min_max_arg, bool *has_other_arg)
 {
   DBUG_ENTER("check_group_min_max_predicates");
   DBUG_ASSERT(cond && min_max_arg_item);
@@ -12322,12 +12349,24 @@ check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
     DBUG_PRINT("info", ("Analyzing: %s", ((Item_func*) cond)->func_name()));
     List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
     Item *and_or_arg;
+    Item_func::Functype func_type= ((Item_cond*) cond)->functype();
+    bool has_min_max= false, has_other= false;
     while ((and_or_arg= li++))
     {
-      if (!check_group_min_max_predicates(and_or_arg, min_max_arg_item,
-                                         image_type))
+      /*
+        The WHERE clause doesn't pass the condition if:
+        (1) any subtree doesn't pass the condition or
+        (2) the subtree passes the test, but it is an OR and it references both
+            the min/max argument and other columns.
+      */
+      if (!check_group_min_max_predicates(and_or_arg, min_max_arg_item,      //1
+                                          image_type,
+                                          &has_min_max, &has_other) ||
+          (func_type == Item_func::COND_OR_FUNC && has_min_max && has_other))//2
         DBUG_RETURN(FALSE);
     }
+    *has_min_max_arg= has_min_max || *has_min_max_arg;
+    *has_other_arg= has_other || *has_other_arg;
     DBUG_RETURN(TRUE);
   }
 
@@ -12361,6 +12400,10 @@ check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
   if (cond_type == Item::FIELD_ITEM)
   {
     DBUG_PRINT("info", ("Analyzing: %s", cond->full_name()));
+    if (min_max_arg_item->eq((Item_field*)cond, 1))
+      *has_min_max_arg= true;
+    else
+      *has_other_arg= true;
     DBUG_RETURN(TRUE);
   }
 
@@ -12369,9 +12412,33 @@ check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
 
   /* Test if cond references only group-by or non-group fields. */
   Item_func *pred= (Item_func*) cond;
+  Item_func::Functype pred_type= pred->functype();
+  DBUG_PRINT("info", ("Analyzing: %s", pred->func_name()));
+  if (pred_type == Item_func::MULT_EQUAL_FUNC)
+  {
+    /*
+      Check that each field in a multiple equality is either a constant or
+      it is a reference to the min/max argument, or it doesn't contain the
+      min/max argument at all.
+    */
+    Item_equal_fields_iterator eq_it(*((Item_equal*)pred));
+    Item *eq_item;
+    bool has_min_max= false, has_other= false;
+    while ((eq_item= eq_it++))
+    {
+      if (min_max_arg_item->eq(eq_item->real_item(), 1))
+        has_min_max= true;
+      else
+        has_other= true;
+    }
+    *has_min_max_arg= has_min_max || *has_min_max_arg;
+    *has_other_arg= has_other || *has_other_arg;
+    DBUG_RETURN(!(has_min_max && has_other));
+  }
+
   Item **arguments= pred->arguments();
   Item *cur_arg;
-  DBUG_PRINT("info", ("Analyzing: %s", pred->func_name()));
+  bool has_min_max= false, has_other= false;
   for (uint arg_idx= 0; arg_idx < pred->argument_count (); arg_idx++)
   {
     cur_arg= arguments[arg_idx]->real_item();
@@ -12380,11 +12447,11 @@ check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
     {
       if (min_max_arg_item->eq(cur_arg, 1)) 
       {
-       /*
-         If pred references the MIN/MAX argument, check whether pred is a range
-         condition that compares the MIN/MAX argument with a constant.
-       */
-        Item_func::Functype pred_type= pred->functype();
+        has_min_max= true;
+        /*
+          If pred references the MIN/MAX argument, check whether pred is a range
+          condition that compares the MIN/MAX argument with a constant.
+        */
         if (pred_type != Item_func::EQUAL_FUNC     &&
             pred_type != Item_func::LT_FUNC        &&
             pred_type != Item_func::LE_FUNC        &&
@@ -12424,14 +12491,16 @@ check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
               min_max_arg_item->field->cmp_type() != args[1]->result_type())))
           DBUG_RETURN(FALSE);
       }
+      else
+        has_other= true;
     }
     else if (cur_arg->type() == Item::FUNC_ITEM)
     {
-      if (!check_group_min_max_predicates(cur_arg, min_max_arg_item,
-                                         image_type))
+      if (!check_group_min_max_predicates(cur_arg, min_max_arg_item, image_type,
+                                          &has_min_max, &has_other))
         DBUG_RETURN(FALSE);
     }
-    else if (cur_arg->const_item())
+    else if (cur_arg->const_item() && !cur_arg->is_expensive())
     {
       /*
         For predicates of the form "const OP expr" we also have to check 'expr'
@@ -12441,7 +12510,11 @@ check_group_min_max_predicates(Item *cond, Item_field *min_max_arg_item,
     }
     else
       DBUG_RETURN(FALSE);
+    if(has_min_max && has_other)
+      DBUG_RETURN(FALSE);
   }
+  *has_min_max_arg= has_min_max || *has_min_max_arg;
+  *has_other_arg= has_other || *has_other_arg;
 
   DBUG_RETURN(TRUE);
 }
diff --git a/sql/opt_range.h b/sql/opt_range.h
index c59b2a7eb02..fff6e414ad9 100644
--- a/sql/opt_range.h
+++ b/sql/opt_range.h
@@ -323,7 +323,7 @@ public:
       0     Ok
       other Error
   */
-  virtual int init_ror_merged_scan(bool reuse_handler)
+  virtual int init_ror_merged_scan(bool reuse_handler, MEM_ROOT *alloc)
   { DBUG_ASSERT(0); return 1; }
 
   /*
@@ -473,7 +473,7 @@ public:
                       uchar *cur_prefix);
   bool reverse_sorted() { return 0; }
   bool unique_key_range();
-  int init_ror_merged_scan(bool reuse_handler);
+  int init_ror_merged_scan(bool reuse_handler, MEM_ROOT *alloc);
   void save_last_pos()
   { file->position(record); }
   int get_type() { return QS_TYPE_RANGE; }
@@ -722,7 +722,7 @@ public:
 #ifndef DBUG_OFF
   void dbug_dump(int indent, bool verbose);
 #endif
-  int init_ror_merged_scan(bool reuse_handler);
+  int init_ror_merged_scan(bool reuse_handler, MEM_ROOT *alloc);
   bool push_quick_back(MEM_ROOT *alloc, QUICK_RANGE_SELECT *quick_sel_range);
 
   class QUICK_SELECT_WITH_RECORD : public Sql_alloc
diff --git a/sql/opt_subselect.cc b/sql/opt_subselect.cc
index 8cd4ba08ff3..49ad8462fb4 100644
--- a/sql/opt_subselect.cc
+++ b/sql/opt_subselect.cc
@@ -666,6 +666,9 @@ int check_and_do_in_subquery_rewrites(JOIN *join)
         8. No execution method was already chosen (by a prepared statement)
         9. Parent select is not a table-less select
         10. Neither parent nor child select have STRAIGHT_JOIN option.
+        11. It is first optimisation (the subquery could be moved from ON
+        clause during first optimisation and then be considered for SJ
+        on the second when it is too late)
     */
     if (optimizer_flag(thd, OPTIMIZER_SWITCH_SEMIJOIN) &&
         in_subs &&                                                    // 1
@@ -679,7 +682,8 @@ int check_and_do_in_subquery_rewrites(JOIN *join)
         select_lex->outer_select()->leaf_tables.elements &&           // 9
         !((join->select_options |                                     // 10
            select_lex->outer_select()->join->select_options)          // 10
-          & SELECT_STRAIGHT_JOIN))                                    // 10
+          & SELECT_STRAIGHT_JOIN) &&                                  // 10
+        select_lex->first_cond_optimization)                          // 11
     {
       DBUG_PRINT("info", ("Subquery is semi-join conversion candidate"));
 
@@ -1509,6 +1513,9 @@ static bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)
   */
   parent_lex->leaf_tables.concat(&subq_lex->leaf_tables);
 
+  if (subq_lex->options & OPTION_SCHEMA_TABLE)
+    parent_lex->options |= OPTION_SCHEMA_TABLE;
+
   /*
     Same as above for next_local chain
     (a theory: a next_local chain always starts with ::leaf_tables
@@ -1726,6 +1733,9 @@ static bool convert_subq_to_jtbm(JOIN *parent_join,
   */
   parent_lex->leaf_tables.push_back(jtbm);
 
+  if (subq_pred->unit->first_select()->options & OPTION_SCHEMA_TABLE)
+    parent_lex->options |= OPTION_SCHEMA_TABLE;
+
   /*
     Same as above for TABLE_LIST::next_local chain
     (a theory: a next_local chain always starts with ::leaf_tables
@@ -2545,6 +2555,10 @@ void advance_sj_state(JOIN *join, table_map remaining_tables, uint idx,
           /* Mark strategy as used */ 
           (*strategy)->mark_used();
           pos->sj_strategy= sj_strategy;
+          if (sj_strategy == SJ_OPT_MATERIALIZE)
+            join->sjm_lookup_tables |= handled_fanout;
+          else
+            join->sjm_lookup_tables &= ~handled_fanout;
           *current_read_time= read_time;
           *current_record_count= rec_count;
           join->cur_dups_producing_tables &= ~handled_fanout;
@@ -3069,6 +3083,13 @@ void restore_prev_sj_state(const table_map remaining_tables,
                                   const JOIN_TAB *tab, uint idx)
 {
   TABLE_LIST *emb_sj_nest;
+
+  if (tab->emb_sj_nest)
+  {
+    table_map subq_tables= tab->emb_sj_nest->sj_inner_tables;
+    tab->join->sjm_lookup_tables &= ~subq_tables;
+  }
+
   if ((emb_sj_nest= tab->emb_sj_nest))
   {
     /* If we're removing the last SJ-inner table, remove the sj-nest */
@@ -3246,6 +3267,7 @@ void fix_semijoin_strategies_for_picked_join_order(JOIN *join)
   uint tablenr;
   table_map remaining_tables= 0;
   table_map handled_tabs= 0;
+  join->sjm_lookup_tables= 0;
   for (tablenr= table_count - 1 ; tablenr != join->const_tables - 1; tablenr--)
   {
     POSITION *pos= join->best_positions + tablenr;
@@ -3271,6 +3293,7 @@ void fix_semijoin_strategies_for_picked_join_order(JOIN *join)
       first= tablenr - sjm->tables + 1;
       join->best_positions[first].n_sj_tables= sjm->tables;
       join->best_positions[first].sj_strategy= SJ_OPT_MATERIALIZE;
+      join->sjm_lookup_tables|= s->table->map;
     }
     else if (pos->sj_strategy == SJ_OPT_MATERIALIZE_SCAN)
     {
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index fa3a07b72c5..069fe6452e8 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -84,7 +84,7 @@ static ulonglong get_exact_record_count(List<TABLE_LIST> &tables)
   while ((tl= ti++))
   {
     ha_rows tmp= tl->table->file->records();
-    if ((tmp == HA_POS_ERROR))
+    if (tmp == HA_POS_ERROR)
       return ULONGLONG_MAX;
     count*= tmp;
   }
diff --git a/sql/partition_info.cc b/sql/partition_info.cc
index 028afd7899e..934f4e970cb 100644
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -1582,29 +1582,21 @@ bool check_partition_dirs(partition_info *part_info)
       partition_element *subpart_elem;
       while ((subpart_elem= sub_it++))
       {
-        if (test_if_data_home_dir(subpart_elem->data_file_name))
-          goto dd_err;
-        if (test_if_data_home_dir(subpart_elem->index_file_name))
-          goto id_err;
+        if (error_if_data_home_dir(subpart_elem->data_file_name,
+                                   "DATA DIRECTORY") ||
+            error_if_data_home_dir(subpart_elem->index_file_name,
+                                   "INDEX DIRECTORY"))
+        return 1;
       }
     }
     else
     {
-      if (test_if_data_home_dir(part_elem->data_file_name))
-        goto dd_err;
-      if (test_if_data_home_dir(part_elem->index_file_name))
-        goto id_err;
+      if (error_if_data_home_dir(part_elem->data_file_name, "DATA DIRECTORY") ||
+          error_if_data_home_dir(part_elem->index_file_name, "INDEX DIRECTORY"))
+        return 1;
     }
   }
   return 0;
-
-dd_err:
-  my_error(ER_WRONG_ARGUMENTS,MYF(0),"DATA DIRECTORY");
-  return 1;
-
-id_err:
-  my_error(ER_WRONG_ARGUMENTS,MYF(0),"INDEX DIRECTORY");
-  return 1;
 }
 
 
@@ -2286,4 +2278,9 @@ void partition_info::print_debug(const char *str, uint *value)
 {
 }
 
+bool check_partition_dirs(partition_info *part_info)
+{
+  return 0;
+}
+
 #endif /* WITH_PARTITION_STORAGE_ENGINE */
diff --git a/sql/partition_info.h b/sql/partition_info.h
index e59d4ec8ba4..2fbdfff6636 100644
--- a/sql/partition_info.h
+++ b/sql/partition_info.h
@@ -306,6 +306,7 @@ private:
   char *create_default_partition_names(uint part_no, uint num_parts,
                                        uint start_no);
   char *create_subpartition_name(uint subpart_no, const char *part_name);
+public:
   bool has_unique_name(partition_element *element);
 };
 
diff --git a/sql/rpl_handler.cc b/sql/rpl_handler.cc
index 258dae0edb2..1d21b3f9445 100644
--- a/sql/rpl_handler.cc
+++ b/sql/rpl_handler.cc
@@ -555,4 +555,24 @@ int unregister_binlog_relay_io_observer(Binlog_relay_IO_observer *observer, void
 {
   return binlog_relay_io_delegate->remove_observer(observer, (st_plugin_int *)p);
 }
+#else
+int register_binlog_transmit_observer(Binlog_transmit_observer *observer, void *p)
+{
+  return 0;
+}
+
+int unregister_binlog_transmit_observer(Binlog_transmit_observer *observer, void *p)
+{
+  return 0;
+}
+
+int register_binlog_relay_io_observer(Binlog_relay_IO_observer *observer, void *p)
+{
+  return 0;
+}
+
+int unregister_binlog_relay_io_observer(Binlog_relay_IO_observer *observer, void *p)
+{
+  return 0;
+}
 #endif /* HAVE_REPLICATION */
diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc
index 1b9e744bcc1..1be97b34204 100644
--- a/sql/rpl_utility.cc
+++ b/sql/rpl_utility.cc
@@ -1,5 +1,6 @@
 /*
    Copyright (c) 2006, 2010, Oracle and/or its affiliates.
+   Copyright (c) 2011, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -521,9 +522,9 @@ bool is_conversion_ok(int order, Relay_log_info *rli)
   bool allow_non_lossy, allow_lossy;
 
   allow_non_lossy = slave_type_conversions_options &
-                    (ULL(1) << SLAVE_TYPE_CONVERSIONS_ALL_NON_LOSSY);
+                    (1ULL << SLAVE_TYPE_CONVERSIONS_ALL_NON_LOSSY);
   allow_lossy= slave_type_conversions_options &
-               (ULL(1) << SLAVE_TYPE_CONVERSIONS_ALL_LOSSY);
+               (1ULL << SLAVE_TYPE_CONVERSIONS_ALL_LOSSY);
 
   DBUG_PRINT("enter", ("order: %d, flags:%s%s", order,
                        allow_non_lossy ? " ALL_NON_LOSSY" : "",
@@ -878,8 +879,13 @@ TABLE *table_def::create_conversion_table(THD *thd, Relay_log_info *rli, TABLE *
   DBUG_ENTER("table_def::create_conversion_table");
 
   List<Create_field> field_list;
-
-  for (uint col= 0 ; col < size() ; ++col)
+  /*
+    At slave, columns may differ. So we should create
+    min(columns@master, columns@slave) columns in the
+    conversion table.
+  */
+  uint const cols_to_create= min(target_table->s->fields, size());
+  for (uint col= 0 ; col < cols_to_create; ++col)
   {
     Create_field *field_def=
       (Create_field*) alloc_root(thd->mem_root, sizeof(Create_field));
diff --git a/sql/scheduler.cc b/sql/scheduler.cc
index 7f250158ccb..71789b0303b 100644
--- a/sql/scheduler.cc
+++ b/sql/scheduler.cc
@@ -1,5 +1,5 @@
 /* Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
-   Copyright (c) 2012, Monty Program Ab
+   Copyright (c) 2012, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -152,52 +152,3 @@ void one_thread_scheduler(scheduler_functions *func)
   func->end_thread= no_threads_end;
 }
 
-
-
-/*
-  no pluggable schedulers in mariadb.
-  when we'll want it, we'll do it properly
-*/
-#if 0
-
-static scheduler_functions *saved_thread_scheduler;
-static uint saved_thread_handling;
-
-extern "C"
-int my_thread_scheduler_set(scheduler_functions *scheduler)
-{
-  DBUG_ASSERT(scheduler != 0);
-
-  if (scheduler == NULL)
-    return 1;
-
-  saved_thread_scheduler= thread_scheduler;
-  saved_thread_handling= thread_handling;
-  thread_scheduler= scheduler;
-  // Scheduler loaded dynamically
-  thread_handling= SCHEDULER_TYPES_COUNT;
-  return 0;
-}
-
-
-extern "C"
-int my_thread_scheduler_reset()
-{
-  DBUG_ASSERT(saved_thread_scheduler != NULL);
-
-  if (saved_thread_scheduler == NULL)
-    return 1;
-
-  thread_scheduler= saved_thread_scheduler;
-  thread_handling= saved_thread_handling;
-  saved_thread_scheduler= 0;
-  return 0;
-}
-#else
-extern "C" int my_thread_scheduler_set(scheduler_functions *scheduler)
-{ return 1; }
-
-extern "C" int my_thread_scheduler_reset()
-{ return 1; }
-#endif
-
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 9f5404d75ce..18d86a13998 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -253,8 +253,7 @@ uchar *sys_var::value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
 
 bool sys_var::set_default(THD *thd, enum_var_type type)
 {
-  LEX_STRING empty={0,0};
-  set_var var(type, this, &empty, 0);
+  set_var var(type, this, &null_lex_str, 0);
 
   if (type == OPT_GLOBAL || scope() == GLOBAL)
     global_save_default(thd, &var);
@@ -264,6 +263,114 @@ bool sys_var::set_default(THD *thd, enum_var_type type)
   return check(thd, &var) || update(thd, &var);
 }
 
+
+#define do_num_val(T,CMD)                               \
+do {                                                    \
+  mysql_mutex_lock(&LOCK_global_system_variables);      \
+  T val= *(T*) value_ptr(thd, type,  base);             \
+  mysql_mutex_unlock(&LOCK_global_system_variables);    \
+  CMD;                                                  \
+} while (0)
+
+#define case_for_integers(CMD)                      \
+    case SHOW_SINT:     do_num_val (int,CMD);       \
+    case SHOW_SLONG:    do_num_val (long,CMD);      \
+    case SHOW_SLONGLONG:do_num_val (longlong,CMD);  \
+    case SHOW_UINT:     do_num_val (uint,CMD);      \
+    case SHOW_ULONG:    do_num_val (ulong,CMD);     \
+    case SHOW_ULONGLONG:do_num_val (ulonglong,CMD); \
+    case SHOW_HA_ROWS:  do_num_val (ha_rows,CMD);   \
+    case SHOW_BOOL:     do_num_val (bool,CMD);      \
+    case SHOW_MY_BOOL:  do_num_val (my_bool,CMD)
+
+#define case_for_double(CMD)                            \
+    case SHOW_DOUBLE:   do_num_val (double,CMD)
+
+#define case_get_string_as_lex_string                   \
+    case SHOW_CHAR:                                     \
+      mysql_mutex_lock(&LOCK_global_system_variables);  \
+      sval.str= (char*) value_ptr(thd, type, base);     \
+      sval.length= sval.str ? strlen(sval.str) : 0;     \
+      break;                                            \
+    case SHOW_CHAR_PTR:                                 \
+      mysql_mutex_lock(&LOCK_global_system_variables);  \
+      sval.str= *(char**) value_ptr(thd, type, base);   \
+      sval.length= sval.str ? strlen(sval.str) : 0;     \
+      break;                                            \
+    case SHOW_LEX_STRING:                               \
+      mysql_mutex_lock(&LOCK_global_system_variables);  \
+      sval= *(LEX_STRING *) value_ptr(thd, type, base); \
+      break
+
+longlong sys_var::val_int(bool *is_null,
+                          THD *thd, enum_var_type type, LEX_STRING *base)
+{
+  LEX_STRING sval;
+  *is_null= false;
+  switch (show_type())
+  {
+    case_get_string_as_lex_string;
+    case_for_integers(return val);
+    case_for_double(return val);
+    default:            
+      my_error(ER_VAR_CANT_BE_READ, MYF(0), name.str); 
+      return 0;
+  }
+
+  longlong ret= 0;
+  if (!(*is_null= !sval.str))
+    ret= longlong_from_string_with_check(system_charset_info,
+                                         sval.str, sval.str + sval.length);
+  mysql_mutex_unlock(&LOCK_global_system_variables);
+  return ret;
+}
+
+
+String *sys_var::val_str(String *str,
+                         THD *thd, enum_var_type type, LEX_STRING *base)
+{
+  LEX_STRING sval;
+  switch (show_type())
+  {
+    case_get_string_as_lex_string;
+    case_for_integers(return str->set((ulonglong)val, system_charset_info) ? 0 : str);
+    case_for_double(return str->set_real(val, 6, system_charset_info) ? 0 : str);
+    default:
+      my_error(ER_VAR_CANT_BE_READ, MYF(0), name.str);
+      return 0;
+  }
+
+  if (!sval.str || str->copy(sval.str, sval.length, system_charset_info))
+    str= NULL;
+  mysql_mutex_unlock(&LOCK_global_system_variables);
+  return str;
+}
+
+
+double sys_var::val_real(bool *is_null,
+                         THD *thd, enum_var_type type, LEX_STRING *base)
+{
+  LEX_STRING sval;
+  *is_null= false;
+  switch (show_type())
+  {
+    case_get_string_as_lex_string;
+    case_for_integers(return val);
+    case_for_double(return val);
+    default:            
+      my_error(ER_VAR_CANT_BE_READ, MYF(0), name.str); 
+      return 0;
+  }
+
+  double ret= 0;
+  if (!(*is_null= !sval.str))
+    ret= double_from_string_with_check(system_charset_info,
+                                       sval.str, sval.str + sval.length);
+  mysql_mutex_unlock(&LOCK_global_system_variables);
+  return ret;
+}
+
+
 void sys_var::do_deprecated_warning(THD *thd)
 {
   if (deprecation_substitute != NULL)
diff --git a/sql/set_var.h b/sql/set_var.h
index f912c9fffad..6cb0cd33f87 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -108,6 +108,10 @@ public:
   bool set_default(THD *thd, enum_var_type type);
   bool update(THD *thd, set_var *var);
 
+  longlong val_int(bool *is_null, THD *thd, enum_var_type type, LEX_STRING *base);
+  String *val_str(String *str, THD *thd, enum_var_type type, LEX_STRING *base);
+  double val_real(bool *is_null, THD *thd, enum_var_type type, LEX_STRING *base);
+
   SHOW_TYPE show_type() { return show_val_type; }
   int scope() const { return flags & SCOPE_MASK; }
   CHARSET_INFO *charset(THD *thd);
diff --git a/sql/share/errmsg-utf8.txt b/sql/share/errmsg-utf8.txt
index 49f35719a77..f1d5af44fd5 100644
--- a/sql/share/errmsg-utf8.txt
+++ b/sql/share/errmsg-utf8.txt
@@ -75,30 +75,30 @@ ER_CANT_CREATE_FILE
         swe "Kan inte skapa filen '%-.200s' (Felkod: %M)"
         ukr "Не можу створити файл '%-.200s' (помилка: %M)"
 ER_CANT_CREATE_TABLE  
-        cze "Nemohu vytvo-Břit tabulku '%-.200s' (chybový kód: %M)"
-        dan "Kan ikke oprette tabellen '%-.200s' (Fejlkode: %M)"
-        nla "Kan tabel '%-.200s' niet aanmaken (Errcode: %M)"
-        eng "Can't create table '%-.200s' (errno: %M)"
-        jps "'%-.200s' テーブルが作れません.(errno: %M)",
-        est "Ei suuda luua tabelit '%-.200s' (veakood: %M)"
-        fre "Ne peut créer la table '%-.200s' (Errcode: %M)"
-        ger "Kann Tabelle '%-.200s' nicht erzeugen (Fehler: %M)"
-        greek "Αδύνατη η δημιουργία του πίνακα '%-.200s' (κωδικός λάθους: %M)"
-        hun "A '%-.200s' tabla nem hozhato letre (hibakod: %M)"
-        ita "Impossibile creare la tabella '%-.200s' (errno: %M)"
-        jpn "'%-.200s' テーブルが作れません.(errno: %M)"
-        kor "테이블 '%-.200s'를 만들지 못했습니다. (에러번호: %M)"
-        nor "Kan ikke opprette tabellen '%-.200s' (Feilkode: %M)"
-        norwegian-ny "Kan ikkje opprette tabellen '%-.200s' (Feilkode: %M)"
-        pol "Nie można stworzyć tabeli '%-.200s' (Kod błędu: %M)"
-        por "Não pode criar a tabela '%-.200s' (erro no. %M)"
-        rum "Nu pot sa creez tabla '%-.200s' (Eroare: %M)"
-        rus "Невозможно создать таблицу '%-.200s' (ошибка: %M)"
-        serbian "Ne mogu da kreiram tabelu '%-.200s' (errno: %M)"
-        slo "Nemôžem vytvoriť tabuľku '%-.200s' (chybový kód: %M)"
-        spa "No puedo crear tabla '%-.200s' (Error: %M)"
-        swe "Kan inte skapa tabellen '%-.200s' (Felkod: %M)"
-        ukr "Не можу створити таблицю '%-.200s' (помилка: %M)"
+        cze "Nemohu vytvo-Břit tabulku %`s.%`s (chybový kód: %M)"
+        dan "Kan ikke oprette tabellen %`s.%`s (Fejlkode: %M)"
+        nla "Kan tabel %`s.%`s niet aanmaken (Errcode: %M)"
+        eng "Can't create table %`s.%`s (errno: %M)"
+        jps "%`s.%`s テーブルが作れません.(errno: %M)",
+        est "Ei suuda luua tabelit %`s.%`s (veakood: %M)"
+        fre "Ne peut créer la table %`s.%`s (Errcode: %M)"
+        ger "Kann Tabelle %`s.%`s nicht erzeugen (Fehler: %M)"
+        greek "Αδύνατη η δημιουργία του πίνακα %`s.%`s (κωδικός λάθους: %M)"
+        hun "A %`s.%`s tabla nem hozhato letre (hibakod: %M)"
+        ita "Impossibile creare la tabella %`s.%`s (errno: %M)"
+        jpn "%`s.%`s テーブルが作れません.(errno: %M)"
+        kor "테이블 %`s.%`s를 만들지 못했습니다. (에러번호: %M)"
+        nor "Kan ikke opprette tabellen %`s.%`s (Feilkode: %M)"
+        norwegian-ny "Kan ikkje opprette tabellen %`s.%`s (Feilkode: %M)"
+        pol "Nie można stworzyć tabeli %`s.%`s (Kod błędu: %M)"
+        por "Não pode criar a tabela %`s.%`s (erro no. %M)"
+        rum "Nu pot sa creez tabla %`s.%`s (Eroare: %M)"
+        rus "Невозможно создать таблицу %`s.%`s (ошибка: %M)"
+        serbian "Ne mogu da kreiram tabelu %`s.%`s (errno: %M)"
+        slo "Nemôžem vytvoriť tabuľku %`s.%`s (chybový kód: %M)"
+        spa "No puedo crear tabla %`s.%`s (Error: %M)"
+        swe "Kan inte skapa tabellen %`s.%`s (Felkod: %M)"
+        ukr "Не можу створити таблицю %`s.%`s (помилка: %M)"
 ER_CANT_CREATE_DB  
         cze "Nemohu vytvo-Břit databázi '%-.192s' (chybový kód: %M)"
         dan "Kan ikke oprette databasen '%-.192s' (Fejlkode: %M)"
@@ -696,53 +696,26 @@ ER_FORM_NOT_FOUND
         swe "Formulär '%-.192s' finns inte i '%-.192s'"
         ukr "Вигляд '%-.192s' не існує для '%-.192s'"
 ER_GET_ERRNO  
-        cze "Obsluha tabulky vr-Bátila chybu %M"
-        dan "Modtog fejl %M fra tabel håndteringen"
-        nla "Fout %M van tabel handler"
-        eng "Got error %M from storage engine"
-        est "Tabeli handler tagastas vea %M"
-        fre "Reçu l'erreur %M du handler de la table"
-        ger "Fehler %M (Speicher-Engine)"
-        greek "Ελήφθη μήνυμα λάθους %M από τον χειριστή πίνακα (table handler)"
-        hun "%M hibajelzes a tablakezelotol"
-        ita "Rilevato l'errore %M dal gestore delle tabelle"
-        jpn "Got error %M from table handler"
-        kor "테이블 handler에서 %M 에러가 발생 하였습니다."
-        nor "Mottok feil %M fra tabell håndterer"
-        norwegian-ny "Mottok feil %M fra tabell handterar"
-        pol "Otrzymano bł?d %M z obsługi tabeli"
-        por "Obteve erro %M no manipulador de tabelas"
-        rum "Eroarea %M obtinuta din handlerul tabelei"
-        rus "Получена ошибка %M от обработчика таблиц"
-        serbian "Handler tabela je vratio grešku %M"
-        slo "Obsluha tabuľky vrátila chybu %M"
-        spa "Error %M desde el manejador de la tabla"
-        swe "Fick felkod %M från databashanteraren"
-        ukr "Отримано помилку %M від дескриптора таблиці"
+        nla "Fout %M van tabel handler %s"
+        eng "Got error %M from storage engine %s"
+        fre "Reçu l'erreur %M du handler de la table %s"
+        ger "Fehler %M von Speicher-Engine %s"
+        greek "Ελήφθη μήνυμα λάθους %M από τον χειριστή πίνακα (table handler) %s"
+        ita "Rilevato l'errore %M dal gestore delle tabelle %s"
+        nor "Mottok feil %M fra tabell håndterer %s"
+        norwegian-ny "Mottok feil %M fra tabell handterar %s"
+        pol "Otrzymano bł?d %M z obsługi tabeli %s"
+        por "Obteve erro %M no manipulador de tabelas %s"
+        rum "Eroarea %M obtinuta din handlerul tabelei %s"
+        rus "Получена ошибка %M от обработчика таблиц %s"
+        spa "Error %M desde el manejador de la tabla %s"
+        swe "Fick felkod %M från databashanteraren %s"
+        ukr "Отримано помилку %M від дескриптора таблиці %s"
 ER_ILLEGAL_HA  
-        cze "Obsluha tabulky '%-.192s' nem-Bá tento parametr"
-        dan "Denne mulighed eksisterer ikke for tabeltypen '%-.192s'"
-        nla "Tabel handler voor '%-.192s' heeft deze optie niet"
-        eng "Table storage engine for '%-.192s' doesn't have this option"
-        est "Tabeli '%-.192s' handler ei toeta antud operatsiooni"
-        fre "Le handler de la table '%-.192s' n'a pas cette option"
-        ger "Diese Option gibt es nicht (Speicher-Engine für '%-.192s')"
-        greek "Ο χειριστής πίνακα (table handler) για '%-.192s' δεν διαθέτει αυτή την επιλογή"
-        hun "A(z) '%-.192s' tablakezelonek nincs ilyen opcioja"
-        ita "Il gestore delle tabelle per '%-.192s' non ha questa opzione"
-        jpn "Table handler for '%-.192s' doesn't have this option"
-        kor "'%-.192s'의 테이블 handler는 이러한 옵션을 제공하지 않읍니다."
-        nor "Tabell håndtereren for '%-.192s' har ikke denne muligheten"
-        norwegian-ny "Tabell håndteraren for '%-.192s' har ikkje denne moglegheita"
-        pol "Obsługa tabeli '%-.192s' nie posiada tej opcji"
-        por "Manipulador de tabela para '%-.192s' não tem esta opção"
-        rum "Handlerul tabelei pentru '%-.192s' nu are aceasta optiune"
-        rus "Обработчик таблицы '%-.192s' не поддерживает эту возможность"
-        serbian "Handler tabela za '%-.192s' nema ovu opciju"
-        slo "Obsluha tabuľky '%-.192s' nemá tento parameter"
-        spa "El manejador de la tabla de '%-.192s' no tiene esta opcion"
-	swe "Tabellhanteraren for tabell '%-.192s' stödjer ej detta"
-        ukr "Дескриптор таблиці '%-.192s' не має цієї властивості"
+        eng "Storage engine %s of the table %`s.%`s doesn't have this option"
+        ger "Diese Option gibt es nicht in Speicher-Engine %s für %`s.%`s"
+        rus "Обработчик %s таблицы %`s.%`s не поддерживает эту возможность"
+        ukr "Дескриптор %s таблиці %`s.%`s не має цієї властивості"
 ER_KEY_NOT_FOUND  
         cze "Nemohu naj-Bít záznam v '%-.192s'"
         dan "Kan ikke finde posten i '%-.192s'"
@@ -1750,28 +1723,10 @@ ER_KEY_COLUMN_DOES_NOT_EXITS 42000 S1009
         swe "Nyckelkolumn '%-.192s' finns inte"
         ukr "Ключовий стовбець '%-.192s' не існує у таблиці"
 ER_BLOB_USED_AS_KEY 42000 S1009
-        cze "Blob sloupec '%-.192s' nem-Bůže být použit jako klíč"
-        dan "BLOB feltet '%-.192s' kan ikke bruges ved specifikation af indeks"
-        nla "BLOB kolom '%-.192s' kan niet gebruikt worden bij zoeksleutel specificatie"
-        eng "BLOB column '%-.192s' can't be used in key specification with the used table type"
-        est "BLOB-tüüpi tulpa '%-.192s' ei saa kasutada võtmena"
-        fre "Champ BLOB '%-.192s' ne peut être utilisé dans une clé"
-        ger "BLOB-Feld '%-.192s' kann beim verwendeten Tabellentyp nicht als Schlüssel verwendet werden"
-        greek "Πεδίο τύπου Blob '%-.192s' δεν μπορεί να χρησιμοποιηθεί στον ορισμό ενός κλειδιού (key specification)"
-        hun "Blob objektum '%-.192s' nem hasznalhato kulcskent"
-        ita "La colonna BLOB '%-.192s' non puo` essere usata nella specifica della chiave"
-        kor "BLOB 칼럼 '%-.192s'는 키 정의에서 사용될 수 없습니다."
-        nor "Blob felt '%-.192s' kan ikke brukes ved spesifikasjon av nøkler"
-        norwegian-ny "Blob kolonne '%-.192s' kan ikkje brukast ved spesifikasjon av nyklar"
-        pol "Kolumna typu Blob '%-.192s' nie może być użyta w specyfikacji klucza"
-        por "Coluna BLOB '%-.192s' não pode ser utilizada na especificação de chave para o tipo de tabela usado"
-        rum "Coloana de tip BLOB '%-.192s' nu poate fi folosita in specificarea cheii cu tipul de tabla folosit"
-        rus "Столбец типа BLOB '%-.192s' не может быть использован как значение ключа в таблице такого типа"
-        serbian "BLOB kolona '%-.192s' ne može biti upotrebljena za navođenje ključa sa tipom tabele koji se trenutno koristi"
-        slo "Blob pole '%-.192s' nemôže byť použité ako kľúč"
-        spa "La columna Blob '%-.192s' no puede ser usada en una declaracion de clave"
-        swe "En BLOB '%-.192s' kan inte vara nyckel med den använda tabelltypen"
-        ukr "BLOB стовбець '%-.192s' не може бути використаний у визначенні ключа в цьому типі таблиці"
+        eng "BLOB column %`s can't be used in key specification in the %s table"
+        ger "BLOB-Feld %`s kann beim %s Tabellen nicht als Schlüssel verwendet werden"
+        rus "Столбец типа BLOB %`s не может быть использован как значение ключа в %s таблице"
+        ukr "BLOB стовбець %`s не може бути використаний у визначенні ключа в %s таблиці"
 ER_TOO_BIG_FIELDLENGTH 42000 S1009
         cze "P-Bříliš velká délka sloupce '%-.192s' (nejvíce %lu). Použijte BLOB"
         dan "For stor feltlængde for kolonne '%-.192s' (maks = %lu). Brug BLOB i stedet"
@@ -3691,39 +3646,39 @@ ER_TOO_LONG_STRING 42000
         swe "Resultatsträngen är längre än max_allowed_packet"
         ukr "Строка результату довша ніж max_allowed_packet"
 ER_TABLE_CANT_HANDLE_BLOB 42000 
-        cze "Typ pou-Bžité tabulky nepodporuje BLOB/TEXT sloupce"
-        dan "Denne tabeltype understøtter ikke brug af BLOB og TEXT kolonner"
-        nla "Het gebruikte tabel type ondersteunt geen BLOB/TEXT kolommen"
-        eng "The used table type doesn't support BLOB/TEXT columns"
-        est "Valitud tabelitüüp ei toeta BLOB/TEXT tüüpi välju"
-        fre "Ce type de table ne supporte pas les colonnes BLOB/TEXT"
-        ger "Der verwendete Tabellentyp unterstützt keine BLOB- und TEXT-Felder"
-        hun "A hasznalt tabla tipus nem tamogatja a BLOB/TEXT mezoket"
-        ita "Il tipo di tabella usata non supporta colonne di tipo BLOB/TEXT"
-        por "Tipo de tabela usado não permite colunas BLOB/TEXT"
-        rum "Tipul de tabela folosit nu suporta coloane de tip BLOB/TEXT"
-        rus "Используемая таблица не поддерживает типы BLOB/TEXT"
-        serbian "Iskorišteni tip tabele ne podržava kolone tipa 'BLOB' odnosno 'TEXT'"
-        spa "El tipo de tabla usada no permite soporte para columnas BLOB/TEXT"
-        swe "Den använda tabelltypen kan inte hantera BLOB/TEXT-kolumner"
-        ukr "Використаний тип таблиці не підтримує BLOB/TEXT стовбці"
+        cze "Typ pou-Bžité tabulky (%s) nepodporuje BLOB/TEXT sloupce"
+        dan "Denne tabeltype (%s) understøtter ikke brug af BLOB og TEXT kolonner"
+        nla "Het gebruikte tabel type (%s) ondersteunt geen BLOB/TEXT kolommen"
+        eng "Storage engine %s doesn't support BLOB/TEXT columns"
+        est "Valitud tabelitüüp (%s) ei toeta BLOB/TEXT tüüpi välju"
+        fre "Ce type de table (%s) ne supporte pas les colonnes BLOB/TEXT"
+        ger "Der verwendete Tabellentyp (%s) unterstützt keine BLOB- und TEXT-Felder"
+        hun "A hasznalt tabla tipus (%s) nem tamogatja a BLOB/TEXT mezoket"
+        ita "Il tipo di tabella usata (%s) non supporta colonne di tipo BLOB/TEXT"
+        por "Tipo de tabela usado (%s) não permite colunas BLOB/TEXT"
+        rum "Tipul de tabela folosit (%s) nu suporta coloane de tip BLOB/TEXT"
+        rus "%s таблицы не поддерживают типы BLOB/TEXT"
+        serbian "Iskorišteni tip tabele (%s) ne podržava kolone tipa 'BLOB' odnosno 'TEXT'"
+        spa "El tipo de tabla usada (%s) no permite soporte para columnas BLOB/TEXT"
+        swe "Den använda tabelltypen (%s) kan inte hantera BLOB/TEXT-kolumner"
+        ukr "%s таблиці не підтримують BLOB/TEXT стовбці"
 ER_TABLE_CANT_HANDLE_AUTO_INCREMENT 42000 
-        cze "Typ pou-Bžité tabulky nepodporuje AUTO_INCREMENT sloupce"
-        dan "Denne tabeltype understøtter ikke brug af AUTO_INCREMENT kolonner"
-        nla "Het gebruikte tabel type ondersteunt geen AUTO_INCREMENT kolommen"
-        eng "The used table type doesn't support AUTO_INCREMENT columns"
-        est "Valitud tabelitüüp ei toeta AUTO_INCREMENT tüüpi välju"
-        fre "Ce type de table ne supporte pas les colonnes AUTO_INCREMENT"
-        ger "Der verwendete Tabellentyp unterstützt keine AUTO_INCREMENT-Felder"
-        hun "A hasznalt tabla tipus nem tamogatja az AUTO_INCREMENT tipusu mezoket"
-        ita "Il tipo di tabella usata non supporta colonne di tipo AUTO_INCREMENT"
-        por "Tipo de tabela usado não permite colunas AUTO_INCREMENT"
-        rum "Tipul de tabela folosit nu suporta coloane de tip AUTO_INCREMENT"
-        rus "Используемая таблица не поддерживает автоинкрементные столбцы"
-        serbian "Iskorišteni tip tabele ne podržava kolone tipa 'AUTO_INCREMENT'"
-        spa "El tipo de tabla usada no permite soporte para columnas AUTO_INCREMENT"
-        swe "Den använda tabelltypen kan inte hantera AUTO_INCREMENT-kolumner"
-        ukr "Використаний тип таблиці не підтримує AUTO_INCREMENT стовбці"
+        cze "Typ pou-Bžité tabulky (%s) nepodporuje AUTO_INCREMENT sloupce"
+        dan "Denne tabeltype understøtter (%s) ikke brug af AUTO_INCREMENT kolonner"
+        nla "Het gebruikte tabel type (%s) ondersteunt geen AUTO_INCREMENT kolommen"
+        eng "Storage engine %s doesn't support AUTO_INCREMENT columns"
+        est "Valitud tabelitüüp (%s) ei toeta AUTO_INCREMENT tüüpi välju"
+        fre "Ce type de table (%s) ne supporte pas les colonnes AUTO_INCREMENT"
+        ger "Der verwendete Tabellentyp (%s) unterstützt keine AUTO_INCREMENT-Felder"
+        hun "A hasznalt tabla tipus (%s) nem tamogatja az AUTO_INCREMENT tipusu mezoket"
+        ita "Il tipo di tabella usata (%s) non supporta colonne di tipo AUTO_INCREMENT"
+        por "Tipo de tabela usado (%s) não permite colunas AUTO_INCREMENT"
+        rum "Tipul de tabela folosit (%s) nu suporta coloane de tip AUTO_INCREMENT"
+        rus "%s таблицы не поддерживают автоинкрементные столбцы"
+        serbian "Iskorišteni tip tabele (%s) ne podržava kolone tipa 'AUTO_INCREMENT'"
+        spa "El tipo de tabla usada (%s) no permite soporte para columnas AUTO_INCREMENT"
+        swe "Den använda tabelltypen (%s) kan inte hantera AUTO_INCREMENT-kolumner"
+        ukr "%s таблиці не підтримують AUTO_INCREMENT стовбці"
 ER_DELAYED_INSERT_TABLE_LOCKED  
         cze "INSERT DELAYED nen-Bí možno s tabulkou '%-.192s' použít, protože je zamčená pomocí LOCK TABLES"
         dan "INSERT DELAYED kan ikke bruges med tabellen '%-.192s', fordi tabellen er låst med LOCK TABLES"
@@ -3766,29 +3721,10 @@ ER_WRONG_COLUMN_NAME 42000
         swe "Felaktigt kolumnnamn '%-.100s'"
         ukr "Невірне ім'я стовбця '%-.100s'"
 ER_WRONG_KEY_COLUMN 42000 
-        cze "Handler pou-Bžité tabulky neumí indexovat sloupce '%-.192s'"
-        dan "Den brugte tabeltype kan ikke indeksere kolonnen '%-.192s'"
-        nla "De gebruikte tabel 'handler' kan kolom '%-.192s' niet indexeren"
-        eng "The used storage engine can't index column '%-.192s'"
-        est "Tabelihandler ei oska indekseerida tulpa '%-.192s'"
-        fre "Le handler de la table ne peut indexé la colonne '%-.192s'"
-        ger "Die verwendete Speicher-Engine kann die Spalte '%-.192s' nicht indizieren"
-        greek "The used table handler can't index column '%-.192s'"
-        hun "A hasznalt tablakezelo nem tudja a '%-.192s' mezot indexelni"
-        ita "Il gestore delle tabelle non puo` indicizzare la colonna '%-.192s'"
-        jpn "The used table handler can't index column '%-.192s'"
-        kor "The used table handler can't index column '%-.192s'"
-        nor "The used table handler can't index column '%-.192s'"
-        norwegian-ny "The used table handler can't index column '%-.192s'"
-        pol "The used table handler can't index column '%-.192s'"
-        por "O manipulador de tabela usado não pode indexar a coluna '%-.192s'"
-        rum "Handler-ul tabelei folosite nu poate indexa coloana '%-.192s'"
-        rus "Использованный обработчик таблицы не может проиндексировать столбец '%-.192s'"
-        serbian "Handler tabele ne može da indeksira kolonu '%-.192s'"
-        slo "The used table handler can't index column '%-.192s'"
-        spa "El manipulador de tabla usado no puede indexar columna '%-.192s'"
-        swe "Den använda tabelltypen kan inte indexera kolumn '%-.192s'"
-        ukr "Використаний вказівник таблиці не може індексувати стовбець '%-.192s'"
+        eng "The storage engine %s can't index column %`s"
+        ger "Die Speicher-Engine %s kann die Spalte %`s nicht indizieren"
+        rus "Обработчик таблиц %s не может проиндексировать столбец %`s"
+        ukr "Вказівник таблиц %s не може індексувати стовбець %`s"
 ER_WRONG_MRG_TABLE  
         cze "V-Bšechny tabulky v MERGE tabulce nejsou definovány stejně"
         dan "Tabellerne i MERGE er ikke defineret ens"
@@ -4088,22 +4024,8 @@ ER_NEW_ABORTING_CONNECTION 08S01
         spa "Abortada conexión %ld para db: '%-.192s' usuario: '%-.48s' servidor: '%-.64s' (%-.64s)"
         swe "Avbröt länken för tråd %ld till db '%-.192s', användare '%-.48s', host '%-.64s' (%-.64s)"
         ukr "Перервано з'єднання %ld до бази данних: '%-.192s' користувач: '%-.48s' хост: '%-.64s' (%-.64s)"
-ER_DUMP_NOT_IMPLEMENTED  
-        cze "Handler tabulky nepodporuje bin-Bární dump"
-        dan "Denne tabeltype unserstøtter ikke binært tabeldump"
-        nla "De 'handler' voor de tabel ondersteund geen binaire tabel dump"
-        eng "The storage engine for the table does not support binary table dump"
-        fre "Ce type de table ne supporte pas les copies binaires"
-        ger "Die Speicher-Engine für die Tabelle unterstützt keinen binären Tabellen-Dump"
-        ita "Il gestore per la tabella non supporta il dump binario"
-        jpn "The handler for the table does not support binary table dump"
-        por "O manipulador de tabela não suporta 'dump' binário de tabela"
-        rum "The handler for the table does not support binary table dump"
-        rus "Обработчик этой таблицы не поддерживает двоичного сохранения образа таблицы (dump)"
-        serbian "Handler tabele ne podržava binarni dump tabele"
-        spa "El manipulador de tabla no soporta dump para tabla binaria"
-        swe "Tabellhanteraren klarar inte en binär kopiering av tabellen"
-        ukr "Цей тип таблиці не підтримує бінарну передачу таблиці"
+ER_unused_2
+        eng "You should never see it"
 ER_FLUSH_MASTER_BINLOG_CLOSED  
         eng "Binlog closed, cannot RESET MASTER"
         ger "Binlog geschlossen. Kann RESET MASTER nicht ausführen"
@@ -4477,18 +4399,18 @@ ER_LOCK_DEADLOCK 40001
         spa "Encontrado deadlock cuando tentando obtener el bloqueo; Tente recomenzar la transición"
         swe "Fick 'DEADLOCK' vid låsförsök av block/rad. Försök att starta om transaktionen"
 ER_TABLE_CANT_HANDLE_FT  
-        nla "Het gebruikte tabel type ondersteund geen FULLTEXT indexen"
-        eng "The used table type doesn't support FULLTEXT indexes"
-        est "Antud tabelitüüp ei toeta FULLTEXT indekseid"
-        fre "Le type de table utilisé ne supporte pas les index FULLTEXT"
-        ger "Der verwendete Tabellentyp unterstützt keine FULLTEXT-Indizes"
-        ita "La tabella usata non supporta gli indici FULLTEXT"
-        por "O tipo de tabela utilizado não suporta índices de texto completo (fulltext indexes)"
-        rus "Используемый тип таблиц не поддерживает полнотекстовых индексов"
-        serbian "Upotrebljeni tip tabele ne podržava 'FULLTEXT' indekse"
-        spa "El tipo de tabla usada no soporta índices FULLTEXT"
-        swe "Tabelltypen har inte hantering av FULLTEXT-index"
-        ukr "Використаний тип таблиці не підтримує FULLTEXT індексів"
+        nla "Het gebruikte tabel type (%s) ondersteund geen FULLTEXT indexen"
+        eng "The storage engine %s doesn't support FULLTEXT indexes"
+        est "Antud tabelitüüp (%s) ei toeta FULLTEXT indekseid"
+        fre "Le type de table utilisé (%s) ne supporte pas les index FULLTEXT"
+        ger "Der verwendete Tabellentyp (%s) unterstützt keine FULLTEXT-Indizes"
+        ita "La tabella usata (%s) non supporta gli indici FULLTEXT"
+        por "O tipo de tabela utilizado (%s) não suporta índices de texto completo (fulltext indexes)"
+        rus "Используемый тип таблиц (%s) не поддерживает полнотекстовых индексов"
+        serbian "Upotrebljeni tip tabele (%s) ne podržava 'FULLTEXT' indekse"
+        spa "El tipo de tabla usada (%s) no soporta índices FULLTEXT"
+        swe "Tabelltypen (%s) har inte hantering av FULLTEXT-index"
+        ukr "Використаний тип таблиці (%s) не підтримує FULLTEXT індексів"
 ER_CANNOT_ADD_FOREIGN  
         nla "Kan foreign key beperking niet toevoegen"
         eng "Cannot add foreign key constraint"
@@ -4989,13 +4911,13 @@ ER_WRONG_NAME_FOR_CATALOG 42000
         spa "Nombre de catalog incorrecto '%-.100s'"
         swe "Felaktigt katalog namn '%-.100s'"
 ER_WARN_QC_RESIZE  
-        eng "Query cache failed to set size %lu; new query cache size is %lu"
-        ger "Änderung der Query-Cache-Größe auf %lu fehlgeschlagen; neue Query-Cache-Größe ist %lu"
-        por "Falha em Query cache para configurar tamanho %lu, novo tamanho de query cache é %lu"
-        rus "Кеш запросов не может установить размер %lu, новый размер кеша зпросов - %lu"
-        spa "Query cache fallada para configurar tamaño %lu, nuevo tamaño de query cache es %lu"
-        swe "Storleken av "Query cache" kunde inte sättas till %lu, ny storlek är %lu"
-        ukr "Кеш запитів неспроможен встановити розмір %lu, новий розмір кеша запитів - %lu"
+        eng "Query cache failed to set size %llu; new query cache size is %lu"
+        ger "Änderung der Query-Cache-Größe auf %llu fehlgeschlagen; neue Query-Cache-Größe ist %lu"
+        por "Falha em Query cache para configurar tamanho %llu, novo tamanho de query cache é %lu"
+        rus "Кеш запросов не может установить размер %llu, новый размер кеша зпросов - %lu"
+        spa "Query cache fallada para configurar tamaño %llu, nuevo tamaño de query cache es %lu"
+        swe "Storleken av "Query cache" kunde inte sättas till %llu, ny storlek är %lu"
+        ukr "Кеш запитів неспроможен встановити розмір %llu, новий розмір кеша запитів - %lu"
 ER_BAD_FT_COLUMN  
         eng "Column '%-.192s' cannot be part of FULLTEXT index"
         ger "Feld '%-.192s' kann nicht Teil eines FULLTEXT-Index sein"
@@ -5622,8 +5544,8 @@ ER_NON_GROUPING_FIELD_USED 42000
         eng "Non-grouping field '%-.192s' is used in %-.64s clause"
         ger "In der %-.192s-Klausel wird das die Nicht-Gruppierungsspalte '%-.64s' verwendet"
 ER_TABLE_CANT_HANDLE_SPKEYS
-        eng "The used table type doesn't support SPATIAL indexes"
-        ger "Der verwendete Tabellentyp unterstützt keine SPATIAL-Indizes"
+        eng "The storage engine %s doesn't support SPATIAL indexes"
+        ger "Der verwendete Tabellentyp (%s) unterstützt keine SPATIAL-Indizes"
 ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA
         eng "Triggers can not be created on system tables"
         ger "Trigger können nicht auf Systemtabellen erzeugt werden"
@@ -6018,8 +5940,8 @@ ER_ONLY_INTEGERS_ALLOWED
         eng "Only integers allowed as number here"
         ger "An dieser Stelle sind nur Ganzzahlen zulässig"
 ER_UNSUPORTED_LOG_ENGINE
-        eng "This storage engine cannot be used for log tables"
-        ger "Diese Speicher-Engine kann für Logtabellen nicht verwendet werden"
+        eng "Storage engine %s cannot be used for log tables"
+        ger "Speicher-Engine %s kann für Logtabellen nicht verwendet werden"
 ER_BAD_LOG_STATEMENT
         eng "You cannot '%s' a log table if logging is enabled"
         ger "Sie können eine Logtabelle nicht '%s', wenn Loggen angeschaltet ist"
@@ -6189,13 +6111,13 @@ ER_EXCEPTIONS_WRITE_ERROR
   eng "Write to exceptions table failed. Message: %-.128s""
   ger "Schreiben in Ausnahme-Tabelle fehlgeschlagen. Meldung: %-.128s""
 ER_TOO_LONG_TABLE_COMMENT
-  eng "Comment for table '%-.64s' is too long (max = %lu)"
-  por "Comentário para a tabela '%-.64s' é longo demais (max = %lu)"
-  ger "Kommentar für Tabelle '%-.64s' ist zu lang (max = %lu)"
+  eng "Comment for table '%-.64s' is too long (max = %u)"
+  por "Comentário para a tabela '%-.64s' é longo demais (max = %u)"
+  ger "Kommentar für Tabelle '%-.64s' ist zu lang (max = %u)"
 ER_TOO_LONG_FIELD_COMMENT
-  eng "Comment for field '%-.64s' is too long (max = %lu)"
-  por "Comentário para o campo '%-.64s' é longo demais (max = %lu)"
-  ger "Kommentar für Feld '%-.64s' ist zu lang (max = %lu)"
+  eng "Comment for field '%-.64s' is too long (max = %u)"
+  por "Comentário para o campo '%-.64s' é longo demais (max = %u)"
+  ger "Kommentar für Feld '%-.64s' ist zu lang (max = %u)"
 ER_FUNC_INEXISTENT_NAME_COLLISION 42000 
   eng "FUNCTION %s does not exist. Check the 'Function Name Parsing and Resolution' section in the Reference Manual"
   ger "FUNCTION %s existiert nicht. Erläuterungen im Abschnitt 'Function Name Parsing and Resolution' im Referenzhandbuch"
@@ -6500,7 +6422,7 @@ ER_BINLOG_UNSAFE_INSERT_TWO_KEYS
 ER_TABLE_IN_FK_CHECK
   eng "Table is being used in foreign key check."
 
-ER_UNUSED_1
+ER_unused_1
   eng "You should never see it"
 
 ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST
@@ -6821,4 +6743,7 @@ ER_CANT_START_STOP_SLAVE
 ER_SLAVE_STARTED
         eng "SLAVE '%.*s' started"
 ER_SLAVE_STOPPED
-        eng "SLAVE '%.*s' stopped"
\ No newline at end of file
+        eng "SLAVE '%.*s' stopped"
+ER_SQL_DISCOVER_ERROR
+        eng "Engine %s failed to discover table %`-.192s.%`-.192s with '%s'"
+
diff --git a/sql/slave.cc b/sql/slave.cc
index 78fa7998012..41eb7247b8c 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -1351,6 +1351,7 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi)
     unavailable (very old master not supporting UNIX_TIMESTAMP()?).
   */
 
+#ifdef ENABLED_DEBUG_SYNC
   DBUG_EXECUTE_IF("dbug.before_get_UNIX_TIMESTAMP",
                   {
                     const char act[]=
@@ -1360,6 +1361,7 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi)
                     DBUG_ASSERT(!debug_sync_set_action(current_thd,
                                                        STRING_WITH_LEN(act)));
                   };);
+#endif
 
   master_res= NULL;
   if (!mysql_real_query(mysql, STRING_WITH_LEN("SELECT UNIX_TIMESTAMP()")) &&
@@ -1401,6 +1403,7 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi)
     Note: we could have put a @@SERVER_ID in the previous SELECT
     UNIX_TIMESTAMP() instead, but this would not have worked on 3.23 masters.
   */
+#ifdef ENABLED_DEBUG_SYNC
   DBUG_EXECUTE_IF("dbug.before_get_SERVER_ID",
                   {
                     const char act[]=
@@ -1410,6 +1413,7 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi)
                     DBUG_ASSERT(!debug_sync_set_action(current_thd, 
                                                        STRING_WITH_LEN(act)));
                   };);
+#endif
   master_res= NULL;
   master_row= NULL;
   if (!mysql_real_query(mysql,
@@ -3263,6 +3267,7 @@ pthread_handler_t handle_slave_io(void *arg)
 
 connected:
 
+#ifdef ENABLED_DEBUG_SYNC
     DBUG_EXECUTE_IF("dbug.before_get_running_status_yes",
                     {
                       const char act[]=
@@ -3272,6 +3277,7 @@ connected:
                       DBUG_ASSERT(!debug_sync_set_action(thd, 
                                                          STRING_WITH_LEN(act)));
                     };);
+#endif
 
   // TODO: the assignment below should be under mutex (5.0)
   mi->slave_running= MYSQL_SLAVE_RUN_CONNECT;
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 7cd2e789351..37f5e97110a 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -2432,7 +2432,7 @@ sp_head::fill_field_definition(THD *thd, LEX *lex,
                       lex->charset ? lex->charset :
                                      thd->variables.collation_database,
                       lex->uint_geom_type,
-		      lex->vcol_info, NULL))
+		      lex->vcol_info, NULL, FALSE))
     return TRUE;
 
   if (field_def->interval_list.elements)
diff --git a/sql/spatial.cc b/sql/spatial.cc
index de0b563eaf4..2359f4fa271 100644
--- a/sql/spatial.cc
+++ b/sql/spatial.cc
@@ -312,6 +312,9 @@ bool Geometry::envelope(String *result) const
   const char *end;
 
   if (get_mbr(&mbr, &end))
+    return 1;
+
+  if (!mbr.valid())
   {
     /* Empty geometry */
     if (result->reserve(1 + 4*2))
@@ -444,18 +447,19 @@ const char *Geometry::append_points(String *txt, uint32 n_points,
 const char *Geometry::get_mbr_for_points(MBR *mbr, const char *data,
 					 uint offset) const
 {
-  uint32 points;
+  uint32 n_points;
   /* read number of points */
   if (no_data(data, 4))
     return 0;
-  points= uint4korr(data);
+  n_points= uint4korr(data);
   data+= 4;
 
-  if (no_data(data, (POINT_DATA_SIZE + offset) * points))
+  if (n_points > max_n_points ||
+      no_data(data, (POINT_DATA_SIZE + offset) * n_points))
     return 0;
 
   /* Calculate MBR for points */
-  while (points--)
+  while (n_points--)
   {
     data+= offset;
     mbr->add_xy(data, data + SIZEOF_STORED_DOUBLE);
@@ -559,9 +563,12 @@ const Geometry::Class_info *Gis_point::get_class_info() const
 
 uint32 Gis_line_string::get_data_size() const 
 {
-  if (no_data(m_data, 4))
+  uint32 n_points, size;
+  if (no_data(m_data, 4) ||
+      (n_points= uint4korr(m_data)) > max_n_points ||
+      no_data(m_data, (size= 4 + n_points * POINT_DATA_SIZE)))
     return GET_SIZE_ERROR;
-  return 4 + uint4korr(m_data) * POINT_DATA_SIZE;
+  return size;
 }
 
 
@@ -631,7 +638,7 @@ bool Gis_line_string::get_data_as_wkt(String *txt, const char **end) const
   n_points= uint4korr(data);
   data += 4;
 
-  if (n_points < 1 ||
+  if (n_points < 1 || n_points > max_n_points ||
       no_data(data, POINT_DATA_SIZE * n_points) ||
       txt->reserve(((MAX_DIGITS_IN_DOUBLE + 1)*2 + 1) * n_points))
     return 1;
@@ -669,7 +676,8 @@ int Gis_line_string::geom_length(double *len, const char **end) const
     return 1;
   n_points= uint4korr(data);
   data+= 4;
-  if (n_points < 1 || no_data(data, POINT_DATA_SIZE * n_points))
+  if (n_points < 1 || n_points > max_n_points ||
+      no_data(data, POINT_DATA_SIZE * n_points))
     return 1;
 
   get_point(&prev_x, &prev_y, data);
@@ -717,7 +725,7 @@ int Gis_line_string::is_closed(int *closed) const
     return 0;
   }
   data+= 4;
-  if (n_points == 0 ||
+  if (n_points == 0 || n_points > max_n_points ||
       no_data(data, POINT_DATA_SIZE * n_points))
     return 1;
 
@@ -753,6 +761,9 @@ int Gis_line_string::end_point(String *result) const
   if (no_data(m_data, 4))
     return 1;
   n_points= uint4korr(m_data);
+  if (n_points == 0 || n_points > max_n_points ||
+      no_data(m_data, POINT_DATA_SIZE * n_points))
+    return 1;
   return create_point(result, m_data + 4 + (n_points - 1) * POINT_DATA_SIZE);
 }
 
@@ -762,11 +773,14 @@ int Gis_line_string::point_n(uint32 num, String *result) const
   uint32 n_points;
   if (no_data(m_data, 4))
     return 1;
+  num--;
   n_points= uint4korr(m_data);
-  if ((uint32) (num - 1) >= n_points) // means (num > n_points || num < 1)
+  if (num >= n_points ||
+      num > max_n_points || // means (num > n_points || num < 1)
+      no_data(m_data, num * POINT_DATA_SIZE))
     return 1;
 
-  return create_point(result, m_data + 4 + (num - 1) * POINT_DATA_SIZE);
+  return create_point(result, m_data + 4 + num*POINT_DATA_SIZE);
 }
 
 
@@ -782,7 +796,8 @@ int Gis_line_string::store_shapes(Gcalc_shape_transporter *trn) const
     return 1;
   n_points= uint4korr(data);
   data+= 4;
-  if (n_points < 1 || no_data(data, POINT_DATA_SIZE * n_points))
+  if (n_points < 1 ||  n_points > max_n_points ||
+      no_data(data, POINT_DATA_SIZE * n_points))
     return 1;
 
   trn->start_line();
@@ -815,6 +830,7 @@ const Geometry::Class_info *Gis_line_string::get_class_info() const
 uint32 Gis_polygon::get_data_size() const 
 {
   uint32 n_linear_rings;
+  uint32 n_points;
   const char *data= m_data;
 
   if (no_data(data, 4))
@@ -824,10 +840,13 @@ uint32 Gis_polygon::get_data_size() const
 
   while (n_linear_rings--)
   {
-    if (no_data(data, 4))
+    if (no_data(data, 4) ||
+        (n_points= uint4korr(data)) > max_n_points)
       return GET_SIZE_ERROR;
-    data+= 4 + uint4korr(data)*POINT_DATA_SIZE;
+    data+= 4 + n_points*POINT_DATA_SIZE;
   }
+  if (no_data(data, 0))
+    return GET_SIZE_ERROR;
   return (uint32) (data - m_data);
 }
 
@@ -966,7 +985,7 @@ bool Gis_polygon::get_data_as_wkt(String *txt, const char **end) const
       return 1;
     n_points= uint4korr(data);
     data+= 4;
-    if (no_data(data, POINT_DATA_SIZE * n_points) ||
+    if (n_points > max_n_points || no_data(data, POINT_DATA_SIZE * n_points) ||
 	txt->reserve(2 + ((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points))
       return 1;
     txt->qs_append('(');
@@ -1020,7 +1039,8 @@ int Gis_polygon::area(double *ar, const char **end_of_data) const
     if (no_data(data, 4))
       return 1;
     n_points= uint4korr(data);
-    if (no_data(data, POINT_DATA_SIZE * n_points))
+    if (n_points == 0 || n_points > max_n_points ||
+        no_data(data, POINT_DATA_SIZE * n_points))
       return 1;
     get_point(&prev_x, &prev_y, data+4);
     data+= (4+POINT_DATA_SIZE);
@@ -1056,7 +1076,8 @@ int Gis_polygon::exterior_ring(String *result) const
   n_points= uint4korr(data);
   data+= 4;
   length= n_points * POINT_DATA_SIZE;
-  if (no_data(data, length) || result->reserve(1 + 4 + 4 + length))
+  if (n_points > max_n_points ||
+      no_data(data, length) || result->reserve(1 + 4 + 4 + length))
     return 1;
 
   result->q_append((char) wkb_ndr);
@@ -1102,7 +1123,8 @@ int Gis_polygon::interior_ring_n(uint32 num, String *result) const
   n_points= uint4korr(data);
   points_size= n_points * POINT_DATA_SIZE;
   data+= 4;
-  if (no_data(data, points_size) || result->reserve(1 + 4 + 4 + points_size))
+  if (n_points > max_n_points ||
+      no_data(data, points_size) || result->reserve(1 + 4 + 4 + points_size))
     return 1;
 
   result->q_append((char) wkb_ndr);
@@ -1122,13 +1144,11 @@ int Gis_polygon::centroid_xy(double *x, double *y) const
   const char *data= m_data;
   bool first_loop= 1;
 
-  if (no_data(data, 4))
+  if (no_data(data, 4) ||
+      (n_linear_rings= uint4korr(data)) == 0)
     return 1;
-  n_linear_rings= uint4korr(data);
   data+= 4;
 
-  DBUG_ASSERT(n_linear_rings > 0);
-
   while (n_linear_rings--)
   {
     uint32 n_points, org_n_points;
@@ -1141,7 +1161,8 @@ int Gis_polygon::centroid_xy(double *x, double *y) const
       return 1;
     org_n_points= n_points= uint4korr(data);
     data+= 4;
-    if (no_data(data, POINT_DATA_SIZE * n_points))
+    if (n_points == 0 || n_points > max_n_points ||
+        no_data(data, POINT_DATA_SIZE * n_points))
       return 1;
     get_point(&prev_x, &prev_y, data);
     data+= POINT_DATA_SIZE;
@@ -1215,7 +1236,8 @@ int Gis_polygon::store_shapes(Gcalc_shape_transporter *trn) const
       return 1;
     n_points= uint4korr(data);
     data+= 4;
-    if (!n_points || no_data(data, POINT_DATA_SIZE * n_points))
+    if (!n_points || n_points > max_n_points ||
+        no_data(data, POINT_DATA_SIZE * n_points))
       return 1;
 
     trn->start_ring();
@@ -1268,9 +1290,14 @@ const Geometry::Class_info *Gis_polygon::get_class_info() const
 
 uint32 Gis_multi_point::get_data_size() const 
 {
-  if (no_data(m_data, 4))
-    return GET_SIZE_ERROR;
-  return 4 + uint4korr(m_data)*(POINT_DATA_SIZE + WKB_HEADER_SIZE);
+  uint32 n_points;
+  uint32 size;
+
+  if (no_data(m_data, 4) ||
+      (n_points= uint4korr(m_data)) > max_n_points ||
+      no_data(m_data, (size= 4 + n_points*(POINT_DATA_SIZE + WKB_HEADER_SIZE))))
+     return GET_SIZE_ERROR;
+  return size;
 }
 
 
@@ -1364,8 +1391,8 @@ bool Gis_multi_point::get_data_as_wkt(String *txt, const char **end) const
     return 1;
 
   n_points= uint4korr(m_data);
-  if (no_data(m_data+4,
-	      n_points * (POINT_DATA_SIZE + WKB_HEADER_SIZE)) ||
+  if (n_points > max_n_points ||
+      no_data(m_data+4, n_points * (POINT_DATA_SIZE + WKB_HEADER_SIZE)) ||
       txt->reserve(((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points))
     return 1;
   *end= append_points(txt, n_points, m_data+4, WKB_HEADER_SIZE);
@@ -1446,6 +1473,7 @@ const Geometry::Class_info *Gis_multi_point::get_class_info() const
 uint32 Gis_multi_line_string::get_data_size() const 
 {
   uint32 n_line_strings;
+  uint32 n_points;
   const char *data= m_data;
 
   if (no_data(data, 4))
@@ -1455,11 +1483,13 @@ uint32 Gis_multi_line_string::get_data_size() const
 
   while (n_line_strings--)
   {
-    if (no_data(data, WKB_HEADER_SIZE + 4))
+    if (no_data(data, WKB_HEADER_SIZE + 4) ||
+        (n_points= uint4korr(data + WKB_HEADER_SIZE)) > max_n_points)
       return GET_SIZE_ERROR;
-    data+= (WKB_HEADER_SIZE + 4 + uint4korr(data + WKB_HEADER_SIZE) *
-	    POINT_DATA_SIZE);
+    data+= (WKB_HEADER_SIZE + 4 + n_points*POINT_DATA_SIZE);
   }
+  if (no_data(data, 0))
+    return GET_SIZE_ERROR;
   return (uint32) (data - m_data);
 }
 
@@ -1583,7 +1613,7 @@ bool Gis_multi_line_string::get_data_as_wkt(String *txt,
       return 1;
     n_points= uint4korr(data + WKB_HEADER_SIZE);
     data+= WKB_HEADER_SIZE + 4;
-    if (no_data(data, n_points * POINT_DATA_SIZE) ||
+    if (n_points > max_n_points || no_data(data, n_points * POINT_DATA_SIZE) ||
 	txt->reserve(2 + ((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points))
       return 1;
     txt->qs_append('(');
@@ -1644,7 +1674,7 @@ int Gis_multi_line_string::geometry_n(uint32 num, String *result) const
       return 1;
     n_points= uint4korr(data + WKB_HEADER_SIZE);
     length= WKB_HEADER_SIZE + 4+ POINT_DATA_SIZE * n_points;
-    if (no_data(data, length))
+    if (n_points > max_n_points || no_data(data, length))
       return 1;
     if (!--num)
       break;
@@ -1755,6 +1785,7 @@ const Geometry::Class_info *Gis_multi_line_string::get_class_info() const
 uint32 Gis_multi_polygon::get_data_size() const 
 {
   uint32 n_polygons;
+  uint32 n_points;
   const char *data= m_data;
 
   if (no_data(data, 4))
@@ -1773,11 +1804,14 @@ uint32 Gis_multi_polygon::get_data_size() const
 
     while (n_linear_rings--)
     {
-      if (no_data(data, 4))
+      if (no_data(data, 4) ||
+          (n_points= uint4korr(data)) > max_n_points)
 	return GET_SIZE_ERROR;
-      data+= 4 + uint4korr(data) * POINT_DATA_SIZE;
+      data+= 4 + n_points * POINT_DATA_SIZE;
     }
   }
+  if (no_data(data, 0))
+    return GET_SIZE_ERROR;
   return (uint32) (data - m_data);
 }
 
@@ -1905,7 +1939,8 @@ bool Gis_multi_polygon::get_data_as_wkt(String *txt, const char **end) const
         return 1;
       uint32 n_points= uint4korr(data);
       data+= 4;
-      if (no_data(data, POINT_DATA_SIZE * n_points) ||
+      if (n_points > max_n_points ||
+          no_data(data, POINT_DATA_SIZE * n_points) ||
 	  txt->reserve(2 + ((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points,
 		       512))
 	return 1;
@@ -1988,6 +2023,8 @@ int Gis_multi_polygon::geometry_n(uint32 num, String *result) const
       if (no_data(data, 4))
 	return 1;
       n_points= uint4korr(data);
+      if (n_points > max_n_points)
+        return 1;
       data+= 4 + POINT_DATA_SIZE * n_points;
     }
   } while (--num);
@@ -2317,7 +2354,7 @@ bool Gis_geometry_collection::get_mbr(MBR *mbr, const char **end) const
   n_objects= uint4korr(data);
   data+= 4;
   if (n_objects == 0)
-    return 1;
+    goto exit;
 
   while (n_objects--)
   {
@@ -2334,6 +2371,7 @@ bool Gis_geometry_collection::get_mbr(MBR *mbr, const char **end) const
     if (geom->get_mbr(mbr, &data))
       return 1;
   }
+exit:
   *end= data;
   return 0;
 }
@@ -2351,10 +2389,11 @@ int Gis_geometry_collection::area(double *ar,  const char **end) const
     return 1;
   n_objects= uint4korr(data);
   data+= 4;
-  if (n_objects == 0)
-    return 1;
 
   result= 0.0;
+  if (n_objects == 0)
+    goto exit;
+
   while (n_objects--)
   {
     uint32 wkb_type;
@@ -2371,6 +2410,7 @@ int Gis_geometry_collection::area(double *ar,  const char **end) const
       return 1;
     result+= *ar;
   }
+exit:
   *end= data;
   *ar= result;
   return 0;
@@ -2389,10 +2429,11 @@ int Gis_geometry_collection::geom_length(double *len, const char **end) const
     return 1;
   n_objects= uint4korr(data);
   data+= 4;
+  result= 0.0;
+
   if (n_objects == 0)
-    return 1;
+    goto exit;
 
-  result= 0.0;
   while (n_objects--)
   {
     uint32 wkb_type;
@@ -2409,6 +2450,8 @@ int Gis_geometry_collection::geom_length(double *len, const char **end) const
       return 1;
     result+= *len;
   }
+
+exit:
   *end= data;
   *len= result;
   return 0;
diff --git a/sql/spatial.h b/sql/spatial.h
index 1277e7bc01c..9aaedfe8a20 100644
--- a/sql/spatial.h
+++ b/sql/spatial.h
@@ -200,6 +200,9 @@ struct MBR
 
     return (d == intersection.dimension());
   }
+
+  int valid() const
+  { return xmin <= xmax && ymin <= ymax; }
 };
 
 
@@ -210,6 +213,11 @@ struct Geometry_buffer;
 class Geometry
 {
 public:
+  // Maximum number of points in feature that can fit into String
+  static const uint32 max_n_points=
+    (uint32) (INT_MAX32 - WKB_HEADER_SIZE - 4 /* n_points */) /
+    POINT_DATA_SIZE;
+
   Geometry() {}                               /* Remove gcc warning */
   virtual ~Geometry() {}                        /* Remove gcc warning */
   static void *operator new(size_t size, void *buffer)
@@ -391,10 +399,6 @@ public:
 
 class Gis_line_string: public Geometry
 {
-  // Maximum number of points in LineString that can fit into String
-  static const uint32 max_n_points=
-    (uint32) (UINT_MAX32 - WKB_HEADER_SIZE - 4 /* n_points */) /
-    POINT_DATA_SIZE;
 public:
   Gis_line_string() {}                        /* Remove gcc warning */
   virtual ~Gis_line_string() {}               /* Remove gcc warning */
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index cb7e35fae09..db734389b7f 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -52,6 +52,8 @@
 #include "sql_db.h"
 #include "sql_array.h"
 
+#include "sql_plugin_compat.h"
+
 bool mysql_user_table_is_in_short_password_format= false;
 
 static const
@@ -4532,12 +4534,16 @@ end:
   @see check_access
   @see check_table_access
 
-  @note This functions assumes that either number of tables to be inspected
+  @note
+     This functions assumes that either number of tables to be inspected
      by it is limited explicitly (i.e. is is not UINT_MAX) or table list
      used and thd->lex->query_tables_own_last value correspond to each
      other (the latter should be either 0 or point to next_global member
      of one of elements of this table list).
 
+     We delay locking of LOCK_grant until we really need it as we assume that
+     most privileges be resolved with user or db level accesses.
+
    @return Access status
      @retval FALSE Access granted; But column privileges might need to be
       checked.
@@ -4554,6 +4560,8 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
   Security_context *sctx= thd->security_ctx;
   uint i;
   ulong orig_want_access= want_access;
+  my_bool locked= 0;
+  GRANT_TABLE *grant_table;
   DBUG_ENTER("check_grant");
   DBUG_ASSERT(number > 0);
 
@@ -4577,11 +4585,9 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
     */
     tl->grant.orig_want_privilege= (want_access & ~SHOW_VIEW_ACL);
   }
+  number= i;
 
-  mysql_rwlock_rdlock(&LOCK_grant);
-  for (tl= tables;
-       tl && number-- && tl != first_not_own_table;
-       tl= tl->next_global)
+  for (tl= tables; number-- ; tl= tl->next_global)
   {
     sctx = test(tl->security_ctx) ? tl->security_ctx : thd->security_ctx;
 
@@ -4634,13 +4640,18 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
       }
       continue;
     }
-    GRANT_TABLE *grant_table= table_hash_search(sctx->host, sctx->ip,
-                                                tl->get_db_name(),
-                                                sctx->priv_user,
-                                                tl->get_table_name(),
-                                                FALSE);
 
-    if (!grant_table)
+    if (!locked)
+    {
+      locked= 1;
+      mysql_rwlock_rdlock(&LOCK_grant);
+    }
+
+    if (!(grant_table= table_hash_search(sctx->host, sctx->ip,
+                                         tl->get_db_name(),
+                                         sctx->priv_user,
+                                         tl->get_table_name(),
+                                         FALSE)))
     {
       want_access &= ~tl->grant.privilege;
       goto err;					// No grants
@@ -4667,11 +4678,13 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
       goto err;					// impossible
     }
   }
-  mysql_rwlock_unlock(&LOCK_grant);
+  if (locked)
+    mysql_rwlock_unlock(&LOCK_grant);
   DBUG_RETURN(FALSE);
 
 err:
-  mysql_rwlock_unlock(&LOCK_grant);
+  if (locked)
+    mysql_rwlock_unlock(&LOCK_grant);
   if (!no_errors)				// Not a silent skip of table
   {
     char command[128];
@@ -7025,10 +7038,8 @@ bool sp_grant_privileges(THD *thd, const char *sp_db, const char *sp_name,
   tables->db= (char*)sp_db;
   tables->table_name= tables->alias= (char*)sp_name;
 
-  thd->make_lex_string(&combo->user,
-                       combo->user.str, strlen(combo->user.str), 0);
-  thd->make_lex_string(&combo->host,
-                       combo->host.str, strlen(combo->host.str), 0);
+  thd->make_lex_string(&combo->user, combo->user.str, strlen(combo->user.str));
+  thd->make_lex_string(&combo->host, combo->host.str, strlen(combo->host.str));
 
   combo->password= empty_lex_str;
   combo->plugin= empty_lex_str;
@@ -7950,7 +7961,7 @@ static bool send_server_handshake_packet(MPVIO_EXT *mpvio,
     data_len= SCRAMBLE_LENGTH;
   }
 
-  end= strnmov(end, server_version, SERVER_VERSION_LENGTH) + 1;
+  end= strxnmov(end, SERVER_VERSION_LENGTH, RPL_VERSION_HACK, server_version, NullS) + 1;
   int4store((uchar*) end, mpvio->thd->thread_id);
   end+= 4;
 
@@ -8254,7 +8265,7 @@ static bool parse_com_change_user_packet(MPVIO_EXT *mpvio, uint packet_length)
   thd->user_connect= 0;
   strmake(sctx->priv_user, sctx->user, USERNAME_LENGTH);
 
-  if (thd->make_lex_string(&mpvio->db, db_buff, db_len, 0) == 0)
+  if (thd->make_lex_string(&mpvio->db, db_buff, db_len) == 0)
     DBUG_RETURN(1); /* The error is set by make_lex_string(). */
 
   /*
@@ -8480,7 +8491,7 @@ static ulong parse_client_handshake_packet(MPVIO_EXT *mpvio,
 
   Security_context *sctx= thd->security_ctx;
 
-  if (thd->make_lex_string(&mpvio->db, db, db_len, 0) == 0)
+  if (thd->make_lex_string(&mpvio->db, db, db_len) == 0)
     return packet_error; /* The error is set by make_lex_string(). */
   my_free(sctx->user);
   if (!(sctx->user= my_strndup(user, user_len, MYF(MY_WME))))
@@ -8869,7 +8880,20 @@ static int do_auth_once(THD *thd, const LEX_STRING *auth_plugin_name,
   if (plugin)
   {
     st_mysql_auth *auth= (st_mysql_auth *) plugin_decl(plugin)->info;
-    res= auth->authenticate_user(mpvio, &mpvio->auth_info);
+    switch (auth->interface_version) {
+    case 0x0200:
+      res= auth->authenticate_user(mpvio, &mpvio->auth_info);
+      break;
+    case 0x0100:
+      {
+        MYSQL_SERVER_AUTH_INFO_0x0100 compat;
+        compat.downgrade(&mpvio->auth_info);
+        res= auth->authenticate_user(mpvio, (MYSQL_SERVER_AUTH_INFO *)&compat);
+        compat.upgrade(&mpvio->auth_info);
+      }
+      break;
+    default: DBUG_ASSERT(0);
+    }
 
     if (unlock_plugin)
       plugin_unlock(thd, plugin);
@@ -8920,8 +8944,6 @@ bool acl_authenticate(THD *thd, uint connect_errors,
                                                              : COM_CONNECT;
   DBUG_ENTER("acl_authenticate");
 
-  compile_time_assert(MYSQL_USERNAME_LENGTH == USERNAME_LENGTH);
-
   bzero(&mpvio, sizeof(mpvio));
   mpvio.read_packet= server_mpvio_read_packet;
   mpvio.write_packet= server_mpvio_write_packet;
diff --git a/sql/sql_admin.cc b/sql/sql_admin.cc
index e6bbef482a7..9e3ea46f526 100644
--- a/sql/sql_admin.cc
+++ b/sql/sql_admin.cc
@@ -89,6 +89,7 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
   const char **ext;
   MY_STAT stat_info;
   Open_table_context ot_ctx(thd, (MYSQL_OPEN_IGNORE_FLUSH |
+                                  MYSQL_OPEN_FOR_REPAIR |
                                   MYSQL_OPEN_HAS_MDL_LOCK |
                                   MYSQL_LOCK_IGNORE_TIMEOUT));
   DBUG_ENTER("prepare_for_repair");
@@ -98,8 +99,6 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
 
   if (!(table= table_list->table))
   {
-    char key[MAX_DBKEY_LENGTH];
-    uint key_length;
     /*
       If the table didn't exist, we have a shared metadata lock
       on it that is left from mysql_admin_table()'s attempt to 
@@ -112,9 +111,7 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
       Attempt to do full-blown table open in mysql_admin_table() has failed.
       Let us try to open at least a .FRM for this table.
     */
-    my_hash_value_type hash_value;
 
-    key_length= create_table_def_key(thd, key, table_list, 0);
     table_list->mdl_request.init(MDL_key::TABLE,
                                  table_list->db, table_list->table_name,
                                  MDL_EXCLUSIVE, MDL_TRANSACTION);
@@ -125,11 +122,8 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
       DBUG_RETURN(0);
     has_mdl_lock= TRUE;
 
-    hash_value= my_calc_hash(&table_def_cache, (uchar*) key, key_length);
-    mysql_mutex_lock(&LOCK_open);
-    share= get_table_share(thd, table_list, key, key_length, 0,
-                           &error, hash_value);
-    mysql_mutex_unlock(&LOCK_open);
+    share= get_table_share(thd, table_list->db, table_list->table_name,
+                           GTS_TABLE);
     if (share == NULL)
       DBUG_RETURN(0);				// Can't open frm file
 
@@ -199,7 +193,8 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
     */
     pos_in_locked_tables= table->pos_in_locked_tables;
     if (wait_while_table_is_used(thd, table,
-                                 HA_EXTRA_PREPARE_FOR_FORCED_CLOSE))
+                                 HA_EXTRA_PREPARE_FOR_FORCED_CLOSE,
+                                 TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
       goto end;
     /* Close table but don't remove from locked list */
     close_all_tables_for_name(thd, table_list->table->s,
@@ -593,8 +588,10 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
     */
     if (lock_type == TL_WRITE && !table->table->s->tmp_table)
     {
+      table->table->s->protect_against_usage();
       if (wait_while_table_is_used(thd, table->table,
-                                   HA_EXTRA_PREPARE_FOR_RENAME))
+                                   HA_EXTRA_PREPARE_FOR_RENAME,
+                                   TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
         goto err;
       DEBUG_SYNC(thd, "after_admin_flush");
       /* Flush entries in the query cache involving this table. */
@@ -826,6 +823,11 @@ send_result_message:
 
     case HA_ADMIN_TRY_ALTER:
     {
+      uint save_flags;
+      Alter_info *alter_info= &lex->alter_info;
+
+      /* Store the original value of alter_info->flags */
+      save_flags= alter_info->flags;
       /*
         This is currently used only by InnoDB. ha_innobase::optimize() answers
         "try with alter", so here we close the table, do an ALTER TABLE,
@@ -833,10 +835,19 @@ send_result_message:
         We have to end the row, so analyze could return more rows.
       */
       protocol->store(STRING_WITH_LEN("note"), system_charset_info);
-      protocol->store(STRING_WITH_LEN(
-          "Table does not support optimize, doing recreate + analyze instead"),
-                      system_charset_info);
-      if (protocol->write())
+      if(alter_info->flags & ALTER_ADMIN_PARTITION)
+      {
+        protocol->store(STRING_WITH_LEN(
+        "Table does not support optimize on partitions. All partitions "
+        "will be rebuilt and analyzed."),system_charset_info);
+      }
+      else
+      {
+        protocol->store(STRING_WITH_LEN(
+        "Table does not support optimize, doing recreate + analyze instead"),
+        system_charset_info);
+      }
+     if (protocol->write())
         goto err;
       DBUG_PRINT("info", ("HA_ADMIN_TRY_ALTER, trying analyze..."));
       TABLE_LIST *save_next_local= table->next_local,
@@ -855,6 +866,11 @@ send_result_message:
         table->mdl_request.ticket= NULL;
         DEBUG_SYNC(thd, "ha_admin_open_ltable");
         table->mdl_request.set_type(MDL_SHARED_WRITE);
+        /*
+          Reset the ALTER_ADMIN_PARTITION bit in alter_info->flags
+          to force analyze on all partitions.
+        */
+        alter_info->flags &= ~(ALTER_ADMIN_PARTITION);
         if ((table->table= open_ltable(thd, table, lock_type, 0)))
         {
           result_code= table->table->file->ha_analyze(thd, check_opt);
@@ -865,6 +881,7 @@ send_result_message:
         }
         else
           result_code= -1; // open failed
+        alter_info->flags= save_flags;
       }
       /* Start a new row for the final status row */
       protocol->prepare_for_resend();
diff --git a/sql/sql_array.h b/sql/sql_array.h
index f07126bc0ef..43ca4ef4219 100644
--- a/sql/sql_array.h
+++ b/sql/sql_array.h
@@ -104,7 +104,7 @@ public:
                           MYF(MY_THREAD_SPECIFIC));
   }
 
-  Elem& at(int idx)
+  Elem& at(size_t idx)
   {
     return *(((Elem*)array.buffer) + idx);
   }
@@ -124,11 +124,21 @@ public:
     return (insert_dynamic(&array, (uchar*)&el));
   }
 
-  int elements()
+  bool append_val(Elem el)
+  {
+    return (insert_dynamic(&array, (uchar*)&el));
+  }
+
+  size_t elements()
   {
     return array.elements;
   }
 
+  void set_elements(size_t n)
+  {
+    array.elements= n;
+  }
+
   ~Dynamic_array()
   {
     delete_dynamic(&array);
diff --git a/sql/sql_audit.h b/sql/sql_audit.h
index 46afe4b7596..a651ce61374 100644
--- a/sql/sql_audit.h
+++ b/sql/sql_audit.h
@@ -43,10 +43,16 @@ static inline bool mysql_audit_general_enabled()
   return mysql_global_audit_mask[0] & MYSQL_AUDIT_GENERAL_CLASSMASK;
 }
 
+static inline bool mysql_audit_connection_enabled()
+{
+  return mysql_global_audit_mask[0] & MYSQL_AUDIT_CONNECTION_CLASSMASK;
+}
+
 #else
 static inline void mysql_audit_notify(THD *thd, uint event_class,
                                       uint event_subtype, ...) { }
 #define mysql_audit_general_enabled() 0
+#define mysql_audit_connection_enabled() 0
 #endif
 extern void mysql_audit_release(THD *thd);
 
@@ -137,41 +143,58 @@ void mysql_audit_general(THD *thd, uint event_subtype,
   }
 }
 
-#define MYSQL_AUDIT_NOTIFY_CONNECTION_CONNECT(thd) mysql_audit_notify(\
-  (thd), MYSQL_AUDIT_CONNECTION_CLASS, MYSQL_AUDIT_CONNECTION_CONNECT,\
-  (thd)->stmt_da->is_error() ? (thd)->stmt_da->sql_errno() : 0,\
-  (thd)->thread_id, (thd)->security_ctx->user,\
-  (thd)->security_ctx->user ? strlen((thd)->security_ctx->user) : 0,\
-  (thd)->security_ctx->priv_user, strlen((thd)->security_ctx->priv_user),\
-  (thd)->security_ctx->external_user,\
-  (thd)->security_ctx->external_user ?\
-    strlen((thd)->security_ctx->external_user) : 0,\
-  (thd)->security_ctx->proxy_user, strlen((thd)->security_ctx->proxy_user),\
-  (thd)->security_ctx->host,\
-  (thd)->security_ctx->host ? strlen((thd)->security_ctx->host) : 0,\
-  (thd)->security_ctx->ip,\
-  (thd)->security_ctx->ip ? strlen((thd)->security_ctx->ip) : 0,\
-  (thd)->db, (thd)->db ? strlen((thd)->db) : 0)
-
-#define MYSQL_AUDIT_NOTIFY_CONNECTION_DISCONNECT(thd, errcode)\
-  mysql_audit_notify(\
-  (thd), MYSQL_AUDIT_CONNECTION_CLASS, MYSQL_AUDIT_CONNECTION_DISCONNECT,\
-  (errcode), (thd)->thread_id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-
-#define MYSQL_AUDIT_NOTIFY_CONNECTION_CHANGE_USER(thd) mysql_audit_notify(\
-  (thd), MYSQL_AUDIT_CONNECTION_CLASS, MYSQL_AUDIT_CONNECTION_CHANGE_USER,\
-  (thd)->stmt_da->is_error() ? (thd)->stmt_da->sql_errno() : 0,\
-  (thd)->thread_id, (thd)->security_ctx->user,\
-  (thd)->security_ctx->user ? strlen((thd)->security_ctx->user) : 0,\
-  (thd)->security_ctx->priv_user, strlen((thd)->security_ctx->priv_user),\
-  (thd)->security_ctx->external_user,\
-  (thd)->security_ctx->external_user ?\
-    strlen((thd)->security_ctx->external_user) : 0,\
-  (thd)->security_ctx->proxy_user, strlen((thd)->security_ctx->proxy_user),\
-  (thd)->security_ctx->host,\
-  (thd)->security_ctx->host ? strlen((thd)->security_ctx->host) : 0,\
-  (thd)->security_ctx->ip,\
-  (thd)->security_ctx->ip ? strlen((thd)->security_ctx->ip) : 0,\
-  (thd)->db, (thd)->db ? strlen((thd)->db) : 0)
+static inline
+void mysql_audit_notify_connection_connect(THD *thd)
+{
+  if (mysql_audit_connection_enabled())
+  {
+    const Security_context *sctx= thd->security_ctx;
+    mysql_audit_notify(thd, MYSQL_AUDIT_CONNECTION_CLASS,
+                       MYSQL_AUDIT_CONNECTION_CONNECT,
+                       thd->stmt_da->is_error() ? thd->stmt_da->sql_errno() : 0,
+                       thd->thread_id,
+                       sctx->user, sctx->user ? strlen(sctx->user) : 0,
+                       sctx->priv_user, strlen(sctx->priv_user),
+                       sctx->external_user,
+                       sctx->external_user ?  strlen(sctx->external_user) : 0,
+                       sctx->proxy_user, strlen(sctx->proxy_user),
+                       sctx->host, sctx->host ? strlen(sctx->host) : 0,
+                       sctx->ip, sctx->ip ? strlen(sctx->ip) : 0,
+                       thd->db, thd->db ? strlen(thd->db) : 0);
+  }
+}
+
+static inline
+void mysql_audit_notify_connection_disconnect(THD *thd, int errcode)
+{
+  if (mysql_audit_connection_enabled())
+  {
+    mysql_audit_notify(thd, MYSQL_AUDIT_CONNECTION_CLASS,
+                       MYSQL_AUDIT_CONNECTION_DISCONNECT,
+                       errcode, thd->thread_id,
+                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+
+static inline
+void mysql_audit_notify_connection_change_user(THD *thd)
+{
+  if (mysql_audit_connection_enabled())
+  {
+    const Security_context *sctx= thd->security_ctx;
+    mysql_audit_notify(thd, MYSQL_AUDIT_CONNECTION_CLASS,
+                       MYSQL_AUDIT_CONNECTION_CHANGE_USER,
+                       thd->stmt_da->is_error() ? thd->stmt_da->sql_errno() : 0,
+                       thd->thread_id,
+                       sctx->user, sctx->user ? strlen(sctx->user) : 0,
+                       sctx->priv_user, strlen(sctx->priv_user),
+                       sctx->external_user,
+                       sctx->external_user ?  strlen(sctx->external_user) : 0,
+                       sctx->proxy_user, strlen(sctx->proxy_user),
+                       sctx->host, sctx->host ? strlen(sctx->host) : 0,
+                       sctx->ip, sctx->ip ? strlen(sctx->ip) : 0,
+                       thd->db, thd->db ? strlen(thd->db) : 0);
+  }
+}
 
 #endif /* SQL_AUDIT_INCLUDED */
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 969e2f2c7e4..004fbb24294 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -55,7 +55,7 @@
 #include <hash.h>
 #include "rpl_filter.h"
 #include "sql_table.h"                          // build_table_filename
-#include "datadict.h"   // dd_frm_type()
+#include "datadict.h"   // dd_frm_is_view()
 #include "sql_hset.h"   // Hash_set
 #ifdef  __WIN__
 #include <io.h>
@@ -167,6 +167,24 @@ Repair_mrg_table_error_handler::handle_condition(THD *,
   Protects table_def_hash, used and unused lists in the
   TABLE_SHARE object, LRU lists of used TABLEs and used
   TABLE_SHAREs, refresh_version and the table id counter.
+  In particular:
+
+  end_of_unused_share
+  last_table_id
+  oldest_unused_share
+  refresh_version
+  table_cache_count
+  table_def_cache
+  table_def_shutdown_in_progress
+  unused_tables
+  TABLE::next
+  TABLE::prev
+  TABLE_SHARE::free_tables
+  TABLE_SHARE::m_flush_tickets
+  TABLE_SHARE::next
+  TABLE_SHARE::prev
+  TABLE_SHARE::ref_count
+  TABLE_SHARE::used_tables
 */
 mysql_mutex_t LOCK_open;
 
@@ -302,18 +320,18 @@ static void check_unused(THD *thd)
   Create a table cache key
 
   SYNOPSIS
-    create_table_def_key()
+    create_tmp_table_def_key()
     thd			Thread handler
     key			Create key here (must be of size MAX_DBKEY_LENGTH)
-    table_list		Table definition
-    tmp_table		Set if table is a tmp table
+    db                  Database name.
+    table_name          Table name.
 
  IMPLEMENTATION
     The table cache_key is created from:
     db_name + \0
     table_name + \0
 
-    if the table is a tmp table, we add the following to make each tmp table
+    additionally we add the following to make each tmp table
     unique on the slave:
 
     4 bytes for master thread id
@@ -323,22 +341,13 @@ static void check_unused(THD *thd)
     Length of key
 */
 
-uint create_table_def_key(THD *thd, char *key,
-                          const TABLE_LIST *table_list,
-                          bool tmp_table)
+uint create_tmp_table_def_key(THD *thd, char *key,
+                              const char *db, const char *table_name)
 {
-  char *db_end= strnmov(key, table_list->db, MAX_DBKEY_LENGTH - 2);
-  *db_end++= '\0';
-  char *table_end= strnmov(db_end, table_list->table_name,
-                           key + MAX_DBKEY_LENGTH - 1 - db_end);
-  *table_end++= '\0';
-  uint key_length= (uint) (table_end-key);
-  if (tmp_table)
-  {
-    int4store(key + key_length, thd->server_id);
-    int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
-    key_length+= TMP_TABLE_KEY_EXTRA;
-  }
+  uint key_length= create_table_def_key(key, db, table_name);
+  int4store(key + key_length, thd->server_id);
+  int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
+  key_length+= TMP_TABLE_KEY_EXTRA;
   return key_length;
 }
 
@@ -561,78 +570,75 @@ static void table_def_unuse_table(TABLE *table)
   table_list		Table that should be opened
   key			Table cache key
   key_length		Length of key
-  db_flags		Flags to open_table_def():
-			OPEN_VIEW
-  error			out: Error code from open_table_def()
+  flags   		operation: what to open table or view
+  hash_value            = my_calc_hash(&table_def_cache, key, key_length)
 
   IMPLEMENTATION
     Get a table definition from the table definition cache.
     If it doesn't exist, create a new from the table definition file.
 
-  NOTES
-    We must have wrlock on LOCK_open when we come here
-    (To be changed later)
-
   RETURN
    0  Error
    #  Share for table
 */
 
-TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
-                             uint key_length, uint db_flags, int *error,
+TABLE_SHARE *get_table_share(THD *thd, const char *db, const char *table_name,
+                             char *key, uint key_length, uint flags,
                              my_hash_value_type hash_value)
 {
   TABLE_SHARE *share;
   DBUG_ENTER("get_table_share");
 
-  *error= 0;
-
-  /*
-    To be able perform any operation on table we should own
-    some kind of metadata lock on it.
-  */
-  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE,
-                                             table_list->db,
-                                             table_list->table_name,
-                                             MDL_SHARED));
+  mysql_mutex_lock(&LOCK_open);
 
   /* Read table definition from cache */
-  if ((share= (TABLE_SHARE*) my_hash_search_using_hash_value(&table_def_cache,
-                                                             hash_value, (uchar*) key, key_length)))
-    goto found;
+  share= (TABLE_SHARE*) my_hash_search_using_hash_value(&table_def_cache,
+                                        hash_value, (uchar*) key, key_length);
 
-  if (!(share= alloc_table_share(table_list, key, key_length)))
+  if (!share)
   {
-    DBUG_RETURN(0);
-  }
+    if (!(share= alloc_table_share(db, table_name, key, key_length)))
+      goto err;
 
-  /*
-    We assign a new table id under the protection of LOCK_open.
-    We do this instead of creating a new mutex
-    and using it for the sole purpose of serializing accesses to a
-    static variable, we assign the table id here. We assign it to the
-    share before inserting it into the table_def_cache to be really
-    sure that it cannot be read from the cache without having a table
-    id assigned.
-
-    CAVEAT. This means that the table cannot be used for
-    binlogging/replication purposes, unless get_table_share() has been
-    called directly or indirectly.
-   */
-  assign_new_table_id(share);
-
-  if (my_hash_insert(&table_def_cache, (uchar*) share))
-  {
-    free_table_share(share);
-    DBUG_RETURN(0);				// return error
-  }
-  if (open_table_def(thd, share, db_flags))
-  {
-    *error= share->error;
-    (void) my_hash_delete(&table_def_cache, (uchar*) share);
-    DBUG_RETURN(0);
-  }
-  share->ref_count++;				// Mark in use
+    /*
+      We assign a new table id under the protection of LOCK_open.
+      We do this instead of creating a new mutex
+      and using it for the sole purpose of serializing accesses to a
+      static variable, we assign the table id here. We assign it to the
+      share before inserting it into the table_def_cache to be really
+      sure that it cannot be read from the cache without having a table
+      id assigned.
+
+      CAVEAT. This means that the table cannot be used for
+      binlogging/replication purposes, unless get_table_share() has been
+      called directly or indirectly.
+     */
+    assign_new_table_id(share);
+
+    if (my_hash_insert(&table_def_cache, (uchar*) share))
+    {
+      free_table_share(share);
+      goto err;
+    }
+    share->ref_count++;                         // Mark in use
+    share->error= OPEN_FRM_OPEN_ERROR;
+    mysql_mutex_lock(&share->LOCK_ha_data);
+    mysql_mutex_unlock(&LOCK_open);
+
+    if (flags & GTS_FORCE_DISCOVERY)
+      ha_discover_table(thd, share); // don't read the frm at all
+    else
+      open_table_def(thd, share, flags | GTS_FORCE_DISCOVERY); // frm or discover
+
+    mysql_mutex_unlock(&share->LOCK_ha_data);
+    mysql_mutex_lock(&LOCK_open);
+
+    if (share->error)
+    {
+      share->ref_count--;
+      (void) my_hash_delete(&table_def_cache, (uchar*) share);
+      goto err;
+    }
 
 #ifdef HAVE_PSI_TABLE_INTERFACE
   share->m_psi= PSI_CALL(get_table_share)(false, share);
@@ -640,25 +646,38 @@ TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
   share->m_psi= NULL;
 #endif
 
-  DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
-                      (ulong) share, share->ref_count));
-  DBUG_RETURN(share);
+    DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
+                        (ulong) share, share->ref_count));
+
+    goto end;
+  }
+
+  /* cannot force discovery of a cached share */
+  DBUG_ASSERT(!(flags & GTS_FORCE_DISCOVERY));
+
+  /* make sure that open_table_def() for this share is not running */
+  mysql_mutex_lock(&share->LOCK_ha_data);
+  mysql_mutex_unlock(&share->LOCK_ha_data);
 
-found:
   /*
      We found an existing table definition. Return it if we didn't get
      an error when reading the table definition from file.
   */
   if (share->error)
   {
-    /* Table definition contained an error */
-    open_table_error(share, share->error, share->open_errno, share->errarg);
-    DBUG_RETURN(0);
+    open_table_error(share, share->error, share->open_errno);
+    goto err;
   }
-  if (share->is_view && !(db_flags & OPEN_VIEW))
+
+  if (share->is_view && !(flags & GTS_VIEW))
   {
-    open_table_error(share, 1, ENOENT, 0);
-    DBUG_RETURN(0);
+    open_table_error(share, OPEN_FRM_NOT_A_TABLE, ENOENT);
+    goto err;
+  }
+  if (!share->is_view && !(flags & GTS_TABLE))
+  {
+    open_table_error(share, OPEN_FRM_NOT_A_VIEW, ENOENT);
+    goto err;
   }
 
   ++share->ref_count;
@@ -683,99 +702,28 @@ found:
 
   DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
                       (ulong) share, share->ref_count));
-  DBUG_RETURN(share);
-}
-
-
-/**
-  Get a table share. If it didn't exist, try creating it from engine
-
-  For arguments and return values, see get_table_share()
-*/
-
-static TABLE_SHARE *
-get_table_share_with_discover(THD *thd, TABLE_LIST *table_list,
-                              char *key, uint key_length,
-                              uint db_flags, int *error,
-                              my_hash_value_type hash_value)
+  goto end;
 
-{
-  TABLE_SHARE *share;
-  bool exists;
-  DBUG_ENTER("get_table_share_with_discover");
-
-  share= get_table_share(thd, table_list, key, key_length, db_flags, error,
-                         hash_value);
-  /*
-    If share is not NULL, we found an existing share.
-
-    If share is NULL, and there is no error, we're inside
-    pre-locking, which silences 'ER_NO_SUCH_TABLE' errors
-    with the intention to silently drop non-existing tables 
-    from the pre-locking list. In this case we still need to try
-    auto-discover before returning a NULL share.
-
-    Or, we're inside SHOW CREATE VIEW, which
-    also installs a silencer for ER_NO_SUCH_TABLE error.
-
-    If share is NULL and the error is ER_NO_SUCH_TABLE, this is
-    the same as above, only that the error was not silenced by
-    pre-locking or SHOW CREATE VIEW.
-
-    In both these cases it won't harm to try to discover the
-    table.
-
-    Finally, if share is still NULL, it's a real error and we need
-    to abort.
-
-    @todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
-  */
-  if (share ||
-      (thd->is_error() && thd->stmt_da->sql_errno() != ER_NO_SUCH_TABLE &&
-       thd->stmt_da->sql_errno() != ER_NO_SUCH_TABLE_IN_ENGINE))
-    DBUG_RETURN(share);
-
-  *error= 0;
+err:
+  mysql_mutex_unlock(&LOCK_open);
+  DBUG_RETURN(0);
 
-  /* Table didn't exist. Check if some engine can provide it */
-  if (ha_check_if_table_exists(thd, table_list->db, table_list->table_name,
-                               &exists))
-  {
-    thd->clear_error();
-    /* Conventionally, the storage engine API does not report errors. */
-    my_error(ER_OUT_OF_RESOURCES, MYF(0));
-  }
-  else if (! exists)
+end:
+  if (flags & GTS_NOLOCK)
   {
+    release_table_share(share);
     /*
-      No such table in any engine.
-      Hide "Table doesn't exist" errors if the table belongs to a view.
-      The check for thd->is_error() is necessary to not push an
-      unwanted error in case the error was already silenced.
-      @todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
+      if GTS_NOLOCK is requested, the returned share pointer cannot be used,
+      the share it points to may go away any moment.
+      But perhaps the caller is only interested to know whether a share or
+      table existed?
+      Let's return an invalid pointer here to catch dereferencing attempts.
     */
-    if (thd->is_error())
-    {
-      if (table_list->parent_l)
-      {
-        thd->clear_error();
-        my_error(ER_WRONG_MRG_TABLE, MYF(0));
-      }
-      else if (table_list->belong_to_view)
-      {
-        TABLE_LIST *view= table_list->belong_to_view;
-        thd->clear_error();
-        my_error(ER_VIEW_INVALID, MYF(0),
-                 view->view_db.str, view->view_name.str);
-      }
-    }
-  }
-  else
-  {
-    thd->clear_error();
-    *error= 7; /* Run auto-discover. */
+    share= (TABLE_SHARE*) 1;
   }
-  DBUG_RETURN(NULL);
+
+  mysql_mutex_unlock(&LOCK_open);
+  DBUG_RETURN(share);
 }
 
 
@@ -843,15 +791,13 @@ void release_table_share(TABLE_SHARE *share)
 TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
 {
   char key[SAFE_NAME_LEN*2+2];
-  TABLE_LIST table_list;
   uint key_length;
   mysql_mutex_assert_owner(&LOCK_open);
 
-  table_list.db= (char*) db;
-  table_list.table_name= (char*) table_name;
-  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
-  return (TABLE_SHARE*) my_hash_search(&table_def_cache,
-                                       (uchar*) key, key_length);
+  key_length= create_table_def_key(key, db, table_name);
+  TABLE_SHARE* share= (TABLE_SHARE*)my_hash_search(&table_def_cache,
+                                                   (uchar*) key, key_length);
+  return !share || share->error ? 0 : share;
 }  
 
 
@@ -1085,7 +1031,7 @@ bool close_cached_tables(THD *thd, TABLE_LIST *tables,
       if (share)
       {
         kill_delayed_threads_for_table(share);
-        /* tdc_remove_table() also sets TABLE_SHARE::version to 0. */
+        /* tdc_remove_table() calls share->remove_from_cache_at_close() */
         tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED, table->db,
                          table->table_name, TRUE);
 	found=1;
@@ -2138,7 +2084,7 @@ TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
 TABLE *find_temporary_table(THD *thd, const TABLE_LIST *tl)
 {
   char key[MAX_DBKEY_LENGTH];
-  uint key_length= create_table_def_key(thd, key, tl, 1);
+  uint key_length= create_tmp_table_def_key(thd, key, tl->db, tl->table_name);
 
   return find_temporary_table(thd, key, key_length);
 }
@@ -2318,15 +2264,12 @@ bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
   char *key;
   uint key_length;
   TABLE_SHARE *share= table->s;
-  TABLE_LIST table_list;
   DBUG_ENTER("rename_temporary_table");
 
   if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
     DBUG_RETURN(1);				/* purecov: inspected */
 
-  table_list.db= (char*) db;
-  table_list.table_name= (char*) table_name;
-  key_length= create_table_def_key(thd, key, &table_list, 1);
+  key_length= create_tmp_table_def_key(thd, key, db, table_name);
   share->set_table_cache_key(key, key_length);
   DBUG_RETURN(0);
 }
@@ -2351,7 +2294,8 @@ bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
 */
 
 bool wait_while_table_is_used(THD *thd, TABLE *table,
-                              enum ha_extra_function function)
+                              enum ha_extra_function function,
+                              enum_tdc_remove_table_type remove_type)
 {
   DBUG_ENTER("wait_while_table_is_used");
   DBUG_PRINT("enter", ("table: '%s'  share: 0x%lx  db_stat: %u  version: %lu",
@@ -2362,7 +2306,7 @@ bool wait_while_table_is_used(THD *thd, TABLE *table,
              table->mdl_ticket, thd->variables.lock_wait_timeout))
     DBUG_RETURN(TRUE);
 
-  tdc_remove_table(thd, TDC_RT_REMOVE_NOT_OWN,
+  tdc_remove_table(thd, remove_type,
                    table->s->db.str, table->s->table_name.str,
                    FALSE);
   /* extra() call must come only after all instances above are closed */
@@ -2415,71 +2359,6 @@ void drop_open_table(THD *thd, TABLE *table, const char *db_name,
 
 
 /**
-    Check that table exists in table definition cache, on disk
-    or in some storage engine.
-
-    @param       thd        Thread context
-    @param       table      Table list element
-    @param       fast_check Check only if share or .frm file exists 
-    @param[out]  exists     Out parameter which is set to TRUE if table
-                            exists and to FALSE otherwise.
-
-    @note This function acquires LOCK_open internally.
-
-    @note If there is no .FRM file for the table but it exists in one
-          of engines (e.g. it was created on another node of NDB cluster)
-          this function will fetch and create proper .FRM file for it.
-
-    @retval  TRUE   Some error occurred
-    @retval  FALSE  No error. 'exists' out parameter set accordingly.
-*/
-
-bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool fast_check,
-                           bool *exists)
-{
-  char path[FN_REFLEN + 1];
-  TABLE_SHARE *share;
-  DBUG_ENTER("check_if_table_exists");
-
-  *exists= TRUE;
-
-  DBUG_ASSERT(fast_check ||
-              thd->mdl_context.
-              is_lock_owner(MDL_key::TABLE, table->db,
-                            table->table_name, MDL_SHARED));
-
-  mysql_mutex_lock(&LOCK_open);
-  share= get_cached_table_share(table->db, table->table_name);
-  mysql_mutex_unlock(&LOCK_open);
-
-  if (share)
-    goto end;
-
-  build_table_filename(path, sizeof(path) - 1, table->db, table->table_name,
-                       reg_ext, 0);
-
-  if (!access(path, F_OK))
-    goto end;
-
-  if (fast_check)
-  {
-    *exists= FALSE;
-    goto end;
-  }
-
-  /* .FRM file doesn't exist. Check if some engine can provide it. */
-  if (ha_check_if_table_exists(thd, table->db, table->table_name, exists))
-  {
-    my_printf_error(ER_OUT_OF_RESOURCES, "Failed to open '%-.64s', error while "
-                    "unpacking from engine", MYF(0), table->table_name);
-    DBUG_RETURN(TRUE);
-  }
-end:
-  DBUG_RETURN(FALSE);
-}
-
-
-/**
   An error handler which converts, if possible, ER_LOCK_DEADLOCK error
   that can occur when we are trying to acquire a metadata lock to
   a request for back-off and re-start of open_tables() process.
@@ -2752,11 +2631,9 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
   char	*alias= table_list->alias;
   uint flags= ot_ctx->get_flags();
   MDL_ticket *mdl_ticket;
-  int error;
   TABLE_SHARE *share;
   my_hash_value_type hash_value;
-  bool recycled_free_table;
-
+  uint gts_flags;
   DBUG_ENTER("open_table");
 
   /* an open table operation needs a lot of the stack space */
@@ -2766,8 +2643,9 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
   if (thd->killed)
     DBUG_RETURN(TRUE);
 
-  key_length= (create_table_def_key(thd, key, table_list, 1) -
-               TMP_TABLE_KEY_EXTRA);
+  key_length= create_tmp_table_def_key(thd, key, table_list->db,
+                                       table_list->table_name) -
+               TMP_TABLE_KEY_EXTRA;
 
   /*
     Unless requested otherwise, try to resolve this table in the list
@@ -2899,7 +2777,6 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
                                        MDL_SHARED))
     {
       char path[FN_REFLEN + 1];
-      enum legacy_db_type not_used;
       build_table_filename(path, sizeof(path) - 1,
                            table_list->db, table_list->table_name, reg_ext, 0);
       /*
@@ -2909,7 +2786,7 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
         during prelocking process (in this case in theory we still
         should hold shared metadata lock on it).
       */
-      if (dd_frm_type(thd, path, &not_used) == FRMTYPE_VIEW)
+      if (dd_frm_is_view(thd, path))
       {
         if (!tdc_open_view(thd, table_list, alias, key, key_length,
                            mem_root, 0))
@@ -2959,12 +2836,12 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
       global read lock until end of this statement in order to have
       this statement blocked by active FLUSH TABLES WITH READ LOCK.
 
-      We don't block acquire this protection under LOCK TABLES as
+      We don't need to acquire this protection under LOCK TABLES as
       such protection already acquired at LOCK TABLES time and
       not released until UNLOCK TABLES.
 
       We don't block statements which modify only temporary tables
-      as these tables are not preserved by backup by any form of
+      as these tables are not preserved by any form of
       backup which uses FLUSH TABLES WITH READ LOCK.
 
       TODO: The fact that we sometimes acquire protection against
@@ -3029,12 +2906,7 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
 
   if (table_list->open_strategy == TABLE_LIST::OPEN_IF_EXISTS)
   {
-    bool exists;
-
-    if (check_if_table_exists(thd, table_list, 0, &exists))
-      DBUG_RETURN(TRUE);
-
-    if (!exists)
+    if (!ha_table_exists(thd, table_list->db, table_list->table_name))
       DBUG_RETURN(FALSE);
 
     /* Table exists. Let us try to open it. */
@@ -3042,26 +2914,40 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
   else if (table_list->open_strategy == TABLE_LIST::OPEN_STUB)
     DBUG_RETURN(FALSE);
 
+  if (table_list->i_s_requested_object & OPEN_TABLE_ONLY)
+    gts_flags= GTS_TABLE;
+  else if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
+    gts_flags= GTS_VIEW;
+  else
+    gts_flags= GTS_TABLE | GTS_VIEW;
+
 retry_share:
 
-  mysql_mutex_lock(&LOCK_open);
+  share= get_table_share(thd, table_list->db, table_list->table_name,
+                         key, key_length, gts_flags, hash_value);
 
-  if (!(share= get_table_share_with_discover(thd, table_list, key,
-                                             key_length, OPEN_VIEW,
-                                             &error,
-                                             hash_value)))
+  if (!share)
   {
-    mysql_mutex_unlock(&LOCK_open);
     /*
-      If thd->is_error() is not set, we either need discover
-      (error == 7), or the error was silenced by the prelocking
-      handler (error == 0), in which case we should skip this
-      table.
+      Hide "Table doesn't exist" errors if the table belongs to a view.
+      The check for thd->is_error() is necessary to not push an
+      unwanted error in case the error was already silenced.
+      @todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
     */
-    if (error == 7 && !thd->is_error())
+    if (thd->is_error())
     {
-      (void) ot_ctx->request_backoff_action(Open_table_context::OT_DISCOVER,
-                                            table_list);
+      if (table_list->parent_l)
+      {
+        thd->clear_error();
+        my_error(ER_WRONG_MRG_TABLE, MYF(0));
+      }
+      else if (table_list->belong_to_view)
+      {
+        TABLE_LIST *view= table_list->belong_to_view;
+        thd->clear_error();
+        my_error(ER_VIEW_INVALID, MYF(0),
+                 view->view_db.str, view->view_name.str);
+      }
     }
     DBUG_RETURN(TRUE);
   }
@@ -3080,7 +2966,7 @@ retry_share:
     if (table_list->parent_l)
     {
       my_error(ER_WRONG_MRG_TABLE, MYF(0));
-      goto err_unlock;
+      goto err_lock;
     }
 
     /*
@@ -3088,13 +2974,7 @@ retry_share:
       that it was a view when the statement was prepared.
     */
     if (check_and_update_table_version(thd, table_list, share))
-      goto err_unlock;
-    if (table_list->i_s_requested_object & OPEN_TABLE_ONLY)
-    {
-      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db,
-               table_list->table_name);
-      goto err_unlock;
-    }
+      goto err_lock;
 
     /* Open view */
     if (open_new_frm(thd, share, alias,
@@ -3103,7 +2983,9 @@ retry_share:
                      READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
                      thd->open_options,
                      0, table_list, mem_root))
-      goto err_unlock;
+      goto err_lock;
+
+    mysql_mutex_lock(&LOCK_open);
 
     /* TODO: Don't free this */
     release_table_share(share);
@@ -3114,21 +2996,9 @@ retry_share:
     DBUG_RETURN(FALSE);
   }
 
-  /*
-    Note that situation when we are trying to open a table for what
-    was a view during previous execution of PS will be handled in by
-    the caller. Here we should simply open our table even if
-    TABLE_LIST::view is true.
-  */
-
-  if (table_list->i_s_requested_object &  OPEN_VIEW_ONLY)
-  {
-    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db,
-             table_list->table_name);
-    goto err_unlock;
-  }
-
-  if (!(flags & MYSQL_OPEN_IGNORE_FLUSH))
+  mysql_mutex_lock(&LOCK_open);
+  if (!(flags & MYSQL_OPEN_IGNORE_FLUSH) ||
+      (share->protected_against_usage() && !(flags & MYSQL_OPEN_FOR_REPAIR)))
   {
     if (share->has_old_version())
     {
@@ -3180,19 +3050,24 @@ retry_share:
   {
     table= share->free_tables.front();
     table_def_use_table(thd, table);
-    recycled_free_table= true;
-    /* We need to release share as we have EXTRA reference to it in our hands. */
+
+    /* Release the share as we hold an extra reference to it */
     release_table_share(share);
+    mysql_mutex_unlock(&LOCK_open);
+
+    DBUG_ASSERT(table->file != NULL);
+    table->file->rebind_psi();
   }
   else
   {
-    /* We have too many TABLE instances around let us try to get rid of them. */
+    enum open_frm_error error;
+
+    /* If we have too many TABLE instances around, try to get rid of them */
     while (table_cache_count > table_cache_size && unused_tables)
       free_cache_entry(unused_tables);
 
     mysql_mutex_unlock(&LOCK_open);
 
-    recycled_free_table= false;
     /* make a new table */
     if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
       goto err_lock;
@@ -3210,7 +3085,7 @@ retry_share:
     {
       my_free(table);
 
-      if (error == 7)
+      if (error == OPEN_FRM_DISCOVER)
         (void) ot_ctx->request_backoff_action(Open_table_context::OT_DISCOVER,
                                               table_list);
       else if (share->crashed)
@@ -3227,18 +3102,10 @@ retry_share:
       goto err_lock;
     }
 
-    mysql_mutex_lock(&LOCK_open);
     /* Add table to the share's used tables list. */
+    mysql_mutex_lock(&LOCK_open);
     table_def_add_used_table(thd, table);
-  }
-
-  mysql_mutex_unlock(&LOCK_open);
-
-  /* Call rebind_psi outside of the LOCK_open critical section. */
-  if (recycled_free_table)
-  {
-    DBUG_ASSERT(table->file != NULL);
-    table->file->rebind_psi();
+    mysql_mutex_unlock(&LOCK_open);
   }
 
   table->mdl_ticket= mdl_ticket;
@@ -3263,7 +3130,6 @@ retry_share:
 
 err_lock:
   mysql_mutex_lock(&LOCK_open);
-err_unlock:
   release_table_share(share);
   mysql_mutex_unlock(&LOCK_open);
 
@@ -3284,7 +3150,7 @@ err_unlock:
 TABLE *find_locked_table(TABLE *list, const char *db, const char *table_name)
 {
   char	key[MAX_DBKEY_LENGTH];
-  uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
+  uint key_length= create_table_def_key(key, db, table_name);
 
   for (TABLE *table= list; table ; table=table->next)
   {
@@ -3892,38 +3758,25 @@ bool tdc_open_view(THD *thd, TABLE_LIST *table_list, const char *alias,
                    MEM_ROOT *mem_root, uint flags)
 {
   TABLE not_used;
-  int error;
-  my_hash_value_type hash_value;
   TABLE_SHARE *share;
 
-  hash_value= my_calc_hash(&table_def_cache, (uchar*) cache_key,
-                           cache_key_length);
-  mysql_mutex_lock(&LOCK_open);
+  if (!(share= get_table_share(thd, table_list->db, table_list->table_name,
+                               cache_key, cache_key_length, GTS_VIEW)))
+    return TRUE;
 
-  if (!(share= get_table_share(thd, table_list, cache_key,
-                               cache_key_length,
-                               OPEN_VIEW, &error,
-                               hash_value)))
-    goto err;
+  DBUG_ASSERT(share->is_view);
 
-  if (share->is_view &&
-      !open_new_frm(thd, share, alias,
-                    (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
-                            HA_GET_INDEX | HA_TRY_READ_ONLY),
-                    READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
-                    flags, thd->open_options, &not_used, table_list,
-                    mem_root))
-  {
-    release_table_share(share);
-    mysql_mutex_unlock(&LOCK_open);
-    return FALSE;
-  }
+  bool err= open_new_frm(thd, share, alias,
+                    (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
+                     HA_GET_INDEX | HA_TRY_READ_ONLY),
+                    READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD | flags,
+                    thd->open_options, &not_used, table_list, mem_root);
 
-  my_error(ER_WRONG_OBJECT, MYF(0), share->db.str, share->table_name.str, "VIEW");
+  mysql_mutex_lock(&LOCK_open);
   release_table_share(share);
-err:
   mysql_mutex_unlock(&LOCK_open);
-  return TRUE;
+
+  return err;
 }
 
 
@@ -3977,40 +3830,20 @@ static bool open_table_entry_fini(THD *thd, TABLE_SHARE *share, TABLE *entry)
 
 static bool auto_repair_table(THD *thd, TABLE_LIST *table_list)
 {
-  char	cache_key[MAX_DBKEY_LENGTH];
-  uint	cache_key_length;
   TABLE_SHARE *share;
   TABLE *entry;
-  int not_used;
   bool result= TRUE;
-  my_hash_value_type hash_value;
-
-  cache_key_length= create_table_def_key(thd, cache_key, table_list, 0);
 
   thd->clear_error();
 
-  hash_value= my_calc_hash(&table_def_cache, (uchar*) cache_key,
-                           cache_key_length);
-  mysql_mutex_lock(&LOCK_open);
+  if (!(entry= (TABLE*)my_malloc(sizeof(TABLE), MYF(MY_WME))))
+    return result;
 
-  if (!(share= get_table_share(thd, table_list, cache_key,
-                               cache_key_length,
-                               OPEN_VIEW, &not_used,
-                               hash_value)))
-    goto end_unlock;
+  if (!(share= get_table_share(thd, table_list->db, table_list->table_name,
+                               GTS_TABLE)))
+    goto end_free;
 
-  if (share->is_view)
-  {
-    release_table_share(share);
-    goto end_unlock;
-  }
-
-  if (!(entry= (TABLE*)my_malloc(sizeof(TABLE), MYF(MY_WME))))
-  {
-    release_table_share(share);
-    goto end_unlock;
-  }
-  mysql_mutex_unlock(&LOCK_open);
+  DBUG_ASSERT(! share->is_view);
 
   if (open_table_from_share(thd, share, table_list->alias,
                             (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
@@ -4035,7 +3868,6 @@ static bool auto_repair_table(THD *thd, TABLE_LIST *table_list)
     closefrm(entry, 0);
     result= FALSE;
   }
-  my_free(entry);
 
   mysql_mutex_lock(&LOCK_open);
   release_table_share(share);
@@ -4043,8 +3875,9 @@ static bool auto_repair_table(THD *thd, TABLE_LIST *table_list)
   tdc_remove_table(thd, TDC_RT_REMOVE_ALL,
                    table_list->db, table_list->table_name,
                    TRUE);
-end_unlock:
   mysql_mutex_unlock(&LOCK_open);
+end_free:
+  my_free(entry);
   return result;
 }
 
@@ -4185,8 +4018,12 @@ recover_from_failed_open(THD *thd)
 
         tdc_remove_table(thd, TDC_RT_REMOVE_ALL, m_failed_table->db,
                          m_failed_table->table_name, FALSE);
-        ha_create_table_from_engine(thd, m_failed_table->db,
-                                    m_failed_table->table_name);
+        if ((result=
+             !get_table_share(thd, m_failed_table->db,
+                              m_failed_table->table_name,
+                              GTS_TABLE | GTS_FORCE_DISCOVERY | GTS_NOLOCK)))
+          break;
+
 
         thd->warning_info->clear_warning_info(thd->query_id);
         thd->clear_error();                 // Clear error message
@@ -4814,7 +4651,7 @@ lock_table_names(THD *thd,
   if (mdl_requests.is_empty())
     DBUG_RETURN(FALSE);
 
-  /* Check if CREATE TABLE IF NOT EXISTS was used */
+  /* Check if CREATE TABLE was used */
   create_table= (tables_start && tables_start->open_strategy ==
                  TABLE_LIST::OPEN_IF_EXISTS);
 
@@ -4853,12 +4690,9 @@ lock_table_names(THD *thd,
 
   for (;;)
   {
-    bool exists= TRUE;
-    bool res;
-
     if (create_table)
       thd->push_internal_handler(&error_handler);  // Avoid warnings & errors
-    res= thd->mdl_context.acquire_locks(&mdl_requests, lock_wait_timeout);
+    bool res= thd->mdl_context.acquire_locks(&mdl_requests, lock_wait_timeout);
     if (create_table)
       thd->pop_internal_handler();
     if (!res)
@@ -4868,13 +4702,10 @@ lock_table_names(THD *thd,
       DBUG_RETURN(TRUE);                        // Return original error
 
     /*
-      We come here in the case of lock timeout when executing
-      CREATE TABLE IF NOT EXISTS.
-      Verify that table really exists (it should as we got a lock conflict)
+      We come here in the case of lock timeout when executing CREATE TABLE.
+      Verify that table does exist (it usually does, as we got a lock conflict)
     */
-    if (check_if_table_exists(thd, tables_start, 1, &exists))
-      DBUG_RETURN(TRUE);                       // Should never happen
-    if (exists)
+    if (ha_table_exists(thd, tables_start->db, tables_start->table_name))
     {
       if (thd->lex->create_info.options & HA_LEX_CREATE_IF_NOT_EXISTS)
       {
@@ -4886,17 +4717,16 @@ lock_table_names(THD *thd,
         my_error(ER_TABLE_EXISTS_ERROR, MYF(0), tables_start->table_name);
       DBUG_RETURN(TRUE);
     }
-    /* purecov: begin inspected */
     /*
-      We got error from acquire_locks but table didn't exists.
-      In theory this should never happen, except maybe in
-      CREATE or DROP DATABASE scenario.
+      We got error from acquire_locks, but the table didn't exists.
+      This could happen if another connection runs a statement
+      involving this non-existent table, and this statement took the mdl,
+      but didn't error out with ER_NO_SUCH_TABLE yet (yes, a race condition).
       We play safe and restart the original acquire_locks with the
-      original timeout
+      original timeout.
     */
     create_table= 0;
     lock_wait_timeout= org_lock_wait_timeout;
-    /* purecov: end */
   }
 }
 
@@ -6119,6 +5949,8 @@ void close_tables_for_reopen(THD *thd, TABLE_LIST **tables,
   the opened TABLE instance will be addded to THD::temporary_tables list.
 
   @param thd                          Thread context.
+  @param hton                         Storage engine of the table, if known,
+                                      or NULL otherwise.
   @param path                         Path (without .frm)
   @param db                           Database name.
   @param table_name                   Table name.
@@ -6134,7 +5966,8 @@ void close_tables_for_reopen(THD *thd, TABLE_LIST **tables,
   @retval NULL on error.
 */
 
-TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
+TABLE *open_table_uncached(THD *thd, handlerton *hton,
+                           const char *path, const char *db,
                            const char *table_name,
                            bool add_to_temporary_tables_list)
 {
@@ -6142,7 +5975,6 @@ TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
   TABLE_SHARE *share;
   char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
   uint key_length;
-  TABLE_LIST table_list;
   DBUG_ENTER("open_table_uncached");
   DBUG_PRINT("enter",
              ("table: '%s'.'%s'  path: '%s'  server_id: %u  "
@@ -6150,10 +5982,8 @@ TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
               db, table_name, path,
               (uint) thd->server_id, (ulong) thd->variables.pseudo_thread_id));
 
-  table_list.db=         (char*) db;
-  table_list.table_name= (char*) table_name;
   /* Create the cache_key for temporary tables */
-  key_length= create_table_def_key(thd, cache_key, &table_list, 1);
+  key_length= create_tmp_table_def_key(thd, cache_key, db, table_name);
 
   if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
                                       strlen(path)+1 + key_length,
@@ -6167,8 +5997,9 @@ TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
 
   init_tmp_table_share(thd, share, saved_cache_key, key_length,
                        strend(saved_cache_key)+1, tmp_path);
+  share->db_plugin= ha_lock_engine(thd, hton);
 
-  if (open_table_def(thd, share, 0))
+  if (open_table_def(thd, share, GTS_TABLE | GTS_FORCE_DISCOVERY))
   {
     /* No need to lock share->mutex as this is not needed for tmp tables */
     free_table_share(share);
@@ -6217,17 +6048,27 @@ TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
 }
 
 
-bool rm_temporary_table(handlerton *base, char *path)
+/**
+  Delete a temporary table.
+
+  @param base  Handlerton for table to be deleted.
+  @param path  Path to the table to be deleted (i.e. path
+               to its .frm without an extension).
+
+  @retval false - success.
+  @retval true  - failure.
+*/
+
+bool rm_temporary_table(handlerton *base, const char *path)
 {
   bool error=0;
   handler *file;
-  char *ext;
+  char frm_path[FN_REFLEN + 1];
   DBUG_ENTER("rm_temporary_table");
 
-  strmov(ext= strend(path), reg_ext);
-  if (mysql_file_delete(key_file_frm, path, MYF(0)))
+  strxnmov(frm_path, sizeof(frm_path) - 1, path, reg_ext, NullS);
+  if (mysql_file_delete(key_file_frm, frm_path, MYF(0)))
     error=1; /* purecov: inspected */
-  *ext= 0;				// remove extension
   file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
   if (file && file->ha_delete_table(path))
   {
@@ -8173,7 +8014,8 @@ bool setup_fields(THD *thd, Item **ref_pointer_array,
   thd->mark_used_columns= mark_used_columns;
   DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns));
   if (allow_sum_func)
-    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
+    thd->lex->allow_sum_func|=
+      (nesting_map)1 << thd->lex->current_select->nest_level;
   thd->where= THD::DEFAULT_WHERE;
   save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
   thd->lex->current_select->is_item_list_lookup= 0;
@@ -9283,15 +9125,10 @@ my_bool mysql_rm_tmp_tables(void)
 
     /* Remove all SQLxxx tables from directory */
 
-    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
+    for (idx=0 ; idx < (uint) dirp->number_of_files ; idx++)
     {
       file=dirp->dir_entry+idx;
 
-      /* skiping . and .. */
-      if (file->name[0] == '.' && (!file->name[1] ||
-                                   (file->name[1] == '.' &&  !file->name[2])))
-        continue;
-
       if (!memcmp(file->name, tmp_file_prefix,
                   tmp_file_prefix_length))
       {
@@ -9307,7 +9144,7 @@ my_bool mysql_rm_tmp_tables(void)
           memcpy(filePathCopy, filePath, filePath_len - ext_len);
           filePathCopy[filePath_len - ext_len]= 0;
           init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
-          if (!open_table_def(thd, &share, 0) &&
+          if (!open_table_def(thd, &share) &&
               ((handler_file= get_new_handler(&share, thd->mem_root,
                                               share.db_type()))))
           {
@@ -9462,6 +9299,7 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
   TABLE *table;
   TABLE_SHARE *share;
   DBUG_ENTER("tdc_remove_table");
+  DBUG_PRINT("enter",("name: %s  remove_type: %d", table_name, remove_type));
 
   if (! has_lock)
     mysql_mutex_lock(&LOCK_open);
@@ -9474,7 +9312,7 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
               thd->mdl_context.is_lock_owner(MDL_key::TABLE, db, table_name,
                                              MDL_EXCLUSIVE));
 
-  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
+  key_length= create_table_def_key(key, db, table_name);
 
   if ((share= (TABLE_SHARE*) my_hash_search(&table_def_cache,(uchar*) key,
                                             key_length)))
@@ -9487,7 +9325,8 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
       {
         DBUG_ASSERT(share->used_tables.is_empty());
       }
-      else if (remove_type == TDC_RT_REMOVE_NOT_OWN)
+      else if (remove_type == TDC_RT_REMOVE_NOT_OWN ||
+               remove_type == TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE)
       {
         I_P_List_iterator<TABLE, TABLE_share> it2(share->used_tables);
         while ((table= it2++))
@@ -9498,8 +9337,8 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
       }
 #endif
       /*
-        Set share's version to zero in order to ensure that it gets
-        automatically deleted once it is no longer referenced.
+        Mark share to ensure that it gets automatically deleted once
+        it is no longer referenced.
 
         Note that code in TABLE_SHARE::wait_for_old_version() assumes
         that marking share as old and removal of its unused tables
@@ -9508,7 +9347,13 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
         TDC does not contain old shares which don't have any tables
         used.
       */
-      share->version= 0;
+      if (remove_type == TDC_RT_REMOVE_NOT_OWN)
+        share->remove_from_cache_at_close();
+      else
+      {
+        /* Ensure that no can open the table while it's used */
+        share->protect_against_usage();
+      }
 
       while ((table= it++))
         free_cache_entry(table);
@@ -9552,7 +9397,6 @@ int init_ftfuncs(THD *thd, SELECT_LEX *select_lex, bool no_order)
     List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
     Item_func_match *ifm;
     DBUG_PRINT("info",("Performing FULLTEXT search"));
-    THD_STAGE_INFO(thd, stage_fulltext_initialization);
 
     while ((ifm=li++))
       ifm->init_search(no_order);
@@ -9588,12 +9432,14 @@ open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
 {
   LEX_STRING pathstr;
   File_parser *parser;
-  char path[FN_REFLEN];
+  char path[FN_REFLEN+1];
   DBUG_ENTER("open_new_frm");
 
   /* Create path with extension */
-  pathstr.length= (uint) (strxmov(path, share->normalized_path.str, reg_ext,
-                                  NullS)- path);
+  pathstr.length= (uint) (strxnmov(path, sizeof(path) - 1,
+                                   share->normalized_path.str,
+                                   reg_ext,
+                                   NullS) - path);
   pathstr.str=    path;
 
   if ((parser= sql_parse_prepare(&pathstr, mem_root, 1)))
diff --git a/sql/sql_base.h b/sql/sql_base.h
index 78ab8c7df24..95d9bf21fe8 100644
--- a/sql/sql_base.h
+++ b/sql/sql_base.h
@@ -60,7 +60,8 @@ enum find_item_error_report_type {REPORT_ALL_ERRORS, REPORT_EXCEPT_NOT_FOUND,
                                   IGNORE_EXCEPT_NON_UNIQUE};
 
 enum enum_tdc_remove_table_type {TDC_RT_REMOVE_ALL, TDC_RT_REMOVE_NOT_OWN,
-                                 TDC_RT_REMOVE_UNUSED};
+                                 TDC_RT_REMOVE_UNUSED,
+                                 TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE};
 
 /* bits for last argument to remove_table_from_cache() */
 #define RTFC_NO_FLAG                0x0000
@@ -68,6 +69,8 @@ enum enum_tdc_remove_table_type {TDC_RT_REMOVE_ALL, TDC_RT_REMOVE_NOT_OWN,
 #define RTFC_WAIT_OTHER_THREAD_FLAG 0x0002
 #define RTFC_CHECK_KILLED_FLAG      0x0004
 
+extern HASH table_def_cache;
+
 bool check_dup(const char *db, const char *name, TABLE_LIST *tables);
 extern mysql_mutex_t LOCK_open;
 bool table_cache_init(void);
@@ -78,15 +81,59 @@ void table_def_start_shutdown(void);
 void assign_new_table_id(TABLE_SHARE *share);
 uint cached_open_tables(void);
 uint cached_table_definitions(void);
-uint create_table_def_key(THD *thd, char *key,
-                          const TABLE_LIST *table_list,
-                          bool tmp_table);
-TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
-                             uint key_length, uint db_flags, int *error,
+
+/**
+  Create a table cache key for non-temporary table.
+
+  @param key         Buffer for key (must be at least NAME_LEN*2+2 bytes).
+  @param db          Database name.
+  @param table_name  Table name.
+
+  @return Length of key.
+
+  @sa create_table_def_key(thd, char *, table_list, bool)
+*/
+
+inline uint
+create_table_def_key(char *key, const char *db, const char *table_name)
+{
+  /*
+    In theory caller should ensure that both db and table_name are
+    not longer than NAME_LEN bytes. In practice we play safe to avoid
+    buffer overruns.
+  */
+  return (uint)(strmake(strmake(key, db, NAME_LEN) + 1, table_name,
+                        NAME_LEN) - key + 1);
+}
+
+uint create_tmp_table_def_key(THD *thd, char *key, const char *db,
+                              const char *table_name);
+TABLE_SHARE *get_table_share(THD *thd, const char *db, const char *table_name,
+                             char *key, uint key_length, uint flags,
                              my_hash_value_type hash_value);
 void release_table_share(TABLE_SHARE *share);
 TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name);
 
+// convenience helper: call get_table_share() without precomputed hash_value
+static inline TABLE_SHARE *get_table_share(THD *thd, const char *db,
+                                           const char *table_name,
+                                           char *key, uint key_length,
+                                           uint flags)
+{
+  return get_table_share(thd, db, table_name, key, key_length, flags,
+                my_calc_hash(&table_def_cache, (uchar*) key, key_length));
+}
+
+// convenience helper: call get_table_share() without precomputed cache key
+static inline TABLE_SHARE *get_table_share(THD *thd, const char *db,
+                                           const char *table_name, uint flags)
+{
+  char	key[MAX_DBKEY_LENGTH];
+  uint	key_length;
+  key_length= create_table_def_key(key, db, table_name);
+  return get_table_share(thd, db, table_name, key, key_length, flags);
+}
+
 TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update,
                    uint lock_flags);
 
@@ -128,6 +175,7 @@ TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update,
 */
 #define MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK         0x1000
 #define MYSQL_LOCK_NOT_TEMPORARY		0x2000
+#define MYSQL_OPEN_FOR_REPAIR                   0x4000
 
 /** Please refer to the internals manual. */
 #define MYSQL_OPEN_REOPEN  (MYSQL_OPEN_IGNORE_FLUSH |\
@@ -147,8 +195,8 @@ bool open_new_frm(THD *thd, TABLE_SHARE *share, const char *alias,
 
 bool get_key_map_from_key_list(key_map *map, TABLE *table,
                                List<String> *index_list);
-TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
-			   const char *table_name,
+TABLE *open_table_uncached(THD *thd, handlerton *hton, const char *path,
+                           const char *db, const char *table_name,
                            bool add_to_temporary_tables_list);
 TABLE *find_locked_table(TABLE *list, const char *db, const char *table_name);
 TABLE *find_write_locked_table(TABLE *list, const char *db,
@@ -158,7 +206,7 @@ thr_lock_type read_lock_type_for_table(THD *thd,
                                        TABLE_LIST *table_list);
 
 my_bool mysql_rm_tmp_tables(void);
-bool rm_temporary_table(handlerton *base, char *path);
+bool rm_temporary_table(handlerton *base, const char *path);
 void close_tables_for_reopen(THD *thd, TABLE_LIST **tables,
                              const MDL_savepoint &start_of_statement_svp);
 TABLE_LIST *find_table_in_list(TABLE_LIST *table,
@@ -229,7 +277,9 @@ bool setup_tables_and_check_access(THD *thd,
                                    ulong want_access,
                                    bool full_table_list);
 bool wait_while_table_is_used(THD *thd, TABLE *table,
-                              enum ha_extra_function function);
+                              enum ha_extra_function function,
+                              enum_tdc_remove_table_type remove_type=
+                              TDC_RT_REMOVE_NOT_OWN);
 
 void drop_open_table(THD *thd, TABLE *table, const char *db_name,
                      const char *table_name);
@@ -298,13 +348,23 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
 bool tdc_open_view(THD *thd, TABLE_LIST *table_list, const char *alias,
                    char *cache_key, uint cache_key_length,
                    MEM_ROOT *mem_root, uint flags);
+
+static inline bool tdc_open_view(THD *thd, TABLE_LIST *table_list,
+                                 const char *alias, MEM_ROOT *mem_root,
+                                 uint flags)
+{
+  char key[MAX_DBKEY_LENGTH];
+  uint key_length;
+  key_length= create_table_def_key(key, table_list->db, table_list->table_name);
+  return tdc_open_view(thd, table_list, alias, key, key_length, mem_root, flags);
+}
+
 void tdc_flush_unused_tables();
 TABLE *find_table_for_mdl_upgrade(THD *thd, const char *db,
                                   const char *table_name,
                                   bool no_error);
 void mark_tmp_table_for_reuse(TABLE *table);
-bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool fast_check,
-                           bool *exists);
+
 int update_virtual_fields(THD *thd, TABLE *table,
       enum enum_vcol_update_mode vcol_update_mode= VCOL_UPDATE_FOR_READ);
 int dynamic_column_error_message(enum_dyncol_func_result rc);
@@ -321,7 +381,6 @@ extern TABLE *unused_tables;
 extern Item **not_found_item;
 extern Field *not_found_field;
 extern Field *view_ref_found;
-extern HASH table_def_cache;
 
 /**
   clean/setup table fields and map.
diff --git a/sql/sql_bitmap.h b/sql/sql_bitmap.h
index db4c7110ac7..5e86a889053 100644
--- a/sql/sql_bitmap.h
+++ b/sql/sql_bitmap.h
@@ -1,4 +1,5 @@
-/* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2003, 2010, Oracle and/or its affiliates
+   Copyright (c) 2009, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -60,7 +61,7 @@ public:
     intersect(map2buff);
     if (map.n_bits > sizeof(ulonglong) * 8)
       bitmap_set_above(&map, sizeof(ulonglong),
-                       test(map2buff & (LL(1) << (sizeof(ulonglong) * 8 - 1))));
+                       test(map2buff & (1LL << (sizeof(ulonglong) * 8 - 1))));
   }
   void subtract(Bitmap& map2) { bitmap_subtract(&map, &map2.map); }
   void merge(Bitmap& map2) { bitmap_union(&map, &map2.map); }
diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index f5e1deab546..ba204f48978 100644
--- a/sql/sql_cache.cc
+++ b/sql/sql_cache.cc
@@ -834,18 +834,18 @@ void Query_cache_block::destroy()
   DBUG_VOID_RETURN;
 }
 
-inline uint Query_cache_block::headers_len()
+uint Query_cache_block::headers_len()
 {
   return (ALIGN_SIZE(sizeof(Query_cache_block_table)*n_tables) +
 	  ALIGN_SIZE(sizeof(Query_cache_block)));
 }
 
-inline uchar* Query_cache_block::data(void)
+uchar* Query_cache_block::data(void)
 {
   return (uchar*)( ((uchar*)this) + headers_len() );
 }
 
-inline Query_cache_query * Query_cache_block::query()
+Query_cache_query * Query_cache_block::query()
 {
 #ifndef DBUG_OFF
   if (type != QUERY)
@@ -854,7 +854,7 @@ inline Query_cache_query * Query_cache_block::query()
   return (Query_cache_query *) data();
 }
 
-inline Query_cache_table * Query_cache_block::table()
+Query_cache_table * Query_cache_block::table()
 {
 #ifndef DBUG_OFF
   if (type != TABLE)
@@ -863,7 +863,7 @@ inline Query_cache_table * Query_cache_block::table()
   return (Query_cache_table *) data();
 }
 
-inline Query_cache_result * Query_cache_block::result()
+Query_cache_result * Query_cache_block::result()
 {
 #ifndef DBUG_OFF
   if (type != RESULT && type != RES_CONT && type != RES_BEG &&
@@ -873,7 +873,7 @@ inline Query_cache_result * Query_cache_block::result()
   return (Query_cache_result *) data();
 }
 
-inline Query_cache_block_table * Query_cache_block::table(TABLE_COUNTER_TYPE n)
+Query_cache_block_table * Query_cache_block::table(TABLE_COUNTER_TYPE n)
 {
   return ((Query_cache_block_table *)
 	  (((uchar*)this)+ALIGN_SIZE(sizeof(Query_cache_block)) +
@@ -3132,8 +3132,8 @@ void Query_cache::invalidate_table(THD *thd, TABLE_LIST *table_list)
     char key[MAX_DBKEY_LENGTH];
     uint key_length;
 
-    key_length=(uint) (strmov(strmov(key,table_list->db)+1,
-			      table_list->table_name) -key)+ 1;
+    key_length= create_table_def_key(key, table_list->db,
+                                     table_list->table_name);
 
     // We don't store temporary tables => no key_length+=4 ...
     invalidate_table(thd, (uchar *)key, key_length);
@@ -3251,8 +3251,8 @@ Query_cache::register_tables_from_list(THD *thd, TABLE_LIST *tables_used,
       DBUG_PRINT("qcache", ("view: %s  db: %s",
                             tables_used->view_name.str,
                             tables_used->view_db.str));
-      key_length= (uint) (strmov(strmov(key, tables_used->view_db.str) + 1,
-                                 tables_used->view_name.str) - key) + 1;
+      key_length= create_table_def_key(key, tables_used->view_db.str,
+                                       tables_used->view_name.str);
       /*
         There are not callback function for for VIEWs
       */
@@ -4297,14 +4297,13 @@ my_bool Query_cache::move_by_type(uchar **border,
   case Query_cache_block::RESULT:
   {
     DBUG_PRINT("qcache", ("block 0x%lx RES* (%d)", (ulong) block,
-			(int) block->type));
+               (int) block->type));
     if (*border == 0)
       break;
-    Query_cache_block *query_block = block->result()->parent(),
-		      *next = block->next,
-		      *prev = block->prev;
-    Query_cache_block::block_type type = block->type;
+    Query_cache_block *query_block= block->result()->parent();
     BLOCK_LOCK_WR(query_block);
+    Query_cache_block *next= block->next, *prev= block->prev;
+    Query_cache_block::block_type type= block->type;
     ulong len = block->length, used = block->used;
     Query_cache_block *pprev = block->pprev,
 		      *pnext = block->pnext,
@@ -4466,8 +4465,9 @@ uint Query_cache::filename_2_table_key (char *key, const char *path,
   *db_length= (filename - dbname) - 1;
   DBUG_PRINT("qcache", ("table '%-.*s.%s'", *db_length, dbname, filename));
 
-  DBUG_RETURN((uint) (strmov(strmake(key, dbname, *db_length) + 1,
-			     filename) -key) + 1);
+  DBUG_RETURN((uint) (strmake(strmake(key, dbname,
+                                      min(*db_length, NAME_LEN)) + 1,
+                              filename, NAME_LEN) - key) + 1);
 }
 
 /****************************************************************************
diff --git a/sql/sql_cache.h b/sql/sql_cache.h
index 7444d444cf9..f35ac889b23 100644
--- a/sql/sql_cache.h
+++ b/sql/sql_cache.h
@@ -141,12 +141,12 @@ struct Query_cache_block
   inline bool is_free(void) { return type == FREE; }
   void init(ulong length);
   void destroy();
-  inline uint headers_len();
-  inline uchar* data(void);
-  inline Query_cache_query *query();
-  inline Query_cache_table *table();
-  inline Query_cache_result *result();
-  inline Query_cache_block_table *table(TABLE_COUNTER_TYPE n);
+  uint headers_len();
+  uchar* data(void);
+  Query_cache_query *query();
+  Query_cache_table *table();
+  Query_cache_result *result();
+  Query_cache_block_table *table(TABLE_COUNTER_TYPE n);
 };
 
 struct Query_cache_query
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index a068cdc8f88..240c4e4d627 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2008, 2012, Monty Program Ab
+   Copyright (c) 2008, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -112,7 +112,8 @@ Key::Key(const Key &rhs, MEM_ROOT *mem_root)
   columns(rhs.columns, mem_root),
   name(rhs.name),
   option_list(rhs.option_list),
-  generated(rhs.generated)
+  generated(rhs.generated),
+  create_if_not_exists(rhs.create_if_not_exists)
 {
   list_copy_and_replace_each_value(columns, mem_root);
 }
@@ -350,29 +351,6 @@ void thd_set_thread_stack(THD *thd, char *stack_start)
 }
 
 /**
-  Lock connection data for the set of connections this connection
-  belongs to
-
-  @param thd                       THD object
-*/
-void thd_lock_thread_count(THD *)
-{
-  mysql_mutex_lock(&LOCK_thread_count);
-}
-
-/**
-  Lock connection data for the set of connections this connection
-  belongs to
-
-  @param thd                       THD object
-*/
-void thd_unlock_thread_count(THD *)
-{
-  mysql_cond_broadcast(&COND_thread_count);
-  mysql_mutex_unlock(&LOCK_thread_count);
-}
-
-/**
   Close the socket used by this connection
 
   @param thd                THD object
@@ -908,6 +886,7 @@ THD::THD()
   col_access=0;
   is_slave_error= thread_specific_used= FALSE;
   my_hash_clear(&handler_tables_hash);
+  my_hash_clear(&ull_hash);
   tmp_table=0;
   cuted_fields= 0L;
   m_sent_row_count= 0L;
@@ -947,7 +926,6 @@ THD::THD()
   net.vio=0;
   net.buff= 0;
   client_capabilities= 0;                       // minimalistic client
-  ull=0;
   system_thread= NON_SYSTEM_THREAD;
   cleanup_done= abort_on_warning= 0;
   peer_port= 0;					// For SHOW PROCESSLIST
@@ -1005,7 +983,14 @@ THD::THD()
   protocol_binary.init(this);
 
   tablespace_op=FALSE;
-  tmp= sql_rnd_with_mutex();
+
+  /*
+    Initialize the random generator. We call my_rnd() without a lock as
+    it's not really critical if two threads modifies the structure at the
+    same time.  We ensure that we have an unique number foreach thread
+    by adding the address of the stack.
+  */
+  tmp= (ulong) (my_rnd(&sql_rand) * 0xffffffff);
   my_rnd_init(&rand, tmp + (ulong) &rand, tmp + (ulong) ::global_query_id);
   substitute_null_with_insert_id = FALSE;
   thr_lock_info_init(&lock_info); /* safety: will be reset after start */
@@ -1260,8 +1245,8 @@ LEX_STRING *thd_make_lex_string(THD *thd, LEX_STRING *lex_str,
                                 const char *str, unsigned int size,
                                 int allocate_lex_string)
 {
-  return thd->make_lex_string(lex_str, str, size,
-                              (bool) allocate_lex_string);
+  return allocate_lex_string ? thd->make_lex_string(str, size)
+                             : thd->make_lex_string(lex_str, str, size);
 }
 
 extern "C"
@@ -1452,11 +1437,12 @@ void THD::cleanup(void)
 #error xid_state in the cache should be replaced by the allocated value
   }
 #endif
-  {
-    transaction.xid_state.xa_state= XA_NOTR;
-    trans_rollback(this);
-    xid_cache_delete(&transaction.xid_state);
-  }
+
+  close_temporary_tables(this);
+
+  transaction.xid_state.xa_state= XA_NOTR;
+  trans_rollback(this);
+  xid_cache_delete(&transaction.xid_state);
 
   locked_tables_list.unlock_locked_tables(this);
   mysql_ha_cleanup(this);
@@ -1474,8 +1460,6 @@ void THD::cleanup(void)
   if (global_read_lock.is_acquired())
     global_read_lock.unlock_global_read_lock(this);
 
-  /* All metadata locks must have been released by now. */
-  DBUG_ASSERT(!mdl_context.has_locks());
   if (user_connect)
   {
     decrease_user_connections(user_connect);
@@ -1490,17 +1474,12 @@ void THD::cleanup(void)
 
   delete_dynamic(&user_var_events);
   my_hash_free(&user_vars);
-  close_temporary_tables(this);
   sp_cache_clear(&sp_proc_cache);
   sp_cache_clear(&sp_func_cache);
 
-  if (ull)
-  {
-    mysql_mutex_lock(&LOCK_user_locks);
-    item_user_lock_release(ull);
-    mysql_mutex_unlock(&LOCK_user_locks);
-    ull= NULL;
-  }
+  mysql_ull_cleanup(this);
+  /* All metadata locks must have been released by now. */
+  DBUG_ASSERT(!mdl_context.has_locks());
 
   apc_target.destroy();
   cleanup_done=1;
@@ -1935,6 +1914,19 @@ void THD::cleanup_after_query()
     stmt_depends_on_first_successful_insert_id_in_prev_stmt= 0;
     auto_inc_intervals_in_cur_stmt_for_binlog.empty();
     rand_used= 0;
+#ifndef EMBEDDED_LIBRARY
+    /*
+      Clean possible unused INSERT_ID events by current statement.
+      is_update_query() is needed to ignore SET statements:
+        Statements that don't update anything directly and don't
+        used stored functions. This is mostly necessary to ignore
+        statements in binlog between SET INSERT_ID and DML statement
+        which is intended to consume its event (there can be other
+        SET statements between them).
+    */
+    if ((rli_slave || rli_fake) && is_update_query(lex->sql_command))
+      auto_inc_intervals_forced.empty();
+#endif
   }
   if (first_successful_insert_id_in_cur_stmt > 0)
   {
@@ -1962,30 +1954,6 @@ void THD::cleanup_after_query()
 }
 
 
-/**
-  Create a LEX_STRING in this connection.
-
-  @param lex_str  pointer to LEX_STRING object to be initialized
-  @param str      initializer to be copied into lex_str
-  @param length   length of str, in bytes
-  @param allocate_lex_string  if TRUE, allocate new LEX_STRING object,
-                              instead of using lex_str value
-  @return  NULL on failure, or pointer to the LEX_STRING object
-*/
-LEX_STRING *THD::make_lex_string(LEX_STRING *lex_str,
-                                 const char* str, uint length,
-                                 bool allocate_lex_string)
-{
-  if (allocate_lex_string)
-    if (!(lex_str= (LEX_STRING *)alloc_root(mem_root, sizeof(LEX_STRING))))
-      return 0;
-  if (!(lex_str->str= strmake_root(mem_root, str, length)))
-    return 0;
-  lex_str->length= length;
-  return lex_str;
-}
-
-
 /*
   Convert a string to another character set
 
@@ -3196,42 +3164,13 @@ int select_exists_subselect::send_data(List<Item> &items)
 int select_dumpvar::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
 {
   unit= u;
-  List_iterator_fast<my_var> var_li(var_list);
-  List_iterator_fast<Item> it(list);
-  Item *item;
-  my_var *mv;
-  Item_func_set_user_var **suv;
   
   if (var_list.elements != list.elements)
   {
     my_message(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT,
                ER(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT), MYF(0));
     return 1;
-  }
-
-  /*
-    Iterate over the destination variables and mark them as being
-    updated in this query.
-    We need to do this at JOIN::prepare time to ensure proper
-    const detection of Item_func_get_user_var that is determined
-    by the presence of Item_func_set_user_vars
-  */
-
-  suv= set_var_items= (Item_func_set_user_var **) 
-    sql_alloc(sizeof(Item_func_set_user_var *) * list.elements);
-
-  while ((mv= var_li++) && (item= it++))
-  {
-    if (!mv->local)
-    {
-      *suv= new Item_func_set_user_var(mv->s, item);
-      (*suv)->fix_fields(thd, 0);
-    }
-    else
-      *suv= NULL;
-    suv++;
-  }
-
+  }               
   return 0;
 }
 
@@ -3561,7 +3500,6 @@ int select_dumpvar::send_data(List<Item> &items)
   List_iterator<Item> it(items);
   Item *item;
   my_var *mv;
-  Item_func_set_user_var **suv;
   DBUG_ENTER("select_dumpvar::send_data");
 
   if (unit->offset_limit_cnt)
@@ -3574,19 +3512,20 @@ int select_dumpvar::send_data(List<Item> &items)
     my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
     DBUG_RETURN(1);
   }
-  for (suv= set_var_items; ((mv= var_li++) && (item= it++)); suv++)
+  while ((mv= var_li++) && (item= it++))
   {
     if (mv->local)
     {
-      DBUG_ASSERT(!*suv);
       if (thd->spcont->set_variable(thd, mv->offset, &item))
 	    DBUG_RETURN(1);
     }
     else
     {
-      DBUG_ASSERT(*suv);
-      (*suv)->save_item_result(item);
-      if ((*suv)->update())
+      Item_func_set_user_var *suv= new Item_func_set_user_var(mv->s, item);
+      suv->save_item_result(item);
+      if (suv->fix_fields(thd, 0))
+        DBUG_RETURN (1);
+      if (suv->update())
         DBUG_RETURN (1);
     }
   }
@@ -4117,6 +4056,15 @@ extern "C" unsigned long thd_get_thread_id(const MYSQL_THD thd)
 }
 
 
+/**
+  Check if THD socket is still connected.
+ */
+extern "C" int thd_is_connected(MYSQL_THD thd)
+{
+  return thd->is_connected();
+}
+
+
 #ifdef INNODB_COMPATIBILITY_HOOKS
 extern "C" const struct charset_info_st *thd_charset(MYSQL_THD thd)
 {
@@ -4541,17 +4489,8 @@ void THD::set_query_and_id(char *query_arg, uint32 query_length_arg,
 {
   mysql_mutex_lock(&LOCK_thd_data);
   set_query_inner(query_arg, query_length_arg, cs);
-  query_id= new_query_id;
   mysql_mutex_unlock(&LOCK_thd_data);
-}
-
-/** Assign a new value to thd->query_id.  */
-
-void THD::set_query_id(query_id_t new_query_id)
-{
-  mysql_mutex_lock(&LOCK_thd_data);
   query_id= new_query_id;
-  mysql_mutex_unlock(&LOCK_thd_data);
 }
 
 /** Assign a new value to thd->mysys_var.  */
@@ -4585,6 +4524,8 @@ void THD::leave_locked_tables_mode()
     /* Also ensure that we don't release metadata locks for open HANDLERs. */
     if (handler_tables_hash.records)
       mysql_ha_set_explicit_lock_duration(this);
+    if (ull_hash.records)
+      mysql_ull_set_explicit_lock_duration(this);
   }
   locked_tables_mode= LTM_NONE;
 }
@@ -4721,9 +4662,14 @@ bool xid_cache_insert(XID *xid, enum xa_states xa_state)
 bool xid_cache_insert(XID_STATE *xid_state)
 {
   mysql_mutex_lock(&LOCK_xid_cache);
-  DBUG_ASSERT(my_hash_search(&xid_cache, xid_state->xid.key(),
-                             xid_state->xid.key_length())==0);
-  my_bool res=my_hash_insert(&xid_cache, (uchar*)xid_state);
+  if (my_hash_search(&xid_cache, xid_state->xid.key(),
+      xid_state->xid.key_length()))
+  {
+    mysql_mutex_unlock(&LOCK_xid_cache);
+    my_error(ER_XAER_DUPID, MYF(0));
+    return true;
+  }
+  bool res= my_hash_insert(&xid_cache, (uchar*)xid_state);
   mysql_mutex_unlock(&LOCK_xid_cache);
   return res;
 }
@@ -4838,7 +4784,7 @@ void xid_cache_delete(XID_STATE *xid_state)
 int THD::decide_logging_format(TABLE_LIST *tables)
 {
   DBUG_ENTER("THD::decide_logging_format");
-  DBUG_PRINT("info", ("query: %s", query()));
+  DBUG_PRINT("info", ("Query: %s", query()));
   DBUG_PRINT("info", ("variables.binlog_format: %lu",
                       variables.binlog_format));
   DBUG_PRINT("info", ("lex->get_stmt_unsafe_flags(): 0x%x",
diff --git a/sql/sql_class.h b/sql/sql_class.h
index fccca9e8cbf..afe6b831466 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2009, 2012, Monty Program Ab
+   Copyright (c) 2009, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -69,7 +69,6 @@ class Lex_input_stream;
 class Parser_state;
 class Rows_log_event;
 class Sroutine_hash_entry;
-class User_level_lock;
 class user_var_entry;
 
 enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
@@ -87,38 +86,38 @@ enum enum_mark_columns
 enum enum_filetype { FILETYPE_CSV, FILETYPE_XML };
 
 /* Bits for different SQL modes modes (including ANSI mode) */
-#define MODE_REAL_AS_FLOAT              1
-#define MODE_PIPES_AS_CONCAT            2
-#define MODE_ANSI_QUOTES                4
-#define MODE_IGNORE_SPACE               8
-#define MODE_IGNORE_BAD_TABLE_OPTIONS   16
-#define MODE_ONLY_FULL_GROUP_BY         32
-#define MODE_NO_UNSIGNED_SUBTRACTION    64
-#define MODE_NO_DIR_IN_CREATE           128
-#define MODE_POSTGRESQL                 256
-#define MODE_ORACLE                     512
-#define MODE_MSSQL                      1024
-#define MODE_DB2                        2048
-#define MODE_MAXDB                      4096
-#define MODE_NO_KEY_OPTIONS             8192
-#define MODE_NO_TABLE_OPTIONS           16384
-#define MODE_NO_FIELD_OPTIONS           32768
-#define MODE_MYSQL323                   65536L
-#define MODE_MYSQL40                    (MODE_MYSQL323*2)
-#define MODE_ANSI                       (MODE_MYSQL40*2)
-#define MODE_NO_AUTO_VALUE_ON_ZERO      (MODE_ANSI*2)
-#define MODE_NO_BACKSLASH_ESCAPES       (MODE_NO_AUTO_VALUE_ON_ZERO*2)
-#define MODE_STRICT_TRANS_TABLES        (MODE_NO_BACKSLASH_ESCAPES*2)
-#define MODE_STRICT_ALL_TABLES          (MODE_STRICT_TRANS_TABLES*2)
-#define MODE_NO_ZERO_IN_DATE            (MODE_STRICT_ALL_TABLES*2)
-#define MODE_NO_ZERO_DATE               (MODE_NO_ZERO_IN_DATE*2)
-#define MODE_INVALID_DATES              (MODE_NO_ZERO_DATE*2)
-#define MODE_ERROR_FOR_DIVISION_BY_ZERO (MODE_INVALID_DATES*2)
-#define MODE_TRADITIONAL                (MODE_ERROR_FOR_DIVISION_BY_ZERO*2)
-#define MODE_NO_AUTO_CREATE_USER        (MODE_TRADITIONAL*2)
-#define MODE_HIGH_NOT_PRECEDENCE        (MODE_NO_AUTO_CREATE_USER*2)
-#define MODE_NO_ENGINE_SUBSTITUTION     (MODE_HIGH_NOT_PRECEDENCE*2)
-#define MODE_PAD_CHAR_TO_FULL_LENGTH    (ULL(1) << 31)
+#define MODE_REAL_AS_FLOAT              (1ULL << 0)
+#define MODE_PIPES_AS_CONCAT            (1ULL << 1)
+#define MODE_ANSI_QUOTES                (1ULL << 2)
+#define MODE_IGNORE_SPACE               (1ULL << 3)
+#define MODE_IGNORE_BAD_TABLE_OPTIONS   (1ULL << 4)
+#define MODE_ONLY_FULL_GROUP_BY         (1ULL << 5)
+#define MODE_NO_UNSIGNED_SUBTRACTION    (1ULL << 6)
+#define MODE_NO_DIR_IN_CREATE           (1ULL << 7)
+#define MODE_POSTGRESQL                 (1ULL << 8)
+#define MODE_ORACLE                     (1ULL << 9)
+#define MODE_MSSQL                      (1ULL << 10)
+#define MODE_DB2                        (1ULL << 11)
+#define MODE_MAXDB                      (1ULL << 12)
+#define MODE_NO_KEY_OPTIONS             (1ULL << 13)
+#define MODE_NO_TABLE_OPTIONS           (1ULL << 14)
+#define MODE_NO_FIELD_OPTIONS           (1ULL << 15)
+#define MODE_MYSQL323                   (1ULL << 16)
+#define MODE_MYSQL40                    (1ULL << 17)
+#define MODE_ANSI                       (1ULL << 18)
+#define MODE_NO_AUTO_VALUE_ON_ZERO      (1ULL << 19)
+#define MODE_NO_BACKSLASH_ESCAPES       (1ULL << 20)
+#define MODE_STRICT_TRANS_TABLES        (1ULL << 21)
+#define MODE_STRICT_ALL_TABLES          (1ULL << 22)
+#define MODE_NO_ZERO_IN_DATE            (1ULL << 23)
+#define MODE_NO_ZERO_DATE               (1ULL << 24)
+#define MODE_INVALID_DATES              (1ULL << 25)
+#define MODE_ERROR_FOR_DIVISION_BY_ZERO (1ULL << 26)
+#define MODE_TRADITIONAL                (1ULL << 27)
+#define MODE_NO_AUTO_CREATE_USER        (1ULL << 28)
+#define MODE_HIGH_NOT_PRECEDENCE        (1ULL << 29)
+#define MODE_NO_ENGINE_SUBSTITUTION     (1ULL << 30)
+#define MODE_PAD_CHAR_TO_FULL_LENGTH    (1ULL << 31)
 
 extern char internal_table_name[2];
 extern char empty_c_string[1];
@@ -235,8 +234,9 @@ public:
   enum drop_type {KEY, COLUMN };
   const char *name;
   enum drop_type type;
-  Alter_drop(enum drop_type par_type,const char *par_name)
-    :name(par_name), type(par_type) {}
+  bool drop_if_exists;
+  Alter_drop(enum drop_type par_type,const char *par_name, bool par_exists)
+    :name(par_name), type(par_type), drop_if_exists(par_exists) {}
   /**
     Used to make a clone of this object for ALTER/CREATE TABLE
     @sa comment for Key_part_spec::clone
@@ -270,20 +270,23 @@ public:
   LEX_STRING name;
   engine_option_value *option_list;
   bool generated;
+  bool create_if_not_exists;
 
   Key(enum Keytype type_par, const LEX_STRING &name_arg,
       KEY_CREATE_INFO *key_info_arg,
       bool generated_arg, List<Key_part_spec> &cols,
-      engine_option_value *create_opt)
+      engine_option_value *create_opt, bool if_not_exists_opt)
     :type(type_par), key_create_info(*key_info_arg), columns(cols),
-    name(name_arg), option_list(create_opt), generated(generated_arg)
+    name(name_arg), option_list(create_opt), generated(generated_arg),
+    create_if_not_exists(if_not_exists_opt)
   {}
   Key(enum Keytype type_par, const char *name_arg, size_t name_len_arg,
       KEY_CREATE_INFO *key_info_arg, bool generated_arg,
       List<Key_part_spec> &cols,
-      engine_option_value *create_opt)
+      engine_option_value *create_opt, bool if_not_exists_opt)
     :type(type_par), key_create_info(*key_info_arg), columns(cols),
-    option_list(create_opt), generated(generated_arg)
+    option_list(create_opt), generated(generated_arg),
+    create_if_not_exists(if_not_exists_opt)
   {
     name.str= (char *)name_arg;
     name.length= name_len_arg;
@@ -314,8 +317,10 @@ public:
   uint delete_opt, update_opt, match_opt;
   Foreign_key(const LEX_STRING &name_arg, List<Key_part_spec> &cols,
 	      Table_ident *table,   List<Key_part_spec> &ref_cols,
-	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg)
-    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols, NULL),
+	      uint delete_opt_arg, uint update_opt_arg, uint match_opt_arg,
+              bool if_not_exists_opt)
+    :Key(FOREIGN_KEY, name_arg, &default_key_create_info, 0, cols, NULL,
+         if_not_exists_opt),
     ref_table(table), ref_columns(ref_cols),
     delete_opt(delete_opt_arg), update_opt(update_opt_arg),
     match_opt(match_opt_arg)
@@ -597,6 +602,9 @@ typedef struct system_variables
   ulong wt_timeout_long, wt_deadlock_search_depth_long;
 
   double long_query_time_double;
+
+  my_bool pseudo_slave_mode;
+
 } SV;
 
 /**
@@ -1711,11 +1719,11 @@ public:
 
   HASH		handler_tables_hash;
   /*
-    One thread can hold up to one named user-level lock. This variable
-    points to a lock object if the lock is present. See item_func.cc and
+    A thread can hold named user-level locks. This variable
+    contains granted tickets if a lock is present. See item_func.cc and
     chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
   */
-  User_level_lock *ull;
+  HASH ull_hash;
 #ifndef DBUG_OFF
   uint dbug_sentry; // watch out for memory corruption
 #endif
@@ -2719,9 +2727,21 @@ public:
     return alloc_root(&transaction.mem_root,size);
   }
 
-  LEX_STRING *make_lex_string(LEX_STRING *lex_str,
-                              const char* str, uint length,
-                              bool allocate_lex_string);
+  LEX_STRING *make_lex_string(LEX_STRING *lex_str, const char* str, uint length)
+  {
+    if (!(lex_str->str= strmake_root(mem_root, str, length)))
+      return 0;
+    lex_str->length= length;
+    return lex_str;
+  }
+
+  LEX_STRING *make_lex_string(const char* str, uint length)
+  {
+    LEX_STRING *lex_str;
+    if (!(lex_str= (LEX_STRING *)alloc_root(mem_root, sizeof(LEX_STRING))))
+      return 0;
+    return make_lex_string(lex_str, str, length);
+  }
 
   bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
 		      const char *from, uint from_length,
@@ -3193,7 +3213,10 @@ public:
   { set_query(CSET_STRING()); }
   void set_query_and_id(char *query_arg, uint32 query_length_arg,
                         CHARSET_INFO *cs, query_id_t new_query_id);
-  void set_query_id(query_id_t new_query_id);
+  void set_query_id(query_id_t new_query_id)
+  {
+    query_id= new_query_id;
+  }
   void set_open_tables(TABLE *open_tables_arg)
   {
     mysql_mutex_lock(&LOCK_thd_data);
@@ -3480,6 +3503,7 @@ public:
 #else
   void begin_dataset() {}
 #endif
+  virtual void update_used_tables() {}
 };
 
 
@@ -4253,6 +4277,7 @@ public:
     return updated;
   }
   virtual void abort_result_set();
+  void update_used_tables();
 };
 
 class my_var : public Sql_alloc  {
@@ -4276,7 +4301,6 @@ public:
 
 class select_dumpvar :public select_result_interceptor {
   ha_rows row_count;
-  Item_func_set_user_var **set_var_items;
 public:
   List<my_var> var_list;
   select_dumpvar()  { var_list.empty(); row_count= 0;}
diff --git a/sql/sql_connect.cc b/sql/sql_connect.cc
index 59aa51916fb..c3f2bb0ca11 100644
--- a/sql/sql_connect.cc
+++ b/sql/sql_connect.cc
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2007, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2008, 2012, Monty Program Ab
+   Copyright (c) 2008, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -226,7 +226,7 @@ void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
   DBUG_ENTER("time_out_user_resource_limits");
 
   /* If more than a hour since last check, reset resource checking */
-  if (check_time  - uc->reset_utime >= LL(3600000000))
+  if (check_time  - uc->reset_utime >= 3600000000ULL)
   {
     uc->questions=0;
     uc->updates=0;
@@ -1187,7 +1187,7 @@ bool thd_prepare_connection(THD *thd)
   bool rc;
   lex_start(thd);
   rc= login_connection(thd);
-  MYSQL_AUDIT_NOTIFY_CONNECTION_CONNECT(thd);
+  mysql_audit_notify_connection_connect(thd);
   if (rc)
     return rc;
 
diff --git a/sql/sql_const.h b/sql/sql_const.h
index c6aa52197d5..7dadbb7b8b4 100644
--- a/sql/sql_const.h
+++ b/sql/sql_const.h
@@ -93,7 +93,7 @@
 #define FIELD_NR_MASK	16383			/* To get fieldnumber */
 #define FERR		-1			/* Error from my_functions */
 #define CREATE_MODE	0			/* Default mode on new files */
-#define NAMES_SEP_CHAR	'\377'			/* Char to sep. names */
+#define NAMES_SEP_CHAR	255			/* Char to sep. names */
 
 #define READ_RECORD_BUFFER	(uint) (IO_SIZE*8) /* Pointer_buffer_size */
 #define DISK_BUFFER_SIZE	(uint) (IO_SIZE*16) /* Size of diskbuffer */
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 87650e643f2..d4f8431beec 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -52,11 +52,9 @@ const char *del_exts[]= {".frm", ".BAK", ".TMD",".opt", NullS};
 static TYPELIB deletable_extentions=
 {array_elements(del_exts)-1,"del_exts", del_exts, NULL};
 
-static bool find_db_tables_and_rm_known_files(THD *thd, MY_DIR *dirp,
-                                              const char *db,
-                                              const char *path,
-                                              TABLE_LIST **tables,
-                                              bool *found_other_files);
+static bool find_db_tables_and_rm_known_files(THD *, MY_DIR *, const char *,
+                                              const char *, TABLE_LIST **,
+                                              bool *);
 
 long mysql_rm_arc_files(THD *thd, MY_DIR *dirp, const char *org_path);
 static my_bool rm_dir_w_symlink(const char *org_path, my_bool send_error);
@@ -834,11 +832,7 @@ bool mysql_rm_db(THD *thd,char *db,bool if_exists, bool silent)
     mysql_ha_rm_tables(thd, tables);
 
   for (table= tables; table; table= table->next_local)
-  {
-    tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name,
-                     false);
     deleted_tables++;
-  }
 
   thd->push_internal_handler(&err_handler);
   if (!thd->killed &&
@@ -936,16 +930,10 @@ update_binlog:
     for (tbl= tables; tbl; tbl= tbl->next_local)
     {
       uint tbl_name_len;
-      bool exists;
       char quoted_name[FN_REFLEN+3];
 
       // Only write drop table to the binlog for tables that no longer exist.
-      if (check_if_table_exists(thd, tbl, 0, &exists))
-      {
-        error= true;
-        goto exit;
-      }
-      if (exists)
+      if (ha_table_exists(thd, tbl->db, tbl->table_name))
         continue;
 
       my_snprintf(quoted_name, sizeof(quoted_name), "%`s", tbl->table_name);
@@ -1010,18 +998,13 @@ static bool find_db_tables_and_rm_known_files(THD *thd, MY_DIR *dirp,
   tot_list_next_local= tot_list_next_global= &tot_list;
 
   for (uint idx=0 ;
-       idx < (uint) dirp->number_off_files && !thd->killed ;
+       idx < (uint) dirp->number_of_files && !thd->killed ;
        idx++)
   {
     FILEINFO *file=dirp->dir_entry+idx;
     char *extension;
     DBUG_PRINT("info",("Examining: %s", file->name));
 
-    /* skiping . and .. */
-    if (file->name[0] == '.' && (!file->name[1] ||
-       (file->name[1] == '.' &&  !file->name[2])))
-      continue;
-
     if (file->name[0] == 'a' && file->name[1] == 'r' &&
              file->name[2] == 'c' && file->name[3] == '\0')
     {
@@ -1189,18 +1172,13 @@ long mysql_rm_arc_files(THD *thd, MY_DIR *dirp, const char *org_path)
   DBUG_PRINT("enter", ("path: %s", org_path));
 
   for (uint idx=0 ;
-       idx < (uint) dirp->number_off_files && !thd->killed ;
+       idx < (uint) dirp->number_of_files && !thd->killed ;
        idx++)
   {
     FILEINFO *file=dirp->dir_entry+idx;
     char *extension, *revision;
     DBUG_PRINT("info",("Examining: %s", file->name));
 
-    /* skiping . and .. */
-    if (file->name[0] == '.' && (!file->name[1] ||
-       (file->name[1] == '.' &&  !file->name[2])))
-      continue;
-
     extension= fn_ext(file->name);
     if (extension[0] != '.' ||
         extension[1] != 'f' || extension[2] != 'r' ||
@@ -1687,7 +1665,7 @@ bool mysql_upgrade_db(THD *thd, LEX_STRING *old_db)
   /* Step2: Move tables to the new database */
   if ((dirp = my_dir(path,MYF(MY_DONT_SORT))))
   {
-    uint nfiles= (uint) dirp->number_off_files;
+    uint nfiles= (uint) dirp->number_of_files;
     for (uint idx=0 ; idx < nfiles && !thd->killed ; idx++)
     {
       FILEINFO *file= dirp->dir_entry + idx;
@@ -1778,17 +1756,15 @@ bool mysql_upgrade_db(THD *thd, LEX_STRING *old_db)
 
   if ((dirp = my_dir(path,MYF(MY_DONT_SORT))))
   {
-    uint nfiles= (uint) dirp->number_off_files;
+    uint nfiles= (uint) dirp->number_of_files;
     for (uint idx=0 ; idx < nfiles ; idx++)
     {
       FILEINFO *file= dirp->dir_entry + idx;
       char oldname[FN_REFLEN + 1], newname[FN_REFLEN + 1];
       DBUG_PRINT("info",("Examining: %s", file->name));
 
-      /* skiping . and .. and MY_DB_OPT_FILE */
-      if ((file->name[0] == '.' &&
-           (!file->name[1] || (file->name[1] == '.' && !file->name[2]))) ||
-          !my_strcasecmp(files_charset_info, file->name, MY_DB_OPT_FILE))
+      /* skiping MY_DB_OPT_FILE */
+      if (!my_strcasecmp(files_charset_info, file->name, MY_DB_OPT_FILE))
         continue;
 
       /* pass empty file name, and file->name as extension to avoid encoding */
diff --git a/sql/sql_db.h b/sql/sql_db.h
index 1f447c11a52..62d379c515d 100644
--- a/sql/sql_db.h
+++ b/sql/sql_db.h
@@ -19,7 +19,6 @@
 #include "hash.h"                               /* HASH */
 
 class THD;
-typedef struct st_ha_create_information HA_CREATE_INFO;
 
 int mysql_create_db(THD *thd, char *db, HA_CREATE_INFO *create, bool silent);
 bool mysql_alter_db(THD *thd, const char *db, HA_CREATE_INFO *create);
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index 1c93a59904c..d1e5d731183 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -304,7 +304,8 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, SQL_HANDLER *reopen)
   /* There can be only one table in '*tables'. */
   if (! (table->file->ha_table_flags() & HA_CAN_SQL_HANDLER))
   {
-    my_error(ER_ILLEGAL_HA, MYF(0), tables->alias);
+    my_error(ER_ILLEGAL_HA, MYF(0), table->file->table_type(),
+             table->s->db.str, table->s->table_name.str);
     goto err;
   }
 
@@ -901,7 +902,8 @@ retry:
       break;
     }
     default:
-      my_message(ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA), MYF(0));
+      my_error(ER_ILLEGAL_HA, MYF(0), table->file->table_type(),
+               table->s->db.str, table->s->table_name.str);
       goto err;
     }
 
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 09e4953cdc4..4f025c7c335 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -2041,9 +2041,9 @@ public:
     thd.unlink();				// Must be unlinked under lock
     my_free(thd.query());
     thd.security_ctx->user= thd.security_ctx->host=0;
-    thread_count--;
     delayed_insert_threads--;
     mysql_mutex_unlock(&LOCK_thread_count);
+    thread_safe_decrement32(&thread_count, &thread_count_lock);
     mysql_cond_broadcast(&COND_thread_count); /* Tell main we are ready */
   }
 
@@ -2178,9 +2178,9 @@ bool delayed_get_table(THD *thd, MDL_request *grl_protection_request,
     {
       if (!(di= new Delayed_insert()))
         goto end_create;
-      mysql_mutex_lock(&LOCK_thread_count);
-      thread_count++;
-      mysql_mutex_unlock(&LOCK_thread_count);
+
+      thread_safe_increment32(&thread_count, &thread_count_lock);
+
       /*
         Annotating delayed inserts is not supported.
       */
@@ -3891,8 +3891,8 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
   {
     if (!mysql_create_table_no_lock(thd, create_table->db,
                                     create_table->table_name,
-                                    create_info, alter_info, 0,
-                                    select_field_count, NULL))
+                                    create_info, alter_info, NULL,
+                                    select_field_count))
     {
       DEBUG_SYNC(thd,"create_table_select_before_open");
 
diff --git a/sql/sql_join_cache.cc b/sql/sql_join_cache.cc
index fde9f70fa79..6b0882bda80 100644
--- a/sql/sql_join_cache.cc
+++ b/sql/sql_join_cache.cc
@@ -775,7 +775,7 @@ ulong JOIN_CACHE::get_min_join_buffer_size()
          tab= next_linear_tab(join, tab, WITHOUT_BUSH_ROOTS))
     {
       len+= tab->get_max_used_fieldlength();
-      len_last=+ tab->get_used_fieldlength();
+      len_last+= tab->get_used_fieldlength();
     }
     size_t len_addon= get_record_max_affix_length() +
                       get_max_key_addon_space_per_record();
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 82cdd4ead7b..fbe5bcd57f2 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -507,6 +507,7 @@ void lex_start(THD *thd)
   lex->expr_allows_subselect= TRUE;
   lex->use_only_table_context= FALSE;
   lex->parse_vcol_expr= FALSE;
+  lex->check_exists= FALSE;
   lex->verbose= 0;
 
   lex->name.str= 0;
@@ -1883,6 +1884,7 @@ void st_select_lex::init_query()
   max_equal_elems= 0;
   ref_pointer_array= 0;
   select_n_where_fields= 0;
+  select_n_reserved= 0;
   select_n_having_items= 0;
   n_child_sum_items= 0;
   subquery_in_having= explicit_limit= 0;
@@ -2328,6 +2330,7 @@ bool st_select_lex::setup_ref_array(THD *thd, uint order_group_num)
   ref_pointer_array=
     (Item **)thd->stmt_arena->alloc(sizeof(Item*) * (n_child_sum_items +
                                                      item_list.elements +
+                                                     select_n_reserved +
                                                      select_n_having_items +
                                                      select_n_where_fields +
                                                      order_group_num)*5);
@@ -2883,7 +2886,7 @@ void st_select_lex_unit::set_limit(st_select_lex *sl)
     val= fix_fields_successful ? item->val_uint() : 0;
   }
   else
-    val= ULL(0);
+    val= 0;
 
   offset_limit_cnt= (ha_rows)val;
 #ifndef BIG_TABLES
@@ -3877,7 +3880,8 @@ void SELECT_LEX::update_used_tables()
   {
     for (ORDER *order= order_list.first; order; order= order->next)
       (*order->item)->update_used_tables();
-  }      
+  }
+  join->result->update_used_tables();
 }
 
 
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index cc117e18d1e..363b0d77e41 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -740,6 +740,8 @@ public:
     and all inner subselects.
   */
   uint select_n_where_fields;
+  /* reserved for exists 2 in */
+  uint select_n_reserved;
   enum_parsing_place parsing_place; /* where we are parsing expression */
   bool with_sum_func;   /* sum function indicator */
 
@@ -2433,7 +2435,8 @@ struct LEX: public Query_tables_list
   uint16 create_view_algorithm;
   uint8 create_view_check;
   uint8 context_analysis_only;
-  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
+  bool drop_temporary, local_file, one_shot_set;
+  bool check_exists;
   bool autocommit;
   bool verbose, no_write_to_binlog;
 
diff --git a/sql/sql_list.h b/sql/sql_list.h
index b4e0ab84aab..aef2f8d5f25 100644
--- a/sql/sql_list.h
+++ b/sql/sql_list.h
@@ -287,13 +287,15 @@ public:
       if (node == &end_of_list)
         return;
     }
-    *prev= *last;
+    *prev= &end_of_list;
     last= prev;
   }
   inline void prepand(base_list *list)
   {
     if (!list->is_empty())
     {
+      if (is_empty())
+        last= list->last;
       *list->last= first;
       first= list->first;
       elements+= list->elements;
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index d805597898b..e8268f42cc7 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -1,5 +1,5 @@
 /* Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2008, 2012, Monty Program Ab
+   Copyright (c) 2008, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -804,9 +804,10 @@ end:
   delete thd;
 
 #ifndef EMBEDDED_LIBRARY
-  mysql_mutex_lock(&LOCK_thread_count);
-  thread_count--;
+  thread_safe_decrement32(&thread_count, &thread_count_lock);
   in_bootstrap= FALSE;
+
+  mysql_mutex_lock(&LOCK_thread_count);
   mysql_cond_broadcast(&COND_thread_count);
   mysql_mutex_unlock(&LOCK_thread_count);
   my_thread_end();
@@ -1110,9 +1111,16 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   thd->query_plan_flags= QPLAN_INIT;
   thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
   thd->set_time();
-  thd->set_query_id(get_query_id());
   if (!(server_command_flags[command] & CF_SKIP_QUERY_ID))
-    next_query_id();
+    thd->set_query_id(next_query_id());
+  else
+  {
+    /*
+      ping, get statistics or similar stateless command.
+      No reason to increase query id here.
+    */
+    thd->set_query_id(get_query_id());
+  }
   inc_thread_running();
 
   if (!(server_command_flags[command] & CF_SKIP_QUESTIONS))
@@ -1183,7 +1191,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
     else
       rc= acl_authenticate(thd, 0, packet_length);
 
-    MYSQL_AUDIT_NOTIFY_CONNECTION_CHANGE_USER(thd);
+    mysql_audit_notify_connection_change_user(thd);
     if (rc)
     {
       /* Free user if allocated by acl_authenticate */
@@ -1569,7 +1577,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
     if (!(uptime= (ulong) (thd->start_time - server_start_time)))
       queries_per_second1000= 0;
     else
-      queries_per_second1000= thd->query_id * LL(1000) / uptime;
+      queries_per_second1000= thd->query_id * 1000 / uptime;
 
     length= my_snprintf(buff, buff_len - 1,
                         "Uptime: %lu  Threads: %d  Questions: %lu  "
@@ -1851,7 +1859,7 @@ int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
     break;
   case SCH_USER_STATS:
   case SCH_CLIENT_STATS:
-    if (check_global_access(thd, SUPER_ACL | PROCESS_ACL))
+    if (check_global_access(thd, SUPER_ACL | PROCESS_ACL, true))
       DBUG_RETURN(1);
   case SCH_TABLE_STATS:
   case SCH_INDEX_STATS:
@@ -2026,7 +2034,7 @@ bool sp_process_definer(THD *thd)
     if ((strcmp(lex->definer->user.str, thd->security_ctx->priv_user) ||
          my_strcasecmp(system_charset_info, lex->definer->host.str,
                        thd->security_ctx->priv_host)) &&
-        check_global_access(thd, SUPER_ACL))
+        check_global_access(thd, SUPER_ACL, true))
     {
       my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
       DBUG_RETURN(TRUE);
@@ -2277,7 +2285,7 @@ mysql_execute_command(THD *thd)
     if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
 	!(lex->sql_command == SQLCOM_SET_OPTION) &&
 	!(lex->sql_command == SQLCOM_DROP_TABLE &&
-          lex->drop_temporary && lex->drop_if_exists) &&
+          lex->drop_temporary && lex->check_exists) &&
         all_tables_not_ok(thd, all_tables))
     {
       /* we warn the slave SQL thread */
@@ -3301,6 +3309,7 @@ end_with_restore_list:
       thd->first_successful_insert_id_in_cur_stmt=
         thd->first_successful_insert_id_in_prev_stmt;
 
+#ifdef ENABLED_DEBUG_SYNC
     DBUG_EXECUTE_IF("after_mysql_insert",
                     {
                       const char act1[]=
@@ -3316,6 +3325,7 @@ end_with_restore_list:
                                                          STRING_WITH_LEN(act2)));
                     };);
     DEBUG_SYNC(thd, "after_mysql_insert");
+#endif
     break;
   }
   case SQLCOM_REPLACE_SELECT:
@@ -3489,7 +3499,7 @@ end_with_restore_list:
       thd->variables.option_bits|= OPTION_KEEP_LOG;
     }
     /* DDL and binlog write order are protected by metadata locks. */
-    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
+    res= mysql_rm_table(thd, first_table, lex->check_exists,
 			lex->drop_temporary);
   }
   break;
@@ -3703,7 +3713,7 @@ end_with_restore_list:
 #endif
     if (check_access(thd, DROP_ACL, lex->name.str, NULL, NULL, 1, 0))
       break;
-    res= mysql_rm_db(thd, lex->name.str, lex->drop_if_exists, 0);
+    res= mysql_rm_db(thd, lex->name.str, lex->check_exists, 0);
     break;
   }
   case SQLCOM_ALTER_DB_UPGRADE:
@@ -3831,7 +3841,7 @@ end_with_restore_list:
   case SQLCOM_DROP_EVENT:
     if (!(res= Events::drop_event(thd,
                                   lex->spname->m_db, lex->spname->m_name,
-                                  lex->drop_if_exists)))
+                                  lex->check_exists)))
       my_ok(thd);
     break;
 #else
@@ -4520,7 +4530,7 @@ create_sp_error:
 
         if (lex->spname->m_db.str == NULL)
         {
-          if (lex->drop_if_exists)
+          if (lex->check_exists)
           {
             push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                                 ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
@@ -4589,7 +4599,7 @@ create_sp_error:
 	my_ok(thd);
 	break;
       case SP_KEY_NOT_FOUND:
-	if (lex->drop_if_exists)
+	if (lex->check_exists)
 	{
           res= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
 	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
@@ -4804,7 +4814,7 @@ create_sp_error:
 
     if ((err_code= drop_server(thd, &lex->server_options)))
     {
-      if (! lex->drop_if_exists && err_code == ER_FOREIGN_SERVER_DOESNT_EXIST)
+      if (! lex->check_exists && err_code == ER_FOREIGN_SERVER_DOESNT_EXIST)
       {
         DBUG_PRINT("info", ("problem dropping server %s",
                             lex->server_options.server_name));
@@ -5238,6 +5248,10 @@ check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
 
   if ((db != NULL) && (db != any_db))
   {
+    /*
+      Check if this is reserved database, like information schema or
+      performance schema
+    */
     const ACL_internal_schema_access *access;
     access= get_cached_schema_access(grant_internal_info, db);
     if (access)
@@ -5680,14 +5694,17 @@ bool check_some_access(THD *thd, ulong want_access, TABLE_LIST *table)
     1	Access denied.  In this case an error is sent to the client
 */
 
-bool check_global_access(THD *thd, ulong want_access)
+bool check_global_access(THD *thd, ulong want_access, bool no_errors)
 {
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
   char command[128];
   if ((thd->security_ctx->master_access & want_access))
     return 0;
-  get_privilege_desc(command, sizeof(command), want_access);
-  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
+  if (!no_errors)
+  {
+    get_privilege_desc(command, sizeof(command), want_access);
+    my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
+  }
   status_var_increment(thd->status_var.access_denied_errors);
   return 1;
 #else
@@ -6227,7 +6244,7 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type,
     lex->col_list.push_back(new Key_part_spec(*field_name, 0));
     key= new Key(Key::PRIMARY, null_lex_str,
                       &default_key_create_info,
-                      0, lex->col_list, NULL);
+                      0, lex->col_list, NULL, lex->check_exists);
     lex->alter_info.key_list.push_back(key);
     lex->col_list.empty();
   }
@@ -6237,7 +6254,7 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type,
     lex->col_list.push_back(new Key_part_spec(*field_name, 0));
     key= new Key(Key::UNIQUE, null_lex_str,
                  &default_key_create_info, 0,
-                 lex->col_list, NULL);
+                 lex->col_list, NULL, lex->check_exists);
     lex->alter_info.key_list.push_back(key);
     lex->col_list.empty();
   }
@@ -6289,7 +6306,7 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type,
       new_field->init(thd, field_name->str, type, length, decimals, type_modifier,
                       default_value, on_update_value, comment, change,
                       interval_list, cs, uint_geom_type, vcol_info,
-                      create_options))
+                      create_options, lex->check_exists))
     DBUG_RETURN(1);
 
   lex->alter_info.create_list.push_back(new_field);
@@ -7894,6 +7911,7 @@ bool check_string_char_length(LEX_STRING *str, const char *err_msg,
   return TRUE;
 }
 
+C_MODE_START
 
 /*
   Check if path does not contain mysql data home directory
@@ -7906,7 +7924,6 @@ bool check_string_char_length(LEX_STRING *str, const char *err_msg,
     0	ok
     1	error ;  Given path contains data directory
 */
-C_MODE_START
 
 int test_if_data_home_dir(const char *dir)
 {
@@ -7917,6 +7934,22 @@ int test_if_data_home_dir(const char *dir)
   if (!dir)
     DBUG_RETURN(0);
 
+  /*
+    data_file_name and index_file_name include the table name without
+    extension. Mostly this does not refer to an existing file. When
+    comparing data_file_name or index_file_name against the data
+    directory, we try to resolve all symbolic links. On some systems,
+    we use realpath(3) for the resolution. This returns ENOENT if the
+    resolved path does not refer to an existing file. my_realpath()
+    does then copy the requested path verbatim, without symlink
+    resolution. Thereafter the comparison can fail even if the
+    requested path is within the data directory. E.g. if symlinks to
+    another file system are used. To make realpath(3) return the
+    resolved path, we strip the table name and compare the directory
+    path only. If the directory doesn't exist either, table creation
+    will fail anyway.
+  */
+
   (void) fn_format(path, dir, "", "",
                    (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
   dir_len= strlen(path);
@@ -7950,6 +7983,22 @@ int test_if_data_home_dir(const char *dir)
 C_MODE_END
 
 
+int error_if_data_home_dir(const char *path, const char *what)
+{
+  size_t dirlen;
+  char   dirpath[FN_REFLEN];
+  if (path)
+  {
+    dirname_part(dirpath, path, &dirlen);
+    if (test_if_data_home_dir(dirpath))
+    {
+      my_error(ER_WRONG_ARGUMENTS, MYF(0), what);
+      return 1;
+    }
+  }
+  return 0;
+}
+
 /**
   Check that host name string is valid.
 
diff --git a/sql/sql_parse.h b/sql/sql_parse.h
index 4510ebe94e2..25c41cc624c 100644
--- a/sql/sql_parse.h
+++ b/sql/sql_parse.h
@@ -34,6 +34,7 @@ enum enum_mysql_completiontype {
 };
 
 extern "C" int test_if_data_home_dir(const char *dir);
+int error_if_data_home_dir(const char *path, const char *what);
 
 bool multi_update_precheck(THD *thd, TABLE_LIST *tables);
 bool multi_delete_precheck(THD *thd, TABLE_LIST *tables);
@@ -196,7 +197,7 @@ check_table_access(THD *thd, ulong requirements,TABLE_LIST *tables,
 
 /* These were under the INNODB_COMPATIBILITY_HOOKS */
 
-bool check_global_access(THD *thd, ulong want_access);
+bool check_global_access(THD *thd, ulong want_access, bool no_errors= false);
 
 inline bool is_supported_parser_charset(CHARSET_INFO *cs)
 {
diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc
index f042f028450..b2e2016b47d 100644
--- a/sql/sql_partition.cc
+++ b/sql/sql_partition.cc
@@ -1,5 +1,5 @@
 /* Copyright (c) 2005, 2011, Oracle and/or its affiliates.
-   Copyright (c) 2009-2011, Monty Program Ab
+   Copyright (c) 2009, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -4536,7 +4536,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
     */
     DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db, table_name,
                                                MDL_INTENTION_EXCLUSIVE));
-    new_table= open_table_uncached(thd, path, db, table_name, 0);
+    new_table= open_table_uncached(thd, old_db_type, path, db, table_name, 0);
     if (!new_table)
       DBUG_RETURN(TRUE);
 
@@ -4717,8 +4717,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
       }
       alt_part_info->part_type= tab_part_info->part_type;
       alt_part_info->subpart_type= tab_part_info->subpart_type;
-      if (alt_part_info->set_up_defaults_for_partitioning(new_table->file,
-                                                    ULL(0), 
+      if (alt_part_info->set_up_defaults_for_partitioning(new_table->file, 0, 
                                                     tab_part_info->num_parts))
       {
         goto err;
@@ -5134,8 +5133,7 @@ state of p1.
       alt_part_info->num_subparts= tab_part_info->num_subparts;
       DBUG_ASSERT(!alt_part_info->use_default_partitions);
       if (alt_part_info->set_up_defaults_for_partitioning(new_table->file,
-                                                          ULL(0), 
-                                                          0))
+                                                          0, 0))
       {
         goto err;
       }
@@ -5268,7 +5266,7 @@ the generated partition syntax in a correct manner.
         tab_part_info->use_default_num_subpartitions= FALSE;
       }
       if (tab_part_info->check_partition_info(thd, (handlerton**)NULL,
-                                              new_table->file, ULL(0), TRUE))
+                                              new_table->file, 0, TRUE))
       {
         goto err;
       }
diff --git a/sql/sql_partition.h b/sql/sql_partition.h
index 2fd9b4c3d75..8db07f836b0 100644
--- a/sql/sql_partition.h
+++ b/sql/sql_partition.h
@@ -32,7 +32,6 @@ class partition_info;
 struct TABLE;
 struct TABLE_LIST;
 typedef struct st_bitmap MY_BITMAP;
-typedef struct st_ha_create_information HA_CREATE_INFO;
 typedef struct st_key KEY;
 typedef struct st_key_range key_range;
 
diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc
index 8778713d7e7..72f16ba7837 100644
--- a/sql/sql_plugin.cc
+++ b/sql/sql_plugin.cc
@@ -35,6 +35,8 @@
 #include <mysql/plugin_auth.h>
 #include "lock.h"                               // MYSQL_LOCK_IGNORE_TIMEOUT
 #include <mysql/plugin_auth.h>
+#include "sql_plugin_compat.h"
+
 #define REPORT_TO_LOG  1
 #define REPORT_TO_USER 2
 
@@ -135,7 +137,7 @@ static int min_plugin_info_interface_version[MYSQL_MAX_PLUGIN_TYPE_NUM]=
   MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION,
   MYSQL_AUDIT_INTERFACE_VERSION,
   MYSQL_REPLICATION_INTERFACE_VERSION,
-  MYSQL_AUTHENTICATION_INTERFACE_VERSION
+  MIN_AUTHENTICATION_INTERFACE_VERSION
 };
 static int cur_plugin_info_interface_version[MYSQL_MAX_PLUGIN_TYPE_NUM]=
 {
@@ -195,6 +197,8 @@ static bool reap_needed= false;
 static int plugin_array_version=0;
 
 static bool initialized= 0;
+ulong dlopen_count;
+
 
 /*
   write-lock on LOCK_system_variables_hash is required before modifying
@@ -306,10 +310,6 @@ static void unlock_variables(THD *thd, struct system_variables *vars);
 static void cleanup_variables(THD *thd, struct system_variables *vars);
 static void plugin_vars_free_values(sys_var *vars);
 static void restore_pluginvar_names(sys_var *first);
-static void plugin_opt_set_limits(struct my_option *,
-                                  const struct st_mysql_sys_var *);
-#define my_intern_plugin_lock(A,B) intern_plugin_lock(A,B)
-#define my_intern_plugin_lock_ci(A,B) intern_plugin_lock(A,B)
 static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref plugin);
 static void intern_plugin_unlock(LEX *lex, plugin_ref plugin);
 static void reap_plugins(void);
@@ -507,7 +507,6 @@ static my_bool read_mysql_plugin_info(struct st_plugin_dl *plugin_dl,
   /* Determine interface version */
   if (!sym)
   {
-    free_plugin_mem(plugin_dl);
     report_error(report, ER_CANT_FIND_DL_ENTRY, plugin_interface_version_sym);
     DBUG_RETURN(TRUE);
   }
@@ -517,7 +516,6 @@ static my_bool read_mysql_plugin_info(struct st_plugin_dl *plugin_dl,
   if (plugin_dl->mysqlversion < min_plugin_interface_version ||
       (plugin_dl->mysqlversion >> 8) > (MYSQL_PLUGIN_INTERFACE_VERSION >> 8))
   {
-    free_plugin_mem(plugin_dl);
     report_error(report, ER_CANT_OPEN_LIBRARY, dlpath, 0,
                  "plugin interface version mismatch");
     DBUG_RETURN(TRUE);
@@ -525,7 +523,6 @@ static my_bool read_mysql_plugin_info(struct st_plugin_dl *plugin_dl,
   /* Find plugin declarations */
   if (!(sym= dlsym(plugin_dl->handle, plugin_declarations_sym)))
   {
-    free_plugin_mem(plugin_dl);
     report_error(report, ER_CANT_FIND_DL_ENTRY, plugin_declarations_sym);
     DBUG_RETURN(TRUE);
   }
@@ -556,7 +553,6 @@ static my_bool read_mysql_plugin_info(struct st_plugin_dl *plugin_dl,
                     MYF(MY_ZEROFILL|MY_WME));
     if (!cur)
     {
-      free_plugin_mem(plugin_dl);
       report_error(report, ER_OUTOFMEMORY,
                    static_cast<int>(plugin_dl->dl.length));
       DBUG_RETURN(TRUE);
@@ -631,7 +627,6 @@ static my_bool read_maria_plugin_info(struct st_plugin_dl *plugin_dl,
       Actually this branch impossible because in case of absence of maria
       version we try mysql version.
     */
-    free_plugin_mem(plugin_dl);
     report_error(report, ER_CANT_FIND_DL_ENTRY,
                  maria_plugin_interface_version_sym);
     DBUG_RETURN(TRUE);
@@ -642,7 +637,6 @@ static my_bool read_maria_plugin_info(struct st_plugin_dl *plugin_dl,
   if (plugin_dl->mariaversion < min_maria_plugin_interface_version ||
       (plugin_dl->mariaversion >> 8) > (MARIA_PLUGIN_INTERFACE_VERSION >> 8))
   {
-    free_plugin_mem(plugin_dl);
     report_error(report, ER_CANT_OPEN_LIBRARY, dlpath, 0,
                  "plugin interface version mismatch");
     DBUG_RETURN(TRUE);
@@ -650,7 +644,6 @@ static my_bool read_maria_plugin_info(struct st_plugin_dl *plugin_dl,
   /* Find plugin declarations */
   if (!(sym= dlsym(plugin_dl->handle, maria_plugin_declarations_sym)))
   {
-    free_plugin_mem(plugin_dl);
     report_error(report, ER_CANT_FIND_DL_ENTRY, maria_plugin_declarations_sym);
     DBUG_RETURN(TRUE);
   }
@@ -664,7 +657,6 @@ static my_bool read_maria_plugin_info(struct st_plugin_dl *plugin_dl,
       sizeof_st_plugin= *(int *)sym;
     else
     {
-      free_plugin_mem(plugin_dl);
       report_error(report, ER_CANT_FIND_DL_ENTRY, maria_sizeof_st_plugin_sym);
       DBUG_RETURN(TRUE);
     }
@@ -682,7 +674,6 @@ static my_bool read_maria_plugin_info(struct st_plugin_dl *plugin_dl,
                   MYF(MY_ZEROFILL|MY_WME));
       if (!cur)
       {
-        free_plugin_mem(plugin_dl);
         report_error(report, ER_OUTOFMEMORY,
                      static_cast<int>(plugin_dl->dl.length));
         DBUG_RETURN(TRUE);
@@ -712,11 +703,12 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
 #ifdef HAVE_DLOPEN
   char dlpath[FN_REFLEN];
   uint plugin_dir_len, dummy_errors, dlpathlen, i;
-  struct st_plugin_dl *tmp, plugin_dl;
+  struct st_plugin_dl *tmp= 0, plugin_dl;
   void *sym;
   DBUG_ENTER("plugin_dl_add");
   DBUG_PRINT("enter", ("dl->str: '%s', dl->length: %d",
                        dl->str, (int) dl->length));
+  mysql_mutex_assert_owner(&LOCK_plugin);
   plugin_dir_len= strlen(opt_plugin_dir);
   /*
     Ensure that the dll doesn't have a path.
@@ -754,8 +746,9 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
       if (*errmsg == ' ') errmsg++;
     }
     report_error(report, ER_CANT_OPEN_LIBRARY, dlpath, errno, errmsg);
-    DBUG_RETURN(0);
+    goto ret;
   }
+  dlopen_count++;
 
   /* Checks which plugin interface present and reads info */
   if (!(sym= dlsym(plugin_dl.handle, maria_plugin_interface_version_sym)))
@@ -765,12 +758,12 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
                                      plugin_interface_version_sym),
                                dlpath,
                                report))
-      DBUG_RETURN(0);
+      goto ret;
   }
   else
   {
     if (read_maria_plugin_info(&plugin_dl, sym, dlpath, report))
-      DBUG_RETURN(0);
+      goto ret;
   }
 
   /* link the services in */
@@ -787,7 +780,7 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
                     "service '%s' interface version mismatch",
                     list_of_services[i].name);
         report_error(report, ER_CANT_OPEN_LIBRARY, dlpath, 0, buf);
-        DBUG_RETURN(0);
+        goto ret;
       }
       *(void**)sym= list_of_services[i].service;
     }
@@ -797,10 +790,9 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
   plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;
   if (! (plugin_dl.dl.str= (char*) my_malloc(plugin_dl.dl.length, MYF(0))))
   {
-    free_plugin_mem(&plugin_dl);
     report_error(report, ER_OUTOFMEMORY,
                  static_cast<int>(plugin_dl.dl.length));
-    DBUG_RETURN(0);
+    goto ret;
   }
   plugin_dl.dl.length= copy_and_convert(plugin_dl.dl.str, plugin_dl.dl.length,
     files_charset_info, dl->str, dl->length, system_charset_info,
@@ -809,12 +801,17 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
   /* Add this dll to array */
   if (! (tmp= plugin_dl_insert_or_reuse(&plugin_dl)))
   {
-    free_plugin_mem(&plugin_dl);
     report_error(report, ER_OUTOFMEMORY,
                  static_cast<int>(sizeof(struct st_plugin_dl)));
-    DBUG_RETURN(0);
+    goto ret;
   }
+
+ret:
+  if (!tmp)
+    free_plugin_mem(&plugin_dl);
+
   DBUG_RETURN(tmp);
+
 #else
   DBUG_ENTER("plugin_dl_add");
   report_error(report, ER_FEATURE_DISABLED, "plugin", "HAVE_DLOPEN");
@@ -823,34 +820,23 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
 }
 
 
-static void plugin_dl_del(const LEX_STRING *dl)
+static void plugin_dl_del(struct st_plugin_dl *plugin_dl)
 {
-#ifdef HAVE_DLOPEN
-  uint i;
   DBUG_ENTER("plugin_dl_del");
 
+  if (!plugin_dl)
+    DBUG_VOID_RETURN;
+
   mysql_mutex_assert_owner(&LOCK_plugin);
 
-  for (i= 0; i < plugin_dl_array.elements; i++)
+  /* Do not remove this element, unless no other plugin uses this dll. */
+  if (! --plugin_dl->ref_count)
   {
-    struct st_plugin_dl *tmp= *dynamic_element(&plugin_dl_array, i,
-                                               struct st_plugin_dl **);
-    if (tmp->ref_count &&
-        ! my_strnncoll(files_charset_info,
-                       (const uchar *)dl->str, dl->length,
-                       (const uchar *)tmp->dl.str, tmp->dl.length))
-    {
-      /* Do not remove this element, unless no other plugin uses this dll. */
-      if (! --tmp->ref_count)
-      {
-        free_plugin_mem(tmp);
-        bzero(tmp, sizeof(struct st_plugin_dl));
-      }
-      break;
-    }
+    free_plugin_mem(plugin_dl);
+    bzero(plugin_dl, sizeof(struct st_plugin_dl));
   }
+
   DBUG_VOID_RETURN;
-#endif
 }
 
 
@@ -921,7 +907,8 @@ static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref rc)
 
   mysql_mutex_assert_owner(&LOCK_plugin);
 
-  if (pi->state & (PLUGIN_IS_READY | PLUGIN_IS_UNINITIALIZED))
+  if (pi->state & (PLUGIN_IS_READY | PLUGIN_IS_UNINITIALIZED |
+                   PLUGIN_IS_DELETED))
   {
     plugin_ref plugin;
 #ifdef DBUG_OFF
@@ -986,7 +973,7 @@ plugin_ref plugin_lock(THD *thd, plugin_ref ptr)
 #endif
   mysql_mutex_lock(&LOCK_plugin);
   plugin_ref_to_int(ptr)->locks_total++;
-  rc= my_intern_plugin_lock_ci(lex, ptr);
+  rc= intern_plugin_lock(lex, ptr);
   mysql_mutex_unlock(&LOCK_plugin);
   DBUG_RETURN(rc);
 }
@@ -1000,7 +987,7 @@ plugin_ref plugin_lock_by_name(THD *thd, const LEX_STRING *name, int type)
   DBUG_ENTER("plugin_lock_by_name");
   mysql_mutex_lock(&LOCK_plugin);
   if ((plugin= plugin_find_internal(name, type)))
-    rc= my_intern_plugin_lock_ci(lex, plugin_int_to_ref(plugin));
+    rc= intern_plugin_lock(lex, plugin_int_to_ref(plugin));
   mysql_mutex_unlock(&LOCK_plugin);
   DBUG_RETURN(rc);
 }
@@ -1136,7 +1123,7 @@ err:
   if (errs == 0 && oks == 0 && !dupes) // no plugin was found
     report_error(report, ER_CANT_FIND_DL_ENTRY, name->str);
 
-  plugin_dl_del(dl);
+  plugin_dl_del(tmp.plugin_dl);
   DBUG_RETURN(errs > 0 || oks + dupes == 0);
 }
 
@@ -1152,22 +1139,21 @@ static void plugin_deinitialize(struct st_plugin_int *plugin, bool ref_check)
 
   if (plugin->plugin->status_vars)
   {
-#ifdef FIX_LATER
-    /**
-      @todo
-      unfortunately, status variables were introduced without a
-      pluginname_ namespace, that is pluginname_ was not added automatically
-      to status variable names. It should be fixed together with the next
-      incompatible API change.
+    /*
+      historical ndb behavior caused MySQL plugins to specify
+      status var names in full, with the plugin name prefix.
+      this was never fixed in MySQL.
+      MariaDB fixes that but support MySQL style too.
     */
-    SHOW_VAR array[2]= {
+    SHOW_VAR *show_vars= plugin->plugin->status_vars;
+    SHOW_VAR tmp_array[2]= {
       {plugin->plugin->name, (char*)plugin->plugin->status_vars, SHOW_ARRAY},
       {0, 0, SHOW_UNDEF}
     };
-    remove_status_vars(array);
-#else
-    remove_status_vars(plugin->plugin->status_vars);
-#endif /* FIX_LATER */
+    if (strncasecmp(show_vars->name, plugin->name.str, plugin->name.length))
+      show_vars= tmp_array;
+
+    remove_status_vars(show_vars);
   }
 
   if (plugin_type_deinitialize[plugin->plugin->type])
@@ -1213,8 +1199,7 @@ static void plugin_del(struct st_plugin_int *plugin)
   restore_pluginvar_names(plugin->system_vars);
   plugin_vars_free_values(plugin->system_vars);
   my_hash_delete(&plugin_hash[plugin->plugin->type], (uchar*)plugin);
-  if (plugin->plugin_dl)
-    plugin_dl_del(&plugin->plugin_dl->dl);
+  plugin_dl_del(plugin->plugin_dl);
   plugin->state= PLUGIN_IS_FREED;
   plugin_array_version++;
   free_root(&plugin->mem_root, MYF(0));
@@ -1378,24 +1363,22 @@ static int plugin_initialize(struct st_plugin_int *plugin)
 
   if (plugin->plugin->status_vars)
   {
-#ifdef FIX_LATER
     /*
-      We have a problem right now where we can not prepend without
-      breaking backwards compatibility. We will fix this shortly so
-      that engines have "use names" and we wil use those for
-      CREATE TABLE, and use the plugin name then for adding automatic
-      variable names.
+      historical ndb behavior caused MySQL plugins to specify
+      status var names in full, with the plugin name prefix.
+      this was never fixed in MySQL.
+      MariaDB fixes that, but supports MySQL style too.
     */
-    SHOW_VAR array[2]= {
+    SHOW_VAR *show_vars= plugin->plugin->status_vars;
+    SHOW_VAR tmp_array[2]= {
       {plugin->plugin->name, (char*)plugin->plugin->status_vars, SHOW_ARRAY},
       {0, 0, SHOW_UNDEF}
     };
-    if (add_status_vars(array)) // add_status_vars makes a copy
-      goto err;
-#else
-    if (add_status_vars(plugin->plugin->status_vars))
+    if (strncasecmp(show_vars->name, plugin->name.str, plugin->name.length))
+      show_vars= tmp_array;
+
+    if (add_status_vars(show_vars))
       goto err;
-#endif /* FIX_LATER */
   }
 
   /*
@@ -1507,6 +1490,8 @@ int plugin_init(int *argc, char **argv, int flags)
   if (initialized)
     DBUG_RETURN(0);
 
+  dlopen_count =0;
+
 #ifdef HAVE_PSI_INTERFACE
   init_plugin_psi_keys();
 #endif
@@ -1535,8 +1520,8 @@ int plugin_init(int *argc, char **argv, int flags)
   }
 
   /* prepare debug_sync service */
-  DBUG_ASSERT(strcmp(list_of_services[5].name, "debug_sync_service") == 0);
-  list_of_services[5].service= *(void**)&debug_sync_C_callback_ptr;
+  DBUG_ASSERT(strcmp(list_of_services[4].name, "debug_sync_service") == 0);
+  list_of_services[4].service= *(void**)&debug_sync_C_callback_ptr;
 
   mysql_mutex_lock(&LOCK_plugin);
 
@@ -1616,7 +1601,7 @@ int plugin_init(int *argc, char **argv, int flags)
       {
         DBUG_ASSERT(!global_system_variables.table_plugin);
         global_system_variables.table_plugin=
-          my_intern_plugin_lock(NULL, plugin_int_to_ref(plugin_ptr));
+          intern_plugin_lock(NULL, plugin_int_to_ref(plugin_ptr));
         DBUG_ASSERT(plugin_ptr->ref_count == 1);
       }
     }
@@ -1729,9 +1714,6 @@ static void plugin_load(MEM_ROOT *tmp_root, int *argc, char **argv)
   int error;
   THD *new_thd= new THD;
   bool result;
-#ifdef EMBEDDED_LIBRARY
-  No_such_table_error_handler error_handler;
-#endif /* EMBEDDED_LIBRARY */
   DBUG_ENTER("plugin_load");
 
   new_thd->thread_stack= (char*) &tables;
@@ -1740,22 +1722,13 @@ static void plugin_load(MEM_ROOT *tmp_root, int *argc, char **argv)
   new_thd->db_length= 5;
   bzero((char*) &new_thd->net, sizeof(new_thd->net));
   tables.init_one_table("mysql", 5, "plugin", 6, "plugin", TL_READ);
-
-#ifdef EMBEDDED_LIBRARY
-  /*
-    When building an embedded library, if the mysql.plugin table
-    does not exist, we silently ignore the missing table
-  */
-  new_thd->push_internal_handler(&error_handler);
-#endif /* EMBEDDED_LIBRARY */
+  tables.open_strategy= TABLE_LIST:: IF_EMBEDDED(OPEN_IF_EXISTS, OPEN_NORMAL);
 
   result= open_and_lock_tables(new_thd, &tables, FALSE, MYSQL_LOCK_IGNORE_TIMEOUT);
 
-#ifdef EMBEDDED_LIBRARY
-  new_thd->pop_internal_handler();
-  if (error_handler.safely_trapped_errors())
+  table= tables.table;
+  if (IF_EMBEDDED(!table, false))
     goto end;
-#endif /* EMBEDDED_LIBRARY */
 
   if (result)
   {
@@ -1767,7 +1740,7 @@ static void plugin_load(MEM_ROOT *tmp_root, int *argc, char **argv)
       sql_print_warning("Could not open mysql.plugin table. Some options may be missing from the help text");
     goto end;
   }
-  table= tables.table;
+
   if (init_read_record(&read_record_info, new_thd, table, NULL, 1, 0, FALSE))
   {
     sql_print_error("Could not initialize init_read_record; Plugins not "
@@ -1799,7 +1772,7 @@ static void plugin_load(MEM_ROOT *tmp_root, int *argc, char **argv)
     mysql_mutex_unlock(&LOCK_plugin);
   }
   if (error > 0)
-    sql_print_error(ER(ER_GET_ERRNO), my_errno);
+    sql_print_error(ER(ER_GET_ERRNO), my_errno, table->file->table_type());
   end_read_record(&read_record_info);
   table->m_needs_reopen= TRUE;                  // Force close to free memory
   close_mysql_tables(new_thd);
@@ -2370,14 +2343,88 @@ err:
 }
 
 
+static bool plugin_dl_foreach_internal(THD *thd, st_plugin_dl *plugin_dl,
+                                       st_maria_plugin *plug,
+                                       plugin_foreach_func *func, void *arg)
+{
+  for (; plug->name; plug++)
+  {
+    st_plugin_int tmp, *plugin;
+
+    tmp.name.str= const_cast<char*>(plug->name);
+    tmp.name.length= strlen(plug->name);
+    tmp.plugin= plug;
+    tmp.plugin_dl= plugin_dl;
+
+    mysql_mutex_lock(&LOCK_plugin);
+    if ((plugin= plugin_find_internal(&tmp.name, MYSQL_ANY_PLUGIN)) &&
+        plugin->plugin == plug)
+
+    {
+      tmp.state= plugin->state;
+      tmp.load_option= plugin->load_option;
+    }
+    else
+    {
+      tmp.state= PLUGIN_IS_FREED;
+      tmp.load_option= PLUGIN_OFF;
+    }
+    mysql_mutex_unlock(&LOCK_plugin);
+
+    plugin= &tmp;
+    if (func(thd, plugin_int_to_ref(plugin), arg))
+      return 1;
+  }
+  return 0;
+}
+
+bool plugin_dl_foreach(THD *thd, const LEX_STRING *dl,
+                       plugin_foreach_func *func, void *arg)
+{
+  bool err= 0;
+
+  if (dl)
+  {
+    mysql_mutex_lock(&LOCK_plugin);
+    st_plugin_dl *plugin_dl= plugin_dl_add(dl, REPORT_TO_USER);
+    mysql_mutex_unlock(&LOCK_plugin);
+
+    if (!plugin_dl)
+      return 1;
+
+    err= plugin_dl_foreach_internal(thd, plugin_dl, plugin_dl->plugins,
+                                    func, arg);
+
+    mysql_mutex_lock(&LOCK_plugin);
+    plugin_dl_del(plugin_dl);
+    mysql_mutex_unlock(&LOCK_plugin);
+  }
+  else
+  {
+    struct st_maria_plugin **builtins;
+    for (builtins= mysql_mandatory_plugins; !err && *builtins; builtins++)
+      err= plugin_dl_foreach_internal(thd, 0, *builtins, func, arg);
+    for (builtins= mysql_optional_plugins; !err && *builtins; builtins++)
+      err= plugin_dl_foreach_internal(thd, 0, *builtins, func, arg);
+  }
+  return err;
+}
+
+
 /****************************************************************************
   Internal type declarations for variables support
 ****************************************************************************/
 
 #undef MYSQL_SYSVAR_NAME
 #define MYSQL_SYSVAR_NAME(name) name
-#define PLUGIN_VAR_TYPEMASK 0x007f
-#define PLUGIN_VAR_BOOKMARK_KEY (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_MEMALLOC)
+#define PLUGIN_VAR_TYPEMASK 0x7f
+#define BOOKMARK_MEMALLOC   0x80
+
+static inline char plugin_var_bookmark_key(uint flags)
+{
+  return (flags & PLUGIN_VAR_TYPEMASK) |
+         (flags & PLUGIN_VAR_MEMALLOC ? BOOKMARK_MEMALLOC : 0);
+}
 
 #define EXTRA_OPTIONS 3 /* options for: 'foo', 'plugin-foo' and NULL */
 
@@ -2680,7 +2727,7 @@ sys_var *find_sys_var(THD *thd, const char *str, uint length)
   {
     mysql_rwlock_unlock(&LOCK_system_variables_hash);
     LEX *lex= thd ? thd->lex : 0;
-    if (!(plugin= my_intern_plugin_lock(lex, plugin_int_to_ref(pi->plugin))))
+    if (!(plugin= intern_plugin_lock(lex, plugin_int_to_ref(pi->plugin))))
       var= NULL; /* failed to lock it, it must be uninstalling */
     else
     if (!(plugin_state(plugin) & PLUGIN_IS_READY))
@@ -2731,7 +2778,7 @@ static st_bookmark *find_bookmark(const char *plugin, const char *name,
   else
     memcpy(varname + 1, name, namelen + 1);
 
-  varname[0]= flags & PLUGIN_VAR_BOOKMARK_KEY;
+  varname[0]= plugin_var_bookmark_key(flags);
 
   result= (st_bookmark*) my_hash_search(&bookmark_hash,
                                         (const uchar*) varname, length - 1);
@@ -2789,7 +2836,7 @@ static st_bookmark *register_var(const char *plugin, const char *name,
   {
     result= (st_bookmark*) alloc_root(&plugin_mem_root,
                                       sizeof(struct st_bookmark) + length-1);
-    varname[0]= flags & PLUGIN_VAR_BOOKMARK_KEY;
+    varname[0]= plugin_var_bookmark_key(flags);
     memcpy(result->key, varname, length);
     result->name_len= length - 2;
     result->offset= -1;
@@ -2911,7 +2958,7 @@ static uchar *intern_sys_var_ptr(THD* thd, int offset, bool global_lock)
 
       if (!(var= intern_find_sys_var(v->key + 1, v->name_len)) ||
           !(pi= var->cast_pluginvar()) ||
-          v->key[0] != (pi->plugin_var->flags & PLUGIN_VAR_BOOKMARK_KEY))
+          v->key[0] != plugin_var_bookmark_key(pi->plugin_var->flags))
         continue;
 
       /* Here we do anything special that may be required of the data types */
@@ -3004,7 +3051,7 @@ void plugin_thdvar_init(THD *thd)
 
   mysql_mutex_lock(&LOCK_plugin);
   thd->variables.table_plugin=
-        my_intern_plugin_lock(NULL, global_system_variables.table_plugin);
+        intern_plugin_lock(NULL, global_system_variables.table_plugin);
   intern_plugin_unlock(NULL, old_table_plugin);
   mysql_mutex_unlock(&LOCK_plugin);
   DBUG_VOID_RETURN;
@@ -3043,7 +3090,7 @@ static void cleanup_variables(THD *thd, struct system_variables *vars)
     DBUG_ASSERT((uint)v->offset <= vars->dynamic_variables_head);
 
     if ((v->key[0] & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR &&
-         v->key[0] & PLUGIN_VAR_MEMALLOC)
+         v->key[0] & BOOKMARK_MEMALLOC)
     {
       char **ptr= (char**)(vars->dynamic_variables_ptr + v->offset);
       my_free(*ptr);
@@ -3315,8 +3362,8 @@ bool sys_var_pluginvar::global_update(THD *thd, set_var *var)
   options->block_size= (long) (opt)->blk_sz
 
 
-static void plugin_opt_set_limits(struct my_option *options,
-                                  const struct st_mysql_sys_var *opt)
+void plugin_opt_set_limits(struct my_option *options,
+                           const struct st_mysql_sys_var *opt)
 {
   options->sub_size= 0;
 
@@ -3416,17 +3463,6 @@ static void plugin_opt_set_limits(struct my_option *options,
     options->arg_type= OPT_ARG;
 }
 
-extern "C" my_bool get_one_plugin_option(int optid, const struct my_option *,
-                                         char *);
-
-my_bool get_one_plugin_option(int optid __attribute__((unused)),
-                              const struct my_option *opt,
-                              char *argument)
-{
-  return 0;
-}
-
-
 /**
   Creates a set of my_option objects associated with a specified plugin-
   handle.
@@ -3906,3 +3942,18 @@ void add_plugin_options(DYNAMIC_ARRAY *options, MEM_ROOT *mem_root)
   }
 }
 
+
+/**
+  Returns a sys_var corresponding to a particular MYSQL_SYSVAR(...)
+*/
+sys_var *find_plugin_sysvar(st_plugin_int *plugin, st_mysql_sys_var *plugin_var)
+{
+  for (sys_var *var= plugin->system_vars; var; var= var->next)
+  {
+    sys_var_pluginvar *pvar=var->cast_pluginvar();
+    if (pvar->plugin_var == plugin_var)
+      return var;
+  }
+  return 0;
+}
+
diff --git a/sql/sql_plugin.h b/sql/sql_plugin.h
index dc713826fe2..906ff20ddb7 100644
--- a/sql/sql_plugin.h
+++ b/sql/sql_plugin.h
@@ -39,6 +39,8 @@ enum enum_plugin_load_option { PLUGIN_OFF, PLUGIN_ON, PLUGIN_FORCE,
   PLUGIN_FORCE_PLUS_PERMANENT };
 extern const char *global_plugin_typelib_names[];
 
+extern ulong dlopen_count;
+
 #include <my_sys.h>
 #include "sql_list.h"
 
@@ -151,9 +153,7 @@ extern void plugin_shutdown(void);
 void add_plugin_options(DYNAMIC_ARRAY *options, MEM_ROOT *mem_root);
 extern bool plugin_is_ready(const LEX_STRING *name, int type);
 #define my_plugin_lock_by_name(A,B,C) plugin_lock_by_name(A,B,C)
-#define my_plugin_lock_by_name_ci(A,B,C) plugin_lock_by_name(A,B,C)
 #define my_plugin_lock(A,B) plugin_lock(A,B)
-#define my_plugin_lock_ci(A,B) plugin_lock(A,B)
 extern plugin_ref plugin_lock(THD *thd, plugin_ref ptr);
 extern plugin_ref plugin_lock_by_name(THD *thd, const LEX_STRING *name,
                                       int type);
@@ -166,6 +166,8 @@ extern bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name,
 extern bool plugin_register_builtin(struct st_mysql_plugin *plugin);
 extern void plugin_thdvar_init(THD *thd);
 extern void plugin_thdvar_cleanup(THD *thd);
+sys_var *find_plugin_sysvar(st_plugin_int *plugin, st_mysql_sys_var *var);
+void plugin_opt_set_limits(struct my_option *, const struct st_mysql_sys_var *);
 extern SHOW_COMP_OPTION plugin_status(const char *name, size_t len, int type);
 extern bool check_valid_path(const char *path, size_t length);
 
@@ -175,4 +177,6 @@ typedef my_bool (plugin_foreach_func)(THD *thd,
 #define plugin_foreach(A,B,C,D) plugin_foreach_with_mask(A,B,C,PLUGIN_IS_READY,D)
 extern bool plugin_foreach_with_mask(THD *thd, plugin_foreach_func *func,
                                      int type, uint state_mask, void *arg);
+extern bool plugin_dl_foreach(THD *thd, const LEX_STRING *dl,
+                              plugin_foreach_func *func, void *arg);
 #endif
diff --git a/sql/sql_plugin_compat.h b/sql/sql_plugin_compat.h
new file mode 100644
index 00000000000..8c6014f8dc6
--- /dev/null
+++ b/sql/sql_plugin_compat.h
@@ -0,0 +1,65 @@
+/* Copyright (C) 2013 Sergei Golubchik and Monty Program Ab
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+/* old plugin api structures, used for backward compatibility */
+
+#define upgrade_var(X) latest->X= X
+#define upgrade_str(X) strmake(latest->X, X, sizeof(X))
+#define downgrade_var(X) X= latest->X
+#define downgrade_str(X) strmake(X, latest->X, sizeof(X)-1)
+
+/**************************************************************/
+/* Authentication API, version 0x0100 *************************/
+#define MIN_AUTHENTICATION_INTERFACE_VERSION 0x0100
+
+struct MYSQL_SERVER_AUTH_INFO_0x0100 {
+  char *user_name;
+  unsigned int user_name_length;
+  const char *auth_string;
+  unsigned long auth_string_length;
+  char authenticated_as[49]; 
+  char external_user[512];
+  int  password_used;
+  const char *host_or_ip;
+  unsigned int host_or_ip_length;
+
+  void upgrade(MYSQL_SERVER_AUTH_INFO *latest)
+  {
+    upgrade_var(user_name);
+    upgrade_var(user_name_length);
+    upgrade_var(auth_string);
+    upgrade_var(auth_string_length);
+    upgrade_str(authenticated_as);
+    upgrade_str(external_user);
+    upgrade_var(password_used);
+    upgrade_var(host_or_ip);
+    upgrade_var(host_or_ip_length);
+  }
+  void downgrade(MYSQL_SERVER_AUTH_INFO *latest)
+  {
+    downgrade_var(user_name);
+    downgrade_var(user_name_length);
+    downgrade_var(auth_string);
+    downgrade_var(auth_string_length);
+    downgrade_str(authenticated_as);
+    downgrade_str(external_user);
+    downgrade_var(password_used);
+    downgrade_var(host_or_ip);
+    downgrade_var(host_or_ip_length);
+  }
+};
+
+/**************************************************************/
+
diff --git a/sql/sql_plugin_services.h b/sql/sql_plugin_services.h
index e3ef338eaad..d2f60a6e08c 100644
--- a/sql/sql_plugin_services.h
+++ b/sql/sql_plugin_services.h
@@ -1,4 +1,5 @@
-/* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2009, 2010, Oracle and/or its affiliates.
+   Copyright (c) 2012, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -41,11 +42,6 @@ static struct thd_wait_service_st thd_wait_handler= {
   thd_wait_end
 };
 
-static struct my_thread_scheduler_service my_thread_scheduler_handler= {
-  my_thread_scheduler_set,
-  my_thread_scheduler_reset,
-};
-
 static struct progress_report_service_st progress_report_handler= {
   thd_progress_init,
   thd_progress_report,
@@ -63,7 +59,6 @@ static struct st_service_ref list_of_services[]=
   { "my_snprintf_service",         VERSION_my_snprintf,         &my_snprintf_handler },
   { "thd_alloc_service",           VERSION_thd_alloc,           &thd_alloc_handler },
   { "thd_wait_service",            VERSION_thd_wait,            &thd_wait_handler },
-  { "my_thread_scheduler_service", VERSION_my_thread_scheduler, &my_thread_scheduler_handler },
   { "progress_report_service",     VERSION_progress_report,     &progress_report_handler },
   { "debug_sync_service",          VERSION_debug_sync,          0 }, // updated in plugin_init()
   { "thd_kill_statement_service",  VERSION_kill_statement,      &thd_kill_statement_handler }
diff --git a/sql/sql_priv.h b/sql/sql_priv.h
index 345556a0b7f..7ff13bf06c3 100644
--- a/sql/sql_priv.h
+++ b/sql/sql_priv.h
@@ -1,5 +1,5 @@
 /* Copyright (c) 2000, 2011, Oracle and/or its affiliates.
-   Copyright (c) 2010-2011 Monty Program Ab
+   Copyright (c) 2010, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -143,15 +143,15 @@
   however, needs to rollback the effects of the
   succeeded statement to keep replication consistent.
 */
-#define OPTION_MASTER_SQL_ERROR (1ULL << 35)
+#define OPTION_MASTER_SQL_ERROR         (1ULL << 35)
 
 /*
   Dont report errors for individual rows,
   But just report error on commit (or read ofcourse)
   Note! Reserved for use in MySQL Cluster
 */
-#define OPTION_ALLOW_BATCH              (ULL(1) << 36) // THD, intern (slave)
-#define OPTION_SKIP_REPLICATION         (ULL(1) << 37) // THD, user
+#define OPTION_ALLOW_BATCH              (1ULL << 36) // THD, intern (slave)
+#define OPTION_SKIP_REPLICATION         (1ULL << 37) // THD, user
 
 /*
   Check how many bytes are available on buffer.
@@ -227,7 +227,7 @@ template <class T> bool valid_buffer_range(T jump,
 #define OPTIMIZER_SWITCH_OPTIMIZE_JOIN_BUFFER_SIZE (1ULL << 25)
 #define OPTIMIZER_SWITCH_TABLE_ELIMINATION         (1ULL << 26)
 #define OPTIMIZER_SWITCH_EXTENDED_KEYS             (1ULL << 27)
-#define OPTIMIZER_SWITCH_LAST                      (1ULL << 27)
+#define OPTIMIZER_SWITCH_EXISTS_TO_IN              (1ULL << 28)
 
 #define OPTIMIZER_SWITCH_DEFAULT   (OPTIMIZER_SWITCH_INDEX_MERGE | \
                                     OPTIMIZER_SWITCH_INDEX_MERGE_UNION | \
diff --git a/sql/sql_reload.cc b/sql/sql_reload.cc
index 2720dc7cd74..e9c9dc86e41 100644
--- a/sql/sql_reload.cc
+++ b/sql/sql_reload.cc
@@ -205,6 +205,7 @@ bool reload_acl_and_cache(THD *thd, unsigned long options,
   DBUG_ASSERT(!thd || thd->locked_tables_mode ||
               !thd->mdl_context.has_locks() ||
               thd->handler_tables_hash.records ||
+              thd->ull_hash.records ||
               thd->global_read_lock.is_acquired());
 
   /*
diff --git a/sql/sql_rename.cc b/sql/sql_rename.cc
index c91623cee6e..c957076ac4f 100644
--- a/sql/sql_rename.cc
+++ b/sql/sql_rename.cc
@@ -29,10 +29,12 @@
 #include "sql_base.h"   // tdc_remove_table, lock_table_names,
 #include "sql_handler.h"                        // mysql_ha_rm_tables
 #include "sql_statistics.h" 
-#include "datadict.h"
 
 static TABLE_LIST *rename_tables(THD *thd, TABLE_LIST *table_list,
 				 bool skip_error);
+static bool do_rename(THD *thd, TABLE_LIST *ren_table, char *new_db,
+                      char *new_table_name, char *new_table_alias,
+                      bool skip_error);
 
 static TABLE_LIST *reverse_table_list(TABLE_LIST *table_list);
 
@@ -145,10 +147,6 @@ bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
                        MYSQL_OPEN_SKIP_TEMPORARY))
     goto err;
 
-  for (ren_table= table_list; ren_table; ren_table= ren_table->next_local)
-    tdc_remove_table(thd, TDC_RT_REMOVE_ALL, ren_table->db,
-                     ren_table->table_name, FALSE);
-
   error=0;
   /*
     An exclusive lock on table names is satisfactory to ensure
@@ -236,16 +234,14 @@ static TABLE_LIST *reverse_table_list(TABLE_LIST *table_list)
     true      rename failed
 */
 
-bool
+static bool
 do_rename(THD *thd, TABLE_LIST *ren_table, char *new_db, char *new_table_name,
           char *new_table_alias, bool skip_error)
 {
   int rc= 1;
-  char new_name[FN_REFLEN + 1], old_name[FN_REFLEN + 1];
+  handlerton *hton;
+  bool new_exists, old_exists;
   const char *new_alias, *old_alias;
-  frm_type_enum frm_type;
-  enum legacy_db_type table_type;
-
   DBUG_ENTER("do_rename");
 
   if (lower_case_table_names == 2)
@@ -260,53 +256,52 @@ do_rename(THD *thd, TABLE_LIST *ren_table, char *new_db, char *new_table_name,
   }
   DBUG_ASSERT(new_alias);
 
-  build_table_filename(new_name, sizeof(new_name) - 1,
-                       new_db, new_alias, reg_ext, 0);
-  build_table_filename(old_name, sizeof(old_name) - 1,
-                       ren_table->db, old_alias, reg_ext, 0);
-  if (check_table_file_presence(old_name,
-                                new_name, new_db, new_alias, new_alias, TRUE))
+  new_exists= ha_table_exists(thd, new_db, new_alias);
+
+  if (new_exists)
   {
-    DBUG_RETURN(1);			// This can't be skipped
+    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_alias);
+    DBUG_RETURN(1);                     // This can't be skipped
   }
 
-  frm_type= dd_frm_type(thd, old_name, &table_type);
-  switch (frm_type)
+  old_exists= ha_table_exists(thd, ren_table->db, old_alias, &hton);
+
+  if (old_exists)
   {
-    case FRMTYPE_TABLE:
+    DBUG_ASSERT(!thd->locked_tables_mode);
+    tdc_remove_table(thd, TDC_RT_REMOVE_ALL,
+                     ren_table->db, ren_table->table_name, false);
+
+    if (hton != view_pseudo_hton)
+    {
+      if (!(rc= mysql_rename_table(hton, ren_table->db, old_alias,
+                                   new_db, new_alias, 0)))
       {
-        if (!(rc= mysql_rename_table(ha_resolve_by_legacy_type(thd,
-                                                               table_type), 
-                                     ren_table->db, old_alias,
-                                     new_db, new_alias, 0)))
+        LEX_STRING db_name= { ren_table->db, ren_table->db_length };
+        LEX_STRING table_name= { ren_table->table_name,
+                                 ren_table->table_name_length };
+        LEX_STRING new_table= { (char *) new_alias, strlen(new_alias) };
+        (void) rename_table_in_stat_tables(thd, &db_name, &table_name,
+                                           &db_name, &new_table);
+        if ((rc= Table_triggers_list::change_table_name(thd, ren_table->db,
+                                                        old_alias,
+                                                        ren_table->table_name,
+                                                        new_db,
+                                                        new_alias)))
         {
-          LEX_STRING db_name= { ren_table->db, ren_table->db_length };
-          LEX_STRING table_name= { ren_table->table_name,
-                                   ren_table->table_name_length };
-          LEX_STRING new_table= { (char *) new_alias, strlen(new_alias) };
-          (void) rename_table_in_stat_tables(thd, &db_name, &table_name,
-                                             &db_name, &new_table);
-          if ((rc= Table_triggers_list::change_table_name(thd, ren_table->db,
-                                                          old_alias,
-                                                          ren_table->table_name,
-                                                          new_db,
-                                                          new_alias)))
-          {
-            /*
-              We've succeeded in renaming table's .frm and in updating
-              corresponding handler data, but have failed to update table's
-              triggers appropriately. So let us revert operations on .frm
-              and handler's data and report about failure to rename table.
-            */
-            (void) mysql_rename_table(ha_resolve_by_legacy_type(thd,
-                                                                table_type),
-                                      new_db, new_alias,
-                                      ren_table->db, old_alias, 0);
-          }
+          /*
+            We've succeeded in renaming table's .frm and in updating
+            corresponding handler data, but have failed to update table's
+            triggers appropriately. So let us revert operations on .frm
+            and handler's data and report about failure to rename table.
+          */
+          (void) mysql_rename_table(hton, new_db, new_alias,
+                                    ren_table->db, old_alias, 0);
         }
       }
-      break;
-    case FRMTYPE_VIEW:
+    }
+    else
+    {
       /* 
          change of schema is not allowed
          except of ALTER ...UPGRADE DATA DIRECTORY NAME command
@@ -314,22 +309,19 @@ do_rename(THD *thd, TABLE_LIST *ren_table, char *new_db, char *new_table_name,
       */
       if (thd->lex->sql_command != SQLCOM_ALTER_DB_UPGRADE &&
           strcmp(ren_table->db, new_db))
-        my_error(ER_FORBID_SCHEMA_CHANGE, MYF(0), ren_table->db, 
-                 new_db);
+        my_error(ER_FORBID_SCHEMA_CHANGE, MYF(0), ren_table->db, new_db);
       else
         rc= mysql_rename_view(thd, new_db, new_alias, ren_table);
-      break;
-    default:
-      DBUG_ASSERT(0); // should never happen
-    case FRMTYPE_ERROR:
-      my_error(ER_FILE_NOT_FOUND, MYF(0), old_name, my_errno);
-      break;
+    }
+  }
+  else
+  {
+    my_error(ER_NO_SUCH_TABLE, MYF(0), ren_table->db, old_alias);
   }
   if (rc && !skip_error)
     DBUG_RETURN(1);
 
   DBUG_RETURN(0);
-
 }
 /*
   Rename all tables in list; Return pointer to wrong entry if something goes
diff --git a/sql/sql_rename.h b/sql/sql_rename.h
index 039a3b8b4a1..aaf09a8d030 100644
--- a/sql/sql_rename.h
+++ b/sql/sql_rename.h
@@ -20,8 +20,5 @@ class THD;
 struct TABLE_LIST;
 
 bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent);
-bool do_rename(THD *thd, TABLE_LIST *ren_table, char *new_db,
-               char *new_table_name, char *new_table_alias,
-               bool skip_error);
 
 #endif /* SQL_RENAME_INCLUDED */
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index 917f4ea1a80..0bae99c2a27 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -1,5 +1,5 @@
 /* Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2008, 2012, Monty Program Ab
+   Copyright (c) 2008, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -716,7 +716,7 @@ void mysql_binlog_send(THD* thd, char* log_ident, my_off_t pos,
     *p_start_coord= &start_coord;
   LOG_POS_COORD coord_buf= { log_file_name, BIN_LOG_HEADER_SIZE },
     *p_coord= &coord_buf;
-  if (heartbeat_period != LL(0))
+  if (heartbeat_period != 0)
   {
     heartbeat_ts= &heartbeat_buf;
     set_timespec_nsec(*heartbeat_ts, 0);
@@ -966,6 +966,7 @@ impossible position";
 
       event_type=
         (Log_event_type)((uchar)(*packet)[LOG_EVENT_OFFSET+ev_offset]);
+#ifdef ENABLED_DEBUG_SYNC
       DBUG_EXECUTE_IF("dump_thread_wait_before_send_xid",
                       {
                         if (event_type == XID_EVENT)
@@ -984,6 +985,7 @@ impossible position";
                                                              STRING_WITH_LEN(act2)));
                         }
                       });
+#endif
       if (event_type == FORMAT_DESCRIPTION_EVENT)
       {
         current_checksum_alg= get_checksum_alg(packet->ptr() + ev_offset,
@@ -1348,6 +1350,8 @@ int start_slave(THD* thd , Master_info* mi,  bool net_report)
 
         if (thd->lex->mi.pos)
         {
+          if (thd->lex->mi.relay_log_pos)
+            slave_errno=ER_BAD_SLAVE_UNTIL_COND;
           mi->rli.until_condition= Relay_log_info::UNTIL_MASTER_POS;
           mi->rli.until_log_pos= thd->lex->mi.pos;
           /*
@@ -1359,6 +1363,8 @@ int start_slave(THD* thd , Master_info* mi,  bool net_report)
         }
         else if (thd->lex->mi.relay_log_pos)
         {
+          if (thd->lex->mi.pos)
+            slave_errno=ER_BAD_SLAVE_UNTIL_COND;
           mi->rli.until_condition= Relay_log_info::UNTIL_RELAY_POS;
           mi->rli.until_log_pos= thd->lex->mi.relay_log_pos;
           strmake(mi->rli.until_log_name, thd->lex->mi.relay_log_name,
@@ -1820,7 +1826,7 @@ bool change_master(THD* thd, Master_info* mi, bool *master_info_added)
   else
     mi->heartbeat_period= (float) min(SLAVE_MAX_HEARTBEAT_PERIOD,
                                       (slave_net_timeout/2.0));
-  mi->received_heartbeats= LL(0); // counter lives until master is CHANGEd
+  mi->received_heartbeats= 0; // counter lives until master is CHANGEd
   /*
     reset the last time server_id list if the current CHANGE MASTER 
     is mentioning IGNORE_SERVER_IDS= (...)
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 27b93cff189..fa82a55a8c7 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2012 Oracle and/or its affiliates.
+/* Copyright (c) 2000, 2013 Oracle and/or its affiliates.
    Copyright (c) 2009, 2013 Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
@@ -128,9 +128,10 @@ static int return_zero_rows(JOIN *join, select_result *res,
                             List<Item> &fields, bool send_row,
                             ulonglong select_options, const char *info,
                             Item *having, List<Item> &all_fields);
-static COND *build_equal_items(THD *thd, COND *cond,
+static COND *build_equal_items(JOIN *join, COND *cond,
                                COND_EQUAL *inherited,
                                List<TABLE_LIST> *join_list,
+                               bool ignore_on_conds,
                                COND_EQUAL **cond_equal_ref);
 static COND* substitute_for_best_equal_field(JOIN_TAB *context_tab,
                                              COND *cond,
@@ -146,7 +147,8 @@ static uint build_bitmap_for_nested_joins(List<TABLE_LIST> *join_list,
 
 static COND *optimize_cond(JOIN *join, COND *conds,
                            List<TABLE_LIST> *join_list,
-                           Item::cond_result *cond_value, 
+                           bool ignore_on_conds,
+			   Item::cond_result *cond_value, 
                            COND_EQUAL **cond_equal);
 bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
 static int do_select(JOIN *join,List<Item> *fields,TABLE *tmp_table,
@@ -597,28 +599,37 @@ inline int setup_without_group(THD *thd, Item **ref_pointer_array,
 			       List<Item> &all_fields,
 			       COND **conds,
 			       ORDER *order,
-			       ORDER *group, bool *hidden_group_fields)
+			       ORDER *group,
+                               bool *hidden_group_fields,
+                               uint *reserved)
 {
   int res;
-  nesting_map save_allow_sum_func=thd->lex->allow_sum_func ;
+  st_select_lex *const select= thd->lex->current_select;
+  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
   /* 
     Need to save the value, so we can turn off only any new non_agg_field_used
     additions coming from the WHERE
   */
-  const bool saved_non_agg_field_used=
-    thd->lex->current_select->non_agg_field_used();
+  const bool saved_non_agg_field_used= select->non_agg_field_used();
   DBUG_ENTER("setup_without_group");
 
-  thd->lex->allow_sum_func&= ~(1 << thd->lex->current_select->nest_level);
+  thd->lex->allow_sum_func&= ~((nesting_map)1 << select->nest_level);
   res= setup_conds(thd, tables, leaves, conds);
+  if (thd->lex->current_select->first_cond_optimization)
+  {
+    if (!res && *conds)
+      (*reserved)= (*conds)->exists2in_reserved_items();
+    else
+      (*reserved)= 0;
+  }
 
   /* it's not wrong to have non-aggregated columns in a WHERE */
-  thd->lex->current_select->set_non_agg_field_used(saved_non_agg_field_used);
+  select->set_non_agg_field_used(saved_non_agg_field_used);
 
-  thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
+  thd->lex->allow_sum_func|= (nesting_map)1 << select->nest_level;
   res= res || setup_order(thd, ref_pointer_array, tables, fields, all_fields,
                           order);
-  thd->lex->allow_sum_func&= ~(1 << thd->lex->current_select->nest_level);
+  thd->lex->allow_sum_func&= ~((nesting_map)1 << select->nest_level);
   res= res || setup_group(thd, ref_pointer_array, tables, fields, all_fields,
                           group, hidden_group_fields);
   thd->lex->allow_sum_func= save_allow_sum_func;
@@ -758,7 +769,7 @@ JOIN::prepare(Item ***rref_pointer_array,
       setup_without_group(thd, (*rref_pointer_array), tables_list,
 			  select_lex->leaf_tables, fields_list,
 			  all_fields, &conds, order, group_list,
-			  &hidden_group_fields))
+			  &hidden_group_fields, &select_lex->select_n_reserved))
     DBUG_RETURN(-1);				/* purecov: inspected */
 
   ref_pointer_array= *rref_pointer_array;
@@ -767,7 +778,7 @@ JOIN::prepare(Item ***rref_pointer_array,
   {
     nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
     thd->where="having clause";
-    thd->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
+    thd->lex->allow_sum_func|= (nesting_map)1 << select_lex_arg->nest_level;
     select_lex->having_fix_field= 1;
     /*
       Wrap alone field in HAVING clause in case it will be outer field of subquery
@@ -1038,6 +1049,23 @@ JOIN::optimize_inner()
     table_count= select_lex->leaf_tables.elements;
     select_lex->update_used_tables();
   }
+  /*
+    In fact we transform underlying subqueries after their 'prepare' phase and
+    before 'optimize' from upper query 'optimize' to allow semijoin
+    conversion happened (which done in the same way.
+  */
+  if(select_lex->first_cond_optimization &&
+     conds && conds->walk(&Item::exists2in_processor, 0, (uchar *)thd))
+    DBUG_RETURN(1);
+  /*
+TODO: make view to decide if it is possible to write to WHERE directly or make Semi-Joins able to process ON condition if it is possible
+  for (TABLE_LIST *tbl= tables_list; tbl; tbl= tbl->next_local)
+  {
+    if (tbl->on_expr &&
+        tbl->on_expr->walk(&Item::exists2in_processor, 0, (uchar *)thd))
+      DBUG_RETURN(1);
+  }
+  */
 
   if (transform_max_min_subquery())
     DBUG_RETURN(1); /* purecov: inspected */
@@ -1124,7 +1152,8 @@ JOIN::optimize_inner()
   if (setup_jtbm_semi_joins(this, join_list, &conds))
     DBUG_RETURN(1);
 
-  conds= optimize_cond(this, conds, join_list, &cond_value, &cond_equal);
+  conds= optimize_cond(this, conds, join_list, FALSE,
+                       &cond_value, &cond_equal);
      
   if (thd->is_error())
   {
@@ -1134,7 +1163,9 @@ JOIN::optimize_inner()
   }
 
   {
-    having= optimize_cond(this, having, join_list, &having_value, &having_equal);
+    having= optimize_cond(this, having, join_list, TRUE,
+                          &having_value, &having_equal);
+
     if (thd->is_error())
     {
       error= 1;
@@ -2140,8 +2171,7 @@ JOIN::reinit()
   DBUG_ENTER("JOIN::reinit");
 
   unit->offset_limit_cnt= (ha_rows)(select_lex->offset_limit ?
-                                    select_lex->offset_limit->val_uint() :
-                                    ULL(0));
+                                    select_lex->offset_limit->val_uint() : 0);
 
   first_record= 0;
   cleaned= false;
@@ -2281,6 +2311,7 @@ void JOIN::exec_inner()
 {
   List<Item> *columns_list= &fields_list;
   int      tmp_error;
+
   DBUG_ENTER("JOIN::exec");
 
   const bool has_group_by= this->group;
@@ -3813,6 +3844,7 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
     DBUG_RETURN(TRUE);
 
   join->join_tab=stat;
+  join->top_join_tab_count= table_count;
   join->map2table=stat_ref;
   join->table= table_vector;
   join->const_tables=const_count;
@@ -3860,6 +3892,8 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
   if (join->choose_subquery_plan(all_table_map & ~join->const_table_map))
     goto error;
 
+  DEBUG_SYNC(join->thd, "inside_make_join_statistics");
+
   /* Generate an execution plan from the found optimal join order. */
   DBUG_RETURN(join->thd->check_killed() || get_best_combination(join));
 
@@ -4153,7 +4187,7 @@ add_key_field(JOIN *join,
         !(field->table->pos_in_table_list->is_materialized_derived() &&
           field->table->created)) ||
        (field->table->pos_in_table_list->is_materialized_derived() &&
-        !field->table->created)))
+        !field->table->created && !(field->flags & BLOB_FLAG))))
   {
     optimize= KEY_OPTIMIZE_EQ;
   }   
@@ -5130,6 +5164,7 @@ static void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)
 }
 
 
+
 /**
   Check for the presence of AGGFN(DISTINCT a) queries that may be subject
   to loose index scan.
@@ -5456,6 +5491,8 @@ best_access_path(JOIN      *join,
                2. we won't get two ref-or-null's
           */
           if (!(remaining_tables & keyuse->used_tables) &&
+              s->access_from_tables_is_allowed(keyuse->used_tables,
+                                               join->sjm_lookup_tables) &&
               !(ref_or_null_part && (keyuse->optimize &
                                      KEY_OPTIMIZE_REF_OR_NULL)))
           {
@@ -5576,7 +5613,8 @@ best_access_path(JOIN      *join,
                 in ReuseRangeEstimateForRef-3.
               */
               if (table->quick_keys.is_set(key) &&
-                  (const_part & ((1 << table->quick_key_parts[key])-1)) ==
+                  (const_part &
+                    (((key_part_map)1 << table->quick_key_parts[key])-1)) ==
                   (((key_part_map)1 << table->quick_key_parts[key])-1) &&
                   table->quick_n_ranges[key] == 1 &&
                   records > (double) table->quick_rows[key])
@@ -5740,7 +5778,8 @@ best_access_path(JOIN      *join,
               */
               if (table->quick_keys.is_set(key) &&
                   table->quick_key_parts[key] <= max_key_part &&
-                  const_part & (1 << table->quick_key_parts[key]) &&
+                  const_part &
+                    ((key_part_map)1 << table->quick_key_parts[key]) &&
                   table->quick_n_ranges[key] == 1 + test(ref_or_null_part &
                                                          const_part) &&
                   records > (double) table->quick_rows[key])
@@ -6000,6 +6039,7 @@ static void choose_initial_table_order(JOIN *join)
   TABLE_LIST *emb_subq;
   JOIN_TAB **tab= join->best_ref + join->const_tables;
   JOIN_TAB **tabs_end= tab + join->table_count - join->const_tables;
+  DBUG_ENTER("choose_initial_table_order");
   /* Find where the top-level JOIN_TABs end and subquery JOIN_TABs start */
   for (; tab != tabs_end; tab++)
   {
@@ -6009,7 +6049,7 @@ static void choose_initial_table_order(JOIN *join)
   uint n_subquery_tabs= tabs_end - tab;
 
   if (!n_subquery_tabs)
-    return;
+    DBUG_VOID_RETURN;
 
   /* Copy the subquery JOIN_TABs to a separate array */
   JOIN_TAB *subquery_tabs[MAX_TABLES];
@@ -6064,6 +6104,7 @@ static void choose_initial_table_order(JOIN *join)
       subq_tab += n_subquery_tables - 1;
     }
   }
+  DBUG_VOID_RETURN;
 }
 
 
@@ -7993,7 +8034,9 @@ static bool create_ref_for_key(JOIN *join, JOIN_TAB *j,
     */
     do
     {
-      if (!(~used_tables & keyuse->used_tables))
+      if (!(~used_tables & keyuse->used_tables) &&
+          j->access_from_tables_is_allowed(keyuse->used_tables,
+                                           join->sjm_lookup_tables))
       {
         if  (are_tables_local(j, keyuse->val->used_tables()))
         {
@@ -8062,7 +8105,9 @@ static bool create_ref_for_key(JOIN *join, JOIN_TAB *j,
     uint i;
     for (i=0 ; i < keyparts ; keyuse++,i++)
     {
-      while (((~used_tables) & keyuse->used_tables) || 
+      while (((~used_tables) & keyuse->used_tables) ||
+	     !j->access_from_tables_is_allowed(keyuse->used_tables,
+                                               join->sjm_lookup_tables) ||    
              keyuse->keypart == NO_KEYPART ||
 	     (keyuse->keypart != 
               (is_hash_join_key_no(key) ?
@@ -8074,7 +8119,7 @@ static bool create_ref_for_key(JOIN *join, JOIN_TAB *j,
       j->ref.items[i]=keyuse->val;		// Save for cond removal
       j->ref.cond_guards[i]= keyuse->cond_guard;
       if (keyuse->null_rejecting) 
-        j->ref.null_rejecting |= 1 << i;
+        j->ref.null_rejecting|= (key_part_map)1 << i;
       keyuse_uses_no_tables= keyuse_uses_no_tables && !keyuse->used_tables;
       /*
         Todo: we should remove this check for thd->lex->describe on the next
@@ -8121,20 +8166,17 @@ static bool create_ref_for_key(JOIN *join, JOIN_TAB *j,
   ulong key_flags= j->table->actual_key_flags(keyinfo);
   if (j->type == JT_CONST)
     j->table->const_table= 1;
-  else if (((key_flags & (HA_NOSAME | HA_NULL_PART_KEY))!= HA_NOSAME) ||
-	   keyparts != j->table->actual_n_key_parts(keyinfo) ||
-           null_ref_key)
-  {
-    if (test(key_flags & HA_EXT_NOSAME) && keyparts == keyinfo->ext_key_parts &&
-        !null_ref_key)
-      j->type= JT_EQ_REF;
-    else
-    {
-      /* Must read with repeat */
-      j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;
-      j->ref.null_ref_key= null_ref_key;
-      j->ref.null_ref_part= null_ref_part;
-    }
+  else if (!((keyparts == keyinfo->key_parts && 
+              ((key_flags & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME)) ||
+	     (keyparts > keyinfo->key_parts &&   // true only for extended keys 
+              test(key_flags & HA_EXT_NOSAME) &&
+              keyparts == keyinfo->ext_key_parts)) ||
+	    null_ref_key)
+  {
+    /* Must read with repeat */
+    j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;
+    j->ref.null_ref_key= null_ref_key;
+    j->ref.null_ref_part= null_ref_part;
   }
   else if (keyuse_uses_no_tables)
   {
@@ -8285,9 +8327,9 @@ inline void add_cond_and_fix(THD *thd, Item **e1, Item *e2)
     Item *res;
     if ((res= new Item_cond_and(*e1, e2)))
     {
-      *e1= res;
       res->fix_fields(thd, 0);
       res->update_used_tables();
+      *e1= res;
     }
   }
   else
@@ -8359,7 +8401,7 @@ static void add_not_null_conds(JOIN *join)
     {
       for (uint keypart= 0; keypart < tab->ref.key_parts; keypart++)
       {
-        if (tab->ref.null_rejecting & (1 << keypart))
+        if (tab->ref.null_rejecting & ((key_part_map)1 << keypart))
         {
           Item *item= tab->ref.items[keypart];
           Item *notnull;
@@ -10543,11 +10585,14 @@ bool JOIN_TAB::preread_init()
                         dbug_serve_apcs(join->thd, 1);
                  );
 
+  /* init ftfuns for just initialized derived table */
+  if (table->fulltext_searched)
+    init_ftfuncs(join->thd, join->select_lex, test(join->order));
+
   return FALSE;
 }
 
 
-
 /**
   Build a TABLE_REF structure for index lookup in the temporary table
 
@@ -11800,7 +11845,9 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
                       item_equal->n_field_items());  
       }
 
-      ((Item_cond_and*)cond)->cond_equal= cond_equal;
+      ((Item_cond_and*)cond)->cond_equal.copy(cond_equal);
+      cond_equal.current_level=
+        ((Item_cond_and*)cond)->cond_equal.current_level;
       inherited= &(((Item_cond_and*)cond)->cond_equal);
     }
     /*
@@ -11855,6 +11902,7 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
           item_equal->update_used_tables();
           set_if_bigger(thd->lex->current_select->max_equal_elems,
                         item_equal->n_field_items());  
+          item_equal->upper_levels= inherited;
           return item_equal;
 	}
 
@@ -11877,7 +11925,8 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
           set_if_bigger(thd->lex->current_select->max_equal_elems,
                         item_equal->n_field_items());  
         }
-        and_cond->cond_equal= cond_equal;
+        and_cond->cond_equal.copy(cond_equal);
+        cond_equal.current_level= and_cond->cond_equal.current_level;
         args->concat((List<Item> *)&cond_equal.current_level);
         
         return and_cond;
@@ -11959,6 +12008,8 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
   @param inherited           path to all inherited multiple equality items
   @param join_list           list of join tables to which the condition
                              refers to
+  @ignore_on_conds           TRUE <-> do not build multiple equalities
+                             for on expressions
   @param[out] cond_equal_ref pointer to the structure to place built
                              equalities in
 
@@ -11966,10 +12017,13 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
     pointer to the transformed condition containing multiple equalities
 */
    
-static COND *build_equal_items(THD *thd, COND *cond, COND_EQUAL *inherited,
+static COND *build_equal_items(JOIN *join, COND *cond,
+                               COND_EQUAL *inherited,
                                List<TABLE_LIST> *join_list,
+                               bool ignore_on_conds,
                                COND_EQUAL **cond_equal_ref)
 {
+  THD *thd= join->thd;
   COND_EQUAL *cond_equal= 0;
 
   if (cond) 
@@ -11994,7 +12048,7 @@ static COND *build_equal_items(THD *thd, COND *cond, COND_EQUAL *inherited,
   }
   *cond_equal_ref= cond_equal;
 
-  if (join_list)
+  if (join_list && !ignore_on_conds)
   {
     TABLE_LIST *table;
     List_iterator<TABLE_LIST> li(*join_list);
@@ -12009,8 +12063,8 @@ static COND *build_equal_items(THD *thd, COND *cond, COND_EQUAL *inherited,
           We can modify table->on_expr because its old value will
           be restored before re-execution of PS/SP.
         */
-        table->on_expr= build_equal_items(thd, table->on_expr, inherited,
-                                          nested_join_list,
+        table->on_expr= build_equal_items(join, table->on_expr, inherited,
+                                          nested_join_list, ignore_on_conds,
                                           &table->cond_equal);
       }
     }
@@ -12207,11 +12261,16 @@ Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,
   Item *item_const= item_equal->get_const();
   Item_equal_fields_iterator it(*item_equal);
   Item *head;
-  DBUG_ASSERT(!cond || cond->type() == Item::COND_ITEM);
-
   TABLE_LIST *current_sjm= NULL;
   Item *current_sjm_head= NULL;
 
+  DBUG_ASSERT(!cond ||
+              cond->type() == Item::INT_ITEM ||
+              (cond->type() == Item::FUNC_ITEM &&
+               ((Item_func *) cond)->functype() == Item_func::EQ_FUNC) ||  
+              (cond->type() == Item::COND_ITEM  && 
+               ((Item_func *) cond)->functype() == Item_func::COND_AND_FUNC));
+       
   /* 
     Pick the "head" item: the constant one or the first in the join order
     (if the first in the join order happends to be inside an SJM nest, that's
@@ -12286,8 +12345,8 @@ Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,
 
     if (produce_equality)
     {
-      if (eq_item)
-        eq_list.push_back(eq_item);
+      if (eq_item && eq_list.push_back(eq_item))
+        return 0;
       
       /*
         If we're inside an SJM-nest (current_sjm!=NULL), and the multi-equality
@@ -12311,31 +12370,61 @@ Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,
     current_sjm= field_sjm;
   }
 
-  if (!cond)
+  /*
+    We have produced zero, one, or more pair-wise equalities eq_i. We want to
+    return an expression in form:
+
+      cond AND eq_1 AND eq_2 AND eq_3 AND ...
+    
+    'cond' is a parameter for this function, which may be NULL, an Item_int(1),
+    or an Item_func_eq or an Item_cond_and.
+
+    We want to return a well-formed condition: no nested Item_cond_and objects,
+    or Item_cond_and with a single child:
+    - if 'cond' is an Item_cond_and, we add eq_i as its tail
+    - if 'cond' is Item_int(1), we return eq_i
+    - otherwise, we create our own Item_cond_and and put 'cond' at the front of
+      it.
+    - if we have only one condition to return, we don't create an Item_cond_and
+  */
+
+  if (eq_item && eq_list.push_back(eq_item))
+    return 0;
+  COND *res= 0;
+  switch (eq_list.elements)
+  {
+  case 0:
+    res= cond ? cond : new Item_int((longlong) 1, 1);
+    break;
+  case 1:
+    if (!cond || cond->type() ==  Item::INT_ITEM)
+      res= eq_item;
+    break;
+  default:
+    break;
+  }
+  if (!res) 
   {
-    if (eq_list.is_empty())
+    if (cond)
     {
-      if (eq_item)
-        return eq_item;
-      return new Item_int((longlong) 1, 1);
+      if (cond->type() == Item::COND_ITEM)
+      {
+        res= cond;
+        ((Item_cond *) res)->add_at_end(&eq_list);
+      }
+      else if (eq_list.push_front(cond))
+        return 0;
     }
-    /* eq_item is always set if list is not empty */
-    DBUG_ASSERT(eq_item);
-    eq_list.push_back(eq_item);
-    if (!(cond= new Item_cond_and(eq_list)))
-      return 0;                                 // Error
-  }
-  else
+  }  
+  if (!res)
+    res= new Item_cond_and(eq_list);
+  if (res)
   {
-    if (eq_item)
-      eq_list.push_back(eq_item);
-    if (!eq_list.is_empty())
-      ((Item_cond *) cond)->add_at_head(&eq_list);
+    res->quick_fix_field();
+    res->update_used_tables();
   }
-  cond->quick_fix_field();
-  cond->update_used_tables();
-   
-  return cond;
+
+  return res;
 }
 
 
@@ -12438,31 +12527,68 @@ static COND* substitute_for_best_equal_field(JOIN_TAB *context_tab,
 
     if (and_level)
     {
+      COND *eq_cond= 0;
       List_iterator_fast<Item_equal> it(cond_equal->current_level);
+      bool false_eq_cond= FALSE;
       while ((item_equal= it++))
       {
-        cond= eliminate_item_equal(cond, cond_equal->upper_levels, item_equal);
-        // This occurs when eliminate_item_equal() founds that cond is
-        // always false and substitutes it with Item_int 0.
-        // Due to this, value of item_equal will be 0, so just return it.
-        if (!cond)
-          return org_cond;                      // Error
-        if (cond->type() != Item::COND_ITEM)
+        eq_cond= eliminate_item_equal(eq_cond, cond_equal->upper_levels,
+                                               item_equal);
+        if (!eq_cond)
+	{
+          eq_cond= 0;
+          break;
+        }
+        else if (eq_cond->type() == Item::INT_ITEM && !eq_cond->val_bool()) 
+	{
+          /*
+            This occurs when eliminate_item_equal() founds that cond is
+            always false and substitutes it with Item_int 0.
+            Due to this, value of item_equal will be 0, so just return it.
+	  */
+          cond= eq_cond;
+          false_eq_cond= TRUE;
           break;
+        }
       }
-    }
-    if (cond->type() == Item::COND_ITEM &&
-        !((Item_cond*)cond)->argument_list()->elements)
-      cond= new Item_int((int32)cond->val_bool());
-
+      if (eq_cond && !false_eq_cond)
+      {
+        /* Insert the generated equalities before all other conditions */
+        if (eq_cond->type() == Item::COND_ITEM)
+          ((Item_cond *) cond)->add_at_head(
+                                  ((Item_cond *) eq_cond)->argument_list());
+        else
+	{
+          if (cond_list->is_empty())
+            cond= eq_cond;
+          else
+	  {
+             /* Do not add an equality condition if it's always true */ 
+             if (eq_cond->type() != Item::INT_ITEM &&
+                 cond_list->push_front(eq_cond))
+               eq_cond= 0;
+          }
+	}
+      }
+      if (!eq_cond)
+      {
+        /* 
+          We are out of memory doing the transformation.
+          This is a fatal error now. However we bail out by returning the
+          original condition that we had before we started the transformation. 
+	*/
+	cond_list->concat((List<Item> *) &cond_equal->current_level);
+      }
+    }	 
   }
   else if (cond->type() == Item::FUNC_ITEM && 
            ((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)
   {
     item_equal= (Item_equal *) cond;
     item_equal->sort(&compare_fields_by_table_order, table_join_idx);
+    cond_equal= item_equal->upper_levels;
     if (cond_equal && cond_equal->current_level.head() == item_equal)
-      cond_equal= 0;
+      cond_equal= cond_equal->upper_levels;
     cond= eliminate_item_equal(0, cond_equal, item_equal);
     return cond ? cond : org_cond;
   }
@@ -12913,9 +13039,6 @@ simplify_joins(JOIN *join, List<TABLE_LIST> *join_list, COND *conds, bool top,
         table->prep_on_expr= table->on_expr= 0;
       }
     }
-    
-    if (!top)
-      continue;
 
     /* 
       Only inner tables of non-convertible outer joins
@@ -13421,7 +13544,8 @@ void optimize_wo_join_buffering(JOIN *join, uint first_tab, uint last_tab,
 
 
 static COND *
-optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,
+optimize_cond(JOIN *join, COND *conds, 
+              List<TABLE_LIST> *join_list, bool ignore_on_conds,
               Item::cond_result *cond_value, COND_EQUAL **cond_equal)
 {
   THD *thd= join->thd;
@@ -13430,7 +13554,9 @@ optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,
   if (!conds)
   {
     *cond_value= Item::COND_TRUE;
-    build_equal_items(join->thd, NULL, NULL, join_list, cond_equal);
+    if (!ignore_on_conds)
+      build_equal_items(join, NULL, NULL, join_list, ignore_on_conds,
+                        cond_equal);
   }  
   else
   {
@@ -13443,7 +13569,8 @@ optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,
       multiple equality contains a constant.
     */ 
     DBUG_EXECUTE("where", print_where(conds, "original", QT_ORDINARY););
-    conds= build_equal_items(join->thd, conds, NULL, join_list, cond_equal);
+    conds= build_equal_items(join, conds, NULL, join_list, ignore_on_conds,
+                             cond_equal);
      DBUG_EXECUTE("where",print_where(conds,"after equal_items", QT_ORDINARY););
 
     /* change field = field to field = const for each found field = const */
@@ -13499,7 +13626,61 @@ internal_remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)
 	li.remove();
       else if (item != new_item)
       {
-	(void) li.replace(new_item);
+        if (and_level)
+	{
+          /*
+            Take a special care of multiple equality predicates
+            that may be part of 'cond' and 'new_item'.
+            Those multiple equalities that have common members
+            must be merged.
+	  */  
+          Item_cond_and *cond_and= (Item_cond_and *) cond;
+          List<Item_equal> *cond_equal_items=
+            &cond_and->cond_equal.current_level;
+          List<Item> *cond_and_list= cond_and->argument_list();
+
+          if (new_item->type() == Item::COND_ITEM && 
+              ((Item_cond*) new_item)->functype() == Item_func::COND_AND_FUNC)
+          {
+            Item_cond_and *new_item_and= (Item_cond_and *) new_item;
+            List<Item_equal> *new_item_equal_items=
+              &new_item_and->cond_equal.current_level;
+            List<Item> *new_item_and_list= new_item_and->argument_list();
+            cond_and_list->disjoin((List<Item>*) cond_equal_items);
+            new_item_and_list->disjoin((List<Item>*) new_item_equal_items);
+            Item_equal *equal_item;
+            List_iterator<Item_equal> it(*new_item_equal_items);
+	    while ((equal_item= it++))
+	    {
+              equal_item->merge_into_list(cond_equal_items);
+            }
+            if (new_item_and_list->is_empty())
+              li.remove();
+            else
+              li.replace(*new_item_and_list);
+            cond_and_list->concat((List<Item>*) cond_equal_items); 
+          }
+          else if (new_item->type() == Item::FUNC_ITEM && 
+                   ((Item_cond*) new_item)->functype() ==
+                   Item_func::MULT_EQUAL_FUNC)
+	  {
+            cond_and_list->disjoin((List<Item>*) cond_equal_items);
+            ((Item_equal *) new_item)->merge_into_list(cond_equal_items);
+            li.remove();
+            cond_and_list->concat((List<Item>*) cond_equal_items); 
+          }
+          else
+            li.replace(new_item);
+        }
+        else
+	{ 
+          if (new_item->type() == Item::COND_ITEM &&
+              ((Item_cond*) new_item)->functype() == 
+              ((Item_cond*) cond)->functype())
+            li.replace(*((Item_cond*) new_item)->argument_list());
+	  else
+            li.replace(new_item);
+        } 
 	should_fix_fields=1;
       }
       if (*cond_value == Item::COND_UNDEF)
@@ -14078,6 +14259,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
   }
   case Item::FIELD_ITEM:
   case Item::DEFAULT_VALUE_ITEM:
+  case Item::INSERT_VALUE_ITEM:
   {
     Item_field *field= (Item_field*) item;
     bool orig_modify= modify_item;
@@ -14756,11 +14938,11 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
       }
       else
       {
-	recinfo->null_bit= 1 << (null_count & 7);
+	recinfo->null_bit= (uint8)1 << (null_count & 7);
 	recinfo->null_pos= null_count/8;
       }
       field->move_field(pos,null_flags+null_count/8,
-			1 << (null_count & 7));
+			(uint8)1 << (null_count & 7));
       null_count++;
     }
     else
@@ -15214,7 +15396,7 @@ TABLE *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list)
       {
         cur_field->move_field(field_pos, (uchar*) null_pos, null_bit);
         null_bit<<= 1;
-        if (null_bit == (1 << 8))
+        if (null_bit == (uint)1 << 8)
         {
           ++null_pos;
           null_bit= 1;
@@ -16335,7 +16517,9 @@ evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
   DBUG_ENTER("evaluate_join_record");
   DBUG_PRINT("enter",
              ("evaluate_join_record join: %p join_tab: %p"
-              " cond: %p error: %d", join, join_tab, select_cond, error));
+              " cond: %p error: %d  alias %s",
+              join, join_tab, select_cond, error,
+              join_tab->table->alias.ptr()));
   if (error > 0 || (join->thd->is_error()))     // Fatal error
     DBUG_RETURN(NESTED_LOOP_ERROR);
   if (error < 0)
@@ -16448,6 +16632,7 @@ evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
     if (join_tab->check_weed_out_table && found)
     {
       int res= join_tab->check_weed_out_table->sj_weedout_check_row(join->thd);
+      DBUG_PRINT("info", ("weedout_check: %d", res));
       if (res == -1)
         DBUG_RETURN(NESTED_LOOP_ERROR);
       else if (res == 1)
@@ -16468,8 +16653,8 @@ evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
       (See above join->return_tab= tab).
     */
     join->examined_rows++;
-    DBUG_PRINT("counts", ("join->examined_rows++: %lu",
-                          (ulong) join->examined_rows));
+    DBUG_PRINT("counts", ("join->examined_rows++: %lu  found: %d",
+                          (ulong) join->examined_rows, (int) found));
 
     if (found)
     {
@@ -19237,7 +19422,6 @@ create_sort_index(THD *thd, JOIN *join, ORDER *order,
 
   *(join->pre_sort_join_tab)= *tab;
   
-
   tab->select=NULL;
   tab->set_select_cond(NULL, __LINE__);
   tab->type=JT_ALL;				// Read with normal read_record
diff --git a/sql/sql_select.h b/sql/sql_select.h
index 54aca3c4829..c748a4f5101 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -1,8 +1,8 @@
 #ifndef SQL_SELECT_INCLUDED
 #define SQL_SELECT_INCLUDED
 
-/* Copyright (c) 2000, 2011, Oracle and/or its affiliates.
-   Copyright (c) 2008-2011 Monty Program Ab
+/* Copyright (c) 2000, 2013, Oracle and/or its affiliates.
+   Copyright (c) 2008, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -514,6 +514,16 @@ typedef struct st_join_table {
   bool preread_init();
 
   bool is_sjm_nest() { return test(bush_children); }
+
+  bool access_from_tables_is_allowed(table_map used_tables,
+                                     table_map sjm_lookup_tables)
+  {
+    table_map used_sjm_lookup_tables= used_tables & sjm_lookup_tables;
+    return !used_sjm_lookup_tables ||
+           (emb_sj_nest && 
+            !(used_sjm_lookup_tables & ~emb_sj_nest->sj_inner_tables));
+  }
+
 } JOIN_TAB;
 
 
@@ -964,6 +974,11 @@ public:
   bool     hash_join;
   bool	   do_send_rows;
   table_map const_table_map;
+  /** 
+    Bitmap of semijoin tables that the current partial plan decided
+    to materialize and access by lookups
+  */
+  table_map sjm_lookup_tables;
   /*
     Constant tables for which we have found a row (as opposed to those for
     which we didn't).
@@ -1295,8 +1310,9 @@ public:
     outer_ref_cond= pseudo_bits_cond= NULL;
     in_to_exists_where= NULL;
     in_to_exists_having= NULL;
-
     pre_sort_join_tab= NULL;
+    emb_sjm_nest= NULL;
+    sjm_lookup_tables= 0;
   }
 
   int prepare(Item ***rref_pointer_array, TABLE_LIST *tables, uint wind_num,
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 1f860fe23db..84da93a2131 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -1,5 +1,5 @@
 /* Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2009, 2012, Monty Program Ab
+   Copyright (c) 2009, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -57,11 +57,8 @@
 #include <my_dir.h>
 #include "lock.h"                           // MYSQL_OPEN_IGNORE_FLUSH
 #include "debug_sync.h"
-#include "datadict.h"   // dd_frm_type()
 #include "keycaches.h"
 
-#define STR_OR_NIL(S) ((S) ? (S) : "<nil>")
-
 #ifdef WITH_PARTITION_STORAGE_ENGINE
 #include "ha_partition.h"
 #endif
@@ -122,6 +119,14 @@ append_algorithm(TABLE_LIST *table, String *buff);
 
 static COND * make_cond_for_info_schema(COND *cond, TABLE_LIST *table);
 
+typedef struct st_lookup_field_values
+{
+  LEX_STRING db_value, table_value;
+  bool wild_db_value, wild_table_value;
+} LOOKUP_FIELD_VALUES;
+
+bool get_lookup_field_values(THD *, COND *, TABLE_LIST *, LOOKUP_FIELD_VALUES *);
+
 /***************************************************************************
 ** List all table types supported
 ***************************************************************************/
@@ -160,7 +165,6 @@ static my_bool show_plugins(THD *thd, plugin_ref plugin,
         cs);
 
   switch (plugin_state(plugin)) {
-  /* case PLUGIN_IS_FREED: does not happen */
   case PLUGIN_IS_DELETED:
     table->field[2]->store(STRING_WITH_LEN("DELETED"), cs);
     break;
@@ -173,6 +177,9 @@ static my_bool show_plugins(THD *thd, plugin_ref plugin,
   case PLUGIN_IS_DISABLED:
     table->field[2]->store(STRING_WITH_LEN("DISABLED"), cs);
     break;
+  case PLUGIN_IS_FREED: // filtered in fill_plugins, used in fill_all_plugins
+    table->field[2]->store(STRING_WITH_LEN("NOT INSTALLED"), cs);
+    break;
   default:
     DBUG_ASSERT(0);
   }
@@ -270,6 +277,65 @@ int fill_plugins(THD *thd, TABLE_LIST *tables, COND *cond)
 }
 
 
+int fill_all_plugins(THD *thd, TABLE_LIST *tables, COND *cond)
+{
+  DBUG_ENTER("fill_all_plugins");
+  TABLE *table= tables->table;
+  LOOKUP_FIELD_VALUES lookup;
+
+  if (get_lookup_field_values(thd, cond, tables, &lookup))
+    DBUG_RETURN(0);
+
+  if (lookup.db_value.str && !lookup.db_value.str[0])
+    DBUG_RETURN(0); // empty string never matches a valid SONAME
+
+  MY_DIR *dirp= my_dir(opt_plugin_dir, MY_THREAD_SPECIFIC);
+  if (!dirp)
+  {
+    my_error(ER_CANT_READ_DIR, MYF(0), opt_plugin_dir, my_errno);
+    DBUG_RETURN(1);
+  }
+
+  if (!lookup.db_value.str)
+    plugin_dl_foreach(thd, 0, show_plugins, table);
+
+  const char *wstr= lookup.db_value.str, *wend= wstr + lookup.db_value.length;
+  for (uint i=0; i < (uint) dirp->number_of_files; i++)
+  {
+    FILEINFO *file= dirp->dir_entry+i;
+    LEX_STRING dl= { file->name, strlen(file->name) };
+    const char *dlend= dl.str + dl.length;
+    const size_t so_ext_len= sizeof(SO_EXT) - 1;
+
+    if (strcasecmp(dlend - so_ext_len, SO_EXT))
+      continue;
+
+    if (lookup.db_value.str)
+    {
+      if (lookup.wild_db_value)
+      {
+        if (my_wildcmp(files_charset_info, dl.str, dlend, wstr, wend,
+                       wild_prefix, wild_one, wild_many))
+          continue;
+      }
+      else
+      {
+        if (my_strnncoll(files_charset_info,
+                         (uchar*)dl.str, dl.length,
+                         (uchar*)lookup.db_value.str, lookup.db_value.length))
+          continue;
+      }
+    }
+
+    plugin_dl_foreach(thd, &dl, show_plugins, table);
+    thd->clear_error();
+  }
+
+  my_dirend(dirp);
+  DBUG_RETURN(0);
+}
+
+
 /***************************************************************************
 ** List all Authors.
 ** If you can update it, you get to be in it :)
@@ -689,6 +755,11 @@ db_name_is_in_ignore_db_dirs_list(const char *directory)
   return my_hash_search(&ignore_db_dirs_hash, (uchar *) buff, buff_len)!=NULL;
 }
 
+enum find_files_result {
+  FIND_FILES_OK,
+  FIND_FILES_OOM,
+  FIND_FILES_DIR
+};
 
 /*
   find_files() - find files in a given directory.
@@ -697,11 +768,10 @@ db_name_is_in_ignore_db_dirs_list(const char *directory)
     find_files()
     thd                 thread handler
     files               put found files in this list
-    db                  database name to set in TABLE_LIST structure
+    db                  database name to search tables in
+                        or NULL to search for databases
     path                path to database
     wild                filter for found files
-    dir                 read databases in path if TRUE, read .frm files in
-                        database otherwise
 
   RETURN
     FIND_FILES_OK       success
@@ -710,65 +780,40 @@ db_name_is_in_ignore_db_dirs_list(const char *directory)
 */
 
 
-find_files_result
-find_files(THD *thd, List<LEX_STRING> *files, const char *db,
-           const char *path, const char *wild, bool dir)
+static find_files_result
+find_files(THD *thd, Dynamic_array<LEX_STRING*> *files, LEX_STRING *db,
+           const char *path, const LEX_STRING *wild)
 {
-  uint i;
-  char *ext;
   MY_DIR *dirp;
-  FILEINFO *file;
-  LEX_STRING *file_name= 0;
-  uint file_name_len;
-#ifndef NO_EMBEDDED_ACCESS_CHECKS
-  uint col_access=thd->col_access;
-#endif
-  uint wild_length= 0;
-  TABLE_LIST table_list;
+  Discovered_table_list tl(thd, files, wild);
   DBUG_ENTER("find_files");
 
-  if (wild)
-  {
-    if (!wild[0])
-      wild= 0;
-    else
-      wild_length= strlen(wild);
-  }
-
-  bzero((char*) &table_list,sizeof(table_list));
-
-  if (!(dirp = my_dir(path,MYF((dir ? MY_WANT_STAT : 0) |
-                               MY_THREAD_SPECIFIC))))
+  if (!(dirp = my_dir(path, MY_THREAD_SPECIFIC | (db ? 0 : MY_WANT_STAT))))
   {
     if (my_errno == ENOENT)
-      my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), db);
+      my_error(ER_BAD_DB_ERROR, MYF(ME_BELL | ME_WAITTANG), db->str);
     else
-      my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), path, my_errno);
+      my_error(ER_CANT_READ_DIR, MYF(ME_BELL | ME_WAITTANG), path, my_errno);
     DBUG_RETURN(FIND_FILES_DIR);
   }
 
-  for (i=0 ; i < (uint) dirp->number_off_files  ; i++)
+  if (!db)                                           /* Return databases */
   {
-    char uname[SAFE_NAME_LEN + 1];              /* Unencoded name */
-    file=dirp->dir_entry+i;
-    if (dir)
-    {                                           /* Return databases */
-      if ((file->name[0] == '.' &&
-          ((file->name[1] == '.' && file->name[2] == '\0') ||
-            file->name[1] == '\0')))
-        continue;                               /* . or .. */
+    for (uint i=0; i < (uint) dirp->number_of_files; i++)
+    {
+      FILEINFO *file= dirp->dir_entry+i;
 #ifdef USE_SYMDIR
       char *ext;
       char buff[FN_REFLEN];
       if (my_use_symdir && !strcmp(ext=fn_ext(file->name), ".sym"))
       {
-	/* Only show the sym file if it points to a directory */
-	char *end;
+        /* Only show the sym file if it points to a directory */
+        char *end;
         *ext=0;                                 /* Remove extension */
-	unpack_dirname(buff, file->name);
-	end= strend(buff);
-	if (end != buff && end[-1] == FN_LIBCHAR)
-	  end[-1]= 0;				// Remove end FN_LIBCHAR
+        unpack_dirname(buff, file->name);
+        end= strend(buff);
+        if (end != buff && end[-1] == FN_LIBCHAR)
+          end[-1]= 0;				// Remove end FN_LIBCHAR
         if (!mysql_file_stat(key_file_misc, buff, file->mystat, MYF(0)))
                continue;
        }
@@ -779,70 +824,25 @@ find_files(THD *thd, List<LEX_STRING> *files, const char *db,
       if (is_in_ignore_db_dirs_list(file->name))
         continue;
 
-      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));
-      if (wild)
-      {
-	if (lower_case_table_names)
-	{
-          if (my_wildcmp(files_charset_info,
-                         uname, uname + file_name_len,
-                         wild, wild + wild_length,
-                         wild_prefix, wild_one, wild_many))
-            continue;
-	}
-	else if (wild_compare(uname, wild, 0))
-	  continue;
-      }
-    }
-    else
-    {
-        // Return only .frm files which aren't temp files.
-      if (my_strcasecmp(system_charset_info, ext=fn_rext(file->name),reg_ext) ||
-          is_prefix(file->name, tmp_file_prefix))
-        continue;
-      *ext=0;
-      file_name_len= filename_to_tablename(file->name, uname, sizeof(uname));
-      if (wild)
-      {
-	if (lower_case_table_names)
-	{
-          if (my_wildcmp(files_charset_info,
-                         uname, uname + file_name_len,
-                         wild, wild + wild_length,
-                         wild_prefix, wild_one,wild_many))
-            continue;
-	}
-	else if (wild_compare(uname, wild, 0))
-	  continue;
-      }
-    }
-#ifndef NO_EMBEDDED_ACCESS_CHECKS
-    /* Don't show tables where we don't have any privileges */
-    if (db && !(col_access & TABLE_ACLS))
-    {
-      table_list.db= (char*) db;
-      table_list.db_length= strlen(db);
-      table_list.table_name= uname;
-      table_list.table_name_length= file_name_len;
-      table_list.grant.privilege=col_access;
-      if (check_grant(thd, TABLE_ACLS, &table_list, TRUE, 1, TRUE))
-        continue;
-    }
-#endif
-    if (!(file_name=
-          thd->make_lex_string(file_name, uname, file_name_len, TRUE)) ||
-        files->push_back(file_name))
-    {
-      my_dirend(dirp);
-      DBUG_RETURN(FIND_FILES_OOM);
+      if (tl.add_file(file->name))
+        goto err;
     }
+    tl.sort();
+  }
+  else
+  {
+    if (ha_discover_table_names(thd, db, dirp, &tl))
+      goto err;
   }
-  DBUG_PRINT("info",("found: %d files", files->elements));
-  my_dirend(dirp);
 
-  (void) ha_find_files(thd, db, path, wild, dir, files);
+  DBUG_PRINT("info",("found: %zu files", files->elements()));
+  my_dirend(dirp);
 
   DBUG_RETURN(FIND_FILES_OK);
+
+err:
+  my_dirend(dirp);
+  DBUG_RETURN(FIND_FILES_OOM);
 }
 
 
@@ -2626,7 +2626,7 @@ static bool status_vars_inited= 0;
 C_MODE_START
 static int show_var_cmp(const void *var1, const void *var2)
 {
-  return strcmp(((SHOW_VAR*)var1)->name, ((SHOW_VAR*)var2)->name);
+  return strcasecmp(((SHOW_VAR*)var1)->name, ((SHOW_VAR*)var2)->name);
 }
 C_MODE_END
 
@@ -2831,6 +2831,17 @@ static bool show_status_array(THD *thd, const char *wild,
     name_buffer[sizeof(name_buffer)-1]=0;       /* Safety */
     if (ucase_names)
       my_caseup_str(system_charset_info, name_buffer);
+    else
+    {
+      my_casedn_str(system_charset_info, name_buffer);
+      DBUG_ASSERT(name_buffer[0] >= 'a');
+      DBUG_ASSERT(name_buffer[0] <= 'z');
+
+      /* traditionally status variables have a first letter uppercased */
+      if (status_var)
+        name_buffer[0]-= 'a' - 'A';
+    }
+
 
     restore_record(table, s->default_values);
     table->field[0]->store(name_buffer, strlen(name_buffer),
@@ -3152,8 +3163,8 @@ int fill_schema_user_stats(THD* thd, TABLE_LIST* tables, COND* cond)
   int result;
   DBUG_ENTER("fill_schema_user_stats");
 
-  if (check_global_access(thd, SUPER_ACL | PROCESS_ACL))
-    DBUG_RETURN(1);
+  if (check_global_access(thd, SUPER_ACL | PROCESS_ACL, true))
+    DBUG_RETURN(0);
 
   /*
     Iterates through all the global stats and sends them to the client.
@@ -3187,8 +3198,8 @@ int fill_schema_client_stats(THD* thd, TABLE_LIST* tables, COND* cond)
   int result;
   DBUG_ENTER("fill_schema_client_stats");
 
-  if (check_global_access(thd, SUPER_ACL | PROCESS_ACL))
-    DBUG_RETURN(1);
+  if (check_global_access(thd, SUPER_ACL | PROCESS_ACL, true))
+    DBUG_RETURN(0);
 
   /*
     Iterates through all the global stats and sends them to the client.
@@ -3329,13 +3340,6 @@ void calc_sum_of_all_status(STATUS_VAR *to)
 /* This is only used internally, but we need it here as a forward reference */
 extern ST_SCHEMA_TABLE schema_tables[];
 
-typedef struct st_lookup_field_values
-{
-  LEX_STRING db_value, table_value;
-  bool wild_db_value, wild_table_value;
-} LOOKUP_FIELD_VALUES;
-
-
 /*
   Store record to I_S table, convert HEAP table
   to MyISAM if necessary
@@ -3443,8 +3447,8 @@ bool get_lookup_value(THD *thd, Item_func *item_func,
                                (uchar *) item_field->field_name,
                                strlen(item_field->field_name), 0))
     {
-      thd->make_lex_string(&lookup_field_vals->db_value, tmp_str->ptr(),
-                           tmp_str->length(), FALSE);
+      thd->make_lex_string(&lookup_field_vals->db_value,
+                           tmp_str->ptr(), tmp_str->length());
     }
     /* Lookup value is table name */
     else if (!cs->coll->strnncollsp(cs, (uchar *) field_name2,
@@ -3452,8 +3456,8 @@ bool get_lookup_value(THD *thd, Item_func *item_func,
                                     (uchar *) item_field->field_name,
                                     strlen(item_field->field_name), 0))
     {
-      thd->make_lex_string(&lookup_field_vals->table_value, tmp_str->ptr(),
-                           tmp_str->length(), FALSE);
+      thd->make_lex_string(&lookup_field_vals->table_value,
+                           tmp_str->ptr(), tmp_str->length());
     }
   }
   return 0;
@@ -3630,7 +3634,7 @@ bool get_lookup_field_values(THD *thd, COND *cond, TABLE_LIST *tables,
                              LOOKUP_FIELD_VALUES *lookup_field_values)
 {
   LEX *lex= thd->lex;
-  const char *wild= lex->wild ? lex->wild->ptr() : NullS;
+  String *wild= lex->wild;
   bool rc= 0;
 
   bzero((char*) lookup_field_values, sizeof(LOOKUP_FIELD_VALUES));
@@ -3638,8 +3642,8 @@ bool get_lookup_field_values(THD *thd, COND *cond, TABLE_LIST *tables,
   case SQLCOM_SHOW_DATABASES:
     if (wild)
     {
-      thd->make_lex_string(&lookup_field_values->db_value, 
-                           wild, strlen(wild), 0);
+      thd->make_lex_string(&lookup_field_values->db_value,
+                           wild->ptr(), wild->length());
       lookup_field_values->wild_db_value= 1;
     }
     break;
@@ -3648,14 +3652,25 @@ bool get_lookup_field_values(THD *thd, COND *cond, TABLE_LIST *tables,
   case SQLCOM_SHOW_TRIGGERS:
   case SQLCOM_SHOW_EVENTS:
     thd->make_lex_string(&lookup_field_values->db_value, 
-                         lex->select_lex.db, strlen(lex->select_lex.db), 0);
+                         lex->select_lex.db, strlen(lex->select_lex.db));
     if (wild)
     {
       thd->make_lex_string(&lookup_field_values->table_value, 
-                           wild, strlen(wild), 0);
+                           wild->ptr(), wild->length());
       lookup_field_values->wild_table_value= 1;
     }
     break;
+  case SQLCOM_SHOW_PLUGINS:
+    if (lex->ident.str)
+      thd->make_lex_string(&lookup_field_values->db_value, 
+                           lex->ident.str, lex->ident.length);
+    else if (lex->wild)
+    {
+      thd->make_lex_string(&lookup_field_values->db_value, 
+                           lex->wild->ptr(), lex->wild->length());
+      lookup_field_values->wild_db_value= 1;
+    }
+    break;
   default:
     /*
       The "default" is for queries over I_S.
@@ -3698,23 +3713,15 @@ enum enum_schema_tables get_schema_table_idx(ST_SCHEMA_TABLE *schema_table)
     wild                  wild string
     idx_field_vals        idx_field_vals->db_name contains db name or
                           wild string
-    with_i_schema         returns 1 if we added 'IS' name to list
-                          otherwise returns 0
 
   RETURN
     zero                  success
     non-zero              error
 */
 
-int make_db_list(THD *thd, List<LEX_STRING> *files,
-                 LOOKUP_FIELD_VALUES *lookup_field_vals,
-                 bool *with_i_schema)
+int make_db_list(THD *thd, Dynamic_array<LEX_STRING*> *files,
+                 LOOKUP_FIELD_VALUES *lookup_field_vals)
 {
-  LEX_STRING *i_s_name_copy= 0;
-  i_s_name_copy= thd->make_lex_string(i_s_name_copy,
-                                      INFORMATION_SCHEMA_NAME.str,
-                                      INFORMATION_SCHEMA_NAME.length, TRUE);
-  *with_i_schema= 0;
   if (lookup_field_vals->wild_db_value)
   {
     /*
@@ -3727,12 +3734,11 @@ int make_db_list(THD *thd, List<LEX_STRING> *files,
                            INFORMATION_SCHEMA_NAME.str,
                            lookup_field_vals->db_value.str))
     {
-      *with_i_schema= 1;
-      if (files->push_back(i_s_name_copy))
+      if (files->append_val(&INFORMATION_SCHEMA_NAME))
         return 1;
     }
-    return (find_files(thd, files, NullS, mysql_data_home,
-                       lookup_field_vals->db_value.str, 1) != FIND_FILES_OK);
+    return find_files(thd, files, 0, mysql_data_home,
+                      &lookup_field_vals->db_value);
   }
 
 
@@ -3748,12 +3754,11 @@ int make_db_list(THD *thd, List<LEX_STRING> *files,
     if (is_infoschema_db(lookup_field_vals->db_value.str,
                          lookup_field_vals->db_value.length))
     {
-      *with_i_schema= 1;
-      if (files->push_back(i_s_name_copy))
+      if (files->append_val(&INFORMATION_SCHEMA_NAME))
         return 1;
       return 0;
     }
-    if (files->push_back(&lookup_field_vals->db_value))
+    if (files->append_val(&lookup_field_vals->db_value))
       return 1;
     return 0;
   }
@@ -3762,17 +3767,15 @@ int make_db_list(THD *thd, List<LEX_STRING> *files,
     Create list of existing databases. It is used in case
     of select from information schema table
   */
-  if (files->push_back(i_s_name_copy))
+  if (files->append_val(&INFORMATION_SCHEMA_NAME))
     return 1;
-  *with_i_schema= 1;
-  return (find_files(thd, files, NullS,
-                     mysql_data_home, NullS, 1) != FIND_FILES_OK);
+  return find_files(thd, files, 0, mysql_data_home, &null_lex_str);
 }
 
 
 struct st_add_schema_table
 {
-  List<LEX_STRING> *files;
+  Dynamic_array<LEX_STRING*> *files;
   const char *wild;
 };
 
@@ -3782,7 +3785,7 @@ static my_bool add_schema_table(THD *thd, plugin_ref plugin,
 {
   LEX_STRING *file_name= 0;
   st_add_schema_table *data= (st_add_schema_table *)p_data;
-  List<LEX_STRING> *file_list= data->files;
+  Dynamic_array<LEX_STRING*> *file_list= data->files;
   const char *wild= data->wild;
   ST_SCHEMA_TABLE *schema_table= plugin_data(plugin, ST_SCHEMA_TABLE *);
   DBUG_ENTER("add_schema_table");
@@ -3802,16 +3805,16 @@ static my_bool add_schema_table(THD *thd, plugin_ref plugin,
       DBUG_RETURN(0);
   }
 
-  if ((file_name= thd->make_lex_string(file_name, schema_table->table_name,
-                                       strlen(schema_table->table_name),
-                                       TRUE)) &&
-      !file_list->push_back(file_name))
+  if ((file_name= thd->make_lex_string(schema_table->table_name,
+                                       strlen(schema_table->table_name))) &&
+      !file_list->append(file_name))
     DBUG_RETURN(0);
   DBUG_RETURN(1);
 }
 
 
-int schema_tables_add(THD *thd, List<LEX_STRING> *files, const char *wild)
+int schema_tables_add(THD *thd, Dynamic_array<LEX_STRING*> *files,
+                      const char *wild)
 {
   LEX_STRING *file_name= 0;
   ST_SCHEMA_TABLE *tmp_schema_table= schema_tables;
@@ -3835,9 +3838,9 @@ int schema_tables_add(THD *thd, List<LEX_STRING> *files, const char *wild)
         continue;
     }
     if ((file_name=
-         thd->make_lex_string(file_name, tmp_schema_table->table_name,
-                              strlen(tmp_schema_table->table_name), TRUE)) &&
-        !files->push_back(file_name))
+         thd->make_lex_string(tmp_schema_table->table_name,
+                              strlen(tmp_schema_table->table_name))) &&
+        !files->append(file_name))
       continue;
     DBUG_RETURN(1);
   }
@@ -3862,7 +3865,6 @@ int schema_tables_add(THD *thd, List<LEX_STRING> *files, const char *wild)
   @param[in]      table_names           List of table names in database
   @param[in]      lex                   pointer to LEX struct
   @param[in]      lookup_field_vals     pointer to LOOKUP_FIELD_VALUE struct
-  @param[in]      with_i_schema         TRUE means that we add I_S tables to list
   @param[in]      db_name               database name
 
   @return         Operation status
@@ -3872,40 +3874,32 @@ int schema_tables_add(THD *thd, List<LEX_STRING> *files, const char *wild)
 */
 
 static int
-make_table_name_list(THD *thd, List<LEX_STRING> *table_names, LEX *lex,
-                     LOOKUP_FIELD_VALUES *lookup_field_vals,
-                     bool with_i_schema, LEX_STRING *db_name)
+make_table_name_list(THD *thd, Dynamic_array<LEX_STRING*> *table_names,
+                     LEX *lex, LOOKUP_FIELD_VALUES *lookup_field_vals,
+                     LEX_STRING *db_name)
 {
   char path[FN_REFLEN + 1];
   build_table_filename(path, sizeof(path) - 1, db_name->str, "", "", 0);
   if (!lookup_field_vals->wild_table_value &&
       lookup_field_vals->table_value.str)
   {
-    if (with_i_schema)
+    if (db_name == &INFORMATION_SCHEMA_NAME)
     {
       LEX_STRING *name;
       ST_SCHEMA_TABLE *schema_table=
         find_schema_table(thd, lookup_field_vals->table_value.str);
       if (schema_table && !schema_table->hidden)
       {
-        if (!(name= 
-              thd->make_lex_string(NULL, schema_table->table_name,
-                                   strlen(schema_table->table_name), TRUE)) ||
-            table_names->push_back(name))
+        if (!(name= thd->make_lex_string(schema_table->table_name,
+                                         strlen(schema_table->table_name))) ||
+            table_names->append(name))
           return 1;
       }
     }
     else
     {
-      if (table_names->push_back(&lookup_field_vals->table_value))
+      if (table_names->append_val(&lookup_field_vals->table_value))
         return 1;
-      /*
-        Check that table is relevant in current transaction.
-        (used for ndb engine, see ndbcluster_find_files(), ha_ndbcluster.cc)
-      */
-      (void) ha_find_files(thd, db_name->str, path,
-                         lookup_field_vals->table_value.str, 0,
-                         table_names);
     }
     return 0;
   }
@@ -3914,12 +3908,12 @@ make_table_name_list(THD *thd, List<LEX_STRING> *table_names, LEX *lex,
     This call will add all matching the wildcards (if specified) IS tables
     to the list
   */
-  if (with_i_schema)
+  if (db_name == &INFORMATION_SCHEMA_NAME)
     return (schema_tables_add(thd, table_names,
                               lookup_field_vals->table_value.str));
 
-  find_files_result res= find_files(thd, table_names, db_name->str, path,
-                                    lookup_field_vals->table_value.str, 0);
+  find_files_result res= find_files(thd, table_names, db_name, path,
+                                    &lookup_field_vals->table_value);
   if (res != FIND_FILES_OK)
   {
     /*
@@ -4015,10 +4009,10 @@ fill_schema_table_by_open(THD *thd, bool is_show_fields_or_keys,
     These copies are used for make_table_list() while unaltered values
     are passed to process_table() functions.
   */
-  if (!thd->make_lex_string(&db_name, orig_db_name->str,
-                            orig_db_name->length, FALSE) ||
-      !thd->make_lex_string(&table_name, orig_table_name->str,
-                            orig_table_name->length, FALSE))
+  if (!thd->make_lex_string(&db_name,
+                            orig_db_name->str, orig_db_name->length) ||
+      !thd->make_lex_string(&table_name,
+                            orig_table_name->str, orig_table_name->length))
     goto end;
 
   /*
@@ -4085,12 +4079,14 @@ fill_schema_table_by_open(THD *thd, bool is_show_fields_or_keys,
     of backward compatibility.
   */
   if (!is_show_fields_or_keys && result && thd->is_error() &&
-      thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE)
+      (thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE ||
+       thd->stmt_da->sql_errno() == ER_WRONG_OBJECT))
   {
     /*
       Hide error for a non-existing table.
       For example, this error can occur when we use a where condition
-      with a db name and table, but the table does not exist.
+      with a db name and table, but the table does not exist or
+      there is a view with the same name.
     */
     result= false;
     thd->clear_error();
@@ -4142,7 +4138,6 @@ end:
   @param[in]      table                    TABLE struct for I_S table
   @param[in]      db_name                  database name
   @param[in]      table_name               table name
-  @param[in]      with_i_schema            I_S table if TRUE
 
   @return         Operation status
     @retval       0           success
@@ -4150,37 +4145,28 @@ end:
 */
 
 static int fill_schema_table_names(THD *thd, TABLE_LIST *tables,
-                                   LEX_STRING *db_name, LEX_STRING *table_name,
-                                   bool with_i_schema)
+                                   LEX_STRING *db_name, LEX_STRING *table_name)
 {
   TABLE *table= tables->table;
-  if (with_i_schema)
+  if (db_name == &INFORMATION_SCHEMA_NAME)
   {
     table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"),
                            system_charset_info);
   }
   else if (tables->table_open_method != SKIP_OPEN_TABLE)
   {
-    enum legacy_db_type not_used;
-    char path[FN_REFLEN + 1];
-    (void) build_table_filename(path, sizeof(path) - 1, db_name->str, 
-                                table_name->str, reg_ext, 0);
-    switch (dd_frm_type(thd, path, &not_used)) {
-    case FRMTYPE_ERROR:
-      table->field[3]->store(STRING_WITH_LEN("ERROR"),
-                             system_charset_info);
-      break;
-    case FRMTYPE_TABLE:
-      table->field[3]->store(STRING_WITH_LEN("BASE TABLE"),
-                             system_charset_info);
-      break;
-    case FRMTYPE_VIEW:
-      table->field[3]->store(STRING_WITH_LEN("VIEW"),
-                             system_charset_info);
-      break;
-    default:
-      DBUG_ASSERT(0);
+    CHARSET_INFO *cs= system_charset_info;
+    handlerton *hton;
+    if (ha_table_exists(thd, db_name->str, table_name->str, &hton))
+    {
+      if (hton == view_pseudo_hton)
+        table->field[3]->store(STRING_WITH_LEN("VIEW"), cs);
+      else
+        table->field[3]->store(STRING_WITH_LEN("BASE TABLE"), cs);
     }
+    else
+      table->field[3]->store(STRING_WITH_LEN("ERROR"), cs);
+
     if (thd->is_error() && thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE)
     {
       thd->clear_error();
@@ -4335,10 +4321,6 @@ static int fill_schema_table_from_frm(THD *thd, TABLE_LIST *tables,
   TABLE tbl;
   TABLE_LIST table_list;
   uint res= 0;
-  int not_used;
-  my_hash_value_type hash_value;
-  char key[MAX_DBKEY_LENGTH];
-  uint key_length;
   char db_name_buff[NAME_LEN + 1], table_name_buff[NAME_LEN + 1];
 
   bzero((char*) &table_list, sizeof(TABLE_LIST));
@@ -4410,15 +4392,12 @@ static int fill_schema_table_from_frm(THD *thd, TABLE_LIST *tables,
     goto end;
   }
 
-  key_length= create_table_def_key(thd, key, &table_list, 0);
-  hash_value= my_calc_hash(&table_def_cache, (uchar*) key, key_length);
-  mysql_mutex_lock(&LOCK_open);
-  share= get_table_share(thd, &table_list, key,
-                         key_length, OPEN_VIEW, &not_used, hash_value);
+  share= get_table_share(thd, table_list.db, table_list.table_name,
+                         GTS_TABLE | GTS_VIEW);
   if (!share)
   {
     res= 0;
-    goto end_unlock;
+    goto end;
   }
 
   if (share->is_view)
@@ -4438,10 +4417,7 @@ static int fill_schema_table_from_frm(THD *thd, TABLE_LIST *tables,
       res= 1;
       goto end_share;
     }
-  }
 
-  if (share->is_view)
-  {
     if (open_new_frm(thd, share, table_name->str,
                      (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
                              HA_GET_INDEX | HA_TRY_READ_ONLY),
@@ -4467,10 +4443,10 @@ static int fill_schema_table_from_frm(THD *thd, TABLE_LIST *tables,
     free_root(&tbl.mem_root, MYF(0));
   }
 
+
 end_share:
+  mysql_mutex_lock(&LOCK_open);
   release_table_share(share);
-
-end_unlock:
   mysql_mutex_unlock(&LOCK_open);
 
 end:
@@ -4560,14 +4536,12 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
 {
   LEX *lex= thd->lex;
   TABLE *table= tables->table;
+  TABLE_LIST table_acl_check;
   SELECT_LEX *lsel= tables->schema_select_lex;
   ST_SCHEMA_TABLE *schema_table= tables->schema_table;
   LOOKUP_FIELD_VALUES lookup_field_vals;
-  LEX_STRING *db_name, *table_name;
-  bool with_i_schema;
   enum enum_schema_tables schema_table_idx;
-  List<LEX_STRING> db_names;
-  List_iterator_fast<LEX_STRING> it(db_names);
+  Dynamic_array<LEX_STRING*> db_names;
   COND *partial_cond= 0;
   int error= 1;
   Open_tables_backup open_tables_state_backup;
@@ -4630,9 +4604,9 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
     goto err;
   }
 
-  DBUG_PRINT("INDEX VALUES",("db_name='%s', table_name='%s'",
-                             STR_OR_NIL(lookup_field_vals.db_value.str),
-                             STR_OR_NIL(lookup_field_vals.table_value.str)));
+  DBUG_PRINT("info",("db_name='%s', table_name='%s'",
+                     lookup_field_vals.db_value.str,
+                     lookup_field_vals.table_value.str));
 
   if (!lookup_field_vals.wild_db_value && !lookup_field_vals.wild_table_value)
   {
@@ -4669,11 +4643,13 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
     goto err;
   }
 
-  if (make_db_list(thd, &db_names, &lookup_field_vals, &with_i_schema))
+  bzero((char*) &table_acl_check, sizeof(table_acl_check));
+
+  if (make_db_list(thd, &db_names, &lookup_field_vals))
     goto err;
-  it.rewind(); /* To get access to new elements in basis list */
-  while ((db_name= it++))
+  for (size_t i=0; i < db_names.elements(); i++)
   {
+    LEX_STRING *db_name= db_names.at(i);
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
     if (!(check_access(thd, SELECT_ACL, db_name->str,
                        &thd->col_access, NULL, 0, 1) ||
@@ -4682,18 +4658,30 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
         acl_get(sctx->host, sctx->ip, sctx->priv_user, db_name->str, 0))
 #endif
     {
-      List<LEX_STRING> table_names;
+      Dynamic_array<LEX_STRING*> table_names;
       int res= make_table_name_list(thd, &table_names, lex,
-                                    &lookup_field_vals,
-                                    with_i_schema, db_name);
+                                    &lookup_field_vals, db_name);
       if (res == 2)   /* Not fatal error, continue */
         continue;
       if (res)
         goto err;
 
-      List_iterator_fast<LEX_STRING> it_files(table_names);
-      while ((table_name= it_files++))
+      for (size_t i=0; i < table_names.elements(); i++)
       {
+        LEX_STRING *table_name= table_names.at(i);
+
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+        if (!(thd->col_access & TABLE_ACLS))
+        {
+          table_acl_check.db= db_name->str;
+          table_acl_check.db_length= db_name->length;
+          table_acl_check.table_name= table_name->str;
+          table_acl_check.table_name_length= table_name->length;
+          table_acl_check.grant.privilege= thd->col_access;
+          if (check_grant(thd, TABLE_ACLS, &table_acl_check, TRUE, 1, TRUE))
+            continue;
+        }
+#endif
 	restore_record(table, s->default_values);
         table->field[schema_table->idx_field1]->
           store(db_name->str, db_name->length, system_charset_info);
@@ -4721,14 +4709,13 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
           /* SHOW TABLE NAMES command */
           if (schema_table_idx == SCH_TABLE_NAMES)
           {
-            if (fill_schema_table_names(thd, tables, db_name,
-                                        table_name, with_i_schema))
+            if (fill_schema_table_names(thd, tables, db_name, table_name))
               continue;
           }
           else
           {
             if (!(table_open_method & ~OPEN_FRM_ONLY) &&
-                !with_i_schema)
+                db_name != &INFORMATION_SCHEMA_NAME)
             {
               /*
                 Here we need to filter out warnings, which can happen
@@ -4762,11 +4749,6 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
           }
         }
       }
-      /*
-        If we have information schema its always the first table and only
-        the first table. Reset for other tables.
-      */
-      with_i_schema= 0;
     }
   }
 
@@ -4798,9 +4780,7 @@ int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
   */
 
   LOOKUP_FIELD_VALUES lookup_field_vals;
-  List<LEX_STRING> db_names;
-  LEX_STRING *db_name;
-  bool with_i_schema;
+  Dynamic_array<LEX_STRING*> db_names;
   HA_CREATE_INFO create;
   TABLE *table= tables->table;
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
@@ -4813,15 +4793,14 @@ int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
   DBUG_PRINT("INDEX VALUES",("db_name: %s  table_name: %s",
                              lookup_field_vals.db_value.str,
                              lookup_field_vals.table_value.str));
-  if (make_db_list(thd, &db_names, &lookup_field_vals,
-                   &with_i_schema))
+  if (make_db_list(thd, &db_names, &lookup_field_vals))
     DBUG_RETURN(1);
 
   /*
     If we have lookup db value we should check that the database exists
   */
   if(lookup_field_vals.db_value.str && !lookup_field_vals.wild_db_value &&
-     !with_i_schema)
+     db_names.at(0) != &INFORMATION_SCHEMA_NAME)
   {
     char path[FN_REFLEN+16];
     uint path_len;
@@ -4835,15 +4814,14 @@ int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
       DBUG_RETURN(0);
   }
 
-  List_iterator_fast<LEX_STRING> it(db_names);
-  while ((db_name=it++))
+  for (size_t i=0; i < db_names.elements(); i++)
   {
-    if (with_i_schema)       // information schema name is always first in list
+    LEX_STRING *db_name= db_names.at(i);
+    if (db_name == &INFORMATION_SCHEMA_NAME)
     {
       if (store_schema_shemata(thd, table, db_name,
                                system_charset_info))
         DBUG_RETURN(1);
-      with_i_schema= 0;
       continue;
     }
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
@@ -7473,20 +7451,20 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
       break;
     case MYSQL_TYPE_DATE:
       if (!(item=new Item_return_date_time(fields_info->field_name,
-                                           MAX_DATE_WIDTH,
+                                           strlen(fields_info->field_name),
                                            fields_info->field_type)))
         DBUG_RETURN(0);
       break;
     case MYSQL_TYPE_TIME:
       if (!(item=new Item_return_date_time(fields_info->field_name,
-                                           MAX_TIME_FULL_WIDTH,
+                                           strlen(fields_info->field_name),
                                            fields_info->field_type)))
         DBUG_RETURN(0);
       break;
     case MYSQL_TYPE_TIMESTAMP:
     case MYSQL_TYPE_DATETIME:
       if (!(item=new Item_return_date_time(fields_info->field_name,
-                                           MAX_DATETIME_WIDTH,
+                                           strlen(fields_info->field_name),
                                            fields_info->field_type)))
         DBUG_RETURN(0);
       break;
@@ -7860,9 +7838,9 @@ int make_schema_select(THD *thd, SELECT_LEX *sel,
      because of lower_case_table_names
   */
   thd->make_lex_string(&db, INFORMATION_SCHEMA_NAME.str,
-                       INFORMATION_SCHEMA_NAME.length, 0);
+                       INFORMATION_SCHEMA_NAME.length);
   thd->make_lex_string(&table, schema_table->table_name,
-                       strlen(schema_table->table_name), 0);
+                       strlen(schema_table->table_name));
   if (schema_table->old_format(thd, schema_table) ||   /* Handle old syntax */
       !sel->add_table_to_list(thd, new Table_ident(thd, db, table, 0),
                               0, 0, TL_READ, MDL_SHARED_READ))
@@ -8664,7 +8642,7 @@ ST_FIELD_INFO plugin_fields_info[]=
   {"PLUGIN_NAME", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 0, "Name",
    SKIP_OPEN_TABLE},
   {"PLUGIN_VERSION", 20, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
-  {"PLUGIN_STATUS", 10, MYSQL_TYPE_STRING, 0, 0, "Status", SKIP_OPEN_TABLE},
+  {"PLUGIN_STATUS", 16, MYSQL_TYPE_STRING, 0, 0, "Status", SKIP_OPEN_TABLE},
   {"PLUGIN_TYPE", 80, MYSQL_TYPE_STRING, 0, 0, "Type", SKIP_OPEN_TABLE},
   {"PLUGIN_TYPE_VERSION", 20, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE},
   {"PLUGIN_LIBRARY", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, "Library",
@@ -8925,6 +8903,8 @@ ST_SCHEMA_TABLE schema_tables[]=
    OPTIMIZE_I_S_TABLE|OPEN_TABLE_ONLY},
   {"PLUGINS", plugin_fields_info, create_schema_table,
    fill_plugins, make_old_format, 0, -1, -1, 0, 0},
+  {"ALL_PLUGINS", plugin_fields_info, create_schema_table,
+   fill_all_plugins, make_old_format, 0, 5, -1, 0, 0},
   {"PROCESSLIST", processlist_fields_info, create_schema_table,
    fill_schema_processlist, make_old_format, 0, -1, -1, 0, 0},
   {"PROFILING", query_profile_statistics_info, create_schema_table,
diff --git a/sql/sql_show.h b/sql/sql_show.h
index 03d8af3aabd..ec4d6a2b7c9 100644
--- a/sql/sql_show.h
+++ b/sql/sql_show.h
@@ -27,21 +27,13 @@ class String;
 class THD;
 class sp_name;
 struct TABLE_LIST;
-struct st_ha_create_information;
 typedef class st_select_lex SELECT_LEX;
-typedef st_ha_create_information HA_CREATE_INFO;
 struct LEX;
 typedef struct st_mysql_show_var SHOW_VAR;
 typedef struct st_schema_table ST_SCHEMA_TABLE;
 struct TABLE;
 typedef struct system_status_var STATUS_VAR;
 
-enum find_files_result {
-  FIND_FILES_OK,
-  FIND_FILES_OOM,
-  FIND_FILES_DIR
-};
-
 /* Used by handlers to store things in schema tables */
 #define IS_FILES_FILE_ID              0
 #define IS_FILES_FILE_NAME            1
@@ -82,9 +74,6 @@ enum find_files_result {
 #define IS_FILES_STATUS              36
 #define IS_FILES_EXTRA               37
 
-find_files_result find_files(THD *thd, List<LEX_STRING> *files, const char *db,
-                             const char *path, const char *wild, bool dir);
-
 int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,
                       HA_CREATE_INFO  *create_info_arg, bool show_database);
 int view_store_create_info(THD *thd, TABLE_LIST *table, String *buff);
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index 9d11677666f..095c557c531 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -796,7 +796,7 @@ copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
 
   uint32 length= min(to_length, from_length), length2= length;
 
-#if defined(__i386__)
+#if defined(__i386__) || defined(__x86_64__)
   /*
     Special loop for i386, it allows to refer to a
     non-aligned memory block as UINT32, which makes
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 3c094e1740e..3ff20c52092 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2000, 2012, Oracle and/or its affiliates.
-   Copyright (c) 2010, 2011, Monty Program Ab
+   Copyright (c) 2010, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -22,7 +22,6 @@
 #include "unireg.h"
 #include "debug_sync.h"
 #include "sql_table.h"
-#include "sql_rename.h" // do_rename
 #include "sql_parse.h"                        // test_if_data_home_dir
 #include "sql_cache.h"                          // query_cache_*
 #include "sql_base.h"   // open_table_uncached, lock_table_names
@@ -54,7 +53,6 @@
 #include "sql_parse.h"
 #include "sql_show.h"
 #include "transaction.h"
-#include "datadict.h"  // dd_frm_type()
 
 #ifdef __WIN__
 #include <io.h>
@@ -72,8 +70,7 @@ static int copy_data_between_tables(THD *thd, TABLE *,TABLE *,
 static bool prepare_blob_field(THD *thd, Create_field *sql_field);
 static bool check_engine(THD *, const char *, const char *, HA_CREATE_INFO *);
 static int mysql_prepare_create_table(THD *, HA_CREATE_INFO *, Alter_info *,
-                                      bool, uint *, handler *, KEY **, uint *,
-                                      int);
+                                      uint *, handler *, KEY **, uint *, int);
 
 /**
   @brief Helper function for explain_filename
@@ -649,13 +646,6 @@ uint build_tmptable_filename(THD* thd, char *buff, size_t bufflen)
 
 struct st_global_ddl_log
 {
-  /*
-    We need to adjust buffer size to be able to handle downgrades/upgrades
-    where IO_SIZE has changed. We'll set the buffer size such that we can
-    handle that the buffer size was upto 4 times bigger in the version
-    that wrote the DDL log.
-  */
-  char file_entry_buf[4*IO_SIZE];
   char file_name_str[FN_REFLEN];
   char *file_name;
   DDL_LOG_MEMORY_ENTRY *first_free;
@@ -683,51 +673,60 @@ mysql_mutex_t LOCK_gdl;
 #define DDL_LOG_NUM_ENTRY_POS 0
 #define DDL_LOG_NAME_LEN_POS 4
 #define DDL_LOG_IO_SIZE_POS 8
+#define DDL_LOG_HEADER_SIZE 12
 
-/*
-  Read one entry from ddl log file
-  SYNOPSIS
-    read_ddl_log_file_entry()
-    entry_no                     Entry number to read
-  RETURN VALUES
-    TRUE                         Error
-    FALSE                        Success
+/**
+  Read one entry from ddl log file.
+  @param[out]  file_entry_buf  Buffer to read into
+  @param       entry_no        Entry number to read
+  @param       size            Number of bytes of the entry to read
+
+  @return Operation status
+    @retval true   Error
+    @retval false  Success
 */
 
-static bool read_ddl_log_file_entry(uint entry_no)
+static bool read_ddl_log_file_entry(uchar *file_entry_buf,
+                                    uint entry_no,
+                                    uint size)
 {
   bool error= FALSE;
   File file_id= global_ddl_log.file_id;
-  uchar *file_entry_buf= (uchar*)global_ddl_log.file_entry_buf;
   uint io_size= global_ddl_log.io_size;
   DBUG_ENTER("read_ddl_log_file_entry");
+  DBUG_ASSERT(io_size >= size);
 
-  if (mysql_file_pread(file_id, file_entry_buf, io_size, io_size * entry_no,
-                       MYF(MY_WME)) != io_size)
+  if (mysql_file_pread(file_id, file_entry_buf, size, io_size * entry_no,
+                       MYF(MY_WME)) != size)
     error= TRUE;
   DBUG_RETURN(error);
 }
 
 
-/*
-  Write one entry from ddl log file
-  SYNOPSIS
-    write_ddl_log_file_entry()
-    entry_no                     Entry number to write
-  RETURN VALUES
-    TRUE                         Error
-    FALSE                        Success
+/**
+  Write one entry to ddl log file.
+
+  @param  file_entry_buf  Buffer to write
+  @param  entry_no        Entry number to write
+  @param  size            Number of bytes of the entry to write
+
+  @return Operation status
+    @retval true   Error
+    @retval false  Success
 */
 
-static bool write_ddl_log_file_entry(uint entry_no)
+static bool write_ddl_log_file_entry(uchar *file_entry_buf,
+                                     uint entry_no,
+                                     uint size)
 {
   bool error= FALSE;
   File file_id= global_ddl_log.file_id;
-  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
+  uint io_size= global_ddl_log.io_size;
   DBUG_ENTER("write_ddl_log_file_entry");
+  DBUG_ASSERT(io_size >= size);
 
-  if (mysql_file_pwrite(file_id, (uchar*)file_entry_buf,
-                        IO_SIZE, IO_SIZE * entry_no, MYF(MY_WME)) != IO_SIZE)
+  if (mysql_file_pwrite(file_id, file_entry_buf, size,
+                        io_size * entry_no, MYF(MY_WME)) != size)
     error= TRUE;
   DBUG_RETURN(error);
 }
@@ -746,17 +745,20 @@ static bool write_ddl_log_header()
 {
   uint16 const_var;
   bool error= FALSE;
+  uchar file_entry_buf[DDL_LOG_HEADER_SIZE];
   DBUG_ENTER("write_ddl_log_header");
+  DBUG_ASSERT((DDL_LOG_NAME_POS + 3 * global_ddl_log.name_len)
+                <= global_ddl_log.io_size);
 
-  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NUM_ENTRY_POS],
+  int4store(&file_entry_buf[DDL_LOG_NUM_ENTRY_POS],
             global_ddl_log.num_entries);
-  const_var= FN_LEN;
-  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_LEN_POS],
+  const_var= global_ddl_log.name_len;
+  int4store(&file_entry_buf[DDL_LOG_NAME_LEN_POS],
             (ulong) const_var);
-  const_var= IO_SIZE;
-  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_IO_SIZE_POS],
+  const_var= global_ddl_log.io_size;
+  int4store(&file_entry_buf[DDL_LOG_IO_SIZE_POS],
             (ulong) const_var);
-  if (write_ddl_log_file_entry(0UL))
+  if (write_ddl_log_file_entry(file_entry_buf, 0UL, DDL_LOG_HEADER_SIZE))
   {
     sql_print_error("Error writing ddl log header");
     DBUG_RETURN(TRUE);
@@ -796,18 +798,20 @@ static inline void create_ddl_log_file_name(char *file_name)
 
 static uint read_ddl_log_header()
 {
-  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
+  char file_entry_buf[DDL_LOG_HEADER_SIZE];
   char file_name[FN_REFLEN];
   uint entry_no;
   bool successful_open= FALSE;
   DBUG_ENTER("read_ddl_log_header");
+  DBUG_ASSERT(global_ddl_log.io_size <= IO_SIZE);
 
   create_ddl_log_file_name(file_name);
   if ((global_ddl_log.file_id= mysql_file_open(key_file_global_ddl_log,
                                                file_name,
                                                O_RDWR | O_BINARY, MYF(0))) >= 0)
   {
-    if (read_ddl_log_file_entry(0UL))
+    if (read_ddl_log_file_entry((uchar *) file_entry_buf, 0UL,
+                                DDL_LOG_HEADER_SIZE))
     {
       /* Write message into error log */
       sql_print_error("Failed to read ddl log file in recovery");
@@ -820,8 +824,6 @@ static uint read_ddl_log_header()
     entry_no= uint4korr(&file_entry_buf[DDL_LOG_NUM_ENTRY_POS]);
     global_ddl_log.name_len= uint4korr(&file_entry_buf[DDL_LOG_NAME_LEN_POS]);
     global_ddl_log.io_size= uint4korr(&file_entry_buf[DDL_LOG_IO_SIZE_POS]);
-    DBUG_ASSERT(global_ddl_log.io_size <=
-                sizeof(global_ddl_log.file_entry_buf));
   }
   else
   {
@@ -836,30 +838,22 @@ static uint read_ddl_log_header()
 }
 
 
-/*
-  Read a ddl log entry
-  SYNOPSIS
-    read_ddl_log_entry()
-    read_entry               Number of entry to read
-    out:entry_info           Information from entry
-  RETURN VALUES
-    TRUE                     Error
-    FALSE                    Success
-  DESCRIPTION
-    Read a specified entry in the ddl log
+/**
+  Set ddl log entry struct from buffer
+  @param read_entry      Entry number
+  @param file_entry_buf  Buffer to use
+  @param ddl_log_entry   Entry to be set
+
+  @note Pointers in ddl_log_entry will point into file_entry_buf!
 */
 
-bool read_ddl_log_entry(uint read_entry, DDL_LOG_ENTRY *ddl_log_entry)
+static void set_ddl_log_entry_from_buf(uint read_entry,
+                                       uchar *file_entry_buf,
+                                       DDL_LOG_ENTRY *ddl_log_entry)
 {
-  char *file_entry_buf= (char*)&global_ddl_log.file_entry_buf;
   uint inx;
   uchar single_char;
-  DBUG_ENTER("read_ddl_log_entry");
-
-  if (read_ddl_log_file_entry(read_entry))
-  {
-    DBUG_RETURN(TRUE);
-  }
+  DBUG_ENTER("set_ddl_log_entry_from_buf");
   ddl_log_entry->entry_pos= read_entry;
   single_char= file_entry_buf[DDL_LOG_ENTRY_TYPE_POS];
   ddl_log_entry->entry_type= (enum ddl_log_entry_code)single_char;
@@ -867,14 +861,14 @@ bool read_ddl_log_entry(uint read_entry, DDL_LOG_ENTRY *ddl_log_entry)
   ddl_log_entry->action_type= (enum ddl_log_action_code)single_char;
   ddl_log_entry->phase= file_entry_buf[DDL_LOG_PHASE_POS];
   ddl_log_entry->next_entry= uint4korr(&file_entry_buf[DDL_LOG_NEXT_ENTRY_POS]);
-  ddl_log_entry->name= &file_entry_buf[DDL_LOG_NAME_POS];
+  ddl_log_entry->name= (char*) &file_entry_buf[DDL_LOG_NAME_POS];
   inx= DDL_LOG_NAME_POS + global_ddl_log.name_len;
-  ddl_log_entry->from_name= &file_entry_buf[inx];
+  ddl_log_entry->from_name= (char*) &file_entry_buf[inx];
   inx+= global_ddl_log.name_len;
-  ddl_log_entry->handler_name= &file_entry_buf[inx];
-  DBUG_RETURN(FALSE);
+  ddl_log_entry->handler_name= (char*) &file_entry_buf[inx];
+  DBUG_VOID_RETURN;
 }
-
+ 
 
 /*
   Initialise ddl log
@@ -969,7 +963,7 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
     plugin_ref plugin= ha_resolve_by_name(thd, &handler_name);
     if (!plugin)
     {
-      my_error(ER_ILLEGAL_HA, MYF(0), ddl_log_entry->handler_name);
+      my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), ddl_log_entry->handler_name);
       goto error;
     }
     hton= plugin_data(plugin, handlerton*);
@@ -1077,6 +1071,7 @@ static bool get_free_ddl_log_entry(DDL_LOG_MEMORY_ENTRY **active_entry,
   DDL_LOG_MEMORY_ENTRY *first_used= global_ddl_log.first_used;
   DBUG_ENTER("get_free_ddl_log_entry");
 
+  mysql_mutex_assert_owner(&LOCK_gdl);
   if (global_ddl_log.first_free == NULL)
   {
     if (!(used_entry= (DDL_LOG_MEMORY_ENTRY*)my_malloc(
@@ -1134,34 +1129,36 @@ bool write_ddl_log_entry(DDL_LOG_ENTRY *ddl_log_entry,
                          DDL_LOG_MEMORY_ENTRY **active_entry)
 {
   bool error, write_header;
+  char file_entry_buf[IO_SIZE];
   DBUG_ENTER("write_ddl_log_entry");
 
   if (init_ddl_log())
   {
     DBUG_RETURN(TRUE);
   }
-  global_ddl_log.file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]=
+  memset(file_entry_buf, 0, sizeof(file_entry_buf));
+  file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]=
                                     (char)DDL_LOG_ENTRY_CODE;
-  global_ddl_log.file_entry_buf[DDL_LOG_ACTION_TYPE_POS]=
+  file_entry_buf[DDL_LOG_ACTION_TYPE_POS]=
                                     (char)ddl_log_entry->action_type;
-  global_ddl_log.file_entry_buf[DDL_LOG_PHASE_POS]= 0;
-  int4store(&global_ddl_log.file_entry_buf[DDL_LOG_NEXT_ENTRY_POS],
+  file_entry_buf[DDL_LOG_PHASE_POS]= 0;
+  int4store(&file_entry_buf[DDL_LOG_NEXT_ENTRY_POS],
             ddl_log_entry->next_entry);
-  DBUG_ASSERT(strlen(ddl_log_entry->name) < FN_LEN);
-  strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS],
-          ddl_log_entry->name, FN_LEN - 1);
+  DBUG_ASSERT(strlen(ddl_log_entry->name) < global_ddl_log.name_len);
+  strmake(&file_entry_buf[DDL_LOG_NAME_POS], ddl_log_entry->name,
+          global_ddl_log.name_len - 1);
   if (ddl_log_entry->action_type == DDL_LOG_RENAME_ACTION ||
       ddl_log_entry->action_type == DDL_LOG_REPLACE_ACTION)
   {
-    DBUG_ASSERT(strlen(ddl_log_entry->from_name) < FN_LEN);
-    strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + FN_LEN],
-          ddl_log_entry->from_name, FN_LEN - 1);
+    DBUG_ASSERT(strlen(ddl_log_entry->from_name) < global_ddl_log.name_len);
+    strmake(&file_entry_buf[DDL_LOG_NAME_POS + global_ddl_log.name_len],
+            ddl_log_entry->from_name, global_ddl_log.name_len - 1);
   }
   else
-    global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + FN_LEN]= 0;
-  DBUG_ASSERT(strlen(ddl_log_entry->handler_name) < FN_LEN);
-  strmake(&global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS + (2*FN_LEN)],
-          ddl_log_entry->handler_name, FN_LEN - 1);
+    file_entry_buf[DDL_LOG_NAME_POS + global_ddl_log.name_len]= 0;
+  DBUG_ASSERT(strlen(ddl_log_entry->handler_name) < global_ddl_log.name_len);
+  strmake(&file_entry_buf[DDL_LOG_NAME_POS + (2*global_ddl_log.name_len)],
+          ddl_log_entry->handler_name, global_ddl_log.name_len - 1);
   if (get_free_ddl_log_entry(active_entry, &write_header))
   {
     DBUG_RETURN(TRUE);
@@ -1169,14 +1166,15 @@ bool write_ddl_log_entry(DDL_LOG_ENTRY *ddl_log_entry,
   error= FALSE;
   DBUG_PRINT("ddl_log",
              ("write type %c next %u name '%s' from_name '%s' handler '%s'",
-             (char) global_ddl_log.file_entry_buf[DDL_LOG_ACTION_TYPE_POS],
+             (char) file_entry_buf[DDL_LOG_ACTION_TYPE_POS],
              ddl_log_entry->next_entry,
-             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS],
-             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS
-                                                    + FN_LEN],
-             (char*) &global_ddl_log.file_entry_buf[DDL_LOG_NAME_POS
-                                                    + (2*FN_LEN)]));
-  if (write_ddl_log_file_entry((*active_entry)->entry_pos))
+             (char*) &file_entry_buf[DDL_LOG_NAME_POS],
+             (char*) &file_entry_buf[DDL_LOG_NAME_POS +
+                                     global_ddl_log.name_len],
+             (char*) &file_entry_buf[DDL_LOG_NAME_POS +
+                                     (2*global_ddl_log.name_len)]));
+  if (write_ddl_log_file_entry((uchar*) file_entry_buf,
+                               (*active_entry)->entry_pos, IO_SIZE))
   {
     error= TRUE;
     sql_print_error("Failed to write entry_no = %u",
@@ -1226,13 +1224,14 @@ bool write_execute_ddl_log_entry(uint first_entry,
                                  DDL_LOG_MEMORY_ENTRY **active_entry)
 {
   bool write_header= FALSE;
-  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
+  char file_entry_buf[IO_SIZE];
   DBUG_ENTER("write_execute_ddl_log_entry");
 
   if (init_ddl_log())
   {
     DBUG_RETURN(TRUE);
   }
+  memset(file_entry_buf, 0, sizeof(file_entry_buf));
   if (!complete)
   {
     /*
@@ -1246,12 +1245,7 @@ bool write_execute_ddl_log_entry(uint first_entry,
   }
   else
     file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (char)DDL_IGNORE_LOG_ENTRY_CODE;
-  file_entry_buf[DDL_LOG_ACTION_TYPE_POS]= 0; /* Ignored for execute entries */
-  file_entry_buf[DDL_LOG_PHASE_POS]= 0;
   int4store(&file_entry_buf[DDL_LOG_NEXT_ENTRY_POS], first_entry);
-  file_entry_buf[DDL_LOG_NAME_POS]= 0;
-  file_entry_buf[DDL_LOG_NAME_POS + FN_LEN]= 0;
-  file_entry_buf[DDL_LOG_NAME_POS + 2*FN_LEN]= 0;
   if (!(*active_entry))
   {
     if (get_free_ddl_log_entry(active_entry, &write_header))
@@ -1259,7 +1253,9 @@ bool write_execute_ddl_log_entry(uint first_entry,
       DBUG_RETURN(TRUE);
     }
   }
-  if (write_ddl_log_file_entry((*active_entry)->entry_pos))
+  if (write_ddl_log_file_entry((uchar*) file_entry_buf,
+                               (*active_entry)->entry_pos,
+                               IO_SIZE))
   {
     sql_print_error("Error writing execute entry in ddl log");
     release_ddl_log_memory_entry(*active_entry);
@@ -1304,10 +1300,16 @@ bool write_execute_ddl_log_entry(uint first_entry,
 
 bool deactivate_ddl_log_entry(uint entry_no)
 {
-  char *file_entry_buf= (char*)global_ddl_log.file_entry_buf;
+  uchar file_entry_buf[DDL_LOG_NAME_POS];
   DBUG_ENTER("deactivate_ddl_log_entry");
 
-  if (!read_ddl_log_file_entry(entry_no))
+
+  /*
+    Only need to read and write the first bytes of the entry, where
+    ENTRY_TYPE, ACTION_TYPE and PHASE reside. Using DDL_LOG_NAME_POS
+    to include all info except for the names.
+  */
+  if (!read_ddl_log_file_entry(file_entry_buf, entry_no, DDL_LOG_NAME_POS))
   {
     if (file_entry_buf[DDL_LOG_ENTRY_TYPE_POS] == DDL_LOG_ENTRY_CODE)
     {
@@ -1325,7 +1327,7 @@ bool deactivate_ddl_log_entry(uint entry_no)
       {
         DBUG_ASSERT(0);
       }
-      if (write_ddl_log_file_entry(entry_no))
+      if (write_ddl_log_file_entry(file_entry_buf, entry_no, DDL_LOG_NAME_POS))
       {
         sql_print_error("Error in deactivating log entry. Position = %u",
                         entry_no);
@@ -1386,6 +1388,7 @@ void release_ddl_log_memory_entry(DDL_LOG_MEMORY_ENTRY *log_entry)
   DDL_LOG_MEMORY_ENTRY *next_log_entry= log_entry->next_log_entry;
   DDL_LOG_MEMORY_ENTRY *prev_log_entry= log_entry->prev_log_entry;
   DBUG_ENTER("release_ddl_log_memory_entry");
+  mysql_mutex_assert_owner(&LOCK_gdl);
 
   global_ddl_log.first_free= log_entry;
   log_entry->next_log_entry= first_free;
@@ -1415,24 +1418,26 @@ bool execute_ddl_log_entry(THD *thd, uint first_entry)
 {
   DDL_LOG_ENTRY ddl_log_entry;
   uint read_entry= first_entry;
+  uchar file_entry_buf[IO_SIZE];
   DBUG_ENTER("execute_ddl_log_entry");
 
   mysql_mutex_lock(&LOCK_gdl);
   do
   {
-    if (read_ddl_log_entry(read_entry, &ddl_log_entry))
+    if (read_ddl_log_file_entry(file_entry_buf, read_entry, IO_SIZE))
     {
-      /* Write to error log and continue with next log entry */
+      /* Print the error to the log and continue with next log entry */
       sql_print_error("Failed to read entry = %u from ddl log",
                       read_entry);
       break;
     }
+    set_ddl_log_entry_from_buf(read_entry, file_entry_buf, &ddl_log_entry);
     DBUG_ASSERT(ddl_log_entry.entry_type == DDL_LOG_ENTRY_CODE ||
                 ddl_log_entry.entry_type == DDL_IGNORE_LOG_ENTRY_CODE);
 
     if (execute_ddl_log_action(thd, &ddl_log_entry))
     {
-      /* Write to error log and continue with next log entry */
+      /* Print the error to the log and continue with next log entry */
       sql_print_error("Failed to execute action for entry = %u from ddl log",
                       read_entry);
       break;
@@ -1477,6 +1482,8 @@ void execute_ddl_log_recovery()
   uint num_entries, i;
   THD *thd;
   DDL_LOG_ENTRY ddl_log_entry;
+  uchar *file_entry_buf;
+  uint io_size;
   char file_name[FN_REFLEN];
   static char recover_query_string[]= "INTERNAL DDL LOG RECOVER IN PROGRESS";
   DBUG_ENTER("execute_ddl_log_recovery");
@@ -1484,7 +1491,6 @@ void execute_ddl_log_recovery()
   /*
     Initialise global_ddl_log struct
   */
-  bzero(global_ddl_log.file_entry_buf, sizeof(global_ddl_log.file_entry_buf));
   global_ddl_log.inited= FALSE;
   global_ddl_log.recovery_phase= TRUE;
   global_ddl_log.io_size= IO_SIZE;
@@ -1502,14 +1508,23 @@ void execute_ddl_log_recovery()
 
   /* this also initialize LOCK_gdl */
   num_entries= read_ddl_log_header();
+  io_size= global_ddl_log.io_size;
+  file_entry_buf= (uchar*) my_malloc(io_size, MYF(0));
+  if (!file_entry_buf)
+  {
+    sql_print_error("Failed to allocate buffer for recover ddl log");
+    DBUG_VOID_RETURN;
+  }
   for (i= 1; i < num_entries + 1; i++)
   {
-    if (read_ddl_log_entry(i, &ddl_log_entry))
+    if (read_ddl_log_file_entry(file_entry_buf, i, io_size))
     {
       sql_print_error("Failed to read entry no = %u from ddl log",
                        i);
       continue;
     }
+
+    set_ddl_log_entry_from_buf(i, file_entry_buf, &ddl_log_entry);
     if (ddl_log_entry.entry_type == DDL_LOG_EXECUTE_CODE)
     {
       if (execute_ddl_log_entry(thd, ddl_log_entry.next_entry))
@@ -1524,6 +1539,7 @@ void execute_ddl_log_recovery()
   (void) mysql_file_delete(key_file_global_ddl_log, file_name, MYF(0));
   global_ddl_log.recovery_phase= FALSE;
   delete thd;
+  my_free(file_entry_buf);
   /* Remember that we don't have a THD */
   set_current_thd(0);
   DBUG_VOID_RETURN;
@@ -1540,14 +1556,16 @@ void execute_ddl_log_recovery()
 
 void release_ddl_log()
 {
-  DDL_LOG_MEMORY_ENTRY *free_list= global_ddl_log.first_free;
-  DDL_LOG_MEMORY_ENTRY *used_list= global_ddl_log.first_used;
+  DDL_LOG_MEMORY_ENTRY *free_list;
+  DDL_LOG_MEMORY_ENTRY *used_list;
   DBUG_ENTER("release_ddl_log");
 
   if (!global_ddl_log.do_release)
     DBUG_VOID_RETURN;
 
   mysql_mutex_lock(&LOCK_gdl);
+  free_list= global_ddl_log.first_free;
+  used_list= global_ddl_log.first_used;
   while (used_list)
   {
     DDL_LOG_MEMORY_ENTRY *tmp= used_list->next_log_entry;
@@ -1656,14 +1674,10 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
   strxmov(shadow_frm_name, shadow_path, reg_ext, NullS);
   if (flags & WFRM_WRITE_SHADOW)
   {
-    if (mysql_prepare_create_table(lpt->thd, lpt->create_info,
-                                   lpt->alter_info,
-                                   /*tmp_table*/ 1,
-                                   &lpt->db_options,
-                                   lpt->table->file,
-                                   &lpt->key_info_buffer,
-                                   &lpt->key_count,
-                                   /*select_field_count*/ 0))
+    if (mysql_prepare_create_table(lpt->thd, lpt->create_info, lpt->alter_info,
+                                   &lpt->db_options, lpt->table->file,
+                                   &lpt->key_info_buffer, &lpt->key_count,
+                                   C_ALTER_TABLE))
     {
       DBUG_RETURN(TRUE);
     }
@@ -1687,13 +1701,23 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
 #endif
     /* Write shadow frm file */
     lpt->create_info->table_options= lpt->db_options;
-    if ((mysql_create_frm(lpt->thd, shadow_frm_name, lpt->db,
-                          lpt->table_name, lpt->create_info,
-                          lpt->alter_info->create_list, lpt->key_count,
-                          lpt->key_info_buffer, lpt->table->file)) ||
-        lpt->table->file->ha_create_handler_files(shadow_path, NULL,
-                                                  CHF_CREATE_FLAG,
-                                                  lpt->create_info))
+    LEX_CUSTRING frm= build_frm_image(lpt->thd, lpt->table_name,
+                                      lpt->create_info,
+                                      lpt->alter_info->create_list,
+                                      lpt->key_count, lpt->key_info_buffer,
+                                      lpt->table->file);
+    if (!frm.str)
+    {
+      error= 1;
+      goto end;
+    }
+
+    int error= writefrm(shadow_path, lpt->db, lpt->table_name,
+                        lpt->create_info->tmp_table(), frm.str, frm.length);
+    my_free(const_cast<uchar*>(frm.str));
+
+    if (error || lpt->table->file->ha_create_partitioning_metadata(shadow_path,
+                                       NULL, CHF_CREATE_FLAG))
     {
       mysql_file_delete(key_file_frm, shadow_frm_name, MYF(0));
       error= 1;
@@ -1708,12 +1732,12 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
       handlers that have the main version of the frm file stored in the
       handler.
     */
-    uchar *data;
+    const uchar *data;
     size_t length;
     if (readfrm(shadow_path, &data, &length) ||
         packfrm(data, length, &lpt->pack_frm_data, &lpt->pack_frm_len))
     {
-      my_free(data);
+      my_free(const_cast<uchar*>(data));
       my_free(lpt->pack_frm_data);
       mem_alloc_error(length);
       error= 1;
@@ -1731,7 +1755,7 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
     */
     build_table_filename(path, sizeof(path) - 1, lpt->db,
                          lpt->table_name, "", 0);
-    strxmov(frm_name, path, reg_ext, NullS);
+    strxnmov(frm_name, sizeof(frm_name), path, reg_ext, NullS);
     /*
       When we are changing to use new frm file we need to ensure that we
       don't collide with another thread in process to open the frm file.
@@ -1744,14 +1768,14 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
     */
     if (mysql_file_delete(key_file_frm, frm_name, MYF(MY_WME)) ||
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-        lpt->table->file->ha_create_handler_files(path, shadow_path,
-                                                  CHF_DELETE_FLAG, NULL) ||
+        lpt->table->file->ha_create_partitioning_metadata(path, shadow_path,
+                                                  CHF_DELETE_FLAG) ||
         deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos) ||
         (sync_ddl_log(), FALSE) ||
         mysql_file_rename(key_file_frm,
                           shadow_frm_name, frm_name, MYF(MY_WME)) ||
-        lpt->table->file->ha_create_handler_files(path, shadow_path,
-                                                  CHF_RENAME_FLAG, NULL))
+        lpt->table->file->ha_create_partitioning_metadata(path, shadow_path,
+                                                  CHF_RENAME_FLAG))
 #else
         mysql_file_rename(key_file_frm,
                           shadow_frm_name, frm_name, MYF(MY_WME)))
@@ -1911,10 +1935,6 @@ bool mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
       if (lock_table_names(thd, tables, NULL, thd->variables.lock_wait_timeout,
                            MYSQL_OPEN_SKIP_TEMPORARY))
         DBUG_RETURN(true);
-      for (table= tables; table; table= table->next_local)
-     
-        tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name,
-                         false);
     }
     else
     {
@@ -2124,8 +2144,7 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
     bool is_trans;
     char *db=table->db;
     size_t db_length= table->db_length;
-    handlerton *table_type;
-    enum legacy_db_type frm_db_type= DB_TYPE_UNKNOWN;
+    handlerton *table_type= 0;
 
     DBUG_PRINT("table", ("table_l: '%s'.'%s'  table: 0x%lx  s: 0x%lx",
                          table->db, table->table_name, (long) table->table,
@@ -2205,22 +2224,9 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
     {
       non_temp_tables_count++;
 
-      if (thd->locked_tables_mode)
-      {
-        if (wait_while_table_is_used(thd, table->table, HA_EXTRA_NOT_USED))
-        {
-          error= -1;
-          goto err;
-        }
-        close_all_tables_for_name(thd, table->table->s,
-                                  HA_EXTRA_PREPARE_FOR_DROP);
-        table->table= 0;
-      }
-
-      /* Check that we have an exclusive lock on the table to be dropped. */
       DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
                                                  table->table_name,
-                                                 MDL_EXCLUSIVE));
+                                                 MDL_SHARED));
 
       alias= (lower_case_table_names == 2) ? table->alias : table->table_name;
       /* remove .frm file and engine files */
@@ -2260,14 +2266,10 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
       }
     }
     DEBUG_SYNC(thd, "rm_table_no_locks_before_delete_table");
-    DBUG_EXECUTE_IF("sleep_before_no_locks_delete_table",
-                    my_sleep(100000););
     error= 0;
-    if (drop_temporary ||
-        ((access(path, F_OK) &&
-          ha_create_table_from_engine(thd, db, alias)) ||
-         (!drop_view &&
-          dd_frm_type(thd, path, &frm_db_type) != FRMTYPE_TABLE)))
+    if (!table->internal_tmp_table &&
+        (drop_temporary || !ha_table_exists(thd, db, alias, &table_type) ||
+         (!drop_view && table_type == view_pseudo_hton)))
     {
       /*
         One of the following cases happened:
@@ -2275,6 +2277,10 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
           . "DROP" but table was not found on disk and table can't be
             created from engine.
           . ./sql/datadict.cc +32 /Alfranio - TODO: We need to test this.
+
+        Table->internal_tmp_table is set when one of the #sql-xxx files
+        was left in the datadir after a crash during ALTER TABLE.
+        See Bug#30152.
       */
       if (if_exists)
 	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
@@ -2289,30 +2295,48 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
     else
     {
       char *end;
+
       /*
-        Cannot use the db_type from the table, since that might have changed
-        while waiting for the exclusive name lock.
+        It could happen that table's share in the table_def_cache
+        is the only thing that keeps the engine plugin loaded
+        (if it is uninstalled and waits for the ref counter to drop to 0).
+
+        In this case, the tdc_remove_table() below will release and unload
+        the plugin. And ha_delete_table() will get a dangling pointer.
+
+        Let's lock the plugin till the end of the statement.
       */
-      if (frm_db_type == DB_TYPE_UNKNOWN)
+      if (table_type && table_type != view_pseudo_hton)
+        ha_lock_engine(thd, table_type);
+
+      if (thd->locked_tables_mode)
       {
-        dd_frm_type(thd, path, &frm_db_type);
-        DBUG_PRINT("info", ("frm_db_type %d from %s", frm_db_type, path));
+        if (wait_while_table_is_used(thd, table->table, HA_EXTRA_NOT_USED,
+                                     TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
+        {
+          error= -1;
+          goto err;
+        }
+        /* the following internally does TDC_RT_REMOVE_ALL */
+        close_all_tables_for_name(thd, table->table->s,
+                                  HA_EXTRA_PREPARE_FOR_DROP);
+        table->table= 0;
       }
-      table_type= ha_resolve_by_legacy_type(thd, frm_db_type);
+      else
+        tdc_remove_table(thd, TDC_RT_REMOVE_ALL, table->db, table->table_name,
+                         false);
+
+      /* Check that we have an exclusive lock on the table to be dropped. */
+      DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
+                                                 table->table_name,
+                                                 MDL_EXCLUSIVE));
+
       // Remove extension for delete
       *(end= path + path_length - reg_ext_length)= '\0';
-      DBUG_PRINT("info", ("deleting table of type %d",
-                          (table_type ? table_type->db_type : 0)));
+
       error= ha_delete_table(thd, table_type, path, db, table->table_name,
                              !dont_log_query);
 
-      /* No error if non existent table and 'IF EXIST' clause or view */
-      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && 
-	  (if_exists || table_type == NULL))
-      {
-	error= 0;
-        thd->clear_error();
-      }
       if (error == HA_ERR_ROW_IS_REFERENCED)
       {
 	/* the table is referenced by a foreign key constraint */
@@ -2320,18 +2344,29 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
       }
       if (!error || error == ENOENT || error == HA_ERR_NO_SUCH_TABLE)
       {
-        int new_error;
+        int frm_delete_error, trigger_drop_error= 0;
 	/* Delete the table definition file */
 	strmov(end,reg_ext);
-        if (!(new_error= mysql_file_delete(key_file_frm, path, MYF(MY_WME))))
+        frm_delete_error= mysql_file_delete(key_file_frm, path, MYF(MY_WME));
+        if (frm_delete_error)
+          frm_delete_error= my_errno;
+        else
         {
           non_tmp_table_deleted= TRUE;
-          new_error= Table_triggers_list::drop_all_triggers(thd, db,
-                                                            table->table_name);
+          trigger_drop_error=
+            Table_triggers_list::drop_all_triggers(thd, db, table->table_name);
+        }
+
+        if (trigger_drop_error ||
+            (frm_delete_error && frm_delete_error != ENOENT))
+          error= 1;
+        else if (!frm_delete_error || !error || if_exists)
+        {
+          error= 0;
+          thd->clear_error();
         }
-        error|= new_error;
       }
-       non_tmp_error= error ? TRUE : non_tmp_error;
+      non_tmp_error= error ? TRUE : non_tmp_error;
     }
     if (error)
     {
@@ -2870,12 +2905,12 @@ void promote_first_timestamp_column(List<Create_field> *column_definitions)
       thd                       Thread object.
       create_info               Create information (like MAX_ROWS).
       alter_info                List of columns and indexes to create
-      tmp_table                 If a temporary table is to be created.
       db_options          INOUT Table options (like HA_OPTION_PACK_RECORD).
       file                      The handler for the new table.
       key_info_buffer     OUT   An array of KEY structs for the indexes.
       key_count           OUT   The number of elements in the array.
-      select_field_count        The number of fields coming from a select table.
+      create_table_mode         C_ORDINARY_CREATE, C_ALTER_TABLE,
+                                C_CREATE_SELECT, C_ASSISTED_DISCOVERY
 
   DESCRIPTION
     Prepares the table and key structures for table creation.
@@ -2890,11 +2925,9 @@ void promote_first_timestamp_column(List<Create_field> *column_definitions)
 
 static int
 mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
-                           Alter_info *alter_info,
-                           bool tmp_table,
-                           uint *db_options,
+                           Alter_info *alter_info, uint *db_options,
                            handler *file, KEY **key_info_buffer,
-                           uint *key_count, int select_field_count)
+                           uint *key_count, int create_table_mode)
 {
   const char	*key_name;
   Create_field	*sql_field,*dup_field;
@@ -2907,6 +2940,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
   List_iterator<Create_field> it(alter_info->create_list);
   List_iterator<Create_field> it2(alter_info->create_list);
   uint total_uneven_bit_length= 0;
+  int select_field_count= C_CREATE_SELECT(create_table_mode);
+  bool tmp_table= create_table_mode == C_ALTER_TABLE;
   DBUG_ENTER("mysql_prepare_create_table");
 
   select_field_pos= alter_info->create_list.elements - select_field_count;
@@ -3192,8 +3227,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     sql_field->offset= record_offset;
     if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
       auto_increment++;
-    if (parse_option_list(thd, &sql_field->option_struct,
-                          sql_field->option_list,
+    if (parse_option_list(thd, create_info->db_type, &sql_field->option_struct,
+                          &sql_field->option_list,
                           create_info->db_type->field_options, FALSE,
                           thd->mem_root))
       DBUG_RETURN(TRUE);
@@ -3223,15 +3258,13 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
   if (auto_increment &&
       (file->ha_table_flags() & HA_NO_AUTO_INCREMENT))
   {
-    my_message(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,
-               ER(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT), MYF(0));
+    my_error(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT, MYF(0), file->table_type());
     DBUG_RETURN(TRUE);
   }
 
   if (blob_columns && (file->ha_table_flags() & HA_NO_BLOBS))
   {
-    my_message(ER_TABLE_CANT_HANDLE_BLOB, ER(ER_TABLE_CANT_HANDLE_BLOB),
-               MYF(0));
+    my_error(ER_TABLE_CANT_HANDLE_BLOB, MYF(0), file->table_type());
     DBUG_RETURN(TRUE);
   }
 
@@ -3397,8 +3430,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     key_info->usable_key_parts= key_number;
     key_info->algorithm= key->key_create_info.algorithm;
     key_info->option_list= key->option_list;
-    if (parse_option_list(thd, &key_info->option_struct,
-                          key_info->option_list,
+    if (parse_option_list(thd, create_info->db_type, &key_info->option_struct,
+                          &key_info->option_list,
                           create_info->db_type->index_options, FALSE,
                           thd->mem_root))
       DBUG_RETURN(TRUE);
@@ -3407,8 +3440,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     {
       if (!(file->ha_table_flags() & HA_CAN_FULLTEXT))
       {
-	my_message(ER_TABLE_CANT_HANDLE_FT, ER(ER_TABLE_CANT_HANDLE_FT),
-                   MYF(0));
+	my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0), file->table_type());
 	DBUG_RETURN(TRUE);
       }
     }
@@ -3425,8 +3457,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     {
       if (!(file->ha_table_flags() & HA_CAN_RTREEKEYS))
       {
-        my_message(ER_TABLE_CANT_HANDLE_SPKEYS, ER(ER_TABLE_CANT_HANDLE_SPKEYS),
-                   MYF(0));
+	my_error(ER_TABLE_CANT_HANDLE_SPKEYS, MYF(0), file->table_type());
         DBUG_RETURN(TRUE);
       }
       if (key_info->key_parts != 1)
@@ -3541,7 +3572,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 	{
 	  if (!(file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
 	  {
-	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
+	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str,
+                     file->table_type());
 	    DBUG_RETURN(TRUE);
 	  }
           if (f_is_geom(sql_field->pack_flag) && sql_field->geom_type ==
@@ -3663,7 +3695,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
       }
       else if (length == 0 && (sql_field->flags & NOT_NULL_FLAG))
       {
-	my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.str);
+	my_error(ER_WRONG_KEY_COLUMN, MYF(0), file->table_type(),
+                 column->field_name.str);
 	  DBUG_RETURN(TRUE);
       }
       if (length > file->max_key_part_length() && key->type != Key::FULLTEXT)
@@ -3828,8 +3861,23 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     }
   }
 
-  if (parse_option_list(thd, &create_info->option_struct,
-                          create_info->option_list,
+  if (create_info->tmp_table())
+    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
+
+  /* Give warnings for not supported table options */
+#if defined(WITH_ARIA_STORAGE_ENGINE)
+  extern handlerton *maria_hton;
+  if (file->ht != maria_hton)
+#endif
+    if (create_info->transactional)
+      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                          ER_ILLEGAL_HA_CREATE_OPTION,
+                          ER(ER_ILLEGAL_HA_CREATE_OPTION),
+                          file->engine_name()->str,
+                          "TRANSACTIONAL=1");
+
+  if (parse_option_list(thd, file->partition_ht(), &create_info->option_struct,
+                          &create_info->option_list,
                           file->partition_ht()->table_options, FALSE,
                           thd->mem_root))
       DBUG_RETURN(TRUE);
@@ -3999,164 +4047,58 @@ static bool check_if_created_table_can_be_opened(THD *thd,
   /*
     It is impossible to open definition of partitioned table without .par file.
   */
-  if (file->ha_create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info))
+  if (file->ha_create_partitioning_metadata(path, NULL, CHF_CREATE_FLAG))
     return TRUE;
 
   init_tmp_table_share(thd, &share, db, 0, table_name, path);
+  share.db_plugin= ha_lock_engine(thd, file->ht);
 
-  result= (open_table_def(thd, &share, 0) ||
+  result= (open_table_def(thd, &share) ||
            open_table_from_share(thd, &share, "", 0, (uint) READ_ALL,
                                  0, &table, TRUE));
   if (! result)
     (void) closefrm(&table, 0);
 
   free_table_share(&share);
-  (void) file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info);
+  (void) file->ha_create_partitioning_metadata(path, NULL, CHF_DELETE_FLAG);
   return result;
 }
 #endif
 
 
-/**
-  Check that there is no frm file for given table
-
-  @param old_path        path to the old frm file
-  @param path            path to the frm file in new encoding
-  @param db              database name
-  @param table_name      table name
-  @param alias           table name for error message (for new encoding)
-  @param issue_error     should we issue error messages
-
-  @retval FALSE there is no frm file
-  @retval TRUE  there is frm file
-*/
-
-bool check_table_file_presence(char *old_path,
-                               char *path,
-                               const char *db,
-                               const char *table_name,
-                               const char *alias,
-                               bool issue_error)
-{
-  if (!access(path,F_OK))
-  {
-    if (issue_error)
-      my_error(ER_TABLE_EXISTS_ERROR,MYF(0),alias);
-    return TRUE;
-  }
-  {
-    /*
-      Check if file of the table in 5.0 file name encoding exists.
-
-      Except case when it is the same table.
-    */
-    char tbl50[FN_REFLEN];
-#ifdef _WIN32
-    if (check_if_legal_tablename(table_name) != 0)
-    {
-      /*
-       Check for reserved device names for which access() returns 0
-       (CON, AUX etc).
-      */
-      return FALSE;
-    }
-#endif
-    strxmov(tbl50, mysql_data_home, "/", db, "/", table_name, NullS);
-    fn_format(tbl50, tbl50, "", reg_ext, MY_UNPACK_FILENAME);
-    if (!access(tbl50, F_OK) &&
-        (old_path == NULL ||
-         strcmp(old_path, tbl50) != 0))
-    {
-      if (issue_error)
-      {
-        strxmov(tbl50, MYSQL50_TABLE_NAME_PREFIX, table_name, NullS);
-        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), tbl50);
-      }
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-
-
-/*
-  Create a table
-
-  SYNOPSIS
-    mysql_create_table_no_lock()
-    thd			Thread object
-    db			Database
-    table_name		Table name
-    create_info	        Create information (like MAX_ROWS)
-    fields		List of fields to create
-    keys		List of keys to create
-    internal_tmp_table  Set to 1 if this is an internal temporary table
-			(From ALTER TABLE)
-    select_field_count
-    is_trans            identifies the type of engine where the table
-                        was created: either trans or non-trans.
-
-  DESCRIPTION
-    If one creates a temporary table, this is automatically opened
-
-    Note that this function assumes that caller already have taken
-    exclusive metadata lock on table being created or used some other
-    way to ensure that concurrent operations won't intervene.
-    mysql_create_table() is a wrapper that can be used for this.
-
-    no_log is needed for the case of CREATE ... SELECT,
-    as the logging will be done later in sql_insert.cc
-    select_field_count is also used for CREATE ... SELECT,
-    and must be zero for standard create of table.
-
-  RETURN VALUES
-    FALSE OK
-    TRUE  error
-*/
-
-bool mysql_create_table_no_lock(THD *thd,
+handler *mysql_create_frm_image(THD *thd,
                                 const char *db, const char *table_name,
                                 HA_CREATE_INFO *create_info,
-                                Alter_info *alter_info,
-                                bool internal_tmp_table,
-                                uint select_field_count,
-                                bool *is_trans)
+                                Alter_info *alter_info, int create_table_mode,
+                                LEX_CUSTRING *frm)
 {
-  char		path[FN_REFLEN + 1];
-  uint          path_length;
-  const char	*alias;
   uint		db_options, key_count;
   KEY		*key_info_buffer;
-  handler	*file;
-  bool		error= TRUE;
-  DBUG_ENTER("mysql_create_table_no_lock");
-  DBUG_PRINT("enter", ("db: '%s'  table: '%s'  tmp: %d",
-                       db, table_name, internal_tmp_table));
+  handler       *file;
+  DBUG_ENTER("mysql_create_frm_image");
 
-
-  /* Check for duplicate fields and check type of table to create */
   if (!alter_info->create_list.elements)
   {
     my_message(ER_TABLE_MUST_HAVE_COLUMNS, ER(ER_TABLE_MUST_HAVE_COLUMNS),
                MYF(0));
-    DBUG_RETURN(TRUE);
+    DBUG_RETURN(NULL);
   }
+
   if (check_engine(thd, db, table_name, create_info))
-    DBUG_RETURN(TRUE);
+    DBUG_RETURN(NULL);
 
   set_table_default_charset(thd, create_info, (char*) db);
 
   db_options= create_info->table_options;
-  if (!create_info->frm_only &&
+  if (create_table_mode != C_ALTER_TABLE_FRM_ONLY &&
       create_info->row_type != ROW_TYPE_FIXED &&
       create_info->row_type != ROW_TYPE_DEFAULT)
     db_options|= HA_OPTION_PACK_RECORD;
-  alias= table_case_name(create_info, table_name);
   if (!(file= get_new_handler((TABLE_SHARE*) 0, thd->mem_root,
                               create_info->db_type)))
   {
     mem_alloc_error(sizeof(handler));
-    DBUG_RETURN(TRUE);
+    DBUG_RETURN(NULL);
   }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   partition_info *part_info= thd->work_part_info;
@@ -4173,7 +4115,7 @@ bool mysql_create_table_no_lock(THD *thd,
     if (!part_info)
     {
       mem_alloc_error(sizeof(partition_info));
-      DBUG_RETURN(TRUE);
+      goto err;
     }
     file->set_auto_partitions(part_info);
     part_info->default_engine_type= create_info->db_type;
@@ -4198,7 +4140,7 @@ bool mysql_create_table_no_lock(THD *thd,
     char *part_syntax_buf;
     uint syntax_len;
     handlerton *engine_type;
-    if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
+    if (create_info->tmp_table())
     {
       my_error(ER_PARTITION_NO_TEMPORARY, MYF(0));
       goto err;
@@ -4270,9 +4212,8 @@ bool mysql_create_table_no_lock(THD *thd,
       delete file;
       create_info->db_type= partition_hton;
       if (!(file= get_ha_partition(part_info)))
-      {
-        DBUG_RETURN(TRUE);
-      }
+        DBUG_RETURN(NULL);
+
       /*
         If we have default number of partitions or subpartitions we
         might require to set-up the part_info object such that it
@@ -4314,193 +4255,188 @@ bool mysql_create_table_no_lock(THD *thd,
                                   engine_type)))
       {
         mem_alloc_error(sizeof(handler));
-        DBUG_RETURN(TRUE);
+        DBUG_RETURN(NULL);
       }
     }
   }
 #endif
 
-  if (mysql_prepare_create_table(thd, create_info, alter_info,
-                                 internal_tmp_table,
-                                 &db_options, file,
-                                 &key_info_buffer, &key_count,
-                                 select_field_count))
+  if (mysql_prepare_create_table(thd, create_info, alter_info, &db_options,
+                                 file, &key_info_buffer, &key_count,
+                                 create_table_mode))
     goto err;
+  create_info->table_options=db_options;
 
-      /* Check if table exists */
-  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
-  {
-    path_length= build_tmptable_filename(thd, path, sizeof(path));
-    create_info->table_options|=HA_CREATE_DELAY_KEY_WRITE;
-  }
-  else  
-  {
-    path_length= build_table_filename(path, sizeof(path) - 1, db, alias, reg_ext,
-                                      internal_tmp_table ? FN_IS_TMP : 0);
-  }
+  *frm= build_frm_image(thd, table_name, create_info,
+                        alter_info->create_list, key_count,
+                        key_info_buffer, file);
+
+  if (frm->str)
+    DBUG_RETURN(file);
+
+err:
+  delete file;
+  DBUG_RETURN(NULL);
+}
+
+
+/*
+  Create a table
+
+  SYNOPSIS
+    mysql_create_table_no_lock()
+    thd			Thread object
+    db			Database
+    table_name		Table name
+    create_info	        Create information (like MAX_ROWS)
+    fields		List of fields to create
+    keys		List of keys to create
+    is_trans            identifies the type of engine where the table
+                        was created: either trans or non-trans.
+    create_table_mode   C_ORDINARY_CREATE, C_ALTER_TABLE, C_ASSISTED_DISCOVERY
+                        or any positive number (for C_CREATE_SELECT).
 
-  /* Check if table already exists */
-  if ((create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
-      find_temporary_table(thd, db, table_name))
+  DESCRIPTION
+    If one creates a temporary table, this is automatically opened
+
+    Note that this function assumes that caller already have taken
+    exclusive metadata lock on table being created or used some other
+    way to ensure that concurrent operations won't intervene.
+    mysql_create_table() is a wrapper that can be used for this.
+
+    select_field_count is also used for CREATE ... SELECT,
+    and must be zero for standard create of table.
+
+  RETURN VALUES
+    FALSE OK
+    TRUE  error
+*/
+
+bool mysql_create_table_no_lock(THD *thd,
+                                const char *db, const char *table_name,
+                                HA_CREATE_INFO *create_info,
+                                Alter_info *alter_info, bool *is_trans,
+                                int create_table_mode)
+{
+  char		path[FN_REFLEN + 1];
+  uint          path_length;
+  const char	*alias;
+  handler	*file= 0;
+  LEX_CUSTRING  frm= {0,0};
+  bool		error= TRUE;
+  bool          internal_tmp_table= create_table_mode == C_ALTER_TABLE ||
+                                    create_table_mode == C_ALTER_TABLE_FRM_ONLY;
+  DBUG_ENTER("mysql_create_table_no_lock");
+  DBUG_PRINT("enter", ("db: '%s'  table: '%s'  tmp: %d",
+                       db, table_name, internal_tmp_table));
+
+  if (!my_use_symdir || (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE))
   {
-    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
-      goto warn;
-    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
-    goto err;
+    if (create_info->data_file_name)
+      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                          WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
+                          "DATA DIRECTORY");
+    if (create_info->index_file_name)
+      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                          WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
+                          "INDEX DIRECTORY");
+    create_info->data_file_name= create_info->index_file_name= 0;
   }
+  else
+  if (error_if_data_home_dir(create_info->data_file_name,  "DATA DIRECTORY") ||
+      error_if_data_home_dir(create_info->index_file_name, "INDEX DIRECTORY")||
+      check_partition_dirs(thd->lex->part_info))
+    goto err;
 
-  /* Give warnings for not supported table options */
-#if defined(WITH_ARIA_STORAGE_ENGINE)
-  extern handlerton *maria_hton;
-  if (file->ht != maria_hton)
-#endif
-    if (create_info->transactional)
-      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                          ER_ILLEGAL_HA_CREATE_OPTION,
-                          ER(ER_ILLEGAL_HA_CREATE_OPTION),
-                          file->engine_name()->str,
-                          "TRANSACTIONAL=1");
+  alias= table_case_name(create_info, table_name);
 
-  if (!internal_tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
+  /* Check if table exists */
+  if (create_info->tmp_table())
   {
-    if (check_table_file_presence(NULL, path, db, table_name, table_name,
-                                  !(create_info->options &
-                                    HA_LEX_CREATE_IF_NOT_EXISTS)))
+    path_length= build_tmptable_filename(thd, path, sizeof(path));
+    path[path_length - reg_ext_length]= '\0'; // Remove .frm extension
+
+    if (find_temporary_table(thd, db, table_name))
     {
       if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
         goto warn;
+      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), alias);
       goto err;
     }
-    /*
-      We don't assert here, but check the result, because the table could be
-      in the table definition cache and in the same time the .frm could be
-      missing from the disk, in case of manual intervention which deletes
-      the .frm file. The user has to use FLUSH TABLES; to clear the cache.
-      Then she could create the table. This case is pretty obscure and
-      therefore we don't introduce a new error message only for it.
-    */
-    mysql_mutex_lock(&LOCK_open);
-    if (get_cached_table_share(db, table_name))
-    {
-      mysql_mutex_unlock(&LOCK_open);
-      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
-      goto err;
-    }
-    mysql_mutex_unlock(&LOCK_open);
   }
-
-  /*
-    Check that table with given name does not already
-    exist in any storage engine. In such a case it should
-    be discovered and the error ER_TABLE_EXISTS_ERROR be returned
-    unless user specified CREATE TABLE IF EXISTS
-    An exclusive metadata lock ensures that no
-    one else is attempting to discover the table. Since
-    it's not on disk as a frm file, no one could be using it!
-  */
-  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
+  else  
   {
-    bool create_if_not_exists =
-      create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS;
-    int retcode = ha_table_exists_in_engine(thd, db, table_name);
-    DBUG_PRINT("info", ("exists_in_engine: %u",retcode));
-    switch (retcode)
-    {
-      case HA_ERR_NO_SUCH_TABLE:
-        /* Normal case, no table exists. we can go and create it */
-        break;
-      case HA_ERR_TABLE_EXIST:
-        DBUG_PRINT("info", ("Table existed in handler"));
+    path_length= build_table_filename(path, sizeof(path) - 1, db, alias, "",
+                                      internal_tmp_table ? FN_IS_TMP : 0);
 
-        if (create_if_not_exists)
-          goto warn;
-        my_error(ER_TABLE_EXISTS_ERROR,MYF(0),table_name);
-        goto err;
-      default:
-        DBUG_PRINT("info", ("error: %u from storage engine", retcode));
-        my_error(retcode, MYF(0),table_name);
-        goto err;
+    if (!internal_tmp_table && ha_table_exists(thd, db, table_name))
+    {
+      if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
+        goto warn;
+      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
+      goto err;
     }
   }
 
   THD_STAGE_INFO(thd, stage_creating_table);
 
-#ifdef HAVE_READLINK
+  if (create_table_mode == C_ASSISTED_DISCOVERY)
   {
-    size_t dirlen;
-    char   dirpath[FN_REFLEN];
+    /* check that it's used correctly */
+    DBUG_ASSERT(alter_info->create_list.elements == 0);
+    DBUG_ASSERT(alter_info->key_list.elements == 0);
 
-    /*
-      data_file_name and index_file_name include the table name without
-      extension. Mostly this does not refer to an existing file. When
-      comparing data_file_name or index_file_name against the data
-      directory, we try to resolve all symbolic links. On some systems,
-      we use realpath(3) for the resolution. This returns ENOENT if the
-      resolved path does not refer to an existing file. my_realpath()
-      does then copy the requested path verbatim, without symlink
-      resolution. Thereafter the comparison can fail even if the
-      requested path is within the data directory. E.g. if symlinks to
-      another file system are used. To make realpath(3) return the
-      resolved path, we strip the table name and compare the directory
-      path only. If the directory doesn't exist either, table creation
-      will fail anyway.
-    */
-    if (create_info->data_file_name)
+    TABLE_SHARE share;
+    handlerton *hton= create_info->db_type;
+    int ha_err;
+    Field *no_fields= 0;
+
+    if (!hton->discover_table_structure)
     {
-      dirname_part(dirpath, create_info->data_file_name, &dirlen);
-      if (test_if_data_home_dir(dirpath))
-      {
-        my_error(ER_WRONG_ARGUMENTS, MYF(0), "DATA DIRECTORY");
-        goto err;
-      }
+      my_error(ER_ILLEGAL_HA, MYF(0), hton_name(hton)->str, db, table_name);
+      goto err;
     }
-    if (create_info->index_file_name)
+
+    init_tmp_table_share(thd, &share, db, 0, table_name, path);
+
+    /* prepare everything for discovery */
+    share.field= &no_fields;
+    share.db_plugin= ha_lock_engine(thd, hton);
+    share.option_list= create_info->option_list;
+    share.connect_string= create_info->connect_string;
+
+    if (parse_engine_table_options(thd, hton, &share))
+      goto err;
+
+    ha_err= hton->discover_table_structure(hton, thd, &share, create_info);
+    free_table_share(&share);
+
+    if (ha_err)
     {
-      dirname_part(dirpath, create_info->index_file_name, &dirlen);
-      if (test_if_data_home_dir(dirpath))
-      {
-        my_error(ER_WRONG_ARGUMENTS, MYF(0), "INDEX DIRECTORY");
-        goto err;
-      }
+      my_error(ER_GET_ERRNO, MYF(0), ha_err, hton_name(hton)->str);
+      goto err;
     }
   }
-
-#ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (check_partition_dirs(thd->lex->part_info))
-  {
-    goto err;
-  }
-#endif /* WITH_PARTITION_STORAGE_ENGINE */
-
-  if (!my_use_symdir || (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE))
-#endif /* HAVE_READLINK */
+  else
   {
-    if (create_info->data_file_name)
-      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                          WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
-                          "DATA DIRECTORY");
-    if (create_info->index_file_name)
-      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                          WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED),
-                          "INDEX DIRECTORY");
-    create_info->data_file_name= create_info->index_file_name= 0;
+    file= mysql_create_frm_image(thd, db, table_name, create_info, alter_info,
+                                 create_table_mode, &frm);
+    if (!file)
+      goto err;
+    if (rea_create_table(thd, &frm, path, db, table_name, create_info,
+                         create_table_mode == C_ALTER_TABLE_FRM_ONLY ? 0 : file))
+      goto err;
   }
-  create_info->table_options=db_options;
 
-  path[path_length - reg_ext_length]= '\0'; // Remove .frm extension
-  if (rea_create_table(thd, path, db, table_name,
-                       create_info, alter_info->create_list,
-                       key_count, key_info_buffer, file))
-    goto err;
-
-  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
+  if (create_info->tmp_table())
   {
     /*
       Open a table (skipping table cache) and add it into
       THD::temporary_tables list.
     */
 
-    TABLE *table= open_table_uncached(thd, path, db, table_name, TRUE);
+    TABLE *table= open_table_uncached(thd, create_info->db_type, path,
+                                      db, table_name, TRUE);
 
     if (!table)
     {
@@ -4514,7 +4450,7 @@ bool mysql_create_table_no_lock(THD *thd,
     thd->thread_specific_used= TRUE;
   }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  else if (part_info && create_info->frm_only)
+  else if (thd->work_part_info && create_table_mode == C_ALTER_TABLE_FRM_ONLY)
   {
     /*
       For partitioned tables we can't find some problems with table
@@ -4530,7 +4466,7 @@ bool mysql_create_table_no_lock(THD *thd,
                                              create_info, file))
     {
       char frm_name[FN_REFLEN];
-      strxmov(frm_name, path, reg_ext, NullS);
+      strxnmov(frm_name, sizeof(frm_name), path, reg_ext, NullS);
       (void) mysql_file_delete(key_file_frm, frm_name, MYF(0));
       goto err;
     }
@@ -4540,6 +4476,7 @@ bool mysql_create_table_no_lock(THD *thd,
   error= FALSE;
 err:
   THD_STAGE_INFO(thd, stage_after_create);
+  my_free(const_cast<uchar*>(frm.str));
   delete file;
   DBUG_RETURN(error);
 
@@ -4551,7 +4488,6 @@ warn:
   goto err;
 }
 
-
 /**
   Implementation of SQLCOM_CREATE_TABLE.
 
@@ -4566,41 +4502,38 @@ bool mysql_create_table(THD *thd, TABLE_LIST *create_table,
                         HA_CREATE_INFO *create_info,
                         Alter_info *alter_info)
 {
-  bool result;
+  const char *db= create_table->db;
+  const char *table_name= create_table->table_name;
   bool is_trans= FALSE;
+  int create_table_mode;
   DBUG_ENTER("mysql_create_table");
 
-  /*
-    Open or obtain an exclusive metadata lock on table being created.
-  */
+  /* Open or obtain an exclusive metadata lock on table being created  */
   if (open_and_lock_tables(thd, thd->lex->query_tables, FALSE, 0))
   {
     /* is_error() may be 0 if table existed and we generated a warning */
-    result= thd->is_error();
-    goto end;
+    DBUG_RETURN(thd->is_error());
   }
 
   /* Got lock. */
   DEBUG_SYNC(thd, "locked_table_name");
 
+  if (alter_info->create_list.elements || alter_info->key_list.elements)
+    create_table_mode= C_ORDINARY_CREATE;
+  else
+    create_table_mode= C_ASSISTED_DISCOVERY;
+
   promote_first_timestamp_column(&alter_info->create_list);
-  result= mysql_create_table_no_lock(thd, create_table->db,
-                                     create_table->table_name, create_info,
-                                     alter_info, FALSE, 0, &is_trans);
+  if (mysql_create_table_no_lock(thd, db, table_name, create_info, alter_info,
+                                 &is_trans, create_table_mode))
+    DBUG_RETURN(1);
 
-  /*
-    Don't write statement if:
-    - Table creation has failed
-    - Row-based logging is used and we are creating a temporary table
-    Otherwise, the statement shall be binlogged.
-  */
-  if (!result &&
-      (!thd->is_current_stmt_binlog_format_row() ||
-       (thd->is_current_stmt_binlog_format_row() &&
-        !(create_info->options & HA_LEX_CREATE_TMP_TABLE))))
-    result= write_bin_log(thd, TRUE, thd->query(), thd->query_length(), is_trans);
+  /* In RBR we don't need to log CREATE TEMPORARY TABLE */
+  if (thd->is_current_stmt_binlog_format_row() && create_info->tmp_table())
+    DBUG_RETURN(0);
 
-end:
+  bool result;
+  result= write_bin_log(thd, TRUE, thd->query(), thd->query_length(), is_trans);
   DBUG_RETURN(result);
 }
 
@@ -4720,9 +4653,13 @@ mysql_rename_table(handlerton *base, const char *old_db,
     if (!(flags & NO_FRM_RENAME) && rename_file_ext(from,to,reg_ext))
     {
       error=my_errno;
-      /* Restore old file name */
       if (file)
-        file->ha_rename_table(to_base, from_base);
+      {
+        if (error == ENOENT)
+          error= 0; // this is ok if file->ha_rename_table() succeeded
+        else
+          file->ha_rename_table(to_base, from_base); // Restore old file name
+      }
     }
   }
   delete file;
@@ -4820,7 +4757,7 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table, TABLE_LIST* src_table,
   local_create_info.options|= create_info->options&HA_LEX_CREATE_IF_NOT_EXISTS;
   /* Replace type of source table with one specified in the statement. */
   local_create_info.options&= ~HA_LEX_CREATE_TMP_TABLE;
-  local_create_info.options|= create_info->options & HA_LEX_CREATE_TMP_TABLE;
+  local_create_info.options|= create_info->tmp_table();
   /* Reset auto-increment counter for the new table. */
   local_create_info.auto_increment_value= 0;
   /*
@@ -4831,14 +4768,14 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table, TABLE_LIST* src_table,
 
   if ((res= mysql_create_table_no_lock(thd, table->db, table->table_name,
                                        &local_create_info, &local_alter_info,
-                                       FALSE, 0, &is_trans)))
+                                       &is_trans, C_ORDINARY_CREATE)))
     goto err;
 
   /*
     Ensure that we have an exclusive lock on target table if we are creating
     non-temporary table.
   */
-  DBUG_ASSERT((create_info->options & HA_LEX_CREATE_TMP_TABLE) ||
+  DBUG_ASSERT((create_info->tmp_table()) ||
               thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
                                              table->table_name,
                                              MDL_EXCLUSIVE));
@@ -4865,7 +4802,7 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table, TABLE_LIST* src_table,
            4    temporary temporary Nothing
            ==== ========= ========= ==============================
     */
-    if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
+    if (!(create_info->tmp_table()))
     {
       if (src_table->table->s->tmp_table)               // Case 2
       {
@@ -5032,6 +4969,246 @@ is_index_maintenance_unique (TABLE *table, Alter_info *alter_info)
 
 
 /*
+   Preparation for table creation
+
+   SYNOPSIS
+     handle_if_exists_option()
+       thd                       Thread object.
+       table                     The altered table.
+       alter_info                List of columns and indexes to create
+
+   DESCRIPTION
+     Looks for the IF [NOT] EXISTS options, checks the states and remove items
+     from the list if existing found.
+
+   RETURN VALUES
+     NONE
+*/
+
+static void
+handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
+{
+  Field **f_ptr;
+  DBUG_ENTER("handle_if_exists_option");
+
+  /* Handle ADD COLUMN IF NOT EXISTS. */
+  {
+    List_iterator<Create_field> it(alter_info->create_list);
+    Create_field *sql_field;
+
+    while ((sql_field=it++))
+    {
+      if (!sql_field->create_if_not_exists || sql_field->change)
+        continue;
+      /*
+         If there is a field with the same name in the table already,
+         remove the sql_field from the list.
+      */
+      for (f_ptr=table->field; *f_ptr; f_ptr++)
+      {
+        if (my_strcasecmp(system_charset_info,
+              sql_field->field_name, (*f_ptr)->field_name) == 0)
+        {
+          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+              ER_DUP_FIELDNAME, ER(ER_DUP_FIELDNAME),
+              sql_field->field_name);
+          it.remove();
+          if (alter_info->create_list.is_empty())
+          {
+            alter_info->flags&= ~ALTER_ADD_COLUMN;
+            if (alter_info->key_list.is_empty())
+              alter_info->flags&= ~ALTER_ADD_INDEX;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  /* Handle MODIFY COLUMN IF EXISTS. */
+  {
+    List_iterator<Create_field> it(alter_info->create_list);
+    Create_field *sql_field;
+
+    while ((sql_field=it++))
+    {
+      if (!sql_field->create_if_not_exists || !sql_field->change)
+        continue;
+      /*
+         If there is NO field with the same name in the table already,
+         remove the sql_field from the list.
+      */
+      for (f_ptr=table->field; *f_ptr; f_ptr++)
+      {
+        if (my_strcasecmp(system_charset_info,
+              sql_field->field_name, (*f_ptr)->field_name) == 0)
+        {
+          break;
+        }
+      }
+      if (*f_ptr == NULL)
+      {
+        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+            ER_BAD_FIELD_ERROR, ER(ER_BAD_FIELD_ERROR),
+            sql_field->change, table->s->table_name.str);
+        it.remove();
+        if (alter_info->create_list.is_empty())
+        {
+          alter_info->flags&= ~(ALTER_ADD_COLUMN | ALTER_CHANGE_COLUMN);
+          if (alter_info->key_list.is_empty())
+            alter_info->flags&= ~ALTER_ADD_INDEX;
+        }
+      }
+    }
+  }
+
+  /* Handle DROP COLUMN/KEY IF EXISTS. */
+  {
+    List_iterator<Alter_drop> drop_it(alter_info->drop_list);
+    Alter_drop *drop;
+    bool remove_drop;
+    while ((drop= drop_it++))
+    {
+      if (!drop->drop_if_exists)
+        continue;
+      remove_drop= TRUE;
+      if (drop->type == Alter_drop::COLUMN)
+      {
+        /*
+           If there is NO field with that name in the table,
+           remove the 'drop' from the list.
+        */
+        for (f_ptr=table->field; *f_ptr; f_ptr++)
+        {
+          if (my_strcasecmp(system_charset_info,
+                            drop->name, (*f_ptr)->field_name) == 0)
+          {
+            remove_drop= FALSE;
+            break;
+          }
+        }
+      }
+      else /* Alter_drop::KEY */
+      {
+        uint n_key;
+        for (n_key=0; n_key < table->s->keys; n_key++)
+        {
+          if (my_strcasecmp(system_charset_info,
+                            drop->name, table->key_info[n_key].name) == 0)
+          {
+            remove_drop= FALSE;
+            break;
+          }
+        }
+      }
+      if (remove_drop)
+      {
+        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+            ER_CANT_DROP_FIELD_OR_KEY, ER(ER_CANT_DROP_FIELD_OR_KEY),
+            drop->name);
+        drop_it.remove();
+        if (alter_info->drop_list.is_empty())
+          alter_info->flags&= ~(ALTER_DROP_COLUMN | ALTER_DROP_INDEX);
+      }
+    }
+  }
+
+  /* ALTER TABLE ADD KEY IF NOT EXISTS */
+  /* ALTER TABLE ADD FOREIGN KEY IF NOT EXISTS */
+  {
+    Key *key;
+    List_iterator<Key> key_it(alter_info->key_list);
+    uint n_key;
+    while ((key=key_it++))
+    {
+      if (!key->create_if_not_exists)
+        continue;
+      for (n_key=0; n_key < table->s->keys; n_key++)
+      {
+        if (my_strcasecmp(system_charset_info,
+              key->name.str, table->key_info[n_key].name) == 0)
+        {
+          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+              ER_DUP_KEYNAME, ER(ER_DUP_KEYNAME), key->name.str);
+          key_it.remove();
+          if (key->type == Key::FOREIGN_KEY)
+          {
+            /* ADD FOREIGN KEY appends two items. */
+            key_it.remove();
+          }
+          if (alter_info->key_list.is_empty())
+            alter_info->flags&= ~ALTER_ADD_INDEX;
+          break;
+        }
+      }
+    }
+  }
+  
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+  partition_info *tab_part_info= table->part_info;
+  if (tab_part_info && thd->lex->check_exists)
+  {
+    /* ALTER TABLE ADD PARTITION IF NOT EXISTS */
+    if (alter_info->flags & ALTER_ADD_PARTITION)
+    {
+      partition_info *alt_part_info= thd->lex->part_info;
+      if (alt_part_info)
+      {
+        List_iterator<partition_element> new_part_it(alt_part_info->partitions);
+        partition_element *pe;
+        while ((pe= new_part_it++))
+        {
+          if (!tab_part_info->has_unique_name(pe))
+          {
+            push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+                ER_SAME_NAME_PARTITION, ER(ER_SAME_NAME_PARTITION),
+                pe->partition_name);
+            alter_info->flags&= ~ALTER_ADD_PARTITION;
+            thd->lex->part_info= NULL;
+            break;
+          }
+        }
+      }
+    }
+    /* ALTER TABLE DROP PARTITION IF EXISTS */
+    if (alter_info->flags & ALTER_DROP_PARTITION)
+    {
+      List_iterator<char> names_it(alter_info->partition_names);
+      char *name;
+
+      while ((name= names_it++))
+      {
+        List_iterator<partition_element> part_it(tab_part_info->partitions);
+        partition_element *part_elem;
+        while ((part_elem= part_it++))
+        {
+          if (my_strcasecmp(system_charset_info,
+                              part_elem->partition_name, name) == 0)
+            break;
+        }
+        if (!part_elem)
+        {
+          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+              ER_DROP_PARTITION_NON_EXISTENT,
+              ER(ER_DROP_PARTITION_NON_EXISTENT), "DROP");
+          names_it.remove();
+        }
+      }
+      if (alter_info->partition_names.elements == 0)
+        alter_info->flags&= ~ALTER_DROP_PARTITION;
+    }
+  }
+#endif /*WITH_PARTITION_STORAGE_ENGINE*/
+
+  /* Clear the ALTER_FOREIGN_KEY flag if nothing other than that set. */
+  if (alter_info->flags == ALTER_FOREIGN_KEY)
+    alter_info->flags= 0;
+
+  DBUG_VOID_RETURN;
+}
+
+
+/*
   SYNOPSIS
     mysql_compare_tables()
       table                     The original table.
@@ -5123,12 +5300,11 @@ mysql_compare_tables(TABLE *table,
   *need_copy_table= ALTER_TABLE_DATA_CHANGED;
 
   /* Create the prepared information. */
-  if (mysql_prepare_create_table(thd, create_info,
-                                 &tmp_alter_info,
-                                 (table->s->tmp_table != NO_TMP_TABLE),
-                                 &db_options,
-                                 table->file, key_info_buffer,
-                                 &key_count, 0))
+  int create_table_mode= table->s->tmp_table == NO_TMP_TABLE ?
+                           C_ORDINARY_CREATE : C_ALTER_TABLE;
+  if (mysql_prepare_create_table(thd, create_info, &tmp_alter_info,
+                                 &db_options, table->file, key_info_buffer,
+                                 &key_count, create_table_mode))
     DBUG_RETURN(1);
   /* Allocate result buffers. */
   if (! (*index_drop_buffer=
@@ -5494,6 +5670,7 @@ bool alter_table_manage_keys(TABLE *table, int indexes_were_disabled,
 
   switch (keys_onoff) {
   case ENABLE:
+    DEBUG_SYNC(table->in_use, "alter_table_enable_indexes");
     error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
     break;
   case LEAVE_AS_IS:
@@ -5508,7 +5685,8 @@ bool alter_table_manage_keys(TABLE *table, int indexes_were_disabled,
   {
     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                         ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
-                        table->s->table_name.str);
+                        table->file->table_type(),
+                        table->s->db.str, table->s->table_name.str);
     error= 0;
   } else if (error)
     table->file->print_error(error, MYF(0));
@@ -5950,7 +6128,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
       key= new Key(key_type, key_name, strlen(key_name),
                    &key_create_info,
                    test(key_info->flags & HA_GENERATED_KEY),
-                   key_parts, key_info->option_list);
+                   key_parts, key_info->option_list, FALSE);
       new_key_list.push_back(key);
     }
   }
@@ -6069,13 +6247,11 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   TABLE *table, *new_table= 0;
   MDL_ticket *mdl_ticket;
   MDL_request target_mdl_request;
-  int error= 0;
+  int error= 0, create_table_mode= C_ALTER_TABLE;
   char tmp_name[80],old_name[32],new_name_buff[FN_REFLEN + 1];
-  char old_name_buff[FN_REFLEN + 1];
   char new_alias_buff[FN_REFLEN], *table_name, *db, *new_alias, *alias;
   char index_file[FN_REFLEN], data_file[FN_REFLEN];
   char path[FN_REFLEN + 1];
-  char reg_path[FN_REFLEN+1];
   ha_rows copied,deleted;
   handlerton *old_db_type, *new_db_type, *save_old_db_type;
   enum_alter_table_change_level need_copy_table= ALTER_TABLE_METADATA_ONLY;
@@ -6130,7 +6306,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
           (!create_info->db_type || /* unknown engine */
            !(create_info->db_type->flags & HTON_SUPPORT_LOG_TABLES)))
       {
-        my_error(ER_UNSUPORTED_LOG_ENGINE, MYF(0));
+        my_error(ER_UNSUPORTED_LOG_ENGINE, MYF(0),
+                 hton_name(create_info->db_type)->str);
         DBUG_RETURN(TRUE);
       }
 
@@ -6145,7 +6322,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   }
 
   /*
-    Assign variables table_name, new_name, db, new_db, path, reg_path
+    Assign variables table_name, new_name, db, new_db, path,
     to simplify further comparisions: we want to see if it's a RENAME
     later just by comparing the pointers, avoiding the need for strcmp.
   */
@@ -6155,7 +6332,6 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   db=table_list->db;
   if (!new_db || !my_strcasecmp(table_alias_charset, new_db, db))
     new_db= db;
-  build_table_filename(reg_path, sizeof(reg_path) - 1, db, table_name, reg_ext, 0);
   build_table_filename(path, sizeof(path) - 1, db, table_name, "", 0);
 
   mysql_ha_rm_tables(thd, table_list);
@@ -6278,12 +6454,10 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
         */
         build_table_filename(new_name_buff, sizeof(new_name_buff) - 1,
                              new_db, new_name_buff, reg_ext, 0);
-        build_table_filename(old_name_buff, sizeof(old_name_buff) - 1,
-                             db, table_name, reg_ext, 0);
-        if (check_table_file_presence(old_name_buff, new_name_buff, new_db,
-                                      new_name, new_alias, TRUE))
+        if (!access(new_name_buff, F_OK))
 	{
 	  /* Table will be closed in do_command() */
+          my_error(ER_TABLE_EXISTS_ERROR, MYF(0), new_alias);
           goto err;
 	}
       }
@@ -6349,11 +6523,19 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   DBUG_PRINT("info", ("old type: %s  new type: %s",
              ha_resolve_storage_engine_name(old_db_type),
              ha_resolve_storage_engine_name(new_db_type)));
-  if (ha_check_storage_engine_flag(old_db_type, HTON_ALTER_NOT_SUPPORTED) ||
-      ha_check_storage_engine_flag(new_db_type, HTON_ALTER_NOT_SUPPORTED))
+  if (ha_check_storage_engine_flag(old_db_type, HTON_ALTER_NOT_SUPPORTED))
+  {
+    DBUG_PRINT("info", ("doesn't support alter"));
+    my_error(ER_ILLEGAL_HA, MYF(0), hton_name(old_db_type)->str,
+             db, table_name);
+    goto err;
+  }
+
+  if (ha_check_storage_engine_flag(new_db_type, HTON_ALTER_NOT_SUPPORTED))
   {
     DBUG_PRINT("info", ("doesn't support alter"));
-    my_error(ER_ILLEGAL_HA, MYF(0), table_name);
+    my_error(ER_ILLEGAL_HA, MYF(0), hton_name(new_db_type)->str,
+             new_db, new_name);
     goto err;
   }
   
@@ -6361,31 +6543,13 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   if (!(alter_info->flags & ~(ALTER_RENAME | ALTER_KEYS_ONOFF)) &&
       !table->s->tmp_table) // no need to touch frm
   {
-    switch (alter_info->keys_onoff) {
-    case LEAVE_AS_IS:
-      break;
-    case ENABLE:
-      if (wait_while_table_is_used(thd, table, extra_func))
-        goto err;
-      DEBUG_SYNC(thd,"alter_table_enable_indexes");
-      error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
-      break;
-    case DISABLE:
-      if (wait_while_table_is_used(thd, table, extra_func))
-        goto err;
-      error=table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
-      break;
-    default:
-      DBUG_ASSERT(FALSE);
-      error= 0;
-      break;
-    }
-    if (error == HA_ERR_WRONG_COMMAND)
+    if (alter_info->keys_onoff != LEAVE_AS_IS)
     {
-      error= 0;
-      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
-			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
-			  table->alias.c_ptr());
+      if (wait_while_table_is_used(thd, table, extra_func,
+                                   TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
+        goto err;
+      error= alter_table_manage_keys(table, 0, alter_info->keys_onoff);
+      table->s->allow_access_to_protected_table();
     }
 
     if (!error && (new_name != table_name || new_db != db))
@@ -6399,7 +6563,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
         simple rename did nothing and therefore we can safely return
         without additional clean-up.
       */
-      if (wait_while_table_is_used(thd, table, extra_func))
+      if (wait_while_table_is_used(thd, table, extra_func,
+                                   TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
         goto err;
       close_all_tables_for_name(thd, table->s, HA_EXTRA_PREPARE_FOR_RENAME);
       /*
@@ -6442,7 +6607,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
       error= 0;
       push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
 			  ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
-			  table->alias.c_ptr());
+                          table->file->table_type(),
+                          table->s->db.str, table->s->table_name.str);
     }
 
     if (!error)
@@ -6475,6 +6641,17 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
     DBUG_RETURN(error);
   }
 
+  handle_if_exists_options(thd, table, alter_info);
+
+  /* Look if we have to do anything at all. */
+  /* Normally ALTER can become NOOP only after handling */
+  /* the IF (NOT) EXISTS options. */
+  if (alter_info->flags == 0)
+  {
+    copied= deleted= 0;
+    goto end_temporary;
+  }
+
   /* We have to do full alter table. */
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
@@ -6735,13 +6912,17 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
                         need_copy_table, need_lock_for_indexes));
   }
 
-  /*
-    better have a negative test here, instead of positive, like
-    alter_info->flags & ALTER_ADD_COLUMN|ALTER_ADD_INDEX|...
-    so that ALTER TABLE won't break when somebody will add new flag
-  */
   if (need_copy_table == ALTER_TABLE_METADATA_ONLY)
-    create_info->frm_only= 1;
+  {
+    char frm_name[FN_REFLEN+1];
+    strxnmov(frm_name, sizeof(frm_name), path, reg_ext, NullS);
+    /*
+      C_ALTER_TABLE_FRM_ONLY can only be used if old frm exists.
+      discovering frm-less engines cannot enjoy this optimization.
+    */
+    if (!my_access(frm_name, F_OK))
+      create_table_mode= C_ALTER_TABLE_FRM_ONLY;
+  }
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (table_for_fast_alter_partition)
@@ -6810,13 +6991,13 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
                   my_sleep(100000););
   /*
     Create a table with a temporary name.
-    With create_info->frm_only == 1 this creates a .frm file only and
+    With C_ALTER_TABLE_FRM_ONLY this creates a .frm file only and
     we keep the original row format.
     We don't log the statement, it will be logged later.
   */
   if (need_copy_table == ALTER_TABLE_METADATA_ONLY)
   {
-    DBUG_ASSERT(create_info->frm_only);
+    DBUG_ASSERT(create_table_mode == C_ALTER_TABLE_FRM_ONLY);
     /* Ensure we keep the original table format */
     create_info->table_options= ((create_info->table_options &
                                   ~HA_OPTION_PACK_RECORD) |
@@ -6824,10 +7005,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
                                   HA_OPTION_PACK_RECORD));
   }
   tmp_disable_binlog(thd);
-  error= mysql_create_table_no_lock(thd, new_db, tmp_name,
-                                    create_info,
-                                    alter_info,
-                                    1, 0, NULL);
+  error= mysql_create_table_no_lock(thd, new_db, tmp_name, create_info,
+                                    alter_info, NULL, create_table_mode);
   reenable_binlog(thd);
   if (error)
     goto err;
@@ -6839,6 +7018,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
     if (table->s->tmp_table)
     {
       Open_table_context ot_ctx(thd, (MYSQL_OPEN_IGNORE_FLUSH |
+                                      MYSQL_OPEN_FOR_REPAIR |
                                       MYSQL_LOCK_IGNORE_TIMEOUT));
       TABLE_LIST tbl;
       bzero((void*) &tbl, sizeof(tbl));
@@ -6855,7 +7035,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
       build_table_filename(path, sizeof(path) - 1, new_db, tmp_name, "",
                            FN_IS_TMP);
       /* Open our intermediate table. */
-      new_table= open_table_uncached(thd, path, new_db, tmp_name, TRUE);
+      new_table= open_table_uncached(thd, new_db_type, path,
+                                     new_db, tmp_name, TRUE);
     }
     if (!new_table)
       goto err_new_table_cleanup;
@@ -6909,7 +7090,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
         table->file->indexes_are_disabled())
       need_lock_for_indexes= true;
     if (!table->s->tmp_table && need_lock_for_indexes &&
-        wait_while_table_is_used(thd, table, extra_func))
+        wait_while_table_is_used(thd, table, extra_func,
+                                 TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
       goto err_new_table_cleanup;
     THD_STAGE_INFO(thd, stage_manage_keys);
     DEBUG_SYNC(thd, "alter_table_manage_keys");
@@ -6918,6 +7100,11 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
     error= trans_commit_stmt(thd);
     if (trans_commit_implicit(thd))
       error= 1;
+    /*
+      If the table was locked, allow one to still run SHOW commands against it
+    */
+    if (table->s->protected_against_usage())
+      table->s->allow_access_to_protected_table();
   }
   thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
@@ -7129,7 +7316,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   if (lower_case_table_names)
     my_casedn_str(files_charset_info, old_name);
 
-  if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_RENAME))
+  if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_RENAME,
+                               TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
   {
     if (pending_inplace_add_index)
     {
@@ -7284,9 +7472,8 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
     }
 
     /* Tell the handler that a new frm file is in place. */
-    error= t_table_list->table->file->ha_create_handler_files(path, NULL,
-                                                              CHF_INDEX_FLAG,
-                                                              create_info);
+    error= t_table_list->table->file->ha_create_partitioning_metadata(path, NULL,
+                                                              CHF_INDEX_FLAG);
 
     DBUG_ASSERT(thd->open_tables == t_table_list->table);
     close_thread_table(thd, &thd->open_tables);
@@ -7309,7 +7496,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
 
   DBUG_ASSERT(!(mysql_bin_log.is_open() &&
                 thd->is_current_stmt_binlog_format_row() &&
-                (create_info->options & HA_LEX_CREATE_TMP_TABLE)));
+                (create_info->tmp_table())));
   if (write_bin_log(thd, TRUE, thd->query(), thd->query_length()))
     DBUG_RETURN(TRUE);
 
@@ -7340,7 +7527,8 @@ err_new_table_cleanup:
   }
   else
     (void) quick_rm_table(new_db_type, new_db, tmp_name,
-                          create_info->frm_only ? FN_IS_TMP | FRM_ONLY : FN_IS_TMP);
+                          create_table_mode == C_ALTER_TABLE_FRM_ONLY ?
+                          FN_IS_TMP | FRM_ONLY : FN_IS_TMP);
 
 err:
 #ifdef WITH_PARTITION_STORAGE_ENGINE
@@ -7486,11 +7674,11 @@ copy_data_between_tables(THD *thd, TABLE *from,TABLE *to,
   if (!(copy= new Copy_field[to->s->fields]))
     goto err;		/* purecov: inspected */
 
+  /* We need external lock before we can disable/enable keys */
   if (to->file->ha_external_lock(thd, F_WRLCK))
     goto err;
   errpos= 2;
 
-  /* We need external lock before we can disable/enable keys */
   alter_table_manage_keys(to, from->file->indexes_are_disabled(), keys_onoff);
 
   /* We can abort alter table for any table type */
@@ -7932,7 +8120,7 @@ static bool check_engine(THD *thd, const char *db_name,
                        ha_resolve_storage_engine_name(*new_engine),
                        table_name);
   }
-  if (create_info->options & HA_LEX_CREATE_TMP_TABLE &&
+  if (create_info->tmp_table() &&
       ha_check_storage_engine_flag(*new_engine, HTON_TEMPORARY_NOT_SUPPORTED))
   {
     if (create_info->used_fields & HA_CREATE_USED_ENGINE)
diff --git a/sql/sql_table.h b/sql/sql_table.h
index 9d5e768a5a3..8bc6865decd 100644
--- a/sql/sql_table.h
+++ b/sql/sql_table.h
@@ -1,4 +1,5 @@
-/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2006, 2010, Oracle and/or its affiliates.
+   Copyright (c) 2011, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -25,8 +26,9 @@ struct TABLE_LIST;
 class THD;
 struct TABLE;
 struct handlerton;
+class handler;
 typedef struct st_ha_check_opt HA_CHECK_OPT;
-typedef struct st_ha_create_information HA_CREATE_INFO;
+struct HA_CREATE_INFO;
 typedef struct st_key KEY;
 typedef struct st_key_cache KEY_CACHE;
 typedef struct st_lock_param_type ALTER_PARTITION_PARAM_TYPE;
@@ -131,18 +133,57 @@ uint build_table_filename(char *buff, size_t bufflen, const char *db,
                           const char *table, const char *ext, uint flags);
 uint build_table_shadow_filename(char *buff, size_t bufflen,
                                  ALTER_PARTITION_PARAM_TYPE *lpt);
-bool check_table_file_presence(char *old_path, char *path, const char *db,
-                               const char *table_name, const char *alias,
-                               bool issue_error);
 bool mysql_create_table(THD *thd, TABLE_LIST *create_table,
                         HA_CREATE_INFO *create_info,
                         Alter_info *alter_info);
+
+/*
+  mysql_create_table_no_lock can be called in one of the following
+  mutually exclusive situations:
+
+  - Just a normal ordinary CREATE TABLE statement that explicitly
+    defines the table structure.
+
+  - CREATE TABLE ... SELECT. It is special, because only in this case,
+    the list of fields is allowed to have duplicates, as long as one of the
+    duplicates comes from the select list, and the other doesn't. For
+    example in
+
+       CREATE TABLE t1 (a int(5) NOT NUL) SELECT b+10 as a FROM t2;
+
+    the list in alter_info->create_list will have two fields `a`.
+
+  - ALTER TABLE, that creates a temporary table #sql-xxx, which will be later
+    renamed to replace the original table.
+
+  - ALTER TABLE as above, but which only modifies the frm file, it only
+    creates an frm file for the #sql-xxx, the table in the engine is not
+    created.
+
+  - Assisted discovery, CREATE TABLE statement without the table structure.
+
+  These situations are distinguished by the following "create table mode"
+  values, where a CREATE ... SELECT is denoted by any non-negative number
+  (which should be the number of fields in the SELECT ... part), and other
+  cases use constants as defined below.
+*/
+#define C_CREATE_SELECT(X)        ((X) > 0 ? (X) : 0)
+#define C_ORDINARY_CREATE         0
+#define C_ALTER_TABLE            -1
+#define C_ALTER_TABLE_FRM_ONLY   -2
+#define C_ASSISTED_DISCOVERY     -3
+
 bool mysql_create_table_no_lock(THD *thd, const char *db,
                                 const char *table_name,
                                 HA_CREATE_INFO *create_info,
+                                Alter_info *alter_info, bool *is_trans,
+                                int create_table_mode);
+
+handler *mysql_create_frm_image(THD *thd,
+                                const char *db, const char *table_name,
+                                HA_CREATE_INFO *create_info,
                                 Alter_info *alter_info,
-                                bool tmp_table, uint select_field_count,
-                                bool *is_trans);
+                                int create_table_mode, LEX_CUSTRING *frm);
 bool mysql_prepare_alter_table(THD *thd, TABLE *table,
                                HA_CREATE_INFO *create_info,
                                Alter_info *alter_info);
diff --git a/sql/sql_time.cc b/sql/sql_time.cc
index 57dbd979933..89c2e3b7086 100644
--- a/sql/sql_time.cc
+++ b/sql/sql_time.cc
@@ -302,6 +302,9 @@ str_to_datetime_with_warn(CHARSET_INFO *cs,
     make_truncated_value_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                                  str, length, flags & TIME_TIME_ONLY ?
                                  MYSQL_TIMESTAMP_TIME : ts_type, NullS);
+  DBUG_EXECUTE_IF("str_to_datetime_warn",
+                  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
+                               ER_YES, str););
   return ts_type;
 }
 
@@ -1014,13 +1017,13 @@ calc_time_diff(MYSQL_TIME *l_time1, MYSQL_TIME *l_time2, int l_sign, longlong *s
 			       (uint) l_time2->day);
   }
 
-  microseconds= ((longlong)days*LL(86400) +
+  microseconds= ((longlong)days*86400LL +
                  (longlong)(l_time1->hour*3600L +
                             l_time1->minute*60L +
                             l_time1->second) -
                  l_sign*(longlong)(l_time2->hour*3600L +
                                    l_time2->minute*60L +
-                                   l_time2->second)) * LL(1000000) +
+                                   l_time2->second)) * 1000000LL +
                 (longlong)l_time1->second_part -
                 l_sign*(longlong)l_time2->second_part;
 
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index d7d902bc6b0..35a4464b9e2 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -443,7 +443,7 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create)
 
   if (!create)
   {
-    bool if_exists= thd->lex->drop_if_exists;
+    bool if_exists= thd->lex->check_exists;
 
     /*
       Protect the query table list from the temporary and potentially
@@ -701,10 +701,7 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables,
                      thd->security_ctx->priv_host)))
   {
     if (check_global_access(thd, SUPER_ACL))
-    {
-      my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
       return TRUE;
-    }
   }
 
   /*
diff --git a/sql/sql_truncate.cc b/sql/sql_truncate.cc
index 4b77344c042..19ce553f5ce 100644
--- a/sql/sql_truncate.cc
+++ b/sql/sql_truncate.cc
@@ -258,27 +258,18 @@ static bool recreate_temporary_table(THD *thd, TABLE *table)
 {
   bool error= TRUE;
   TABLE_SHARE *share= table->s;
-  HA_CREATE_INFO create_info;
   handlerton *table_type= table->s->db_type();
   DBUG_ENTER("recreate_temporary_table");
 
-  memset(&create_info, 0, sizeof(create_info));
-  create_info.options|= HA_LEX_CREATE_TMP_TABLE;
-
   table->file->info(HA_STATUS_AUTO | HA_STATUS_NO_LOCK);
 
   /* Don't free share. */
   close_temporary_table(thd, table, FALSE, FALSE);
 
-  /*
-    We must use share->normalized_path.str since for temporary tables it
-    differs from what dd_recreate_table() would generate based
-    on table and schema names.
-  */
-  ha_create_table(thd, share->normalized_path.str, share->db.str,
-                  share->table_name.str, &create_info, 1);
+  dd_recreate_table(thd, share->db.str, share->table_name.str,
+                    share->normalized_path.str);
 
-  if (open_table_uncached(thd, share->path.str, share->db.str,
+  if (open_table_uncached(thd, table_type, share->path.str, share->db.str,
                           share->table_name.str, TRUE))
   {
     error= FALSE;
@@ -350,9 +341,27 @@ bool Truncate_statement::lock_table(THD *thd, TABLE_LIST *table_ref,
                          MYSQL_OPEN_SKIP_TEMPORARY))
       DBUG_RETURN(TRUE);
 
-    if (dd_check_storage_engine_flag(thd, table_ref->db, table_ref->table_name,
-                                     HTON_CAN_RECREATE, hton_can_recreate))
+    handlerton *hton;
+    if (!ha_table_exists(thd, table_ref->db, table_ref->table_name, &hton) ||
+        hton == view_pseudo_hton)
+    {
+      my_error(ER_NO_SUCH_TABLE, MYF(0), table_ref->db, table_ref->table_name);
       DBUG_RETURN(TRUE);
+    }
+
+    if (!hton)
+    {
+      /*
+        The table exists, but its storage engine is unknown, perhaps not
+        loaded at the moment. We need to open and parse the frm to know the
+        storage engine in question, so let's proceed with the truncation and
+        try to open the table. This will produce the correct error message
+        about unknown engine.
+      */
+      *hton_can_recreate= false;
+    }
+    else
+      *hton_can_recreate= hton->flags & HTON_CAN_RECREATE;
   }
 
   /*
@@ -364,7 +373,8 @@ bool Truncate_statement::lock_table(THD *thd, TABLE_LIST *table_ref,
   {
     DEBUG_SYNC(thd, "upgrade_lock_for_truncate");
     /* To remove the table from the cache we need an exclusive lock. */
-    if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_DROP))
+    if (wait_while_table_is_used(thd, table, HA_EXTRA_PREPARE_FOR_DROP,
+                                 TDC_RT_REMOVE_NOT_OWN_AND_MARK_NOT_USABLE))
       DBUG_RETURN(TRUE);
     m_ticket_downgrade= table->mdl_ticket;
     /* Close if table is going to be recreated. */
diff --git a/sql/sql_udf.h b/sql/sql_udf.h
index cdb15b9e0f5..4aa055b9858 100644
--- a/sql/sql_udf.h
+++ b/sql/sql_udf.h
@@ -103,14 +103,14 @@ class udf_handler :public Sql_alloc
     if (get_arguments())
     {
       *null_value=1;
-      return LL(0);
+      return 0;
     }
     Udf_func_longlong func= (Udf_func_longlong) u_d->func;
     longlong tmp=func(&initid, &f_args, &is_null, &error);
     if (is_null || error)
     {
       *null_value=1;
-      return LL(0);
+      return 0;
     }
     *null_value=0;
     return tmp;
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 0d1cb7de5f2..8413f612111 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -1573,6 +1573,15 @@ int multi_update::prepare(List<Item> &not_used_values,
   DBUG_RETURN(thd->is_fatal_error != 0);
 }
 
+void multi_update::update_used_tables()
+{
+  Item *item;
+  List_iterator_fast<Item> it(*values);
+  while ((item= it++))
+  {
+    item->update_used_tables();
+  }
+}
 
 /*
   Check if table is safe to update on fly
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index 02f70c12ad2..5b5bd0ed2fc 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -1,5 +1,5 @@
 /* Copyright (c) 2004, 2011, Oracle and/or its affiliates.
-   Copyright (c) 2011 Monty Program Ab
+   Copyright (c) 2011, 2013, Monty Program Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -33,7 +33,7 @@
 #include "sp_head.h"
 #include "sp.h"
 #include "sp_cache.h"
-#include "datadict.h"   // dd_frm_type()
+#include "datadict.h"   // dd_frm_is_view()
 
 #define MD5_BUFF_LENGTH 33
 
@@ -211,16 +211,12 @@ static void make_valid_column_names(List<Item> &item_list)
 static bool
 fill_defined_view_parts (THD *thd, TABLE_LIST *view)
 {
-  char key[MAX_DBKEY_LENGTH];
-  uint key_length;
   LEX *lex= thd->lex;
   TABLE_LIST decoy;
 
   memcpy (&decoy, view, sizeof (TABLE_LIST));
-  key_length= create_table_def_key(thd, key, view, 0);
-
-  if (tdc_open_view(thd, &decoy, decoy.alias, key, key_length,
-                    thd->mem_root, OPEN_VIEW_NO_PARSE))
+  if (tdc_open_view(thd, &decoy, decoy.alias, thd->mem_root,
+                    OPEN_VIEW_NO_PARSE))
     return TRUE;
 
   if (!lex->definer)
@@ -871,7 +867,7 @@ static int mysql_register_view(THD *thd, TABLE_LIST *view,
   view->source= thd->lex->create_view_select;
 
   if (!thd->make_lex_string(&view->select_stmt, view_query.ptr(),
-                            view_query.length(), false))
+                            view_query.length()))
   {
     my_error(ER_OUT_OF_RESOURCES, MYF(0));
     error= -1;
@@ -1004,7 +1000,7 @@ loop_out:
                  view->view_creation_ctx->get_connection_cl()->name);
 
   if (!thd->make_lex_string(&view->view_body_utf8, is_query.ptr(),
-                            is_query.length(), false))
+                            is_query.length()))
   {
     my_error(ER_OUT_OF_RESOURCES, MYF(0));
     error= -1;
@@ -1646,7 +1642,6 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
   String non_existant_views;
   char *wrong_object_db= NULL, *wrong_object_name= NULL;
   bool error= FALSE;
-  enum legacy_db_type not_used;
   bool some_views_deleted= FALSE;
   bool something_wrong= FALSE;
   DBUG_ENTER("mysql_drop_view");
@@ -1669,23 +1664,28 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
 
   for (view= views; view; view= view->next_local)
   {
-    frm_type_enum type= FRMTYPE_ERROR;
+    bool not_exist;
     build_table_filename(path, sizeof(path) - 1,
                          view->db, view->table_name, reg_ext, 0);
 
-    if (access(path, F_OK) || 
-        FRMTYPE_VIEW != (type= dd_frm_type(thd, path, &not_used)))
+    if ((not_exist= my_access(path, F_OK)) || !dd_frm_is_view(thd, path))
     {
       char name[FN_REFLEN];
       my_snprintf(name, sizeof(name), "%s.%s", view->db, view->table_name);
-      if (thd->lex->drop_if_exists)
+      if (thd->lex->check_exists)
       {
 	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
 			    ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
 			    name);
 	continue;
       }
-      if (type == FRMTYPE_TABLE)
+      if (not_exist)
+      {
+        if (non_existant_views.length())
+          non_existant_views.append(',');
+        non_existant_views.append(String(view->table_name,system_charset_info));
+      }
+      else
       {
         if (!wrong_object_name)
         {
@@ -1693,12 +1693,6 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
           wrong_object_name= view->table_name;
         }
       }
-      else
-      {
-        if (non_existant_views.length())
-          non_existant_views.append(',');
-        non_existant_views.append(String(view->table_name,system_charset_info));
-      }
       continue;
     }
     if (mysql_file_delete(key_file_frm, path, MYF(MY_WME)))
@@ -1707,9 +1701,8 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
     some_views_deleted= TRUE;
 
     /*
-      For a view, there is a TABLE_SHARE object, but its
-      ref_count never goes above 1. Remove it from the table
-      definition cache, in case the view was cached.
+      For a view, there is a TABLE_SHARE object.
+      Remove it from the table definition cache, in case the view was cached.
     */
     tdc_remove_table(thd, TDC_RT_REMOVE_ALL, view->db, view->table_name,
                      FALSE);
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 56e7db96a1a..fdd90d95b2d 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -722,7 +722,7 @@ static bool add_create_index (LEX *lex, Key::Keytype type,
 {
   Key *key;
   key= new Key(type, name, info ? info : &lex->key_create_info, generated, 
-               lex->col_list, lex->option_list);
+               lex->col_list, lex->option_list, lex->check_exists);
   if (key == NULL)
     return TRUE;
 
@@ -899,10 +899,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %pure_parser                                    /* We have threads */
 /*
-  Currently there are 171 shift/reduce conflicts.
+  Currently there are 170 shift/reduce conflicts.
   We should not introduce new conflicts any more.
 */
-%expect 171
+%expect 170
 
 /*
    Comments for TOKENS.
@@ -1566,14 +1566,14 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         IDENT_sys TEXT_STRING_sys TEXT_STRING_literal
         NCHAR_STRING opt_component key_cache_name
         sp_opt_label BIN_NUM label_ident TEXT_STRING_filesystem ident_or_empty
-        opt_constraint constraint opt_ident
+        opt_constraint constraint opt_ident opt_if_not_exists_ident
 
 %type <lex_str_ptr>
         opt_table_alias
 
 %type <table>
         table_ident table_ident_nodb references xid
-        table_ident_opt_wild
+        table_ident_opt_wild create_like
 
 %type <simple_string>
         remember_name remember_end opt_db text_or_password
@@ -1583,7 +1583,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %type <num>
         type type_with_opt_collate int_type real_type order_dir lock_option
-        udf_type if_exists opt_local opt_table_options table_options
+        udf_type opt_if_exists opt_local opt_table_options table_options
         table_option opt_if_not_exists opt_no_write_to_binlog
         opt_temporary all_or_any opt_distinct
         opt_ignore_leaves fulltext_options spatial_type union_option
@@ -1742,7 +1742,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         clear_privileges flush_options flush_option
         opt_with_read_lock flush_options_list
         equal optional_braces
-        opt_mi_check_type opt_to mi_check_types normal_join
+        opt_mi_check_type opt_to mi_check_types 
         table_to_table_list table_to_table opt_table_list opt_as
         handler_rkey_function handler_read_or_scan
         single_multi table_wild_list table_wild_one opt_wild
@@ -1799,8 +1799,12 @@ END_OF_INPUT
         '-' '+' '*' '/' '%' '(' ')'
         ',' '!' '{' '}' '&' '|' AND_SYM OR_SYM OR_OR_SYM BETWEEN_SYM CASE_SYM
         THEN_SYM WHEN_SYM DIV_SYM MOD_SYM OR2_SYM AND_AND_SYM DELETE_SYM
+
+%type <num> normal_join inner_join
+
 %%
 
+
 /*
   Indentation of grammar rules:
 
@@ -2238,7 +2242,7 @@ create:
             lex->name.length= 0;
             lex->create_last_non_select_table= lex->last_table();
           }
-          create2
+          create_body
           {
             LEX *lex= YYTHD->lex;
             lex->current_select= &lex->select_lex; 
@@ -2254,36 +2258,36 @@ create:
             }
             create_table_set_open_action_and_adjust_tables(lex);
           }
-        | CREATE opt_unique INDEX_SYM ident key_alg ON table_ident
+        | CREATE opt_unique INDEX_SYM opt_if_not_exists ident key_alg ON table_ident
           {
-            if (add_create_index_prepare(Lex, $7))
+            if (add_create_index_prepare(Lex, $8))
               MYSQL_YYABORT;
           }
           '(' key_list ')' normal_key_options
           {
-            if (add_create_index(Lex, $2, $4))
+            if (add_create_index(Lex, $2, $5))
               MYSQL_YYABORT;
           }
-        | CREATE fulltext INDEX_SYM ident init_key_options ON
+        | CREATE fulltext INDEX_SYM opt_if_not_exists ident init_key_options ON
           table_ident
           {
-            if (add_create_index_prepare(Lex, $7))
+            if (add_create_index_prepare(Lex, $8))
               MYSQL_YYABORT;
           }
           '(' key_list ')' fulltext_key_options
           {
-            if (add_create_index(Lex, $2, $4))
+            if (add_create_index(Lex, $2, $5))
               MYSQL_YYABORT;
           }
-        | CREATE spatial INDEX_SYM ident init_key_options ON
+        | CREATE spatial INDEX_SYM opt_if_not_exists ident init_key_options ON
           table_ident
           {
-            if (add_create_index_prepare(Lex, $7))
+            if (add_create_index_prepare(Lex, $8))
               MYSQL_YYABORT;
           }
           '(' key_list ')' spatial_key_options
           {
-            if (add_create_index(Lex, $2, $4))
+            if (add_create_index(Lex, $2, $5))
               MYSQL_YYABORT;
           }
         | CREATE DATABASE opt_if_not_exists ident
@@ -4413,36 +4417,23 @@ size_number:
   End tablespace part
 */
 
-create2:
-          '(' create2a {}
-        | opt_create_table_options
-          opt_create_partitioning
-          create3 {}
-        | LIKE table_ident
-          {
-            THD *thd= YYTHD;
-            TABLE_LIST *src_table;
-            LEX *lex= thd->lex;
-
-            lex->create_info.options|= HA_LEX_CREATE_TABLE_LIKE;
-            src_table= lex->select_lex.add_table_to_list(thd, $2, NULL, 0,
-                                                         TL_READ,
-                                                         MDL_SHARED_READ);
-            if (! src_table)
-              MYSQL_YYABORT;
-            /* CREATE TABLE ... LIKE is not allowed for views. */
-            src_table->required_type= FRMTYPE_TABLE;
-          }
-        | '(' LIKE table_ident ')'
+create_body:
+          '(' create_field_list ')'
+          { Lex->create_info.option_list= NULL; }
+          opt_create_table_options opt_create_partitioning opt_create_select {}
+        | opt_create_table_options opt_create_partitioning opt_create_select {}
+        /*
+          the following rule is redundant, but there's a shift/reduce
+          conflict that prevents the rule above from parsing a syntax like
+          CREATE TABLE t1 (SELECT 1);
+        */
+        | '(' create_select ')' { Select->set_braces(1);} union_opt {}
+        | create_like
           {
-            THD *thd= YYTHD;
-            TABLE_LIST *src_table;
-            LEX *lex= thd->lex;
 
-            lex->create_info.options|= HA_LEX_CREATE_TABLE_LIKE;
-            src_table= lex->select_lex.add_table_to_list(thd, $3, NULL, 0,
-                                                         TL_READ,
-                                                         MDL_SHARED_READ);
+            Lex->create_info.options|= HA_LEX_CREATE_TABLE_LIKE;
+            TABLE_LIST *src_table= Lex->select_lex.add_table_to_list(YYTHD,
+                                        $1, NULL, 0, TL_READ, MDL_SHARED_READ);
             if (! src_table)
               MYSQL_YYABORT;
             /* CREATE TABLE ... LIKE is not allowed for views. */
@@ -4450,21 +4441,12 @@ create2:
           }
         ;
 
-create2a:
-          create_field_list ')'
-          {
-            Lex->create_info.option_list= NULL;
-          }
-          opt_create_table_options
-          opt_create_partitioning
-          create3 {}
-        |  opt_create_partitioning
-           create_select ')'
-           { Select->set_braces(1);}
-           union_opt {}
+create_like:
+          LIKE table_ident                      { $$= $2; }
+        | '(' LIKE table_ident ')'              { $$= $3; }
         ;
 
-create3:
+opt_create_select:
           /* empty */ {}
         | opt_duplicate opt_as create_select
           { Select->set_braces(0);}
@@ -5224,9 +5206,17 @@ table_option:
         ;
 
 opt_if_not_exists:
-          /* empty */ { $$= 0; }
-        | IF not EXISTS { $$=HA_LEX_CREATE_IF_NOT_EXISTS; }
-        ;
+          /* empty */
+          {
+            Lex->check_exists= FALSE;
+            $$= 0;
+          }
+        | IF not EXISTS
+          {
+            Lex->check_exists= TRUE;
+            $$=HA_LEX_CREATE_IF_NOT_EXISTS;
+          }
+         ;
 
 opt_create_table_options:
           /* empty */
@@ -5544,14 +5534,14 @@ column_def:
         ;
 
 key_def:
-          normal_key_type opt_ident key_alg '(' key_list ')'
+          normal_key_type opt_if_not_exists_ident key_alg '(' key_list ')'
           { Lex->option_list= NULL; }
           normal_key_options
           {
             if (add_create_index (Lex, $1, $2))
               MYSQL_YYABORT;
           }
-        | fulltext opt_key_or_index opt_ident init_key_options 
+        | fulltext opt_key_or_index opt_if_not_exists_ident init_key_options 
             '(' key_list ')'
           { Lex->option_list= NULL; }
             fulltext_key_options
@@ -5559,7 +5549,7 @@ key_def:
             if (add_create_index (Lex, $1, $3))
               MYSQL_YYABORT;
           }
-        | spatial opt_key_or_index opt_ident init_key_options 
+        | spatial opt_key_or_index opt_if_not_exists_ident init_key_options 
             '(' key_list ')'
           { Lex->option_list= NULL; }
             spatial_key_options
@@ -5575,7 +5565,7 @@ key_def:
             if (add_create_index (Lex, $2, $3.str ? $3 : $1))
               MYSQL_YYABORT;
           }
-        | opt_constraint FOREIGN KEY_SYM opt_ident '(' key_list ')' references
+        | opt_constraint FOREIGN KEY_SYM opt_if_not_exists_ident '(' key_list ')' references
           {
             LEX *lex=Lex;
             Key *key= new Foreign_key($4.str ? $4 : $1, lex->col_list,
@@ -5583,7 +5573,8 @@ key_def:
                                       lex->ref_list,
                                       lex->fk_delete_opt,
                                       lex->fk_update_opt,
-                                      lex->fk_match_option);
+                                      lex->fk_match_option,
+                                      lex->check_exists);
             if (key == NULL)
               MYSQL_YYABORT;
             lex->alter_info.key_list.push_back(key);
@@ -6552,6 +6543,18 @@ opt_ident:
         | field_ident { $$= $1; }
         ;
 
+opt_if_not_exists_ident:
+        opt_if_not_exists opt_ident
+        {
+          LEX *lex= Lex;
+          if (lex->check_exists && lex->sql_command != SQLCOM_ALTER_TABLE)
+          {
+            my_parse_error(ER(ER_SYNTAX_ERROR));
+            MYSQL_YYABORT;
+          }
+          $$= $2;
+        };
+
 opt_component:
           /* empty */    { $$= null_lex_str; }
         | '.' ident      { $$= $2; }
@@ -6808,7 +6811,7 @@ alter_commands:
   new table and so forth.
 */
         | add_partition_rule
-        | DROP PARTITION_SYM alt_part_name_list
+        | DROP PARTITION_SYM opt_if_exists alt_part_name_list
           {
             Lex->alter_info.flags|= ALTER_DROP_PARTITION;
           }
@@ -6909,7 +6912,7 @@ all_or_alt_part_name_list:
         ;
 
 add_partition_rule:
-          ADD PARTITION_SYM opt_no_write_to_binlog
+          ADD PARTITION_SYM opt_if_not_exists opt_no_write_to_binlog
           {
             LEX *lex= Lex;
             lex->part_info= new partition_info();
@@ -6919,7 +6922,7 @@ add_partition_rule:
               MYSQL_YYABORT;
             }
             lex->alter_info.flags|= ALTER_ADD_PARTITION;
-            lex->no_write_to_binlog= $3;
+            lex->no_write_to_binlog= $4;
           }
           add_part_extra
           {}
@@ -6995,7 +6998,7 @@ alter_list:
         ;
 
 add_column:
-          ADD opt_column
+          ADD opt_column opt_if_not_exists
           {
             LEX *lex=Lex;
             lex->change=0;
@@ -7017,10 +7020,10 @@ alter_list_item:
           {
             Lex->alter_info.flags|= ALTER_ADD_COLUMN | ALTER_ADD_INDEX;
           }
-        | CHANGE opt_column field_ident
+        | CHANGE opt_column opt_if_exists field_ident
           {
             LEX *lex=Lex;
-            lex->change= $3.str;
+            lex->change= $4.str;
             lex->alter_info.flags|= ALTER_CHANGE_COLUMN;
             lex->option_list= NULL;
           }
@@ -7028,7 +7031,7 @@ alter_list_item:
           {
             Lex->create_last_non_select_table= Lex->last_table();
           }
-        | MODIFY_SYM opt_column field_ident
+        | MODIFY_SYM opt_column opt_if_exists field_ident
           {
             LEX *lex=Lex;
             lex->length=lex->dec=0; lex->type=0;
@@ -7042,12 +7045,12 @@ alter_list_item:
           field_def
           {
             LEX *lex=Lex;
-            if (add_field_to_list(lex->thd,&$3,
-                                  (enum enum_field_types) $5,
+            if (add_field_to_list(lex->thd,&$4,
+                                  (enum enum_field_types) $6,
                                   lex->length,lex->dec,lex->type,
                                   lex->default_value, lex->on_update_value,
                                   &lex->comment,
-                                  $3.str, &lex->interval_list, lex->charset,
+                                  $4.str, &lex->interval_list, lex->charset,
                                   lex->uint_geom_type,
                                   lex->vcol_info, lex->option_list))
               MYSQL_YYABORT;
@@ -7056,32 +7059,33 @@ alter_list_item:
           {
             Lex->create_last_non_select_table= Lex->last_table();
           }
-        | DROP opt_column field_ident opt_restrict
+        | DROP opt_column opt_if_exists field_ident opt_restrict
           {
             LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::COLUMN, $3.str);
+            Alter_drop *ad= new Alter_drop(Alter_drop::COLUMN, $4.str, $3);
             if (ad == NULL)
               MYSQL_YYABORT;
             lex->alter_info.drop_list.push_back(ad);
             lex->alter_info.flags|= ALTER_DROP_COLUMN;
           }
-        | DROP FOREIGN KEY_SYM opt_ident
+        | DROP FOREIGN KEY_SYM opt_if_exists opt_ident
           {
             Lex->alter_info.flags|= ALTER_DROP_INDEX | ALTER_FOREIGN_KEY;
           }
         | DROP PRIMARY_SYM KEY_SYM
           {
             LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, primary_key_name);
+            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, primary_key_name,
+                                           FALSE);
             if (ad == NULL)
               MYSQL_YYABORT;
             lex->alter_info.drop_list.push_back(ad);
             lex->alter_info.flags|= ALTER_DROP_INDEX;
           }
-        | DROP key_or_index field_ident
+        | DROP key_or_index opt_if_exists field_ident
           {
             LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $3.str);
+            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $4.str, $3);
             if (ad == NULL)
               MYSQL_YYABORT;
             lex->alter_info.drop_list.push_back(ad);
@@ -9915,9 +9919,7 @@ join_table:
             left-associative joins.
           */
           table_ref normal_join table_ref %prec TABLE_REF_PRIORITY
-          { MYSQL_YYABORT_UNLESS($1 && ($$=$3)); }
-        | table_ref STRAIGHT_JOIN table_factor
-          { MYSQL_YYABORT_UNLESS($1 && ($$=$3)); $3->straight=1; }
+          { MYSQL_YYABORT_UNLESS($1 && ($$=$3)); $3->straight=$2; }
         | table_ref normal_join table_ref
           ON
           {
@@ -9929,22 +9931,7 @@ join_table:
           }
           expr
           {
-            add_join_on($3,$6);
-            Lex->pop_context();
-            Select->parsing_place= NO_MATTER;
-          }
-        | table_ref STRAIGHT_JOIN table_factor
-          ON
-          {
-            MYSQL_YYABORT_UNLESS($1 && $3);
-            /* Change the current name resolution context to a local context. */
-            if (push_new_name_resolution_context(YYTHD, $1, $3))
-              MYSQL_YYABORT;
-            Select->parsing_place= IN_ON;
-          }
-          expr
-          {
-            $3->straight=1;
+	    $3->straight=$2;
             add_join_on($3,$6);
             Lex->pop_context();
             Select->parsing_place= NO_MATTER;
@@ -9955,10 +9942,15 @@ join_table:
             MYSQL_YYABORT_UNLESS($1 && $3);
           }
           '(' using_list ')'
-          { add_join_natural($1,$3,$7,Select); $$=$3; }
-        | table_ref NATURAL JOIN_SYM table_factor
+          { 
+	    $3->straight=$2;
+            add_join_natural($1,$3,$7,Select); 
+	    $$=$3; 
+          }
+        | table_ref NATURAL inner_join table_factor
           {
             MYSQL_YYABORT_UNLESS($1 && ($$=$4));
+	    $4->straight=$3;
             add_join_natural($1,$4,NULL,Select);
           }
 
@@ -10038,10 +10030,16 @@ join_table:
           }
         ;
 
+
+inner_join: /* $$ set if using STRAIGHT_JOIN, false otherwise */
+          JOIN_SYM           { $$ = 0; }
+        | INNER_SYM JOIN_SYM { $$ = 0; }
+        | STRAIGHT_JOIN      { $$ = 1; }
+        ;
+
 normal_join:
-          JOIN_SYM {}
-        | INNER_SYM JOIN_SYM {}
-        | CROSS JOIN_SYM {}
+          inner_join         { $$ = $1; }
+        | CROSS JOIN_SYM     { $$ = 0; }
         ;
 
 /* 
@@ -11002,41 +11000,41 @@ do:
 */
 
 drop:
-          DROP opt_temporary table_or_tables if_exists
+          DROP opt_temporary table_or_tables opt_if_exists
           {
             LEX *lex=Lex;
             lex->sql_command = SQLCOM_DROP_TABLE;
             lex->drop_temporary= $2;
-            lex->drop_if_exists= $4;
+            lex->check_exists= $4;
             YYPS->m_lock_type= TL_UNLOCK;
             YYPS->m_mdl_type= MDL_EXCLUSIVE;
           }
           table_list opt_restrict
           {}
-        | DROP INDEX_SYM ident ON table_ident {}
+        | DROP INDEX_SYM opt_if_exists ident ON table_ident {}
           {
             LEX *lex=Lex;
-            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $3.str);
+            Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $4.str, $3);
             if (ad == NULL)
               MYSQL_YYABORT;
             lex->sql_command= SQLCOM_DROP_INDEX;
             lex->alter_info.reset();
             lex->alter_info.flags= ALTER_DROP_INDEX;
             lex->alter_info.drop_list.push_back(ad);
-            if (!lex->current_select->add_table_to_list(lex->thd, $5, NULL,
+            if (!lex->current_select->add_table_to_list(lex->thd, $6, NULL,
                                                         TL_OPTION_UPDATING,
                                                         TL_READ_NO_INSERT,
                                                         MDL_SHARED_NO_WRITE))
               MYSQL_YYABORT;
           }
-        | DROP DATABASE if_exists ident
+        | DROP DATABASE opt_if_exists ident
           {
             LEX *lex=Lex;
             lex->sql_command= SQLCOM_DROP_DB;
-            lex->drop_if_exists=$3;
+            lex->check_exists=$3;
             lex->name= $4;
           }
-        | DROP FUNCTION_SYM if_exists ident '.' ident
+        | DROP FUNCTION_SYM opt_if_exists ident '.' ident
           {
             THD *thd= YYTHD;
             LEX *lex= thd->lex;
@@ -11052,14 +11050,14 @@ drop:
               MYSQL_YYABORT;
             }
             lex->sql_command = SQLCOM_DROP_FUNCTION;
-            lex->drop_if_exists= $3;
+            lex->check_exists= $3;
             spname= new sp_name($4, $6, true);
             if (spname == NULL)
               MYSQL_YYABORT;
             spname->init_qname(thd);
             lex->spname= spname;
           }
-        | DROP FUNCTION_SYM if_exists ident
+        | DROP FUNCTION_SYM opt_if_exists ident
           {
             THD *thd= YYTHD;
             LEX *lex= thd->lex;
@@ -11073,14 +11071,14 @@ drop:
             if (thd->db && lex->copy_db_to(&db.str, &db.length))
               MYSQL_YYABORT;
             lex->sql_command = SQLCOM_DROP_FUNCTION;
-            lex->drop_if_exists= $3;
+            lex->check_exists= $3;
             spname= new sp_name(db, $4, false);
             if (spname == NULL)
               MYSQL_YYABORT;
             spname->init_qname(thd);
             lex->spname= spname;
           }
-        | DROP PROCEDURE_SYM if_exists sp_name
+        | DROP PROCEDURE_SYM opt_if_exists sp_name
           {
             LEX *lex=Lex;
             if (lex->sphead)
@@ -11089,34 +11087,34 @@ drop:
               MYSQL_YYABORT;
             }
             lex->sql_command = SQLCOM_DROP_PROCEDURE;
-            lex->drop_if_exists= $3;
+            lex->check_exists= $3;
             lex->spname= $4;
           }
         | DROP USER clear_privileges user_list
           {
             Lex->sql_command = SQLCOM_DROP_USER;
           }
-        | DROP VIEW_SYM if_exists
+        | DROP VIEW_SYM opt_if_exists
           {
             LEX *lex= Lex;
             lex->sql_command= SQLCOM_DROP_VIEW;
-            lex->drop_if_exists= $3;
+            lex->check_exists= $3;
             YYPS->m_lock_type= TL_UNLOCK;
             YYPS->m_mdl_type= MDL_EXCLUSIVE;
           }
           table_list opt_restrict
           {}
-        | DROP EVENT_SYM if_exists sp_name
+        | DROP EVENT_SYM opt_if_exists sp_name
           {
-            Lex->drop_if_exists= $3;
+            Lex->check_exists= $3;
             Lex->spname= $4;
             Lex->sql_command = SQLCOM_DROP_EVENT;
           }
-        | DROP TRIGGER_SYM if_exists sp_name
+        | DROP TRIGGER_SYM opt_if_exists sp_name
           {
             LEX *lex= Lex;
             lex->sql_command= SQLCOM_DROP_TRIGGER;
-            lex->drop_if_exists= $3;
+            lex->check_exists= $3;
             lex->spname= $4;
           }
         | DROP TABLESPACE tablespace_name opt_ts_engine opt_ts_wait
@@ -11129,10 +11127,10 @@ drop:
             LEX *lex= Lex;
             lex->alter_tablespace_info->ts_cmd_type= DROP_LOGFILE_GROUP;
           }
-        | DROP SERVER_SYM if_exists ident_or_text
+        | DROP SERVER_SYM opt_if_exists ident_or_text
           {
             Lex->sql_command = SQLCOM_DROP_SERVER;
-            Lex->drop_if_exists= $3;
+            Lex->check_exists= $3;
             Lex->server_options.server_name= $4.str;
             Lex->server_options.server_name_length= $4.length;
           }
@@ -11170,9 +11168,17 @@ table_alias_ref:
           }
         ;
 
-if_exists:
-          /* empty */ { $$= 0; }
-        | IF EXISTS { $$= 1; }
+opt_if_exists:
+          /* empty */
+        {
+          Lex->check_exists= FALSE;
+          $$= 0;
+        }
+        | IF EXISTS
+        {
+          Lex->check_exists= TRUE;
+          $$= 1;
+        }
         ;
 
 opt_temporary:
@@ -11636,6 +11642,7 @@ show:
           {
             LEX *lex=Lex;
             lex->wild=0;
+            lex->ident=null_lex_str;
             mysql_init_select(lex);
             lex->current_select->parsing_place= SELECT_LIST;
             bzero((char*) &lex->create_info,sizeof(lex->create_info));
@@ -11699,6 +11706,19 @@ show_param:
             if (prepare_schema_table(YYTHD, lex, 0, SCH_PLUGINS))
               MYSQL_YYABORT;
           }
+        | PLUGINS_SYM SONAME_SYM TEXT_STRING_sys
+          {
+            Lex->ident= $3;
+            Lex->sql_command= SQLCOM_SHOW_PLUGINS;
+            if (prepare_schema_table(YYTHD, Lex, 0, SCH_ALL_PLUGINS))
+              MYSQL_YYABORT;
+          }
+        | PLUGINS_SYM SONAME_SYM wild_and_where
+          {
+            Lex->sql_command= SQLCOM_SHOW_PLUGINS;
+            if (prepare_schema_table(YYTHD, Lex, 0, SCH_ALL_PLUGINS))
+              MYSQL_YYABORT;
+          }
         | ENGINE_SYM known_storage_engines show_engine_param
           { Lex->create_info.db_type= $2; }
         | ENGINE_SYM ALL show_engine_param
@@ -13297,6 +13317,7 @@ keyword:
         | LANGUAGE_SYM          {}
         | NO_SYM                {}
         | OPEN_SYM              {}
+        | OPTION                {}
         | OPTIONS_SYM           {}
         | OWNER_SYM             {}
         | PARSER_SYM            {}
diff --git a/sql/strfunc.cc b/sql/strfunc.cc
index 9603ca30cfa..aa6d2535b0d 100644
--- a/sql/strfunc.cc
+++ b/sql/strfunc.cc
@@ -86,7 +86,7 @@ ulonglong find_set(TYPELIB *lib, const char *str, uint length, CHARSET_INFO *cs,
         *set_warning= 1;
       }
       else
-        found|= ((longlong) 1 << (find - 1));
+        found|= 1ULL << (find - 1);
       if (pos >= end)
         break;
       start= pos + mblen;
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
index 433be2f6e22..6d5d92081a9 100644
--- a/sql/sys_vars.cc
+++ b/sql/sys_vars.cc
@@ -1222,7 +1222,7 @@ static Sys_var_ulonglong Sys_max_binlog_cache_size(
        "Sets the total size of the transactional cache",
        GLOBAL_VAR(max_binlog_cache_size), CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(IO_SIZE, ULONGLONG_MAX),
-       DEFAULT((UINT_MAX/IO_SIZE)*IO_SIZE),
+       DEFAULT((ULONGLONG_MAX/IO_SIZE)*IO_SIZE),
        BLOCK_SIZE(IO_SIZE));
 
 static Sys_var_ulonglong Sys_max_binlog_stmt_cache_size(
@@ -1230,7 +1230,7 @@ static Sys_var_ulonglong Sys_max_binlog_stmt_cache_size(
        "Sets the total size of the statement cache",
        GLOBAL_VAR(max_binlog_stmt_cache_size), CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(IO_SIZE, ULONGLONG_MAX),
-       DEFAULT((UINT_MAX/IO_SIZE)*IO_SIZE),
+       DEFAULT((ULONGLONG_MAX/IO_SIZE)*IO_SIZE),
        BLOCK_SIZE(IO_SIZE));
 
 static bool fix_max_binlog_size(sys_var *self, THD *thd, enum_var_type type)
@@ -1603,6 +1603,7 @@ export const char *optimizer_switch_names[]=
   "optimize_join_buffer_size",
   "table_elimination",
   "extended_keys",
+  "exists_to_in",
   "default", NullS
 };
 /** propagates changes to @@engine_condition_pushdown */
@@ -1644,7 +1645,8 @@ static Sys_var_flagset Sys_optimizer_switch(
         "semijoin_with_cache, "
         "subquery_cache, "
         "table_elimination, "
-        "extended_keys "
+        "extended_keys, "
+        "exists_to_in "
        "} and val is one of {on, off, default}",
        SESSION_VAR(optimizer_switch), CMD_LINE(REQUIRED_ARG),
        optimizer_switch_names, DEFAULT(OPTIMIZER_SWITCH_DEFAULT),
@@ -3960,9 +3962,67 @@ static Sys_var_ulong Sys_debug_binlog_fsync_sleep(
        CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(0, UINT_MAX), DEFAULT(0), BLOCK_SIZE(1));
 #endif
+
 static Sys_var_harows Sys_expensive_subquery_limit(
        "expensive_subquery_limit",
        "The maximum number of rows a subquery may examine in order to be "
        "executed during optimization and used for constant optimization",
        SESSION_VAR(expensive_subquery_limit), CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(0, HA_POS_ERROR), DEFAULT(100), BLOCK_SIZE(1));
+
+static bool check_pseudo_slave_mode(sys_var *self, THD *thd, set_var *var)
+{
+  longlong previous_val= thd->variables.pseudo_slave_mode;
+  longlong val= (longlong) var->save_result.ulonglong_value;
+  bool rli_fake= false;
+
+#ifndef EMBEDDED_LIBRARY
+  rli_fake= thd->rli_fake ? true : false;
+#endif
+
+  if (rli_fake)
+  {
+    if (!val)
+    {
+#ifndef EMBEDDED_LIBRARY
+      delete thd->rli_fake;
+      thd->rli_fake= NULL;
+#endif
+    }
+    else if (previous_val && val)
+      goto ineffective;
+    else if (!previous_val && val)
+      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                   ER_WRONG_VALUE_FOR_VAR,
+                   "'pseudo_slave_mode' is already ON.");
+  }
+  else
+  {
+    if (!previous_val && !val)
+      goto ineffective;
+    else if (previous_val && !val)
+      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                   ER_WRONG_VALUE_FOR_VAR,
+                   "Slave applier execution mode not active, "
+                   "statement ineffective.");
+  }
+  goto end;
+
+ineffective:
+  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+               ER_WRONG_VALUE_FOR_VAR,
+               "'pseudo_slave_mode' change was ineffective.");
+
+end:
+  return FALSE;
+}
+static Sys_var_mybool Sys_pseudo_slave_mode(
+       "pseudo_slave_mode",
+       "SET pseudo_slave_mode= 0,1 are commands that mysqlbinlog "
+       "adds to beginning and end of binary log dumps. While zero "
+       "value indeed disables, the actual enabling of the slave "
+       "applier execution mode is done implicitly when a "
+       "Format_description_event is sent through the session.",
+       SESSION_ONLY(pseudo_slave_mode), NO_CMD_LINE, DEFAULT(FALSE),
+       NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_pseudo_slave_mode));
+
diff --git a/sql/sys_vars.h b/sql/sys_vars.h
index ffa7de118c8..9d91c4175f8 100644
--- a/sql/sys_vars.h
+++ b/sql/sys_vars.h
@@ -548,8 +548,7 @@ public:
 protected:
   virtual uchar *session_value_ptr(THD *thd, LEX_STRING *base)
   {
-    return thd->security_ctx->proxy_user[0] ?
-      (uchar *) &(thd->security_ctx->proxy_user[0]) : NULL;
+    return (uchar*)thd->security_ctx->external_user;
   }
 };
 
diff --git a/sql/table.cc b/sql/table.cc
index c8dc2b4ed5a..b8732a78afc 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -1,6 +1,6 @@
 /*
    Copyright (c) 2000, 2011, Oracle and/or its affiliates.
-   Copyright (c) 2008-2011 Monty Program Ab
+   Copyright (c) 2008, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -22,7 +22,6 @@
 #include "sql_priv.h"
 #include "unireg.h"                    // REQUIRED: for other includes
 #include "table.h"
-#include "frm_crypt.h"           // get_crypt_for_frm
 #include "key.h"                                // find_ref_key
 #include "sql_table.h"                          // build_table_filename,
                                                 // primary_key_name
@@ -40,6 +39,7 @@
 #include "sql_select.h"
 #include "sql_derived.h"
 #include "sql_statistics.h"
+#include "discover.h"
 #include "mdl.h"                 // MDL_wait_for_graph_visitor
 
 /* INFORMATION_SCHEMA name */
@@ -65,18 +65,12 @@ LEX_STRING parse_vcol_keyword= { C_STRING_WITH_LEN("PARSE_VCOL_EXPR ") };
 
 	/* Functions defined in this file */
 
-void open_table_error(TABLE_SHARE *share, int error, int db_errno,
-                      myf errortype, int errarg);
-static int open_binary_frm(THD *thd, TABLE_SHARE *share,
-                           uchar *head, File file);
 static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
 			      uint types, char **names);
 static uint find_field(Field **fields, uchar *record, uint start, uint length);
 
 inline bool is_system_table_name(const char *name, uint length);
 
-static ulong get_form_pos(File file, uchar *head);
-
 /**************************************************************************
   Object_creation_ctx implementation.
 **************************************************************************/
@@ -292,8 +286,8 @@ TABLE_CATEGORY get_table_category(const LEX_STRING *db, const LEX_STRING *name)
     #  Share
 */
 
-TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
-                               uint key_length)
+TABLE_SHARE *alloc_table_share(const char *db, const char *table_name,
+                               char *key, uint key_length)
 {
   MEM_ROOT mem_root;
   TABLE_SHARE *share;
@@ -301,12 +295,10 @@ TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
   char path[FN_REFLEN];
   uint path_length;
   DBUG_ENTER("alloc_table_share");
-  DBUG_PRINT("enter", ("table: '%s'.'%s'",
-                       table_list->db, table_list->table_name));
+  DBUG_PRINT("enter", ("table: '%s'.'%s'", db, table_name));
 
   path_length= build_table_filename(path, sizeof(path) - 1,
-                                    table_list->db,
-                                    table_list->table_name, "", 0);
+                                    db, table_name, "", 0);
   init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0, MYF(0));
   if (multi_alloc_root(&mem_root,
                        &share, sizeof(*share),
@@ -323,8 +315,9 @@ TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
     strmov(share->path.str, path);
     share->normalized_path.str=    share->path.str;
     share->normalized_path.length= path_length;
-
-    share->version=       refresh_version;
+    share->table_category= get_table_category(& share->db, & share->table_name);
+    share->set_refresh_version();
+    share->open_errno= ENOENT;
 
     /*
       Since alloc_table_share() can be called without any locking (for
@@ -579,27 +572,6 @@ inline bool is_system_table_name(const char *name, uint length)
 }
 
 
-/**
-  Check if a string contains path elements
-*/  
-
-static bool has_disabled_path_chars(const char *str)
-{
-  for (; *str; str++)
-  {
-    switch (*str) {
-      case FN_EXTCHAR:
-      case '/':
-      case '\\':
-      case '~':
-      case '@':
-        return TRUE;
-    }
-  }
-  return FALSE;
-}
-
-
 /*
   Read table definition from a binary / text based .frm file
   
@@ -614,175 +586,138 @@ static bool has_disabled_path_chars(const char *str)
     table_def_cache
     The data is returned in 'share', which is alloced by
     alloc_table_share().. The code assumes that share is initialized.
-
-  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)
-   6    Unknown .frm version
 */
 
-int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
+enum open_frm_error open_table_def(THD *thd, TABLE_SHARE *share, uint flags)
 {
-  int error, table_type;
-  bool error_given;
+  bool error_given= false;
   File file;
-  uchar head[64];
+  uchar *buf;
+  uchar head[FRM_HEADER_SIZE];
   char	path[FN_REFLEN];
-  MEM_ROOT **root_ptr, *old_root;
+  size_t frmlen, read_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));
 
-  error= 1;
-  error_given= 0;
+  share->error= OPEN_FRM_OPEN_ERROR;
 
   strxmov(path, share->normalized_path.str, reg_ext, NullS);
-  if ((file= mysql_file_open(key_file_frm,
-                             path, O_RDONLY | O_SHARE, MYF(0))) < 0)
+  file= mysql_file_open(key_file_frm, path, O_RDONLY | O_SHARE, MYF(0));
+  if (file < 0)
   {
-    /*
-      We don't try to open 5.0 unencoded name, if
-      - non-encoded name contains '@' signs, 
-        because '@' can be misinterpreted.
-        It is not clear if '@' is escape character in 5.1,
-        or a normal character in 5.0.
-        
-      - non-encoded db or table name contain "#mysql50#" prefix.
-        This kind of tables must have been opened only by the
-        mysql_file_open() above.
-    */
-    if (has_disabled_path_chars(share->table_name.str) ||
-        has_disabled_path_chars(share->db.str) ||
-        !strncmp(share->db.str, MYSQL50_TABLE_NAME_PREFIX,
-                 MYSQL50_TABLE_NAME_PREFIX_LENGTH) ||
-        !strncmp(share->table_name.str, MYSQL50_TABLE_NAME_PREFIX,
-                 MYSQL50_TABLE_NAME_PREFIX_LENGTH))
-      goto err_not_open;
-
-    /* Try unencoded 5.0 name */
-    uint length;
-    strxnmov(path, sizeof(path)-1,
-             mysql_data_home, "/", share->db.str, "/",
-             share->table_name.str, reg_ext, NullS);
-    length= unpack_filename(path, path) - reg_ext_length;
-    /*
-      The following is a safety test and should never fail
-      as the old file name should never be longer than the new one.
-    */
-    DBUG_ASSERT(length <= share->normalized_path.length);
-    /*
-      If the old and the new names have the same length,
-      then table name does not have tricky characters,
-      so no need to check the old file name.
-    */
-    if (length == share->normalized_path.length ||
-        ((file= mysql_file_open(key_file_frm,
-                                path, O_RDONLY | O_SHARE, MYF(0))) < 0))
-      goto err_not_open;
-
-    /* Unencoded 5.0 table name found */
-    path[length]= '\0'; // Remove .frm extension
-    strmov(share->normalized_path.str, path);
-    share->normalized_path.length= length;
+    if ((flags & GTS_TABLE) && (flags & GTS_FORCE_DISCOVERY))
+    {
+      ha_discover_table(thd, share);
+      error_given= true;
+    }
+    goto err_not_open;
   }
 
-  error= 4;
-  if (mysql_file_read(file, head, 64, MYF(MY_NABP)))
+  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 (head[0] == (uchar) 254 && head[1] == 1)
+  if (memcmp(head, STRING_WITH_LEN("TYPE=VIEW\n")) == 0)
   {
-    if (head[2] == FRM_VER || head[2] == FRM_VER+1 ||
-        (head[2] >= FRM_VER+3 && head[2] <= FRM_VER+4))
-    {
-      /* Open view only */
-      if (db_flags & OPEN_VIEW_ONLY)
-      {
-        error_given= 1;
-        goto err;
-      }
-      table_type= 1;
-    }
-    else
-    {
-      error= 6;                                 // Unkown .frm version
-      goto err;
-    }
+    share->is_view= 1;
+    share->error= flags & GTS_VIEW ? OPEN_FRM_OK : OPEN_FRM_NOT_A_TABLE;
+    goto err;
   }
-  else if (memcmp(head, STRING_WITH_LEN("TYPE=")) == 0)
+  if (!is_binary_frm_header(head))
   {
-    error= 5;
-    if (memcmp(head+5,"VIEW",4) == 0)
-    {
-      share->is_view= 1;
-      if (db_flags & OPEN_VIEW)
-        error= 0;
-    }
+    /* No handling of text based files yet */
+    share->error = OPEN_FRM_CORRUPTED;
     goto err;
   }
-  else
+  if (!(flags & GTS_TABLE))
+  {
+    share->error = OPEN_FRM_NOT_A_VIEW;
     goto err;
+  }
 
-  /* No handling of text based files yet */
-  if (table_type == 1)
+  frmlen= uint4korr(head+10);
+  set_if_smaller(frmlen, FRM_MAX_SIZE); // safety
+
+  if (!(buf= (uchar*)my_malloc(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)
   {
-    root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
-    old_root= *root_ptr;
-    *root_ptr= &share->mem_root;
-    error= open_binary_frm(thd, share, head, file);
-    *root_ptr= old_root;
-    error_given= 1;
+    share->error = OPEN_FRM_READ_ERROR;
+    my_free(buf);
+    goto err;
   }
+  mysql_file_close(file, MYF(MY_WME));
 
-  share->table_category= get_table_category(& share->db, & share->table_name);
+  frmlen= read_length + sizeof(head);
 
-  if (!error)
-    thd->status_var.opened_shares++;
+  share->init_from_binary_frm_image(thd, false, buf, frmlen);
+  error_given= true; // init_from_binary_frm_image has already called my_error()
+  my_free(buf);
+
+  goto err_not_open;
 
 err:
   mysql_file_close(file, MYF(MY_WME));
 
 err_not_open:
-  if (error && !error_given)
+  if (share->error && !error_given)
   {
-    share->error= error;
-    open_table_error(share, error, (share->open_errno= my_errno), 0);
+    share->open_errno= my_errno;
+    open_table_error(share, share->error, share->open_errno);
   }
 
-  DBUG_RETURN(error);
+  DBUG_RETURN(share->error);
 }
 
 
-/*
-  Read data from a binary .frm file from MySQL 3.23 - 5.0 into TABLE_SHARE
+/**
+  Read data from a binary .frm file image into a TABLE_SHARE
+
+  @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.
+
 */
 
-static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
-                           File file)
+int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
+                                            const uchar *frm_image,
+                                            size_t frm_length)
 {
-  int error, errarg= 0;
+  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 db_create_options, keys, key_parts, n_length;
-  uint key_info_length, com_length, null_bit_pos;
+  uint com_length, null_bit_pos;
   uint extra_rec_buf_length;
   uint i,j;
   bool use_hash;
   char *keynames, *names, *comment_pos;
-  uchar forminfo[288];
-  uchar *record;
-  uchar *disk_buff, *strpos, *null_flags, *null_pos;
+  const uchar *forminfo, *extra2;
+  const uchar *frm_image_end = frm_image + frm_length;
+  uchar *record, *null_flags, *null_pos;
+  const uchar *disk_buff, *strpos;
   ulong pos, record_offset; 
   ulong *rec_per_key= NULL;
   ulong rec_buff_length;
   handler *handler_file= 0;
   KEY	*keyinfo;
   KEY_PART_INFO *key_part= NULL;
-  SQL_CRYPT *crypted=0;
   Field  **field_ptr, *reg_field;
   const char **interval_array;
   enum legacy_db_type legacy_db_type;
@@ -790,74 +725,138 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   bool null_bits_are_used;
   uint vcol_screen_length, UNINIT_VAR(options_len);
   char *vcol_screen_pos;
-  uchar *UNINIT_VAR(options);
-  uchar *extra_segment_buff= 0;
+  const uchar *options= 0;
   KEY first_keyinfo;
   uint len;
   KEY_PART_INFO *first_key_part= NULL;
   uint ext_key_parts= 0;
   uint first_key_parts= 0;
+  plugin_ref se_plugin= 0;
   keyinfo= &first_keyinfo;
   share->ext_key_parts= 0;
-  DBUG_ENTER("open_binary_frm");
+  MEM_ROOT **root_ptr, *old_root;
+  DBUG_ENTER("TABLE_SHARE::init_from_binary_frm_image");
+
+  root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
+  old_root= *root_ptr;
+  *root_ptr= &share->mem_root;
 
-  new_field_pack_flag= head[27];
-  new_frm_ver= (head[2] - FRM_VER);
+  if (write && write_frm_image(frm_image, frm_length))
+    goto err;
+
+  if (frm_length < FRM_HEADER_SIZE + FRM_FORMINFO_SIZE)
+    goto err;
+
+  new_field_pack_flag= frm_image[27];
+  new_frm_ver= (frm_image[2] - FRM_VER);
   field_pack_length= new_frm_ver < 2 ? 11 : 17;
-  disk_buff= 0;
 
-  error= 3;
-  /* Position of the form in the form file. */
-  if (!(pos= get_form_pos(file, head)))
-    goto err;                                   /* purecov: inspected */
+  /* Length of the MariaDB extra2 segment in the form file. */
+  len = uint2korr(frm_image+4);
+  extra2= frm_image + 64;
+
+  if (*extra2 != '/')   // old frm had '/' there
+  {
+    const uchar *e2end= extra2 + len;
+    while (extra2 + 3 < e2end)
+    {
+      uchar type= *extra2++;
+      size_t length= *extra2++;
+      if (!length)
+      {
+        if (extra2 + 258 >= e2end)
+          goto err;
+        length= uint2korr(extra2);
+        extra2+=2;
+        if (length < 256)
+          goto err;
+      }
+      if (extra2 + length > e2end)
+        goto err;
+      switch (type) {
+      case EXTRA2_TABLEDEF_VERSION:
+        if (tabledef_version.str) // see init_from_sql_statement_string()
+        {
+          if (length != tabledef_version.length ||
+              memcmp(extra2, tabledef_version.str, length))
+            goto err;
+        }
+        else
+        {
+          tabledef_version.length= length;
+          tabledef_version.str= (uchar*)memdup_root(&mem_root, extra2, length);
+          if (!tabledef_version.str)
+            goto err;
+        }
+        break;
+      case EXTRA2_ENGINE_TABLEOPTS:
+        if (options)
+          goto err;
+        /* remember but delay parsing until we have read fields and keys */
+        options= extra2;
+        options_len= length;
+        break;
+      default:
+        /* abort frm parsing if it's an unknown but important extra2 value */
+        if (type >= EXTRA2_ENGINE_IMPORTANT)
+          goto err;
+      }
+      extra2+= length;
+    }
+    if (extra2 != e2end)
+      goto err;
+  }
 
-  mysql_file_seek(file,pos,MY_SEEK_SET,MYF(0));
-  if (mysql_file_read(file, forminfo,288,MYF(MY_NABP)))
+  if (frm_length < FRM_HEADER_SIZE + len ||
+      !(pos= uint4korr(frm_image + FRM_HEADER_SIZE + len)))
     goto err;
-  share->frm_version= head[2];
+
+  forminfo= frm_image + pos;
+  if (forminfo + FRM_FORMINFO_SIZE >= frm_image_end)
+    goto err;
+
+  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 && head[33] == 5)
+  if (share->frm_version == FRM_VER_TRUE_VARCHAR -1 && frm_image[33] == 5)
     share->frm_version= FRM_VER_TRUE_VARCHAR;
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (*(head+61) &&
+  if (frm_image[61] &&
       !(share->default_part_db_type= 
-        ha_checktype(thd, (enum legacy_db_type) (uint) *(head+61), 1, 0)))
+        ha_checktype(thd, (enum legacy_db_type) (uint) frm_image[61], 1, 0)))
     goto err;
-  DBUG_PRINT("info", ("default_part_db_type = %u", head[61]));
+  DBUG_PRINT("info", ("default_part_db_type = %u", frm_image[61]));
 #endif
-  legacy_db_type= (enum legacy_db_type) (uint) *(head+3);
-  DBUG_ASSERT(share->db_plugin == NULL);
+  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)
-    share->db_plugin= ha_lock_engine(NULL, 
-                                     ha_checktype(thd, legacy_db_type, 0, 0));
-  share->db_create_options= db_create_options= uint2korr(head+30);
+    se_plugin= ha_lock_engine(NULL, ha_checktype(thd, legacy_db_type, 0, 0));
+  share->db_create_options= db_create_options= uint2korr(frm_image+30);
   share->db_options_in_use= share->db_create_options;
-  share->mysql_version= uint4korr(head+51);
+  share->mysql_version= uint4korr(frm_image+51);
   share->null_field_first= 0;
-  if (!head[32])				// New frm file in 3.23
-  {
-    share->avg_row_length= uint4korr(head+34);
-    share->transactional= (ha_choice) (head[39] & 3);
-    share->page_checksum= (ha_choice) ((head[39] >> 2) & 3);
-    share->row_type= (row_type) head[40];
-    share->table_charset= get_charset((((uint) head[41]) << 8) + 
-                                        (uint) head[38],MYF(0));
+  if (!frm_image[32])				// New frm file in 3.23
+  {
+    share->avg_row_length= uint4korr(frm_image+34);
+    share->transactional= (ha_choice) (frm_image[39] & 3);
+    share->page_checksum= (ha_choice) ((frm_image[39] >> 2) & 3);
+    share->row_type= (enum row_type) frm_image[40];
+    share->table_charset= get_charset((((uint) frm_image[41]) << 8) + 
+                                        (uint) frm_image[38],MYF(0));
     share->null_field_first= 1;
   }
   if (!share->table_charset)
   {
-    /* unknown charset in head[38] or pre-3.23 frm */
+    /* unknown charset in frm_image[38] or pre-3.23 frm */
     if (use_mb(default_charset_info))
     {
       /* Warn that we may be changing the size of character columns */
@@ -871,15 +870,15 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   share->db_record_offset= 1;
   if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
     share->blob_ptr_size= portable_sizeof_char_ptr;
-  error=4;
-  share->max_rows= uint4korr(head+18);
-  share->min_rows= uint4korr(head+22);
+  share->max_rows= uint4korr(frm_image+18);
+  share->min_rows= uint4korr(frm_image+22);
 
   /* Read keyinformation */
-  key_info_length= (uint) uint2korr(head+28);
-  mysql_file_seek(file, (ulong) uint2korr(head+6), MY_SEEK_SET, MYF(0));
-  if (read_string(file,(uchar**) &disk_buff,key_info_length))
-    goto err;                                   /* purecov: inspected */
+  disk_buff= frm_image + uint2korr(frm_image+6);
+
+  if (disk_buff + 6 >= frm_image_end)
+    goto err;
+
   if (disk_buff[0] & 0x80)
   {
     share->keys=      keys=      (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
@@ -929,6 +928,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   {
     if (new_frm_ver >= 3)
     {
+      if (strpos + 8 >= frm_image_end)
+        goto err;
       keyinfo->flags=	   (uint) uint2korr(strpos) ^ HA_NOSAME;
       keyinfo->key_length= (uint) uint2korr(strpos+2);
       keyinfo->key_parts=  (uint) strpos[4];
@@ -938,6 +939,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
     }
     else
     {
+      if (strpos + 4 >= frm_image_end)
+        goto err;
       keyinfo->flags=	 ((uint) strpos[0]) ^ HA_NOSAME;
       keyinfo->key_length= (uint) uint2korr(strpos+1);
       keyinfo->key_parts=  (uint) strpos[3];
@@ -975,6 +978,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
     keyinfo->rec_per_key= rec_per_key;
     for (j=keyinfo->key_parts ; j-- ; key_part++)
     {
+      if (strpos + (new_frm_ver >= 1 ? 9 : 7) >= frm_image_end)
+        goto err;
       *rec_per_key++=0;
       key_part->fieldnr=	(uint16) (uint2korr(strpos) & FIELD_NR_MASK);
       key_part->offset= (uint) uint2korr(strpos+2)-1;
@@ -1026,57 +1031,58 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
         }
       }
       if (j == first_key_parts)
-        keyinfo->ext_key_flags= keyinfo->flags | HA_NOSAME | HA_EXT_NOSAME;
+        keyinfo->ext_key_flags= keyinfo->flags | HA_EXT_NOSAME;
     }
     share->ext_key_parts+= keyinfo->ext_key_parts;  
   }
   keynames=(char*) key_part;
-  strpos+= (strmov(keynames, (char *) strpos) - keynames)+1;
+  strpos+= strnmov(keynames, (char *) strpos, frm_image_end - strpos) - keynames;
+  if (*strpos++) // key names are \0-terminated
+    goto err;
 
   //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)
+        goto err;
       keyinfo->comment.length= uint2korr(strpos);
-      keyinfo->comment.str= strmake_root(&share->mem_root, (char*) strpos+2,
+      strpos+= 2;
+
+      if (strpos + keyinfo->comment.length >= frm_image_end)
+        goto err;
+      keyinfo->comment.str= strmake_root(&share->mem_root, (char*) strpos,
                                          keyinfo->comment.length);
-      strpos+= 2 + keyinfo->comment.length;
+      strpos+= keyinfo->comment.length;
     } 
     DBUG_ASSERT(test(keyinfo->flags & HA_USES_COMMENT) == 
                (keyinfo->comment.length > 0));
   }
 
-  share->reclength = uint2korr((head+16));
+  share->reclength = uint2korr((frm_image+16));
   share->stored_rec_length= share->reclength;
-  if (*(head+26) == 1)
+  if (frm_image[26] == 1)
     share->system= 1;				/* one-record-database */
-#ifdef HAVE_CRYPTED_FRM
-  else if (*(head+26) == 2)
-  {
-    crypted= get_crypt_for_frm();
-    share->crypted= 1;
-  }
-#endif
 
-  record_offset= (ulong) (uint2korr(head+6)+
-                          ((uint2korr(head+14) == 0xffff ?
-                            uint4korr(head+47) : uint2korr(head+14))));
+  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(head+55)))
+  if ((n_length= uint4korr(frm_image+55)))
   {
     /* Read extra data segment */
-    uchar *next_chunk, *buff_end;
+    const uchar *next_chunk, *buff_end;
     DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));
-    if (!(extra_segment_buff= (uchar*) my_malloc(n_length + 1, MYF(MY_WME))))
-      goto err;
-    next_chunk= extra_segment_buff;
-    if (mysql_file_pread(file, extra_segment_buff,
-                         n_length, record_offset + share->reclength,
-                         MYF(MY_NABP)))
-    {
+    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,
@@ -1086,7 +1092,6 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
       goto err;
     }
     next_chunk+= share->connect_string.length + 2;
-    buff_end= extra_segment_buff + n_length;
     if (next_chunk + 2 < buff_end)
     {
       uint str_db_type_length= uint2korr(next_chunk);
@@ -1095,26 +1100,20 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
       name.length= str_db_type_length;
 
       plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);
-      if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, share->db_plugin))
+      if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, se_plugin))
       {
-        if (legacy_db_type > DB_TYPE_UNKNOWN &&
-            legacy_db_type < DB_TYPE_FIRST_DYNAMIC &&
-            legacy_db_type != ha_legacy_type(
-                plugin_data(tmp_plugin, handlerton *)))
+        if (se_plugin)
         {
           /* bad file, legacy_db_type did not match the name */
           goto err;
         }
         /*
           tmp_plugin is locked with a local lock.
-          we unlock the old value of share->db_plugin before
+          we unlock the old value of se_plugin before
           replacing it with a globally locked version of tmp_plugin
         */
-        plugin_unlock(NULL, share->db_plugin);
-        share->db_plugin= my_plugin_lock(NULL, tmp_plugin);
-        DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
-                            str_db_type_length, next_chunk + 2,
-                            ha_legacy_type(share->db_type())));
+        plugin_unlock(NULL, se_plugin);
+        se_plugin= plugin_lock(NULL, tmp_plugin);
       }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
       else if (str_db_type_length == 9 &&
@@ -1123,28 +1122,23 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
         /*
           Use partition handler
           tmp_plugin is locked with a local lock.
-          we unlock the old value of share->db_plugin before
+          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))
         {
-          error= 8;
           my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0),
                    "--skip-partition");
           goto err;
         }
-        plugin_unlock(NULL, share->db_plugin);
-        share->db_plugin= ha_lock_engine(NULL, partition_hton);
-        DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
-                            str_db_type_length, next_chunk + 2,
-                            ha_legacy_type(share->db_type())));
+        plugin_unlock(NULL, se_plugin);
+        se_plugin= ha_lock_engine(NULL, partition_hton);
       }
 #endif
       else if (!tmp_plugin)
       {
         /* purecov: begin inspected */
-        error= 8;
         name.str[name.length]=0;
         my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), name.str);
         goto err;
@@ -1228,41 +1222,31 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
 
     DBUG_ASSERT(next_chunk <= buff_end);
 
-    if (share->db_create_options & HA_OPTION_TEXT_CREATE_OPTIONS)
+    if (share->db_create_options & HA_OPTION_TEXT_CREATE_OPTIONS_legacy)
     {
-      /*
-        store options position, but skip till the time we will
-        know number of fields
-      */
+      if (options)
+        goto err;
       options_len= uint4korr(next_chunk);
       options= next_chunk + 4;
       next_chunk+= options_len + 4;
     }
     DBUG_ASSERT(next_chunk <= buff_end);
   }
-  share->key_block_size= uint2korr(head+62);
+  share->key_block_size= uint2korr(frm_image+62);
 
-  error=4;
-  extra_rec_buf_length= uint2korr(head+59);
+  if (share->db_plugin && !plugin_equals(share->db_plugin, se_plugin))
+    goto err; // wrong engine (someone changed the frm under our feet?)
+
+  extra_rec_buf_length= uint2korr(frm_image+59);
   rec_buff_length= ALIGN_SIZE(share->reclength + 1 + extra_rec_buf_length);
   share->rec_buff_length= rec_buff_length;
   if (!(record= (uchar *) alloc_root(&share->mem_root,
                                      rec_buff_length)))
     goto err;                          /* purecov: inspected */
   share->default_values= record;
-  if (mysql_file_pread(file, record, (size_t) share->reclength,
-                       record_offset, MYF(MY_NABP)))
-    goto err;                          /* purecov: inspected */
+  memcpy(record, frm_image + record_offset, share->reclength);
 
-  mysql_file_seek(file, pos+288, MY_SEEK_SET, MYF(0));
-#ifdef HAVE_CRYPTED_FRM
-  if (crypted)
-  {
-    crypted->decode((char*) forminfo+256,288-256);
-    if (sint2korr(forminfo+284) != 0)		// Should be 0
-      goto err;                        // Wrong password
-  }
-#endif
+  disk_buff= frm_image + pos + FRM_FORMINFO_SIZE;
 
   share->fields= uint2korr(forminfo+258);
   pos= uint2korr(forminfo+260);   /* Length of all screens */
@@ -1300,16 +1284,6 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   read_length=(uint) (share->fields * field_pack_length +
 		      pos+ (uint) (n_length+int_length+com_length+
 		                   vcol_screen_length));
-  if (read_string(file,(uchar**) &disk_buff,read_length))
-    goto err;                           /* purecov: inspected */
-#ifdef HAVE_CRYPTED_FRM
-  if (crypted)
-  {
-    crypted->decode((char*) disk_buff,read_length);
-    delete crypted;
-    crypted=0;
-  }
-#endif
   strpos= disk_buff+pos;
 
   share->intervals= (TYPELIB*) (field_ptr+share->fields+1);
@@ -1357,14 +1331,14 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
 
  /* Allocate handler */
   if (!(handler_file= get_new_handler(share, thd->mem_root,
-                                      share->db_type())))
+                                      plugin_data(se_plugin, handlerton *))))
     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= (uchar*) record+1;
+    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
@@ -1377,8 +1351,7 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   else
   {
     share->null_bytes= (share->null_fields+7)/8;
-    null_flags= null_pos= (uchar*) (record + 1 +share->reclength -
-                                    share->null_bytes);
+    null_flags= null_pos= record + 1 + share->reclength - share->null_bytes;
     null_bit_pos= 0;
   }
 #endif
@@ -1420,7 +1393,6 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
 	geom_type= (Field::geometry_type) strpos[14];
 	charset= &my_charset_bin;
 #else
-	error= 4;  // unsupported field type
 	goto err;
 #endif
       }
@@ -1431,8 +1403,16 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
           charset= &my_charset_bin;
         else if (!(charset= get_charset(csid, MYF(0))))
         {
-          error= 5; // Unknown or unavailable charset
-          errarg= (int) csid;
+          const char *csname= get_charset_name((uint) csid);
+          char tmp[10];
+          if (!csname || csname[0] =='?')
+          {
+            my_snprintf(tmp, sizeof(tmp), "#%d", csid);
+            csname= tmp;
+          }
+          my_printf_error(ER_UNKNOWN_COLLATION,
+                          "Unknown collation '%s' in table '%-.64s' definition", 
+                          MYF(0), csname, share->table_name.str);
           goto err;
         }
       }
@@ -1476,10 +1456,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
         if (opt_interval_id)
           interval_nr= (uint)vcol_screen_pos[3];
         else if ((uint)vcol_screen_pos[0] != 1)
-        {
-          error= 4;
           goto err;
-        }
+
         fld_stored_in_db= (bool) (uint) vcol_screen_pos[2];
         vcol_expr_length= vcol_info_length -
                           (uint)(FRM_VCOL_HEADER_SIZE(opt_interval_id));
@@ -1578,10 +1556,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
 		  (TYPELIB*) 0),
 		 share->fieldnames.type_names[i]);
     if (!reg_field)				// Not supported field type
-    {
-      error= 4;
-      goto err;			/* purecov: inspected */
-    }
+      goto err;
+
 
     reg_field->field_index= i;
     reg_field->comment=comment;
@@ -1607,20 +1583,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
     if (reg_field->unireg_check == Field::NEXT_NUMBER)
       share->found_next_number_field= field_ptr;
 
-    if (use_hash)
-    {
-      if (my_hash_insert(&share->name_hash,
-                         (uchar*) field_ptr))
-      {
-        /*
-          Set return code 8 here to indicate that an error has
-          occurred but that the error message already has been
-          sent (OOM).
-        */
-        error= 8; 
-        goto err;
-      }
-    }
+    if (use_hash && my_hash_insert(&share->name_hash, (uchar*) field_ptr))
+      goto err;
     if (!reg_field->stored_in_db)
     {
       share->stored_fields--;
@@ -1772,10 +1736,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
                                                  (uint) key_part->offset,
                                                  (uint) key_part->length);
 	if (!key_part->fieldnr)
-        {
-          error= 4;                             // Wrong file
           goto err;
-        }
+
         field= key_part->field= share->field[key_part->fieldnr-1];
         key_part->type= field->key_type();
         if (field->null_ptr)
@@ -1923,8 +1885,6 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   }
   else
     share->primary_key= MAX_KEY;
-  my_free(disk_buff);
-  disk_buff=0;
   if (new_field_pack_flag <= 1)
   {
     /* Old file format with default as not null */
@@ -1933,7 +1893,7 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
           null_length, 255);
   }
 
-  if (share->db_create_options & HA_OPTION_TEXT_CREATE_OPTIONS)
+  if (options)
   {
     DBUG_ASSERT(options_len);
     if (engine_table_options_frm_read(options, options_len, share))
@@ -1950,13 +1910,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
                             share->default_values, reg_field,
 			    &share->next_number_key_offset,
                             &share->next_number_keypart)) < 0)
-    {
-      /* Wrong field definition */
-      error= 4;
-      goto err;
-    }
-    else
-      reg_field->flags |= AUTO_INCREMENT_FLAG;
+      goto err; // Wrong field definition
+    reg_field->flags |= AUTO_INCREMENT_FLAG;
   }
 
   if (share->blob_fields)
@@ -2000,17 +1955,18 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   if (use_hash)
     (void) my_hash_check(&share->name_hash);
 #endif
-  my_free(extra_segment_buff);
-  DBUG_RETURN (0);
+
+  share->db_plugin= se_plugin;
+  share->error= OPEN_FRM_OK;
+  thd->status_var.opened_shares++;
+  *root_ptr= old_root;
+  DBUG_RETURN(0);
 
  err:
-  share->error= error;
+  share->error= OPEN_FRM_CORRUPTED;
   share->open_errno= my_errno;
-  share->errarg= errarg;
-  my_free(disk_buff);
-  my_free(extra_segment_buff);
-  delete crypted;
   delete handler_file;
+  plugin_unlock(0, se_plugin);
   my_hash_free(&share->name_hash);
   if (share->ha_data_destroy)
   {
@@ -2025,9 +1981,172 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   }
 #endif /* WITH_PARTITION_STORAGE_ENGINE */
 
-  open_table_error(share, error, share->open_errno, errarg);
-  DBUG_RETURN(error);
-} /* open_binary_frm */
+  if (!thd->is_error())
+    open_table_error(share, OPEN_FRM_CORRUPTED, share->open_errno);
+
+  *root_ptr= old_root;
+  DBUG_RETURN(HA_ERR_NOT_A_TABLE);
+}
+
+
+static bool sql_unusable_for_discovery(THD *thd, 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)
+    return 1;
+  // ... create like
+  if (create_info->options & HA_LEX_CREATE_TABLE_LIKE)
+    return 1;
+  // ... create select
+  if (lex->select_lex.item_list.elements)
+    return 1;
+  // ... temporary
+  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
+    return 1;
+  // ... if exists
+  if (create_info->options & HA_LEX_CREATE_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
+  if (create_info->used_fields & HA_CREATE_USED_ENGINE)
+    return 1;
+
+  return 0;
+}
+
+int TABLE_SHARE::init_from_sql_statement_string(THD *thd, bool write,
+                                        const char *sql, size_t sql_length)
+{
+  ulonglong saved_mode= thd->variables.sql_mode;
+  CHARSET_INFO *old_cs= thd->variables.character_set_client;
+  Parser_state parser_state;
+  bool error;
+  char *sql_copy;
+  handler *file;
+  LEX *old_lex;
+  Query_arena *arena, backup;
+  LEX tmp_lex;
+  LEX_CUSTRING frm= {0,0};
+
+  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);
+
+  thd->variables.sql_mode= 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;
+
+  arena= thd->stmt_arena;
+  if (arena->is_conventional())
+    arena= 0;
+  else
+    thd->set_n_backup_active_arena(arena, &backup);
+
+  lex_start(thd);
+
+  if ((error= parse_sql(thd, & parser_state, NULL)))
+    goto ret;
+
+  if (sql_unusable_for_discovery(thd, sql_copy))
+  {
+    my_error(ER_SQL_DISCOVER_ERROR, MYF(0), plugin_name(db_plugin)->str,
+             db.str, table_name.str, sql_copy);
+    goto ret;
+  }
+
+  thd->lex->create_info.db_type= plugin_data(db_plugin, handlerton *);
+
+  if (tabledef_version.str)
+    thd->lex->create_info.tabledef_version= tabledef_version;
+
+  file= mysql_create_frm_image(thd, db.str, table_name.str,
+                               &thd->lex->create_info, &thd->lex->alter_info,
+                               C_ORDINARY_CREATE, &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(thd->lex);
+  thd->lex= old_lex;
+  if (arena)
+    thd->restore_active_arena(arena, &backup);
+  reenable_binlog(thd);
+  thd->variables.sql_mode= saved_mode;
+  thd->variables.character_set_client= old_cs;
+  if (thd->is_error() || error)
+  {
+    thd->clear_error();
+    my_error(ER_NO_SUCH_TABLE, MYF(0), db.str, table_name.str);
+    DBUG_RETURN(HA_ERR_NOT_A_TABLE);
+  }
+  DBUG_RETURN(0);
+}
+
+bool TABLE_SHARE::write_frm_image(const uchar *frm, size_t len)
+{
+  return writefrm(normalized_path.str, db.str, table_name.str, false, frm, len);
+}
+
+
+bool TABLE_SHARE::read_frm_image(const uchar **frm, size_t *len)
+{
+  if (partition_info_str)               // 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));
+}
+
 
 /*
   @brief
@@ -2336,11 +2455,12 @@ end:
    7    Table definition has changed in engine
 */
 
-int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
-                          uint db_stat, uint prgflag, uint ha_open_flags,
-                          TABLE *outparam, bool is_create_table)
+enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
+                       const char *alias, uint db_stat, uint prgflag,
+                       uint ha_open_flags, TABLE *outparam,
+                       bool is_create_table)
 {
-  int error;
+  enum open_frm_error error;
   uint records, i, bitmap_size;
   bool error_reported= FALSE;
   uchar *record, *bitmaps;
@@ -2352,7 +2472,7 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
 
   thd->lex->context_analysis_only&= ~CONTEXT_ANALYSIS_ONLY_VIEW; // not a view
 
-  error= 1;
+  error= OPEN_FRM_ERROR_ALREADY_ISSUED; // for OOM errors below
   bzero((char*) outparam, sizeof(*outparam));
   outparam->in_use= thd;
   outparam->s= share;
@@ -2381,7 +2501,6 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
     DBUG_ASSERT(!db_stat);
   }
 
-  error= 4;
   outparam->reginfo.lock_type= TL_UNLOCK;
   outparam->current_lock= F_UNLCK;
   records=0;
@@ -2534,7 +2653,7 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
                                       &(*field_ptr)->vcol_info->expr_str,
                                       &error_reported))
         {
-          error= 4; // in case no error is reported
+          error= OPEN_FRM_CORRUPTED;
           goto err;
         }
         *(vfield_ptr++)= *field_ptr;
@@ -2645,53 +2764,32 @@ partititon_err:
   outparam->default_column_bitmaps();
 
   /* The table struct is now initialized;  Open the table */
-  error= 2;
   if (db_stat)
   {
-    int ha_err;
-    if ((ha_err= (outparam->file->
-                  ha_open(outparam, share->normalized_path.str,
-                          (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
-                          (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
-                           ((db_stat & HA_WAIT_IF_LOCKED) ||
-                            (specialflag & SPECIAL_WAIT_IF_LOCKED)) ?
-                           HA_OPEN_WAIT_IF_LOCKED :
-                           (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
-                          HA_OPEN_ABORT_IF_LOCKED :
-                           HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
+    if (db_stat & HA_OPEN_TEMPORARY)
+      ha_open_flags|= HA_OPEN_TMP_TABLE;
+    else if ((db_stat & HA_WAIT_IF_LOCKED) ||
+             (specialflag & SPECIAL_WAIT_IF_LOCKED))
+      ha_open_flags|= HA_OPEN_WAIT_IF_LOCKED;
+    else if (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO))
+      ha_open_flags|= HA_OPEN_ABORT_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);
+    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));
-
-      switch (ha_err)
-      {
-        case HA_ERR_NO_SUCH_TABLE:
-	  /*
-            The table did not exists in storage engine, use same error message
-            as if the .frm file didn't exist
-          */
-	  error= 1;
-	  my_errno= ENOENT;
-          break;
-        case EMFILE:
-	  /*
-            Too many files opened, use same error message as if the .frm
-            file can't open
-           */
-          DBUG_PRINT("error", ("open file: %s failed, too many files opened (errno: %d)", 
-		  share->normalized_path.str, ha_err));
-	  error= 1;
-	  my_errno= EMFILE;
-          break;
-        default:
-          outparam->file->print_error(ha_err, MYF(0));
-          error_reported= TRUE;
-          if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
-            error= 7;
-          break;
-      }
-      goto err;                                 /* purecov: inspected */
+      outparam->file->print_error(ha_err, MYF(0));
+      error_reported= TRUE;
+      if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
+        error= OPEN_FRM_DISCOVER;
+      goto err;
     }
   }
 
@@ -2705,11 +2803,11 @@ partititon_err:
   thd->status_var.opened_tables++;
 
   thd->lex->context_analysis_only= save_context_analysis_only;
-  DBUG_RETURN (0);
+  DBUG_RETURN (OPEN_FRM_OK);
 
  err:
   if (! error_reported)
-    open_table_error(share, error, my_errno, 0);
+    open_table_error(share, error, my_errno);
   delete outparam->file;
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (outparam->part_info)
@@ -2820,158 +2918,17 @@ void free_field_buffers_larger_than(TABLE *table, uint32 size)
   }
 }
 
-/**
-  Find where a form starts.
-
-  @param head The start of the form file.
-
-  @remark If formname is NULL then only formnames is read.
-
-  @retval The form position.
-*/
-
-static ulong get_form_pos(File file, uchar *head)
-{
-  uchar *pos, *buf;
-  uint names, length;
-  ulong ret_value=0;
-  DBUG_ENTER("get_form_pos");
-
-  names= uint2korr(head+8);
-
-  if (!(names= uint2korr(head+8)))
-    DBUG_RETURN(0);
-
-  length= uint2korr(head+4);
-
-  mysql_file_seek(file, 64L, MY_SEEK_SET, MYF(0));
-
-  if (!(buf= (uchar*) my_malloc(length+names*4, MYF(MY_WME))))
-    DBUG_RETURN(0);
-
-  if (mysql_file_read(file, buf, length+names*4, MYF(MY_NABP)))
-  {
-    my_free(buf);
-    DBUG_RETURN(0);
-  }
-
-  pos= buf+length;
-  ret_value= uint4korr(pos);
-
-  my_free(buf);
-
-  DBUG_RETURN(ret_value);
-}
-
-
-/*
-  Read string from a file with malloc
-
-  NOTES:
-    We add an \0 at end of the read string to make reading of C strings easier
-*/
+/* error message when opening a form file */
 
-int read_string(File file, uchar**to, size_t length)
+void open_table_error(TABLE_SHARE *share, enum open_frm_error error,
+                      int db_errno)
 {
-  DBUG_ENTER("read_string");
-
-  my_free(*to);
-  if (!(*to= (uchar*) my_malloc(length+1,MYF(MY_WME))) ||
-      mysql_file_read(file, *to, length, MYF(MY_NABP)))
-  {
-     my_free(*to);                            /* purecov: inspected */
-    *to= 0;                                   /* purecov: inspected */
-    DBUG_RETURN(1);                           /* purecov: inspected */
-  }
-  *((char*) *to+length)= '\0';
-  DBUG_RETURN (0);
-} /* read_string */
-
-
-	/* Add a new form to a form file */
-
-ulong make_new_entry(File file, uchar *fileinfo, TYPELIB *formnames,
-		     const char *newname)
-{
-  uint i,bufflength,maxlength,n_length,length,names;
-  ulong endpos,newpos;
-  uchar buff[IO_SIZE];
-  uchar *pos;
-  DBUG_ENTER("make_new_entry");
-
-  length=(uint) strlen(newname)+1;
-  n_length=uint2korr(fileinfo+4);
-  maxlength=uint2korr(fileinfo+6);
-  names=uint2korr(fileinfo+8);
-  newpos=uint4korr(fileinfo+10);
-
-  if (64+length+n_length+(names+1)*4 > maxlength)
-  {						/* Expand file */
-    newpos+=IO_SIZE;
-    int4store(fileinfo+10,newpos);
-    /* Copy from file-end */
-    endpos= (ulong) mysql_file_seek(file, 0L, MY_SEEK_END, MYF(0));
-    bufflength= (uint) (endpos & (IO_SIZE-1));	/* IO_SIZE is a power of 2 */
-
-    while (endpos > maxlength)
-    {
-      mysql_file_seek(file, (ulong) (endpos-bufflength), MY_SEEK_SET, MYF(0));
-      if (mysql_file_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
-	DBUG_RETURN(0L);
-      mysql_file_seek(file, (ulong) (endpos-bufflength+IO_SIZE), MY_SEEK_SET,
-                      MYF(0));
-      if ((mysql_file_write(file, buff, bufflength, MYF(MY_NABP+MY_WME))))
-	DBUG_RETURN(0);
-      endpos-=bufflength; bufflength=IO_SIZE;
-    }
-    bzero(buff,IO_SIZE);			/* Null new block */
-    mysql_file_seek(file, (ulong) maxlength, MY_SEEK_SET, MYF(0));
-    if (mysql_file_write(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
-	DBUG_RETURN(0L);
-    maxlength+=IO_SIZE;				/* Fix old ref */
-    int2store(fileinfo+6,maxlength);
-    for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;
-	 pos+=4)
-    {
-      endpos=uint4korr(pos)+IO_SIZE;
-      int4store(pos,endpos);
-    }
-  }
-
-  if (n_length == 1 )
-  {						/* First name */
-    length++;
-    (void) strxmov((char*) buff,"/",newname,"/",NullS);
-  }
-  else
-    (void) strxmov((char*) buff,newname,"/",NullS); /* purecov: inspected */
-  mysql_file_seek(file, 63L+(ulong) n_length, MY_SEEK_SET, MYF(0));
-  if (mysql_file_write(file, buff, (size_t) length+1, MYF(MY_NABP+MY_WME)) ||
-      (names && mysql_file_write(file,
-                                 (uchar*) (*formnames->type_names+n_length-1),
-                                 names*4, MYF(MY_NABP+MY_WME))) ||
-      mysql_file_write(file, fileinfo+10, 4, MYF(MY_NABP+MY_WME)))
-    DBUG_RETURN(0L); /* purecov: inspected */
-
-  int2store(fileinfo+8,names+1);
-  int2store(fileinfo+4,n_length+length);
-  (void) mysql_file_chsize(file, newpos, 0, MYF(MY_WME));/* Append file with '\0' */
-  DBUG_RETURN(newpos);
-} /* make_new_entry */
-
-
-	/* error message when opening a form file */
-
-void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
-{
-  int err_no;
   char buff[FN_REFLEN];
-  myf errortype= ME_ERROR+ME_WAITTANG;          // Write fatals error to log
+  const myf errortype= ME_ERROR+ME_WAITTANG;  // Write fatals error to log
   DBUG_ENTER("open_table_error");
 
   switch (error) {
-  case 7:
-  case 1:
+  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
@@ -2985,55 +2942,30 @@ void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
                errortype, buff, db_errno);
     }
     break;
-  case 2:
-  {
-    handler *file= 0;
-    const char *datext= "";
-    
-    if (share->db_type() != NULL)
-    {
-      if ((file= get_new_handler(share, current_thd->mem_root,
-                                 share->db_type())))
-      {
-        if (!(datext= *file->bas_ext()))
-          datext= "";
-      }
-    }
-    err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
-      ER_FILE_USED : ER_CANT_OPEN_FILE;
-    strxmov(buff, share->normalized_path.str, datext, NullS);
-    my_error(err_no,errortype, buff, db_errno);
-    delete file;
+  case OPEN_FRM_OK:
+    DBUG_ASSERT(0); // open_table_error() is never called for this one
     break;
-  }
-  case 5:
-  {
-    const char *csname= get_charset_name((uint) errarg);
-    char tmp[10];
-    if (!csname || csname[0] =='?')
-    {
-      my_snprintf(tmp, sizeof(tmp), "#%d", errarg);
-      csname= tmp;
-    }
-    my_printf_error(ER_UNKNOWN_COLLATION,
-                    "Unknown collation '%s' in table '%-.64s' definition", 
-                    MYF(0), csname, share->table_name.str);
+  case OPEN_FRM_ERROR_ALREADY_ISSUED:
     break;
-  }
-  case 6:
-    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
-    my_printf_error(ER_NOT_FORM_FILE,
-                    "Table '%-.64s' was created with a different version "
-                    "of MySQL and cannot be read", 
-                    MYF(0), buff);
+  case OPEN_FRM_NOT_A_VIEW:
+    my_error(ER_WRONG_OBJECT, MYF(0), share->db.str,
+             share->table_name.str, "VIEW");
     break;
-  case 8:
+  case OPEN_FRM_NOT_A_TABLE:
+    my_error(ER_WRONG_OBJECT, MYF(0), share->db.str,
+             share->table_name.str, "TABLE");
     break;
-  default:				/* Better wrong error than none */
-  case 4:
+  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;
   }
   DBUG_VOID_RETURN;
 } /* open_table_error */
@@ -3137,28 +3069,6 @@ static uint find_field(Field **fields, uchar *record, uint start, uint length)
 }
 
 
-	/* Check that the integer is in the internal */
-
-int set_zone(register int nr, int min_zone, int max_zone)
-{
-  if (nr<=min_zone)
-    return (min_zone);
-  if (nr>=max_zone)
-    return (max_zone);
-  return (nr);
-} /* set_zone */
-
-	/* Adjust number to next larger disk buffer */
-
-ulong next_io_size(register ulong pos)
-{
-  reg2 ulong offset;
-  if ((offset= pos & (IO_SIZE-1)))
-    return pos-offset+IO_SIZE;
-  return pos;
-} /* next_io_size */
-
-
 /*
   Store an SQL quoted string.
 
@@ -3221,22 +3131,12 @@ void append_unescaped(String *res, const char *pos, uint length)
 }
 
 
-	/* Create a .frm file */
-
-File create_frm(THD *thd, const char *name, const char *db,
-                const char *table, uint reclength, uchar *fileinfo,
-  		HA_CREATE_INFO *create_info, uint keys, KEY *key_info)
+void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo,
+                        HA_CREATE_INFO *create_info, uint keys, KEY *key_info)
 {
-  register File file;
-  ulong length;
-  uchar fill[IO_SIZE];
-  int create_flags= O_RDWR | O_TRUNC;
   ulong key_comment_total_bytes= 0;
   uint i;
-  DBUG_ENTER("create_frm");
-
-  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
-    create_flags|= O_EXCL | O_NOFOLLOW;
+  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)
@@ -3244,101 +3144,77 @@ File create_frm(THD *thd, const char *name, const char *db,
   if (create_info->min_rows > UINT_MAX32)
     create_info->min_rows= UINT_MAX32;
 
-  if ((file= mysql_file_create(key_file_frm,
-                               name, CREATE_MODE, create_flags, MYF(0))) >= 0)
-  {
-    uint key_length, tmp_key_length, tmp, csid;
-    bzero((char*) fileinfo,64);
-    /* header */
-    fileinfo[0]=(uchar) 254;
-    fileinfo[1]= 1;
-    fileinfo[2]= FRM_VER+3+ test(create_info->varchar);
+  uint key_length, tmp_key_length, tmp, csid;
+  bzero((char*) fileinfo, FRM_HEADER_SIZE);
+  /* header */
+  fileinfo[0]=(uchar) 254;
+  fileinfo[1]= 1;
+  fileinfo[2]= FRM_VER+3+ test(create_info->varchar);
 
-    fileinfo[3]= (uchar) ha_legacy_type(
-          ha_checktype(thd,ha_legacy_type(create_info->db_type),0,0));
-    fileinfo[4]=1;
-    int2store(fileinfo+6,IO_SIZE);		/* Next block starts here */
-    /*
-      Keep in sync with pack_keys() in unireg.cc
-      For each key:
-      8 bytes for the key header
-      9 bytes for each key-part (MAX_REF_PARTS)
-      NAME_LEN bytes for the name
-      1 byte for the NAMES_SEP_CHAR (before the name)
-      For all keys:
-      6 bytes for the header
-      1 byte for the NAMES_SEP_CHAR (after the last name)
-      9 extra bytes (padding for safety? alignment?)
-    */
-    for (i= 0; i < keys; i++)
-    {
-      DBUG_ASSERT(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;
-    }
+  fileinfo[3]= (uchar) ha_legacy_type(
+        ha_checktype(thd,ha_legacy_type(create_info->db_type),0,0));
 
-    key_length= keys * (8 + MAX_REF_PARTS * 9 + NAME_LEN + 1) + 16
-                + key_comment_total_bytes;
-
-    length= next_io_size((ulong) (IO_SIZE+key_length+reclength+
-                                  create_info->extra_size));
-    int4store(fileinfo+10,length);
-    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));
-    fileinfo[40]= (uchar) create_info->row_type;
-    /* Next few bytes where for RAID support */
-    fileinfo[41]= (uchar) (csid >> 8);
-    fileinfo[42]= 0;
-    fileinfo[43]= 0;
-    fileinfo[44]= 0;
-    fileinfo[45]= 0;
-    fileinfo[46]= 0;
-    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 reserved for extra_rec_buf_length,
-      61 for default_part_db_type
-    */
-    int2store(fileinfo+62, create_info->key_block_size);
-    bzero(fill,IO_SIZE);
-    for (; length > IO_SIZE ; length-= IO_SIZE)
-    {
-      if (mysql_file_write(file, fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
-      {
-        (void) mysql_file_close(file, MYF(0));
-        (void) mysql_file_delete(key_file_frm, name, MYF(0));
-	return(-1);
-      }
-    }
-  }
-  else
-  {
-    if (my_errno == ENOENT)
-      my_error(ER_BAD_DB_ERROR,MYF(0),db);
-    else
-      my_error(ER_CANT_CREATE_TABLE,MYF(0),table,my_errno);
-  }
-  DBUG_RETURN(file);
-} /* create_frm */
+  /*
+    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(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;
+  }
+
+  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));
+  fileinfo[40]= (uchar) create_info->row_type;
+  /* Next few bytes where for RAID support */
+  fileinfo[41]= (uchar) (csid >> 8);
+  fileinfo[42]= 0;
+  fileinfo[43]= 0;
+  fileinfo[44]= 0;
+  fileinfo[45]= 0;
+  fileinfo[46]= 0;
+  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 reserved for extra_rec_buf_length,
+    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)
@@ -3367,7 +3243,7 @@ rename_file_ext(const char * from,const char * to,const char * ext)
   char from_b[FN_REFLEN],to_b[FN_REFLEN];
   (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(MY_WME)));
+  return mysql_file_rename(key_file_frm, from_b, to_b, MYF(0));
 }
 
 
@@ -3578,9 +3454,9 @@ bool check_column_name(const char *name)
     }
 #else
     last_char_is_space= *name==' ';
-#endif
-    if (*name == NAMES_SEP_CHAR)
+    if (*name == '\377')
       return 1;
+#endif
     name++;
     name_length++;
   }
@@ -4818,7 +4694,7 @@ void TABLE_LIST::register_want_access(ulong want_access)
   Load security context information for this view
 
   SYNOPSIS
-    TABLE_LIST::prepare_view_securety_context()
+    TABLE_LIST::prepare_view_security_context()
     thd                  [in] thread handler
 
   RETURN
@@ -4827,9 +4703,9 @@ void TABLE_LIST::register_want_access(ulong want_access)
 */
 
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
-bool TABLE_LIST::prepare_view_securety_context(THD *thd)
+bool TABLE_LIST::prepare_view_security_context(THD *thd)
 {
-  DBUG_ENTER("TABLE_LIST::prepare_view_securety_context");
+  DBUG_ENTER("TABLE_LIST::prepare_view_security_context");
   DBUG_PRINT("enter", ("table: %s", alias));
 
   DBUG_ASSERT(!prelocking_placeholder && view);
@@ -4936,7 +4812,7 @@ bool TABLE_LIST::prepare_security(THD *thd)
   Security_context *save_security_ctx= thd->security_ctx;
 
   DBUG_ASSERT(!prelocking_placeholder);
-  if (prepare_view_securety_context(thd))
+  if (prepare_view_security_context(thd))
     DBUG_RETURN(TRUE);
   thd->security_ctx= find_view_security_context(thd);
   while ((tbl= tb++))
diff --git a/sql/table.h b/sql/table.h
index 1a567ae75d1..fa5bd83371a 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -562,6 +562,17 @@ typedef I_P_List <Wait_for_flush,
                  Wait_for_flush_list;
 
 
+enum open_frm_error {
+  OPEN_FRM_OK = 0,
+  OPEN_FRM_OPEN_ERROR,
+  OPEN_FRM_READ_ERROR,
+  OPEN_FRM_CORRUPTED,
+  OPEN_FRM_DISCOVER,
+  OPEN_FRM_ERROR_ALREADY_ISSUED,
+  OPEN_FRM_NOT_A_VIEW,
+  OPEN_FRM_NOT_A_TABLE
+};
+
 /**
   Control block to access table statistics loaded 
   from persistent statistical tables
@@ -605,6 +616,8 @@ struct TABLE_SHARE
   I_P_List <TABLE, TABLE_share> used_tables;
   I_P_List <TABLE, TABLE_share> free_tables;
 
+  LEX_CUSTRING tabledef_version;
+
   engine_option_value *option_list;     /* text options for table */
   ha_table_option_struct *option_struct; /* structure with parsed options */
 
@@ -654,8 +667,9 @@ struct TABLE_SHARE
   plugin_ref db_plugin;			/* storage engine plugin */
   inline handlerton *db_type() const	/* table_type for handler */
   { 
-    // DBUG_ASSERT(db_plugin);
-    return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
+    return is_view   ? view_pseudo_hton :
+           db_plugin ? plugin_data(db_plugin, handlerton*)
+                     : NULL;
   }
   enum row_type row_type;		/* How rows are stored */
   enum tmp_table_type tmp_table;
@@ -694,7 +708,8 @@ struct TABLE_SHARE
   uint next_number_index;               /* autoincrement key number */
   uint next_number_key_offset;          /* autoinc keypart offset in a key */
   uint next_number_keypart;             /* autoinc keypart number in a key */
-  uint error, open_errno, errarg;       /* error from open_table_def() */
+  enum open_frm_error error;            /* error from open_table_def() */
+  uint open_errno;                      /* error from open_table_def() */
   uint column_bitmap_size;
   uchar frm_version;
   uint vfields;                         /* Number of computed (virtual) fields */
@@ -825,12 +840,42 @@ struct TABLE_SHARE
     return table_map_id;
   }
 
-
   /** Is this table share being expelled from the table definition cache?  */
   inline bool has_old_version() const
   {
     return version != refresh_version;
   }
+  inline bool protected_against_usage() const
+  {
+    return version == 0;
+  }
+  inline void protect_against_usage()
+  {
+    version= 0;
+  }
+  /*
+    This is used only for the case of locked tables, as we want to
+    allow one to do SHOW commands on them even after ALTER or REPAIR
+  */
+  inline void allow_access_to_protected_table()
+  {
+    DBUG_ASSERT(version == 0);
+    version= 1;
+  }
+  /*
+    Remove from table definition cache at close.
+    Table can still be opened by SHOW
+  */
+  inline void remove_from_cache_at_close()
+  {
+    if (version != 0)                           /* Don't remove protection */
+      version= 1;
+  }
+  inline void set_refresh_version()
+  {
+    version= refresh_version;
+  }
+
   /**
     Convert unrelated members of TABLE_SHARE to one enum
     representing its type.
@@ -944,6 +989,40 @@ struct TABLE_SHARE
   }
   
   uint actual_n_key_parts(THD *thd);
+
+  LEX_CUSTRING *frm_image; ///< only during CREATE TABLE (@sa ha_create_table)
+
+  /*
+    populates TABLE_SHARE from the table description in the binary frm image.
+    if 'write' is true, this frm image is also written into a corresponding
+    frm file, that serves as a persistent metadata cache to avoid
+    discovering the table over and over again
+  */
+  int init_from_binary_frm_image(THD *thd, bool write,
+                                 const uchar *frm_image, size_t frm_length);
+
+  /*
+    populates TABLE_SHARE from the table description, specified as the
+    complete CREATE TABLE sql statement.
+    if 'write' is true, this frm image is also written into a corresponding
+    frm file, that serves as a persistent metadata cache to avoid
+    discovering the table over and over again
+  */
+  int init_from_sql_statement_string(THD *thd, bool write,
+                                     const char *sql, size_t sql_length);
+  /*
+    writes the frm image to an frm file, corresponding to this table
+  */
+  bool write_frm_image(const uchar *frm_image, size_t frm_length);
+
+  /*
+    returns an frm image for this table.
+    the memory is allocated and must be freed later
+  */
+  bool read_frm_image(const uchar **frm_image, size_t *frm_length);
+
+  /* frees the memory allocated in read_frm_image */
+  void free_frm_image(const uchar *frm);
 };
 
 
@@ -1580,7 +1659,7 @@ struct TABLE_LIST
 
   /**
     Prepare TABLE_LIST that consists of one table instance to use in
-    simple_open_and_lock_tables
+    open_and_lock_tables
   */
   inline void init_one_table(const char *db_name_arg,
                              size_t db_length_arg,
@@ -2004,7 +2083,7 @@ struct TABLE_LIST
   bool prepare_security(THD *thd);
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
   Security_context *find_view_security_context(THD *thd);
-  bool prepare_view_securety_context(THD *thd);
+  bool prepare_view_security_context(THD *thd);
 #endif
   /*
     Cleanup for re-execution in a prepared statement or a stored
@@ -2147,9 +2226,9 @@ private:
 #else
   inline void set_check_merged() {}
 #endif
-  /** See comments for set_metadata_id() */
+  /** See comments for set_table_ref_id() */
   enum enum_table_ref_type m_table_ref_type;
-  /** See comments for set_metadata_id() */
+  /** See comments for set_table_ref_id() */
   ulong m_table_ref_version;
 };
 
@@ -2403,26 +2482,35 @@ static inline void dbug_tmp_restore_column_maps(MY_BITMAP *read_set,
 #endif
 }
 
+enum get_table_share_flags {
+  GTS_TABLE                = 1,
+  GTS_VIEW                 = 2,
+  GTS_NOLOCK               = 4,
+  GTS_FORCE_DISCOVERY      = 8
+};
 
 size_t max_row_length(TABLE *table, const uchar *data);
 
-
 void init_mdl_requests(TABLE_LIST *table_list);
 
-int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
-                          uint db_stat, uint prgflag, uint ha_open_flags,
-                          TABLE *outparam, bool is_create_table);
+enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
+                       const char *alias, uint db_stat, uint prgflag,
+                       uint ha_open_flags, TABLE *outparam,
+                       bool is_create_table);
 bool unpack_vcol_info_from_frm(THD *thd, MEM_ROOT *mem_root,
                                TABLE *table, Field *field,
                                LEX_STRING *vcol_expr, bool *error_reported);
-TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
-                               uint key_length);
+TABLE_SHARE *alloc_table_share(const char *db, const char *table_name,
+                               char *key, uint key_length);
 void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
                           uint key_length,
                           const char *table_name, const char *path);
 void free_table_share(TABLE_SHARE *share);
-int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags);
-void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg);
+enum open_frm_error open_table_def(THD *thd, TABLE_SHARE *share,
+                                   uint flags = GTS_TABLE);
+
+void open_table_error(TABLE_SHARE *share, enum open_frm_error error,
+                      int db_errno);
 void update_create_info_from_table(HA_CREATE_INFO *info, TABLE *form);
 bool check_and_convert_db_name(LEX_STRING *db, bool preserve_lettercase);
 bool check_db_name(LEX_STRING *db);
@@ -2433,20 +2521,24 @@ char *get_field(MEM_ROOT *mem, Field *field);
 bool get_field(MEM_ROOT *mem, Field *field, class String *res);
 
 int closefrm(TABLE *table, bool free_share);
-int read_string(File file, uchar* *to, size_t length);
 void free_blobs(TABLE *table);
 void free_field_buffers_larger_than(TABLE *table, uint32 size);
-int set_zone(int nr,int min_zone,int max_zone);
 ulong get_form_pos(File file, uchar *head, TYPELIB *save_names);
-ulong make_new_entry(File file,uchar *fileinfo,TYPELIB *formnames,
-		     const char *newname);
-ulong next_io_size(ulong pos);
 void append_unescaped(String *res, const char *pos, uint length);
-File create_frm(THD *thd, const char *name, const char *db,
-                const char *table, uint reclength, uchar *fileinfo,
-  		HA_CREATE_INFO *create_info, uint keys, KEY *key_info);
+void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo,
+                        HA_CREATE_INFO *create_info, uint keys, KEY *key_info);
 char *fn_rext(char *name);
 
+/* Check that the integer is in the internal */
+static inline int set_zone(int nr,int min_zone,int max_zone)
+{
+  if (nr <= min_zone)
+    return min_zone;
+  if (nr >= max_zone)
+    return max_zone;
+  return nr;
+}
+
 /* performance schema */
 extern LEX_STRING PERFORMANCE_SCHEMA_DB_NAME;
 
diff --git a/sql/threadpool_unix.cc b/sql/threadpool_unix.cc
index 13deb167d9b..69df00a2c9a 100644
--- a/sql/threadpool_unix.cc
+++ b/sql/threadpool_unix.cc
@@ -29,14 +29,14 @@
 #ifdef __linux__
 #include <sys/epoll.h>
 typedef struct epoll_event native_event;
-#endif
-#if defined (__FreeBSD__) || defined (__APPLE__)
+#elif defined(HAVE_KQUEUE)
 #include <sys/event.h>
 typedef struct kevent native_event;
-#endif
-#if defined (__sun)
+#elif defined (__sun)
 #include <port.h>
 typedef port_event_t native_event;
+#else
+#error threadpool is not available on this platform
 #endif
 
 /** Maximum number of native events a listener can read in one go */
@@ -285,7 +285,7 @@ static void *native_event_get_userdata(native_event *event)
   return event->data.ptr;
 }
 
-#elif defined (__FreeBSD__) || defined (__APPLE__)
+#elif defined(HAVE_KQUEUE)
 int io_poll_create()
 {
   return kqueue();
@@ -386,8 +386,6 @@ static void* native_event_get_userdata(native_event *event)
 {
   return event->portev_user;
 }
-#else
-#error not ported yet to this OS
 #endif
 
 
@@ -1247,11 +1245,12 @@ static void connection_abort(connection_t *connection)
   DBUG_ENTER("connection_abort");
   thread_group_t *group= connection->thread_group;
   
+  threadpool_remove_connection(connection->thd); 
+  
   mysql_mutex_lock(&group->mutex);
   group->connection_count--;
   mysql_mutex_unlock(&group->mutex);
-
-  threadpool_remove_connection(connection->thd); 
+  
   my_free(connection);
   DBUG_VOID_RETURN;
 }
diff --git a/sql/transaction.cc b/sql/transaction.cc
index 7d8fc89ec8c..9a1952427d8 100644
--- a/sql/transaction.cc
+++ b/sql/transaction.cc
@@ -610,15 +610,19 @@ bool trans_xa_start(THD *thd)
     my_error(ER_XAER_RMFAIL, MYF(0), xa_state_names[xa_state]);
   else if (thd->locked_tables_mode || thd->in_active_multi_stmt_transaction())
     my_error(ER_XAER_OUTSIDE, MYF(0));
-  else if (xid_cache_search(thd->lex->xid))
-    my_error(ER_XAER_DUPID, MYF(0));
   else if (!trans_begin(thd))
   {
     DBUG_ASSERT(thd->transaction.xid_state.xid.is_null());
     thd->transaction.xid_state.xa_state= XA_ACTIVE;
     thd->transaction.xid_state.rm_error= 0;
     thd->transaction.xid_state.xid.set(thd->lex->xid);
-    xid_cache_insert(&thd->transaction.xid_state);
+    if (xid_cache_insert(&thd->transaction.xid_state))
+    {
+      thd->transaction.xid_state.xa_state= XA_NOTR;
+      thd->transaction.xid_state.xid.null();
+      trans_rollback(thd);
+      DBUG_RETURN(true);
+    }
     DBUG_RETURN(FALSE);
   }
 
@@ -704,6 +708,16 @@ bool trans_xa_commit(THD *thd)
 
   if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
   {
+    /*
+      xid_state.in_thd is always true beside of xa recovery procedure.
+      Note, that there is no race condition here between xid_cache_search
+      and xid_cache_delete, since we always delete our own XID
+      (thd->lex->xid == thd->transaction.xid_state.xid).
+      The only case when thd->lex->xid != thd->transaction.xid_state.xid
+      and xid_state->in_thd == 0 is in the function
+      xa_cache_insert(XID, xa_states), which is called before starting
+      client connections, and thus is always single-threaded.
+    */
     XID_STATE *xs= xid_cache_search(thd->lex->xid);
     res= !xs || xs->in_thd;
     if (res)
diff --git a/sql/tztime.cc b/sql/tztime.cc
index b16cc65d6bb..5e1e8bec7b3 100644
--- a/sql/tztime.cc
+++ b/sql/tztime.cc
@@ -1856,7 +1856,7 @@ static Time_zone*
 tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
 {
   TABLE *table= 0;
-  TIME_ZONE_INFO *tz_info;
+  TIME_ZONE_INFO *tz_info= NULL;
   Tz_names_entry *tmp_tzname;
   Time_zone *return_val= 0;
   int res;
@@ -1866,7 +1866,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
   uchar keybuff[32];
   Field *field;
   String abbr(buff, sizeof(buff), &my_charset_latin1);
-  char *alloc_buff, *tz_name_buff;
+  char *alloc_buff= NULL;
+  char *tz_name_buff= NULL;
   /*
     Temporary arrays that are used for loading of data for filling
     TIME_ZONE_INFO structure
@@ -1886,22 +1887,6 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
 
   DBUG_ENTER("tz_load_from_open_tables");
 
-  /* Prepare tz_info for loading also let us make copy of time zone name */
-  if (!(alloc_buff= (char*) alloc_root(&tz_storage, sizeof(TIME_ZONE_INFO) +
-                                       tz_name->length() + 1)))
-  {
-    sql_print_error("Out of memory while loading time zone description");
-    return 0;
-  }
-  tz_info= (TIME_ZONE_INFO *)alloc_buff;
-  bzero(tz_info, sizeof(TIME_ZONE_INFO));
-  tz_name_buff= alloc_buff + sizeof(TIME_ZONE_INFO);
-  /*
-    By writing zero to the end we guarantee that we can call ptr()
-    instead of c_ptr() for time zone name.
-  */
-  strmake(tz_name_buff, tz_name->ptr(), tz_name->length());
-
   /*
     Let us find out time zone id by its name (there is only one index
     and it is specifically for this purpose).
@@ -2520,7 +2505,7 @@ scan_tz_dir(char * name_end)
 
   name_end= strmake(name_end, "/", FN_REFLEN - (name_end - fullname));
 
-  for (i= 0; i < cur_dir->number_off_files; i++)
+  for (i= 0; i < cur_dir->number_of_files; i++)
   {
     if (cur_dir->dir_entry[i].name[0] != '.')
     {
diff --git a/sql/unireg.cc b/sql/unireg.cc
index e40dc02c21b..04af09fd31c 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -1,5 +1,6 @@
 /*
    Copyright (c) 2000, 2011, Oracle and/or its affiliates.
+   Copyright (c) 2009, 2013, Monty Program Ab.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -27,9 +28,9 @@
 #include "sql_priv.h"
 #include "unireg.h"
 #include "sql_partition.h"                      // struct partition_info
-#include "sql_table.h"                          // check_duplicate_warning
 #include "sql_class.h"                  // THD, Internal_error_handler
 #include "create_options.h"
+#include "discover.h"
 #include <m_ctype.h>
 #include <assert.h>
 
@@ -38,137 +39,58 @@
 /* threshold for safe_alloca */
 #define ALLOCA_THRESHOLD       2048
 
-static uchar * pack_screens(List<Create_field> &create_fields,
-			    uint *info_length, uint *screens, bool small_file);
-static uint pack_keys(uchar *keybuff,uint key_count, KEY *key_info,
-                      ulong data_offset);
-static bool pack_header(uchar *forminfo,enum legacy_db_type table_type,
-			List<Create_field> &create_fields,
-			uint info_length, uint screens, uint table_options,
-			ulong data_offset, handler *file);
+static uint pack_keys(uchar *,uint, KEY *, ulong);
+static bool pack_header(uchar *, List<Create_field> &, uint, ulong, handler *);
 static uint get_interval_id(uint *,List<Create_field> &, Create_field *);
-static bool pack_fields(File file, List<Create_field> &create_fields,
-                        ulong data_offset);
-static bool make_empty_rec(THD *thd, int file, enum legacy_db_type table_type,
-			   uint table_options,
-			   List<Create_field> &create_fields,
-			   uint reclength, ulong data_offset,
-                           handler *handler);
+static bool pack_fields(uchar *, List<Create_field> &, ulong);
+static size_t packed_fields_length(List<Create_field> &);
+static bool make_empty_rec(THD *, uchar *, uint, List<Create_field> &, uint, ulong);
 
 /**
-  An interceptor to hijack ER_TOO_MANY_FIELDS error from
-  pack_screens and retry again without UNIREG screens.
-
-  XXX: what is a UNIREG  screen?
-*/
-
-struct Pack_header_error_handler: public Internal_error_handler
-{
-  virtual bool handle_condition(THD *thd,
-                                uint sql_errno,
-                                const char* sqlstate,
-                                MYSQL_ERROR::enum_warning_level level,
-                                const char* msg,
-                                MYSQL_ERROR ** cond_hdl);
-  bool is_handled;
-  Pack_header_error_handler() :is_handled(FALSE) {}
-};
-
-
-bool
-Pack_header_error_handler::
-handle_condition(THD *,
-                 uint sql_errno,
-                 const char*,
-                 MYSQL_ERROR::enum_warning_level,
-                 const char*,
-                 MYSQL_ERROR ** cond_hdl)
-{
-  *cond_hdl= NULL;
-  is_handled= (sql_errno == ER_TOO_MANY_FIELDS);
-  return is_handled;
-}
-
-/*
   Create a frm (table definition) file
 
-  SYNOPSIS
-    mysql_create_frm()
-    thd			Thread handler
-    file_name		Path for file (including database and .frm)
-    db                  Name of database
-    table               Name of table
-    create_info		create info parameters
-    create_fields	Fields to create
-    keys		number of keys to create
-    key_info		Keys to create
-    db_file		Handler to use. May be zero, in which case we use
-			create_info->db_type
-  RETURN
-    false  ok
-    true   error
+  @param thd                    Thread handler
+  @param table                  Name of table
+  @param create_info            create info parameters
+  @param create_fields          Fields to create
+  @param keys                   number of keys to create
+  @param key_info               Keys to create
+  @param db_file                Handler to use.
+
+  @return the generated frm image as a LEX_CUSTRING,
+  or null LEX_CUSTRING (str==0) in case of an error.
 */
 
-bool mysql_create_frm(THD *thd, const char *file_name,
-                      const char *db, const char *table,
-		      HA_CREATE_INFO *create_info,
-		      List<Create_field> &create_fields,
-		      uint keys, KEY *key_info,
-		      handler *db_file)
+LEX_CUSTRING build_frm_image(THD *thd, const char *table,
+                              HA_CREATE_INFO *create_info,
+                              List<Create_field> &create_fields,
+                              uint keys, KEY *key_info, handler *db_file)
 {
   LEX_STRING str_db_type;
-  uint reclength, info_length, screens, key_info_length, maxlength, tmp_len, i;
+  uint reclength, key_info_length, tmp_len, i;
   ulong key_buff_length;
-  File file;
   ulong filepos, data_offset;
   uint options_len;
-  uchar fileinfo[64],forminfo[288],*keybuff;
-  uchar *screen_buff;
-  char buff[128];
+  uchar fileinfo[FRM_HEADER_SIZE],forminfo[FRM_FORMINFO_SIZE];
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   partition_info *part_info= thd->work_part_info;
 #endif
-  Pack_header_error_handler pack_header_error_handler;
   int error;
-  DBUG_ENTER("mysql_create_frm");
-
-  DBUG_ASSERT(*fn_rext((char*)file_name)); // Check .frm extension
-
-  if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,0)))
-    DBUG_RETURN(1);
-  DBUG_ASSERT(db_file != NULL);
+  uchar *frm_ptr, *pos;
+  LEX_CUSTRING frm= {0,0};
+  DBUG_ENTER("build_frm_image");
 
  /* If fixed row records, we need one bit to check for deleted rows */
   if (!(create_info->table_options & HA_OPTION_PACK_RECORD))
     create_info->null_bits++;
   data_offset= (create_info->null_bits + 7) / 8;
 
-  thd->push_internal_handler(&pack_header_error_handler);
-
-  error= pack_header(forminfo, ha_legacy_type(create_info->db_type),
-                     create_fields,info_length,
-                     screens, create_info->table_options,
+  error= pack_header(forminfo, create_fields, create_info->table_options,
                      data_offset, db_file);
 
-  thd->pop_internal_handler();
-
   if (error)
-  {
-    my_free(screen_buff);
-    if (! pack_header_error_handler.is_handled)
-      DBUG_RETURN(1);
-
-    // Try again without UNIREG screens (to get more columns)
-    if (!(screen_buff=pack_screens(create_fields,&info_length,&screens,1)))
-      DBUG_RETURN(1);
-    if (pack_header(forminfo, ha_legacy_type(create_info->db_type),
-                    create_fields,info_length,
-		    screens, create_info->table_options, data_offset, db_file))
-    {
-      my_free(screen_buff);
-      DBUG_RETURN(1);
-    }
-  }
+    DBUG_RETURN(frm);
+
   reclength=uint2korr(forminfo+266);
 
   /* Calculate extra data segment length */
@@ -201,13 +123,6 @@ bool mysql_create_frm(THD *thd, const char *file_name,
                                                create_fields,
                                                keys, key_info);
   DBUG_PRINT("info", ("Options length: %u", options_len));
-  if (options_len)
-  {
-    create_info->table_options|= HA_OPTION_TEXT_CREATE_OPTIONS;
-    create_info->extra_size+= (options_len + 4);
-  }
-  else
-    create_info->table_options&= ~HA_OPTION_TEXT_CREATE_OPTIONS;
 
   /*
     This gives us the byte-position of the character at
@@ -244,58 +159,108 @@ bool mysql_create_frm(THD *thd, const char *file_name,
     if (thd->is_strict_mode())
     {
       my_error(ER_TOO_LONG_TABLE_COMMENT, MYF(0),
-               real_table_name, static_cast<ulong>(TABLE_COMMENT_MAXLEN));
-      my_free(screen_buff);
-      DBUG_RETURN(1);
+               real_table_name, TABLE_COMMENT_MAXLEN);
+      DBUG_RETURN(frm);
     }
     char warn_buff[MYSQL_ERRMSG_SIZE];
     my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_TOO_LONG_TABLE_COMMENT),
-                real_table_name, static_cast<ulong>(TABLE_COMMENT_MAXLEN));
-    /* do not push duplicate warnings */
-    if (!check_duplicate_warning(current_thd, warn_buff, strlen(warn_buff)))
-      push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                   ER_TOO_LONG_TABLE_COMMENT, warn_buff);
+                real_table_name, TABLE_COMMENT_MAXLEN);
+    push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                 ER_TOO_LONG_TABLE_COMMENT, warn_buff);
     create_info->comment.length= tmp_len;
   }
   /*
     If table comment is longer than TABLE_COMMENT_INLINE_MAXLEN bytes,
     store the comment in an extra segment (up to TABLE_COMMENT_MAXLEN bytes).
-    Pre 6.0, the limit was 60 characters, with no extra segment-handling.
+    Pre 5.5, the limit was 60 characters, with no extra segment-handling.
   */
   if (create_info->comment.length > TABLE_COMMENT_INLINE_MAXLEN)
   {
     forminfo[46]=255;
     create_info->extra_size+= 2 + create_info->comment.length;
   }
-  else{
+  else
+  {
     strmake((char*) forminfo+47, create_info->comment.str ?
             create_info->comment.str : "", create_info->comment.length);
     forminfo[46]=(uchar) create_info->comment.length;
   }
 
-  if ((file=create_frm(thd, file_name, db, table, reclength, fileinfo,
-		       create_info, keys, key_info)) < 0)
+  if (!create_info->tabledef_version.str)
   {
-    my_free(screen_buff);
-    DBUG_RETURN(1);
+    uchar *to= (uchar*) thd->alloc(MY_UUID_SIZE);
+    if (unlikely(!to))
+      DBUG_RETURN(frm);
+    my_uuid(to);
+    create_info->tabledef_version.str= to;
+    create_info->tabledef_version.length= MY_UUID_SIZE;
   }
+  DBUG_ASSERT(create_info->tabledef_version.length > 0);
+  DBUG_ASSERT(create_info->tabledef_version.length <= 255);
+
+  prepare_frm_header(thd, reclength, fileinfo, create_info, keys, key_info);
+
+  /* one byte for a type, one or three for a length */
+  uint extra2_size= 1 + 1 + create_info->tabledef_version.length;
+  if (options_len)
+    extra2_size+= 1 + (options_len > 255 ? 3 : 1) + options_len;
 
   key_buff_length= uint4korr(fileinfo+47);
-  keybuff=(uchar*) my_malloc(key_buff_length, MYF(MY_THREAD_SPECIFIC));
-  key_info_length= pack_keys(keybuff, keys, key_info, data_offset);
 
-  /*
-    Ensure that there are no forms in this newly created form file.
-    Even if the form file exists, create_frm must truncate it to
-    ensure one form per form file.
-  */
-  DBUG_ASSERT(uint2korr(fileinfo+8) == 0);
+  frm.length= FRM_HEADER_SIZE;                  // fileinfo;
+  frm.length+= extra2_size + 4;                 // mariadb extra2 frm segment
+
+  int2store(fileinfo+4, extra2_size);
+  int2store(fileinfo+6, frm.length);            // Position to key information
+  frm.length+= key_buff_length;
+  frm.length+= reclength;                       // row with default values
+  frm.length+= create_info->extra_size;
+
+  filepos= frm.length;
+  frm.length+= FRM_FORMINFO_SIZE;               // forminfo
+  frm.length+= packed_fields_length(create_fields);
+  
+  frm_ptr= (uchar*) my_malloc(frm.length, MYF(MY_WME | MY_ZEROFILL |
+                                              MY_THREAD_SPECIFIC));
+  if (!frm_ptr)
+    DBUG_RETURN(frm);
+
+  /* write the extra2 segment */
+  pos = frm_ptr + 64;
+  compile_time_assert(EXTRA2_TABLEDEF_VERSION != '/');
+  *pos++ = EXTRA2_TABLEDEF_VERSION;     // old servers write '/' here
+  *pos++ = create_info->tabledef_version.length;
+  memcpy(pos, create_info->tabledef_version.str,
+              create_info->tabledef_version.length);
+  pos+= create_info->tabledef_version.length;
 
-  if (!(filepos= make_new_entry(file, fileinfo, NULL, "")))
-    goto err;
-  maxlength=(uint) next_io_size((ulong) (uint2korr(forminfo)+1000));
-  int2store(forminfo+2,maxlength);
-  int4store(fileinfo+10,(ulong) (filepos+maxlength));
+  if (options_len)
+  {
+    *pos++= EXTRA2_ENGINE_TABLEOPTS;
+    if (options_len < 255)
+      *pos++= options_len;
+    else
+    {
+      /*
+        At the moment we support options_len up to 64K.
+        We can easily extend it in the future, if the need arises.
+      */
+      DBUG_ASSERT(options_len <= 65535);
+      int2store(pos + 1, options_len);
+      pos+= 3;
+    }
+    pos= engine_table_options_frm_image(pos, create_info->option_list,
+                                        create_fields, keys, key_info);
+  }
+
+  int4store(pos, filepos); // end of the extra2 segment
+  pos+= 4;
+
+  DBUG_ASSERT(pos == frm_ptr + uint2korr(fileinfo+6));
+  key_info_length= pack_keys(pos, keys, key_info, data_offset);
+
+  int2store(forminfo+2, frm.length - filepos);
+  int4store(fileinfo+10, frm.length);
   fileinfo[26]= (uchar) test((create_info->max_rows == 1) &&
 			     (create_info->min_rows == 1) && (keys == 0));
   int2store(fileinfo+28,key_info_length);
@@ -309,125 +274,59 @@ bool mysql_create_frm(THD *thd, const char *file_name,
 #endif
   int2store(fileinfo+59,db_file->extra_rec_buf_length());
 
-  if (mysql_file_pwrite(file, fileinfo, 64, 0L, MYF_RW) ||
-      mysql_file_pwrite(file, keybuff, key_info_length,
-                        (ulong) uint2korr(fileinfo+6), MYF_RW))
-    goto err;
-  mysql_file_seek(file,
-                  (ulong) uint2korr(fileinfo+6) + (ulong) key_buff_length,
-                  MY_SEEK_SET, MYF(0));
-  if (make_empty_rec(thd,file,ha_legacy_type(create_info->db_type),
-                     create_info->table_options,
-		     create_fields,reclength, data_offset, db_file))
-    goto err;
-
-  int2store(buff, create_info->connect_string.length);
-  if (mysql_file_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||
-      mysql_file_write(file, (const uchar*)create_info->connect_string.str,
-               create_info->connect_string.length, MYF(MY_NABP)))
-      goto err;
+  memcpy(frm_ptr, fileinfo, FRM_HEADER_SIZE);
 
-  int2store(buff, str_db_type.length);
-  if (mysql_file_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||
-      mysql_file_write(file, (const uchar*)str_db_type.str,
-               str_db_type.length, MYF(MY_NABP)))
+  pos+= key_buff_length;
+  if (make_empty_rec(thd, pos, create_info->table_options, create_fields,
+                     reclength, data_offset))
     goto err;
 
+  pos+= reclength;
+  int2store(pos, create_info->connect_string.length);
+  pos+= 2;
+  memcpy(pos, create_info->connect_string.str, create_info->connect_string.length);
+  pos+= create_info->connect_string.length;
+  int2store(pos, str_db_type.length);
+  pos+= 2;
+  memcpy(pos, str_db_type.str, str_db_type.length);
+  pos+= str_db_type.length;
+
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (part_info)
   {
     char auto_partitioned= part_info->is_auto_partitioned ? 1 : 0;
-    int4store(buff, part_info->part_info_len);
-    if (mysql_file_write(file, (const uchar*)buff, 4, MYF_RW) ||
-        mysql_file_write(file, (const uchar*)part_info->part_info_string,
-                 part_info->part_info_len + 1, MYF_RW) ||
-        mysql_file_write(file, (const uchar*)&auto_partitioned, 1, MYF_RW))
-      goto err;
+    int4store(pos, part_info->part_info_len);
+    pos+= 4;
+    memcpy(pos, part_info->part_info_string, part_info->part_info_len + 1);
+    pos+= part_info->part_info_len + 1;
+    *pos++= auto_partitioned;
   }
   else
 #endif
   {
-    bzero((uchar*) buff, 6);
-    if (mysql_file_write(file, (uchar*) buff, 6, MYF_RW))
-      goto err;
+    pos+= 6;
   }
 
   for (i= 0; i < keys; i++)
   {
     if (key_info[i].parser_name)
     {
-      if (mysql_file_write(file, (const uchar*)key_info[i].parser_name->str,
-                           key_info[i].parser_name->length + 1, MYF(MY_NABP)))
-        goto err;
+      memcpy(pos, key_info[i].parser_name->str, key_info[i].parser_name->length + 1);
+      pos+= key_info[i].parser_name->length + 1;
     }
   }
-  if (forminfo[46] == (uchar)255)
+  if (forminfo[46] == (uchar)255)       // New style MySQL 5.5 table comment
   {
-    uchar comment_length_buff[2];
-    int2store(comment_length_buff,create_info->comment.length);
-    if (mysql_file_write(file, comment_length_buff, 2, MYF(MY_NABP)) ||
-        mysql_file_write(file, (uchar*) create_info->comment.str,
-                         create_info->comment.length, MYF(MY_NABP)))
-      goto err;
+    int2store(pos, create_info->comment.length);
+    pos+=2;
+    memcpy(pos, create_info->comment.str, create_info->comment.length);
+    pos+= create_info->comment.length;
   }
 
-  if (options_len)
-  {
-    uchar *optbuff= (uchar *)my_safe_alloca(options_len + 4, ALLOCA_THRESHOLD);
-    my_bool error;
-    DBUG_PRINT("info", ("Create options length: %u", options_len));
-    if (!optbuff)
-      goto err;
-    int4store(optbuff, options_len);
-    engine_table_options_frm_image(optbuff + 4,
-                                   create_info->option_list,
-                                   create_fields,
-                                   keys, key_info);
-    error= my_write(file, optbuff, options_len + 4, MYF_RW);
-    my_safe_afree(optbuff, options_len + 4, ALLOCA_THRESHOLD);
-    if (error)
-      goto err;
-  }
-
-  mysql_file_seek(file, filepos, MY_SEEK_SET, MYF(0));
-  if (mysql_file_write(file, forminfo, 288, MYF_RW) ||
-      mysql_file_write(file, screen_buff, info_length, MYF_RW) ||
-      pack_fields(file, create_fields, data_offset))
+  memcpy(frm_ptr + filepos, forminfo, 288);
+  if (pack_fields(frm_ptr + filepos + 288, create_fields, data_offset))
     goto err;
 
-#ifdef HAVE_CRYPTED_FRM
-  if (create_info->password)
-  {
-    char tmp=2,*disk_buff=0;
-    SQL_CRYPT *crypted=new SQL_CRYPT(create_info->password);
-    if (!crypted || mysql_file_pwrite(file, &tmp, 1, 26, MYF_RW))// Mark crypted
-      goto err;
-    uint read_length=uint2korr(forminfo)-256;
-    mysql_file_seek(file, filepos+256, MY_SEEK_SET, MYF(0));
-    if (read_string(file,(uchar**) &disk_buff,read_length))
-      goto err;
-    crypted->encode(disk_buff,read_length);
-    delete crypted;
-    if (mysql_file_pwrite(file, disk_buff, read_length, filepos+256, MYF_RW))
-    {
-      my_free(disk_buff);
-      goto err;
-    }
-    my_free(disk_buff);
-  }
-#endif
-
-  my_free(screen_buff);
-  my_free(keybuff);
-
-  if (opt_sync_frm && !(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
-      (mysql_file_sync(file, MYF(MY_WME)) ||
-       my_sync_dir_by_file(file_name, MYF(MY_WME))))
-      goto err2;
-
-  if (mysql_file_close(file, MYF(MY_WME)))
-    goto err3;
-
   {
     /* 
       Restore all UCS2 intervals.
@@ -444,17 +343,14 @@ bool mysql_create_frm(THD *thd, const char *file_name,
       }
     }
   }
-  DBUG_RETURN(0);
+
+  frm.str= frm_ptr;
+  DBUG_RETURN(frm);
 
 err:
-  my_free(screen_buff);
-  my_free(keybuff);
-err2:
-  (void) mysql_file_close(file, MYF(MY_WME));
-err3:
-  mysql_file_delete(key_file_frm, file_name, MYF(0));
-  DBUG_RETURN(1);
-} /* mysql_create_frm */
+  my_free(frm_ptr);
+  DBUG_RETURN(frm);
+}
 
 
 /*
@@ -463,130 +359,58 @@ err3:
   SYNOPSIS
     rea_create_table()
     thd			Thread handler
+    frm                 binary frm image of the table to create
     path		Name of file (including database, without .frm)
     db			Data base name
     table_name		Table name
     create_info		create info parameters
-    create_fields	Fields to create
-    keys		number of keys to create
-    key_info		Keys to create
-    file		Handler to use
+    file                Handler to use or NULL if only frm needs to be created
 
   RETURN
     0  ok
     1  error
 */
 
-int rea_create_table(THD *thd, const char *path,
-                     const char *db, const char *table_name,
-                     HA_CREATE_INFO *create_info,
-                     List<Create_field> &create_fields,
-                     uint keys, KEY *key_info, handler *file)
+int rea_create_table(THD *thd, LEX_CUSTRING *frm,
+                     const char *path, const char *db, const char *table_name,
+                     HA_CREATE_INFO *create_info, handler *file)
 {
   DBUG_ENTER("rea_create_table");
 
-  char frm_name[FN_REFLEN];
-  strxmov(frm_name, path, reg_ext, NullS);
-  if (mysql_create_frm(thd, frm_name, db, table_name, create_info,
-                       create_fields, keys, key_info, file))
+  if (file)
+  {
+    // TODO don't write frm for temp tables
+    if (create_info->tmp_table() &&
+        writefrm(path, db, table_name, true, frm->str, frm->length))
+      goto err_handler;
 
-    DBUG_RETURN(1);
+    if (thd->variables.keep_files_on_create)
+      create_info->options|= HA_CREATE_KEEP_FILES;
+
+    if (file->ha_create_partitioning_metadata(path, NULL, CHF_CREATE_FLAG) ||
+       ha_create_table(thd, path, db, table_name, create_info, frm))
+    {
+      file->ha_create_partitioning_metadata(path, NULL, CHF_DELETE_FLAG);
+      goto err_handler;
+    }
+  }
+  else
+  {
+    if (writefrm(path, db, table_name, false, frm->str, frm->length))
+      goto err_handler;
+  }
 
-  // Make sure mysql_create_frm din't remove extension
-  DBUG_ASSERT(*fn_rext(frm_name));
-  if (thd->variables.keep_files_on_create)
-    create_info->options|= HA_CREATE_KEEP_FILES;
-  if (!create_info->frm_only &&
-      (file->ha_create_handler_files(path, NULL, CHF_CREATE_FLAG,
-                                     create_info) ||
-       ha_create_table(thd, path, db, table_name, create_info, 0)))
-    goto err_handler;
   DBUG_RETURN(0);
 
 err_handler:
-  (void) file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info);
+  char frm_name[FN_REFLEN];
+  strxmov(frm_name, path, reg_ext, NullS);
   mysql_file_delete(key_file_frm, frm_name, MYF(0));
   DBUG_RETURN(1);
 } /* rea_create_table */
 
 
-	/* Pack screens to a screen for save in a form-file */
-
-static uchar *pack_screens(List<Create_field> &create_fields,
-                           uint *info_length, uint *screens,
-                           bool small_file)
-{
-  reg1 uint i;
-  uint row,start_row,end_row,fields_on_screen;
-  uint length,cols;
-  uchar *info,*pos,*start_screen;
-  uint fields=create_fields.elements;
-  List_iterator<Create_field> it(create_fields);
-  DBUG_ENTER("pack_screens");
-
-  start_row=4; end_row=22; cols=80; fields_on_screen=end_row+1-start_row;
-
-  *screens=(fields-1)/fields_on_screen+1;
-  length= (*screens) * (SC_INFO_LENGTH+ (cols>> 1)+4);
-
-  Create_field *field;
-  while ((field=it++))
-    length+=(uint) strlen(field->field_name)+1+TE_INFO_LENGTH+cols/2;
-
-  if (!(info=(uchar*) my_malloc(length,MYF(MY_WME | MY_THREAD_SPECIFIC))))
-    DBUG_RETURN(0);
-
-  start_screen=0;
-  row=end_row;
-  pos=info;
-  it.rewind();
-  for (i=0 ; i < fields ; i++)
-  {
-    Create_field *cfield=it++;
-    if (row++ == end_row)
-    {
-      if (i)
-      {
-	length=(uint) (pos-start_screen);
-	int2store(start_screen,length);
-	start_screen[2]=(uchar) (fields_on_screen+1);
-	start_screen[3]=(uchar) (fields_on_screen);
-      }
-      row=start_row;
-      start_screen=pos;
-      pos+=4;
-      pos[0]= (uchar) start_row-2;	/* Header string */
-      pos[1]= (uchar) (cols >> 2);
-      pos[2]= (uchar) (cols >> 1) +1;
-      strfill((char *) pos+3,(uint) (cols >> 1),' ');
-      pos+=(cols >> 1)+4;
-    }
-    length=(uint) strlen(cfield->field_name);
-    if (length > cols-3)
-      length=cols-3;
-
-    if (!small_file)
-    {
-      pos[0]=(uchar) row;
-      pos[1]=0;
-      pos[2]=(uchar) (length+1);
-      pos=(uchar*) strmake((char*) pos+3,cfield->field_name,length)+1;
-    }
-    cfield->row=(uint8) row;
-    cfield->col=(uint8) (length+1);
-    cfield->sc_length=(uint8) min(cfield->length,cols-(length+2));
-  }
-  length=(uint) (pos-start_screen);
-  int2store(start_screen,length);
-  start_screen[2]=(uchar) (row-start_row+2);
-  start_screen[3]=(uchar) (row-start_row+1);
-
-  *info_length=(uint) (pos-info);
-  DBUG_RETURN(info);
-} /* pack_screens */
-
-
-	/* Pack keyinfo and keynames to keybuff for save in form-file. */
+/* Pack keyinfo and keynames to keybuff for save in form-file. */
 
 static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo,
                       ulong data_offset)
@@ -669,12 +493,10 @@ static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo,
 } /* pack_keys */
 
 
-	/* Make formheader */
+/* Make formheader */
 
-static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
-			List<Create_field> &create_fields,
-                        uint info_length, uint screens, uint table_options,
-                        ulong data_offset, handler *file)
+static bool pack_header(uchar *forminfo, List<Create_field> &create_fields,
+                        uint table_options, ulong data_offset, handler *file)
 {
   uint length,int_count,int_length,no_empty, int_parts;
   uint time_stamp_pos,null_fields;
@@ -693,8 +515,7 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
   com_length=vcol_info_length=0;
   n_length=2L;
 
-	/* Check fields */
-
+  /* Check fields */
   List_iterator<Create_field> it(create_fields);
   Create_field *field;
   while ((field=it++))
@@ -706,20 +527,14 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
                                                      COLUMN_COMMENT_MAXLEN);
     if (tmp_len < field->comment.length)
     {
-      if (current_thd->is_strict_mode())
-      {
-        my_error(ER_TOO_LONG_FIELD_COMMENT, MYF(0), field->field_name,
-                 static_cast<ulong>(COLUMN_COMMENT_MAXLEN));
+      myf myf_warning= current_thd->is_strict_mode() ? 0 : ME_JUST_WARNING;
+
+      my_error(ER_TOO_LONG_FIELD_COMMENT, myf_warning, field->field_name,
+               COLUMN_COMMENT_MAXLEN);
+
+      if (!myf_warning)
 	DBUG_RETURN(1);
-      }
-      char warn_buff[MYSQL_ERRMSG_SIZE];
-      my_snprintf(warn_buff, sizeof(warn_buff), ER(ER_TOO_LONG_FIELD_COMMENT),
-                  field->field_name,
-                  static_cast<ulong>(COLUMN_COMMENT_MAXLEN));
-      /* do not push duplicate warnings */
-      if (!check_duplicate_warning(current_thd, warn_buff, strlen(warn_buff)))
-        push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
-                     ER_TOO_LONG_FIELD_COMMENT, warn_buff);
+
       field->comment.length= tmp_len;
     }
     if (field->vcol_info)
@@ -745,7 +560,7 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
         expressions saved in the frm file for virtual columns.
       */
       vcol_info_length+= field->vcol_info->expr_str.length+
-	                 FRM_VCOL_HEADER_SIZE(field->interval!=NULL);
+	                 FRM_VCOL_HEADER_SIZE(field->interval);
     }
 
     totlength+= field->length;
@@ -822,8 +637,7 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
   }
   int_length+=int_count*2;			// 255 prefix + 0 suffix
 
-	/* Save values in forminfo */
-
+  /* Save values in forminfo */
   if (reclength > (ulong) file->max_record_length())
   {
     my_error(ER_TOO_BIG_ROWSIZE, MYF(0), static_cast<long>(file->max_record_length()));
@@ -831,7 +645,7 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
   }
   /* Hack to avoid bugs with small static rows in MySQL */
   reclength=max(file->min_record_length(table_options),reclength);
-  if (info_length+(ulong) create_fields.elements*FCOMP+288+
+  if ((ulong) create_fields.elements*FCOMP+FRM_FORMINFO_SIZE+
       n_length+int_length+com_length+vcol_info_length > 65535L || 
       int_count > 255)
   {
@@ -839,13 +653,13 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
     DBUG_RETURN(1);
   }
 
-  bzero((char*)forminfo,288);
-  length=(info_length+create_fields.elements*FCOMP+288+n_length+int_length+
+  bzero((char*)forminfo,FRM_FORMINFO_SIZE);
+  length=(create_fields.elements*FCOMP+FRM_FORMINFO_SIZE+n_length+int_length+
 	  com_length+vcol_info_length);
   int2store(forminfo,length);
-  forminfo[256] = (uint8) screens;
+  forminfo[256] = 0;
   int2store(forminfo+258,create_fields.elements);
-  int2store(forminfo+260,info_length);
+  int2store(forminfo+260,0);
   int2store(forminfo+262,totlength);
   int2store(forminfo+264,no_empty);
   int2store(forminfo+266,reclength);
@@ -859,13 +673,11 @@ static bool pack_header(uchar *forminfo, enum legacy_db_type table_type,
   int2store(forminfo+282,null_fields);
   int2store(forminfo+284,com_length);
   int2store(forminfo+286,vcol_info_length);
-  /* forminfo+288 is free to use for additional information */
   DBUG_RETURN(0);
 } /* pack_header */
 
 
-	/* get each unique interval each own id */
-
+/* get each unique interval each own id */
 static uint get_interval_id(uint *int_count,List<Create_field> &create_fields,
 			    Create_field *last_field)
 {
@@ -892,29 +704,57 @@ static uint get_interval_id(uint *int_count,List<Create_field> &create_fields,
 }
 
 
-	/* Save fields, fieldnames and intervals */
+static size_t packed_fields_length(List<Create_field> &create_fields)
+{
+  Create_field *field;
+  size_t length= 0;
+  DBUG_ENTER("packed_fields_length");
 
-static bool pack_fields(File file, List<Create_field> &create_fields,
+  List_iterator<Create_field> it(create_fields);
+  uint int_count=0;
+  while ((field=it++))
+  {
+    if (field->interval_id > int_count)
+    {
+      int_count= field->interval_id;
+      length++;
+      for (int i=0; field->interval->type_names[i]; i++)
+      {
+        length+= field->interval->type_lengths[i];
+        length++;
+      }
+      length++;
+    }
+    if (field->vcol_info)
+    {
+      length+= field->vcol_info->expr_str.length +
+               FRM_VCOL_HEADER_SIZE(field->interval);
+    }
+    length+= FCOMP;
+    length+= strlen(field->field_name)+1;
+    length+= field->comment.length;
+  }
+  length++;
+  length++;
+  DBUG_RETURN(length);
+}
+
+/* Save fields, fieldnames and intervals */
+
+static bool pack_fields(uchar *buff, List<Create_field> &create_fields,
                         ulong data_offset)
 {
-  reg2 uint i;
   uint int_count, comment_length= 0, vcol_info_length=0;
-  uchar buff[MAX_FIELD_WIDTH];
   Create_field *field;
   DBUG_ENTER("pack_fields");
 
-	/* Write field info */
-
+  /* Write field info */
   List_iterator<Create_field> it(create_fields);
-
   int_count=0;
   while ((field=it++))
   {
     uint recpos;
     uint cur_vcol_expr_len= 0;
-    buff[0]= (uchar) field->row;
-    buff[1]= (uchar) field->col;
-    buff[2]= (uchar) field->sc_length;
     int2store(buff+3, field->length);
     /* The +1 is here becasue the col offset in .frm file have offset 1 */
     recpos= field->offset+1 + (uint) data_offset;
@@ -948,40 +788,29 @@ static bool pack_fields(File file, List<Create_field> &create_fields,
         the additional data saved for the virtual field
       */
       buff[12]= cur_vcol_expr_len= field->vcol_info->expr_str.length +
-	                           FRM_VCOL_HEADER_SIZE(field->interval!=NULL);
-      vcol_info_length+= cur_vcol_expr_len + 
-	                 FRM_VCOL_HEADER_SIZE(field->interval!=NULL);
+	                           FRM_VCOL_HEADER_SIZE(field->interval);
+      vcol_info_length+= cur_vcol_expr_len;
       buff[13]= (uchar) MYSQL_TYPE_VIRTUAL;
     }
     int2store(buff+15, field->comment.length);
     comment_length+= field->comment.length;
     set_if_bigger(int_count,field->interval_id);
-    if (mysql_file_write(file, buff, FCOMP, MYF_RW))
-      DBUG_RETURN(1);
+    buff+= FCOMP;
   }
 
-	/* Write fieldnames */
-  buff[0]=(uchar) NAMES_SEP_CHAR;
-  if (mysql_file_write(file, buff, 1, MYF_RW))
-    DBUG_RETURN(1);
-  i=0;
+  /* Write fieldnames */
+  *buff++= NAMES_SEP_CHAR;
   it.rewind();
   while ((field=it++))
   {
-    char *pos= strmov((char*) buff,field->field_name);
-    *pos++=NAMES_SEP_CHAR;
-    if (i == create_fields.elements-1)
-      *pos++=0;
-    if (mysql_file_write(file, buff, (size_t) (pos-(char*) buff), MYF_RW))
-      DBUG_RETURN(1);
-    i++;
+    buff= (uchar*)strmov((char*) buff, field->field_name);
+    *buff++=NAMES_SEP_CHAR;
   }
+  *buff++= 0;
 
-	/* Write intervals */
+  /* Write intervals */
   if (int_count)
   {
-    String tmp((char*) buff,sizeof(buff), &my_charset_bin);
-    tmp.length(0);
     it.rewind();
     int_count=0;
     while ((field=it++))
@@ -1023,34 +852,30 @@ static bool pack_fields(File file, List<Create_field> &create_fields,
         }
 
         int_count= field->interval_id;
-        tmp.append(sep);
-        for (const char **pos=field->interval->type_names ; *pos ; pos++)
+        *buff++= sep;
+        for (int i=0; field->interval->type_names[i]; i++)
         {
-          tmp.append(*pos);
-          tmp.append(sep);
+          memcpy(buff, field->interval->type_names[i], field->interval->type_lengths[i]);
+          buff+= field->interval->type_lengths[i];
+          *buff++= sep;
         }
-        tmp.append('\0');                      // End of intervall
+        *buff++= 0;
+        
       }
     }
-    if (mysql_file_write(file, (uchar*) tmp.ptr(), tmp.length(), MYF_RW))
-      DBUG_RETURN(1);
   }
   if (comment_length)
   {
     it.rewind();
-    int_count=0;
     while ((field=it++))
     {
-      if (field->comment.length)
-        if (mysql_file_write(file, (uchar*) field->comment.str,
-                             field->comment.length, MYF_RW))
-	  DBUG_RETURN(1);
+      memcpy(buff, field->comment.str, field->comment.length);
+      buff+= field->comment.length;
     }
   }
   if (vcol_info_length)
   {
     it.rewind();
-    int_count=0;
     while ((field=it++))
     {
       /*
@@ -1063,18 +888,13 @@ static bool pack_fields(File file, List<Create_field> &create_fields,
       */
       if (field->vcol_info && field->vcol_info->expr_str.length)
       {
-        buff[0]= (uchar)(1 + test(field->interval_id));
-        buff[1]= (uchar) field->sql_type;
-        buff[2]= (uchar) field->stored_in_db;
-        if (field->interval_id)
-          buff[3]= (uchar) field->interval_id;
-      if (my_write(file, buff, 3 + test(field->interval_id), MYF_RW))
-          DBUG_RETURN(1);
-        if (my_write(file,
-                     (uchar*) field->vcol_info->expr_str.str,
-                     field->vcol_info->expr_str.length,
-                     MYF_RW))
-          DBUG_RETURN(1);
+        *buff++= (uchar)(1 + test(field->interval));
+        *buff++= (uchar) field->sql_type;
+        *buff++= (uchar) field->stored_in_db;
+        if (field->interval)
+          *buff++= (uchar) field->interval_id;
+        memcpy(buff, field->vcol_info->expr_str.str, field->vcol_info->expr_str.length);
+        buff+= field->vcol_info->expr_str.length;
       }
     }
   }
@@ -1082,19 +902,16 @@ static bool pack_fields(File file, List<Create_field> &create_fields,
 }
 
 
-	/* save an empty record on start of formfile */
+/* save an empty record on start of formfile */
 
-static bool make_empty_rec(THD *thd, File file,enum legacy_db_type table_type,
-			   uint table_options,
+static bool make_empty_rec(THD *thd, uchar *buff, uint table_options,
 			   List<Create_field> &create_fields,
-			   uint reclength,
-                           ulong data_offset,
-                           handler *handler)
+			   uint reclength, ulong data_offset)
 {
   int error= 0;
   Field::utype type;
   uint null_count;
-  uchar *buff,*null_pos;
+  uchar *null_pos;
   TABLE table;
   TABLE_SHARE share;
   Create_field *field;
@@ -1106,13 +923,6 @@ static bool make_empty_rec(THD *thd, File file,enum legacy_db_type table_type,
   bzero((char*) &share, sizeof(share));
   table.s= &share;
 
-  if (!(buff=(uchar*) my_malloc((size_t) reclength,
-                                MYF(MY_WME | MY_ZEROFILL |
-                                    MY_THREAD_SPECIFIC))))
-  {
-    DBUG_RETURN(1);
-  }
-
   table.in_use= thd;
   table.s->blob_ptr_size= portable_sizeof_char_ptr;
 
@@ -1198,10 +1008,7 @@ static bool make_empty_rec(THD *thd, File file,enum legacy_db_type table_type,
   if (null_count & 7)
     *(null_pos + null_count / 8)|= ~(((uchar) 1 << (null_count & 7)) - 1);
 
-  error= mysql_file_write(file, buff, (size_t) reclength, MYF_RW) != 0;
-
 err:
-  my_free(buff);
   thd->count_cuted_fields= old_count_cuted_fields;
   DBUG_RETURN(error);
 } /* make_empty_rec */
diff --git a/sql/unireg.h b/sql/unireg.h
index da510bb4e6d..5e232becbb2 100644
--- a/sql/unireg.h
+++ b/sql/unireg.h
@@ -23,8 +23,6 @@
 
 /*  Extra functions used by unireg library */
 
-typedef struct st_ha_create_information HA_CREATE_INFO;
-
 #ifndef NO_ALARM_LOOP
 #define NO_ALARM_LOOP		/* lib5 and popen can't use alarm */
 #endif
@@ -88,7 +86,7 @@ typedef struct st_ha_create_information HA_CREATE_INFO;
 #define READ_ALL		1	/* openfrm: Read all parameters */
 #define CHANGE_FRM		2	/* openfrm: open .frm as O_RDWR */
 #define READ_KEYINFO		4	/* L{s nyckeldata fr}n filen */
-#define EXTRA_RECORD		8	/* Reservera plats f|r extra record */
+#define EXTRA_RECORD		8	/* Reserve space for an extra record */
 #define DONT_OPEN_TABLES	8	/* Don't open database-files (frd) */
 #define DONT_OPEN_MASTER_REG	16	/* Don't open first reg-file (prt) */
 #define EXTRA_LONG_RECORD	16	/* Plats f|r dubbel s|k-record */
@@ -169,15 +167,44 @@ typedef struct st_ha_create_information HA_CREATE_INFO;
 #include "sql_list.h"                           /* List<> */
 #include "field.h"                              /* Create_field */
 
-bool mysql_create_frm(THD *thd, const char *file_name,
-                      const char *db, const char *table,
-		      HA_CREATE_INFO *create_info,
-		      List<Create_field> &create_field,
-		      uint key_count,KEY *key_info,handler *db_type);
-int rea_create_table(THD *thd, const char *path,
-                     const char *db, const char *table_name,
-                     HA_CREATE_INFO *create_info,
-  		     List<Create_field> &create_field,
-                     uint key_count,KEY *key_info,
-                     handler *file);
+/*
+  Types of values in the MariaDB extra2 frm segment.
+  Each value is written as
+    type:       1 byte
+    length:     1 byte  (1..255) or \0 and 2 bytes.
+    binary value of the 'length' bytes.
+
+  Older MariaDB servers can ignore values of unknown types if
+  the type code is less than 128 (EXTRA2_ENGINE_IMPORTANT).
+  Otherwise older (but newer than 10.0.1) servers are required
+  to report an error.
+*/
+enum extra2_frm_value_type {
+  EXTRA2_TABLEDEF_VERSION=0,
+
+#define EXTRA2_ENGINE_IMPORTANT 128
+
+  EXTRA2_ENGINE_TABLEOPTS=128,
+};
+
+int rea_create_table(THD *thd, LEX_CUSTRING *frm,
+                     const char *path, const char *db, const char *table_name,
+                     HA_CREATE_INFO *create_info, handler *file);
+LEX_CUSTRING build_frm_image(THD *thd, const char *table,
+                             HA_CREATE_INFO *create_info,
+                             List<Create_field> &create_fields,
+                             uint keys, KEY *key_info, handler *db_file);
+
+#define FRM_HEADER_SIZE 64
+#define FRM_FORMINFO_SIZE 288
+#define FRM_MAX_SIZE (256*1024)
+
+static inline bool is_binary_frm_header(uchar *head)
+{
+  return head[0] == 254
+      && head[1] == 1
+      && head[2] >= FRM_VER
+      && head[2] <= FRM_VER+4;
+}
+
 #endif