~drizzle-trunk/drizzle/development

  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.

 

  /* 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,

  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_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_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();

  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;

 

  }

  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)))

  {

        {

          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.

    */

 

    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;

 

*/

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;

  res_selected_fields.clear();

  res_all_fields.clear();

  List<Item> extra_funcs;

  uint32_t i, border= all_fields.elements - elements;

 

             !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;

 

  res_selected_fields.clear();

      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;

  res_selected_fields.clear();

  res_all_fields.clear();

      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

                List<TableList> *tables, enum_query_type)

{

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

  TableList **table= (TableList **)session->getMemRoot()->allocate(sizeof(TableList*) *

                                                tables->elements);

  if (table == 0)

 

  //Item List

  bool first= 1;

  Item *item;

  while ((item= it++))

  {

 

  /*

    from clause

  */

  if (table_list.elements)

  {