#At file:///home/gluh/MySQL/mysql-pe-bug-48729/ based on revid:sergey.glukhov@stripped
3968 Sergey Glukhov 2010-03-12
Bug#48729 SELECT ... FROM INFORMATION_SCHEMA.ROUTINES causes memory to grow
Analysis showed that in case of accessing I_S tables for
ROUTINES, PARAMETERS, EVENTS we perform unnecessary allocations
with get_field() function for every processed row that
in their turn causes significant memory growth.
The fix is to avoid use of get_field().
@ sql/event_db_repository.cc
added new parameter
@ sql/sql_show.cc
Functions store_schema_params(), store_schema_proc(),
copy_event_to_schema_table() are changed to avoid
use of get_field() function.
@ sql/sql_show.h
added new parameter
modified:
sql/event_db_repository.cc
sql/sql_show.cc
sql/sql_show.h
=== modified file 'sql/event_db_repository.cc'
--- a/sql/event_db_repository.cc 2010-02-26 14:25:52 +0000
+++ b/sql/event_db_repository.cc 2010-03-12 14:58:40 +0000
@@ -394,6 +394,7 @@ Event_db_repository::index_read_for_db_f
KEY *key_info;
uint key_len;
uchar *key_buf= NULL;
+ String tmp_string;
LINT_INIT(key_buf);
DBUG_ENTER("Event_db_repository::index_read_for_db_for_i_s");
@@ -427,9 +428,11 @@ Event_db_repository::index_read_for_db_f
HA_READ_PREFIX)))
{
DBUG_PRINT("info",("Found rows. Let's retrieve them. ret=%d", ret));
+ tmp_string.set_charset(system_charset_info);
do
{
- ret= copy_event_to_schema_table(thd, schema_table, event_table);
+ ret= copy_event_to_schema_table(thd, schema_table, event_table,
+ &tmp_string);
if (ret == 0)
ret= event_table->file->index_next_same(event_table->record[0],
key_buf, key_len);
@@ -470,6 +473,7 @@ Event_db_repository::table_scan_all_for_
{
int ret;
READ_RECORD read_record_info;
+ String tmp_string;
DBUG_ENTER("Event_db_repository::table_scan_all_for_i_s");
init_read_record(&read_record_info, thd, event_table, NULL, 1, 0, FALSE);
@@ -479,11 +483,13 @@ Event_db_repository::table_scan_all_for_
but rr_handle_error returns -1 for that reason. Thus, read_record()
returns -1 eventually.
*/
+ tmp_string.set_charset(system_charset_info);
do
{
ret= read_record_info.read_record(&read_record_info);
if (ret == 0)
- ret= copy_event_to_schema_table(thd, schema_table, event_table);
+ ret= copy_event_to_schema_table(thd, schema_table, event_table,
+ &tmp_string);
} while (ret == 0);
DBUG_PRINT("info", ("Scan finished. ret=%d", ret));
=== modified file 'sql/sql_show.cc'
--- a/sql/sql_show.cc 2010-02-25 15:47:36 +0000
+++ b/sql/sql_show.cc 2010-03-12 14:58:40 +0000
@@ -31,6 +31,7 @@
#ifdef HAVE_EVENT_SCHEDULER
#include "events.h"
#include "event_data_objects.h"
+#include "event_db_repository.h"
#endif
#include <my_dir.h>
#include "debug_sync.h"
@@ -4483,6 +4484,13 @@ int fill_schema_coll_charset_app(THD *th
}
+static void store_field_value_to_buff(Field *field, String *buff)
+{
+ buff->length(0);
+ field->val_str(buff);
+}
+
+
/**
@brief Store record into I_S.PARAMETERS table
@@ -4502,14 +4510,14 @@ int fill_schema_coll_charset_app(THD *th
bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
const char *wild, bool full_access,
- const char *sp_user)
+ const char *sp_user, String *tmp_string)
{
TABLE_SHARE share;
TABLE tbl;
CHARSET_INFO *cs= system_charset_info;
char params_buff[MAX_FIELD_WIDTH], returns_buff[MAX_FIELD_WIDTH],
- sp_db_buff[NAME_LEN], sp_name_buff[NAME_LEN], path[FN_REFLEN],
- definer_buff[USERNAME_LENGTH + HOSTNAME_LENGTH + 1];
+ sp_db_buff[NAME_LEN + 1], sp_name_buff[NAME_LEN + 1], path[FN_REFLEN],
+ definer_buff[USERNAME_LENGTH + HOSTNAME_LENGTH + 2];
String params(params_buff, sizeof(params_buff), cs);
String returns(returns_buff, sizeof(returns_buff), cs);
String sp_db(sp_db_buff, sizeof(sp_db_buff), cs);
@@ -4524,25 +4532,24 @@ bool store_schema_params(THD *thd, TABLE
(void) build_table_filename(path, sizeof(path), "", "", "", 0);
init_tmp_table_share(thd, &share, "", 0, "", path);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DB], &sp_db);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_NAME], &sp_name);
- get_field(thd->mem_root,proc_table->field[MYSQL_PROC_FIELD_DEFINER],&definer);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_DB], &sp_db);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_NAME], &sp_name);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_DEFINER],
+ &definer);
routine_type= (uint) proc_table->field[MYSQL_PROC_MYSQL_TYPE]->val_int();
if (!full_access)
- full_access= !strcmp(sp_user, definer.ptr());
+ full_access= !strcmp(sp_user, definer.c_ptr_safe());
if (!full_access &&
- check_some_routine_access(thd, sp_db.ptr(),sp_name.ptr(),
+ check_some_routine_access(thd, sp_db.c_ptr_safe(),sp_name.c_ptr_safe(),
routine_type == TYPE_ENUM_PROCEDURE))
DBUG_RETURN(0);
- params.length(0);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_PARAM_LIST],
- ¶ms);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_PARAM_LIST],
+ ¶ms);
returns.length(0);
if (routine_type == TYPE_ENUM_FUNCTION)
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_RETURNS],
- &returns);
+ proc_table->field[MYSQL_PROC_FIELD_RETURNS]->val_str(&returns);
sp= sp_load_for_information_schema(thd, proc_table, &sp_db, &sp_name,
(ulong) proc_table->
@@ -4556,7 +4563,6 @@ bool store_schema_params(THD *thd, TABLE
{
Field *field;
Create_field *field_def;
- String tmp_string;
if (routine_type == TYPE_ENUM_FUNCTION)
{
restore_record(table, s->default_values);
@@ -4564,9 +4570,9 @@ bool store_schema_params(THD *thd, TABLE
table->field[1]->store(sp_db.ptr(), sp_db.length(), cs);
table->field[2]->store(sp_name.ptr(), sp_name.length(), cs);
table->field[3]->store((longlong) 0, TRUE);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_MYSQL_TYPE],
- &tmp_string);
- table->field[14]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_MYSQL_TYPE],
+ tmp_string);
+ table->field[14]->store(tmp_string->ptr(), tmp_string->length(), cs);
field_def= &sp->m_return_field_def;
field= make_field(&share, (uchar*) 0, field_def->length,
(uchar*) "", 0, field_def->pack_flag,
@@ -4617,9 +4623,9 @@ bool store_schema_params(THD *thd, TABLE
table->field[4]->set_notnull();
table->field[5]->store(spvar->name.str, spvar->name.length, cs);
table->field[5]->set_notnull();
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_MYSQL_TYPE],
- &tmp_string);
- table->field[14]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_MYSQL_TYPE],
+ tmp_string);
+ table->field[14]->store(tmp_string->ptr(), tmp_string->length(), cs);
field= make_field(&share, (uchar*) 0, field_def->length,
(uchar*) "", 0, field_def->pack_flag,
@@ -4647,20 +4653,28 @@ bool store_schema_params(THD *thd, TABLE
bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table,
- const char *wild, bool full_access, const char *sp_user)
+ const char *wild, bool full_access, const char *sp_user,
+ String *tmp_string)
{
- String tmp_string;
- String sp_db, sp_name, definer;
+ CHARSET_INFO *cs= system_charset_info;
+ char sp_db_buff[NAME_LEN + 1], sp_name_buff[NAME_LEN + 1],
+ definer_buff[USERNAME_LENGTH + HOSTNAME_LENGTH + 2];
+
+ String sp_db(sp_db_buff, sizeof(sp_db_buff), cs);
+ String sp_name(sp_name_buff, sizeof(sp_name_buff), cs);
+ String definer(definer_buff, sizeof(definer_buff), cs);
+
MYSQL_TIME time;
LEX *lex= thd->lex;
- CHARSET_INFO *cs= system_charset_info;
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DB], &sp_db);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_NAME], &sp_name);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DEFINER],&definer);
+
+ proc_table->field[MYSQL_PROC_FIELD_DB]->val_str(&sp_db);
+ proc_table->field[MYSQL_PROC_FIELD_NAME]->val_str(&sp_name);
+ proc_table->field[MYSQL_PROC_FIELD_DEFINER]->val_str(&definer);
+
if (!full_access)
- full_access= !strcmp(sp_user, definer.ptr());
+ full_access= !strcmp(sp_user, definer.c_ptr_safe());
if (!full_access &&
- check_some_routine_access(thd, sp_db.ptr(), sp_name.ptr(),
+ check_some_routine_access(thd, sp_db.c_ptr_safe(), sp_name.c_ptr_safe(),
proc_table->field[MYSQL_PROC_MYSQL_TYPE]->
val_int() == TYPE_ENUM_PROCEDURE))
return 0;
@@ -4674,32 +4688,32 @@ bool store_schema_proc(THD *thd, TABLE *
(sql_command_flags[lex->sql_command] & CF_STATUS_COMMAND) == 0)
{
restore_record(table, s->default_values);
- if (!wild || !wild[0] || !wild_compare(sp_name.ptr(), wild, 0))
+ if (!wild || !wild[0] || !wild_compare(sp_name.c_ptr_safe(), wild, 0))
{
int enum_idx= (int) proc_table->field[MYSQL_PROC_FIELD_ACCESS]->val_int();
table->field[3]->store(sp_name.ptr(), sp_name.length(), cs);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_SPECIFIC_NAME],
- &tmp_string);
- table->field[0]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->
+ field[MYSQL_PROC_FIELD_SPECIFIC_NAME],
+ tmp_string);
+ table->field[0]->store(tmp_string->ptr(), tmp_string->length(), cs);
table->field[1]->store(STRING_WITH_LEN("def"), cs);
table->field[2]->store(sp_db.ptr(), sp_db.length(), cs);
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_MYSQL_TYPE],
- &tmp_string);
- table->field[4]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_MYSQL_TYPE],
+ tmp_string);
+ table->field[4]->store(tmp_string->ptr(), tmp_string->length(), cs);
if (proc_table->field[MYSQL_PROC_MYSQL_TYPE]->val_int() ==
TYPE_ENUM_FUNCTION)
{
sp_head *sp;
bool free_sp_head;
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_RETURNS],
- &tmp_string);
-
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_RETURNS],
+ tmp_string);
sp= sp_load_for_information_schema(thd, proc_table, &sp_db, &sp_name,
(ulong) proc_table->
field[MYSQL_PROC_FIELD_SQL_MODE]->
val_int(),
TYPE_ENUM_FUNCTION,
- tmp_string.c_ptr_safe(),
+ tmp_string->c_ptr_safe(),
"", &free_sp_head);
if (sp)
@@ -4730,24 +4744,23 @@ bool store_schema_proc(THD *thd, TABLE *
if (full_access)
{
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_BODY_UTF8],
- &tmp_string);
- table->field[14]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_BODY_UTF8],
+ tmp_string);
+ table->field[14]->store(tmp_string->ptr(), tmp_string->length(), cs);
table->field[14]->set_notnull();
}
table->field[13]->store(STRING_WITH_LEN("SQL"), cs);
table->field[17]->store(STRING_WITH_LEN("SQL"), cs);
-
-
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DETERMINISTIC],
- &tmp_string);
- table->field[18]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->
+ field[MYSQL_PROC_FIELD_DETERMINISTIC],
+ tmp_string);
+ table->field[18]->store(tmp_string->ptr(), tmp_string->length(), cs);
table->field[19]->store(sp_data_access_name[enum_idx].str,
sp_data_access_name[enum_idx].length , cs);
-
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_SECURITY_TYPE],
- &tmp_string);
- table->field[21]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->
+ field[MYSQL_PROC_FIELD_SECURITY_TYPE],
+ tmp_string);
+ table->field[21]->store(tmp_string->ptr(), tmp_string->length(), cs);
bzero((char *)&time, sizeof(time));
((Field_timestamp *) proc_table->field[MYSQL_PROC_FIELD_CREATED])->
get_time(&time);
@@ -4756,29 +4769,25 @@ bool store_schema_proc(THD *thd, TABLE *
((Field_timestamp *) proc_table->field[MYSQL_PROC_FIELD_MODIFIED])->
get_time(&time);
table->field[23]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
-
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_SQL_MODE],
- &tmp_string);
- table->field[24]->store(tmp_string.ptr(), tmp_string.length(), cs);
-
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_COMMENT],
- &tmp_string);
- table->field[25]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_SQL_MODE],
+ tmp_string);
+ table->field[24]->store(tmp_string->ptr(), tmp_string->length(), cs);
+ store_field_value_to_buff(proc_table->field[MYSQL_PROC_FIELD_COMMENT],
+ tmp_string);
+ table->field[25]->store(tmp_string->ptr(), tmp_string->length(), cs);
table->field[26]->store(definer.ptr(), definer.length(), cs);
-
- get_field(thd->mem_root,
- proc_table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT],
- &tmp_string);
- table->field[27]->store(tmp_string.ptr(), tmp_string.length(), cs);
-
- get_field(thd->mem_root,
- proc_table->field[ MYSQL_PROC_FIELD_COLLATION_CONNECTION],
- &tmp_string);
- table->field[28]->store(tmp_string.ptr(), tmp_string.length(), cs);
-
- get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DB_COLLATION],
- &tmp_string);
- table->field[29]->store(tmp_string.ptr(), tmp_string.length(), cs);
+ store_field_value_to_buff(proc_table->
+ field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT],
+ tmp_string);
+ table->field[27]->store(tmp_string->ptr(), tmp_string->length(), cs);
+ store_field_value_to_buff(proc_table->
+ field[ MYSQL_PROC_FIELD_COLLATION_CONNECTION],
+ tmp_string);
+ table->field[28]->store(tmp_string->ptr(), tmp_string->length(), cs);
+ store_field_value_to_buff(proc_table->
+ field[MYSQL_PROC_FIELD_DB_COLLATION],
+ tmp_string);
+ table->field[29]->store(tmp_string->ptr(), tmp_string->length(), cs);
return schema_table_store_record(thd, table);
}
@@ -4799,6 +4808,7 @@ int fill_schema_proc(THD *thd, TABLE_LIS
Open_tables_backup open_tables_state_backup;
enum enum_schema_tables schema_table_idx=
get_schema_table_idx(tables->schema_table);
+ String tmp_string;
DBUG_ENTER("fill_schema_proc");
strxmov(definer, thd->security_ctx->priv_user, "@",
@@ -4822,9 +4832,12 @@ int fill_schema_proc(THD *thd, TABLE_LIS
goto err;
}
+ tmp_string.set_charset(system_charset_info);
if (schema_table_idx == SCH_PROCEDURES ?
- store_schema_proc(thd, table, proc_table, wild, full_access, definer) :
- store_schema_params(thd, table, proc_table, wild, full_access, definer))
+ store_schema_proc(thd, table, proc_table, wild, full_access, definer,
+ &tmp_string) :
+ store_schema_params(thd, table, proc_table, wild, full_access, definer,
+ &tmp_string))
{
res= 1;
goto err;
@@ -4832,8 +4845,10 @@ int fill_schema_proc(THD *thd, TABLE_LIS
while (!proc_table->file->index_next(proc_table->record[0]))
{
if (schema_table_idx == SCH_PROCEDURES ?
- store_schema_proc(thd, table, proc_table, wild, full_access, definer):
- store_schema_params(thd, table, proc_table, wild, full_access, definer))
+ store_schema_proc(thd, table, proc_table, wild, full_access, definer,
+ &tmp_string):
+ store_schema_params(thd, table, proc_table, wild, full_access, definer,
+ &tmp_string))
{
res= 1;
goto err;
@@ -5852,6 +5867,22 @@ static interval_type get_real_interval_t
#endif
#ifdef HAVE_EVENT_SCHEDULER
+
+static void copy_datetime(Field *dst, Field *src, Time_zone *time_zone)
+{
+ my_time_t time_in_seconds;
+ MYSQL_TIME time;
+ my_bool not_used= FALSE;
+ bzero((char *)&time, sizeof(time));
+ src->get_date(&time, TIME_NO_ZERO_DATE);
+ time_in_seconds= my_tz_OFFSET0->TIME_to_gmt_sec(&time, ¬_used);
+ bzero((char *)&time, sizeof(time));
+ time_zone->gmt_sec_to_TIME(&time, time_in_seconds);
+ dst->set_notnull();
+ dst->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
+}
+
+
/*
Loads an event from mysql.event and copies it's data to a row of
I_S.EVENTS
@@ -5868,24 +5899,35 @@ static interval_type get_real_interval_t
*/
int
-copy_event_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table)
+copy_event_to_schema_table(THD *thd, TABLE *sch_table,
+ TABLE *event_table, String *tmp_string)
{
+ char event_db_buff[NAME_LEN + 1], event_name_buff[NAME_LEN + 1],
+ definer_buff[USERNAME_LENGTH + HOSTNAME_LENGTH + 2];
const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
CHARSET_INFO *scs= system_charset_info;
MYSQL_TIME time;
- Event_timed et;
+ Time_zone *time_zone;
+ String event_db(event_db_buff, sizeof(event_db_buff), scs);
+ String event_name(event_name_buff, sizeof(event_name_buff), scs);
+ String definer(definer_buff, sizeof(definer_buff), scs);
DBUG_ENTER("copy_event_to_schema_table");
- restore_record(sch_table, s->default_values);
- if (et.load_from_row(thd, event_table))
+ if (event_table->s->fields < ET_FIELD_COUNT)
{
my_error(ER_CANNOT_LOAD_FROM_TABLE, MYF(0), event_table->alias);
DBUG_RETURN(1);
}
- if (!(!wild || !wild[0] || !wild_compare(et.name.str, wild, 0)))
- DBUG_RETURN(0);
+ restore_record(sch_table, s->default_values);
+
+ event_table->field[ET_FIELD_DB]->val_str(&event_db);
+ event_table->field[ET_FIELD_NAME]->val_str(&event_name);
+ event_table->field[ET_FIELD_DEFINER]->val_str(&definer);
+
+ if (!(!wild || !wild[0] || !wild_compare(event_name.c_ptr_safe(), wild, 0)))
+ DBUG_RETURN(FALSE);
/*
Skip events in schemas one does not have access to. The check is
@@ -5893,147 +5935,135 @@ copy_event_to_schema_table(THD *thd, TAB
has access.
*/
if (thd->lex->sql_command != SQLCOM_SHOW_EVENTS &&
- check_access(thd, EVENT_ACL, et.dbname.str, NULL, NULL, 0, 1))
- DBUG_RETURN(0);
+ check_access(thd, EVENT_ACL, event_db.c_ptr_safe(), NULL, NULL, 0, 1))
+ DBUG_RETURN(FALSE);
- /* ->field[0] is EVENT_CATALOG and is by default NULL */
sch_table->field[ISE_EVENT_CATALOG]->store(STRING_WITH_LEN("def"), scs);
- sch_table->field[ISE_EVENT_SCHEMA]->
- store(et.dbname.str, et.dbname.length,scs);
- sch_table->field[ISE_EVENT_NAME]->
- store(et.name.str, et.name.length, scs);
- sch_table->field[ISE_DEFINER]->
- store(et.definer.str, et.definer.length, scs);
- const String *tz_name= et.time_zone->get_name();
- sch_table->field[ISE_TIME_ZONE]->
- store(tz_name->ptr(), tz_name->length(), scs);
- sch_table->field[ISE_EVENT_BODY]->
- store(STRING_WITH_LEN("SQL"), scs);
- sch_table->field[ISE_EVENT_DEFINITION]->store(
- et.body_utf8.str, et.body_utf8.length, scs);
+ sch_table->field[ISE_EVENT_SCHEMA]->store(event_db.ptr(),
+ event_db.length(),scs);
+ sch_table->field[ISE_EVENT_NAME]->store(event_name.ptr(),
+ event_name.length(), scs);
+ sch_table->field[ISE_DEFINER]->store(definer.ptr(), definer.length(), scs);
- /* SQL_MODE */
+
+ store_field_value_to_buff(event_table->field[ET_FIELD_TIME_ZONE], tmp_string);
+ sch_table->field[ISE_TIME_ZONE]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
+ if (!(time_zone= my_tz_find(thd, tmp_string)))
{
- LEX_STRING sql_mode;
- sql_mode_string_representation(thd, et.sql_mode, &sql_mode);
- sch_table->field[ISE_SQL_MODE]->
- store(sql_mode.str, sql_mode.length, scs);
+ my_error(ER_CANNOT_LOAD_FROM_TABLE, MYF(0), event_table->alias);
+ DBUG_RETURN(FALSE);
}
+ sch_table->field[ISE_EVENT_BODY]->store(STRING_WITH_LEN("SQL"), scs);
+ store_field_value_to_buff(event_table->field[ET_FIELD_BODY_UTF8], tmp_string);
+ sch_table->field[ISE_EVENT_DEFINITION]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
- int not_used=0;
-
- if (et.expression)
+ /* SQL_MODE */
+ store_field_value_to_buff(event_table->field[ET_FIELD_SQL_MODE], tmp_string);
+ sch_table->field[ISE_SQL_MODE]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
+ longlong expression= event_table->field[ET_FIELD_INTERVAL_EXPR]->val_int();
+ if (!event_table->field[ET_FIELD_INTERVAL_EXPR]->is_null())
{
- String show_str;
/* type */
sch_table->field[ISE_EVENT_TYPE]->store(STRING_WITH_LEN("RECURRING"), scs);
- if (Events::reconstruct_interval_expression(&show_str, et.interval,
- et.expression))
- DBUG_RETURN(1);
-
- sch_table->field[ISE_INTERVAL_VALUE]->set_notnull();
- sch_table->field[ISE_INTERVAL_VALUE]->
- store(show_str.ptr(), show_str.length(), scs);
+ interval_type interval;
+ store_field_value_to_buff(event_table->field[ET_FIELD_TRANSIENT_INTERVAL],
+ tmp_string);
+ if (!event_table->field[ET_FIELD_TRANSIENT_INTERVAL]->is_null())
+ {
+ int i;
+ LEX_STRING tmp;
+
+ tmp.length= tmp_string->length();
+ tmp.str= tmp_string->c_ptr_safe();
+ i= find_string_in_array(interval_type_to_name, &tmp, system_charset_info);
+ if (i < 0)
+ DBUG_RETURN(TRUE);
+ interval= (interval_type) i;
+ tmp_string->length(0);
+ if (Events::reconstruct_interval_expression(tmp_string, interval,
+ expression))
+ DBUG_RETURN(TRUE);
+ sch_table->field[ISE_INTERVAL_VALUE]->set_notnull();
+ sch_table->field[ISE_INTERVAL_VALUE]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
+ }
- LEX_STRING *ival= &interval_type_to_name[et.interval];
+ LEX_STRING *ival= &interval_type_to_name[interval];
sch_table->field[ISE_INTERVAL_FIELD]->set_notnull();
sch_table->field[ISE_INTERVAL_FIELD]->store(ival->str, ival->length, scs);
/* starts & ends . STARTS is always set - see sql_yacc.yy */
- et.time_zone->gmt_sec_to_TIME(&time, et.starts);
- sch_table->field[ISE_STARTS]->set_notnull();
- sch_table->field[ISE_STARTS]->
- store_time(&time, MYSQL_TIMESTAMP_DATETIME);
-
- if (!et.ends_null)
- {
- et.time_zone->gmt_sec_to_TIME(&time, et.ends);
- sch_table->field[ISE_ENDS]->set_notnull();
- sch_table->field[ISE_ENDS]->
- store_time(&time, MYSQL_TIMESTAMP_DATETIME);
- }
+ copy_datetime(sch_table->field[ISE_STARTS],
+ event_table->field[ET_FIELD_STARTS], time_zone);
+ if (!event_table->field[ET_FIELD_ENDS]->is_null())
+ copy_datetime(sch_table->field[ISE_ENDS],
+ event_table->field[ET_FIELD_ENDS], time_zone);
}
else
{
/* type */
sch_table->field[ISE_EVENT_TYPE]->store(STRING_WITH_LEN("ONE TIME"), scs);
-
- et.time_zone->gmt_sec_to_TIME(&time, et.execute_at);
- sch_table->field[ISE_EXECUTE_AT]->set_notnull();
- sch_table->field[ISE_EXECUTE_AT]->
- store_time(&time, MYSQL_TIMESTAMP_DATETIME);
+ /*executed at*/
+ copy_datetime(sch_table->field[ISE_EXECUTE_AT],
+ event_table->field[ET_FIELD_EXECUTE_AT], time_zone);
}
/* status */
-
- switch (et.status)
- {
- case Event_parse_data::ENABLED:
- sch_table->field[ISE_STATUS]->store(STRING_WITH_LEN("ENABLED"), scs);
- break;
- case Event_parse_data::SLAVESIDE_DISABLED:
- sch_table->field[ISE_STATUS]->store(STRING_WITH_LEN("SLAVESIDE_DISABLED"),
- scs);
- break;
- case Event_parse_data::DISABLED:
- sch_table->field[ISE_STATUS]->store(STRING_WITH_LEN("DISABLED"), scs);
- break;
- default:
- DBUG_ASSERT(0);
- }
- sch_table->field[ISE_ORIGINATOR]->store(et.originator, TRUE);
-
+ store_field_value_to_buff(event_table->field[ET_FIELD_STATUS], tmp_string);
+ sch_table->field[ISE_STATUS]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
+ sch_table->field[ISE_ORIGINATOR]->store(event_table->
+ field[ET_FIELD_ORIGINATOR]->val_int(),
+ TRUE);
/* on_completion */
- if (et.on_completion == Event_parse_data::ON_COMPLETION_DROP)
+ if (event_table->field[ET_FIELD_ON_COMPLETION]->val_int() ==
+ Event_parse_data::ON_COMPLETION_DROP)
sch_table->field[ISE_ON_COMPLETION]->
store(STRING_WITH_LEN("NOT PRESERVE"), scs);
else
sch_table->field[ISE_ON_COMPLETION]->
store(STRING_WITH_LEN("PRESERVE"), scs);
- number_to_datetime(et.created, &time, 0, ¬_used);
- DBUG_ASSERT(not_used==0);
+ bzero((char *)&time, sizeof(time));
+ ((Field_timestamp *) event_table->field[ET_FIELD_CREATED])->get_time(&time);
sch_table->field[ISE_CREATED]->store_time(&time, MYSQL_TIMESTAMP_DATETIME);
-
- number_to_datetime(et.modified, &time, 0, ¬_used);
- DBUG_ASSERT(not_used==0);
- sch_table->field[ISE_LAST_ALTERED]->
- store_time(&time, MYSQL_TIMESTAMP_DATETIME);
-
- if (et.last_executed)
- {
- et.time_zone->gmt_sec_to_TIME(&time, et.last_executed);
- sch_table->field[ISE_LAST_EXECUTED]->set_notnull();
- sch_table->field[ISE_LAST_EXECUTED]->
- store_time(&time, MYSQL_TIMESTAMP_DATETIME);
- }
-
- sch_table->field[ISE_EVENT_COMMENT]->
- store(et.comment.str, et.comment.length, scs);
-
+ bzero((char *)&time, sizeof(time));
+ ((Field_timestamp *) event_table->field[ET_FIELD_MODIFIED])->get_time(&time);
+ sch_table->field[ISE_LAST_ALTERED]->store_time(&time,
+ MYSQL_TIMESTAMP_DATETIME);
+
+ if (!event_table->field[ET_FIELD_LAST_EXECUTED]->is_null())
+ copy_datetime(sch_table->field[ISE_LAST_EXECUTED],
+ event_table->field[ET_FIELD_LAST_EXECUTED], time_zone);
+
+ store_field_value_to_buff(event_table->field[ET_FIELD_COMMENT], tmp_string);
+ sch_table->field[ISE_EVENT_COMMENT]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
sch_table->field[ISE_CLIENT_CS]->set_notnull();
- sch_table->field[ISE_CLIENT_CS]->store(
- et.creation_ctx->get_client_cs()->csname,
- strlen(et.creation_ctx->get_client_cs()->csname),
- scs);
+ store_field_value_to_buff(event_table->field[ET_FIELD_CHARACTER_SET_CLIENT],
+ tmp_string);
+ sch_table->field[ISE_CLIENT_CS]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
sch_table->field[ISE_CONNECTION_CL]->set_notnull();
- sch_table->field[ISE_CONNECTION_CL]->store(
- et.creation_ctx->get_connection_cl()->name,
- strlen(et.creation_ctx->get_connection_cl()->name),
- scs);
-
+ store_field_value_to_buff(event_table->field[ET_FIELD_COLLATION_CONNECTION],
+ tmp_string);
+ sch_table->field[ISE_CONNECTION_CL]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
sch_table->field[ISE_DB_CL]->set_notnull();
- sch_table->field[ISE_DB_CL]->store(
- et.creation_ctx->get_db_cl()->name,
- strlen(et.creation_ctx->get_db_cl()->name),
- scs);
+ store_field_value_to_buff(event_table->field[ET_FIELD_DB_COLLATION],
+ tmp_string);
+ sch_table->field[ISE_DB_CL]->store(tmp_string->ptr(),
+ tmp_string->length(), scs);
if (schema_table_store_record(thd, sch_table))
- DBUG_RETURN(1);
+ DBUG_RETURN(TRUE);
- DBUG_RETURN(0);
+ DBUG_RETURN(FALSE);
}
#endif
=== modified file 'sql/sql_show.h'
--- a/sql/sql_show.h 2009-10-12 09:08:34 +0000
+++ b/sql/sql_show.h 2010-03-12 14:58:40 +0000
@@ -38,6 +38,7 @@ bool store_db_create_info(THD *thd, cons
HA_CREATE_INFO *create_info, const char *orig_dbname);
int view_store_create_info(THD *thd, TABLE_LIST *table, String *buff);
-int copy_event_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table);
+int copy_event_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table,
+ String *tmp_string);
#endif /* SQL_SHOW_H */
Attachment: [text/bzr-bundle] bzr/sergey.glukhov@sun.com-20100312145840-mn65bmps6xuoeyiv.bundle
