Merge kindahl-laptop.dnsalias.net:/home/bkroot/mysql-5.1-rpl

into  kindahl-laptop.dnsalias.net:/home/bk/b34458-mysql-5.1-rpl

sql/handler.cc

@@ -3843,29 +3843,25 @@ bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
   - table is not mysql.event
 */
 
-/* The Sun compiler cannot instantiate the template below if this is
-   declared static, but it works by putting it into an anonymous
-   namespace. */
-namespace {
-  bool check_table_binlog_row_based(THD *thd, TABLE *table)
+static bool check_table_binlog_row_based(THD *thd, TABLE *table)
+{
+  if (table->s->cached_row_logging_check == -1)
   {
-    if (table->s->cached_row_logging_check == -1)
-    {
-      int const check(table->s->tmp_table == NO_TMP_TABLE &&
-                      binlog_filter->db_ok(table->s->db.str));
-      table->s->cached_row_logging_check= check;
-    }
+    int const check(table->s->tmp_table == NO_TMP_TABLE &&
+                    binlog_filter->db_ok(table->s->db.str));
+    table->s->cached_row_logging_check= check;
+  }
 
-    DBUG_ASSERT(table->s->cached_row_logging_check == 0 ||
-                table->s->cached_row_logging_check == 1);
+  DBUG_ASSERT(table->s->cached_row_logging_check == 0 ||
+              table->s->cached_row_logging_check == 1);
 
-    return (thd->current_stmt_binlog_row_based &&
-            table->s->cached_row_logging_check &&
-            (thd->options & OPTION_BIN_LOG) &&
-            mysql_bin_log.is_open());
-  }
+  return (thd->current_stmt_binlog_row_based &&
+          table->s->cached_row_logging_check &&
+          (thd->options & OPTION_BIN_LOG) &&
+          mysql_bin_log.is_open());
 }
 
+
 /** @brief
    Write table maps for all (manually or automatically) locked tables
    to the binary log.
@@ -3879,7 +3875,7 @@ namespace {
        that are locked by the thread 'thd'.  Either manually locked
        (stored in THD::locked_tables) and automatically locked (stored
        in THD::lock) are considered.
-   
+
    RETURN VALUE
        0   All OK
        1   Failed to write all table maps
@@ -3888,115 +3884,97 @@ namespace {
        THD::lock
        THD::locked_tables
 */
-namespace
+
+static int write_locked_table_maps(THD *thd)
 {
-  int write_locked_table_maps(THD *thd)
-  {
-    DBUG_ENTER("write_locked_table_maps");
-    DBUG_PRINT("enter", ("thd: 0x%lx  thd->lock: 0x%lx  thd->locked_tables: 0x%lx  "
-                         "thd->extra_lock: 0x%lx",
-                         (long) thd, (long) thd->lock,
-                         (long) thd->locked_tables, (long) thd->extra_lock));
+  DBUG_ENTER("write_locked_table_maps");
+  DBUG_PRINT("enter", ("thd: 0x%lx  thd->lock: 0x%lx  thd->locked_tables: 0x%lx  "
+                       "thd->extra_lock: 0x%lx",
+                       (long) thd, (long) thd->lock,
+                       (long) thd->locked_tables, (long) thd->extra_lock));
 
-    if (thd->get_binlog_table_maps() == 0)
+  if (thd->get_binlog_table_maps() == 0)
+  {
+    MYSQL_LOCK *locks[3];
+    locks[0]= thd->extra_lock;
+    locks[1]= thd->lock;
+    locks[2]= thd->locked_tables;
+    for (uint i= 0 ; i < sizeof(locks)/sizeof(*locks) ; ++i )
     {
-      MYSQL_LOCK *locks[3];
-      locks[0]= thd->extra_lock;
-      locks[1]= thd->lock;
-      locks[2]= thd->locked_tables;
-      for (uint i= 0 ; i < sizeof(locks)/sizeof(*locks) ; ++i )
+      MYSQL_LOCK const *const lock= locks[i];
+      if (lock == NULL)
+        continue;
+
+      TABLE **const end_ptr= lock->table + lock->table_count;
+      for (TABLE **table_ptr= lock->table ; 
+           table_ptr != end_ptr ;
+           ++table_ptr)
       {
-        MYSQL_LOCK const *const lock= locks[i];
-        if (lock == NULL)
-          continue;
-
-        TABLE **const end_ptr= lock->table + lock->table_count;
-        for (TABLE **table_ptr= lock->table ; 
-             table_ptr != end_ptr ;
-             ++table_ptr)
+        TABLE *const table= *table_ptr;
+        DBUG_PRINT("info", ("Checking table %s", table->s->table_name.str));
+        if (table->current_lock == F_WRLCK &&
+            check_table_binlog_row_based(thd, table))
         {
-          TABLE *const table= *table_ptr;
-          DBUG_PRINT("info", ("Checking table %s", table->s->table_name.str));
-          if (table->current_lock == F_WRLCK &&
-              check_table_binlog_row_based(thd, table))
-          {
-            int const has_trans= table->file->has_transactions();
-            int const error= thd->binlog_write_table_map(table, has_trans);
-            /*
-              If an error occurs, it is the responsibility of the caller to
-              roll back the transaction.
-            */
-            if (unlikely(error))
-              DBUG_RETURN(1);
-          }
+          int const has_trans= table->file->has_transactions();
+          int const error= thd->binlog_write_table_map(table, has_trans);
+          /*
+            If an error occurs, it is the responsibility of the caller to
+            roll back the transaction.
+          */
+          if (unlikely(error))
+            DBUG_RETURN(1);
         }
       }
     }
-    DBUG_RETURN(0);
   }
+  DBUG_RETURN(0);
+}
 
-  template<class RowsEventT> int
-  binlog_log_row(TABLE* table,
-                 const uchar *before_record,
-                 const uchar *after_record)
+
+typedef bool Log_func(THD*, TABLE*, bool, MY_BITMAP*,
+                      uint, const uchar*, const uchar*);
+
+static int binlog_log_row(TABLE* table,
+                          const uchar *before_record,
+                          const uchar *after_record,
+                          Log_func *log_func)
+{
+  if (table->no_replicate)
+    return 0;
+  bool error= 0;
+  THD *const thd= table->in_use;
+
+  if (check_table_binlog_row_based(thd, table))
   {
-    if (table->no_replicate)
-      return 0;
-    bool error= 0;
-    THD *const thd= table->in_use;
+    MY_BITMAP cols;
+    /* Potential buffer on the stack for the bitmap */
+    uint32 bitbuf[BITMAP_STACKBUF_SIZE/sizeof(uint32)];
+    uint n_fields= table->s->fields;
+    my_bool use_bitbuf= n_fields <= sizeof(bitbuf)*8;
 
-    if (check_table_binlog_row_based(thd, table))
+    /*
+      If there are no table maps written to the binary log, this is
+      the first row handled in this statement. In that case, we need
+      to write table maps for all locked tables to the binary log.
+    */
+    if (likely(!(error= bitmap_init(&cols,
+                                    use_bitbuf ? bitbuf : NULL,
+                                    (n_fields + 7) & ~7UL,
+                                    FALSE))))
     {
-      MY_BITMAP cols;
-      /* Potential buffer on the stack for the bitmap */
-      uint32 bitbuf[BITMAP_STACKBUF_SIZE/sizeof(uint32)];
-      uint n_fields= table->s->fields;
-      my_bool use_bitbuf= n_fields <= sizeof(bitbuf)*8;
-
-      /*
-        If there are no table maps written to the binary log, this is
-        the first row handled in this statement. In that case, we need
-        to write table maps for all locked tables to the binary log.
-      */
-      if (likely(!(error= bitmap_init(&cols,
-                                      use_bitbuf ? bitbuf : NULL,
-                                      (n_fields + 7) & ~7UL,
-                                      FALSE))))
-      {
-        bitmap_set_all(&cols);
-        if (likely(!(error= write_locked_table_maps(thd))))
-        {
-          error=
-            RowsEventT::binlog_row_logging_function(thd, table,
-                                                    table->file->
-                                                    has_transactions(),
-                                                    &cols, table->s->fields,
-                                                    before_record,
-                                                    after_record);
-        }
-        if (!use_bitbuf)
-          bitmap_free(&cols);
-      }
+      bitmap_set_all(&cols);
+      if (likely(!(error= write_locked_table_maps(thd))))
+        error= (*log_func)(thd, table, table->file->has_transactions(),
+                           &cols, table->s->fields,
+                           before_record, after_record);
+
+      if (!use_bitbuf)
+        bitmap_free(&cols);
     }
-    return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
   }
-
-  /*
-    Instantiate the versions we need for the above template function,
-    because we have -fno-implicit-template as compiling option.
-  */
-
-  template int
-  binlog_log_row<Write_rows_log_event>(TABLE *, const uchar *, const uchar *);
-
-  template int
-  binlog_log_row<Delete_rows_log_event>(TABLE *, const uchar *, const uchar *);
-
-  template int
-  binlog_log_row<Update_rows_log_event>(TABLE *, const uchar *, const uchar *);
+  return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
 }
 
-
 int handler::ha_external_lock(THD *thd, int lock_type)
 {
   DBUG_ENTER("handler::ha_external_lock");
@@ -4041,10 +4019,11 @@ int handler::ha_reset()
 int handler::ha_write_row(uchar *buf)
 {
   int error;
+  Log_func *log_func= Write_rows_log_event::binlog_row_logging_function;
   DBUG_ENTER("handler::ha_write_row");
   if (unlikely(error= write_row(buf)))
     DBUG_RETURN(error);
-  if (unlikely(error= binlog_log_row<Write_rows_log_event>(table, 0, buf)))
+  if (unlikely(error= binlog_log_row(table, 0, buf, log_func)))
     DBUG_RETURN(error); /* purecov: inspected */
   DBUG_RETURN(0);
 }
@@ -4053,6 +4032,7 @@ int handler::ha_write_row(uchar *buf)
 int handler::ha_update_row(const uchar *old_data, uchar *new_data)
 {
   int error;
+  Log_func *log_func= Update_rows_log_event::binlog_row_logging_function;
 
   /*
     Some storage engines require that the new record is in record[0]
@@ -4062,7 +4042,7 @@ int handler::ha_update_row(const uchar *old_data, uchar *new_data)
 
   if (unlikely(error= update_row(old_data, new_data)))
     return error;
-  if (unlikely(error= binlog_log_row<Update_rows_log_event>(table, old_data, new_data)))
+  if (unlikely(error= binlog_log_row(table, old_data, new_data, log_func)))
     return error;
   return 0;
 }
@@ -4070,9 +4050,10 @@ int handler::ha_update_row(const uchar *old_data, uchar *new_data)
 int handler::ha_delete_row(const uchar *buf)
 {
   int error;
+  Log_func *log_func= Delete_rows_log_event::binlog_row_logging_function;
   if (unlikely(error= delete_row(buf)))
     return error;
-  if (unlikely(error= binlog_log_row<Delete_rows_log_event>(table, buf, 0)))
+  if (unlikely(error= binlog_log_row(table, buf, 0, log_func)))
     return error;
   return 0;
 }