Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

The world's most popular open source database

JOIN Class Reference

#include <sql_select.h>

Inheritance diagram for JOIN:

[legend]Collaboration diagram for JOIN:

[legend]List of all members.

Public Member Functions
	JOIN (THD *thd_arg, List< Item > &fields_arg, ulonglong select_options_arg, select_result *result_arg)
void	init (THD *thd_arg, List< Item > &fields_arg, ulonglong select_options_arg, select_result *result_arg)
int	prepare (Item ***rref_pointer_array, TABLE_LIST *tables, uint wind_num, COND *conds, uint og_num, ORDER *order, ORDER *group, Item *having, ORDER *proc_param, SELECT_LEX *select, SELECT_LEX_UNIT *unit)
int	optimize ()
int	reinit ()
void	exec ()
int	destroy ()
void	restore_tmp ()
bool	alloc_func_list ()
bool	make_sum_func_list (List< Item > &all_fields, List< Item > &send_fields, bool before_group_by, bool recompute=FALSE)
void	set_items_ref_array (Item **ptr)
void	init_items_ref_array ()
bool	rollup_init ()
bool	rollup_make_fields (List< Item > &all_fields, List< Item > &fields, Item_sum ***func)
int	rollup_send_data (uint idx)
int	rollup_write_data (uint idx, TABLE *table)
bool	test_in_subselect (Item **where)
void	join_free ()
void	cleanup (bool full)
void	clear ()
bool	save_join_tab ()
bool	send_row_on_empty_set ()
bool	change_result (select_result *result)
bool	is_top_level_join () const
Public Attributes
JOIN_TAB *	join_tab
JOIN_TAB **	best_ref
JOIN_TAB **	map2table
JOIN_TAB *	join_tab_save
TABLE **	table
TABLE **	all_tables
TABLE *	sort_by_table
uint	tables
uint	const_tables
uint	send_group_parts
bool	sort_and_group
bool	first_record
bool	full_join
bool	group
bool	no_field_update
bool	do_send_rows
bool	resume_nested_loop
table_map	const_table_map
table_map	found_const_table_map
table_map	outer_join
ha_rows	send_records
ha_rows	found_records
ha_rows	examined_rows
ha_rows	row_limit
ha_rows	select_limit
ha_rows	fetch_limit
POSITION	positions [MAX_TABLES+1]
POSITION	best_positions [MAX_TABLES+1]
nested_join_map	cur_embedding_map
double	best_read
List< Item > *	fields
List< Cached_item >	group_fields
List< Cached_item >	group_fields_cache
TABLE *	tmp_table
TABLE *	exec_tmp_table1
TABLE *	exec_tmp_table2
THD *	thd
Item_sum **	sum_funcs
Item_sum ***	sum_funcs_end
Item_sum **	sum_funcs2
Item_sum ***	sum_funcs_end2
Procedure *	procedure
Item *	having
Item *	tmp_having
Item *	having_history
ulonglong	select_options
select_result *	result
TMP_TABLE_PARAM	tmp_table_param
MYSQL_LOCK *	lock
SELECT_LEX_UNIT *	unit
SELECT_LEX *	select_lex
JOIN *	tmp_join
ROLLUP	rollup
bool	select_distinct
bool	simple_order
bool	simple_group
bool	no_order
bool	skip_sort_order
bool	need_tmp
bool	hidden_group_fields
DYNAMIC_ARRAY	keyuse
Item::cond_result	cond_value
List< Item >	all_fields
List< Item >	tmp_all_fields1
List< Item >	tmp_all_fields2
List< Item >	tmp_all_fields3
List< Item >	tmp_fields_list1
List< Item >	tmp_fields_list2
List< Item >	tmp_fields_list3
List< Item > &	fields_list
List< Item >	procedure_fields_list
int	error
ORDER *	order
ORDER *	group_list
ORDER *	proc_param
COND *	conds
Item *	conds_history
TABLE_LIST *	tables_list
List< TABLE_LIST > *	join_list
COND_EQUAL *	cond_equal
SQL_SELECT *	select
JOIN_TAB *	return_tab
Item **	ref_pointer_array
Item **	items0
Item **	items1
Item **	items2
Item **	items3
Item **	current_ref_pointer_array
uint	ref_pointer_array_size
const char *	zero_result_cause
bool	union_part
bool	optimized
Private Member Functions
	JOIN (const JOIN &rhs)
JOIN &	operator= (const JOIN &rhs)

---

Detailed Description

Definition at line 201 of file sql_select.h.

---

Constructor & Destructor Documentation

JOIN::JOIN

(

const JOIN &

rhs

)

[private]

JOIN::JOIN	(	THD *	thd_arg,
		List< Item > &	fields_arg,
		ulonglong	select_options_arg,
		select_result *	result_arg
	)			[inline]

Definition at line 310 of file sql_select.h.

References init().

    :fields_list(fields_arg)
  {
    init(thd_arg, fields_arg, select_options_arg, result_arg);
  }

Here is the call graph for this function:

---

Member Function Documentation

bool JOIN::alloc_func_list

(

)

Definition at line 13378 of file sql_select.cc.

References DBUG_ENTER, DBUG_RETURN, base_list::elements, fields_list, rollup, send_group_parts, st_rollup::state, st_rollup::STATE_NONE, sum_funcs, sum_funcs_end, and tmp_table_param.

Referenced by exec(), and prepare().

{
  uint func_count, group_parts;
  DBUG_ENTER("alloc_func_list");

  func_count= tmp_table_param.sum_func_count;
  /*
    If we are using rollup, we need a copy of the summary functions for
    each level
  */
  if (rollup.state != ROLLUP::STATE_NONE)
    func_count*= (send_group_parts+1);

  group_parts= send_group_parts;
  /*
    If distinct, reserve memory for possible
    disctinct->group_by optimization
  */
  if (select_distinct)
    group_parts+= fields_list.elements;

  /* This must use calloc() as rollup_make_fields depends on this */
  sum_funcs= (Item_sum**) thd->calloc(sizeof(Item_sum**) * (func_count+1) +
                                      sizeof(Item_sum***) * (group_parts+1));
  sum_funcs_end= (Item_sum***) (sum_funcs+func_count+1);
  DBUG_RETURN(sum_funcs == 0);
}

Here is the caller graph for this function:

bool JOIN::change_result

(

select_result *

result

)

Definition at line 14830 of file sql_select.cc.

References DBUG_ENTER, DBUG_RETURN, FALSE, fields_list, procedure, result, select_lex, and TRUE.

Referenced by mysql_select(), and Sensitive_cursor::open().

{
  DBUG_ENTER("JOIN::change_result");
  result= res;
  if (!procedure && (result->prepare(fields_list, select_lex->master_unit()) ||
                     result->prepare2()))
  {
    DBUG_RETURN(TRUE);
  }
  DBUG_RETURN(FALSE);
}

Here is the caller graph for this function:

void JOIN::cleanup

(

bool

full

)

Definition at line 5948 of file sql_select.cc.

References st_join_table::cleanup(), DBUG_ENTER, DBUG_VOID_RETURN, List< T >::delete_elements(), st_table::file, filesort_free_buffers(), free_io_cache(), group_fields, handler::ha_index_or_rnd_end(), join_tab, st_join_table::table, tmp_join, and tmp_table_param.

Referenced by destroy(), and join_free().

{
  DBUG_ENTER("JOIN::cleanup");

  if (table)
  {
    JOIN_TAB *tab,*end;
    /*
      Only a sorted table may be cached.  This sorted table is always the
      first non const table in join->table
    */
    if (tables > const_tables) // Test for not-const tables
    {
      free_io_cache(table[const_tables]);
      filesort_free_buffers(table[const_tables]);
    }

    if (full)
    {
      for (tab= join_tab, end= tab+tables; tab != end; tab++)
        tab->cleanup();
      table= 0;
      tables= 0;
    }
    else
    {
      for (tab= join_tab, end= tab+tables; tab != end; tab++)
      {
        if (tab->table)
            tab->table->file->ha_index_or_rnd_end();
      }
    }
  }
  /*
    We are not using tables anymore
    Unlock all tables. We may be in an INSERT .... SELECT statement.
  */
  if (full)
  {
    if (tmp_join)
      tmp_table_param.copy_field= 0;
    group_fields.delete_elements();
    /*
      We can't call delete_elements() on copy_funcs as this will cause
      problems in free_elements() as some of the elements are then deleted.
    */
    tmp_table_param.copy_funcs.empty();
    /*
      If we have tmp_join and 'this' JOIN is not tmp_join and
      tmp_table_param.copy_field's  of them are equal then we have to remove
      pointer to  tmp_table_param.copy_field from tmp_join, because it qill
      be removed in tmp_table_param.cleanup().
    */
    if (tmp_join &&
        tmp_join != this &&
        tmp_join->tmp_table_param.copy_field ==
        tmp_table_param.copy_field)
    {
      tmp_join->tmp_table_param.copy_field=
        tmp_join->tmp_table_param.save_copy_field= 0;
    }
    tmp_table_param.cleanup();
  }
  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void JOIN::clear

(

)

Definition at line 14131 of file sql_select.cc.

References clear_tables(), copy_fields(), func, sum_funcs, and tmp_table_param.

Referenced by end_send_group(), and end_write_group().

{
  clear_tables(this);
  copy_fields(&tmp_table_param);

  if (sum_funcs)
  {
    Item_sum *func, **func_ptr= sum_funcs;
    while ((func= *(func_ptr++)))
      func->clear();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int JOIN::destroy

(

)

Definition at line 1851 of file sql_select.cc.

References cleanup(), st_join_table::cleanup(), cond_equal, DBUG_ENTER, DBUG_RETURN, delete_dynamic(), destroy(), error, exec_tmp_table1, exec_tmp_table2, free_tmp_table(), join_tab, keyuse, procedure, select, select_lex, tmp_join, and tmp_table_param.

Referenced by destroy().

{
  DBUG_ENTER("JOIN::destroy");
  select_lex->join= 0;

  if (tmp_join)
  {
    if (join_tab != tmp_join->join_tab)
    {
      JOIN_TAB *tab, *end;
      for (tab= join_tab, end= tab+tables ; tab != end ; tab++)
        tab->cleanup();
    }
    tmp_join->tmp_join= 0;
    tmp_table_param.copy_field=0;
    DBUG_RETURN(tmp_join->destroy());
  }
  cond_equal= 0;

  cleanup(1);
  if (exec_tmp_table1)
    free_tmp_table(thd, exec_tmp_table1);
  if (exec_tmp_table2)
    free_tmp_table(thd, exec_tmp_table2);
  delete select;
  delete_dynamic(&keyuse);
  delete procedure;
  DBUG_RETURN(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void JOIN::exec

(

)

Definition at line 1310 of file sql_select.cc.

References all_fields, alloc_func_list(), calc_group_buffer(), Procedure::change_columns(), change_refs_to_tmp_fields(), change_to_use_tmp_fields(), SQL_SELECT::cond, Item::COND_FALSE, cond_value, conds, const_table_map, const_tables, count_field_types(), create_sort_index(), create_tmp_table(), DBUG_ENTER, DBUG_EXECUTE, DBUG_PRINT, DBUG_VOID_RETURN, st_table::distinct, do_select(), do_send_rows, base_list::elements, Procedure::end_of_records(), end_read_record(), error, exec_tmp_table1, exec_tmp_table2, FALSE, fields_list, st_table::file, st_join_table::first_inner, Procedure::flags, get_schema_tables_result(), group, st_table::group, group_list, HA_STATUS_VARIABLE, having, handler::info(), init_items_ref_array(), int(), st_join_table::is_using_loose_index_scan(), items0, items1, items2, items3, join_free(), join_tab, st_join_table::keyuse, st_reginfo::lock_type, make_cond_for_table(), make_group_fields(), make_simple_join(), make_sum_func_list(), st_table::map, no_order, OPTION_FOUND_ROWS, OPTION_SCHEMA_TABLE, order, print_where(), PROC_GROUP, procedure, procedure_fields_list, Item::quick_fix_field(), st_join_table::read_record, ref_pointer_array, st_table::reginfo, remove_duplicates(), result, return_zero_rows(), save_join_tab(), st_join_table::select, st_join_table::select_cond, select_describe(), select_distinct, select_lex, select_limit, select_options, Protocol::SEND_EOF, Protocol::SEND_NUM_ROWS, send_records, Procedure::send_row(), send_row_on_empty_set(), set_items_ref_array(), setup_copy_fields(), setup_sum_funcs(), simple_group, simple_order, skip_sort_order, sort_and_group, st_join_table::sorted, sum_funcs, sum_funcs2, sum_funcs_end, sum_funcs_end2, st_join_table::table, tables, tables_list, test_if_skip_sort_order(), test_if_subpart(), thd, TL_UNLOCK, tmp_all_fields1, tmp_all_fields2, tmp_all_fields3, tmp_fields_list1, tmp_fields_list2, tmp_fields_list3, tmp_having, tmp_join, tmp_table_param, Item::top_level_item(), TRUE, unit, Procedure::update_refs(), Item::update_used_tables(), Item::val_int(), and zero_result_cause.

Referenced by subselect_single_select_engine::exec(), and mysql_select().

{
  List<Item> *columns_list= &fields_list;
  int      tmp_error;
  DBUG_ENTER("JOIN::exec");

  error= 0;
  if (procedure)
  {
    procedure_fields_list= fields_list;
    if (procedure->change_columns(procedure_fields_list) ||
        result->prepare(procedure_fields_list, unit))
    {
      thd->limit_found_rows= thd->examined_row_count= 0;
      DBUG_VOID_RETURN;
    }
    columns_list= &procedure_fields_list;
  }
  (void) result->prepare2(); // Currently, this cannot fail.

  if (!tables_list)
  {                                           // Only test of functions
    if (select_options & SELECT_DESCRIBE)
      select_describe(this, FALSE, FALSE, FALSE,
                      (zero_result_cause?zero_result_cause:"No tables used"));
    else
    {
      result->send_fields(*columns_list,
                          Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
      /*
        We have to test for 'conds' here as the WHERE may not be constant
        even if we don't have any tables for prepared statements or if
        conds uses something like 'rand()'.
      */
      if (cond_value != Item::COND_FALSE &&
          (!conds || conds->val_int()) &&
          (!having || having->val_int()))
      {
        if (do_send_rows &&
            (procedure ? (procedure->send_row(procedure_fields_list) ||
             procedure->end_of_records()) : result->send_data(fields_list)))
          error= 1;
        else
        {
          error= (int) result->send_eof();
          send_records= ((select_options & OPTION_FOUND_ROWS) ? 1 :
                         thd->sent_row_count);
        }
      }
      else
      {
        error=(int) result->send_eof();
        send_records= 0;
      }
    }
    /* Single select (without union) always returns 0 or 1 row */
    thd->limit_found_rows= send_records;
    thd->examined_row_count= 0;
    DBUG_VOID_RETURN;
  }
  thd->limit_found_rows= thd->examined_row_count= 0;

  if (zero_result_cause)
  {
    (void) return_zero_rows(this, result, select_lex->leaf_tables,
                            *columns_list,
                            send_row_on_empty_set(),
                            select_options,
                            zero_result_cause,
                            having);
    DBUG_VOID_RETURN;
  }

  if (select_options & SELECT_DESCRIBE)
  {
    /*
      Check if we managed to optimize ORDER BY away and don't use temporary
      table to resolve ORDER BY: in that case, we only may need to do
      filesort for GROUP BY.
    */
    if (!order && !no_order && (!skip_sort_order || !need_tmp))
    {
      /*
        Reset 'order' to 'group_list' and reinit variables describing
        'order'
      */
      order= group_list;
      simple_order= simple_group;
      skip_sort_order= 0;
    }
    if (order &&
        (const_tables == tables ||
         ((simple_order || skip_sort_order) &&
          test_if_skip_sort_order(&join_tab[const_tables], order,
                                  select_limit, 0))))
      order=0;
    having= tmp_having;
    select_describe(this, need_tmp,
                    order != 0 && !skip_sort_order,
                    select_distinct);
    DBUG_VOID_RETURN;
  }

  JOIN *curr_join= this;
  List<Item> *curr_all_fields= &all_fields;
  List<Item> *curr_fields_list= &fields_list;
  TABLE *curr_tmp_table= 0;

  if ((curr_join->select_lex->options & OPTION_SCHEMA_TABLE) &&
      get_schema_tables_result(curr_join))
  {
    DBUG_VOID_RETURN;
  }

  /* Create a tmp table if distinct or if the sort is too complicated */
  if (need_tmp)
  {
    if (tmp_join)
    {
      /*
        We are in a non cacheable sub query. Get the saved join structure
        after optimization.
        (curr_join may have been modified during last exection and we need
        to reset it)
      */
      curr_join= tmp_join;
    }
    curr_tmp_table= exec_tmp_table1;

    /* Copy data to the temporary table */
    thd->proc_info= "Copying to tmp table";
    DBUG_PRINT("info", ("%s", thd->proc_info));
    if (!curr_join->sort_and_group &&
        curr_join->const_tables != curr_join->tables)
      curr_join->join_tab[curr_join->const_tables].sorted= 0;
    if ((tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table, 0)))
    {
      error= tmp_error;
      DBUG_VOID_RETURN;
    }
    curr_tmp_table->file->info(HA_STATUS_VARIABLE);
    
    if (curr_join->having)
      curr_join->having= curr_join->tmp_having= 0; // Allready done
    
    /* Change sum_fields reference to calculated fields in tmp_table */
    curr_join->all_fields= *curr_all_fields;
    if (!items1)
    {
      items1= items0 + all_fields.elements;
      if (sort_and_group || curr_tmp_table->group)
      {
        if (change_to_use_tmp_fields(thd, items1,
                                     tmp_fields_list1, tmp_all_fields1,
                                     fields_list.elements, all_fields))
          DBUG_VOID_RETURN;
      }
      else
      {
        if (change_refs_to_tmp_fields(thd, items1,
                                      tmp_fields_list1, tmp_all_fields1,
                                      fields_list.elements, all_fields))
          DBUG_VOID_RETURN;
      }
      curr_join->tmp_all_fields1= tmp_all_fields1;
      curr_join->tmp_fields_list1= tmp_fields_list1;
      curr_join->items1= items1;
    }
    curr_all_fields= &tmp_all_fields1;
    curr_fields_list= &tmp_fields_list1;
    curr_join->set_items_ref_array(items1);
    
    if (sort_and_group || curr_tmp_table->group)
    {
      curr_join->tmp_table_param.field_count+= 
        curr_join->tmp_table_param.sum_func_count+
        curr_join->tmp_table_param.func_count;
      curr_join->tmp_table_param.sum_func_count= 
        curr_join->tmp_table_param.func_count= 0;
    }
    else
    {
      curr_join->tmp_table_param.field_count+= 
        curr_join->tmp_table_param.func_count;
      curr_join->tmp_table_param.func_count= 0;
    }
    
    // procedure can't be used inside subselect => we do nothing special for it
    if (procedure)
      procedure->update_refs();
    
    if (curr_tmp_table->group)
    {                                           // Already grouped
      if (!curr_join->order && !curr_join->no_order && !skip_sort_order)
        curr_join->order= curr_join->group_list;  /* order by group */
      curr_join->group_list= 0;
    }
    
    /*
      If we have different sort & group then we must sort the data by group
      and copy it to another tmp table
      This code is also used if we are using distinct something
      we haven't been able to store in the temporary table yet
      like SEC_TO_TIME(SUM(...)).
    */

    if (curr_join->group_list && (!test_if_subpart(curr_join->group_list,
                                                   curr_join->order) || 
                                  curr_join->select_distinct) ||
        (curr_join->select_distinct &&
         curr_join->tmp_table_param.using_indirect_summary_function))
    {                                   /* Must copy to another table */
      DBUG_PRINT("info",("Creating group table"));
      
      /* Free first data from old join */
      curr_join->join_free();
      if (make_simple_join(curr_join, curr_tmp_table))
        DBUG_VOID_RETURN;
      calc_group_buffer(curr_join, group_list);
      count_field_types(&curr_join->tmp_table_param,
                        curr_join->tmp_all_fields1,
                        curr_join->select_distinct && !curr_join->group_list);
      curr_join->tmp_table_param.hidden_field_count= 
        (curr_join->tmp_all_fields1.elements-
         curr_join->tmp_fields_list1.elements);
      
      
      if (exec_tmp_table2)
        curr_tmp_table= exec_tmp_table2;
      else
      {
        /* group data to new table */

        /*
          If the access method is loose index scan then all MIN/MAX
          functions are precomputed, and should be treated as regular
          functions. See extended comment in JOIN::exec.
        */
        if (curr_join->join_tab->is_using_loose_index_scan())
          curr_join->tmp_table_param.precomputed_group_by= TRUE;

        if (!(curr_tmp_table=
              exec_tmp_table2= create_tmp_table(thd,
                                                &curr_join->tmp_table_param,
                                                *curr_all_fields,
                                                (ORDER*) 0,
                                                curr_join->select_distinct && 
                                                !curr_join->group_list,
                                                1, curr_join->select_options,
                                                HA_POS_ERROR,
                                                (char *) "")))
          DBUG_VOID_RETURN;
        curr_join->exec_tmp_table2= exec_tmp_table2;
      }
      if (curr_join->group_list)
      {
        thd->proc_info= "Creating sort index";
        if (curr_join->join_tab == join_tab && save_join_tab())
        {
          DBUG_VOID_RETURN;
        }
        if (create_sort_index(thd, curr_join, curr_join->group_list,
                              HA_POS_ERROR, HA_POS_ERROR) ||
            make_group_fields(this, curr_join))
        {
          DBUG_VOID_RETURN;
        }
      }
      
      thd->proc_info="Copying to group table";
      DBUG_PRINT("info", ("%s", thd->proc_info));
      tmp_error= -1;
      if (curr_join != this)
      {
        if (sum_funcs2)
        {
          curr_join->sum_funcs= sum_funcs2;
          curr_join->sum_funcs_end= sum_funcs_end2; 
        }
        else
        {
          curr_join->alloc_func_list();
          sum_funcs2= curr_join->sum_funcs;
          sum_funcs_end2= curr_join->sum_funcs_end;
        }
      }
      if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,
                                        1, TRUE))
        DBUG_VOID_RETURN;
      curr_join->group_list= 0;
      if (!curr_join->sort_and_group &&
          curr_join->const_tables != curr_join->tables)
        curr_join->join_tab[curr_join->const_tables].sorted= 0;
      if (setup_sum_funcs(curr_join->thd, curr_join->sum_funcs) ||
          (tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table,
                                0)))
      {
        error= tmp_error;
        DBUG_VOID_RETURN;
      }
      end_read_record(&curr_join->join_tab->read_record);
      curr_join->const_tables= curr_join->tables; // Mark free for cleanup()
      curr_join->join_tab[0].table= 0;           // Table is freed
      
      // No sum funcs anymore
      if (!items2)
      {
        items2= items1 + all_fields.elements;
        if (change_to_use_tmp_fields(thd, items2,
                                     tmp_fields_list2, tmp_all_fields2, 
                                     fields_list.elements, tmp_all_fields1))
          DBUG_VOID_RETURN;
        curr_join->tmp_fields_list2= tmp_fields_list2;
        curr_join->tmp_all_fields2= tmp_all_fields2;
      }
      curr_fields_list= &curr_join->tmp_fields_list2;
      curr_all_fields= &curr_join->tmp_all_fields2;
      curr_join->set_items_ref_array(items2);
      curr_join->tmp_table_param.field_count+= 
        curr_join->tmp_table_param.sum_func_count;
      curr_join->tmp_table_param.sum_func_count= 0;
    }
    if (curr_tmp_table->distinct)
      curr_join->select_distinct=0;             /* Each row is unique */
    
    curr_join->join_free();                     /* Free quick selects */
    if (curr_join->select_distinct && ! curr_join->group_list)
    {
      thd->proc_info="Removing duplicates";
      if (curr_join->tmp_having)
        curr_join->tmp_having->update_used_tables();
      if (remove_duplicates(curr_join, curr_tmp_table,
                            *curr_fields_list, curr_join->tmp_having))
        DBUG_VOID_RETURN;
      curr_join->tmp_having=0;
      curr_join->select_distinct=0;
    }
    curr_tmp_table->reginfo.lock_type= TL_UNLOCK;
    if (make_simple_join(curr_join, curr_tmp_table))
      DBUG_VOID_RETURN;
    calc_group_buffer(curr_join, curr_join->group_list);
    count_field_types(&curr_join->tmp_table_param, *curr_all_fields, 0);
    
  }
  if (procedure)
    count_field_types(&curr_join->tmp_table_param, *curr_all_fields, 0);
  
  if (curr_join->group || curr_join->tmp_table_param.sum_func_count ||
      (procedure && (procedure->flags & PROC_GROUP)))
  {
    if (make_group_fields(this, curr_join))
    {
      DBUG_VOID_RETURN;
    }
    if (!items3)
    {
      if (!items0)
        init_items_ref_array();
      items3= ref_pointer_array + (all_fields.elements*4);
      setup_copy_fields(thd, &curr_join->tmp_table_param,
                        items3, tmp_fields_list3, tmp_all_fields3,
                        curr_fields_list->elements, *curr_all_fields);
      tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;
      tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;
      tmp_table_param.save_copy_field_end=
        curr_join->tmp_table_param.copy_field_end;
      curr_join->tmp_all_fields3= tmp_all_fields3;
      curr_join->tmp_fields_list3= tmp_fields_list3;
    }
    else
    {
      curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;
      curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;
      curr_join->tmp_table_param.copy_field_end=
        tmp_table_param.save_copy_field_end;
    }
    curr_fields_list= &tmp_fields_list3;
    curr_all_fields= &tmp_all_fields3;
    curr_join->set_items_ref_array(items3);

    if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,
                                      1, TRUE) || 
        setup_sum_funcs(curr_join->thd, curr_join->sum_funcs) ||
        thd->is_fatal_error)
      DBUG_VOID_RETURN;
  }
  if (curr_join->group_list || curr_join->order)
  {
    DBUG_PRINT("info",("Sorting for send_fields"));
    thd->proc_info="Sorting result";
    /* If we have already done the group, add HAVING to sorted table */
    if (curr_join->tmp_having && ! curr_join->group_list && 
        ! curr_join->sort_and_group)
    {
      // Some tables may have been const
      curr_join->tmp_having->update_used_tables();
      JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables];
      table_map used_tables= (curr_join->const_table_map |
                              curr_table->table->map);

      Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,
                                                 used_tables,
                                                 used_tables);
      if (sort_table_cond)
      {
        if (!curr_table->select)
          if (!(curr_table->select= new SQL_SELECT))
            DBUG_VOID_RETURN;
        if (!curr_table->select->cond)
          curr_table->select->cond= sort_table_cond;
        else                                    // This should never happen
        {
          if (!(curr_table->select->cond=
                new Item_cond_and(curr_table->select->cond,
                                  sort_table_cond)))
            DBUG_VOID_RETURN;
          /*
            Item_cond_and do not need fix_fields for execution, its parameters
            are fixed or do not need fix_fields, too
          */
          curr_table->select->cond->quick_fix_field();
        }
        curr_table->select_cond= curr_table->select->cond;
        curr_table->select_cond->top_level_item();
        DBUG_EXECUTE("where",print_where(curr_table->select->cond,
                                         "select and having"););
        curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having,
                                                   ~ (table_map) 0,
                                                   ~used_tables);
        DBUG_EXECUTE("where",print_where(curr_join->tmp_having,
                                         "having after sort"););
      }
    }
    {
      if (group)
        curr_join->select_limit= HA_POS_ERROR;
      else
      {
        /*
          We can abort sorting after thd->select_limit rows if we there is no
          WHERE clause for any tables after the sorted one.
        */
        JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables+1];
        JOIN_TAB *end_table= &curr_join->join_tab[curr_join->tables];
        for (; curr_table < end_table ; curr_table++)
        {
          /*
            table->keyuse is set in the case there was an original WHERE clause
            on the table that was optimized away.
          */
          if (curr_table->select_cond ||
              (curr_table->keyuse && !curr_table->first_inner))
          {
            /* We have to sort all rows */
            curr_join->select_limit= HA_POS_ERROR;
            break;
          }
        }
      }
      if (curr_join->join_tab == join_tab && save_join_tab())
      {
        DBUG_VOID_RETURN;
      }
      /*
        Here we sort rows for ORDER BY/GROUP BY clause, if the optimiser
        chose FILESORT to be faster than INDEX SCAN or there is no 
        suitable index present.
        Note, that create_sort_index calls test_if_skip_sort_order and may
        finally replace sorting with index scan if there is a LIMIT clause in
        the query. XXX: it's never shown in EXPLAIN!
        OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.
      */
      if (create_sort_index(thd, curr_join,
                            curr_join->group_list ? 
                            curr_join->group_list : curr_join->order,
                            curr_join->select_limit,
                            (select_options & OPTION_FOUND_ROWS ?
                             HA_POS_ERROR : unit->select_limit_cnt)))
        DBUG_VOID_RETURN;
      if (curr_join->const_tables != curr_join->tables &&
          !curr_join->join_tab[curr_join->const_tables].table->sort.io_cache)
      {
        /*
          If no IO cache exists for the first table then we are using an
          INDEX SCAN and no filesort. Thus we should not remove the sorted
          attribute on the INDEX SCAN.
        */
        skip_sort_order= 1;
      }
    }
  }
  /* XXX: When can we have here thd->net.report_error not zero? */
  if (thd->net.report_error)
  {
    error= thd->net.report_error;
    DBUG_VOID_RETURN;
  }
  curr_join->having= curr_join->tmp_having;
  curr_join->fields= curr_fields_list;
  curr_join->procedure= procedure;

  if (is_top_level_join() && thd->cursor && tables != const_tables)
  {
    /*
      We are here if this is JOIN::exec for the last select of the main unit
      and the client requested to open a cursor.
      We check that not all tables are constant because this case is not
      handled by do_select() separately, and this case is not implemented
      for cursors yet.
    */
    DBUG_ASSERT(error == 0);
    /*
      curr_join is used only for reusable joins - that is, 
      to perform SELECT for each outer row (like in subselects).
      This join is main, so we know for sure that curr_join == join.
    */
    DBUG_ASSERT(curr_join == this);
    /* Open cursor for the last join sweep */
    error= thd->cursor->open(this);
  }
  else
  {
    thd->proc_info="Sending data";
    DBUG_PRINT("info", ("%s", thd->proc_info));
    result->send_fields((procedure ? curr_join->procedure_fields_list :
                         *curr_fields_list),
                        Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
    error= do_select(curr_join, curr_fields_list, NULL, procedure);
    thd->limit_found_rows= curr_join->send_records;
    thd->examined_row_count= curr_join->examined_rows;
  }

  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void JOIN::init	(	THD *	thd_arg,
		List< Item > &	fields_arg,
		ulonglong	select_options_arg,
		select_result *	result_arg
	)			[inline]

Definition at line 317 of file sql_select.h.

References all_fields, bzero, cond_equal, const_tables, do_send_rows, error, examined_rows, exec_tmp_table1, exec_tmp_table2, FALSE, fetch_limit, fields_list, first_record, found_records, HA_POS_ERROR, having, having_history, hidden_group_fields, items0, items1, items2, items3, join_list, join_tab, join_tab_save, keyuse, lock, need_tmp, no_order, optimized, procedure, ref_pointer_array, ref_pointer_array_size, result, resume_nested_loop, return_tab, rollup, select, SELECT_DISTINCT, select_distinct, select_lex, select_options, send_records, simple_group, simple_order, skip_sort_order, sort_and_group, st_rollup::state, st_rollup::STATE_NONE, sum_funcs, sum_funcs2, table, tables, test, thd, tmp_having, tmp_join, tmp_table_param, and zero_result_cause.

Referenced by JOIN().

  {
    join_tab= join_tab_save= 0;
    table= 0;
    tables= 0;
    const_tables= 0;
    join_list= 0;
    sort_and_group= 0;
    first_record= 0;
    do_send_rows= 1;
    resume_nested_loop= FALSE;
    send_records= 0;
    found_records= 0;
    fetch_limit= HA_POS_ERROR;
    examined_rows= 0;
    exec_tmp_table1= 0;
    exec_tmp_table2= 0;
    thd= thd_arg;
    sum_funcs= sum_funcs2= 0;
    procedure= 0;
    having= tmp_having= having_history= 0;
    select_options= select_options_arg;
    result= result_arg;
    lock= thd_arg->lock;
    select_lex= 0; //for safety
    tmp_join= 0;
    select_distinct= test(select_options & SELECT_DISTINCT);
    no_order= 0;
    simple_order= 0;
    simple_group= 0;
    skip_sort_order= 0;
    need_tmp= 0;
    hidden_group_fields= 0; /*safety*/
    error= 0;
    select= 0;
    return_tab= 0;
    ref_pointer_array= items0= items1= items2= items3= 0;
    ref_pointer_array_size= 0;
    zero_result_cause= 0;
    optimized= 0;
    cond_equal= 0;

    all_fields= fields_arg;
    fields_list= fields_arg;
    bzero((char*) &keyuse,sizeof(keyuse));
    tmp_table_param.init();
    tmp_table_param.end_write_records= HA_POS_ERROR;
    rollup.state= ROLLUP::STATE_NONE;
  }

Here is the caller graph for this function:

void JOIN::init_items_ref_array

(

)

[inline]

Definition at line 386 of file sql_select.h.

References all_fields, current_ref_pointer_array, base_list::elements, items0, memcpy, ref_pointer_array, and ref_pointer_array_size.

Referenced by exec().

  {
    items0= ref_pointer_array + all_fields.elements;
    memcpy(items0, ref_pointer_array, ref_pointer_array_size);
    current_ref_pointer_array= items0;
  }

Here is the caller graph for this function:

bool JOIN::is_top_level_join

(

)

const [inline]

Definition at line 416 of file sql_select.h.

References select_lex, thd, and unit.

  {
    return (unit == &thd->lex->unit && (unit->fake_select_lex == 0 ||
                                        select_lex == unit->fake_select_lex));
  }

void JOIN::join_free

(

)

Definition at line 5881 of file sql_select.cc.

References cleanup(), DBUG_ENTER, DBUG_VOID_RETURN, full(), lock, mysql_unlock_read_tables(), select_lex, SELECT_NO_UNLOCK, select_options, and unit.

Referenced by do_select(), exec(), and return_zero_rows().

{
  SELECT_LEX_UNIT *unit;
  SELECT_LEX *sl;
  /*
    Optimization: if not EXPLAIN and we are done with the JOIN,
    free all tables.
  */
  bool full= (!select_lex->uncacheable && !thd->lex->describe);
  bool can_unlock= full;
  DBUG_ENTER("JOIN::join_free");

  cleanup(full);

  for (unit= select_lex->first_inner_unit(); unit; unit= unit->next_unit())
    for (sl= unit->first_select(); sl; sl= sl->next_select())
    {
      Item_subselect *subselect= sl->master_unit()->item;
      bool full_local= full && (!subselect || subselect->is_evaluated());
      /*
        If this join is evaluated, we can fully clean it up and clean up all
        its underlying joins even if they are correlated -- they will not be
        used any more anyway.
        If this join is not yet evaluated, we still must clean it up to
        close its table cursors -- it may never get evaluated, as in case of
        ... HAVING FALSE OR a IN (SELECT ...))
        but all table cursors must be closed before the unlock.
      */
      sl->cleanup_all_joins(full_local);
      /* Can't unlock if at least one JOIN is still needed */
      can_unlock= can_unlock && full_local;
    }

  /*
    We are not using tables anymore
    Unlock all tables. We may be in an INSERT .... SELECT statement.
  */
  if (can_unlock && lock && thd->lock &&
      !(select_options & SELECT_NO_UNLOCK) &&
      !select_lex->subquery_in_having &&
      (select_lex == (thd->lex->unit.fake_select_lex ?
                      thd->lex->unit.fake_select_lex : &thd->lex->select_lex)))
  {
    /*
      TODO: unlock tables even if the join isn't top level select in the
      tree.
    */
    mysql_unlock_read_tables(thd, lock);           // Don't free join->lock
    lock= 0;
  }

  DBUG_VOID_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool JOIN::make_sum_func_list	(	List< Item > &	all_fields,
		List< Item > &	send_fields,
		bool	before_group_by,
		bool	recompute = FALSE
	)

Definition at line 13422 of file sql_select.cc.

References Item::const_item(), DBUG_ENTER, DBUG_RETURN, FALSE, func, rollup, rollup_make_fields(), send_fields(), send_group_parts, st_rollup::state, st_rollup::STATE_INITED, st_rollup::STATE_NONE, st_rollup::STATE_READY, Item::SUM_FUNC_ITEM, sum_funcs, sum_funcs_end, TRUE, and Item::type().

Referenced by exec(), and get_best_group_min_max().

{
  List_iterator_fast<Item> it(field_list);
  Item_sum **func;
  Item *item;
  DBUG_ENTER("make_sum_func_list");

  if (*sum_funcs && !recompute)
    DBUG_RETURN(FALSE); /* We have already initialized sum_funcs. */

  func= sum_funcs;
  while ((item=it++))
  {
    if (item->type() == Item::SUM_FUNC_ITEM && !item->const_item())
      *func++= (Item_sum*) item;
  }
  if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
  {
    rollup.state= ROLLUP::STATE_READY;
    if (rollup_make_fields(field_list, send_fields, &func))
      DBUG_RETURN(TRUE);                        // Should never happen
  }
  else if (rollup.state == ROLLUP::STATE_NONE)
  {
    for (uint i=0 ; i <= send_group_parts ;i++)
      sum_funcs_end[i]= func;
  }
  else if (rollup.state == ROLLUP::STATE_READY)
    DBUG_RETURN(FALSE);                         // Don't put end marker
  *func=0;                                      // End marker
  DBUG_RETURN(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

JOIN& JOIN::operator=

(

const JOIN &

rhs

)

[private]

int JOIN::optimize

(

)

Definition at line 550 of file sql_select.cc.

References all_fields, backup, best_read, build_bitmap_for_nested_joins(), cond_equal, Item::COND_FALSE, cond_value, conds, const_table_map, const_tables, Item::copy_andor_structure(), DBUG_ENTER, DBUG_EXECUTE, DBUG_PRINT, DBUG_RETURN, DESCRIBE_EXTENDED, do_send_rows, st_table_list::embedding, ER, ER_TOO_BIG_SELECT, error, Item::fix_fields(), found_const_table_map, get_sort_by_table(), group_list, HA_POS_ERROR, having, join_list, join_tab, keyuse, make_cond_for_table(), make_join_statistics(), make_outerjoin_info(), make_select(), map2table, my_message(), MYF, mysql_unlock_some_tables(), st_table_list::next_leaf, st_table_list::on_expr, opt_sum_query(), optimize_cond(), optimized, OPTION_BIG_SELECTS, OPTION_FOUND_ROWS, order, outer_join, print_where(), PSEUDO_TABLE_BITS, RAND_TABLE_BIT, reset_nj_counters(), result, row_limit, sel, select, SELECT_DESCRIBE, select_distinct, select_lex, select_limit, SELECT_NO_UNLOCK, select_options, simplify_joins(), sort_by_table, substitute_for_best_equal_field(), table, st_table_list::table, tables, tables_list, thd, tmp_table_param, TRUE, unit, Item::update_used_tables(), Item::used_tables(), and zero_result_cause.

Referenced by subselect_single_select_engine::exec(), and mysql_select().

{
  DBUG_ENTER("JOIN::optimize");
  // to prevent double initialization on EXPLAIN
  if (optimized)
    DBUG_RETURN(0);
  optimized= 1;

  row_limit= ((select_distinct || order || group_list) ? HA_POS_ERROR :
              unit->select_limit_cnt);
  /* select_limit is used to decide if we are likely to scan the whole table */
  select_limit= unit->select_limit_cnt;
  if (having || (select_options & OPTION_FOUND_ROWS))
    select_limit= HA_POS_ERROR;
  do_send_rows = (unit->select_limit_cnt) ? 1 : 0;
  // Ignore errors of execution if option IGNORE present
  if (thd->lex->ignore)
    thd->lex->current_select->no_error= 1;
#ifdef HAVE_REF_TO_FIELDS                       // Not done yet
  /* Add HAVING to WHERE if possible */
  if (having && !group_list && !sum_func_count)
  {
    if (!conds)
    {
      conds= having;
      having= 0;
    }
    else if ((conds=new Item_cond_and(conds,having)))
    {
      /*
        Item_cond_and can't be fixed after creation, so we do not check
        conds->fixed
      */
      conds->fix_fields(thd, &conds);
      conds->change_ref_to_fields(thd, tables_list);
      conds->top_level_item();
      having= 0;
    }
  }
#endif
  SELECT_LEX *sel= thd->lex->current_select;
  if (sel->first_cond_optimization)
  {
    /*
      The following code will allocate the new items in a permanent
      MEMROOT for prepared statements and stored procedures.
    */

    Query_arena *arena= thd->stmt_arena, backup;
    if (arena->is_conventional())
      arena= 0;                                   // For easier test
    else
      thd->set_n_backup_active_arena(arena, &backup);

    sel->first_cond_optimization= 0;

    /* Convert all outer joins to inner joins if possible */
    conds= simplify_joins(this, join_list, conds, TRUE);
    build_bitmap_for_nested_joins(join_list, 0);

    sel->prep_where= conds ? conds->copy_andor_structure(thd) : 0;
    sel->prep_having= having ? having->copy_andor_structure(thd) : 0;

    if (arena)
      thd->restore_active_arena(arena, &backup);
  }

  conds= optimize_cond(this, conds, join_list, &cond_value);   
  if (thd->net.report_error)
  {
    error= 1;
    DBUG_PRINT("error",("Error from optimize_cond"));
    DBUG_RETURN(1);
  }

  {
    Item::cond_result having_value;
    having= optimize_cond(this, having, join_list, &having_value);
    if (thd->net.report_error)
    {
      error= 1;
      DBUG_PRINT("error",("Error from optimize_cond"));
      DBUG_RETURN(1);
    }

    if (cond_value == Item::COND_FALSE || having_value == Item::COND_FALSE || 
        (!unit->select_limit_cnt && !(select_options & OPTION_FOUND_ROWS)))
    {                                           /* Impossible cond */
      DBUG_PRINT("info", (having_value == Item::COND_FALSE ? 
                            "Impossible HAVING" : "Impossible WHERE"));
      zero_result_cause=  having_value == Item::COND_FALSE ?
                           "Impossible HAVING" : "Impossible WHERE";
      error= 0;
      DBUG_RETURN(0);
    }
  }

#ifdef WITH_PARTITION_STORAGE_ENGINE
  {
    TABLE_LIST *tbl;
    for (tbl= select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)
    {
      /* 
        If tbl->embedding!=NULL that means that this table is in the inner
        part of the nested outer join, and we can't do partition pruning
        (TODO: check if this limitation can be lifted)
      */
      if (!tbl->embedding)
      {
        Item *prune_cond= tbl->on_expr? tbl->on_expr : conds;
        tbl->table->no_partitions_used= prune_partitions(thd, tbl->table,
                                                         prune_cond);
      }
    }
  }
#endif

  /* Optimize count(*), min() and max() */
  if (tables_list && tmp_table_param.sum_func_count && ! group_list)
  {
    int res;
    /*
      opt_sum_query() returns -1 if no rows match to the WHERE conditions,
      or 1 if all items were resolved, or 0, or an error number HA_ERR_...
    */
    if ((res=opt_sum_query(select_lex->leaf_tables, all_fields, conds)))
    {
      if (res > 1)
      {
        DBUG_PRINT("error",("Error from opt_sum_query"));
        DBUG_RETURN(1);
      }
      if (res < 0)
      {
        DBUG_PRINT("info",("No matching min/max row"));
        zero_result_cause= "No matching min/max row";
        error=0;
        DBUG_RETURN(0);
      }
      DBUG_PRINT("info",("Select tables optimized away"));
      zero_result_cause= "Select tables optimized away";
      tables_list= 0;                           // All tables resolved
      /*
        Extract all table-independent conditions and replace the WHERE
        clause with them. All other conditions were computed by opt_sum_query
        and the MIN/MAX/COUNT function(s) have been replaced by constants,
        so there is no need to compute the whole WHERE clause again.
        Notice that make_cond_for_table() will always succeed to remove all
        computed conditions, because opt_sum_query() is applicable only to
        conjunctions.
        Preserve conditions for EXPLAIN.
      */
      if (conds && !(thd->lex->describe & DESCRIBE_EXTENDED))
      {
        COND *table_independent_conds=
          make_cond_for_table(conds, PSEUDO_TABLE_BITS, 0);
        DBUG_EXECUTE("where",
                     print_where(table_independent_conds,
                                 "where after opt_sum_query()"););
        conds= table_independent_conds;
      }
    }
  }
  if (!tables_list)
  {
    DBUG_PRINT("info",("No tables"));
    error= 0;
    DBUG_RETURN(0);
  }
  error= -1;                                    // Error is sent to client
  sort_by_table= get_sort_by_table(order, group_list, select_lex->leaf_tables);

  /* Calculate how to do the join */
  thd->proc_info= "statistics";
  if (make_join_statistics(this, select_lex->leaf_tables, conds, &keyuse) ||
      thd->is_fatal_error)
  {
    DBUG_PRINT("error",("Error: make_join_statistics() failed"));
    DBUG_RETURN(1);
  }

  /* Remove distinct if only const tables */
  select_distinct= select_distinct && (const_tables != tables);
  thd->proc_info= "preparing";
  if (result->initialize_tables(this))
  {
    DBUG_PRINT("error",("Error: initialize_tables() failed"));
    DBUG_RETURN(1);                             // error == -1
  }
  if (const_table_map != found_const_table_map &&
      !(select_options & SELECT_DESCRIBE) &&
      (!conds ||
       !(conds->used_tables() & RAND_TABLE_BIT) ||
       select_lex->master_unit() == &thd->lex->unit)) // upper level SELECT
  {
    zero_result_cause= "no matching row in const table";
    DBUG_PRINT("error",("Error: %s", zero_result_cause));
    error= 0;
    DBUG_RETURN(0);
  }
  if (!(thd->options & OPTION_BIG_SELECTS) &&
      best_read > (double) thd->variables.max_join_size &&
      !(select_options & SELECT_DESCRIBE))
  {                                             /* purecov: inspected */
    my_message(ER_TOO_BIG_SELECT, ER(ER_TOO_BIG_SELECT), MYF(0));
    error= -1;
    DBUG_RETURN(1);
  }
  if (const_tables && !thd->locked_tables &&
      !(select_options & SELECT_NO_UNLOCK))
    mysql_unlock_some_tables(thd, table, const_tables);
  if (!conds && outer_join)
  {
    /* Handle the case where we have an OUTER JOIN without a WHERE */
    conds=new Item_int((longlong) 1,1); // Always true
  }
  select= make_select(*table, const_table_map,
                      const_table_map, conds, 1, &error);
  if (error)
  {                                             /* purecov: inspected */
    error= -1;                                  /* purecov: inspected */
    DBUG_PRINT("error",("Error: make_select() failed"));
    DBUG_RETURN(1);
  }
  
  reset_nj_counters(join_list);
  make_outerjoin_info(this);

  /*
    Among the equal fields belonging to the same multiple equality
    choose the one that is to be retrieved first and substitute
    all references to these in where condition for a reference for
    the selected field.
  */
  if (conds)
  {
    conds= substitute_for_best_equal_field(conds, cond_equal, map2table);
    conds->update_used_tables();
    DBUG_EXECUTE("where", print_where(conds, "after substitute_best_equal"););
  }
  /*
    Permorm the the optimization on fields evaluation mentioned above
    for all on expressions.
  */ 
  for (JOIN_TAB *tab= join_tab + const_tables; tab < join_tab + tables ; tab++)
  {
    if (*tab->on_expr_ref)
    {
      *tab->on_expr_ref= substitute_for_best_equal_field(*tab->on_expr_ref,
                                                         tab->cond_equal,
                                                         map2table);
      (*tab->on_expr_ref)->update_used_tables();
    }
  }

  if (make_join_select(this, select, conds))
  {
    zero_result_cause=
      "Impossible WHERE noticed after reading const tables";
    DBUG_RETURN(0);                             // error == 0
  }

  error= -1;                                    /* if goto err */

  /* Optimize distinct away if possible */
  {
    ORDER *org_order= order;
    order=remove_const(this, order,conds,1, &simple_order);
    /*
      If we are using ORDER BY NULL or ORDER BY const_expression,
      return result in any order (even if we are using a GROUP BY)
    */
    if (!order && org_order)
      skip_sort_order= 1;
  }
  if (group_list || tmp_table_param.sum_func_count)
  {
    if (! hidden_group_fields && rollup.state == ROLLUP::STATE_NONE)
      select_distinct=0;
  }
  else if (select_distinct && tables - const_tables == 1)
  {
    /*
      We are only using one table. In this case we change DISTINCT to a
      GROUP BY query if:
      - The GROUP BY can be done through indexes (no sort) and the ORDER
        BY only uses selected fields.
        (In this case we can later optimize away GROUP BY and ORDER BY)
      - We are scanning the whole table without LIMIT
        This can happen if:
        - We are using CALC_FOUND_ROWS
        - We are using an ORDER BY that can't be optimized away.

      We don't want to use this optimization when we are using LIMIT
      because in this case we can just create a temporary table that
      holds LIMIT rows and stop when this table is full.
    */
    JOIN_TAB *tab= &join_tab[const_tables];
    bool all_order_fields_used;
    if (order)
      skip_sort_order= test_if_skip_sort_order(tab, order, select_limit, 1);
    if ((group_list=create_distinct_group(thd, select_lex->ref_pointer_array,
                                          order, fields_list,
                                          &all_order_fields_used)))
    {
      bool skip_group= (skip_sort_order &&
                        test_if_skip_sort_order(tab, group_list, select_limit,
                                                1) != 0);
      if ((skip_group && all_order_fields_used) ||
          select_limit == HA_POS_ERROR ||
          (order && !skip_sort_order))
      {
        /*  Change DISTINCT to GROUP BY */
        select_distinct= 0;
        no_order= !order;
        if (all_order_fields_used)
        {
          if (order && skip_sort_order)
          {
            /*
              Force MySQL to read the table in sorted order to get result in
              ORDER BY order.
            */
            tmp_table_param.quick_group=0;
          }
          order=0;
        }
        group=1;                                // For end_write_group
      }
      else
        group_list= 0;
    }
    else if (thd->is_fatal_error)                       // End of memory
      DBUG_RETURN(1);
  }
  simple_group= 0;
  {
    ORDER *old_group_list;
    group_list= remove_const(this, (old_group_list= group_list), conds,
                             rollup.state == ROLLUP::STATE_NONE,
                             &simple_group);
    if (old_group_list && !group_list)
      select_distinct= 0;
  }
  /*
     Check if we can optimize away GROUP BY/DISTINCT.
     We can do that if there are no aggregate functions and the
     fields in DISTINCT clause (if present) and/or columns in GROUP BY
     (if present) contain direct references to all key parts of
     an unique index (in whatever order).
     Note that the unique keys for DISTINCT and GROUP BY should not
     be the same (as long as they are unique).

     The FROM clause must contain a single non-constant table.
  */
  if (tables - const_tables == 1 && (group_list || select_distinct) &&
      !tmp_table_param.sum_func_count &&
      (!join_tab[const_tables].select ||
       !join_tab[const_tables].select->quick ||
       join_tab[const_tables].select->quick->get_type() != 
       QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))
  {
    if (group_list &&
       list_contains_unique_index(join_tab[const_tables].table,
                                 find_field_in_order_list,
                                 (void *) group_list))
    {
      group_list= 0;
      group= 0;
    }
    if (select_distinct &&
       list_contains_unique_index(join_tab[const_tables].table,
                                 find_field_in_item_list,
                                 (void *) &fields_list))
    {
      select_distinct= 0;
    }
  }
  if (!group_list && group)
  {
    order=0;                                    // The output has only one row
    simple_order=1;
    select_distinct= 0;                       // No need in distinct for 1 row
  }

  calc_group_buffer(this, group_list);
  send_group_parts= tmp_table_param.group_parts; /* Save org parts */
  if (procedure && procedure->group)
  {
    group_list= procedure->group= remove_const(this, procedure->group, conds,
                                               1, &simple_group);
    calc_group_buffer(this, group_list);
  }

  if (test_if_subpart(group_list, order) ||
      (!group_list && tmp_table_param.sum_func_count))
    order=0;

  // Can't use sort on head table if using row cache
  if (full_join)
  {
    if (group_list)
      simple_group=0;
    if (order)
      simple_order=0;
  }

  /*
    Check if we need to create a temporary table.
    This has to be done if all tables are not already read (const tables)
    and one of the following conditions holds:
    - We are using DISTINCT (simple distinct's are already optimized away)
    - We are using an ORDER BY or GROUP BY on fields not in the first table
    - We are using different ORDER BY and GROUP BY orders
    - The user wants us to buffer the result.
  */
  need_tmp= (const_tables != tables &&
             ((select_distinct || !simple_order || !simple_group) ||
              (group_list && order) ||
              test(select_options & OPTION_BUFFER_RESULT)));

  // No cache for MATCH
  make_join_readinfo(this,
                     (select_options & (SELECT_DESCRIBE |
                                        SELECT_NO_JOIN_CACHE)) |
                     (select_lex->ftfunc_list->elements ?
                      SELECT_NO_JOIN_CACHE : 0));

  /* Perform FULLTEXT search before all regular searches */
  if (!(select_options & SELECT_DESCRIBE))
    init_ftfuncs(thd, select_lex, test(order));

  /*
    is this simple IN subquery?
  */
  if (!group_list && !order &&
      unit->item && unit->item->substype() == Item_subselect::IN_SUBS &&
      tables == 1 && conds &&
      !unit->first_select()->next_select())
  {
    if (!having)
    {
      Item *where= 0;
      if (join_tab[0].type == JT_EQ_REF &&
          join_tab[0].ref.items[0]->name == in_left_expr_name)
      {
        if (test_in_subselect(&where))
        {
          join_tab[0].type= JT_UNIQUE_SUBQUERY;
          error= 0;
          DBUG_RETURN(unit->item->
                      change_engine(new
                                    subselect_uniquesubquery_engine(thd,
                                                                    join_tab,
                                                                    unit->item,
                                                                    where)));
        }
      }
      else if (join_tab[0].type == JT_REF &&
               join_tab[0].ref.items[0]->name == in_left_expr_name)
      {
        if (test_in_subselect(&where))
        {
          join_tab[0].type= JT_INDEX_SUBQUERY;
          error= 0;
          DBUG_RETURN(unit->item->
                      change_engine(new
                                    subselect_indexsubquery_engine(thd,
                                                                   join_tab,
                                                                   unit->item,
                                                                   where,
                                                                   0)));
        }
      }
    } else if (join_tab[0].type == JT_REF_OR_NULL &&
               join_tab[0].ref.items[0]->name == in_left_expr_name &&
               having->type() == Item::FUNC_ITEM &&
               ((Item_func *) having)->functype() ==
               Item_func::ISNOTNULLTEST_FUNC)
    {
      join_tab[0].type= JT_INDEX_SUBQUERY;
      error= 0;

      if ((conds= remove_additional_cond(conds)))
        join_tab->info= "Using index; Using where";
      else
        join_tab->info= "Using index";

      DBUG_RETURN(unit->item->
                  change_engine(new subselect_indexsubquery_engine(thd,
                                                                   join_tab,
                                                                   unit->item,
                                                                   conds,
                                                                   1)));
    }

  }
  /*
    Need to tell handlers that to play it safe, it should fetch all
    columns of the primary key of the tables: this is because MySQL may
    build row pointers for the rows, and for all columns of the primary key
    the read set has not necessarily been set by the server code.
  */
  if (need_tmp || select_distinct || group_list || order)
  {
    for (uint i = const_tables; i < tables; i++)
      join_tab[i].table->prepare_for_position();
  }

  DBUG_EXECUTE("info",TEST_join(this););

  if (const_tables != tables)
  {
    /*
      Because filesort always does a full table scan or a quick range scan
      we must add the removed reference to the select for the table.
      We only need to do this when we have a simple_order or simple_group
      as in other cases the join is done before the sort.
    */
    if ((order || group_list) &&
        join_tab[const_tables].type != JT_ALL &&
        join_tab[const_tables].type != JT_FT &&
        join_tab[const_tables].type != JT_REF_OR_NULL &&
        (order && simple_order || group_list && simple_group))
    {
      if (add_ref_to_table_cond(thd,&join_tab[const_tables]))
        DBUG_RETURN(1);
    }
    
    if (!(select_options & SELECT_BIG_RESULT) &&
        ((group_list &&
          (!simple_group ||
           !test_if_skip_sort_order(&join_tab[const_tables], group_list,
                                    unit->select_limit_cnt, 0))) ||
         select_distinct) &&
        tmp_table_param.quick_group && !procedure)
    {
      need_tmp=1; simple_order=simple_group=0;  // Force tmp table without sort
    }
    if (order)
    {
      /*
        Force using of tmp table if sorting by a SP or UDF function due to
        their expensive and probably non-deterministic nature.
      */
      for (ORDER *tmp_order= order; tmp_order ; tmp_order=tmp_order->next)
      {
        Item *item= *tmp_order->item;
        if (item->walk(&Item::is_expensive_processor, 0, (byte*)0))
        {
          /* Force tmp table without sort */
          need_tmp=1; simple_order=simple_group=0;
          break;
        }
      }
    }
  }

  tmp_having= having;
  if (select_options & SELECT_DESCRIBE)
  {
    error= 0;
    DBUG_RETURN(0);
  }
  having= 0;

  /*
    The loose index scan access method guarantees that all grouping or
    duplicate row elimination (for distinct) is already performed
    during data retrieval, and that all MIN/MAX functions are already
    computed for each group. Thus all MIN/MAX functions should be
    treated as regular functions, and there is no need to perform
    grouping in the main execution loop.
    Notice that currently loose index scan is applicable only for
    single table queries, thus it is sufficient to test only the first
    join_tab element of the plan for its access method.
  */
  if (join_tab->is_using_loose_index_scan())
    tmp_table_param.precomputed_group_by= TRUE;

  /* Create a tmp table if distinct or if the sort is too complicated */
  if (need_tmp)
  {
    DBUG_PRINT("info",("Creating tmp table"));
    thd->proc_info="Creating tmp table";

    init_items_ref_array();

    tmp_table_param.hidden_field_count= (all_fields.elements -
                                         fields_list.elements);
    if (!(exec_tmp_table1=
          create_tmp_table(thd, &tmp_table_param, all_fields,
                           ((!simple_group && !procedure &&
                             !(test_flags & TEST_NO_KEY_GROUP)) ?
                            group_list : (ORDER*) 0),
                           group_list ? 0 : select_distinct,
                           group_list && simple_group,
                           select_options,
                           (order == 0 || skip_sort_order || 
                            test(select_options & OPTION_BUFFER_RESULT)) ? 
                             select_limit : HA_POS_ERROR,
                           (char *) "")))
      DBUG_RETURN(1);

    /*
      We don't have to store rows in temp table that doesn't match HAVING if:
      - we are sorting the table and writing complete group rows to the
        temp table.
      - We are using DISTINCT without resolving the distinct as a GROUP BY
        on all columns.
      
      If having is not handled here, it will be checked before the row
      is sent to the client.
    */    
    if (tmp_having && 
        (sort_and_group || (exec_tmp_table1->distinct && !group_list)))
      having= tmp_having;

    /* if group or order on first table, sort first */
    if (group_list && simple_group)
    {
      DBUG_PRINT("info",("Sorting for group"));
      thd->proc_info="Sorting for group";
      if (create_sort_index(thd, this, group_list,
                            HA_POS_ERROR, HA_POS_ERROR) ||
          alloc_group_fields(this, group_list) ||
          make_sum_func_list(all_fields, fields_list, 1) ||
          setup_sum_funcs(thd, sum_funcs))
        DBUG_RETURN(1);
      group_list=0;
    }
    else
    {
      if (make_sum_func_list(all_fields, fields_list, 0) ||
          setup_sum_funcs(thd, sum_funcs))
        DBUG_RETURN(1);
      if (!group_list && ! exec_tmp_table1->distinct && order && simple_order)
      {
        DBUG_PRINT("info",("Sorting for order"));
        thd->proc_info="Sorting for order";
        if (create_sort_index(thd, this, order,
                              HA_POS_ERROR, HA_POS_ERROR))
          DBUG_RETURN(1);
        order=0;
      }
    }
    
    /*
      Optimize distinct when used on some of the tables
      SELECT DISTINCT t1.a FROM t1,t2 WHERE t1.b=t2.b
      In this case we can stop scanning t2 when we have found one t1.a
    */

    if (exec_tmp_table1->distinct)
    {
      table_map used_tables= thd->used_tables;
      JOIN_TAB *last_join_tab= join_tab+tables-1;
      do
      {
        if (used_tables & last_join_tab->table->map)
          break;
        last_join_tab->not_used_in_distinct=1;
      } while (last_join_tab-- != join_tab);
      /* Optimize "select distinct b from t1 order by key_part_1 limit #" */
      if (order && skip_sort_order)
      {
        /* Should always succeed */
        if (test_if_skip_sort_order(&join_tab[const_tables],
                                    order, unit->select_limit_cnt, 0))
          order=0;
      }
    }

    if (select_lex->uncacheable && !is_top_level_join())
    {
      /* If this join belongs to an uncacheable subquery */
      if (!(tmp_join= (JOIN*)thd->alloc(sizeof(JOIN))))
        DBUG_RETURN(-1);
      error= 0;                         // Ensure that tmp_join.error= 0
      restore_tmp();
    }
  }

  error= 0;
  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int JOIN::prepare	(	Item ***	rref_pointer_array,
		TABLE_LIST *	tables,
		uint	wind_num,
		COND *	conds,
		uint	og_num,
		ORDER *	order,
		ORDER *	group,
		Item *	having,
		ORDER *	proc_param,
		SELECT_LEX *	select,
		SELECT_LEX_UNIT *	unit
	)

Definition at line 309 of file sql_select.cc.

References all_fields, alloc_func_list(), Item::check_cols(), conds, Item::const_during_execution(), count_field_types(), DBUG_ENTER, DBUG_RETURN, base_list::elements, ER, ER_DIFF_GROUPS_PROC, ER_MIX_OF_GROUP_FUNC_AND_FIELDS, ER_ORDER_WITH_PROC, ER_WRONG_SUM_SELECT, err, error, FALSE, fields_list, Item::fix_fields(), Item::fixed, flag, Procedure::flags, group, Procedure::group, group_list, having, hidden_group_fields, join_list, MARK_COLUMNS_READ, my_message(), MYF, st_order::next, Item_sum::next, st_table_list::next_leaf, optimized, OPTION_SETUP_TABLES_DONE, order, Procedure::param_fields, PROC_NO_SORT, proc_param, procedure, Item_sum::ref_by, ref_pointer_array, ref_pointer_array_size, Item_subselect::RES_ERROR, Item_subselect::RES_OK, result, rollup_init(), SELECT_ACL, select_lex, select_options, Item_subselect::select_transformer(), send_group_parts, setup_fields(), setup_ftfuncs(), setup_new_fields(), setup_procedure(), setup_tables_and_check_access(), setup_wild(), setup_without_group(), Item::split_sum_func2(), tables, tables_list, test_if_subpart(), thd, tmp_table_param, TRUE, union_part, unit, and Item::with_sum_func.

Referenced by mysql_select(), and subselect_single_select_engine::prepare().

{
  DBUG_ENTER("JOIN::prepare");

  // to prevent double initialization on EXPLAIN
  if (optimized)
    DBUG_RETURN(0);

  conds= conds_init;
  order= order_init;
  group_list= group_init;
  having= having_init;
  proc_param= proc_param_init;
  tables_list= tables_init;
  select_lex= select_lex_arg;
  select_lex->join= this;
  join_list= &select_lex->top_join_list;
  union_part= (unit_arg->first_select()->next_select() != 0);

  /*
    If we have already executed SELECT, then it have not sense to prevent
    its table from update (see unique_table())
  */
  if (thd->derived_tables_processing)
    select_lex->exclude_from_table_unique_test= TRUE;

  /* Check that all tables, fields, conds and order are ok */

  if ((!(select_options & OPTION_SETUP_TABLES_DONE) &&
       setup_tables_and_check_access(thd, &select_lex->context, join_list,
                                     tables_list,
                                     &select_lex->leaf_tables, FALSE, 
                                     SELECT_ACL)) ||
      setup_wild(thd, tables_list, fields_list, &all_fields, wild_num) ||
      select_lex->setup_ref_array(thd, og_num) ||
      setup_fields(thd, (*rref_pointer_array), fields_list, MARK_COLUMNS_READ,
                   &all_fields, 1) ||
      setup_without_group(thd, (*rref_pointer_array), tables_list,
                          select_lex->leaf_tables, fields_list,
                          all_fields, &conds, order, group_list,
                          &hidden_group_fields))
    DBUG_RETURN(-1);                            /* purecov: inspected */

  ref_pointer_array= *rref_pointer_array;
  
  if (having)
  {
    nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
    thd->where="having clause";
    thd->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
    select_lex->having_fix_field= 1;
    bool having_fix_rc= (!having->fixed &&
                         (having->fix_fields(thd, &having) ||
                          having->check_cols(1)));
    select_lex->having_fix_field= 0;
    if (having_fix_rc || thd->net.report_error)
      DBUG_RETURN(-1);                          /* purecov: inspected */
    thd->lex->allow_sum_func= save_allow_sum_func;
  }

  if (!thd->lex->view_prepare_mode)
  {
    Item_subselect *subselect;
    /* Is it subselect? */
    if ((subselect= select_lex->master_unit()->item))
    {
      Item_subselect::trans_res res;
      if ((res= subselect->select_transformer(this)) !=
          Item_subselect::RES_OK)
      {
        select_lex->fix_prepare_information(thd, &conds);
        DBUG_RETURN((res == Item_subselect::RES_ERROR));
      }
    }
  }

  if (having && having->with_sum_func)
    having->split_sum_func2(thd, ref_pointer_array, all_fields,
                            &having, TRUE);
  if (select_lex->inner_sum_func_list)
  {
    Item_sum *end=select_lex->inner_sum_func_list;
    Item_sum *item_sum= end;  
    do
    { 
      item_sum= item_sum->next;
      item_sum->split_sum_func2(thd, ref_pointer_array,
                                all_fields, item_sum->ref_by, FALSE);
    } while (item_sum != end);
  }

  if (setup_ftfuncs(select_lex)) /* should be after having->fix_fields */
    DBUG_RETURN(-1);
  

  /*
    Check if one one uses a not constant column with group functions
    and no GROUP BY.
    TODO:  Add check of calculation of GROUP functions and fields:
           SELECT COUNT(*)+table.col1 from table1;
  */
  {
    if (!group_list)
    {
      uint flag=0;
      List_iterator_fast<Item> it(fields_list);
      Item *item;
      while ((item= it++))
      {
        if (item->with_sum_func)
          flag|=1;
        else if (!(flag & 2) && !item->const_during_execution())
          flag|=2;
      }
      if (flag == 3)
      {
        my_message(ER_MIX_OF_GROUP_FUNC_AND_FIELDS,
                   ER(ER_MIX_OF_GROUP_FUNC_AND_FIELDS), MYF(0));
        DBUG_RETURN(-1);
      }
    }
    TABLE_LIST *table_ptr;
    for (table_ptr= select_lex->leaf_tables;
         table_ptr;
         table_ptr= table_ptr->next_leaf)
      tables++;
  }
  {
    /* Caclulate the number of groups */
    send_group_parts= 0;
    for (ORDER *group_tmp= group_list ; group_tmp ; group_tmp= group_tmp->next)
      send_group_parts++;
  }
  
  procedure= setup_procedure(thd, proc_param, result, fields_list, &error);
  if (error)
    goto err;                                   /* purecov: inspected */
  if (procedure)
  {
    if (setup_new_fields(thd, fields_list, all_fields,
                         procedure->param_fields))
        goto err;                               /* purecov: inspected */
    if (procedure->group)
    {
      if (!test_if_subpart(procedure->group,group_list))
      {                                         /* purecov: inspected */
        my_message(ER_DIFF_GROUPS_PROC, ER(ER_DIFF_GROUPS_PROC),
                   MYF(0));                     /* purecov: inspected */
        goto err;                               /* purecov: inspected */
      }
    }
    if (order && (procedure->flags & PROC_NO_SORT))
    {                                           /* purecov: inspected */
      my_message(ER_ORDER_WITH_PROC, ER(ER_ORDER_WITH_PROC),
                 MYF(0));                       /* purecov: inspected */
      goto err;                                 /* purecov: inspected */
    }
  }

  /* Init join struct */
  count_field_types(&tmp_table_param, all_fields, 0);
  ref_pointer_array_size= all_fields.elements*sizeof(Item*);
  this->group= group_list != 0;
  unit= unit_arg;

#ifdef RESTRICTED_GROUP
  if (sum_func_count && !group_list && (func_count || field_count))
  {
    my_message(ER_WRONG_SUM_SELECT,ER(ER_WRONG_SUM_SELECT),MYF(0));
    goto err;
  }
#endif
  if (!procedure && result && result->prepare(fields_list, unit_arg))
    goto err;                                   /* purecov: inspected */

  if (select_lex->olap == ROLLUP_TYPE && rollup_init())
    goto err;
  if (alloc_func_list())
    goto err;

  select_lex->fix_prepare_information(thd, &conds);
  DBUG_RETURN(0); // All OK

err:
  delete procedure;                             /* purecov: inspected */
  procedure= 0;
  DBUG_RETURN(-1);                              /* purecov: inspected */
}

Here is the call graph for this function:

Here is the caller graph for this function:

int JOIN::reinit

(

)

Definition at line 1248 of file sql_select.cc.

References DBUG_ENTER, DBUG_RETURN, handler::delete_all_rows(), exec_tmp_table1, exec_tmp_table2, handler::extra(), st_table::file, filesort_free_buffers(), first_record, free_io_cache(), func, HA_EXTRA_RESET_STATE, items0, join_tab, join_tab_save, memcpy, restore_tmp(), select_lex, set_items_ref_array(), sum_funcs, tmp_join, ULL, and unit.

Referenced by subselect_single_select_engine::exec().

{
  DBUG_ENTER("JOIN::reinit");

  unit->offset_limit_cnt= (ha_rows)(select_lex->offset_limit ?
                                    select_lex->offset_limit->val_uint() :
                                    ULL(0));

  first_record= 0;

  if (exec_tmp_table1)
  {
    exec_tmp_table1->file->extra(HA_EXTRA_RESET_STATE);
    exec_tmp_table1->file->delete_all_rows();
    free_io_cache(exec_tmp_table1);
    filesort_free_buffers(exec_tmp_table1);
  }
  if (exec_tmp_table2)
  {
    exec_tmp_table2->file->extra(HA_EXTRA_RESET_STATE);
    exec_tmp_table2->file->delete_all_rows();
    free_io_cache(exec_tmp_table2);
    filesort_free_buffers(exec_tmp_table2);
  }
  if (items0)
    set_items_ref_array(items0);

  if (join_tab_save)
    memcpy(join_tab, join_tab_save, sizeof(JOIN_TAB) * tables);

  if (tmp_join)
    restore_tmp();

  /* Reset of sum functions */
  if (sum_funcs)
  {
    Item_sum *func, **func_ptr= sum_funcs;
    while ((func= *(func_ptr++)))
      func->clear();
  }

  DBUG_RETURN(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void JOIN::restore_tmp

(

)

Definition at line 1241 of file sql_select.cc.

References memcpy, and tmp_join.

Referenced by reinit().

{
  memcpy(tmp_join, this, (size_t) sizeof(JOIN));
}

Here is the caller graph for this function:

bool JOIN::rollup_init

(

)

Definition at line 13831 of file sql_select.cc.

References all_fields, change_group_ref(), base_list::elements, base_list::empty(), FALSE, st_rollup::fields, fields_list, Item::FUNC_ITEM, st_order::item, Item::maybe_null, new(), st_order::next, st_rollup::null_items, List< T >::push_back(), ref_pointer_array_size, st_rollup::ref_pointer_arrays, rollup, send_group_parts, st_rollup::state, st_rollup::STATE_INITED, tmp_table_param, Item::type(), and Item::with_sum_func.

Referenced by prepare().

{
  uint i,j;
  Item **ref_array;

  tmp_table_param.quick_group= 0;       // Can't create groups in tmp table
  rollup.state= ROLLUP::STATE_INITED;

  /*
    Create pointers to the different sum function groups
    These are updated by rollup_make_fields()
  */
  tmp_table_param.group_parts= send_group_parts;

  if (!(rollup.null_items= (Item_null_result**) thd->alloc((sizeof(Item*) +
                                                sizeof(Item**) +
                                                sizeof(List<Item>) +
                                                ref_pointer_array_size)
                                                * send_group_parts )))
    return 1;
  
  rollup.fields= (List<Item>*) (rollup.null_items + send_group_parts);
  rollup.ref_pointer_arrays= (Item***) (rollup.fields + send_group_parts);
  ref_array= (Item**) (rollup.ref_pointer_arrays+send_group_parts);

  /*
    Prepare space for field list for the different levels
    These will be filled up in rollup_make_fields()
  */
  for (i= 0 ; i < send_group_parts ; i++)
  {
    rollup.null_items[i]= new (thd->mem_root) Item_null_result();
    List<Item> *rollup_fields= &rollup.fields[i];
    rollup_fields->empty();
    rollup.ref_pointer_arrays[i]= ref_array;
    ref_array+= all_fields.elements;
  }
  for (i= 0 ; i < send_group_parts; i++)
  {
    for (j=0 ; j < fields_list.elements ; j++)
      rollup.fields[i].push_back(rollup.null_items[i]);
  }
  List_iterator_fast<Item> it(all_fields);
  Item *item;
  while ((item= it++))
  {
    ORDER *group_tmp;
    for (group_tmp= group_list; group_tmp; group_tmp= group_tmp->next)
    {
      if (*group_tmp->item == item)
        item->maybe_null= 1;
    }
    if (item->type() == Item::FUNC_ITEM)
    {
      bool changed= FALSE;
      if (change_group_ref(thd, (Item_func *) item, group_list, &changed))
        return 1;
      /*
        We have to prevent creation of a field in a temporary table for
        an expression that contains GROUP BY attributes.
        Marking the expression item as 'with_sum_func' will ensure this.
      */ 
      if (changed)
        item->with_sum_func= 1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool JOIN::rollup_make_fields	(	List< Item > &	all_fields,
		List< Item > &	fields,
		Item_sum ***	func
	)

Definition at line 13919 of file sql_select.cc.

References Item::const_item(), Item::copy_or_same(), base_list::elements, st_rollup::fields, func, Item::get_tmp_table_field(), List< T >::head(), st_order::item, Item::maybe_null, new(), st_order::next, pos(), st_rollup::ref_pointer_arrays, List_iterator< T >::replace(), List_iterator_fast< T >::rewind(), rollup, send_group_parts, Item::SUM_FUNC_ITEM, sum_funcs_end, and Item::type().

Referenced by make_sum_func_list().

{
  List_iterator_fast<Item> it(fields_arg);
  Item *first_field= sel_fields.head();
  uint level;

  /*
    Create field lists for the different levels

    The idea here is to have a separate field list for each rollup level to
    avoid all runtime checks of which columns should be NULL.

    The list is stored in reverse order to get sum function in such an order
    in func that it makes it easy to reset them with init_sum_functions()

    Assuming:  SELECT a, b, c SUM(b) FROM t1 GROUP BY a,b WITH ROLLUP

    rollup.fields[0] will contain list where a,b,c is NULL
    rollup.fields[1] will contain list where b,c is NULL
    ...
    rollup.ref_pointer_array[#] points to fields for rollup.fields[#]
    ...
    sum_funcs_end[0] points to all sum functions
    sum_funcs_end[1] points to all sum functions, except grand totals
    ...
  */

  for (level=0 ; level < send_group_parts ; level++)
  {
    uint i;
    uint pos= send_group_parts - level -1;
    bool real_fields= 0;
    Item *item;
    List_iterator<Item> new_it(rollup.fields[pos]);
    Item **ref_array_start= rollup.ref_pointer_arrays[pos];
    ORDER *start_group;

    /* Point to first hidden field */
    Item **ref_array= ref_array_start + fields_arg.elements-1;

    /* Remember where the sum functions ends for the previous level */
    sum_funcs_end[pos+1]= *func;

    /* Find the start of the group for this level */
    for (i= 0, start_group= group_list ;
         i++ < pos ;
         start_group= start_group->next)
      ;

    it.rewind();
    while ((item= it++))
    {
      if (item == first_field)
      {
        real_fields= 1;                         // End of hidden fields
        ref_array= ref_array_start;
      }

      if (item->type() == Item::SUM_FUNC_ITEM && !item->const_item())
      {
        /*
          This is a top level summary function that must be replaced with
          a sum function that is reset for this level.

          NOTE: This code creates an object which is not that nice in a
          sub select.  Fortunately it's not common to have rollup in
          sub selects.
        */
        item= item->copy_or_same(thd);
        ((Item_sum*) item)->make_unique();
        *(*func)= (Item_sum*) item;
        (*func)++;
      }
      else 
      {
        /* Check if this is something that is part of this group by */
        ORDER *group_tmp;
        for (group_tmp= start_group, i= pos ;
             group_tmp ; group_tmp= group_tmp->next, i++)
        {
          if (*group_tmp->item == item)
          {
            /*
              This is an element that is used by the GROUP BY and should be
              set to NULL in this level
            */
            Item_null_result *null_item= new (thd->mem_root) Item_null_result();
            if (!null_item)
              return 1;
            item->maybe_null= 1;                // Value will be null sometimes
            null_item->result_field= item->get_tmp_table_field();
            item= null_item;
            break;
          }
        }
      }
      *ref_array= item;
      if (real_fields)
      {
        (void) new_it++;                        // Point to next item
        new_it.replace(item);                   // Replace previous
        ref_array++;
      }
      else
        ref_array--;
    }
  }
  sum_funcs_end[0]= *func;                      // Point to last function
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int JOIN::rollup_send_data

(

uint

idx

)

Definition at line 14049 of file sql_select.cc.

References current_ref_pointer_array, do_send_rows, st_rollup::fields, having, memcpy, ref_pointer_array, ref_pointer_array_size, st_rollup::ref_pointer_arrays, result, rollup, send_group_parts, send_records, set_items_ref_array(), and Item::val_int().

Referenced by end_send_group().

{
  uint i;
  for (i= send_group_parts ; i-- > idx ; )
  {
    /* Get reference pointers to sum functions in place */
    memcpy((char*) ref_pointer_array,
           (char*) rollup.ref_pointer_arrays[i],
           ref_pointer_array_size);
    if ((!having || having->val_int()))
    {
      if (send_records < unit->select_limit_cnt && do_send_rows &&
          result->send_data(rollup.fields[i]))
        return 1;
      send_records++;
    }
  }
  /* Restore ref_pointer_array */
  set_items_ref_array(current_ref_pointer_array);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int JOIN::rollup_write_data	(	uint	idx,
		TABLE *	table
	)

Definition at line 14090 of file sql_select.cc.

References copy_sum_funcs(), create_myisam_from_heap(), current_ref_pointer_array, st_rollup::fields, st_table::file, having, Item::is_result_field(), memcpy, Item::NULL_ITEM, st_table::record, ref_pointer_array, ref_pointer_array_size, st_rollup::ref_pointer_arrays, rollup, Item::save_in_result_field(), send_group_parts, set_items_ref_array(), sum_funcs_end, table, tmp_table_param, Item::type(), Item::val_int(), and handler::write_row().

Referenced by end_write_group().

{
  uint i;
  for (i= send_group_parts ; i-- > idx ; )
  {
    /* Get reference pointers to sum functions in place */
    memcpy((char*) ref_pointer_array,
           (char*) rollup.ref_pointer_arrays[i],
           ref_pointer_array_size);
    if ((!having || having->val_int()))
    {
      int error;
      Item *item;
      List_iterator_fast<Item> it(rollup.fields[i]);
      while ((item= it++))
      {
        if (item->type() == Item::NULL_ITEM && item->is_result_field())
          item->save_in_result_field(1);
      }
      copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
      if ((error= table->file->write_row(table->record[0])))
      {
        if (create_myisam_from_heap(thd, table, &tmp_table_param,
                                      error, 0))
          return 1;                  
      }
    }
  }
  /* Restore ref_pointer_array */
  set_items_ref_array(current_ref_pointer_array);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool JOIN::save_join_tab

(

)

Definition at line 1294 of file sql_select.cc.

References join_tab, join_tab_save, and select_lex.

Referenced by exec().

{
  if (!join_tab_save && select_lex->master_unit()->uncacheable)
  {
    if (!(join_tab_save= (JOIN_TAB*)thd->memdup((gptr) join_tab,
                                                sizeof(JOIN_TAB) * tables)))
      return 1;
  }
  return 0;
}

Here is the caller graph for this function:

bool JOIN::send_row_on_empty_set

(

)

[inline]

Definition at line 410 of file sql_select.h.

References do_send_rows, group_list, and tmp_table_param.

Referenced by do_select(), and exec().

  {
    return (do_send_rows && tmp_table_param.sum_func_count != 0 &&
            !group_list);
  }

Here is the caller graph for this function:

void JOIN::set_items_ref_array

(

Item **

ptr

)

[inline]

Definition at line 381 of file sql_select.h.

References current_ref_pointer_array, memcpy, ref_pointer_array, and ref_pointer_array_size.

Referenced by exec(), reinit(), rollup_send_data(), and rollup_write_data().

  {
    memcpy((char*) ref_pointer_array, (char*) ptr, ref_pointer_array_size);
    current_ref_pointer_array= ptr;
  }

Here is the caller graph for this function:

bool JOIN::test_in_subselect

(

Item **

where

)

Definition at line 517 of file sql_select.cc.

References Item_func::COND_AND_FUNC, Item::COND_ITEM, conds, Item_func::EQ_FUNC, Item::FIELD_ITEM, Item::FUNC_ITEM, st_join_table::info, join_tab, Item::REF_ITEM, remove_additional_cond(), Item::type(), and where.

{
  if (conds->type() == Item::FUNC_ITEM &&
      ((Item_func *)this->conds)->functype() == Item_func::EQ_FUNC &&
      ((Item_func *)conds)->arguments()[0]->type() == Item::REF_ITEM &&
      ((Item_func *)conds)->arguments()[1]->type() == Item::FIELD_ITEM)
  {
    join_tab->info= "Using index";
    *where= 0;
    return 1;
  }
  if (conds->type() == Item::COND_ITEM &&
      ((class Item_func *)this->conds)->functype() ==
      Item_func::COND_AND_FUNC)
  {
    if ((*where= remove_additional_cond(conds)))
      join_tab->info= "Using index; Using where";
    else
      join_tab->info= "Using index";
    return 1;
  }
  return 0;
}

Here is the call graph for this function:

---

Member Data Documentation

List<Item> JOIN::all_fields

Definition at line 284 of file sql_select.h.

Referenced by exec(), get_best_group_min_max(), init(), init_items_ref_array(), optimize(), prepare(), rollup_init(), and Item_in_subselect::single_value_transformer().

TABLE ** JOIN::all_tables

Definition at line 209 of file sql_select.h.

Referenced by optimize_keyuse().

POSITION JOIN::best_positions[MAX_TABLES+1]

Definition at line 231 of file sql_select.h.

Referenced by find_best(), get_best_combination(), greedy_search(), optimize_straight_join(), print_plan(), and select_describe().

double JOIN::best_read

Definition at line 239 of file sql_select.h.

Referenced by choose_plan(), find_best(), greedy_search(), optimize(), optimize_straight_join(), and print_plan().

JOIN_TAB ** JOIN::best_ref

Definition at line 206 of file sql_select.h.

Referenced by best_extension_by_limited_search(), cache_record_length(), choose_plan(), find_best(), greedy_search(), make_join_statistics(), optimize_straight_join(), print_plan(), and set_position().

COND_EQUAL* JOIN::cond_equal

Definition at line 298 of file sql_select.h.

Referenced by destroy(), init(), optimize(), and optimize_cond().

Item::cond_result JOIN::cond_value

Definition at line 283 of file sql_select.h.

Referenced by exec(), and optimize().

COND* JOIN::conds

Definition at line 294 of file sql_select.h.

Referenced by do_select(), exec(), get_best_group_min_max(), join_read_const_table(), mysql_select(), optimize(), prepare(), Item_in_subselect::row_value_transformer(), Item_singlerow_subselect::select_transformer(), Item_in_subselect::single_value_transformer(), and test_in_subselect().

Item* JOIN::conds_history

Definition at line 295 of file sql_select.h.

Referenced by mysql_select().

table_map JOIN::const_table_map

Definition at line 219 of file sql_select.h.

Referenced by best_access_path(), create_ref_for_key(), exec(), make_simple_join(), optimize(), optimize_keyuse(), remove_const(), and test_if_skip_sort_order().

uint JOIN::const_tables

Definition at line 210 of file sql_select.h.

Referenced by add_not_null_conds(), best_access_path(), cache_record_length(), choose_plan(), clear_tables(), create_sort_index(), determine_search_depth(), do_select(), exec(), Sensitive_cursor::fetch(), find_best(), get_best_combination(), greedy_search(), init(), make_join_readinfo(), make_outerjoin_info(), make_simple_join(), Sensitive_cursor::open(), optimize(), optimize_straight_join(), and remove_const().

nested_join_map JOIN::cur_embedding_map

Definition at line 237 of file sql_select.h.

Referenced by check_interleaving_with_nj(), choose_plan(), and restore_prev_nj_state().

Item ** JOIN::current_ref_pointer_array

Definition at line 303 of file sql_select.h.

Referenced by init_items_ref_array(), rollup_send_data(), rollup_write_data(), and set_items_ref_array().

bool JOIN::do_send_rows

Definition at line 213 of file sql_select.h.

Referenced by end_send(), end_send_group(), end_write(), exec(), init(), make_simple_join(), optimize(), rollup_send_data(), and send_row_on_empty_set().

int JOIN::error

Definition at line 291 of file sql_select.h.

Referenced by destroy(), exec(), subselect_single_select_engine::exec(), get_schema_tables_result(), init(), mysql_select(), optimize(), prepare(), and select_describe().

ha_rows JOIN::examined_rows

Definition at line 220 of file sql_select.h.

Referenced by create_sort_index(), evaluate_join_record(), and init().

TABLE* JOIN::exec_tmp_table1

Definition at line 244 of file sql_select.h.

Referenced by destroy(), exec(), init(), and reinit().

TABLE * JOIN::exec_tmp_table2

Definition at line 244 of file sql_select.h.

Referenced by destroy(), exec(), init(), and reinit().

ha_rows JOIN::fetch_limit

Definition at line 230 of file sql_select.h.

Referenced by end_send(), end_send_group(), Sensitive_cursor::fetch(), init(), and Sensitive_cursor::open().

List<Item>* JOIN::fields

Definition at line 240 of file sql_select.h.

Referenced by do_select(), end_send(), end_send_group(), and Sensitive_cursor::open().

List<Item>& JOIN::fields_list

Definition at line 289 of file sql_select.h.

Referenced by add_group_and_distinct_keys(), alloc_func_list(), change_result(), exec(), get_best_group_min_max(), init(), prepare(), and rollup_init().

bool JOIN::first_record

Definition at line 212 of file sql_select.h.

Referenced by end_send_group(), end_write_group(), init(), make_simple_join(), and reinit().

table_map JOIN::found_const_table_map

Definition at line 219 of file sql_select.h.

Referenced by optimize().

ha_rows JOIN::found_records

Definition at line 220 of file sql_select.h.

Referenced by end_update(), end_write(), evaluate_join_record(), and init().

bool JOIN::full_join

Definition at line 212 of file sql_select.h.

Referenced by get_best_combination().

bool JOIN::group

Definition at line 212 of file sql_select.h.

Referenced by calc_group_buffer(), end_send_group(), end_write_group(), exec(), make_simple_join(), and prepare().

List<Cached_item> JOIN::group_fields

Definition at line 241 of file sql_select.h.

Referenced by alloc_group_fields(), cleanup(), end_send_group(), end_write_group(), and make_group_fields().

List<Cached_item> JOIN::group_fields_cache

Definition at line 241 of file sql_select.h.

Referenced by make_group_fields().

ORDER * JOIN::group_list

Definition at line 293 of file sql_select.h.

Referenced by add_group_and_distinct_keys(), exec(), get_best_group_min_max(), make_group_fields(), optimize(), prepare(), and send_row_on_empty_set().

Item* JOIN::having

Definition at line 250 of file sql_select.h.

Referenced by end_send(), end_send_group(), end_write(), end_write_group(), exec(), init(), mysql_select(), optimize(), prepare(), rollup_send_data(), rollup_write_data(), Item_in_subselect::row_value_transformer(), Item_singlerow_subselect::select_transformer(), and Item_in_subselect::single_value_transformer().

Item* JOIN::having_history

Definition at line 252 of file sql_select.h.

Referenced by init(), and mysql_select().

bool JOIN::hidden_group_fields

Definition at line 281 of file sql_select.h.

Referenced by init(), and prepare().

Item** JOIN::items0

Definition at line 303 of file sql_select.h.

Referenced by exec(), init(), init_items_ref_array(), and reinit().

Item ** JOIN::items1

Definition at line 303 of file sql_select.h.

Referenced by exec(), and init().

Item ** JOIN::items2

Definition at line 303 of file sql_select.h.

Referenced by exec(), and init().

Item ** JOIN::items3

Definition at line 303 of file sql_select.h.

Referenced by exec(), and init().

List<TABLE_LIST>* JOIN::join_list

Definition at line 297 of file sql_select.h.

Referenced by choose_plan(), init(), optimize(), prepare(), and update_ref_and_keys().

JOIN_TAB* JOIN::join_tab

Definition at line 206 of file sql_select.h.

Referenced by add_not_null_conds(), cleanup(), create_sort_index(), destroy(), do_select(), end_send(), end_update(), error_if_full_join(), exec(), Sensitive_cursor::fetch(), flush_cached_records(), get_best_combination(), get_schema_tables_result(), init(), make_join_readinfo(), make_outerjoin_info(), make_simple_join(), Sensitive_cursor::open(), optimize(), reinit(), remove_const(), save_join_tab(), select_describe(), test_in_subselect(), TEST_join(), and update_depend_map().

JOIN_TAB* JOIN::join_tab_save

Definition at line 208 of file sql_select.h.

Referenced by init(), reinit(), and save_join_tab().

DYNAMIC_ARRAY JOIN::keyuse

Definition at line 282 of file sql_select.h.

Referenced by destroy(), init(), and optimize().

MYSQL_LOCK* JOIN::lock

Definition at line 256 of file sql_select.h.

Referenced by init(), and join_free().

JOIN_TAB** JOIN::map2table

Definition at line 207 of file sql_select.h.

Referenced by get_best_combination(), only_eq_ref_tables(), optimize(), and update_depend_map().

bool JOIN::need_tmp

Definition at line 281 of file sql_select.h.

Referenced by init().

bool JOIN::no_field_update

Definition at line 212 of file sql_select.h.

bool JOIN::no_order

Definition at line 277 of file sql_select.h.

Referenced by exec(), and init().

bool JOIN::optimized

Definition at line 308 of file sql_select.h.

Referenced by init(), optimize(), and prepare().

ORDER* JOIN::order

Definition at line 293 of file sql_select.h.

Referenced by exec(), make_join_readinfo(), optimize(), and prepare().

table_map JOIN::outer_join

Definition at line 219 of file sql_select.h.

Referenced by best_access_path(), and optimize().

POSITION JOIN::positions[MAX_TABLES+1]

Definition at line 231 of file sql_select.h.

Referenced by best_access_path(), best_extension_by_limited_search(), find_best(), greedy_search(), optimize_straight_join(), prev_record_reads(), print_plan(), and set_position().

ORDER * JOIN::proc_param

Definition at line 293 of file sql_select.h.

Referenced by prepare().

Procedure* JOIN::procedure

Definition at line 249 of file sql_select.h.

Referenced by change_result(), destroy(), do_select(), end_send(), end_send_group(), end_write_group(), exec(), init(), prepare(), and setup_end_select_func().

List<Item> JOIN::procedure_fields_list

Definition at line 290 of file sql_select.h.

Referenced by do_select(), end_send(), and exec().

Item** JOIN::ref_pointer_array

Definition at line 301 of file sql_select.h.

Referenced by exec(), init(), init_items_ref_array(), prepare(), rollup_send_data(), rollup_write_data(), and set_items_ref_array().

uint JOIN::ref_pointer_array_size

Definition at line 304 of file sql_select.h.

Referenced by init(), init_items_ref_array(), prepare(), rollup_init(), rollup_send_data(), rollup_write_data(), and set_items_ref_array().

select_result* JOIN::result

Definition at line 254 of file sql_select.h.

Referenced by change_result(), do_select(), end_send(), end_send_group(), exec(), init(), optimize(), prepare(), rollup_send_data(), and select_describe().

bool JOIN::resume_nested_loop

Definition at line 218 of file sql_select.h.

Referenced by Sensitive_cursor::fetch(), init(), and sub_select().

JOIN_TAB* JOIN::return_tab

Definition at line 300 of file sql_select.h.

Referenced by evaluate_join_record(), evaluate_null_complemented_join_record(), init(), and sub_select().

ROLLUP JOIN::rollup

Definition at line 263 of file sql_select.h.

Referenced by alloc_func_list(), end_send_group(), end_write_group(), init(), make_sum_func_list(), rollup_init(), rollup_make_fields(), rollup_send_data(), and rollup_write_data().

ha_rows JOIN::row_limit

Definition at line 220 of file sql_select.h.

Referenced by make_simple_join(), and optimize().

SQL_SELECT* JOIN::select

Definition at line 299 of file sql_select.h.

Referenced by destroy(), init(), and optimize().

bool JOIN::select_distinct

Definition at line 265 of file sql_select.h.

Referenced by add_group_and_distinct_keys(), exec(), get_best_group_min_max(), init(), and optimize().

SELECT_LEX* JOIN::select_lex

Definition at line 260 of file sql_select.h.

Referenced by change_result(), create_sort_index(), destroy(), exec(), init(), is_top_level_join(), join_free(), join_read_const_table(), optimize(), prepare(), reinit(), Item_in_subselect::row_value_transformer(), save_join_tab(), select_describe(), Item_singlerow_subselect::select_transformer(), and Item_in_subselect::single_value_transformer().

ha_rows JOIN::select_limit

Definition at line 220 of file sql_select.h.

Referenced by exec(), make_join_readinfo(), and optimize().

ulonglong JOIN::select_options

Definition at line 253 of file sql_select.h.

Referenced by choose_plan(), create_ref_for_key(), end_send(), end_send_group(), end_write(), exec(), find_best(), init(), join_free(), make_join_readinfo(), mysql_select(), optimize(), prepare(), remove_duplicates(), and test_if_skip_sort_order().

uint JOIN::send_group_parts

Definition at line 211 of file sql_select.h.

Referenced by alloc_func_list(), end_send(), end_send_group(), end_write_group(), make_sum_func_list(), prepare(), rollup_init(), rollup_make_fields(), rollup_send_data(), and rollup_write_data().

ha_rows JOIN::send_records

Definition at line 220 of file sql_select.h.

Referenced by do_select(), end_send(), end_send_group(), end_unique_update(), end_update(), end_write(), exec(), init(), make_simple_join(), Sensitive_cursor::open(), and rollup_send_data().

bool JOIN::simple_group

Definition at line 272 of file sql_select.h.

Referenced by exec(), and init().

bool JOIN::simple_order

Definition at line 272 of file sql_select.h.

Referenced by exec(), and init().

bool JOIN::skip_sort_order

Definition at line 279 of file sql_select.h.

Referenced by exec(), init(), and make_join_readinfo().

bool JOIN::sort_and_group

Definition at line 212 of file sql_select.h.

Referenced by alloc_group_fields(), end_send(), exec(), init(), make_group_fields(), make_simple_join(), and setup_end_select_func().

TABLE * JOIN::sort_by_table

Definition at line 209 of file sql_select.h.

Referenced by best_access_path(), find_best(), make_join_readinfo(), optimize(), and optimize_straight_join().

Item_sum** JOIN::sum_funcs

Definition at line 246 of file sql_select.h.

Referenced by alloc_func_list(), clear(), end_send_group(), end_unique_update(), end_update(), end_write_group(), exec(), get_best_group_min_max(), init(), QUICK_GROUP_MIN_MAX_SELECT::init(), make_sum_func_list(), reinit(), and setup_end_select_func().

Item_sum** JOIN::sum_funcs2

Definition at line 248 of file sql_select.h.

Referenced by exec(), and init().

Item_sum *** JOIN::sum_funcs_end

Definition at line 246 of file sql_select.h.

Referenced by alloc_func_list(), end_send_group(), end_write_group(), exec(), make_sum_func_list(), rollup_make_fields(), and rollup_write_data().

Item_sum *** JOIN::sum_funcs_end2

Definition at line 248 of file sql_select.h.

Referenced by exec().

TABLE** JOIN::table

Definition at line 209 of file sql_select.h.

Referenced by clear_tables(), get_best_combination(), init(), make_simple_join(), optimize(), and rollup_write_data().

uint JOIN::tables

Definition at line 210 of file sql_select.h.

Referenced by choose_plan(), create_sort_index(), determine_search_depth(), do_select(), end_send(), end_update(), error_if_full_join(), exec(), get_best_combination(), get_best_group_min_max(), get_schema_tables_result(), get_sweep_read_cost(), greedy_search(), init(), make_join_readinfo(), make_join_statistics(), make_simple_join(), Sensitive_cursor::open(), optimize(), prepare(), remove_const(), select_describe(), sub_select(), TEST_join(), and update_depend_map().

TABLE_LIST* JOIN::tables_list

Definition at line 296 of file sql_select.h.

Referenced by exec(), optimize(), and prepare().

THD* JOIN::thd

Definition at line 245 of file sql_select.h.

Referenced by add_not_null_conds(), alloc_group_fields(), best_extension_by_limited_search(), cache_record_length(), calc_group_buffer(), choose_plan(), Sensitive_cursor::close(), cmp_buffer_with_ref(), create_ref_for_key(), do_select(), end_unique_update(), end_update(), end_write(), end_write_group(), evaluate_join_record(), exec(), Sensitive_cursor::fetch(), find_best(), flush_cached_records(), get_best_combination(), get_schema_tables_result(), init(), is_top_level_join(), join_ft_read_first(), join_init_read_record(), join_read_always_key(), join_read_const(), join_read_last_key(), make_join_readinfo(), make_join_select(), make_join_statistics(), make_simple_join(), Sensitive_cursor::open(), optimize(), optimize_cond(), optimize_straight_join(), prepare(), QUICK_GROUP_MIN_MAX_SELECT::QUICK_GROUP_MIN_MAX_SELECT(), remove_duplicates(), return_zero_rows(), select_describe(), simplify_joins(), sub_select(), sub_select_cache(), test_if_quick_select(), and test_if_skip_sort_order().

List<Item> JOIN::tmp_all_fields1

Definition at line 286 of file sql_select.h.

Referenced by exec().

List<Item> JOIN::tmp_all_fields2

Definition at line 286 of file sql_select.h.

Referenced by exec().

List<Item> JOIN::tmp_all_fields3

Definition at line 286 of file sql_select.h.

Referenced by exec().

List<Item> JOIN::tmp_fields_list1

Definition at line 288 of file sql_select.h.

Referenced by exec().

List<Item> JOIN::tmp_fields_list2

Definition at line 288 of file sql_select.h.

Referenced by exec().

List<Item> JOIN::tmp_fields_list3

Definition at line 288 of file sql_select.h.

Referenced by exec().

Item* JOIN::tmp_having

Definition at line 251 of file sql_select.h.

Referenced by exec(), init(), and mysql_select().

JOIN* JOIN::tmp_join

Definition at line 262 of file sql_select.h.

Referenced by cleanup(), destroy(), exec(), init(), reinit(), and restore_tmp().

TABLE* JOIN::tmp_table

Definition at line 242 of file sql_select.h.

Referenced by do_select(), end_send(), end_unique_update(), end_update(), end_write(), end_write_group(), Sensitive_cursor::open(), and setup_end_select_func().

TMP_TABLE_PARAM JOIN::tmp_table_param

Definition at line 255 of file sql_select.h.

Referenced by alloc_func_list(), calc_group_buffer(), cleanup(), clear(), destroy(), do_select(), end_send_group(), end_unique_update(), end_update(), end_write(), end_write_group(), exec(), QUICK_GROUP_MIN_MAX_SELECT::get_next(), init(), make_simple_join(), optimize(), prepare(), rollup_init(), rollup_write_data(), send_row_on_empty_set(), setup_end_select_func(), and Item_in_subselect::single_value_transformer().

bool JOIN::union_part

Definition at line 307 of file sql_select.h.

Referenced by prepare().

SELECT_LEX_UNIT* JOIN::unit

Definition at line 258 of file sql_select.h.

Referenced by best_access_path(), end_send(), end_send_group(), end_write(), exec(), is_top_level_join(), join_free(), make_simple_join(), Sensitive_cursor::open(), optimize(), prepare(), reinit(), remove_duplicates(), select_describe(), and test_if_skip_sort_order().

const char* JOIN::zero_result_cause

Definition at line 305 of file sql_select.h.

Referenced by exec(), init(), and optimize().

---

The documentation for this class was generated from the following files:

• mysql/src/5.1-dbg/sql/sql_select.h
• mysql/src/5.1-dbg/sql/sql_select.cc

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.