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

Stage 2 of MDEV-6152:

Browse Source 
- Added mem_root to all calls to new Item
- Added private method operator new(size_t size) to Item to ensure that
  we always use a mem_root when creating an item.

This saves use once call to current_thd per Item creation
This commit is contained in:
Monty 2015-08-20 15:24:13 +03:00 committed by Sergey Vojtovich
parent 31e365efae
commit 1bae0d9e56
51 changed files with 1146 additions and 881 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
plugin/feedback/feedback.cc
View File

@ -99,20 +99,23 @@ static COND* make_cond(THD *thd, TABLE_LIST *tables, LEX_STRING *filter)
nrc.init(); nrc.init();
nrc.resolve_in_table_list_only(tables); nrc.resolve_in_table_list_only(tables);
res= new Item_cond_or(thd); res= new (thd->mem_root) Item_cond_or(thd);
if (!res) if (!res)
return OOM; return OOM;
for (; filter->str; filter++) for (; filter->str; filter++)
{ {
Item_field *fld= new Item_field(thd, &nrc, db, table, field); Item_field *fld= new (thd->mem_root) Item_field(thd, &nrc, db, table,
Item_string *pattern= new Item_string(thd, filter->str, filter->length, cs); field);
Item_string *escape= new Item_string(thd, "\\", 1, cs); Item_string *pattern= new (thd->mem_root) Item_string(thd, filter->str,
filter->length, cs);
Item_string *escape= new (thd->mem_root) Item_string(thd, "\\", 1, cs);
if (!fld || !pattern || !escape) if (!fld || !pattern || !escape)
return OOM; return OOM;
Item_func_like *like= new Item_func_like(thd, fld, pattern, escape, 0); Item_func_like *like= new (thd->mem_root) Item_func_like(thd, fld, pattern,
escape, 0);
if (!like) if (!like)
return OOM; return OOM;

34
sql/events.cc
View File

@ -632,37 +632,43 @@ send_show_create_event(THD *thd, Event_timed *et, Protocol *protocol)
List<Item> field_list; List<Item> field_list;
LEX_STRING sql_mode; LEX_STRING sql_mode;
const String *tz_name; const String *tz_name;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("send_show_create_event"); DBUG_ENTER("send_show_create_event");
show_str.length(0); show_str.length(0);
if (et->get_create_event(thd, &show_str)) if (et->get_create_event(thd, &show_str))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
field_list.push_back(new Item_empty_string(thd, "Event", NAME_CHAR_LEN)); field_list.push_back(new (mem_root)
Item_empty_string(thd, "Event", NAME_CHAR_LEN));
if (sql_mode_string_representation(thd, et->sql_mode, &sql_mode)) if (sql_mode_string_representation(thd, et->sql_mode, &sql_mode))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
field_list.push_back(new Item_empty_string(thd, "sql_mode", field_list.push_back(new (mem_root)
(uint) sql_mode.length)); Item_empty_string(thd, "sql_mode",
(uint) sql_mode.length));
tz_name= et->time_zone->get_name(); tz_name= et->time_zone->get_name();
field_list.push_back(new Item_empty_string(thd, "time_zone", field_list.push_back(new (mem_root)
tz_name->length())); Item_empty_string(thd, "time_zone", tz_name->length()));
field_list.push_back(new Item_empty_string(thd, "Create Event", field_list.push_back(new (mem_root)
show_str.length())); Item_empty_string(thd, "Create Event",
show_str.length()));
field_list.push_back( field_list.push_back(new (mem_root)
new Item_empty_string(thd, "character_set_client", MY_CS_NAME_SIZE)); Item_empty_string(thd, "character_set_client",
MY_CS_NAME_SIZE));
field_list.push_back( field_list.push_back(new (mem_root)
new Item_empty_string(thd, "collation_connection", MY_CS_NAME_SIZE)); Item_empty_string(thd, "collation_connection",
MY_CS_NAME_SIZE));
field_list.push_back( field_list.push_back(new (mem_root)
new Item_empty_string(thd, "Database Collation", MY_CS_NAME_SIZE)); Item_empty_string(thd, "Database Collation",
MY_CS_NAME_SIZE));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

2
sql/field.cc
View File

@ -10097,7 +10097,7 @@ Create_field::Create_field(THD *thd, Field *old_field, Field *orig_field)
StringBuffer<MAX_FIELD_WIDTH> tmp(charset); StringBuffer<MAX_FIELD_WIDTH> tmp(charset);
String *res= orig_field->val_str(&tmp); String *res= orig_field->val_str(&tmp);
char *pos= (char*) sql_strmake(res->ptr(), res->length()); char *pos= (char*) sql_strmake(res->ptr(), res->length());
def= new Item_string(thd, pos, res->length(), charset); def= new (thd->mem_root) Item_string(thd, pos, res->length(), charset);
} }
orig_field->move_field_offset(-diff); // Back to record[0] orig_field->move_field_offset(-diff); // Back to record[0]
} }

28
sql/handler.cc
View File

@ -1981,16 +1981,21 @@ bool mysql_xa_recover(THD *thd)
{ {
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysql_xa_recover"); DBUG_ENTER("mysql_xa_recover");
field_list.push_back(new Item_int(thd, "formatID", 0, field_list.push_back(new (mem_root)
MY_INT32_NUM_DECIMAL_DIGITS)); Item_int(thd, "formatID", 0,
field_list.push_back(new Item_int(thd, "gtrid_length", 0, MY_INT32_NUM_DECIMAL_DIGITS));
MY_INT32_NUM_DECIMAL_DIGITS)); field_list.push_back(new (mem_root)
field_list.push_back(new Item_int(thd, "bqual_length", 0, Item_int(thd, "gtrid_length", 0,
MY_INT32_NUM_DECIMAL_DIGITS)); MY_INT32_NUM_DECIMAL_DIGITS));
field_list.push_back(new Item_empty_string(thd, "data", field_list.push_back(new (mem_root)
XIDDATASIZE)); Item_int(thd, "bqual_length", 0,
MY_INT32_NUM_DECIMAL_DIGITS));
field_list.push_back(new (mem_root)
Item_empty_string(thd, "data",
XIDDATASIZE));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -5525,11 +5530,12 @@ bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
{ {
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
bool result; bool result;
field_list.push_back(new Item_empty_string(thd, "Type", 10)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Type", 10));
field_list.push_back(new Item_empty_string(thd, "Name", FN_REFLEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Name", FN_REFLEN));
field_list.push_back(new Item_empty_string(thd, "Status", 10)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Status", 10));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

209
sql/item.cc
View File

@ -693,7 +693,7 @@ Item* Item::set_expr_cache(THD *thd)
{ {
DBUG_ENTER("Item::set_expr_cache"); DBUG_ENTER("Item::set_expr_cache");
Item_cache_wrapper *wrapper; Item_cache_wrapper *wrapper;
if ((wrapper= new Item_cache_wrapper(thd, this)) && if ((wrapper= new (thd->mem_root) Item_cache_wrapper(thd, this)) &&
!wrapper->fix_fields(thd, (Item**)&wrapper)) !wrapper->fix_fields(thd, (Item**)&wrapper))
{ {
if (wrapper->set_cache(thd)) if (wrapper->set_cache(thd))
@ -1046,7 +1046,7 @@ Item *Item::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
{ {
if (!needs_charset_converter(tocs)) if (!needs_charset_converter(tocs))
return this; return this;
Item_func_conv_charset *conv= new Item_func_conv_charset(thd, this, tocs, 1); Item_func_conv_charset *conv= new (thd->mem_root) Item_func_conv_charset(thd, this, tocs, 1);
return conv->safe ? conv : NULL; return conv->safe ? conv : NULL;
} }
@ -1058,7 +1058,7 @@ Item *Item::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
Example: Example:
Item_singlerow_subselect has "Item_cache **row". Item_singlerow_subselect has "Item_cache **row".
Creating of Item_func_conv_charset followed by THD::change_item_tree() Creating of Item_func_conv_charset followed by THD::change_item_tree()
should not change row[i] from Item_cache directly to Item_func_conv_charset, because Item_singlerow_subselect should not change row[i] from Item_cache directly to Item_func_conv_charset,
because Item_singlerow_subselect later calls Item_cache-specific methods, because Item_singlerow_subselect later calls Item_cache-specific methods,
e.g. row[i]->store() and row[i]->cache_value(). e.g. row[i]->store() and row[i]->cache_value().
@ -1079,7 +1079,7 @@ Item *Item_cache::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
if (conv == example) if (conv == example)
return this; return this;
Item_cache *cache; Item_cache *cache;
if (!conv || !(cache= new Item_cache_str(thd, conv))) if (!conv || !(cache= new (thd->mem_root) Item_cache_str(thd, conv)))
return NULL; // Safe conversion is not possible, or OEM return NULL; // Safe conversion is not possible, or OEM
cache->setup(thd, conv); cache->setup(thd, conv);
cache->fixed= false; // Make Item::fix_fields() happy cache->fixed= false; // Make Item::fix_fields() happy
@ -1135,8 +1135,10 @@ Item *Item::const_charset_converter(THD *thd, CHARSET_INFO *tocs,
DBUG_ASSERT(fixed); DBUG_ASSERT(fixed);
StringBuffer<64>tmp; StringBuffer<64>tmp;
String *s= val_str(&tmp); String *s= val_str(&tmp);
MEM_ROOT *mem_root= thd->mem_root;
if (!s) if (!s)
return new Item_null(thd, (char *) func_name, tocs); return new (mem_root) Item_null(thd, (char *) func_name, tocs);
if (!needs_charset_converter(s->length(), tocs)) if (!needs_charset_converter(s->length(), tocs))
{ {
@ -1147,14 +1149,16 @@ Item *Item::const_charset_converter(THD *thd, CHARSET_INFO *tocs,
} }
uint conv_errors; uint conv_errors;
Item_string *conv= func_name ? Item_string *conv= (func_name ?
new Item_static_string_func(thd, func_name, new (mem_root)
s, tocs, &conv_errors, Item_static_string_func(thd, func_name,
collation.derivation, s, tocs, &conv_errors,
collation.repertoire) : collation.derivation,
new Item_string(thd, s, tocs, &conv_errors, collation.repertoire) :
collation.derivation, new (mem_root)
collation.repertoire); Item_string(thd, s, tocs, &conv_errors,
collation.derivation,
collation.repertoire));
if (!conv || (conv_errors && lossless)) if (!conv || (conv_errors && lossless))
{ {
@ -1797,9 +1801,10 @@ void Item::split_sum_func2(THD *thd, Item **ref_pointer_array,
Item *real_itm= real_item(); Item *real_itm= real_item();
ref_pointer_array[el]= real_itm; ref_pointer_array[el]= real_itm;
if (!(item_ref= new Item_aggregate_ref(thd, if (!(item_ref= (new (thd->mem_root)
&thd->lex->current_select->context, Item_aggregate_ref(thd,
ref_pointer_array + el, 0, name))) &thd->lex->current_select->context,
ref_pointer_array + el, 0, name))))
return; // fatal_error is set return; // fatal_error is set
if (type() == SUM_FUNC_ITEM) if (type() == SUM_FUNC_ITEM)
item_ref->depended_from= ((Item_sum *) this)->depended_from(); item_ref->depended_from= ((Item_sum *) this)->depended_from();
@ -2091,7 +2096,7 @@ bool agg_item_set_converter(DTCollation &coll, const char *fname,
if (conv == *arg) if (conv == *arg)
continue; continue;
if (!conv && ((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII)) if (!conv && ((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII))
conv= new Item_func_conv_charset(thd, *arg, coll.collation, 1); conv= new (thd->mem_root) Item_func_conv_charset(thd, *arg, coll.collation, 1);
if (!conv) if (!conv)
{ {
@ -2885,6 +2890,13 @@ void Item_decimal::set_decimal_value(my_decimal *value_par)
} }
Item *Item_decimal::clone_item(THD *thd)
{
return new (thd->mem_root) Item_decimal(thd, name, &decimal_value, decimals,
max_length);
}
String *Item_float::val_str(String *str) String *Item_float::val_str(String *str)
{ {
// following assert is redundant, because fixed=1 assigned in constructor // following assert is redundant, because fixed=1 assigned in constructor
@ -2903,6 +2915,13 @@ my_decimal *Item_float::val_decimal(my_decimal *decimal_value)
} }
Item *Item_float::clone_item(THD *thd)
{
return new (thd->mem_root) Item_float(thd, name, value, decimals,
max_length);
}
void Item_string::print(String *str, enum_query_type query_type) void Item_string::print(String *str, enum_query_type query_type)
{ {
const bool print_introducer= const bool print_introducer=
@ -3084,6 +3103,11 @@ Item *Item_null::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
return this; return this;
} }
Item *Item_null::clone_item(THD *thd)
{
return new (thd->mem_root) Item_null(thd, name);
}
/*********************** Item_param related ******************************/ /*********************** Item_param related ******************************/
/** /**
@ -3698,24 +3722,28 @@ bool Item_param::basic_const_item() const
} }
/* see comments in the header file */
Item * Item *
Item_param::clone_item(THD *thd) Item_param::clone_item(THD *thd)
{ {
/* see comments in the header file */ MEM_ROOT *mem_root= thd->mem_root;
switch (state) { switch (state) {
case NULL_VALUE: case NULL_VALUE:
return new Item_null(thd, name); return new (mem_root) Item_null(thd, name);
case INT_VALUE: case INT_VALUE:
return (unsigned_flag ? return (unsigned_flag ?
new Item_uint(thd, name, value.integer, max_length) : new (mem_root) Item_uint(thd, name, value.integer, max_length) :
new Item_int(thd, name, value.integer, max_length)); new (mem_root) Item_int(thd, name, value.integer, max_length));
case REAL_VALUE: case REAL_VALUE:
return new Item_float(thd, name, value.real, decimals, max_length); return new (mem_root) Item_float(thd, name, value.real, decimals,
max_length);
case STRING_VALUE: case STRING_VALUE:
case LONG_DATA_VALUE: case LONG_DATA_VALUE:
return new Item_string(thd, name, str_value.c_ptr_quick(), return new (mem_root) Item_string(thd, name, str_value.c_ptr_quick(),
str_value.length(), str_value.charset(), str_value.length(), str_value.charset(),
collation.derivation, collation.repertoire); collation.derivation,
collation.repertoire);
case TIME_VALUE: case TIME_VALUE:
break; break;
case NO_VALUE: case NO_VALUE:
@ -3969,18 +3997,19 @@ bool Item_param::append_for_log(THD *thd, String *str)
Item_copy *Item_copy::create(THD *thd, Item *item) Item_copy *Item_copy::create(THD *thd, Item *item)
{ {
MEM_ROOT *mem_root= thd->mem_root;
switch (item->result_type()) switch (item->result_type())
{ {
case STRING_RESULT: case STRING_RESULT:
return new Item_copy_string(thd, item); return new (mem_root) Item_copy_string(thd, item);
case REAL_RESULT: case REAL_RESULT:
return new Item_copy_float(thd, item); return new (mem_root) Item_copy_float(thd, item);
case INT_RESULT: case INT_RESULT:
return item->unsigned_flag ? return item->unsigned_flag ?
new Item_copy_uint(thd, item) : new (mem_root) Item_copy_uint(thd, item) :
new Item_copy_int(thd, item); new (mem_root) Item_copy_int(thd, item);
case DECIMAL_RESULT: case DECIMAL_RESULT:
return new Item_copy_decimal(thd, item); return new (mem_root) Item_copy_decimal(thd, item);
case TIME_RESULT: case TIME_RESULT:
case ROW_RESULT: case ROW_RESULT:
case IMPOSSIBLE_RESULT: case IMPOSSIBLE_RESULT:
@ -4778,7 +4807,7 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
fix_inner_refs() function. fix_inner_refs() function.
*/ */
; ;
if (!(rf= new Item_outer_ref(thd, context, this))) if (!(rf= new (thd->mem_root) Item_outer_ref(thd, context, this)))
return -1; return -1;
thd->change_item_tree(reference, rf); thd->change_item_tree(reference, rf);
select->inner_refs_list.push_back(rf); select->inner_refs_list.push_back(rf);
@ -4885,13 +4914,16 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
save= *ref; save= *ref;
*ref= NULL; // Don't call set_properties() *ref= NULL; // Don't call set_properties()
rf= (place == IN_HAVING ? rf= (place == IN_HAVING ?
new Item_ref(thd, context, ref, (char*) table_name, new (thd->mem_root)
(char*) field_name, alias_name_used) : Item_ref(thd, context, ref, (char*) table_name,
(char*) field_name, alias_name_used) :
(!select->group_list.elements ? (!select->group_list.elements ?
new Item_direct_ref(thd, context, ref, (char*) table_name, new (thd->mem_root)
(char*) field_name, alias_name_used) : Item_direct_ref(thd, context, ref, (char*) table_name,
new Item_outer_ref(thd, context, ref, (char*) table_name, (char*) field_name, alias_name_used) :
(char*) field_name, alias_name_used))); new (thd->mem_root)
Item_outer_ref(thd, context, ref, (char*) table_name,
(char*) field_name, alias_name_used)));
*ref= save; *ref= save;
if (!rf) if (!rf)
return -1; return -1;
@ -4924,7 +4956,7 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
if (last_checked_context->select_lex->having_fix_field) if (last_checked_context->select_lex->having_fix_field)
{ {
Item_ref *rf; Item_ref *rf;
rf= new Item_ref(thd, context, (*from_field)->table->s->db.str, rf= new (thd->mem_root) Item_ref(thd, context, (*from_field)->table->s->db.str,
(*from_field)->table->alias.c_ptr(), (*from_field)->table->alias.c_ptr(),
(char*) field_name); (char*) field_name);
if (!rf) if (!rf)
@ -5020,7 +5052,8 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
{ {
uint counter; uint counter;
enum_resolution_type resolution; enum_resolution_type resolution;
Item** res= find_item_in_list(this, thd->lex->current_select->item_list, Item** res= find_item_in_list(this,
thd->lex->current_select->item_list,
&counter, REPORT_EXCEPT_NOT_FOUND, &counter, REPORT_EXCEPT_NOT_FOUND,
&resolution); &resolution);
if (!res) if (!res)
@ -5058,8 +5091,9 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
Item_ref to point to the Item in the select list and replace the Item_ref to point to the Item in the select list and replace the
Item_field created by the parser with the new Item_ref. Item_field created by the parser with the new Item_ref.
*/ */
Item_ref *rf= new Item_ref(thd, context, db_name, table_name, Item_ref *rf= new (thd->mem_root)
field_name); Item_ref(thd, context, db_name, table_name,
field_name);
if (!rf) if (!rf)
return 1; return 1;
bool err= rf->fix_fields(thd, (Item **) &rf) || rf->check_cols(1); bool err= rf->fix_fields(thd, (Item **) &rf) || rf->check_cols(1);
@ -5350,12 +5384,12 @@ static void convert_zerofill_number_to_string(THD *thd, Item **item, Field_num *
res= (*item)->val_str(&tmp); res= (*item)->val_str(&tmp);
if ((*item)->is_null()) if ((*item)->is_null())
*item= new Item_null(thd); *item= new (thd->mem_root) Item_null(thd);
else else
{ {
field->prepend_zeros(res); field->prepend_zeros(res);
pos= (char *) sql_strmake (res->ptr(), res->length()); pos= (char *) sql_strmake (res->ptr(), res->length());
*item= new Item_string(thd, pos, res->length(), field->charset()); *item= new (thd->mem_root) Item_string(thd, pos, res->length(), field->charset());
} }
} }
@ -6043,6 +6077,14 @@ int Item_string::save_in_field(Field *field, bool no_conversions)
} }
Item *Item_string::clone_item(THD *thd)
{
return new (thd->mem_root)
Item_string(thd, name, str_value.ptr(),
str_value.length(), collation.collation);
}
static int save_int_value_in_field (Field *field, longlong nr, static int save_int_value_in_field (Field *field, longlong nr,
bool null_value, bool unsigned_flag) bool null_value, bool unsigned_flag)
{ {
@ -6059,6 +6101,12 @@ int Item_int::save_in_field(Field *field, bool no_conversions)
} }
Item *Item_int::clone_item(THD *thd)
{
return new (thd->mem_root) Item_int(thd, name, value, max_length);
}
void Item_datetime::set(longlong packed) void Item_datetime::set(longlong packed)
{ {
unpack_time(packed, &ltime); unpack_time(packed, &ltime);
@ -6090,18 +6138,25 @@ Item *Item_int_with_ref::clone_item(THD *thd)
parameter markers. parameter markers.
*/ */
return (ref->unsigned_flag ? return (ref->unsigned_flag ?
new Item_uint(thd, ref->name, ref->val_int(), ref->max_length) : new (thd->mem_root)
new Item_int(thd, ref->name, ref->val_int(), ref->max_length)); Item_uint(thd, ref->name, ref->val_int(), ref->max_length) :
new (thd->mem_root)
Item_int(thd, ref->name, ref->val_int(), ref->max_length));
} }
Item_num *Item_uint::neg(THD *thd) Item_num *Item_uint::neg(THD *thd)
{ {
Item_decimal *item= new Item_decimal(thd, value, 1); Item_decimal *item= new (thd->mem_root) Item_decimal(thd, value, 1);
return item->neg(thd); return item->neg(thd);
} }
Item *Item_uint::clone_item(THD *thd)
{
return new (thd->mem_root) Item_uint(thd, name, value, max_length);
}
static uint nr_of_decimals(const char *str, const char *end) static uint nr_of_decimals(const char *str, const char *end)
{ {
const char *decimal_point; const char *decimal_point;
@ -6665,7 +6720,7 @@ Item *Item_field::update_value_transformer(THD *thd, uchar *select_arg)
ref_pointer_array[el]= (Item*)this; ref_pointer_array[el]= (Item*)this;
all_fields->push_front((Item*)this); all_fields->push_front((Item*)this);
ref= new Item_ref(thd, &select->context, ref_pointer_array + el, ref= new (thd->mem_root) Item_ref(thd, &select->context, ref_pointer_array + el,
table_name, field_name); table_name, field_name);
return ref; return ref;
} }
@ -6959,7 +7014,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
if (from_field != not_found_field) if (from_field != not_found_field)
{ {
Item_field* fld; Item_field* fld;
if (!(fld= new Item_field(thd, from_field))) if (!(fld= new (thd->mem_root) Item_field(thd, from_field)))
goto error; goto error;
thd->change_item_tree(reference, fld); thd->change_item_tree(reference, fld);
mark_as_dependent(thd, last_checked_context->select_lex, mark_as_dependent(thd, last_checked_context->select_lex,
@ -7406,7 +7461,7 @@ Item *Item_ref::get_tmp_table_item(THD *thd)
if (!result_field) if (!result_field)
return (*ref)->get_tmp_table_item(thd); return (*ref)->get_tmp_table_item(thd);
Item_field *item= new Item_field(thd, result_field); Item_field *item= new (thd->mem_root) Item_field(thd, result_field);
if (item) if (item)
{ {
item->table_name= table_name; item->table_name= table_name;
@ -7884,11 +7939,11 @@ int Item_cache_wrapper::save_in_field(Field *to, bool no_conversions)
} }
Item* Item_cache_wrapper::get_tmp_table_item(THD *thd_arg) Item* Item_cache_wrapper::get_tmp_table_item(THD *thd)
{ {
if (!orig_item->with_sum_func && !orig_item->const_item()) if (!orig_item->with_sum_func && !orig_item->const_item())
return new Item_field(thd_arg, result_field); return new (thd->mem_root) Item_field(thd, result_field);
return copy_or_same(thd_arg); return copy_or_same(thd);
} }
@ -8575,11 +8630,13 @@ Item_result item_cmp_type(Item_result a,Item_result b)
void resolve_const_item(THD *thd, Item **ref, Item *comp_item) void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
{ {
Item *item= *ref; Item *item= *ref;
Item *new_item= NULL;
if (item->basic_const_item()) if (item->basic_const_item())
return; // Can't be better return; // Can't be better
Item *new_item= NULL;
Item_result res_type=item_cmp_type(comp_item->cmp_type(), item->cmp_type()); Item_result res_type=item_cmp_type(comp_item->cmp_type(), item->cmp_type());
char *name=item->name; // Alloced by sql_alloc char *name=item->name; // Alloced by sql_alloc
MEM_ROOT *mem_root= thd->mem_root;
switch (res_type) { switch (res_type) {
case TIME_RESULT: case TIME_RESULT:
@ -8589,7 +8646,7 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
/* the following call creates a constant and puts it in new_item */ /* the following call creates a constant and puts it in new_item */
get_datetime_value(thd, &ref_copy, &new_item, comp_item, &is_null); get_datetime_value(thd, &ref_copy, &new_item, comp_item, &is_null);
if (is_null) if (is_null)
new_item= new Item_null(thd, name); new_item= new (mem_root) Item_null(thd, name);
break; break;
} }
case STRING_RESULT: case STRING_RESULT:
@ -8598,12 +8655,12 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
String tmp(buff,sizeof(buff),&my_charset_bin),*result; String tmp(buff,sizeof(buff),&my_charset_bin),*result;
result=item->val_str(&tmp); result=item->val_str(&tmp);
if (item->null_value) if (item->null_value)
new_item= new Item_null(thd, name); new_item= new (mem_root) Item_null(thd, name);
else else
{ {
uint length= result->length(); uint length= result->length();
char *tmp_str= sql_strmake(result->ptr(), length); char *tmp_str= sql_strmake(result->ptr(), length);
new_item= new Item_string(thd, name, tmp_str, length, result->charset()); new_item= new (mem_root) Item_string(thd, name, tmp_str, length, result->charset());
} }
break; break;
} }
@ -8612,8 +8669,8 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
longlong result=item->val_int(); longlong result=item->val_int();
uint length=item->max_length; uint length=item->max_length;
bool null_value=item->null_value; bool null_value=item->null_value;
new_item= (null_value ? (Item*) new Item_null(thd, name) : new_item= (null_value ? (Item*) new (mem_root) Item_null(thd, name) :
(Item*) new Item_int(thd, name, result, length)); (Item*) new (mem_root) Item_int(thd, name, result, length));
break; break;
} }
case ROW_RESULT: case ROW_RESULT:
@ -8651,8 +8708,8 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
double result= item->val_real(); double result= item->val_real();
uint length=item->max_length,decimals=item->decimals; uint length=item->max_length,decimals=item->decimals;
bool null_value=item->null_value; bool null_value=item->null_value;
new_item= (null_value ? (Item*) new Item_null(thd, name) : (Item*) new_item= (null_value ? (Item*) new (mem_root) Item_null(thd, name) : (Item*)
new Item_float(thd, name, result, decimals, length)); new (mem_root) Item_float(thd, name, result, decimals, length));
break; break;
} }
case DECIMAL_RESULT: case DECIMAL_RESULT:
@ -8662,8 +8719,8 @@ void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
uint length= item->max_length, decimals= item->decimals; uint length= item->max_length, decimals= item->decimals;
bool null_value= item->null_value; bool null_value= item->null_value;
new_item= (null_value ? new_item= (null_value ?
(Item*) new Item_null(thd, name) : (Item*) new (mem_root) Item_null(thd, name) :
(Item*) new Item_decimal(thd, name, result, length, decimals)); (Item*) new (mem_root) Item_decimal(thd, name, result, length, decimals));
break; break;
} }
case IMPOSSIBLE_RESULT: case IMPOSSIBLE_RESULT:
@ -8803,21 +8860,23 @@ Item_cache* Item_cache::get_cache(THD *thd, const Item *item)
@return cache item @return cache item
*/ */
Item_cache* Item_cache::get_cache(THD *thd, const Item *item, const Item_result type) Item_cache* Item_cache::get_cache(THD *thd, const Item *item,
const Item_result type)
{ {
MEM_ROOT *mem_root= thd->mem_root;
switch (type) { switch (type) {
case INT_RESULT: case INT_RESULT:
return new Item_cache_int(thd, item->field_type()); return new (mem_root) Item_cache_int(thd, item->field_type());
case REAL_RESULT: case REAL_RESULT:
return new Item_cache_real(thd); return new (mem_root) Item_cache_real(thd);
case DECIMAL_RESULT: case DECIMAL_RESULT:
return new Item_cache_decimal(thd); return new (mem_root) Item_cache_decimal(thd);
case STRING_RESULT: case STRING_RESULT:
return new Item_cache_str(thd, item); return new (mem_root) Item_cache_str(thd, item);
case ROW_RESULT: case ROW_RESULT:
return new Item_cache_row(thd); return new (mem_root) Item_cache_row(thd);
case TIME_RESULT: case TIME_RESULT:
return new Item_cache_temporal(thd, item->field_type()); return new (mem_root) Item_cache_temporal(thd, item->field_type());
case IMPOSSIBLE_RESULT: case IMPOSSIBLE_RESULT:
DBUG_ASSERT(0); DBUG_ASSERT(0);
break; break;
@ -8922,7 +8981,8 @@ int Item_cache_int::save_in_field(Field *field, bool no_conversions)
} }
Item_cache_temporal::Item_cache_temporal(THD *thd, enum_field_types field_type_arg): Item_cache_temporal::Item_cache_temporal(THD *thd,
enum_field_types field_type_arg):
Item_cache_int(thd, field_type_arg) Item_cache_int(thd, field_type_arg)
{ {
if (mysql_type_to_time_type(cached_field_type) == MYSQL_TIMESTAMP_ERROR) if (mysql_type_to_time_type(cached_field_type) == MYSQL_TIMESTAMP_ERROR)
@ -9050,6 +9110,15 @@ void Item_cache_temporal::store_packed(longlong val_arg, Item *example_arg)
} }
Item *Item_cache_temporal::clone_item(THD *thd)
{
Item_cache_temporal *item= new (thd->mem_root)
Item_cache_temporal(thd, cached_field_type);
item->store_packed(value, example);
return item;
}
bool Item_cache_real::cache_value() bool Item_cache_real::cache_value()
{ {
if (!example) if (!example)

32
sql/item.h
View File

@ -610,9 +610,9 @@ class Item: public Type_std_attributes
*/ */
uint join_tab_idx; uint join_tab_idx;
static void *operator new(size_t size);
public: public:
static void *operator new(size_t size) throw ()
{ return sql_alloc(size); }
static void *operator new(size_t size, MEM_ROOT *mem_root) throw () static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return alloc_root(mem_root, size); } { return alloc_root(mem_root, size); }
static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); } static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
@ -2454,7 +2454,7 @@ public:
enum Item_result result_type () const { return STRING_RESULT; } enum Item_result result_type () const { return STRING_RESULT; }
enum_field_types field_type() const { return MYSQL_TYPE_NULL; } enum_field_types field_type() const { return MYSQL_TYPE_NULL; }
bool basic_const_item() const { return 1; } bool basic_const_item() const { return 1; }
Item *clone_item(THD *thd) { return new Item_null(thd, name); } Item *clone_item(THD *thd);
bool is_null() { return 1; } bool is_null() { return 1; }
virtual inline void print(String *str, enum_query_type query_type) virtual inline void print(String *str, enum_query_type query_type)
@ -2663,7 +2663,7 @@ public:
String *val_str(String*); String *val_str(String*);
int save_in_field(Field *field, bool no_conversions); int save_in_field(Field *field, bool no_conversions);
bool basic_const_item() const { return 1; } bool basic_const_item() const { return 1; }
Item *clone_item(THD *thd) { return new Item_int(thd, name, value, max_length); } Item *clone_item(THD *thd);
virtual void print(String *str, enum_query_type query_type); virtual void print(String *str, enum_query_type query_type);
Item_num *neg(THD *thd) { value= -value; return this; } Item_num *neg(THD *thd) { value= -value; return this; }
uint decimal_precision() const uint decimal_precision() const
@ -2684,8 +2684,7 @@ public:
double val_real() double val_real()
{ DBUG_ASSERT(fixed == 1); return ulonglong2double((ulonglong)value); } { DBUG_ASSERT(fixed == 1); return ulonglong2double((ulonglong)value); }
String *val_str(String*); String *val_str(String*);
Item *clone_item(THD *thd) Item *clone_item(THD *thd);
{ return new Item_uint(thd, name, value, max_length); }
virtual void print(String *str, enum_query_type query_type); virtual void print(String *str, enum_query_type query_type);
Item_num *neg(THD *thd); Item_num *neg(THD *thd);
uint decimal_precision() const { return max_length; } uint decimal_precision() const { return max_length; }
@ -2729,10 +2728,7 @@ public:
my_decimal *val_decimal(my_decimal *val) { return &decimal_value; } my_decimal *val_decimal(my_decimal *val) { return &decimal_value; }
int save_in_field(Field *field, bool no_conversions); int save_in_field(Field *field, bool no_conversions);
bool basic_const_item() const { return 1; } bool basic_const_item() const { return 1; }
Item *clone_item(THD *thd) Item *clone_item(THD *thd);
{
return new Item_decimal(thd, name, &decimal_value, decimals, max_length);
}
virtual void print(String *str, enum_query_type query_type); virtual void print(String *str, enum_query_type query_type);
Item_num *neg(THD *thd) Item_num *neg(THD *thd)
{ {
@ -2788,8 +2784,7 @@ public:
String *val_str(String*); String *val_str(String*);
my_decimal *val_decimal(my_decimal *); my_decimal *val_decimal(my_decimal *);
bool basic_const_item() const { return 1; } bool basic_const_item() const { return 1; }
Item *clone_item(THD *thd) Item *clone_item(THD *thd);
{ return new Item_float(thd, name, value, decimals, max_length); }
Item_num *neg(THD *thd) { value= -value; return this; } Item_num *neg(THD *thd) { value= -value; return this; }
virtual void print(String *str, enum_query_type query_type); virtual void print(String *str, enum_query_type query_type);
bool eq(const Item *item, bool binary_cmp) const bool eq(const Item *item, bool binary_cmp) const
@ -2914,11 +2909,7 @@ public:
{ {
return str_eq(&str_value, item, binary_cmp); return str_eq(&str_value, item, binary_cmp);
} }
Item *clone_item(THD *thd) Item *clone_item(THD *thd);
{
return new Item_string(thd, name, str_value.ptr(),
str_value.length(), collation.collation);
}
Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
{ {
return const_charset_converter(thd, tocs, true); return const_charset_converter(thd, tocs, true);
@ -4849,12 +4840,7 @@ public:
is a constant and need not be optimized further. is a constant and need not be optimized further.
Important when storing packed datetime values. Important when storing packed datetime values.
*/ */
Item *clone_item(THD *thd) Item *clone_item(THD *thd);
{
Item_cache_temporal *item= new Item_cache_temporal(thd, cached_field_type);
item->store_packed(value, example);
return item;
}
}; };

87
sql/item_cmpfunc.cc
View File

@ -442,7 +442,7 @@ static bool convert_const_to_int(THD *thd, Item_field *field_item,
if (0 == field_cmp) if (0 == field_cmp)
{ {
Item *tmp= new Item_int_with_ref(thd, field->val_int(), *item, Item *tmp= new (thd->mem_root) Item_int_with_ref(thd, field->val_int(), *item,
MY_TEST(field->flags & UNSIGNED_FLAG)); MY_TEST(field->flags & UNSIGNED_FLAG));
if (tmp) if (tmp)
thd->change_item_tree(item, tmp); thd->change_item_tree(item, tmp);
@ -878,7 +878,7 @@ get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg,
{ {
Query_arena backup; Query_arena backup;
Query_arena *save_arena= thd->switch_to_arena_for_cached_items(&backup); Query_arena *save_arena= thd->switch_to_arena_for_cached_items(&backup);
Item_cache_temporal *cache= new Item_cache_temporal(thd, f_type); Item_cache_temporal *cache= new (thd->mem_root) Item_cache_temporal(thd, f_type);
if (save_arena) if (save_arena)
thd->set_query_arena(save_arena); thd->set_query_arena(save_arena);
@ -3475,6 +3475,12 @@ uchar *in_string::get_value(Item *item)
return (uchar*) item->val_str(&tmp); return (uchar*) item->val_str(&tmp);
} }
Item *in_string::create_item(THD *thd)
{
return new (thd->mem_root) Item_string_for_in_vector(thd, collation);
}
in_row::in_row(uint elements, Item * item) in_row::in_row(uint elements, Item * item)
{ {
base= (char*) new cmp_item_row[count= elements]; base= (char*) new cmp_item_row[count= elements];
@ -3531,6 +3537,16 @@ uchar *in_longlong::get_value(Item *item)
return (uchar*) &tmp; return (uchar*) &tmp;
} }
Item *in_longlong::create_item(THD *thd)
{
/*
We're created a signed INT, this may not be correct in
general case (see BUG#19342).
*/
return new (thd->mem_root) Item_int(thd, (longlong)0);
}
void in_datetime::set(uint pos,Item *item) void in_datetime::set(uint pos,Item *item)
{ {
Item **tmp_item= &item; Item **tmp_item= &item;
@ -3552,6 +3568,12 @@ uchar *in_datetime::get_value(Item *item)
return (uchar*) &tmp; return (uchar*) &tmp;
} }
Item *in_datetime::create_item(THD *thd)
{
return new (thd->mem_root) Item_datetime(thd);
}
in_double::in_double(uint elements) in_double::in_double(uint elements)
:in_vector(elements,sizeof(double),(qsort2_cmp) cmp_double, 0) :in_vector(elements,sizeof(double),(qsort2_cmp) cmp_double, 0)
{} {}
@ -3569,6 +3591,11 @@ uchar *in_double::get_value(Item *item)
return (uchar*) &tmp; return (uchar*) &tmp;
} }
Item *in_double::create_item(THD *thd)
{
return new (thd->mem_root) Item_float(thd, 0.0, 0);
}
in_decimal::in_decimal(uint elements) in_decimal::in_decimal(uint elements)
:in_vector(elements, sizeof(my_decimal),(qsort2_cmp) cmp_decimal, 0) :in_vector(elements, sizeof(my_decimal),(qsort2_cmp) cmp_decimal, 0)
@ -3596,6 +3623,11 @@ uchar *in_decimal::get_value(Item *item)
return (uchar *)result; return (uchar *)result;
} }
Item *in_decimal::create_item(THD *thd)
{
return new (thd->mem_root) Item_decimal(thd, 0, FALSE);
}
cmp_item* cmp_item::get_comparator(Item_result type, Item *warn_item, cmp_item* cmp_item::get_comparator(Item_result type, Item *warn_item,
CHARSET_INFO *cs) CHARSET_INFO *cs)
@ -4220,6 +4252,15 @@ Item_cond::Item_cond(THD *thd, Item_cond *item)
} }
Item *Item_cond_and::copy_andor_structure(THD *thd)
{
Item_cond_and *item;
if ((item= new (thd->mem_root) Item_cond_and(thd, this)))
item->copy_andor_arguments(thd, this);
return item;
}
void Item_cond::copy_andor_arguments(THD *thd, Item_cond *item) void Item_cond::copy_andor_arguments(THD *thd, Item_cond *item)
{ {
List_iterator_fast<Item> li(item->list); List_iterator_fast<Item> li(item->list);
@ -4284,7 +4325,7 @@ Item_cond::fix_fields(THD *thd, Item **ref)
Query_arena backup, *arena; Query_arena backup, *arena;
Item *new_item; Item *new_item;
arena= thd->activate_stmt_arena_if_needed(&backup); arena= thd->activate_stmt_arena_if_needed(&backup);
if ((new_item= new Item_func_ne(thd, item, new Item_int(thd, 0, 1)))) if ((new_item= new (thd->mem_root) Item_func_ne(thd, item, new (thd->mem_root) Item_int(thd, 0, 1))))
li.replace(item= new_item); li.replace(item= new_item);
if (arena) if (arena)
thd->restore_active_arena(arena, &backup); thd->restore_active_arena(arena, &backup);
@ -4606,7 +4647,7 @@ void Item_cond::neg_arguments(THD *thd)
Item *new_item= item->neg_transformer(thd); Item *new_item= item->neg_transformer(thd);
if (!new_item) if (!new_item)
{ {
if (!(new_item= new Item_func_not(thd, item))) if (!(new_item= new (thd->mem_root) Item_func_not(thd, item)))
return; // Fatal OEM error return; // Fatal OEM error
} }
(void) li.replace(new_item); (void) li.replace(new_item);
@ -4624,7 +4665,6 @@ void Item_cond_and::mark_as_condition_AND_part(TABLE_LIST *embedding)
} }
} }
/** /**
Evaluation of AND(expr, expr, expr ...). Evaluation of AND(expr, expr, expr ...).
@ -4682,6 +4722,15 @@ longlong Item_cond_or::val_int()
return 0; return 0;
} }
Item *Item_cond_or::copy_andor_structure(THD *thd)
{
Item_cond_or *item;
if ((item= new (thd->mem_root) Item_cond_or(thd, this)))
item->copy_andor_arguments(thd, this);
return item;
}
/** /**
Create an AND expression from two expressions. Create an AND expression from two expressions.
@ -4709,7 +4758,7 @@ Item *and_expressions(THD *thd, Item *a, Item *b, Item **org_item)
if (a == *org_item) if (a == *org_item)
{ {
Item_cond *res; Item_cond *res;
if ((res= new Item_cond_and(thd, a, (Item*) b))) if ((res= new (thd->mem_root) Item_cond_and(thd, a, (Item*) b)))
{ {
res->used_tables_cache= a->used_tables() | b->used_tables(); res->used_tables_cache= a->used_tables() | b->used_tables();
res->not_null_tables_cache= a->not_null_tables() | b->not_null_tables(); res->not_null_tables_cache= a->not_null_tables() | b->not_null_tables();
@ -5527,7 +5576,7 @@ bool Item_func_not::fix_fields(THD *thd, Item **ref)
Item *new_item; Item *new_item;
bool rc= TRUE; bool rc= TRUE;
arena= thd->activate_stmt_arena_if_needed(&backup); arena= thd->activate_stmt_arena_if_needed(&backup);
if ((new_item= new Item_func_eq(thd, args[0], new Item_int(thd, 0, 1)))) if ((new_item= new (thd->mem_root) Item_func_eq(thd, args[0], new (thd->mem_root) Item_int(thd, 0, 1))))
{ {
new_item->name= name; new_item->name= name;
rc= (*ref= new_item)->fix_fields(thd, ref); rc= (*ref= new_item)->fix_fields(thd, ref);
@ -5579,7 +5628,7 @@ Item *Item_func_xor::neg_transformer(THD *thd)
*/ */
Item *Item_func_isnull::neg_transformer(THD *thd) Item *Item_func_isnull::neg_transformer(THD *thd)
{ {
Item *item= new Item_func_isnotnull(thd, args[0]); Item *item= new (thd->mem_root) Item_func_isnotnull(thd, args[0]);
return item; return item;
} }
@ -5589,7 +5638,7 @@ Item *Item_func_isnull::neg_transformer(THD *thd)
*/ */
Item *Item_func_isnotnull::neg_transformer(THD *thd) Item *Item_func_isnotnull::neg_transformer(THD *thd)
{ {
Item *item= new Item_func_isnull(thd, args[0]); Item *item= new (thd->mem_root) Item_func_isnull(thd, args[0]);
return item; return item;
} }
@ -5598,7 +5647,7 @@ Item *Item_cond_and::neg_transformer(THD *thd) /* NOT(a AND b AND ...) -> */
/* NOT a OR NOT b OR ... */ /* NOT a OR NOT b OR ... */
{ {
neg_arguments(thd); neg_arguments(thd);
Item *item= new Item_cond_or(thd, list); Item *item= new (thd->mem_root) Item_cond_or(thd, list);
return item; return item;
} }
@ -5607,7 +5656,7 @@ Item *Item_cond_or::neg_transformer(THD *thd) /* NOT(a OR b OR ...) -> */
/* NOT a AND NOT b AND ... */ /* NOT a AND NOT b AND ... */
{ {
neg_arguments(thd); neg_arguments(thd);
Item *item= new Item_cond_and(thd, list); Item *item= new (thd->mem_root) Item_cond_and(thd, list);
return item; return item;
} }
@ -5615,7 +5664,7 @@ Item *Item_cond_or::neg_transformer(THD *thd) /* NOT(a OR b OR ...) -> */
Item *Item_func_nop_all::neg_transformer(THD *thd) Item *Item_func_nop_all::neg_transformer(THD *thd)
{ {
/* "NOT (e $cmp$ ANY (SELECT ...)) -> e $rev_cmp$" ALL (SELECT ...) */ /* "NOT (e $cmp$ ANY (SELECT ...)) -> e $rev_cmp$" ALL (SELECT ...) */
Item_func_not_all *new_item= new Item_func_not_all(thd, args[0]); Item_func_not_all *new_item= new (thd->mem_root) Item_func_not_all(thd, args[0]);
Item_allany_subselect *allany= (Item_allany_subselect*)args[0]; Item_allany_subselect *allany= (Item_allany_subselect*)args[0];
allany->create_comp_func(FALSE); allany->create_comp_func(FALSE);
allany->all= !allany->all; allany->all= !allany->all;
@ -5626,7 +5675,7 @@ Item *Item_func_nop_all::neg_transformer(THD *thd)
Item *Item_func_not_all::neg_transformer(THD *thd) Item *Item_func_not_all::neg_transformer(THD *thd)
{ {
/* "NOT (e $cmp$ ALL (SELECT ...)) -> e $rev_cmp$" ANY (SELECT ...) */ /* "NOT (e $cmp$ ALL (SELECT ...)) -> e $rev_cmp$" ANY (SELECT ...) */
Item_func_nop_all *new_item= new Item_func_nop_all(thd, args[0]); Item_func_nop_all *new_item= new (thd->mem_root) Item_func_nop_all(thd, args[0]);
Item_allany_subselect *allany= (Item_allany_subselect*)args[0]; Item_allany_subselect *allany= (Item_allany_subselect*)args[0];
allany->all= !allany->all; allany->all= !allany->all;
allany->create_comp_func(TRUE); allany->create_comp_func(TRUE);
@ -5636,37 +5685,37 @@ Item *Item_func_not_all::neg_transformer(THD *thd)
Item *Item_func_eq::negated_item(THD *thd) /* a = b -> a != b */ Item *Item_func_eq::negated_item(THD *thd) /* a = b -> a != b */
{ {
return new Item_func_ne(thd, args[0], args[1]); return new (thd->mem_root) Item_func_ne(thd, args[0], args[1]);
} }
Item *Item_func_ne::negated_item(THD *thd) /* a != b -> a = b */ Item *Item_func_ne::negated_item(THD *thd) /* a != b -> a = b */
{ {
return new Item_func_eq(thd, args[0], args[1]); return new (thd->mem_root) Item_func_eq(thd, args[0], args[1]);
} }
Item *Item_func_lt::negated_item(THD *thd) /* a < b -> a >= b */ Item *Item_func_lt::negated_item(THD *thd) /* a < b -> a >= b */
{ {
return new Item_func_ge(thd, args[0], args[1]); return new (thd->mem_root) Item_func_ge(thd, args[0], args[1]);
} }
Item *Item_func_ge::negated_item(THD *thd) /* a >= b -> a < b */ Item *Item_func_ge::negated_item(THD *thd) /* a >= b -> a < b */
{ {
return new Item_func_lt(thd, args[0], args[1]); return new (thd->mem_root) Item_func_lt(thd, args[0], args[1]);
} }
Item *Item_func_gt::negated_item(THD *thd) /* a > b -> a <= b */ Item *Item_func_gt::negated_item(THD *thd) /* a > b -> a <= b */
{ {
return new Item_func_le(thd, args[0], args[1]); return new (thd->mem_root) Item_func_le(thd, args[0], args[1]);
} }
Item *Item_func_le::negated_item(THD *thd) /* a <= b -> a > b */ Item *Item_func_le::negated_item(THD *thd) /* a <= b -> a > b */
{ {
return new Item_func_gt(thd, args[0], args[1]); return new (thd->mem_root) Item_func_gt(thd, args[0], args[1]);
} }
/** /**

56
sql/item_cmpfunc.h
View File

@ -971,10 +971,7 @@ public:
~in_string(); ~in_string();
void set(uint pos,Item *item); void set(uint pos,Item *item);
uchar *get_value(Item *item); uchar *get_value(Item *item);
Item* create_item(THD *thd) Item* create_item(THD *thd);
{
return new Item_string_for_in_vector(thd, collation);
}
void value_to_item(uint pos, Item *item) void value_to_item(uint pos, Item *item)
{ {
String *str=((String*) base)+pos; String *str=((String*) base)+pos;
@ -1001,15 +998,7 @@ public:
in_longlong(uint elements); in_longlong(uint elements);
void set(uint pos,Item *item); void set(uint pos,Item *item);
uchar *get_value(Item *item); uchar *get_value(Item *item);
Item* create_item(THD *thd);
Item* create_item(THD *thd)
{
/*
We're created a signed INT, this may not be correct in
general case (see BUG#19342).
*/
return new Item_int(thd, (longlong)0);
}
void value_to_item(uint pos, Item *item) void value_to_item(uint pos, Item *item)
{ {
((Item_int*) item)->value= ((packed_longlong*) base)[pos].val; ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val;
@ -1042,10 +1031,7 @@ public:
lval_cache(0) {}; lval_cache(0) {};
void set(uint pos,Item *item); void set(uint pos,Item *item);
uchar *get_value(Item *item); uchar *get_value(Item *item);
Item* create_item(THD *thd) Item *create_item(THD *thd);
{
return new Item_datetime(thd);
}
void value_to_item(uint pos, Item *item) void value_to_item(uint pos, Item *item)
{ {
packed_longlong *val= reinterpret_cast<packed_longlong*>(base)+pos; packed_longlong *val= reinterpret_cast<packed_longlong*>(base)+pos;
@ -1063,10 +1049,7 @@ public:
in_double(uint elements); in_double(uint elements);
void set(uint pos,Item *item); void set(uint pos,Item *item);
uchar *get_value(Item *item); uchar *get_value(Item *item);
Item *create_item(THD *thd) Item *create_item(THD *thd);
{
return new Item_float(thd, 0.0, 0);
}
void value_to_item(uint pos, Item *item) void value_to_item(uint pos, Item *item)
{ {
((Item_float*)item)->value= ((double*) base)[pos]; ((Item_float*)item)->value= ((double*) base)[pos];
@ -1082,10 +1065,7 @@ public:
in_decimal(uint elements); in_decimal(uint elements);
void set(uint pos, Item *item); void set(uint pos, Item *item);
uchar *get_value(Item *item); uchar *get_value(Item *item);
Item *create_item(THD *thd) Item *create_item(THD *thd);
{
return new Item_decimal(thd, 0, FALSE);
}
void value_to_item(uint pos, Item *item) void value_to_item(uint pos, Item *item)
{ {
my_decimal *dec= ((my_decimal *)base) + pos; my_decimal *dec= ((my_decimal *)base) + pos;
@ -2178,13 +2158,7 @@ public:
const char *func_name() const { return "and"; } const char *func_name() const { return "and"; }
table_map not_null_tables() const table_map not_null_tables() const
{ return abort_on_null ? not_null_tables_cache: and_tables_cache; } { return abort_on_null ? not_null_tables_cache: and_tables_cache; }
Item* copy_andor_structure(THD *thd) Item *copy_andor_structure(THD *thd);
{
Item_cond_and *item;
if ((item= new Item_cond_and(thd, this)))
item->copy_andor_arguments(thd, this);
return item;
}
Item *neg_transformer(THD *thd); Item *neg_transformer(THD *thd);
void mark_as_condition_AND_part(TABLE_LIST *embedding); void mark_as_condition_AND_part(TABLE_LIST *embedding);
virtual uint exists2in_reserved_items() { return list.elements; }; virtual uint exists2in_reserved_items() { return list.elements; };
@ -2217,13 +2191,7 @@ public:
longlong val_int(); longlong val_int();
const char *func_name() const { return "or"; } const char *func_name() const { return "or"; }
table_map not_null_tables() const { return and_tables_cache; } table_map not_null_tables() const { return and_tables_cache; }
Item* copy_andor_structure(THD *thd) Item *copy_andor_structure(THD *thd);
{
Item_cond_or *item;
if ((item= new Item_cond_or(thd, this)))
item->copy_andor_arguments(thd, this);
return item;
}
Item *neg_transformer(THD *thd); Item *neg_transformer(THD *thd);
}; };
@ -2253,16 +2221,6 @@ inline bool is_cond_or(Item *item)
return (cond_item->functype() == Item_func::COND_OR_FUNC); return (cond_item->functype() == Item_func::COND_OR_FUNC);
} }
/* Some useful inline functions */
inline Item *and_conds(THD *thd, Item *a, Item *b)
{
if (!b) return a;
if (!a) return b;
return new Item_cond_and(thd, a, b);
}
Item *and_expressions(Item *a, Item *b, Item **org_item); Item *and_expressions(Item *a, Item *b, Item **org_item);
longlong get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg, longlong get_datetime_value(THD *thd, Item ***item_arg, Item **cache_arg,

4
sql/item_create.cc
View File

@ -5234,7 +5234,7 @@ Create_func_round::create_native(THD *thd, LEX_STRING name,
case 1: case 1:
{ {
Item *param_1= item_list->pop(); Item *param_1= item_list->pop();
Item *i0 = new (thd->mem_root) Item_int(thd, (char*)"0", 0, 1); Item *i0= new (thd->mem_root) Item_int(thd, (char*)"0", 0, 1);
func= new (thd->mem_root) Item_func_round(thd, param_1, i0, 0); func= new (thd->mem_root) Item_func_round(thd, param_1, i0, 0);
break; break;
} }
@ -6397,7 +6397,7 @@ Item *create_func_dyncol_delete(THD *thd, Item *str, List<Item> &nums)
for (uint i= 0; (key= it++); i++) for (uint i= 0; (key= it++); i++)
{ {
dfs[i].key= key; dfs[i].key= key;
dfs[i].value= new Item_null(thd); dfs[i].value= new (thd->mem_root) Item_null(thd);
dfs[i].type= DYN_COL_INT; dfs[i].type= DYN_COL_INT;
args->push_back(dfs[i].key); args->push_back(dfs[i].key);
args->push_back(dfs[i].value); args->push_back(dfs[i].value);

16
sql/item_func.cc
View File

@ -727,7 +727,7 @@ void Item_func::signal_divide_by_null()
Item *Item_func::get_tmp_table_item(THD *thd) Item *Item_func::get_tmp_table_item(THD *thd)
{ {
if (!with_sum_func && !const_item()) if (!with_sum_func && !const_item())
return new Item_field(thd, result_field); return new (thd->mem_root) Item_field(thd, result_field);
return copy_or_same(thd); return copy_or_same(thd);
} }
@ -5534,8 +5534,10 @@ get_var_with_binlog(THD *thd, enum_sql_command sql_command,
LEX *sav_lex= thd->lex, lex_tmp; LEX *sav_lex= thd->lex, lex_tmp;
thd->lex= &lex_tmp; thd->lex= &lex_tmp;
lex_start(thd); lex_start(thd);
tmp_var_list.push_back(new set_var_user(new Item_func_set_user_var(thd, name, tmp_var_list.push_back(new (thd->mem_root)
new Item_null(thd)))); set_var_user(new (thd->mem_root)
Item_func_set_user_var(thd, name,
new (thd->mem_root) Item_null(thd))));
/* Create the variable */ /* Create the variable */
if (sql_set_variables(thd, &tmp_var_list, false)) if (sql_set_variables(thd, &tmp_var_list, false))
{ {
@ -5699,7 +5701,7 @@ bool Item_func_get_user_var::eq(const Item *item, bool binary_cmp) const
bool Item_func_get_user_var::set_value(THD *thd, bool Item_func_get_user_var::set_value(THD *thd,
sp_rcontext * /*ctx*/, Item **it) sp_rcontext * /*ctx*/, Item **it)
{ {
Item_func_set_user_var *suv= new Item_func_set_user_var(thd, get_name(), *it); Item_func_set_user_var *suv= new (thd->mem_root) Item_func_set_user_var(thd, get_name(), *it);
/* /*
Item_func_set_user_var is not fixed after construction, call Item_func_set_user_var is not fixed after construction, call
fix_fields(). fix_fields().
@ -6114,10 +6116,10 @@ void Item_func_match::init_search(THD *thd, bool no_order)
if (key == NO_SUCH_KEY) if (key == NO_SUCH_KEY)
{ {
List<Item> fields; List<Item> fields;
fields.push_back(new Item_string(thd, " ", 1, cmp_collation.collation)); fields.push_back(new (thd->mem_root) Item_string(thd, " ", 1, cmp_collation.collation));
for (uint i= 1; i < arg_count; i++) for (uint i= 1; i < arg_count; i++)
fields.push_back(args[i]); fields.push_back(args[i]);
concat_ws= new Item_func_concat_ws(thd, fields); concat_ws= new (thd->mem_root) Item_func_concat_ws(thd, fields);
/* /*
Above function used only to get value and do not need fix_fields for it: Above function used only to get value and do not need fix_fields for it:
Item_string - basic constant Item_string - basic constant
@ -6465,7 +6467,7 @@ Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
set_if_smaller(component_name->length, MAX_SYS_VAR_LENGTH); set_if_smaller(component_name->length, MAX_SYS_VAR_LENGTH);
return new Item_func_get_system_var(thd, var, var_type, component_name, return new (thd->mem_root) Item_func_get_system_var(thd, var, var_type, component_name,
NULL, 0); NULL, 0);
} }

213
sql/item_subselect.cc
View File

@ -875,7 +875,7 @@ bool Item_subselect::const_item() const
Item *Item_subselect::get_tmp_table_item(THD *thd_arg) Item *Item_subselect::get_tmp_table_item(THD *thd_arg)
{ {
if (!with_sum_func && !const_item()) if (!with_sum_func && !const_item())
return new Item_field(thd_arg, result_field); return new (thd->mem_root) Item_field(thd_arg, result_field);
return copy_or_same(thd_arg); return copy_or_same(thd_arg);
} }
@ -1013,7 +1013,7 @@ void Item_maxmin_subselect::no_rows_in_result()
*/ */
if (parsing_place != SELECT_LIST || const_item()) if (parsing_place != SELECT_LIST || const_item())
return; return;
value= Item_cache::get_cache(thd, new Item_null(thd)); value= Item_cache::get_cache(thd, new (thd->mem_root) Item_null(thd));
null_value= 0; null_value= 0;
was_values= 0; was_values= 0;
make_const(); make_const();
@ -1031,7 +1031,7 @@ void Item_singlerow_subselect::no_rows_in_result()
*/ */
if (parsing_place != SELECT_LIST || const_item()) if (parsing_place != SELECT_LIST || const_item())
return; return;
value= Item_cache::get_cache(thd, new Item_null(thd)); value= Item_cache::get_cache(thd, new (thd->mem_root) Item_null(thd));
reset(); reset();
make_const(); make_const();
} }
@ -1448,7 +1448,7 @@ void Item_exists_subselect::fix_length_and_dec()
an IN always requires LIMIT 1) an IN always requires LIMIT 1)
*/ */
thd->change_item_tree(&unit->global_parameters()->select_limit, thd->change_item_tree(&unit->global_parameters()->select_limit,
new Item_int(thd, (int32) 1)); new (thd->mem_root) Item_int(thd, (int32) 1));
DBUG_PRINT("info", ("Set limit to 1")); DBUG_PRINT("info", ("Set limit to 1"));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -1819,7 +1819,7 @@ Item_in_subselect::single_value_transformer(JOIN *join)
As far as Item_in_optimizer does not substitute itself on fix_fields As far as Item_in_optimizer does not substitute itself on fix_fields
we can use same item for all selects. we can use same item for all selects.
*/ */
expr= new Item_direct_ref(thd, &select_lex->context, expr= new (thd->mem_root) Item_direct_ref(thd, &select_lex->context,
(Item**)optimizer->get_cache(), (Item**)optimizer->get_cache(),
(char *)"<no matter>", (char *)"<no matter>",
(char *)in_left_expr_name); (char *)in_left_expr_name);
@ -1887,7 +1887,7 @@ bool Item_allany_subselect::transform_into_max_min(JOIN *join)
(ALL && (> || =>)) || (ANY && (< || =<)) (ALL && (> || =>)) || (ANY && (< || =<))
for ALL condition is inverted for ALL condition is inverted
*/ */
item= new Item_sum_max(thd, *select_lex->ref_pointer_array); item= new (thd->mem_root) Item_sum_max(thd, *select_lex->ref_pointer_array);
} }
else else
{ {
@ -1895,7 +1895,7 @@ bool Item_allany_subselect::transform_into_max_min(JOIN *join)
(ALL && (< || =<)) || (ANY && (> || =>)) (ALL && (< || =<)) || (ANY && (> || =>))
for ALL condition is inverted for ALL condition is inverted
*/ */
item= new Item_sum_min(thd, *select_lex->ref_pointer_array); item= new (thd->mem_root) Item_sum_min(thd, *select_lex->ref_pointer_array);
} }
if (upper_item) if (upper_item)
upper_item->set_sum_test(item); upper_item->set_sum_test(item);
@ -1936,7 +1936,7 @@ bool Item_allany_subselect::transform_into_max_min(JOIN *join)
else else
{ {
Item_maxmin_subselect *item; Item_maxmin_subselect *item;
subs= item= new Item_maxmin_subselect(thd, this, select_lex, func->l_op()); subs= item= new (thd->mem_root) Item_maxmin_subselect(thd, this, select_lex, func->l_op());
if (upper_item) if (upper_item)
upper_item->set_sub_test(item); upper_item->set_sub_test(item);
/* /*
@ -2056,7 +2056,7 @@ Item_in_subselect::create_single_in_to_exists_cond(JOIN * join,
We can encounter "NULL IN (SELECT ...)". Wrap the added condition We can encounter "NULL IN (SELECT ...)". Wrap the added condition
within a trig_cond. within a trig_cond.
*/ */
item= new Item_func_trig_cond(thd, item, get_cond_guard(0)); item= new (thd->mem_root) Item_func_trig_cond(thd, item, get_cond_guard(0));
} }
if (!join_having) if (!join_having)
@ -2300,42 +2300,50 @@ Item_in_subselect::create_row_in_to_exists_cond(JOIN * join,
check_cols(left_expr->element_index(i)->cols())) check_cols(left_expr->element_index(i)->cols()))
DBUG_RETURN(true); DBUG_RETURN(true);
Item *item_eq= Item *item_eq=
new Item_func_eq(thd, new new (thd->mem_root)
Item_direct_ref(thd, &select_lex->context, Item_func_eq(thd, new (thd->mem_root)
(*optimizer->get_cache())-> Item_direct_ref(thd, &select_lex->context,
addr(i), (*optimizer->get_cache())->
(char *)"<no matter>", addr(i),
(char *)in_left_expr_name), (char *)"<no matter>",
new (char *)in_left_expr_name),
new (thd->mem_root)
Item_ref(thd, &select_lex->context,
select_lex->ref_pointer_array + i,
(char *)"<no matter>",
(char *)"<list ref>"));
Item *item_isnull=
new (thd->mem_root)
Item_func_isnull(thd,
new (thd->mem_root)
Item_ref(thd, &select_lex->context, Item_ref(thd, &select_lex->context,
select_lex->ref_pointer_array + i, select_lex->ref_pointer_array+i,
(char *)"<no matter>", (char *)"<no matter>",
(char *)"<list ref>")); (char *)"<list ref>"));
Item *item_isnull= Item *col_item= new (thd->mem_root)
new Item_func_isnull(thd, new Item_cond_or(thd, item_eq, item_isnull);
Item_ref(thd, &select_lex->context,
select_lex->ref_pointer_array+i,
(char *)"<no matter>",
(char *)"<list ref>"));
Item *col_item= new Item_cond_or(thd, item_eq, item_isnull);
if (!abort_on_null && left_expr->element_index(i)->maybe_null) if (!abort_on_null && left_expr->element_index(i)->maybe_null)
{ {
if (!(col_item= new Item_func_trig_cond(thd, col_item, get_cond_guard(i)))) if (!(col_item= new (thd->mem_root)
Item_func_trig_cond(thd, col_item, get_cond_guard(i))))
DBUG_RETURN(true); DBUG_RETURN(true);
} }
*having_item= and_items(thd, *having_item, col_item); *having_item= and_items(thd, *having_item, col_item);
Item *item_nnull_test= Item *item_nnull_test=
new Item_is_not_null_test(thd, this, new (thd->mem_root)
new Item_ref(thd, &select_lex->context, Item_is_not_null_test(thd, this,
select_lex-> new (thd->mem_root)
ref_pointer_array + i, Item_ref(thd, &select_lex->context,
(char *)"<no matter>", select_lex->
(char *)"<list ref>")); ref_pointer_array + i,
(char *)"<no matter>",
(char *)"<list ref>"));
if (!abort_on_null && left_expr->element_index(i)->maybe_null) if (!abort_on_null && left_expr->element_index(i)->maybe_null)
{ {
if (!(item_nnull_test= if (!(item_nnull_test=
new Item_func_trig_cond(thd, item_nnull_test, get_cond_guard(i)))) new (thd->mem_root)
Item_func_trig_cond(thd, item_nnull_test, get_cond_guard(i))))
DBUG_RETURN(true); DBUG_RETURN(true);
} }
item_having_part2= and_items(thd, item_having_part2, item_nnull_test); item_having_part2= and_items(thd, item_having_part2, item_nnull_test);
@ -2356,51 +2364,56 @@ Item_in_subselect::create_row_in_to_exists_cond(JOIN * join,
if (select_lex->ref_pointer_array[i]-> if (select_lex->ref_pointer_array[i]->
check_cols(left_expr->element_index(i)->cols())) check_cols(left_expr->element_index(i)->cols()))
DBUG_RETURN(true); DBUG_RETURN(true);
item= item= new (thd->mem_root)
new Item_func_eq(thd, new Item_func_eq(thd,
Item_direct_ref(thd, &select_lex->context, new (thd->mem_root)
(*optimizer->get_cache())-> Item_direct_ref(thd, &select_lex->context,
addr(i), (*optimizer->get_cache())->
(char *)"<no matter>", addr(i),
(char *)in_left_expr_name), (char *)"<no matter>",
new (char *)in_left_expr_name),
Item_direct_ref(thd, &select_lex->context, new (thd->mem_root)
select_lex-> Item_direct_ref(thd, &select_lex->context,
ref_pointer_array+i, select_lex->
(char *)"<no matter>", ref_pointer_array+i,
(char *)"<list ref>")); (char *)"<no matter>",
(char *)"<list ref>"));
if (!abort_on_null && select_lex->ref_pointer_array[i]->maybe_null) if (!abort_on_null && select_lex->ref_pointer_array[i]->maybe_null)
{ {
Item *having_col_item= Item *having_col_item=
new Item_is_not_null_test(thd, this, new (thd->mem_root)
new Item_is_not_null_test(thd, this,
Item_ref(thd, &select_lex->context, new (thd->mem_root)
select_lex->ref_pointer_array + i, Item_ref(thd, &select_lex->context,
(char *)"<no matter>", select_lex->ref_pointer_array + i,
(char *)"<list ref>")); (char *)"<no matter>",
(char *)"<list ref>"));
item_isnull= new item_isnull= new (thd->mem_root)
Item_func_isnull(thd, new Item_func_isnull(thd,
new (thd->mem_root)
Item_direct_ref(thd, &select_lex->context, Item_direct_ref(thd, &select_lex->context,
select_lex-> select_lex->
ref_pointer_array+i, ref_pointer_array+i,
(char *)"<no matter>", (char *)"<no matter>",
(char *)"<list ref>")); (char *)"<list ref>"));
item= new Item_cond_or(thd, item, item_isnull); item= new (thd->mem_root) Item_cond_or(thd, item, item_isnull);
if (left_expr->element_index(i)->maybe_null) if (left_expr->element_index(i)->maybe_null)
{ {
if (!(item= new Item_func_trig_cond(thd, item, get_cond_guard(i)))) if (!(item= new (thd->mem_root)
Item_func_trig_cond(thd, item, get_cond_guard(i))))
DBUG_RETURN(true); DBUG_RETURN(true);
if (!(having_col_item= if (!(having_col_item= new (thd->mem_root)
new Item_func_trig_cond(thd, having_col_item, get_cond_guard(i)))) Item_func_trig_cond(thd, having_col_item, get_cond_guard(i))))
DBUG_RETURN(true); DBUG_RETURN(true);
} }
*having_item= and_items(thd, *having_item, having_col_item); *having_item= and_items(thd, *having_item, having_col_item);
} }
if (!abort_on_null && left_expr->element_index(i)->maybe_null) if (!abort_on_null && left_expr->element_index(i)->maybe_null)
{ {
if (!(item= new Item_func_trig_cond(thd, item, get_cond_guard(i)))) if (!(item= new (thd->mem_root)
Item_func_trig_cond(thd, item, get_cond_guard(i))))
DBUG_RETURN(true); DBUG_RETURN(true);
} }
*where_item= and_items(thd, *where_item, item); *where_item= and_items(thd, *where_item, item);
@ -2567,7 +2580,7 @@ bool Item_in_subselect::inject_in_to_exists_cond(JOIN *join_arg)
join_arg->having= select_lex->having; join_arg->having= select_lex->having;
} }
join_arg->thd->change_item_tree(&unit->global_parameters()->select_limit, join_arg->thd->change_item_tree(&unit->global_parameters()->select_limit,
new Item_int(thd, (int32) 1)); new (thd->mem_root) Item_int(thd, (int32) 1));
unit->select_limit_cnt= 1; unit->select_limit_cnt= 1;
DBUG_RETURN(false); DBUG_RETURN(false);
@ -2594,7 +2607,7 @@ bool Item_exists_subselect::select_prepare_to_be_in()
Query_arena *arena, backup; Query_arena *arena, backup;
bool result; bool result;
arena= thd->activate_stmt_arena_if_needed(&backup); arena= thd->activate_stmt_arena_if_needed(&backup);
result= (!(optimizer= new Item_in_optimizer(thd, new Item_int(thd, 1), this))); result= (!(optimizer= new (thd->mem_root) Item_in_optimizer(thd, new (thd->mem_root) Item_int(thd, 1), this)));
if (arena) if (arena)
thd->restore_active_arena(arena, &backup); thd->restore_active_arena(arena, &backup);
if (result) if (result)
@ -2814,13 +2827,17 @@ bool Item_exists_subselect::exists2in_processor(uchar *opt_arg)
/* remove the parts from condition */ /* remove the parts from condition */
if (!upper_not || !local_field->maybe_null) if (!upper_not || !local_field->maybe_null)
*eq_ref= new Item_int(thd, 1); *eq_ref= new (thd->mem_root) Item_int(thd, 1);
else else
{ {
*eq_ref= new Item_func_isnotnull(thd, *eq_ref= new (thd->mem_root)
new Item_field(thd, Item_func_isnotnull(thd,
((Item_field*)(local_field->real_item()))->context, new (thd->mem_root)
((Item_field*)(local_field->real_item()))->field)); Item_field(thd,
((Item_field*)(local_field->
real_item()))->context,
((Item_field*)(local_field->
real_item()))->field));
if((*eq_ref)->fix_fields(thd, (Item **)eq_ref)) if((*eq_ref)->fix_fields(thd, (Item **)eq_ref))
{ {
res= TRUE; res= TRUE;
@ -2840,7 +2857,7 @@ bool Item_exists_subselect::exists2in_processor(uchar *opt_arg)
left_exp= outer_exp; left_exp= outer_exp;
else else
{ {
if (!(left_exp= new Item_row(thd, outer))) if (!(left_exp= new (thd->mem_root) Item_row(thd, outer)))
{ {
res= TRUE; res= TRUE;
goto out; goto out;
@ -2882,10 +2899,11 @@ bool Item_exists_subselect::exists2in_processor(uchar *opt_arg)
As far as Item_ref_in_optimizer do not substitute itself on fix_fields As far as Item_ref_in_optimizer do not substitute itself on fix_fields
we can use same item for all selects. we can use same item for all selects.
*/ */
in_subs->expr= new Item_direct_ref(thd, &first_select->context, in_subs->expr= new (thd->mem_root)
(Item**)optimizer->get_cache(), Item_direct_ref(thd, &first_select->context,
(char *)"<no matter>", (Item**)optimizer->get_cache(),
(char *)in_left_expr_name); (char *)"<no matter>",
(char *)in_left_expr_name);
if (in_subs->fix_fields(thd, optimizer->arguments() + 1)) if (in_subs->fix_fields(thd, optimizer->arguments() + 1))
{ {
res= TRUE; res= TRUE;
@ -2947,14 +2965,17 @@ bool Item_exists_subselect::exists2in_processor(uchar *opt_arg)
if (eqs.elements() == 1) if (eqs.elements() == 1)
{ {
exp= (optimizer->arguments()[0]->maybe_null ? exp= (optimizer->arguments()[0]->maybe_null ?
(Item*) (Item*) new (thd->mem_root)
new Item_cond_and(thd, Item_cond_and(thd,
new Item_func_isnotnull(thd, new (thd->mem_root)
new Item_direct_ref(thd, &unit->outer_select()->context, Item_func_isnotnull(thd,
optimizer->arguments(), new (thd->mem_root)
(char *)"<no matter>", Item_direct_ref(thd,
(char *)exists_outer_expr_name)), &unit->outer_select()->context,
optimizer) : optimizer->arguments(),
(char *)"<no matter>",
(char *)exists_outer_expr_name)),
optimizer) :
(Item *)optimizer); (Item *)optimizer);
} }
else else
@ -2970,18 +2991,20 @@ bool Item_exists_subselect::exists2in_processor(uchar *opt_arg)
if (optimizer->arguments()[0]->maybe_null) if (optimizer->arguments()[0]->maybe_null)
{ {
and_list-> and_list->
push_front( push_front(new (thd->mem_root)
new Item_func_isnotnull(thd, Item_func_isnotnull(thd,
new Item_direct_ref(thd, &unit->outer_select()->context, new (thd->mem_root)
optimizer->arguments()[0]->addr(i), Item_direct_ref(thd,
(char *)"<no matter>", &unit->outer_select()->context,
(char *)exists_outer_expr_name))); optimizer->arguments()[0]->addr(i),
(char *)"<no matter>",
(char *)exists_outer_expr_name)));
} }
} }
if (and_list->elements > 0) if (and_list->elements > 0)
{ {
and_list->push_front(optimizer); and_list->push_front(optimizer);
exp= new Item_cond_and(thd, *and_list); exp= new (thd->mem_root) Item_cond_and(thd, *and_list);
} }
else else
exp= optimizer; exp= optimizer;
@ -3056,7 +3079,7 @@ Item_in_subselect::select_in_like_transformer(JOIN *join)
arena= thd->activate_stmt_arena_if_needed(&backup); arena= thd->activate_stmt_arena_if_needed(&backup);
if (!optimizer) if (!optimizer)
{ {
result= (!(optimizer= new Item_in_optimizer(thd, left_expr, this))); result= (!(optimizer= new (thd->mem_root) Item_in_optimizer(thd, left_expr, this)));
if (result) if (result)
goto out; goto out;
} }
@ -3122,7 +3145,7 @@ bool Item_exists_subselect::fix_fields(THD *thd, Item **ref)
{ {
DBUG_ENTER("Item_exists_subselect::fix_fields"); DBUG_ENTER("Item_exists_subselect::fix_fields");
if (exists_transformed) if (exists_transformed)
DBUG_RETURN( !( (*ref)= new Item_int(thd, 1))); DBUG_RETURN( !( (*ref)= new (thd->mem_root) Item_int(thd, 1)));
DBUG_RETURN(Item_subselect::fix_fields(thd, ref)); DBUG_RETURN(Item_subselect::fix_fields(thd, ref));
} }
@ -3134,7 +3157,7 @@ bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
DBUG_ENTER("Item_in_subselect::fix_fields"); DBUG_ENTER("Item_in_subselect::fix_fields");
if (test_strategy(SUBS_SEMI_JOIN)) if (test_strategy(SUBS_SEMI_JOIN))
DBUG_RETURN( !( (*ref)= new Item_int(thd, 1)) ); DBUG_RETURN( !( (*ref)= new (thd->mem_root) Item_int(thd, 1)) );
/* /*
Check if the outer and inner IN operands match in those cases when we Check if the outer and inner IN operands match in those cases when we
@ -4888,7 +4911,7 @@ bool subselect_hash_sj_engine::make_semi_join_conds()
DBUG_ENTER("subselect_hash_sj_engine::make_semi_join_conds"); DBUG_ENTER("subselect_hash_sj_engine::make_semi_join_conds");
DBUG_ASSERT(semi_join_conds == NULL); DBUG_ASSERT(semi_join_conds == NULL);
if (!(semi_join_conds= new Item_cond_and(thd))) if (!(semi_join_conds= new (thd->mem_root) Item_cond_and(thd)))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
if (!(tmp_table_ref= (TABLE_LIST*) thd->alloc(sizeof(TABLE_LIST)))) if (!(tmp_table_ref= (TABLE_LIST*) thd->alloc(sizeof(TABLE_LIST))))
@ -4912,8 +4935,8 @@ bool subselect_hash_sj_engine::make_semi_join_conds()
/* Item for the corresponding field from the materialized temp table. */ /* Item for the corresponding field from the materialized temp table. */
Item_field *right_col_item; Item_field *right_col_item;
if (!(right_col_item= new Item_field(thd, context, tmp_table->field[i])) || if (!(right_col_item= new (thd->mem_root) Item_field(thd, context, tmp_table->field[i])) ||
!(eq_cond= new Item_func_eq(thd, item_in->left_expr->element_index(i), !(eq_cond= new (thd->mem_root) Item_func_eq(thd, item_in->left_expr->element_index(i),
right_col_item)) || right_col_item)) ||
(((Item_cond_and*)semi_join_conds)->add(eq_cond))) (((Item_cond_and*)semi_join_conds)->add(eq_cond)))
{ {
@ -5520,9 +5543,9 @@ bool Ordered_key::init(MY_BITMAP *columns_to_index)
{ {
if (!bitmap_is_set(columns_to_index, i)) if (!bitmap_is_set(columns_to_index, i))
continue; continue;
cur_tmp_field= new Item_field(thd, tbl->field[i]); cur_tmp_field= new (thd->mem_root) Item_field(thd, tbl->field[i]);
/* Create the predicate (tmp_column[i] < outer_ref[i]). */ /* Create the predicate (tmp_column[i] < outer_ref[i]). */
fn_less_than= new Item_func_lt(thd, cur_tmp_field, fn_less_than= new (thd->mem_root) Item_func_lt(thd, cur_tmp_field,
search_key->element_index(i)); search_key->element_index(i));
fn_less_than->fix_fields(thd, (Item**) &fn_less_than); fn_less_than->fix_fields(thd, (Item**) &fn_less_than);
key_columns[cur_key_col]= cur_tmp_field; key_columns[cur_key_col]= cur_tmp_field;
@ -5554,9 +5577,9 @@ bool Ordered_key::init(int col_idx)
key_columns= (Item_field**) thd->alloc(sizeof(Item_field*)); key_columns= (Item_field**) thd->alloc(sizeof(Item_field*));
compare_pred= (Item_func_lt**) thd->alloc(sizeof(Item_func_lt*)); compare_pred= (Item_func_lt**) thd->alloc(sizeof(Item_func_lt*));
key_columns[0]= new Item_field(thd, tbl->field[col_idx]); key_columns[0]= new (thd->mem_root) Item_field(thd, tbl->field[col_idx]);
/* Create the predicate (tmp_column[i] < outer_ref[i]). */ /* Create the predicate (tmp_column[i] < outer_ref[i]). */
compare_pred[0]= new Item_func_lt(thd, key_columns[0], compare_pred[0]= new (thd->mem_root) Item_func_lt(thd, key_columns[0],
search_key->element_index(col_idx)); search_key->element_index(col_idx));
compare_pred[0]->fix_fields(thd, (Item**)&compare_pred[0]); compare_pred[0]->fix_fields(thd, (Item**)&compare_pred[0]);

23
sql/item_sum.cc
View File

@ -490,7 +490,7 @@ Item *Item_sum::get_tmp_table_item(THD *thd)
if (arg->type() == Item::FIELD_ITEM) if (arg->type() == Item::FIELD_ITEM)
((Item_field*) arg)->field= result_field_tmp++; ((Item_field*) arg)->field= result_field_tmp++;
else else
sum_item->args[i]= new Item_field(thd, result_field_tmp++); sum_item->args[i]= new (thd->mem_root) Item_field(thd, result_field_tmp++);
} }
} }
} }
@ -610,6 +610,10 @@ void Item_sum::cleanup()
forced_const= FALSE; forced_const= FALSE;
} }
Item *Item_sum::result_item(THD *thd, Field *field)
{
return new (thd->mem_root) Item_field(thd, field);
}
/** /**
Compare keys consisting of single field that cannot be compared as binary. Compare keys consisting of single field that cannot be compared as binary.
@ -1759,6 +1763,12 @@ Item *Item_sum_std::copy_or_same(THD* thd)
} }
Item *Item_sum_std::result_item(THD *thd, Field *field)
{
return new (thd->mem_root) Item_std_field(thd, this);
}
/* /*
Variance Variance
*/ */
@ -1989,6 +1999,11 @@ void Item_sum_variance::update_field()
} }
Item *Item_sum_variance::result_item(THD *thd, Field *field)
{
return new (thd->mem_root) Item_variance_field(thd, this);
}
/* min & max */ /* min & max */
void Item_sum_hybrid::clear() void Item_sum_hybrid::clear()
@ -2477,6 +2492,12 @@ void Item_sum_avg::update_field()
} }
Item *Item_sum_avg::result_item(THD *thd, Field *field)
{
return new (thd->mem_root) Item_avg_field(thd, hybrid_type, this);
}
void Item_sum_hybrid::update_field() void Item_sum_hybrid::update_field()
{ {
switch (hybrid_type) { switch (hybrid_type) {

13
sql/item_sum.h
View File

@ -431,8 +431,8 @@ public:
virtual void update_field()=0; virtual void update_field()=0;
virtual bool keep_field_type(void) const { return 0; } virtual bool keep_field_type(void) const { return 0; }
virtual void fix_length_and_dec() { maybe_null=1; null_value=1; } virtual void fix_length_and_dec() { maybe_null=1; null_value=1; }
virtual Item *result_item(THD *thd, Field *field) virtual Item *result_item(THD *thd, Field *field);
{ return new Item_field(thd, field); }
/* /*
Return bitmap of tables that are needed to evaluate the item. Return bitmap of tables that are needed to evaluate the item.
@ -879,8 +879,7 @@ public:
String *val_str(String *str); String *val_str(String *str);
void reset_field(); void reset_field();
void update_field(); void update_field();
Item *result_item(THD *thd, Field *field) Item *result_item(THD *thd, Field *field);
{ return new Item_avg_field(thd, hybrid_type, this); }
void no_rows_in_result() {} void no_rows_in_result() {}
const char *func_name() const const char *func_name() const
{ {
@ -977,8 +976,7 @@ public:
my_decimal *val_decimal(my_decimal *); my_decimal *val_decimal(my_decimal *);
void reset_field(); void reset_field();
void update_field(); void update_field();
Item *result_item(THD *thd, Field *field) Item *result_item(THD *thd, Field *field);
{ return new Item_variance_field(thd, this); }
void no_rows_in_result() {} void no_rows_in_result() {}
const char *func_name() const const char *func_name() const
{ return sample ? "var_samp(" : "variance("; } { return sample ? "var_samp(" : "variance("; }
@ -1019,8 +1017,7 @@ class Item_sum_std :public Item_sum_variance
{} {}
enum Sumfunctype sum_func () const { return STD_FUNC; } enum Sumfunctype sum_func () const { return STD_FUNC; }
double val_real(); double val_real();
Item *result_item(THD *thd, Field *field) Item *result_item(THD *thd, Field *field);
{ return new Item_std_field(thd, this); }
const char *func_name() const { return "std("; } const char *func_name() const { return "std("; }
Item *copy_or_same(THD* thd); Item *copy_or_same(THD* thd);
enum Item_result result_type () const { return REAL_RESULT; } enum Item_result result_type () const { return REAL_RESULT; }

244
sql/item_xmlfunc.cc
View File

@ -840,7 +840,8 @@ String *Item_nodeset_func_elementbyindex::val_nodeset(String *nodeset)
static Item* nodeset2bool(MY_XPATH *xpath, Item *item) static Item* nodeset2bool(MY_XPATH *xpath, Item *item)
{ {
if (item->type() == Item::XPATH_NODESET) if (item->type() == Item::XPATH_NODESET)
return new Item_xpath_cast_bool(xpath->thd, item, xpath->pxml); return new (xpath->thd->mem_root)
Item_xpath_cast_bool(xpath->thd, item, xpath->pxml);
return item; return item;
} }
@ -912,14 +913,15 @@ static Item* nodeset2bool(MY_XPATH *xpath, Item *item)
*/ */
static Item *eq_func(THD *thd, int oper, Item *a, Item *b) static Item *eq_func(THD *thd, int oper, Item *a, Item *b)
{ {
MEM_ROOT *mem_root= thd->mem_root;
switch (oper) switch (oper)
{ {
case '=': return new Item_func_eq(thd, a, b); case '=': return new (mem_root) Item_func_eq(thd, a, b);
case '!': return new Item_func_ne(thd, a, b); case '!': return new (mem_root) Item_func_ne(thd, a, b);
case MY_XPATH_LEX_GE: return new Item_func_ge(thd, a, b); case MY_XPATH_LEX_GE: return new (mem_root) Item_func_ge(thd, a, b);
case MY_XPATH_LEX_LE: return new Item_func_le(thd, a, b); case MY_XPATH_LEX_LE: return new (mem_root) Item_func_le(thd, a, b);
case MY_XPATH_LEX_GREATER: return new Item_func_gt(thd, a, b); case MY_XPATH_LEX_GREATER: return new (mem_root) Item_func_gt(thd, a, b);
case MY_XPATH_LEX_LESS: return new Item_func_lt(thd, a, b); case MY_XPATH_LEX_LESS: return new (mem_root) Item_func_lt(thd, a, b);
} }
return 0; return 0;
} }
@ -939,14 +941,15 @@ static Item *eq_func(THD *thd, int oper, Item *a, Item *b)
*/ */
static Item *eq_func_reverse(THD *thd, int oper, Item *a, Item *b) static Item *eq_func_reverse(THD *thd, int oper, Item *a, Item *b)
{ {
MEM_ROOT *mem_root= thd->mem_root;
switch (oper) switch (oper)
{ {
case '=': return new Item_func_eq(thd, a, b); case '=': return new (mem_root) Item_func_eq(thd, a, b);
case '!': return new Item_func_ne(thd, a, b); case '!': return new (mem_root) Item_func_ne(thd, a, b);
case MY_XPATH_LEX_GE: return new Item_func_le(thd, a, b); case MY_XPATH_LEX_GE: return new (mem_root) Item_func_le(thd, a, b);
case MY_XPATH_LEX_LE: return new Item_func_ge(thd, a, b); case MY_XPATH_LEX_LE: return new (mem_root) Item_func_ge(thd, a, b);
case MY_XPATH_LEX_GREATER: return new Item_func_lt(thd, a, b); case MY_XPATH_LEX_GREATER: return new (mem_root) Item_func_lt(thd, a, b);
case MY_XPATH_LEX_LESS: return new Item_func_gt(thd, a, b); case MY_XPATH_LEX_LESS: return new (mem_root) Item_func_gt(thd, a, b);
} }
return 0; return 0;
} }
@ -992,24 +995,25 @@ static Item *create_comparator(MY_XPATH *xpath,
in a loop through all of the nodes in the node set. in a loop through all of the nodes in the node set.
*/ */
Item_string *fake= new Item_string_xml_non_const(xpath->thd, "", 0, THD *thd= xpath->thd;
xpath->cs); Item_string *fake= (new (thd->mem_root)
Item_string_xml_non_const(thd, "", 0, xpath->cs));
Item_nodeset_func *nodeset; Item_nodeset_func *nodeset;
Item *scalar, *comp; Item *scalar, *comp;
if (a->type() == Item::XPATH_NODESET) if (a->type() == Item::XPATH_NODESET)
{ {
nodeset= (Item_nodeset_func*) a; nodeset= (Item_nodeset_func*) a;
scalar= b; scalar= b;
comp= eq_func(xpath->thd, oper, (Item*)fake, scalar); comp= eq_func(thd, oper, (Item*)fake, scalar);
} }
else else
{ {
nodeset= (Item_nodeset_func*) b; nodeset= (Item_nodeset_func*) b;
scalar= a; scalar= a;
comp= eq_func_reverse(xpath->thd, oper, fake, scalar); comp= eq_func_reverse(thd, oper, fake, scalar);
} }
return new Item_nodeset_to_const_comparator(xpath->thd, nodeset, comp, return (new (thd->mem_root)
xpath->pxml); Item_nodeset_to_const_comparator(thd, nodeset, comp, xpath->pxml));
} }
} }
@ -1026,6 +1030,9 @@ static Item *create_comparator(MY_XPATH *xpath,
static Item* nametestfunc(MY_XPATH *xpath, static Item* nametestfunc(MY_XPATH *xpath,
int type, Item *arg, const char *beg, uint len) int type, Item *arg, const char *beg, uint len)
{ {
THD *thd= xpath->thd;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ASSERT(arg != 0); DBUG_ASSERT(arg != 0);
DBUG_ASSERT(arg->type() == Item::XPATH_NODESET); DBUG_ASSERT(arg->type() == Item::XPATH_NODESET);
DBUG_ASSERT(beg != 0); DBUG_ASSERT(beg != 0);
@ -1035,35 +1042,35 @@ static Item* nametestfunc(MY_XPATH *xpath,
switch (type) switch (type)
{ {
case MY_XPATH_AXIS_ANCESTOR: case MY_XPATH_AXIS_ANCESTOR:
res= new Item_nodeset_func_ancestorbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_ancestorbyname(thd, arg, beg, len,
xpath->pxml, 0); xpath->pxml, 0);
break; break;
case MY_XPATH_AXIS_ANCESTOR_OR_SELF: case MY_XPATH_AXIS_ANCESTOR_OR_SELF:
res= new Item_nodeset_func_ancestorbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_ancestorbyname(thd, arg, beg, len,
xpath->pxml, 1); xpath->pxml, 1);
break; break;
case MY_XPATH_AXIS_PARENT: case MY_XPATH_AXIS_PARENT:
res= new Item_nodeset_func_parentbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_parentbyname(thd, arg, beg, len,
xpath->pxml); xpath->pxml);
break; break;
case MY_XPATH_AXIS_DESCENDANT: case MY_XPATH_AXIS_DESCENDANT:
res= new Item_nodeset_func_descendantbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_descendantbyname(thd, arg, beg, len,
xpath->pxml, 0); xpath->pxml, 0);
break; break;
case MY_XPATH_AXIS_DESCENDANT_OR_SELF: case MY_XPATH_AXIS_DESCENDANT_OR_SELF:
res= new Item_nodeset_func_descendantbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_descendantbyname(thd, arg, beg, len,
xpath->pxml, 1); xpath->pxml, 1);
break; break;
case MY_XPATH_AXIS_ATTRIBUTE: case MY_XPATH_AXIS_ATTRIBUTE:
res= new Item_nodeset_func_attributebyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_attributebyname(thd, arg, beg, len,
xpath->pxml); xpath->pxml);
break; break;
case MY_XPATH_AXIS_SELF: case MY_XPATH_AXIS_SELF:
res= new Item_nodeset_func_selfbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_selfbyname(thd, arg, beg, len,
xpath->pxml); xpath->pxml);
break; break;
default: default:
res= new Item_nodeset_func_childbyname(xpath->thd, arg, beg, len, res= new (mem_root) Item_nodeset_func_childbyname(thd, arg, beg, len,
xpath->pxml); xpath->pxml);
} }
return res; return res;
@ -1173,43 +1180,46 @@ my_xpath_keyword(MY_XPATH *x,
static Item *create_func_true(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_true(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_bool(xpath->thd, 1); return new (xpath->thd->mem_root) Item_bool(xpath->thd, 1);
} }
static Item *create_func_false(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_false(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_bool(xpath->thd, 0); return new (xpath->thd->mem_root) Item_bool(xpath->thd, 0);
} }
static Item *create_func_not(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_not(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_func_not(xpath->thd, nodeset2bool(xpath, args[0])); return new (xpath->thd->mem_root)
Item_func_not(xpath->thd, nodeset2bool(xpath, args[0]));
} }
static Item *create_func_ceiling(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_ceiling(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_func_ceiling(xpath->thd, args[0]); return new (xpath->thd->mem_root) Item_func_ceiling(xpath->thd, args[0]);
} }
static Item *create_func_floor(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_floor(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_func_floor(xpath->thd, args[0]); return new (xpath->thd->mem_root) Item_func_floor(xpath->thd, args[0]);
} }
static Item *create_func_bool(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_bool(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_xpath_cast_bool(xpath->thd, args[0], xpath->pxml); return new (xpath->thd->mem_root)
Item_xpath_cast_bool(xpath->thd, args[0], xpath->pxml);
} }
static Item *create_func_number(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_number(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_xpath_cast_number(xpath->thd, args[0]); return new (xpath->thd->mem_root)
Item_xpath_cast_number(xpath->thd, args[0]);
} }
@ -1217,53 +1227,61 @@ static Item *create_func_string_length(MY_XPATH *xpath, Item **args,
uint nargs) uint nargs)
{ {
Item *arg= nargs ? args[0] : xpath->context; Item *arg= nargs ? args[0] : xpath->context;
return arg ? new Item_func_char_length(xpath->thd, arg) : 0; return arg ? new (xpath->thd->mem_root)
Item_func_char_length(xpath->thd, arg) : 0;
} }
static Item *create_func_round(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_round(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_func_round(xpath->thd, args[0], return new (xpath->thd->mem_root)
new Item_int(xpath->thd, (char *) "0", 0, 1), 0); Item_func_round(xpath->thd, args[0],
new (xpath->thd->mem_root)
Item_int(xpath->thd, (char *) "0", 0, 1), 0);
} }
static Item *create_func_last(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_last(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return xpath->context ? return (xpath->context ?
new Item_func_xpath_count(xpath->thd, xpath->context, xpath->pxml) : new (xpath->thd->mem_root)
NULL; Item_func_xpath_count(xpath->thd, xpath->context, xpath->pxml) :
NULL);
} }
static Item *create_func_position(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_position(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return xpath->context ? return (xpath->context ?
new Item_func_xpath_position(xpath->thd, xpath->context, new (xpath->thd->mem_root)
xpath->pxml) : NULL; Item_func_xpath_position(xpath->thd, xpath->context, xpath->pxml) :
NULL);
} }
static Item *create_func_contains(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_contains(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_xpath_cast_bool(xpath->thd, return (new (xpath->thd->mem_root)
new Item_func_locate(xpath->thd, args[0], Item_xpath_cast_bool(xpath->thd,
args[1]), xpath->pxml); new (xpath->thd->mem_root)
Item_func_locate(xpath->thd, args[0], args[1]),
xpath->pxml));
} }
static Item *create_func_concat(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_concat(MY_XPATH *xpath, Item **args, uint nargs)
{ {
return new Item_func_concat(xpath->thd, args[0], args[1]); return new (xpath->thd->mem_root)
Item_func_concat(xpath->thd, args[0], args[1]);
} }
static Item *create_func_substr(MY_XPATH *xpath, Item **args, uint nargs) static Item *create_func_substr(MY_XPATH *xpath, Item **args, uint nargs)
{ {
THD *thd= xpath->thd;
if (nargs == 2) if (nargs == 2)
return new Item_func_substr(xpath->thd, args[0], args[1]); return new (thd->mem_root) Item_func_substr(thd, args[0], args[1]);
else return new (thd->mem_root) Item_func_substr(thd, args[0], args[1], args[2]);
return new Item_func_substr(xpath->thd, args[0], args[1], args[2]);
} }
@ -1271,7 +1289,7 @@ static Item *create_func_count(MY_XPATH *xpath, Item **args, uint nargs)
{ {
if (args[0]->type() != Item::XPATH_NODESET) if (args[0]->type() != Item::XPATH_NODESET)
return 0; return 0;
return new Item_func_xpath_count(xpath->thd, args[0], xpath->pxml); return new (xpath->thd->mem_root) Item_func_xpath_count(xpath->thd, args[0], xpath->pxml);
} }
@ -1279,7 +1297,8 @@ static Item *create_func_sum(MY_XPATH *xpath, Item **args, uint nargs)
{ {
if (args[0]->type() != Item::XPATH_NODESET) if (args[0]->type() != Item::XPATH_NODESET)
return 0; return 0;
return new Item_func_xpath_sum(xpath->thd, args[0], xpath->pxml); return new (xpath->thd->mem_root)
Item_func_xpath_sum(xpath->thd, args[0], xpath->pxml);
} }
@ -1652,10 +1671,11 @@ static int my_xpath_parse_AbsoluteLocationPath(MY_XPATH *xpath)
if (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH)) if (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH))
{ {
xpath->context= new Item_nodeset_func_descendantbyname(xpath->thd, xpath->context= new (xpath->thd->mem_root)
xpath->context, Item_nodeset_func_descendantbyname(xpath->thd,
"*", 1, xpath->context,
xpath->pxml, 1); "*", 1,
xpath->pxml, 1);
return my_xpath_parse_RelativeLocationPath(xpath); return my_xpath_parse_RelativeLocationPath(xpath);
} }
@ -1694,10 +1714,11 @@ static int my_xpath_parse_RelativeLocationPath(MY_XPATH *xpath)
while (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH)) while (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH))
{ {
if (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH)) if (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH))
xpath->context= new Item_nodeset_func_descendantbyname(xpath->thd, xpath->context= new (xpath->thd->mem_root)
xpath->context, Item_nodeset_func_descendantbyname(xpath->thd,
"*", 1, xpath->context,
xpath->pxml, 1); "*", 1,
xpath->pxml, 1);
if (!my_xpath_parse_Step(xpath)) if (!my_xpath_parse_Step(xpath))
{ {
xpath->error= 1; xpath->error= 1;
@ -1735,8 +1756,8 @@ my_xpath_parse_AxisSpecifier_NodeTest_opt_Predicate_list(MY_XPATH *xpath)
Item *prev_context= xpath->context; Item *prev_context= xpath->context;
String *context_cache; String *context_cache;
context_cache= &((Item_nodeset_func*)xpath->context)->context_cache; context_cache= &((Item_nodeset_func*)xpath->context)->context_cache;
xpath->context= new Item_nodeset_context_cache(xpath->thd, context_cache, xpath->context= new (xpath->thd->mem_root)
xpath->pxml); Item_nodeset_context_cache(xpath->thd, context_cache, xpath->pxml);
xpath->context_cache= context_cache; xpath->context_cache= context_cache;
if(!my_xpath_parse_PredicateExpr(xpath)) if(!my_xpath_parse_PredicateExpr(xpath))
@ -1755,16 +1776,18 @@ my_xpath_parse_AxisSpecifier_NodeTest_opt_Predicate_list(MY_XPATH *xpath)
if (xpath->item->is_bool_type()) if (xpath->item->is_bool_type())
{ {
xpath->context= new Item_nodeset_func_predicate(xpath->thd, prev_context, xpath->context= new (xpath->thd->mem_root)
xpath->item, Item_nodeset_func_predicate(xpath->thd, prev_context,
xpath->pxml); xpath->item,
xpath->pxml);
} }
else else
{ {
xpath->context= new Item_nodeset_func_elementbyindex(xpath->thd, xpath->context= new (xpath->thd->mem_root)
prev_context, Item_nodeset_func_elementbyindex(xpath->thd,
xpath->item, prev_context,
xpath->pxml); xpath->item,
xpath->pxml);
} }
} }
return 1; return 1;
@ -1886,9 +1909,10 @@ static int my_xpath_parse_AbbreviatedStep(MY_XPATH *xpath)
if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT)) if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT))
return 0; return 0;
if (my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT)) if (my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT))
xpath->context= new Item_nodeset_func_parentbyname(xpath->thd, xpath->context= new (xpath->thd->mem_root)
xpath->context, "*", Item_nodeset_func_parentbyname(xpath->thd,
1, xpath->pxml); xpath->context, "*",
1, xpath->pxml);
return 1; return 1;
} }
@ -1917,9 +1941,10 @@ static int my_xpath_parse_PrimaryExpr_literal(MY_XPATH *xpath)
{ {
if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_STRING)) if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_STRING))
return 0; return 0;
xpath->item= new Item_string(xpath->thd, xpath->prevtok.beg + 1, xpath->item= new (xpath->thd->mem_root)
xpath->prevtok.end - xpath->prevtok.beg - 2, Item_string(xpath->thd, xpath->prevtok.beg + 1,
xpath->cs); xpath->prevtok.end - xpath->prevtok.beg - 2,
xpath->cs);
return 1; return 1;
} }
static int my_xpath_parse_PrimaryExpr(MY_XPATH *xpath) static int my_xpath_parse_PrimaryExpr(MY_XPATH *xpath)
@ -2012,8 +2037,9 @@ static int my_xpath_parse_UnionExpr(MY_XPATH *xpath)
xpath->error= 1; xpath->error= 1;
return 0; return 0;
} }
xpath->item= new Item_nodeset_func_union(xpath->thd, prev, xpath->item, xpath->item= new (xpath->thd->mem_root)
xpath->pxml); Item_nodeset_func_union(xpath->thd, prev, xpath->item,
xpath->pxml);
} }
return 1; return 1;
} }
@ -2059,10 +2085,11 @@ my_xpath_parse_FilterExpr_opt_slashes_RelativeLocationPath(MY_XPATH *xpath)
/* treat double slash (//) as /descendant-or-self::node()/ */ /* treat double slash (//) as /descendant-or-self::node()/ */
if (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH)) if (my_xpath_parse_term(xpath, MY_XPATH_LEX_SLASH))
xpath->context= new Item_nodeset_func_descendantbyname(xpath->thd, xpath->context= new (xpath->thd->mem_root)
xpath->context, Item_nodeset_func_descendantbyname(xpath->thd,
"*", 1, xpath->context,
xpath->pxml, 1); "*", 1,
xpath->pxml, 1);
rc= my_xpath_parse_RelativeLocationPath(xpath); rc= my_xpath_parse_RelativeLocationPath(xpath);
/* push back the context and restore the item */ /* push back the context and restore the item */
@ -2124,8 +2151,9 @@ static int my_xpath_parse_OrExpr(MY_XPATH *xpath)
xpath->error= 1; xpath->error= 1;
return 0; return 0;
} }
xpath->item= new Item_cond_or(xpath->thd, nodeset2bool(xpath, prev), xpath->item= new (xpath->thd->mem_root)
nodeset2bool(xpath, xpath->item)); Item_cond_or(xpath->thd, nodeset2bool(xpath, prev),
nodeset2bool(xpath, xpath->item));
} }
return 1; return 1;
} }
@ -2156,8 +2184,9 @@ static int my_xpath_parse_AndExpr(MY_XPATH *xpath)
return 0; return 0;
} }
xpath->item= new Item_cond_and(xpath->thd, nodeset2bool(xpath, prev), xpath->item= new (xpath->thd->mem_root)
nodeset2bool(xpath, xpath->item)); Item_cond_and(xpath->thd, nodeset2bool(xpath, prev),
nodeset2bool(xpath, xpath->item));
} }
return 1; return 1;
} }
@ -2319,6 +2348,8 @@ static int my_xpath_parse_AdditiveExpr(MY_XPATH *xpath)
{ {
int oper= xpath->prevtok.term; int oper= xpath->prevtok.term;
Item *prev= xpath->item; Item *prev= xpath->item;
THD *thd= xpath->thd;
if (!my_xpath_parse_MultiplicativeExpr(xpath)) if (!my_xpath_parse_MultiplicativeExpr(xpath))
{ {
xpath->error= 1; xpath->error= 1;
@ -2326,9 +2357,11 @@ static int my_xpath_parse_AdditiveExpr(MY_XPATH *xpath)
} }
if (oper == MY_XPATH_LEX_PLUS) if (oper == MY_XPATH_LEX_PLUS)
xpath->item= new Item_func_plus(xpath->thd, prev, xpath->item); xpath->item= new (thd->mem_root)
Item_func_plus(thd, prev, xpath->item);
else else
xpath->item= new Item_func_minus(xpath->thd, prev, xpath->item); xpath->item= new (thd->mem_root)
Item_func_minus(thd, prev, xpath->item);
}; };
return 1; return 1;
} }
@ -2363,6 +2396,7 @@ static int my_xpath_parse_MultiplicativeExpr(MY_XPATH *xpath)
if (!my_xpath_parse_UnaryExpr(xpath)) if (!my_xpath_parse_UnaryExpr(xpath))
return 0; return 0;
THD *thd= xpath->thd;
while (my_xpath_parse_MultiplicativeOperator(xpath)) while (my_xpath_parse_MultiplicativeOperator(xpath))
{ {
int oper= xpath->prevtok.term; int oper= xpath->prevtok.term;
@ -2375,13 +2409,13 @@ static int my_xpath_parse_MultiplicativeExpr(MY_XPATH *xpath)
switch (oper) switch (oper)
{ {
case MY_XPATH_LEX_ASTERISK: case MY_XPATH_LEX_ASTERISK:
xpath->item= new Item_func_mul(xpath->thd, prev, xpath->item); xpath->item= new (thd->mem_root) Item_func_mul(thd, prev, xpath->item);
break; break;
case MY_XPATH_LEX_DIV: case MY_XPATH_LEX_DIV:
xpath->item= new Item_func_int_div(xpath->thd, prev, xpath->item); xpath->item= new (thd->mem_root) Item_func_int_div(thd, prev, xpath->item);
break; break;
case MY_XPATH_LEX_MOD: case MY_XPATH_LEX_MOD:
xpath->item= new Item_func_mod(xpath->thd, prev, xpath->item); xpath->item= new (thd->mem_root) Item_func_mod(thd, prev, xpath->item);
break; break;
} }
} }
@ -2406,7 +2440,8 @@ static int my_xpath_parse_UnaryExpr(MY_XPATH *xpath)
return my_xpath_parse_UnionExpr(xpath); return my_xpath_parse_UnionExpr(xpath);
if (!my_xpath_parse_UnaryExpr(xpath)) if (!my_xpath_parse_UnaryExpr(xpath))
return 0; return 0;
xpath->item= new Item_func_neg(xpath->thd, xpath->item); xpath->item= new (xpath->thd->mem_root)
Item_func_neg(xpath->thd, xpath->item);
return 1; return 1;
} }
@ -2438,18 +2473,21 @@ static int my_xpath_parse_UnaryExpr(MY_XPATH *xpath)
static int my_xpath_parse_Number(MY_XPATH *xpath) static int my_xpath_parse_Number(MY_XPATH *xpath)
{ {
const char *beg; const char *beg;
THD *thd;
if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DIGITS)) if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DIGITS))
return 0; return 0;
beg= xpath->prevtok.beg; beg= xpath->prevtok.beg;
thd= xpath->thd;
if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT)) if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT))
{ {
xpath->item= new Item_int(xpath->thd, xpath->prevtok.beg, xpath->item= new (thd->mem_root) Item_int(thd, xpath->prevtok.beg,
xpath->prevtok.end - xpath->prevtok.beg); xpath->prevtok.end - xpath->prevtok.beg);
return 1; return 1;
} }
my_xpath_parse_term(xpath, MY_XPATH_LEX_DIGITS); my_xpath_parse_term(xpath, MY_XPATH_LEX_DIGITS);
xpath->item= new Item_float(xpath->thd, beg, xpath->prevtok.end - beg); xpath->item= new (thd->mem_root) Item_float(thd, beg,
xpath->prevtok.end - beg);
return 1; return 1;
} }
@ -2542,6 +2580,7 @@ my_xpath_parse_VariableReference(MY_XPATH *xpath)
LEX_STRING name; LEX_STRING name;
int user_var; int user_var;
const char *dollar_pos; const char *dollar_pos;
THD *thd= xpath->thd;
if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOLLAR) || if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOLLAR) ||
(!(dollar_pos= xpath->prevtok.beg)) || (!(dollar_pos= xpath->prevtok.beg)) ||
(!((user_var= my_xpath_parse_term(xpath, MY_XPATH_LEX_AT) && (!((user_var= my_xpath_parse_term(xpath, MY_XPATH_LEX_AT) &&
@ -2553,18 +2592,19 @@ my_xpath_parse_VariableReference(MY_XPATH *xpath)
name.str= (char*) xpath->prevtok.beg; name.str= (char*) xpath->prevtok.beg;
if (user_var) if (user_var)
xpath->item= new Item_func_get_user_var(xpath->thd, name); xpath->item= new (thd->mem_root) Item_func_get_user_var(thd, name);
else else
{ {
sp_variable *spv; sp_variable *spv;
sp_pcontext *spc; sp_pcontext *spc;
LEX *lex; LEX *lex;
if ((lex= current_thd->lex) && if ((lex= thd->lex) &&
(spc= lex->spcont) && (spc= lex->spcont) &&
(spv= spc->find_variable(name, false))) (spv= spc->find_variable(name, false)))
{ {
Item_splocal *splocal= new Item_splocal(xpath->thd, name, spv->offset, Item_splocal *splocal= new (thd->mem_root)
spv->type, 0); Item_splocal(thd, name, spv->offset,
spv->type, 0);
#ifndef DBUG_OFF #ifndef DBUG_OFF
if (splocal) if (splocal)
splocal->m_sp= lex->sphead; splocal->m_sp= lex->sphead;
@ -2643,12 +2683,12 @@ my_xpath_parse(MY_XPATH *xpath, const char *str, const char *strend)
my_xpath_lex_init(&xpath->prevtok, str, strend); my_xpath_lex_init(&xpath->prevtok, str, strend);
my_xpath_lex_scan(xpath, &xpath->lasttok, str, strend); my_xpath_lex_scan(xpath, &xpath->lasttok, str, strend);
xpath->rootelement= new Item_nodeset_func_rootelement(xpath->thd, xpath->rootelement= new (xpath->thd->mem_root)
xpath->pxml); Item_nodeset_func_rootelement(xpath->thd,
xpath->pxml);
return return (my_xpath_parse_Expr(xpath) &&
my_xpath_parse_Expr(xpath) && my_xpath_parse_term(xpath, MY_XPATH_LEX_EOF));
my_xpath_parse_term(xpath, MY_XPATH_LEX_EOF);
} }

27
sql/log_event.cc
View File

@ -1036,17 +1036,18 @@ int Log_event::net_send(THD *thd, Protocol *protocol, const char* log_name,
void Log_event::init_show_field_list(THD *thd, List<Item>* field_list) void Log_event::init_show_field_list(THD *thd, List<Item>* field_list)
{ {
field_list->push_back(new Item_empty_string(thd, "Log_name", 20)); MEM_ROOT *mem_root= thd->mem_root;
field_list->push_back(new Item_return_int(thd, "Pos", field_list->push_back(new (mem_root) Item_empty_string(thd, "Log_name", 20));
field_list->push_back(new (mem_root) Item_return_int(thd, "Pos",
MY_INT32_NUM_DECIMAL_DIGITS, MY_INT32_NUM_DECIMAL_DIGITS,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list->push_back(new Item_empty_string(thd, "Event_type", 20)); field_list->push_back(new (mem_root) Item_empty_string(thd, "Event_type", 20));
field_list->push_back(new Item_return_int(thd, "Server_id", 10, field_list->push_back(new (mem_root) Item_return_int(thd, "Server_id", 10,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list->push_back(new Item_return_int(thd, "End_log_pos", field_list->push_back(new (mem_root) Item_return_int(thd, "End_log_pos",
MY_INT32_NUM_DECIMAL_DIGITS, MY_INT32_NUM_DECIMAL_DIGITS,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list->push_back(new Item_empty_string(thd, "Info", 20)); field_list->push_back(new (mem_root) Item_empty_string(thd, "Info", 20));
} }
/** /**
@ -5725,7 +5726,7 @@ void Load_log_event::set_fields(const char* affected_db,
const char* field = fields; const char* field = fields;
for (i= 0; i < num_fields; i++) for (i= 0; i < num_fields; i++)
{ {
field_list.push_back(new Item_field(thd, context, field_list.push_back(new (thd->mem_root) Item_field(thd, context,
affected_db, table_name, field)); affected_db, table_name, field));
field+= field_lens[i] + 1; field+= field_lens[i] + 1;
} }
@ -7854,33 +7855,33 @@ int User_var_log_event::do_apply_event(rpl_group_info *rgi)
if (is_null) if (is_null)
{ {
it= new Item_null(thd); it= new (thd->mem_root) Item_null(thd);
} }
else else
{ {
switch (type) { switch (type) {
case REAL_RESULT: case REAL_RESULT:
float8get(real_val, val); float8get(real_val, val);
it= new Item_float(thd, real_val, 0); it= new (thd->mem_root) Item_float(thd, real_val, 0);
val= (char*) &real_val; // Pointer to value in native format val= (char*) &real_val; // Pointer to value in native format
val_len= 8; val_len= 8;
break; break;
case INT_RESULT: case INT_RESULT:
int_val= (longlong) uint8korr(val); int_val= (longlong) uint8korr(val);
it= new Item_int(thd, int_val); it= new (thd->mem_root) Item_int(thd, int_val);
val= (char*) &int_val; // Pointer to value in native format val= (char*) &int_val; // Pointer to value in native format
val_len= 8; val_len= 8;
break; break;
case DECIMAL_RESULT: case DECIMAL_RESULT:
{ {
Item_decimal *dec= new Item_decimal(thd, (uchar*) val+2, val[0], val[1]); Item_decimal *dec= new (thd->mem_root) Item_decimal(thd, (uchar*) val+2, val[0], val[1]);
it= dec; it= dec;
val= (char *)dec->val_decimal(NULL); val= (char *)dec->val_decimal(NULL);
val_len= sizeof(my_decimal); val_len= sizeof(my_decimal);
break; break;
} }
case STRING_RESULT: case STRING_RESULT:
it= new Item_string(thd, val, val_len, charset); it= new (thd->mem_root) Item_string(thd, val, val_len, charset);
break; break;
case ROW_RESULT: case ROW_RESULT:
default: default:
@ -7889,7 +7890,7 @@ int User_var_log_event::do_apply_event(rpl_group_info *rgi)
} }
} }
Item_func_set_user_var *e= new Item_func_set_user_var(thd, user_var_name, it); Item_func_set_user_var *e= new (thd->mem_root) Item_func_set_user_var(thd, user_var_name, it);
/* /*
Item_func_set_user_var can't substitute something else on its place => Item_func_set_user_var can't substitute something else on its place =>
0 can be passed as last argument (reference on item) 0 can be passed as last argument (reference on item)

12
sql/opt_index_cond_pushdown.cc
View File

@ -192,7 +192,7 @@ static Item *make_cond_for_index(THD *thd, Item *cond, TABLE *table, uint keyno,
if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC) if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
{ {
table_map used_tables= 0; table_map used_tables= 0;
Item_cond_and *new_cond= new Item_cond_and(thd); Item_cond_and *new_cond= new (thd->mem_root) Item_cond_and(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; return (COND*) 0;
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -227,7 +227,7 @@ static Item *make_cond_for_index(THD *thd, Item *cond, TABLE *table, uint keyno,
} }
else /* It's OR */ else /* It's OR */
{ {
Item_cond_or *new_cond= new Item_cond_or(thd); Item_cond_or *new_cond= new (thd->mem_root) Item_cond_or(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; return (COND*) 0;
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -269,7 +269,7 @@ static Item *make_cond_remainder(THD *thd, Item *cond, TABLE *table, uint keyno,
if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC) if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
{ {
/* Create new top level AND item */ /* Create new top level AND item */
Item_cond_and *new_cond= new Item_cond_and(thd); Item_cond_and *new_cond= new (thd->mem_root) Item_cond_and(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; return (COND*) 0;
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -297,7 +297,7 @@ static Item *make_cond_remainder(THD *thd, Item *cond, TABLE *table, uint keyno,
} }
else /* It's OR */ else /* It's OR */
{ {
Item_cond_or *new_cond= new Item_cond_or(thd); Item_cond_or *new_cond= new (thd->mem_root) Item_cond_or(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; return (COND*) 0;
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -420,8 +420,8 @@ void push_index_cond(JOIN_TAB *tab, uint keyno)
tab->select_cond= row_cond; tab->select_cond= row_cond;
else else
{ {
COND *new_cond= new Item_cond_and(tab->join->thd, row_cond, COND *new_cond= new (tab->join->thd->mem_root)
idx_remainder_cond); Item_cond_and(tab->join->thd, row_cond, idx_remainder_cond);
tab->select_cond= new_cond; tab->select_cond= new_cond;
tab->select_cond->quick_fix_field(); tab->select_cond->quick_fix_field();
((Item_cond_and*)tab->select_cond)->used_tables_cache= ((Item_cond_and*)tab->select_cond)->used_tables_cache=

37
sql/opt_subselect.cc
View File

@ -1136,7 +1136,7 @@ bool convert_join_subqueries_to_semijoins(JOIN *join)
&join->conds : &(in_subq->emb_on_expr_nest->on_expr); &join->conds : &(in_subq->emb_on_expr_nest->on_expr);
Item *replace_me= in_subq->original_item(); Item *replace_me= in_subq->original_item();
if (replace_where_subcondition(join, tree, replace_me, if (replace_where_subcondition(join, tree, replace_me,
new Item_int(thd, 1), new (thd->mem_root) Item_int(thd, 1),
FALSE)) FALSE))
goto restore_arena_and_fail; goto restore_arena_and_fail;
} }
@ -1595,7 +1595,7 @@ static bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)
{ {
nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr); nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr);
Item_func_eq *item_eq= Item_func_eq *item_eq=
new Item_func_eq(thd, subq_pred->left_expr, new (thd->mem_root) Item_func_eq(thd, subq_pred->left_expr,
subq_lex->ref_pointer_array[0]); subq_lex->ref_pointer_array[0]);
item_eq->in_equality_no= 0; item_eq->in_equality_no= 0;
sj_nest->sj_on_expr= and_items(thd, sj_nest->sj_on_expr, item_eq); sj_nest->sj_on_expr= and_items(thd, sj_nest->sj_on_expr, item_eq);
@ -1607,7 +1607,7 @@ static bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)
nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr-> nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr->
element_index(i)); element_index(i));
Item_func_eq *item_eq= Item_func_eq *item_eq=
new Item_func_eq(thd, subq_pred->left_expr->element_index(i), new (thd->mem_root) Item_func_eq(thd, subq_pred->left_expr->element_index(i),
subq_lex->ref_pointer_array[i]); subq_lex->ref_pointer_array[i]);
item_eq->in_equality_no= i; item_eq->in_equality_no= i;
sj_nest->sj_on_expr= and_items(thd, sj_nest->sj_on_expr, item_eq); sj_nest->sj_on_expr= and_items(thd, sj_nest->sj_on_expr, item_eq);
@ -3797,8 +3797,8 @@ static Item *create_subq_in_equalities(THD *thd, SJ_MATERIALIZATION_INFO *sjm,
Item *res= NULL; Item *res= NULL;
if (subq_pred->left_expr->cols() == 1) if (subq_pred->left_expr->cols() == 1)
{ {
if (!(res= new Item_func_eq(thd, subq_pred->left_expr, if (!(res= new (thd->mem_root) Item_func_eq(thd, subq_pred->left_expr,
new Item_field(thd, sjm->table->field[0])))) new (thd->mem_root) Item_field(thd, sjm->table->field[0]))))
return NULL; /* purecov: inspected */ return NULL; /* purecov: inspected */
} }
else else
@ -3806,8 +3806,8 @@ static Item *create_subq_in_equalities(THD *thd, SJ_MATERIALIZATION_INFO *sjm,
Item *conj; Item *conj;
for (uint i= 0; i < subq_pred->left_expr->cols(); i++) for (uint i= 0; i < subq_pred->left_expr->cols(); i++)
{ {
if (!(conj= new Item_func_eq(thd, subq_pred->left_expr->element_index(i), if (!(conj= new (thd->mem_root) Item_func_eq(thd, subq_pred->left_expr->element_index(i),
new Item_field(thd, sjm->table->field[i]))) || new (thd->mem_root) Item_field(thd, sjm->table->field[i]))) ||
!(res= and_items(thd, res, conj))) !(res= and_items(thd, res, conj)))
return NULL; /* purecov: inspected */ return NULL; /* purecov: inspected */
} }
@ -3836,7 +3836,7 @@ static void remove_sj_conds(THD *thd, Item **tree)
while ((item= li++)) while ((item= li++))
{ {
if (is_cond_sj_in_equality(item)) if (is_cond_sj_in_equality(item))
li.replace(new Item_int(thd, 1)); li.replace(new (thd->mem_root) Item_int(thd, 1));
} }
} }
} }
@ -5102,7 +5102,7 @@ TABLE *create_dummy_tmp_table(THD *thd)
sjm_table_param.init(); sjm_table_param.init();
sjm_table_param.field_count= 1; sjm_table_param.field_count= 1;
List<Item> sjm_table_cols; List<Item> sjm_table_cols;
Item *column_item= new Item_int(thd, 1); Item *column_item= new (thd->mem_root) Item_int(thd, 1);
sjm_table_cols.push_back(column_item); sjm_table_cols.push_back(column_item);
if (!(table= create_tmp_table(thd, &sjm_table_param, if (!(table= create_tmp_table(thd, &sjm_table_param,
sjm_table_cols, (ORDER*) 0, sjm_table_cols, (ORDER*) 0,
@ -5194,6 +5194,7 @@ bool setup_jtbm_semi_joins(JOIN *join, List<TABLE_LIST> *join_list,
TABLE_LIST *table; TABLE_LIST *table;
NESTED_JOIN *nested_join; NESTED_JOIN *nested_join;
List_iterator<TABLE_LIST> li(*join_list); List_iterator<TABLE_LIST> li(*join_list);
THD *thd= join->thd;
DBUG_ENTER("setup_jtbm_semi_joins"); DBUG_ENTER("setup_jtbm_semi_joins");
while ((table= li++)) while ((table= li++))
@ -5242,7 +5243,7 @@ bool setup_jtbm_semi_joins(JOIN *join, List<TABLE_LIST> *join_list,
(subselect_single_select_engine*)subq_pred->engine; (subselect_single_select_engine*)subq_pred->engine;
select_value_catcher *new_sink; select_value_catcher *new_sink;
if (!(new_sink= if (!(new_sink=
new (join->thd->mem_root) select_value_catcher(join->thd, subq_pred))) new (thd->mem_root) select_value_catcher(thd, subq_pred)))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
if (new_sink->setup(&engine->select_lex->join->fields_list) || if (new_sink->setup(&engine->select_lex->join->fields_list) ||
engine->select_lex->join->change_result(new_sink, NULL) || engine->select_lex->join->change_result(new_sink, NULL) ||
@ -5262,14 +5263,14 @@ bool setup_jtbm_semi_joins(JOIN *join, List<TABLE_LIST> *join_list,
Item *eq_cond; Item *eq_cond;
for (uint i= 0; i < subq_pred->left_expr->cols(); i++) for (uint i= 0; i < subq_pred->left_expr->cols(); i++)
{ {
eq_cond= new Item_func_eq(join->thd, eq_cond= new (thd->mem_root)
subq_pred->left_expr->element_index(i), Item_func_eq(thd, subq_pred->left_expr->element_index(i),
new_sink->row[i]); new_sink->row[i]);
if (!eq_cond) if (!eq_cond)
DBUG_RETURN(1); DBUG_RETURN(1);
if (!((*join_where)= and_items(join->thd, *join_where, eq_cond)) || if (!((*join_where)= and_items(thd, *join_where, eq_cond)) ||
(*join_where)->fix_fields(join->thd, join_where)) (*join_where)->fix_fields(thd, join_where))
DBUG_RETURN(1); DBUG_RETURN(1);
} }
} }
@ -5281,7 +5282,7 @@ bool setup_jtbm_semi_joins(JOIN *join, List<TABLE_LIST> *join_list,
/* Set up a dummy TABLE*, optimizer code needs JOIN_TABs to have TABLE */ /* Set up a dummy TABLE*, optimizer code needs JOIN_TABs to have TABLE */
TABLE *dummy_table; TABLE *dummy_table;
if (!(dummy_table= create_dummy_tmp_table(join->thd))) if (!(dummy_table= create_dummy_tmp_table(thd)))
DBUG_RETURN(1); DBUG_RETURN(1);
table->table= dummy_table; table->table= dummy_table;
table->table->pos_in_table_list= table; table->table->pos_in_table_list= table;
@ -5307,9 +5308,9 @@ bool setup_jtbm_semi_joins(JOIN *join, List<TABLE_LIST> *join_list,
Item *sj_conds= hash_sj_engine->semi_join_conds; Item *sj_conds= hash_sj_engine->semi_join_conds;
(*join_where)= and_items(join->thd, *join_where, sj_conds); (*join_where)= and_items(thd, *join_where, sj_conds);
if (!(*join_where)->fixed) if (!(*join_where)->fixed)
(*join_where)->fix_fields(join->thd, join_where); (*join_where)->fix_fields(thd, join_where);
} }
table->table->maybe_null= MY_TEST(join->mixed_implicit_grouping); table->table->maybe_null= MY_TEST(join->mixed_implicit_grouping);
} }

2
sql/opt_table_elimination.cc
View File

@ -1217,7 +1217,7 @@ void build_eq_mods_for_cond(THD *thd, Dep_analysis_context *ctx,
} }
case Item_func::ISNULL_FUNC: case Item_func::ISNULL_FUNC:
{ {
Item *tmp=new Item_null(thd); Item *tmp=new (thd->mem_root) Item_null(thd);
if (tmp) if (tmp)
check_equality(ctx, eq_mod, *and_level, cond_func, args[0], tmp); check_equality(ctx, eq_mod, *and_level, cond_func, args[0], tmp);
break; break;

2
sql/protocol.cc
View File

@ -1248,7 +1248,7 @@ bool Protocol_text::send_out_parameters(List<Item_param> *sp_params)
continue; // It's an IN-parameter. continue; // It's an IN-parameter.
Item_func_set_user_var *suv= Item_func_set_user_var *suv=
new Item_func_set_user_var(thd, *user_var_name, item_param); new (thd->mem_root) Item_func_set_user_var(thd, *user_var_name, item_param);
/* /*
Item_func_set_user_var is not fixed after construction, call Item_func_set_user_var is not fixed after construction, call
fix_fields(). fix_fields().

13
sql/repl_failsafe.cc
View File

@ -230,18 +230,19 @@ bool show_slave_hosts(THD* thd)
{ {
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("show_slave_hosts"); DBUG_ENTER("show_slave_hosts");
field_list.push_back(new Item_return_int(thd, "Server_id", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Server_id", 10,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_empty_string(thd, "Host", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Host", 20));
if (opt_show_slave_auth_info) if (opt_show_slave_auth_info)
{ {
field_list.push_back(new Item_empty_string(thd, "User", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "User", 20));
field_list.push_back(new Item_empty_string(thd, "Password", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Password", 20));
} }
field_list.push_back(new Item_return_int(thd, "Port", 7, MYSQL_TYPE_LONG)); field_list.push_back(new (mem_root) Item_return_int(thd, "Port", 7, MYSQL_TYPE_LONG));
field_list.push_back(new Item_return_int(thd, "Master_id", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Master_id", 10,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,

21
sql/set_var.cc
View File

@ -788,12 +788,33 @@ int set_var::light_check(THD *thd)
Consider set_var::check() method if there is a need to return Consider set_var::check() method if there is a need to return
an error due to logics. an error due to logics.
*/ */
int set_var::update(THD *thd) int set_var::update(THD *thd)
{ {
return value ? var->update(thd, this) : var->set_default(thd, this); return value ? var->update(thd, this) : var->set_default(thd, this);
} }
set_var::set_var(THD *thd, enum_var_type type_arg, sys_var *var_arg,
const LEX_STRING *base_name_arg, Item *value_arg)
:var(var_arg), type(type_arg), base(*base_name_arg)
{
/*
If the set value is a field, change it to a string to allow things like
SET table_type=MYISAM;
*/
if (value_arg && value_arg->type() == Item::FIELD_ITEM)
{
Item_field *item= (Item_field*) value_arg;
// names are utf8
if (!(value= new (thd->mem_root) Item_string_sys(thd, item->field_name)))
value=value_arg; /* Give error message later */
}
else
value=value_arg;
}
/***************************************************************************** /*****************************************************************************
Functions to handle SET @user_variable=const_expr Functions to handle SET @user_variable=const_expr
*****************************************************************************/ *****************************************************************************/

18
sql/set_var.h
View File

@ -286,23 +286,7 @@ public:
LEX_STRING base; /**< for structured variables, like keycache_name.variable_name */ LEX_STRING base; /**< for structured variables, like keycache_name.variable_name */
set_var(THD *thd, enum_var_type type_arg, sys_var *var_arg, set_var(THD *thd, enum_var_type type_arg, sys_var *var_arg,
const LEX_STRING *base_name_arg, Item *value_arg) const LEX_STRING *base_name_arg, Item *value_arg);
:var(var_arg), type(type_arg), base(*base_name_arg)
{
/*
If the set value is a field, change it to a string to allow things like
SET table_type=MYISAM;
*/
if (value_arg && value_arg->type() == Item::FIELD_ITEM)
{
Item_field *item= (Item_field*) value_arg;
// names are utf8
if (!(value=new Item_string_sys(thd, item->field_name)))
value=value_arg; /* Give error message later */
}
else
value=value_arg;
}
virtual bool is_system() { return 1; } virtual bool is_system() { return 1; }
int check(THD *thd); int check(THD *thd);
int update(THD *thd); int update(THD *thd);

111
sql/slave.cc
View File

@ -2515,113 +2515,114 @@ static bool send_show_master_info_header(THD *thd, bool full,
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
Master_info *mi; Master_info *mi;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("show_master_info_header"); DBUG_ENTER("show_master_info_header");
if (full) if (full)
{ {
field_list.push_back(new Item_empty_string(thd, "Connection_name", field_list.push_back(new (mem_root) Item_empty_string(thd, "Connection_name",
MAX_CONNECTION_NAME)); MAX_CONNECTION_NAME));
field_list.push_back(new Item_empty_string(thd, "Slave_SQL_State", field_list.push_back(new (mem_root) Item_empty_string(thd, "Slave_SQL_State",
30)); 30));
} }
field_list.push_back(new Item_empty_string(thd, "Slave_IO_State", field_list.push_back(new (mem_root) Item_empty_string(thd, "Slave_IO_State",
30)); 30));
field_list.push_back(new Item_empty_string(thd, "Master_Host", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_Host",
sizeof(mi->host))); sizeof(mi->host)));
field_list.push_back(new Item_empty_string(thd, "Master_User", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_User",
sizeof(mi->user))); sizeof(mi->user)));
field_list.push_back(new Item_return_int(thd, "Master_Port", 7, field_list.push_back(new (mem_root) Item_return_int(thd, "Master_Port", 7,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_return_int(thd, "Connect_Retry", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Connect_Retry", 10,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_empty_string(thd, "Master_Log_File", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_Log_File",
FN_REFLEN)); FN_REFLEN));
field_list.push_back(new Item_return_int(thd, "Read_Master_Log_Pos", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Read_Master_Log_Pos", 10,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_empty_string(thd, "Relay_Log_File", field_list.push_back(new (mem_root) Item_empty_string(thd, "Relay_Log_File",
FN_REFLEN)); FN_REFLEN));
field_list.push_back(new Item_return_int(thd, "Relay_Log_Pos", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Relay_Log_Pos", 10,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_empty_string(thd, "Relay_Master_Log_File", field_list.push_back(new (mem_root) Item_empty_string(thd, "Relay_Master_Log_File",
FN_REFLEN)); FN_REFLEN));
field_list.push_back(new Item_empty_string(thd, "Slave_IO_Running", 3)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Slave_IO_Running", 3));
field_list.push_back(new Item_empty_string(thd, "Slave_SQL_Running", 3)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Slave_SQL_Running", 3));
field_list.push_back(new Item_empty_string(thd, "Replicate_Do_DB", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Do_DB", 20));
field_list.push_back(new Item_empty_string(thd, "Replicate_Ignore_DB", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Ignore_DB", 20));
field_list.push_back(new Item_empty_string(thd, "Replicate_Do_Table", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Do_Table", 20));
field_list.push_back(new Item_empty_string(thd, "Replicate_Ignore_Table", field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Ignore_Table",
23)); 23));
field_list.push_back(new Item_empty_string(thd, "Replicate_Wild_Do_Table", field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Wild_Do_Table",
24)); 24));
field_list.push_back(new Item_empty_string(thd, "Replicate_Wild_Ignore_Table", field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Wild_Ignore_Table",
28)); 28));
field_list.push_back(new Item_return_int(thd, "Last_Errno", 4, field_list.push_back(new (mem_root) Item_return_int(thd, "Last_Errno", 4,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_empty_string(thd, "Last_Error", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Last_Error", 20));
field_list.push_back(new Item_return_int(thd, "Skip_Counter", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Skip_Counter", 10,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_return_int(thd, "Exec_Master_Log_Pos", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Exec_Master_Log_Pos", 10,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_return_int(thd, "Relay_Log_Space", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Relay_Log_Space", 10,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_empty_string(thd, "Until_Condition", 6)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Until_Condition", 6));
field_list.push_back(new Item_empty_string(thd, "Until_Log_File", FN_REFLEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Until_Log_File", FN_REFLEN));
field_list.push_back(new Item_return_int(thd, "Until_Log_Pos", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Until_Log_Pos", 10,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_Allowed", 7)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_Allowed", 7));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_CA_File", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_CA_File",
sizeof(mi->ssl_ca))); sizeof(mi->ssl_ca)));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_CA_Path", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_CA_Path",
sizeof(mi->ssl_capath))); sizeof(mi->ssl_capath)));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_Cert", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_Cert",
sizeof(mi->ssl_cert))); sizeof(mi->ssl_cert)));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_Cipher", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_Cipher",
sizeof(mi->ssl_cipher))); sizeof(mi->ssl_cipher)));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_Key", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_Key",
sizeof(mi->ssl_key))); sizeof(mi->ssl_key)));
field_list.push_back(new Item_return_int(thd, "Seconds_Behind_Master", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Seconds_Behind_Master", 10,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_empty_string(thd, field_list.push_back(new (mem_root) Item_empty_string(thd,
"Master_SSL_Verify_Server_Cert", "Master_SSL_Verify_Server_Cert",
3)); 3));
field_list.push_back(new Item_return_int(thd, "Last_IO_Errno", 4, field_list.push_back(new (mem_root) Item_return_int(thd, "Last_IO_Errno", 4,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_empty_string(thd, "Last_IO_Error", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Last_IO_Error", 20));
field_list.push_back(new Item_return_int(thd, "Last_SQL_Errno", 4, field_list.push_back(new (mem_root) Item_return_int(thd, "Last_SQL_Errno", 4,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_empty_string(thd, "Last_SQL_Error", 20)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Last_SQL_Error", 20));
field_list.push_back(new Item_empty_string(thd, "Replicate_Ignore_Server_Ids", field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Ignore_Server_Ids",
FN_REFLEN)); FN_REFLEN));
field_list.push_back(new Item_return_int(thd, "Master_Server_Id", field_list.push_back(new (mem_root) Item_return_int(thd, "Master_Server_Id",
sizeof(ulong), sizeof(ulong),
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_Crl", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_Crl",
sizeof(mi->ssl_crl))); sizeof(mi->ssl_crl)));
field_list.push_back(new Item_empty_string(thd, "Master_SSL_Crlpath", field_list.push_back(new (mem_root) Item_empty_string(thd, "Master_SSL_Crlpath",
sizeof(mi->ssl_crlpath))); sizeof(mi->ssl_crlpath)));
field_list.push_back(new Item_empty_string(thd, "Using_Gtid", field_list.push_back(new (mem_root) Item_empty_string(thd, "Using_Gtid",
sizeof("Current_Pos")-1)); sizeof("Current_Pos")-1));
field_list.push_back(new Item_empty_string(thd, "Gtid_IO_Pos", 30)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Gtid_IO_Pos", 30));
field_list.push_back(new Item_empty_string(thd, "Replicate_Do_Domain_Ids", field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Do_Domain_Ids",
FN_REFLEN)); FN_REFLEN));
field_list.push_back(new Item_empty_string(thd, "Replicate_Ignore_Domain_Ids", field_list.push_back(new (mem_root) Item_empty_string(thd, "Replicate_Ignore_Domain_Ids",
FN_REFLEN)); FN_REFLEN));
field_list.push_back(new Item_empty_string(thd, "Parallel_Mode", field_list.push_back(new (mem_root) Item_empty_string(thd, "Parallel_Mode",
sizeof("conservative")-1)); sizeof("conservative")-1));
if (full) if (full)
{ {
field_list.push_back(new Item_return_int(thd, "Retried_transactions", field_list.push_back(new (mem_root) Item_return_int(thd, "Retried_transactions",
10, MYSQL_TYPE_LONG)); 10, MYSQL_TYPE_LONG));
field_list.push_back(new Item_return_int(thd, "Max_relay_log_size", field_list.push_back(new (mem_root) Item_return_int(thd, "Max_relay_log_size",
10, MYSQL_TYPE_LONGLONG)); 10, MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_return_int(thd, "Executed_log_entries", field_list.push_back(new (mem_root) Item_return_int(thd, "Executed_log_entries",
10, MYSQL_TYPE_LONG)); 10, MYSQL_TYPE_LONG));
field_list.push_back(new Item_return_int(thd, "Slave_received_heartbeats", field_list.push_back(new (mem_root) Item_return_int(thd, "Slave_received_heartbeats",
10, MYSQL_TYPE_LONG)); 10, MYSQL_TYPE_LONG));
field_list.push_back(new Item_float(thd, "Slave_heartbeat_period", field_list.push_back(new (mem_root) Item_float(thd, "Slave_heartbeat_period",
0.0, 3, 10)); 0.0, 3, 10));
field_list.push_back(new Item_empty_string(thd, "Gtid_Slave_Pos", field_list.push_back(new (mem_root) Item_empty_string(thd, "Gtid_Slave_Pos",
gtid_pos_length)); gtid_pos_length));
} }

24
sql/sp_head.cc
View File

@ -2021,7 +2021,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
if (spvar->mode == sp_variable::MODE_OUT) if (spvar->mode == sp_variable::MODE_OUT)
{ {
Item_null *null_item= new Item_null(thd); Item_null *null_item= new (thd->mem_root) Item_null(thd);
Item *tmp_item= null_item; Item *tmp_item= null_item;
if (!null_item || if (!null_item ||
@ -2561,6 +2561,7 @@ sp_head::show_create_routine(THD *thd, int type)
LEX_STRING sql_mode; LEX_STRING sql_mode;
bool full_access; bool full_access;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("sp_head::show_create_routine"); DBUG_ENTER("sp_head::show_create_routine");
DBUG_PRINT("info", ("routine %s", m_name.str)); DBUG_PRINT("info", ("routine %s", m_name.str));
@ -2575,8 +2576,8 @@ sp_head::show_create_routine(THD *thd, int type)
/* Send header. */ /* Send header. */
fields.push_back(new Item_empty_string(thd, col1_caption, NAME_CHAR_LEN)); fields.push_back(new (mem_root) Item_empty_string(thd, col1_caption, NAME_CHAR_LEN));
fields.push_back(new Item_empty_string(thd, "sql_mode", sql_mode.length)); fields.push_back(new (mem_root) Item_empty_string(thd, "sql_mode", sql_mode.length));
{ {
/* /*
@ -2585,7 +2586,7 @@ sp_head::show_create_routine(THD *thd, int type)
*/ */
Item_empty_string *stmt_fld= Item_empty_string *stmt_fld=
new Item_empty_string(thd, col3_caption, new (mem_root) Item_empty_string(thd, col3_caption,
MY_MAX(m_defstr.length, 1024)); MY_MAX(m_defstr.length, 1024));
stmt_fld->maybe_null= TRUE; stmt_fld->maybe_null= TRUE;
@ -2593,13 +2594,13 @@ sp_head::show_create_routine(THD *thd, int type)
fields.push_back(stmt_fld); fields.push_back(stmt_fld);
} }
fields.push_back(new Item_empty_string(thd, "character_set_client", fields.push_back(new (mem_root) Item_empty_string(thd, "character_set_client",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
fields.push_back(new Item_empty_string(thd, "collation_connection", fields.push_back(new (mem_root) Item_empty_string(thd, "collation_connection",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
fields.push_back(new Item_empty_string(thd, "Database Collation", fields.push_back(new (mem_root) Item_empty_string(thd, "Database Collation",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
if (protocol->send_result_set_metadata(&fields, if (protocol->send_result_set_metadata(&fields,
@ -2783,10 +2784,11 @@ sp_head::show_routine_code(THD *thd)
if (check_show_routine_access(thd, this, &full_access) || !full_access) if (check_show_routine_access(thd, this, &full_access) || !full_access)
DBUG_RETURN(1); DBUG_RETURN(1);
field_list.push_back(new Item_uint(thd, "Pos", 9)); field_list.push_back(new (thd->mem_root) Item_uint(thd, "Pos", 9));
// 1024 is for not to confuse old clients // 1024 is for not to confuse old clients
field_list.push_back(new Item_empty_string(thd, "Instruction", field_list.push_back(new (thd->mem_root)
MY_MAX(buffer.length(), 1024))); Item_empty_string(thd, "Instruction",
MY_MAX(buffer.length(), 1024)));
if (protocol->send_result_set_metadata(&field_list, Protocol::SEND_NUM_ROWS | if (protocol->send_result_set_metadata(&field_list, Protocol::SEND_NUM_ROWS |
Protocol::SEND_EOF)) Protocol::SEND_EOF))
DBUG_RETURN(1); DBUG_RETURN(1);
@ -3895,7 +3897,7 @@ sp_instr_set_case_expr::exec_core(THD *thd, uint *nextp)
initialized. Set to NULL so we can continue. initialized. Set to NULL so we can continue.
*/ */
Item *null_item= new Item_null(thd); Item *null_item= new (thd->mem_root) Item_null(thd);
if (!null_item || if (!null_item ||
thd->spcont->set_case_expr(thd, m_case_expr_id, &null_item)) thd->spcont->set_case_expr(thd, m_case_expr_id, &null_item))

2
sql/sp_rcontext.cc
View File

@ -137,7 +137,7 @@ bool sp_rcontext::init_var_items(THD *thd)
for (uint idx = 0; idx < num_vars; ++idx) for (uint idx = 0; idx < num_vars; ++idx)
{ {
if (!(m_var_items[idx]= new Item_field(thd, m_var_table->field[idx]))) if (!(m_var_items[idx]= new (thd->mem_root) Item_field(thd, m_var_table->field[idx])))
return true; return true;
} }

2
sql/sql_acl.cc
View File

@ -7788,7 +7788,7 @@ bool mysql_show_grants(THD *thd, LEX_USER *lex_user)
} }
DBUG_ASSERT(rolename || username); DBUG_ASSERT(rolename || username);
Item_string *field=new Item_string_ascii(thd, "", 0); Item_string *field=new (thd->mem_root) Item_string_ascii(thd, "", 0);
List<Item> field_list; List<Item> field_list;
field->name=buff; field->name=buff;
field->max_length=1024; field->max_length=1024;

8
sql/sql_admin.cc
View File

@ -326,14 +326,14 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
DBUG_ENTER("mysql_admin_table"); DBUG_ENTER("mysql_admin_table");
DBUG_PRINT("enter", ("extra_open_options: %u", extra_open_options)); DBUG_PRINT("enter", ("extra_open_options: %u", extra_open_options));
field_list.push_back(item = new Item_empty_string(thd, "Table", field_list.push_back(item= new (thd->mem_root) Item_empty_string(thd, "Table",
NAME_CHAR_LEN * 2)); NAME_CHAR_LEN * 2));
item->maybe_null = 1; item->maybe_null = 1;
field_list.push_back(item = new Item_empty_string(thd, "Op", 10)); field_list.push_back(item= new (thd->mem_root) Item_empty_string(thd, "Op", 10));
item->maybe_null = 1; item->maybe_null = 1;
field_list.push_back(item = new Item_empty_string(thd, "Msg_type", 10)); field_list.push_back(item= new (thd->mem_root) Item_empty_string(thd, "Msg_type", 10));
item->maybe_null = 1; item->maybe_null = 1;
field_list.push_back(item = new Item_empty_string(thd, "Msg_text", field_list.push_back(item= new (thd->mem_root) Item_empty_string(thd, "Msg_text",
SQL_ADMIN_MSG_TEXT_SIZE)); SQL_ADMIN_MSG_TEXT_SIZE));
item->maybe_null = 1; item->maybe_null = 1;
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,

24
sql/sql_analyse.cc
View File

@ -1168,22 +1168,24 @@ int collect_ulonglong(ulonglong *element,
bool analyse::change_columns(THD *thd, List<Item> &field_list) bool analyse::change_columns(THD *thd, List<Item> &field_list)
{ {
MEM_ROOT *mem_root= thd->mem_root;
field_list.empty(); field_list.empty();
func_items[0] = new Item_proc_string(thd, "Field_name", 255); func_items[0]= new (mem_root) Item_proc_string(thd, "Field_name", 255);
func_items[1] = new Item_proc_string(thd, "Min_value", 255); func_items[1]= new (mem_root) Item_proc_string(thd, "Min_value", 255);
func_items[1]->maybe_null = 1; func_items[1]->maybe_null = 1;
func_items[2] = new Item_proc_string(thd, "Max_value", 255); func_items[2]= new (mem_root) Item_proc_string(thd, "Max_value", 255);
func_items[2]->maybe_null = 1; func_items[2]->maybe_null = 1;
func_items[3] = new Item_proc_int(thd, "Min_length"); func_items[3]= new (mem_root) Item_proc_int(thd, "Min_length");
func_items[4] = new Item_proc_int(thd, "Max_length"); func_items[4]= new (mem_root) Item_proc_int(thd, "Max_length");
func_items[5] = new Item_proc_int(thd, "Empties_or_zeros"); func_items[5]= new (mem_root) Item_proc_int(thd, "Empties_or_zeros");
func_items[6] = new Item_proc_int(thd, "Nulls"); func_items[6]= new (mem_root) Item_proc_int(thd, "Nulls");
func_items[7] = new Item_proc_string(thd, "Avg_value_or_avg_length", 255); func_items[7]= new (mem_root) Item_proc_string(thd, "Avg_value_or_avg_length", 255);
func_items[8] = new Item_proc_string(thd, "Std", 255); func_items[8]= new (mem_root) Item_proc_string(thd, "Std", 255);
func_items[8]->maybe_null = 1; func_items[8]->maybe_null = 1;
func_items[9] = new Item_proc_string(thd, "Optimal_fieldtype", func_items[9]= new (mem_root) Item_proc_string(thd, "Optimal_fieldtype",
MY_MAX(64, output_str_length)); MY_MAX(64,
output_str_length));
for (uint i = 0; i < array_elements(func_items); i++) for (uint i = 0; i < array_elements(func_items); i++)
field_list.push_back(func_items[i]); field_list.push_back(func_items[i]);

8
sql/sql_base.cc
View File

@ -7304,7 +7304,7 @@ mark_common_columns(THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2,
set_new_item_local_context(thd, item_ident_2, nj_col_2->table_ref)) set_new_item_local_context(thd, item_ident_2, nj_col_2->table_ref))
goto err; goto err;
if (!(eq_cond= new Item_func_eq(thd, item_ident_1, item_ident_2))) if (!(eq_cond= new (thd->mem_root) Item_func_eq(thd, item_ident_1, item_ident_2)))
goto err; /* Out of memory. */ goto err; /* Out of memory. */
if (field_1 && field_1->vcol_info) if (field_1 && field_1->vcol_info)
@ -7651,7 +7651,7 @@ store_top_level_join_columns(THD *thd, TABLE_LIST *table_ref,
/* Add a TRUE condition to outer joins that have no common columns. */ /* Add a TRUE condition to outer joins that have no common columns. */
if (table_ref_2->outer_join && if (table_ref_2->outer_join &&
!table_ref_1->on_expr && !table_ref_2->on_expr) !table_ref_1->on_expr && !table_ref_2->on_expr)
table_ref_2->on_expr= new Item_int(thd, (longlong) 1, 1); // Always true. table_ref_2->on_expr= new (thd->mem_root) Item_int(thd, (longlong) 1, 1); // Always true.
/* Change this table reference to become a leaf for name resolution. */ /* Change this table reference to become a leaf for name resolution. */
if (left_neighbor) if (left_neighbor)
@ -7816,7 +7816,7 @@ int setup_wild(THD *thd, TABLE_LIST *tables, List<Item> &fields,
Item_int do not need fix_fields() because it is basic constant. Item_int do not need fix_fields() because it is basic constant.
*/ */
it.replace(new Item_int(thd, "Not_used", (longlong) 1, it.replace(new (thd->mem_root) Item_int(thd, "Not_used", (longlong) 1,
MY_INT64_NUM_DECIMAL_DIGITS)); MY_INT64_NUM_DECIMAL_DIGITS));
} }
else if (insert_fields(thd, ((Item_field*) item)->context, else if (insert_fields(thd, ((Item_field*) item)->context,
@ -8510,7 +8510,7 @@ void wrap_ident(THD *thd, Item **conds)
DBUG_ASSERT((*conds)->type() == Item::FIELD_ITEM || (*conds)->type() == Item::REF_ITEM); DBUG_ASSERT((*conds)->type() == Item::FIELD_ITEM || (*conds)->type() == Item::REF_ITEM);
Query_arena *arena, backup; Query_arena *arena, backup;
arena= thd->activate_stmt_arena_if_needed(&backup); arena= thd->activate_stmt_arena_if_needed(&backup);
if ((wrapper= new Item_direct_ref_to_ident(thd, (Item_ident *) (*conds)))) if ((wrapper= new (thd->mem_root) Item_direct_ref_to_ident(thd, (Item_ident *) (*conds))))
(*conds)= (Item*) wrapper; (*conds)= (Item*) wrapper;
if (arena) if (arena)
thd->restore_active_arena(arena, &backup); thd->restore_active_arena(arena, &backup);

69
sql/sql_class.cc
View File

@ -2456,10 +2456,10 @@ int THD::send_explain_fields(select_result *result, uint8 explain_flags, bool is
void THD::make_explain_json_field_list(List<Item> &field_list, bool is_analyze) void THD::make_explain_json_field_list(List<Item> &field_list, bool is_analyze)
{ {
Item *item= new Item_empty_string(this, (is_analyze ? Item *item= new (mem_root) Item_empty_string(this, (is_analyze ?
"ANALYZE" : "ANALYZE" :
"EXPLAIN"), "EXPLAIN"),
78, system_charset_info); 78, system_charset_info);
field_list.push_back(item); field_list.push_back(item);
} }
@ -2477,59 +2477,70 @@ void THD::make_explain_field_list(List<Item> &field_list, uint8 explain_flags,
{ {
Item *item; Item *item;
CHARSET_INFO *cs= system_charset_info; CHARSET_INFO *cs= system_charset_info;
field_list.push_back(item= new Item_return_int(this, "id", 3, field_list.push_back(item= new (mem_root)
MYSQL_TYPE_LONGLONG)); Item_return_int(this, "id", 3,
MYSQL_TYPE_LONGLONG));
item->maybe_null= 1; item->maybe_null= 1;
field_list.push_back(new Item_empty_string(this, "select_type", 19, cs)); field_list.push_back(new (mem_root)
field_list.push_back(item= new Item_empty_string(this, "table", NAME_CHAR_LEN, Item_empty_string(this, "select_type", 19, cs));
cs)); field_list.push_back(item= new (mem_root)
Item_empty_string(this, "table", NAME_CHAR_LEN, cs));
item->maybe_null= 1; item->maybe_null= 1;
if (explain_flags & DESCRIBE_PARTITIONS) if (explain_flags & DESCRIBE_PARTITIONS)
{ {
/* Maximum length of string that make_used_partitions_str() can produce */ /* Maximum length of string that make_used_partitions_str() can produce */
item= new Item_empty_string(this, "partitions", item= new (mem_root) Item_empty_string(this, "partitions",
MAX_PARTITIONS * (1 + FN_LEN), cs); MAX_PARTITIONS * (1 + FN_LEN), cs);
field_list.push_back(item); field_list.push_back(item);
item->maybe_null= 1; item->maybe_null= 1;
} }
field_list.push_back(item= new Item_empty_string(this, "type", 10, cs)); field_list.push_back(item= new (mem_root)
Item_empty_string(this, "type", 10, cs));
item->maybe_null= 1; item->maybe_null= 1;
field_list.push_back(item=new Item_empty_string(this, "possible_keys", field_list.push_back(item= new (mem_root)
NAME_CHAR_LEN*MAX_KEY, cs)); Item_empty_string(this, "possible_keys",
NAME_CHAR_LEN*MAX_KEY, cs));
item->maybe_null=1; item->maybe_null=1;
field_list.push_back(item=new Item_empty_string(this, "key", NAME_CHAR_LEN, field_list.push_back(item=new (mem_root)
cs)); Item_empty_string(this, "key", NAME_CHAR_LEN, cs));
item->maybe_null=1; item->maybe_null=1;
field_list.push_back(item=new Item_empty_string(this, "key_len", field_list.push_back(item=new (mem_root)
NAME_CHAR_LEN*MAX_KEY)); Item_empty_string(this, "key_len",
NAME_CHAR_LEN*MAX_KEY));
item->maybe_null=1; item->maybe_null=1;
field_list.push_back(item=new Item_empty_string(this, "ref", field_list.push_back(item=new (mem_root)
NAME_CHAR_LEN*MAX_REF_PARTS, Item_empty_string(this, "ref",
cs)); NAME_CHAR_LEN*MAX_REF_PARTS,
cs));
item->maybe_null=1; item->maybe_null=1;
field_list.push_back(item= new Item_return_int(this, "rows", 10, field_list.push_back(item= new (mem_root)
MYSQL_TYPE_LONGLONG)); Item_return_int(this, "rows", 10,
MYSQL_TYPE_LONGLONG));
if (is_analyze) if (is_analyze)
{ {
field_list.push_back(item= new Item_float(this, "r_rows", 0.1234, 10, 4)); field_list.push_back(item= new (mem_root)
Item_float(this, "r_rows", 0.1234, 10, 4));
item->maybe_null=1; item->maybe_null=1;
} }
if (is_analyze || (explain_flags & DESCRIBE_EXTENDED)) if (is_analyze || (explain_flags & DESCRIBE_EXTENDED))
{ {
field_list.push_back(item= new Item_float(this, "filtered", 0.1234, 2, 4)); field_list.push_back(item= new (mem_root)
Item_float(this, "filtered", 0.1234, 2, 4));
item->maybe_null=1; item->maybe_null=1;
} }
if (is_analyze) if (is_analyze)
{ {
field_list.push_back(item= new Item_float(this, "r_filtered", 0.1234, 2, field_list.push_back(item= new (mem_root)
4)); Item_float(this, "r_filtered", 0.1234, 2,
4));
item->maybe_null=1; item->maybe_null=1;
} }
item->maybe_null= 1; item->maybe_null= 1;
field_list.push_back(new Item_empty_string(this, "Extra", 255, cs)); field_list.push_back(new (mem_root)
Item_empty_string(this, "Extra", 255, cs));
} }
@ -3807,7 +3818,7 @@ Statement_map::~Statement_map()
bool my_var_user::set(THD *thd, Item *item) bool my_var_user::set(THD *thd, Item *item)
{ {
Item_func_set_user_var *suv= new Item_func_set_user_var(thd, name, item); Item_func_set_user_var *suv= new (thd->mem_root) Item_func_set_user_var(thd, name, item);
suv->save_item_result(item); suv->save_item_result(item);
return suv->fix_fields(thd, 0) || suv->update(); return suv->fix_fields(thd, 0) || suv->update();
} }

7
sql/sql_class.h
View File

@ -5334,6 +5334,13 @@ inline bool add_group_to_list(THD *thd, Item *item, bool asc)
return thd->lex->current_select->add_group_to_list(thd, item, asc); return thd->lex->current_select->add_group_to_list(thd, item, asc);
} }
inline Item *and_conds(THD *thd, Item *a, Item *b)
{
if (!b) return a;
if (!a) return b;
return new (thd->mem_root) Item_cond_and(thd, a, b);
}
/* inline handler methods that need to know TABLE and THD structures */ /* inline handler methods that need to know TABLE and THD structures */
inline void handler::increment_statistics(ulong SSV::*offset) const inline void handler::increment_statistics(ulong SSV::*offset) const
{ {

8
sql/sql_error.cc
View File

@ -814,13 +814,15 @@ const LEX_STRING warning_level_names[]=
bool mysqld_show_warnings(THD *thd, ulong levels_to_show) bool mysqld_show_warnings(THD *thd, ulong levels_to_show)
{ {
List<Item> field_list; List<Item> field_list;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_show_warnings"); DBUG_ENTER("mysqld_show_warnings");
DBUG_ASSERT(thd->get_stmt_da()->is_warning_info_read_only()); DBUG_ASSERT(thd->get_stmt_da()->is_warning_info_read_only());
field_list.push_back(new Item_empty_string(thd, "Level", 7)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Level", 7));
field_list.push_back(new Item_return_int(thd, "Code", 4, MYSQL_TYPE_LONG)); field_list.push_back(new (mem_root) Item_return_int(thd, "Code", 4,
field_list.push_back(new Item_empty_string(thd, "Message", MYSQL_TYPE_LONG));
field_list.push_back(new (mem_root) Item_empty_string(thd, "Message",
MYSQL_ERRMSG_SIZE)); MYSQL_ERRMSG_SIZE));
if (thd->protocol->send_result_set_metadata(&field_list, if (thd->protocol->send_result_set_metadata(&field_list,

72
sql/sql_explain.cc
View File

@ -227,8 +227,8 @@ void Explain_query::print_explain_json(select_result_sink *output, bool is_analy
CHARSET_INFO *cs= system_charset_info; CHARSET_INFO *cs= system_charset_info;
List<Item> item_list; List<Item> item_list;
String *buf= &writer.output; String *buf= &writer.output;
item_list.push_back(new Item_string(output->thd, buf->ptr(), buf->length(), item_list.push_back(new (thd->mem_root)
cs)); Item_string(thd, buf->ptr(), buf->length(), cs));
output->send_data(item_list); output->send_data(item_list);
} }
@ -260,13 +260,13 @@ bool Explain_query::print_explain_str(THD *thd, String *out_str,
static void push_str(THD *thd, List<Item> *item_list, const char *str) static void push_str(THD *thd, List<Item> *item_list, const char *str)
{ {
item_list->push_back(new Item_string_sys(thd, str)); item_list->push_back(new (thd->mem_root) Item_string_sys(thd, str));
} }
static void push_string(THD *thd, List<Item> *item_list, String *str) static void push_string(THD *thd, List<Item> *item_list, String *str)
{ {
item_list->push_back(new Item_string_sys(thd, str->ptr(), str->length())); item_list->push_back(new (thd->mem_root) Item_string_sys(thd, str->ptr(), str->length()));
} }
static void push_string_list(THD *thd, List<Item> *item_list, static void push_string_list(THD *thd, List<Item> *item_list,
@ -318,25 +318,26 @@ int print_explain_row(select_result_sink *result,
const char *extra) const char *extra)
{ {
THD *thd= result->thd; THD *thd= result->thd;
Item *item_null= new Item_null(thd); Item *item_null= new (thd->mem_root) Item_null(thd);
List<Item> item_list; List<Item> item_list;
Item *item; Item *item;
MEM_ROOT *mem_root= thd->mem_root;
item_list.push_back(new Item_int(thd, (int32) select_number)); item_list.push_back(new (mem_root) Item_int(thd, (int32) select_number));
item_list.push_back(new Item_string_sys(thd, select_type)); item_list.push_back(new (mem_root) Item_string_sys(thd, select_type));
item_list.push_back(new Item_string_sys(thd, table_name)); item_list.push_back(new (mem_root) Item_string_sys(thd, table_name));
if (options & DESCRIBE_PARTITIONS) if (options & DESCRIBE_PARTITIONS)
{ {
if (partitions) if (partitions)
{ {
item_list.push_back(new Item_string_sys(thd, partitions)); item_list.push_back(new (mem_root) Item_string_sys(thd, partitions));
} }
else else
item_list.push_back(item_null); item_list.push_back(item_null);
} }
const char *jtype_str= join_type_str[jtype]; const char *jtype_str= join_type_str[jtype];
item_list.push_back(new Item_string_sys(thd, jtype_str)); item_list.push_back(new (mem_root) Item_string_sys(thd, jtype_str));
/* 'possible_keys' */ /* 'possible_keys' */
if (possible_keys && !possible_keys->is_empty()) if (possible_keys && !possible_keys->is_empty())
@ -348,21 +349,21 @@ int print_explain_row(select_result_sink *result,
item_list.push_back(item_null); item_list.push_back(item_null);
/* 'index */ /* 'index */
item= index ? new Item_string_sys(thd, index) : item_null; item= index ? new (mem_root) Item_string_sys(thd, index) : item_null;
item_list.push_back(item); item_list.push_back(item);
/* 'key_len */ /* 'key_len */
item= key_len ? new Item_string_sys(thd, key_len) : item_null; item= key_len ? new (mem_root) Item_string_sys(thd, key_len) : item_null;
item_list.push_back(item); item_list.push_back(item);
/* 'ref' */ /* 'ref' */
item= ref ? new Item_string_sys(thd, ref) : item_null; item= ref ? new (mem_root) Item_string_sys(thd, ref) : item_null;
item_list.push_back(item); item_list.push_back(item);
/* 'rows' */ /* 'rows' */
if (rows) if (rows)
{ {
item_list.push_back(new Item_int(thd, *rows, item_list.push_back(new (mem_root) Item_int(thd, *rows,
MY_INT64_NUM_DECIMAL_DIGITS)); MY_INT64_NUM_DECIMAL_DIGITS));
} }
else else
@ -372,7 +373,7 @@ int print_explain_row(select_result_sink *result,
if (is_analyze) if (is_analyze)
{ {
if (r_rows) if (r_rows)
item_list.push_back(new Item_float(thd, *r_rows, 2)); item_list.push_back(new (mem_root) Item_float(thd, *r_rows, 2));
else else
item_list.push_back(item_null); item_list.push_back(item_null);
} }
@ -380,15 +381,15 @@ int print_explain_row(select_result_sink *result,
/* 'filtered' */ /* 'filtered' */
const double filtered=100.0; const double filtered=100.0;
if (options & DESCRIBE_EXTENDED || is_analyze) if (options & DESCRIBE_EXTENDED || is_analyze)
item_list.push_back(new Item_float(thd, filtered, 2)); item_list.push_back(new (mem_root) Item_float(thd, filtered, 2));
/* 'r_filtered' */ /* 'r_filtered' */
if (is_analyze) if (is_analyze)
item_list.push_back(new Item_float(thd, r_filtered, 2)); item_list.push_back(new (mem_root) Item_float(thd, r_filtered, 2));
/* 'Extra' */ /* 'Extra' */
if (extra) if (extra)
item_list.push_back(new Item_string_sys(thd, extra)); item_list.push_back(new (mem_root) Item_string_sys(thd, extra));
else else
item_list.push_back(item_null); item_list.push_back(item_null);
@ -436,6 +437,7 @@ int Explain_union::print_explain(Explain_query *query,
THD *thd= output->thd; THD *thd= output->thd;
//CHARSET_INFO *cs= system_charset_info; //CHARSET_INFO *cs= system_charset_info;
char table_name_buffer[SAFE_NAME_LEN]; char table_name_buffer[SAFE_NAME_LEN];
MEM_ROOT *mem_root= thd->mem_root;
/* print all UNION children, in order */ /* print all UNION children, in order */
for (int i= 0; i < (int) union_members.elements(); i++) for (int i= 0; i < (int) union_members.elements(); i++)
@ -449,7 +451,7 @@ int Explain_union::print_explain(Explain_query *query,
/* Print a line with "UNION RESULT" */ /* Print a line with "UNION RESULT" */
List<Item> item_list; List<Item> item_list;
Item *item_null= new Item_null(thd); Item *item_null= new (mem_root) Item_null(thd);
/* `id` column */ /* `id` column */
item_list.push_back(item_null); item_list.push_back(item_null);
@ -459,7 +461,7 @@ int Explain_union::print_explain(Explain_query *query,
/* `table` column: something like "<union1,2>" */ /* `table` column: something like "<union1,2>" */
uint len= make_union_table_name(table_name_buffer); uint len= make_union_table_name(table_name_buffer);
item_list.push_back(new Item_string_sys(thd, table_name_buffer, len)); item_list.push_back(new (mem_root) Item_string_sys(thd, table_name_buffer, len));
/* `partitions` column */ /* `partitions` column */
if (explain_flags & DESCRIBE_PARTITIONS) if (explain_flags & DESCRIBE_PARTITIONS)
@ -487,7 +489,7 @@ int Explain_union::print_explain(Explain_query *query,
if (is_analyze) if (is_analyze)
{ {
double avg_rows= fake_select_lex_tracker.get_avg_rows(); double avg_rows= fake_select_lex_tracker.get_avg_rows();
item_list.push_back(new Item_float(thd, avg_rows, 2)); item_list.push_back(new (mem_root) Item_float(thd, avg_rows, 2));
} }
/* `filtered` */ /* `filtered` */
@ -504,7 +506,7 @@ int Explain_union::print_explain(Explain_query *query,
{ {
extra_buf.append(STRING_WITH_LEN("Using filesort")); extra_buf.append(STRING_WITH_LEN("Using filesort"));
} }
item_list.push_back(new Item_string_sys(thd, extra_buf.ptr(), item_list.push_back(new (mem_root) Item_string_sys(thd, extra_buf.ptr(),
extra_buf.length())); extra_buf.length()));
//output->unit.offset_limit_cnt= 0; //output->unit.offset_limit_cnt= 0;
@ -701,13 +703,15 @@ int Explain_select::print_explain(Explain_query *query,
uint8 explain_flags, bool is_analyze) uint8 explain_flags, bool is_analyze)
{ {
THD *thd= output->thd; THD *thd= output->thd;
MEM_ROOT *mem_root= thd->mem_root;
if (message) if (message)
{ {
List<Item> item_list; List<Item> item_list;
Item *item_null= new Item_null(thd); Item *item_null= new (mem_root) Item_null(thd);
item_list.push_back(new Item_int(thd, (int32) select_id)); item_list.push_back(new (mem_root) Item_int(thd, (int32) select_id));
item_list.push_back(new Item_string_sys(thd, select_type)); item_list.push_back(new (mem_root) Item_string_sys(thd, select_type));
for (uint i=0 ; i < 7; i++) for (uint i=0 ; i < 7; i++)
item_list.push_back(item_null); item_list.push_back(item_null);
if (explain_flags & DESCRIBE_PARTITIONS) if (explain_flags & DESCRIBE_PARTITIONS)
@ -724,7 +728,7 @@ int Explain_select::print_explain(Explain_query *query,
item_list.push_back(item_null); item_list.push_back(item_null);
} }
item_list.push_back(new Item_string_sys(thd, message)); item_list.push_back(new (mem_root) Item_string_sys(thd, message));
if (output->send_data(item_list)) if (output->send_data(item_list))
return 1; return 1;
@ -1112,13 +1116,13 @@ int Explain_table_access::print_explain(select_result_sink *output, uint8 explai
bool using_temporary, bool using_filesort) bool using_temporary, bool using_filesort)
{ {
THD *thd= output->thd; THD *thd= output->thd;
//CHARSET_INFO *cs= system_charset_info; MEM_ROOT *mem_root= thd->mem_root;
List<Item> item_list; List<Item> item_list;
Item *item_null= new Item_null(thd); Item *item_null= new (mem_root) Item_null(thd);
/* `id` column */ /* `id` column */
item_list.push_back(new Item_int(thd, (int32) select_id)); item_list.push_back(new (mem_root) Item_int(thd, (int32) select_id));
/* `select_type` column */ /* `select_type` column */
push_str(thd, &item_list, select_type); push_str(thd, &item_list, select_type);
@ -1183,7 +1187,7 @@ int Explain_table_access::print_explain(select_result_sink *output, uint8 explai
/* `rows` */ /* `rows` */
if (rows_set) if (rows_set)
{ {
item_list.push_back(new Item_int(thd, (longlong) (ulonglong) rows, item_list.push_back(new (mem_root) Item_int(thd, (longlong) (ulonglong) rows,
MY_INT64_NUM_DECIMAL_DIGITS)); MY_INT64_NUM_DECIMAL_DIGITS));
} }
else else
@ -1199,7 +1203,7 @@ int Explain_table_access::print_explain(select_result_sink *output, uint8 explai
else else
{ {
double avg_rows= tracker.get_avg_rows(); double avg_rows= tracker.get_avg_rows();
item_list.push_back(new Item_float(thd, avg_rows, 2)); item_list.push_back(new (mem_root) Item_float(thd, avg_rows, 2));
} }
} }
@ -1208,7 +1212,7 @@ int Explain_table_access::print_explain(select_result_sink *output, uint8 explai
{ {
if (filtered_set) if (filtered_set)
{ {
item_list.push_back(new Item_float(thd, filtered, 2)); item_list.push_back(new (mem_root) Item_float(thd, filtered, 2));
} }
else else
item_list.push_back(item_null); item_list.push_back(item_null);
@ -1226,7 +1230,7 @@ int Explain_table_access::print_explain(select_result_sink *output, uint8 explai
double r_filtered= tracker.get_filtered_after_where(); double r_filtered= tracker.get_filtered_after_where();
if (bka_type.is_using_jbuf()) if (bka_type.is_using_jbuf())
r_filtered *= jbuf_tracker.get_filtered_after_where(); r_filtered *= jbuf_tracker.get_filtered_after_where();
item_list.push_back(new Item_float(thd, r_filtered * 100.0, 2)); item_list.push_back(new (mem_root) Item_float(thd, r_filtered * 100.0, 2));
} }
} }
@ -1260,7 +1264,7 @@ int Explain_table_access::print_explain(select_result_sink *output, uint8 explai
extra_buf.append(STRING_WITH_LEN("Using filesort")); extra_buf.append(STRING_WITH_LEN("Using filesort"));
} }
item_list.push_back(new Item_string_sys(thd, extra_buf.ptr(), item_list.push_back(new (mem_root) Item_string_sys(thd, extra_buf.ptr(),
extra_buf.length())); extra_buf.length()));
if (output->send_data(item_list)) if (output->send_data(item_list))

3
sql/sql_expression_cache.cc
View File

@ -161,7 +161,8 @@ void Expression_cache_tmptable::init()
goto error; goto error;
} }
if (!(cached_result= new Item_field(table_thd, cache_table->field[0]))) if (!(cached_result= new (table_thd->mem_root)
Item_field(table_thd, cache_table->field[0])))
{ {
DBUG_PRINT("error", ("Creating Item_field failed")); DBUG_PRINT("error", ("Creating Item_field failed"));
goto error; goto error;

2
sql/sql_get_diagnostics.cc
View File

@ -270,7 +270,7 @@ Condition_information_item::make_utf8_string_item(THD *thd, const String *str)
String tmp(str->ptr(), str->length(), from_cs); String tmp(str->ptr(), str->length(), from_cs);
/* If necessary, convert the string (ignoring errors), then copy it over. */ /* If necessary, convert the string (ignoring errors), then copy it over. */
uint conv_errors; uint conv_errors;
return new Item_string(thd, &tmp, to_cs, &conv_errors, return new (thd->mem_root) Item_string(thd, &tmp, to_cs, &conv_errors,
DERIVATION_COERCIBLE, MY_REPERTOIRE_UNICODE30); DERIVATION_COERCIBLE, MY_REPERTOIRE_UNICODE30);
} }

45
sql/sql_help.cc
View File

@ -93,7 +93,7 @@ static bool init_fields(THD *thd, TABLE_LIST *tables,
for (; count-- ; find_fields++) for (; count-- ; find_fields++)
{ {
/* We have to use 'new' here as field will be re_linked on free */ /* We have to use 'new' here as field will be re_linked on free */
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
"mysql", find_fields->table_name, "mysql", find_fields->table_name,
find_fields->field_name); find_fields->field_name);
if (!(find_fields->field= find_field_in_tables(thd, field, tables, NULL, if (!(find_fields->field= find_field_in_tables(thd, field, tables, NULL,
@ -450,11 +450,13 @@ void get_all_items_for_category(THD *thd, TABLE *items, Field *pfname,
int send_answer_1(Protocol *protocol, String *s1, String *s2, String *s3) int send_answer_1(Protocol *protocol, String *s1, String *s2, String *s3)
{ {
THD *thd= protocol->thd; THD *thd= protocol->thd;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("send_answer_1"); DBUG_ENTER("send_answer_1");
List<Item> field_list; List<Item> field_list;
field_list.push_back(new Item_empty_string(thd, "name", 64)); field_list.push_back(new (mem_root) Item_empty_string(thd, "name", 64));
field_list.push_back(new Item_empty_string(thd, "description", 1000)); field_list.push_back(new (mem_root) Item_empty_string(thd, "description", 1000));
field_list.push_back(new Item_empty_string(thd, "example", 1000)); field_list.push_back(new (mem_root) Item_empty_string(thd, "example", 1000));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -494,13 +496,14 @@ int send_answer_1(Protocol *protocol, String *s1, String *s2, String *s3)
int send_header_2(Protocol *protocol, bool for_category) int send_header_2(Protocol *protocol, bool for_category)
{ {
THD *thd= protocol->thd; THD *thd= protocol->thd;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("send_header_2"); DBUG_ENTER("send_header_2");
List<Item> field_list; List<Item> field_list;
if (for_category) if (for_category)
field_list.push_back(new Item_empty_string(thd, "source_category_name", field_list.push_back(new (mem_root) Item_empty_string(thd, "source_category_name",
64)); 64));
field_list.push_back(new Item_empty_string(thd, "name", 64)); field_list.push_back(new (mem_root) Item_empty_string(thd, "name", 64));
field_list.push_back(new Item_empty_string(thd, "is_it_category", 1)); field_list.push_back(new (mem_root) Item_empty_string(thd, "is_it_category", 1));
DBUG_RETURN(protocol->send_result_set_metadata(&field_list, Protocol::SEND_NUM_ROWS | DBUG_RETURN(protocol->send_result_set_metadata(&field_list, Protocol::SEND_NUM_ROWS |
Protocol::SEND_EOF)); Protocol::SEND_EOF));
} }
@ -628,11 +631,15 @@ SQL_SELECT *prepare_select_for_name(THD *thd, const char *mask, uint mlen,
TABLE_LIST *tables, TABLE *table, TABLE_LIST *tables, TABLE *table,
Field *pfname, int *error) Field *pfname, int *error)
{ {
Item *cond= new Item_func_like(thd, new Item_field(thd, pfname), MEM_ROOT *mem_root= thd->mem_root;
new Item_string(thd, mask, mlen, Item *cond= new (mem_root)
pfname->charset()), Item_func_like(thd,
new Item_string_ascii(thd, "\\"), new (mem_root)
FALSE); Item_field(thd, pfname),
new (mem_root) Item_string(thd, mask, mlen,
pfname->charset()),
new (mem_root) Item_string_ascii(thd, "\\"),
FALSE);
if (thd->is_fatal_error) if (thd->is_fatal_error)
return 0; // OOM return 0; // OOM
return prepare_simple_select(thd, cond, table, error); return prepare_simple_select(thd, cond, table, error);
@ -767,11 +774,17 @@ bool mysqld_help(THD *thd, const char *mask)
{ {
Field *topic_cat_id= used_fields[help_topic_help_category_id].field; Field *topic_cat_id= used_fields[help_topic_help_category_id].field;
Item *cond_topic_by_cat= Item *cond_topic_by_cat=
new Item_func_equal(thd, new Item_field(thd, topic_cat_id), new (mem_root)
new Item_int(thd, (int32) category_id)); Item_func_equal(thd,
new (mem_root)
Item_field(thd, topic_cat_id),
new (mem_root)
Item_int(thd, (int32) category_id));
Item *cond_cat_by_cat= Item *cond_cat_by_cat=
new Item_func_equal(thd, new Item_field(thd, cat_cat_id), new (mem_root)
new Item_int(thd, (int32) category_id)); Item_func_equal(thd,
new (mem_root) Item_field(thd, cat_cat_id),
new (mem_root) Item_int(thd, (int32) category_id));
if (!(select= prepare_simple_select(thd, cond_topic_by_cat, if (!(select= prepare_simple_select(thd, cond_topic_by_cat,
tables[0].table, &error))) tables[0].table, &error)))
goto error; goto error;

2
sql/sql_join_cache.cc
View File

@ -318,7 +318,7 @@ void JOIN_CACHE::collect_info_on_key_args()
The allocated arrays are adjacent. The allocated arrays are adjacent.
NOTES NOTES
The memory is allocated in join->thd->memroot The memory is allocated in join->thd->mem_root
RETURN VALUE RETURN VALUE
pointer to the first array pointer to the first array

29
sql/sql_parse.cc
View File

@ -2672,6 +2672,7 @@ mysql_execute_command(THD *thd)
if (lex->set_arena_for_set_stmt(&backup)) if (lex->set_arena_for_set_stmt(&backup))
goto error; goto error;
MEM_ROOT *mem_root= thd->mem_root;
while ((var= it++)) while ((var= it++))
{ {
DBUG_ASSERT(var->is_system()); DBUG_ASSERT(var->is_system());
@ -2699,8 +2700,8 @@ mysql_execute_command(THD *thd)
longlong val= v->var->val_int(&null_value, thd, v->type, &v->base); longlong val= v->var->val_int(&null_value, thd, v->type, &v->base);
o= new set_var(thd, v->type, v->var, &v->base, o= new set_var(thd, v->type, v->var, &v->base,
(null_value ? (null_value ?
(Item *) new Item_null(thd) : (Item *) new (mem_root) Item_null(thd) :
(Item *) new Item_int(thd, val))); (Item *) new (mem_root) Item_int(thd, val)));
} }
break; break;
case GET_UINT: case GET_UINT:
@ -2711,8 +2712,8 @@ mysql_execute_command(THD *thd)
ulonglong val= v->var->val_int(&null_value, thd, v->type, &v->base); ulonglong val= v->var->val_int(&null_value, thd, v->type, &v->base);
o= new set_var(thd, v->type, v->var, &v->base, o= new set_var(thd, v->type, v->var, &v->base,
(null_value ? (null_value ?
(Item *) new Item_null(thd) : (Item *) new (mem_root) Item_null(thd) :
(Item *) new Item_uint(thd, val))); (Item *) new (mem_root) Item_uint(thd, val)));
} }
break; break;
case GET_DOUBLE: case GET_DOUBLE:
@ -2721,8 +2722,8 @@ mysql_execute_command(THD *thd)
double val= v->var->val_real(&null_value, thd, v->type, &v->base); double val= v->var->val_real(&null_value, thd, v->type, &v->base);
o= new set_var(thd, v->type, v->var, &v->base, o= new set_var(thd, v->type, v->var, &v->base,
(null_value ? (null_value ?
(Item *) new Item_null(thd) : (Item *) new (mem_root) Item_null(thd) :
(Item *) new Item_float(thd, val, 1))); (Item *) new (mem_root) Item_float(thd, val, 1)));
} }
break; break;
default: default:
@ -2741,13 +2742,13 @@ mysql_execute_command(THD *thd)
val= v->var->val_str(&tmp, thd, v->type, &v->base); val= v->var->val_str(&tmp, thd, v->type, &v->base);
if (val) if (val)
{ {
Item_string *str= new Item_string(thd, v->var->charset(thd), Item_string *str= new (mem_root) Item_string(thd, v->var->charset(thd),
val->ptr(), val->length()); val->ptr(), val->length());
o= new set_var(thd, v->type, v->var, &v->base, str); o= new set_var(thd, v->type, v->var, &v->base, str);
} }
else else
o= new set_var(thd, v->type, v->var, &v->base, o= new set_var(thd, v->type, v->var, &v->base,
new Item_null(thd)); new (mem_root) Item_null(thd));
} }
break; break;
} }
@ -3003,7 +3004,7 @@ mysql_execute_command(THD *thd)
my_error(ER_WRONG_ARGUMENTS, MYF(0), "PURGE LOGS BEFORE"); my_error(ER_WRONG_ARGUMENTS, MYF(0), "PURGE LOGS BEFORE");
goto error; goto error;
} }
it= new Item_func_unix_timestamp(thd, it); it= new (thd->mem_root) Item_func_unix_timestamp(thd, it);
it->fix_fields(thd, &it); it->fix_fields(thd, &it);
res = purge_master_logs_before_date(thd, (ulong)it->val_int()); res = purge_master_logs_before_date(thd, (ulong)it->val_int());
break; break;
@ -4088,7 +4089,7 @@ end_with_restore_list:
/* condition will be TRUE on SP re-excuting */ /* condition will be TRUE on SP re-excuting */
if (select_lex->item_list.elements != 0) if (select_lex->item_list.elements != 0)
select_lex->item_list.empty(); select_lex->item_list.empty();
if (add_item_to_list(thd, new Item_null(thd))) if (add_item_to_list(thd, new (thd->mem_root) Item_null(thd)))
goto error; goto error;
THD_STAGE_INFO(thd, stage_init); THD_STAGE_INFO(thd, stage_init);
@ -7876,7 +7877,7 @@ Item *normalize_cond(THD *thd, Item *cond)
Item::Type type= cond->type(); Item::Type type= cond->type();
if (type == Item::FIELD_ITEM || type == Item::REF_ITEM) if (type == Item::FIELD_ITEM || type == Item::REF_ITEM)
{ {
cond= new Item_func_ne(thd, cond, new Item_int(thd, 0)); cond= new (thd->mem_root) Item_func_ne(thd, cond, new (thd->mem_root) Item_int(thd, 0));
} }
} }
return cond; return cond;
@ -7911,7 +7912,7 @@ void add_join_on(THD *thd, TABLE_LIST *b, Item *expr)
right and left join. If called later, it happens if we add more right and left join. If called later, it happens if we add more
than one condition to the ON clause. than one condition to the ON clause.
*/ */
b->on_expr= new Item_cond_and(thd, b->on_expr,expr); b->on_expr= new (thd->mem_root) Item_cond_and(thd, b->on_expr,expr);
} }
b->on_expr->top_level_item(); b->on_expr->top_level_item();
} }
@ -8819,12 +8820,12 @@ Item *negate_expression(THD *thd, Item *expr)
if it is not boolean function then we have to emulate value of if it is not boolean function then we have to emulate value of
not(not(a)), it will be a != 0 not(not(a)), it will be a != 0
*/ */
return new Item_func_ne(thd, arg, new Item_int(thd, (char*) "0", 0, 1)); return new (thd->mem_root) Item_func_ne(thd, arg, new (thd->mem_root) Item_int(thd, (char*) "0", 0, 1));
} }
if ((negated= expr->neg_transformer(thd)) != 0) if ((negated= expr->neg_transformer(thd)) != 0)
return negated; return negated;
return new Item_func_not(thd, expr); return new (thd->mem_root) Item_func_not(thd, expr);
} }
/** /**

11
sql/sql_prepare.cc
View File

@ -1897,14 +1897,17 @@ static bool mysql_test_multiupdate(Prepared_statement *stmt,
static bool mysql_test_multidelete(Prepared_statement *stmt, static bool mysql_test_multidelete(Prepared_statement *stmt,
TABLE_LIST *tables) TABLE_LIST *tables)
{ {
stmt->thd->lex->current_select= &stmt->thd->lex->select_lex; THD *thd= stmt->thd;
if (add_item_to_list(stmt->thd, new Item_null(stmt->thd)))
thd->lex->current_select= &thd->lex->select_lex;
if (add_item_to_list(thd, new (thd->mem_root)
Item_null(thd)))
{ {
my_error(ER_OUTOFMEMORY, MYF(ME_FATALERROR), 0); my_error(ER_OUTOFMEMORY, MYF(ME_FATALERROR), 0);
goto error; goto error;
} }
if (multi_delete_precheck(stmt->thd, tables) || if (multi_delete_precheck(thd, tables) ||
select_like_stmt_test_with_open(stmt, tables, select_like_stmt_test_with_open(stmt, tables,
&mysql_multi_delete_prepare, &mysql_multi_delete_prepare,
OPTION_SETUP_TABLES_DONE)) OPTION_SETUP_TABLES_DONE))
@ -3369,7 +3372,7 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
/* /*
alloc_query() uses thd->memroot && thd->query, so we should call alloc_query() uses thd->mem_root && thd->query, so we should call
both of backup_statement() and backup_query_arena() here. both of backup_statement() and backup_query_arena() here.
*/ */
thd->set_n_backup_statement(this, &stmt_backup); thd->set_n_backup_statement(this, &stmt_backup);

9
sql/sql_profile.cc
View File

@ -121,7 +121,7 @@ int make_profile_table_for_show(THD *thd, ST_SCHEMA_TABLE *schema_table)
continue; continue;
field_info= &schema_table->fields_info[i]; field_info= &schema_table->fields_info[i];
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
NullS, NullS, field_info->field_name); NullS, NullS, field_info->field_name);
if (field) if (field)
{ {
@ -389,13 +389,14 @@ bool PROFILING::show_profiles()
DBUG_ENTER("PROFILING::show_profiles"); DBUG_ENTER("PROFILING::show_profiles");
QUERY_PROFILE *prof; QUERY_PROFILE *prof;
List<Item> field_list; List<Item> field_list;
MEM_ROOT *mem_root= thd->mem_root;
field_list.push_back(new Item_return_int(thd, "Query_ID", 10, field_list.push_back(new (mem_root) Item_return_int(thd, "Query_ID", 10,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field_list.push_back(new Item_return_int(thd, "Duration", field_list.push_back(new (mem_root) Item_return_int(thd, "Duration",
TIME_FLOAT_DIGITS - 1, TIME_FLOAT_DIGITS - 1,
MYSQL_TYPE_DOUBLE)); MYSQL_TYPE_DOUBLE));
field_list.push_back(new Item_empty_string(thd, "Query", 40)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Query", 40));
if (thd->protocol->send_result_set_metadata(&field_list, if (thd->protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

17
sql/sql_repl.cc
View File

@ -4000,13 +4000,15 @@ err:
bool show_binlog_info(THD* thd) bool show_binlog_info(THD* thd)
{ {
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("show_binlog_info"); DBUG_ENTER("show_binlog_info");
List<Item> field_list; List<Item> field_list;
field_list.push_back(new Item_empty_string(thd, "File", FN_REFLEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "File", FN_REFLEN));
field_list.push_back(new Item_return_int(thd, "Position", 20, field_list.push_back(new (mem_root) Item_return_int(thd, "Position", 20,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
field_list.push_back(new Item_empty_string(thd, "Binlog_Do_DB", 255)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Binlog_Do_DB", 255));
field_list.push_back(new Item_empty_string(thd, "Binlog_Ignore_DB", 255)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Binlog_Ignore_DB", 255));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -4049,6 +4051,7 @@ bool show_binlogs(THD* thd)
uint length; uint length;
int cur_dir_len; int cur_dir_len;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("show_binlogs"); DBUG_ENTER("show_binlogs");
if (!mysql_bin_log.is_open()) if (!mysql_bin_log.is_open())
@ -4057,9 +4060,9 @@ bool show_binlogs(THD* thd)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
field_list.push_back(new Item_empty_string(thd, "Log_name", 255)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Log_name", 255));
field_list.push_back(new Item_return_int(thd, "File_size", 20, field_list.push_back(new (mem_root) Item_return_int(thd, "File_size", 20,
MYSQL_TYPE_LONGLONG)); MYSQL_TYPE_LONGLONG));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);

107
sql/sql_select.cc
View File

@ -512,9 +512,9 @@ fix_inner_refs(THD *thd, List<Item> &all_fields, SELECT_LEX *select,
direct_ref= TRUE; direct_ref= TRUE;
new_ref= direct_ref ? new_ref= direct_ref ?
new Item_direct_ref(thd, ref->context, item_ref, ref->table_name, new (thd->mem_root) Item_direct_ref(thd, ref->context, item_ref, ref->table_name,
ref->field_name, ref->alias_name_used) : ref->field_name, ref->alias_name_used) :
new Item_ref(thd, ref->context, item_ref, ref->table_name, new (thd->mem_root) Item_ref(thd, ref->context, item_ref, ref->table_name,
ref->field_name, ref->alias_name_used); ref->field_name, ref->alias_name_used);
if (!new_ref) if (!new_ref)
return TRUE; return TRUE;
@ -892,7 +892,7 @@ JOIN::prepare(Item ***rref_pointer_array,
if ((*ord->item)->type() == Item::FIELD_ITEM && if ((*ord->item)->type() == Item::FIELD_ITEM &&
(*ord->item)->field_type() == MYSQL_TYPE_BIT) (*ord->item)->field_type() == MYSQL_TYPE_BIT)
{ {
Item_field *field= new Item_field(thd, *(Item_field**)ord->item); Item_field *field= new (thd->mem_root) Item_field(thd, *(Item_field**)ord->item);
int el= all_fields.elements; int el= all_fields.elements;
ref_pointer_array[el]= field; ref_pointer_array[el]= field;
all_fields.push_front(field); all_fields.push_front(field);
@ -1150,7 +1150,7 @@ TODO: make view to decide if it is possible to write to WHERE directly or make S
conds= having; conds= having;
having= 0; having= 0;
} }
else if ((conds=new Item_cond_and(conds,having))) else if ((conds=new (thd->mem_root) Item_cond_and(conds,having)))
{ {
/* /*
Item_cond_and can't be fixed after creation, so we do not check Item_cond_and can't be fixed after creation, so we do not check
@ -1408,7 +1408,7 @@ TODO: make view to decide if it is possible to write to WHERE directly or make S
if (!conds && outer_join) if (!conds && outer_join)
{ {
/* Handle the case where we have an OUTER JOIN without a WHERE */ /* Handle the case where we have an OUTER JOIN without a WHERE */
conds= new Item_int(thd, (longlong) 1,1); // Always true conds= new (thd->mem_root) Item_int(thd, (longlong) 1,1); // Always true
} }
if (impossible_where) if (impossible_where)
@ -1544,7 +1544,7 @@ TODO: make view to decide if it is possible to write to WHERE directly or make S
if (conds && const_table_map != found_const_table_map && if (conds && const_table_map != found_const_table_map &&
(select_options & SELECT_DESCRIBE)) (select_options & SELECT_DESCRIBE))
{ {
conds=new Item_int(thd, (longlong) 0, 1); // Always false conds=new (thd->mem_root) Item_int(thd, (longlong) 0, 1); // Always false
} }
/* Cache constant expressions in WHERE, HAVING, ON clauses. */ /* Cache constant expressions in WHERE, HAVING, ON clauses. */
@ -2976,7 +2976,7 @@ void JOIN::exec_inner()
else else
{ {
if (!(curr_table->select->cond= if (!(curr_table->select->cond=
new Item_cond_and(thd, curr_table->select->cond, new (thd->mem_root) Item_cond_and(thd, curr_table->select->cond,
sort_table_cond))) sort_table_cond)))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -2985,7 +2985,7 @@ void JOIN::exec_inner()
if (sort_table_cond->type() == Item::COND_ITEM) if (sort_table_cond->type() == Item::COND_ITEM)
sort_table_cond= sort_table_cond->copy_andor_structure(thd); sort_table_cond= sort_table_cond->copy_andor_structure(thd);
if (!(curr_table->pre_idx_push_select_cond= if (!(curr_table->pre_idx_push_select_cond=
new Item_cond_and(thd, curr_table->pre_idx_push_select_cond, new (thd->mem_root) Item_cond_and(thd, curr_table->pre_idx_push_select_cond,
sort_table_cond))) sort_table_cond)))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -3888,7 +3888,7 @@ make_join_statistics(JOIN *join, List<TABLE_LIST> &tables_list,
if (join->cond_value == Item::COND_FALSE) if (join->cond_value == Item::COND_FALSE)
{ {
join->impossible_where= true; join->impossible_where= true;
conds= new Item_int(join->thd, (longlong) 0, 1); conds= new (join->thd->mem_root) Item_int(join->thd, (longlong) 0, 1);
} }
join->cond_equal= NULL; join->cond_equal= NULL;
@ -4838,7 +4838,7 @@ Item_func_null_predicate::add_key_fields(JOIN *join, KEY_FIELD **key_fields,
/* column_name IS [NOT] NULL */ /* column_name IS [NOT] NULL */
if (is_local_field(args[0]) && !(used_tables() & OUTER_REF_TABLE_BIT)) if (is_local_field(args[0]) && !(used_tables() & OUTER_REF_TABLE_BIT))
{ {
Item *tmp= new Item_null(join->thd); Item *tmp= new (join->thd->mem_root) Item_null(join->thd);
if (unlikely(!tmp)) // Should never be true if (unlikely(!tmp)) // Should never be true
return; return;
add_key_equal_fields(join, key_fields, *and_level, this, add_key_equal_fields(join, key_fields, *and_level, this,
@ -9156,7 +9156,7 @@ inline void add_cond_and_fix(THD *thd, Item **e1, Item *e2)
if (!e2) if (!e2)
return; return;
Item *res; Item *res;
if ((res= new Item_cond_and(thd, *e1, e2))) if ((res= new (thd->mem_root) Item_cond_and(thd, *e1, e2)))
{ {
res->fix_fields(thd, 0); res->fix_fields(thd, 0);
res->update_used_tables(); res->update_used_tables();
@ -9257,7 +9257,8 @@ static void add_not_null_conds(JOIN *join)
*/ */
if (!referred_tab) if (!referred_tab)
continue; continue;
if (!(notnull= new Item_func_isnotnull(join->thd, not_null_item))) if (!(notnull= new (join->thd->mem_root)
Item_func_isnotnull(join->thd, not_null_item)))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
/* /*
We need to do full fix_fields() call here in order to have correct We need to do full fix_fields() call here in order to have correct
@ -9321,7 +9322,7 @@ add_found_match_trig_cond(THD *thd, JOIN_TAB *tab, COND *cond,
if (tab == root_tab) if (tab == root_tab)
return cond; return cond;
if ((tmp= add_found_match_trig_cond(thd, tab->first_upper, cond, root_tab))) if ((tmp= add_found_match_trig_cond(thd, tab->first_upper, cond, root_tab)))
tmp= new Item_func_trig_cond(thd, tmp, &tab->found); tmp= new (thd->mem_root) Item_func_trig_cond(thd, tmp, &tab->found);
if (tmp) if (tmp)
{ {
tmp->quick_fix_field(); tmp->quick_fix_field();
@ -9673,7 +9674,7 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
below to check if we should use 'quick' instead. below to check if we should use 'quick' instead.
*/ */
DBUG_PRINT("info", ("Item_int")); DBUG_PRINT("info", ("Item_int"));
tmp= new Item_int(thd, (longlong) 1, 1); // Always true tmp= new (thd->mem_root) Item_int(thd, (longlong) 1, 1); // Always true
} }
} }
@ -9906,13 +9907,13 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
(table_map) 0, -1, FALSE, FALSE); (table_map) 0, -1, FALSE, FALSE);
if (!tmp_cond) if (!tmp_cond)
continue; continue;
tmp_cond= new Item_func_trig_cond(thd, tmp_cond, tmp_cond= new (thd->mem_root) Item_func_trig_cond(thd, tmp_cond,
&cond_tab->not_null_compl); &cond_tab->not_null_compl);
if (!tmp_cond) if (!tmp_cond)
DBUG_RETURN(1); DBUG_RETURN(1);
tmp_cond->quick_fix_field(); tmp_cond->quick_fix_field();
cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond : cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :
new Item_cond_and(thd, cond_tab->select_cond, new (thd->mem_root) Item_cond_and(thd, cond_tab->select_cond,
tmp_cond); tmp_cond);
if (!cond_tab->select_cond) if (!cond_tab->select_cond)
DBUG_RETURN(1); DBUG_RETURN(1);
@ -10013,7 +10014,7 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
the null complemented row. the null complemented row.
*/ */
DBUG_PRINT("info", ("Item_func_trig_cond")); DBUG_PRINT("info", ("Item_func_trig_cond"));
tmp_cond= new Item_func_trig_cond(thd, tmp_cond, tmp_cond= new (thd->mem_root) Item_func_trig_cond(thd, tmp_cond,
&first_inner_tab-> &first_inner_tab->
not_null_compl); not_null_compl);
DBUG_PRINT("info", ("Item_func_trig_cond 0x%lx", DBUG_PRINT("info", ("Item_func_trig_cond 0x%lx",
@ -10024,7 +10025,7 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
DBUG_PRINT("info", ("Item_cond_and")); DBUG_PRINT("info", ("Item_cond_and"));
*sel_cond_ref= !(*sel_cond_ref) ? *sel_cond_ref= !(*sel_cond_ref) ?
tmp_cond : tmp_cond :
new Item_cond_and(thd, *sel_cond_ref, tmp_cond); new (thd->mem_root) Item_cond_and(thd, *sel_cond_ref, tmp_cond);
DBUG_PRINT("info", ("Item_cond_and 0x%lx", DBUG_PRINT("info", ("Item_cond_and 0x%lx",
(ulong)(*sel_cond_ref))); (ulong)(*sel_cond_ref)));
if (!(*sel_cond_ref)) if (!(*sel_cond_ref))
@ -11012,7 +11013,8 @@ void JOIN_TAB::remove_redundant_bnl_scan_conds()
{ {
List_iterator<Item> pushed_cond_li(*((Item_cond*) select_cond)->argument_list()); List_iterator<Item> pushed_cond_li(*((Item_cond*) select_cond)->argument_list());
Item *pushed_item; Item *pushed_item;
Item_cond_and *reduced_select_cond= new Item_cond_and(join->thd); Item_cond_and *reduced_select_cond= new (join->thd->mem_root)
Item_cond_and(join->thd);
if (is_cond_and(cache_select->cond)) if (is_cond_and(cache_select->cond))
{ {
@ -12739,7 +12741,7 @@ static bool check_row_equality(THD *thd, Item *left_row, Item_row *right_row,
if (!is_converted) if (!is_converted)
{ {
Item_func_eq *eq_item; Item_func_eq *eq_item;
if (!(eq_item= new Item_func_eq(thd, left_item, right_item)) || if (!(eq_item= new (thd->mem_root) Item_func_eq(thd, left_item, right_item)) ||
eq_item->set_cmp_func_and_arg_cmp_context()) eq_item->set_cmp_func_and_arg_cmp_context())
return FALSE; return FALSE;
eq_item->quick_fix_field(); eq_item->quick_fix_field();
@ -13039,7 +13041,7 @@ COND *Item_func_eq::build_equal_items(THD *thd,
Here a new AND level must be created. It can happen only Here a new AND level must be created. It can happen only
when a row equality is processed as a standalone predicate. when a row equality is processed as a standalone predicate.
*/ */
Item_cond_and *and_cond= new Item_cond_and(thd, eq_list); Item_cond_and *and_cond= new (thd->mem_root) Item_cond_and(thd, eq_list);
and_cond->quick_fix_field(); and_cond->quick_fix_field();
List<Item> *cond_args= and_cond->argument_list(); List<Item> *cond_args= and_cond->argument_list();
List_iterator_fast<Item_equal> it(cond_equal.current_level); List_iterator_fast<Item_equal> it(cond_equal.current_level);
@ -13398,7 +13400,7 @@ Item *eliminate_item_equal(THD *thd, COND *cond, COND_EQUAL *upper_levels,
List<Item> eq_list; List<Item> eq_list;
Item_func_eq *eq_item= 0; Item_func_eq *eq_item= 0;
if (((Item *) item_equal)->const_item() && !item_equal->val_int()) if (((Item *) item_equal)->const_item() && !item_equal->val_int())
return new Item_int(thd, (longlong) 0, 1); return new (thd->mem_root) Item_int(thd, (longlong) 0, 1);
Item *item_const= item_equal->get_const(); Item *item_const= item_equal->get_const();
Item_equal_fields_iterator it(*item_equal); Item_equal_fields_iterator it(*item_equal);
Item *head; Item *head;
@ -13463,7 +13465,7 @@ Item *eliminate_item_equal(THD *thd, COND *cond, COND_EQUAL *upper_levels,
Upper item also has "field_item=const". Upper item also has "field_item=const".
Don't produce equality if const is equal to item_const. Don't produce equality if const is equal to item_const.
*/ */
Item_func_eq *func= new Item_func_eq(thd, item_const, upper_const); Item_func_eq *func= new (thd->mem_root) Item_func_eq(thd, item_const, upper_const);
func->set_cmp_func(); func->set_cmp_func();
func->quick_fix_field(); func->quick_fix_field();
if (func->val_int()) if (func->val_int())
@ -13512,7 +13514,7 @@ Item *eliminate_item_equal(THD *thd, COND *cond, COND_EQUAL *upper_levels,
if (head_real_item->type() == Item::FIELD_ITEM) if (head_real_item->type() == Item::FIELD_ITEM)
head_item= head_real_item; head_item= head_real_item;
eq_item= new Item_func_eq(thd, field_item->real_item(), head_item); eq_item= new (thd->mem_root) Item_func_eq(thd, field_item->real_item(), head_item);
if (!eq_item || eq_item->set_cmp_func()) if (!eq_item || eq_item->set_cmp_func())
return 0; return 0;
@ -13545,7 +13547,7 @@ Item *eliminate_item_equal(THD *thd, COND *cond, COND_EQUAL *upper_levels,
switch (eq_list.elements) switch (eq_list.elements)
{ {
case 0: case 0:
res= cond ? cond : new Item_int(thd, (longlong) 1, 1); res= cond ? cond : new (thd->mem_root) Item_int(thd, (longlong) 1, 1);
break; break;
case 1: case 1:
if (!cond || cond->type() == Item::INT_ITEM) if (!cond || cond->type() == Item::INT_ITEM)
@ -13568,7 +13570,7 @@ Item *eliminate_item_equal(THD *thd, COND *cond, COND_EQUAL *upper_levels,
} }
} }
if (!res) if (!res)
res= new Item_cond_and(thd, eq_list); res= new (thd->mem_root) Item_cond_and(thd, eq_list);
if (res) if (res)
{ {
res->quick_fix_field(); res->quick_fix_field();
@ -15405,8 +15407,8 @@ Item_func_isnull::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
query_cache_abort(&thd->query_cache_tls); query_cache_abort(&thd->query_cache_tls);
#endif #endif
COND *new_cond, *cond= this; COND *new_cond, *cond= this;
if ((new_cond= new Item_func_eq(thd, args[0], if ((new_cond= new (thd->mem_root) Item_func_eq(thd, args[0],
new Item_int(thd, "last_insert_id()", new (thd->mem_root) Item_int(thd, "last_insert_id()",
thd->read_first_successful_insert_id_in_prev_stmt(), thd->read_first_successful_insert_id_in_prev_stmt(),
MY_INT64_NUM_DECIMAL_DIGITS)))) MY_INT64_NUM_DECIMAL_DIGITS))))
{ {
@ -16265,7 +16267,7 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
string_total_length+= new_field->pack_length(); string_total_length+= new_field->pack_length();
} }
thd->mem_root= mem_root_save; thd->mem_root= mem_root_save;
arg= sum_item->set_arg(i, thd, new Item_field(thd, new_field)); arg= sum_item->set_arg(i, thd, new (thd->mem_root) Item_field(thd, new_field));
thd->mem_root= &table->mem_root; thd->mem_root= &table->mem_root;
if (param->force_not_null_cols) if (param->force_not_null_cols)
{ {
@ -19849,7 +19851,7 @@ make_cond_for_table_from_pred(THD *thd, Item *root_cond, Item *cond,
if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC) if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
{ {
/* Create new top level AND item */ /* Create new top level AND item */
Item_cond_and *new_cond=new Item_cond_and(thd); Item_cond_and *new_cond=new (thd->mem_root) Item_cond_and(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; // OOM /* purecov: inspected */ return (COND*) 0; // OOM /* purecov: inspected */
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -19884,7 +19886,7 @@ make_cond_for_table_from_pred(THD *thd, Item *root_cond, Item *cond,
} }
else else
{ // Or list { // Or list
Item_cond_or *new_cond=new Item_cond_or(thd); Item_cond_or *new_cond=new (thd->mem_root) Item_cond_or(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; // OOM /* purecov: inspected */ return (COND*) 0; // OOM /* purecov: inspected */
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -19979,7 +19981,7 @@ make_cond_after_sjm(THD *thd, Item *root_cond, Item *cond, table_map tables,
if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC) if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
{ {
/* Create new top level AND item */ /* Create new top level AND item */
Item_cond_and *new_cond= new Item_cond_and(thd); Item_cond_and *new_cond= new (thd->mem_root) Item_cond_and(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; // OOM /* purecov: inspected */ return (COND*) 0; // OOM /* purecov: inspected */
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -20010,7 +20012,7 @@ make_cond_after_sjm(THD *thd, Item *root_cond, Item *cond, table_map tables,
} }
else else
{ // Or list { // Or list
Item_cond_or *new_cond= new Item_cond_or(thd); Item_cond_or *new_cond= new (thd->mem_root) Item_cond_or(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; // OOM /* purecov: inspected */ return (COND*) 0; // OOM /* purecov: inspected */
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -22035,7 +22037,7 @@ create_distinct_group(THD *thd, Item **ref_pointer_array,
converted to a LONG field. Original field will remain of the converted to a LONG field. Original field will remain of the
BIT type and will be returned to a client. BIT type and will be returned to a client.
*/ */
Item_field *new_item= new Item_field(thd, (Item_field*)item); Item_field *new_item= new (thd->mem_root) Item_field(thd, (Item_field*)item);
int el= all_fields.elements; int el= all_fields.elements;
orig_ref_pointer_array[el]= new_item; orig_ref_pointer_array[el]= new_item;
all_fields.push_front(new_item); all_fields.push_front(new_item);
@ -22445,7 +22447,7 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
((Item_ref *)pos)->ref_type() == Item_ref::AGGREGATE_REF)) ((Item_ref *)pos)->ref_type() == Item_ref::AGGREGATE_REF))
{ {
Item_field *item; Item_field *item;
if (!(item= new Item_field(thd, ((Item_field*) real_pos)))) if (!(item= new (thd->mem_root) Item_field(thd, ((Item_field*) real_pos))))
goto err; goto err;
if (pos->type() == Item::REF_ITEM) if (pos->type() == Item::REF_ITEM)
{ {
@ -22458,7 +22460,7 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
pos= item; pos= item;
if (item->field->flags & BLOB_FLAG) if (item->field->flags & BLOB_FLAG)
{ {
if (!(pos= new Item_copy_string(thd, pos))) if (!(pos= new (thd->mem_root) Item_copy_string(thd, pos)))
goto err; goto err;
/* /*
Item_copy_string::copy for function can call Item_copy_string::copy for function can call
@ -22513,7 +22515,7 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
on how the value is to be used: In some cases this may be an on how the value is to be used: In some cases this may be an
argument in a group function, like: IF(ISNULL(col),0,COUNT(*)) argument in a group function, like: IF(ISNULL(col),0,COUNT(*))
*/ */
if (!(pos=new Item_copy_string(thd, pos))) if (!(pos=new (thd->mem_root) Item_copy_string(thd, pos)))
goto err; goto err;
if (i < border) // HAVING, ORDER and GROUP BY if (i < border) // HAVING, ORDER and GROUP BY
{ {
@ -22726,8 +22728,8 @@ change_to_use_tmp_fields(THD *thd, Item **ref_pointer_array,
would access already-unlocked tables. would access already-unlocked tables.
*/ */
Item_func_set_user_var* suv= Item_func_set_user_var* suv=
new Item_func_set_user_var(thd, (Item_func_set_user_var*) item); new (thd->mem_root) Item_func_set_user_var(thd, (Item_func_set_user_var*) item);
Item_field *new_field= new Item_field(thd, field); Item_field *new_field= new (thd->mem_root) Item_field(thd, field);
if (!suv || !new_field) if (!suv || !new_field)
DBUG_RETURN(true); // Fatal error DBUG_RETURN(true); // Fatal error
/* /*
@ -22750,7 +22752,7 @@ change_to_use_tmp_fields(THD *thd, Item **ref_pointer_array,
if (item->type() == Item::SUM_FUNC_ITEM && field->table->group) if (item->type() == Item::SUM_FUNC_ITEM && field->table->group)
item_field= ((Item_sum*) item)->result_item(thd, field); item_field= ((Item_sum*) item)->result_item(thd, field);
else else
item_field= (Item *) new Item_field(thd, field); item_field= (Item *) new (thd->mem_root) Item_field(thd, field);
if (!item_field) if (!item_field)
DBUG_RETURN(true); // Fatal error DBUG_RETURN(true); // Fatal error
@ -22990,7 +22992,7 @@ static bool add_ref_to_table_cond(THD *thd, JOIN_TAB *join_tab)
if (!join_tab->ref.key_parts) if (!join_tab->ref.key_parts)
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
Item_cond_and *cond= new Item_cond_and(thd); Item_cond_and *cond= new (thd->mem_root) Item_cond_and(thd);
TABLE *table=join_tab->table; TABLE *table=join_tab->table;
int error= 0; int error= 0;
if (!cond) if (!cond)
@ -23001,7 +23003,7 @@ static bool add_ref_to_table_cond(THD *thd, JOIN_TAB *join_tab)
Field *field=table->field[table->key_info[join_tab->ref.key].key_part[i]. Field *field=table->field[table->key_info[join_tab->ref.key].key_part[i].
fieldnr-1]; fieldnr-1];
Item *value=join_tab->ref.items[i]; Item *value=join_tab->ref.items[i];
cond->add(new Item_func_equal(thd, new Item_field(thd, field), value)); cond->add(new (thd->mem_root) Item_func_equal(thd, new (thd->mem_root) Item_field(thd, field), value));
} }
if (thd->is_fatal_error) if (thd->is_fatal_error)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
@ -23118,7 +23120,7 @@ static bool change_group_ref(THD *thd, Item_func *expr, ORDER *group_list,
if (item->eq(*group_tmp->item,0)) if (item->eq(*group_tmp->item,0))
{ {
Item *new_item; Item *new_item;
if (!(new_item= new Item_ref(thd, context, group_tmp->item, 0, if (!(new_item= new (thd->mem_root) Item_ref(thd, context, group_tmp->item, 0,
item->name))) item->name)))
return 1; // fatal_error is set return 1; // fatal_error is set
thd->change_item_tree(arg, new_item); thd->change_item_tree(arg, new_item);
@ -23256,7 +23258,7 @@ bool JOIN::rollup_process_const_fields()
{ {
if (*group_tmp->item == item) if (*group_tmp->item == item)
{ {
Item* new_item= new Item_func_rollup_const(thd, item); Item* new_item= new (thd->mem_root) Item_func_rollup_const(thd, item);
if (!new_item) if (!new_item)
return 1; return 1;
new_item->fix_fields(thd, (Item **) 0); new_item->fix_fields(thd, (Item **) 0);
@ -23535,11 +23537,12 @@ int print_explain_message_line(select_result_sink *result,
const char *message) const char *message)
{ {
THD *thd= result->thd; THD *thd= result->thd;
Item *item_null= new Item_null(thd); MEM_ROOT *mem_root= thd->mem_root;
Item *item_null= new (mem_root) Item_null(thd);
List<Item> item_list; List<Item> item_list;
item_list.push_back(new Item_int(thd, (int32) select_number)); item_list.push_back(new (mem_root) Item_int(thd, (int32) select_number));
item_list.push_back(new Item_string_sys(thd, select_type)); item_list.push_back(new (mem_root) Item_string_sys(thd, select_type));
/* `table` */ /* `table` */
item_list.push_back(item_null); item_list.push_back(item_null);
@ -23554,7 +23557,7 @@ int print_explain_message_line(select_result_sink *result,
/* `rows` */ /* `rows` */
if (rows) if (rows)
{ {
item_list.push_back(new Item_int(thd, *rows, item_list.push_back(new (mem_root) Item_int(thd, *rows,
MY_INT64_NUM_DECIMAL_DIGITS)); MY_INT64_NUM_DECIMAL_DIGITS));
} }
else else
@ -23574,7 +23577,7 @@ int print_explain_message_line(select_result_sink *result,
/* `Extra` */ /* `Extra` */
if (message) if (message)
item_list.push_back(new Item_string_sys(thd, message)); item_list.push_back(new (mem_root) Item_string_sys(thd, message));
else else
item_list.push_back(item_null); item_list.push_back(item_null);
@ -23629,11 +23632,13 @@ void JOIN_TAB::update_explain_data(uint idx)
join->select_lex->select_number != INT_MAX && join->select_lex->select_number != INT_MAX &&
join->select_lex->select_number != UINT_MAX) join->select_lex->select_number != UINT_MAX)
{ {
Explain_table_access *eta= new (join->thd->mem_root) Explain_table_access(join->thd->mem_root); Explain_table_access *eta= new (join->thd->mem_root)
Explain_table_access(join->thd->mem_root);
save_explain_data(eta, join->const_table_map, join->select_distinct, save_explain_data(eta, join->const_table_map, join->select_distinct,
join->first_breadth_first_optimization_tab()); join->first_breadth_first_optimization_tab());
Explain_select *sel= join->thd->lex->explain->get_select(join->select_lex->select_number); Explain_select *sel= join->thd->lex->explain->
get_select(join->select_lex->select_number);
idx -= my_count_bits(join->eliminated_tables); idx -= my_count_bits(join->eliminated_tables);
sel->replace_table(idx, eta); sel->replace_table(idx, eta);
} }

2
sql/sql_select.h
View File

@ -1852,7 +1852,7 @@ int join_read_record_no_init(JOIN_TAB *tab);
void set_position(JOIN *join,uint idx,JOIN_TAB *table,KEYUSE *key); void set_position(JOIN *join,uint idx,JOIN_TAB *table,KEYUSE *key);
inline Item * and_items(THD *thd, Item* cond, Item *item) inline Item * and_items(THD *thd, Item* cond, Item *item)
{ {
return (cond ? (new Item_cond_and(thd, cond, item)) : item); return (cond ? (new (thd->mem_root) Item_cond_and(thd, cond, item)) : item);
} }
bool choose_plan(JOIN *join, table_map join_tables); bool choose_plan(JOIN *join, table_map join_tables);
void optimize_wo_join_buffering(JOIN *join, uint first_tab, uint last_tab, void optimize_wo_join_buffering(JOIN *join, uint first_tab, uint last_tab,

150
sql/sql_show.cc
View File

@ -451,11 +451,12 @@ bool mysqld_show_authors(THD *thd)
{ {
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_show_authors"); DBUG_ENTER("mysqld_show_authors");
field_list.push_back(new Item_empty_string(thd, "Name", 40)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Name", 40));
field_list.push_back(new Item_empty_string(thd, "Location", 40)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Location", 40));
field_list.push_back(new Item_empty_string(thd, "Comment", 512)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Comment", 512));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -485,11 +486,12 @@ bool mysqld_show_contributors(THD *thd)
{ {
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_show_contributors"); DBUG_ENTER("mysqld_show_contributors");
field_list.push_back(new Item_empty_string(thd, "Name", 40)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Name", 40));
field_list.push_back(new Item_empty_string(thd, "Location", 40)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Location", 40));
field_list.push_back(new Item_empty_string(thd, "Comment", 512)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Comment", 512));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -562,11 +564,12 @@ bool mysqld_show_privileges(THD *thd)
{ {
List<Item> field_list; List<Item> field_list;
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_show_privileges"); DBUG_ENTER("mysqld_show_privileges");
field_list.push_back(new Item_empty_string(thd, "Privilege", 10)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Privilege", 10));
field_list.push_back(new Item_empty_string(thd, "Context", 15)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Context", 15));
field_list.push_back(new Item_empty_string(thd, "Comment", NAME_CHAR_LEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Comment", NAME_CHAR_LEN));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -1092,6 +1095,7 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
String buffer(buff, sizeof(buff), system_charset_info); String buffer(buff, sizeof(buff), system_charset_info);
List<Item> field_list; List<Item> field_list;
bool error= TRUE; bool error= TRUE;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_show_create"); DBUG_ENTER("mysqld_show_create");
DBUG_PRINT("enter",("db: %s table: %s",table_list->db, DBUG_PRINT("enter",("db: %s table: %s",table_list->db,
table_list->table_name)); table_list->table_name));
@ -1144,19 +1148,19 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
if (table_list->view) if (table_list->view)
{ {
field_list.push_back(new Item_empty_string(thd, "View", NAME_CHAR_LEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "View", NAME_CHAR_LEN));
field_list.push_back(new Item_empty_string(thd, "Create View", field_list.push_back(new (mem_root) Item_empty_string(thd, "Create View",
MY_MAX(buffer.length(),1024))); MY_MAX(buffer.length(),1024)));
field_list.push_back(new Item_empty_string(thd, "character_set_client", field_list.push_back(new (mem_root) Item_empty_string(thd, "character_set_client",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
field_list.push_back(new Item_empty_string(thd, "collation_connection", field_list.push_back(new (mem_root) Item_empty_string(thd, "collation_connection",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
} }
else else
{ {
field_list.push_back(new Item_empty_string(thd, "Table", NAME_CHAR_LEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Table", NAME_CHAR_LEN));
// 1024 is for not to confuse old clients // 1024 is for not to confuse old clients
field_list.push_back(new Item_empty_string(thd, "Create Table", field_list.push_back(new (mem_root) Item_empty_string(thd, "Create Table",
MY_MAX(buffer.length(),1024))); MY_MAX(buffer.length(),1024)));
} }
@ -1215,6 +1219,7 @@ bool mysqld_show_create_db(THD *thd, LEX_STRING *dbname,
#endif #endif
Schema_specification_st create; Schema_specification_st create;
Protocol *protocol=thd->protocol; Protocol *protocol=thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysql_show_create_db"); DBUG_ENTER("mysql_show_create_db");
#ifndef NO_EMBEDDED_ACCESS_CHECKS #ifndef NO_EMBEDDED_ACCESS_CHECKS
@ -1249,8 +1254,8 @@ bool mysqld_show_create_db(THD *thd, LEX_STRING *dbname,
load_db_opt_by_name(thd, dbname->str, &create); load_db_opt_by_name(thd, dbname->str, &create);
} }
List<Item> field_list; List<Item> field_list;
field_list.push_back(new Item_empty_string(thd, "Database", NAME_CHAR_LEN)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Database", NAME_CHAR_LEN));
field_list.push_back(new Item_empty_string(thd, "Create Database", 1024)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Create Database", 1024));
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
@ -1295,6 +1300,7 @@ void
mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild) mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
{ {
TABLE *table; TABLE *table;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_list_fields"); DBUG_ENTER("mysqld_list_fields");
DBUG_PRINT("enter",("table: %s",table_list->table_name)); DBUG_PRINT("enter",("table: %s",table_list->table_name));
@ -1313,11 +1319,11 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
!wild_case_compare(system_charset_info, field->field_name,wild)) !wild_case_compare(system_charset_info, field->field_name,wild))
{ {
if (table_list->view) if (table_list->view)
field_list.push_back(new Item_ident_for_show(thd, field, field_list.push_back(new (mem_root) Item_ident_for_show(thd, field,
table_list->view_db.str, table_list->view_db.str,
table_list->view_name.str)); table_list->view_name.str));
else else
field_list.push_back(new Item_field(thd, field)); field_list.push_back(new (mem_root) Item_field(thd, field));
} }
} }
restore_record(table, s->default_values); // Get empty record restore_record(table, s->default_values); // Get empty record
@ -2341,28 +2347,29 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
ulong max_query_length= (verbose ? thd->variables.max_allowed_packet : ulong max_query_length= (verbose ? thd->variables.max_allowed_packet :
PROCESS_LIST_WIDTH); PROCESS_LIST_WIDTH);
Protocol *protocol= thd->protocol; Protocol *protocol= thd->protocol;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("mysqld_list_processes"); DBUG_ENTER("mysqld_list_processes");
field_list.push_back(new Item_int(thd, "Id", 0, MY_INT32_NUM_DECIMAL_DIGITS)); field_list.push_back(new (mem_root) Item_int(thd, "Id", 0, MY_INT32_NUM_DECIMAL_DIGITS));
field_list.push_back(new Item_empty_string(thd, "User", field_list.push_back(new (mem_root) Item_empty_string(thd, "User",
USERNAME_CHAR_LENGTH)); USERNAME_CHAR_LENGTH));
field_list.push_back(new Item_empty_string(thd, "Host", field_list.push_back(new (mem_root) Item_empty_string(thd, "Host",
LIST_PROCESS_HOST_LEN)); LIST_PROCESS_HOST_LEN));
field_list.push_back(field=new Item_empty_string(thd, "db", NAME_CHAR_LEN)); field_list.push_back(field=new (mem_root) Item_empty_string(thd, "db", NAME_CHAR_LEN));
field->maybe_null=1; field->maybe_null=1;
field_list.push_back(new Item_empty_string(thd, "Command", 16)); field_list.push_back(new (mem_root) Item_empty_string(thd, "Command", 16));
field_list.push_back(field= new Item_return_int(thd, "Time", 7, field_list.push_back(field= new (mem_root) Item_return_int(thd, "Time", 7,
MYSQL_TYPE_LONG)); MYSQL_TYPE_LONG));
field->unsigned_flag= 0; field->unsigned_flag= 0;
field_list.push_back(field=new Item_empty_string(thd, "State", 30)); field_list.push_back(field=new (mem_root) Item_empty_string(thd, "State", 30));
field->maybe_null=1; field->maybe_null=1;
field_list.push_back(field=new Item_empty_string(thd, "Info", field_list.push_back(field=new (mem_root) Item_empty_string(thd, "Info",
max_query_length)); max_query_length));
field->maybe_null=1; field->maybe_null=1;
if (!thd->variables.old_mode && if (!thd->variables.old_mode &&
!(thd->variables.old_behavior & OLD_MODE_NO_PROGRESS_INFO)) !(thd->variables.old_behavior & OLD_MODE_NO_PROGRESS_INFO))
{ {
field_list.push_back(field= new Item_float(thd, "Progress", 0.0, 3, 7)); field_list.push_back(field= new (mem_root) Item_float(thd, "Progress", 0.0, 3, 7));
field->maybe_null= 0; field->maybe_null= 0;
} }
if (protocol->send_result_set_metadata(&field_list, if (protocol->send_result_set_metadata(&field_list,
@ -3541,7 +3548,7 @@ COND *make_cond_for_info_schema(THD *thd, COND *cond, TABLE_LIST *table)
if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC) if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
{ {
/* Create new top level AND item */ /* Create new top level AND item */
Item_cond_and *new_cond=new Item_cond_and(thd); Item_cond_and *new_cond=new (thd->mem_root) Item_cond_and(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; return (COND*) 0;
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -3564,7 +3571,7 @@ COND *make_cond_for_info_schema(THD *thd, COND *cond, TABLE_LIST *table)
} }
else else
{ // Or list { // Or list
Item_cond_or *new_cond= new Item_cond_or(thd); Item_cond_or *new_cond= new (thd->mem_root) Item_cond_or(thd);
if (!new_cond) if (!new_cond)
return (COND*) 0; return (COND*) 0;
List_iterator<Item> li(*((Item_cond*) cond)->argument_list()); List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
@ -7317,6 +7324,7 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
ST_SCHEMA_TABLE *schema_table= table_list->schema_table; ST_SCHEMA_TABLE *schema_table= table_list->schema_table;
ST_FIELD_INFO *fields_info= schema_table->fields_info; ST_FIELD_INFO *fields_info= schema_table->fields_info;
CHARSET_INFO *cs= system_charset_info; CHARSET_INFO *cs= system_charset_info;
MEM_ROOT *mem_root= thd->mem_root;
DBUG_ENTER("create_schema_table"); DBUG_ENTER("create_schema_table");
for (; fields_info->field_name; fields_info++) for (; fields_info->field_name; fields_info++)
@ -7327,44 +7335,50 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
case MYSQL_TYPE_SHORT: case MYSQL_TYPE_SHORT:
case MYSQL_TYPE_LONGLONG: case MYSQL_TYPE_LONGLONG:
case MYSQL_TYPE_INT24: case MYSQL_TYPE_INT24:
if (!(item= new Item_return_int(thd, fields_info->field_name, if (!(item= new (mem_root)
fields_info->field_length, Item_return_int(thd, fields_info->field_name,
fields_info->field_type, fields_info->field_length,
fields_info->value))) fields_info->field_type,
fields_info->value)))
{ {
DBUG_RETURN(0); DBUG_RETURN(0);
} }
item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED); item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED);
break; break;
case MYSQL_TYPE_DATE: case MYSQL_TYPE_DATE:
if (!(item=new Item_return_date_time(thd, fields_info->field_name, if (!(item=new (mem_root)
strlen(fields_info->field_name), Item_return_date_time(thd, fields_info->field_name,
fields_info->field_type))) strlen(fields_info->field_name),
fields_info->field_type)))
DBUG_RETURN(0); DBUG_RETURN(0);
break; break;
case MYSQL_TYPE_TIME: case MYSQL_TYPE_TIME:
if (!(item=new Item_return_date_time(thd, fields_info->field_name, if (!(item=new (mem_root)
strlen(fields_info->field_name), Item_return_date_time(thd, fields_info->field_name,
fields_info->field_type))) strlen(fields_info->field_name),
fields_info->field_type)))
DBUG_RETURN(0); DBUG_RETURN(0);
break; break;
case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_TIMESTAMP:
case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_DATETIME:
if (!(item=new Item_return_date_time(thd, fields_info->field_name, if (!(item=new (mem_root)
strlen(fields_info->field_name), Item_return_date_time(thd, fields_info->field_name,
fields_info->field_type))) strlen(fields_info->field_name),
fields_info->field_type)))
DBUG_RETURN(0); DBUG_RETURN(0);
break; break;
case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_FLOAT:
case MYSQL_TYPE_DOUBLE: case MYSQL_TYPE_DOUBLE:
if ((item= new Item_float(thd, fields_info->field_name, 0.0, if ((item= new (mem_root)
NOT_FIXED_DEC, Item_float(thd, fields_info->field_name, 0.0,
fields_info->field_length)) == NULL) NOT_FIXED_DEC,
fields_info->field_length)) == NULL)
DBUG_RETURN(NULL); DBUG_RETURN(NULL);
break; break;
case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL: case MYSQL_TYPE_NEWDECIMAL:
if (!(item= new Item_decimal(thd, (longlong) fields_info->value, false))) if (!(item= new (mem_root)
Item_decimal(thd, (longlong) fields_info->value, false)))
{ {
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -7372,7 +7386,7 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
Create a type holder, as we want the type of the item to defined Create a type holder, as we want the type of the item to defined
the type of the object, not the value the type of the object, not the value
*/ */
if (!(item= new Item_type_holder(thd, item))) if (!(item= new (mem_root) Item_type_holder(thd, item)))
DBUG_RETURN(0); DBUG_RETURN(0);
item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED); item->unsigned_flag= (fields_info->field_flags & MY_I_S_UNSIGNED);
item->decimals= fields_info->field_length%10; item->decimals= fields_info->field_length%10;
@ -7388,8 +7402,9 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB: case MYSQL_TYPE_BLOB:
if (!(item= new Item_blob(thd, fields_info->field_name, if (!(item= new (mem_root)
fields_info->field_length))) Item_blob(thd, fields_info->field_name,
fields_info->field_length)))
{ {
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -7398,7 +7413,8 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
/* Don't let unimplemented types pass through. Could be a grave error. */ /* Don't let unimplemented types pass through. Could be a grave error. */
DBUG_ASSERT(fields_info->field_type == MYSQL_TYPE_STRING); DBUG_ASSERT(fields_info->field_type == MYSQL_TYPE_STRING);
if (!(item= new Item_empty_string(thd, "", fields_info->field_length, cs))) if (!(item= new (mem_root)
Item_empty_string(thd, "", fields_info->field_length, cs)))
{ {
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -7457,8 +7473,8 @@ static int make_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
{ {
if (field_info->old_name) if (field_info->old_name)
{ {
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root)
NullS, NullS, field_info->field_name); Item_field(thd, context, NullS, NullS, field_info->field_name);
if (field) if (field)
{ {
field->set_name(field_info->old_name, field->set_name(field_info->old_name,
@ -7484,7 +7500,7 @@ int make_schemata_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
{ {
ST_FIELD_INFO *field_info= &schema_table->fields_info[1]; ST_FIELD_INFO *field_info= &schema_table->fields_info[1];
String buffer(tmp,sizeof(tmp), system_charset_info); String buffer(tmp,sizeof(tmp), system_charset_info);
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
NullS, NullS, field_info->field_name); NullS, NullS, field_info->field_name);
if (!field || add_item_to_list(thd, field)) if (!field || add_item_to_list(thd, field))
return 1; return 1;
@ -7519,7 +7535,7 @@ int make_table_names_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
buffer.append(lex->wild->ptr()); buffer.append(lex->wild->ptr());
buffer.append(')'); buffer.append(')');
} }
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
NullS, NullS, field_info->field_name); NullS, NullS, field_info->field_name);
if (add_item_to_list(thd, field)) if (add_item_to_list(thd, field))
return 1; return 1;
@ -7528,7 +7544,7 @@ int make_table_names_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
{ {
field->set_name(buffer.ptr(), buffer.length(), system_charset_info); field->set_name(buffer.ptr(), buffer.length(), system_charset_info);
field_info= &schema_table->fields_info[3]; field_info= &schema_table->fields_info[3];
field= new Item_field(thd, context, NullS, NullS, field_info->field_name); field= new (thd->mem_root) Item_field(thd, context, NullS, NullS, field_info->field_name);
if (add_item_to_list(thd, field)) if (add_item_to_list(thd, field))
return 1; return 1;
field->set_name(field_info->old_name, strlen(field_info->old_name), field->set_name(field_info->old_name, strlen(field_info->old_name),
@ -7552,7 +7568,7 @@ int make_columns_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
*field_num == 18 || *field_num == 18 ||
*field_num == 19)) *field_num == 19))
continue; continue;
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
NullS, NullS, field_info->field_name); NullS, NullS, field_info->field_name);
if (field) if (field)
{ {
@ -7577,7 +7593,7 @@ int make_character_sets_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
for (; *field_num >= 0; field_num++) for (; *field_num >= 0; field_num++)
{ {
field_info= &schema_table->fields_info[*field_num]; field_info= &schema_table->fields_info[*field_num];
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
NullS, NullS, field_info->field_name); NullS, NullS, field_info->field_name);
if (field) if (field)
{ {
@ -7602,7 +7618,7 @@ int make_proc_old_format(THD *thd, ST_SCHEMA_TABLE *schema_table)
for (; *field_num >= 0; field_num++) for (; *field_num >= 0; field_num++)
{ {
field_info= &schema_table->fields_info[*field_num]; field_info= &schema_table->fields_info[*field_num];
Item_field *field= new Item_field(thd, context, Item_field *field= new (thd->mem_root) Item_field(thd, context,
NullS, NullS, field_info->field_name); NullS, NullS, field_info->field_name);
if (field) if (field)
{ {
@ -9113,10 +9129,8 @@ static bool show_create_trigger_impl(THD *thd,
int trigger_idx) int trigger_idx)
{ {
int ret_code; int ret_code;
Protocol *p= thd->protocol; Protocol *p= thd->protocol;
List<Item> fields; List<Item> fields;
LEX_STRING trg_name; LEX_STRING trg_name;
ulonglong trg_sql_mode; ulonglong trg_sql_mode;
LEX_STRING trg_sql_mode_str; LEX_STRING trg_sql_mode_str;
@ -9124,8 +9138,8 @@ static bool show_create_trigger_impl(THD *thd,
LEX_STRING trg_client_cs_name; LEX_STRING trg_client_cs_name;
LEX_STRING trg_connection_cl_name; LEX_STRING trg_connection_cl_name;
LEX_STRING trg_db_cl_name; LEX_STRING trg_db_cl_name;
CHARSET_INFO *trg_client_cs; CHARSET_INFO *trg_client_cs;
MEM_ROOT *mem_root= thd->mem_root;
/* /*
TODO: Check privileges here. This functionality will be added by TODO: Check privileges here. This functionality will be added by
@ -9157,8 +9171,8 @@ static bool show_create_trigger_impl(THD *thd,
/* Send header. */ /* Send header. */
fields.push_back(new Item_empty_string(thd, "Trigger", NAME_LEN)); fields.push_back(new (mem_root) Item_empty_string(thd, "Trigger", NAME_LEN));
fields.push_back(new Item_empty_string(thd, "sql_mode", fields.push_back(new (mem_root) Item_empty_string(thd, "sql_mode",
trg_sql_mode_str.length)); trg_sql_mode_str.length));
{ {
@ -9168,7 +9182,7 @@ static bool show_create_trigger_impl(THD *thd,
*/ */
Item_empty_string *stmt_fld= Item_empty_string *stmt_fld=
new Item_empty_string(thd, "SQL Original Statement", new (mem_root) Item_empty_string(thd, "SQL Original Statement",
MY_MAX(trg_sql_original_stmt.length, 1024)); MY_MAX(trg_sql_original_stmt.length, 1024));
stmt_fld->maybe_null= TRUE; stmt_fld->maybe_null= TRUE;
@ -9176,13 +9190,13 @@ static bool show_create_trigger_impl(THD *thd,
fields.push_back(stmt_fld); fields.push_back(stmt_fld);
} }
fields.push_back(new Item_empty_string(thd, "character_set_client", fields.push_back(new (mem_root) Item_empty_string(thd, "character_set_client",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
fields.push_back(new Item_empty_string(thd, "collation_connection", fields.push_back(new (mem_root) Item_empty_string(thd, "collation_connection",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
fields.push_back(new Item_empty_string(thd, "Database Collation", fields.push_back(new (mem_root) Item_empty_string(thd, "Database Collation",
MY_CS_NAME_SIZE)); MY_CS_NAME_SIZE));
if (p->send_result_set_metadata(&fields, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) if (p->send_result_set_metadata(&fields, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))

4
sql/sql_table.cc
View File

@ -9626,9 +9626,9 @@ bool mysql_checksum_table(THD *thd, TABLE_LIST *tables,
*/ */
DBUG_ASSERT(! thd->in_sub_stmt); DBUG_ASSERT(! thd->in_sub_stmt);
field_list.push_back(item = new Item_empty_string(thd, "Table", NAME_LEN*2)); field_list.push_back(item= new (thd->mem_root) Item_empty_string(thd, "Table", NAME_LEN*2));
item->maybe_null= 1; item->maybe_null= 1;
field_list.push_back(item= new Item_int(thd, "Checksum", field_list.push_back(item= new (thd->mem_root) Item_int(thd, "Checksum",
(longlong) 1, (longlong) 1,
MY_INT64_NUM_DECIMAL_DIGITS)); MY_INT64_NUM_DECIMAL_DIGITS));
item->maybe_null= 1; item->maybe_null= 1;

4
sql/sql_union.cc
View File

@ -342,6 +342,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
bool is_union_select; bool is_union_select;
bool instantiate_tmp_table= false; bool instantiate_tmp_table= false;
DBUG_ENTER("st_select_lex_unit::prepare"); DBUG_ENTER("st_select_lex_unit::prepare");
DBUG_ASSERT(thd == thd_arg && thd == current_thd);
describe= MY_TEST(additional_options & SELECT_DESCRIBE); describe= MY_TEST(additional_options & SELECT_DESCRIBE);
@ -484,7 +485,8 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
while ((item_tmp= it++)) while ((item_tmp= it++))
{ {
/* Error's in 'new' will be detected after loop */ /* Error's in 'new' will be detected after loop */
types.push_back(new Item_type_holder(thd_arg, item_tmp)); types.push_back(new (thd_arg->mem_root)
Item_type_holder(thd_arg, item_tmp));
} }
if (thd_arg->is_fatal_error) if (thd_arg->is_fatal_error)

4
sql/sql_update.cc
View File

@ -148,7 +148,7 @@ static bool check_fields(THD *thd, List<Item> &items)
we make temporary copy of Item_field, to avoid influence of changing we make temporary copy of Item_field, to avoid influence of changing
result_field on Item_ref which refer on this field result_field on Item_ref which refer on this field
*/ */
thd->change_item_tree(it.ref(), new Item_field(thd, field)); thd->change_item_tree(it.ref(), new (thd->mem_root) Item_field(thd, field));
} }
return FALSE; return FALSE;
} }
@ -1978,7 +1978,7 @@ loop_end:
table to be updated was created by mysql 4.1. Deny this. table to be updated was created by mysql 4.1. Deny this.
*/ */
field->can_alter_field_type= 0; field->can_alter_field_type= 0;
Item_field *ifield= new Item_field(join->thd, (Field *) field); Item_field *ifield= new (thd->mem_root) Item_field(join->thd, (Field *) field);
if (!ifield) if (!ifield)
DBUG_RETURN(1); DBUG_RETURN(1);
ifield->maybe_null= 0; ifield->maybe_null= 0;

170
sql/sql_yacc.yy
View File

@ -284,8 +284,9 @@ int case_stmt_action_expr(LEX *lex, Item* expr)
if (parsing_ctx->push_case_expr_id(case_expr_id)) if (parsing_ctx->push_case_expr_id(case_expr_id))
return 1; return 1;
i= new sp_instr_set_case_expr(sp->instructions(), i= new (lex->thd->mem_root)
parsing_ctx, case_expr_id, expr, lex); sp_instr_set_case_expr(sp->instructions(), parsing_ctx, case_expr_id, expr,
lex);
sp->add_cont_backpatch(i); sp->add_cont_backpatch(i);
return sp->add_instr(i); return sp->add_instr(i);
@ -307,10 +308,12 @@ int case_stmt_action_when(LEX *lex, Item *when, bool simple)
sp_instr_jump_if_not *i; sp_instr_jump_if_not *i;
Item_case_expr *var; Item_case_expr *var;
Item *expr; Item *expr;
THD *thd= lex->thd;
if (simple) if (simple)
{ {
var= new Item_case_expr(lex->thd, ctx->get_current_case_expr_id()); var= new (thd->mem_root)
Item_case_expr(thd, ctx->get_current_case_expr_id());
#ifndef DBUG_OFF #ifndef DBUG_OFF
if (var) if (var)
@ -319,11 +322,11 @@ int case_stmt_action_when(LEX *lex, Item *when, bool simple)
} }
#endif #endif
expr= new Item_func_eq(lex->thd, var, when); expr= new (thd->mem_root) Item_func_eq(thd, var, when);
i= new sp_instr_jump_if_not(ip, ctx, expr, lex); i= new (thd->mem_root) sp_instr_jump_if_not(ip, ctx, expr, lex);
} }
else else
i= new sp_instr_jump_if_not(ip, ctx, when, lex); i= new (thd->mem_root) sp_instr_jump_if_not(ip, ctx, when, lex);
/* /*
BACKPATCH: Registering forward jump from BACKPATCH: Registering forward jump from
@ -332,7 +335,7 @@ int case_stmt_action_when(LEX *lex, Item *when, bool simple)
*/ */
return !MY_TEST(i) || return !MY_TEST(i) ||
sp->push_backpatch(i, ctx->push_label(lex->thd, empty_lex_str, 0)) || sp->push_backpatch(i, ctx->push_label(thd, empty_lex_str, 0)) ||
sp->add_cont_backpatch(i) || sp->add_cont_backpatch(i) ||
sp->add_instr(i); sp->add_instr(i);
} }
@ -348,7 +351,7 @@ int case_stmt_action_then(LEX *lex)
sp_head *sp= lex->sphead; sp_head *sp= lex->sphead;
sp_pcontext *ctx= lex->spcont; sp_pcontext *ctx= lex->spcont;
uint ip= sp->instructions(); uint ip= sp->instructions();
sp_instr_jump *i = new sp_instr_jump(ip, ctx); sp_instr_jump *i= new (lex->thd->mem_root) sp_instr_jump(ip, ctx);
if (!MY_TEST(i) || sp->add_instr(i)) if (!MY_TEST(i) || sp->add_instr(i))
return 1; return 1;
@ -411,7 +414,8 @@ set_system_variable(THD *thd, struct sys_var_with_base *tmp,
return TRUE; return TRUE;
} }
if (! (var= new set_var(thd, var_type, tmp->var, &tmp->base_name, val))) if (! (var= new (thd->mem_root)
set_var(thd, var_type, tmp->var, &tmp->base_name, val)))
return TRUE; return TRUE;
return lex->var_list.push_back(var); return lex->var_list.push_back(var);
@ -447,8 +451,9 @@ set_local_variable(THD *thd, sp_variable *spv, Item *val)
return TRUE; return TRUE;
} }
sp_set= new sp_instr_set(lex->sphead->instructions(), lex->spcont, sp_set= new (thd->mem_root)
spv->offset, it, spv->type, lex, TRUE); sp_instr_set(lex->sphead->instructions(), lex->spcont,
spv->offset, it, spv->type, lex, TRUE);
return (sp_set == NULL || lex->sphead->add_instr(sp_set)); return (sp_set == NULL || lex->sphead->add_instr(sp_set));
} }
@ -474,7 +479,7 @@ set_trigger_new_row(THD *thd, LEX_STRING *name, Item *val)
/* QQ: Shouldn't this be field's default value ? */ /* QQ: Shouldn't this be field's default value ? */
if (! val) if (! val)
val= new Item_null(thd); val= new (thd->mem_root) Item_null(thd);
DBUG_ASSERT(lex->trg_chistics.action_time == TRG_ACTION_BEFORE && DBUG_ASSERT(lex->trg_chistics.action_time == TRG_ACTION_BEFORE &&
(lex->trg_chistics.event == TRG_EVENT_INSERT || (lex->trg_chistics.event == TRG_EVENT_INSERT ||
@ -488,8 +493,10 @@ set_trigger_new_row(THD *thd, LEX_STRING *name, Item *val)
if (trg_fld == NULL) if (trg_fld == NULL)
return TRUE; return TRUE;
sp_fld= new sp_instr_set_trigger_field(lex->sphead->instructions(), sp_fld= new (thd->mem_root)
lex->spcont, trg_fld, val, lex); sp_instr_set_trigger_field(lex->sphead->instructions(),
lex->spcont, trg_fld, val,
lex);
if (sp_fld == NULL) if (sp_fld == NULL)
return TRUE; return TRUE;
@ -814,8 +821,8 @@ static bool sp_create_assignment_instr(THD *thd, bool no_lookahead)
sp_instr_stmt *i; sp_instr_stmt *i;
Lex_input_stream *lip= &thd->m_parser_state->m_lip; Lex_input_stream *lip= &thd->m_parser_state->m_lip;
if (!(i= new sp_instr_stmt(sp->instructions(), lex->spcont, if (!(i= new (thd->mem_root)
lex))) sp_instr_stmt(sp->instructions(), lex->spcont, lex)))
return true; return true;
/* /*
@ -2796,7 +2803,7 @@ sp_name:
{ {
MYSQL_YYABORT; MYSQL_YYABORT;
} }
$$= new sp_name($1, $3, true); $$= new (thd->mem_root) sp_name($1, $3, true);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
$$->init_qname(thd); $$->init_qname(thd);
@ -2811,7 +2818,7 @@ sp_name:
} }
if (lex->copy_db_to(&db.str, &db.length)) if (lex->copy_db_to(&db.str, &db.length))
MYSQL_YYABORT; MYSQL_YYABORT;
$$= new sp_name(db, $1, false); $$= new (lex->thd->mem_root) sp_name(db, $1, false);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
$$->init_qname(thd); $$->init_qname(thd);
@ -3066,13 +3073,14 @@ sp_decl:
/* The last instruction is responsible for freeing LEX. */ /* The last instruction is responsible for freeing LEX. */
sp_instr_set *is= new sp_instr_set(lex->sphead->instructions(), sp_instr_set *is= (new (lex->thd->mem_root)
pctx, sp_instr_set(lex->sphead->instructions(),
var_idx, pctx,
dflt_value_item, var_idx,
var_type, dflt_value_item,
lex, var_type,
last); lex,
last));
if (is == NULL || if (is == NULL ||
lex->sphead->add_instr(is)) lex->sphead->add_instr(is))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3112,7 +3120,8 @@ sp_decl:
sp_pcontext *ctx= lex->spcont; sp_pcontext *ctx= lex->spcont;
sp_instr_hpush_jump *i= sp_instr_hpush_jump *i=
new sp_instr_hpush_jump(sp->instructions(), ctx, h); new (lex->thd->mem_root) sp_instr_hpush_jump(sp->instructions(),
ctx, h);
if (i == NULL || sp->add_instr(i)) if (i == NULL || sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3135,14 +3144,16 @@ sp_decl:
if ($2 == sp_handler::CONTINUE) if ($2 == sp_handler::CONTINUE)
{ {
i= new sp_instr_hreturn(sp->instructions(), ctx); i= new (lex->thd->mem_root)
sp_instr_hreturn(sp->instructions(), ctx);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
else else
{ /* EXIT or UNDO handler, just jump to the end of the block */ { /* EXIT or UNDO handler, just jump to the end of the block */
i= new sp_instr_hreturn(sp->instructions(), ctx); i= new (lex->thd->mem_root)
sp_instr_hreturn(sp->instructions(), ctx);
if (i == NULL || if (i == NULL ||
sp->add_instr(i) || sp->add_instr(i) ||
sp->push_backpatch(i, lex->spcont->last_label())) /* Block end */ sp->push_backpatch(i, lex->spcont->last_label())) /* Block end */
@ -3169,8 +3180,9 @@ sp_decl:
delete $5; delete $5;
MYSQL_YYABORT; MYSQL_YYABORT;
} }
i= new sp_instr_cpush(sp->instructions(), ctx, $5, i= new (lex->thd->mem_root)
ctx->current_cursor_count()); sp_instr_cpush(sp->instructions(), ctx, $5,
ctx->current_cursor_count());
if (i == NULL || if (i == NULL ||
sp->add_instr(i) || sp->add_instr(i) ||
ctx->add_cursor($2)) ctx->add_cursor($2))
@ -3712,8 +3724,8 @@ sp_proc_stmt_statement:
lex->var_list.is_empty()); lex->var_list.is_empty());
if (lex->sql_command != SQLCOM_SET_OPTION) if (lex->sql_command != SQLCOM_SET_OPTION)
{ {
sp_instr_stmt *i=new sp_instr_stmt(sp->instructions(), sp_instr_stmt *i=new (lex->thd->mem_root)
lex->spcont, lex); sp_instr_stmt(sp->instructions(), lex->spcont, lex);
if (i == NULL) if (i == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3754,8 +3766,9 @@ sp_proc_stmt_return:
{ {
sp_instr_freturn *i; sp_instr_freturn *i;
i= new sp_instr_freturn(sp->instructions(), lex->spcont, $3, i= new (lex->thd->mem_root)
sp->m_return_field_def.sql_type, lex); sp_instr_freturn(sp->instructions(), lex->spcont, $3,
sp->m_return_field_def.sql_type, lex);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3811,7 +3824,8 @@ sp_proc_stmt_leave:
n= ctx->diff_handlers(lab->ctx, exclusive); n= ctx->diff_handlers(lab->ctx, exclusive);
if (n) if (n)
{ {
sp_instr_hpop *hpop= new sp_instr_hpop(ip++, ctx, n); sp_instr_hpop *hpop= new (lex->thd->mem_root)
sp_instr_hpop(ip++, ctx, n);
if (hpop == NULL) if (hpop == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
sp->add_instr(hpop); sp->add_instr(hpop);
@ -3819,12 +3833,13 @@ sp_proc_stmt_leave:
n= ctx->diff_cursors(lab->ctx, exclusive); n= ctx->diff_cursors(lab->ctx, exclusive);
if (n) if (n)
{ {
sp_instr_cpop *cpop= new sp_instr_cpop(ip++, ctx, n); sp_instr_cpop *cpop= new (lex->thd->mem_root)
sp_instr_cpop(ip++, ctx, n);
if (cpop == NULL) if (cpop == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
sp->add_instr(cpop); sp->add_instr(cpop);
} }
i= new sp_instr_jump(ip, ctx); i= new (lex->thd->mem_root) sp_instr_jump(ip, ctx);
if (i == NULL) if (i == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
sp->push_backpatch(i, lab); /* Jumping forward */ sp->push_backpatch(i, lab); /* Jumping forward */
@ -3855,7 +3870,8 @@ sp_proc_stmt_iterate:
n= ctx->diff_handlers(lab->ctx, FALSE); /* Inclusive the dest. */ n= ctx->diff_handlers(lab->ctx, FALSE); /* Inclusive the dest. */
if (n) if (n)
{ {
sp_instr_hpop *hpop= new sp_instr_hpop(ip++, ctx, n); sp_instr_hpop *hpop= new (lex->thd->mem_root)
sp_instr_hpop(ip++, ctx, n);
if (hpop == NULL || if (hpop == NULL ||
sp->add_instr(hpop)) sp->add_instr(hpop))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3863,12 +3879,14 @@ sp_proc_stmt_iterate:
n= ctx->diff_cursors(lab->ctx, FALSE); /* Inclusive the dest. */ n= ctx->diff_cursors(lab->ctx, FALSE); /* Inclusive the dest. */
if (n) if (n)
{ {
sp_instr_cpop *cpop= new sp_instr_cpop(ip++, ctx, n); sp_instr_cpop *cpop= new (lex->thd->mem_root)
sp_instr_cpop(ip++, ctx, n);
if (cpop == NULL || if (cpop == NULL ||
sp->add_instr(cpop)) sp->add_instr(cpop))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
i= new sp_instr_jump(ip, ctx, lab->ip); /* Jump back */ i= new (lex->thd->mem_root)
sp_instr_jump(ip, ctx, lab->ip); /* Jump back */
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3889,7 +3907,8 @@ sp_proc_stmt_open:
my_error(ER_SP_CURSOR_MISMATCH, MYF(0), $2.str); my_error(ER_SP_CURSOR_MISMATCH, MYF(0), $2.str);
MYSQL_YYABORT; MYSQL_YYABORT;
} }
i= new sp_instr_copen(sp->instructions(), lex->spcont, offset); i= new (lex->thd->mem_root)
sp_instr_copen(sp->instructions(), lex->spcont, offset);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3909,7 +3928,8 @@ sp_proc_stmt_fetch:
my_error(ER_SP_CURSOR_MISMATCH, MYF(0), $3.str); my_error(ER_SP_CURSOR_MISMATCH, MYF(0), $3.str);
MYSQL_YYABORT; MYSQL_YYABORT;
} }
i= new sp_instr_cfetch(sp->instructions(), lex->spcont, offset); i= new (lex->thd->mem_root)
sp_instr_cfetch(sp->instructions(), lex->spcont, offset);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3931,7 +3951,8 @@ sp_proc_stmt_close:
my_error(ER_SP_CURSOR_MISMATCH, MYF(0), $2.str); my_error(ER_SP_CURSOR_MISMATCH, MYF(0), $2.str);
MYSQL_YYABORT; MYSQL_YYABORT;
} }
i= new sp_instr_cclose(sp->instructions(), lex->spcont, offset); i= new (lex->thd->mem_root)
sp_instr_cclose(sp->instructions(), lex->spcont, offset);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -3995,8 +4016,8 @@ sp_if:
sp_head *sp= lex->sphead; sp_head *sp= lex->sphead;
sp_pcontext *ctx= lex->spcont; sp_pcontext *ctx= lex->spcont;
uint ip= sp->instructions(); uint ip= sp->instructions();
sp_instr_jump_if_not *i = new sp_instr_jump_if_not(ip, ctx, sp_instr_jump_if_not *i= new (lex->thd->mem_root)
$2, lex); sp_instr_jump_if_not(ip, ctx, $2, lex);
if (i == NULL || if (i == NULL ||
sp->push_backpatch(i, ctx->push_label(thd, empty_lex_str, 0)) || sp->push_backpatch(i, ctx->push_label(thd, empty_lex_str, 0)) ||
sp->add_cont_backpatch(i) || sp->add_cont_backpatch(i) ||
@ -4010,7 +4031,7 @@ sp_if:
sp_head *sp= Lex->sphead; sp_head *sp= Lex->sphead;
sp_pcontext *ctx= Lex->spcont; sp_pcontext *ctx= Lex->spcont;
uint ip= sp->instructions(); uint ip= sp->instructions();
sp_instr_jump *i = new sp_instr_jump(ip, ctx); sp_instr_jump *i= new (thd->mem_root) sp_instr_jump(ip, ctx);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -4181,8 +4202,8 @@ else_clause_opt:
LEX *lex= Lex; LEX *lex= Lex;
sp_head *sp= lex->sphead; sp_head *sp= lex->sphead;
uint ip= sp->instructions(); uint ip= sp->instructions();
sp_instr_error *i= new sp_instr_error(ip, lex->spcont, sp_instr_error *i= new (thd->mem_root)
ER_SP_CASE_NOT_FOUND); sp_instr_error(ip, lex->spcont, ER_SP_CASE_NOT_FOUND);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -4298,14 +4319,16 @@ sp_block_content:
sp->backpatch(ctx->last_label()); /* We always have a label */ sp->backpatch(ctx->last_label()); /* We always have a label */
if ($2.hndlrs) if ($2.hndlrs)
{ {
i= new sp_instr_hpop(sp->instructions(), ctx, $2.hndlrs); i= new (thd->mem_root)
sp_instr_hpop(sp->instructions(), ctx, $2.hndlrs);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
if ($2.curs) if ($2.curs)
{ {
i= new sp_instr_cpop(sp->instructions(), ctx, $2.curs); i= new (lex->thd->mem_root)
sp_instr_cpop(sp->instructions(), ctx, $2.curs);
if (i == NULL || if (i == NULL ||
sp->add_instr(i)) sp->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -4322,7 +4345,8 @@ sp_control_content:
LEX *lex= Lex; LEX *lex= Lex;
uint ip= lex->sphead->instructions(); uint ip= lex->sphead->instructions();
sp_label *lab= lex->spcont->last_label(); /* Jumping back */ sp_label *lab= lex->spcont->last_label(); /* Jumping back */
sp_instr_jump *i = new sp_instr_jump(ip, lex->spcont, lab->ip); sp_instr_jump *i= new (lex->thd->mem_root)
sp_instr_jump(ip, lex->spcont, lab->ip);
if (i == NULL || if (i == NULL ||
lex->sphead->add_instr(i)) lex->sphead->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -4334,8 +4358,8 @@ sp_control_content:
LEX *lex= Lex; LEX *lex= Lex;
sp_head *sp= lex->sphead; sp_head *sp= lex->sphead;
uint ip= sp->instructions(); uint ip= sp->instructions();
sp_instr_jump_if_not *i = new sp_instr_jump_if_not(ip, lex->spcont, sp_instr_jump_if_not *i= new (lex->thd->mem_root)
$3, lex); sp_instr_jump_if_not(ip, lex->spcont, $3, lex);
if (i == NULL || if (i == NULL ||
/* Jumping forward */ /* Jumping forward */
sp->push_backpatch(i, lex->spcont->last_label()) || sp->push_backpatch(i, lex->spcont->last_label()) ||
@ -4350,7 +4374,8 @@ sp_control_content:
LEX *lex= Lex; LEX *lex= Lex;
uint ip= lex->sphead->instructions(); uint ip= lex->sphead->instructions();
sp_label *lab= lex->spcont->last_label(); /* Jumping back */ sp_label *lab= lex->spcont->last_label(); /* Jumping back */
sp_instr_jump *i = new sp_instr_jump(ip, lex->spcont, lab->ip); sp_instr_jump *i= new (lex->thd->mem_root)
sp_instr_jump(ip, lex->spcont, lab->ip);
if (i == NULL || if (i == NULL ||
lex->sphead->add_instr(i)) lex->sphead->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -4363,9 +4388,8 @@ sp_control_content:
LEX *lex= Lex; LEX *lex= Lex;
uint ip= lex->sphead->instructions(); uint ip= lex->sphead->instructions();
sp_label *lab= lex->spcont->last_label(); /* Jumping back */ sp_label *lab= lex->spcont->last_label(); /* Jumping back */
sp_instr_jump_if_not *i = new sp_instr_jump_if_not(ip, lex->spcont, sp_instr_jump_if_not *i= new (lex->thd->mem_root)
$5, lab->ip, sp_instr_jump_if_not(ip, lex->spcont, $5, lab->ip, lex);
lex);
if (i == NULL || if (i == NULL ||
lex->sphead->add_instr(i)) lex->sphead->add_instr(i))
MYSQL_YYABORT; MYSQL_YYABORT;
@ -8684,7 +8708,7 @@ expr:
else else
{ {
/* X OR Y */ /* X OR Y */
$$ = new (thd->mem_root) Item_cond_or(thd, $1, $3); $$= new (thd->mem_root) Item_cond_or(thd, $1, $3);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -8692,7 +8716,7 @@ expr:
| expr XOR expr %prec XOR | expr XOR expr %prec XOR
{ {
/* XOR is a proprietary extension */ /* XOR is a proprietary extension */
$$ = new (thd->mem_root) Item_func_xor(thd, $1, $3); $$= new (thd->mem_root) Item_func_xor(thd, $1, $3);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -8734,7 +8758,7 @@ expr:
else else
{ {
/* X AND Y */ /* X AND Y */
$$ = new (thd->mem_root) Item_cond_and(thd, $1, $3); $$= new (thd->mem_root) Item_cond_and(thd, $1, $3);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -8858,7 +8882,7 @@ predicate:
{ {
$7->push_front($5); $7->push_front($5);
$7->push_front($1); $7->push_front($1);
Item_func_in *item = new (thd->mem_root) Item_func_in(thd, *$7); Item_func_in *item= new (thd->mem_root) Item_func_in(thd, *$7);
if (item == NULL) if (item == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
item->negate(); item->negate();
@ -9625,7 +9649,7 @@ function_call_nonkeyword:
} }
| POSITION_SYM '(' bit_expr IN_SYM expr ')' | POSITION_SYM '(' bit_expr IN_SYM expr ')'
{ {
$$ = new (thd->mem_root) Item_func_locate(thd, $5, $3); $$= new (thd->mem_root) Item_func_locate(thd, $5, $3);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -9826,7 +9850,7 @@ function_call_conflict:
} }
| MOD_SYM '(' expr ',' expr ')' | MOD_SYM '(' expr ',' expr ')'
{ {
$$ = new (thd->mem_root) Item_func_mod(thd, $3, $5); $$= new (thd->mem_root) Item_func_mod(thd, $3, $5);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -9847,7 +9871,7 @@ function_call_conflict:
} }
| QUARTER_SYM '(' expr ')' | QUARTER_SYM '(' expr ')'
{ {
$$ = new (thd->mem_root) Item_func_quarter(thd, $3); $$= new (thd->mem_root) Item_func_quarter(thd, $3);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -11802,7 +11826,7 @@ drop:
MYSQL_YYABORT; MYSQL_YYABORT;
} }
lex->set_command(SQLCOM_DROP_FUNCTION, $3); lex->set_command(SQLCOM_DROP_FUNCTION, $3);
spname= new sp_name($4, $6, true); spname= new (lex->thd->mem_root) sp_name($4, $6, true);
if (spname == NULL) if (spname == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
spname->init_qname(thd); spname->init_qname(thd);
@ -11821,7 +11845,7 @@ drop:
if (thd->db && lex->copy_db_to(&db.str, &db.length)) if (thd->db && lex->copy_db_to(&db.str, &db.length))
MYSQL_YYABORT; MYSQL_YYABORT;
lex->set_command(SQLCOM_DROP_FUNCTION, $3); lex->set_command(SQLCOM_DROP_FUNCTION, $3);
spname= new sp_name(db, $4, false); spname= new (lex->thd->mem_root) sp_name(db, $4, false);
if (spname == NULL) if (spname == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
spname->init_qname(thd); spname->init_qname(thd);
@ -12050,7 +12074,7 @@ insert_field_spec:
| SET | SET
{ {
LEX *lex=Lex; LEX *lex=Lex;
if (!(lex->insert_list = new List_item) || if (!(lex->insert_list= new List_item) ||
lex->many_values.push_back(lex->insert_list)) lex->many_values.push_back(lex->insert_list))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -12106,7 +12130,7 @@ opt_equal:
no_braces: no_braces:
'(' '('
{ {
if (!(Lex->insert_list = new List_item)) if (!(Lex->insert_list= new List_item))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
opt_values ')' opt_values ')'
@ -13511,7 +13535,7 @@ literal:
TOK_GENERIC_VALUE := NULL_SYM TOK_GENERIC_VALUE := NULL_SYM
*/ */
YYLIP->reduce_digest_token(TOK_GENERIC_VALUE, NULL_SYM); YYLIP->reduce_digest_token(TOK_GENERIC_VALUE, NULL_SYM);
$$ = new (thd->mem_root) Item_null(thd); $$= new (thd->mem_root) Item_null(thd);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
YYLIP->next_state= MY_LEX_OPERATOR_OR_IDENT; YYLIP->next_state= MY_LEX_OPERATOR_OR_IDENT;
@ -13530,13 +13554,13 @@ literal:
} }
| HEX_NUM | HEX_NUM
{ {
$$ = new (thd->mem_root) Item_hex_hybrid(thd, $1.str, $1.length); $$= new (thd->mem_root) Item_hex_hybrid(thd, $1.str, $1.length);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
| HEX_STRING | HEX_STRING
{ {
$$ = new (thd->mem_root) Item_hex_string(thd, $1.str, $1.length); $$= new (thd->mem_root) Item_hex_string(thd, $1.str, $1.length);
if ($$ == NULL) if ($$ == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
} }
@ -15172,7 +15196,7 @@ handler_rkey_function:
LEX *lex=Lex; LEX *lex=Lex;
lex->ha_read_mode = RKEY; lex->ha_read_mode = RKEY;
lex->ha_rkey_mode=$1; lex->ha_rkey_mode=$1;
if (!(lex->insert_list = new List_item)) if (!(lex->insert_list= new List_item))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
'(' values ')' '(' values ')'
@ -15609,7 +15633,7 @@ column_list:
column_list_id: column_list_id:
ident ident
{ {
String *new_str = new (thd->mem_root) String((const char*) $1.str,$1.length,system_charset_info); String *new_str= new (thd->mem_root) String((const char*) $1.str,$1.length,system_charset_info);
if (new_str == NULL) if (new_str == NULL)
MYSQL_YYABORT; MYSQL_YYABORT;
List_iterator <LEX_COLUMN> iter(Lex->columns); List_iterator <LEX_COLUMN> iter(Lex->columns);

10
sql/table.cc
View File

@ -4142,7 +4142,7 @@ bool TABLE::fill_item_list(List<Item> *item_list) const
*/ */
for (Field **ptr= field; *ptr; ptr++) for (Field **ptr= field; *ptr; ptr++)
{ {
Item_field *item= new Item_field(in_use, *ptr); Item_field *item= new (in_use->mem_root) Item_field(in_use, *ptr);
if (!item || item_list->push_back(item)) if (!item || item_list->push_back(item))
return TRUE; return TRUE;
} }
@ -5297,7 +5297,7 @@ Item *Field_iterator_table::create_item(THD *thd)
{ {
SELECT_LEX *select= thd->lex->current_select; SELECT_LEX *select= thd->lex->current_select;
Item_field *item= new Item_field(thd, &select->context, *ptr); Item_field *item= new (thd->mem_root) Item_field(thd, &select->context, *ptr);
if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY && if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
!thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS) !thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS)
{ {
@ -5354,7 +5354,7 @@ Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
{ {
DBUG_RETURN(field); DBUG_RETURN(field);
} }
Item *item= new Item_direct_view_ref(thd, &view->view->select_lex.context, Item *item= new (thd->mem_root) Item_direct_view_ref(thd, &view->view->select_lex.context,
field_ref, view->alias, field_ref, view->alias,
name, view); name, view);
/* /*
@ -5559,7 +5559,7 @@ Field_iterator_table_ref::get_or_create_column_ref(THD *thd, TABLE_LIST *parent_
/* The field belongs to a stored table. */ /* The field belongs to a stored table. */
Field *tmp_field= table_field_it.field(); Field *tmp_field= table_field_it.field();
Item_field *tmp_item= Item_field *tmp_item=
new Item_field(thd, &thd->lex->current_select->context, tmp_field); new (thd->mem_root) Item_field(thd, &thd->lex->current_select->context, tmp_field);
if (!tmp_item) if (!tmp_item)
return NULL; return NULL;
nj_col= new Natural_join_column(tmp_item, table_ref); nj_col= new Natural_join_column(tmp_item, table_ref);
@ -7328,7 +7328,7 @@ bool TABLE_LIST::change_refs_to_fields()
DBUG_ASSERT(!field_it.end_of_fields()); DBUG_ASSERT(!field_it.end_of_fields());
if (!materialized_items[idx]) if (!materialized_items[idx])
{ {
materialized_items[idx]= new Item_field(thd, table->field[idx]); materialized_items[idx]= new (thd->mem_root) Item_field(thd, table->field[idx]);
if (!materialized_items[idx]) if (!materialized_items[idx])
return TRUE; return TRUE;
} }

5
storage/sphinx/ha_sphinx.cc
View File

@ -2335,10 +2335,11 @@ int ha_sphinx::write_row ( byte * )
} else } else
{ {
THD *thd= ha_thd();
if ( (*ppField)->type()==MYSQL_TYPE_TIMESTAMP ) if ( (*ppField)->type()==MYSQL_TYPE_TIMESTAMP )
{ {
Item_field * pWrap = new Item_field ( ha_thd(), *ppField ); // autofreed by query arena, I assume Item_field * pWrap = new (thd->mem_root) Item_field(thd, *ppField); // autofreed by query arena, I assume
Item_func_unix_timestamp * pConv = new Item_func_unix_timestamp ( ha_thd(), pWrap ); Item_func_unix_timestamp * pConv = new (thd->mem_root) Item_func_unix_timestamp(thd, pWrap);
pConv->quick_fix_field(); pConv->quick_fix_field();
unsigned int uTs = (unsigned int) pConv->val_int(); unsigned int uTs = (unsigned int) pConv->val_int();

12
storage/spider/spd_sys_table.cc
View File

@ -2390,7 +2390,7 @@ TABLE *spider_mk_sys_tmp_table(
goto error_alloc_field; goto error_alloc_field;
field->init(table); field->init(table);
if (!(i_field = new Item_field(thd, (Field *) field))) if (!(i_field = new (thd->mem_root) Item_field(thd, (Field *) field)))
goto error_alloc_item_field; goto error_alloc_item_field;
if (i_list.push_back(i_field)) if (i_list.push_back(i_field))
@ -2443,29 +2443,29 @@ TABLE *spider_mk_sys_tmp_table_for_result(
goto error_alloc_field1; goto error_alloc_field1;
field1->init(table); field1->init(table);
if (!(i_field1 = new Item_field(thd, (Field *) field1))) if (!(i_field1 = new (thd->mem_root) Item_field(thd, (Field *) field1)))
goto error_alloc_item_field1; goto error_alloc_item_field1;
if (i_list.push_back(i_field1)) if (i_list.push_back(i_field1))
goto error_push_item1; goto error_push_item1;
if (!(field2 = new Field_blob( if (!(field2 = new (thd->mem_root) Field_blob(
4294967295U, FALSE, field_name2, cs, TRUE))) 4294967295U, FALSE, field_name2, cs, TRUE)))
goto error_alloc_field2; goto error_alloc_field2;
field2->init(table); field2->init(table);
if (!(i_field2 = new Item_field(thd, (Field *) field2))) if (!(i_field2 = new (thd->mem_root) Item_field(thd, (Field *) field2)))
goto error_alloc_item_field2; goto error_alloc_item_field2;
if (i_list.push_back(i_field2)) if (i_list.push_back(i_field2))
goto error_push_item2; goto error_push_item2;
if (!(field3 = new Field_blob( if (!(field3 = new (thd->mem_root) Field_blob(
4294967295U, FALSE, field_name3, cs, TRUE))) 4294967295U, FALSE, field_name3, cs, TRUE)))
goto error_alloc_field3; goto error_alloc_field3;
field3->init(table); field3->init(table);
if (!(i_field3 = new Item_field(thd, (Field *) field3))) if (!(i_field3 = new (thd->mem_root) Item_field(thd, (Field *) field3)))
goto error_alloc_item_field3; goto error_alloc_item_field3;
if (i_list.push_back(i_field3)) if (i_list.push_back(i_field3))