bug: move one_storage_engine checking loop

down to the point where all tables are already known (and subqueries converted to joins, if needed)

Author: vuvova

sql/sql_select.cc

@@ -759,12 +759,6 @@ JOIN::prepare(Item ***rref_pointer_array,
 
  TABLE_LIST *tbl;
  List_iterator_fast<TABLE_LIST> li(select_lex->leaf_tables);
- /*
- If all tables comes from the same storage engine, one_storage_engine will
- be set to point to the handlerton of this engine.
- */
- one_storage_engine= 0;
- uint table_loop_count= 0;
  while ((tbl= li++))
  {
  /*
@@ -776,17 +770,8 @@ JOIN::prepare(Item ***rref_pointer_array,
  Note: this loop doesn't touch tables inside merged semi-joins, because
  subquery-to-semijoin conversion has not been done yet. This is intended.
  */
- if (tbl->table)
- {
- if (mixed_implicit_grouping)
- tbl->table->maybe_null= 1;
- if (!table_loop_count++)
- one_storage_engine= tbl->table->file->ht;
- else if (one_storage_engine != tbl->table->file->ht)
- one_storage_engine= 0;
- }
- else
- one_storage_engine= 0;
+ if (mixed_implicit_grouping && tbl->table)
+ tbl->table->maybe_null= 1;
  }
 
  if ((wild_num && setup_wild(thd, tables_list, fields_list, &all_fields,
@@ -1914,92 +1899,106 @@ JOIN::optimize_inner()
  group by handler to evaluate the group by
  */
 
- if ((tmp_table_param.sum_func_count || group_list) && !procedure &&
- (one_storage_engine && one_storage_engine->create_group_by))
+ if ((tmp_table_param.sum_func_count || group_list) && !procedure)
  {
- /* Check if the storage engine can intercept the query */
- group_by_handler *gbh= one_storage_engine->create_group_by(thd, &all_fields,
- tables_list, group_list, order, conds, having);
- if (gbh)
+ /*
+ At the moment we only support push down for queries where
+ all tables are in the same storage engine
+ */
+ TABLE_LIST *tbl= tables_list;
+ handlerton *ht= tbl && tbl->table ? tbl->table->file->ht : 0;
+ for (tbl= tbl->next_local; ht && tbl; tbl= tbl->next_local)
  {
- pushdown_query= new (thd->mem_root) Pushdown_query(select_lex, gbh);
- uint handler_flags= gbh->flags();
-  int err;
+ if (!tbl->table || tbl->table->file->ht != ht)
+  ht= 0;
+ }
 
- /*
- We must store rows in the tmp table if we need to do an ORDER BY
- or DISTINCT and the storage handler can't handle it.
- */
- need_tmp= ((!(handler_flags & GROUP_BY_ORDER_BY) &&
- (order || group_list)) ||
- (!(handler_flags & GROUP_BY_DISTINCT) && select_distinct));
- 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,
- 0, handler_flags & GROUP_BY_DISTINCT ?
- 0 : select_distinct, 1,
- select_options, HA_POS_ERROR, "",
- !need_tmp,
- (!order ||
- (handler_flags & GROUP_BY_ORDER_BY)))))
- DBUG_RETURN(1);
+ if (ht && ht->create_group_by)
+ {
+ /* Check if the storage engine can intercept the query */
+ group_by_handler *gbh= ht->create_group_by(thd, &all_fields,
+ tables_list, group_list, order, conds, having);
+ if (gbh)
+ {
+ pushdown_query= new (thd->mem_root) Pushdown_query(select_lex, gbh);
+ uint handler_flags= gbh->flags();
+ int err;
 
- /*
- Setup reference fields, used by summary functions and group by fields,
- to point to the temporary table.
- The actual switching to the temporary tables fields for HAVING
- and ORDER BY is done in do_select() by calling
- set_items_ref_array(items1).
- */
- init_items_ref_array();
- items1= items0 + all_fields.elements;
- if (change_to_use_tmp_fields(thd, items1,
- tmp_fields_list1, tmp_all_fields1,
- fields_list.elements, all_fields))
- DBUG_RETURN(1);
+ /*
+ We must store rows in the tmp table if we need to do an ORDER BY
+ or DISTINCT and the storage handler can't handle it.
+ */
+ need_tmp= ((!(handler_flags & GROUP_BY_ORDER_BY) &&
+ (order || group_list)) ||
+ (!(handler_flags & GROUP_BY_DISTINCT) && select_distinct));
+ 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, 0,
+ handler_flags & GROUP_BY_DISTINCT ?
+ 0 : select_distinct, 1,
+ select_options, HA_POS_ERROR, "",
+ !need_tmp,
+ (!order ||
+ (handler_flags & GROUP_BY_ORDER_BY)))))
+ DBUG_RETURN(1);
 
- /* Give storage engine access to temporary table */
- if ((err= gbh->ha_init(exec_tmp_table1, having, order)))
- {
- gbh->print_error(err, MYF(0));
- DBUG_RETURN(1);
+ /*
+ Setup reference fields, used by summary functions and group by fields,
+ to point to the temporary table.
+ The actual switching to the temporary tables fields for HAVING
+ and ORDER BY is done in do_select() by calling
+ set_items_ref_array(items1).
+ */
+ init_items_ref_array();
+ items1= items0 + all_fields.elements;
+ if (change_to_use_tmp_fields(thd, items1,
+ tmp_fields_list1, tmp_all_fields1,
+ fields_list.elements, all_fields))
+ DBUG_RETURN(1);
+
+ /* Give storage engine access to temporary table */
+ if ((err= gbh->ha_init(exec_tmp_table1, having, order)))
+ {
+ gbh->print_error(err, MYF(0));
+ DBUG_RETURN(1);
+ }
+ pushdown_query->store_data_in_temp_table= need_tmp;
+ pushdown_query->having= having;
+ /*
+ If no ORDER BY clause was specified explicitly, we should sort things
+ according to the group_by
+ */
+ if (!order)
+ order= group_list;
+ /*
+ Group by and having is calculated by the group_by handler.
+ Reset the group by and having
+ */
+ group= 0; group_list= 0;
+ having= tmp_having= 0;
+ /*
+ Select distinct is handled by handler or by creating an unique index
+ over all fields in the temporary table
+ */
+ select_distinct= 0;
+ if (handler_flags & GROUP_BY_ORDER_BY)
+ order= 0;
+ tmp_table_param.field_count+= tmp_table_param.sum_func_count;
+ tmp_table_param.sum_func_count= 0;
+
+ /* Remember information about the original join */
+ original_join_tab= join_tab;
+ original_table_count= table_count;
+
+ /* Set up one join tab to get sorting to work */
+ const_tables= 0;
+ table_count= 1;
+ join_tab= (JOIN_TAB*) thd->calloc(sizeof(JOIN_TAB));
+ join_tab[0].table= exec_tmp_table1;
+
+ DBUG_RETURN(thd->is_fatal_error);
  }
- pushdown_query->store_data_in_temp_table= need_tmp;
- pushdown_query->having= having;
- /*
- If no ORDER BY clause was specified explicitly, we should sort things
- according to the group_by
- */
- if (!order)
- order= group_list;
- /*
- Group by and having is calculated by the group_by handler.
- Reset the group by and having
- */
- group= 0; group_list= 0;
- having= tmp_having= 0;
- /*
- Select distinct is handled by handler or by creating an unique index
- over all fields in the temporary table
- */
- select_distinct= 0;
- if (handler_flags & GROUP_BY_ORDER_BY)
- order= 0;
- tmp_table_param.field_count+= tmp_table_param.sum_func_count;
- tmp_table_param.sum_func_count= 0;
-
- /* Remember information about the original join */
- original_join_tab= join_tab;
- original_table_count= table_count;
-
- /* Set up one join tab to get sorting to work */
- const_tables= 0;
- table_count= 1;
- join_tab= (JOIN_TAB*) thd->calloc(sizeof(JOIN_TAB));
- join_tab[0].table= exec_tmp_table1;
-
- DBUG_RETURN(thd->is_fatal_error);
  }
  }
 

sql/sql_select.h

@@ -1087,8 +1087,6 @@ class JOIN :public Sql_alloc
  /* Finally picked QEP. This is result of join optimization */
  POSITION *best_positions;
 
- /* points to a storage engine if all tables comes from the storage engine */
- handlerton *one_storage_engine;
  Pushdown_query *pushdown_query;
  JOIN_TAB *original_join_tab;
  uint original_table_count;
@@ -1391,7 +1389,6 @@ class JOIN :public Sql_alloc
  group_optimized_away= 0;
  no_rows_in_result_called= 0;
  positions= best_positions= 0;
- one_storage_engine= 0;
  pushdown_query= 0;
  original_join_tab= 0;
  do_select_call_count= 0;