| List: | Commits | « Previous MessageNext Message » | |
| From: | eugene | Date: | April 1 2007 1:16am |
| Subject: | bk commit into 5.0 tree (evgen:1.2421) BUG#27321 | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.0 repository of evgen. When evgen does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet@stripped, 2007-04-01 03:16:50+04:00, evgen@stripped +7 -0 Bug#27321: Wrong subquery result in a grouping select. The Item_outer_ref class based on the Item_direct_ref class was always used to represent an outer field. But if the outer select is a grouping one and the outer field isn't under an aggregate function which is aggregated in that outer select the Item_ref should be used to represent such a field. If the outer select in which the outer field is resolved isn't grouping then the Item_field class should be used to represent such a field. This logic also should be used for an outer field resolved through its alias name. Now the Item_field::fix_outer_field() uses Item_outer_field objects to represent aliased and non-aliased outer fields for grouping outer selects only. Item_outer_ref::val_xxx() methods were added. The direct_ref and the found_in_select_list fields were added to the Item_outer_ref class. Now the fix_inner_refs() function resolves which set of functions, val_xxx() or val_xxx_result(), will be used by an Item_outer_ref object. mysql-test/r/subselect.result@stripped, 2007-04-01 03:13:29+04:00, evgen@stripped +29 -3 Added a test case for the bug#27321: Wrong subquery result in a grouping select. Some test cases were corrected after this fix. mysql-test/r/subselect3.result@stripped, 2007-04-01 03:13:29+04:00, evgen@stripped +2 -8 Some test cases were corrected after the fix for the bug#27321. mysql-test/t/subselect.test@stripped, 2007-04-01 03:13:28+04:00, evgen@stripped +18 -0 Added a test case for the bug#27321: Wrong subquery result in a grouping select. mysql-test/t/subselect3.test@stripped, 2007-04-01 03:13:27+04:00, evgen@stripped +0 -2 Some test cases were corrected after the fix for the bug#27321. sql/item.cc@stripped, 2007-04-01 03:15:52+04:00, evgen@stripped +100 -41 Bug#27321: Wrong subquery result in a grouping select. Now the Item_field::fix_outer_field() uses Item_outer_field objects to represent aliased and non-aliased outer fields for grouping outer selects only. Item_outer_ref::val_xxx() methods were added. sql/item.h@stripped, 2007-04-01 03:15:13+04:00, evgen@stripped +30 -8 Bug#27321: Wrong subquery result in a grouping select. The direct_ref and the found_in_select_list fields were added to the Item_outer_ref class. sql/sql_select.cc@stripped, 2007-04-01 03:14:25+04:00, evgen@stripped +51 -17 Bug#27321: Wrong subquery result in a grouping select. Now the fix_inner_refs() function resolves which set of functions, val_xxx() or val_xxx_result(), will be used by an Item_outer_ref object. # This is a BitKeeper patch. What follows are the unified diffs for the # set of deltas contained in the patch. The rest of the patch, the part # that BitKeeper cares about, is below these diffs. # User: evgen # Host: moonbone.local # Root: /mnt/gentoo64/work/27321-bug-5.0-opt-mysql --- 1.259/sql/item.cc 2007-03-23 00:51:14 +03:00 +++ 1.260/sql/item.cc 2007-04-01 03:15:52 +04:00 @@ -3447,6 +3447,7 @@ Item **ref= (Item **) not_found_item; SELECT_LEX *current_sel= (SELECT_LEX *) thd->lex->current_select; Name_resolution_context *outer_context= 0; + SELECT_LEX *select; /* Currently derived tables cannot be correlated */ if (current_sel->master_unit()->first_select()->linkage != DERIVED_TABLE_TYPE) @@ -3455,7 +3456,7 @@ outer_context; outer_context= outer_context->outer_context) { - SELECT_LEX *select= outer_context->select_lex; + select= outer_context->select_lex; Item_subselect *prev_subselect_item= last_checked_context->select_lex->master_unit()->item; last_checked_context= outer_context; @@ -3498,32 +3499,23 @@ } if (*from_field != view_ref_found) { - prev_subselect_item->used_tables_cache|= (*from_field)->table->map; prev_subselect_item->const_item_cache= 0; + set_field(*from_field); if (!last_checked_context->select_lex->having_fix_field && - !fixed_as_field) + select->group_list.elements && !fixed_as_field) { Item_outer_ref *rf; Query_arena *arena= 0, backup; /* - Each outer field is replaced for an Item_outer_ref object. - This is done in order to get correct results when the outer - select employs a temporary table. - The original fields are saved in the inner_fields_list of the - outer select. This list is created by the following reasons: - 1. We can't add field items to the outer select list directly - because the outer select hasn't been fully fixed yet. - 2. We need a location to refer to in the Item_ref object - so the inner_fields_list is used as such temporary - reference storage. + If an outer field is resolved in a grouping select then it + is replaced for an Item_outer_ref object. The new Item_outer_ref object replaces the original field and is - also saved in the inner_refs_list of the outer select. Here + saved in the inner_refs_list of the outer select. Here it is only created. It can be fixed only after the original field has been fixed and this is done in the fix_inner_refs() function. */ - set_field(*from_field); arena= thd->activate_stmt_arena_if_needed(&backup); rf= new Item_outer_ref(context, this); if (!rf) @@ -3537,6 +3529,7 @@ if (arena) thd->restore_active_arena(arena, &backup); fixed_as_field= 1; + rf->in_sum_func= thd->lex->in_sum_func; } if (thd->lex->in_sum_func && thd->lex->in_sum_func->nest_level == @@ -3628,37 +3621,57 @@ { Item *save; Item_ref *rf; - /* Should have been checked in resolve_ref_in_select_and_group(). */ DBUG_ASSERT(*ref && (*ref)->fixed); - /* - Here, a subset of actions performed by Item_ref::set_properties - is not enough. So we pass ptr to NULL into Item_[direct]_ref - constructor, so no initialization is performed, and call - fix_fields() below. - */ save= *ref; *ref= NULL; // Don't call set_properties() - rf= (place == IN_HAVING ? - new Item_ref(context, ref, (char*) table_name, - (char*) field_name, alias_name_used) : - new Item_direct_ref(context, ref, (char*) table_name, - (char*) field_name, alias_name_used)); - *ref= save; - if (!rf) - return -1; - thd->change_item_tree(reference, rf); + /* See comment for the fix_inner_refs() function */ + if (place == IN_HAVING || !select->group_list.elements) + { + /* + Here, a subset of actions performed by Item_ref::set_properties + is not enough. So we pass ptr to NULL into Item_[direct]_ref + constructor, so no initialization is performed, and call + fix_fields() below. + */ + rf= (place == IN_HAVING) ? + new Item_ref(context, ref, (char*) table_name, + (char*) field_name, alias_name_used) : + new Item_direct_ref(context, ref, (char*) table_name, + (char*) field_name, alias_name_used); + if (!rf) + return -1; + thd->change_item_tree(reference, rf); + } + else + { + Query_arena *arena= 0, backup; + arena= thd->activate_stmt_arena_if_needed(&backup); + rf= new Item_outer_ref(context, ref, (char*) table_name, + (char*) field_name, alias_name_used); + if (!rf) + { + if (arena) + thd->restore_active_arena(arena, &backup); + return -1; + } + *reference= rf; + outer_context->select_lex->inner_refs_list.push_back((Item_outer_ref*)rf); + ((Item_outer_ref*)rf)->in_sum_func= thd->lex->in_sum_func; + if (arena) + thd->restore_active_arena(arena, &backup); + fixed_as_field= 1; + } /* rf is Item_ref => never substitute other items (in this case) during fix_fields() => we can use rf after fix_fields() */ DBUG_ASSERT(!rf->fixed); // Assured by Item_ref() + *ref= save; if (rf->fix_fields(thd, reference) || rf->check_cols(1)) return -1; - mark_as_dependent(thd, last_checked_context->select_lex, - context->select_lex, this, - rf); + context->select_lex, this, rf); return 0; } else @@ -5547,15 +5560,61 @@ bool Item_outer_ref::fix_fields(THD *thd, Item **reference) { - DBUG_ASSERT(*ref); - /* outer_field->check_cols() will be made in Item_direct_ref::fix_fields */ - outer_field->fixed_as_field= 1; - if (!outer_field->fixed && - (outer_field->fix_fields(thd, reference))) + bool err; + /* outer_ref->check_cols() will be made in Item_direct_ref::fix_fields */ + if ((*ref) && !(*ref)->fixed && ((*ref)->fix_fields(thd, reference))) return TRUE; - table_name= outer_field->table_name; - return Item_direct_ref::fix_fields(thd, reference); + err= Item_direct_ref::fix_fields(thd, reference); + if (!outer_ref) + outer_ref= *ref; + if ((*ref)->type() == Item::FIELD_ITEM) + table_name= ((Item_field*)outer_ref)->table_name; + return err; +} + +double Item_outer_ref::val_real() +{ + DBUG_ASSERT(fixed); + double tmp= direct_ref ? (*ref)->val_real() : (*ref)->val_result(); + null_value=(*ref)->null_value; + return tmp; } + + +longlong Item_outer_ref::val_int() +{ + DBUG_ASSERT(fixed); + longlong tmp= direct_ref ? (*ref)->val_int() :(*ref)->val_int_result(); + null_value=(*ref)->null_value; + return tmp; +} + + +bool Item_outer_ref::val_bool() +{ + DBUG_ASSERT(fixed); + bool tmp= direct_ref ? (*ref)->val_bool() : (*ref)->val_bool_result(); + null_value= (*ref)->null_value; + return tmp; +} + + +String *Item_outer_ref::val_str(String* tmp) +{ + DBUG_ASSERT(fixed); + tmp= direct_ref ? (*ref)->val_str(tmp) : (*ref)->str_result(tmp); + null_value=(*ref)->null_value; + return tmp; +} + +my_decimal *Item_outer_ref::val_decimal(my_decimal *decimal_value) +{ + my_decimal *val= direct_ref ? (*ref)->val_decimal(decimal_value) : + (*ref)->val_decimal_result(decimal_value); + null_value= (*ref)->null_value; + return val; +} + /* Compare two view column references for equality. --- 1.224/sql/item.h 2007-03-22 11:21:02 +03:00 +++ 1.225/sql/item.h 2007-04-01 03:15:13 +04:00 @@ -1978,31 +1978,48 @@ virtual Ref_Type ref_type() { return VIEW_REF; } }; - +class Item_sum; class Item_outer_ref :public Item_direct_ref { public: - Item_field *outer_field; + Item *outer_ref; + /* The aggregate function under which this outer ref is used, if any. */ + Item_sum *in_sum_func; + /* To indicate which methods to use: val_xxx() or val_xxx_result(). */ + bool direct_ref; + /* + To indicate that the outer_ref is already present in the select list + of the outer select. + */ + bool found_in_select_list; Item_outer_ref(Name_resolution_context *context_arg, Item_field *outer_field_arg) :Item_direct_ref(context_arg, 0, outer_field_arg->table_name, - outer_field_arg->field_name), - outer_field(outer_field_arg) + outer_field_arg->field_name), + outer_ref(outer_field_arg), in_sum_func(0), direct_ref(0), + found_in_select_list(0) { - ref= (Item**)&outer_field; + ref= &outer_ref; set_properties(); fixed= 0; } + Item_outer_ref(Name_resolution_context *context_arg, Item **item, + const char *table_name_arg, const char *field_name_arg, + bool alias_name_used_arg) + :Item_direct_ref(context_arg, item, table_name_arg, field_name_arg, + alias_name_used_arg), + outer_ref(0), in_sum_func(0), direct_ref(0), found_in_select_list(1) + {} void cleanup() { - ref= (Item**)&outer_field; + ref= (Item**)&outer_ref; fixed= 0; Item_direct_ref::cleanup(); - outer_field->cleanup(); + outer_ref->cleanup(); } void save_in_result_field(bool no_conversions) { - outer_field->save_org_in_field(result_field); + outer_ref->save_org_in_field(result_field); } bool fix_fields(THD *, Item **); table_map used_tables() const @@ -2010,6 +2027,11 @@ return (*ref)->const_item() ? 0 : OUTER_REF_TABLE_BIT; } virtual Ref_Type ref_type() { return OUTER_REF; } + double val_real(); + longlong val_int(); + bool val_bool(); + String *val_str(String* tmp); + my_decimal *val_decimal(my_decimal *decimal_value); }; --- 1.502/sql/sql_select.cc 2007-03-26 10:44:03 +04:00 +++ 1.503/sql/sql_select.cc 2007-04-01 03:14:25 +04:00 @@ -278,15 +278,29 @@ ref_pointer_array Array of references to Items used in current select DESCRIPTION - The function fixes fields referenced from inner selects and - also fixes references (Item_ref objects) to these fields. Each field - is fixed as a usual hidden field of the current select - it is added + The function serves 3 purposes - adds fields referenced from inner + selects to the current select list, resolves which function set to + use (val_xxx() of val_xxx_result()) and fixes references (Item_ref + objects) to these fields. If a field isn't already present in the + select list and the ref_pointer_array is provided then it is added to the all_fields list and the pointer to it is saved in the - ref_pointer_array if latter is provided. - After the field has been fixed we proceed with fixing references - (Item_ref objects) to this field from inner subqueries. If the - ref_pointer_array is provided then Item_ref objects is set to - reference element in that array with the pointer to the field. + ref_pointer_array. + + The function set is resolved by next rules: + 1) If the outer field isn't used under an aggregate function + then Item_outer_ref should use val_xxx_result() functions. + 2) If the outer field is used under an aggregate function and this + function is aggregated in the select where the outer field was + resolved or in some more inner select then the val_xxx() + methods should be used. + The resolution is done here and not at the fix_fields() stage due to + it can be done only after sum functions are fixed and pulled up to + selects where they are have to be aggregated. + + After this we proceed with fixing references (Item_ref objects) to + this field from inner subqueries. If the ref_pointer_array is provided + then Item_ref objects is set to reference element in that array with + the pointer to the field. RETURN TRUE an error occured @@ -302,25 +316,44 @@ List_iterator<Item_outer_ref> ref_it(select->inner_refs_list); while ((ref= ref_it++)) { - Item_field *item= ref->outer_field; + Item *item= ref->outer_ref; /* TODO: this field item already might be present in the select list. In this case instead of adding new field item we could use an existing one. The change will lead to less operations for copying fields, smaller temporary tables and less data passed through filesort. */ - if (ref_pointer_array) + if (ref_pointer_array && !ref->found_in_select_list) { int el= all_fields.elements; - ref_pointer_array[el]= (Item*)item; + ref_pointer_array[el]= item; /* Add the field item to the select list of the current select. */ - all_fields.push_front((Item*)item); + all_fields.push_front(item); /* If it's needed reset each Item_ref item that refers this field with a new reference taken from ref_pointer_array. */ ref->ref= ref_pointer_array + el; } + + if (ref->in_sum_func) + { + if (ref->in_sum_func->nest_level > select->nest_level) + ref->direct_ref= TRUE; + else + { + Item_sum *sum_func; + for (sum_func= ref->in_sum_func; sum_func; + sum_func= sum_func->in_sum_func) + { + if (sum_func->depended_from() == select) + { + ref->direct_ref= TRUE; + break; + } + } + } + } if (!ref->fixed && ref->fix_fields(thd, 0)) { res= TRUE; @@ -478,10 +511,6 @@ if (having && having->with_sum_func) having->split_sum_func2(thd, ref_pointer_array, all_fields, &having, TRUE); - if (select_lex->inner_refs_list.elements && - fix_inner_refs(thd, all_fields, select_lex, ref_pointer_array)) - DBUG_RETURN(-1); - if (select_lex->inner_sum_func_list) { Item_sum *end=select_lex->inner_sum_func_list; @@ -494,6 +523,10 @@ } while (item_sum != end); } + if (select_lex->inner_refs_list.elements && + fix_inner_refs(thd, all_fields, select_lex, ref_pointer_array)) + DBUG_RETURN(-1); + if (setup_ftfuncs(select_lex)) /* should be after having->fix_fields */ DBUG_RETURN(-1); @@ -5214,7 +5247,8 @@ } else if (keyuse->val->type() == Item::FIELD_ITEM || (keyuse->val->type() == Item::REF_ITEM && - ((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF) ) + ((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF && + ((Item_outer_ref*)keyuse->val)->direct_ref) ) return new store_key_field(thd, key_part->field, key_buff + maybe_null, --- 1.181/mysql-test/r/subselect.result 2007-03-23 00:48:00 +03:00 +++ 1.182/mysql-test/r/subselect.result 2007-04-01 03:13:29 +04:00 @@ -48,7 +48,7 @@ 3 DEPENDENT SUBQUERY NULL NULL NULL NULL NULL NULL NULL No tables used 2 DERIVED NULL NULL NULL NULL NULL NULL NULL No tables used Warnings: -Note 1276 Field or reference 'a' of SELECT #3 was resolved in SELECT #1 +Note 1276 Field or reference 'b.a' of SELECT #3 was resolved in SELECT #1 Note 1276 Field or reference 'b.a' of SELECT #3 was resolved in SELECT #1 Note 1003 select 1 AS `1` from (select 1 AS `a`) `b` having ((select '1' AS `a`) = 1) SELECT 1 FROM (SELECT 1 as a) as b HAVING (SELECT a)=1; @@ -330,7 +330,7 @@ explain extended select * from t6 where exists (select * from t7 where uq = clinic_uq); id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t6 ALL NULL NULL NULL NULL 4 Using where -2 DEPENDENT SUBQUERY t7 eq_ref PRIMARY PRIMARY 4 t6.clinic_uq 1 Using where; Using index +2 DEPENDENT SUBQUERY t7 eq_ref PRIMARY PRIMARY 4 test.t6.clinic_uq 1 Using index Warnings: Note 1276 Field or reference 'test.t6.clinic_uq' of SELECT #2 was resolved in SELECT #1 Note 1003 select `test`.`t6`.`patient_uq` AS `patient_uq`,`test`.`t6`.`clinic_uq` AS `clinic_uq` from `test`.`t6` where exists(select 1 AS `Not_used` from `test`.`t7` where (`test`.`t7`.`uq` = `test`.`t6`.`clinic_uq`)) @@ -1741,7 +1741,7 @@ explain extended select * from t1 as tt where not exists (select id from t1 where id < 8 and (id = tt.id or id is null) having id is not null); id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY tt ALL NULL NULL NULL NULL 12 Using where -2 DEPENDENT SUBQUERY t1 eq_ref PRIMARY PRIMARY 4 tt.id 1 Using where; Using index +2 DEPENDENT SUBQUERY t1 eq_ref PRIMARY PRIMARY 4 test.tt.id 1 Using where; Using index Warnings: Note 1276 Field or reference 'test.tt.id' of SELECT #2 was resolved in SELECT #1 Note 1003 select `test`.`tt`.`id` AS `id`,`test`.`tt`.`text` AS `text` from `test`.`t1` `tt` where (not(exists(select `test`.`t1`.`id` AS `id` from `test`.`t1` where ((`test`.`t1`.`id` < 8) and (`test`.`t1`.`id` = `test`.`tt`.`id`)) having (`test`.`t1`.`id` is not null)))) @@ -3924,3 +3924,29 @@ 3 3 4 1 4 2,2 DROP table t1,t2; +CREATE TABLE t1 (a int, b INT, c CHAR(10) NOT NULL, PRIMARY KEY (a, b)); +INSERT INTO t1 VALUES (1,1,'a'), (1,2,'b'), (1,3,'c'), (1,4,'d'), (1,5,'e'), +(2,1,'f'), (2,2,'g'), (2,3,'h'), (3,4,'i'),(3,3,'j'), (3,2,'k'), (3,1,'l'), +(1,9,'m'); +SELECT a, MAX(b), +(SELECT t.c FROM t1 AS t WHERE t1.a=t.a AND t.b=MAX(t1.b + 0)) as test +FROM t1 GROUP BY a; +a MAX(b) test +1 9 m +2 3 h +3 4 i +SELECT a x, MAX(b), +(SELECT t.c FROM t1 AS t WHERE x=t.a AND t.b=MAX(t1.b + 0)) as test +FROM t1 GROUP BY a; +x MAX(b) test +1 9 m +2 3 h +3 4 i +SELECT a, AVG(b), +(SELECT t.c FROM t1 AS t WHERE t1.a=t.a AND t.b=AVG(t1.b)) AS test +FROM t1 GROUP BY a; +a AVG(b) test +1 4.0000 d +2 2.0000 g +3 2.5000 NULL +DROP TABLE t1; --- 1.146/mysql-test/t/subselect.test 2007-03-23 00:48:00 +03:00 +++ 1.147/mysql-test/t/subselect.test 2007-04-01 03:13:28 +04:00 @@ -2782,3 +2782,21 @@ FROM t1 GROUP BY a; DROP table t1,t2; + +# +# Bug#27321: Wrong subquery result in a grouping select +# +CREATE TABLE t1 (a int, b INT, c CHAR(10) NOT NULL, PRIMARY KEY (a, b)); +INSERT INTO t1 VALUES (1,1,'a'), (1,2,'b'), (1,3,'c'), (1,4,'d'), (1,5,'e'), +(2,1,'f'), (2,2,'g'), (2,3,'h'), (3,4,'i'),(3,3,'j'), (3,2,'k'), (3,1,'l'), +(1,9,'m'); +SELECT a, MAX(b), + (SELECT t.c FROM t1 AS t WHERE t1.a=t.a AND t.b=MAX(t1.b + 0)) as test + FROM t1 GROUP BY a; +SELECT a x, MAX(b), + (SELECT t.c FROM t1 AS t WHERE x=t.a AND t.b=MAX(t1.b + 0)) as test + FROM t1 GROUP BY a; +SELECT a, AVG(b), + (SELECT t.c FROM t1 AS t WHERE t1.a=t.a AND t.b=AVG(t1.b)) AS test + FROM t1 GROUP BY a; +DROP TABLE t1; --- 1.6/mysql-test/r/subselect3.result 2007-03-20 20:49:35 +03:00 +++ 1.7/mysql-test/r/subselect3.result 2007-04-01 03:13:29 +04:00 @@ -432,7 +432,7 @@ explain select oref, a, a in (select ie from t1 where oref=t2.oref) Z from t2; id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t2 ALL NULL NULL NULL NULL 7 -2 DEPENDENT SUBQUERY t1 ref_or_null idx idx 10 t2.oref,func 4 Using where; Using index; Full scan on NULL key +2 DEPENDENT SUBQUERY t1 ref_or_null idx idx 10 test.t2.oref,func 4 Using where; Using index; Full scan on NULL key select oref, a, a in (select ie from t1 where oref=t2.oref) Z from t2; oref a Z ee NULL NULL @@ -457,7 +457,7 @@ from t2; id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t2 ALL NULL NULL NULL NULL 7 -2 DEPENDENT SUBQUERY t1 ref idx idx 5 t2.oref 2 Using where; Using temporary; Using filesort +2 DEPENDENT SUBQUERY t1 ref idx idx 5 test.t2.oref 2 Using where; Using temporary; Using filesort select oref, a, a in (select min(ie) from t1 where oref=t2.oref group by grp having min(ie) > 1) Z @@ -661,12 +661,6 @@ HAVING (MAX(t1.b) > (SELECT MAX(t2.b) FROM t2 WHERE t2.c < t1.c HAVING MAX(t2.b+t1.a) < 10)); a b c -SELECT a, AVG(b), (SELECT t.c FROM t1 AS t WHERE t1.a=t.a AND t.b=AVG(t1.b)) -AS test FROM t1 GROUP BY a; -a AVG(b) test -1 4.0000 NULL -2 2.0000 k -3 2.5000 NULL SELECT a,b,c FROM t1 WHERE b in (9,3,4) ORDER BY b,c; a b c 1 3 c --- 1.6/mysql-test/t/subselect3.test 2007-03-20 20:45:49 +03:00 +++ 1.7/mysql-test/t/subselect3.test 2007-04-01 03:13:27 +04:00 @@ -507,8 +507,6 @@ SELECT * FROM t1 GROUP by t1.a HAVING (MAX(t1.b) > (SELECT MAX(t2.b) FROM t2 WHERE t2.c < t1.c HAVING MAX(t2.b+t1.a) < 10)); -SELECT a, AVG(b), (SELECT t.c FROM t1 AS t WHERE t1.a=t.a AND t.b=AVG(t1.b)) - AS test FROM t1 GROUP BY a; SELECT a,b,c FROM t1 WHERE b in (9,3,4) ORDER BY b,c;
| Thread | ||
|---|---|---|
| • bk commit into 5.0 tree (evgen:1.2421) BUG#27321 | eugene | 1 Apr |
© 1995-2008 MySQL AB. All rights reserved.
Page generated in 0.627 sec. using MySQL 5.1.14-beta-log