1 files changed, 236 insertions, 14 deletions

diff --git a/sql/item.cc b/sql/item.cc
index 56af69be427..b7a921f53cd 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -7635,6 +7635,229 @@ Item *Item_field::update_value_transformer(THD *thd, uchar *select_arg)
 }
 
 
+/**
+  @brief
+    Prepare AND/OR formula for extraction of a pushable condition
+
+  @param checker  the checker callback function to be applied to the nodes
+                  of the tree of the object
+  @param arg      parameter to be passed to the checker
+
+  @details
+    This method recursively traverses this AND/OR condition and for each
+    subformula of the condition it checks whether it can be usable for the
+    extraction of a pushable condition. The criteria of pushability of
+    a subformula is checked by the callback function 'checker' with one
+    parameter arg. The subformulas that are not usable are marked with
+    the flag NO_EXTRACTION_FL.
+  @note
+    This method is called before any call of build_pushable_cond.
+    The flag NO_EXTRACTION_FL set in a subformula allows to avoid building
+    clones for the subformulas that are not used in the pushable condition.
+  @note
+    This method is called for pushdown conditions into materialized
+    derived tables/views optimization.
+    Item::pushable_cond_checker_for_derived() is passed as the actual callback
+    function.
+    Also it is called for pushdown conditions in materialized IN subqueries.
+    Item::pushable_cond_checker_for_subquery is passed as the actual
+    callback function.
+*/
+
+void Item::check_pushable_cond(Pushdown_checker checker, uchar *arg)
+{
+  clear_extraction_flag();
+  if (type() == Item::COND_ITEM)
+  {
+    bool and_cond= ((Item_cond*) this)->functype() == Item_func::COND_AND_FUNC;
+    List_iterator<Item> li(*((Item_cond*) this)->argument_list());
+    uint count= 0;
+    Item *item;
+    while ((item=li++))
+    {
+      item->check_pushable_cond(checker, arg);
+      if (item->get_extraction_flag() !=  NO_EXTRACTION_FL)
+        count++;
+      else if (!and_cond)
+        break;
+    }
+    if ((and_cond && count == 0) || item)
+    {
+      set_extraction_flag(NO_EXTRACTION_FL);
+      if (and_cond)
+        li.rewind();
+      while ((item= li++))
+        item->clear_extraction_flag();
+    }
+  }
+  else if (!((this->*checker) (arg)))
+    set_extraction_flag(NO_EXTRACTION_FL);
+}
+
+
+/**
+  @brief
+    Build condition extractable from this condition for pushdown
+
+  @param thd      the thread handle
+  @param checker  the checker callback function to be applied to the
+                  equal items of multiple equality items
+  @param arg      parameter to be passed to the checker
+
+  @details
+    This method finds out what condition that can be pushed down can be
+    extracted from this condition. If such condition C exists the
+    method builds the item for it. The method uses the flag NO_EXTRACTION_FL
+    set by the preliminary call of the method check_pushable_cond() to figure
+    out whether a subformula is pushable or not.
+    In the case when this item is a multiple equality a checker method is
+    called to find the equal fields to build a new equality that can be
+    pushed down.
+  @note
+    The built condition C is always implied by the condition cond
+    (cond => C). The method tries to build the most restrictive such
+    condition (i.e. for any other condition C' such that cond => C'
+    we have C => C').
+  @note
+    The build item is not ready for usage: substitution for the field items
+    has to be done and it has to be re-fixed.
+  @note
+    This method is called for pushdown conditions into materialized
+    derived tables/views optimization.
+    Item::pushable_equality_checker_for_derived() is passed as the actual
+    callback function.
+    Also it is called for pushdown conditions into materialized IN subqueries.
+    Item::pushable_equality_checker_for_subquery() is passed as the actual
+    callback function.
+
+ @retval
+    the built condition pushable into if such a condition exists
+    NULL if there is no such a condition
+*/
+
+Item *Item::build_pushable_cond(THD *thd,
+                                Pushdown_checker checker,
+                                uchar *arg)
+{
+  bool is_multiple_equality= type() == Item::FUNC_ITEM &&
+  ((Item_func*) this)->functype() == Item_func::MULT_EQUAL_FUNC;
+
+  if (get_extraction_flag() == NO_EXTRACTION_FL)
+    return 0;
+
+  if (type() == Item::COND_ITEM)
+  {
+    bool cond_and= false;
+    Item_cond *new_cond;
+    if (((Item_cond*) this)->functype() == Item_func::COND_AND_FUNC)
+    {
+      cond_and= true;
+      new_cond= new (thd->mem_root) Item_cond_and(thd);
+    }
+    else
+      new_cond= new (thd->mem_root) Item_cond_or(thd);
+    if (!new_cond)
+      return 0;
+    List_iterator<Item> li(*((Item_cond*) this)->argument_list());
+    Item *item;
+    bool is_fix_needed= false;
+    while ((item=li++))
+    {
+      if (item->get_extraction_flag() == NO_EXTRACTION_FL)
+      {
+        if (!cond_and)
+          return 0;
+        continue;
+      }
+      Item *fix= item->build_pushable_cond(thd, checker, arg);
+      if (!fix && !cond_and)
+        return 0;
+      if (!fix)
+        continue;
+
+      if (fix->type() == Item::COND_ITEM &&
+          ((Item_cond*) fix)->functype() == Item_func::COND_AND_FUNC)
+        is_fix_needed= true;
+
+      if (new_cond->argument_list()->push_back(fix, thd->mem_root))
+        return 0;
+    }
+    if (is_fix_needed)
+      new_cond->fix_fields(thd, 0);
+
+    switch (new_cond->argument_list()->elements)
+    {
+    case 0:
+      return 0;
+    case 1:
+      return new_cond->argument_list()->head();
+    default:
+      return new_cond;
+    }
+  }
+  else if (is_multiple_equality)
+  {
+    Item *new_cond= NULL;
+    int i= 0;
+    Item_equal *item_equal= (Item_equal *) this;
+    Item *left_item = item_equal->get_const();
+    Item_equal_fields_iterator it(*item_equal);
+    Item *item;
+    Item *right_item;
+    if (!left_item)
+    {
+      while ((item=it++))
+      {
+        left_item= ((item->*checker) (arg)) ? item : NULL;
+        if (left_item)
+          break;
+      }
+    }
+    if (!left_item)
+      return 0;
+    while ((item=it++))
+    {
+      right_item= ((item->*checker) (arg)) ? item : NULL;
+      if (!right_item)
+        continue;
+      Item_func_eq *eq= 0;
+      Item *left_item_clone= left_item->build_clone(thd);
+      Item *right_item_clone= item->build_clone(thd);
+      if (left_item_clone && right_item_clone)
+      {
+        left_item_clone->set_item_equal(NULL);
+        right_item_clone->set_item_equal(NULL);
+        eq= new (thd->mem_root) Item_func_eq(thd, right_item_clone,
+                                             left_item_clone);
+      }
+      if (eq)
+      {
+        i++;
+        switch (i)
+        {
+        case 1:
+          new_cond= eq;
+          break;
+        case 2:
+          new_cond= new (thd->mem_root) Item_cond_and(thd, new_cond, eq);
+          break;
+        default:
+          ((Item_cond_and*)new_cond)->argument_list()->push_back(eq,
+                                                                thd->mem_root);
+          break;
+        }
+      }
+    }
+    if (new_cond && new_cond->fix_fields(thd, &new_cond))
+      return 0;
+    return new_cond;
+  }
+  else if (get_extraction_flag() != NO_EXTRACTION_FL)
+    return build_clone(thd);
+  return 0;
+}
+
+
 static
 Item *get_field_item_for_having(THD *thd, Item *item, st_select_lex *sel)
 {
@@ -7754,18 +7977,18 @@ Item *Item_direct_view_ref::derived_field_transformer_for_where(THD *thd,
 }
 
 static
-Grouping_tmp_field *find_matching_grouping_field(Item *item,
-                                                 st_select_lex *sel)
+Field_pair *find_matching_grouping_field(Item *item,
+					 st_select_lex *sel)
 {
   DBUG_ASSERT(item->type() == Item::FIELD_ITEM ||
               (item->type() == Item::REF_ITEM &&
                ((Item_ref *) item)->ref_type() == Item_ref::VIEW_REF)); 
-  List_iterator<Grouping_tmp_field> li(sel->grouping_tmp_fields);
-  Grouping_tmp_field *gr_field;
+  List_iterator<Field_pair> li(sel->grouping_tmp_fields);
+  Field_pair *gr_field;
   Item_field *field_item= (Item_field *) (item->real_item());
   while ((gr_field= li++))
   {
-    if (field_item->field == gr_field->tmp_field)
+    if (field_item->field == gr_field->field)
       return gr_field;
   }
   Item_equal *item_equal= item->get_item_equal();
@@ -7779,7 +8002,7 @@ Grouping_tmp_field *find_matching_grouping_field(Item *item,
       li.rewind();
       while ((gr_field= li++))
       {
-        if (field_item->field == gr_field->tmp_field)
+        if (field_item->field == gr_field->field)
 	  return gr_field;
       }
     }
@@ -7788,26 +8011,25 @@ Grouping_tmp_field *find_matching_grouping_field(Item *item,
 }
     
 
-Item *Item_field::derived_grouping_field_transformer_for_where(THD *thd,
-                                                               uchar *arg)
+Item *Item_field::grouping_field_transformer_for_where(THD *thd, uchar *arg)
 {
   st_select_lex *sel= (st_select_lex *)arg;
-  Grouping_tmp_field *gr_field= find_matching_grouping_field(this, sel);
+  Field_pair *gr_field= find_matching_grouping_field(this, sel);
   if (gr_field)
-    return gr_field->producing_item->build_clone(thd);
+    return gr_field->corresponding_item->build_clone(thd);
   return this;
 }
 
 
 Item *
-Item_direct_view_ref::derived_grouping_field_transformer_for_where(THD *thd,
-                                                                   uchar *arg)
+Item_direct_view_ref::grouping_field_transformer_for_where(THD *thd,
+                                                           uchar *arg)
 {
   if (!item_equal)
     return this;
   st_select_lex *sel= (st_select_lex *)arg;
-  Grouping_tmp_field *gr_field= find_matching_grouping_field(this, sel);
-  return gr_field->producing_item->build_clone(thd);
+  Field_pair *gr_field= find_matching_grouping_field(this, sel);
+  return gr_field->corresponding_item->build_clone(thd);
 }
 
 void Item_field::print(String *str, enum_query_type query_type)