At file:///home/psergey/dev/maria-5.1-table-elim-r11/ ------------------------------------------------------------ revno: 2738 revision-id: psergey@askmonty.org-20090819120659-0ndd6mqxeetgee2n parent: psergey@askmonty.org-20090819101838-55ys0h923olqz4q9 committer: Sergey Petrunya <psergey@askmonty.org> 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");