WL#3023 (Use locks in a statement-like manner):

  Table maps are now written on aquiring locks to tables and released
  at the end of each logical statement.


mysql-test/extra/binlog_tests/ctype_cp932.test:
  Disabling cleanup code
mysql-test/r/binlog_row_blackhole.result:
  Result change
mysql-test/r/binlog_row_mix_innodb_myisam.result:
  Result change
mysql-test/r/binlog_stm_ctype_cp932.result:
  Result change
mysql-test/r/rpl_row_charset.result:
  Result change
mysql-test/r/rpl_row_create_table.result:
  Result change
mysql-test/t/rpl_row_create_table.test:
  Binlog position change
sql/handler.cc:
  Writing table map after external_lock()
sql/handler.h:
  Adding class for table operation hooks.
sql/log.cc:
  Adding binlog_write_table_map() to THD.
  Removing write_table_map() from MYSQL_LOG.
sql/log.h:
  Minor interface changes to move table map writing.
sql/log_event.cc:
  Removing pre-allocation of memory for buffers.
  Allowing ULONG_MAX as table id denoting an event to ignore (only used to transfer flags).
  Adding code to collect tables while seeing table maps and lock collected tables
  when seeing a binrow event.
  Debriding code as a result of the above changes.
sql/log_event.h:
  Minor interface changes.
sql/mysql_priv.h:
  Adding hooks argument to create_table_from_items().
sql/parse_file.cc:
  Minor fix to avoid crash in debug printout.
sql/rpl_rli.h:
  Adding list of tables to lock to RLI structure.
sql/slave.cc:
  Using list of tables to lock from RLI structure.
sql/sql_acl.cc:
  Removing redundant pending events flush.
sql/sql_base.cc:
  Moving pending event flush.
  Using flag to guard to clear statement transaction only if this is the original
  open tables state.
sql/sql_class.cc:
  Adding flag for open tables state.
  Removing redundant pending events flushes.
  Write a dummy event to indicate that the tables to lock should be emptied
  on the slave.
sql/sql_class.h:
  Adding open tables state flags.
  Adding binlog_write_table_map() function to THD.
  Changes to select_create() to support new locking scheme.
sql/sql_insert.cc:
  Adding rollback of statement transaction on error. It can now contain
  events after locking tables.
sql/sql_load.cc:
  Removing redundant pending event flush.
sql/sql_table.cc:
  Adding hooks argument to create_table_from_items().
  Calling prelock hook before starting to lock tables.
sql/sql_update.cc:
  Removing a compiler warning.
sql/table.h:
  Minor changes.

1 files changed, 35 insertions, 2 deletions

diff --git a/sql/handler.cc b/sql/handler.cc
index c380ff3508e..6ea627ba9e7 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -3016,10 +3016,43 @@ template int binlog_log_row<Update_rows_log_event>(TABLE *, const byte *, const
 
 int handler::ha_external_lock(THD *thd, int lock_type)
 {
+  DBUG_ENTER("handler::ha_external_lock");
   int error;
   if (unlikely(error= external_lock(thd, lock_type)))
-    return error;
-  return 0;
+    DBUG_RETURN(error);
+#ifdef HAVE_ROW_BASED_REPLICATION
+  if (table->file->is_injective())
+    DBUG_RETURN(0);
+
+  /*
+    There is a number of statements that are logged statement-based
+    but call external lock. For these, we do not need to generate a
+    table map.
+
+    TODO: The need for this switch is an indication that the model for
+    locking combined with row-based replication needs to be looked
+    over. Ideally, no such special handling should be needed.
+   */
+  switch (thd->lex->sql_command)
+  {
+  case SQLCOM_TRUNCATE:
+  case SQLCOM_ALTER_TABLE:
+    DBUG_RETURN(0);
+  }
+
+  /*
+    If we are locking a table for writing, we generate a table map.
+    For all other kinds of locks, we don't do anything.
+   */
+  if (lock_type == F_WRLCK && check_table_binlog_row_based(thd, table))
+  {
+    int const has_trans= table->file->has_transactions();
+    error= thd->binlog_write_table_map(table, has_trans);
+    if (unlikely(error))
+      DBUG_RETURN(error);
+  }
+#endif
+  DBUG_RETURN(0);
 }
 
 int handler::ha_write_row(byte *buf)