From 1f8bdbe4eb61b15996b5a9a25c75a905487c083f Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 22 Mar 2007 14:48:03 -0700 Subject: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Ensured correct setting of the depended_from field in references generated for set functions aggregated in outer selects. A wrong value of this field resulted in wrong maps returned by used_tables() for these references. Made sure that a temporary table field is added for any set function aggregated in outer context when creation of a temporary table is needed to execute the inner subquery. mysql-test/r/subselect.result: Added a test case for bug #27229. mysql-test/t/subselect.test: Added a test case for bug #27229. sql/item.cc: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Ensured correct setting of the depended_from field in references generated for set functions aggregated in outer selects. sql/item_sum.cc: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Added the field aggr_sel to the objects of the class Item_sum. In any Item_sum object created for a set function this field has to contain a pointer to the select where the set function is aggregated. sql/item_sum.h: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Added the field aggr_sel to the objects of the class Item_sum. In any Item_sum object created for a set function this field has to contain a pointer to the select where the set function is aggregated. Added a method that says whether a set function is aggregated in outer context and, if so, returns the aggregating select. Removed the field nest_level_tables_count introduced by the patch for bug 24484 as aggr_sel->join->tables contains the sane number. sql/sql_base.cc: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Added the field aggr_sel to the objects of the class Item_sum. Removed changes introduced by the patch for bug 24484 as the field leaf_count of the THD class is not used anymore. sql/sql_class.h: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Added the field aggr_sel to the objects of the class Item_sum. Removed changes introduce by the patch for bug 24484 as the field leaf_count of the THD class is not used anymore. sql/sql_insert.cc: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. Added the field aggr_sel to the objects of the class Item_sum. Removed changes introduce by the patch for bug 24484 as the field leaf_count of the THD class is not used anymore. sql/sql_select.cc: Fixed bug #27229: crash when a set function aggregated in outer context was used as an argument of GROUP_CONCAT. When creating a temporary table a field is added in it for any set function aggregated in outer context. --- sql/item_sum.cc | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) (limited to 'sql/item_sum.cc') diff --git a/sql/item_sum.cc b/sql/item_sum.cc index fcebc89c6e9..03a1c32456a 100644 --- a/sql/item_sum.cc +++ b/sql/item_sum.cc @@ -61,9 +61,9 @@ bool Item_sum::init_sum_func_check(THD *thd) /* Save a pointer to object to be used in items for nested set functions */ thd->lex->in_sum_func= this; nest_level= thd->lex->current_select->nest_level; - nest_level_tables_count= thd->lex->current_select->join->tables; ref_by= 0; aggr_level= -1; + aggr_sel= NULL; max_arg_level= -1; max_sum_func_level= -1; return FALSE; @@ -151,7 +151,10 @@ bool Item_sum::check_sum_func(THD *thd, Item **ref) invalid= aggr_level < 0 && !(allow_sum_func & (1 << nest_level)); } if (!invalid && aggr_level < 0) + { aggr_level= nest_level; + aggr_sel= thd->lex->current_select; + } /* By this moment we either found a subquery where the set function is to be aggregated and assigned a value that is >= 0 to aggr_level, @@ -212,7 +215,6 @@ bool Item_sum::check_sum_func(THD *thd, Item **ref) bool Item_sum::register_sum_func(THD *thd, Item **ref) { SELECT_LEX *sl; - SELECT_LEX *aggr_sl= NULL; nesting_map allow_sum_func= thd->lex->allow_sum_func; for (sl= thd->lex->current_select->master_unit()->outer_select() ; sl && sl->nest_level > max_arg_level; @@ -222,7 +224,7 @@ bool Item_sum::register_sum_func(THD *thd, Item **ref) { /* Found the most nested subquery where the function can be aggregated */ aggr_level= sl->nest_level; - aggr_sl= sl; + aggr_sel= sl; } } if (sl && (allow_sum_func & (1 << sl->nest_level))) @@ -233,21 +235,22 @@ bool Item_sum::register_sum_func(THD *thd, Item **ref) The set function will be aggregated in this subquery. */ aggr_level= sl->nest_level; - aggr_sl= sl; + aggr_sel= sl; + } if (aggr_level >= 0) { ref_by= ref; - /* Add the object to the list of registered objects assigned to aggr_sl */ - if (!aggr_sl->inner_sum_func_list) + /* Add the object to the list of registered objects assigned to aggr_sel */ + if (!aggr_sel->inner_sum_func_list) next= this; else { - next= aggr_sl->inner_sum_func_list->next; - aggr_sl->inner_sum_func_list->next= this; + next= aggr_sel->inner_sum_func_list->next; + aggr_sel->inner_sum_func_list->next= this; } - aggr_sl->inner_sum_func_list= this; - aggr_sl->with_sum_func= 1; + aggr_sel->inner_sum_func_list= this; + aggr_sel->with_sum_func= 1; /* Mark Item_subselect(s) as containing aggregate function all the way up @@ -265,11 +268,11 @@ bool Item_sum::register_sum_func(THD *thd, Item **ref) has aggregate functions directly referenced (i.e. not through a sub-select). */ for (sl= thd->lex->current_select; - sl && sl != aggr_sl && sl->master_unit()->item; + sl && sl != aggr_sel && sl->master_unit()->item; sl= sl->master_unit()->outer_select() ) sl->master_unit()->item->with_sum_func= 1; } - thd->lex->current_select->mark_as_dependent(aggr_sl); + thd->lex->current_select->mark_as_dependent(aggr_sel); return FALSE; } @@ -299,10 +302,10 @@ Item_sum::Item_sum(List &list) :arg_count(list.elements), Item_sum::Item_sum(THD *thd, Item_sum *item): Item_result_field(thd, item), arg_count(item->arg_count), + aggr_sel(item->aggr_sel), nest_level(item->nest_level), aggr_level(item->aggr_level), quick_group(item->quick_group), used_tables_cache(item->used_tables_cache), - forced_const(item->forced_const), - nest_level_tables_count(item->nest_level_tables_count) + forced_const(item->forced_const) { if (arg_count <= 2) args=tmp_args; @@ -447,7 +450,7 @@ void Item_sum::update_used_tables () /* the aggregate function is aggregated into its local context */ if (aggr_level == nest_level) - used_tables_cache |= (1 << nest_level_tables_count) - 1; + used_tables_cache |= (1 << aggr_sel->join->tables) - 1; } } -- cgit v1.2.1