database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Remove dflt_field from field structure as this was only needed when createing temporary table and I found another soultion that doesn't increase the size of the field structure for all table instances. (Better fix for bug #19089)

Browse Source 
Fixed compiler warnings
Fixed valgrind warning in Item_date_add_intervall::eq. (Recoding of bugfix #19490)


sql/field.cc:
  remove dflt_field from field structure (not needed)
  Simple cleanup of code that been copied elsewhere
sql/field.h:
  remove dflt_field from field structure (not needed)
sql/item.h:
  Removed compiler warnings
sql/item_timefunc.cc:
  Fixed Item_date_add_intervall::eq
  The problem was that when we call 'eq' 'this' is not fixed, which means we can't call const_item() or a value function.
  I fixed this so that we check eq for all arguments and that the sign and type are identical.
  (The original code gave a 'accessing uninitialized data' in valgrind.
sql/mysql_priv.h:
  Added default fields to create_tmp_field
sql/sql_insert.cc:
  New default_field parameter to create_tmp_field()
sql/sql_select.cc:
  New default_field parameter to create_tmp_field()
  Use this in create_tmp_table() to set right default value for a field
This commit is contained in:
unknown
2006-05-24 11:56:59 +03:00
parent fc2e96ee7b
commit 12a0f4ff14
7 changed files with 51 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
sql/field.cc
View File

@ -1222,13 +1222,13 @@ Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
uchar null_bit_arg,
utype unireg_check_arg, const char *field_name_arg,
struct st_table *table_arg)
:ptr(ptr_arg),null_ptr(null_ptr_arg),
:ptr(ptr_arg), null_ptr(null_ptr_arg),
table(table_arg),orig_table(table_arg),
table_name(table_arg ? &table_arg->alias : &unknown_table_name),
field_name(field_name_arg),
query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0),
unireg_check(unireg_check_arg),
field_length(length_arg), null_bit(null_bit_arg), dflt_field(0)
field_length(length_arg), null_bit(null_bit_arg)
{
flags=null_ptr ? 0: NOT_NULL_FLAG;
comment.str= (char*) "";
@ -8964,22 +8964,21 @@ create_field::create_field(Field *old_field,Field *orig_field)
old_field->table->timestamp_field != old_field || /* timestamp field */
unireg_check == Field::TIMESTAMP_UN_FIELD)) /* has default val */
{
char buff[MAX_FIELD_WIDTH],*pos;
String tmp(buff,sizeof(buff), charset), *res;
my_ptrdiff_t diff;
/* Get the value from default_values */
diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
orig_field->table->record[0]);
orig_field->move_field(diff); // Points now at default_values
bool is_null=orig_field->is_real_null();
res= orig_field->val_str(&tmp);
orig_field->move_field(-diff); // Back to record[0]
if (!is_null)
if (!orig_field->is_real_null())
{
char buff[MAX_FIELD_WIDTH],*pos;
String tmp(buff,sizeof(buff), charset), *res;
res= orig_field->val_str(&tmp);
pos= (char*) sql_strmake(res->ptr(), res->length());
def= new Item_string(pos, res->length(), charset);
}
orig_field->move_field(-diff); // Back to record[0]
}
}

6
sql/field.h
View File

@ -53,12 +53,6 @@ public:
char *ptr; // Position to field in record
uchar *null_ptr; // Byte where null_bit is
/*
dflt_field is used only for the fields of temporary tables.
It points to the default value of the field in another table
from which this field has been created.
*/
Field *dflt_field; // Field to copy default value from
/*
Note that you can use table->in_use as replacement for current_thd member
only inside of val_*() and store() members (e.g. you can't use it in cons)

2
sql/item.h
View File

@ -388,6 +388,8 @@ public:
required, otherwise we only reading it and SELECT
privilege might be required.
*/
Settable_routine_parameter() {}
virtual ~Settable_routine_parameter() {}
virtual void set_required_privilege(bool rw) {};
/*

36
sql/item_timefunc.cc
View File

@ -2130,39 +2130,11 @@ longlong Item_date_add_interval::val_int()
bool Item_date_add_interval::eq(const Item *item, bool binary_cmp) const
{
INTERVAL interval, other_interval;
String val= value; // Because of const
if (this == item)
return TRUE;
if ((item->type() != FUNC_ITEM) ||
(arg_count != ((Item_func*) item)->arg_count) ||
(func_name() != ((Item_func*) item)->func_name()))
return FALSE;
Item_date_add_interval *other= (Item_date_add_interval*) item;
if ((int_type != other->int_type) ||
(!args[0]->eq(other->args[0], binary_cmp)))
return FALSE;
if (!args[1]->const_item() || !other->args[1]->const_item())
return (args[1]->eq(other->args[1], binary_cmp));
if (get_interval_value(args[1], int_type, &val, &interval))
return FALSE;
val= other->value;
if ((get_interval_value(other->args[1], other->int_type, &val,
&other_interval)) ||
((date_sub_interval ^ interval.neg) ^
(other->date_sub_interval ^ other_interval.neg)))
return FALSE;
// Assume comparing same types here due to earlier check
return memcmp(&interval, &other_interval, sizeof(INTERVAL)) == 0;
if (!Item_func::eq(item, binary_cmp))
return 0;
return ((int_type == other->int_type) &&
(date_sub_interval == other->date_sub_interval));
}

1
sql/mysql_priv.h
View File

@ -704,6 +704,7 @@ bool mysql_derived_prepare(THD *thd, LEX *lex, TABLE_LIST *t);
bool mysql_derived_filling(THD *thd, LEX *lex, TABLE_LIST *t);
Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
Item ***copy_func, Field **from_field,
Field **def_field,
bool group, bool modify_item,
bool table_cant_handle_bit_fields,
bool make_copy_field,

9
sql/sql_insert.cc
View File

@ -2500,12 +2500,13 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
while ((item=it++))
{
create_field *cr_field;
Field *field;
Field *field, *def_field;
if (item->type() == Item::FUNC_ITEM)
field=item->tmp_table_field(&tmp_table);
field= item->tmp_table_field(&tmp_table);
else
field=create_tmp_field(thd, &tmp_table, item, item->type(),
(Item ***) 0, &tmp_field, 0, 0, 0, 0, 0);
field= create_tmp_field(thd, &tmp_table, item, item->type(),
(Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
0);
if (!field ||
!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
((Item_field *)item)->field :

54
sql/sql_select.cc
View File

@ -8116,6 +8116,7 @@ Field *create_tmp_field_for_schema(THD *thd, Item *item, TABLE *table)
in this array
from_field if field will be created using other field as example,
pointer example field will be written here
default_field If field has a default value field, store it here
group 1 if we are going to do a relative group by on result
modify_item 1 if item->result_field should point to new item.
This is relevent for how fill_record() is going to
@ -8134,6 +8135,7 @@ Field *create_tmp_field_for_schema(THD *thd, Item *item, TABLE *table)
Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
Item ***copy_func, Field **from_field,
Field **default_field,
bool group, bool modify_item,
bool table_cant_handle_bit_fields,
bool make_copy_field,
@ -8200,7 +8202,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
if (orig_type == Item::REF_ITEM && orig_modify)
((Item_ref*)orig_item)->set_result_field(result);
if (field->field->eq_def(result))
result->dflt_field= field->field;
*default_field= field->field;
return result;
}
/* Fall through */
@ -8288,7 +8290,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
char *tmpname,path[FN_REFLEN];
byte *pos,*group_buff;
uchar *null_flags;
Field **reg_field, **from_field;
Field **reg_field, **from_field, **default_field;
uint *blob_field;
Copy_field *copy=0;
KEY *keyinfo;
@ -8357,6 +8359,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
if (!multi_alloc_root(&own_root,
&table, sizeof(*table),
&reg_field, sizeof(Field*) * (field_count+1),
&default_field, sizeof(Field*) * (field_count),
&blob_field, sizeof(uint)*(field_count+1),
&from_field, sizeof(Field*)*field_count,
&copy_func, sizeof(*copy_func)*(copy_func_count+1),
@ -8386,6 +8389,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
bzero((char*) table,sizeof(*table));
bzero((char*) reg_field,sizeof(Field*)*(field_count+1));
bzero((char*) default_field, sizeof(Field*) * (field_count));
bzero((char*) from_field,sizeof(Field*)*field_count);
table->mem_root= own_root;
@ -8417,7 +8421,6 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
/* For easier error reporting */
table->s->table_cache_key= (char*) (table->s->db= "");
/* Calculate which type of fields we will store in the temporary table */
reclength= string_total_length= 0;
@ -8454,9 +8457,11 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
Item *arg= *argp;
if (!arg->const_item())
{
uint field_index= (uint) (reg_field - table->field);
Field *new_field=
create_tmp_field(thd, table, arg, arg->type(), &copy_func,
tmp_from_field, group != 0,not_all_columns,
tmp_from_field, &default_field[field_index],
group != 0,not_all_columns,
distinct, 0,
param->convert_blob_length);
if (!new_field)
@ -8465,12 +8470,12 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
reclength+=new_field->pack_length();
if (new_field->flags & BLOB_FLAG)
{
*blob_field++= (uint) (reg_field - table->field);
*blob_field++= field_index;
blob_count++;
}
if (new_field->type() == FIELD_TYPE_BIT)
total_uneven_bit_length+= new_field->field_length & 7;
new_field->field_index= (uint) (reg_field - table->field);
new_field->field_index= field_index;
*(reg_field++)= new_field;
if (new_field->real_type() == MYSQL_TYPE_STRING ||
new_field->real_type() == MYSQL_TYPE_VARCHAR)
@ -8496,6 +8501,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
}
else
{
uint field_index= (uint) (reg_field - table->field);
/*
The last parameter to create_tmp_field() is a bit tricky:
@ -8512,7 +8518,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
Field *new_field= (param->schema_table) ?
create_tmp_field_for_schema(thd, item, table) :
create_tmp_field(thd, table, item, type, &copy_func,
tmp_from_field, group != 0,
tmp_from_field, &default_field[field_index],
group != 0,
!force_copy_fields &&
(not_all_columns || group !=0),
item->marker == 4, force_copy_fields,
@ -8534,7 +8541,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
total_uneven_bit_length+= new_field->field_length & 7;
if (new_field->flags & BLOB_FLAG)
{
*blob_field++= (uint) (reg_field - table->field);
*blob_field++= field_index;
blob_count++;
}
if (item->marker == 4 && item->maybe_null)
@ -8543,7 +8550,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
new_field->flags|= GROUP_FLAG;
}
new_field->query_id= thd->query_id;
new_field->field_index= (uint) (reg_field - table->field);
new_field->field_index= field_index;
*(reg_field++) =new_field;
}
if (!--hidden_field_count)
@ -8563,6 +8570,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
}
DBUG_ASSERT(field_count >= (uint) (reg_field - table->field));
field_count= (uint) (reg_field - table->field);
*reg_field= 0;
*blob_field= 0; // End marker
/* If result table is small; use a heap */
@ -8678,31 +8686,33 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
}
field->reset();
if (field->dflt_field && field->dflt_field->ptr)
/*
Test if there is a default field value. The test for ->ptr is to skip
'offset' fields generated by initalize_tables
*/
if (default_field[i] && default_field[i]->ptr)
{
/*
field->dflt_field is set only in the cases when 'field' can
/*
default_field[i] is set only in the cases when 'field' can
inherit the default value that is defined for the field referred
by the Item_field object from which 'field' has been created.
For a field created not from a Item_field item dflt_field == 0.
*/
my_ptrdiff_t diff;
Field *orig_field= field->dflt_field;
Field *orig_field= default_field[i];
/* Get the value from default_values */
diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
orig_field->table->record[0]);
orig_field->move_field(diff); // Points now at default_values
bool is_null= orig_field->is_real_null();
char *from= orig_field->ptr;
orig_field->move_field(-diff); // Back to record[0]
if (is_null)
if (orig_field->is_real_null())
field->set_null();
else
{
field->set_notnull();
memcpy(field->ptr, from, field->pack_length());
memcpy(field->ptr, orig_field->ptr, field->pack_length());
}
}
orig_field->move_field(-diff); // Back to record[0]
}
if (from_field[i])
{ /* Not a table Item */
@ -12233,6 +12243,8 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
Item::Type order_item_type;
Item **select_item; /* The corresponding item from the SELECT clause. */
Field *from_field; /* The corresponding field from the FROM clause. */
uint counter;
bool unaliased;
/*
Local SP variables may be int but are expressions, not positions.
@ -12254,8 +12266,6 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
return FALSE;
}
/* Lookup the current GROUP/ORDER field in the SELECT clause. */
uint counter;
bool unaliased;
select_item= find_item_in_list(order_item, fields, &counter,
REPORT_EXCEPT_NOT_FOUND, &unaliased);
if (!select_item)