Manual merge of parallel development in separate team trees.

client/mysqldump.c:
  Auto merged
sql/event_db_repository.cc:
  Auto merged
sql/event_queue.cc:
  Auto merged
sql/field.cc:
  Auto merged
sql/item.cc:
  Auto merged
sql/item_subselect.cc:
  Auto merged
sql/log_event.h:
  Auto merged
sql/sp.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_db.cc:
  Auto merged
sql/sql_handler.cc:
  Auto merged
sql/sql_lex.cc:
  Auto merged
sql/sql_plugin.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_show.cc:
  Auto merged
sql/table.h:
  Auto merged
sql/sql_yacc.yy:
  Manual merge.

54 files changed, 793 insertions, 532 deletions

diff --git a/sql/CMakeLists.txt b/sql/CMakeLists.txt
index 1400c1487d0..a0c00e868e5 100755
--- a/sql/CMakeLists.txt
+++ b/sql/CMakeLists.txt
@@ -28,9 +28,9 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include
 )
 
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_SOURCE_DIR}/sql/message.rc 
-							${CMAKE_SOURCE_DIR}/sql/message.h 
-							${CMAKE_SOURCE_DIR}/sql/sql_yacc.h 
-							${CMAKE_SOURCE_DIR}/sql/sql_yacc.cc
+                            ${CMAKE_SOURCE_DIR}/sql/message.h 
+                            ${CMAKE_SOURCE_DIR}/sql/sql_yacc.h 
+                            ${CMAKE_SOURCE_DIR}/sql/sql_yacc.cc
                             ${CMAKE_SOURCE_DIR}/include/mysql_version.h
                             ${CMAKE_SOURCE_DIR}/sql/sql_builtin.cc
                             ${CMAKE_SOURCE_DIR}/sql/lex_hash.h 
@@ -41,8 +41,8 @@ SET_SOURCE_FILES_PROPERTIES(${CMAKE_SOURCE_DIR}/sql/message.rc
 
 ADD_DEFINITIONS(-DMYSQL_SERVER -D_CONSOLE -DHAVE_DLOPEN)
 
-ADD_EXECUTABLE(mysqld${MYSQLD_EXE_SUFFIX}
-	       ../sql-common/client.c derror.cc des_key_file.cc
+ADD_EXECUTABLE(mysqld
+               ../sql-common/client.c derror.cc des_key_file.cc
                discover.cc ../libmysql/errmsg.c field.cc field_conv.cc 
                filesort.cc gstream.cc
                ha_partition.cc
@@ -74,74 +74,91 @@ ADD_EXECUTABLE(mysqld${MYSQLD_EXE_SUFFIX}
                sql_tablespace.cc events.cc ../sql-common/my_user.c 
                partition_info.cc rpl_utility.cc rpl_injector.cc sql_locale.cc
                rpl_rli.cc rpl_mi.cc sql_servers.cc
-	       sql_connect.cc scheduler.cc 
+               sql_connect.cc scheduler.cc 
                ${PROJECT_SOURCE_DIR}/sql/sql_yacc.cc
-  			   ${PROJECT_SOURCE_DIR}/sql/sql_yacc.h
-			   ${PROJECT_SOURCE_DIR}/include/mysqld_error.h
-			   ${PROJECT_SOURCE_DIR}/include/mysqld_ername.h 
-			   ${PROJECT_SOURCE_DIR}/include/sql_state.h
-			   ${PROJECT_SOURCE_DIR}/include/mysql_version.h 
-			   ${PROJECT_SOURCE_DIR}/sql/sql_builtin.cc
-			   ${PROJECT_SOURCE_DIR}/sql/lex_hash.h)
-TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX}
-		      heap myisam myisammrg mysys yassl zlib debug dbug yassl 
+               ${PROJECT_SOURCE_DIR}/sql/sql_yacc.h
+               ${PROJECT_SOURCE_DIR}/include/mysqld_error.h
+               ${PROJECT_SOURCE_DIR}/include/mysqld_ername.h 
+               ${PROJECT_SOURCE_DIR}/include/sql_state.h
+               ${PROJECT_SOURCE_DIR}/include/mysql_version.h 
+               ${PROJECT_SOURCE_DIR}/sql/sql_builtin.cc
+               ${PROJECT_SOURCE_DIR}/sql/lex_hash.h)
+
+TARGET_LINK_LIBRARIES(mysqld
+                      heap myisam myisammrg mysys yassl zlib debug dbug yassl 
                       taocrypt strings vio regex wsock32 ws2_32)
 
+SET_TARGET_PROPERTIES(mysqld PROPERTIES OUTPUT_NAME mysqld${MYSQLD_EXE_SUFFIX})
+
+# Work around for 2.4.6 bug, OUTPUT_NAME will not set the right .PDB
+# file name. Note that COMPILE_FLAGS set some temporary pdb during build,
+# LINK_FLAGS sets the real one.
+SET_TARGET_PROPERTIES(mysqld PROPERTIES
+                      COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/mysqld${MYSQLD_EXE_SUFFIX}.pdb"
+                      LINK_FLAGS  "/PDB:${CMAKE_CFG_INTDIR}/mysqld${MYSQLD_EXE_SUFFIX}.pdb")
+
 IF(EMBED_MANIFESTS)
   MYSQL_EMBED_MANIFEST("mysqld" "asInvoker")
 ENDIF(EMBED_MANIFESTS)
 IF(WITH_ARCHIVE_STORAGE_ENGINE)
-  TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX} archive)
+  TARGET_LINK_LIBRARIES(mysqld archive)
 ENDIF(WITH_ARCHIVE_STORAGE_ENGINE)
 IF(WITH_BLACKHOLE_STORAGE_ENGINE)
-  TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX} blackhole)
+  TARGET_LINK_LIBRARIES(mysqld blackhole)
 ENDIF(WITH_BLACKHOLE_STORAGE_ENGINE)
 IF(WITH_CSV_STORAGE_ENGINE)
-  TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX} csv)
+  TARGET_LINK_LIBRARIES(mysqld csv)
 ENDIF(WITH_CSV_STORAGE_ENGINE)
 IF(WITH_EXAMPLE_STORAGE_ENGINE)
-  TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX} example)
+  TARGET_LINK_LIBRARIES(mysqld example)
 ENDIF(WITH_EXAMPLE_STORAGE_ENGINE)
 IF(WITH_FEDERATED_STORAGE_ENGINE)
-  TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX} federated)
+  TARGET_LINK_LIBRARIES(mysqld federated)
 ENDIF(WITH_FEDERATED_STORAGE_ENGINE)
 IF(WITH_INNOBASE_STORAGE_ENGINE)
-  TARGET_LINK_LIBRARIES(mysqld${MYSQLD_EXE_SUFFIX} innobase)
+  TARGET_LINK_LIBRARIES(mysqld innobase)
 ENDIF(WITH_INNOBASE_STORAGE_ENGINE)
 
-ADD_DEPENDENCIES(mysqld${MYSQLD_EXE_SUFFIX} GenError)
+ADD_DEPENDENCIES(mysqld GenError)
+
+# NOTE CMake 2.4.6 creates strange dependencies between files in OUTPUT,
+# so for now we only list one if more than one
 
 # Sql Parser custom command
 ADD_CUSTOM_COMMAND(
-	SOURCE ${PROJECT_SOURCE_DIR}/sql/sql_yacc.yy 
-	OUTPUT ${PROJECT_SOURCE_DIR}/sql/sql_yacc.cc
-	COMMAND bison.exe ARGS -y -p MYSQL --defines=sql_yacc.h	
-	                       --output=sql_yacc.cc sql_yacc.yy
-	DEPENDS ${PROJECT_SOURCE_DIR}/sql/sql_yacc.yy)
+        OUTPUT ${PROJECT_SOURCE_DIR}/sql/sql_yacc.h
+#              ${PROJECT_SOURCE_DIR}/sql/sql_yacc.cc
+        COMMAND bison.exe ARGS -y -p MYSQL --defines=sql_yacc.h
+                               --output=sql_yacc.cc sql_yacc.yy
+        DEPENDS ${PROJECT_SOURCE_DIR}/sql/sql_yacc.yy)
 
-ADD_CUSTOM_COMMAND(
-	OUTPUT ${PROJECT_SOURCE_DIR}/sql/sql_yacc.h
-	COMMAND echo
-	DEPENDS ${PROJECT_SOURCE_DIR}/sql/sql_yacc.cc
-)
-
-# Windows message file
-ADD_CUSTOM_COMMAND(
-	SOURCE message.mc
-	OUTPUT message.rc message.h
-	COMMAND mc ARGS message.mc
-	DEPENDS message.mc)
+IF(WIN32)
+  # Windows message file
+  ADD_CUSTOM_COMMAND(
+          OUTPUT ${PROJECT_SOURCE_DIR}/sql/message.h
+#                ${PROJECT_SOURCE_DIR}/sql/message.rc
+          COMMAND mc ARGS message.mc
+          DEPENDS ${PROJECT_SOURCE_DIR}/sql/message.mc)
+ENDIF(WIN32)
 
 # Gen_lex_hash
 ADD_EXECUTABLE(gen_lex_hash gen_lex_hash.cc)
-TARGET_LINK_LIBRARIES(gen_lex_hash dbug mysqlclient wsock32)
+TARGET_LINK_LIBRARIES(gen_lex_hash debug dbug mysqlclient wsock32)
 GET_TARGET_PROPERTY(GEN_LEX_HASH_EXE gen_lex_hash LOCATION)
 ADD_CUSTOM_COMMAND(
-	OUTPUT ${PROJECT_SOURCE_DIR}/sql/lex_hash.h
-	COMMAND ${GEN_LEX_HASH_EXE} ARGS > lex_hash.h
-	DEPENDS ${GEN_LEX_HASH_EXE}
-)
-ADD_DEPENDENCIES(mysqld${MYSQLD_EXE_SUFFIX} gen_lex_hash)
+        OUTPUT ${PROJECT_SOURCE_DIR}/sql/lex_hash.h
+        COMMAND ${GEN_LEX_HASH_EXE} ARGS > lex_hash.h
+        DEPENDS ${GEN_LEX_HASH_EXE})
+
+ADD_CUSTOM_TARGET(
+        GenServerSource ALL
+        DEPENDS ${PROJECT_SOURCE_DIR}/sql/sql_yacc.h
+#               ${PROJECT_SOURCE_DIR}/sql/sql_yacc.cc
+                ${PROJECT_SOURCE_DIR}/sql/message.h
+#               ${PROJECT_SOURCE_DIR}/sql/message.rc
+                ${PROJECT_SOURCE_DIR}/sql/lex_hash.h)
+
+ADD_DEPENDENCIES(mysqld GenServerSource)
 
 # Remove the auto-generated files as part of 'Clean Solution'
 SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES 
diff --git a/sql/event_db_repository.cc b/sql/event_db_repository.cc
index 37afbabad43..705bd8b2704 100644
--- a/sql/event_db_repository.cc
+++ b/sql/event_db_repository.cc
@@ -395,8 +395,9 @@ Event_db_repository::index_read_for_db_for_i_s(THD *thd, TABLE *schema_table,
   }
 
   key_copy(key_buf, event_table->record[0], key_info, key_len);
-  if (!(ret= event_table->file->index_read(event_table->record[0], key_buf,
-                                           (key_part_map)1, HA_READ_PREFIX)))
+  if (!(ret= event_table->file->index_read_map(event_table->record[0], key_buf,
+                                               (key_part_map)1,
+                                               HA_READ_PREFIX)))
   {
     DBUG_PRINT("info",("Found rows. Let's retrieve them. ret=%d", ret));
     do
@@ -844,8 +845,8 @@ Event_db_repository::find_named_event(LEX_STRING db, LEX_STRING name,
 
   key_copy(key, table->record[0], table->key_info, table->key_info->key_length);
 
-  if (table->file->index_read_idx(table->record[0], 0, key, HA_WHOLE_KEY,
-                                  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0], 0, key, HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
   {
     DBUG_PRINT("info", ("Row not found"));
     DBUG_RETURN(TRUE);
diff --git a/sql/event_queue.cc b/sql/event_queue.cc
index 71ae5c7652f..898fc206c34 100644
--- a/sql/event_queue.cc
+++ b/sql/event_queue.cc
@@ -56,8 +56,9 @@
     execute_at.second_part is not considered during comparison
 */
 
-static int
-event_queue_element_compare_q(void *vptr, uchar* a, uchar *b)
+extern "C" int event_queue_element_compare_q(void *, uchar *, uchar *);
+
+int event_queue_element_compare_q(void *vptr, uchar* a, uchar *b)
 {
   my_time_t lhs = ((Event_queue_element *)a)->execute_at;
   my_time_t rhs = ((Event_queue_element *)b)->execute_at;
diff --git a/sql/field.cc b/sql/field.cc
index 37262f8c38c..8e869484dda 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -6298,12 +6298,12 @@ uint Field::is_equal(Create_field *new_field)
 
 /* If one of the fields is binary and the other one isn't return 1 else 0 */
 
-bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flags)
+bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flag_arg)
 {
   return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
-          !(flags & (BINCMP_FLAG | BINARY_FLAG))) ||
+          !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
          (!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
-          (flags & (BINCMP_FLAG | BINARY_FLAG))));
+          (flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
 }
 
 
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index d46b3a3bb08..6521be1cb9a 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -1125,7 +1125,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
     0                          Success
 */
 
-int ha_partition::prepare_new_partition(TABLE *table,
+int ha_partition::prepare_new_partition(TABLE *tbl,
                                         HA_CREATE_INFO *create_info,
                                         handler *file, const char *part_name,
                                         partition_element *p_elem)
@@ -1134,13 +1134,13 @@ int ha_partition::prepare_new_partition(TABLE *table,
   bool create_flag= FALSE;
   DBUG_ENTER("prepare_new_partition");
 
-  if ((error= set_up_table_before_create(table, part_name, create_info,
+  if ((error= set_up_table_before_create(tbl, part_name, create_info,
                                          0, p_elem)))
     goto error;
-  if ((error= file->create(part_name, table, create_info)))
+  if ((error= file->create(part_name, tbl, create_info)))
     goto error;
   create_flag= TRUE;
-  if ((error= file->ha_open(table, part_name, m_mode, m_open_test_lock)))
+  if ((error= file->ha_open(tbl, part_name, m_mode, m_open_test_lock)))
     goto error;
   /*
     Note: if you plan to add another call that may return failure,
@@ -1776,7 +1776,7 @@ partition_element *ha_partition::find_partition_element(uint part_id)
      4) Data file name on partition
 */
 
-int ha_partition::set_up_table_before_create(TABLE *table,
+int ha_partition::set_up_table_before_create(TABLE *tbl,
                     const char *partition_name_with_path, 
                     HA_CREATE_INFO *info,
                     uint part_id,
@@ -1793,8 +1793,8 @@ int ha_partition::set_up_table_before_create(TABLE *table,
     if (!part_elem)
       DBUG_RETURN(1);                             // Fatal error
   }
-  table->s->max_rows= part_elem->part_max_rows;
-  table->s->min_rows= part_elem->part_min_rows;
+  tbl->s->max_rows= part_elem->part_max_rows;
+  tbl->s->min_rows= part_elem->part_min_rows;
   partition_name= strrchr(partition_name_with_path, FN_LIBCHAR);
   if ((part_elem->index_file_name &&
       (error= append_file_to_dir(thd,
@@ -3400,11 +3400,11 @@ int ha_partition::index_end()
     used in conjuntion with multi read ranges.
 */
 
-int ha_partition::index_read(uchar * buf, const uchar * key,
-                             key_part_map keypart_map,
-                             enum ha_rkey_function find_flag)
+int ha_partition::index_read_map(uchar *buf, const uchar *key,
+                                 key_part_map keypart_map,
+                                 enum ha_rkey_function find_flag)
 {
-  DBUG_ENTER("ha_partition::index_read");
+  DBUG_ENTER("ha_partition::index_read_map");
 
   end_range= 0;
   m_index_scan_type= partition_index_read;
@@ -3566,7 +3566,7 @@ int ha_partition::common_first_last(uchar *buf)
     index_read_last()
     buf                   Read row in MySQL Row Format
     key                   Key
-    keylen                Length of key
+    keypart_map           Which part of key is used
 
   RETURN VALUE
     >0                    Error code
@@ -3577,8 +3577,8 @@ int ha_partition::common_first_last(uchar *buf)
     Can only be used on indexes supporting HA_READ_ORDER
 */
 
-int ha_partition::index_read_last(uchar *buf, const uchar *key,
-                                  key_part_map keypart_map)
+int ha_partition::index_read_last_map(uchar *buf, const uchar *key,
+                                      key_part_map keypart_map)
 {
   DBUG_ENTER("ha_partition::index_read_last");
 
@@ -3929,9 +3929,9 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
     switch (m_index_scan_type) {
     case partition_index_read:
       DBUG_PRINT("info", ("index_read on partition %d", i));
-      error= file->index_read(buf, m_start_key.key,
-                              m_start_key.keypart_map,
-                              m_start_key.flag);
+      error= file->index_read_map(buf, m_start_key.key,
+                                  m_start_key.keypart_map,
+                                  m_start_key.flag);
       break;
     case partition_index_first:
       DBUG_PRINT("info", ("index_first on partition %d", i));
@@ -4020,10 +4020,10 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
 
     switch (m_index_scan_type) {
     case partition_index_read:
-      error= file->index_read(rec_buf_ptr,
-                              m_start_key.key,
-                              m_start_key.keypart_map,
-                              m_start_key.flag);
+      error= file->index_read_map(rec_buf_ptr,
+                                  m_start_key.key,
+                                  m_start_key.keypart_map,
+                                  m_start_key.flag);
       break;
     case partition_index_first:
       error= file->index_first(rec_buf_ptr);
@@ -4034,9 +4034,9 @@ int ha_partition::handle_ordered_index_scan(uchar *buf, bool reverse_order)
       reverse_order= TRUE;
       break;
     case partition_index_read_last:
-      error= file->index_read_last(rec_buf_ptr,
-                                   m_start_key.key,
-                                   m_start_key.keypart_map);
+      error= file->index_read_last_map(rec_buf_ptr,
+                                       m_start_key.key,
+                                       m_start_key.keypart_map);
       reverse_order= TRUE;
       break;
     default:
diff --git a/sql/ha_partition.h b/sql/ha_partition.h
index 895f001fa6a..555f7a72740 100644
--- a/sql/ha_partition.h
+++ b/sql/ha_partition.h
@@ -387,9 +387,9 @@ public:
     index_init initializes an index before using it and index_end does
     any end processing needed.
   */
-  virtual int index_read(uchar * buf, const uchar * key,
-                         key_part_map keypart_map,
-                         enum ha_rkey_function find_flag);
+  virtual int index_read_map(uchar * buf, const uchar * key,
+                             key_part_map keypart_map,
+                             enum ha_rkey_function find_flag);
   virtual int index_init(uint idx, bool sorted);
   virtual int index_end();
 
@@ -402,8 +402,8 @@ public:
   virtual int index_first(uchar * buf);
   virtual int index_last(uchar * buf);
   virtual int index_next_same(uchar * buf, const uchar * key, uint keylen);
-  virtual int index_read_last(uchar * buf, const uchar * key,
-                              key_part_map keypart_map);
+  virtual int index_read_last_map(uchar * buf, const uchar * key,
+                                  key_part_map keypart_map);
 
   /*
     read_first_row is virtual method but is only implemented by
diff --git a/sql/handler.cc b/sql/handler.cc
index 3e9524e9821..dbe7f6727f7 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -25,8 +25,6 @@
 
 #include "mysql_priv.h"
 #include "rpl_filter.h"
-
-
 #include <myisampack.h>
 #include <errno.h>
 
@@ -64,7 +62,7 @@ static const LEX_STRING sys_table_aliases[]=
 };
 
 const char *ha_row_type[] = {
-  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "?","?","?"
+  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "PAGE", "?","?","?"
 };
 
 const char *tx_isolation_names[] =
@@ -1993,9 +1991,9 @@ void handler::get_auto_increment(ulonglong offset, ulonglong increment,
     key_copy(key, table->record[0],
              table->key_info + table->s->next_number_index,
              table->s->next_number_key_offset);
-    error= index_read(table->record[1], key,
-                      make_prev_keypart_map(table->s->next_number_keypart),
-                      HA_READ_PREFIX_LAST);
+    error= index_read_map(table->record[1], key,
+                          make_prev_keypart_map(table->s->next_number_keypart),
+                          HA_READ_PREFIX_LAST);
     /*
       MySQL needs to call us for next row: assume we are inserting ("a",null)
       here, we return 3, and next this statement will want to insert
@@ -3218,10 +3216,10 @@ int handler::read_range_first(const key_range *start_key,
   if (!start_key)			// Read first record
     result= index_first(table->record[0]);
   else
-    result= index_read(table->record[0],
-		       start_key->key,
-                       start_key->keypart_map,
-		       start_key->flag);
+    result= index_read_map(table->record[0],
+                           start_key->key,
+                           start_key->keypart_map,
+                           start_key->flag);
   if (result)
     DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
 		? HA_ERR_END_OF_FILE
@@ -3293,15 +3291,15 @@ int handler::compare_key(key_range *range)
 }
 
 
-int handler::index_read_idx(uchar * buf, uint index, const uchar * key,
-                            key_part_map keypart_map,
-                            enum ha_rkey_function find_flag)
+int handler::index_read_idx_map(uchar * buf, uint index, const uchar * key,
+                                key_part_map keypart_map,
+                                enum ha_rkey_function find_flag)
 {
   int error, error1;
   error= index_init(index, 0);
   if (!error)
   {
-    error= index_read(buf, key, keypart_map, find_flag);
+    error= index_read_map(buf, key, keypart_map, find_flag);
     error1= index_end();
   }
   return error ?  error : error1;
diff --git a/sql/handler.h b/sql/handler.h
index 60e936bef5b..557b9fd7887 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -278,7 +278,7 @@ enum legacy_db_type
 
 enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
 		ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
-		ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT, ROW_TYPE_PAGES };
+		ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT, ROW_TYPE_PAGE };
 
 enum enum_binlog_func {
   BFN_RESET_LOGS=        1,
@@ -321,6 +321,7 @@ enum enum_binlog_command {
 #define HA_CREATE_USED_PASSWORD         (1L << 17)
 #define HA_CREATE_USED_CONNECTION       (1L << 18)
 #define HA_CREATE_USED_KEY_BLOCK_SIZE   (1L << 19)
+#define HA_CREATE_USED_TRANSACTIONAL    (1L << 20)
 
 typedef ulonglong my_xid; // this line is the same as in log_event.h
 #define MYSQL_XID_PREFIX "MySQLXid"
@@ -788,6 +789,7 @@ class partition_info;
 struct st_partition_iter;
 #define NOT_A_PARTITION_ID ((uint32)-1)
 
+enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES };
 
 typedef struct st_ha_create_information
 {
@@ -810,6 +812,8 @@ typedef struct st_ha_create_information
   uint options;				/* OR of HA_CREATE_ options */
   uint merge_insert_method;
   uint extra_size;                      /* length of extra data segment */
+  /* 0 not used, 1 if not transactional, 2 if transactional */
+  enum ha_choice transactional;
   bool table_existed;			/* 1 in create if table existed */
   bool frm_only;                        /* 1 if no ha_create_table() */
   bool varchar;                         /* 1 if table has a VARCHAR */
@@ -1277,27 +1281,28 @@ public:
                          enum ha_rkey_function find_flag)
    { return  HA_ERR_WRONG_COMMAND; }
   public:
-/**
-  @brief
-  Positions an index cursor to the index specified in the handle. Fetches the
-  row if available. If the key value is null, begin at the first key of the
-  index.
-*/
-  virtual int index_read(uchar * buf, const uchar * key, key_part_map keypart_map,
-                         enum ha_rkey_function find_flag)
-   {
-     uint key_len= calculate_key_len(table, active_index, key, keypart_map);
-     return  index_read(buf, key, key_len, find_flag);
-   }
-/**
-  @brief
-  Positions an index cursor to the index specified in the handle. Fetches the
-  row if available. If the key value is null, begin at the first key of the
-  index.
-*/
-  virtual int index_read_idx(uchar * buf, uint index, const uchar * key,
+  /**
+     @brief
+     Positions an index cursor to the index specified in the handle. Fetches the
+     row if available. If the key value is null, begin at the first key of the
+     index.
+  */
+  virtual int index_read_map(uchar * buf, const uchar * key,
                              key_part_map keypart_map,
-                             enum ha_rkey_function find_flag);
+                             enum ha_rkey_function find_flag)
+  {
+    uint key_len= calculate_key_len(table, active_index, key, keypart_map);
+    return  index_read(buf, key, key_len, find_flag);
+  }
+  /**
+     @brief
+     Positions an index cursor to the index specified in the handle. Fetches the
+     row if available. If the key value is null, begin at the first key of the
+     index.
+  */
+  virtual int index_read_idx_map(uchar * buf, uint index, const uchar * key,
+                                 key_part_map keypart_map,
+                                 enum ha_rkey_function find_flag);
   virtual int index_next(uchar * buf)
    { return  HA_ERR_WRONG_COMMAND; }
   virtual int index_prev(uchar * buf)
@@ -1311,17 +1316,17 @@ public:
   virtual int index_read_last(uchar * buf, const uchar * key, uint key_len)
    { return (my_errno=HA_ERR_WRONG_COMMAND); }
   public:
-/**
-  @brief
-  The following functions works like index_read, but it find the last
-  row with the current key value or prefix.
-*/
-  virtual int index_read_last(uchar * buf, const uchar * key,
-                              key_part_map keypart_map)
-   {
-     uint key_len= calculate_key_len(table, active_index, key, keypart_map);
-     return  index_read_last(buf, key, key_len);
-   }
+  /**
+     @brief
+     The following functions works like index_read, but it find the last
+     row with the current key value or prefix.
+  */
+  virtual int index_read_last_map(uchar * buf, const uchar * key,
+                                  key_part_map keypart_map)
+  {
+    uint key_len= calculate_key_len(table, active_index, key, keypart_map);
+    return index_read_last(buf, key, key_len);
+  }
   virtual int read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
                                      KEY_MULTI_RANGE *ranges, uint range_count,
                                      bool sorted, HANDLER_BUFFER *buffer);
@@ -1864,7 +1869,7 @@ int ha_find_files(THD *thd,const char *db,const char *path,
 int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
 
 /* key cache */
-int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
+extern "C" int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
 int ha_resize_key_cache(KEY_CACHE *key_cache);
 int ha_change_key_cache_param(KEY_CACHE *key_cache);
 int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
diff --git a/sql/item.cc b/sql/item.cc
index e2994bb8615..8afb502c983 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -3869,15 +3869,15 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
           if ((*res)->type() == Item::FIELD_ITEM)
           {
             /*
-             It's an Item_field referencing another Item_field in the select
-             list.
-             use the field from the Item_field in the select list and leave
-             the Item_field instance in place.
+              It's an Item_field referencing another Item_field in the select
+              list.
+              Use the field from the Item_field in the select list and leave
+              the Item_field instance in place.
             */
 
-            Field *field= (*((Item_field**)res))->field;
+            Field *new_field= (*((Item_field**)res))->field;
 
-            if (field == NULL)
+            if (new_field == NULL)
             {
               /* The column to which we link isn't valid. */
               my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name, 
@@ -3885,7 +3885,7 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
               return(1);
             }
 
-            set_field(field);
+            set_field(new_field);
             return 0;
           }
           else
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 755e711e383..8f5ff050dd6 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -3017,11 +3017,11 @@ uchar *in_longlong::get_value(Item *item)
 
 void in_datetime::set(uint pos,Item *item)
 {
-  Item **tmp= &item;
+  Item **tmp_item= &item;
   bool is_null;
   struct packed_longlong *buff= &((packed_longlong*) base)[pos];
 
-  buff->val= get_datetime_value(thd, &tmp, 0, warn_item, &is_null);
+  buff->val= get_datetime_value(thd, &tmp_item, 0, warn_item, &is_null);
   buff->unsigned_flag= 1L;
 }
 
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 47914c59b4c..35ecfdb0f2c 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -1158,7 +1158,6 @@ public:
 class Item_func_in :public Item_func_opt_neg
 {
 public:
-  Item_result cmp_type;
   /* 
     an array of values when the right hand arguments of IN
     are all SQL constant and there are no nulls 
diff --git a/sql/item_func.cc b/sql/item_func.cc
index f016aa6cd05..efc42c1b73f 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -4376,11 +4376,11 @@ int Item_func_set_user_var::save_in_field(Field *field, bool no_conversions,
   else if (result_type() == DECIMAL_RESULT)
   {
     my_decimal decimal_value;
-    my_decimal *value= entry->val_decimal(&null_value, &decimal_value);
+    my_decimal *val= entry->val_decimal(&null_value, &decimal_value);
     if (null_value)
       return set_field_to_null(field);
     field->set_notnull();
-    error=field->store_decimal(value);
+    error=field->store_decimal(val);
   }
   else
   {
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index 8ac812ec34a..d1c8e7a37e8 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -1049,6 +1049,23 @@ String *Item_str_conv::val_str(String *str)
 }
 
 
+void Item_func_lcase::fix_length_and_dec()
+{
+  collation.set(args[0]->collation);
+  multiply= collation.collation->casedn_multiply;
+  converter= collation.collation->cset->casedn;
+  max_length= args[0]->max_length * multiply;
+}
+
+void Item_func_ucase::fix_length_and_dec()
+{
+  collation.set(args[0]->collation);
+  multiply= collation.collation->caseup_multiply;
+  converter= collation.collation->cset->caseup;
+  max_length= args[0]->max_length * multiply;
+}
+
+
 String *Item_func_left::val_str(String *str)
 {
   DBUG_ASSERT(fixed == 1);
diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h
index ea9517976a8..155f8457156 100644
--- a/sql/item_strfunc.h
+++ b/sql/item_strfunc.h
@@ -145,8 +145,7 @@ class Item_str_conv :public Item_str_func
 {
 protected:
   uint multiply;
-  size_t (*converter)(CHARSET_INFO *cs, char *src, size_t srclen,
-                      char *dst, size_t dstlen);
+  my_charset_conv_case converter;
   String tmp_value;
 public:
   Item_str_conv(Item *item) :Item_str_func(item) {}
@@ -159,13 +158,7 @@ class Item_func_lcase :public Item_str_conv
 public:
   Item_func_lcase(Item *item) :Item_str_conv(item) {}
   const char *func_name() const { return "lcase"; }
-  void fix_length_and_dec()
-  {
-    collation.set(args[0]->collation);
-    multiply= collation.collation->casedn_multiply;
-    converter= collation.collation->cset->casedn;
-    max_length= args[0]->max_length * multiply;
-  }
+  void fix_length_and_dec();
 };
 
 class Item_func_ucase :public Item_str_conv
@@ -173,13 +166,7 @@ class Item_func_ucase :public Item_str_conv
 public:
   Item_func_ucase(Item *item) :Item_str_conv(item) {}
   const char *func_name() const { return "ucase"; }
-  void fix_length_and_dec()
-  {
-    collation.set(args[0]->collation);
-    multiply= collation.collation->caseup_multiply;
-    converter= collation.collation->cset->caseup;
-    max_length= args[0]->max_length * multiply;
-  }
+  void fix_length_and_dec();
 };
 
 
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 6d4207e89ec..843c6ced263 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -2129,10 +2129,10 @@ int subselect_uniquesubquery_engine::exec()
  
   if (!table->file->inited)
     table->file->ha_index_init(tab->ref.key, 0);
-  error= table->file->index_read(table->record[0],
-                                 tab->ref.key_buff,
-                                 make_prev_keypart_map(tab->ref.key_parts),
-                                 HA_READ_KEY_EXACT);
+  error= table->file->index_read_map(table->record[0],
+                                     tab->ref.key_buff,
+                                     make_prev_keypart_map(tab->ref.key_parts),
+                                     HA_READ_KEY_EXACT);
   if (error &&
       error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
     error= report_error(table, error);
@@ -2239,10 +2239,10 @@ int subselect_indexsubquery_engine::exec()
 
   if (!table->file->inited)
     table->file->ha_index_init(tab->ref.key, 1);
-  error= table->file->index_read(table->record[0],
-                                 tab->ref.key_buff,
-                                 make_prev_keypart_map(tab->ref.key_parts),
-                                 HA_READ_KEY_EXACT);
+  error= table->file->index_read_map(table->record[0],
+                                     tab->ref.key_buff,
+                                     make_prev_keypart_map(tab->ref.key_parts),
+                                     HA_READ_KEY_EXACT);
   if (error &&
       error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
     error= report_error(table, error);
diff --git a/sql/item_xmlfunc.cc b/sql/item_xmlfunc.cc
index 067af930d6f..15be9c97b6e 100644
--- a/sql/item_xmlfunc.cc
+++ b/sql/item_xmlfunc.cc
@@ -570,13 +570,13 @@ String *Item_nodeset_func_rootelement::val_nodeset(String *nodeset)
 
 String * Item_nodeset_func_union::val_nodeset(String *nodeset)
 {
-  uint numnodes= pxml->length() / sizeof(MY_XML_NODE);
+  uint num_nodes= pxml->length() / sizeof(MY_XML_NODE);
   String set0, *s0= args[0]->val_nodeset(&set0);
   String set1, *s1= args[1]->val_nodeset(&set1);
   String both_str;
-  both_str.alloc(numnodes);
+  both_str.alloc(num_nodes);
   char *both= (char*) both_str.ptr();
-  bzero((void*)both, numnodes);
+  bzero((void*)both, num_nodes);
   MY_XPATH_FLT *flt;
 
   fltbeg= (MY_XPATH_FLT*) s0->ptr();
@@ -590,7 +590,7 @@ String * Item_nodeset_func_union::val_nodeset(String *nodeset)
     both[flt->num]= 1;
 
   nodeset->length(0);
-  for (uint i= 0, pos= 0; i < numnodes; i++)
+  for (uint i= 0, pos= 0; i < num_nodes; i++)
   {
     if (both[i])
      ((XPathFilter*)nodeset)->append_element(i, pos++);
@@ -2656,7 +2656,9 @@ static uint xml_parent_tag(MY_XML_NODE *items, uint nitems, uint level)
   RETURN
     Currently only MY_XML_OK
 */
-static int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
+extern "C" int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len);
+
+int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
 {
   MY_XML_USER_DATA *data= (MY_XML_USER_DATA*)st->user_data;
   MY_XML_NODE *nodes= (MY_XML_NODE*) data->pxml->ptr();
@@ -2687,7 +2689,9 @@ static int xml_enter(MY_XML_PARSER *st,const char *attr, size_t len)
   RETURN
     Currently only MY_XML_OK
 */
-static int xml_value(MY_XML_PARSER *st,const char *attr, size_t len)
+extern "C" int xml_value(MY_XML_PARSER *st,const char *attr, size_t len);
+
+int xml_value(MY_XML_PARSER *st,const char *attr, size_t len)
 {
   MY_XML_USER_DATA *data= (MY_XML_USER_DATA*)st->user_data;
   MY_XML_NODE *nodes= (MY_XML_NODE*) data->pxml->ptr();
@@ -2717,7 +2721,9 @@ static int xml_value(MY_XML_PARSER *st,const char *attr, size_t len)
   RETURN
     Currently only MY_XML_OK
 */
-static int xml_leave(MY_XML_PARSER *st,const char *attr, size_t len)
+extern "C" int xml_leave(MY_XML_PARSER *st,const char *attr, size_t len);
+
+int xml_leave(MY_XML_PARSER *st,const char *attr, size_t len)
 {
   MY_XML_USER_DATA *data= (MY_XML_USER_DATA*)st->user_data;
   DBUG_ASSERT(data->level > 0);
diff --git a/sql/key.cc b/sql/key.cc
index fee06ec058f..e8354ed2635 100644
--- a/sql/key.cc
+++ b/sql/key.cc
@@ -480,6 +480,7 @@ int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length)
     rec0                        Pointer to table->record[0]
     first_rec                   Pointer to record compare with
     second_rec                  Pointer to record compare against first_rec
+
   DESCRIPTION
     This method is set-up such that it can be called directly from the
     priority queue and it is attempted to be optimised as much as possible
diff --git a/sql/log.cc b/sql/log.cc
index 3686459fedf..74a210a35b3 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -1934,7 +1934,7 @@ bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host,
 {
   char buff[32];
   uint length= 0;
-  char time_buff[MAX_TIME_SIZE];
+  char local_time_buff[MAX_TIME_SIZE];
   struct tm start;
   uint time_buff_len= 0;
 
@@ -1950,13 +1950,13 @@ bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host,
 
         localtime_r(&event_time, &start);
 
-        time_buff_len= my_snprintf(time_buff, MAX_TIME_SIZE,
+        time_buff_len= my_snprintf(local_time_buff, MAX_TIME_SIZE,
                                    "%02d%02d%02d %2d:%02d:%02d",
                                    start.tm_year % 100, start.tm_mon + 1,
                                    start.tm_mday, start.tm_hour,
                                    start.tm_min, start.tm_sec);
 
-        if (my_b_write(&log_file, (uchar*) &time_buff, time_buff_len))
+        if (my_b_write(&log_file, (uchar*) local_time_buff, time_buff_len))
           goto err;
       }
       else
@@ -2346,8 +2346,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
         s.flags|= LOG_EVENT_BINLOG_IN_USE_F;
       if (!s.is_valid())
         goto err;
-      if (null_created_arg)
-        s.created= 0;
+      s.dont_set_created= null_created_arg;
       if (s.write(&log_file))
         goto err;
       bytes_written+= s.data_written;
diff --git a/sql/log_event.cc b/sql/log_event.cc
index fecc35c95b9..58928864255 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -456,7 +456,11 @@ Log_event::Log_event()
    thd(0)
 {
   server_id=	::server_id;
-  when=		my_time(0);
+  /*
+    We can't call my_time() here as this would cause a call before
+    my_init() is called
+  */
+  when=		0;
   log_pos=	0;
 }
 #endif /* !MYSQL_CLIENT */
@@ -637,6 +641,7 @@ void Log_event::init_show_field_list(List<Item>* field_list)
 bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
 {
   uchar header[LOG_EVENT_HEADER_LEN];
+  ulong now;
   DBUG_ENTER("Log_event::write_header");
 
   /* Store number of bytes that will be written by this event */
@@ -687,6 +692,8 @@ bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
     log_pos= my_b_safe_tell(file)+data_written;
   }
 
+  now= (ulong) get_time();                              // Query start time
+
   /*
     Header will be of size LOG_EVENT_HEADER_LEN for all events, except for
     FORMAT_DESCRIPTION_EVENT and ROTATE_EVENT, where it will be
@@ -694,7 +701,7 @@ bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
     because we read them before knowing the format).
   */
 
-  int4store(header, (ulong) when);              // timestamp
+  int4store(header, now);              // timestamp
   header[EVENT_TYPE_OFFSET]= get_type_code();
   int4store(header+ SERVER_ID_OFFSET, server_id);
   int4store(header+ EVENT_LEN_OFFSET, data_written);
@@ -803,10 +810,12 @@ end:
 #ifndef MYSQL_CLIENT
 Log_event* Log_event::read_log_event(IO_CACHE* file,
 				     pthread_mutex_t* log_lock,
-                                     const Format_description_log_event *description_event)
+                                     const Format_description_log_event
+                                     *description_event)
 #else
 Log_event* Log_event::read_log_event(IO_CACHE* file,
-                                     const Format_description_log_event *description_event)
+                                     const Format_description_log_event
+                                     *description_event)
 #endif
 {
   DBUG_ENTER("Log_event::read_log_event");
@@ -1461,7 +1470,7 @@ Query_log_event::Query_log_event()
 /*
   SYNOPSIS
     Query_log_event::Query_log_event()
-      thd               - thread handle
+      thd_arg           - thread handle
       query_arg         - array of char representing the query
       query_length      - size of the  `query_arg' array
       using_trans       - there is a modified transactional table
@@ -1477,10 +1486,12 @@ Query_log_event::Query_log_event()
 */
 Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
 				 ulong query_length, bool using_trans,
-				 bool suppress_use, THD::killed_state killed_status_arg)
+				 bool suppress_use,
+                                 THD::killed_state killed_status_arg)
   :Log_event(thd_arg,
-             (thd_arg->thread_specific_used ? LOG_EVENT_THREAD_SPECIFIC_F : 0) |
-               (suppress_use ? LOG_EVENT_SUPPRESS_USE_F : 0),
+             (thd_arg->thread_specific_used ? LOG_EVENT_THREAD_SPECIFIC_F :
+              0) |
+             (suppress_use ? LOG_EVENT_SUPPRESS_USE_F : 0),
 	     using_trans),
    data_buf(0), query(query_arg), catalog(thd_arg->catalog),
    db(thd_arg->db), q_len((uint32) query_length),
@@ -1501,10 +1512,10 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
   error_code=
     (killed_status_arg == THD::NOT_KILLED) ? thd_arg->net.last_errno :
     ((thd_arg->system_thread & SYSTEM_THREAD_DELAYED_INSERT) ? 0 :
-     thd->killed_errno());
+     thd_arg->killed_errno());
   
   time(&end_time);
-  exec_time = (ulong) (end_time  - thd->start_time);
+  exec_time = (ulong) (end_time  - thd_arg->start_time);
   catalog_len = (catalog) ? (uint32) strlen(catalog) : 0;
   /* status_vars_len is set just before writing the event */
   db_len = (db) ? (uint32) strlen(db) : 0;
@@ -1513,15 +1524,15 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
   
   /*
     If we don't use flags2 for anything else than options contained in
-    thd->options, it would be more efficient to flags2=thd_arg->options
+    thd_arg->options, it would be more efficient to flags2=thd_arg->options
     (OPTIONS_WRITTEN_TO_BINLOG would be used only at reading time).
     But it's likely that we don't want to use 32 bits for 3 bits; in the future
     we will probably want to reclaim the 29 bits. So we need the &.
   */
   flags2= (uint32) (thd_arg->options & OPTIONS_WRITTEN_TO_BIN_LOG);
-  DBUG_ASSERT(thd->variables.character_set_client->number < 256*256);
-  DBUG_ASSERT(thd->variables.collation_connection->number < 256*256);
-  DBUG_ASSERT(thd->variables.collation_server->number < 256*256);
+  DBUG_ASSERT(thd_arg->variables.character_set_client->number < 256*256);
+  DBUG_ASSERT(thd_arg->variables.collation_connection->number < 256*256);
+  DBUG_ASSERT(thd_arg->variables.collation_server->number < 256*256);
   int2store(charset, thd_arg->variables.character_set_client->number);
   int2store(charset+2, thd_arg->variables.collation_connection->number);
   int2store(charset+4, thd_arg->variables.collation_server->number);
@@ -2247,9 +2258,10 @@ Muted_query_log_event::Muted_query_log_event()
 **************************************************************************/
 
 #ifndef MYSQL_CLIENT
-Start_log_event_v3::Start_log_event_v3() :Log_event(), binlog_version(BINLOG_VERSION), artificial_event(0)
+Start_log_event_v3::Start_log_event_v3()
+  :Log_event(), created(0), binlog_version(BINLOG_VERSION),
+   artificial_event(0), dont_set_created(0)
 {
-  created= when;
   memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
 }
 #endif
@@ -2319,7 +2331,8 @@ void Start_log_event_v3::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
 */
 
 Start_log_event_v3::Start_log_event_v3(const char* buf,
-                                       const Format_description_log_event* description_event)
+                                       const Format_description_log_event
+                                       *description_event)
   :Log_event(buf, description_event)
 {
   buf+= description_event->common_header_len;
@@ -2331,6 +2344,7 @@ Start_log_event_v3::Start_log_event_v3(const char* buf,
   created= uint4korr(buf+ST_CREATED_OFFSET);
   /* We use log_pos to mark if this was an artificial event or not */
   artificial_event= (log_pos == 0);
+  dont_set_created= 1;
 }
 
 
@@ -2344,6 +2358,8 @@ bool Start_log_event_v3::write(IO_CACHE* file)
   char buff[START_V3_HEADER_LEN];
   int2store(buff + ST_BINLOG_VER_OFFSET,binlog_version);
   memcpy(buff + ST_SERVER_VER_OFFSET,server_version,ST_SERVER_VER_LEN);
+  if (!dont_set_created)
+    created= when= get_time();
   int4store(buff + ST_CREATED_OFFSET,created);
   return (write_header(file, sizeof(buff)) ||
           my_b_safe_write(file, (uchar*) buff, sizeof(buff)));
@@ -2374,8 +2390,7 @@ bool Start_log_event_v3::write(IO_CACHE* file)
 int Start_log_event_v3::do_apply_event(Relay_log_info const *rli)
 {
   DBUG_ENTER("Start_log_event_v3::do_apply_event");
-  switch (binlog_version)
-  {
+  switch (binlog_version) {
   case 3:
   case 4:
     /*
@@ -2446,7 +2461,6 @@ Format_description_log_event::
 Format_description_log_event(uint8 binlog_ver, const char* server_ver)
   :Start_log_event_v3()
 {
-  created= when;
   binlog_version= binlog_ver;
   switch (binlog_ver) {
   case 4: /* MySQL 5.0 */
@@ -2598,6 +2612,8 @@ bool Format_description_log_event::write(IO_CACHE* file)
   uchar buff[FORMAT_DESCRIPTION_HEADER_LEN];
   int2store(buff + ST_BINLOG_VER_OFFSET,binlog_version);
   memcpy((char*) buff + ST_SERVER_VER_OFFSET,server_version,ST_SERVER_VER_LEN);
+  if (!dont_set_created)
+    created= when= get_time();
   int4store(buff + ST_CREATED_OFFSET,created);
   buff[ST_COMMON_HEADER_LEN_OFFSET]= LOG_EVENT_HEADER_LEN;
   memcpy((char*) buff+ST_COMMON_HEADER_LEN_OFFSET+1, (uchar*) post_header_len,
@@ -4904,8 +4920,9 @@ err:
 */
 
 #ifndef MYSQL_CLIENT  
-Append_block_log_event::Append_block_log_event(THD* thd_arg, const char* db_arg,
-					       char* block_arg,
+Append_block_log_event::Append_block_log_event(THD *thd_arg,
+                                               const char *db_arg,
+					       char *block_arg,
 					       uint block_len_arg,
 					       bool using_trans)
   :Log_event(thd_arg,0, using_trans), block(block_arg),
@@ -5154,7 +5171,8 @@ int Delete_file_log_event::do_apply_event(Relay_log_info const *rli)
 */
 
 #ifndef MYSQL_CLIENT  
-Execute_load_log_event::Execute_load_log_event(THD *thd_arg, const char* db_arg,
+Execute_load_log_event::Execute_load_log_event(THD *thd_arg,
+                                               const char* db_arg,
 					       bool using_trans)
   :Log_event(thd_arg, 0, using_trans), file_id(thd_arg->file_id), db(db_arg)
 {
@@ -5355,7 +5373,7 @@ int Begin_load_query_log_event::get_create_or_append() const
 
 #ifndef MYSQL_CLIENT
 Execute_load_query_log_event::
-Execute_load_query_log_event(THD* thd_arg, const char* query_arg,
+Execute_load_query_log_event(THD *thd_arg, const char* query_arg,
                      ulong query_length_arg, uint fn_pos_start_arg,
                      uint fn_pos_end_arg,
                      enum_load_dup_handling dup_handling_arg,
@@ -6998,7 +7016,8 @@ int Write_rows_log_event::do_after_row_operations(TABLE *table, int error)
   return error? error : local_error;
 }
 
-int Write_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
+int Write_rows_log_event::do_prepare_row(THD *thd_arg,
+                                         Relay_log_info const *rli,
                                          TABLE *table,
                                          uchar const *const row_start,
                                          uchar const **const row_end)
@@ -7009,7 +7028,7 @@ int Write_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
   if (int error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
                             &m_master_reclength, table->write_set, WRITE_ROWS_EVENT))
   {
-    thd->net.last_errno= error;
+    thd_arg->net.last_errno= error;
     return error;
   }
   bitmap_copy(table->read_set, table->write_set);
@@ -7272,11 +7291,12 @@ replace_record(THD *thd, TABLE *table,
           DBUG_RETURN(ENOMEM);
       }
 
-      key_copy((uchar*)key.get(), table->record[0], table->key_info + keynum, 0);
-      error= table->file->index_read_idx(table->record[1], keynum,
-                                         (const uchar*)key.get(),
-                                         HA_WHOLE_KEY,
-                                         HA_READ_KEY_EXACT);
+      key_copy((uchar*)key.get(), table->record[0], table->key_info + keynum,
+               0);
+      error= table->file->index_read_idx_map(table->record[1], keynum,
+                                             (const uchar*)key.get(),
+                                             HA_WHOLE_KEY,
+                                             HA_READ_KEY_EXACT);
       if (error)
       {
         table->file->print_error(error, MYF(0));
@@ -7527,8 +7547,8 @@ static int find_and_fetch_row(TABLE *table, uchar *key)
     my_ptrdiff_t const pos=
       table->s->null_bytes > 0 ? table->s->null_bytes - 1 : 0;
     table->record[1][pos]= 0xFF;
-    if ((error= table->file->index_read(table->record[1], key, HA_WHOLE_KEY,
-                                        HA_READ_KEY_EXACT)))
+    if ((error= table->file->index_read_map(table->record[1], key, HA_WHOLE_KEY,
+                                            HA_READ_KEY_EXACT)))
     {
       table->file->print_error(error, MYF(0));
       table->file->ha_index_end();
@@ -7728,7 +7748,8 @@ int Delete_rows_log_event::do_after_row_operations(TABLE *table, int error)
   return error;
 }
 
-int Delete_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
+int Delete_rows_log_event::do_prepare_row(THD *thd_arg,
+                                          Relay_log_info const *rli,
                                           TABLE *table,
                                           uchar const *const row_start,
                                           uchar const **const row_end)
@@ -7737,7 +7758,7 @@ int Delete_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
   if (int error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
                             &m_master_reclength, table->read_set, DELETE_ROWS_EVENT))
   {
-    thd->net.last_errno= error;
+    thd_arg->net.last_errno= error;
     return error;
   }
 
@@ -7894,7 +7915,10 @@ int Update_rows_log_event::do_before_row_operations(TABLE *table)
 
 int Update_rows_log_event::do_after_row_operations(TABLE *table, int error)
 {
-  /*error= ToDo:find out what this should really be, this triggers close_scan in nbd, returning error?*/
+  /*
+    error= ToDo:find out what this should really be, this triggers
+    close_scan in nbd, returning error?
+  */
   table->file->ha_index_or_rnd_end();
   my_free(m_memory, MYF(MY_ALLOW_ZERO_PTR));
   m_memory= NULL;
@@ -7904,7 +7928,8 @@ int Update_rows_log_event::do_after_row_operations(TABLE *table, int error)
   return error;
 }
 
-int Update_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
+int Update_rows_log_event::do_prepare_row(THD *thd_arg,
+                                          Relay_log_info const *rli,
                                           TABLE *table,
                                           uchar const *const row_start,
                                           uchar const **const row_end)
@@ -7919,9 +7944,10 @@ int Update_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
 
   /* record[0] is the before image for the update */
   if ((error= unpack_row(rli, table, m_width, row_start, &m_cols, row_end,
-                         &m_master_reclength, table->read_set, UPDATE_ROWS_EVENT)))
+                         &m_master_reclength, table->read_set,
+                         UPDATE_ROWS_EVENT)))
   {
-    thd->net.last_errno= error;
+    thd_arg->net.last_errno= error;
     return error;
   }
 
@@ -7929,9 +7955,10 @@ int Update_rows_log_event::do_prepare_row(THD *thd, Relay_log_info const *rli,
   uchar const *next_start = *row_end;
   /* m_after_image is the after image for the update */
   if ((error= unpack_row(rli, table, m_width, next_start, &m_cols_ai, row_end,
-                         &m_master_reclength, table->write_set, UPDATE_ROWS_EVENT)))
+                         &m_master_reclength, table->write_set,
+                         UPDATE_ROWS_EVENT)))
   {
-    thd->net.last_errno= error;
+    thd_arg->net.last_errno= error;
     return error;
   }
 
@@ -8115,5 +8142,3 @@ Incident_log_event::write_data_body(IO_CACHE *file)
   DBUG_ENTER("Incident_log_event::write_data_body");
   DBUG_RETURN(write_str(file, m_message.str, m_message.length));
 }
-
-
diff --git a/sql/log_event.h b/sql/log_event.h
index 3785a0bea0f..1f45e384e30 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -66,8 +66,8 @@
    which increments every time we write an event to the binlog) (3 bytes).
    Q: how do we handle when the counter is overflowed and restarts from 0 ?
 
-   - Query and Load (Create or Execute) events may have a more precise timestamp
-   (with microseconds), number of matched/affected/warnings rows
+   - Query and Load (Create or Execute) events may have a more precise
+     timestamp (with microseconds), number of matched/affected/warnings rows
    and fields of session variables: SQL_MODE,
    FOREIGN_KEY_CHECKS, UNIQUE_CHECKS, SQL_AUTO_IS_NULL, the collations and
    charsets, the PASSWORD() version (old/new/...).
@@ -715,7 +715,8 @@ public:
   */
   static Log_event* read_log_event(IO_CACHE* file,
 				   pthread_mutex_t* log_lock,
-                                   const Format_description_log_event *description_event);
+                                   const Format_description_log_event
+                                   *description_event);
   static int read_log_event(IO_CACHE* file, String* packet,
 			    pthread_mutex_t* log_lock);
   /*
@@ -743,7 +744,8 @@ public:
   Log_event() : temp_buf(0) {}
     /* avoid having to link mysqlbinlog against libpthread */
   static Log_event* read_log_event(IO_CACHE* file,
-                                   const Format_description_log_event *description_event);
+                                   const Format_description_log_event
+                                   *description_event);
   /* print*() functions are used by mysqlbinlog */
   virtual void print(FILE* file, PRINT_EVENT_INFO* print_event_info) = 0;
   void print_timestamp(IO_CACHE* file, time_t *ts = 0);
@@ -779,12 +781,24 @@ public:
   { return 0; }
   virtual bool write_data_body(IO_CACHE* file __attribute__((unused)))
   { return 0; }
+  inline time_t get_time()
+  {
+    THD *tmp_thd;
+    if (when)
+      return when;
+    if (thd)
+      return thd->start_time;
+    if ((tmp_thd= current_thd))
+      return tmp_thd->start_time;
+    return my_time(0);
+  }
 #endif
   virtual Log_event_type get_type_code() = 0;
   virtual bool is_valid() const = 0;
   virtual bool is_artificial_event() { return 0; }
   inline bool get_cache_stmt() const { return cache_stmt; }
-  Log_event(const char* buf, const Format_description_log_event* description_event);
+  Log_event(const char* buf, const Format_description_log_event
+            *description_event);
   virtual ~Log_event() { free_temp_buf();}
   void register_temp_buf(char* buf) { temp_buf = buf; }
   void free_temp_buf()
@@ -807,6 +821,8 @@ public:
   /* returns the human readable name of the event's type */
   const char* get_type_str();
 
+  /* Return start of query time or current time */
+
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 public:
 
@@ -818,7 +834,8 @@ public:
 
      @see do_apply_event
    */
-  int apply_event(Relay_log_info const *rli) {
+  int apply_event(Relay_log_info const *rli)
+  {
     return do_apply_event(rli);
   }
 
@@ -926,7 +943,6 @@ protected:
      non-zero. The caller shall decrease the counter by one.
    */
   virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
-
 #endif
 };
 
@@ -1158,7 +1174,8 @@ private:
                    char **fn_start, char **fn_end);
 protected:
   int copy_log_event(const char *buf, ulong event_len,
-                     int body_offset, const Format_description_log_event* description_event);
+                     int body_offset,
+                     const Format_description_log_event* description_event);
 
 public:
   ulong thread_id;
@@ -1303,6 +1320,11 @@ public:
     setting log_event == 0 (for now).
   */
   bool artificial_event;
+  /*
+    We set this to 1 if we don't want to have the created time in the log,
+    which is the case when we rollover to a new log.
+  */
+  bool dont_set_created;
 
 #ifndef MYSQL_CLIENT
   Start_log_event_v3();
@@ -1369,7 +1391,8 @@ public:
 
   Format_description_log_event(uint8 binlog_ver, const char* server_ver=0);
   Format_description_log_event(const char* buf, uint event_len,
-                               const Format_description_log_event* description_event);
+                               const Format_description_log_event
+                               *description_event);
   ~Format_description_log_event() { my_free((uchar*)post_header_len, MYF(0)); }
   Log_event_type get_type_code() { return FORMAT_DESCRIPTION_EVENT;}
 #ifndef MYSQL_CLIENT
@@ -1427,7 +1450,8 @@ public:
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
-  Intvar_log_event(const char* buf, const Format_description_log_event* description_event);
+  Intvar_log_event(const char* buf,
+                   const Format_description_log_event *description_event);
   ~Intvar_log_event() {}
   Log_event_type get_type_code() { return INTVAR_EVENT;}
   const char* get_var_type_name();
@@ -1474,7 +1498,8 @@ class Rand_log_event: public Log_event
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
-  Rand_log_event(const char* buf, const Format_description_log_event* description_event);
+  Rand_log_event(const char* buf,
+                 const Format_description_log_event *description_event);
   ~Rand_log_event() {}
   Log_event_type get_type_code() { return RAND_EVENT;}
   int get_data_size() { return 16; /* sizeof(ulonglong) * 2*/ }
@@ -1517,7 +1542,8 @@ class Xid_log_event: public Log_event
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
-  Xid_log_event(const char* buf, const Format_description_log_event* description_event);
+  Xid_log_event(const char* buf,
+                const Format_description_log_event *description_event);
   ~Xid_log_event() {}
   Log_event_type get_type_code() { return XID_EVENT;}
   int get_data_size() { return sizeof(xid); }
@@ -1563,7 +1589,8 @@ public:
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
-  User_var_log_event(const char* buf, const Format_description_log_event* description_event);
+  User_var_log_event(const char* buf,
+                     const Format_description_log_event *description_event);
   ~User_var_log_event() {}
   Log_event_type get_type_code() { return USER_VAR_EVENT;}
 #ifndef MYSQL_CLIENT
@@ -1595,7 +1622,8 @@ public:
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
 #endif
 
-  Stop_log_event(const char* buf, const Format_description_log_event* description_event):
+  Stop_log_event(const char* buf,
+                 const Format_description_log_event *description_event):
     Log_event(buf, description_event)
   {}
   ~Stop_log_event() {}
@@ -1704,7 +1732,8 @@ public:
 #endif /* HAVE_REPLICATION */
 #else
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local);
+  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
+             bool enable_local);
 #endif
 
   Create_file_log_event(const char* buf, uint event_len,
@@ -1779,7 +1808,8 @@ public:
 #endif
 
   Append_block_log_event(const char* buf, uint event_len,
-                         const Format_description_log_event* description_event);
+                         const Format_description_log_event
+                         *description_event);
   ~Append_block_log_event() {}
   Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
   int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
@@ -1815,7 +1845,8 @@ public:
 #endif /* HAVE_REPLICATION */
 #else
   void print(FILE* file, PRINT_EVENT_INFO* print_event_info);
-  void print(FILE* file, PRINT_EVENT_INFO* print_event_info, bool enable_local);
+  void print(FILE* file, PRINT_EVENT_INFO* print_event_info,
+             bool enable_local);
 #endif
 
   Delete_file_log_event(const char* buf, uint event_len,
@@ -1858,7 +1889,8 @@ public:
 #endif
 
   Execute_load_log_event(const char* buf, uint event_len,
-                         const Format_description_log_event* description_event);
+                         const Format_description_log_event
+                         *description_event);
   ~Execute_load_log_event() {}
   Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
   int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
@@ -1897,7 +1929,8 @@ public:
 #endif /* HAVE_REPLICATION */
 #endif
   Begin_load_query_log_event(const char* buf, uint event_len,
-                             const Format_description_log_event* description_event);
+                             const Format_description_log_event
+                             *description_event);
   ~Begin_load_query_log_event() {}
   Log_event_type get_type_code() { return BEGIN_LOAD_QUERY_EVENT; }
 };
@@ -1949,7 +1982,8 @@ public:
 	     const char *local_fname);
 #endif
   Execute_load_query_log_event(const char* buf, uint event_len,
-                               const Format_description_log_event *description_event);
+                               const Format_description_log_event
+                               *description_event);
   ~Execute_load_query_log_event() {}
 
   Log_event_type get_type_code() { return EXECUTE_LOAD_QUERY_EVENT; }
@@ -1976,7 +2010,8 @@ public:
     Log_event's ctor, this way we can extract maximum information from the
     event's header (the unique ID for example).
   */
-  Unknown_log_event(const char* buf, const Format_description_log_event* description_event):
+  Unknown_log_event(const char* buf,
+                    const Format_description_log_event *description_event):
     Log_event(buf, description_event)
   {}
   ~Unknown_log_event() {}
diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc
index 8663963b35e..35e358001fd 100644
--- a/sql/log_event_old.cc
+++ b/sql/log_event_old.cc
@@ -5,7 +5,7 @@
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 int
-Write_rows_log_event_old::do_prepare_row(THD *thd,
+Write_rows_log_event_old::do_prepare_row(THD *thd_arg,
                                          Relay_log_info const *rli,
                                          TABLE *table,
                                          uchar const *row_start,
@@ -25,7 +25,7 @@ Write_rows_log_event_old::do_prepare_row(THD *thd,
 
 
 int
-Delete_rows_log_event_old::do_prepare_row(THD *thd,
+Delete_rows_log_event_old::do_prepare_row(THD *thd_arg,
                                           Relay_log_info const *rli,
                                           TABLE *table,
                                           uchar const *row_start,
@@ -58,7 +58,7 @@ Delete_rows_log_event_old::do_prepare_row(THD *thd,
 }
 
 
-int Update_rows_log_event_old::do_prepare_row(THD *thd,
+int Update_rows_log_event_old::do_prepare_row(THD *thd_arg,
                                               Relay_log_info const *rli,
                                               TABLE *table,
                                               uchar const *row_start,
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index a607e77eecf..375782787a3 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -168,7 +168,7 @@ public:
 
 protected:
   Object_creation_ctx() {}
-  virtual Object_creation_ctx *create_backup_ctx(THD *thd) = 0;
+  virtual Object_creation_ctx *create_backup_ctx(THD *thd) const = 0;
 
   virtual void change_env(THD *thd) const = 0;
 
@@ -204,7 +204,7 @@ protected:
                               CHARSET_INFO *connection_cl);
 
 protected:
-  virtual Object_creation_ctx *create_backup_ctx(THD *thd);
+  virtual Object_creation_ctx *create_backup_ctx(THD *thd) const;
 
   virtual void change_env(THD *thd) const;
 
@@ -1642,7 +1642,7 @@ bool key_cmp_if_same(TABLE *form,const uchar *key,uint index,uint key_length);
 void key_unpack(String *to,TABLE *form,uint index);
 bool is_key_used(TABLE *table, uint idx, const MY_BITMAP *fields);
 int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length);
-int key_rec_cmp(void *key_info, uchar *a, uchar *b);
+extern "C" int key_rec_cmp(void *key_info, uchar *a, uchar *b);
 
 bool init_errmessage(void);
 #endif /* MYSQL_SERVER */
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 6c8fa7e7ac3..ce3532b3a9f 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -693,7 +693,7 @@ struct st_VioSSLFd *ssl_acceptor_fd;
 pthread_handler_t signal_hand(void *arg);
 static void mysql_init_variables(void);
 static void get_options(int *argc,char **argv);
-static my_bool get_one_option(int, const struct my_option *, char *);
+extern "C" my_bool mysqld_get_one_option(int, const struct my_option *, char *);
 static void set_server_version(void);
 static int init_thread_environment();
 static char *get_relative_path(const char *path);
@@ -1141,6 +1141,7 @@ void unireg_end(void)
 extern "C" void unireg_abort(int exit_code)
 {
   DBUG_ENTER("unireg_abort");
+
   if (exit_code)
     sql_print_error("Aborting\n");
   else if (opt_help)
@@ -2353,7 +2354,7 @@ static void init_signals(void)
   sigaddset(&set,SIGTSTP);
 #endif
   if (thd_lib_detected != THD_LIB_LT)
-  sigaddset(&set,THR_SERVER_ALARM);
+    sigaddset(&set,THR_SERVER_ALARM);
   if (test_flags & TEST_SIGINT)
   {
     // May be SIGINT
@@ -2549,7 +2550,9 @@ static void check_data_home(const char *path)
 
 
 /* ARGSUSED */
-static int my_message_sql(uint error, const char *str, myf MyFlags)
+extern "C" int my_message_sql(uint error, const char *str, myf MyFlags);
+
+int my_message_sql(uint error, const char *str, myf MyFlags)
 {
   THD *thd;
   DBUG_ENTER("my_message_sql");
@@ -2612,13 +2615,16 @@ static int my_message_sql(uint error, const char *str, myf MyFlags)
 
 
 #ifndef EMBEDDED_LIBRARY
-static void *my_str_malloc_mysqld(size_t size)
+extern "C" void *my_str_malloc_mysqld(size_t size);
+extern "C" void my_str_free_mysqld(void *ptr);
+
+void *my_str_malloc_mysqld(size_t size)
 {
   return my_malloc(size, MYF(MY_FAE));
 }
 
 
-static void my_str_free_mysqld(void *ptr)
+void my_str_free_mysqld(void *ptr)
 {
   my_free((uchar*)ptr, MYF(MY_FAE));
 }
@@ -3418,7 +3424,7 @@ server.");
     my_getopt_skip_unknown= 0;
 
     if ((ho_error= handle_options(&defaults_argc, &tmp_argv, no_opts,
-                                  get_one_option)))
+                                  mysqld_get_one_option)))
       unireg_abort(ho_error);
 
     if (defaults_argc)
@@ -3902,7 +3908,6 @@ we force server id to 2, but this MySQL server will not act as a slave.");
   */
   if (init_slave() && !active_mi)
   {
-    end_thr_alarm(1);				// Don't allow alarms
     unireg_abort(1);
   }
 
@@ -3910,16 +3915,12 @@ we force server id to 2, but this MySQL server will not act as a slave.");
   {
     select_thread_in_use= 0;                    // Allow 'kill' to work
     bootstrap(stdin);
-    end_thr_alarm(1);				// Don't allow alarms
     unireg_abort(bootstrap_error ? 1 : 0);
   }
   if (opt_init_file)
   {
     if (read_init_file(opt_init_file))
-    {
-      end_thr_alarm(1);				// Don't allow alarms
       unireg_abort(1);
-    }
   }
   execute_ddl_log_recovery();
 
@@ -6879,6 +6880,7 @@ SHOW_VAR status_vars[]= {
   {"Open_streams",             (char*) &my_stream_opened,       SHOW_LONG_NOFLUSH},
   {"Open_table_definitions",   (char*) &show_table_definitions, SHOW_FUNC},
   {"Open_tables",              (char*) &show_open_tables,       SHOW_FUNC},
+  {"Opened_files",             (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},
   {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
   {"Prepared_stmt_count",      (char*) &show_prepared_stmt_count, SHOW_FUNC},
 #ifdef HAVE_QUERY_CACHE
@@ -7246,9 +7248,10 @@ static void mysql_init_variables(void)
 }
 
 
-static my_bool
-get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
-	       char *argument)
+my_bool
+mysqld_get_one_option(int optid,
+                      const struct my_option *opt __attribute__((unused)),
+                      char *argument)
 {
   switch(optid) {
   case '#':
@@ -7744,7 +7747,10 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
 
 /* Handle arguments for multiple key caches */
 
-static uchar* *
+extern "C" uchar **mysql_getopt_value(const char *keyname, uint key_length,
+                                      const struct my_option *option);
+
+uchar* *
 mysql_getopt_value(const char *keyname, uint key_length,
 		   const struct my_option *option)
 {
@@ -7773,11 +7779,19 @@ mysql_getopt_value(const char *keyname, uint key_length,
 }
 
 
-static void option_error_reporter(enum loglevel level, const char *format, ...)
+extern "C" void option_error_reporter(enum loglevel level, const char *format, ...);
+
+void option_error_reporter(enum loglevel level, const char *format, ...)
 {
   va_list args;
   va_start(args, format);
-  vprint_msg_to_log(level, format, args);
+
+  /* Don't print warnings for --loose options during bootstrap */
+  if (level == ERROR_LEVEL || !opt_bootstrap ||
+      global_system_variables.log_warnings)
+  {
+    vprint_msg_to_log(level, format, args);
+  }
   va_end(args);
 }
 
@@ -7795,7 +7809,7 @@ static void get_options(int *argc,char **argv)
   my_getopt_skip_unknown= TRUE;
 
   if ((ho_error= handle_options(argc, &argv, my_long_options,
-                                get_one_option)))
+                                mysqld_get_one_option)))
     exit(ho_error);
   (*argc)++; /* add back one for the progname handle_options removes */
              /* no need to do this for argv as we are discarding it. */
@@ -8156,7 +8170,7 @@ void refresh_status(THD *thd)
   add_to_status(&global_status_var, &thd->status_var);
 
   /* Reset thread's status variables */
-  bzero((char*) &thd->status_var, sizeof(thd->status_var));
+  bzero((uchar*) &thd->status_var, sizeof(thd->status_var));
 
   /* Reset some global variables */
   reset_status_vars();
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 948b268d9a3..516da13d857 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -8375,7 +8375,8 @@ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length,
     {
       /* Read the next record in the same range with prefix after cur_prefix. */
       DBUG_ASSERT(cur_prefix != 0);
-      result= file->index_read(record, cur_prefix, keypart_map, HA_READ_AFTER_KEY);
+      result= file->index_read_map(record, cur_prefix, keypart_map,
+                                   HA_READ_AFTER_KEY);
       if (result || (file->compare_key(file->end_range) <= 0))
         DBUG_RETURN(result);
     }
@@ -8446,9 +8447,10 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
     }
     last_range= *(cur_range++);
 
-    result= file->index_read(record, last_range->min_key,
-			     last_range->min_keypart_map,
-			     (ha_rkey_function)(last_range->flag ^ GEOM_FLAG));
+    result= file->index_read_map(record, last_range->min_key,
+                                 last_range->min_keypart_map,
+                                 (ha_rkey_function)(last_range->flag ^
+                                                    GEOM_FLAG));
     if (result != HA_ERR_KEY_NOT_FOUND && result != HA_ERR_END_OF_FILE)
       DBUG_RETURN(result);
     last_range= 0;				// Not found, to next range
@@ -8579,18 +8581,19 @@ int QUICK_SELECT_DESC::get_next()
 
     if (last_range->flag & EQ_RANGE)
     {
-      result = file->index_read(record, last_range->max_key,
-				last_range->max_keypart_map, HA_READ_KEY_EXACT);
+      result = file->index_read_map(record, last_range->max_key,
+                                    last_range->max_keypart_map,
+                                    HA_READ_KEY_EXACT);
     }
     else
     {
       DBUG_ASSERT(last_range->flag & NEAR_MAX ||
                   range_reads_after_key(last_range));
-      result=file->index_read(record, last_range->max_key,
-			      last_range->max_keypart_map,
-			      ((last_range->flag & NEAR_MAX) ?
-			       HA_READ_BEFORE_KEY :
-                               HA_READ_PREFIX_LAST_OR_PREV));
+      result=file->index_read_map(record, last_range->max_key,
+                                  last_range->max_keypart_map,
+                                  ((last_range->flag & NEAR_MAX) ?
+                                   HA_READ_BEFORE_KEY :
+                                   HA_READ_PREFIX_LAST_OR_PREV));
     }
     if (result)
     {
@@ -10446,9 +10449,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::get_next()
       first sub-group with the extended prefix.
     */
     if (!have_min && !have_max && key_infix_len > 0)
-      result= file->index_read(record, group_prefix,
-                               make_prev_keypart_map(real_key_parts),
-                               HA_READ_KEY_EXACT);
+      result= file->index_read_map(record, group_prefix,
+                                   make_prev_keypart_map(real_key_parts),
+                                   HA_READ_KEY_EXACT);
 
     result= have_min ? min_res : have_max ? max_res : result;
   } while ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
@@ -10510,9 +10513,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min()
     /* Apply the constant equality conditions to the non-group select fields */
     if (key_infix_len > 0)
     {
-      if ((result= file->index_read(record, group_prefix,
-                                    make_prev_keypart_map(real_key_parts),
-                                    HA_READ_KEY_EXACT)))
+      if ((result= file->index_read_map(record, group_prefix,
+                                        make_prev_keypart_map(real_key_parts),
+                                        HA_READ_KEY_EXACT)))
         DBUG_RETURN(result);
     }
 
@@ -10527,9 +10530,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min()
     {
       /* Find the first subsequent record without NULL in the MIN/MAX field. */
       key_copy(tmp_record, record, index_info, 0);
-      result= file->index_read(record, tmp_record,
-                               make_keypart_map(real_key_parts),
-                               HA_READ_AFTER_KEY);
+      result= file->index_read_map(record, tmp_record,
+                                   make_keypart_map(real_key_parts),
+                                   HA_READ_AFTER_KEY);
       /*
         Check if the new record belongs to the current group by comparing its
         prefix with the group's prefix. If it is from the next group, then the
@@ -10584,9 +10587,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_max()
   if (min_max_ranges.elements > 0)
     result= next_max_in_range();
   else
-    result= file->index_read(record, group_prefix,
-                             make_prev_keypart_map(real_key_parts),
-                             HA_READ_PREFIX_LAST);
+    result= file->index_read_map(record, group_prefix,
+                                 make_prev_keypart_map(real_key_parts),
+                                 HA_READ_PREFIX_LAST);
   DBUG_RETURN(result);
 }
 
@@ -10637,9 +10640,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_prefix()
     else
     {
       /* Load the first key in this group into record. */
-      result= file->index_read(record, group_prefix,
-                               make_prev_keypart_map(group_key_parts),
-                               HA_READ_AFTER_KEY);
+      result= file->index_read_map(record, group_prefix,
+                                   make_prev_keypart_map(group_key_parts),
+                                   HA_READ_AFTER_KEY);
       if (result)
         DBUG_RETURN(result);
     }
@@ -10716,7 +10719,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range()
                  HA_READ_AFTER_KEY : HA_READ_KEY_OR_NEXT;
     }
 
-    result= file->index_read(record, group_prefix, keypart_map, find_flag);
+    result= file->index_read_map(record, group_prefix, keypart_map, find_flag);
     if (result)
     {
       if ((result == HA_ERR_KEY_NOT_FOUND || result == HA_ERR_END_OF_FILE) &&
@@ -10849,7 +10852,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_max_in_range()
                  HA_READ_BEFORE_KEY : HA_READ_PREFIX_LAST_OR_PREV;
     }
 
-    result= file->index_read(record, group_prefix, keypart_map, find_flag);
+    result= file->index_read_map(record, group_prefix, keypart_map, find_flag);
 
     if (result)
     {
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index 8851401d21f..6836c53db4e 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -270,9 +270,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
                  Closed interval: Either The MIN argument is non-nullable, or
                  we have a >= predicate for the MIN argument.
               */
-              error= table->file->index_read(table->record[0], ref.key_buff,
-                                             make_prev_keypart_map(ref.key_parts),
-                                             HA_READ_KEY_OR_NEXT);
+              error= table->file->index_read_map(table->record[0],
+                                                 ref.key_buff,
+                                                 make_prev_keypart_map(ref.key_parts),
+                                                 HA_READ_KEY_OR_NEXT);
             else
             {
               /*
@@ -281,9 +282,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
                 2) there is a > predicate on it, nullability is irrelevant.
                 We need to scan the next bigger record first.
               */
-              error= table->file->index_read(table->record[0], ref.key_buff, 
-                                             make_prev_keypart_map(ref.key_parts),
-                                             HA_READ_AFTER_KEY);
+              error= table->file->index_read_map(table->record[0],
+                                                 ref.key_buff, 
+                                                 make_prev_keypart_map(ref.key_parts),
+                                                 HA_READ_AFTER_KEY);
               /* 
                  If the found record is outside the group formed by the search
                  prefix, or there is no such record at all, check if all
@@ -305,9 +307,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
                    key_cmp_if_same(table, ref.key_buff, ref.key, prefix_len)))
               {
                 DBUG_ASSERT(item_field->field->real_maybe_null());
-                error= table->file->index_read(table->record[0], ref.key_buff,
-                                               make_prev_keypart_map(ref.key_parts),
-                                               HA_READ_KEY_EXACT);
+                error= table->file->index_read_map(table->record[0],
+                                                   ref.key_buff,
+                                                   make_prev_keypart_map(ref.key_parts),
+                                                   HA_READ_KEY_EXACT);
               }
             }
           }
@@ -394,11 +397,11 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
           if (!ref.key_length)
             error= table->file->index_last(table->record[0]);
           else
-	    error= table->file->index_read(table->record[0], key_buff,
-                                           make_prev_keypart_map(ref.key_parts),
-					   range_fl & NEAR_MAX ?
-					   HA_READ_BEFORE_KEY :
-					   HA_READ_PREFIX_LAST_OR_PREV);
+	    error= table->file->index_read_map(table->record[0], key_buff,
+                                               make_prev_keypart_map(ref.key_parts),
+                                               range_fl & NEAR_MAX ?
+                                               HA_READ_BEFORE_KEY :
+                                               HA_READ_PREFIX_LAST_OR_PREV);
 	  if (!error && reckey_in_range(1, &ref, item_field->field,
 			                conds, range_fl, prefix_len))
 	    error= HA_ERR_KEY_NOT_FOUND;
diff --git a/sql/partition_info.cc b/sql/partition_info.cc
index 308b96d84f8..ab887d5dda0 100644
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -91,10 +91,10 @@ partition_info *partition_info::get_clone()
 #define MAX_PART_NAME_SIZE 8
 
 char *partition_info::create_default_partition_names(uint part_no,
-                                                     uint no_parts, 
+                                                     uint no_parts_arg,
                                                      uint start_no)
 {
-  char *ptr= (char*) sql_calloc(no_parts*MAX_PART_NAME_SIZE);
+  char *ptr= (char*) sql_calloc(no_parts_arg*MAX_PART_NAME_SIZE);
   char *move_ptr= ptr;
   uint i= 0;
   DBUG_ENTER("create_default_partition_names");
@@ -105,11 +105,11 @@ char *partition_info::create_default_partition_names(uint part_no,
     {
       my_sprintf(move_ptr, (move_ptr,"p%u", (start_no + i)));
       move_ptr+=MAX_PART_NAME_SIZE;
-    } while (++i < no_parts);
+    } while (++i < no_parts_arg);
   }
   else
   {
-    mem_alloc_error(no_parts*MAX_PART_NAME_SIZE);
+    mem_alloc_error(no_parts_arg*MAX_PART_NAME_SIZE);
   }
   DBUG_RETURN(ptr);
 }
diff --git a/sql/rpl_filter.cc b/sql/rpl_filter.cc
index bb5db0106eb..fb609e12dcb 100644
--- a/sql/rpl_filter.cc
+++ b/sql/rpl_filter.cc
@@ -362,9 +362,11 @@ Rpl_filter::add_ignore_db(const char* table_spec)
   ignore_db.push_back(db);
 }
 
+extern "C" uchar *get_table_key(const uchar *, size_t *, my_bool);
+extern "C" void free_table_ent(void* a);
 
-static uchar* get_table_key(const uchar* a, size_t *len,
-			   my_bool __attribute__((unused)))
+uchar *get_table_key(const uchar* a, size_t *len,
+                     my_bool __attribute__((unused)))
 {
   TABLE_RULE_ENT *e= (TABLE_RULE_ENT *) a;
 
@@ -373,7 +375,7 @@ static uchar* get_table_key(const uchar* a, size_t *len,
 }
 
 
-static void free_table_ent(void* a)
+void free_table_ent(void* a)
 {
   TABLE_RULE_ENT *e= (TABLE_RULE_ENT *) a;
   
diff --git a/sql/set_var.cc b/sql/set_var.cc
index ace3bee8342..697de9cda97 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -3266,11 +3266,12 @@ bool sys_var_thd_storage_engine::check(THD *thd, set_var *var)
   var->save_result.plugin= NULL;
   if (var->value->result_type() == STRING_RESULT)
   {
-    LEX_STRING name;
+    LEX_STRING engine_name;
     handlerton *hton;
     if (!(res=var->value->val_str(&str)) ||
-        !(name.str= (char *)res->ptr()) || !(name.length= res->length()) ||
-	!(var->save_result.plugin= ha_resolve_by_name(thd, &name)) ||
+        !(engine_name.str= (char *)res->ptr()) ||
+        !(engine_name.length= res->length()) ||
+	!(var->save_result.plugin= ha_resolve_by_name(thd, &engine_name)) ||
         !(hton= plugin_data(var->save_result.plugin, handlerton *)) ||
         ha_checktype(thd, ha_legacy_type(hton), 1, 0) != hton)
     {
@@ -3292,13 +3293,13 @@ uchar *sys_var_thd_storage_engine::value_ptr(THD *thd, enum_var_type type,
 {
   uchar* result;
   handlerton *hton;
-  LEX_STRING *name;
+  LEX_STRING *engine_name;
   plugin_ref plugin= thd->variables.*offset;
   if (type == OPT_GLOBAL)
     plugin= my_plugin_lock(thd, &(global_system_variables.*offset));
   hton= plugin_data(plugin, handlerton*);
-  name= &hton2plugin[hton->slot]->name;
-  result= (uchar *) thd->strmake(name->str, name->length);
+  engine_name= &hton2plugin[hton->slot]->name;
+  result= (uchar *) thd->strmake(engine_name->str, engine_name->length);
   if (type == OPT_GLOBAL)
     plugin_unlock(thd, plugin);
   return result;
@@ -3585,7 +3586,7 @@ void free_key_cache(const char *name, KEY_CACHE *key_cache)
 }
 
 
-bool process_key_caches(int (* func) (const char *name, KEY_CACHE *))
+bool process_key_caches(process_key_cache_t func)
 {
   I_List_iterator<NAMED_LIST> it(key_caches);
   NAMED_LIST *element;
diff --git a/sql/set_var.h b/sql/set_var.h
index 67ec449a02f..eb2c893c89e 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -1128,6 +1128,11 @@ public:
 };
 
 
+extern "C"
+{
+  typedef int (*process_key_cache_t) (const char *, KEY_CACHE *);
+}
+
 /* Named lists (used for keycaches) */
 
 class NAMED_LIST :public ilink
@@ -1152,8 +1157,7 @@ public:
   {
     my_free((uchar*) name, MYF(0));
   }
-  friend bool process_key_caches(int (* func) (const char *name,
-					       KEY_CACHE *));
+  friend bool process_key_caches(process_key_cache_t func);
   friend void delete_elements(I_List<NAMED_LIST> *list,
 			      void (*free_element)(const char*, uchar*));
 };
@@ -1201,6 +1205,6 @@ extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path;
 KEY_CACHE *get_key_cache(LEX_STRING *cache_name);
 KEY_CACHE *get_or_create_key_cache(const char *name, uint length);
 void free_key_cache(const char *name, KEY_CACHE *key_cache);
-bool process_key_caches(int (* func) (const char *name, KEY_CACHE *));
+bool process_key_caches(process_key_cache_t func);
 void delete_elements(I_List<NAMED_LIST> *list,
 		     void (*free_element)(const char*, uchar*));
diff --git a/sql/sp.cc b/sql/sp.cc
index 7b69842669f..437ffb3b484 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -97,7 +97,8 @@ public:
 protected:
   virtual Object_creation_ctx *create_backup_ctx(THD *thd) const
   {
-    return new Stored_routine_creation_ctx(thd);
+    DBUG_ENTER("Stored_routine_creation_ctx::create_backup_ctx");
+    DBUG_RETURN(new Stored_routine_creation_ctx(thd));
   }
 
 private:
@@ -348,8 +349,8 @@ db_find_routine_aux(THD *thd, int type, sp_name *name, TABLE *table)
   key_copy(key, table->record[0], table->key_info,
            table->key_info->key_length);
 
-  if (table->file->index_read_idx(table->record[0], 0, key, HA_WHOLE_KEY,
-				  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0], 0, key, HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
     DBUG_RETURN(SP_KEY_NOT_FOUND);
 
   DBUG_RETURN(SP_OK);
@@ -1182,9 +1183,9 @@ sp_drop_db_routines(THD *thd, char *db)
 
   ret= SP_OK;
   table->file->ha_index_init(0, 1);
-  if (! table->file->index_read(table->record[0],
-                                (uchar *)table->field[MYSQL_PROC_FIELD_DB]->ptr,
-                                (key_part_map)1, HA_READ_KEY_EXACT))
+  if (! table->file->index_read_map(table->record[0],
+                                    (uchar *)table->field[MYSQL_PROC_FIELD_DB]->ptr,
+                                    (key_part_map)1, HA_READ_KEY_EXACT))
   {
     int nxtres;
     bool deleted= FALSE;
diff --git a/sql/sp_cache.cc b/sql/sp_cache.cc
index 84b15ee15c4..cc6ba9ef1d0 100644
--- a/sql/sp_cache.cc
+++ b/sql/sp_cache.cc
@@ -214,8 +214,12 @@ void sp_cache_flush_obsolete(sp_cache **cp)
   Internal functions 
  *************************************************************************/
 
-static uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
-                                       my_bool first)
+extern "C" uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
+                                           my_bool first);
+extern "C" void hash_free_sp_head(void *p);
+
+uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
+                                my_bool first)
 {
   sp_head *sp= (sp_head *)ptr;
   *plen= sp->m_qname.length;
@@ -223,8 +227,7 @@ static uchar *hash_get_key_for_sp_head(const uchar *ptr, size_t *plen,
 }
 
 
-static void
-hash_free_sp_head(void *p)
+void hash_free_sp_head(void *p)
 {
   sp_head *sp= (sp_head *)p;
   delete sp;
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 7b2073b8de3..b8535ee9958 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -32,6 +32,8 @@
 
 #include <my_user.h>
 
+extern "C" uchar *sp_table_key(const uchar *ptr, size_t *plen, my_bool first);
+
 Item_result
 sp_map_result_type(enum enum_field_types type)
 {
@@ -483,7 +485,6 @@ sp_head::sp_head()
   */
   m_db= m_name= m_qname= str_reset;
 
-  extern uchar *sp_table_key(const uchar *ptr, size_t *plen, my_bool first);
   DBUG_ENTER("sp_head::sp_head");
 
   m_backpatch.empty();
@@ -1078,6 +1079,12 @@ sp_head::execute(THD *thd)
   old_arena= thd->stmt_arena;
 
   /*
+    Switch query context. This has to be done early as this is sometimes
+    allocated trough sql_alloc
+  */
+  saved_creation_ctx= m_creation_ctx->set_n_backup(thd);
+
+  /*
     We have to save/restore this info when we are changing call level to
     be able properly do close_thread_tables() in instructions.
   */
@@ -1122,10 +1129,6 @@ sp_head::execute(THD *thd)
   */
   thd->spcont->callers_arena= &backup_arena;
 
-  /* Switch query context. */
-
-  saved_creation_ctx= m_creation_ctx->set_n_backup(thd);
-
   do
   {
     sp_instr *i;
@@ -3602,8 +3605,8 @@ typedef struct st_sp_table
   uint8 trg_event_map;
 } SP_TABLE;
 
-uchar *
-sp_table_key(const uchar *ptr, size_t *plen, my_bool first)
+
+uchar *sp_table_key(const uchar *ptr, size_t *plen, my_bool first)
 {
   SP_TABLE *tab= (SP_TABLE *)ptr;
   *plen= tab->qname.length;
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 91f1570f653..7e017d7d028 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -1815,9 +1815,9 @@ static bool update_user_table(THD *thd, TABLE *table,
   key_copy((uchar *) user_key, table->record[0], table->key_info,
            table->key_info->key_length);
 
-  if (table->file->index_read_idx(table->record[0], 0,
-				  (uchar *) user_key, HA_WHOLE_KEY,
-				  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0], 0,
+                                      (uchar *) user_key, HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
   {
     my_message(ER_PASSWORD_NO_MATCH, ER(ER_PASSWORD_NO_MATCH),
                MYF(0));	/* purecov: deadcode */
@@ -1908,8 +1908,9 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo,
   key_copy(user_key, table->record[0], table->key_info,
            table->key_info->key_length);
 
-  if (table->file->index_read_idx(table->record[0], 0, user_key, HA_WHOLE_KEY,
-                                  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0], 0, user_key,
+                                      HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
   {
     /* what == 'N' means revoke */
     if (what == 'N')
@@ -2131,8 +2132,9 @@ static int replace_db_table(TABLE *table, const char *db,
   key_copy(user_key, table->record[0], table->key_info,
            table->key_info->key_length);
 
-  if (table->file->index_read_idx(table->record[0],0, user_key, HA_WHOLE_KEY,
-                                  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0],0, user_key,
+                                      HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
   {
     if (what == 'N')
     { // no row, no revoke
@@ -2348,8 +2350,8 @@ GRANT_TABLE::GRANT_TABLE(TABLE *form, TABLE *col_privs)
     col_privs->field[4]->store("",0, &my_charset_latin1);
 
     col_privs->file->ha_index_init(0, 1);
-    if (col_privs->file->index_read(col_privs->record[0], (uchar*) key,
-                                    (key_part_map)15, HA_READ_KEY_EXACT))
+    if (col_privs->file->index_read_map(col_privs->record[0], (uchar*) key,
+                                        (key_part_map)15, HA_READ_KEY_EXACT))
     {
       cols = 0; /* purecov: deadcode */
       col_privs->file->ha_index_end();
@@ -2511,8 +2513,8 @@ static int replace_column_table(GRANT_TABLE *g_t,
     key_copy(user_key, table->record[0], table->key_info,
              table->key_info->key_length);
 
-    if (table->file->index_read(table->record[0], user_key, HA_WHOLE_KEY,
-                                HA_READ_KEY_EXACT))
+    if (table->file->index_read_map(table->record[0], user_key, HA_WHOLE_KEY,
+                                    HA_READ_KEY_EXACT))
     {
       if (revoke_grant)
       {
@@ -2589,8 +2591,9 @@ static int replace_column_table(GRANT_TABLE *g_t,
     key_copy(user_key, table->record[0], table->key_info,
              key_prefix_length);
 
-    if (table->file->index_read(table->record[0], user_key, (key_part_map)15,
-                                HA_READ_KEY_EXACT))
+    if (table->file->index_read_map(table->record[0], user_key,
+                                    (key_part_map)15,
+                                    HA_READ_KEY_EXACT))
       goto end;
 
     /* Scan through all rows with the same host,db,user and table */
@@ -2691,8 +2694,9 @@ static int replace_table_table(THD *thd, GRANT_TABLE *grant_table,
   key_copy(user_key, table->record[0], table->key_info,
            table->key_info->key_length);
 
-  if (table->file->index_read_idx(table->record[0], 0, user_key, HA_WHOLE_KEY,
-				  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0], 0, user_key,
+                                      HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
   {
     /*
       The following should never happen as we first check the in memory
@@ -2816,9 +2820,10 @@ static int replace_routine_table(THD *thd, GRANT_NAME *grant_name,
                          TRUE);
   store_record(table,record[1]);			// store at pos 1
 
-  if (table->file->index_read_idx(table->record[0], 0,
-				  (uchar*) table->field[0]->ptr, HA_WHOLE_KEY,
-				  HA_READ_KEY_EXACT))
+  if (table->file->index_read_idx_map(table->record[0], 0,
+                                      (uchar*) table->field[0]->ptr,
+                                      HA_WHOLE_KEY,
+                                      HA_READ_KEY_EXACT))
   {
     /*
       The following should never happen as we first check the in memory
@@ -5015,9 +5020,9 @@ static int handle_grant_table(TABLE_LIST *tables, uint table_no, bool drop,
                         table->key_info->key_part[1].store_length);
     key_copy(user_key, table->record[0], table->key_info, key_prefix_length);
 
-    if ((error= table->file->index_read_idx(table->record[0], 0,
-                                            user_key, (key_part_map)3,
-                                            HA_READ_KEY_EXACT)))
+    if ((error= table->file->index_read_idx_map(table->record[0], 0,
+                                                user_key, (key_part_map)3,
+                                                HA_READ_KEY_EXACT)))
     {
       if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
       {
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index d5159929ecd..55789a3a233 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -2734,14 +2734,17 @@ void mark_transaction_to_rollback(THD *thd, bool all)
 pthread_mutex_t LOCK_xid_cache;
 HASH xid_cache;
 
-static uchar *xid_get_hash_key(const uchar *ptr, size_t *length,
+extern "C" uchar *xid_get_hash_key(const uchar *, size_t *, my_bool);
+extern "C" void xid_free_hash(void *);
+
+uchar *xid_get_hash_key(const uchar *ptr, size_t *length,
                                   my_bool not_used __attribute__((unused)))
 {
   *length=((XID_STATE*)ptr)->xid.key_length();
   return ((XID_STATE*)ptr)->xid.key();
 }
 
-static void xid_free_hash (void *ptr)
+void xid_free_hash(void *ptr)
 {
   if (!((XID_STATE*)ptr)->in_thd)
     my_free((uchar*)ptr, MYF(0));
@@ -3275,13 +3278,13 @@ int THD::binlog_flush_pending_rows_event(bool stmt_end)
   RETURN VALUE
     Error code, or 0 if no error.
 */
-int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query,
+int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query_arg,
                       ulong query_len, bool is_trans, bool suppress_use,
                       THD::killed_state killed_status_arg)
 {
   DBUG_ENTER("THD::binlog_query");
-  DBUG_PRINT("enter", ("qtype=%d, query='%s'", qtype, query));
-  DBUG_ASSERT(query && mysql_bin_log.is_open());
+  DBUG_PRINT("enter", ("qtype: %d  query: '%s'", qtype, query_arg));
+  DBUG_ASSERT(query_arg && mysql_bin_log.is_open());
 
   /*
     If we are not in prelocked mode, mysql_unlock_tables() will be
@@ -3337,7 +3340,7 @@ int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query,
       flush the pending rows event if necessary.
      */
     {
-      Query_log_event qinfo(this, query, query_len, is_trans, suppress_use,
+      Query_log_event qinfo(this, query_arg, query_len, is_trans, suppress_use,
                             killed_status_arg);
       qinfo.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F;
       /*
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 55987ae8ad9..7117c08a7e1 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -1317,10 +1317,10 @@ public:
     mode, row-based binlogging is used for such cases where two
     auto_increment columns are inserted.
   */
-  inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id)
+  inline void record_first_successful_insert_id_in_cur_stmt(ulonglong id_arg)
   {
     if (first_successful_insert_id_in_cur_stmt == 0)
-      first_successful_insert_id_in_cur_stmt= id;
+      first_successful_insert_id_in_cur_stmt= id_arg;
   }
   inline ulonglong read_first_successful_insert_id_in_prev_stmt(void)
   {
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 23e18f85a3c..15506fcbc80 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -59,8 +59,10 @@ typedef struct my_dblock_st
   lock_db key.
 */
 
-static uchar* lock_db_get_key(my_dblock_t *ptr, size_t *length,
-                              my_bool not_used __attribute__((unused)))
+extern "C" uchar* lock_db_get_key(my_dblock_t *, size_t *, my_bool not_used);
+
+uchar* lock_db_get_key(my_dblock_t *ptr, size_t *length,
+                       my_bool not_used __attribute__((unused)))
 {
   *length= ptr->name_length;
   return (uchar*) ptr->name;
@@ -71,7 +73,9 @@ static uchar* lock_db_get_key(my_dblock_t *ptr, size_t *length,
   Free lock_db hash element.
 */
 
-static void lock_db_free_element(void *ptr)
+extern "C" void lock_db_free_element(void *ptr);
+
+void lock_db_free_element(void *ptr)
 {
   my_free(ptr, MYF(0));
 }
@@ -155,8 +159,11 @@ typedef struct my_dbopt_st
   Function we use in the creation of our hash to get key.
 */
 
-static uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
-                                my_bool not_used __attribute__((unused)))
+extern "C" uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
+                                    my_bool not_used);
+
+uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
+                         my_bool not_used __attribute__((unused)))
 {
   *length= opt->name_length;
   return (uchar*) opt->name;
@@ -182,7 +189,9 @@ static inline void write_to_binlog(THD *thd, char *query, uint q_len,
   Function to free dboptions hash element
 */
 
-static void free_dbopt(void *dbopt)
+extern "C" void free_dbopt(void *dbopt);
+
+void free_dbopt(void *dbopt)
 {
   my_free((uchar*) dbopt, MYF(0));
 }
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 37f1325228d..303918f42a2 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -760,7 +760,7 @@ void multi_delete::send_error(uint errcode,const char *err)
 
 int multi_delete::do_deletes()
 {
-  int local_error= 0, counter= 0, error;
+  int local_error= 0, counter= 0, tmp_error;
   bool will_batch;
   DBUG_ENTER("do_deletes");
   DBUG_ASSERT(do_delete);
@@ -814,11 +814,11 @@ int multi_delete::do_deletes()
         break;
       }
     }
-    if (will_batch && (error= table->file->end_bulk_delete()))
+    if (will_batch && (tmp_error= table->file->end_bulk_delete()))
     {
       if (!local_error)
       {
-        local_error= error;
+        local_error= tmp_error;
         table->file->print_error(local_error,MYF(0));
       }
     }
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index bd3a53c5f1e..8b9896870c0 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -555,8 +555,8 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables,
       table->file->ha_index_or_rnd_end();
       table->file->ha_index_init(keyno, 1);
       key_copy(key, table->record[0], table->key_info + keyno, key_len);
-      error= table->file->index_read(table->record[0],
-                                     key, keypart_map, ha_rkey_mode);
+      error= table->file->index_read_map(table->record[0],
+                                         key, keypart_map, ha_rkey_mode);
       mode=rkey_to_rnext[(int)ha_rkey_mode];
       break;
     }
diff --git a/sql/sql_help.cc b/sql/sql_help.cc
index 023bd1fec94..c1962c8c650 100644
--- a/sql/sql_help.cc
+++ b/sql/sql_help.cc
@@ -294,9 +294,9 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations,
 
   rkey_id->store((longlong) key_id, TRUE);
   rkey_id->get_key_image(buff, rkey_id->pack_length(), Field::itRAW);
-  int key_res= relations->file->index_read(relations->record[0],
-                                           buff, (key_part_map) 1,
-                                           HA_READ_KEY_EXACT);
+  int key_res= relations->file->index_read_map(relations->record[0],
+                                               buff, (key_part_map) 1,
+                                               HA_READ_KEY_EXACT);
 
   for ( ;
         !key_res && key_id == (int16) rkey_id->val_int() ;
@@ -308,8 +308,8 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations,
     field->store((longlong) topic_id, TRUE);
     field->get_key_image(topic_id_buff, field->pack_length(), Field::itRAW);
 
-    if (!topics->file->index_read(topics->record[0], topic_id_buff,
-				  (key_part_map)1, HA_READ_KEY_EXACT))
+    if (!topics->file->index_read_map(topics->record[0], topic_id_buff,
+                                      (key_part_map)1, HA_READ_KEY_EXACT))
     {
       memorize_variant_topic(thd,topics,count,find_fields,
 			     names,name,description,example);
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 36623c1a10f..157309a3366 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -1398,9 +1398,9 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info)
 	  }
 	}
 	key_copy((uchar*) key,table->record[0],table->key_info+key_nr,0);
-	if ((error=(table->file->index_read_idx(table->record[1],key_nr,
-                                                (uchar*) key, HA_WHOLE_KEY,
-						HA_READ_KEY_EXACT))))
+	if ((error=(table->file->index_read_idx_map(table->record[1],key_nr,
+                                                    (uchar*) key, HA_WHOLE_KEY,
+                                                    HA_READ_KEY_EXACT))))
 	  goto err;
       }
       if (info->handle_duplicates == DUP_UPDATE)
@@ -3556,13 +3556,13 @@ select_create::binlog_show_create_table(TABLE **tables, uint count)
   char buf[2048];
   String query(buf, sizeof(buf), system_charset_info);
   int result;
-  TABLE_LIST table_list;
+  TABLE_LIST tmp_table_list;
 
-  memset(&table_list, 0, sizeof(table_list));
-  table_list.table = *tables;
+  memset(&tmp_table_list, 0, sizeof(tmp_table_list));
+  tmp_table_list.table = *tables;
   query.length(0);      // Have to zero it since constructor doesn't
 
-  result= store_create_info(thd, &table_list, &query, create_info);
+  result= store_create_info(thd, &tmp_table_list, &query, create_info);
   DBUG_ASSERT(result == 0); /* store_create_info() always return 0 */
 
   thd->binlog_query(THD::STMT_QUERY_TYPE,
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 78b4f034f98..b8ca8a7bd31 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -2839,8 +2839,8 @@ void st_select_lex::fix_prepare_information(THD *thd, Item **conds,
 
   SYNOPSIS
     set_index_hint_type()
-      type         the kind of hints to be added from now on.
-      clause       the clause to use for hints to be added from now on.
+      type_arg     The kind of hints to be added from now on.
+      clause       The clause to use for hints to be added from now on.
 
   DESCRIPTION
     Used in filling up the tagged hints list.
@@ -2849,10 +2849,10 @@ void st_select_lex::fix_prepare_information(THD *thd, Item **conds,
     Then the context variable index_hint_type can be reset to the
     next hint type.
 */
-void st_select_lex::set_index_hint_type(enum index_hint_type type, 
+void st_select_lex::set_index_hint_type(enum index_hint_type type_arg,
                                         index_clause_map clause)
 { 
-  current_index_hint_type= type;
+  current_index_hint_type= type_arg;
   current_index_hint_clause= clause;
 }
 
diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc
index 56aef9f9b95..2d33da29b77 100644
--- a/sql/sql_plugin.cc
+++ b/sql/sql_plugin.cc
@@ -1058,8 +1058,12 @@ err:
 }
 
 
-static uchar *get_hash_key(const uchar *buff, size_t *length,
-                   my_bool not_used __attribute__((unused)))
+extern "C" uchar *get_plugin_hash_key(const uchar *, size_t *, my_bool);
+extern "C" uchar *get_bookmark_hash_key(const uchar *, size_t *, my_bool);
+
+
+uchar *get_plugin_hash_key(const uchar *buff, size_t *length,
+                           my_bool not_used __attribute__((unused)))
 {
   struct st_plugin_int *plugin= (st_plugin_int *)buff;
   *length= (uint)plugin->name.length;
@@ -1067,8 +1071,8 @@ static uchar *get_hash_key(const uchar *buff, size_t *length,
 }
 
 
-static uchar *get_bookmark_hash_key(const uchar *buff, size_t *length,
-                   my_bool not_used __attribute__((unused)))
+uchar *get_bookmark_hash_key(const uchar *buff, size_t *length,
+                             my_bool not_used __attribute__((unused)))
 {
   struct st_bookmark *var= (st_bookmark *)buff;
   *length= var->name_len + 1;
@@ -1115,7 +1119,7 @@ int plugin_init(int *argc, char **argv, int flags)
   for (i= 0; i < MYSQL_MAX_PLUGIN_TYPE_NUM; i++)
   {
     if (hash_init(&plugin_hash[i], system_charset_info, 16, 0, 0,
-                  get_hash_key, NULL, HASH_UNIQUE))
+                  get_plugin_hash_key, NULL, HASH_UNIQUE))
       goto err;
   }
 
@@ -1702,9 +1706,10 @@ bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name)
 
   table->use_all_columns();
   table->field[0]->store(name->str, name->length, system_charset_info);
-  if (! table->file->index_read_idx(table->record[0], 0,
-                                    (uchar *)table->field[0]->ptr, HA_WHOLE_KEY,
-                                    HA_READ_KEY_EXACT))
+  if (! table->file->index_read_idx_map(table->record[0], 0,
+                                        (uchar *)table->field[0]->ptr,
+                                        HA_WHOLE_KEY,
+                                        HA_READ_KEY_EXACT))
   {
     int error;
     if ((error= table->file->ha_delete_row(table->record[0])))
@@ -2769,8 +2774,10 @@ 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 *);
 
-static my_bool get_one_option(int optid __attribute__((unused)),
+my_bool get_one_plugin_option(int optid __attribute__((unused)),
                               const struct my_option *opt,
                               char *argument)
 {
@@ -3078,7 +3085,7 @@ static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
       DBUG_RETURN(-1);
     }
 
-    error= handle_options(argc, &argv, opts, get_one_option);
+    error= handle_options(argc, &argv, opts, get_one_plugin_option);
     (*argc)++; /* add back one for the program name */
 
     if (error)
@@ -3140,7 +3147,7 @@ static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
     DBUG_RETURN(0);
   }
 
-  if (enabled_saved)
+  if (enabled_saved && global_system_variables.log_warnings)
     sql_print_information("Plugin '%s' disabled by command line option",
                           tmp->name.str);
   DBUG_RETURN(1);
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 5de81898723..3aa490ab7f8 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -11156,10 +11156,10 @@ int safe_index_read(JOIN_TAB *tab)
 {
   int error;
   TABLE *table= tab->table;
-  if ((error=table->file->index_read(table->record[0],
-				     tab->ref.key_buff,
-                                     make_prev_keypart_map(tab->ref.key_parts),
-                                     HA_READ_KEY_EXACT)))
+  if ((error=table->file->index_read_map(table->record[0],
+                                         tab->ref.key_buff,
+                                         make_prev_keypart_map(tab->ref.key_parts),
+                                         HA_READ_KEY_EXACT)))
     return report_error(table, error);
   return 0;
 }
@@ -11295,10 +11295,10 @@ join_read_const(JOIN_TAB *tab)
       error=HA_ERR_KEY_NOT_FOUND;
     else
     {
-      error=table->file->index_read_idx(table->record[0],tab->ref.key,
-					(uchar*) tab->ref.key_buff,
-                                        make_prev_keypart_map(tab->ref.key_parts),
-                                        HA_READ_KEY_EXACT);
+      error=table->file->index_read_idx_map(table->record[0],tab->ref.key,
+                                            (uchar*) tab->ref.key_buff,
+                                            make_prev_keypart_map(tab->ref.key_parts),
+                                            HA_READ_KEY_EXACT);
     }
     if (error)
     {
@@ -11339,10 +11339,10 @@ join_read_key(JOIN_TAB *tab)
       table->status=STATUS_NOT_FOUND;
       return -1;
     }
-    error=table->file->index_read(table->record[0],
-				  tab->ref.key_buff,
-                                  make_prev_keypart_map(tab->ref.key_parts),
-                                  HA_READ_KEY_EXACT);
+    error=table->file->index_read_map(table->record[0],
+                                      tab->ref.key_buff,
+                                      make_prev_keypart_map(tab->ref.key_parts),
+                                      HA_READ_KEY_EXACT);
     if (error && error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
       return report_error(table, error);
   }
@@ -11368,10 +11368,10 @@ join_read_always_key(JOIN_TAB *tab)
   }
   if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
     return -1;
-  if ((error=table->file->index_read(table->record[0],
-				     tab->ref.key_buff,
-                                     make_prev_keypart_map(tab->ref.key_parts),
-                                     HA_READ_KEY_EXACT)))
+  if ((error=table->file->index_read_map(table->record[0],
+                                         tab->ref.key_buff,
+                                         make_prev_keypart_map(tab->ref.key_parts),
+                                         HA_READ_KEY_EXACT)))
   {
     if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
       return report_error(table, error);
@@ -11396,8 +11396,9 @@ join_read_last_key(JOIN_TAB *tab)
     table->file->ha_index_init(tab->ref.key, tab->sorted);
   if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
     return -1;
-  if ((error=table->file->index_read_last(table->record[0],
-                tab->ref.key_buff, make_prev_keypart_map(tab->ref.key_parts))))
+  if ((error=table->file->index_read_last_map(table->record[0],
+                                              tab->ref.key_buff,
+                                              make_prev_keypart_map(tab->ref.key_parts))))
   {
     if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
       return report_error(table, error);
@@ -11938,9 +11939,10 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
     if (item->maybe_null)
       group->buff[-1]= (char) group->field->is_null();
   }
-  if (!table->file->index_read(table->record[1],
-			       join->tmp_table_param.group_buff, HA_WHOLE_KEY,
-			       HA_READ_KEY_EXACT))
+  if (!table->file->index_read_map(table->record[1],
+                                   join->tmp_table_param.group_buff,
+                                   HA_WHOLE_KEY,
+                                   HA_READ_KEY_EXACT))
   {						/* Update old record */
     restore_record(table,record[1]);
     update_tmptable_sum_func(join->sum_funcs,table);
diff --git a/sql/sql_servers.cc b/sql/sql_servers.cc
index 911372d5f4e..a780c561ffe 100644
--- a/sql/sql_servers.cc
+++ b/sql/sql_servers.cc
@@ -516,9 +516,10 @@ int insert_server_record(TABLE *table, FOREIGN_SERVER *server)
                          system_charset_info);
 
   /* read index until record is that specified in server_name */
-  if ((error= table->file->index_read_idx(table->record[0], 0,
-                                   (uchar *)table->field[0]->ptr, HA_WHOLE_KEY,
-                                   HA_READ_KEY_EXACT)))
+  if ((error= table->file->index_read_idx_map(table->record[0], 0,
+                                              (uchar *)table->field[0]->ptr,
+                                              HA_WHOLE_KEY,
+                                              HA_READ_KEY_EXACT)))
   {
     /* if not found, err */
     if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
@@ -858,9 +859,10 @@ update_server_record(TABLE *table, FOREIGN_SERVER *server)
                          server->server_name_length,
                          system_charset_info);
 
-  if ((error= table->file->index_read_idx(table->record[0], 0,
-                                   (uchar *)table->field[0]->ptr, ~(longlong)0,
-                                   HA_READ_KEY_EXACT)))
+  if ((error= table->file->index_read_idx_map(table->record[0], 0,
+                                              (uchar *)table->field[0]->ptr,
+                                              ~(longlong)0,
+                                              HA_READ_KEY_EXACT)))
   {
     if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
       table->file->print_error(error, MYF(0));
@@ -914,9 +916,10 @@ delete_server_record(TABLE *table,
   /* set the field that's the PK to the value we're looking for */
   table->field[0]->store(server_name, server_name_length, system_charset_info);
 
-  if ((error= table->file->index_read_idx(table->record[0], 0,
-                                   (uchar *)table->field[0]->ptr, HA_WHOLE_KEY,
-                                   HA_READ_KEY_EXACT)))
+  if ((error= table->file->index_read_idx_map(table->record[0], 0,
+                                          (uchar *)table->field[0]->ptr,
+                                          HA_WHOLE_KEY,
+                                          HA_READ_KEY_EXACT)))
   {
     if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
       table->file->print_error(error, MYF(0));
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 9df652a679e..1079c1e3d98 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -1356,6 +1356,11 @@ int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet,
       packet->append(STRING_WITH_LEN(" ROW_FORMAT="));
       packet->append(ha_row_type[(uint) share->row_type]);
     }
+    if (share->transactional != HA_CHOICE_UNDEF)
+    {
+      packet->append(STRING_WITH_LEN(" TRANSACTIONAL="));
+      packet->append(share->transactional == HA_CHOICE_YES ? "1" : "0", 1);
+    }
     if (table->s->key_block_size)
     {
       char *end;
@@ -2952,49 +2957,70 @@ static int fill_schema_table_from_frm(THD *thd,TABLE *table,
                                       LEX_STRING *table_name,
                                       enum enum_schema_tables schema_table_idx)
 {
-  TABLE_SHARE share;
+  TABLE_SHARE *share;
   TABLE tbl;
   TABLE_LIST table_list;
-  char path[FN_REFLEN];
-  uint res;
+  uint res= 0;
+  int error;
+  char key[MAX_DBKEY_LENGTH];
+  uint key_length;
+
   bzero((char*) &table_list, sizeof(TABLE_LIST));
   bzero((char*) &tbl, sizeof(TABLE));
-  (void) build_table_filename(path, sizeof(path), db_name->str,
-                              table_name->str, "", 0);
-  init_tmp_table_share(&share, "", 0, "", path);
-  if (!(res= open_table_def(thd, &share, OPEN_VIEW)))
+
+  table_list.table_name= table_name->str;
+  table_list.db= db_name->str;
+  key_length= create_table_def_key(thd, key, &table_list, 0);
+  pthread_mutex_lock(&LOCK_open);
+  share= get_table_share(thd, &table_list, key,
+                         key_length, OPEN_VIEW, &error);
+  if (!share)
   {
-    share.tmp_table= NO_TMP_TABLE;
-    tbl.s= &share;
-    table_list.table= &tbl;
-    if (schema_table->i_s_requested_object & OPEN_TABLE_FROM_SHARE)
+    res= 0;
+    goto err;
+  }
+ 
+  if (share->is_view)
+  {
+    if (schema_table->i_s_requested_object & OPEN_TABLE_ONLY)
     {
-      if (share.is_view ||
-          open_table_from_share(thd, &share, table_name->str, 0,
-                                (READ_KEYINFO | COMPUTE_TYPES |
-                                 EXTRA_RECORD | OPEN_FRM_FILE_ONLY),
-                                thd->open_options, &tbl, FALSE))
-      {
-        share.tmp_table= INTERNAL_TMP_TABLE;
-        free_table_share(&share);
-        return (share.is_view && 
-                !(schema_table->i_s_requested_object & 
-                  ~(OPEN_TABLE_FROM_SHARE|OPTIMIZE_I_S_TABLE)));
-      }
+      /* skip view processing */
+      res= 0;
+      goto err1;
     }
-    table_list.view= (st_lex*) share.is_view;
+    else if (schema_table->i_s_requested_object & OPEN_VIEW_FULL)
+    {
+      /*
+        tell get_all_tables() to fall back to 
+        open_normal_and_derived_tables()
+      */
+      res= 1;
+      goto err1;
+    }
+  }
+
+  if (share->is_view ||
+      !open_table_from_share(thd, share, table_name->str, 0,
+                             (READ_KEYINFO | COMPUTE_TYPES |
+                              EXTRA_RECORD | OPEN_FRM_FILE_ONLY),
+                             thd->open_options, &tbl, FALSE))
+  {
+    tbl.s= share;
+    table_list.table= &tbl;
+    table_list.view= (st_lex*) share->is_view;
     res= schema_table->process_table(thd, &table_list, table,
                                      res, db_name, table_name);
-    share.tmp_table= INTERNAL_TMP_TABLE;
-    if (schema_table->i_s_requested_object & OPEN_TABLE_FROM_SHARE)
-      closefrm(&tbl, true);
-    else
-      free_table_share(&share);
+    closefrm(&tbl, true);
+    goto err;
   }
 
-  if (res)
-    thd->clear_error();
-  return 0;
+err1:
+  release_table_share(share, RELEASE_NORMAL);
+
+err:
+  pthread_mutex_unlock(&LOCK_open);
+  thd->clear_error();
+  return res;
 }
 
 
@@ -3033,7 +3059,7 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond)
   enum enum_schema_tables schema_table_idx;
   List<LEX_STRING> db_names;
   List_iterator_fast<LEX_STRING> it(db_names);
-  COND *partial_cond;
+  COND *partial_cond= 0;
   uint derived_tables= lex->derived_tables; 
   int error= 1;
   Open_tables_state open_tables_state_backup;
@@ -3072,20 +3098,35 @@ int get_all_tables(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 (lookup_field_vals.db_value.length &&
-      !lookup_field_vals.wild_db_value &&
-      lookup_field_vals.table_value.length &&
-      !lookup_field_vals.wild_table_value)
-    partial_cond= 0; 
-  else
-    partial_cond= make_cond_for_info_schema(cond, tables);
 
-  if (lookup_field_vals.db_value.length && !lookup_field_vals.wild_db_value)
+  if (!lookup_field_vals.wild_db_value && !lookup_field_vals.wild_table_value)
+  {
+    /* 
+      if lookup value is empty string then
+      it's impossible table name or db name
+    */
+    if (lookup_field_vals.db_value.str &&
+        !lookup_field_vals.db_value.str[0] ||
+        lookup_field_vals.table_value.str &&
+        !lookup_field_vals.table_value.str[0])
+    {
+      error= 0;
+      goto err;
+    }
+  }
+
+  if (lookup_field_vals.db_value.length &&
+      !lookup_field_vals.wild_db_value)
     tables->has_db_lookup_value= TRUE;
   if (lookup_field_vals.table_value.length &&
       !lookup_field_vals.wild_table_value) 
     tables->has_table_lookup_value= TRUE;
 
+  if (tables->has_db_lookup_value && tables->has_table_lookup_value)
+    partial_cond= 0;
+  else
+    partial_cond= make_cond_for_info_schema(cond, tables);
+
   tables->table_open_method= table_open_method=
     get_table_open_method(tables, schema_table, schema_table_idx);
 
@@ -3250,7 +3291,7 @@ bool store_schema_shemata(THD* thd, TABLE *table, LEX_STRING *db_name,
 }
 
 
-int fill_schema_shemata(THD *thd, TABLE_LIST *tables, COND *cond)
+int fill_schema_schemata(THD *thd, TABLE_LIST *tables, COND *cond)
 {
   /*
     TODO: fill_schema_shemata() is called when new client is connected.
@@ -3276,6 +3317,23 @@ int fill_schema_shemata(THD *thd, TABLE_LIST *tables, COND *cond)
                    &with_i_schema))
     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)
+  {
+    char path[FN_REFLEN+16];
+    uint path_len;
+    MY_STAT stat_info;
+    if (!lookup_field_vals.db_value.str[0])
+      DBUG_RETURN(0);
+    path_len= build_table_filename(path, sizeof(path),
+                                   lookup_field_vals.db_value.str, "", "", 0);
+    path[path_len-1]= 0;
+    if (!my_stat(path,&stat_info,MYF(0)))
+      DBUG_RETURN(0);
+  }
+
   List_iterator_fast<LEX_STRING> it(db_names);
   while ((db_name=it++))
   {
@@ -3393,6 +3451,12 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
       ptr=strxmov(ptr, " row_format=", 
                   ha_row_type[(uint) share->row_type],
                   NullS);
+    if (share->transactional != HA_CHOICE_UNDEF)
+    {
+      ptr= strxmov(ptr, " TRANSACTIONAL=",
+                   (share->transactional == HA_CHOICE_YES ? "1" : "0"),
+                   NullS);
+    }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
     if (show_table->s->db_type() == partition_hton && 
         show_table->part_info != NULL && 
@@ -3434,7 +3498,7 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
       case ROW_TYPE_COMPACT:
         tmp_buff= "Compact";
         break;
-      case ROW_TYPE_PAGES:
+      case ROW_TYPE_PAGE:
         tmp_buff= "Paged";
         break;
       }
@@ -6398,7 +6462,7 @@ ST_SCHEMA_TABLE schema_tables[]=
    create_schema_table, fill_schema_coll_charset_app, 0, 0, -1, -1, 0, 0},
   {"COLUMNS", columns_fields_info, create_schema_table, 
    get_all_tables, make_columns_old_format, get_schema_column_record, 1, 2, 0,
-   OPEN_TABLE_FROM_SHARE|OPTIMIZE_I_S_TABLE},
+   OPTIMIZE_I_S_TABLE|OPEN_VIEW_FULL},
   {"COLUMN_PRIVILEGES", column_privileges_fields_info, create_schema_table,
    fill_schema_column_privileges, 0, 0, -1, -1, 0, 0},
   {"ENGINES", engines_fields_info, create_schema_table,
@@ -6428,7 +6492,7 @@ ST_SCHEMA_TABLE schema_tables[]=
   {"ROUTINES", proc_fields_info, create_schema_table, 
    fill_schema_proc, make_proc_old_format, 0, -1, -1, 0, 0},
   {"SCHEMATA", schema_fields_info, create_schema_table,
-   fill_schema_shemata, make_schemata_old_format, 0, 1, -1, 0, 0},
+   fill_schema_schemata, make_schemata_old_format, 0, 1, -1, 0, 0},
   {"SCHEMA_PRIVILEGES", schema_privileges_fields_info, create_schema_table,
    fill_schema_schema_privileges, 0, 0, -1, -1, 0, 0},
   {"SESSION_STATUS", variables_fields_info, create_schema_table,
@@ -6437,7 +6501,7 @@ ST_SCHEMA_TABLE schema_tables[]=
    fill_variables, make_old_format, 0, -1, -1, 0, 0},
   {"STATISTICS", stat_fields_info, create_schema_table, 
    get_all_tables, make_old_format, get_schema_stat_record, 1, 2, 0,
-   OPEN_TABLE_ONLY|OPEN_TABLE_FROM_SHARE|OPTIMIZE_I_S_TABLE},
+   OPEN_TABLE_ONLY|OPTIMIZE_I_S_TABLE},
   {"STATUS", variables_fields_info, create_schema_table, fill_status, 
    make_old_format, 0, -1, -1, 1, 0},
   {"TABLES", tables_fields_info, create_schema_table, 
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index 6c7dea6bf22..a8eb7360339 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -795,10 +795,8 @@ copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
   const uchar *from_end= (const uchar*) from+from_length;
   char *to_start= to;
   uchar *to_end= (uchar*) to+to_length;
-  int (*mb_wc)(struct charset_info_st *, my_wc_t *, const uchar *,
-	       const uchar *) = from_cs->cset->mb_wc;
-  int (*wc_mb)(struct charset_info_st *, my_wc_t, uchar *s, uchar *e)=
-    to_cs->cset->wc_mb;
+  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
+  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
   uint error_count= 0;
 
   while (1)
@@ -940,10 +938,8 @@ well_formed_copy_nchars(CHARSET_INFO *to_cs,
   {
     int cnvres;
     my_wc_t wc;
-    int (*mb_wc)(struct charset_info_st *, my_wc_t *,
-                 const uchar *, const uchar *)= from_cs->cset->mb_wc;
-    int (*wc_mb)(struct charset_info_st *, my_wc_t,
-                 uchar *s, uchar *e)= to_cs->cset->wc_mb;
+    my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
+    my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
     const uchar *from_end= (const uchar*) from + from_length;
     uchar *to_end= (uchar*) to + to_length;
     char *to_start= to;
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 17544b8ccde..cd39623f2b4 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -5292,6 +5292,8 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
   }
   if (!(used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE))
     create_info->key_block_size= table->s->key_block_size;
+  if (!(used_fields & HA_CREATE_USED_TRANSACTIONAL))
+    create_info->transactional= table->s->transactional;
 
   if (!create_info->tablespace && create_info->storage_media != HA_SM_MEMORY)
   {
diff --git a/sql/sql_udf.cc b/sql/sql_udf.cc
index 10bb7844d88..19582af38f4 100644
--- a/sql/sql_udf.cc
+++ b/sql/sql_udf.cc
@@ -551,9 +551,10 @@ int mysql_drop_function(THD *thd,const LEX_STRING *udf_name)
     goto err;
   table->use_all_columns();
   table->field[0]->store(exact_name_str, exact_name_len, &my_charset_bin);
-  if (!table->file->index_read_idx(table->record[0], 0,
-				   (uchar*) table->field[0]->ptr, HA_WHOLE_KEY,
-				   HA_READ_KEY_EXACT))
+  if (!table->file->index_read_idx_map(table->record[0], 0,
+                                       (uchar*) table->field[0]->ptr,
+                                       HA_WHOLE_KEY,
+                                       HA_READ_KEY_EXACT))
   {
     int error;
     if ((error = table->file->ha_delete_row(table->record[0])))
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 8f66e41b338..8c3ad9a6300 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -874,6 +874,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  OUT_SYM                       /* SQL-2003-R */
 %token  OWNER_SYM
 %token  PACK_KEYS_SYM
+%token  PAGE_SYM
 %token  PARAM_MARKER
 %token  PARSER_SYM
 %token  PARTIAL                       /* SQL-2003-N */
@@ -1026,6 +1027,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  TO_SYM                        /* SQL-2003-R */
 %token  TRAILING                      /* SQL-2003-R */
 %token  TRANSACTION_SYM
+%token  TRANSACTIONAL_SYM
 %token  TRIGGERS_SYM
 %token  TRIGGER_SYM                   /* SQL-2003-R */
 %token  TRIM                          /* SQL-2003-N */
@@ -4493,6 +4495,12 @@ create_table_option:
             Lex->create_info.used_fields|= HA_CREATE_USED_KEY_BLOCK_SIZE;
             Lex->create_info.key_block_size= $3;
           }
+        | TRANSACTIONAL_SYM opt_equal ulong_num
+          {
+	    Lex->create_info.used_fields|= HA_CREATE_USED_TRANSACTIONAL;
+            Lex->create_info.transactional= ($3 != 0 ? HA_CHOICE_YES :
+        				     HA_CHOICE_NO);
+          }
         ;
 
 default_charset:
@@ -4574,6 +4582,8 @@ row_types:
         | COMPRESSED_SYM { $$= ROW_TYPE_COMPRESSED; }
         | REDUNDANT_SYM  { $$= ROW_TYPE_REDUNDANT; }
         | COMPACT_SYM    { $$= ROW_TYPE_COMPACT; }
+	| COMPACT_SYM    { $$= ROW_TYPE_COMPACT; }
+	| PAGE_SYM       { $$= ROW_TYPE_PAGE; }
         ;
 
 merge_insert_types:
@@ -10503,6 +10513,7 @@ keyword_sp:
         | ONE_SHOT_SYM             {}
         | ONE_SYM                  {}
         | PACK_KEYS_SYM            {}
+        | PAGE_SYM                 {}
         | PARTIAL                  {}
         | PARTITIONING_SYM         {}
         | PARTITIONS_SYM           {}
@@ -10572,6 +10583,7 @@ keyword_sp:
         | TEXT_SYM                 {}
         | THAN_SYM                 {}
         | TRANSACTION_SYM          {}
+        | TRANSACTIONAL_SYM        {}
         | TRIGGERS_SYM             {}
         | TIMESTAMP                {}
         | TIMESTAMP_ADD            {}
diff --git a/sql/strfunc.cc b/sql/strfunc.cc
index 9ffc5fd127f..c03365cfc2b 100644
--- a/sql/strfunc.cc
+++ b/sql/strfunc.cc
@@ -265,10 +265,8 @@ uint strconvert(CHARSET_INFO *from_cs, const char *from,
   my_wc_t wc;
   char *to_start= to;
   uchar *to_end= (uchar*) to + to_length - 1;
-  int (*mb_wc)(struct charset_info_st *, my_wc_t *, const uchar *,
-	       const uchar *)= from_cs->cset->mb_wc;
-  int (*wc_mb)(struct charset_info_st *, my_wc_t, uchar *s, uchar *e)=
-    to_cs->cset->wc_mb;
+  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
+  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
   uint error_count= 0;
 
   while (1)
diff --git a/sql/table.cc b/sql/table.cc
index 27f9ccc418e..c1d8e3abe94 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -51,11 +51,13 @@ inline bool is_system_table_name(const char *name, uint length);
 
 Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
 {
-  Object_creation_ctx *backup_ctx= create_backup_ctx(thd);
+  Object_creation_ctx *backup_ctx;
+  DBUG_ENTER("Object_creation_ctx::set_n_backup");
 
+  backup_ctx= create_backup_ctx(thd);
   change_env(thd);
 
-  return backup_ctx;
+  DBUG_RETURN(backup_ctx);
 }
 
 void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)
@@ -84,7 +86,7 @@ Default_object_creation_ctx::Default_object_creation_ctx(
 { }
 
 Object_creation_ctx *
-Default_object_creation_ctx::create_backup_ctx(THD *thd)
+Default_object_creation_ctx::create_backup_ctx(THD *thd) const
 {
   return new Default_object_creation_ctx(thd);
 }
@@ -703,7 +705,8 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
   if (!head[32])				// New frm file in 3.23
   {
     share->avg_row_length= uint4korr(head+34);
-    share-> row_type= (row_type) head[40];
+    share->transactional= (ha_choice) head[39];
+    share->row_type= (row_type) head[40];
     share->table_charset= get_charset((uint) head[38],MYF(0));
     share->null_field_first= 1;
   }
@@ -1750,7 +1753,7 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
   }
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-  if (share->partition_info_len)
+  if (share->partition_info_len && outparam->file)
   {
   /*
     In this execution we must avoid calling thd->change_item_tree since
@@ -2433,6 +2436,7 @@ File create_frm(THD *thd, const char *name, const char *db,
     int4store(fileinfo+34,create_info->avg_row_length);
     fileinfo[38]= (create_info->default_table_charset ?
 		   create_info->default_table_charset->number : 0);
+    fileinfo[39]= (uchar) create_info->transactional;
     fileinfo[40]= (uchar) create_info->row_type;
     /* Next few bytes were for RAID support */
     fileinfo[41]= 0;
@@ -4565,11 +4569,11 @@ Item_subselect *TABLE_LIST::containing_subselect()
     FALSE                no errors found
     TRUE                 found and reported an error.
 */
-bool TABLE_LIST::process_index_hints(TABLE *table)
+bool TABLE_LIST::process_index_hints(TABLE *tbl)
 {
   /* initialize the result variables */
-  table->keys_in_use_for_query= table->keys_in_use_for_group_by= 
-    table->keys_in_use_for_order_by= table->s->keys_in_use;
+  tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by= 
+    tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;
 
   /* index hint list processing */
   if (index_hints)
@@ -4621,8 +4625,8 @@ bool TABLE_LIST::process_index_hints(TABLE *table)
         Check if an index with the given name exists and get his offset in 
         the keys bitmask for the table 
       */
-      if (table->s->keynames.type_names == 0 ||
-          (pos= find_type(&table->s->keynames, hint->key_name.str,
+      if (tbl->s->keynames.type_names == 0 ||
+          (pos= find_type(&tbl->s->keynames, hint->key_name.str,
                           hint->key_name.length, 1)) <= 0)
       {
         my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);
@@ -4658,7 +4662,7 @@ bool TABLE_LIST::process_index_hints(TABLE *table)
         !index_order[INDEX_HINT_FORCE].is_clear_all() ||
         !index_group[INDEX_HINT_FORCE].is_clear_all())
     {
-      table->force_index= TRUE;
+      tbl->force_index= TRUE;
       index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
       index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
       index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
@@ -4666,20 +4670,20 @@ bool TABLE_LIST::process_index_hints(TABLE *table)
 
     /* apply USE INDEX */
     if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
-      table->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
+      tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
     if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
-      table->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
+      tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
     if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
-      table->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
+      tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
 
     /* apply IGNORE INDEX */
-    table->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
-    table->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
-    table->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
+    tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
+    tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
+    tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
   }
 
   /* make sure covering_keys don't include indexes disabled with a hint */
-  table->covering_keys.intersect(table->keys_in_use_for_query);
+  tbl->covering_keys.intersect(tbl->keys_in_use_for_query);
   return 0;
 }
 
diff --git a/sql/table.h b/sql/table.h
index 5ef2467341a..6554b6ed578 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -310,6 +310,7 @@ typedef struct st_table_share
   }
   enum row_type row_type;		/* How rows are stored */
   enum tmp_table_type tmp_table;
+  enum ha_choice transactional;
 
   uint ref_count;                       /* How many TABLE objects uses this */
   uint open_count;			/* Number of tables in open list */
diff --git a/sql/tztime.cc b/sql/tztime.cc
index 14192d06978..9eb38e97827 100644
--- a/sql/tztime.cc
+++ b/sql/tztime.cc
@@ -1854,8 +1854,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
   */
   (void)table->file->ha_index_init(0, 1);
 
-  if (table->file->index_read(table->record[0], table->field[0]->ptr,
-                              HA_WHOLE_KEY, HA_READ_KEY_EXACT))
+  if (table->file->index_read_map(table->record[0], table->field[0]->ptr,
+                                  HA_WHOLE_KEY, HA_READ_KEY_EXACT))
   {
 #ifdef EXTRA_DEBUG
     /*
@@ -1881,8 +1881,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
   table->field[0]->store((longlong) tzid, TRUE);
   (void)table->file->ha_index_init(0, 1);
 
-  if (table->file->index_read(table->record[0], table->field[0]->ptr,
-                              HA_WHOLE_KEY, HA_READ_KEY_EXACT))
+  if (table->file->index_read_map(table->record[0], table->field[0]->ptr,
+                                  HA_WHOLE_KEY, HA_READ_KEY_EXACT))
   {
     sql_print_error("Can't find description of time zone '%u'", tzid);
     goto end;
@@ -1908,8 +1908,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
   table->field[0]->store((longlong) tzid, TRUE);
   (void)table->file->ha_index_init(0, 1);
 
-  res= table->file->index_read(table->record[0], table->field[0]->ptr,
-                               (key_part_map)1, HA_READ_KEY_EXACT);
+  res= table->file->index_read_map(table->record[0], table->field[0]->ptr,
+                                   (key_part_map)1, HA_READ_KEY_EXACT);
   while (!res)
   {
     ttid= (uint)table->field[1]->val_int();
@@ -1979,8 +1979,8 @@ tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
   table->field[0]->store((longlong) tzid, TRUE);
   (void)table->file->ha_index_init(0, 1);
 
-  res= table->file->index_read(table->record[0], table->field[0]->ptr,
-                               (key_part_map)1, HA_READ_KEY_EXACT);
+  res= table->file->index_read_map(table->record[0], table->field[0]->ptr,
+                                   (key_part_map)1, HA_READ_KEY_EXACT);
   while (!res)
   {
     ttime= (my_time_t)table->field[1]->val_int();
diff --git a/sql/unireg.h b/sql/unireg.h
index b368eee6f0e..f0b4a88c7f8 100644
--- a/sql/unireg.h
+++ b/sql/unireg.h
@@ -155,11 +155,40 @@
 #define OPEN_VIEW		8192	/* Allow open on view */
 #define OPEN_VIEW_NO_PARSE     16384    /* Open frm only if it's a view,
                                            but do not parse view itself */
-#define OPEN_FRM_FILE_ONLY     32768    /* Open frm file only */
-#define OPEN_TABLE_ONLY        OPEN_FRM_FILE_ONLY*2 /* Open view only */
-#define OPEN_VIEW_ONLY         OPEN_TABLE_ONLY*2    /* Open table only */
-#define OPEN_TABLE_FROM_SHARE  OPEN_VIEW_ONLY*2     /* For I_S tables*/
-#define OPTIMIZE_I_S_TABLE     OPEN_TABLE_FROM_SHARE*2 /* For I_S tables*/
+/*
+  This flag is used in function get_all_tables() which fills
+  I_S tables with data which are retrieved from frm files and storage engine
+  The flag means that we need to open FRM file only to get necessary data.
+*/
+#define OPEN_FRM_FILE_ONLY     32768
+/*
+  This flag is used in function get_all_tables() which fills
+  I_S tables with data which are retrieved from frm files and storage engine
+  The flag means that we need to process tables only to get necessary data.
+  Views are not processed.
+*/
+#define OPEN_TABLE_ONLY        OPEN_FRM_FILE_ONLY*2
+/*
+  This flag is used in function get_all_tables() which fills
+  I_S tables with data which are retrieved from frm files and storage engine
+  The flag means that we need to process views only to get necessary data.
+  Tables are not processed.
+*/
+#define OPEN_VIEW_ONLY         OPEN_TABLE_ONLY*2
+/*
+  This flag is used in function get_all_tables() which fills
+  I_S tables with data which are retrieved from frm files and storage engine.
+  The flag means that we need to open a view using
+  open_normal_and_derived_tables() function.
+*/
+#define OPEN_VIEW_FULL         OPEN_VIEW_ONLY*2
+/*
+  This flag is used in function get_all_tables() which fills
+  I_S tables with data which are retrieved from frm files and storage engine.
+  The flag means that I_S table uses optimization algorithm.
+*/
+#define OPTIMIZE_I_S_TABLE     OPEN_VIEW_FULL*2
+
 #define SC_INFO_LENGTH 4		/* Form format constant */
 #define TE_INFO_LENGTH 3
 #define MTYP_NOEMPTY_BIT 128