1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MDEV-7486: Cosmetic changes

Browse Source 
- Removed dead code
- Renamed a function
- Removed a parameter that not needed.
- Corrected comments
This commit is contained in:
Igor Babaev 2019-02-18 22:11:25 -08:00
parent 9741930490
commit 4de3fd4ea2
2 changed files with 36 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
sql/sql_lex.cc
View File

@ -7754,13 +7754,13 @@ void binlog_unsafe_map_init()
/** /**
@brief @brief
Finding fiels that are used in the GROUP BY of this st_select_lex Collect fiels that are used in the GROUP BY of this st_select_lex
@param thd The thread handle @param thd The thread handle
@details @details
This method looks through the fields which are used in the GROUP BY of this This method looks through the fields that are used in the GROUP BY of this
st_select_lex and saves this fields. st_select_lex and saves onfo on these fields.
*/ */
void st_select_lex::collect_grouping_fields_for_derived(THD *thd, void st_select_lex::collect_grouping_fields_for_derived(THD *thd,
@ -7826,7 +7826,7 @@ bool st_select_lex::collect_grouping_fields(THD *thd)
This method traverses the AND-OR condition cond and for each subformula of This method traverses the AND-OR condition cond and for each subformula of
the condition it checks whether it can be usable for the extraction of a the condition it checks whether it can be usable for the extraction of a
condition over the grouping fields of this select. The method uses condition over the grouping fields of this select. The method uses
the call-back parameter checker to ckeck whether a primary formula the call-back parameter checker to check whether a primary formula
depends only on grouping fields. depends only on grouping fields.
The subformulas that are not usable are marked with the flag NO_EXTRACTION_FL. The subformulas that are not usable are marked with the flag NO_EXTRACTION_FL.
The subformulas that can be entierly extracted are marked with the flag The subformulas that can be entierly extracted are marked with the flag
@ -7870,7 +7870,7 @@ st_select_lex::check_cond_extraction_for_grouping_fields(THD *thd, Item *cond,
else if (!and_cond) else if (!and_cond)
break; break;
} }
if (item) if ((and_cond && count == 0) || item)
cond->set_extraction_flag(NO_EXTRACTION_FL); cond->set_extraction_flag(NO_EXTRACTION_FL);
if (count_full == arg_list->elements) if (count_full == arg_list->elements)
{ {
@ -9723,7 +9723,7 @@ void st_select_lex::mark_or_conds_to_avoid_pushdown(Item *cond)
@details @details
The method finds out what conditions can be extracted from cond depended The method finds out what conditions can be extracted from cond depended
only on the grouping fields of this SELECT or fields equal to them. only on the grouping fields of this SELECT or fields equal to them.
If the condition that can be pushed is AND-condition it is splitted out If the condition that can be pushed is AND-condition it is splitted up
and for each its element it is checked if it can be pushed. and for each its element it is checked if it can be pushed.
Pushable elements are attached to the attach_to_conds list. Pushable elements are attached to the attach_to_conds list.
If the condition isn't AND-condition it is entirely pushed into If the condition isn't AND-condition it is entirely pushed into
@ -9745,9 +9745,11 @@ void st_select_lex::mark_or_conds_to_avoid_pushdown(Item *cond)
bool bool
st_select_lex::build_pushable_cond_for_having_pushdown(THD *thd, st_select_lex::build_pushable_cond_for_having_pushdown(THD *thd,
Item *cond, Item *cond)
Pushdown_checker checker)
{ {
Pushdown_checker checker=
&Item::pushable_equality_checker_for_having_pushdown;
bool is_multiple_equality= cond->type() == Item::FUNC_ITEM && bool is_multiple_equality= cond->type() == Item::FUNC_ITEM &&
((Item_func*) cond)->functype() == Item_func::MULT_EQUAL_FUNC; ((Item_func*) cond)->functype() == Item_func::MULT_EQUAL_FUNC;
@ -9862,33 +9864,15 @@ Field_pair *get_corresponding_field_pair(Item *item,
/** /**
@brief @brief
Find fields in WHERE clause multiple equalities that can be used in pushdown Collect fields in multiple equalities usable for pushdown from having
@param thd The thread handle @param thd The thread handle
@details @details
This method looks through the multiple equalities of the WHERE clause This method looks through the multiple equalities of the WHERE clause
trying to find any of them which fields are used in the GROUP BY of the trying to find any of them whose fields are used in the GROUP BY of the
SELECT. If such multiple equality exists conditions in the HAVING SELECT. Any field from these multiple equality is included into the
clause that use fields of this multiple equality can be pushed down the list of fields against which any candidate for pushing is checked.
into the WHERE clause as well as the conditions depended on the fields
from the GROUP BY or fields equal to them that are taken from the HAVING
clause multiple equalities.
Example:
SELECT a,MAX(b),c
FROM t1
WHERE (t1.a=t1.c)
GROUP BY t1.a
HAVING (t1.c>1)
=>
SELECT a,MAX(b),c
FROM t1
WHERE (t1.a=t1.c) AND (t1.c>1)
GROUP BY t1.a
@retval @retval
true - if an error occurs true - if an error occurs
@ -9909,22 +9893,16 @@ bool st_select_lex::collect_fields_equal_to_grouping(THD *thd)
Item *item; Item *item;
while ((item= it++)) while ((item= it++))
{ {
if (item->type() != Item::FIELD_ITEM &&
item->type() != Item::REF_ITEM)
continue;
if (get_corresponding_field_pair(item, grouping_tmp_fields)) if (get_corresponding_field_pair(item, grouping_tmp_fields))
break; break;
} }
if (!item) if (!item)
break; break;
it.rewind();
it.rewind();
while ((item= it++)) while ((item= it++))
{ {
if ((item->type() != Item::FIELD_ITEM && if (get_corresponding_field_pair(item, grouping_tmp_fields))
item->type() != Item::REF_ITEM) ||
get_corresponding_field_pair(item, grouping_tmp_fields))
continue; continue;
Field_pair *grouping_tmp_field= Field_pair *grouping_tmp_field=
new Field_pair(((Item_field *)item->real_item())->field, item); new Field_pair(((Item_field *)item->real_item())->field, item);
@ -9937,7 +9915,7 @@ bool st_select_lex::collect_fields_equal_to_grouping(THD *thd)
/** /**
@brief @brief
Cleanup and fix for the condition that is ready to be pushed down Cleanup and fix of the condition that is ready to be pushed down
@param thd The thread handle @param thd The thread handle
@param cond The condition to be processed @param cond The condition to be processed
@ -9954,7 +9932,7 @@ bool st_select_lex::collect_fields_equal_to_grouping(THD *thd)
*/ */
static static
bool cleanup_inequalities_for_having_pushdown(THD *thd, Item *cond) bool cleanup_condition_pushed_from_having(THD *thd, Item *cond)
{ {
if (cond->type() == Item::FUNC_ITEM && if (cond->type() == Item::FUNC_ITEM &&
((Item_func*) cond)->functype() == Item_func::MULT_EQUAL_FUNC) ((Item_func*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)
@ -9966,7 +9944,7 @@ bool cleanup_inequalities_for_having_pushdown(THD *thd, Item *cond)
Item *item; Item *item;
while ((item=it++)) while ((item=it++))
cleanup_inequalities_for_having_pushdown(thd, item); cleanup_condition_pushed_from_having(thd, item);
} }
else else
{ {
@ -10075,7 +10053,7 @@ Item *remove_pushed_top_conjuncts_for_having(THD *thd, Item *cond)
This function builds the most restrictive condition depending only on This function builds the most restrictive condition depending only on
the fields used in the GROUP BY of this select (directly or indirectly the fields used in the GROUP BY of this select (directly or indirectly
through equality) that can be extracted from the HAVING clause of this through equality) that can be extracted from the HAVING clause of this
select having and pushes it into the WHERE clause of this select. select and pushes it into the WHERE clause of this select.
Example of the transformation: Example of the transformation:
@ -10095,11 +10073,11 @@ Item *remove_pushed_top_conjuncts_for_having(THD *thd, Item *cond)
In details: In details:
1. Collect fields used in the GROUP BY grouping_fields of this SELECT 1. Collect fields used in the GROUP BY grouping_fields of this SELECT
2. Collect fields equal to grouping_fields from the WHERE clause 2. Collect fields equal to grouping_fields from the WHERE clause
of this SELECT and attach them to the grouping_fields list. of this SELECT and add them to the grouping_fields list.
3. Search for the conditions in the HAVING clause of this select 3. Extract the most restrictive condition from the HAVING clause of this
that depends only on grouping_fields. Store them in the select that depends only on the grouping fields (directly or indirectly
attach_to_conds list. through equality). Store it in the attach_to_conds list.
4. Remove pushable conditions from the HAVING clause having. 4. Remove pushable conditions from the HAVING clause if it's possible.
@note @note
This method is similar to st_select_lex::pushdown_cond_into_where_clause(). This method is similar to st_select_lex::pushdown_cond_into_where_clause().
@ -10119,37 +10097,25 @@ Item *st_select_lex::pushdown_from_having_into_where(THD *thd, Item *having)
thd->lex->current_select= this; thd->lex->current_select= this;
/* /*
1. Collect fields used in the GROUP BY grouping_fields of this SELECT 1. Collect fields used in the GROUP BY grouping fields of this SELECT
2. Collect fields equal to grouping_fields from the WHERE clause 2. Collect fields equal to grouping_fields from the WHERE clause
of this SELECT and attach them to the grouping_fields list. of this SELECT and add them to the grouping fields list.
*/ */
if (have_window_funcs()) if (collect_grouping_fields(thd) ||
{ collect_fields_equal_to_grouping(thd))
if (group_list.first || join->implicit_grouping)
return having;
ORDER *common_partition_fields=
find_common_window_func_partition_fields(thd);
if (!common_partition_fields ||
collect_grouping_fields(thd) ||
collect_fields_equal_to_grouping(thd))
return having;
}
else if (collect_grouping_fields(thd) ||
collect_fields_equal_to_grouping(thd))
return having; return having;
/* /*
3. Search for the conditions in the HAVING clause of this select 3. Extract the most restrictive condition from the HAVING clause of this
that depends only on grouping_fields. Store them in the select that depends only on the grouping fields (directly or indirectly
attach_to_conds list. through equality). Store it in the attach_to_conds list.
*/ */
thd->having_pushdown= true; thd->having_pushdown= true;
List_iterator_fast<Item> it(attach_to_conds); List_iterator_fast<Item> it(attach_to_conds);
Item *item; Item *item;
check_cond_extraction_for_grouping_fields(thd, having, check_cond_extraction_for_grouping_fields(thd, having,
&Item::dep_on_grouping_fields_checker_for_having_pushdown); &Item::dep_on_grouping_fields_checker_for_having_pushdown);
if (build_pushable_cond_for_having_pushdown(thd, having, if (build_pushable_cond_for_having_pushdown(thd, having))
&Item::pushable_equality_checker_for_having_pushdown))
{ {
attach_to_conds.empty(); attach_to_conds.empty();
goto exit; goto exit;
@ -10157,14 +10123,14 @@ Item *st_select_lex::pushdown_from_having_into_where(THD *thd, Item *having)
if (attach_to_conds.elements != 0) if (attach_to_conds.elements != 0)
{ {
/* /*
4. Remove pushable conditions from the HAVING clause having. 4. Remove pushable conditions from the HAVING clause if it's possible.
*/ */
having= remove_pushed_top_conjuncts_for_having(thd, having); having= remove_pushed_top_conjuncts_for_having(thd, having);
it.rewind(); it.rewind();
while ((item=it++)) while ((item=it++))
{ {
if (cleanup_inequalities_for_having_pushdown(thd, item)) if (cleanup_condition_pushed_from_having(thd, item))
{ {
attach_to_conds.empty(); attach_to_conds.empty();
goto exit; goto exit;

3
sql/sql_lex.h
View File

@ -1504,8 +1504,7 @@ public:
{ return !olap && !explicit_limit && !tvc; } { return !olap && !explicit_limit && !tvc; }
bool build_pushable_cond_for_having_pushdown(THD *thd, bool build_pushable_cond_for_having_pushdown(THD *thd,
Item *cond, Item *cond);
Pushdown_checker checker);
void pushdown_cond_into_where_clause(THD *thd, Item *extracted_cond, void pushdown_cond_into_where_clause(THD *thd, Item *extracted_cond,
Item **remaining_cond, Item **remaining_cond,
Item_transformer transformer, Item_transformer transformer,