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

cleanup: renames

Browse Source 
enum_mark_columns -> enum_column_usage
mark_used_columns -> column_usage

further commits will replace MARK_COLUMN_NONE with
COLUMN_READ and COLUMN_WRITE that convey the intention
without causing columns to be marked
This commit is contained in:
Sergei Golubchik 2018-02-09 19:43:42 +01:00
parent 8cd3d2d941
commit 103715d0fa
10 changed files with 65 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
sql/item.cc
View File

@ -6214,11 +6214,11 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
set_field(from_field); set_field(from_field);
} }
else if (thd->mark_used_columns != MARK_COLUMNS_NONE) else if (thd->column_usage != MARK_COLUMNS_NONE)
{ {
TABLE *table= field->table; TABLE *table= field->table;
MY_BITMAP *current_bitmap, *other_bitmap; MY_BITMAP *current_bitmap, *other_bitmap;
if (thd->mark_used_columns == MARK_COLUMNS_READ) if (thd->column_usage == MARK_COLUMNS_READ)
{ {
current_bitmap= table->read_set; current_bitmap= table->read_set;
other_bitmap= table->write_set; other_bitmap= table->write_set;
@ -8947,7 +8947,7 @@ bool Item_direct_view_ref::fix_fields(THD *thd, Item **reference)
*/ */
Field *fld= ((Item_field*) ref_item)->field; Field *fld= ((Item_field*) ref_item)->field;
DBUG_ASSERT(fld && fld->table); DBUG_ASSERT(fld && fld->table);
if (thd->mark_used_columns == MARK_COLUMNS_READ) if (thd->column_usage == MARK_COLUMNS_READ)
bitmap_set_bit(fld->table->read_set, fld->field_index); bitmap_set_bit(fld->table->read_set, fld->field_index);
} }
} }
@ -9248,7 +9248,7 @@ bool Item_default_value::fix_fields(THD *thd, Item **items)
if (!newptr) if (!newptr)
goto error; goto error;
fix_session_vcol_expr_for_read(thd, def_field, def_field->default_value); fix_session_vcol_expr_for_read(thd, def_field, def_field->default_value);
if (thd->mark_used_columns != MARK_COLUMNS_NONE) if (thd->column_usage != MARK_COLUMNS_NONE)
def_field->default_value->expr->walk(&Item::register_field_in_read_map, 1, 0); def_field->default_value->expr->walk(&Item::register_field_in_read_map, 1, 0);
def_field->move_field(newptr+1, def_field->maybe_null() ? newptr : 0, 1); def_field->move_field(newptr+1, def_field->maybe_null() ? newptr : 0, 1);
} }
@ -9526,15 +9526,15 @@ void Item_trigger_field::setup_field(THD *thd, TABLE *table,
So instead we do it in Table_triggers_list::mark_fields_used() So instead we do it in Table_triggers_list::mark_fields_used()
method which is called during execution of these statements. method which is called during execution of these statements.
*/ */
enum_mark_columns save_mark_used_columns= thd->mark_used_columns; enum_column_usage saved_column_usage= thd->column_usage;
thd->mark_used_columns= MARK_COLUMNS_NONE; thd->column_usage= MARK_COLUMNS_NONE;
/* /*
Try to find field by its name and if it will be found Try to find field by its name and if it will be found
set field_idx properly. set field_idx properly.
*/ */
(void)find_field_in_table(thd, table, field_name.str, field_name.length, (void)find_field_in_table(thd, table, field_name.str, field_name.length,
0, &field_idx); 0, &field_idx);
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
triggers= table->triggers; triggers= table->triggers;
table_grants= table_grant_info; table_grants= table_grant_info;
} }

34
sql/sql_base.cc
View File

@ -5352,7 +5352,7 @@ Field *view_ref_found= (Field*) 0x2;
static void update_field_dependencies(THD *thd, Field *field, TABLE *table) static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
{ {
DBUG_ENTER("update_field_dependencies"); DBUG_ENTER("update_field_dependencies");
if (thd->mark_used_columns != MARK_COLUMNS_NONE) if (thd->column_usage != MARK_COLUMNS_NONE)
{ {
MY_BITMAP *bitmap; MY_BITMAP *bitmap;
@ -5366,7 +5366,7 @@ static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
if (field->vcol_info) if (field->vcol_info)
table->mark_virtual_col(field); table->mark_virtual_col(field);
if (thd->mark_used_columns == MARK_COLUMNS_READ) if (thd->column_usage == MARK_COLUMNS_READ)
bitmap= table->read_set; bitmap= table->read_set;
else else
bitmap= table->write_set; bitmap= table->write_set;
@ -5374,13 +5374,13 @@ static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
/* /*
The test-and-set mechanism in the bitmap is not reliable during The test-and-set mechanism in the bitmap is not reliable during
multi-UPDATE statements under MARK_COLUMNS_READ mode multi-UPDATE statements under MARK_COLUMNS_READ mode
(thd->mark_used_columns == MARK_COLUMNS_READ), as this bitmap contains (thd->column_usage == MARK_COLUMNS_READ), as this bitmap contains
only those columns that are used in the SET clause. I.e they are being only those columns that are used in the SET clause. I.e they are being
set here. See multi_update::prepare() set here. See multi_update::prepare()
*/ */
if (bitmap_fast_test_and_set(bitmap, field->field_index)) if (bitmap_fast_test_and_set(bitmap, field->field_index))
{ {
if (thd->mark_used_columns == MARK_COLUMNS_WRITE) if (thd->column_usage == MARK_COLUMNS_WRITE)
{ {
DBUG_PRINT("warning", ("Found duplicated field")); DBUG_PRINT("warning", ("Found duplicated field"));
thd->dup_field= field; thd->dup_field= field;
@ -5834,7 +5834,7 @@ find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
fld= WRONG_GRANT; fld= WRONG_GRANT;
else else
#endif #endif
if (thd->mark_used_columns != MARK_COLUMNS_NONE) if (thd->column_usage != MARK_COLUMNS_NONE)
{ {
/* /*
Get rw_set correct for this field so that the handler Get rw_set correct for this field so that the handler
@ -5851,7 +5851,7 @@ find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
field_to_set= ((Item_field*)it)->field; field_to_set= ((Item_field*)it)->field;
else else
{ {
if (thd->mark_used_columns == MARK_COLUMNS_READ) if (thd->column_usage == MARK_COLUMNS_READ)
it->walk(&Item::register_field_in_read_map, 0, 0); it->walk(&Item::register_field_in_read_map, 0, 0);
else else
it->walk(&Item::register_field_in_write_map, 0, 0); it->walk(&Item::register_field_in_write_map, 0, 0);
@ -5863,7 +5863,7 @@ find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
{ {
TABLE *table= field_to_set->table; TABLE *table= field_to_set->table;
DBUG_ASSERT(table); DBUG_ASSERT(table);
if (thd->mark_used_columns == MARK_COLUMNS_READ) if (thd->column_usage == MARK_COLUMNS_READ)
bitmap_set_bit(table->read_set, field_to_set->field_index); bitmap_set_bit(table->read_set, field_to_set->field_index);
else else
bitmap_set_bit(table->write_set, field_to_set->field_index); bitmap_set_bit(table->write_set, field_to_set->field_index);
@ -7213,12 +7213,12 @@ int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
****************************************************************************/ ****************************************************************************/
bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array, bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array,
List<Item> &fields, enum_mark_columns mark_used_columns, List<Item> &fields, enum_column_usage column_usage,
List<Item> *sum_func_list, List<Item> *pre_fix, List<Item> *sum_func_list, List<Item> *pre_fix,
bool allow_sum_func) bool allow_sum_func)
{ {
reg2 Item *item; reg2 Item *item;
enum_mark_columns save_mark_used_columns= thd->mark_used_columns; enum_column_usage saved_column_usage= thd->column_usage;
nesting_map save_allow_sum_func= thd->lex->allow_sum_func; nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
List_iterator<Item> it(fields); List_iterator<Item> it(fields);
bool save_is_item_list_lookup; bool save_is_item_list_lookup;
@ -7226,8 +7226,8 @@ bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array,
DBUG_ENTER("setup_fields"); DBUG_ENTER("setup_fields");
DBUG_PRINT("enter", ("ref_pointer_array: %p", ref_pointer_array.array())); DBUG_PRINT("enter", ("ref_pointer_array: %p", ref_pointer_array.array()));
thd->mark_used_columns= mark_used_columns; thd->column_usage= column_usage;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
if (allow_sum_func) if (allow_sum_func)
thd->lex->allow_sum_func|= thd->lex->allow_sum_func|=
(nesting_map)1 << thd->lex->current_select->nest_level; (nesting_map)1 << thd->lex->current_select->nest_level;
@ -7280,8 +7280,8 @@ bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array,
{ {
thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
thd->lex->allow_sum_func= save_allow_sum_func; thd->lex->allow_sum_func= save_allow_sum_func;
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
DBUG_RETURN(TRUE); /* purecov: inspected */ DBUG_RETURN(TRUE); /* purecov: inspected */
} }
if (!ref.is_null()) if (!ref.is_null())
@ -7308,8 +7308,8 @@ bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array,
thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS; thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
thd->lex->allow_sum_func= save_allow_sum_func; thd->lex->allow_sum_func= save_allow_sum_func;
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
DBUG_RETURN(MY_TEST(thd->is_error())); DBUG_RETURN(MY_TEST(thd->is_error()));
} }
@ -7992,8 +7992,8 @@ int setup_conds(THD *thd, TABLE_LIST *tables, List<TABLE_LIST> &leaves,
select_lex->is_item_list_lookup= 0; select_lex->is_item_list_lookup= 0;
thd->mark_used_columns= MARK_COLUMNS_READ; thd->column_usage= MARK_COLUMNS_READ;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
select_lex->cond_count= 0; select_lex->cond_count= 0;
select_lex->between_count= 0; select_lex->between_count= 0;
select_lex->max_equal_elems= 0; select_lex->max_equal_elems= 0;

8
sql/sql_base.h
View File

@ -16,7 +16,7 @@
#ifndef SQL_BASE_INCLUDED #ifndef SQL_BASE_INCLUDED
#define SQL_BASE_INCLUDED #define SQL_BASE_INCLUDED
#include "sql_class.h" /* enum_mark_columns */ #include "sql_class.h" /* enum_column_usage */
#include "sql_trigger.h" /* trg_event_type */ #include "sql_trigger.h" /* trg_event_type */
#include "mysqld.h" /* key_map */ #include "mysqld.h" /* key_map */
#include "table_cache.h" #include "table_cache.h"
@ -159,7 +159,7 @@ void make_leaves_list(THD *thd, List<TABLE_LIST> &list, TABLE_LIST *tables,
int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields, int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
List<Item> *sum_func_list, uint wild_num); List<Item> *sum_func_list, uint wild_num);
bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array, bool setup_fields(THD *thd, Ref_ptr_array ref_pointer_array,
List<Item> &item, enum_mark_columns mark_used_columns, List<Item> &item, enum_column_usage column_usage,
List<Item> *sum_func_list, List<Item> *pre_fix, List<Item> *sum_func_list, List<Item> *pre_fix,
bool allow_sum_func); bool allow_sum_func);
void unfix_fields(List<Item> &items); void unfix_fields(List<Item> &items);
@ -353,13 +353,13 @@ inline TABLE_LIST *find_table_in_global_list(TABLE_LIST *table,
inline bool setup_fields_with_no_wrap(THD *thd, Ref_ptr_array ref_pointer_array, inline bool setup_fields_with_no_wrap(THD *thd, Ref_ptr_array ref_pointer_array,
List<Item> &item, List<Item> &item,
enum_mark_columns mark_used_columns, enum_column_usage column_usage,
List<Item> *sum_func_list, List<Item> *sum_func_list,
bool allow_sum_func) bool allow_sum_func)
{ {
bool res; bool res;
thd->lex->select_lex.no_wrap_view_item= TRUE; thd->lex->select_lex.no_wrap_view_item= TRUE;
res= setup_fields(thd, ref_pointer_array, item, mark_used_columns, res= setup_fields(thd, ref_pointer_array, item, column_usage,
sum_func_list, NULL, allow_sum_func); sum_func_list, NULL, allow_sum_func);
thd->lex->select_lex.no_wrap_view_item= FALSE; thd->lex->select_lex.no_wrap_view_item= FALSE;
return res; return res;

4
sql/sql_class.cc
View File

@ -3803,7 +3803,7 @@ Statement::Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
enum enum_state state_arg, ulong id_arg) enum enum_state state_arg, ulong id_arg)
:Query_arena(mem_root_arg, state_arg), :Query_arena(mem_root_arg, state_arg),
id(id_arg), id(id_arg),
mark_used_columns(MARK_COLUMNS_READ), column_usage(MARK_COLUMNS_READ),
lex(lex_arg), lex(lex_arg),
db(null_clex_str) db(null_clex_str)
{ {
@ -3820,7 +3820,7 @@ Query_arena::Type Statement::type() const
void Statement::set_statement(Statement *stmt) void Statement::set_statement(Statement *stmt)
{ {
id= stmt->id; id= stmt->id;
mark_used_columns= stmt->mark_used_columns; column_usage= stmt->column_usage;
lex= stmt->lex; lex= stmt->lex;
query_string= stmt->query_string; query_string= stmt->query_string;
} }

28
sql/sql_class.h
View File

@ -92,8 +92,21 @@ enum enum_slave_run_triggers_for_rbr { SLAVE_RUN_TRIGGERS_FOR_RBR_NO,
SLAVE_RUN_TRIGGERS_FOR_RBR_LOGGING}; SLAVE_RUN_TRIGGERS_FOR_RBR_LOGGING};
enum enum_slave_type_conversions { SLAVE_TYPE_CONVERSIONS_ALL_LOSSY, enum enum_slave_type_conversions { SLAVE_TYPE_CONVERSIONS_ALL_LOSSY,
SLAVE_TYPE_CONVERSIONS_ALL_NON_LOSSY}; SLAVE_TYPE_CONVERSIONS_ALL_NON_LOSSY};
enum enum_mark_columns
/*
MARK_COLUMNS_NONE: It is unknown whether the column will be read or written
MARK_COLUMNS_READ: A column is goind to be read.
A bit in read set is set to inform handler that the field
is to be read. If field list contains duplicates, then
thd->dup_field is set to point to the last found
duplicate.
MARK_COLUMNS_WRITE: A column is going to be written to.
A bit is set in write set to inform handler that it needs
to update this field in write_row and update_row.
*/
enum enum_column_usage
{ MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE}; { MARK_COLUMNS_NONE, MARK_COLUMNS_READ, MARK_COLUMNS_WRITE};
enum enum_filetype { FILETYPE_CSV, FILETYPE_XML }; enum enum_filetype { FILETYPE_CSV, FILETYPE_XML };
enum enum_binlog_row_image { enum enum_binlog_row_image {
@ -1076,18 +1089,7 @@ public:
*/ */
ulong id; ulong id;
/* enum enum_column_usage column_usage;
MARK_COLUMNS_NONE: Means mark_used_colums is not set and no indicator to
handler of fields used is set
MARK_COLUMNS_READ: Means a bit in read set is set to inform handler
that the field is to be read. If field list contains
duplicates, then thd->dup_field is set to point
to the last found duplicate.
MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
that it needs to update this field in write_row
and update_row.
*/
enum enum_mark_columns mark_used_columns;
LEX_CSTRING name; /* name for named prepared statements */ LEX_CSTRING name; /* name for named prepared statements */
LEX *lex; // parse tree descriptor LEX *lex; // parse tree descriptor

10
sql/sql_insert.cc
View File

@ -1299,7 +1299,7 @@ static bool check_view_insertability(THD * thd, TABLE_LIST *view)
uint used_fields_buff_size= bitmap_buffer_size(table->s->fields); uint used_fields_buff_size= bitmap_buffer_size(table->s->fields);
uint32 *used_fields_buff= (uint32*)thd->alloc(used_fields_buff_size); uint32 *used_fields_buff= (uint32*)thd->alloc(used_fields_buff_size);
MY_BITMAP used_fields; MY_BITMAP used_fields;
enum_mark_columns save_mark_used_columns= thd->mark_used_columns; enum_column_usage saved_column_usage= thd->column_usage;
DBUG_ENTER("check_key_in_view"); DBUG_ENTER("check_key_in_view");
if (!used_fields_buff) if (!used_fields_buff)
@ -1315,20 +1315,20 @@ static bool check_view_insertability(THD * thd, TABLE_LIST *view)
we must not set query_id for fields as they're not we must not set query_id for fields as they're not
really used in this context really used in this context
*/ */
thd->mark_used_columns= MARK_COLUMNS_NONE; thd->column_usage= MARK_COLUMNS_NONE;
/* check simplicity and prepare unique test of view */ /* check simplicity and prepare unique test of view */
for (trans= trans_start; trans != trans_end; trans++) for (trans= trans_start; trans != trans_end; trans++)
{ {
if (!trans->item->fixed && trans->item->fix_fields(thd, &trans->item)) if (!trans->item->fixed && trans->item->fix_fields(thd, &trans->item))
{ {
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
Item_field *field; Item_field *field;
/* simple SELECT list entry (field without expression) */ /* simple SELECT list entry (field without expression) */
if (!(field= trans->item->field_for_view_update())) if (!(field= trans->item->field_for_view_update()))
{ {
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
if (field->field->unireg_check == Field::NEXT_NUMBER) if (field->field->unireg_check == Field::NEXT_NUMBER)
@ -1340,7 +1340,7 @@ static bool check_view_insertability(THD * thd, TABLE_LIST *view)
*/ */
trans->item= field; trans->item= field;
} }
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
/* unique test */ /* unique test */
for (trans= trans_start; trans != trans_end; trans++) for (trans= trans_start; trans != trans_end; trans++)
{ {

10
sql/sql_partition.cc
View File

@ -1583,15 +1583,15 @@ bool fix_partition_func(THD *thd, TABLE *table,
{ {
bool result= TRUE; bool result= TRUE;
partition_info *part_info= table->part_info; partition_info *part_info= table->part_info;
enum_mark_columns save_mark_used_columns= thd->mark_used_columns; enum_column_usage saved_column_usage= thd->column_usage;
DBUG_ENTER("fix_partition_func"); DBUG_ENTER("fix_partition_func");
if (part_info->fixed) if (part_info->fixed)
{ {
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
} }
thd->mark_used_columns= MARK_COLUMNS_NONE; thd->column_usage= MARK_COLUMNS_NONE;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
if (!is_create_table_ind || if (!is_create_table_ind ||
thd->lex->sql_command != SQLCOM_CREATE_TABLE) thd->lex->sql_command != SQLCOM_CREATE_TABLE)
@ -1756,8 +1756,8 @@ bool fix_partition_func(THD *thd, TABLE *table,
table->file->set_part_info(part_info); table->file->set_part_info(part_info);
result= FALSE; result= FALSE;
end: end:
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
DBUG_RETURN(result); DBUG_RETURN(result);
} }

2
sql/sql_select.cc
View File

@ -23219,7 +23219,7 @@ setup_new_fields(THD *thd, List<Item> &fields,
enum_resolution_type not_used; enum_resolution_type not_used;
DBUG_ENTER("setup_new_fields"); DBUG_ENTER("setup_new_fields");
thd->mark_used_columns= MARK_COLUMNS_READ; // Not really needed, but... thd->column_usage= MARK_COLUMNS_READ; // Not really needed, but...
for (; new_field ; new_field= new_field->next) for (; new_field ; new_field= new_field->next)
{ {
if ((item= find_item_in_list(*new_field->item, fields, &counter, if ((item= find_item_in_list(*new_field->item, fields, &counter,

12
sql/sql_view.cc
View File

@ -1934,19 +1934,19 @@ bool check_key_in_view(THD *thd, TABLE_LIST *view)
this operation should not have influence on Field::query_id, to avoid this operation should not have influence on Field::query_id, to avoid
marking as used fields which are not used marking as used fields which are not used
*/ */
enum_mark_columns save_mark_used_columns= thd->mark_used_columns; enum_column_usage saved_column_usage= thd->column_usage;
thd->mark_used_columns= MARK_COLUMNS_NONE; thd->column_usage= MARK_COLUMNS_NONE;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
for (Field_translator *fld= trans; fld < end_of_trans; fld++) for (Field_translator *fld= trans; fld < end_of_trans; fld++)
{ {
if (!fld->item->fixed && fld->item->fix_fields(thd, &fld->item)) if (!fld->item->fixed && fld->item->fix_fields(thd, &fld->item))
{ {
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
} }
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
DBUG_PRINT("info", ("thd->mark_used_columns: %d", thd->mark_used_columns)); DBUG_PRINT("info", ("thd->column_usage: %d", thd->column_usage));
} }
/* Loop over all keys to see if a unique-not-null key is used */ /* Loop over all keys to see if a unique-not-null key is used */
for (;key_info != key_info_end ; key_info++) for (;key_info != key_info_end ; key_info++)

6
sql/table.cc
View File

@ -2858,12 +2858,12 @@ static bool fix_vcol_expr(THD *thd, Virtual_column_info *vcol)
{ {
DBUG_ENTER("fix_vcol_expr"); DBUG_ENTER("fix_vcol_expr");
const enum enum_mark_columns save_mark_used_columns= thd->mark_used_columns; const enum enum_column_usage saved_column_usage= thd->column_usage;
thd->mark_used_columns= MARK_COLUMNS_NONE; thd->column_usage= MARK_COLUMNS_NONE;
int error= vcol->expr->fix_fields(thd, &vcol->expr); int error= vcol->expr->fix_fields(thd, &vcol->expr);
thd->mark_used_columns= save_mark_used_columns; thd->column_usage= saved_column_usage;
if (unlikely(error)) if (unlikely(error))
{ {