~drizzle-trunk/drizzle/development

  @defgroup Query_Optimizer  Query Optimizer

  @{

*/

 

#include <string>

#include <iostream>

#include <algorithm>

#include <vector>

 

 

using namespace std;

 

  bool res= false;

  bool direct_ref= false;

 

  while ((ref= ref_it++))

  {

    Item *item= ref->outer_ref;

    Item **item_ref= ref->ref;

    Item_ref *new_ref;

    /*

      In this case instead of adding new field item we could use an

      existing one. The change will lead to less operations for copying fields,

      smaller temporary tables and less data passed through filesort.

    goto err; // 1

  }

 

  {

    join->conds_history= join->conds;

    join->having_history= (join->having?join->having:join->tmp_having);

 

  join->exec();

 

  {

    select_lex->where= join->conds_history;

    select_lex->having= join->having_history;

    substitutions.

  */

  sz= sizeof(optimizer::KeyField) *

    return true;

  and_level= 0;

  field= end= key_fields;

 

  /* Process ON conditions for the nested joins */

  {

    TableList *table;

    while ((table= li++))

    {

void add_group_and_distinct_keys(Join *join, JoinTable *join_tab)

{

  List<Item_field> indexed_fields;

  Order      *cur_group;

  Item_field *cur_item;

  key_map possible_keys(0);

  else if (join->select_distinct)

  { /* Collect all query fields referenced in the SELECT clause. */

    List<Item> &select_items= join->fields_list;

    Item *item;

    while ((item= select_items_it++))

      item->walk(&Item::collect_item_field_processor, 0,

  j->ref.key_length=length;

  j->ref.key=(int) key;

  if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||

               (keyparts+1)))) ||

  {

    return(true);

  }

*/

void JoinTable::cleanup()

{

  if (cache.buff)

  {

    size_t size= cache.end - cache.buff;

  bool in_upper_level= false;

  while (cond_equal)

  {

    while ((item= li++))

    {

      if (item->contains(field))

        /* Merge two multiple equalities forming a new one */

        left_item_equal->merge(right_item_equal);

        /* Remove the merged multiple equality from the list */

        while ((li++) != right_item_equal) {};

        li.remove();

      }

                                       (Item_row *) right_item,

                                       cond_equal, eq_list);

      if (!is_converted)

    }

    else

    {

      is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);

    }

 

    if (!is_converted)

    if (left_item->type() == Item::ROW_ITEM &&

        right_item->type() == Item::ROW_ITEM)

    {

      return check_row_equality(session,

                                (Item_row *) left_item,

                                (Item_row *) right_item,

    just an argument of a comparison predicate.

    The function also determines the maximum number of members in

    equality lists of each Item_cond_and object assigning it to

 

  @note

    Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of

      Item_func::COND_AND_FUNC;

    List<Item> *args= ((Item_cond*) cond)->argument_list();

 

    Item *item;

 

    if (and_level)

          li.remove();

      }

 

      while ((item_equal= it++))

      {

        item_equal->fix_length_and_dec();

        item_equal->update_used_tables();

                      item_equal->members());

      }

 

       Make replacement of equality predicates for lower levels

       of the condition expression.

    */

    while ((item= li++))

    {

      Item *new_item;

        }

        else

          item_equal= (Item_equal *) eq_list.pop();

                      item_equal->members());

        return item_equal;

      }

        Item_cond_and *and_cond= new Item_cond_and(eq_list);

        and_cond->quick_fix_field();

        List<Item> *args= and_cond->argument_list();

        while ((item_equal= it++))

        {

          item_equal->fix_length_and_dec();

          item_equal->update_used_tables();

                        item_equal->members());

        }

        and_cond->cond_equal= cond_equal;

  if (join_list)

  {

    TableList *table;

 

    while ((table= li++))

    {

      cond_equal= &((Item_cond_and *) cond)->cond_equal;

      cond_list->disjoin((List<Item> *) &cond_equal->current_level);

 

      while ((item_equal= it++))

      {

        item_equal->sort(&compare_fields_by_table_order, table_join_idx);

      }

    }

 

    Item *item;

    while ((item= li++))

    {

 

    if (and_level)

    {

      while ((item_equal= it++))

      {

        cond= eliminate_item_equal(cond, cond_equal->upper_levels, item_equal);

  if (cond->type() == Item::COND_ITEM)

  {

    List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

    Item *item;

    while ((item= li++))

      update_const_equal_items(item, tab);

  if (cond->type() == Item::COND_ITEM)

  {

    bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

    Item *item;

    while ((item=li++))

      change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);

  if (conds->type() == Item::COND_ITEM)

  {

    Item_cond *cnd= (Item_cond*) conds;

    Item *item;

    while ((item= li++))

    {

  if (cond->type() == Item::COND_ITEM)

  {

    bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

    Item *item;

    list<COND_CMP> save;

    while ((item=li++))

  {

    bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);

 

    Item::cond_result tmp_cond_value;

    bool should_fix_fields= false;

 

    {                                           

      /* Argument list contains only one element, so reduce it so a single item, then remove list */

      item= ((Item_cond*) cond)->argument_list()->head();

      return item;

    }

  }

  }

  else if (cond->const_item() && !cond->is_expensive())

  /*

    Excluding all expensive functions is too restritive we should exclude only

    materialized IN subquery predicates because they can't yet be evaluated

    here (they need additional initialization that is done later on).

  {

    bool and_level= (((Item_cond*) cond)->functype()

                     == Item_func::COND_AND_FUNC);

    Item *item;

    while ((item=li++))

    {

    }

  }

 

  if (cmp_buffer_with_ref(tab) ||

      (table->status & (STATUS_GARBAGE | STATUS_NO_PARENT | STATUS_NULL_ROW)))

  {

 

int test_if_quick_select(JoinTable *tab)

{

  return tab->select->test_quick_select(tab->join->session, tab->keys,

                                        (table_map) 0, HA_POS_ERROR, 0, false);

}

        {

          if (!join->first_record)

          {

                  Item *item;

            /* No matching rows for group function */

            join->clear();

      Item_cond_and *new_cond=new Item_cond_and;

      if (!new_cond)

        return (COND*) 0;

      Item *item;

      while ((item=li++))

      {

      Item_cond_or *new_cond=new Item_cond_or;

      if (!new_cond)

        return (COND*) 0;

      Item *item;

      while ((item=li++))

      {

{

  List<Item> *fields= (List<Item> *) data;

  bool part_found= 0;

  Item *item;

 

  while ((item= li++))

    save_quick= select->quick;

    /*

      assume results are not ordered when index merge is used

      by clustered PK values.

    */

 

          tab->type= AM_NEXT;           // Read with index_first(), index_next()

          if (select && select->quick)

          {

          }

          if (table->covering_keys.test(best_key))

          {

          tab->limit= 0;

          return 0; // Reverse sort not supported

        }

      }

    }

    else if (tab->type != AM_NEXT &&

    Item *item;

    Item_field *field;

    int cur_pos_in_select_list= 0;

 

    field= naf_it++;

    while (field && (item=li++))

            if ((*ord->item)->eq((Item*)field, 0))

              goto next_field;

          /*

          */

          my_error(ER_WRONG_FIELD_WITH_GROUP, MYF(0), field->full_name());

          return 1;

                                List<Item> &,

                                bool *all_order_by_fields_used)

{

  Item *item;

  Order *order,*group,**prev;

 

  {

    if (order->in_field_list)

    {

      if (!ord)

        return 0;

      *prev=ord;

      *all_order_by_fields_used= 0;

  }

 

  while ((item=li++))

  {

    if (!item->const_item() && !item->with_sum_func && !item->marker)

*/

void count_field_types(Select_Lex *select_lex, Tmp_Table_Param *param, List<Item> &fields, bool reset_with_sum_func)

{

  Item *field;

 

  param->field_count=param->sum_func_count=param->func_count=

*/

int test_if_item_cache_changed(List<Cached_item> &list)

{

  int idx= -1,i;

  Cached_item *buff;

 

                       List<Item> &all_fields)

{

  Item *pos;

  CopyField *copy= NULL;

  List<Item> extra_funcs;

  uint32_t i, border= all_fields.elements - elements;

 

      !(copy=param->copy_field= new CopyField[param->field_count]))

    goto err2;

 

  for (i= 0; (pos= li++); i++)

  {

    Field *field;

             !real_pos->with_sum_func)

    {                                           // Save for send fields

      pos= real_pos;

        This should be changed to use copy_int or copy_real depending

        on how the value is to be used: In some cases this may be an

        argument in a group function, like: IF(ISNULL(col),0,COUNT(*))

  for (; ptr != end; ptr++)

    (*ptr->do_copy)(ptr);

 

  Item_copy_string *item;

  while ((item = (Item_copy_string*) it++))

    item->copy();

                                                uint32_t elements,

                              List<Item> &all_fields)

{

  Item *item_field,*item;

 

 

  uint32_t i, border= all_fields.elements - elements;

  for (i= 0; (item= it++); i++)

      item_field;

  }

 

  for (i= 0; i < border; i++)

    itr++;

  itr.sublist(res_selected_fields, elements);

                               uint32_t elements,

                                                 List<Item> &all_fields)

{

  Item *item, *new_item;

 

  uint32_t i, border= all_fields.elements - elements;

  for (i= 0; (item= it++); i++)

      new_item;

  }

 

  for (i= 0; i < border; i++)

    itr++;

  itr.sublist(res_selected_fields, elements);

    /*

      Need to check the THD error state because Item::val_xxx() don't

      return error code, but can generate errors

      are extended to return status code.

    */

    if (session->is_error())

  @param changed        out:  returns 1 if item contains a replaced field item

 

  @todo

    updating of the maybe_null attribute is an overkill.

 

  @retval

{

  if (expr->arg_count)

  {

    Item **arg,**arg_end;

    bool arg_changed= false;

    for (arg= expr->arguments(),

                List<TableList> *tables, enum_query_type)

{

  /* List is reversed => we should reverse it before using */

                                                tables->elements);

  if (table == 0)

    return;  // out of memory

 

  //Item List

  bool first= 1;

  Item *item;

  while ((item= it++))

  {

 

  /*

    from clause