List:Commits« Previous MessageNext Message »
From:Sven Sandberg Date:July 22 2009 4:29pm
Subject:bzr commit into mysql-5.1-bugteam branch (sven.sandberg:3028) Bug#39934
View as plain text  
#At file:///home/sven/bzr/b39934-mats-slave_row_engine/5.1-bugteam/ based on revid:sven.sandberg@stripped

 3028 Sven Sandberg	2009-07-22
      Post-push fix for BUG#39934
      Moved decide_logging_format to sql_class.cc
     @ sql/sql_base.cc
        Moved decide_logging_format to sql_class.cc
        The auxiliary macro FLAGSTR is not needed here any more.
     @ sql/sql_class.cc
        - Moved decide_logging_format from sql_base.cc to here.
        - To avoid copying the FLAGSTR macro, I changed some
          DBUG_PRINT to just print flags in hex. No need to
          pretty-print debug traces.
        - Changed the type of 'flags' to handler::Table_flags
          because that's the return type of handler::ha_table_flags.

    modified:
      sql/sql_base.cc
      sql/sql_class.cc
=== modified file 'sql/sql_base.cc'
--- a/sql/sql_base.cc	2009-07-22 16:16:17 +0000
+++ b/sql/sql_base.cc	2009-07-22 16:29:26 +0000
@@ -28,7 +28,6 @@
 #include <io.h>
 #endif
 
-#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
 
 /**
   This internal handler is used to trap internally
@@ -5052,303 +5051,6 @@ static void mark_real_tables_as_free_for
 }
 
 
-/**
-  Decide on logging format to use for the statement and issue errors
-  or warnings as needed.  The decision depends on the following
-  parameters:
-
-  - The logging mode, i.e., the value of binlog_format.  Can be
-    statement, mixed, or row.
-
-  - The type of statement.  There are three types of statements:
-    "normal" safe statements; unsafe statements; and row injections.
-    An unsafe statement is one that, if logged in statement format,
-    might produce different results when replayed on the slave (e.g.,
-    INSERT DELAYED).  A row injection is either a BINLOG statement, or
-    a row event executed by the slave's SQL thread.
-
-  - The capabilities of tables modified by the statement.  The
-    *capabilities vector* for a table is a set of flags associated
-    with the table.  Currently, it only includes two flags: *row
-    capability flag* and *statement capability flag*.
-
-    The row capability flag is set if and only if the engine can
-    handle row-based logging. The statement capability flag is set if
-    and only if the table can handle statement-based logging.
-
-  Decision table for logging format
-  ---------------------------------
-
-  The following table summarizes how the format and generated
-  warning/error depends on the tables' capabilities, the statement
-  type, and the current binlog_format.
-
-     Row capable        N NNNNNNNNN YYYYYYYYY YYYYYYYYY
-     Statement capable  N YYYYYYYYY NNNNNNNNN YYYYYYYYY
-
-     Statement type     * SSSUUUIII SSSUUUIII SSSUUUIII
-
-     binlog_format      * SMRSMRSMR SMRSMRSMR SMRSMRSMR
-
-     Logged format      - SS-SS---- -RR-RR-RR SRRSRR-RR
-     Warning/Error      1 --2332444 5--5--6-- ---7--6--
-
-  Legend
-  ------
-
-  Row capable:    N - Some table not row-capable, Y - All tables row-capable
-  Stmt capable:   N - Some table not stmt-capable, Y - All tables stmt-capable
-  Statement type: (S)afe, (U)nsafe, or Row (I)njection
-  binlog_format:  (S)TATEMENT, (M)IXED, or (R)OW
-  Logged format:  (S)tatement or (R)ow
-  Warning/Error:  Warnings and error messages are as follows:
-
-  1. Error: Cannot execute statement: binlogging impossible since both
-     row-incapable engines and statement-incapable engines are
-     involved.
-
-  2. Error: Cannot execute statement: binlogging impossible since
-     BINLOG_FORMAT = ROW and at least one table uses a storage engine
-     limited to statement-logging.
-
-  3. Warning: Unsafe statement binlogged as statement since storage
-     engine is limited to statement-logging.
-
-  4. Error: Cannot execute row injection: binlogging impossible since
-     at least one table uses a storage engine limited to
-     statement-logging.
-
-  5. Error: Cannot execute statement: binlogging impossible since
-     BINLOG_FORMAT = STATEMENT and at least one table uses a storage
-     engine limited to row-logging.
-
-  6. Error: Cannot execute row injection: binlogging impossible since
-     BINLOG_FORMAT = STATEMENT.
-
-  7. Warning: Unsafe statement binlogged in statement format since
-     BINLOG_FORMAT = STATEMENT.
-
-  In addition, we can produce the following error (not depending on
-  the variables of the decision diagram):
-
-  8. Error: Cannot execute statement: binlogging impossible since more
-     than one engine is involved and at least one engine is
-     self-logging.
-
-  For each error case above, the statement is prevented from being
-  logged, we report an error, and roll back the statement.  For
-  warnings, we set the thd->binlog_flags variable: the warning will be
-  printed only if the statement is successfully logged.
-
-  @see THD::binlog_query
-
-  @param[in] thd    Client thread
-  @param[in] tables Tables involved in the query
-
-  @retval 0 No error; statement can be logged.
-  @retval -1 One of the error conditions above applies (1, 2, 4, 5, or 6).
-*/
-
-int THD::decide_logging_format(TABLE_LIST *tables)
-{
-  DBUG_ENTER("THD::decide_logging_format");
-  DBUG_PRINT("info", ("query: %s", query));
-  DBUG_PRINT("info", ("variables.binlog_format: %ld",
-                      variables.binlog_format));
-  DBUG_PRINT("info", ("lex->get_stmt_unsafe_flags(): 0x%x",
-                      lex->get_stmt_unsafe_flags()));
-  if (mysql_bin_log.is_open() && (options & OPTION_BIN_LOG))
-  {
-    /*
-      Compute one bit field with the union of all the engine
-      capabilities, and one with the intersection of all the engine
-      capabilities.
-    */
-    handler::Table_flags flags_some_set= 0;
-    handler::Table_flags flags_all_set=
-      HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE;
-
-    my_bool multi_engine= FALSE;
-    void* prev_ht= NULL;
-
-#ifndef DBUG_OFF
-    {
-      static const char *prelocked_mode_name[] = {
-        "NON_PRELOCKED",
-        "PRELOCKED",
-        "PRELOCKED_UNDER_LOCK_TABLES",
-      };
-      DBUG_PRINT("debug", ("prelocked_mode: %s",
-                           prelocked_mode_name[prelocked_mode]));
-    }
-#endif
-
-    /*
-      Get the capabilities vector for all involved storage engines and
-      mask out the flags for the binary log.
-    */
-    for (TABLE_LIST *table= tables; table; table= table->next_global)
-    {
-      if (table->placeholder())
-        continue;
-      if (table->table->s->table_category == TABLE_CATEGORY_PERFORMANCE)
-        lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_TABLE);
-      if (table->lock_type >= TL_WRITE_ALLOW_WRITE)
-      {
-        ulonglong const flags= table->table->file->ha_table_flags();
-        DBUG_PRINT("info", ("table: %s; ha_table_flags: %s%s",
-                            table->table_name,
-                            FLAGSTR(flags, HA_BINLOG_STMT_CAPABLE),
-                            FLAGSTR(flags, HA_BINLOG_ROW_CAPABLE)));
-        if (prev_ht && prev_ht != table->table->file->ht)
-          multi_engine= TRUE;
-        prev_ht= table->table->file->ht;
-        flags_all_set &= flags;
-        flags_some_set |= flags;
-      }
-    }
-
-    DBUG_PRINT("info", ("flags_all_set: %s%s",
-                        FLAGSTR(flags_all_set, HA_BINLOG_STMT_CAPABLE),
-                        FLAGSTR(flags_all_set, HA_BINLOG_ROW_CAPABLE)));
-    DBUG_PRINT("info", ("flags_some_set: %s%s",
-                        FLAGSTR(flags_some_set, HA_BINLOG_STMT_CAPABLE),
-                        FLAGSTR(flags_some_set, HA_BINLOG_ROW_CAPABLE)));
-    DBUG_PRINT("info", ("multi_engine: %s",
-                        multi_engine ? "TRUE" : "FALSE"));
-
-    int error= 0;
-    int unsafe_flags;
-
-    /*
-      If more than one engine is involved in the statement and at
-      least one is doing it's own logging (is *self-logging*), the
-      statement cannot be logged atomically, so we generate an error
-      rather than allowing the binlog to become corrupt.
-    */
-    if (multi_engine &&
-        (flags_some_set & HA_HAS_OWN_BINLOGGING))
-    {
-      my_error((error= ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE),
-               MYF(0));
-    }
-
-    /* both statement-only and row-only engines involved */
-    if ((flags_all_set & (HA_BINLOG_STMT_CAPABLE | HA_BINLOG_ROW_CAPABLE)) == 0)
-    {
-      /*
-        1. Error: Binary logging impossible since both row-incapable
-           engines and statement-incapable engines are involved
-      */
-      my_error((error= ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE), MYF(0));
-    }
-    /* statement-only engines involved */
-    else if ((flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
-    {
-      if (lex->is_stmt_row_injection())
-      {
-        /*
-          4. Error: Cannot execute row injection since table uses
-             storage engine limited to statement-logging
-        */
-        my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0));
-      }
-      else if (variables.binlog_format == BINLOG_FORMAT_ROW)
-      {
-        /*
-          2. Error: Cannot modify table that uses a storage engine
-             limited to statement-logging when BINLOG_FORMAT = ROW
-        */
-        my_error((error= ER_BINLOG_ROW_MODE_AND_STMT_ENGINE), MYF(0));
-      }
-      else if ((unsafe_flags= lex->get_stmt_unsafe_flags()) != 0)
-      {
-        /*
-          3. Warning: Unsafe statement binlogged as statement since
-             storage engine is limited to statement-logging.
-        */
-        binlog_unsafe_warning_flags|=
-          (1 << BINLOG_STMT_WARNING_UNSAFE_AND_STMT_ENGINE) |
-          (unsafe_flags << BINLOG_STMT_WARNING_COUNT);
-        DBUG_PRINT("info", ("Scheduling warning to be issued by "
-                            "binlog_query: %s",
-                            ER(ER_BINLOG_UNSAFE_AND_STMT_ENGINE)));
-        DBUG_PRINT("info", ("binlog_unsafe_warning_flags: 0x%x",
-                            binlog_unsafe_warning_flags));
-      }
-      /* log in statement format! */
-    }
-    /* no statement-only engines */
-    else
-    {
-      /* binlog_format = STATEMENT */
-      if (variables.binlog_format == BINLOG_FORMAT_STMT)
-      {
-        if (lex->is_stmt_row_injection())
-        {
-          /*
-            6. Error: Cannot execute row injection since
-               BINLOG_FORMAT = STATEMENT
-          */
-          my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_MODE), MYF(0));
-        }
-        else if ((flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
-        {
-          /*
-            5. Error: Cannot modify table that uses a storage engine
-               limited to row-logging when binlog_format = STATEMENT
-          */
-          my_error((error= ER_BINLOG_STMT_MODE_AND_ROW_ENGINE), MYF(0), "");
-        }
-        else if ((unsafe_flags= lex->get_stmt_unsafe_flags()) != 0)
-        {
-          /*
-            7. Warning: Unsafe statement logged as statement due to
-               binlog_format = STATEMENT
-          */
-          binlog_unsafe_warning_flags|=
-            (1 << BINLOG_STMT_WARNING_UNSAFE_AND_STMT_MODE) |
-            (unsafe_flags << BINLOG_STMT_WARNING_COUNT);
-          DBUG_PRINT("info", ("Scheduling warning to be issued by "
-                              "binlog_query: '%s'",
-                              ER(ER_BINLOG_UNSAFE_STATEMENT)));
-          DBUG_PRINT("info", ("binlog_stmt_flags: 0x%x",
-                              binlog_unsafe_warning_flags));
-        }
-        /* log in statement format! */
-      }
-      /* No statement-only engines and binlog_format != STATEMENT.
-         I.e., nothing prevents us from row logging if needed. */
-      else
-      {
-        if (lex->is_stmt_unsafe() || lex->is_stmt_row_injection()
-            || (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
-        {
-          /* log in row format! */
-          set_current_stmt_binlog_row_based_if_mixed();
-        }
-      }
-    }
-
-    if (error) {
-      DBUG_PRINT("info", ("decision: no logging since an error was generated"));
-      DBUG_RETURN(-1);
-    }
-    DBUG_PRINT("info", ("decision: logging in %s format",
-                        is_current_stmt_binlog_format_row() ?
-                        "ROW" : "STATEMENT"));
-  }
-#ifndef DBUG_OFF
-  else
-    DBUG_PRINT("info", ("decision: no logging since "
-                        "mysql_bin_log.is_open() = %d "
-                        "and (options & OPTION_BIN_LOG) = 0x%llx",
-                        mysql_bin_log.is_open(), (options & OPTION_BIN_LOG)));
-#endif
-
-  DBUG_RETURN(0);
-}
-
 /*
   Lock all tables in list
 

=== modified file 'sql/sql_class.cc'
--- a/sql/sql_class.cc	2009-07-22 16:16:17 +0000
+++ b/sql/sql_class.cc	2009-07-22 16:29:26 +0000
@@ -3158,6 +3158,298 @@ void xid_cache_delete(XID_STATE *xid_sta
   pthread_mutex_unlock(&LOCK_xid_cache);
 }
 
+
+/**
+  Decide on logging format to use for the statement and issue errors
+  or warnings as needed.  The decision depends on the following
+  parameters:
+
+  - The logging mode, i.e., the value of binlog_format.  Can be
+    statement, mixed, or row.
+
+  - The type of statement.  There are three types of statements:
+    "normal" safe statements; unsafe statements; and row injections.
+    An unsafe statement is one that, if logged in statement format,
+    might produce different results when replayed on the slave (e.g.,
+    INSERT DELAYED).  A row injection is either a BINLOG statement, or
+    a row event executed by the slave's SQL thread.
+
+  - The capabilities of tables modified by the statement.  The
+    *capabilities vector* for a table is a set of flags associated
+    with the table.  Currently, it only includes two flags: *row
+    capability flag* and *statement capability flag*.
+
+    The row capability flag is set if and only if the engine can
+    handle row-based logging. The statement capability flag is set if
+    and only if the table can handle statement-based logging.
+
+  Decision table for logging format
+  ---------------------------------
+
+  The following table summarizes how the format and generated
+  warning/error depends on the tables' capabilities, the statement
+  type, and the current binlog_format.
+
+     Row capable        N NNNNNNNNN YYYYYYYYY YYYYYYYYY
+     Statement capable  N YYYYYYYYY NNNNNNNNN YYYYYYYYY
+
+     Statement type     * SSSUUUIII SSSUUUIII SSSUUUIII
+
+     binlog_format      * SMRSMRSMR SMRSMRSMR SMRSMRSMR
+
+     Logged format      - SS-SS---- -RR-RR-RR SRRSRR-RR
+     Warning/Error      1 --2332444 5--5--6-- ---7--6--
+
+  Legend
+  ------
+
+  Row capable:    N - Some table not row-capable, Y - All tables row-capable
+  Stmt capable:   N - Some table not stmt-capable, Y - All tables stmt-capable
+  Statement type: (S)afe, (U)nsafe, or Row (I)njection
+  binlog_format:  (S)TATEMENT, (M)IXED, or (R)OW
+  Logged format:  (S)tatement or (R)ow
+  Warning/Error:  Warnings and error messages are as follows:
+
+  1. Error: Cannot execute statement: binlogging impossible since both
+     row-incapable engines and statement-incapable engines are
+     involved.
+
+  2. Error: Cannot execute statement: binlogging impossible since
+     BINLOG_FORMAT = ROW and at least one table uses a storage engine
+     limited to statement-logging.
+
+  3. Warning: Unsafe statement binlogged as statement since storage
+     engine is limited to statement-logging.
+
+  4. Error: Cannot execute row injection: binlogging impossible since
+     at least one table uses a storage engine limited to
+     statement-logging.
+
+  5. Error: Cannot execute statement: binlogging impossible since
+     BINLOG_FORMAT = STATEMENT and at least one table uses a storage
+     engine limited to row-logging.
+
+  6. Error: Cannot execute row injection: binlogging impossible since
+     BINLOG_FORMAT = STATEMENT.
+
+  7. Warning: Unsafe statement binlogged in statement format since
+     BINLOG_FORMAT = STATEMENT.
+
+  In addition, we can produce the following error (not depending on
+  the variables of the decision diagram):
+
+  8. Error: Cannot execute statement: binlogging impossible since more
+     than one engine is involved and at least one engine is
+     self-logging.
+
+  For each error case above, the statement is prevented from being
+  logged, we report an error, and roll back the statement.  For
+  warnings, we set the thd->binlog_flags variable: the warning will be
+  printed only if the statement is successfully logged.
+
+  @see THD::binlog_query
+
+  @param[in] thd    Client thread
+  @param[in] tables Tables involved in the query
+
+  @retval 0 No error; statement can be logged.
+  @retval -1 One of the error conditions above applies (1, 2, 4, 5, or 6).
+*/
+
+int THD::decide_logging_format(TABLE_LIST *tables)
+{
+  DBUG_ENTER("THD::decide_logging_format");
+  DBUG_PRINT("info", ("query: %s", query));
+  DBUG_PRINT("info", ("variables.binlog_format: %ld",
+                      variables.binlog_format));
+  DBUG_PRINT("info", ("lex->get_stmt_unsafe_flags(): 0x%x",
+                      lex->get_stmt_unsafe_flags()));
+  if (mysql_bin_log.is_open() && (options & OPTION_BIN_LOG))
+  {
+    /*
+      Compute one bit field with the union of all the engine
+      capabilities, and one with the intersection of all the engine
+      capabilities.
+    */
+    handler::Table_flags flags_some_set= 0;
+    handler::Table_flags flags_all_set=
+      HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE;
+
+    my_bool multi_engine= FALSE;
+    void* prev_ht= NULL;
+
+#ifndef DBUG_OFF
+    {
+      static const char *prelocked_mode_name[] = {
+        "NON_PRELOCKED",
+        "PRELOCKED",
+        "PRELOCKED_UNDER_LOCK_TABLES",
+      };
+      DBUG_PRINT("debug", ("prelocked_mode: %s",
+                           prelocked_mode_name[prelocked_mode]));
+    }
+#endif
+
+    /*
+      Get the capabilities vector for all involved storage engines and
+      mask out the flags for the binary log.
+    */
+    for (TABLE_LIST *table= tables; table; table= table->next_global)
+    {
+      if (table->placeholder())
+        continue;
+      if (table->table->s->table_category == TABLE_CATEGORY_PERFORMANCE)
+        lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_TABLE);
+      if (table->lock_type >= TL_WRITE_ALLOW_WRITE)
+      {
+        handler::Table_flags const flags= table->table->file->ha_table_flags();
+        DBUG_PRINT("info", ("table: %s; ha_table_flags: 0x%llx",
+                            table->table_name, flags));
+        if (prev_ht && prev_ht != table->table->file->ht)
+          multi_engine= TRUE;
+        prev_ht= table->table->file->ht;
+        flags_all_set &= flags;
+        flags_some_set |= flags;
+      }
+    }
+
+    DBUG_PRINT("info", ("flags_all_set: 0x%llx", flags_all_set));
+    DBUG_PRINT("info", ("flags_some_set: 0x%llx", flags_some_set));
+    DBUG_PRINT("info", ("multi_engine: %d", multi_engine));
+
+    int error= 0;
+    int unsafe_flags;
+
+    /*
+      If more than one engine is involved in the statement and at
+      least one is doing it's own logging (is *self-logging*), the
+      statement cannot be logged atomically, so we generate an error
+      rather than allowing the binlog to become corrupt.
+    */
+    if (multi_engine &&
+        (flags_some_set & HA_HAS_OWN_BINLOGGING))
+    {
+      my_error((error= ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE),
+               MYF(0));
+    }
+
+    /* both statement-only and row-only engines involved */
+    if ((flags_all_set & (HA_BINLOG_STMT_CAPABLE | HA_BINLOG_ROW_CAPABLE)) == 0)
+    {
+      /*
+        1. Error: Binary logging impossible since both row-incapable
+           engines and statement-incapable engines are involved
+      */
+      my_error((error= ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE), MYF(0));
+    }
+    /* statement-only engines involved */
+    else if ((flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
+    {
+      if (lex->is_stmt_row_injection())
+      {
+        /*
+          4. Error: Cannot execute row injection since table uses
+             storage engine limited to statement-logging
+        */
+        my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0));
+      }
+      else if (variables.binlog_format == BINLOG_FORMAT_ROW)
+      {
+        /*
+          2. Error: Cannot modify table that uses a storage engine
+             limited to statement-logging when BINLOG_FORMAT = ROW
+        */
+        my_error((error= ER_BINLOG_ROW_MODE_AND_STMT_ENGINE), MYF(0));
+      }
+      else if ((unsafe_flags= lex->get_stmt_unsafe_flags()) != 0)
+      {
+        /*
+          3. Warning: Unsafe statement binlogged as statement since
+             storage engine is limited to statement-logging.
+        */
+        binlog_unsafe_warning_flags|=
+          (1 << BINLOG_STMT_WARNING_UNSAFE_AND_STMT_ENGINE) |
+          (unsafe_flags << BINLOG_STMT_WARNING_COUNT);
+        DBUG_PRINT("info", ("Scheduling warning to be issued by "
+                            "binlog_query: %s",
+                            ER(ER_BINLOG_UNSAFE_AND_STMT_ENGINE)));
+        DBUG_PRINT("info", ("binlog_unsafe_warning_flags: 0x%x",
+                            binlog_unsafe_warning_flags));
+      }
+      /* log in statement format! */
+    }
+    /* no statement-only engines */
+    else
+    {
+      /* binlog_format = STATEMENT */
+      if (variables.binlog_format == BINLOG_FORMAT_STMT)
+      {
+        if (lex->is_stmt_row_injection())
+        {
+          /*
+            6. Error: Cannot execute row injection since
+               BINLOG_FORMAT = STATEMENT
+          */
+          my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_MODE), MYF(0));
+        }
+        else if ((flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
+        {
+          /*
+            5. Error: Cannot modify table that uses a storage engine
+               limited to row-logging when binlog_format = STATEMENT
+          */
+          my_error((error= ER_BINLOG_STMT_MODE_AND_ROW_ENGINE), MYF(0), "");
+        }
+        else if ((unsafe_flags= lex->get_stmt_unsafe_flags()) != 0)
+        {
+          /*
+            7. Warning: Unsafe statement logged as statement due to
+               binlog_format = STATEMENT
+          */
+          binlog_unsafe_warning_flags|=
+            (1 << BINLOG_STMT_WARNING_UNSAFE_AND_STMT_MODE) |
+            (unsafe_flags << BINLOG_STMT_WARNING_COUNT);
+          DBUG_PRINT("info", ("Scheduling warning to be issued by "
+                              "binlog_query: '%s'",
+                              ER(ER_BINLOG_UNSAFE_STATEMENT)));
+          DBUG_PRINT("info", ("binlog_stmt_flags: 0x%x",
+                              binlog_unsafe_warning_flags));
+        }
+        /* log in statement format! */
+      }
+      /* No statement-only engines and binlog_format != STATEMENT.
+         I.e., nothing prevents us from row logging if needed. */
+      else
+      {
+        if (lex->is_stmt_unsafe() || lex->is_stmt_row_injection()
+            || (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
+        {
+          /* log in row format! */
+          set_current_stmt_binlog_row_based_if_mixed();
+        }
+      }
+    }
+
+    if (error) {
+      DBUG_PRINT("info", ("decision: no logging since an error was generated"));
+      DBUG_RETURN(-1);
+    }
+    DBUG_PRINT("info", ("decision: logging in %s format",
+                        is_current_stmt_binlog_format_row() ?
+                        "ROW" : "STATEMENT"));
+  }
+#ifndef DBUG_OFF
+  else
+    DBUG_PRINT("info", ("decision: no logging since "
+                        "mysql_bin_log.is_open() = %d "
+                        "and (options & OPTION_BIN_LOG) = 0x%llx",
+                        mysql_bin_log.is_open(), (options & OPTION_BIN_LOG)));
+#endif
+
+  DBUG_RETURN(0);
+}
+
+
 /*
   Implementation of interface to write rows to the binary log through the
   thread.  The thread is responsible for writing the rows it has


Attachment: [text/bzr-bundle] bzr/sven.sandberg@sun.com-20090722162926-ju6wchfwo8iaiurn.bundle
Thread
bzr commit into mysql-5.1-bugteam branch (sven.sandberg:3028) Bug#39934Sven Sandberg23 Jul