~drizzle-trunk/drizzle/development

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

 

/*

  UNION  of select's

  UNION's  were introduced by Monty and Sinisa <sinisa@mysql.com>

*/

                 SELECT_LEX_UNIT *unit, ulong setup_tables_done_option)

{

  bool res;

  if (!(res= unit->prepare(thd, result, SELECT_NO_UNLOCK |

                           setup_tables_done_option)))

    res= unit->exec();

  if (res)

    res|= unit->cleanup();

}

 

 

** store records in temporary table for UNION

***************************************************************************/

 

{

  unit= u;

  return 0;

                         duplicates on insert

      options            create options

      table_alias        name of the temporary table

 

  DESCRIPTION

    Create a temporary table that is used to store the result of a UNION,

 

bool

select_union::create_result_table(THD *thd_arg, List<Item> *column_types,

                                  const char *table_alias,

                                  bool bit_fields_as_long)

{

  tmp_table_param.init();

  tmp_table_param.field_count= column_types->elements;

  tmp_table_param.bit_fields_as_long= bit_fields_as_long;

 

  if (! (table= create_tmp_table(thd_arg, &tmp_table_param, *column_types,

                                 options, HA_POS_ERROR, (char*) table_alias)))

  table->file->extra(HA_EXTRA_WRITE_CACHE);

  table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);

}

 

 

st_select_lex_unit::init_prepare_fake_select_lex(THD *thd_arg) 

{

  thd_arg->lex->current_select= fake_select_lex;

                                           &result_table_list.next_local);

  fake_select_lex->context.table_list= 

    fake_select_lex->context.first_name_resolution_table= 

    fake_select_lex->get_table_list();

       order;

       order=order->next)

  {

    (*order->item)->walk(&Item::change_context_processor, 0,

  }

}

 

 

bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,

{

  SELECT_LEX *lex_select_save= thd_arg->lex->current_select;

  SELECT_LEX *sl, *first_sl= first_select();

  select_result *tmp_result;

  bool is_union_select;

 

  describe= test(additional_options & SELECT_DESCRIBE);

 

        offset_limit_cnt= 0;

        if (result->prepare(sl->join->fields_list, this))

        {

        }

        sl->join->select_options|= SELECT_DESCRIBE;

        sl->join->reinit();

      }

    }

  }

  prepared= 1;

  

  thd_arg->lex->current_select= sl= first_sl;

  found_rows_for_union= first_sl->options & OPTION_FOUND_ROWS;

  else

    tmp_result= sel_result;

 

 

  for (;sl; sl= sl->next_select())

  {

    can_skip_order_by= is_union_select && !(sl->braces && sl->explicit_limit);

 

    saved_error= join->prepare(&sl->ref_pointer_array,

                               sl->with_wild,

                               sl->where,

                               (can_skip_order_by ? 0 :

                                sl->order_list.elements) +

                               sl->group_list.elements,

                               can_skip_order_by ?

                               sl->having,

                               sl, this);

    /* There are no * in the statement anymore (for PS) */

    sl->with_wild= 0;

        The main reason of this is that we can't create

        field object without table.

      */

      types.empty();

      List_iterator_fast<Item> it(sl->item_list);

      Item *item_tmp;

      while ((type= tp++, item_tmp= it++))

      {

        if (((Item_type_holder*)type)->join_types(thd_arg, item_tmp))

      }

    }

  }

    */

    List_iterator_fast<Item> tp(types);

    Item *type;

 

    while ((type= tp++))

    {

                     TMP_TABLE_ALL_COLUMNS);

 

    if (union_result->create_result_table(thd, &types, test(union_distinct),

      goto err;

    result_table_list.db= (char*) "";

    result_table_list.table_name= result_table_list.alias= (char*) "union";

    result_table_list.table= table= union_result->table;

    }

    else

    {

      /*

        We're in execution of a prepared statement or stored procedure:

        reset field items to point at fields from the created temporary table.

      */

    }

  }

 

  thd_arg->lex->current_select= lex_select_save;

 

 

err:

  thd_arg->lex->current_select= lex_select_save;

}

 

 

{

  SELECT_LEX *lex_select_save= thd->lex->current_select;

  SELECT_LEX *select_cursor=first_select();

  ha_rows examined_rows= 0;

 

  if (executed && !uncacheable && !describe)

  executed= 1;

  

  if (uncacheable || !item || !item->assigned() || describe)

      /* re-enabling indexes for next subselect iteration */

      if (union_distinct && table->file->ha_enable_indexes(HA_KEY_SWITCH_ALL))

      {

      }

    }

    for (SELECT_LEX *sl= select_cursor; sl; sl= sl->next_select())

        {

          offset_limit_cnt= 0;

          /*

            whole query

          */

          if (sl->order_list.first || describe)

          (select_limit_cnt == HA_POS_ERROR || sl->braces) ?

          sl->options & ~OPTION_FOUND_ROWS : sl->options | found_rows_for_union;

 

        if (sl->join->flatten_subqueries())

 

        saved_error= sl->join->optimize();

      }

      if (!saved_error)

        if (sl == union_distinct)

        {

          if (table->file->ha_disable_indexes(HA_KEY_SWITCH_ALL))

          table->no_keyread=1;

        }

        saved_error= sl->join->error;

          if (union_result->flush())

          {

            thd->lex->current_select= lex_select_save;

          }

        }

      }

      if (saved_error)

      {

        thd->lex->current_select= lex_select_save;

      }

      /* Needed for the following test and for records_at_start in next loop */

      int error= table->file->info(HA_STATUS_VARIABLE);

      if(error)

      {

        table->file->print_error(error, MYF(0));

      }

      if (found_rows_for_union && !sl->braces && 

          select_limit_cnt != HA_POS_ERROR)

          We get this from the difference of between total number of possible

          rows and actual rows added to the temporary table.

        */

                              ((table->file->stats.records -  records_at_start)));

      }

    }

  optimized= 1;

 

  /* Send result to 'result' */

  {

    if (!thd->is_fatal_error)                           // Check if EOM

    {

                                              fake_select_lex->options, result)))

        {

          fake_select_lex->table_list.empty();