maria-developers team mailing list archive
-
maria-developers team
-
Mailing list archive
-
Message #00794
Rev 2738: Variable/function renames in file:///home/psergey/dev/maria-5.1-table-elim-r11/
At file:///home/psergey/dev/maria-5.1-table-elim-r11/
------------------------------------------------------------
revno: 2738
revision-id: psergey@xxxxxxxxxxxx-20090819120659-0ndd6mqxeetgee2n
parent: psergey@xxxxxxxxxxxx-20090819101838-55ys0h923olqz4q9
committer: Sergey Petrunya <psergey@xxxxxxxxxxxx>
branch nick: maria-5.1-table-elim-r11
timestamp: Wed 2009-08-19 15:06:59 +0300
message:
Variable/function renames
=== modified file 'sql/opt_table_elimination.cc'
--- a/sql/opt_table_elimination.cc 2009-08-19 10:18:38 +0000
+++ b/sql/opt_table_elimination.cc 2009-08-19 12:06:59 +0000
@@ -147,7 +147,7 @@
{
public:
Value_dep(): bound(FALSE), next(NULL) {}
- virtual void now_bound(Func_dep_analyzer *te, Module_dep **bound_modules)=0;
+ virtual void now_bound(Func_dep_analyzer *fda, Module_dep **bound_modules)=0;
virtual ~Value_dep() {} /* only to shut up compiler warnings */
bool bound;
@@ -182,8 +182,8 @@
- unique keys we belong to
- expressions that depend on us.
*/
- void now_bound(Func_dep_analyzer *te, Module_dep **bound_modules);
- void signal_from_field_to_exprs(Func_dep_analyzer* te,
+ void now_bound(Func_dep_analyzer *fda, Module_dep **bound_modules);
+ void signal_from_field_to_exprs(Func_dep_analyzer* fda,
Module_dep **bound_modules);
};
@@ -203,7 +203,7 @@
Field_value *fields; /* Ordered list of fields that belong to this table */
Key_module *keys; /* Ordered list of Unique keys in this table */
//Outer_join_module *outer_join_dep;
- void now_bound(Func_dep_analyzer *te, Module_dep **bound_modules);
+ void now_bound(Func_dep_analyzer *fda, Module_dep **bound_modules);
};
@@ -218,7 +218,7 @@
MODULE_OUTER_JOIN
} type; /* Type of the object */
- virtual bool now_bound(Func_dep_analyzer *te, Value_dep **bound_modules)=0;
+ virtual bool now_bound(Func_dep_analyzer *fda, Value_dep **bound_modules)=0;
virtual ~Module_dep(){}
/*
Used to make a linked list of elements that became bound and thus can
@@ -243,7 +243,7 @@
/* Used during condition analysis only, similar to KEYUSE::level */
uint level;
- bool now_bound(Func_dep_analyzer *te, Value_dep **bound_values);
+ bool now_bound(Func_dep_analyzer *fda, Value_dep **bound_values);
};
@@ -264,7 +264,7 @@
uint keyno;
/* Unique keys form a linked list, ordered by keyno */
Key_module *next_table_key;
- bool now_bound(Func_dep_analyzer *te, Value_dep **bound_values);
+ bool now_bound(Func_dep_analyzer *fda, Value_dep **bound_values);
};
@@ -280,7 +280,7 @@
{
unknown_args= n_children;
}
- bool now_bound(Func_dep_analyzer *te, Value_dep **bound_values);
+ bool now_bound(Func_dep_analyzer *fda, Value_dep **bound_values);
};
@@ -301,9 +301,9 @@
table_map usable_tables;
/* Array of equality dependencies */
- Equality_module *equality_deps;
- uint n_equality_deps; /* Number of elements in the array */
- uint n_equality_deps_alloced;
+ Equality_module *equality_mods;
+ uint n_equality_mods; /* Number of elements in the array */
+ uint n_equality_mods_alloced;
/* tablenr -> Table_value* mapping. */
Table_value *table_deps[MAX_KEY];
@@ -331,10 +331,10 @@
Item* cond);
static
-bool build_eq_deps_for_cond(Func_dep_analyzer *te, Equality_module **fdeps,
+void build_eq_mods_for_cond(Func_dep_analyzer *fda, Equality_module **fdeps,
uint *and_level, Item *cond);
static
-bool add_eq_dep(Func_dep_analyzer *te, Equality_module **eq_dep,
+void add_eq_mod(Func_dep_analyzer *fda, Equality_module **eq_mod,
uint and_level,
Item_func *cond, Item *left, Item *right);
static
@@ -342,14 +342,14 @@
Equality_module *new_fields,
Equality_module *end, uint and_level);
-static Table_value *get_table_value(Func_dep_analyzer *te, TABLE *table);
-static Field_value *get_field_value(Func_dep_analyzer *te, Field *field);
+static Table_value *get_table_value(Func_dep_analyzer *fda, TABLE *table);
+static Field_value *get_field_value(Func_dep_analyzer *fda, Field *field);
static void mark_as_eliminated(JOIN *join, TABLE_LIST *tbl);
#ifndef DBUG_OFF
-static void dbug_print_deps(Func_dep_analyzer *te);
+static void dbug_print_deps(Func_dep_analyzer *fda);
#endif
/*******************************************************************************************/
@@ -358,17 +358,18 @@
Produce Eq_dep elements for given condition.
SYNOPSIS
- build_eq_deps_for_cond()
- te Table elimination context
+ build_eq_mods_for_cond()
+ fda Table elimination context
fdeps INOUT Put produced equality conditions here
and_level INOUT AND-level (like in add_key_fields)
cond Condition to process
+
DESCRIPTION
This function is modeled after add_key_fields()
*/
static
-bool build_eq_deps_for_cond(Func_dep_analyzer *te, Equality_module **fdeps,
+void build_eq_mods_for_cond(Func_dep_analyzer *fda, Equality_module **fdeps,
uint *and_level, Item *cond)
{
if (cond->type() == Item_func::COND_ITEM)
@@ -381,34 +382,29 @@
{
Item *item;
while ((item=li++))
- {
- if (build_eq_deps_for_cond(te, fdeps, and_level, item))
- return TRUE;
- }
+ build_eq_mods_for_cond(fda, fdeps, and_level, item);
for (; org_key_fields != *fdeps ; org_key_fields++)
org_key_fields->level= *and_level;
}
else
{
+ Item *item;
(*and_level)++;
- if (build_eq_deps_for_cond(te, fdeps, and_level, li++))
- return TRUE;
- Item *item;
+ build_eq_mods_for_cond(fda, fdeps, and_level, li++);
while ((item=li++))
{
Equality_module *start_key_fields= *fdeps;
(*and_level)++;
- if (build_eq_deps_for_cond(te, fdeps, and_level, item))
- return TRUE;
+ build_eq_mods_for_cond(fda, fdeps, and_level, item);
*fdeps= merge_func_deps(org_key_fields, start_key_fields, *fdeps,
++(*and_level));
}
}
- return FALSE;
+ return;
}
if (cond->type() != Item::FUNC_ITEM)
- return FALSE;
+ return;
Item_func *cond_func= (Item_func*) cond;
Item **args= cond_func->arguments();
@@ -418,10 +414,10 @@
{
if (cond_func->argument_count() == 2)
{
- if (add_eq_dep(te, fdeps, *and_level, cond_func, args[0], args[1]) ||
- add_eq_dep(te, fdeps, *and_level, cond_func, args[1], args[0]))
- return TRUE;
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[0], args[1]);
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[1], args[0]);
}
+ break;
}
case Item_func::BETWEEN:
{
@@ -430,24 +426,23 @@
(fld= args[0]->real_item())->type() == Item::FIELD_ITEM &&
args[1]->eq(args[2], ((Item_field*)fld)->field->binary()))
{
- if (add_eq_dep(te, fdeps, *and_level, cond_func, args[0], args[1]) ||
- add_eq_dep(te, fdeps, *and_level, cond_func, args[1], args[0]))
- return TRUE;
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[0], args[1]);
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[1], args[0]);
}
break;
}
case Item_func::EQ_FUNC:
case Item_func::EQUAL_FUNC:
{
- add_eq_dep(te, fdeps, *and_level, cond_func, args[0], args[1]);
- add_eq_dep(te, fdeps, *and_level, cond_func, args[1], args[0]);
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[0], args[1]);
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[1], args[0]);
break;
}
case Item_func::ISNULL_FUNC:
{
Item *tmp=new Item_null;
- if (!tmp || add_eq_dep(te, fdeps, *and_level, cond_func, args[0], args[1]))
- return TRUE;
+ if (tmp)
+ add_eq_mod(fda, fdeps, *and_level, cond_func, args[0], args[1]);
break;
}
case Item_func::MULT_EQUAL_FUNC:
@@ -462,12 +457,9 @@
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++))
- {
- if (add_eq_dep(te, fdeps, *and_level, cond_func, item, const_item))
- return TRUE;
- }
+ add_eq_mod(fda, fdeps, *and_level, cond_func, item, const_item);
}
else
{
@@ -485,10 +477,7 @@
while ((item2= it++))
{
if (!field->eq(item2->field))
- {
- if (add_eq_dep(te, fdeps, *and_level, cond_func, item, item2))
- return TRUE;
- }
+ add_eq_mod(fda, fdeps, *and_level, cond_func, item, item2);
}
it.rewind();
}
@@ -498,7 +487,6 @@
default:
break;
}
- return FALSE;
}
@@ -624,8 +612,8 @@
Add an Equality_module element for left=right condition
SYNOPSIS
- add_eq_dep()
- te Table elimination context
+ add_eq_mod()
+ fda Table elimination context
eq_mod INOUT Store created Equality_module here and increment ptr if
you do so
and_level AND-level ()
@@ -645,10 +633,10 @@
*/
static
-bool add_eq_dep(Func_dep_analyzer *te, Equality_module **eq_mod,
+void add_eq_mod(Func_dep_analyzer *fda, Equality_module **eq_mod,
uint and_level, Item_func *cond, Item *left, Item *right)
{
- if ((left->used_tables() & te->usable_tables) &&
+ if ((left->used_tables() & fda->usable_tables) &&
!(right->used_tables() & RAND_TABLE_BIT) &&
left->real_item()->type() == Item::FIELD_ITEM)
{
@@ -658,7 +646,7 @@
if (right->result_type() != STRING_RESULT)
{
if (field->cmp_type() != right->result_type())
- return FALSE;
+ return;
}
else
{
@@ -668,17 +656,33 @@
*/
if (field->cmp_type() == STRING_RESULT &&
((Field_str*)field)->charset() != cond->compare_collation())
- return FALSE;
+ return;
}
}
-
- if (!((*eq_mod)->field= get_field_value(te, field)))
- return TRUE;
+
+ if (*eq_mod == fda->equality_mods + fda->n_equality_mods_alloced)
+ {
+ /*
+ We've filled the entire equality_mods array. Replace it with a bigger
+ one. We do it somewhat inefficiently but it doesn't matter.
+ */
+ Equality_module *new_arr;
+ if (!(new_arr= new Equality_module[fda->n_equality_mods_alloced *2]))
+ return;
+ fda->n_equality_mods_alloced *= 2;
+ for (int i= 0; i < *eq_mod - fda->equality_mods; i++)
+ new_arr[i]= fda->equality_mods[i];
+
+ fda->equality_mods= new_arr;
+ *eq_mod= new_arr + (*eq_mod - fda->equality_mods);
+ }
+
+ if (!((*eq_mod)->field= get_field_value(fda, field)))
+ return;
(*eq_mod)->expression= right;
(*eq_mod)->level= and_level;
(*eq_mod)++;
}
- return FALSE;
}
@@ -686,7 +690,7 @@
Get a Table_value object for the given table, creating it if necessary.
*/
-static Table_value *get_table_value(Func_dep_analyzer *te, TABLE *table)
+static Table_value *get_table_value(Func_dep_analyzer *fda, TABLE *table)
{
Table_value *tbl_dep;
if (!(tbl_dep= new Table_value(table)))
@@ -704,7 +708,7 @@
key_list= &(key_dep->next_table_key);
}
}
- return te->table_deps[table->tablenr]= tbl_dep;
+ return fda->table_deps[table->tablenr]= tbl_dep;
}
@@ -712,15 +716,15 @@
Get a Field_value object for the given field, creating it if necessary
*/
-static Field_value *get_field_value(Func_dep_analyzer *te, Field *field)
+static Field_value *get_field_value(Func_dep_analyzer *fda, Field *field)
{
TABLE *table= field->table;
Table_value *tbl_dep;
/* First, get the table*/
- if (!(tbl_dep= te->table_deps[table->tablenr]))
+ if (!(tbl_dep= fda->table_deps[table->tablenr]))
{
- if (!(tbl_dep= get_table_value(te, table)))
+ if (!(tbl_dep= get_table_value(fda, table)))
return NULL;
}
@@ -750,13 +754,13 @@
class Field_dependency_recorder : public Field_enumerator
{
public:
- Field_dependency_recorder(Func_dep_analyzer *te_arg): te(te_arg)
+ Field_dependency_recorder(Func_dep_analyzer *te_arg): fda(te_arg)
{}
void see_field(Field *field)
{
Table_value *tbl_dep;
- if ((tbl_dep= te->table_deps[field->table->tablenr]))
+ if ((tbl_dep= fda->table_deps[field->table->tablenr]))
{
for (Field_value *field_dep= tbl_dep->fields; field_dep;
field_dep= field_dep->next_table_field)
@@ -764,9 +768,9 @@
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);
+ if (!bitmap_is_set(&fda->expr_deps, offs))
+ fda->equality_mods[expr_offset].unknown_args++;
+ bitmap_set_bit(&fda->expr_deps, offs);
return;
}
}
@@ -776,11 +780,11 @@
Bump the dependency anyway, this will signal that this dependency
cannot be satisfied.
*/
- te->equality_deps[expr_offset].unknown_args++;
+ fda->equality_mods[expr_offset].unknown_args++;
}
}
- Func_dep_analyzer *te;
+ Func_dep_analyzer *fda;
/* Offset of the expression we're processing in the dependency bitmap */
uint expr_offset;
};
@@ -791,7 +795,7 @@
SYNOPSIS
setup_equality_modules_deps()
- te Table elimination context
+ fda Table elimination context
bound_deps_list OUT Start of linked list of elements that were found to
be bound (caller will use this to see if that
allows to declare further elements bound)
@@ -807,7 +811,7 @@
*/
static
-bool setup_equality_modules_deps(Func_dep_analyzer *te,
+bool setup_equality_modules_deps(Func_dep_analyzer *fda,
Module_dep **bound_deps_list)
{
DBUG_ENTER("setup_equality_modules_deps");
@@ -817,8 +821,8 @@
value.
*/
uint offset= 0;
- for (Table_value **tbl_dep=te->table_deps;
- tbl_dep < te->table_deps + MAX_TABLES;
+ for (Table_value **tbl_dep=fda->table_deps;
+ tbl_dep < fda->table_deps + MAX_TABLES;
tbl_dep++)
{
if (*tbl_dep)
@@ -828,39 +832,39 @@
field_dep= field_dep->next_table_field)
{
field_dep->bitmap_offset= offset;
- offset += te->n_equality_deps;
+ offset += fda->n_equality_mods;
}
}
}
void *buf;
if (!(buf= current_thd->alloc(bitmap_buffer_size(offset))) ||
- bitmap_init(&te->expr_deps, (my_bitmap_map*)buf, offset, FALSE))
+ bitmap_init(&fda->expr_deps, (my_bitmap_map*)buf, offset, FALSE))
{
DBUG_RETURN(TRUE);
}
- bitmap_clear_all(&te->expr_deps);
+ bitmap_clear_all(&fda->expr_deps);
/*
- Analyze all "field=expr" dependencies, and have te->expr_deps encode
+ Analyze all "field=expr" dependencies, and have fda->expr_deps encode
dependencies of expressions from fields.
Also collect a linked list of equalities that are bound.
*/
Module_dep *bound_dep= NULL;
- Field_dependency_recorder deps_recorder(te);
- for (Equality_module *eq_dep= te->equality_deps;
- eq_dep < te->equality_deps + te->n_equality_deps;
- eq_dep++)
+ Field_dependency_recorder deps_recorder(fda);
+ for (Equality_module *eq_mod= fda->equality_mods;
+ eq_mod < fda->equality_mods + fda->n_equality_mods;
+ eq_mod++)
{
- deps_recorder.expr_offset= eq_dep - te->equality_deps;
- eq_dep->unknown_args= 0;
- eq_dep->expression->walk(&Item::check_column_usage_processor, FALSE,
+ deps_recorder.expr_offset= eq_mod - fda->equality_mods;
+ eq_mod->unknown_args= 0;
+ eq_mod->expression->walk(&Item::check_column_usage_processor, FALSE,
(uchar*)&deps_recorder);
- if (!eq_dep->unknown_args)
+ if (!eq_mod->unknown_args)
{
- eq_dep->next= bound_dep;
- bound_dep= eq_dep;
+ eq_mod->next= bound_dep;
+ bound_dep= eq_mod;
}
}
*bound_deps_list= bound_dep;
@@ -968,7 +972,7 @@
SYNOPSIS
eliminate_tables_for_list()
- te Table elimination context
+ fda Table elimination context
join_list Join list to work on
list_tables Bitmap of tables embedded in the join_list.
on_expr ON expression, if the join list is the inner side
@@ -1053,7 +1057,7 @@
SYNOPSIS
check_func_dependency()
- te Table elimination context
+ fda Table elimination context
tables Set of tables we want to be functionally dependent
cond Condition to use
@@ -1073,24 +1077,25 @@
TABLE_LIST *oj_tbl,
Item* cond)
{
- uint and_level=0;
Module_dep *bound_modules;
- //psergey-todo: move allocs to somewhere else.
- Func_dep_analyzer pte(join);
- Func_dep_analyzer *te= &pte;
- uint m= max(join->thd->lex->current_select->max_equal_elems,1);
- uint max_elems= ((join->thd->lex->current_select->cond_count+1)*2 +
- join->thd->lex->current_select->between_count)*m + 1 + 10;
- if (!(te->equality_deps= new Equality_module[max_elems]))
+ Func_dep_analyzer fda(join);
+
+ /* Start value */
+ fda.n_equality_mods_alloced=
+ join->thd->lex->current_select->max_equal_elems +
+ (join->thd->lex->current_select->cond_count+1)*2 +
+ join->thd->lex->current_select->between_count;
+
+ if (!(fda.equality_mods= new Equality_module[fda.n_equality_mods_alloced]))
return FALSE;
- Equality_module* eq_dep= te->equality_deps;
+ Equality_module* last_eq_mod= fda.equality_mods;
/* Create Table_value objects for all tables we're trying to eliminate */
if (oj_tbl)
{
- if (!get_table_value(te, oj_tbl->table))
+ if (!get_table_value(&fda, oj_tbl->table))
return FALSE;
}
else
@@ -1100,30 +1105,29 @@
{
if (tbl->table && (tbl->table->map & dep_tables))
{
- if (!get_table_value(te, tbl->table))
+ if (!get_table_value(&fda, tbl->table))
return FALSE;
}
}
}
- te->usable_tables= dep_tables;
+ fda.usable_tables= dep_tables;
/*
Analyze the the ON expression and create Equality_module objects and
Field_value objects for their left parts.
*/
- if (build_eq_deps_for_cond(te, &eq_dep, &and_level, cond) ||
- eq_dep == te->equality_deps)
- return FALSE;
-
- te->n_equality_deps= eq_dep - te->equality_deps;
+ uint and_level=0;
+ build_eq_mods_for_cond(&fda, &last_eq_mod, &and_level, cond);
+ if (!(fda.n_equality_mods= last_eq_mod - fda.equality_mods))
+ return FALSE; /* No useful conditions */
- if (!(te->outer_join_dep= new Outer_join_module(my_count_bits(dep_tables))) ||
- setup_equality_modules_deps(te, &bound_modules))
+ if (!(fda.outer_join_dep= new Outer_join_module(my_count_bits(dep_tables))) ||
+ setup_equality_modules_deps(&fda, &bound_modules))
{
return FALSE; /* OOM, default to non-dependent */
}
- DBUG_EXECUTE("test", dbug_print_deps(te); );
+ DBUG_EXECUTE("test", dbug_print_deps(&fda); );
/* The running wave algorithm itself: */
Value_dep *bound_values= NULL;
@@ -1131,11 +1135,11 @@
{
for (;bound_modules; bound_modules= bound_modules->next)
{
- if (bound_modules->now_bound(te, &bound_values))
+ if (bound_modules->now_bound(&fda, &bound_values))
return TRUE; /* Dependent! */
}
for (;bound_values; bound_values=bound_values->next)
- bound_values->now_bound(te, &bound_modules);
+ bound_values->now_bound(&fda, &bound_modules);
}
return FALSE; /* Not dependent */
}
@@ -1147,7 +1151,7 @@
- all its fields are known
*/
-void Table_value::now_bound(Func_dep_analyzer *te,
+void Table_value::now_bound(Func_dep_analyzer *fda,
Module_dep **bound_modules)
{
DBUG_PRINT("info", ("table %s is now bound", table->alias));
@@ -1159,21 +1163,21 @@
{
/* Mark as bound and add to the list */
field_dep->bound= TRUE;
- field_dep->signal_from_field_to_exprs(te, bound_modules);
+ field_dep->signal_from_field_to_exprs(fda, bound_modules);
}
}
- if (te->outer_join_dep->unknown_args &&
- !--te->outer_join_dep->unknown_args)
+ if (fda->outer_join_dep->unknown_args &&
+ !--fda->outer_join_dep->unknown_args)
{
/* Mark as bound and add to the list */
- te->outer_join_dep->next= *bound_modules;
- *bound_modules= te->outer_join_dep;
+ fda->outer_join_dep->next= *bound_modules;
+ *bound_modules= fda->outer_join_dep;
}
}
-void Field_value::now_bound(Func_dep_analyzer *te,
+void Field_value::now_bound(Func_dep_analyzer *fda,
Module_dep **bound_modules)
{
DBUG_PRINT("info", ("field %s.%s is now bound", field->table->alias,
@@ -1193,7 +1197,7 @@
*bound_modules= key_dep;
}
}
- signal_from_field_to_exprs(te, bound_modules);
+ signal_from_field_to_exprs(fda, bound_modules);
}
@@ -1201,25 +1205,25 @@
Walk through expressions that depend on this field and 'notify' them
that this field is no longer unknown.
*/
-void Field_value::signal_from_field_to_exprs(Func_dep_analyzer* te,
+void Field_value::signal_from_field_to_exprs(Func_dep_analyzer* fda,
Module_dep **bound_modules)
{
- for (uint i=0; i < te->n_equality_deps; i++)
+ for (uint i=0; i < fda->n_equality_mods; i++)
{
- if (bitmap_is_set(&te->expr_deps, bitmap_offset + i) &&
- te->equality_deps[i].unknown_args &&
- !--te->equality_deps[i].unknown_args)
+ if (bitmap_is_set(&fda->expr_deps, bitmap_offset + i) &&
+ fda->equality_mods[i].unknown_args &&
+ !--fda->equality_mods[i].unknown_args)
{
/* Mark as bound and add to the list */
- Equality_module* eq_dep= &te->equality_deps[i];
- eq_dep->next= *bound_modules;
- *bound_modules= eq_dep;
+ Equality_module* eq_mod= &fda->equality_mods[i];
+ eq_mod->next= *bound_modules;
+ *bound_modules= eq_mod;
}
}
}
-bool Outer_join_module::now_bound(Func_dep_analyzer *te,
+bool Outer_join_module::now_bound(Func_dep_analyzer *fda,
Value_dep **bound_values)
{
DBUG_PRINT("info", ("Outer join eliminated"));
@@ -1227,7 +1231,7 @@
}
-bool Equality_module::now_bound(Func_dep_analyzer *te,
+bool Equality_module::now_bound(Func_dep_analyzer *fda,
Value_dep **bound_values)
{
/* For field=expr and we got to know the expr, so we know the field */
@@ -1242,7 +1246,7 @@
}
/* Unique key is known means its table is known */
-bool Key_module::now_bound(Func_dep_analyzer *te, Value_dep **bound_values)
+bool Key_module::now_bound(Func_dep_analyzer *fda, Value_dep **bound_values)
{
if (!table->bound)
{
@@ -1294,7 +1298,7 @@
#ifndef DBUG_OFF
static
-void dbug_print_deps(Func_dep_analyzer *te)
+void dbug_print_deps(Func_dep_analyzer *fda)
{
DBUG_ENTER("dbug_print_deps");
DBUG_LOCK_FILE;
@@ -1302,18 +1306,18 @@
fprintf(DBUG_FILE,"deps {\n");
/* Start with printing equalities */
- for (Equality_module *eq_dep= te->equality_deps;
- eq_dep != te->equality_deps + te->n_equality_deps; eq_dep++)
+ for (Equality_module *eq_mod= fda->equality_mods;
+ eq_mod != fda->equality_mods + fda->n_equality_mods; eq_mod++)
{
char buf[128];
String str(buf, sizeof(buf), &my_charset_bin);
str.length(0);
- eq_dep->expression->print(&str, QT_ORDINARY);
+ eq_mod->expression->print(&str, QT_ORDINARY);
fprintf(DBUG_FILE, " equality%d: %s -> %s.%s\n",
- eq_dep - te->equality_deps,
+ eq_mod - fda->equality_mods,
str.c_ptr(),
- eq_dep->field->table->table->alias,
- eq_dep->field->field->field_name);
+ eq_mod->field->table->table->alias,
+ eq_mod->field->field->field_name);
}
fprintf(DBUG_FILE,"\n");
@@ -1321,7 +1325,7 @@
for (uint i=0; i < MAX_TABLES; i++)
{
Table_value *table_dep;
- if ((table_dep= te->table_deps[i]))
+ if ((table_dep= fda->table_deps[i]))
{
/* Print table */
fprintf(DBUG_FILE, " table %s\n", table_dep->table->alias);
@@ -1332,9 +1336,9 @@
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++)
+ for (uint bit= ofs; bit < ofs + fda->n_equality_mods; bit++)
{
- if (bitmap_is_set(&te->expr_deps, bit))
+ if (bitmap_is_set(&fda->expr_deps, bit))
fprintf(DBUG_FILE, " equality%d ", bit - ofs);
}
fprintf(DBUG_FILE, "\n");
