Vanilla cleanups and refactorings

Dead code cleanup:

part_info->num_parts usage was wrong and working incorrectly in
mysql_drop_partitions() because num_parts is already updated in
prep_alter_part_table(). We don't have to update part_info->partitions
because part_info is destroyed at alter_partition_lock_handling().

Cleanups:

- DBUG_EVALUATE_IF() macro replaced by shorter form DBUG_IF();
- Typo in ER_KEY_COLUMN_DOES_NOT_EXITS.

Refactorings:

- Splitted write_log_replace_delete_frm() into write_log_delete_frm()
  and write_log_replace_frm();
- partition_info via DDL_LOG_STATE;
- set_part_info_exec_log_entry() removed.

DBUG_EVALUATE removed

DBUG_EVALUTATE was only added for consistency together with
DBUG_EVALUATE_IF. It is not used anywhere in the code.

DBUG_SUICIDE() fix on release build

On release DBUG_SUICIDE() was statement. It was wrong as
DBUG_SUICIDE() is used in expression context.

20 files changed, 160 insertions, 195 deletions

diff --git a/sql/ddl_log.cc b/sql/ddl_log.cc
index e5ed0caaeaf..ea33f075938 100644
--- a/sql/ddl_log.cc
+++ b/sql/ddl_log.cc
@@ -2857,8 +2857,7 @@ void ddl_log_release()
    Methods for DDL_LOG_STATE
 */
 
-static void add_log_entry(DDL_LOG_STATE *state,
-                          DDL_LOG_MEMORY_ENTRY *log_entry)
+void ddl_log_add_entry(DDL_LOG_STATE *state, DDL_LOG_MEMORY_ENTRY *log_entry)
 {
   log_entry->next_active_log_entry= state->list;
   state->main_entry= state->list= log_entry;
@@ -3037,7 +3036,7 @@ static bool ddl_log_write(DDL_LOG_STATE *ddl_state,
       ddl_log_release_memory_entry(log_entry);
     DBUG_RETURN(1);
   }
-  add_log_entry(ddl_state, log_entry);
+  ddl_log_add_entry(ddl_state, log_entry);
   ddl_state->flags|= ddl_log_entry->flags;      // Update cache
   DBUG_RETURN(0);
 }
@@ -3187,7 +3186,7 @@ static bool ddl_log_drop(THD *thd, DDL_LOG_STATE *ddl_state,
   }
 
   mysql_mutex_unlock(&LOCK_gdl);
-  add_log_entry(ddl_state, log_entry);
+  ddl_log_add_entry(ddl_state, log_entry);
   DBUG_RETURN(0);
 
 error:
@@ -3487,7 +3486,7 @@ bool ddl_log_store_query(THD *thd, DDL_LOG_STATE *ddl_state,
     goto err;
   parent_entry_pos= ddl_state->list->entry_pos;
   entry_pos= first_entry->entry_pos;
-  add_log_entry(ddl_state, first_entry);
+  ddl_log_add_entry(ddl_state, first_entry);
 
   while (length)
   {
@@ -3503,7 +3502,7 @@ bool ddl_log_store_query(THD *thd, DDL_LOG_STATE *ddl_state,
       if (ddl_log_get_free_entry(&next_entry))
         goto err;
       ddl_log_entry.next_entry= next_entry_pos= next_entry->entry_pos;
-      add_log_entry(ddl_state, next_entry);
+      ddl_log_add_entry(ddl_state, next_entry);
     }
     else
     {
diff --git a/sql/ddl_log.h b/sql/ddl_log.h
index a2a6af76a77..afdd775d7a0 100644
--- a/sql/ddl_log.h
+++ b/sql/ddl_log.h
@@ -279,6 +279,7 @@ void ddl_log_release_memory_entry(DDL_LOG_MEMORY_ENTRY *log_entry);
 bool ddl_log_sync();
 bool ddl_log_execute_entry(THD *thd, uint first_entry);
 
+void ddl_log_add_entry(DDL_LOG_STATE *state, DDL_LOG_MEMORY_ENTRY *log_entry);
 void ddl_log_release_entries(DDL_LOG_STATE *ddl_log_state);
 bool ddl_log_rename_table(THD *thd, DDL_LOG_STATE *ddl_state,
                           handlerton *hton,
diff --git a/sql/handler.cc b/sql/handler.cc
index 0b9df1c010b..3e88ec39b68 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -8236,7 +8236,7 @@ static Create_field *vers_init_sys_field(THD *thd, const char *field_name, int f
     f->set_handler(&type_handler_timestamp2);
     f->length= MAX_DATETIME_PRECISION;
   }
-  f->invisible= DBUG_EVALUATE_IF("sysvers_show", VISIBLE, INVISIBLE_SYSTEM);
+  f->invisible= DBUG_IF("sysvers_show") ? VISIBLE : INVISIBLE_SYSTEM;
 
   if (f->check(thd))
     return NULL;
@@ -8382,7 +8382,7 @@ bool Vers_parse_info::fix_alter_info(THD *thd, Alter_info *alter_info,
   if (!need_check(alter_info) && !share->versioned)
     return false;
 
-  if (DBUG_EVALUATE_IF("sysvers_force", 0, share->tmp_table))
+  if (!DBUG_IF("sysvers_force") && share->tmp_table)
   {
     my_error(ER_VERS_NOT_SUPPORTED, MYF(0), "CREATE TEMPORARY TABLE");
     return true;
diff --git a/sql/log.cc b/sql/log.cc
index 6a0b7a63e66..969e2820975 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -2973,7 +2973,7 @@ int MYSQL_BIN_LOG::generate_new_name(char *new_name, const char *log_name,
   fn_format(new_name, log_name, mysql_data_home, "", 4);
   if (!fn_ext(log_name)[0])
   {
-    if (DBUG_EVALUATE_IF("binlog_inject_new_name_error", TRUE, FALSE) ||
+    if (DBUG_IF("binlog_inject_new_name_error") ||
         unlikely(find_uniq_filename(new_name, next_log_number,
                                     &last_used_log_number)))
     {
@@ -3543,7 +3543,7 @@ bool MYSQL_BIN_LOG::open_index_file(const char *index_file_name_arg,
                      mysql_file_seek(index_file_nr, 0L, MY_SEEK_END, MYF(0)),
                                      0, MYF(MY_WME | MY_WAIT_IF_FULL),
                                      m_key_file_log_index_cache) ||
-      DBUG_EVALUATE_IF("fault_injection_openning_index", 1, 0))
+      DBUG_IF("fault_injection_openning_index"))
   {
     /*
       TODO: all operations creating/deleting the index file or a log, should
@@ -3569,7 +3569,7 @@ bool MYSQL_BIN_LOG::open_index_file(const char *index_file_name_arg,
       open_purge_index_file(FALSE) ||
       purge_index_entry(NULL, NULL, need_mutex) ||
       close_purge_index_file() ||
-      DBUG_EVALUATE_IF("fault_injection_recovering_index", 1, 0))
+      DBUG_IF("fault_injection_recovering_index"))
   {
     sql_print_error("MYSQL_BIN_LOG::open_index_file failed to sync the index "
                     "file.");
@@ -3637,7 +3637,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
   if (open_purge_index_file(TRUE) ||
       register_create_index_entry(log_file_name) ||
       sync_purge_index_file() ||
-      DBUG_EVALUATE_IF("fault_injection_registering_index", 1, 0))
+      DBUG_IF("fault_injection_registering_index"))
   {
     /**
         TODO:
@@ -3918,7 +3918,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
         As this is a new log file, we write the file name to the index
         file. As every time we write to the index file, we sync it.
       */
-      if (DBUG_EVALUATE_IF("fault_injection_updating_index", 1, 0) ||
+      if (DBUG_IF("fault_injection_updating_index") ||
           my_b_write(&index_file, (uchar*) log_file_name,
                      strlen(log_file_name)) ||
           my_b_write(&index_file, (uchar*) "\n", 1) ||
@@ -5331,8 +5331,8 @@ int MYSQL_BIN_LOG::new_file_impl()
       r.checksum_alg= relay_log_checksum_alg;
     DBUG_ASSERT(!is_relay_log ||
                 relay_log_checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF);
-    if (DBUG_EVALUATE_IF("fault_injection_new_file_rotate_event",
-                         (error= close_on_error= TRUE), FALSE) ||
+    if ((DBUG_IF("fault_injection_new_file_rotate_event") &&
+                         (error= close_on_error= TRUE)) ||
         (error= write_event(&r)))
     {
       DBUG_EXECUTE_IF("fault_injection_new_file_rotate_event", errno= 2;);
@@ -6726,7 +6726,7 @@ bool MYSQL_BIN_LOG::write(Log_event *event_info, my_bool *with_annotate)
       Write the event.
     */
     if (write_event(event_info, cache_data, file) ||
-        DBUG_EVALUATE_IF("injecting_fault_writing", 1, 0))
+        DBUG_IF("injecting_fault_writing"))
       goto err;
 
     error= 0;
@@ -8484,7 +8484,7 @@ MYSQL_BIN_LOG::trx_group_commit_leader(group_commit_entry *leader)
     DEBUG_SYNC(leader->thd, "commit_loop_entry_commit_ordered");
     ++num_commits;
     if (current->cache_mngr->using_xa && likely(!current->error) &&
-        DBUG_EVALUATE_IF("skip_commit_ordered", 0, 1))
+        !DBUG_IF("skip_commit_ordered"))
       run_commit_ordered(current->thd, current->all);
     current->thd->wakeup_subsequent_commits(current->error);
 
diff --git a/sql/log_event_server.cc b/sql/log_event_server.cc
index d1df2d7721d..5cf48f10ad8 100644
--- a/sql/log_event_server.cc
+++ b/sql/log_event_server.cc
@@ -6453,7 +6453,7 @@ int Table_map_log_event::do_apply_event(rpl_group_info *rgi)
   LEX_CSTRING tmp_tbl_name= {tname_mem, tname_mem_length };
 
   table_list->init_one_table(&tmp_db_name, &tmp_tbl_name, 0, TL_WRITE);
-  table_list->table_id= DBUG_EVALUATE_IF("inject_tblmap_same_id_maps_diff_table", 0, m_table_id);
+  table_list->table_id= DBUG_IF("inject_tblmap_same_id_maps_diff_table") ? 0 : m_table_id;
   table_list->updating= 1;
   table_list->required_type= TABLE_TYPE_NORMAL;
 
@@ -6693,7 +6693,7 @@ void Table_map_log_event::init_metadata_fields()
 
   if (binlog_row_metadata == BINLOG_ROW_METADATA_FULL)
   {
-    if (DBUG_EVALUATE_IF("dont_log_column_name", 0, init_column_name_field()) ||
+    if ((!DBUG_IF("dont_log_column_name") && init_column_name_field()) ||
         init_charset_field(&is_enum_or_set_field, ENUM_AND_SET_DEFAULT_CHARSET,
                            ENUM_AND_SET_COLUMN_CHARSET) ||
         init_set_str_value_field() ||
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 3e93ee38846..84ca70574d5 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1559,7 +1559,7 @@ static my_bool kill_thread_phase_1(THD *thd, void *)
   if (thd->slave_thread || thd->is_binlog_dump_thread())
     return 0;
 
-  if (DBUG_EVALUATE_IF("only_kill_system_threads", !thd->system_thread, 0))
+  if (DBUG_IF("only_kill_system_threads") ? !thd->system_thread : 0)
     return 0;
   thd->awake(KILL_SERVER_HARD);
   return 0;
diff --git a/sql/partition_info.h b/sql/partition_info.h
index 0656238ec07..995147d6766 100644
--- a/sql/partition_info.h
+++ b/sql/partition_info.h
@@ -79,7 +79,7 @@ struct Vers_part_info : public Sql_alloc
   partition_element *hist_part;
 };
 
-class partition_info : public Sql_alloc
+class partition_info : public DDL_LOG_STATE, public Sql_alloc
 {
 public:
   /*
@@ -154,10 +154,6 @@ public:
 
   Item *item_free_list;
 
-  struct st_ddl_log_memory_entry *first_log_entry;
-  struct st_ddl_log_memory_entry *exec_log_entry;
-  struct st_ddl_log_memory_entry *frm_log_entry;
-
   /* 
     Bitmaps of partitions used by the current query. 
     * read_partitions  - partitions to be used for reading.
@@ -297,7 +293,6 @@ public:
     part_field_buffers(NULL), subpart_field_buffers(NULL),
     restore_part_field_ptrs(NULL), restore_subpart_field_ptrs(NULL),
     part_expr(NULL), subpart_expr(NULL), item_free_list(NULL),
-    first_log_entry(NULL), exec_log_entry(NULL), frm_log_entry(NULL),
     bitmaps_are_initialized(FALSE),
     list_array(NULL), vers_info(NULL), err_value(0),
     part_info_string(NULL),
@@ -319,6 +314,7 @@ public:
     is_auto_partitioned(FALSE),
     has_null_value(FALSE), column_list(FALSE)
   {
+    bzero((DDL_LOG_STATE *) this, sizeof(DDL_LOG_STATE));
     all_fields_in_PF.clear_all();
     all_fields_in_PPF.clear_all();
     all_fields_in_SPF.clear_all();
diff --git a/sql/rpl_parallel.cc b/sql/rpl_parallel.cc
index a2098348efc..49ec08a9cea 100644
--- a/sql/rpl_parallel.cc
+++ b/sql/rpl_parallel.cc
@@ -807,9 +807,7 @@ do_retry:
   {
     mysql_mutex_lock(&entry->LOCK_parallel_entry);
     if (entry->stop_on_error_sub_id == (uint64) ULONGLONG_MAX ||
-#ifndef DBUG_OFF
-        (DBUG_EVALUATE_IF("simulate_mdev_12746", 1, 0)) ||
-#endif
+        DBUG_IF("simulate_mdev_12746") ||
         rgi->gtid_sub_id < entry->stop_on_error_sub_id)
     {
       register_wait_for_prior_event_group_commit(rgi, entry);
diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc
index 9ea8bb3b822..04a2efb3750 100644
--- a/sql/rpl_utility.cc
+++ b/sql/rpl_utility.cc
@@ -338,7 +338,7 @@ bool event_checksum_test(uchar *event_buf, ulong event_len,
       DBUG_ASSERT(event_buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT);
       event_buf[FLAGS_OFFSET]= (uchar) flags;
     }
-    res= DBUG_EVALUATE_IF("simulate_checksum_test_failure", TRUE, computed != incoming);
+    res= (DBUG_IF("simulate_checksum_test_failure") || computed != incoming);
   }
   return res;
 }
diff --git a/sql/semisync_master_ack_receiver.cc b/sql/semisync_master_ack_receiver.cc
index b65b7824a0e..b54ad58d153 100644
--- a/sql/semisync_master_ack_receiver.cc
+++ b/sql/semisync_master_ack_receiver.cc
@@ -72,7 +72,7 @@ bool Ack_receiver::start()
 
     m_status= ST_UP;
 
-    if (DBUG_EVALUATE_IF("rpl_semisync_simulate_create_thread_failure", 1, 0) ||
+    if (DBUG_IF("rpl_semisync_simulate_create_thread_failure") ||
         pthread_attr_init(&attr) != 0 ||
         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) != 0 ||
 #ifndef _WIN32
@@ -247,7 +247,7 @@ void Ack_receiver::run()
     {
       mysql_mutex_unlock(&m_mutex);
 
-      ret= DBUG_EVALUATE_IF("rpl_semisync_simulate_select_error", -1, ret);
+      ret= DBUG_IF("rpl_semisync_simulate_select_error") ? -1 : ret;
 
       if (ret == -1 && errno != EINTR)
         sql_print_information("Failed to wait on semi-sync sockets, "
diff --git a/sql/semisync_slave.cc b/sql/semisync_slave.cc
index ccfda7576c2..684199031ee 100644
--- a/sql/semisync_slave.cc
+++ b/sql/semisync_slave.cc
@@ -63,7 +63,7 @@ int Repl_semi_sync_slave::slave_read_sync_header(const uchar *header,
 
   if (rpl_semi_sync_slave_status)
   {
-    if (DBUG_EVALUATE_IF("semislave_corrupt_log", 0, 1)
+    if (!DBUG_IF("semislave_corrupt_log")
         && header[0] == k_packet_magic_num)
     {
       semi_sync_need_reply  = (header[1] & k_packet_flag_sync);
@@ -140,7 +140,7 @@ void Repl_semi_sync_slave::kill_connection(MYSQL *mysql)
 
   bool ret= (!mysql_real_connect(kill_mysql, mysql->host,
             mysql->user, mysql->passwd,0, mysql->port, mysql->unix_socket, 0));
-  if (DBUG_EVALUATE_IF("semisync_slave_failed_kill", 1, 0) || ret)
+  if (DBUG_IF("semisync_slave_failed_kill") || ret)
   {
     sql_print_information("cannot connect to master to kill slave io_thread's "
                           "connection");
@@ -172,8 +172,7 @@ int Repl_semi_sync_slave::request_transmit(Master_info *mi)
   }
 
   row= mysql_fetch_row(res);
-  if (DBUG_EVALUATE_IF("master_not_support_semisync", 1, 0)
-      || !row)
+  if (DBUG_IF("master_not_support_semisync") || !row)
   {
     /* Master does not support semi-sync */
     sql_print_warning("Master server does not support semi-sync, "
@@ -234,7 +233,7 @@ int Repl_semi_sync_slave::slave_reply(Master_info *mi)
                              name_len + REPLY_BINLOG_NAME_OFFSET);
     if (!reply_res)
     {
-      reply_res = DBUG_EVALUATE_IF("semislave_failed_net_flush", 1, net_flush(net));
+      reply_res = (DBUG_IF("semislave_failed_net_flush") || net_flush(net));
       if (reply_res)
         sql_print_error("Semi-sync slave net_flush() reply failed");
       rpl_semi_sync_slave_send_ack++;
diff --git a/sql/share/errmsg-utf8.txt b/sql/share/errmsg-utf8.txt
index 98e9cb8033f..6b8fd2bcd9e 100644
--- a/sql/share/errmsg-utf8.txt
+++ b/sql/share/errmsg-utf8.txt
@@ -1720,7 +1720,7 @@ ER_TOO_LONG_KEY 42000 S1009
         spa "Declaracion de clave demasiado larga. La maxima longitud de clave es %d"
         swe "För lång nyckel. Högsta tillåtna nyckellängd är %d"
         ukr "Зазначений ключ задовгий. Найбільша довжина ключа %d байтів"
-ER_KEY_COLUMN_DOES_NOT_EXITS 42000 S1009
+ER_KEY_COLUMN_DOES_NOT_EXIST 42000 S1009
         cze "Klíčový sloupec '%-.192s' v tabulce neexistuje"
         dan "Nøglefeltet '%-.192s' eksisterer ikke i tabellen"
         nla "Zoeksleutel kolom '%-.192s' bestaat niet in tabel"
@@ -5903,10 +5903,8 @@ ER_PARTITION_MGMT_ON_NONPARTITIONED
         swe "Partitioneringskommando på en opartitionerad tabell är inte möjligt"
 ER_FEATURE_NOT_SUPPORTED_WITH_PARTITIONING
         eng "Partitioned tables do not support %s"
-ER_DROP_PARTITION_NON_EXISTENT
-        eng "Error in list of partitions to %-.64s"
-        ger "Fehler in der Partitionsliste bei %-.64s"
-        swe "Fel i listan av partitioner att %-.64s"
+ER_PARTITION_DOES_NOT_EXIST
+        eng "Wrong partition name or partition list"
 ER_DROP_LAST_PARTITION
         eng "Cannot remove all partitions, use DROP TABLE instead"
         ger "Es lassen sich nicht sämtliche Partitionen löschen, benutzen Sie statt dessen DROP TABLE"
diff --git a/sql/slave.cc b/sql/slave.cc
index 38f4fd31c70..9d5ba1d5a2b 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -2329,11 +2329,11 @@ past_checksum:
   /* Announce MariaDB slave capabilities. */
   DBUG_EXECUTE_IF("simulate_slave_capability_none", goto after_set_capability;);
   {
-    int rc= DBUG_EVALUATE_IF("simulate_slave_capability_old_53",
+    int rc= DBUG_IF("simulate_slave_capability_old_53") ?
         mysql_real_query(mysql, STRING_WITH_LEN("SET @mariadb_slave_capability="
-                         STRINGIFY_ARG(MARIA_SLAVE_CAPABILITY_ANNOTATE))),
+                         STRINGIFY_ARG(MARIA_SLAVE_CAPABILITY_ANNOTATE))) :
         mysql_real_query(mysql, STRING_WITH_LEN("SET @mariadb_slave_capability="
-                         STRINGIFY_ARG(MARIA_SLAVE_CAPABILITY_MINE))));
+                         STRINGIFY_ARG(MARIA_SLAVE_CAPABILITY_MINE)));
     if (unlikely(rc))
     {
       err_code= mysql_errno(mysql);
@@ -4663,7 +4663,7 @@ pthread_handler_t handle_slave_io(void *arg)
   }
 
   thd->variables.wsrep_on= 0;
-  if (DBUG_EVALUATE_IF("failed_slave_start", 1, 0)
+  if (DBUG_IF("failed_slave_start")
       || repl_semisync_slave.slave_start(mi))
   {
     mi->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR, NULL,
@@ -4939,7 +4939,7 @@ Stopping slave I/O thread due to out-of-memory error from master");
           (!repl_semisync_slave.get_slave_enabled() ||
            (!(mi->semi_ack & SEMI_SYNC_SLAVE_DELAY_SYNC) ||
             (mi->semi_ack & (SEMI_SYNC_NEED_ACK)))) &&
-          (DBUG_EVALUATE_IF("failed_flush_master_info", 1, 0) ||
+          (DBUG_IF("failed_flush_master_info") ||
            flush_master_info(mi, TRUE, TRUE)))
       {
         sql_print_error("Failed to flush master info file");
diff --git a/sql/sql_admin.cc b/sql/sql_admin.cc
index 6ba08ebd55a..26e3d67641d 100644
--- a/sql/sql_admin.cc
+++ b/sql/sql_admin.cc
@@ -713,8 +713,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
             protocol->store(operator_name, system_charset_info);
             protocol->store(&error_clex_str, system_charset_info);
             length= my_snprintf(buff, sizeof(buff),
-                                ER_THD(thd, ER_DROP_PARTITION_NON_EXISTENT),
-                                table_name.str);
+                                ER_THD(thd, ER_PARTITION_DOES_NOT_EXIST));
             protocol->store(buff, length, system_charset_info);
             if(protocol->write())
               goto err;
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index e59b7312813..d983fe9a332 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -6045,7 +6045,7 @@ find_field_in_table(THD *thd, TABLE *table, const char *name, size_t length,
   if (field)
   {
     if (field->invisible == INVISIBLE_FULL &&
-        DBUG_EVALUATE_IF("test_completely_invisible", 0, 1))
+        !DBUG_IF("test_completely_invisible"))
       DBUG_RETURN((Field*)0);
 
     if (field->invisible == INVISIBLE_SYSTEM &&
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 4d7093763ae..c5a0baaaa80 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -293,7 +293,7 @@ bool Foreign_key::validate(List<Create_field> &table_fields)
                           &sql_field->field_name)) {}
     if (!sql_field)
     {
-      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
+      my_error(ER_KEY_COLUMN_DOES_NOT_EXIST, MYF(0), column->field_name.str);
       DBUG_RETURN(TRUE);
     }
     if (type == Key::FOREIGN_KEY && sql_field->vcol_info)
diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc
index 3e7acef0694..06f8fee80cd 100644
--- a/sql/sql_partition.cc
+++ b/sql/sql_partition.cc
@@ -78,9 +78,9 @@ using std::min;
 #include "ha_partition.h"
 
 #define ERROR_INJECT_CRASH(code) \
-  DBUG_EVALUATE_IF(code, (DBUG_SUICIDE(), 0), 0)
+  (DBUG_IF(code) && (DBUG_SUICIDE(), 0))
 #define ERROR_INJECT_ERROR(code) \
-  DBUG_EVALUATE_IF(code, (my_error(ER_UNKNOWN_ERROR, MYF(0)), TRUE), 0)
+  (DBUG_IF(code) && (my_error(ER_UNKNOWN_ERROR, MYF(0)), 1))
 
 /*
   Partition related functions declarations and some static constants;
@@ -5446,6 +5446,7 @@ that are reorganised.
         my_error(ER_ROW_IS_REFERENCED, MYF(0));
         goto err;
       }
+      /* NOTE: num_parts is used in generate_partition_syntax() */
       tab_part_info->num_parts-= num_parts_dropped;
     }
     else if (alter_info->partition_flags & ALTER_PARTITION_REBUILD)
@@ -5454,7 +5455,7 @@ that are reorganised.
                                 tab_part_info->default_engine_type);
       if (set_part_state(alter_info, tab_part_info, PART_CHANGED))
       {
-        my_error(ER_DROP_PARTITION_NON_EXISTENT, MYF(0), "REBUILD");
+        my_error(ER_PARTITION_DOES_NOT_EXIST, MYF(0));
         goto err;
       }
       if (!(*fast_alter_table))
@@ -5730,7 +5731,7 @@ the generated partition syntax in a correct manner.
         } while (++part_count < tab_part_info->num_parts);
         if (drop_count != num_parts_reorged)
         {
-          my_error(ER_DROP_PARTITION_NON_EXISTENT, MYF(0), "REORGANIZE");
+          my_error(ER_PARTITION_DOES_NOT_EXIST, MYF(0));
           goto err;
         }
         tab_part_info->num_parts= check_total_partitions;
@@ -6112,8 +6113,6 @@ static bool mysql_drop_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
   char path[FN_REFLEN+1];
   partition_info *part_info= lpt->table->part_info;
   List_iterator<partition_element> part_it(part_info->partitions);
-  uint i= 0;
-  uint remove_count= 0;
   int error;
   DBUG_ENTER("mysql_drop_partitions");
 
@@ -6128,38 +6127,11 @@ static bool mysql_drop_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
     lpt->table->file->print_error(error, MYF(0));
     DBUG_RETURN(TRUE);
   }
-  do
-  {
-    partition_element *part_elem= part_it++;
-    if (part_elem->part_state == PART_IS_DROPPED)
-    {
-      part_it.remove();
-      remove_count++;
-    }
-  } while (++i < part_info->num_parts);
-  part_info->num_parts-= remove_count;
   DBUG_RETURN(FALSE);
 }
 
 
 /*
-  Insert log entry into list
-  SYNOPSIS
-    insert_part_info_log_entry_list()
-    log_entry
-  RETURN VALUES
-    NONE
-*/
-
-static void insert_part_info_log_entry_list(partition_info *part_info,
-                                            DDL_LOG_MEMORY_ENTRY *log_entry)
-{
-  log_entry->next_active_log_entry= part_info->first_log_entry;
-  part_info->first_log_entry= log_entry;
-}
-
-
-/*
   Release all log entries for this partition info struct
   SYNOPSIS
     release_part_info_log_entries()
@@ -6183,50 +6155,80 @@ static void release_part_info_log_entries(DDL_LOG_MEMORY_ENTRY *log_entry)
 
 
 /*
-  Log an delete/rename frm file
+  Log an delete frm file
   SYNOPSIS
-    write_log_replace_delete_frm()
+    write_log_delete_frm()
+    lpt                            Struct for parameters
+    to_path                        Name to delete
+  RETURN VALUES
+    TRUE                           Error
+    FALSE                          Success
+  DESCRIPTION
+    Support routine that writes a delete of an frm file into the
+    ddl log. It also inserts an entry that keeps track of used space into
+    the partition info object
+*/
+
+static bool write_log_delete_frm(ALTER_PARTITION_PARAM_TYPE *lpt,
+                                 const char *to_path)
+{
+  DDL_LOG_ENTRY ddl_log_entry;
+  DDL_LOG_MEMORY_ENTRY *log_entry;
+  DBUG_ENTER("write_log_delete_frm");
+  bzero(&ddl_log_entry, sizeof(ddl_log_entry));
+  ddl_log_entry.action_type= DDL_LOG_DELETE_ACTION;
+  ddl_log_entry.next_entry= 0;
+  lex_string_set(&ddl_log_entry.handler_name, reg_ext);
+  lex_string_set(&ddl_log_entry.name, to_path);
+
+  if (ddl_log_write_entry(&ddl_log_entry, &log_entry))
+  {
+    DBUG_RETURN(true);
+  }
+  ddl_log_add_entry(lpt->part_info, log_entry);
+  DBUG_RETURN(false);
+}
+
+
+/*
+  Log an rename frm file
+  SYNOPSIS
+    write_log_replace_frm()
     lpt                            Struct for parameters
     next_entry                     Next reference to use in log record
     from_path                      Name to rename from
     to_path                        Name to rename to
-    replace_flag                   TRUE if replace, else delete
   RETURN VALUES
     TRUE                           Error
     FALSE                          Success
   DESCRIPTION
-    Support routine that writes a replace or delete of an frm file into the
+    Support routine that writes a replace of an frm file into the
     ddl log. It also inserts an entry that keeps track of used space into
     the partition info object
 */
 
-static bool write_log_replace_delete_frm(ALTER_PARTITION_PARAM_TYPE *lpt,
-                                         uint next_entry,
-                                         const char *from_path,
-                                         const char *to_path,
-                                         bool replace_flag)
+static bool write_log_replace_frm(ALTER_PARTITION_PARAM_TYPE *lpt,
+                                  uint next_entry,
+                                  const char *from_path,
+                                  const char *to_path)
 {
   DDL_LOG_ENTRY ddl_log_entry;
   DDL_LOG_MEMORY_ENTRY *log_entry;
-  DBUG_ENTER("write_log_replace_delete_frm");
+  DBUG_ENTER("write_log_replace_frm");
 
   bzero(&ddl_log_entry, sizeof(ddl_log_entry));
-  if (replace_flag)
-    ddl_log_entry.action_type= DDL_LOG_REPLACE_ACTION;
-  else
-    ddl_log_entry.action_type= DDL_LOG_DELETE_ACTION;
+  ddl_log_entry.action_type= DDL_LOG_REPLACE_ACTION;
   ddl_log_entry.next_entry= next_entry;
   lex_string_set(&ddl_log_entry.handler_name, reg_ext);
   lex_string_set(&ddl_log_entry.name, to_path);
+  lex_string_set(&ddl_log_entry.from_name, from_path);
 
-  if (replace_flag)
-    lex_string_set(&ddl_log_entry.from_name, from_path);
   if (ddl_log_write_entry(&ddl_log_entry, &log_entry))
   {
-    DBUG_RETURN(TRUE);
+    DBUG_RETURN(true);
   }
-  insert_part_info_log_entry_list(lpt->part_info, log_entry);
-  DBUG_RETURN(FALSE);
+  ddl_log_add_entry(lpt->part_info, log_entry);
+  DBUG_RETURN(false);
 }
 
 
@@ -6305,7 +6307,7 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
 
           *next_entry= log_entry->entry_pos;
           sub_elem->log_entry= log_entry;
-          insert_part_info_log_entry_list(part_info, log_entry);
+          ddl_log_add_entry(part_info, log_entry);
         } while (++j < num_subparts);
       }
       else
@@ -6332,7 +6334,7 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
         }
         *next_entry= log_entry->entry_pos;
         part_elem->log_entry= log_entry;
-        insert_part_info_log_entry_list(part_info, log_entry);
+        ddl_log_add_entry(part_info, log_entry);
       }
     }
   } while (++i < num_elements);
@@ -6410,7 +6412,7 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
           }
           *next_entry= log_entry->entry_pos;
           sub_elem->log_entry= log_entry;
-          insert_part_info_log_entry_list(part_info, log_entry);
+          ddl_log_add_entry(part_info, log_entry);
         } while (++j < num_subparts);
       }
       else
@@ -6429,7 +6431,7 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
         }
         *next_entry= log_entry->entry_pos;
         part_elem->log_entry= log_entry;
-        insert_part_info_log_entry_list(part_info, log_entry);
+        ddl_log_add_entry(part_info, log_entry);
       }
     }
   }
@@ -6438,24 +6440,6 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
 
 
 /*
-  Set execute log entry in ddl log for this partitioned table
-  SYNOPSIS
-    set_part_info_exec_log_entry()
-    part_info                      Partition info object
-    exec_log_entry                 Log entry
-  RETURN VALUES
-    NONE
-*/
-
-static void set_part_info_exec_log_entry(partition_info *part_info,
-                                         DDL_LOG_MEMORY_ENTRY *exec_log_entry)
-{
-  part_info->exec_log_entry= exec_log_entry;
-  exec_log_entry->next_active_log_entry= NULL;
-}
-
-
-/*
   Write the log entry to ensure that the shadow frm file is removed at
   crash.
   SYNOPSIS
@@ -6475,27 +6459,24 @@ static bool write_log_drop_shadow_frm(ALTER_PARTITION_PARAM_TYPE *lpt)
 {
   partition_info *part_info= lpt->part_info;
   DDL_LOG_MEMORY_ENTRY *log_entry;
-  DDL_LOG_MEMORY_ENTRY *exec_log_entry= NULL;
   char shadow_path[FN_REFLEN + 1];
   DBUG_ENTER("write_log_drop_shadow_frm");
 
   build_table_shadow_filename(shadow_path, sizeof(shadow_path) - 1, lpt);
   mysql_mutex_lock(&LOCK_gdl);
-  if (write_log_replace_delete_frm(lpt, 0UL, NULL,
-                                  (const char*)shadow_path, FALSE))
+  if (write_log_delete_frm(lpt, (const char*)shadow_path))
     goto error;
-  log_entry= part_info->first_log_entry;
+  log_entry= part_info->list;
   if (ddl_log_write_execute_entry(log_entry->entry_pos,
-                                  &exec_log_entry))
+                                  &part_info->execute_entry))
     goto error;
   mysql_mutex_unlock(&LOCK_gdl);
-  set_part_info_exec_log_entry(part_info, exec_log_entry);
   DBUG_RETURN(FALSE);
 
 error:
-  release_part_info_log_entries(part_info->first_log_entry);
+  release_part_info_log_entries(part_info->list);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->first_log_entry= NULL;
+  part_info->list= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
 }
@@ -6518,20 +6499,20 @@ static bool write_log_rename_frm(ALTER_PARTITION_PARAM_TYPE *lpt)
 {
   partition_info *part_info= lpt->part_info;
   DDL_LOG_MEMORY_ENTRY *log_entry;
-  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->exec_log_entry;
+  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->execute_entry;
   char path[FN_REFLEN + 1];
   char shadow_path[FN_REFLEN + 1];
-  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->first_log_entry;
+  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->list;
   DBUG_ENTER("write_log_rename_frm");
 
-  part_info->first_log_entry= NULL;
+  part_info->list= NULL;
   build_table_filename(path, sizeof(path) - 1, lpt->db.str, lpt->table_name.str, "", 0);
   build_table_shadow_filename(shadow_path, sizeof(shadow_path) - 1, lpt);
   mysql_mutex_lock(&LOCK_gdl);
-  if (write_log_replace_delete_frm(lpt, 0UL, shadow_path, path, TRUE))
+  if (write_log_replace_frm(lpt, 0UL, shadow_path, path))
     goto error;
-  log_entry= part_info->first_log_entry;
-  part_info->frm_log_entry= log_entry;
+  log_entry= part_info->list;
+  part_info->main_entry= log_entry;
   if (ddl_log_write_execute_entry(log_entry->entry_pos,
                                   &exec_log_entry))
     goto error;
@@ -6540,10 +6521,10 @@ static bool write_log_rename_frm(ALTER_PARTITION_PARAM_TYPE *lpt)
   DBUG_RETURN(FALSE);
 
 error:
-  release_part_info_log_entries(part_info->first_log_entry);
+  release_part_info_log_entries(part_info->list);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->first_log_entry= old_first_log_entry;
-  part_info->frm_log_entry= NULL;
+  part_info->list= old_first_log_entry;
+  part_info->main_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
 }
@@ -6568,25 +6549,25 @@ static bool write_log_drop_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
 {
   partition_info *part_info= lpt->part_info;
   DDL_LOG_MEMORY_ENTRY *log_entry;
-  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->exec_log_entry;
+  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->execute_entry;
   char tmp_path[FN_REFLEN + 1];
   char path[FN_REFLEN + 1];
   uint next_entry= 0;
-  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->first_log_entry;
+  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->list;
   DBUG_ENTER("write_log_drop_partition");
 
-  part_info->first_log_entry= NULL;
+  part_info->list= NULL;
   build_table_filename(path, sizeof(path) - 1, lpt->db.str, lpt->table_name.str, "", 0);
   build_table_shadow_filename(tmp_path, sizeof(tmp_path) - 1, lpt);
   mysql_mutex_lock(&LOCK_gdl);
   if (write_log_dropped_partitions(lpt, &next_entry, (const char*)path,
                                    FALSE))
     goto error;
-  if (write_log_replace_delete_frm(lpt, next_entry, (const char*)tmp_path,
-                                  (const char*)path, TRUE))
+  if (write_log_replace_frm(lpt, next_entry, (const char*)tmp_path,
+                            (const char*)path))
     goto error;
-  log_entry= part_info->first_log_entry;
-  part_info->frm_log_entry= log_entry;
+  log_entry= part_info->list;
+  part_info->main_entry= log_entry;
   if (ddl_log_write_execute_entry(log_entry->entry_pos,
                                   &exec_log_entry))
     goto error;
@@ -6595,10 +6576,10 @@ static bool write_log_drop_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
   DBUG_RETURN(FALSE);
 
 error:
-  release_part_info_log_entries(part_info->first_log_entry);
+  release_part_info_log_entries(part_info->list);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->first_log_entry= old_first_log_entry;
-  part_info->frm_log_entry= NULL;
+  part_info->list= old_first_log_entry;
+  part_info->main_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
 }
@@ -6625,11 +6606,10 @@ static bool write_log_add_change_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
 {
   partition_info *part_info= lpt->part_info;
   DDL_LOG_MEMORY_ENTRY *log_entry;
-  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->exec_log_entry;
   char tmp_path[FN_REFLEN + 1];
   char path[FN_REFLEN + 1];
   uint next_entry= 0;
-  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->first_log_entry;
+  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->list;
   /* write_log_drop_shadow_frm(lpt) must have been run first */
   DBUG_ASSERT(old_first_log_entry);
   DBUG_ENTER("write_log_add_change_partition");
@@ -6644,20 +6624,18 @@ static bool write_log_add_change_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
   if (write_log_dropped_partitions(lpt, &next_entry, (const char*)path,
                                    FALSE))
     goto error;
-  log_entry= part_info->first_log_entry;
+  log_entry= part_info->list;
 
   if (ddl_log_write_execute_entry(log_entry->entry_pos,
-                                  /* Reuse the old execute ddl_log_entry */
-                                  &exec_log_entry))
+                                  &part_info->execute_entry))
     goto error;
   mysql_mutex_unlock(&LOCK_gdl);
-  set_part_info_exec_log_entry(part_info, exec_log_entry);
   DBUG_RETURN(FALSE);
 
 error:
-  release_part_info_log_entries(part_info->first_log_entry);
+  release_part_info_log_entries(part_info->list);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->first_log_entry= old_first_log_entry;
+  part_info->list= old_first_log_entry;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
 }
@@ -6689,10 +6667,10 @@ static bool write_log_final_change_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
 {
   partition_info *part_info= lpt->part_info;
   DDL_LOG_MEMORY_ENTRY *log_entry;
-  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->exec_log_entry;
+  DDL_LOG_MEMORY_ENTRY *exec_log_entry= part_info->execute_entry;
   char path[FN_REFLEN + 1];
   char shadow_path[FN_REFLEN + 1];
-  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->first_log_entry;
+  DDL_LOG_MEMORY_ENTRY *old_first_log_entry= part_info->list;
   uint next_entry= 0;
   DBUG_ENTER("write_log_final_change_partition");
 
@@ -6700,7 +6678,7 @@ static bool write_log_final_change_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
     Do not link any previous log entry.
     Replace the revert operations with forced retry operations.
   */
-  part_info->first_log_entry= NULL;
+  part_info->list= NULL;
   build_table_filename(path, sizeof(path) - 1, lpt->db.str, lpt->table_name.str, "", 0);
   build_table_shadow_filename(shadow_path, sizeof(shadow_path) - 1, lpt);
   mysql_mutex_lock(&LOCK_gdl);
@@ -6710,10 +6688,10 @@ static bool write_log_final_change_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
                                    lpt->alter_info->partition_flags &
                                    ALTER_PARTITION_REORGANIZE))
     goto error;
-  if (write_log_replace_delete_frm(lpt, next_entry, shadow_path, path, TRUE))
+  if (write_log_replace_frm(lpt, next_entry, shadow_path, path))
     goto error;
-  log_entry= part_info->first_log_entry;
-  part_info->frm_log_entry= log_entry;
+  log_entry= part_info->list;
+  part_info->main_entry= log_entry;
   /* Overwrite the revert execute log entry with this retry execute entry */
   if (ddl_log_write_execute_entry(log_entry->entry_pos,
                                   &exec_log_entry))
@@ -6723,10 +6701,10 @@ static bool write_log_final_change_partition(ALTER_PARTITION_PARAM_TYPE *lpt)
   DBUG_RETURN(FALSE);
 
 error:
-  release_part_info_log_entries(part_info->first_log_entry);
+  release_part_info_log_entries(part_info->list);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->first_log_entry= old_first_log_entry;
-  part_info->frm_log_entry= NULL;
+  part_info->list= old_first_log_entry;
+  part_info->main_entry= NULL;
   my_error(ER_DDL_LOG_ERROR, MYF(0));
   DBUG_RETURN(TRUE);
 }
@@ -6747,7 +6725,7 @@ static void write_log_completed(ALTER_PARTITION_PARAM_TYPE *lpt,
                                 bool dont_crash)
 {
   partition_info *part_info= lpt->part_info;
-  DDL_LOG_MEMORY_ENTRY *log_entry= part_info->exec_log_entry;
+  DDL_LOG_MEMORY_ENTRY *log_entry= part_info->execute_entry;
   DBUG_ENTER("write_log_completed");
 
   DBUG_ASSERT(log_entry);
@@ -6763,11 +6741,11 @@ static void write_log_completed(ALTER_PARTITION_PARAM_TYPE *lpt,
     */
     ;
   }
-  release_part_info_log_entries(part_info->first_log_entry);
-  release_part_info_log_entries(part_info->exec_log_entry);
+  release_part_info_log_entries(part_info->list);
+  release_part_info_log_entries(part_info->execute_entry);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->exec_log_entry= NULL;
-  part_info->first_log_entry= NULL;
+  part_info->execute_entry= NULL;
+  part_info->list= NULL;
   DBUG_VOID_RETURN;
 }
 
@@ -6784,11 +6762,11 @@ static void write_log_completed(ALTER_PARTITION_PARAM_TYPE *lpt,
 static void release_log_entries(partition_info *part_info)
 {
   mysql_mutex_lock(&LOCK_gdl);
-  release_part_info_log_entries(part_info->first_log_entry);
-  release_part_info_log_entries(part_info->exec_log_entry);
+  release_part_info_log_entries(part_info->list);
+  release_part_info_log_entries(part_info->execute_entry);
   mysql_mutex_unlock(&LOCK_gdl);
-  part_info->first_log_entry= NULL;
-  part_info->exec_log_entry= NULL;
+  part_info->list= NULL;
+  part_info->execute_entry= NULL;
 }
 
 
@@ -6901,8 +6879,8 @@ static void handle_alter_part_error(ALTER_PARTITION_PARAM_TYPE *lpt,
     close_all_tables_for_name(thd, table->s, HA_EXTRA_NOT_USED, NULL);
   }
 
-  if (part_info->first_log_entry &&
-      ddl_log_execute_entry(thd, part_info->first_log_entry->entry_pos))
+  if (part_info->list &&
+      ddl_log_execute_entry(thd, part_info->list->entry_pos))
   {
     /*
       We couldn't recover from error, most likely manual interaction
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index dad9e34b87d..962b306d33c 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -6717,7 +6717,7 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
     for (uint i=0 ; i < show_table->s->keys ; i++,key_info++)
     {
       if ((key_info->flags & HA_INVISIBLE_KEY) &&
-          DBUG_EVALUATE_IF("test_invisible_index", 0, 1))
+          !DBUG_IF("test_invisible_index"))
         continue;
       KEY_PART_INFO *key_part= key_info->key_part;
       LEX_CSTRING *str;
@@ -6725,7 +6725,7 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
       for (uint j=0 ; j < key_info->user_defined_key_parts ; j++,key_part++)
       {
         if (key_part->field->invisible >= INVISIBLE_SYSTEM &&
-            DBUG_EVALUATE_IF("test_completely_invisible", 0, 1))
+            !DBUG_IF("test_completely_invisible"))
         {
           /*
             NOTE: we will get SEQ_IN_INDEX gap inside the result if this key_part
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index efce4172f62..b2bc1e620d9 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -802,7 +802,7 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
 #ifdef WITH_PARTITION_STORAGE_ENGINE
         lpt->table->file->ha_create_partitioning_metadata(path, shadow_path,
                                                           CHF_DELETE_FLAG) ||
-        ddl_log_increment_phase(part_info->frm_log_entry->entry_pos) ||
+        ddl_log_increment_phase(part_info->main_entry->entry_pos) ||
         (ddl_log_sync(), FALSE) ||
         mysql_file_rename(key_file_frm,
                           shadow_frm_name, frm_name, MYF(MY_WME)) ||
@@ -850,8 +850,8 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
 
 err:
 #ifdef WITH_PARTITION_STORAGE_ENGINE
-    ddl_log_increment_phase(part_info->frm_log_entry->entry_pos);
-    part_info->frm_log_entry= NULL;
+    ddl_log_increment_phase(part_info->main_entry->entry_pos);
+    part_info->main_entry= NULL;
     (void) ddl_log_sync();
 #endif
     ;
@@ -2758,8 +2758,6 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     */
     if (sql_field->stored_in_db())
       record_offset+= sql_field->pack_length;
-    if (sql_field->flags & VERS_SYSTEM_FIELD)
-      continue;
   }
   /* Update virtual fields' offset and give error if
      All fields are invisible */
@@ -3110,14 +3108,14 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
       if (!sql_field || (sql_field->invisible > INVISIBLE_USER &&
                          !column->generated))
       {
-	my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
+	my_error(ER_KEY_COLUMN_DOES_NOT_EXIST, MYF(0), column->field_name.str);
 	DBUG_RETURN(TRUE);
       }
       if (sql_field->invisible > INVISIBLE_USER &&
           !(sql_field->flags & VERS_SYSTEM_FIELD) &&
-          !key->invisible && DBUG_EVALUATE_IF("test_invisible_index", 0, 1))
+          !key->invisible && !DBUG_IF("test_invisible_index"))
       {
-        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
+        my_error(ER_KEY_COLUMN_DOES_NOT_EXIST, MYF(0), column->field_name.str);
         DBUG_RETURN(TRUE);
       }
       while ((dup_column= cols2++) != column)
@@ -6017,9 +6015,8 @@ remove_key:
         if (!part_elem)
         {
           push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
-                              ER_DROP_PARTITION_NON_EXISTENT,
-                              ER_THD(thd, ER_DROP_PARTITION_NON_EXISTENT),
-                              "DROP");
+                              ER_PARTITION_DOES_NOT_EXIST,
+                              ER_THD(thd, ER_PARTITION_DOES_NOT_EXIST));
           names_it.remove();
         }
       }
@@ -8310,7 +8307,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
           key_type= Key::UNIQUE;
         if (dropped_key_part)
         {
-          my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), dropped_key_part);
+          my_error(ER_KEY_COLUMN_DOES_NOT_EXIST, MYF(0), dropped_key_part);
           if (long_hash_key)
           {
             key_info->algorithm= HA_KEY_ALG_LONG_HASH;
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index deb78f4dfe4..6afe7ef8e95 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -5462,7 +5462,7 @@ versioning_option:
           {
             if (unlikely(Lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
             {
-              if (DBUG_EVALUATE_IF("sysvers_force", 0, 1))
+              if (!DBUG_IF("sysvers_force"))
               {
                 my_error(ER_VERS_NOT_SUPPORTED, MYF(0), "CREATE TEMPORARY TABLE");
                 MYSQL_YYABORT;