MDEV-6152: Remove calls to current_thd while creating Item

Part 5: Removing calls to current_thd in net_read calls, creating fields,
        query_cache, acl and some other places where thd was available
This commit is contained in:
Monty 2015-08-31 12:57:46 +03:00
parent 8ea9b8c0b1
commit 56aa19989f
32 changed files with 396 additions and 309 deletions

View file

@ -1028,9 +1028,9 @@ extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length, char *to, size_t to_length,
const char *from, size_t length); const char *from, size_t length);
extern void thd_increment_bytes_sent(ulong length); extern void thd_increment_bytes_sent(void *thd, ulong length);
extern void thd_increment_bytes_received(ulong length); extern void thd_increment_bytes_received(void *thd, ulong length);
extern void thd_increment_net_big_packet_count(ulong length); extern void thd_increment_net_big_packet_count(void *thd, ulong length);
#ifdef __WIN__ #ifdef __WIN__
extern my_bool have_tcpip; /* Is set if tcpip is used */ extern my_bool have_tcpip; /* Is set if tcpip is used */

View file

@ -29,7 +29,7 @@ typedef struct st_net {
my_bool thread_specific_malloc; my_bool thread_specific_malloc;
my_bool compress; my_bool compress;
my_bool unused3; my_bool unused3;
unsigned char *unused; void *thd;
unsigned int last_errno; unsigned int last_errno;
unsigned char error; unsigned char error;
my_bool unused4; my_bool unused4;
@ -81,7 +81,7 @@ enum enum_mysql_set_option
MYSQL_OPTION_MULTI_STATEMENTS_ON, MYSQL_OPTION_MULTI_STATEMENTS_ON,
MYSQL_OPTION_MULTI_STATEMENTS_OFF MYSQL_OPTION_MULTI_STATEMENTS_OFF
}; };
my_bool my_net_init(NET *net, Vio* vio, unsigned int my_flags); my_bool my_net_init(NET *net, Vio* vio, void *thd, unsigned int my_flags);
void my_net_local_init(NET *net); void my_net_local_init(NET *net);
void net_end(NET *net); void net_end(NET *net);
void net_clear(NET *net, my_bool clear_buffer); void net_clear(NET *net, my_bool clear_buffer);

View file

@ -386,10 +386,7 @@ typedef struct st_net {
queries in cache that have not stored its results yet queries in cache that have not stored its results yet
*/ */
#endif #endif
/* void *thd; /* Used by MariaDB server to avoid calling current_thd */
Unused, please remove with the next incompatible ABI change.
*/
unsigned char *unused;
unsigned int last_errno; unsigned int last_errno;
unsigned char error; unsigned char error;
my_bool unused4; /* Please remove with the next incompatible ABI change. */ my_bool unused4; /* Please remove with the next incompatible ABI change. */
@ -517,7 +514,7 @@ enum enum_mysql_set_option
extern "C" { extern "C" {
#endif #endif
my_bool my_net_init(NET *net, Vio* vio, unsigned int my_flags); my_bool my_net_init(NET *net, Vio* vio, void *thd, unsigned int my_flags);
void my_net_local_init(NET *net); void my_net_local_init(NET *net);
void net_end(NET *net); void net_end(NET *net);
void net_clear(NET *net, my_bool clear_buffer); void net_clear(NET *net, my_bool clear_buffer);

View file

@ -3551,7 +3551,7 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
if (mysql->options.extension && mysql->options.extension->async_context) if (mysql->options.extension && mysql->options.extension->async_context)
net->vio->async_context= mysql->options.extension->async_context; net->vio->async_context= mysql->options.extension->async_context;
if (my_net_init(net, net->vio, MYF(0))) if (my_net_init(net, net->vio, 0, MYF(0)))
{ {
vio_delete(net->vio); vio_delete(net->vio);
net->vio = 0; net->vio = 0;

View file

@ -186,7 +186,7 @@ pre_init_event_thread(THD* thd)
thd->security_ctx->master_access= 0; thd->security_ctx->master_access= 0;
thd->security_ctx->db_access= 0; thd->security_ctx->db_access= 0;
thd->security_ctx->host_or_ip= (char*)my_localhost; thd->security_ctx->host_or_ip= (char*)my_localhost;
my_net_init(&thd->net, NULL, MYF(MY_THREAD_SPECIFIC)); my_net_init(&thd->net, NULL, thd, MYF(MY_THREAD_SPECIFIC));
thd->security_ctx->set_user((char*)"event_scheduler"); thd->security_ctx->set_user((char*)"event_scheduler");
thd->net.read_timeout= slave_net_timeout; thd->net.read_timeout= slave_net_timeout;
thd->variables.option_bits|= OPTION_AUTO_IS_NULL; thd->variables.option_bits|= OPTION_AUTO_IS_NULL;

View file

@ -2736,7 +2736,7 @@ Field_new_decimal::Field_new_decimal(uint32 len_arg,
} }
Field *Field_new_decimal::create_from_item (Item *item) Field *Field_new_decimal::create_from_item(MEM_ROOT *mem_root, Item *item)
{ {
uint8 dec= item->decimals; uint8 dec= item->decimals;
uint8 intg= item->decimal_precision() - dec; uint8 intg= item->decimal_precision() - dec;
@ -2775,8 +2775,9 @@ Field *Field_new_decimal::create_from_item (Item *item)
/* Corrected value fits. */ /* Corrected value fits. */
len= required_length; len= required_length;
} }
return new Field_new_decimal(len, item->maybe_null, item->name, return new (mem_root)
dec, item->unsigned_flag); Field_new_decimal(len, item->maybe_null, item->name,
dec, item->unsigned_flag);
} }
@ -2875,14 +2876,13 @@ int Field_new_decimal::store(const char *from, uint length,
ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED; ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
int err; int err;
my_decimal decimal_value; my_decimal decimal_value;
THD *thd= get_thd();
DBUG_ENTER("Field_new_decimal::store(char*)"); DBUG_ENTER("Field_new_decimal::store(char*)");
if ((err= str2my_decimal(E_DEC_FATAL_ERROR & if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
~(E_DEC_OVERFLOW | E_DEC_BAD_NUM), ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
from, length, charset_arg, from, length, charset_arg,
&decimal_value)) && &decimal_value)) &&
thd->abort_on_warning) get_thd()->abort_on_warning)
{ {
ErrConvString errmsg(from, length, charset_arg); ErrConvString errmsg(from, length, charset_arg);
set_warning_truncated_wrong_value("decimal", errmsg.ptr()); set_warning_truncated_wrong_value("decimal", errmsg.ptr());
@ -4929,9 +4929,8 @@ void Field_timestamp::sql_type(String &res) const
int Field_timestamp::set_time() int Field_timestamp::set_time()
{ {
THD *thd= get_thd();
set_notnull(); set_notnull();
store_TIME(thd->query_start(), 0); store_TIME(get_thd()->query_start(), 0);
return 0; return 0;
} }
@ -5092,8 +5091,8 @@ int Field_timestamp::store_decimal(const my_decimal *d)
} }
else else
tmp= number_to_datetime(nr, sec_part, &ltime, TIME_NO_ZERO_IN_DATE | tmp= number_to_datetime(nr, sec_part, &ltime, TIME_NO_ZERO_IN_DATE |
(thd->variables.sql_mode & (thd->variables.sql_mode &
MODE_NO_ZERO_DATE), &error); MODE_NO_ZERO_DATE), &error);
return store_TIME_with_warning(thd, &ltime, &str, error, tmp != -1); return store_TIME_with_warning(thd, &ltime, &str, error, tmp != -1);
} }
@ -5294,16 +5293,16 @@ int Field_temporal_with_date::store_time_dec(MYSQL_TIME *ltime, uint dec)
*/ */
have_smth_to_conv= false; have_smth_to_conv= false;
error= MYSQL_TIME_WARN_OUT_OF_RANGE; error= MYSQL_TIME_WARN_OUT_OF_RANGE;
goto store;
} }
else
/* {
We don't perform range checking here since values stored in TIME /*
structure always fit into DATETIME range. We don't perform range checking here since values stored in TIME
*/ structure always fit into DATETIME range.
have_smth_to_conv= !check_date(&l_time, pack_time(&l_time) != 0, */
sql_mode_for_dates(current_thd), &error); have_smth_to_conv= !check_date(&l_time, pack_time(&l_time) != 0,
store: sql_mode_for_dates(get_thd()), &error);
}
return store_TIME_with_warning(&l_time, &str, error, have_smth_to_conv); return store_TIME_with_warning(&l_time, &str, error, have_smth_to_conv);
} }
@ -6928,8 +6927,9 @@ Field *Field_string::make_new_field(MEM_ROOT *root, TABLE *new_table,
Field *field; Field *field;
if (type() != MYSQL_TYPE_VAR_STRING || keep_type) if (type() != MYSQL_TYPE_VAR_STRING || keep_type)
field= Field::make_new_field(root, new_table, keep_type); field= Field::make_new_field(root, new_table, keep_type);
else if ((field= new Field_varstring(field_length, maybe_null(), field_name, else if ((field= new (root) Field_varstring(field_length, maybe_null(),
new_table->s, charset()))) field_name,
new_table->s, charset())))
{ {
/* /*
Old VARCHAR field which should be modified to a VARCHAR on copy Old VARCHAR field which should be modified to a VARCHAR on copy
@ -7035,7 +7035,7 @@ double Field_varstring::val_real(void)
(error || (length != (uint)(end - (char*)ptr+length_bytes) && (error || (length != (uint)(end - (char*)ptr+length_bytes) &&
!check_if_only_end_space(cs, end, (char*)ptr+length_bytes+length)))) !check_if_only_end_space(cs, end, (char*)ptr+length_bytes+length))))
{ {
push_numerical_conversion_warning(current_thd, (char*)ptr+length_bytes, push_numerical_conversion_warning(get_thd(), (char*)ptr+length_bytes,
length, cs,"DOUBLE", length, cs,"DOUBLE",
ER_TRUNCATED_WRONG_VALUE); ER_TRUNCATED_WRONG_VALUE);
} }
@ -7058,7 +7058,7 @@ longlong Field_varstring::val_int(void)
(error || (length != (uint)(end - (char*)ptr+length_bytes) && (error || (length != (uint)(end - (char*)ptr+length_bytes) &&
!check_if_only_end_space(cs, end, (char*)ptr+length_bytes+length)))) !check_if_only_end_space(cs, end, (char*)ptr+length_bytes+length))))
{ {
push_numerical_conversion_warning(current_thd, (char*)ptr+length_bytes, push_numerical_conversion_warning(get_thd(), (char*)ptr+length_bytes,
length, cs, "INTEGER", length, cs, "INTEGER",
ER_TRUNCATED_WRONG_VALUE); ER_TRUNCATED_WRONG_VALUE);
} }
@ -7085,7 +7085,7 @@ my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
if (!get_thd()->no_errors && error) if (!get_thd()->no_errors && error)
{ {
push_numerical_conversion_warning(current_thd, (char*)ptr+length_bytes, push_numerical_conversion_warning(get_thd(), (char*)ptr+length_bytes,
length, cs, "DECIMAL", length, cs, "DECIMAL",
ER_TRUNCATED_WRONG_VALUE); ER_TRUNCATED_WRONG_VALUE);
} }
@ -7764,7 +7764,7 @@ int Field_blob::do_save_field_metadata(uchar *metadata_ptr)
uint32 Field_blob::sort_length() const uint32 Field_blob::sort_length() const
{ {
return (uint32) (current_thd->variables.max_sort_length + return (uint32) (get_thd()->variables.max_sort_length +
(field_charset == &my_charset_bin ? 0 : packlength)); (field_charset == &my_charset_bin ? 0 : packlength));
} }
@ -9817,7 +9817,9 @@ uint pack_length_to_packflag(uint type)
} }
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length, Field *make_field(TABLE_SHARE *share,
MEM_ROOT *mem_root,
uchar *ptr, uint32 field_length,
uchar *null_pos, uchar null_bit, uchar *null_pos, uchar null_bit,
uint pack_flag, uint pack_flag,
enum_field_types field_type, enum_field_types field_type,
@ -9829,6 +9831,7 @@ Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
{ {
uchar *UNINIT_VAR(bit_ptr); uchar *UNINIT_VAR(bit_ptr);
uchar UNINIT_VAR(bit_offset); uchar UNINIT_VAR(bit_offset);
if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag)) if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
{ {
bit_ptr= null_pos; bit_ptr= null_pos;
@ -9865,16 +9868,18 @@ Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
if (field_type == MYSQL_TYPE_STRING || if (field_type == MYSQL_TYPE_STRING ||
field_type == MYSQL_TYPE_DECIMAL || // 3.23 or 4.0 string field_type == MYSQL_TYPE_DECIMAL || // 3.23 or 4.0 string
field_type == MYSQL_TYPE_VAR_STRING) field_type == MYSQL_TYPE_VAR_STRING)
return new Field_string(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_string(ptr,field_length,null_pos,null_bit,
field_charset); unireg_check, field_name,
field_charset);
if (field_type == MYSQL_TYPE_VARCHAR) if (field_type == MYSQL_TYPE_VARCHAR)
return new Field_varstring(ptr,field_length, return new (mem_root)
HA_VARCHAR_PACKLENGTH(field_length), Field_varstring(ptr,field_length,
null_pos,null_bit, HA_VARCHAR_PACKLENGTH(field_length),
unireg_check, field_name, null_pos,null_bit,
share, unireg_check, field_name,
field_charset); share,
field_charset);
return 0; // Error return 0; // Error
} }
@ -9886,138 +9891,160 @@ Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
if (f_is_geom(pack_flag)) if (f_is_geom(pack_flag))
{ {
status_var_increment(current_thd->status_var.feature_gis); status_var_increment(current_thd->status_var.feature_gis);
return new Field_geom(ptr,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, share, Field_geom(ptr,null_pos,null_bit,
pack_length, geom_type, srid); unireg_check, field_name, share,
pack_length, geom_type, srid);
} }
#endif #endif
if (f_is_blob(pack_flag)) if (f_is_blob(pack_flag))
return new Field_blob(ptr,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, share, Field_blob(ptr,null_pos,null_bit,
pack_length, field_charset); unireg_check, field_name, share,
pack_length, field_charset);
if (interval) if (interval)
{ {
if (f_is_enum(pack_flag)) if (f_is_enum(pack_flag))
return new Field_enum(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_enum(ptr,field_length,null_pos,null_bit,
pack_length, interval, field_charset); unireg_check, field_name,
pack_length, interval, field_charset);
else else
return new Field_set(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_set(ptr,field_length,null_pos,null_bit,
pack_length, interval, field_charset); unireg_check, field_name,
pack_length, interval, field_charset);
} }
} }
switch (field_type) { switch (field_type) {
case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_DECIMAL:
return new Field_decimal(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_decimal(ptr,field_length,null_pos,null_bit,
f_decimals(pack_flag), unireg_check, field_name,
f_is_zerofill(pack_flag) != 0, f_decimals(pack_flag),
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_NEWDECIMAL: case MYSQL_TYPE_NEWDECIMAL:
return new Field_new_decimal(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_new_decimal(ptr,field_length,null_pos,null_bit,
f_decimals(pack_flag), unireg_check, field_name,
f_is_zerofill(pack_flag) != 0, f_decimals(pack_flag),
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_FLOAT:
return new Field_float(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_float(ptr,field_length,null_pos,null_bit,
f_decimals(pack_flag), unireg_check, field_name,
f_is_zerofill(pack_flag) != 0, f_decimals(pack_flag),
f_is_dec(pack_flag)== 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag)== 0);
case MYSQL_TYPE_DOUBLE: case MYSQL_TYPE_DOUBLE:
return new Field_double(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_double(ptr,field_length,null_pos,null_bit,
f_decimals(pack_flag), unireg_check, field_name,
f_is_zerofill(pack_flag) != 0, f_decimals(pack_flag),
f_is_dec(pack_flag)== 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag)== 0);
case MYSQL_TYPE_TINY: case MYSQL_TYPE_TINY:
return new Field_tiny(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_tiny(ptr,field_length,null_pos,null_bit,
f_is_zerofill(pack_flag) != 0, unireg_check, field_name,
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_SHORT: case MYSQL_TYPE_SHORT:
return new Field_short(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_short(ptr,field_length,null_pos,null_bit,
f_is_zerofill(pack_flag) != 0, unireg_check, field_name,
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_INT24: case MYSQL_TYPE_INT24:
return new Field_medium(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_medium(ptr,field_length,null_pos,null_bit,
f_is_zerofill(pack_flag) != 0, unireg_check, field_name,
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_LONG: case MYSQL_TYPE_LONG:
return new Field_long(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_long(ptr,field_length,null_pos,null_bit,
f_is_zerofill(pack_flag) != 0, unireg_check, field_name,
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_LONGLONG: case MYSQL_TYPE_LONGLONG:
return new Field_longlong(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name, Field_longlong(ptr,field_length,null_pos,null_bit,
f_is_zerofill(pack_flag) != 0, unireg_check, field_name,
f_is_dec(pack_flag) == 0); f_is_zerofill(pack_flag) != 0,
f_is_dec(pack_flag) == 0);
case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_TIMESTAMP:
{ {
uint dec= field_length > MAX_DATETIME_WIDTH ? uint dec= field_length > MAX_DATETIME_WIDTH ?
field_length - MAX_DATETIME_WIDTH - 1: 0; field_length - MAX_DATETIME_WIDTH - 1: 0;
return new_Field_timestamp(ptr, null_pos, null_bit, unireg_check, return new_Field_timestamp(mem_root, ptr, null_pos, null_bit, unireg_check,
field_name, share, dec); field_name, share, dec);
} }
case MYSQL_TYPE_TIMESTAMP2: case MYSQL_TYPE_TIMESTAMP2:
{ {
uint dec= field_length > MAX_DATETIME_WIDTH ? uint dec= field_length > MAX_DATETIME_WIDTH ?
field_length - MAX_DATETIME_WIDTH - 1: 0; field_length - MAX_DATETIME_WIDTH - 1: 0;
return new Field_timestampf(ptr, null_pos, null_bit, unireg_check, return new (mem_root)
field_name, share, dec); Field_timestampf(ptr, null_pos, null_bit, unireg_check,
field_name, share, dec);
} }
case MYSQL_TYPE_YEAR: case MYSQL_TYPE_YEAR:
return new Field_year(ptr,field_length,null_pos,null_bit, return new (mem_root)
unireg_check, field_name); Field_year(ptr,field_length,null_pos,null_bit,
unireg_check, field_name);
case MYSQL_TYPE_DATE: case MYSQL_TYPE_DATE:
return new Field_date(ptr,null_pos,null_bit, return new (mem_root)
unireg_check, field_name); Field_date(ptr,null_pos,null_bit,
unireg_check, field_name);
case MYSQL_TYPE_NEWDATE: case MYSQL_TYPE_NEWDATE:
return new Field_newdate(ptr,null_pos,null_bit, return new (mem_root)
unireg_check, field_name); Field_newdate(ptr,null_pos,null_bit,
unireg_check, field_name);
case MYSQL_TYPE_TIME: case MYSQL_TYPE_TIME:
{ {
uint dec= field_length > MIN_TIME_WIDTH ? uint dec= field_length > MIN_TIME_WIDTH ?
field_length - MIN_TIME_WIDTH - 1: 0; field_length - MIN_TIME_WIDTH - 1: 0;
return new_Field_time(ptr, null_pos, null_bit, unireg_check, return new_Field_time(mem_root, ptr, null_pos, null_bit, unireg_check,
field_name, dec); field_name, dec);
} }
case MYSQL_TYPE_TIME2: case MYSQL_TYPE_TIME2:
{ {
uint dec= field_length > MIN_TIME_WIDTH ? uint dec= field_length > MIN_TIME_WIDTH ?
field_length - MIN_TIME_WIDTH - 1: 0; field_length - MIN_TIME_WIDTH - 1: 0;
return new Field_timef(ptr, null_pos, null_bit, unireg_check, return new (mem_root)
field_name, dec); Field_timef(ptr, null_pos, null_bit, unireg_check,
field_name, dec);
} }
case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_DATETIME:
{ {
uint dec= field_length > MAX_DATETIME_WIDTH ? uint dec= field_length > MAX_DATETIME_WIDTH ?
field_length - MAX_DATETIME_WIDTH - 1: 0; field_length - MAX_DATETIME_WIDTH - 1: 0;
return new_Field_datetime(ptr, null_pos, null_bit, unireg_check, return new_Field_datetime(mem_root, ptr, null_pos, null_bit, unireg_check,
field_name, dec); field_name, dec);
} }
case MYSQL_TYPE_DATETIME2: case MYSQL_TYPE_DATETIME2:
{ {
uint dec= field_length > MAX_DATETIME_WIDTH ? uint dec= field_length > MAX_DATETIME_WIDTH ?
field_length - MAX_DATETIME_WIDTH - 1: 0; field_length - MAX_DATETIME_WIDTH - 1: 0;
return new Field_datetimef(ptr, null_pos, null_bit, unireg_check, return new (mem_root)
field_name, dec); Field_datetimef(ptr, null_pos, null_bit, unireg_check,
field_name, dec);
} }
case MYSQL_TYPE_NULL: case MYSQL_TYPE_NULL:
return new Field_null(ptr, field_length, unireg_check, field_name, return new (mem_root)
field_charset); Field_null(ptr, field_length, unireg_check, field_name,
field_charset);
case MYSQL_TYPE_BIT: case MYSQL_TYPE_BIT:
return f_bit_as_char(pack_flag) ? return (f_bit_as_char(pack_flag) ?
new Field_bit_as_char(ptr, field_length, null_pos, null_bit, new (mem_root)
unireg_check, field_name) : Field_bit_as_char(ptr, field_length, null_pos, null_bit,
new Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr, unireg_check, field_name) :
bit_offset, unireg_check, field_name); new (mem_root)
Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr,
bit_offset, unireg_check, field_name));
default: // Impossible (Wrong version) default: // Impossible (Wrong version)
break; break;

View file

@ -1350,7 +1350,7 @@ public:
uint16 mflags, int *order_var); uint16 mflags, int *order_var);
uint is_equal(Create_field *new_field); uint is_equal(Create_field *new_field);
virtual const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end, uint param_data); virtual const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end, uint param_data);
static Field *create_from_item (Item *); static Field *create_from_item(MEM_ROOT *root, Item *);
}; };
@ -2329,45 +2329,50 @@ public:
static inline Field_timestamp * static inline Field_timestamp *
new_Field_timestamp(uchar *ptr, uchar *null_ptr, uchar null_bit, new_Field_timestamp(MEM_ROOT *root,uchar *ptr, uchar *null_ptr, uchar null_bit,
enum Field::utype unireg_check, const char *field_name, enum Field::utype unireg_check, const char *field_name,
TABLE_SHARE *share, uint dec) TABLE_SHARE *share, uint dec)
{ {
if (dec==0) if (dec==0)
return new Field_timestamp(ptr, MAX_DATETIME_WIDTH, null_ptr, null_bit, return new (root)
unireg_check, field_name, share); Field_timestamp(ptr, MAX_DATETIME_WIDTH, null_ptr,
null_bit, unireg_check, field_name, share);
if (dec == NOT_FIXED_DEC) if (dec == NOT_FIXED_DEC)
dec= MAX_DATETIME_PRECISION; dec= MAX_DATETIME_PRECISION;
return new Field_timestamp_hires(ptr, null_ptr, null_bit, unireg_check, return new (root)
field_name, share, dec); Field_timestamp_hires(ptr, null_ptr, null_bit, unireg_check,
field_name, share, dec);
} }
static inline Field_time * static inline Field_time *
new_Field_time(uchar *ptr, uchar *null_ptr, uchar null_bit, new_Field_time(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
enum Field::utype unireg_check, const char *field_name, enum Field::utype unireg_check, const char *field_name,
uint dec) uint dec)
{ {
if (dec == 0) if (dec == 0)
return new Field_time(ptr, MIN_TIME_WIDTH, null_ptr, null_bit, return new (root)
unireg_check, field_name); Field_time(ptr, MIN_TIME_WIDTH, null_ptr, null_bit, unireg_check,
field_name);
if (dec == NOT_FIXED_DEC) if (dec == NOT_FIXED_DEC)
dec= MAX_DATETIME_PRECISION; dec= MAX_DATETIME_PRECISION;
return new Field_time_hires(ptr, null_ptr, null_bit, return new (root)
unireg_check, field_name, dec); Field_time_hires(ptr, null_ptr, null_bit, unireg_check, field_name, dec);
} }
static inline Field_datetime * static inline Field_datetime *
new_Field_datetime(uchar *ptr, uchar *null_ptr, uchar null_bit, new_Field_datetime(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
enum Field::utype unireg_check, enum Field::utype unireg_check,
const char *field_name, uint dec) const char *field_name, uint dec)
{ {
if (dec == 0) if (dec == 0)
return new Field_datetime(ptr, MAX_DATETIME_WIDTH, null_ptr, null_bit, return new (root)
unireg_check, field_name); Field_datetime(ptr, MAX_DATETIME_WIDTH, null_ptr, null_bit,
unireg_check, field_name);
if (dec == NOT_FIXED_DEC) if (dec == NOT_FIXED_DEC)
dec= MAX_DATETIME_PRECISION; dec= MAX_DATETIME_PRECISION;
return new Field_datetime_hires(ptr, null_ptr, null_bit, return new (root)
unireg_check, field_name, dec); Field_datetime_hires(ptr, null_ptr, null_bit,
unireg_check, field_name, dec);
} }
class Field_string :public Field_longstr { class Field_string :public Field_longstr {
@ -3178,7 +3183,8 @@ public:
}; };
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length, Field *make_field(TABLE_SHARE *share, MEM_ROOT *mem_root,
uchar *ptr, uint32 field_length,
uchar *null_pos, uchar null_bit, uchar *null_pos, uchar null_bit,
uint pack_flag, enum_field_types field_type, uint pack_flag, enum_field_types field_type,
CHARSET_INFO *cs, CHARSET_INFO *cs,

View file

@ -2400,7 +2400,7 @@ reg_query_cache_dependant_table(THD *thd,
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
(++(*block_table))->n= ++(*n); (++(*block_table))->n= ++(*n);
if (!cache->insert_table(cache_key_len, if (!cache->insert_table(thd, cache_key_len,
cache_key, (*block_table), cache_key, (*block_table),
table_share->db.length, table_share->db.length,
(uint8) (cache_key_len - (uint8) (cache_key_len -

View file

@ -111,6 +111,8 @@ bool Item::val_bool()
*/ */
bool Item::get_date_with_conversion(MYSQL_TIME *ltime, ulonglong fuzzydate) bool Item::get_date_with_conversion(MYSQL_TIME *ltime, ulonglong fuzzydate)
{ {
THD *thd= current_thd;
/* /*
Some TIME type items return error when trying to do get_date() Some TIME type items return error when trying to do get_date()
without TIME_TIME_ONLY set (e.g. Item_field for Field_time). without TIME_TIME_ONLY set (e.g. Item_field for Field_time).
@ -119,7 +121,7 @@ bool Item::get_date_with_conversion(MYSQL_TIME *ltime, ulonglong fuzzydate)
and leave it to get_date() to check date. and leave it to get_date() to check date.
*/ */
ulonglong time_flag= (field_type() == MYSQL_TYPE_TIME && ulonglong time_flag= (field_type() == MYSQL_TYPE_TIME &&
!(current_thd->variables.old_behavior & OLD_MODE_ZERO_DATE_TIME_CAST)) ? !(thd->variables.old_behavior & OLD_MODE_ZERO_DATE_TIME_CAST)) ?
TIME_TIME_ONLY : 0; TIME_TIME_ONLY : 0;
if (get_date(ltime, fuzzydate | time_flag)) if (get_date(ltime, fuzzydate | time_flag))
return true; return true;
@ -127,7 +129,7 @@ bool Item::get_date_with_conversion(MYSQL_TIME *ltime, ulonglong fuzzydate)
!(fuzzydate & TIME_TIME_ONLY)) !(fuzzydate & TIME_TIME_ONLY))
{ {
MYSQL_TIME tmp; MYSQL_TIME tmp;
if (time_to_datetime_with_warn(current_thd, ltime, &tmp, fuzzydate)) if (time_to_datetime_with_warn(thd, ltime, &tmp, fuzzydate))
return null_value= true; return null_value= true;
*ltime= tmp; *ltime= tmp;
} }
@ -3033,17 +3035,17 @@ longlong_from_string_with_check(CHARSET_INFO *cs, const char *cptr,
int err; int err;
longlong tmp; longlong tmp;
char *end_of_num= (char*) end; char *end_of_num= (char*) end;
THD *thd= current_thd;
tmp= (*(cs->cset->strtoll10))(cs, cptr, &end_of_num, &err); tmp= (*(cs->cset->strtoll10))(cs, cptr, &end_of_num, &err);
/* /*
TODO: Give error if we wanted a signed integer and we got an unsigned TODO: Give error if we wanted a signed integer and we got an unsigned
one one
*/ */
if (!current_thd->no_errors && if (!thd->no_errors &&
(err > 0 || (err > 0 ||
(end != end_of_num && !check_if_only_end_space(cs, end_of_num, end)))) (end != end_of_num && !check_if_only_end_space(cs, end_of_num, end))))
{ {
THD *thd= current_thd;
ErrConvString err_str(cptr, end - cptr, cs); ErrConvString err_str(cptr, end - cptr, cs);
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_TRUNCATED_WRONG_VALUE, ER_TRUNCATED_WRONG_VALUE,
@ -5730,22 +5732,26 @@ bool Item::eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs)
Field *Item::make_string_field(TABLE *table) Field *Item::make_string_field(TABLE *table)
{ {
Field *field; Field *field;
MEM_ROOT *mem_root= table->in_use->mem_root;
DBUG_ASSERT(collation.collation); DBUG_ASSERT(collation.collation);
/* /*
Note: the following check is repeated in Note: the following check is repeated in
subquery_types_allow_materialization(): subquery_types_allow_materialization():
*/ */
if (too_big_for_varchar()) if (too_big_for_varchar())
field= new Field_blob(max_length, maybe_null, name, field= new (mem_root)
collation.collation, TRUE); Field_blob(max_length, maybe_null, name,
collation.collation, TRUE);
/* Item_type_holder holds the exact type, do not change it */ /* Item_type_holder holds the exact type, do not change it */
else if (max_length > 0 && else if (max_length > 0 &&
(type() != Item::TYPE_HOLDER || field_type() != MYSQL_TYPE_STRING)) (type() != Item::TYPE_HOLDER || field_type() != MYSQL_TYPE_STRING))
field= new Field_varstring(max_length, maybe_null, name, table->s, field= new (mem_root)
collation.collation); Field_varstring(max_length, maybe_null, name, table->s,
collation.collation);
else else
field= new Field_string(max_length, maybe_null, name, field= new (mem_root)
collation.collation); Field_string(max_length, maybe_null, name, collation.collation);
if (field) if (field)
field->init(table); field->init(table);
return field; return field;
@ -5771,63 +5777,74 @@ Field *Item::tmp_table_field_from_field_type(TABLE *table, bool fixed_length)
*/ */
uchar *null_ptr= maybe_null ? (uchar*) "" : 0; uchar *null_ptr= maybe_null ? (uchar*) "" : 0;
Field *field; Field *field;
MEM_ROOT *mem_root= table->in_use->mem_root;
switch (field_type()) { switch (field_type()) {
case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL: case MYSQL_TYPE_NEWDECIMAL:
field= Field_new_decimal::create_from_item(this); field= Field_new_decimal::create_from_item(mem_root, this);
break; break;
case MYSQL_TYPE_TINY: case MYSQL_TYPE_TINY:
field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, 0, unsigned_flag); Field_tiny((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, 0, unsigned_flag);
break; break;
case MYSQL_TYPE_SHORT: case MYSQL_TYPE_SHORT:
field= new Field_short((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, 0, unsigned_flag); Field_short((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, 0, unsigned_flag);
break; break;
case MYSQL_TYPE_LONG: case MYSQL_TYPE_LONG:
field= new Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, 0, unsigned_flag); Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, 0, unsigned_flag);
break; break;
#ifdef HAVE_LONG_LONG #ifdef HAVE_LONG_LONG
case MYSQL_TYPE_LONGLONG: case MYSQL_TYPE_LONGLONG:
field= new Field_longlong((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, 0, unsigned_flag); Field_longlong((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, 0, unsigned_flag);
break; break;
#endif #endif
case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_FLOAT:
field= new Field_float((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, decimals, 0, unsigned_flag); Field_float((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, decimals, 0, unsigned_flag);
break; break;
case MYSQL_TYPE_DOUBLE: case MYSQL_TYPE_DOUBLE:
field= new Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, decimals, 0, unsigned_flag); Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, decimals, 0, unsigned_flag);
break; break;
case MYSQL_TYPE_INT24: case MYSQL_TYPE_INT24:
field= new Field_medium((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name, 0, unsigned_flag); Field_medium((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
name, 0, unsigned_flag);
break; break;
case MYSQL_TYPE_NEWDATE: case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_DATE: case MYSQL_TYPE_DATE:
field= new Field_newdate(0, null_ptr, 0, Field::NONE, name); field= new (mem_root)
Field_newdate(0, null_ptr, 0, Field::NONE, name);
break; break;
case MYSQL_TYPE_TIME: case MYSQL_TYPE_TIME:
field= new_Field_time(0, null_ptr, 0, Field::NONE, name, decimals); field= new_Field_time(mem_root, 0, null_ptr, 0, Field::NONE, name,
decimals);
break; break;
case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_TIMESTAMP:
field= new_Field_timestamp(0, null_ptr, 0, field= new_Field_timestamp(mem_root, 0, null_ptr, 0,
Field::NONE, name, 0, decimals); Field::NONE, name, 0, decimals);
break; break;
case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_DATETIME:
field= new_Field_datetime(0, null_ptr, 0, Field::NONE, name, decimals); field= new_Field_datetime(mem_root, 0, null_ptr, 0, Field::NONE, name,
decimals);
break; break;
case MYSQL_TYPE_YEAR: case MYSQL_TYPE_YEAR:
field= new Field_year((uchar*) 0, max_length, null_ptr, 0, Field::NONE, field= new (mem_root)
name); Field_year((uchar*) 0, max_length, null_ptr, 0, Field::NONE, name);
break; break;
case MYSQL_TYPE_BIT: case MYSQL_TYPE_BIT:
field= new Field_bit_as_char(NULL, max_length, null_ptr, 0, field= new (mem_root)
Field::NONE, name); Field_bit_as_char(NULL, max_length, null_ptr, 0, Field::NONE, name);
break; break;
default: default:
/* This case should never be chosen */ /* This case should never be chosen */
@ -5837,8 +5854,8 @@ Field *Item::tmp_table_field_from_field_type(TABLE *table, bool fixed_length)
case MYSQL_TYPE_STRING: case MYSQL_TYPE_STRING:
if (fixed_length && !too_big_for_varchar()) if (fixed_length && !too_big_for_varchar())
{ {
field= new Field_string(max_length, maybe_null, name, field= new (mem_root)
collation.collation); Field_string(max_length, maybe_null, name, collation.collation);
break; break;
} }
/* Fall through to make_string_field() */ /* Fall through to make_string_field() */
@ -5852,15 +5869,16 @@ Field *Item::tmp_table_field_from_field_type(TABLE *table, bool fixed_length)
case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB: case MYSQL_TYPE_BLOB:
if (this->type() == Item::TYPE_HOLDER) if (this->type() == Item::TYPE_HOLDER)
field= new Field_blob(max_length, maybe_null, name, collation.collation, field= new (mem_root)
1); Field_blob(max_length, maybe_null, name, collation.collation, 1);
else else
field= new Field_blob(max_length, maybe_null, name, collation.collation); field= new (mem_root)
Field_blob(max_length, maybe_null, name, collation.collation);
break; // Blob handled outside of case break; // Blob handled outside of case
#ifdef HAVE_SPATIAL #ifdef HAVE_SPATIAL
case MYSQL_TYPE_GEOMETRY: case MYSQL_TYPE_GEOMETRY:
field= new Field_geom(max_length, maybe_null, field= new (mem_root)
name, table->s, get_geometry_type()); Field_geom(max_length, maybe_null, name, table->s, get_geometry_type());
#endif /* HAVE_SPATIAL */ #endif /* HAVE_SPATIAL */
} }
if (field) if (field)
@ -9288,10 +9306,9 @@ int Item_cache_str::save_in_field(Field *field, bool no_conversions)
} }
bool Item_cache_row::allocate(uint num) bool Item_cache_row::allocate(THD *thd, uint num)
{ {
item_count= num; item_count= num;
THD *thd= current_thd;
return (!(values= return (!(values=
(Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count))); (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
} }
@ -9300,7 +9317,7 @@ bool Item_cache_row::allocate(uint num)
bool Item_cache_row::setup(THD *thd, Item *item) bool Item_cache_row::setup(THD *thd, Item *item)
{ {
example= item; example= item;
if (!values && allocate(item->cols())) if (!values && allocate(thd, item->cols()))
return 1; return 1;
for (uint i= 0; i < item_count; i++) for (uint i= 0; i < item_count; i++)
{ {

View file

@ -4769,7 +4769,7 @@ public:
null_value= 1; null_value= 1;
} }
virtual bool allocate(uint i) { return 0; } virtual bool allocate(THD *thd, uint i) { return 0; }
virtual bool setup(THD *thd, Item *item) virtual bool setup(THD *thd, Item *item)
{ {
example= item; example= item;
@ -4950,7 +4950,7 @@ public:
'allocate' used only in row transformer, to preallocate space for row 'allocate' used only in row transformer, to preallocate space for row
cache. cache.
*/ */
bool allocate(uint num); bool allocate(THD *thd, uint num);
/* /*
'setup' is needed only by row => it not called by simple row subselect 'setup' is needed only by row => it not called by simple row subselect
(only by IN subselect (in subselect optimizer)) (only by IN subselect (in subselect optimizer))

View file

@ -1849,7 +1849,7 @@ Item *Item_in_optimizer::transform(THD *thd, Item_transformer transformer,
Item_subselect::ANY_SUBS)); Item_subselect::ANY_SUBS));
Item_in_subselect *in_arg= (Item_in_subselect*)args[1]; Item_in_subselect *in_arg= (Item_in_subselect*)args[1];
current_thd->change_item_tree(&in_arg->left_expr, args[0]); thd->change_item_tree(&in_arg->left_expr, args[0]);
} }
return (this->*transformer)(thd, argument); return (this->*transformer)(thd, argument);
} }

View file

@ -6312,7 +6312,7 @@ Item *create_temporal_literal(THD *thd,
if (status.warnings) // e.g. a note on nanosecond truncation if (status.warnings) // e.g. a note on nanosecond truncation
{ {
ErrConvString err(str, length, cs); ErrConvString err(str, length, cs);
make_truncated_value_warning(current_thd, make_truncated_value_warning(thd,
Sql_condition::time_warn_level(status.warnings), Sql_condition::time_warn_level(status.warnings),
&err, ltime.time_type, 0); &err, ltime.time_type, 0);
} }

View file

@ -521,23 +521,27 @@ bool Item_func::eq(const Item *item, bool binary_cmp) const
Field *Item_func::tmp_table_field(TABLE *table) Field *Item_func::tmp_table_field(TABLE *table)
{ {
Field *field= NULL; Field *field= NULL;
MEM_ROOT *mem_root= table->in_use->mem_root;
switch (result_type()) { switch (result_type()) {
case INT_RESULT: case INT_RESULT:
if (max_char_length() > MY_INT32_NUM_DECIMAL_DIGITS) if (max_char_length() > MY_INT32_NUM_DECIMAL_DIGITS)
field= new Field_longlong(max_char_length(), maybe_null, name, field= new (mem_root)
unsigned_flag); Field_longlong(max_char_length(), maybe_null, name,
unsigned_flag);
else else
field= new Field_long(max_char_length(), maybe_null, name, field= new (mem_root)
unsigned_flag); Field_long(max_char_length(), maybe_null, name,
unsigned_flag);
break; break;
case REAL_RESULT: case REAL_RESULT:
field= new Field_double(max_char_length(), maybe_null, name, decimals); field= new (mem_root)
Field_double(max_char_length(), maybe_null, name, decimals);
break; break;
case STRING_RESULT: case STRING_RESULT:
return make_string_field(table); return make_string_field(table);
case DECIMAL_RESULT: case DECIMAL_RESULT:
field= Field_new_decimal::create_from_item(this); field= Field_new_decimal::create_from_item(mem_root, this);
break; break;
case ROW_RESULT: case ROW_RESULT:
case TIME_RESULT: case TIME_RESULT:
@ -6507,7 +6511,7 @@ Item_func_sp::Item_func_sp(THD *thd, Name_resolution_context *context_arg,
Item_func(thd), context(context_arg), m_name(name), m_sp(NULL), sp_result_field(NULL) Item_func(thd), context(context_arg), m_name(name), m_sp(NULL), sp_result_field(NULL)
{ {
maybe_null= 1; maybe_null= 1;
m_name->init_qname(current_thd); m_name->init_qname(thd);
dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE)); dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
dummy_table->s= (TABLE_SHARE*) (dummy_table+1); dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
} }
@ -6519,7 +6523,7 @@ Item_func_sp::Item_func_sp(THD *thd, Name_resolution_context *context_arg,
sp_result_field(NULL) sp_result_field(NULL)
{ {
maybe_null= 1; maybe_null= 1;
m_name->init_qname(current_thd); m_name->init_qname(thd);
dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE)); dummy_table= (TABLE*) thd->calloc(sizeof(TABLE)+ sizeof(TABLE_SHARE));
dummy_table->s= (TABLE_SHARE*) (dummy_table+1); dummy_table->s= (TABLE_SHARE*) (dummy_table+1);
} }

View file

@ -1011,8 +1011,10 @@ String *Item_func_concat_ws::val_str(String *str)
if (!(res2= args[i]->val_str(use_as_buff))) if (!(res2= args[i]->val_str(use_as_buff)))
continue; // Skip NULL continue; // Skip NULL
if (!thd)
thd= current_thd;
if (res->length() + sep_str->length() + res2->length() > if (res->length() + sep_str->length() + res2->length() >
(thd ? thd : (thd= current_thd))->variables.max_allowed_packet) thd->variables.max_allowed_packet)
{ {
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_WARN_ALLOWED_PACKET_OVERFLOWED, ER_WARN_ALLOWED_PACKET_OVERFLOWED,
@ -1273,8 +1275,12 @@ redo:
while (j != search_end) while (j != search_end)
if (*i++ != *j++) goto skip; if (*i++ != *j++) goto skip;
offset= (int) (ptr-res->ptr()); offset= (int) (ptr-res->ptr());
if (!thd)
thd= current_thd;
if (res->length()-from_length + to_length > if (res->length()-from_length + to_length >
(thd ? thd : (thd= current_thd))->variables.max_allowed_packet) thd->variables.max_allowed_packet)
{ {
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_WARN_ALLOWED_PACKET_OVERFLOWED, ER_WARN_ALLOWED_PACKET_OVERFLOWED,
@ -1301,7 +1307,7 @@ redo:
else else
#endif /* USE_MB */ #endif /* USE_MB */
{ {
THD *thd= current_thd; thd= current_thd;
do do
{ {
if (res->length()-from_length + to_length > if (res->length()-from_length + to_length >

View file

@ -502,23 +502,27 @@ Field *Item_sum::create_tmp_field(bool group, TABLE *table,
uint convert_blob_length) uint convert_blob_length)
{ {
Field *UNINIT_VAR(field); Field *UNINIT_VAR(field);
MEM_ROOT *mem_root= table->in_use->mem_root;
switch (result_type()) { switch (result_type()) {
case REAL_RESULT: case REAL_RESULT:
field= new Field_double(max_length, maybe_null, name, decimals, TRUE); field= new (mem_root)
Field_double(max_length, maybe_null, name, decimals, TRUE);
break; break;
case INT_RESULT: case INT_RESULT:
field= new Field_longlong(max_length, maybe_null, name, unsigned_flag); field= new (mem_root)
Field_longlong(max_length, maybe_null, name, unsigned_flag);
break; break;
case STRING_RESULT: case STRING_RESULT:
if (max_length/collation.collation->mbmaxlen <= 255 || if (max_length/collation.collation->mbmaxlen <= 255 ||
convert_blob_length > Field_varstring::MAX_SIZE || convert_blob_length > Field_varstring::MAX_SIZE ||
!convert_blob_length) !convert_blob_length)
return make_string_field(table); return make_string_field(table);
field= new Field_varstring(convert_blob_length, maybe_null, field= new (mem_root) Field_varstring(convert_blob_length, maybe_null,
name, table->s, collation.collation); name, table->s, collation.collation);
break; break;
case DECIMAL_RESULT: case DECIMAL_RESULT:
field= Field_new_decimal::create_from_item(this); field= Field_new_decimal::create_from_item(mem_root, this);
break; break;
case ROW_RESULT: case ROW_RESULT:
case TIME_RESULT: case TIME_RESULT:
@ -1266,33 +1270,37 @@ Field *Item_sum_hybrid::create_tmp_field(bool group, TABLE *table,
uint convert_blob_length) uint convert_blob_length)
{ {
Field *field; Field *field;
MEM_ROOT *mem_root;
if (args[0]->type() == Item::FIELD_ITEM) if (args[0]->type() == Item::FIELD_ITEM)
{ {
field= ((Item_field*) args[0])->field; field= ((Item_field*) args[0])->field;
if ((field= create_tmp_field_from_field(current_thd, field, name, table, if ((field= create_tmp_field_from_field(table->in_use, field, name, table,
NULL, convert_blob_length))) NULL, convert_blob_length)))
field->flags&= ~NOT_NULL_FLAG; field->flags&= ~NOT_NULL_FLAG;
return field; return field;
} }
/* /*
DATE/TIME fields have STRING_RESULT result types. DATE/TIME fields have STRING_RESULT result types.
In order to preserve field type, it's needed to handle DATE/TIME In order to preserve field type, it's needed to handle DATE/TIME
fields creations separately. fields creations separately.
*/ */
mem_root= table->in_use->mem_root;
switch (args[0]->field_type()) { switch (args[0]->field_type()) {
case MYSQL_TYPE_DATE: case MYSQL_TYPE_DATE:
field= new Field_newdate(0, maybe_null ? (uchar*)"" : 0, 0, Field::NONE, field= new (mem_root)
name); Field_newdate(0, maybe_null ? (uchar*)"" : 0, 0, Field::NONE, name);
break; break;
case MYSQL_TYPE_TIME: case MYSQL_TYPE_TIME:
field= new_Field_time(0, maybe_null ? (uchar*)"" : 0, 0, Field::NONE, field= new_Field_time(mem_root, 0, maybe_null ? (uchar*)"" : 0, 0,
name, decimals); Field::NONE, name, decimals);
break; break;
case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_TIMESTAMP:
case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_DATETIME:
field= new_Field_datetime(0, maybe_null ? (uchar*)"" : 0, 0, Field::NONE, field= new_Field_datetime(mem_root, 0, maybe_null ? (uchar*)"" : 0, 0,
name, decimals); Field::NONE, name, decimals);
break; break;
default: default:
return Item_sum::create_tmp_field(group, table, convert_blob_length); return Item_sum::create_tmp_field(group, table, convert_blob_length);
@ -1657,6 +1665,8 @@ Field *Item_sum_avg::create_tmp_field(bool group, TABLE *table,
uint convert_blob_len) uint convert_blob_len)
{ {
Field *field; Field *field;
MEM_ROOT *mem_root= table->in_use->mem_root;
if (group) if (group)
{ {
/* /*
@ -1664,14 +1674,16 @@ Field *Item_sum_avg::create_tmp_field(bool group, TABLE *table,
The easiest way is to do this is to store both value in a string The easiest way is to do this is to store both value in a string
and unpack on access. and unpack on access.
*/ */
field= new Field_string(((hybrid_type == DECIMAL_RESULT) ? field= new (mem_root)
dec_bin_size : sizeof(double)) + sizeof(longlong), Field_string(((hybrid_type == DECIMAL_RESULT) ?
0, name, &my_charset_bin); dec_bin_size : sizeof(double)) + sizeof(longlong),
0, name, &my_charset_bin);
} }
else if (hybrid_type == DECIMAL_RESULT) else if (hybrid_type == DECIMAL_RESULT)
field= Field_new_decimal::create_from_item(this); field= Field_new_decimal::create_from_item(mem_root, this);
else else
field= new Field_double(max_length, maybe_null, name, decimals, TRUE); field= new (mem_root) Field_double(max_length, maybe_null, name, decimals,
TRUE);
if (field) if (field)
field->init(table); field->init(table);
return field; return field;

View file

@ -6165,7 +6165,7 @@ static void bootstrap(MYSQL_FILE *file)
thd->variables.wsrep_on= 0; thd->variables.wsrep_on= 0;
#endif #endif
thd->bootstrap=1; thd->bootstrap=1;
my_net_init(&thd->net,(st_vio*) 0, MYF(0)); my_net_init(&thd->net,(st_vio*) 0, (void*) 0, MYF(0));
thd->max_client_packet_length= thd->net.max_packet; thd->max_client_packet_length= thd->net.max_packet;
thd->security_ctx->master_access= ~(ulong)0; thd->security_ctx->master_access= ~(ulong)0;
thd->thread_id= thd->variables.pseudo_thread_id= thread_id++; thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
@ -6634,7 +6634,7 @@ void handle_connections_sockets()
mysql_socket_vio_new(new_sock, mysql_socket_vio_new(new_sock,
is_unix_sock ? VIO_TYPE_SOCKET : VIO_TYPE_TCPIP, is_unix_sock ? VIO_TYPE_SOCKET : VIO_TYPE_TCPIP,
is_unix_sock ? VIO_LOCALHOST: 0)) || is_unix_sock ? VIO_LOCALHOST: 0)) ||
my_net_init(&thd->net, vio_tmp, MYF(MY_THREAD_SPECIFIC))) my_net_init(&thd->net, vio_tmp, thd, MYF(MY_THREAD_SPECIFIC)))
{ {
/* /*
Only delete the temporary vio if we didn't already attach it to the Only delete the temporary vio if we didn't already attach it to the
@ -6759,7 +6759,7 @@ pthread_handler_t handle_connections_namedpipes(void *arg)
} }
set_current_thd(thd); set_current_thd(thd);
if (!(thd->net.vio= vio_new_win32pipe(hConnectedPipe)) || if (!(thd->net.vio= vio_new_win32pipe(hConnectedPipe)) ||
my_net_init(&thd->net, thd->net.vio, MYF(MY_THREAD_SPECIFIC))) my_net_init(&thd->net, thd->net.vio, thd, MYF(MY_THREAD_SPECIFIC)))
{ {
close_connection(thd, ER_OUT_OF_RESOURCES); close_connection(thd, ER_OUT_OF_RESOURCES);
delete thd; delete thd;
@ -6956,7 +6956,7 @@ pthread_handler_t handle_connections_shared_memory(void *arg)
event_server_wrote, event_server_wrote,
event_server_read, event_server_read,
event_conn_closed)) || event_conn_closed)) ||
my_net_init(&thd->net, thd->net.vio, MYF(MY_THREAD_SPECIFIC))) my_net_init(&thd->net, thd->net.vio, thd, MYF(MY_THREAD_SPECIFIC)))
{ {
close_connection(thd, ER_OUT_OF_RESOURCES); close_connection(thd, ER_OUT_OF_RESOURCES);
errmsg= 0; errmsg= 0;

View file

@ -103,7 +103,7 @@ extern uint test_flags;
extern ulong bytes_sent, bytes_received, net_big_packet_count; extern ulong bytes_sent, bytes_received, net_big_packet_count;
#ifdef HAVE_QUERY_CACHE #ifdef HAVE_QUERY_CACHE
#define USE_QUERY_CACHE #define USE_QUERY_CACHE
extern void query_cache_insert(const char *packet, ulong length, extern void query_cache_insert(void *thd, const char *packet, ulong length,
unsigned pkt_nr); unsigned pkt_nr);
#endif // HAVE_QUERY_CACHE #endif // HAVE_QUERY_CACHE
#define update_statistics(A) A #define update_statistics(A) A
@ -123,7 +123,7 @@ static my_bool net_write_buff(NET *, const uchar *, ulong);
/** Init with packet info. */ /** Init with packet info. */
my_bool my_net_init(NET *net, Vio* vio, uint my_flags) my_bool my_net_init(NET *net, Vio *vio, void *thd, uint my_flags)
{ {
DBUG_ENTER("my_net_init"); DBUG_ENTER("my_net_init");
DBUG_PRINT("enter", ("my_flags: %u", my_flags)); DBUG_PRINT("enter", ("my_flags: %u", my_flags));
@ -142,10 +142,11 @@ my_bool my_net_init(NET *net, Vio* vio, uint my_flags)
net->where_b = net->remain_in_buf=0; net->where_b = net->remain_in_buf=0;
net->net_skip_rest_factor= 0; net->net_skip_rest_factor= 0;
net->last_errno=0; net->last_errno=0;
net->unused= 0;
net->thread_specific_malloc= MY_TEST(my_flags & MY_THREAD_SPECIFIC); net->thread_specific_malloc= MY_TEST(my_flags & MY_THREAD_SPECIFIC);
net->thd= 0;
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
net->extension= NULL; net->extension= NULL;
net->thd= thd;
#endif #endif
if (vio) if (vio)
@ -602,7 +603,7 @@ net_real_write(NET *net,const uchar *packet, size_t len)
DBUG_ENTER("net_real_write"); DBUG_ENTER("net_real_write");
#if defined(MYSQL_SERVER) && defined(USE_QUERY_CACHE) #if defined(MYSQL_SERVER) && defined(USE_QUERY_CACHE)
query_cache_insert((char*) packet, len, net->pkt_nr); query_cache_insert(net->thd, (char*) packet, len, net->pkt_nr);
#endif #endif
if (net->error == 2) if (net->error == 2)
@ -705,7 +706,7 @@ net_real_write(NET *net,const uchar *packet, size_t len)
break; break;
} }
pos+=length; pos+=length;
update_statistics(thd_increment_bytes_sent(length)); update_statistics(thd_increment_bytes_sent(net->thd, length));
} }
#ifndef __WIN__ #ifndef __WIN__
end: end:
@ -778,7 +779,7 @@ static my_bool my_net_skip_rest(NET *net, uint32 remain, thr_alarm_t *alarmed,
DBUG_PRINT("enter",("bytes_to_skip: %u", (uint) remain)); DBUG_PRINT("enter",("bytes_to_skip: %u", (uint) remain));
/* The following is good for debugging */ /* The following is good for debugging */
update_statistics(thd_increment_net_big_packet_count(1)); update_statistics(thd_increment_net_big_packet_count(net->thd, 1));
if (!thr_alarm_in_use(alarmed)) if (!thr_alarm_in_use(alarmed))
{ {
@ -794,7 +795,7 @@ static my_bool my_net_skip_rest(NET *net, uint32 remain, thr_alarm_t *alarmed,
size_t length= MY_MIN(remain, net->max_packet); size_t length= MY_MIN(remain, net->max_packet);
if (net_safe_read(net, net->buff, length, alarmed)) if (net_safe_read(net, net->buff, length, alarmed))
DBUG_RETURN(1); DBUG_RETURN(1);
update_statistics(thd_increment_bytes_received(length)); update_statistics(thd_increment_bytes_received(net->thd, length));
remain -= (uint32) length; remain -= (uint32) length;
limit-= length; limit-= length;
if (limit < 0) if (limit < 0)
@ -935,7 +936,7 @@ my_real_read(NET *net, size_t *complen,
} }
remain -= (uint32) length; remain -= (uint32) length;
pos+= length; pos+= length;
update_statistics(thd_increment_bytes_received(length)); update_statistics(thd_increment_bytes_received(net->thd, length));
} }
if (i == 0) if (i == 0)
{ /* First parts is packet length */ { /* First parts is packet length */

View file

@ -3061,7 +3061,7 @@ static int init_slave_thread(THD* thd, Master_info *mi,
simulate_error|= (1 << SLAVE_THD_SQL);); simulate_error|= (1 << SLAVE_THD_SQL););
/* We must call store_globals() before doing my_net_init() */ /* We must call store_globals() before doing my_net_init() */
if (init_thr_lock() || thd->store_globals() || if (init_thr_lock() || thd->store_globals() ||
my_net_init(&thd->net, 0, MYF(MY_THREAD_SPECIFIC)) || my_net_init(&thd->net, 0, thd, MYF(MY_THREAD_SPECIFIC)) ||
IF_DBUG(simulate_error & (1<< thd_type), 0)) IF_DBUG(simulate_error & (1<< thd_type), 0))
{ {
thd->cleanup(); thd->cleanup();

View file

@ -872,6 +872,7 @@ sp_head::create_result_field(uint field_max_length, const char *field_name,
field_max_length : m_return_field_def.length; field_max_length : m_return_field_def.length;
field= ::make_field(table->s, /* TABLE_SHARE ptr */ field= ::make_field(table->s, /* TABLE_SHARE ptr */
table->in_use->mem_root,
(uchar*) 0, /* field ptr */ (uchar*) 0, /* field ptr */
field_length, /* field [max] length */ field_length, /* field [max] length */
(uchar*) "", /* null ptr */ (uchar*) "", /* null ptr */

View file

@ -8575,7 +8575,7 @@ static int handle_roles_mappings_table(TABLE *table, bool drop,
int error; int error;
int result= 0; int result= 0;
THD *thd= current_thd; THD *thd= table->in_use;
const char *host, *user, *role; const char *host, *user, *role;
Field *host_field= table->field[0]; Field *host_field= table->field[0];
Field *user_field= table->field[1]; Field *user_field= table->field[1];
@ -8668,7 +8668,7 @@ static int handle_roles_mappings_table(TABLE *table, bool drop,
< 0 Error. < 0 Error.
*/ */
static int handle_grant_table(TABLE_LIST *tables, static int handle_grant_table(THD *thd, TABLE_LIST *tables,
enum enum_acl_tables table_no, bool drop, enum enum_acl_tables table_no, bool drop,
LEX_USER *user_from, LEX_USER *user_to) LEX_USER *user_from, LEX_USER *user_to)
{ {
@ -8685,7 +8685,6 @@ static int handle_grant_table(TABLE_LIST *tables,
uchar user_key[MAX_KEY_LENGTH]; uchar user_key[MAX_KEY_LENGTH];
uint key_prefix_length; uint key_prefix_length;
DBUG_ENTER("handle_grant_table"); DBUG_ENTER("handle_grant_table");
THD *thd= current_thd;
if (table_no == ROLES_MAPPING_TABLE) if (table_no == ROLES_MAPPING_TABLE)
{ {
@ -9189,7 +9188,7 @@ static int handle_grant_struct(enum enum_acl_lists struct_no, bool drop,
< 0 Error. < 0 Error.
*/ */
static int handle_grant_data(TABLE_LIST *tables, bool drop, static int handle_grant_data(THD *thd, TABLE_LIST *tables, bool drop,
LEX_USER *user_from, LEX_USER *user_to) LEX_USER *user_from, LEX_USER *user_to)
{ {
int result= 0; int result= 0;
@ -9212,7 +9211,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
} }
/* Handle db table. */ /* Handle db table. */
if ((found= handle_grant_table(tables, DB_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, DB_TABLE, drop, user_from,
user_to)) < 0)
{ {
/* Handle of table failed, don't touch the in-memory array. */ /* Handle of table failed, don't touch the in-memory array. */
result= -1; result= -1;
@ -9232,7 +9232,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
} }
/* Handle stored routines table. */ /* Handle stored routines table. */
if ((found= handle_grant_table(tables, PROCS_PRIV_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, PROCS_PRIV_TABLE, drop,
user_from, user_to)) < 0)
{ {
/* Handle of table failed, don't touch in-memory array. */ /* Handle of table failed, don't touch in-memory array. */
result= -1; result= -1;
@ -9260,7 +9261,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
} }
/* Handle tables table. */ /* Handle tables table. */
if ((found= handle_grant_table(tables, TABLES_PRIV_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, TABLES_PRIV_TABLE, drop,
user_from, user_to)) < 0)
{ {
/* Handle of table failed, don't touch columns and in-memory array. */ /* Handle of table failed, don't touch columns and in-memory array. */
result= -1; result= -1;
@ -9276,7 +9278,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
} }
/* Handle columns table. */ /* Handle columns table. */
if ((found= handle_grant_table(tables, COLUMNS_PRIV_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, COLUMNS_PRIV_TABLE, drop,
user_from, user_to)) < 0)
{ {
/* Handle of table failed, don't touch the in-memory array. */ /* Handle of table failed, don't touch the in-memory array. */
result= -1; result= -1;
@ -9295,7 +9298,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
/* Handle proxies_priv table. */ /* Handle proxies_priv table. */
if (tables[PROXIES_PRIV_TABLE].table) if (tables[PROXIES_PRIV_TABLE].table)
{ {
if ((found= handle_grant_table(tables, PROXIES_PRIV_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, PROXIES_PRIV_TABLE, drop,
user_from, user_to)) < 0)
{ {
/* Handle of table failed, don't touch the in-memory array. */ /* Handle of table failed, don't touch the in-memory array. */
result= -1; result= -1;
@ -9314,7 +9318,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
/* Handle roles_mapping table. */ /* Handle roles_mapping table. */
if (tables[ROLES_MAPPING_TABLE].table) if (tables[ROLES_MAPPING_TABLE].table)
{ {
if ((found= handle_grant_table(tables, ROLES_MAPPING_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, ROLES_MAPPING_TABLE, drop,
user_from, user_to)) < 0)
{ {
/* Handle of table failed, don't touch the in-memory array. */ /* Handle of table failed, don't touch the in-memory array. */
result= -1; result= -1;
@ -9331,7 +9336,8 @@ static int handle_grant_data(TABLE_LIST *tables, bool drop,
} }
/* Handle user table. */ /* Handle user table. */
if ((found= handle_grant_table(tables, USER_TABLE, drop, user_from, user_to)) < 0) if ((found= handle_grant_table(thd, tables, USER_TABLE, drop, user_from,
user_to)) < 0)
{ {
/* Handle of table failed, don't touch the in-memory array. */ /* Handle of table failed, don't touch the in-memory array. */
result= -1; result= -1;
@ -9425,12 +9431,12 @@ bool mysql_create_user(THD *thd, List <LEX_USER> &list, bool handle_as_role)
Search all in-memory structures and grant tables Search all in-memory structures and grant tables
for a mention of the new user/role name. for a mention of the new user/role name.
*/ */
if (handle_grant_data(tables, 0, user_name, NULL)) if (handle_grant_data(thd, tables, 0, user_name, NULL))
{ {
if (thd->lex->create_info.or_replace()) if (thd->lex->create_info.or_replace())
{ {
// Drop the existing user // Drop the existing user
if (handle_grant_data(tables, 1, user_name, NULL) <= 0) if (handle_grant_data(thd, tables, 1, user_name, NULL) <= 0)
{ {
// DROP failed // DROP failed
append_user(thd, &wrong_users, user_name); append_user(thd, &wrong_users, user_name);
@ -9573,7 +9579,7 @@ bool mysql_drop_user(THD *thd, List <LEX_USER> &list, bool handle_as_role)
continue; continue;
} }
if ((rc= handle_grant_data(tables, 1, user_name, NULL)) > 0) if ((rc= handle_grant_data(thd, tables, 1, user_name, NULL)) > 0)
{ {
// The user or role was successfully deleted // The user or role was successfully deleted
binlog= true; binlog= true;
@ -9686,8 +9692,8 @@ bool mysql_rename_user(THD *thd, List <LEX_USER> &list)
Search all in-memory structures and grant tables Search all in-memory structures and grant tables
for a mention of the new user name. for a mention of the new user name.
*/ */
if (handle_grant_data(tables, 0, user_to, NULL) || if (handle_grant_data(thd, tables, 0, user_to, NULL) ||
handle_grant_data(tables, 0, user_from, user_to) <= 0) handle_grant_data(thd, tables, 0, user_from, user_to) <= 0)
{ {
/* NOTE TODO renaming roles is not yet implemented */ /* NOTE TODO renaming roles is not yet implemented */
append_user(thd, &wrong_users, user_from); append_user(thd, &wrong_users, user_from);

View file

@ -397,9 +397,9 @@ const uchar *query_state_map;
#if defined(ENABLED_DEBUG_SYNC) #if defined(ENABLED_DEBUG_SYNC)
#define QC_DEBUG_SYNC(name) \ #define QC_DEBUG_SYNC(name) \
do { \ do { \
THD *thd= current_thd; \ THD *thd_tmp= current_thd; \
if (thd) \ if (thd_tmp) \
DEBUG_SYNC(thd, name); \ DEBUG_SYNC(thd_tmp, name); \
} while (0) } while (0)
#else #else
#define QC_DEBUG_SYNC(name) #define QC_DEBUG_SYNC(name)
@ -1037,10 +1037,10 @@ uchar *query_cache_query_get_key(const uchar *record, size_t *length,
/** /**
libmysql convenience wrapper to insert data into query cache. libmysql convenience wrapper to insert data into query cache.
*/ */
void query_cache_insert(const char *packet, ulong length, void query_cache_insert(void *thd_arg, const char *packet, ulong length,
unsigned pkt_nr) unsigned pkt_nr)
{ {
THD *thd= current_thd; THD *thd= (THD*) thd_arg;
/* /*
Current_thd can be NULL when a new connection is immediately ended Current_thd can be NULL when a new connection is immediately ended
@ -1052,7 +1052,7 @@ void query_cache_insert(const char *packet, ulong length,
if (!thd) if (!thd)
return; return;
query_cache.insert(&thd->query_cache_tls, query_cache.insert(thd, &thd->query_cache_tls,
packet, length, packet, length,
pkt_nr); pkt_nr);
} }
@ -1063,7 +1063,7 @@ void query_cache_insert(const char *packet, ulong length,
*/ */
void void
Query_cache::insert(Query_cache_tls *query_cache_tls, Query_cache::insert(THD *thd, Query_cache_tls *query_cache_tls,
const char *packet, ulong length, const char *packet, ulong length,
unsigned pkt_nr) unsigned pkt_nr)
{ {
@ -1073,15 +1073,13 @@ Query_cache::insert(Query_cache_tls *query_cache_tls,
if (is_disabled() || query_cache_tls->first_query_block == NULL) if (is_disabled() || query_cache_tls->first_query_block == NULL)
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
DBUG_ASSERT(current_thd);
QC_DEBUG_SYNC("wait_in_query_cache_insert"); QC_DEBUG_SYNC("wait_in_query_cache_insert");
/* /*
Lock the cache with try_lock(). try_lock() will fail if Lock the cache with try_lock(). try_lock() will fail if
cache was disabled between the above test and lock. cache was disabled between the above test and lock.
*/ */
if (try_lock(current_thd, Query_cache::WAIT)) if (try_lock(thd, Query_cache::WAIT))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
Query_cache_block *query_block = query_cache_tls->first_query_block; Query_cache_block *query_block = query_cache_tls->first_query_block;
@ -1130,16 +1128,15 @@ Query_cache::insert(Query_cache_tls *query_cache_tls,
void void
Query_cache::abort(Query_cache_tls *query_cache_tls) Query_cache::abort(THD *thd, Query_cache_tls *query_cache_tls)
{ {
THD *thd;
DBUG_ENTER("query_cache_abort"); DBUG_ENTER("query_cache_abort");
/* See the comment on double-check locking usage above. */ /* See the comment on double-check locking usage above. */
if (is_disabled() || query_cache_tls->first_query_block == NULL) if (is_disabled() || query_cache_tls->first_query_block == NULL)
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
if (try_lock(current_thd, Query_cache::WAIT)) if (try_lock(thd, Query_cache::WAIT))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
/* /*
@ -1149,7 +1146,6 @@ Query_cache::abort(Query_cache_tls *query_cache_tls)
Query_cache_block *query_block= query_cache_tls->first_query_block; Query_cache_block *query_block= query_cache_tls->first_query_block;
if (query_block) if (query_block)
{ {
thd= current_thd;
THD_STAGE_INFO(thd, stage_storing_result_in_query_cache); THD_STAGE_INFO(thd, stage_storing_result_in_query_cache);
DUMP(this); DUMP(this);
BLOCK_LOCK_WR(query_block); BLOCK_LOCK_WR(query_block);
@ -1181,12 +1177,12 @@ void Query_cache::end_of_result(THD *thd)
if (thd->killed) if (thd->killed)
{ {
query_cache_abort(&thd->query_cache_tls); query_cache_abort(thd, &thd->query_cache_tls);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
#ifdef EMBEDDED_LIBRARY #ifdef EMBEDDED_LIBRARY
insert(query_cache_tls, (char*)thd, insert(thd, query_cache_tls, (char*)thd,
emb_count_querycache_size(thd), 0); emb_count_querycache_size(thd), 0);
#endif #endif
@ -3338,7 +3334,7 @@ Query_cache::register_tables_from_list(THD *thd, TABLE_LIST *tables_used,
/* /*
There are not callback function for for VIEWs There are not callback function for for VIEWs
*/ */
if (!insert_table(key_length, key, (*block_table), if (!insert_table(thd, key_length, key, (*block_table),
tables_used->view_db.length, 0, tables_used->view_db.length, 0,
HA_CACHE_TBL_NONTRANSACT, 0, 0, TRUE)) HA_CACHE_TBL_NONTRANSACT, 0, 0, TRUE))
DBUG_RETURN(0); DBUG_RETURN(0);
@ -3357,7 +3353,7 @@ Query_cache::register_tables_from_list(THD *thd, TABLE_LIST *tables_used,
(ulong) tables_used->table->s->table_cache_key.length, (ulong) tables_used->table->s->table_cache_key.length,
(ulong) tables_used->table->s->table_cache_key.str)); (ulong) tables_used->table->s->table_cache_key.str));
if (!insert_table(tables_used->table->s->table_cache_key.length, if (!insert_table(thd, tables_used->table->s->table_cache_key.length,
tables_used->table->s->table_cache_key.str, tables_used->table->s->table_cache_key.str,
(*block_table), (*block_table),
tables_used->db_length, 0, tables_used->db_length, 0,
@ -3423,7 +3419,7 @@ my_bool Query_cache::register_all_tables(THD *thd,
*/ */
my_bool my_bool
Query_cache::insert_table(uint key_len, const char *key, Query_cache::insert_table(THD *thd, uint key_len, const char *key,
Query_cache_block_table *node, Query_cache_block_table *node,
uint32 db_length, uint8 suffix_length_arg, uint32 db_length, uint8 suffix_length_arg,
uint8 cache_type, uint8 cache_type,
@ -3435,8 +3431,6 @@ Query_cache::insert_table(uint key_len, const char *key,
DBUG_PRINT("qcache", ("insert table node 0x%lx, len %d", DBUG_PRINT("qcache", ("insert table node 0x%lx, len %d",
(ulong)node, key_len)); (ulong)node, key_len));
THD *thd= current_thd;
Query_cache_block *table_block= Query_cache_block *table_block=
(hash ? (hash ?
(Query_cache_block *) my_hash_search(&tables, (uchar*) key, key_len) : (Query_cache_block *) my_hash_search(&tables, (uchar*) key, key_len) :

View file

@ -487,11 +487,11 @@ protected:
void destroy(); void destroy();
void insert(Query_cache_tls *query_cache_tls, void insert(THD *thd, Query_cache_tls *query_cache_tls,
const char *packet, const char *packet,
ulong length, ulong length,
unsigned pkt_nr); unsigned pkt_nr);
my_bool insert_table(uint key_len, const char *key, my_bool insert_table(THD *thd, uint key_len, const char *key,
Query_cache_block_table *node, Query_cache_block_table *node,
uint32 db_length, uint8 suffix_length_arg, uint32 db_length, uint8 suffix_length_arg,
uint8 cache_type, uint8 cache_type,
@ -500,7 +500,7 @@ protected:
my_bool hash); my_bool hash);
void end_of_result(THD *thd); void end_of_result(THD *thd);
void abort(Query_cache_tls *query_cache_tls); void abort(THD *thd, Query_cache_tls *query_cache_tls);
/* /*
The following functions are only used when debugging The following functions are only used when debugging
@ -558,7 +558,7 @@ struct Query_cache_query_flags
#define QUERY_CACHE_FLAGS_SIZE sizeof(Query_cache_query_flags) #define QUERY_CACHE_FLAGS_SIZE sizeof(Query_cache_query_flags)
#define QUERY_CACHE_DB_LENGTH_SIZE 2 #define QUERY_CACHE_DB_LENGTH_SIZE 2
#include "sql_cache.h" #include "sql_cache.h"
#define query_cache_abort(A) query_cache.abort(A) #define query_cache_abort(A,B) query_cache.abort(A,B)
#define query_cache_end_of_result(A) query_cache.end_of_result(A) #define query_cache_end_of_result(A) query_cache.end_of_result(A)
#define query_cache_store_query(A, B) query_cache.store_query(A, B) #define query_cache_store_query(A, B) query_cache.store_query(A, B)
#define query_cache_destroy() query_cache.destroy() #define query_cache_destroy() query_cache.destroy()
@ -590,7 +590,7 @@ struct Query_cache_query_flags
#define query_cache_send_result_to_client(A, B, C) 0 #define query_cache_send_result_to_client(A, B, C) 0
#define query_cache_invalidate_by_MyISAM_filename_ref NULL #define query_cache_invalidate_by_MyISAM_filename_ref NULL
#define query_cache_abort(A) do { } while(0) #define query_cache_abort(A,B) do { } while(0)
#define query_cache_end_of_result(A) do { } while(0) #define query_cache_end_of_result(A) do { } while(0)
#define query_cache_maybe_disabled(T) 1 #define query_cache_maybe_disabled(T) 1
#define query_cache_is_cacheable_query(L) 0 #define query_cache_is_cacheable_query(L) 0

View file

@ -1286,7 +1286,7 @@ Sql_condition* THD::raise_condition(uint sql_errno,
} }
} }
query_cache_abort(&query_cache_tls); query_cache_abort(this, &query_cache_tls);
/* /*
Avoid pushing a condition for fatal out of memory errors as this will Avoid pushing a condition for fatal out of memory errors as this will
@ -1939,6 +1939,7 @@ void THD::disconnect()
/* Disconnect even if a active vio is not associated. */ /* Disconnect even if a active vio is not associated. */
if (net.vio != vio) if (net.vio != vio)
vio_close(net.vio); vio_close(net.vio);
net.thd= 0; // Don't collect statistics
mysql_mutex_unlock(&LOCK_thd_data); mysql_mutex_unlock(&LOCK_thd_data);
} }
@ -2065,7 +2066,11 @@ bool THD::store_globals()
real_id= pthread_self(); // For debugging real_id= pthread_self(); // For debugging
mysys_var->stack_ends_here= thread_stack + // for consistency, see libevent_thread_proc mysys_var->stack_ends_here= thread_stack + // for consistency, see libevent_thread_proc
STACK_DIRECTION * (long)my_thread_stack_size; STACK_DIRECTION * (long)my_thread_stack_size;
vio_set_thread_id(net.vio, real_id); if (net.vio)
{
vio_set_thread_id(net.vio, real_id);
net.thd= this;
}
/* /*
We have to call thr_lock_info_init() again here as THD may have been We have to call thr_lock_info_init() again here as THD may have been
created in another thread created in another thread
@ -2090,7 +2095,7 @@ void THD::reset_globals()
/* Undocking the thread specific data. */ /* Undocking the thread specific data. */
set_current_thd(0); set_current_thd(0);
my_pthread_setspecific_ptr(THR_MALLOC, NULL); my_pthread_setspecific_ptr(THR_MALLOC, NULL);
net.thd= 0;
} }
/* /*
@ -3998,26 +4003,29 @@ void TMP_TABLE_PARAM::init()
} }
void thd_increment_bytes_sent(ulong length) void thd_increment_bytes_sent(void *thd, ulong length)
{ {
THD *thd=current_thd; /* thd == 0 when close_connection() calls net_send_error() */
if (likely(thd != 0)) if (likely(thd != 0))
{ {
/* current_thd == 0 when close_connection() calls net_send_error() */ ((THD*) thd)->status_var.bytes_sent+= length;
thd->status_var.bytes_sent+= length;
} }
} }
void thd_increment_bytes_received(ulong length) void thd_increment_bytes_received(void *thd, ulong length)
{ {
current_thd->status_var.bytes_received+= length; if (unlikely(!thd)) // Called from federatedx
thd= current_thd;
((THD*) thd)->status_var.bytes_received+= length;
} }
void thd_increment_net_big_packet_count(ulong length) void thd_increment_net_big_packet_count(void *thd, ulong length)
{ {
current_thd->status_var.net_big_packet_count+= length; if (unlikely(!thd)) // Called from federatedx
thd= current_thd;
((THD*) thd)->status_var.net_big_packet_count+= length;
} }

View file

@ -3931,6 +3931,7 @@ static TABLE *create_table_from_items(THD *thd,
tmp_table.s->db_create_options=0; tmp_table.s->db_create_options=0;
tmp_table.null_row= 0; tmp_table.null_row= 0;
tmp_table.maybe_null= 0; tmp_table.maybe_null= 0;
tmp_table.in_use= thd;
promote_first_timestamp_column(&alter_info->create_list); promote_first_timestamp_column(&alter_info->create_list);
@ -3950,10 +3951,11 @@ static TABLE *create_table_from_items(THD *thd,
(Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0, (Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
0); 0);
if (!field || if (!field ||
!(cr_field=new Create_field(thd, field, !(cr_field= (new (thd->mem_root)
(item->type() == Item::FIELD_ITEM ? Create_field(thd, field,
((Item_field *) item)->field : (item->type() == Item::FIELD_ITEM ?
(Field *) 0)))) ((Item_field *) item)->field :
(Field *) 0)))))
DBUG_RETURN(0); DBUG_RETURN(0);
if (item->maybe_null) if (item->maybe_null)
cr_field->flags &= ~NOT_NULL_FLAG; cr_field->flags &= ~NOT_NULL_FLAG;

View file

@ -7220,7 +7220,7 @@ void mysql_parse(THD *thd, char *rawbuf, uint length,
DBUG_PRINT("info",("Command aborted. Fatal_error: %d", DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
thd->is_fatal_error)); thd->is_fatal_error));
query_cache_abort(&thd->query_cache_tls); query_cache_abort(thd, &thd->query_cache_tls);
} }
THD_STAGE_INFO(thd, stage_freeing_items); THD_STAGE_INFO(thd, stage_freeing_items);
sp_cache_enforce_limit(thd->sp_proc_cache, stored_program_cache_size); sp_cache_enforce_limit(thd->sp_proc_cache, stored_program_cache_size);

View file

@ -15406,7 +15406,7 @@ Item_func_isnull::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
thd->substitute_null_with_insert_id)) thd->substitute_null_with_insert_id))
{ {
#ifdef HAVE_QUERY_CACHE #ifdef HAVE_QUERY_CACHE
query_cache_abort(&thd->query_cache_tls); query_cache_abort(thd, &thd->query_cache_tls);
#endif #endif
COND *new_cond, *cond= this; COND *new_cond, *cond= this;
if ((new_cond= new (thd->mem_root) Item_func_eq(thd, args[0], if ((new_cond= new (thd->mem_root) Item_func_eq(thd, args[0],
@ -15674,11 +15674,13 @@ static Field *create_tmp_field_from_item(THD *thd, Item *item, TABLE *table,
{ {
bool maybe_null= item->maybe_null; bool maybe_null= item->maybe_null;
Field *UNINIT_VAR(new_field); Field *UNINIT_VAR(new_field);
MEM_ROOT *mem_root= thd->mem_root;
switch (item->result_type()) { switch (item->result_type()) {
case REAL_RESULT: case REAL_RESULT:
new_field= new Field_double(item->max_length, maybe_null, new_field= new (mem_root)
item->name, item->decimals, TRUE); Field_double(item->max_length, maybe_null,
item->name, item->decimals, TRUE);
break; break;
case INT_RESULT: case INT_RESULT:
/* /*
@ -15688,11 +15690,13 @@ static Field *create_tmp_field_from_item(THD *thd, Item *item, TABLE *table,
Field_long : make them Field_longlong. Field_long : make them Field_longlong.
*/ */
if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1)) if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))
new_field=new Field_longlong(item->max_length, maybe_null, new_field=new (mem_root)
item->name, item->unsigned_flag); Field_longlong(item->max_length, maybe_null,
item->name, item->unsigned_flag);
else else
new_field=new Field_long(item->max_length, maybe_null, new_field=new (mem_root)
item->name, item->unsigned_flag); Field_long(item->max_length, maybe_null, item->name,
item->unsigned_flag);
break; break;
case STRING_RESULT: case STRING_RESULT:
DBUG_ASSERT(item->collation.collation); DBUG_ASSERT(item->collation.collation);
@ -15711,15 +15715,16 @@ static Field *create_tmp_field_from_item(THD *thd, Item *item, TABLE *table,
else if (item->max_length/item->collation.collation->mbmaxlen > 255 && else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&
convert_blob_length <= Field_varstring::MAX_SIZE && convert_blob_length <= Field_varstring::MAX_SIZE &&
convert_blob_length) convert_blob_length)
new_field= new Field_varstring(convert_blob_length, maybe_null, new_field= new (mem_root)
item->name, table->s, Field_varstring(convert_blob_length, maybe_null,
item->collation.collation); item->name, table->s,
item->collation.collation);
else else
new_field= item->make_string_field(table); new_field= item->make_string_field(table);
new_field->set_derivation(item->collation.derivation); new_field->set_derivation(item->collation.derivation);
break; break;
case DECIMAL_RESULT: case DECIMAL_RESULT:
new_field= Field_new_decimal::create_from_item(item); new_field= Field_new_decimal::create_from_item(mem_root, item);
break; break;
case ROW_RESULT: case ROW_RESULT:
default: default:
@ -16930,7 +16935,7 @@ TABLE *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list)
List_iterator_fast<Create_field> it(field_list); List_iterator_fast<Create_field> it(field_list);
while ((cdef= it++)) while ((cdef= it++))
{ {
*field= make_field(share, 0, cdef->length, *field= make_field(share, thd->mem_root, 0, cdef->length,
(uchar*) (f_maybe_null(cdef->pack_flag) ? "" : 0), (uchar*) (f_maybe_null(cdef->pack_flag) ? "" : 0),
f_maybe_null(cdef->pack_flag) ? 1 : 0, f_maybe_null(cdef->pack_flag) ? 1 : 0,
cdef->pack_flag, cdef->sql_type, cdef->charset, cdef->pack_flag, cdef->sql_type, cdef->charset,

View file

@ -5588,6 +5588,7 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
sp_head *sp; sp_head *sp;
stored_procedure_type routine_type; stored_procedure_type routine_type;
bool free_sp_head; bool free_sp_head;
bool error= 0;
DBUG_ENTER("store_schema_params"); DBUG_ENTER("store_schema_params");
bzero((char*) &tbl, sizeof(TABLE)); bzero((char*) &tbl, sizeof(TABLE));
@ -5638,7 +5639,8 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
&tmp_string); &tmp_string);
table->field[15]->store(tmp_string.ptr(), tmp_string.length(), cs); table->field[15]->store(tmp_string.ptr(), tmp_string.length(), cs);
field_def= &sp->m_return_field_def; field_def= &sp->m_return_field_def;
field= make_field(&share, (uchar*) 0, field_def->length, field= make_field(&share, thd->mem_root,
(uchar*) 0, field_def->length,
(uchar*) "", 0, field_def->pack_flag, (uchar*) "", 0, field_def->pack_flag,
field_def->sql_type, field_def->charset, field_def->sql_type, field_def->charset,
field_def->geom_type, field_def->srid, Field::NONE, field_def->geom_type, field_def->srid, Field::NONE,
@ -5691,7 +5693,7 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
&tmp_string); &tmp_string);
table->field[15]->store(tmp_string.ptr(), tmp_string.length(), cs); table->field[15]->store(tmp_string.ptr(), tmp_string.length(), cs);
field= make_field(&share, (uchar*) 0, field_def->length, field= make_field(&share, thd->mem_root, (uchar*) 0, field_def->length,
(uchar*) "", 0, field_def->pack_flag, (uchar*) "", 0, field_def->pack_flag,
field_def->sql_type, field_def->charset, field_def->sql_type, field_def->charset,
field_def->geom_type, field_def->srid, Field::NONE, field_def->geom_type, field_def->srid, Field::NONE,
@ -5702,17 +5704,15 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
store_column_type(table, field, cs, 6); store_column_type(table, field, cs, 6);
if (schema_table_store_record(thd, table)) if (schema_table_store_record(thd, table))
{ {
free_table_share(&share); error= 1;
if (free_sp_head) break;
delete sp;
DBUG_RETURN(1);
} }
} }
if (free_sp_head) if (free_sp_head)
delete sp; delete sp;
} }
free_table_share(&share); free_table_share(&share);
DBUG_RETURN(0); DBUG_RETURN(error);
} }
@ -5790,7 +5790,8 @@ bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table,
bzero((char*) &tbl, sizeof(TABLE)); bzero((char*) &tbl, sizeof(TABLE));
(void) build_table_filename(path, sizeof(path), "", "", "", 0); (void) build_table_filename(path, sizeof(path), "", "", "", 0);
init_tmp_table_share(thd, &share, "", 0, "", path); init_tmp_table_share(thd, &share, "", 0, "", path);
field= make_field(&share, (uchar*) 0, field_def->length, field= make_field(&share, thd->mem_root, (uchar*) 0,
field_def->length,
(uchar*) "", 0, field_def->pack_flag, (uchar*) "", 0, field_def->pack_flag,
field_def->sql_type, field_def->charset, field_def->sql_type, field_def->charset,
field_def->geom_type, field_def->srid, Field::NONE, field_def->geom_type, field_def->srid, Field::NONE,

View file

@ -506,7 +506,7 @@ bool Sql_cmd_resignal::execute(THD *thd)
if (m_cond) if (m_cond)
{ {
query_cache_abort(&thd->query_cache_tls); query_cache_abort(thd, &thd->query_cache_tls);
/* Keep handled conditions. */ /* Keep handled conditions. */
da->unmark_sql_conditions_from_removal(); da->unmark_sql_conditions_from_removal();

View file

@ -1657,7 +1657,7 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
#endif #endif
*field_ptr= reg_field= *field_ptr= reg_field=
make_field(share, record+recpos, make_field(share, &share->mem_root, record+recpos,
(uint32) field_length, (uint32) field_length,
null_pos, null_bit_pos, null_pos, null_bit_pos,
pack_flag, pack_flag,

View file

@ -924,7 +924,7 @@ static bool make_empty_rec(THD *thd, uchar *buff, uint table_options,
/* /*
regfield don't have to be deleted as it's allocated with sql_alloc() regfield don't have to be deleted as it's allocated with sql_alloc()
*/ */
Field *regfield= make_field(&share, Field *regfield= make_field(&share, thd->mem_root,
buff+field->offset + data_offset, buff+field->offset + data_offset,
field->length, field->length,
null_pos + null_count / 8, null_pos + null_count / 8,

View file

@ -1737,7 +1737,7 @@ pthread_handler_t start_wsrep_THD(void *arg)
thread_created++; thread_created++;
threads.append(thd); threads.append(thd);
my_net_init(&thd->net,(st_vio*) 0, MYF(0)); my_net_init(&thd->net,(st_vio*) 0, thd, MYF(0));
DBUG_PRINT("wsrep",(("creating thread %lld"), (long long)thd->thread_id)); DBUG_PRINT("wsrep",(("creating thread %lld"), (long long)thd->thread_id));
thd->prior_thr_create_utime= thd->start_utime= microsecond_interval_timer(); thd->prior_thr_create_utime= thd->start_utime= microsecond_interval_timer();

View file

@ -1708,7 +1708,7 @@ my_bool ha_myisammrg::register_query_cache_dependant_tables(THD *thd
/* /*
There are not callback function for for MyISAM, and engine data There are not callback function for for MyISAM, and engine data
*/ */
if (!cache->insert_table(key_length, key, (*block_table), if (!cache->insert_table(thd, key_length, key, (*block_table),
db_length, 0, db_length, 0,
table_cache_type(), table_cache_type(),
0, 0, TRUE)) 0, 0, TRUE))