Fix for bug#20670 "UPDATE using key and invoking trigger that modifies

this key does not stop" (5.1 version).

UPDATE statement which WHERE clause used key and which invoked trigger
that modified field in this key worked indefinetely.

This problem occured because in cases when UPDATE statement was
executed in update-on-the-fly mode (in which row is updated right
during evaluation of select for WHERE clause) the new version of
the row became visible to select representing WHERE clause and was
updated again and again.
We already solve this problem for UPDATE statements which does not
invoke triggers by detecting the fact that we are going to update
field in key used for scanning and performing update in two steps,
during the first step we gather information about the rows to be
updated and then doing actual updates. We also do this for
MULTI-UPDATE and in its case we even detect situation when such
fields are updated in triggers (actually we simply assume that
we always update fields used in key if we have before update
trigger).

The fix simply extends this check which is done with help of
check_if_key_used()/QUICK_SELECT_I::check_if_keys_used()
routine/method in such way that it also detects cases when
field used in key is updated in trigger. We do this by
changing check_if_key_used() to take field bitmap instead
field list as argument and passing TABLE::write_set
to it (we also have to add info about fields used in
triggers to this bitmap a bit earlier).
As nice side-effect we have more precise and thus more optimal
perfomance-wise check for the MULTI-UPDATE.
Also check_if_key_used() routine and similar method were renamed
to is_key_used()/is_keys_used() in order to better reflect that
it is simple boolean predicate.
Finally, partition_key_modified() routine now also takes field
bitmap instead of field list as argument.

1 files changed, 15 insertions, 21 deletions

diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 1b97acbcbfe..6805f7cab54 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -25,7 +25,7 @@
 #include "sp_head.h"
 #include "sql_trigger.h"
 
-static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields);
+static bool safe_update_on_fly(JOIN_TAB *join_tab);
 
 /* Return 0 if row hasn't changed */
 
@@ -271,13 +271,16 @@ int mysql_update(THD *thd,
     }
   }
   init_ftfuncs(thd, select_lex, 1);
+
+  table->mark_columns_needed_for_update();
+
   /* Check if we are modifying a key that we are used to search with */
   
   if (select && select->quick)
   {
     used_index= select->quick->index;
     used_key_is_modified= (!select->quick->unique_key_range() &&
-                          select->quick->check_if_keys_used(&fields));
+                          select->quick->is_keys_used(table->write_set));
   }
   else
   {
@@ -285,12 +288,13 @@ int mysql_update(THD *thd,
     if (used_index == MAX_KEY)                  // no index for sort order
       used_index= table->file->key_used_on_scan;
     if (used_index != MAX_KEY)
-      used_key_is_modified= check_if_key_used(table, used_index, fields);
+      used_key_is_modified= is_key_used(table, used_index, table->write_set);
   }
 
+
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   if (used_key_is_modified || order ||
-      partition_key_modified(table, fields))
+      partition_key_modified(table, table->write_set))
 #else
   if (used_key_is_modified || order)
 #endif
@@ -449,8 +453,6 @@ int mysql_update(THD *thd,
                                 MODE_STRICT_ALL_TABLES)));
   will_batch= !table->file->start_bulk_update();
 
-  table->mark_columns_needed_for_update();
-
   /*
     We can use compare_record() to optimize away updates if
     the table handler is returning all columns OR if
@@ -1216,7 +1218,7 @@ multi_update::initialize_tables(JOIN *join)
     table->mark_columns_needed_for_update();
     if (table == main_table)			// First table in join
     {
-      if (safe_update_on_fly(join->join_tab, &temp_fields))
+      if (safe_update_on_fly(join->join_tab))
       {
 	table_to_update= main_table;		// Update table on the fly
 	continue;
@@ -1274,7 +1276,6 @@ multi_update::initialize_tables(JOIN *join)
   SYNOPSIS
     safe_update_on_fly
     join_tab		How table is used in join
-    fields		Fields that are updated
 
   NOTES
     We can update the first table in join on the fly if we know that
@@ -1287,9 +1288,8 @@ multi_update::initialize_tables(JOIN *join)
     - We are doing a range scan and we don't update the scan key or
       the primary key for a clustered table handler.
 
-    When checking for above cases we also should take into account that
-    BEFORE UPDATE trigger potentially may change value of any field in row
-    being updated.
+    This function gets information about fields to be updated from
+    the TABLE::write_set bitmap.
 
   WARNING
     This code is a bit dependent of how make_join_readinfo() works.
@@ -1299,7 +1299,7 @@ multi_update::initialize_tables(JOIN *join)
     1		Safe to update
 */
 
-static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields)
+static bool safe_update_on_fly(JOIN_TAB *join_tab)
 {
   TABLE *table= join_tab->table;
   switch (join_tab->type) {
@@ -1309,21 +1309,15 @@ static bool safe_update_on_fly(JOIN_TAB *join_tab, List<Item> *fields)
     return TRUE;				// At most one matching row
   case JT_REF:
   case JT_REF_OR_NULL:
-    return !check_if_key_used(table, join_tab->ref.key, *fields) &&
-           !(table->triggers &&
-             table->triggers->has_before_update_triggers());
+    return !is_key_used(table, join_tab->ref.key, table->write_set);
   case JT_ALL:
     /* If range search on index */
     if (join_tab->quick)
-      return !join_tab->quick->check_if_keys_used(fields) &&
-             !(table->triggers &&
-               table->triggers->has_before_update_triggers());
+      return !join_tab->quick->is_keys_used(table->write_set);
     /* If scanning in clustered key */
     if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
 	table->s->primary_key < MAX_KEY)
-      return !check_if_key_used(table, table->s->primary_key, *fields) &&
-             !(table->triggers &&
-               table->triggers->has_before_update_triggers());
+      return !is_key_used(table, table->s->primary_key, table->write_set);
     return TRUE;
   default:
     break;					// Avoid compler warning