From: Date: March 12 2010 3:58pm Subject: bzr commit into mysql-pe branch (Sergey.Glukhov:3968) Bug#48729 List-Archive: http://lists.mysql.org/commits/103110 X-Bug: 48729 Message-Id: <0KZ600LMVC8FF6B0@fe-emea-09.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="Boundary_(ID_tRpP0V2C5cSAVQw20vumMQ)" --Boundary_(ID_tRpP0V2C5cSAVQw20vumMQ) MIME-version: 1.0 Content-type: text/plain; CHARSET=US-ASCII Content-transfer-encoding: 7BIT Content-disposition: inline #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 #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 */ --Boundary_(ID_tRpP0V2C5cSAVQw20vumMQ) MIME-version: 1.0 Content-type: text/bzr-bundle; CHARSET=US-ASCII; name="bzr/sergey.glukhov@stripped" Content-transfer-encoding: 7BIT Content-disposition: inline; filename="bzr/sergey.glukhov@stripped" # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: sergey.glukhov@stripped # target_branch: file:///home/gluh/MySQL/mysql-pe-bug-48729/ # testament_sha1: e94056acb0dd53cd04bea666d4fede7f72ccd986 # timestamp: 2010-03-12 18:58:50 +0400 # base_revision_id: sergey.glukhov@stripped\ # 3ifr3q3vud44evj9 # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWc3FZ/4ACn//gFwRT91///// f+f/+r////5gE197ovnsHqseXt08etudB3t72Zejvde3KBp7s7u6EdXrC6w04o6wUaYh1RW6q4SR ECGmgTTATU2lP0GqenqmwmjTFG1NPJNp6oAAAABpoI0TU00TJqNTI8hpBoGgAANGgAADQ0eoaDga A0GjQMmgANAAYmhpoGmgBo0aABo0EhIQSGQmo0zU0BhBoyNBoANAAAMgGhpoESoEEyU/CanqeTBC mzUE/UJ6amg2oDQAaAaPUAeoARKIBDQCmNSemmExFP0mo9QAAAAAAAAZNvXBuIiBB+M9rCHs9dLK +Pj5fJ+C8O2PfApiUrUUaCDbKYd9hTSwfr2977f7OLr57nqPrb/Wtx7rlAe3sC7nWq+iXcOyQXBQ miHGE9B3RB0iMhYUmuWWEWerSOQTEhyJaHYqI3OLPfzLDa2NRmI4WkF4TXhMW9mXe0ksZs1NqhOx tUvIwyf+Wtsz5Md3TQA3NJLNgHFrBcE2PGHHCuSX2FoEVoOIt07bGa8JNmu1KNJMmJhVYupsrkP0 Swm9b8/XiMmSIiyKCwggtkFCAgERYRYIhmKP+CHVFp05Ap/JYSRqwUnWZg/PZa7hvW5IQ7yyTBHY L2Crn0Mag4VnTMzMzIST4dydHfRAOfrcvN2OsuUNyUHO3YpGDkLUhpNu6EUBKGuD2XtbBtKtVoqL IwRdRiljWRYhpCA3yDiSxm6wQWVHMutFVyTBCQ0KyWKm9qskmzKHMkEhzLuy3C2FJZApApNWtRVs tzYsQxul6hhMqFIejXZVmJMlb2Zrzzt2V3DboObxV8HEn19Vx3rKHmjRCJO/DT2e8uuTz/unb0th W2+zaVVzItxSnXVUGTiFWIXF0od2X9cw6MAYHRtG3GkZhNjTnl4KRrU2GV0hiZ4u73lrpsgYuFjr hjYLagaCCb4XVUeCAkMMEDdITFd3kU0uoBqO0wS5AQuMJbFVn+48BarCoUT+Bz5hMmGDDp05d/m1 PxdNSo4Fql5Vah/ULFR+GJBGXTv3pETMANk6HCPrZOY2UIDszC4QZ/i75G0EUtjdG6lqWJjgkLgc EcJ7oOidEWFPDKCppE6lAoU8nlTy7hRvZGyBl1eMipXoKsUXqu9CMaKYNeY4gKB2kfsGxcFDNrb2 4C545UIxmFN+To3GOltVE010+wYg4TxJvRKq7QkkgTBEC3AYSolEGEDRBDvkswGXTcq0yresBspo sSWwTBHAgyWmWzLBVldImZQcbqeFncu9UYgsVSrPLa1GdK9IAcCg7hARJTRE0BvQjCNCqDEPoQlD 3HT4fQrZtMYzxjW5B8+cGEkwuTLZkUYDbawUWSW4VBRVh8tBawUiWC1CGzQ59T9F9QB7ng55LwhQ ioG7LSV1BaqbIiVrqijIJr1/TtvD5Xta+lrmJv2fL0OI4uu7h6mZ5dcs/jyNh1EJZ89Je7IjjUWx L75sbvDbVEk+93OEesVixXXIpCrsbBgbnjXFBoxx4IoRCAyAd8Ab76X9eNXwCey4Sl1uiylb3FW2 VWvEiSurK7q9YLSncZg3rXVroTWUMit50rJ4zRUETKRPmJFEbCRkl5ypZ6wWOpOUl4rnRbSDIgAY NNWMs8g+yx0rYcTQiJJQuqaV/RRLCoxUVWEUhAqV8tXE8W2RlQ67QoXBFLSA2eWgQZjr7kzxMLNZ oL6GMLu3ryvLNf8XaXatgXjrvDreBBPGtoCUJRHIQVPAMy1hyuNg44rJ3vrRECvKWAsQg0rSEdIF BxqtYxRoiH3taTZNosu/MNjPWGfATJMxcSCkpIQwEoTXMsgicUgVxqehYzV0yNigTaKK9YD1SxpZ w6ZtLVmkVfkD0hFyFFUXSsyJRgqbE40Kb0/1O1tuAmDlr2mNea1jjhZGmxEFnCpUMGNKcjzGq4bV geSfQ764lrpdbGdJNC1EM0i1EVrgmsrKFwMrjWefJfxVYLTbbdBk0ywzhTCeEb7hy3CdMDk62EzT kKYXTfbJ2XgrmH2VDdQWl3mUmzwlXg9u+8wyGoeVMZFQ4Xk0xUnoMo88RzbMs63EE1iajRLsGwMY rbl1GReJqLTPjvri00K2JGGixerXL4dyzWRElCOmsvcZuheyz4cIh3NWAOcIJrLonhgjWJXKgV9S XYVBwgrIgXDjaOG6rOFda0KlaxFV+D1Mrr1O1oeDs0l1TQUz3CVYSENskHILQuZX9WAlMGAckt14 ECs6twHtxcqGKF2ZZZBHLy7xvGBwTqZdtOG4114232aEQZhG4hCjiEqJ1qLAiFLU1u3eEK0hYYy9 7yjIfDw2KbzM9ur1QbUHMMBXkHSzEVEXOqKxt1ylU2EKjWqrhyATgFMcuGoIBTAtEOQwrBFkuH1i ggiBqHGKjgNwqNBs7dsxXq5b9gi5wi6bmRQCgVL1UUIG0m7bXIcdT74dMaQSkSRpEkE8oHqnjESQ ww4odE44BTEHWZTpastAHxx9q6XjVcNu/Xdm3l4bBkcpeoM00TQQ29HsnnpPsb8tirPN1hCEXgDI qu45MtCPl6B/3+D5DclPWBV7iBYUfuQ8DtGiekPb7jDhTQSFchu3hmGGGO0UVOJUb0A5/vlsWBEg 0Hd5iEPaXXrLNn3FAsA9yizHaKZEEdjpP9khupWwpw3cLNDb/1MN0cOCSoKW7zBdjB5rdUhRpIQr iXvxUXSH3ihQwLdMsZG8IudoPBaESG+CuZblo5NeKqqqNhokqIxI/t1fEWlA0824zBTmHZqLrDpw Kw+naYEHWBLfu6R6mEKtDEVODuLd/EuE/SXhQ142vG2wbVNoJq0/FTDH4rTViFA4Ap90ZVHT0HXy wbeJ0BQ9IlhDSKwsyznOHBhaIQLLXAIWGw3kghPCWtlpit4FiXjxauJa8Gg3kCoxo4FhhQuM7hvV yJgDuk4F6JmHB0bQiyGMo6rpRxuEkCi0bitk8qemqfHmCoghGcoWKvANJo33qZFjwpZQCMOSJsen 0ddxocQot8xKUXKzdWpzpN2p1VLuIJwK+MeKjkUC3UijmbWBntuV1KeJ8fZoO8e+UApTW38Eax0g mYwm+okWhcuHRFxHFpqaDNjOpma6t55VRHmmZEXe1WnmLxLy8MaYXNI0lpGjRRoeYhyzMQ2HWBaX Z84nYwomZYQwHQtIh6C4Io8qQsfeAjoYBHsQcfcSlnylELxTAkLllWmIkR5fTdhWBeKk0hi9mu/W XgyxDEy2Te+MyMsdz3O68a7agNMs1nwL3dxQ8zIZCsZssFqC1Fc7yylZpss71CJVlNxxsJIRkkjJ AJJCDBqRhYDGLqsXLYwr4B0y//SMuhGfSAo8esq4BrIY/ONhp2WXuyHK2M2brn0dA5iXs+1sSF7l /mkkHG02yL3l9iOkXrJD7TY2MbG2MUS1iskLm6xbFZQPkaiMJwTzbMNRSQY2ztB2lSP5VMdY2+WJ sUg5JiXsc9IlHaUA1CibMM00XhKGYlVGoJRWjYY3FlVHdC1MQuKGIXqNond4EyA8S09Z3lDHRzI8 1VQXGI12ZyK6irFsVkgUntMWMAYXk72YEeY+O1BIfQI3Gticx8EA6ZwHCA8ZUDVoL680vobFvCuS qQ7bHvTCOU0GU2jYjEuc8ROhTjjm8r6SByugTHh7Pt+Z7LSo/ZB8kGyIZeWkN/yIfFAAZgFmIZDR qWaCb773UYTKUaTuDfZDV0CsU2oMSJ86mBz7AcL6Z494plx5gonMB+FtR1X6HGnE1oGOJc0/z96t dHQ9BV1QSLAhIPn35uGfuaUgSEoco2WUOmQiRCd72ae4w7z4TqP1ObmZp0FNZnpS3wLLRLRBLIi4 mo9Xu5CvaaXeQz7DnPUmSzo/XI03EcQU27iy1jTPTIb0y3K2dZNYa5b6RCeAwjYNwiEaZ2CJthYG DGxNDBCHaDQEyyrjW6ZCpVvIS5drWU2PE5yKCKSsSW3IykXfuUdq1cBhUZD0KO8qJx8jAxq0b/dp u5y3n00sJhzYh4vuMQS35L4Ai6UqjrNyL7xcmCDF8wkHcmcCMDRZi1Xf9suFtDxLBuQxyuNRv3iZ pHNo2hQjYEWFTBLNXX030wfXXifW6vdtTpMcgwY33e33XUkLFNU+RFmkTk6jG35t2tdqvsE7nf5l Kte6gQRgxX4RPYHkWt3u9ZaF6FlLTsKKY2h61BuDrZtcWHr8YroijRGQkSECtRnU6ud3NsLJhBJy uh5vA6lrNccLE5zeoOWwAyQQJEB7bcaAt7HOpScFxheV8DVyI467nC2zNaBeh4uwTu0EUY/IoHzR hRU8gIoUNbAfuc9jfZRHwq2lLzzOFzvM7BV7l0NeQ8efUVmam/e2hoR+lsUEhAW0XTjhDeoJr7vd C9rdGWlxdCN8W+i6SA3zsYQ6rOEZYQErz2JlS/AAasdTdH2Q2sRobVPPWpYZhDHE8NIaRF6ItfYI 13ooW67ZaeBo6q3wvbqHaZmOx3w3K5hxt15SD2r6SO1KBVYFRIDhc+BGEiTjKERQhBWPiKDFO+wH 2QCSRlm9wcnFzRjWlfby6q77lH7RcjWvPvQPLcIVdyWwJEhJCRYMiMbSKaDofnddjcTZy6XHg72l gkfO5mJsPSFIKJaZhschLQ3HKu7tI8vj3mOgpHaATGJsoSqBHzbAbqQD0nnw2XWAWxYboCebEogW QFS4pYC6nn4a3LqyzOQXODkSBpNMdKqxCMgF4c5Vwoy8IGllKghAXqhqE0uImzeGo5IHaz5TDNWP uU0lSoYylJxFQ5UkAOHLvQuDAOLAWWJjpSTEUly60YRQgokDe8XnsKvb29iXRsyuD2HTCzUPa6nW HnHF+DJ6nU5B5ISSSHdApt2sLQnoptIEgNtTAJyt9xceUQyY2p2W+QCQ2aFWkmVQ1MM7paqQIpos G2OzT6BYVVshIAtnsPBUJBwPfNnDu0umNOBAt30Qe474cnsse9peFuaLbhQd5Q8dM0O3EiEMYGMQ rUpENPlU5StOzmYeBLKK4EAvg2p2bBNFthLcrCZBTWpcPwmwPVEnQUpCQtUiv94Z8TjamNR+f0nI okaVLnX4NE4FoYi6DLbCSAeTzRXVxHGiGvAHA9ZJJMdAZxD6jo45ZM5Ch3uZg41cqUaXX70Tk9DR 9JkmQ8RG9DX0D3HQSBHJJY4wOP1iJIRv9YA141qcpzlgjvjsa2Uh3vZ8NhaQLhYxiemgFCdh7RoA FSJ1F2hHSER4PCAUBWvc60uy7apoOvShcmA6+zao++1pLTh6CIUzd1p3G0M0vDuUzC2kQ7UUcJ4B o8uYXzVKOPvPvewkfysIvvf9SH1/3+OdnbX4/K/ZkieFU5yPmBD0qAdXoGFF9oDCKQ8osVE42qiO qJZ0tzXzNgbw+s8Tt8QtcvSuEEopAvBnSVQvMBzK4AOdtvxiI7RzRxD3jvcJuc5RAMGakXgKo86k C4o1inzRELqd8i2vPBCw1WhutZVVKMkZPRuKePCOcjA4YK1NpjayZb2xzuDpahPEJMzWQrjTCIwp MXaSDIg6iIiFDq/EzIjIT2BLKHn9UuYRX0YFwYD/AoIOn/4u5IpwoSGbis/8 --Boundary_(ID_tRpP0V2C5cSAVQw20vumMQ)--