diff --git a/sql/item.cc b/sql/item.cc
index e9bbdc7..502b8ae 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -59,6 +59,21 @@ bool cmp_items(Item *a, Item *b)
 }
 
 
+void
+Used_tables_and_const_cache::
+  used_tables_and_const_cache_update_and_join(List<Item> &list)
+{
+  List_iterator_fast<Item> li(list);
+  Item *item;
+  while ((item=li++))
+  {
+    item->update_used_tables();
+    used_tables_and_const_cache_join(item);
+  }
+}
+
+
+
 /*****************************************************************************
 ** Item functions
 *****************************************************************************/
@@ -4730,10 +4745,7 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
         else
         {
           Item::Type ref_type= (*reference)->type();
-          prev_subselect_item->used_tables_cache|=
-            (*reference)->used_tables();
-          prev_subselect_item->const_item_cache&=
-            (*reference)->const_item();
+          prev_subselect_item->used_tables_and_const_cache_join(*reference);
           mark_as_dependent(thd, last_checked_context->select_lex,
                             context->select_lex, this,
                             ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
@@ -4759,8 +4771,7 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
       if (ref != not_found_item)
       {
         DBUG_ASSERT(*ref && (*ref)->fixed);
-        prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
-        prev_subselect_item->const_item_cache&= (*ref)->const_item();
+        prev_subselect_item->used_tables_and_const_cache_join(*ref);
         break;
       }
     }
@@ -6783,8 +6794,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
           if (ref != not_found_item)
           {
             DBUG_ASSERT(*ref && (*ref)->fixed);
-            prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
-            prev_subselect_item->const_item_cache&= (*ref)->const_item();
+            prev_subselect_item->used_tables_and_const_cache_join(*ref);
             break;
           }
           /*
@@ -6828,10 +6838,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
           if (from_field == view_ref_found)
           {
             Item::Type refer_type= (*reference)->type();
-            prev_subselect_item->used_tables_cache|=
-              (*reference)->used_tables();
-            prev_subselect_item->const_item_cache&=
-              (*reference)->const_item();
+            prev_subselect_item->used_tables_and_const_cache_join(*reference);
             DBUG_ASSERT((*reference)->type() == REF_ITEM);
             mark_as_dependent(thd, last_checked_context->select_lex,
                               context->select_lex, this,
diff --git a/sql/item.h b/sql/item.h
index 5820f11..7e7c573b0 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -3328,6 +3328,63 @@ class Item_args
 };
 
 
+class Used_tables_and_const_cache
+{
+public:
+  /*
+    In some cases used_tables_cache is not what used_tables() return
+    so the method should be used where one need used tables bit map
+    (even internally in Item_func_* code).
+  */
+  table_map used_tables_cache;
+  bool const_item_cache;
+
+  Used_tables_and_const_cache()
+   :used_tables_cache(0),
+    const_item_cache(true)
+  { }
+  Used_tables_and_const_cache(const Used_tables_and_const_cache *other)
+   :used_tables_cache(other->used_tables_cache),
+    const_item_cache(other->const_item_cache)
+  { }
+  void used_tables_and_const_cache_init()
+  {
+    used_tables_cache= 0;
+    const_item_cache= true;
+  }
+  void used_tables_and_const_cache_copy(const Used_tables_and_const_cache *c)
+  {
+    *this= *c;
+  }
+  void used_tables_and_const_cache_join(const Item *item)
+  {
+    used_tables_cache|= item->used_tables();
+    const_item_cache&= item->const_item();
+  }
+  /*
+    Call update_used_tables() for all items in the array "args"
+    and join with the current cache.
+    "this" must be initialized with a constructor or
+    re-initialized with used_tables_and_const_cache_init().
+  */
+  void used_tables_and_const_cache_update_and_join(uint argc, Item **argv)
+  {
+    for (uint i=0 ; i < argc ; i++)
+    {
+      argv[i]->update_used_tables();
+      used_tables_and_const_cache_join(argv[i]);
+    }
+  }
+  /*
+    Call update_used_tables() for all items in the list
+    and join with the current cache.
+    "this" must be initialized with a constructor or
+    re-initialized with used_tables_and_const_cache_init().
+  */
+  void used_tables_and_const_cache_update_and_join(List<Item> &list);
+};
+
+
 /**
   An abstract class representing common features of
   regular functions and aggregate functions.
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 23676d7..eec99d9 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -1520,9 +1520,8 @@ bool Item_in_optimizer::fix_left(THD *thd)
   if (args[1]->fixed)
   {
     /* to avoid overriding is called to update left expression */
-    used_tables_cache|= args[1]->used_tables();
+    used_tables_and_const_cache_join(args[1]);
     with_sum_func= with_sum_func || args[1]->with_sum_func;
-    const_item_cache= const_item_cache && args[1]->const_item();
   }
   DBUG_RETURN(0);
 }
@@ -1551,8 +1550,7 @@ bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
   with_subselect= 1;
   with_sum_func= with_sum_func || args[1]->with_sum_func;
   with_field= with_field || args[1]->with_field;
-  used_tables_cache|= args[1]->used_tables();
-  const_item_cache&= args[1]->const_item();
+  used_tables_and_const_cache_join(args[1]);
   fixed= 1;
   return FALSE;
 }
@@ -2081,11 +2079,10 @@ void Item_func_interval::fix_length_and_dec()
   }
   maybe_null= 0;
   max_length= 2;
-  used_tables_cache|= row->used_tables();
+  used_tables_and_const_cache_join(row);
   not_null_tables_cache= row->not_null_tables();
   with_sum_func= with_sum_func || row->with_sum_func;
   with_field= with_field || row->with_field;
-  const_item_cache&= row->const_item();
 }
 
 
@@ -4302,8 +4299,8 @@ Item_cond::fix_fields(THD *thd, Item **ref)
   List_iterator<Item> li(list);
   Item *item;
   uchar buff[sizeof(char*)];			// Max local vars in function
-  not_null_tables_cache= used_tables_cache= 0;
-  const_item_cache= 1;
+  not_null_tables_cache= 0;
+  used_tables_and_const_cache_init();
 
   /*
     and_table_cache is the value that Item_cond_or() returns for
@@ -4453,8 +4450,7 @@ void Item_cond::fix_after_pullout(st_select_lex *new_parent, Item **ref)
   List_iterator<Item> li(list);
   Item *item;
 
-  used_tables_cache=0;
-  const_item_cache=1;
+  used_tables_and_const_cache_init();
 
   and_tables_cache= ~(table_map) 0; // Here and below we do as fix_fields does
   not_null_tables_cache= 0;
@@ -4464,8 +4460,7 @@ void Item_cond::fix_after_pullout(st_select_lex *new_parent, Item **ref)
     table_map tmp_table_map;
     item->fix_after_pullout(new_parent, li.ref());
     item= *li.ref();
-    used_tables_cache|= item->used_tables();
-    const_item_cache&= item->const_item();
+    used_tables_and_const_cache_join(item);
 
     if (item->const_item())
       and_tables_cache= (table_map) 0;
@@ -4648,22 +4643,6 @@ Item_cond::used_tables() const
 }
 
 
-void Item_cond::update_used_tables()
-{
-  List_iterator_fast<Item> li(list);
-  Item *item;
-
-  used_tables_cache=0;
-  const_item_cache=1;
-  while ((item=li++))
-  {
-    item->update_used_tables();
-    used_tables_cache|= item->used_tables();
-    const_item_cache&= item->const_item();
-  }
-}
-
-
 void Item_cond::print(String *str, enum_query_type query_type)
 {
   str->append('(');
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 2d039d5..bf388ef 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -1763,7 +1763,11 @@ class Item_cond :public Item_bool_func
   enum Type type() const { return COND_ITEM; }
   List<Item>* argument_list() { return &list; }
   table_map used_tables() const;
-  void update_used_tables();
+  void update_used_tables()
+  {
+    used_tables_and_const_cache_init();
+    used_tables_and_const_cache_update_and_join(list);
+  }
   virtual void print(String *str, enum_query_type query_type);
   void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
   friend int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 50bc85f..4007d6b 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -178,8 +178,44 @@ Item_func::fix_fields(THD *thd, Item **ref)
   Item **arg,**arg_end;
   uchar buff[STACK_BUFF_ALLOC];			// Max argument in function
 
-  used_tables_cache= not_null_tables_cache= 0;
-  const_item_cache=1;
+  // used_tables_and_const_cache_init(); // QQ: is it needed, for safety?
+  /*
+    Comments about the commented used_tables_and_const_cache_init() above:
+    
+    The "Used_tables_and_const_cache" part of Item_func is initialized in
+    Item_func::Item_func(). So normally, the above initialization is not needed.
+    And it does pass all tests.
+    
+    However, in rare cases "fixed" can be set back to "false" after
+    fix_fields() was called for the very first time.
+    
+    These functions reset "fixed" to "false":
+    -  unfix_fields()
+    -  st_select_lex_unit::reinit_exec_mechanism()
+    -  make_in_exists_conversion()
+    -  convert_join_subqueries_to_semijoins()
+    
+    Possible solutions:
+    - Keep the above initialization commented (or just remove it) and hope
+      that everything will work fine :)
+      Adding some DBUG_ASSERTs at least would nice.
+      
+    - Uncomment initialization used_tables_and_const_cache_init()
+      (this will give better reliability with slighly worse performance)
+      This is what was before this patch.
+      
+    - Make Item::fixed private (or at least protected), add a new method:
+      
+      void Item::unfix()
+      {
+        fixed= 0;
+        used_tables_and_const_cache_init();
+      }
+      and use it instead of direct assignment "item->fixed= false;".
+    
+  */
+  
+  not_null_tables_cache= 0;
 
   /*
     Use stack limit of STACK_MIN_SIZE * 2 since
@@ -221,8 +257,7 @@ Item_func::fix_fields(THD *thd, Item **ref)
 
       with_sum_func= with_sum_func || item->with_sum_func;
       with_field= with_field || item->with_field;
-      used_tables_cache|=     item->used_tables();
-      const_item_cache&=      item->const_item();
+      used_tables_and_const_cache_join(item);
       with_subselect|=        item->has_subquery();
     }
   }
@@ -269,8 +304,8 @@ void Item_func::fix_after_pullout(st_select_lex *new_parent, Item **ref)
 {
   Item **arg,**arg_end;
 
-  used_tables_cache= not_null_tables_cache= 0;
-  const_item_cache=1;
+  used_tables_and_const_cache_init();
+  not_null_tables_cache= 0;
 
   if (arg_count)
   {
@@ -279,9 +314,8 @@ void Item_func::fix_after_pullout(st_select_lex *new_parent, Item **ref)
       (*arg)->fix_after_pullout(new_parent, arg);
       Item *item= *arg;
 
-      used_tables_cache|=     item->used_tables();
+      used_tables_and_const_cache_join(item);
       not_null_tables_cache|= item->not_null_tables();
-      const_item_cache&=      item->const_item();
     }
   }
 }
@@ -436,19 +470,6 @@ void Item_func::split_sum_func(THD *thd, Item **ref_pointer_array,
 }
 
 
-void Item_func::update_used_tables()
-{
-  used_tables_cache=0;
-  const_item_cache=1;
-  for (uint i=0 ; i < arg_count ; i++)
-  {
-    args[i]->update_used_tables();
-    used_tables_cache|=args[i]->used_tables();
-    const_item_cache&=args[i]->const_item();
-  }
-}
-
-
 table_map Item_func::used_tables() const
 {
   return used_tables_cache;
@@ -3503,8 +3524,7 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
 
   /* Fix all arguments */
   func->maybe_null=0;
-  used_tables_cache=0;
-  const_item_cache=1;
+  used_tables_and_const_cache_init();
 
   if ((f_args.arg_count=arg_count))
   {
@@ -3546,8 +3566,7 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
       func->with_sum_func= func->with_sum_func || item->with_sum_func;
       func->with_field= func->with_field || item->with_field;
       func->with_subselect|= item->with_subselect;
-      used_tables_cache|=item->used_tables();
-      const_item_cache&=item->const_item();
+      used_tables_and_const_cache_join(item);
       f_args.arg_type[i]=item->result_type();
     }
     //TODO: why all following memory is not allocated with 1 call of sql_alloc?
diff --git a/sql/item_func.h b/sql/item_func.h
index 653c08e..c78c585 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -31,7 +31,7 @@ extern "C"				/* Bug in BSDI include file */
 #endif
 
 
-class Item_func :public Item_func_or_sum
+class Item_func :public Item_func_or_sum, public Used_tables_and_const_cache
 {
   void sync_with_sum_func_and_with_field(List<Item> &list);
 protected:
@@ -42,15 +42,8 @@ class Item_func :public Item_func_or_sum
   uint allowed_arg_cols;
   String *val_str_from_val_str_ascii(String *str, String *str2);
 public:
-  /*
-    In some cases used_tables_cache is not what used_tables() return
-    so the method should be used where one need used tables bit map 
-    (even internally in Item_func_* code).
-  */
-  table_map used_tables_cache;
   table_map not_null_tables_cache;
 
-  bool const_item_cache;
   enum Functype { UNKNOWN_FUNC,EQ_FUNC,EQUAL_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,
 		  GE_FUNC,GT_FUNC,FT_FUNC,
 		  LIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
@@ -118,11 +111,9 @@ class Item_func :public Item_func_or_sum
   }
   // Constructor used for Item_cond_and/or (see Item comment)
   Item_func(THD *thd, Item_func *item)
-   :Item_func_or_sum(thd, item),
+   :Item_func_or_sum(thd, item), Used_tables_and_const_cache(item),
     allowed_arg_cols(item->allowed_arg_cols),
-    used_tables_cache(item->used_tables_cache),
-    not_null_tables_cache(item->not_null_tables_cache),
-    const_item_cache(item->const_item_cache)
+    not_null_tables_cache(item->not_null_tables_cache)
   {
   }
   bool fix_fields(THD *, Item **ref);
@@ -130,7 +121,11 @@ class Item_func :public Item_func_or_sum
   void quick_fix_field();
   table_map used_tables() const;
   table_map not_null_tables() const;
-  void update_used_tables();
+  void update_used_tables()
+  {
+    used_tables_and_const_cache_init();
+    used_tables_and_const_cache_update_and_join(arg_count, args);
+  }
   bool eq(const Item *item, bool binary_cmp) const;
   virtual optimize_type select_optimize() const { return OPTIMIZE_NONE; }
   virtual bool have_rev_func() const { return 0; }
@@ -1367,8 +1362,7 @@ class Item_udf_func :public Item_func
   {
     DBUG_ASSERT(fixed == 0);
     bool res= udf.fix_fields(thd, this, arg_count, args);
-    used_tables_cache= udf.used_tables_cache;
-    const_item_cache= udf.const_item_cache;
+    used_tables_and_const_cache_copy(udf.used_tables_and_const_cache());
     fixed= 1;
     return res;
   }
diff --git a/sql/item_row.cc b/sql/item_row.cc
index 3548a6b..1fc2000 100644
--- a/sql/item_row.cc
+++ b/sql/item_row.cc
@@ -39,8 +39,7 @@
 */
 
 Item_row::Item_row(List<Item> &arg):
-  Item(), used_tables_cache(0), not_null_tables_cache(0),
-  const_item_cache(1), with_null(0)
+  Item(), Used_tables_and_const_cache(), not_null_tables_cache(0), with_null(0)
 {
 
   //TODO: think placing 2-3 component items in item (as it done for function)
@@ -126,8 +125,7 @@ void Item_row::cleanup()
 
   Item::cleanup();
   /* Reset to the original values */
-  used_tables_cache= 0;
-  const_item_cache= 1;
+  used_tables_and_const_cache_init();
   with_null= 0;
 
   DBUG_VOID_RETURN;
@@ -143,29 +141,14 @@ void Item_row::split_sum_func(THD *thd, Item **ref_pointer_array,
 }
 
 
-void Item_row::update_used_tables()
-{
-  used_tables_cache= 0;
-  const_item_cache= 1;
-  for (uint i= 0; i < arg_count; i++)
-  {
-    items[i]->update_used_tables();
-    used_tables_cache|= items[i]->used_tables();
-    const_item_cache&= items[i]->const_item();
-  }
-}
-
-
 void Item_row::fix_after_pullout(st_select_lex *new_parent, Item **ref)
 {
-  used_tables_cache= 0;
-  const_item_cache= 1;
+  used_tables_and_const_cache_init();
   not_null_tables_cache= 0;
   for (uint i= 0; i < arg_count; i++)
   {
     items[i]->fix_after_pullout(new_parent, &items[i]);
-    used_tables_cache|= items[i]->used_tables();
-    const_item_cache&= items[i]->const_item();
+    used_tables_and_const_cache_join(items[i]);
     not_null_tables_cache|= items[i]->not_null_tables();
   }
 }
diff --git a/sql/item_row.h b/sql/item_row.h
index aa56068..31efc01 100644
--- a/sql/item_row.h
+++ b/sql/item_row.h
@@ -17,22 +17,20 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
 
-class Item_row: public Item
+class Item_row: public Item, private Used_tables_and_const_cache
 {
   Item **items;
-  table_map used_tables_cache, not_null_tables_cache;
+  table_map not_null_tables_cache;
   uint arg_count;
-  bool const_item_cache;
   bool with_null;
 public:
   Item_row(List<Item> &);
   Item_row(Item_row *item):
     Item(),
+    Used_tables_and_const_cache(item),
     items(item->items),
-    used_tables_cache(item->used_tables_cache),
     not_null_tables_cache(0),
     arg_count(item->arg_count),
-    const_item_cache(item->const_item_cache),
     with_null(0)
   {}
 
@@ -71,7 +69,11 @@ class Item_row: public Item
   bool const_item() const { return const_item_cache; };
   enum Item_result result_type() const { return ROW_RESULT; }
   Item_result cmp_type() const { return ROW_RESULT; }
-  void update_used_tables();
+  void update_used_tables()
+  {
+    used_tables_and_const_cache_init();
+    used_tables_and_const_cache_update_and_join(arg_count, items);
+  }
   table_map not_null_tables() const { return not_null_tables_cache; }
   virtual void print(String *str, enum_query_type query_type);
 
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 32d6362..496cb11 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -49,8 +49,9 @@ const char *exists_outer_expr_name= "<exists outer expr>";
 int check_and_do_in_subquery_rewrites(JOIN *join);
 
 Item_subselect::Item_subselect():
-  Item_result_field(), value_assigned(0), own_engine(0), thd(0), old_engine(0), 
-  used_tables_cache(0), have_to_be_excluded(0), const_item_cache(1),
+  Item_result_field(), Used_tables_and_const_cache(),
+  value_assigned(0), own_engine(0), thd(0), old_engine(0), 
+  have_to_be_excluded(0),
   inside_first_fix_fields(0), done_first_fix_fields(FALSE), 
   expr_cache(0), forced_const(FALSE), substitution(0), engine(0), eliminated(FALSE),
   changed(0), is_correlated(FALSE)
diff --git a/sql/item_subselect.h b/sql/item_subselect.h
index add2e0b..47a143e 100644
--- a/sql/item_subselect.h
+++ b/sql/item_subselect.h
@@ -44,7 +44,8 @@ class Cached_item;
 
 /* base class for subselects */
 
-class Item_subselect :public Item_result_field
+class Item_subselect :public Item_result_field,
+                      protected Used_tables_and_const_cache
 {
   bool value_assigned;   /* value already assigned to subselect */
   bool own_engine;  /* the engine was not taken from other Item_subselect */
@@ -53,16 +54,12 @@ class Item_subselect :public Item_result_field
   THD *thd;
   /* old engine if engine was changed */
   subselect_engine *old_engine;
-  /* cache of used external tables */
-  table_map used_tables_cache;
   /* allowed number of columns (1 for single value subqueries) */
   uint max_columns;
   /* where subquery is placed */
   enum_parsing_place parsing_place;
   /* work with 'substitution' */
   bool have_to_be_excluded;
-  /* cache of constant state */
-  bool const_item_cache;
   
   bool inside_first_fix_fields;
   bool done_first_fix_fields;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 20a829e..e8cce56 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -12770,7 +12770,9 @@ static bool check_equality(THD *thd, Item *item, COND_EQUAL *cond_equal,
   @param inherited  path to all inherited multiple equality items
 
   @return
-    pointer to the transformed condition
+    pointer to the transformed condition,
+    whose Used_tables_and_const_cache is up to date,
+    so no additional update_used_tables() is needed on the result.
 */
 
 static COND *build_equal_items_for_cond(THD *thd, COND *cond,
@@ -12784,9 +12786,9 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
   if (cond->type() == Item::COND_ITEM)
   {
     List<Item> eq_list;
-    bool and_level= ((Item_cond*) cond)->functype() ==
-      Item_func::COND_AND_FUNC;
-    List<Item> *args= ((Item_cond*) cond)->argument_list();
+    Item_cond *cond_item= (Item_cond*) cond;
+    bool and_level= cond_item->functype() == Item_func::COND_AND_FUNC;
+    List<Item> *args= cond_item->argument_list();
     
     List_iterator<Item> li(*args);
     Item *item;
@@ -12837,8 +12839,10 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
     /*
        Make replacement of equality predicates for lower levels
        of the condition expression.
+       Update used_tables_cache and const_item_cache on the way.
     */
     li.rewind();
+    cond_item->used_tables_and_const_cache_init();
     while ((item= li++))
     { 
       Item *new_item;
@@ -12853,12 +12857,27 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
         */
         li.replace(new_item);
       }
+      cond_item->used_tables_and_const_cache_join(new_item);
     }
     if (and_level)
     {
       args->append(&eq_list);
       args->append((List<Item> *)&cond_equal.current_level);
+      /*
+        QQ: perhaps we could do this:
+        
+        cond_item->used_tables_and_const_cache_update_and_join(eq_list);
+        cond_item->used_tables_and_const_cache_update_and_join(
+                                    *(List<Item> *) &cond_equal.current_level);
+
+        instead of the cond_item->update_used_tables() call below.
+        But initializing 2 iterators will probably be even slower than
+        redundant iterations over the topmost elements in "args",
+        which were already processed in the "while" loop above.
+      */
+      cond_item->update_used_tables();
     }
+    return cond_item;
   }
   else if (cond->type() == Item::FUNC_ITEM ||
            cond->real_item()->type() == Item::FIELD_ITEM)
@@ -12890,8 +12909,9 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
           item_equal->upper_levels= inherited;
           return item_equal;
 	}
-
-        return eq_list.pop();
+        Item *res= eq_list.pop();
+        res->update_used_tables();
+        return res;
       }
       else
       {
@@ -12913,7 +12933,7 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
         and_cond->cond_equal.copy(cond_equal);
         cond_equal.current_level= and_cond->cond_equal.current_level;
         args->append((List<Item> *)&cond_equal.current_level);
-        
+        and_cond->update_used_tables();
         return and_cond;
       }
     }
@@ -12928,8 +12948,8 @@ static COND *build_equal_items_for_cond(THD *thd, COND *cond,
                         &is_subst_valid, 
                         &Item::equal_fields_propagator,
                         (uchar *) inherited);
-    cond->update_used_tables();
   }
+  cond->update_used_tables();
   return cond;
 }
 
@@ -13016,7 +13036,6 @@ static COND *build_equal_items(JOIN *join, COND *cond,
   if (cond) 
   {
     cond= build_equal_items_for_cond(thd, cond, inherited, link_equal_fields);
-    cond->update_used_tables();
     if (cond->type() == Item::COND_ITEM &&
         ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
       cond_equal= &((Item_cond_and*) cond)->cond_equal;
diff --git a/sql/sql_udf.h b/sql/sql_udf.h
index 076c544..161bd7a 100644
--- a/sql/sql_udf.h
+++ b/sql/sql_udf.h
@@ -52,7 +52,7 @@ typedef struct st_udf_func
 
 class Item_result_field;
 
-class udf_handler :public Sql_alloc
+class udf_handler :public Sql_alloc, private Used_tables_and_const_cache
 {
  protected:
   udf_func *u_d;
@@ -65,8 +65,6 @@ class udf_handler :public Sql_alloc
   Item **args;
 
  public:
-  table_map used_tables_cache;
-  bool const_item_cache;
   bool not_original;
   udf_handler(udf_func *udf_arg) :u_d(udf_arg), buffers(0), error(0),
     is_null(0), initialized(0), not_original(0)
@@ -79,6 +77,10 @@ class udf_handler :public Sql_alloc
   bool fix_fields(THD *thd, Item_func_or_sum *item,
 		  uint arg_count, Item **args);
   void cleanup();
+  const Used_tables_and_const_cache *used_tables_and_const_cache() const
+  {
+    return this;
+  }
   double val(my_bool *null_value)
   {
     is_null= 0;
