(pushing for Andrei)

Bug #27417 thd->no_trans_update.stmt lost value inside of SF-exec-stack
  
Once had been set the flag might later got reset inside of a stored routine 
execution stack.
The reason was in that there was no check if a new statement started at time 
of resetting.
The artifact affects most of binlogable DML queries. Notice, that multi-update 
is wrapped up within
  bug@27716 fix, multi-delete bug@29136.
  
Fixed with saving parent's statement flag of whether the statement modified 
non-transactional table, and unioning (merging) the value with that was gained 
in mysql_execute_command.
  
Resettling thd->no_trans_update members into thd->transaction.`member`;
Asserting code;
Effectively the following properties are held.
  
1. At the end of a substatement thd->transaction.stmt.modified_non_trans_table
   reflects the fact if such a table got modified by the substatement.
   That also respects THD::really_abort_on_warnin() requirements.
2. Eventually thd->transaction.stmt.modified_non_trans_table will be computed as
   the union of the values of all invoked sub-statements.
   That fixes this bug#27417;

Computing of thd->transaction.all.modified_non_trans_table is refined to base to 
the stmt's value for all the case including insert .. select statement which 
before the patch had an extra issue bug@28960.
Minor issues are covered with mysql_load, mysql_delete, and binloggin of insert in
to temp_table select. 
  
The supplied test verifies limitely, mostly asserts. The ultimate testing is defered
for bug@13270, bug@23333.


mysql-test/r/mix_innodb_myisam_binlog.result:
  results changed
mysql-test/t/mix_innodb_myisam_binlog.test:
  regression test incl the related bug#28960.
sql/ha_ndbcluster.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/handler.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/handler.h:
  new member added
sql/log.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/set_var.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/sp_head.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
  
  and saving and merging stmt's flag at the end of a substatement.
sql/sql_class.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/sql_class.h:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/sql_delete.cc:
  correcting basic delete incl truncate branch and multi-delete queries to set
  stmt.modified_non_trans_table;
  optimization to set the flag at the end of per-row loop;
  multi-delete still has an extra issue similar to bug#27716 of multi-update 
  - to be address with bug_29136 fix.
sql/sql_insert.cc:
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/sql_load.cc:
  eliminating a separate issue where the stmt flag was saved and re-stored after 
  write_record that actually could change it and the change would be lost but 
  should remain permanent;
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}
sql/sql_parse.cc:
  initialization to transaction.stmt.modified_non_trans_table at the common part 
  of all types of statements processing - mysql_execute_command().
sql/sql_table.cc:
  moving the reset up to the mysql_execute_command() caller
sql/sql_update.cc:
  correcting update query case (multi-update part of the issues covered by other 
  bug#27716 fix)
  thd->transaction.{all,stmt}.modified_non_trans_table
  instead of
  thd->no_trans_update.{all,stmt}

1 files changed, 15 insertions, 5 deletions

diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index fd8724b2171..589e59faca4 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -337,13 +337,13 @@ sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr)
   
   enum_check_fields save_count_cuted_fields= thd->count_cuted_fields;
   bool save_abort_on_warning= thd->abort_on_warning;
-  bool save_no_trans_update_stmt= thd->no_trans_update.stmt;
+  bool save_stmt_modified_non_trans_table= thd->transaction.stmt.modified_non_trans_table;
 
   thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL;
   thd->abort_on_warning=
     thd->variables.sql_mode &
     (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES);
-  thd->no_trans_update.stmt= FALSE;
+  thd->transaction.stmt.modified_non_trans_table= FALSE;
 
   /* Save the value in the field. Convert the value if needed. */
 
@@ -351,7 +351,7 @@ sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr)
 
   thd->count_cuted_fields= save_count_cuted_fields;
   thd->abort_on_warning= save_abort_on_warning;
-  thd->no_trans_update.stmt= save_no_trans_update_stmt;
+  thd->transaction.stmt.modified_non_trans_table= save_stmt_modified_non_trans_table;
 
   if (thd->net.report_error)
   {
@@ -2400,7 +2400,13 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
                                        bool open_tables, sp_instr* instr)
 {
   int res= 0;
-
+  /* 
+    The flag is saved at the entry to the following substatement.
+    It's reset further in the common code part.
+    It's merged with the saved parent's value at the exit of this func.
+  */
+  bool parent_modified_non_trans_table= thd->transaction.stmt.modified_non_trans_table;
+  thd->transaction.stmt.modified_non_trans_table= FALSE;
   DBUG_ASSERT(!thd->derived_tables);
   DBUG_ASSERT(thd->change_list.is_empty());
   /*
@@ -2467,7 +2473,11 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
   /* Update the state of the active arena. */
   thd->stmt_arena->state= Query_arena::EXECUTED;
 
-
+  /*
+    Merge here with the saved parent's values
+    what is needed from the substatement gained
+  */
+  thd->transaction.stmt.modified_non_trans_table |= parent_modified_non_trans_table;
   /*
     Unlike for PS we should not call Item's destructors for newly created
     items after execution of each instruction in stored routine. This is