bug #18518 (embedded server crashes starting)

The problem is that now server works properly only with the 
row-based replication

config/ac-macros/ha_ndbcluster.m4

@@ -238,7 +238,7 @@ AC_DEFUN([MYSQL_SETUP_NDBCLUSTER], [
 
   if test X"$have_ndb_binlog" = Xyes
   then
-    AC_DEFINE([HAVE_NDB_BINLOG], [1],
+    AC_DEFINE([WITH_NDB_BINLOG], [1],
               [Including Ndb Cluster Binlog])
     AC_MSG_RESULT([Including Ndb Cluster Binlog])
   else

config/ac-macros/replication.m4

@@ -15,7 +15,7 @@ AC_DEFUN([MYSQL_CHECK_REPLICATION], [
 
   case "$row_based" in
   yes )
-    AC_DEFINE([HAVE_ROW_BASED_REPLICATION], [1], [Define to have row-based replication])
+    AC_DEFINE([WITH_ROW_BASED_REPLICATION], [1], [Define to have row-based replication])
     AC_MSG_RESULT([-- including row-based replication])
     [have_row_based=yes]
     ;;

sql/log.cc

@@ -1071,12 +1071,16 @@ binlog_end_trans(THD *thd, binlog_trx_data *trx_data, Log_event *end_ev)
       were, we would have to ensure that we're not ending a statement
       inside a stored function.
      */
+#ifdef HAVE_ROW_BASED_REPLICATION
     thd->binlog_flush_pending_rows_event(true);
+#endif
     error= mysql_bin_log.write(thd, trans_log, end_ev);
   }
   else
   {
+#ifdef HAVE_ROW_BASED_REPLICATION
     thd->binlog_delete_pending_rows_event();
+#endif
   }
 
   /*
@@ -2600,6 +2604,7 @@ bool MYSQL_LOG::is_query_in_union(THD *thd, query_id_t query_id_param)
 }
 
 
+#ifdef HAVE_ROW_BASED_REPLICATION
 /*
   These functions are placed in this file since they need access to
   binlog_hton, which has internal linkage.
@@ -2776,6 +2781,7 @@ int MYSQL_LOG::flush_and_set_pending_rows_event(THD *thd, Rows_log_event* event)
 
   DBUG_RETURN(error);
 }
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 
 /*
   Write an event to the binary log
@@ -2810,7 +2816,9 @@ bool MYSQL_LOG::write(Log_event *event_info)
   */
   bool const end_stmt=
     thd->prelocked_mode && thd->lex->requires_prelocking();
+#ifdef HAVE_ROW_BASED_REPLICATION
   thd->binlog_flush_pending_rows_event(end_stmt);
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 
   pthread_mutex_lock(&LOCK_log);
 
@@ -2852,8 +2860,10 @@ bool MYSQL_LOG::write(Log_event *event_info)
     */
     if (opt_using_transactions && thd)
     {
+#ifdef HAVE_ROW_BASED_REPLICATION
       if (thd->binlog_setup_trx_data())
         goto err;
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 
       binlog_trx_data *const trx_data=
         (binlog_trx_data*) thd->ha_data[binlog_hton.slot];

sql/mysqld.cc

@@ -3180,7 +3180,7 @@ with --log-bin instead.");
   }
   if (global_system_variables.binlog_format == BINLOG_FORMAT_UNSPEC)
   {
-#ifdef HAVE_NDB_BINLOG
+#if defined(HAVE_NDB_BINLOG) && defined(HAVE_ROW_BASED_REPLICATION)
     if (opt_bin_log && have_ndbcluster == SHOW_OPTION_YES)
       global_system_variables.binlog_format= BINLOG_FORMAT_ROW;
     else

sql/set_var.cc

@@ -1262,12 +1262,14 @@ bool sys_var_thd_binlog_format::is_readonly() const
     And this test will also prevent switching from RBR to RBR (a no-op which
     should not happen too often).
   */
+#ifdef HAVE_ROW_BASED_REPLICATION
   if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW) &&
       thd->temporary_tables)
   {
     my_error(ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR, MYF(0));
     return 1;
   }
+#endif /*HAVE_ROW_BASED_REPLICATION*/
   /*
     if in a stored function, it's too late to change mode
   */
@@ -1291,7 +1293,9 @@ bool sys_var_thd_binlog_format::is_readonly() const
 
 void fix_binlog_format_after_update(THD *thd, enum_var_type type)
 {
+#ifdef HAVE_ROW_BASED_REPLICATION
   thd->reset_current_stmt_binlog_row_based();
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 }
 
 static void fix_max_binlog_size(THD *thd, enum_var_type type)

sql/sql_base.cc

@@ -1069,7 +1069,9 @@ void close_thread_tables(THD *thd, bool lock_in_use, bool skip_derived)
       handled either before writing a query log event (inside
       binlog_query()) or when preparing a pending event.
      */
+#ifdef HAVE_ROW_BASED_REPLICATION
     thd->binlog_flush_pending_rows_event(true);
+#endif /*HAVE_ROW_BASED_REPLICATION*/
     mysql_unlock_tables(thd, thd->lock);
     thd->lock=0;
   }

sql/sql_class.cc

@@ -197,7 +197,10 @@ THD::THD()
   :Statement(CONVENTIONAL_EXECUTION, 0, ALLOC_ROOT_MIN_BLOCK_SIZE, 0),
    Open_tables_state(refresh_version), rli_fake(0),
    lock_id(&main_lock_id),
-   user_time(0), in_sub_stmt(0), binlog_table_maps(0),
+   user_time(0), in_sub_stmt(0),
+#ifdef HAVE_ROW_BASED_REPLICATION
+   binlog_table_maps(0),
+#endif /*HAVE_ROW_BASED_REPLICATION*/
    global_read_lock(0), is_fatal_error(0),
    rand_used(0), time_zone_used(0),
    last_insert_id_used(0), insert_id_used(0), clear_next_insert_id(0),
@@ -330,7 +333,9 @@ void THD::init(void)
   bzero((char*) warn_count, sizeof(warn_count));
   total_warn_count= 0;
   update_charset();
+#ifdef HAVE_ROW_BASED_REPLICATION
   reset_current_stmt_binlog_row_based();
+#endif /*HAVE_ROW_BASED_REPLICATION*/
   bzero((char *) &status_var, sizeof(status_var));
 }
 
@@ -2618,8 +2623,10 @@ int THD::binlog_query(THD::enum_binlog_query_type qtype,
         the flushing will be done inside the top-most
         close_thread_tables().
        */
+#ifdef HAVE_ROW_BASED_REPLICATION
       if (this->lock)
         DBUG_RETURN(binlog_flush_pending_rows_event(TRUE));
+#endif /*HAVE_ROW_BASED_REPLICATION*/
       DBUG_RETURN(0);
     }
     /* Otherwise, we fall through */
@@ -2638,7 +2645,9 @@ int THD::binlog_query(THD::enum_binlog_query_type qtype,
         table maps were written.
        */
       int error= mysql_bin_log.write(&qinfo);
+#ifdef HAVE_ROW_BASED_REPLICATION
       binlog_table_maps= 0;
+#endif /*HAVE_ROW_BASED_REPLICATION*/
       DBUG_RETURN(error);
     }
     break;

sql/sql_class.h

@@ -1402,6 +1402,7 @@ public:
   void restore_sub_statement_state(Sub_statement_state *backup);
   void set_n_backup_active_arena(Query_arena *set, Query_arena *backup);
   void restore_active_arena(Query_arena *set, Query_arena *backup);
+#ifdef HAVE_ROW_BASED_REPLICATION
   inline void set_current_stmt_binlog_row_based_if_mixed()
   {
     if (variables.binlog_format == BINLOG_FORMAT_MIXED)
@@ -1415,6 +1416,7 @@ public:
   {
     current_stmt_binlog_row_based= test(variables.binlog_format == BINLOG_FORMAT_ROW);
   }
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 };
 
 

sql/sql_parse.cc

@@ -2449,8 +2449,10 @@ mysql_execute_command(THD *thd)
     statistic_increment(thd->status_var.com_stat[lex->sql_command],
                         &LOCK_status);
 
+#ifdef HAVE_ROW_BASED_REPLICATION
   if (lex->binlog_row_based_if_mixed)
     thd->set_current_stmt_binlog_row_based_if_mixed();
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 
   switch (lex->sql_command) {
   case SQLCOM_SELECT:
@@ -5111,7 +5113,9 @@ end:
   */
   if (thd->one_shot_set && lex->sql_command != SQLCOM_SET_OPTION)
     reset_one_shot_variables(thd);
+#ifdef HAVE_ROW_BASED_REPLICATION
   thd->reset_current_stmt_binlog_row_based();
+#endif /*HAVE_ROW_BASED_REPLICATION*/
 
   /*
     The return value for ROW_COUNT() is "implementation dependent" if the