Skip to content

M
mariadb
Commit 854bb82b authored by Sergey Petrunya's avatar Sergey Petrunya
Browse files
Options

MWL#17: Table elimination 

Address review feedback: 
- Change from Wave-based approach (a-la const table detection) to 
  building and walking functional dependency graph.
- Change from piggy-backing on ref-access code and KEYUSE structures
  to using our own expression analyzer.


sql/item.cc:
  MWL#17: Table elimination
  - Move from C-ish Field_processor_info to C++ ish and generic Field_enumerator
sql/item.h:
  MWL#17: Table elimination
  - Move from C-ish Field_processor_info to C++ ish and generic Field_enumerator
sql/sql_bitmap.h:
  MWL#17: Table elimination
  - Backport of Table_map_iterator from 6.0
parent 5ecad03d
Show whitespace changes
Inline Side-by-side
Showing with 1113 additions and 314 deletions
sql/item.cc
View file @ 854bb82b
......@@ -1918,30 +1918,8 @@ void Item_field::reset_field(Field *f)
bool Item_field::check_column_usage_processor(uchar *arg)
{
Field_processor_info* info=(Field_processor_info*)arg;
if (field->table == info->table)
{
/* It is not ok to use columns that are not part of the key of interest: */
if (!(field->part_of_key.is_set(info->keyno)))
return TRUE;
/* Find which key part we're using and mark it in needed_key_parts */
KEY *key= &field->table->key_info[info->keyno];
for (uint part= 0; part < key->key_parts; part++)
{
if (field->field_index == key->key_part[part].field->field_index)
{
if (part == info->forbidden_part)
return TRUE;
info->needed_key_parts |= key_part_map(1) << part;
break;
}
}
return FALSE;
}
else
info->used_tables |= this->used_tables();
Field_enumerator *fe= (Field_enumerator*)arg;
fe->see_field(field);
return FALSE;
}
......
sql/item.h
View file @ 854bb82b
......@@ -1017,7 +1017,7 @@ public:
bool eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs);
};
/* Data for Item::check_column_usage_processor */
#if 0
typedef struct
{
TABLE *table; /* Table of interest */
......@@ -1028,7 +1028,15 @@ typedef struct
/* [Set by processor] Parts of index of interest that expression refers to */
uint needed_key_parts;
} Field_processor_info;
#endif
/* Data for Item::check_column_usage_processor */
class Field_enumerator
{
public:
virtual void see_field(Field *field)= 0;
virtual ~Field_enumerator() {}; /* Shut up compiler warning */
};
class sp_head;
......
sql/opt_table_elimination.cc
View file @ 854bb82b
......@@ -13,6 +13,7 @@
#endif
#include "mysql_priv.h"
#include "my_bit.h"
#include "sql_select.h"
/*
......@@ -35,137 +36,691 @@
* Items that became disused because they were in the ON expression of an
eliminated outer join are notified by means of the Item tree walk which
calls Item::mark_as_eliminated_processor for every item
- At the moment the only Item that cares is Item_subselect with its
Item_subselect::eliminated flag which is used by EXPLAIN code to
check if the subquery should be shown in EXPLAIN.
- At the moment the only Item that cares whether it was eliminated is
Item_subselect with its Item_subselect::eliminated flag which is used
by EXPLAIN code to check if the subquery should be shown in EXPLAIN.
Table elimination is redone on every PS re-execution.
Table elimination is redone on every PS re-execution. (TODO reasons?)
*/
/*
A structure that represents a functional dependency of something over
something else. This can be one of:
1. A "tbl.field = expr" equality. The field depends on the expression.
2. An Item_equal(...) multi-equality. Each participating field depends on
every other participating field. (TODO???)
3. A UNIQUE_KEY(field1, field2, fieldN). The key depends on the fields that
it is composed of.
4. A table (which is within an outer join nest). Table depends on a unique
key (value of a unique key identifies a table record)
5. An outer join nest. It depends on all tables it contains.
*/
class Func_dep : public Sql_alloc
{
public:
enum {
FD_INVALID,
FD_EXPRESSION,
FD_FIELD,
FD_MULTI_EQUALITY,
FD_UNIQUE_KEY,
FD_TABLE,
FD_OUTER_JOIN
} type;
Func_dep *next;
bool bound;
Func_dep() : next(NULL), bound(FALSE) {}
};
class Field_dep;
class Table_dep;
class Outer_join_dep;
/*
An equality
- Depends on multiple fields (those in its expression), unknown_args is a
counter of unsatisfied dependencies.
*/
class Equality_dep : public Func_dep
{
public:
Field_dep *field;
Item *val;
uint level; /* Used during condition analysis only */
uint unknown_args; /* Number of yet unknown arguments */
};
/*
A field.
- Depends on table or equality
- Has expressions it participates as dependencies
There is no counter, bound fields are in $list, not bound are not.
*/
class Field_dep : public Func_dep
{
public:
Field_dep(Table_dep *table_arg, Field *field_arg) :
table(table_arg), field(field_arg)
{
type= Func_dep::FD_FIELD;
}
/* Table we're from. It also has pointers to keys that we're part of */
Table_dep *table;
Field *field;
Field_dep *next_table_field;
uint bitmap_offset; /* Offset of our part of the bitmap */
};
/*
A unique key.
- Depends on all its components
- Has its table as dependency
*/
class Key_dep: public Func_dep
{
public:
Key_dep(Table_dep *table_arg, uint keyno_arg, uint n_parts_arg) :
table(table_arg), keyno(keyno_arg), n_missing_keyparts(n_parts_arg),
next_table_key(NULL)
{
type= Func_dep::FD_UNIQUE_KEY;
}
Table_dep *table; /* Table this key is from */
uint keyno; // TODO do we care about this
uint n_missing_keyparts;
Key_dep *next_table_key;
};
/*
A table.
- Depends on any of its unique keys
- Has its fields and embedding outer join as dependency.
*/
class Table_dep : public Func_dep
{
public:
Table_dep(TABLE *table_arg) :
table(table_arg), fields(NULL), keys(NULL), outer_join_dep(NULL)
{
type= Func_dep::FD_TABLE;
}
TABLE *table;
Field_dep *fields; /* Fields that belong to this table */
Key_dep *keys; /* Unique keys */
Outer_join_dep *outer_join_dep;
};
/*
An outer join nest.
- Depends on all tables inside it.
- (And that's it).
*/
class Outer_join_dep: public Func_dep
{
public:
Outer_join_dep(TABLE_LIST *table_list_arg, table_map missing_tables_arg) :
table_list(table_list_arg), missing_tables(missing_tables_arg),
all_tables(missing_tables_arg), parent(NULL)
{
type= Func_dep::FD_OUTER_JOIN;
}
TABLE_LIST *table_list;
table_map missing_tables;
table_map all_tables;
Outer_join_dep *parent;
};
/* TODO need this? */
class Table_elimination
{
public:
Table_elimination(JOIN *join_arg) : join(join_arg)
{
bzero(table_deps, sizeof(table_deps));
}
JOIN *join;
/* Array of equality dependencies */
Equality_dep *equality_deps;
uint n_equality_deps; /* Number of elements in the array */
/* tablenr -> Table_dep* mapping. */
Table_dep *table_deps[MAX_KEY];
/* Outer joins that are candidates for elimination */
List<Outer_join_dep> oj_deps;
/* Bitmap of how expressions depend on bits */
MY_BITMAP expr_deps;
};
static
void build_funcdeps_for_cond(Table_elimination *te, Equality_dep **fdeps,
uint *and_level, Item *cond,
table_map usable_tables);
static
void add_funcdep(Table_elimination *te,
Equality_dep **eq_dep, uint and_level,
Item_func *cond, Field *field,
bool eq_func, Item **value,
uint num_values, table_map usable_tables);
static
Equality_dep *merge_func_deps(Equality_dep *start, Equality_dep *new_fields,
Equality_dep *end, uint and_level);
Field_dep *get_field_dep(Table_elimination *te, Field *field);
void eliminate_tables(JOIN *join);
static void mark_as_eliminated(JOIN *join, TABLE_LIST *tbl);
static bool table_has_one_match(TABLE *table, table_map bound_tables,
bool *multiple_matches);
static uint
eliminate_tables_for_list(JOIN *join, TABLE **leaves_arr,
List<TABLE_LIST> *join_list,
bool its_outer_join,
table_map tables_in_list,
table_map tables_used_elsewhere,
bool *multiple_matches);
static bool
extra_keyuses_bind_all_keyparts(table_map bound_tables, TABLE *table,
KEYUSE *key_start, KEYUSE *key_end,
uint n_keyuses, table_map bound_parts);
#ifndef DBUG_OFF
static void dbug_print_deps(Table_elimination *te);
#endif
/*******************************************************************************************/
/*
Perform table elimination
Produce FUNC_DEP elements for the given item (i.e. condition) and add them
to fdeps array.
SYNOPSIS
eliminate_tables()
join Join to work on
const_tbl_count INOUT Number of constant tables (this includes
eliminated tables)
const_tables INOUT Bitmap of constant tables
build_funcdeps_for_cond()
fdeps INOUT Put created FUNC_DEP structures here
DESCRIPTION
This function is the entry point for table elimination.
The idea behind table elimination is that if we have an outer join:
a
SELECT * FROM t1 LEFT JOIN
(t2 JOIN t3) ON t3.primary_key=t1.col AND
t4.primary_key=t2.col
such that
SEE ALSO
add_key_fields()
1. columns of the inner tables are not used anywhere ouside the outer
join (not in WHERE, not in GROUP/ORDER BY clause, not in select list
etc etc), and
2. inner side of the outer join is guaranteed to produce at most one
record combination for each record combination of outer tables.
*/
static
void build_funcdeps_for_cond(Table_elimination *te,
Equality_dep **fdeps, uint *and_level, Item *cond,
table_map usable_tables)
{
if (cond->type() == Item_func::COND_ITEM)
{
List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
Equality_dep *org_key_fields= *fdeps;
then the inner side of the outer join can be removed from the query.
This is because it will always produce one matching record (either a
real match or a NULL-complemented record combination), and since there
are no references to columns of the inner tables anywhere, it doesn't
matter which record combination it was.
/* AND/OR */
if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
{
Item *item;
while ((item=li++))
{
build_funcdeps_for_cond(te, fdeps, and_level, item, usable_tables);
}
/*
TODO: inject here a "if we have {t.col=const AND t.col=smth_else}, then
remove the second part" logic.
*/
for (; org_key_fields != *fdeps ; org_key_fields++)
org_key_fields->level= *and_level;
}
else
{
(*and_level)++;
build_funcdeps_for_cond(te, fdeps, and_level, li++, usable_tables);
Item *item;
while ((item=li++))
{
Equality_dep *start_key_fields= *fdeps;
(*and_level)++;
build_funcdeps_for_cond(te, fdeps, and_level, item, usable_tables);
*fdeps= merge_func_deps(org_key_fields, start_key_fields, *fdeps,
++(*and_level));
}
}
return;
}
This function primary handles checking #1. It collects a bitmap of
tables that are not used in select list/GROUP BY/ORDER BY/HAVING/etc and
thus can possibly be eliminated.
if (cond->type() != Item::FUNC_ITEM)
return;
Item_func *cond_func= (Item_func*) cond;
switch (cond_func->select_optimize()) {
case Item_func::OPTIMIZE_NONE:
break;
case Item_func::OPTIMIZE_KEY:
{
Item **values;
// BETWEEN, IN, NE
if (cond_func->key_item()->real_item()->type() == Item::FIELD_ITEM &&
!(cond_func->used_tables() & OUTER_REF_TABLE_BIT))
{
values= cond_func->arguments()+1;
if (cond_func->functype() == Item_func::NE_FUNC &&
cond_func->arguments()[1]->real_item()->type() == Item::FIELD_ITEM &&
!(cond_func->arguments()[0]->used_tables() & OUTER_REF_TABLE_BIT))
values--;
DBUG_ASSERT(cond_func->functype() != Item_func::IN_FUNC ||
cond_func->argument_count() != 2);
add_funcdep(te, fdeps, *and_level, cond_func,
((Item_field*)(cond_func->key_item()->real_item()))->field,
0, values,
cond_func->argument_count()-1,
usable_tables);
}
if (cond_func->functype() == Item_func::BETWEEN)
{
values= cond_func->arguments();
for (uint i= 1 ; i < cond_func->argument_count() ; i++)
{
Item_field *field_item;
if (cond_func->arguments()[i]->real_item()->type() == Item::FIELD_ITEM
&&
!(cond_func->arguments()[i]->used_tables() & OUTER_REF_TABLE_BIT))
{
field_item= (Item_field *) (cond_func->arguments()[i]->real_item());
add_funcdep(te, fdeps, *and_level, cond_func,
field_item->field, 0, values, 1, usable_tables);
}
}
}
break;
}
case Item_func::OPTIMIZE_OP:
{
bool equal_func=(cond_func->functype() == Item_func::EQ_FUNC ||
cond_func->functype() == Item_func::EQUAL_FUNC);
SIDE EFFECTS
See the OVERVIEW section at the top of this file.
if (cond_func->arguments()[0]->real_item()->type() == Item::FIELD_ITEM &&
!(cond_func->arguments()[0]->used_tables() & OUTER_REF_TABLE_BIT))
{
add_funcdep(te, fdeps, *and_level, cond_func,
((Item_field*)(cond_func->arguments()[0])->real_item())->field,
equal_func,
cond_func->arguments()+1, 1, usable_tables);
}
if (cond_func->arguments()[1]->real_item()->type() == Item::FIELD_ITEM &&
cond_func->functype() != Item_func::LIKE_FUNC &&
!(cond_func->arguments()[1]->used_tables() & OUTER_REF_TABLE_BIT))
{
add_funcdep(te, fdeps, *and_level, cond_func,
((Item_field*)(cond_func->arguments()[1])->real_item())->field,
equal_func,
cond_func->arguments(),1,usable_tables);
}
break;
}
case Item_func::OPTIMIZE_NULL:
/* column_name IS [NOT] NULL */
if (cond_func->arguments()[0]->real_item()->type() == Item::FIELD_ITEM &&
!(cond_func->used_tables() & OUTER_REF_TABLE_BIT))
{
Item *tmp=new Item_null;
if (unlikely(!tmp)) // Should never be true
return;
add_funcdep(te, fdeps, *and_level, cond_func,
((Item_field*)(cond_func->arguments()[0])->real_item())->field,
cond_func->functype() == Item_func::ISNULL_FUNC,
&tmp, 1, usable_tables);
}
break;
case Item_func::OPTIMIZE_EQUAL:
Item_equal *item_equal= (Item_equal *) cond;
Item *const_item= item_equal->get_const();
Item_equal_iterator it(*item_equal);
Item_field *item;
if (const_item)
{
/*
For each field field1 from item_equal consider the equality
field1=const_item as a condition allowing an index access of the table
with field1 by the keys value of field1.
*/
while ((item= it++))
{
add_funcdep(te, fdeps, *and_level, cond_func, item->field,
TRUE, &const_item, 1, usable_tables);
}
}
else
{
/*
Consider all pairs of different fields included into item_equal.
For each of them (field1, field1) consider the equality
field1=field2 as a condition allowing an index access of the table
with field1 by the keys value of field2.
*/
Item_equal_iterator fi(*item_equal);
while ((item= fi++))
{
Field *field= item->field;
while ((item= it++))
{
if (!field->eq(item->field))
{
add_funcdep(te, fdeps, *and_level, cond_func, field/*item*/,
TRUE, (Item **) &item, 1, usable_tables);
}
}
it.rewind();
}
}
break;
}
}
/*
Perform an OR operation on two (adjacent) FUNC_DEP arrays.
SYNOPSIS
merge_func_deps()
DESCRIPTION
This function is invoked for two adjacent arrays of FUNC_DEP elements:
$LEFT_PART $RIGHT_PART
+-----------------------+-----------------------+
start new_fields end
The goal is to produce an array which would correspnd to the combined
$LEFT_PART OR $RIGHT_PART
condition. This is achieved as follows: First, we apply distrubutive law:
(fdep_A_1 AND fdep_A_2 AND ...) OR (fdep_B_1 AND fdep_B_2 AND ...) =
= AND_ij (fdep_A_[i] OR fdep_B_[j])
Then we walk over the obtained "fdep_A_[i] OR fdep_B_[j]" pairs, and
- Discard those that that have left and right part referring to different
columns. We can't infer anything useful from "col1=expr1 OR col2=expr2".
- When left and right parts refer to the same column, we check if they are
essentially the same.
= If they are the same, we keep one copy
"t.col=expr OR t.col=expr" -> "t.col=expr
= if they are different , then we discard both
"t.col=expr1 OR t.col=expr2" -> (nothing useful)
(no per-table or for-index FUNC_DEPS exist yet at this phase).
See also merge_key_fields().
RETURN
End of the result array
*/
void eliminate_tables(JOIN *join)
static
Equality_dep *merge_func_deps(Equality_dep *start, Equality_dep *new_fields,
Equality_dep *end, uint and_level)
{
Item *item;
table_map used_tables;
DBUG_ENTER("eliminate_tables");
if (start == new_fields)
return start; // Impossible or
if (new_fields == end)
return start; // No new fields, skip all
DBUG_ASSERT(join->eliminated_tables == 0);
Equality_dep *first_free=new_fields;
/* If there are no outer joins, we have nothing to eliminate: */
if (!join->outer_join)
DBUG_VOID_RETURN;
for (; new_fields != end ; new_fields++)
{
for (Equality_dep *old=start ; old != first_free ; old++)
{
/*
TODO: does it make sense to attempt to merging multiple-equalities?
A: YES.
(a=b=c) OR (a=b=d) produce "a=b".
QQ:
What to use for merging? Trivial N*M algorithm or pre-sort and then
merge ordered sequences?
*/
if (old->field == new_fields->field)
{
if (!new_fields->val->const_item())
{
/*
If the value matches, we can use the key reference.
If not, we keep it until we have examined all new values
*/
if (old->val->eq(new_fields->val, old->field->field->binary()))
{
old->level= and_level;
}
}
else if (old->val->eq_by_collation(new_fields->val,
old->field->field->binary(),
old->field->field->charset()))
{
old->level= and_level;
}
else
{
/* The expressions are different. */
if (old == --first_free) // If last item
break;
*old= *first_free; // Remove old value
old--; // Retry this value
}
}
}
}
/* Find the tables that are referred to from WHERE/HAVING */
used_tables= (join->conds? join->conds->used_tables() : 0) |
(join->having? join->having->used_tables() : 0);
/*
Ok, the results are within the [start, first_free) range, and the useful
elements have level==and_level. Now, lets remove all unusable elements:
*/
for (Equality_dep *old=start ; old != first_free ;)
{
if (old->level != and_level)
{ // Not used in all levels
if (old == --first_free)
break;
*old= *first_free; // Remove old value
continue;
}
old++;
}
return first_free;
}
/* Add tables referred to from the select list */
List_iterator<Item> it(join->fields_list);
while ((item= it++))
used_tables |= item->used_tables();
/* Add tables referred to from ORDER BY and GROUP BY lists */
ORDER *all_lists[]= { join->order, join->group_list};
for (int i=0; i < 2; i++)
/*
Add a funcdep for a given equality.
*/
static
void add_funcdep(Table_elimination *te,
Equality_dep **eq_dep, uint and_level,
Item_func *cond, Field *field,
bool eq_func, Item **value,
uint num_values, table_map usable_tables)
{
// Field *field= item_field->field;
if (!(field->table->map & usable_tables))
return;
for (uint i=0; i<num_values; i++)
{
for (ORDER *cur_list= all_lists[i]; cur_list; cur_list= cur_list->next)
used_tables |= (*(cur_list->item))->used_tables();
if ((value[i])->used_tables() & RAND_TABLE_BIT)
return;
}
THD* thd= join->thd;
if (join->select_lex == &thd->lex->select_lex)
/*
Save the following cases:
Field op constant
Field LIKE constant where constant doesn't start with a wildcard
Field = field2 where field2 is in a different table
Field op formula
Field IS NULL
Field IS NOT NULL
Field BETWEEN ...
Field IN ...
*/
/*
We can't always use indexes when comparing a string index to a
number. cmp_type() is checked to allow compare of dates to numbers.
eq_func is NEVER true when num_values > 1
*/
if (!eq_func)
{
/* Multi-table UPDATE and DELETE: don't eliminate the tables we modify: */
used_tables |= thd->table_map_for_update;
/*
Additional optimization: if we're processing "t.key BETWEEN c1 AND c1"
then proceed as if we were processing "t.key = c1".
*/
if ((cond->functype() != Item_func::BETWEEN) ||
((Item_func_between*) cond)->negated ||
!value[0]->eq(value[1], field->binary()))
return;
eq_func= TRUE;
}
/* Multi-table UPDATE: don't eliminate tables referred from SET statement */
if (thd->lex->sql_command == SQLCOM_UPDATE_MULTI)
if (field->result_type() == STRING_RESULT)
{
List_iterator<Item> it2(thd->lex->value_list);
while ((item= it2++))
used_tables |= item->used_tables();
if ((*value)->result_type() != STRING_RESULT)
{
if (field->cmp_type() != (*value)->result_type())
return;
}
else
{
/*
We can't use indexes if the effective collation
of the operation differ from the field collation.
*/
if (field->cmp_type() == STRING_RESULT &&
((Field_str*)field)->charset() != cond->compare_collation())
return;
}
}
table_map all_tables= join->all_tables_map();
if (all_tables & ~used_tables)
DBUG_ASSERT(eq_func);
/* Store possible eq field */
(*eq_dep)->type= Func_dep::FD_EXPRESSION; //psergey-todo;
(*eq_dep)->field= get_field_dep(te, field);
(*eq_dep)->val= *value;
(*eq_dep)->level= and_level;
(*eq_dep)++;
}
Table_dep *get_table_dep(Table_elimination *te, TABLE *table)
{
Table_dep *tbl_dep= new Table_dep(table);
Key_dep **key_list= &(tbl_dep->keys);
/* Add dependencies for unique keys */
for (uint i=0; i < table->s->keys; i++)
{
/* There are some tables that we probably could eliminate. Try it. */
TABLE *leaves_array[MAX_TABLES];
bool multiple_matches= FALSE;
eliminate_tables_for_list(join, leaves_array, join->join_list, FALSE,
all_tables, used_tables, &multiple_matches);
KEY *key= table->key_info + i;
if ((key->flags & (HA_NOSAME | HA_END_SPACE_KEY)) == HA_NOSAME)
{
Key_dep *key_dep= new Key_dep(tbl_dep, i, key->key_parts);
*key_list= key_dep;
key_list= &(key_dep->next_table_key);
}
DBUG_VOID_RETURN;
}
return te->table_deps[table->tablenr] = tbl_dep;
}
/*
Given a field, get its dependency element: if it already exists, find it,
otherwise create it.
*/
Field_dep *get_field_dep(Table_elimination *te, Field *field)
{
TABLE *table= field->table;
Table_dep *tbl_dep;
if (!(tbl_dep= te->table_deps[table->tablenr]))
tbl_dep= get_table_dep(te, table);
Field_dep **pfield= &(tbl_dep->fields);
while (*pfield && (*pfield)->field->field_index < field->field_index)
{
pfield= &((*pfield)->next_table_field);
}
if (*pfield && (*pfield)->field->field_index == field->field_index)
return *pfield;
Field_dep *new_field= new Field_dep(tbl_dep, field);
new_field->next_table_field= *pfield;
*pfield= new_field;
return new_field;
}
Outer_join_dep *get_outer_join_dep(Table_elimination *te,
TABLE_LIST *outer_join, table_map deps_map)
{
Outer_join_dep *oj_dep;
oj_dep= new Outer_join_dep(outer_join, deps_map);
Table_map_iterator it(deps_map);
int idx;
while ((idx= it.next_bit()) != Table_map_iterator::BITMAP_END)
{
Table_dep *table_dep;
if (!(table_dep= te->table_deps[idx]))
{
TABLE *table= NULL;
/*
Locate and create the table. The search isnt very efficient but
typically we won't get here as we process the ON expression first
and that will create the Table_dep
*/
for (uint i= 0; i < te->join->tables; i++)
{
if (te->join->join_tab[i].table->tablenr == (uint)idx)
{
table= te->join->join_tab[i].table;
break;
}
}
DBUG_ASSERT(table);
table_dep= get_table_dep(te, table);
}
if (!table_dep->outer_join_dep)
table_dep->outer_join_dep= oj_dep;
else
{
Outer_join_dep *oj= table_dep->outer_join_dep;
while (oj->parent)
oj= oj->parent;
oj->parent=oj_dep;
}
}
return oj_dep;
}
/*
Perform table elimination in a given join list
SYNOPSIS
eliminate_tables_for_list()
join The join
leaves_arr OUT Store here an array of leaf (base) tables that
are descendants of the join_list, and increment
the pointer to point right above the array.
collect_funcdeps_for_join_list()
te Table elimination context.
join_list Join list to work on
its_outer_join TRUE <=> join_list is an inner side of an outer
join
FALSE <=> otherwise (this is top-level join list)
its_outer_join TRUE <=> the join_list is an inner side of an
outer join
FALSE <=> otherwise (this is top-level join
list, simplify_joins flattens out all
other kinds of join lists)
tables_in_list Bitmap of tables embedded in the join_list.
tables_used_elsewhere Bitmap of tables that are referred to from
somewhere outside of the join list (e.g.
......@@ -182,20 +737,18 @@ void eliminate_tables(JOIN *join)
Number of children left after elimination. 0 means everything was
eliminated.
*/
static uint
eliminate_tables_for_list(JOIN *join, TABLE **leaves_arr,
collect_funcdeps_for_join_list(Table_elimination *te,
List<TABLE_LIST> *join_list,
bool its_outer_join,
table_map tables_in_list,
bool build_eq_deps,
table_map tables_used_elsewhere,
bool *multiple_matches)
table_map *eliminable_tables,
Equality_dep **eq_dep)
{
TABLE_LIST *tbl;
List_iterator<TABLE_LIST> it(*join_list);
table_map tables_used_on_left= 0;
TABLE **cur_table= leaves_arr;
bool children_have_multiple_matches= FALSE;
uint remaining_children= 0;
while ((tbl= it++))
{
......@@ -203,253 +756,390 @@ eliminate_tables_for_list(JOIN *join, TABLE **leaves_arr,
{
table_map outside_used_tables= tables_used_elsewhere |
tables_used_on_left;
bool multiple_matches= FALSE;
bool eliminable;
table_map cur_map;
if (tbl->nested_join)
{
/* This is "... LEFT JOIN (join_nest) ON cond" */
uint n;
if (!(n= eliminate_tables_for_list(join, cur_table,
&tbl->nested_join->join_list, TRUE,
tbl->nested_join->used_tables,
cur_map= tbl->nested_join->used_tables;
eliminable= !(cur_map & outside_used_tables);
if (eliminable)
*eliminable_tables |= cur_map;
collect_funcdeps_for_join_list(te, &tbl->nested_join->join_list,
eliminable || build_eq_deps,
outside_used_tables,
&multiple_matches)))
{
mark_as_eliminated(join, tbl);
}
else
remaining_children++;
tbl->nested_join->n_tables= n;
eliminable_tables,
eq_dep);
}
else
{
/* This is "... LEFT JOIN tbl ON cond" */
if (!(tbl->table->map & outside_used_tables) &&
table_has_one_match(tbl->table, join->all_tables_map(),
&multiple_matches))
{
mark_as_eliminated(join, tbl);
cur_map= tbl->table->map;
eliminable= !(tbl->table->map & outside_used_tables);
*eliminable_tables |= cur_map;
}
else
remaining_children++;
if (eliminable || build_eq_deps)
{
// build comp_cond from ON expression
uint and_level=0;
build_funcdeps_for_cond(te, eq_dep, &and_level, tbl->on_expr,
*eliminable_tables);
}
if (eliminable)
te->oj_deps.push_back(get_outer_join_dep(te, tbl, cur_map));
tables_used_on_left |= tbl->on_expr->used_tables();
children_have_multiple_matches= children_have_multiple_matches ||
multiple_matches;
}
else
{
DBUG_ASSERT(!tbl->nested_join);
remaining_children++;
}
return 0;
}
if (tbl->table)
*(cur_table++)= tbl->table;
}
/*
Analyze exising FUNC_DEP array and add elements for tables and uniq keys
SYNOPSIS
*multiple_matches |= children_have_multiple_matches;
DESCRIPTION
Add FUNC_DEP elements
RETURN
.
*/
/* Try eliminating the nest we're called for */
if (its_outer_join && !children_have_multiple_matches &&
!(tables_in_list & tables_used_elsewhere))
class Field_dependency_setter : public Field_enumerator
{
public:
Field_dependency_setter(Table_elimination *te_arg): te(te_arg)
{}
void see_field(Field *field)
{
table_map bound_tables= join->const_table_map | (join->all_tables_map() &
~tables_in_list);
table_map old_bound_tables;
TABLE **leaves_end= cur_table;
/*
Do the same as const table search table: try to expand the set of bound
tables until it covers all tables in the join_list
*/
do
Table_dep *tbl_dep;
if ((tbl_dep= te->table_deps[field->table->tablenr]))
{
for (Field_dep *field_dep= tbl_dep->fields; field_dep;
field_dep= field_dep->next_table_field)
{
if (field->field_index == field_dep->field->field_index)
{
uint offs= field_dep->bitmap_offset + expr_offset;
if (!bitmap_is_set(&te->expr_deps, offs))
te->equality_deps[expr_offset].unknown_args++;
bitmap_set_bit(&te->expr_deps, offs);
return;
}
}
/* We didn't find the field. Bump the dependency anyway */
te->equality_deps[expr_offset].unknown_args++;
}
}
Table_elimination *te;
uint expr_offset; /* Offset of the expression we're processing */
};
static
bool setup_equality_deps(Table_elimination *te, Func_dep **bound_deps_list)
{
DBUG_ENTER("setup_equality_deps");
uint offset= 0;
for (Table_dep **tbl_dep=te->table_deps;
tbl_dep < te->table_deps + MAX_TABLES;
tbl_dep++)
{
old_bound_tables= bound_tables;
for (cur_table= leaves_arr; cur_table != leaves_end; cur_table++)
if (*tbl_dep)
{
if (!((*cur_table)->map & join->eliminated_tables) &&
table_has_one_match(*cur_table, bound_tables, multiple_matches))
for (Field_dep *field_dep= (*tbl_dep)->fields;
field_dep;
field_dep= field_dep->next_table_field)
{
bound_tables |= (*cur_table)->map;
field_dep->bitmap_offset= offset;
offset += te->n_equality_deps;
}
}
}
} while (old_bound_tables != bound_tables);
if (!(tables_in_list & ~bound_tables))
void *buf;
if (!(buf= current_thd->alloc(bitmap_buffer_size(offset))) ||
bitmap_init(&te->expr_deps, (my_bitmap_map*)buf, offset, FALSE))
{
DBUG_RETURN(TRUE);
}
bitmap_clear_all(&te->expr_deps);
/*
This join_list can be eliminated. Signal about this to the caller by
returning number of tables.
Walk through all field=expr elements and collect all fields.
*/
remaining_children= 0;
Func_dep *bound_dep= NULL;
Field_dependency_setter deps_setter(te);
for (Equality_dep *eq_dep= te->equality_deps;
eq_dep < te->equality_deps + te->n_equality_deps;
eq_dep++)
{
deps_setter.expr_offset= eq_dep - te->equality_deps;
eq_dep->unknown_args= 0;
eq_dep->val->walk(&Item::check_column_usage_processor, FALSE,
(uchar*)&deps_setter);
if (!eq_dep->unknown_args)
{
eq_dep->next= bound_dep;
bound_dep= eq_dep;
eq_dep->bound= TRUE;
}
}
return remaining_children;
*bound_deps_list= bound_dep;
DBUG_EXECUTE("test", dbug_print_deps(te); );
DBUG_RETURN(FALSE);
}
/*
Check if the table will produce at most one matching record
Perform table elimination
SYNOPSIS
table_has_one_match()
table The [base] table being checked
bound_tables Tables that should be considered bound.
multiple_matches OUT Set to TRUE when there is no way we could
find find a limitation that would give us one-match
property.
eliminate_tables()
join Join to work on
const_tbl_count INOUT Number of constant tables (this includes
eliminated tables)
const_tables INOUT Bitmap of constant tables
DESCRIPTION
Check if table will produce at most one matching record for each record
combination of tables in bound_tables bitmap.
The check is based on ref analysis data, KEYUSE structures. We're
handling two cases:
This function is the entry point for table elimination.
The idea behind table elimination is that if we have an outer join:
1. Table has a UNIQUE KEY(uk_col_1, ... uk_col_N), and for each uk_col_i
there is a KEYUSE that represents a limitation in form
SELECT * FROM t1 LEFT JOIN
(t2 JOIN t3) ON t3.primary_key=t1.col AND
t4.primary_key=t2.col
such that
table.uk_col_i = func(bound_tables) (X)
1. columns of the inner tables are not used anywhere ouside the outer
join (not in WHERE, not in GROUP/ORDER BY clause, not in select list
etc etc), and
2. inner side of the outer join is guaranteed to produce at most one
record combination for each record combination of outer tables.
2. Same as above but we also handle limitations in form
then the inner side of the outer join can be removed from the query.
This is because it will always produce one matching record (either a
real match or a NULL-complemented record combination), and since there
are no references to columns of the inner tables anywhere, it doesn't
matter which record combination it was.
table.uk_col_i = func(bound_tables, uk_col_j1, ... uk_col_j2) (XX)
This function primary handles checking #1. It collects a bitmap of
tables that are not used in select list/GROUP BY/ORDER BY/HAVING/etc and
thus can possibly be eliminated.
where values of uk_col_jN are known to be bound because for them we
have an equality of form (X) or (XX).
SIDE EFFECTS
See the OVERVIEW section at the top of this file.
RETURN
TRUE Yes, at most one match
FALSE No
*/
static bool table_has_one_match(TABLE *table, table_map bound_tables,
bool *multiple_matches)
void eliminate_tables(JOIN *join)
{
KEYUSE *keyuse= table->reginfo.join_tab->keyuse;
if (keyuse)
{
while (keyuse->table == table)
{
uint key= keyuse->key;
key_part_map bound_parts=0;
uint n_unusable=0;
bool ft_key= test(keyuse->keypart == FT_KEYPART);
KEY *keyinfo= table->key_info + key;
KEYUSE *key_start = keyuse;
THD* thd= join->thd;
Item *item;
table_map used_tables;
DBUG_ENTER("eliminate_tables");
do /* For each keypart and each way to read it */
{
if (keyuse->type == KEYUSE_USABLE)
{
if(!(keyuse->used_tables & ~bound_tables) &&
!(keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL))
DBUG_ASSERT(join->eliminated_tables == 0);
/* If there are no outer joins, we have nothing to eliminate: */
if (!join->outer_join)
DBUG_VOID_RETURN;
/* Find the tables that are referred to from WHERE/HAVING */
used_tables= (join->conds? join->conds->used_tables() : 0) |
(join->having? join->having->used_tables() : 0);
/* Add tables referred to from the select list */
List_iterator<Item> it(join->fields_list);
while ((item= it++))
used_tables |= item->used_tables();
/* Add tables referred to from ORDER BY and GROUP BY lists */
ORDER *all_lists[]= { join->order, join->group_list};
for (int i=0; i < 2; i++)
{
bound_parts |= keyuse->keypart_map;
}
for (ORDER *cur_list= all_lists[i]; cur_list; cur_list= cur_list->next)
used_tables |= (*(cur_list->item))->used_tables();
}
else
n_unusable++;
keyuse++;
} while (keyuse->table == table && keyuse->key == key);
if (ft_key || ((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY))
!= HA_NOSAME))
if (join->select_lex == &thd->lex->select_lex)
{
continue;
}
/* Multi-table UPDATE and DELETE: don't eliminate the tables we modify: */
used_tables |= thd->table_map_for_update;
if (bound_parts == PREV_BITS(key_part_map, keyinfo->key_parts) ||
extra_keyuses_bind_all_keyparts(bound_tables, table, key_start,
keyuse, n_unusable, bound_parts))
/* Multi-table UPDATE: don't eliminate tables referred from SET statement */
if (thd->lex->sql_command == SQLCOM_UPDATE_MULTI)
{
return TRUE;
}
List_iterator<Item> it2(thd->lex->value_list);
while ((item= it2++))
used_tables |= item->used_tables();
}
}
return FALSE;
}
table_map all_tables= join->all_tables_map();
if (all_tables & ~used_tables)
{
/* There are some tables that we probably could eliminate. Try it. */
Table_elimination te(join);
uint m= max(thd->lex->current_select->max_equal_elems,1);
uint max_elems= ((thd->lex->current_select->cond_count+1)*2 +
thd->lex->current_select->between_count)*m + 1 + 10;
if (!(te.equality_deps= new Equality_dep[max_elems]))
DBUG_VOID_RETURN;
Equality_dep *eq_deps_end= te.equality_deps;
table_map eliminable_tables= 0;
collect_funcdeps_for_join_list(&te, join->join_list,
FALSE,
used_tables,
&eliminable_tables,
&eq_deps_end);
te.n_equality_deps= eq_deps_end - te.equality_deps;
Func_dep *bound_dep;
setup_equality_deps(&te, &bound_dep);
/*
Check if KEYUSE elemements with unusable==TRUE bind all parts of the key
SYNOPSIS
extra_keyuses_bind_all_keyparts()
bound_tables Tables which can be considered constants
table Table we're examining
key_start Start of KEYUSE array with elements describing the key
of interest
key_end End of the array + 1
n_keyuses Number of elements in the array that have unusable==TRUE
bound_parts Key parts whose values are known to be bound.
DESCRIPTION
Check if unusable KEYUSE elements cause all parts of key to be bound. An
unusable keyuse element makes a keypart bound when it
represents the following:
keyXpartY=func(bound_columns, preceding_tables)
RETURN
TRUE Yes, at most one match
FALSE No
*/
static bool
extra_keyuses_bind_all_keyparts(table_map bound_tables, TABLE *table,
KEYUSE *key_start, KEYUSE *key_end,
uint n_keyuses, table_map bound_parts)
{
/*
We need
- some 'unusable' KEYUSE elements to work on
- some keyparts to be already bound to start inferences:
Run the wave.
All Func_dep-derived objects are divided into three classes:
- Those that have bound=FALSE
- Those that have bound=TRUE
- Those that have bound=TRUE and are in the list..
*/
if (n_keyuses && bound_parts)
while (bound_dep)
{
KEY *keyinfo= table->key_info + key_start->key;
bool bound_more_parts;
do
Func_dep *next= bound_dep->next;
//e= list.remove_first();
switch (bound_dep->type)
{
bound_more_parts= FALSE;
for (KEYUSE *k= key_start; k!=key_end; k++)
case Func_dep::FD_EXPRESSION:
{
if (k->type == KEYUSE_UNKNOWN)
/* It's a field=expr and we got to know the expr, so we know the field */
Equality_dep *eq_dep= (Equality_dep*)bound_dep;
if (!eq_dep->field->bound)
{
Field_processor_info fp= {table, k->key, k->keypart, 0, 0};
if (k->val->walk(&Item::check_column_usage_processor, FALSE,
(uchar*)&fp))
k->type= KEYUSE_NO_BIND;
else
/* Mark as bound and add to the list */
eq_dep->field->bound= TRUE;
eq_dep->field->next= next;
next= eq_dep->field;
}
break;
}
case Func_dep::FD_FIELD:
{
/*
Field became known. Check out
- unique keys we belong to
- expressions that depend on us.
*/
Field_dep *field_dep= (Field_dep*)bound_dep;
for (Key_dep *key_dep= field_dep->table->keys; key_dep;
key_dep= key_dep->next_table_key)
{
DBUG_PRINT("info", ("key %s.%s is now bound",
key_dep->table->table->alias,
key_dep->table->table->key_info[key_dep->keyno].name));
if (!key_dep->bound)
{
if (!--key_dep->n_missing_keyparts)
{
k->used_tables= fp.used_tables;
k->keypart_map= fp.needed_key_parts;
k->type= KEYUSE_BIND;
/* Mark as bound and add to the list */
key_dep->bound= TRUE;
key_dep->next= next;
next= key_dep;
}
}
}
if (k->type == KEYUSE_BIND)
/* Now, expressions */
for (uint i=0; i < te.n_equality_deps; i++)
{
if (bitmap_is_set(&te.expr_deps, field_dep->bitmap_offset + i))
{
Equality_dep* eq_dep= &te.equality_deps[i];
if (!--eq_dep->unknown_args)
{
/* Mark as bound and add to the list */
eq_dep->bound= TRUE;
eq_dep->next= next;
next= eq_dep;
}
}
}
break;
}
case Func_dep::FD_UNIQUE_KEY:
{
/* Unique key is known means the table is known */
Table_dep *table_dep=((Key_dep*)bound_dep)->table;
if (!table_dep->bound)
{
/* Mark as bound and add to the list */
table_dep->bound= TRUE;
table_dep->next= next;
next= table_dep;
}
break;
}
case Func_dep::FD_TABLE:
{
Table_dep *table_dep=(Table_dep*)bound_dep;
DBUG_PRINT("info", ("table %s is now bound",
table_dep->table->alias));
/*
If this is a binding keyuse, such that
- all tables it refers to are bound,
- all parts it refers to are bound
- but the key part it binds is not itself bound
Table is known means
- all its fields are known
- one more element in outer join nest is known
*/
if (!(k->used_tables & ~bound_tables) &&
!(k->keypart_map & ~bound_parts) &&
!(bound_parts & key_part_map(1) << k->keypart))
for (Field_dep *field_dep= table_dep->fields; field_dep;
field_dep= field_dep->next_table_field)
{
if (!field_dep->bound)
{
/* Mark as bound and add to the list */
field_dep->bound= TRUE;
field_dep->next= next;
next= field_dep;
}
}
Outer_join_dep *outer_join_dep= table_dep->outer_join_dep;
if (!(outer_join_dep->missing_tables &= ~table_dep->table->map))
{
/* Mark as bound and add to the list */
outer_join_dep->bound= TRUE;
outer_join_dep->next= next;
next= outer_join_dep;
}
break;
}
case Func_dep::FD_OUTER_JOIN:
{
bound_parts|= key_part_map(1) << k->keypart;
if (bound_parts == PREV_BITS(key_part_map, keyinfo->key_parts))
return TRUE;
bound_more_parts= TRUE;
Outer_join_dep *outer_join_dep= (Outer_join_dep*)bound_dep;
/* TODO what do here? Stop if eliminated the top-level? */
mark_as_eliminated(te.join, outer_join_dep->table_list);
Outer_join_dep *parent= outer_join_dep->parent;
if (parent &&
!(parent->missing_tables &= ~outer_join_dep->all_tables))
{
/* Mark as bound and add to the list */
parent->bound= TRUE;
parent->next= next;
next= parent;
}
break;
}
case Func_dep::FD_MULTI_EQUALITY:
default:
DBUG_ASSERT(0);
}
bound_dep= next;
}
} while (bound_more_parts);
}
return FALSE;
DBUG_VOID_RETURN;
}
......@@ -488,6 +1178,96 @@ static void mark_as_eliminated(JOIN *join, TABLE_LIST *tbl)
tbl->on_expr->walk(&Item::mark_as_eliminated_processor, FALSE, NULL);
}
#ifndef DBUG_OFF
static
void dbug_print_deps(Table_elimination *te)
{
DBUG_ENTER("dbug_print_deps");
DBUG_LOCK_FILE;
fprintf(DBUG_FILE,"deps {\n");
/* Start with printing equalities */
for (Equality_dep *eq_dep= te->equality_deps;
eq_dep != te->equality_deps + te->n_equality_deps; eq_dep++)
{
char buf[128];
String str(buf, sizeof(buf), &my_charset_bin);
str.length(0);
eq_dep->val->print(&str, QT_ORDINARY);
fprintf(DBUG_FILE, " equality%d: %s -> %s.%s\n",
eq_dep - te->equality_deps,
str.c_ptr(),
eq_dep->field->table->table->alias,
eq_dep->field->field->field_name);
}
fprintf(DBUG_FILE,"\n");
/* Then tables and their fields */
for (uint i=0; i < MAX_TABLES; i++)
{
Table_dep *table_dep;
if ((table_dep= te->table_deps[i]))
{
/* Print table */
fprintf(DBUG_FILE, " table %s\n", table_dep->table->alias);
/* Print fields */
for (Field_dep *field_dep= table_dep->fields; field_dep;
field_dep= field_dep->next_table_field)
{
fprintf(DBUG_FILE, " field %s.%s ->", table_dep->table->alias,
field_dep->field->field_name);
uint ofs= field_dep->bitmap_offset;
for (uint bit= ofs; bit < ofs + te->n_equality_deps; bit++)
{
if (bitmap_is_set(&te->expr_deps, bit))
fprintf(DBUG_FILE, " equality%d ", bit - ofs);
}
fprintf(DBUG_FILE, "\n");
}
}
}
fprintf(DBUG_FILE,"\n}\n");
DBUG_UNLOCK_FILE;
DBUG_VOID_RETURN;
}
#endif
/***********************************************************************************************/
#if 0
static void dbug_print_fdep(FUNC_DEP *fd)
{
switch (fd->type) {
case FUNC_DEP::FD_OUTER_JOIN:
{
fprintf(DBUG_FILE, "outer_join(");
if (fd->table_list->nested_join)
{
bool first= TRUE;
List_iterator<TABLE_LIST> it(fd->table_list->nested_join->join_list);
TABLE_LIST *tbl;
while ((tbl= it++))
{
fprintf(DBUG_FILE, "%s%s", first?"":" ",
tbl->table? tbl->table->alias : "...");
first= FALSE;
}
fprintf(DBUG_FILE, ")");
}
else
fprintf(DBUG_FILE, "%s", fd->table_list->table->alias);
fprintf(DBUG_FILE, ")");
break;
}
}
}
#endif
/**
@} (end of group Table_Elimination)
*/
......
sql/sql_bitmap.h
View file @ 854bb82b
......@@ -93,6 +93,34 @@ public:
}
};
/* An iterator to quickly walk over bits in unlonglong bitmap. */
class Table_map_iterator
{
ulonglong bmp;
uint no;
public:
Table_map_iterator(ulonglong t) : bmp(t), no(0) {}
int next_bit()
{
static const char last_bit[16]= {32, 0, 1, 0,
2, 0, 1, 0,
3, 0, 1, 0,
2, 0, 1, 0};
uint bit;
while ((bit= last_bit[bmp & 0xF]) == 32)
{
no += 4;
bmp= bmp >> 4;
if (!bmp)
return BITMAP_END;
}
bmp &= ~(1LL << bit);
return no + bit;
}
int operator++(int) { return next_bit(); }
enum { BITMAP_END= 64 };
};
template <> class Bitmap<64>
{
ulonglong map;
......@@ -136,5 +164,10 @@ public:
my_bool operator==(const Bitmap<64>& map2) const { return map == map2.map; }
char *print(char *buf) const { longlong2str(map,buf,16); return buf; }
ulonglong to_ulonglong() const { return map; }
class Iterator : public Table_map_iterator
{
public:
Iterator(Bitmap<64> &bmp) : Table_map_iterator(bmp.map) {}
};
};
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7