Merge ahristov@bk-internal.mysql.com:/home/bk/mysql-5.1-new (6f91d118) · Commits · Software / OSDI20 Artifacts / mariadb

sql/event.cc

+32 −32

Original line number	Diff line number	Diff line
		@@ -49,11 +49,11 @@
		- Consider using conditional variable when doing shutdown instead of
		waiting till all worker threads end.

		- Make event_timed::get_show_create_event() work
		- Make Event_timed::get_show_create_event() work

		- Add logging to file

		- Move comparison code to class event_timed
		- Move comparison code to class Event_timed

		Warning:
		- For now parallel execution is not possible because the same sp_head cannot be
		@@ -276,13 +276,13 @@ my_time_compare(TIME a, TIME b)


		/*
		Compares the execute_at members of 2 event_timed instances
		Compares the execute_at members of 2 Event_timed instances

		Synopsis
		event_timed_compare()

		a - first event_timed object
		b - second event_timed object
		a - first Event_timed object
		b - second Event_timed object

		RETURNS:
		-1 - a->execute_at < b->execute_at
		@@ -294,14 +294,14 @@ my_time_compare(TIME a, TIME b)
		*/

		int
		event_timed_compare(event_timed a, event_timed b)
		event_timed_compare(Event_timed a, Event_timed b)
		{
		return my_time_compare(&a->execute_at, &b->execute_at);
		}


		/*
		Compares the execute_at members of 2 event_timed instances.
		Compares the execute_at members of 2 Event_timed instances.
		Used as callback for the prioritized queue when shifting
		elements inside.

		@@ -309,8 +309,8 @@ event_timed_compare(event_timed a, event_timed b)
		event_timed_compare()

		vptr - not used (set it to NULL)
		a - first event_timed object
		b - second event_timed object
		a - first Event_timed object
		b - second Event_timed object

		RETURNS:
		-1 - a->execute_at < b->execute_at
		@@ -324,7 +324,7 @@ event_timed_compare(event_timed a, event_timed b)
		int
		event_timed_compare_q(void vptr, byte a, byte *b)
		{
		return event_timed_compare((event_timed )a, (event_timed )b);
		return event_timed_compare((Event_timed )a, (Event_timed )b);
		}


		@@ -520,7 +520,7 @@ evex_open_event_table(THD thd, enum thr_lock_type lock_type, TABLE *table)
		*/

		inline int
		evex_db_find_event_aux(THD thd, event_timed et, TABLE *table)
		evex_db_find_event_aux(THD thd, Event_timed et, TABLE *table)
		{
		return evex_db_find_event_by_name(thd, et->dbname, et->name,
		et->definer, table);
		@@ -600,7 +600,7 @@ evex_db_find_event_by_name(THD *thd, const LEX_STRING dbname,
		*/

		static int
		evex_fill_row(THD thd, TABLE table, event_timed *et, my_bool is_update)
		evex_fill_row(THD thd, TABLE table, Event_timed *et, my_bool is_update)
		{
		enum evex_table_field field_num;

		@@ -707,7 +707,7 @@ evex_fill_row(THD thd, TABLE table, event_timed *et, my_bool is_update)
		SYNOPSIS
		db_create_event()
		thd THD
		et event_timed object containing information for the event
		et Event_timed object containing information for the event
		create_if_not - if an warning should be generated in case event exists
		rows_affected - how many rows were affected

		@@ -720,7 +720,7 @@ evex_fill_row(THD thd, TABLE table, event_timed *et, my_bool is_update)
		*/

		static int
		db_create_event(THD thd, event_timed et, my_bool create_if_not,
		db_create_event(THD thd, Event_timed et, my_bool create_if_not,
		uint *rows_affected)
		{
		int ret= 0;
		@@ -855,7 +855,7 @@ db_create_event(THD thd, event_timed et, my_bool create_if_not,
		*/

		static int
		db_update_event(THD thd, event_timed et, sp_name *new_name)
		db_update_event(THD thd, Event_timed et, sp_name *new_name)
		{
		TABLE *table;
		int ret= EVEX_OPEN_TABLE_FAILED;
		@@ -954,13 +954,13 @@ db_update_event(THD thd, event_timed et, sp_name *new_name)
		*/

		static int
		db_find_event(THD thd, sp_name name, LEX_STRING definer, event_timed *ett,
		db_find_event(THD thd, sp_name name, LEX_STRING definer, Event_timed *ett,
		TABLE tbl, MEM_ROOT root)
		{
		TABLE *table;
		int ret;
		char *ptr;
		event_timed *et=NULL;
		Event_timed *et=NULL;
		DBUG_ENTER("db_find_event");
		DBUG_PRINT("enter", ("name: %*s", name->m_name.length, name->m_name.str));

		@@ -982,7 +982,7 @@ db_find_event(THD thd, sp_name name, LEX_STRING definer, event_timed *ett,
		my_error(ER_EVENT_DOES_NOT_EXIST, MYF(0), name->m_name.str);
		goto done;
		}
		et= new event_timed;
		et= new Event_timed;

		/*
		1)The table should not be closed beforehand. ::load_from_row() only loads
		@@ -1032,7 +1032,7 @@ evex_load_and_compile_event(THD * thd, sp_name *spn, LEX_STRING definer,
		{
		int ret= 0;
		MEM_ROOT *tmp_mem_root;
		event_timed *ett;
		Event_timed *ett;
		Open_tables_state backup;

		DBUG_ENTER("db_load_and_compile_event");
		@@ -1089,7 +1089,7 @@ evex_load_and_compile_event(THD * thd, sp_name *spn, LEX_STRING definer,
		use_lock - whether to lock the mutex LOCK_event_arrays or not in case it
		has been already locked outside
		is_drop - if an event is currently being executed then we can also delete
		the event_timed instance, so we alarm the event that it should
		the Event_timed instance, so we alarm the event that it should
		drop itself if this parameter is set to TRUE. It's false on
		ALTER EVENT.

		@@ -1116,7 +1116,7 @@ evex_remove_from_cache(LEX_STRING db, LEX_STRING name, bool use_lock,

		for (i= 0; i < evex_queue_num_elements(EVEX_EQ_NAME); ++i)
		{
		event_timed et= evex_queue_element(&EVEX_EQ_NAME, i, event_timed);
		Event_timed et= evex_queue_element(&EVEX_EQ_NAME, i, Event_timed);
		DBUG_PRINT("info", ("[%s.%s]==[%s.%s]?",db->str,name->str, et->dbname.str,
		et->name.str));
		if (!sortcmp_lex_string(*name, et->name, system_charset_info) &&
		@@ -1168,7 +1168,7 @@ evex_remove_from_cache(LEX_STRING db, LEX_STRING name, bool use_lock,
		*/

		int
		evex_create_event(THD thd, event_timed et, uint create_options,
		evex_create_event(THD thd, Event_timed et, uint create_options,
		uint *rows_affected)
		{
		int ret = 0;
		@@ -1213,7 +1213,7 @@ evex_create_event(THD thd, event_timed et, uint create_options,
		*/

		int
		evex_update_event(THD thd, event_timed et, sp_name *new_name,
		evex_update_event(THD thd, Event_timed et, sp_name *new_name,
		uint *rows_affected)
		{
		int ret, i;
		@@ -1267,7 +1267,7 @@ evex_update_event(THD thd, event_timed et, sp_name *new_name,
		rows_affected affected number of rows is returned heres
		*/

		int db_drop_event(THD thd, event_timed et, bool drop_if_exists,
		int db_drop_event(THD thd, Event_timed et, bool drop_if_exists,
		uint *rows_affected)
		{
		TABLE *table;
		@@ -1308,7 +1308,7 @@ int db_drop_event(THD thd, event_timed et, bool drop_if_exists,

		done:
		/*
		evex_drop_event() is used by event_timed::drop therefore
		evex_drop_event() is used by Event_timed::drop therefore
		we have to close our thread tables.
		*/
		close_thread_tables(thd);
		@@ -1330,7 +1330,7 @@ int db_drop_event(THD thd, event_timed et, bool drop_if_exists,
		*/

		int
		evex_drop_event(THD thd, event_timed et, bool drop_if_exists,
		evex_drop_event(THD thd, Event_timed et, bool drop_if_exists,
		uint *rows_affected)
		{
		TABLE *table;
		@@ -1373,7 +1373,7 @@ int
		evex_show_create_event(THD thd, sp_name spn, LEX_STRING definer)
		{
		int ret;
		event_timed *et= NULL;
		Event_timed *et= NULL;
		Open_tables_state backup;

		DBUG_ENTER("evex_update_event");
		@@ -1442,15 +1442,15 @@ evex_show_create_event(THD thd, sp_name spn, LEX_STRING definer)
		1. Go through the in-memory cache, if the scheduler is working
		and for every event whose dbname matches the database we drop
		check whether is currently in execution:
		- event_timed::can_spawn() returns true -> the event is not
		- Event_timed::can_spawn() returns true -> the event is not
		being executed in a child thread. The reason not to use
		event_timed::is_running() is that the latter shows only if
		Event_timed::is_running() is that the latter shows only if
		it is being executed, which is 99% of the time in the thread
		but there are some initiliazations before and after the
		anonymous SP is being called. So if we delete in this moment
		-=> boom, so we have to check whether the thread has been
		spawned and can_spawn() is the right method.
		- event_timed::can_spawn() returns false -> being runned ATM
		- Event_timed::can_spawn() returns false -> being runned ATM
		just set the flags so it should drop itself.
		*/

		@@ -1484,7 +1484,7 @@ evex_drop_db_events(THD thd, char db)

		for (i= 0; i < evex_queue_num_elements(EVEX_EQ_NAME); ++i)
		{
		event_timed et= evex_queue_element(&EVEX_EQ_NAME, i, event_timed);
		Event_timed et= evex_queue_element(&EVEX_EQ_NAME, i, Event_timed);
		if (sortcmp_lex_string(et->dbname, db_lex, system_charset_info))
		continue;

		@@ -1561,7 +1561,7 @@ evex_drop_db_events(THD thd, char db)
		LEX_STRING et_db_lex= {et_db, strlen(et_db)};
		if (!sortcmp_lex_string(et_db_lex, db_lex, system_charset_info))
		{
		event_timed ett;
		Event_timed ett;
		char *ptr;

		if ((ptr= get_field(thd->mem_root, table->field[EVEX_FIELD_STATUS]))

sql/event.h

+9 −9

Original line number	Diff line number	Diff line
		@@ -76,10 +76,10 @@ enum evex_table_field
		EVEX_FIELD_COUNT /* a cool trick to count the number of fields :) */
		} ;

		class event_timed
		class Event_timed
		{
		event_timed(const event_timed &); /* Prevent use of these */
		void operator=(event_timed &);
		Event_timed(const Event_timed &); /* Prevent use of these */
		void operator=(Event_timed &);
		my_bool in_spawned_thread;
		ulong locked_by_thread_id;
		my_bool running;
		@@ -122,7 +122,7 @@ class event_timed
		bool free_sphead_on_delete;
		uint flags;//all kind of purposes

		event_timed():in_spawned_thread(0),locked_by_thread_id(0),
		Event_timed():in_spawned_thread(0),locked_by_thread_id(0),
		running(0), status_changed(false),
		last_executed_changed(false), expression(0), created(0),
		modified(0), on_completion(MYSQL_EVENT_ON_COMPLETION_DROP),
		@@ -135,7 +135,7 @@ class event_timed
		init();
		}

		~event_timed()
		~Event_timed()
		{
		pthread_mutex_destroy(&this->LOCK_running);
		if (free_sphead_on_delete)
		@@ -259,15 +259,15 @@ class event_timed


		int
		evex_create_event(THD thd, event_timed et, uint create_options,
		evex_create_event(THD thd, Event_timed et, uint create_options,
		uint *rows_affected);

		int
		evex_update_event(THD thd, event_timed et, sp_name *new_name,
		evex_update_event(THD thd, Event_timed et, sp_name *new_name,
		uint *rows_affected);

		int
		evex_drop_event(THD thd, event_timed et, bool drop_if_exists,
		evex_drop_event(THD thd, Event_timed et, bool drop_if_exists,
		uint *rows_affected);

		int
		@@ -296,7 +296,7 @@ shutdown_events();

		// auxiliary
		int
		event_timed_compare(event_timed a, event_timed b);
		event_timed_compare(Event_timed a, Event_timed b);

sql/event_executor.cc

+14 −14

Original line number	Diff line number	Diff line
		@@ -55,7 +55,7 @@ static int
		evex_load_events_from_db(THD *thd);

		bool
		evex_print_warnings(THD thd, event_timed et);
		evex_print_warnings(THD thd, Event_timed et);

		/*
		TODO Andrey: Check for command line option whether to start
		@@ -316,7 +316,7 @@ init_event_thread(THD* thd)
		static int
		executor_wait_till_next_event_exec(THD *thd)
		{
		event_timed *et;
		Event_timed *et;
		TIME time_now;
		int t2sleep;

		@@ -331,7 +331,7 @@ executor_wait_till_next_event_exec(THD *thd)
		VOID(pthread_mutex_unlock(&LOCK_event_arrays));
		DBUG_RETURN(WAIT_STATUS_EMPTY_QUEUE);
		}
		et= evex_queue_first_element(&EVEX_EQ_NAME, event_timed*);
		et= evex_queue_first_element(&EVEX_EQ_NAME, Event_timed*);
		DBUG_ASSERT(et);
		if (et->status == MYSQL_EVENT_DISABLED)
		{
		@@ -361,7 +361,7 @@ executor_wait_till_next_event_exec(THD *thd)
		*/
		while (t2sleep-- && !thd->killed && event_executor_running_global_var &&
		evex_queue_num_elements(EVEX_EQ_NAME) &&
		(evex_queue_first_element(&EVEX_EQ_NAME, event_timed*) == et))
		(evex_queue_first_element(&EVEX_EQ_NAME, Event_timed*) == et))
		{
		DBUG_PRINT("evex main thread",("will sleep a bit more"));
		my_sleep(1000000);
		@@ -371,7 +371,7 @@ executor_wait_till_next_event_exec(THD *thd)
		int ret= WAIT_STATUS_READY;
		if (!evex_queue_num_elements(EVEX_EQ_NAME))
		ret= WAIT_STATUS_EMPTY_QUEUE;
		else if (evex_queue_first_element(&EVEX_EQ_NAME, event_timed*) != et)
		else if (evex_queue_first_element(&EVEX_EQ_NAME, Event_timed*) != et)
		ret= WAIT_STATUS_NEW_TOP_EVENT;
		if (thd->killed && event_executor_running_global_var)
		ret= WAIT_STATUS_STOP_EXECUTOR;
		@@ -470,7 +470,7 @@ event_executor_main(void *arg)
		while (!thd->killed)
		{
		TIME time_now;
		event_timed *et;
		Event_timed *et;

		cnt++;
		DBUG_PRINT("info", ("EVEX External Loop %d thd->k", cnt));
		@@ -519,7 +519,7 @@ event_executor_main(void *arg)
		DBUG_PRINT("evex main thread",("empty queue"));
		continue;
		}
		et= evex_queue_first_element(&EVEX_EQ_NAME, event_timed*);
		et= evex_queue_first_element(&EVEX_EQ_NAME, Event_timed*);
		DBUG_PRINT("evex main thread",("got event from the queue"));

		if (!et->execute_at_null && my_time_compare(&time_now,&et->execute_at) == -1)
		@@ -621,7 +621,7 @@ event_executor_main(void *arg)
		VOID(pthread_mutex_lock(&LOCK_event_arrays));
		for (i= 0; i < evex_queue_num_elements(EVEX_EQ_NAME); ++i)
		{
		event_timed et= evex_queue_element(&EVEX_EQ_NAME, i, event_timed);
		Event_timed et= evex_queue_element(&EVEX_EQ_NAME, i, Event_timed);
		et->free_sp();
		delete et;
		}
		@@ -666,14 +666,14 @@ event_executor_main(void *arg)

		SYNOPSIS
		event_executor_worker()
		arg The event_timed object to be processed
		arg The Event_timed object to be processed
		*/

		pthread_handler_t
		event_executor_worker(void *event_void)
		{
		THD thd; / needs to be first for thread_stack */
		event_timed event = (event_timed ) event_void;
		Event_timed event = (Event_timed ) event_void;
		MEM_ROOT worker_mem_root;

		DBUG_ENTER("event_executor_worker");
		@@ -771,7 +771,7 @@ event_executor_worker(void *event_void)
		/*
		Loads all ENABLED events from mysql.event into the prioritized
		queue. Called during scheduler main thread initialization. Compiles
		the events. Creates event_timed instances for every ENABLED event
		the events. Creates Event_timed instances for every ENABLED event
		from mysql.event.

		SYNOPSIS
		@@ -808,8 +808,8 @@ evex_load_events_from_db(THD *thd)
		init_read_record(&read_record_info, thd, table ,NULL,1,0);
		while (!(read_record_info.read_record(&read_record_info)))
		{
		event_timed *et;
		if (!(et= new event_timed))
		Event_timed *et;
		if (!(et= new Event_timed))
		{
		DBUG_PRINT("evex_load_events_from_db", ("Out of memory"));
		ret= -1;
		@@ -941,7 +941,7 @@ static sql_print_xxx_func sql_print_xxx_handlers[3] =
		*/

		bool
		evex_print_warnings(THD thd, event_timed et)
		evex_print_warnings(THD thd, Event_timed et)
		{
		MYSQL_ERROR *err;
		DBUG_ENTER("evex_show_warnings");

sql/event_priv.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -44,7 +44,7 @@ evex_db_find_event_by_name(THD *thd, const LEX_STRING dbname,
		int
		event_timed_compare_q(void vptr, byte a, byte *b);

		int db_drop_event(THD thd, event_timed et, bool drop_if_exists,
		int db_drop_event(THD thd, Event_timed et, bool drop_if_exists,
		uint *rows_affected);

sql/event_timed.cc

+63 −63

Original line number	Diff line number	Diff line
		@@ -26,13 +26,13 @@ extern int yyparse(void *thd);
		Init all member variables

		SYNOPSIS
		event_timed::init()
		Event_timed::init()
		*/

		void
		event_timed::init()
		Event_timed::init()
		{
		DBUG_ENTER("event_timed::init");
		DBUG_ENTER("Event_timed::init");

		dbname.str= name.str= body.str= comment.str= 0;
		dbname.length= name.length= body.length= comment.length= 0;
		@@ -56,15 +56,15 @@ event_timed::init()
		Set a name of the event

		SYNOPSIS
		event_timed::init_name()
		Event_timed::init_name()
		thd THD
		spn the name extracted in the parser
		*/

		void
		event_timed::init_name(THD thd, sp_name spn)
		Event_timed::init_name(THD thd, sp_name spn)
		{
		DBUG_ENTER("event_timed::init_name");
		DBUG_ENTER("Event_timed::init_name");
		uint n; /* Counter for nul trimming */
		/* During parsing, we must use thd->mem_root */
		MEM_ROOT *root= thd->mem_root;
		@@ -100,7 +100,7 @@ event_timed::init_name(THD thd, sp_name spn)
		Set body of the event - what should be executed.

		SYNOPSIS
		event_timed::init_body()
		Event_timed::init_body()
		thd THD

		NOTE
		@@ -109,9 +109,9 @@ event_timed::init_name(THD thd, sp_name spn)
		*/

		void
		event_timed::init_body(THD *thd)
		Event_timed::init_body(THD *thd)
		{
		DBUG_ENTER("event_timed::init_body");
		DBUG_ENTER("Event_timed::init_body");
		DBUG_PRINT("info", ("body=[%s] body_begin=0x%ld end=0x%ld", body_begin,
		body_begin, thd->lex->ptr));

		@@ -136,7 +136,7 @@ event_timed::init_body(THD *thd)
		Set time for execution for one time events.

		SYNOPSIS
		event_timed::init_execute_at()
		Event_timed::init_execute_at()
		expr when (datetime)

		RETURN VALUE
		@@ -147,14 +147,14 @@ event_timed::init_body(THD *thd)
		*/

		int
		event_timed::init_execute_at(THD thd, Item expr)
		Event_timed::init_execute_at(THD thd, Item expr)
		{
		my_bool not_used;
		TIME ltime;
		my_time_t my_time_tmp;

		TIME time_tmp;
		DBUG_ENTER("event_timed::init_execute_at");
		DBUG_ENTER("Event_timed::init_execute_at");

		if (expr->fix_fields(thd, &expr))
		DBUG_RETURN(EVEX_PARSE_ERROR);
		@@ -192,7 +192,7 @@ event_timed::init_execute_at(THD thd, Item expr)
		Set time for execution for transient events.

		SYNOPSIS
		event_timed::init_interval()
		Event_timed::init_interval()
		expr how much?
		new_interval what is the interval

		@@ -204,13 +204,13 @@ event_timed::init_execute_at(THD thd, Item expr)
		*/

		int
		event_timed::init_interval(THD thd, Item expr, interval_type new_interval)
		Event_timed::init_interval(THD thd, Item expr, interval_type new_interval)
		{
		longlong tmp;
		String value;
		INTERVAL interval;

		DBUG_ENTER("event_timed::init_interval");
		DBUG_ENTER("Event_timed::init_interval");

		if (expr->fix_fields(thd, &expr))
		DBUG_RETURN(EVEX_PARSE_ERROR);
		@@ -289,7 +289,7 @@ event_timed::init_interval(THD thd, Item expr, interval_type new_interval)
		Set activation time.

		SYNOPSIS
		event_timed::init_starts()
		Event_timed::init_starts()
		expr how much?
		interval what is the interval

		@@ -307,12 +307,12 @@ event_timed::init_interval(THD thd, Item expr, interval_type new_interval)
		*/

		int
		event_timed::init_starts(THD thd, Item new_starts)
		Event_timed::init_starts(THD thd, Item new_starts)
		{
		my_bool not_used;
		TIME ltime, time_tmp;

		DBUG_ENTER("event_timed::init_starts");
		DBUG_ENTER("Event_timed::init_starts");

		if (new_starts->fix_fields(thd, &new_starts))
		DBUG_RETURN(EVEX_PARSE_ERROR);
		@@ -346,7 +346,7 @@ event_timed::init_starts(THD thd, Item new_starts)
		Set deactivation time.

		SYNOPSIS
		event_timed::init_ends()
		Event_timed::init_ends()
		thd THD
		new_ends when?

		@@ -365,12 +365,12 @@ event_timed::init_starts(THD thd, Item new_starts)
		*/

		int
		event_timed::init_ends(THD thd, Item new_ends)
		Event_timed::init_ends(THD thd, Item new_ends)
		{
		TIME ltime, ltime_now;
		my_bool not_used;

		DBUG_ENTER("event_timed::init_ends");
		DBUG_ENTER("Event_timed::init_ends");

		if (new_ends->fix_fields(thd, &new_ends))
		DBUG_RETURN(EVEX_PARSE_ERROR);
		@@ -411,15 +411,15 @@ event_timed::init_ends(THD thd, Item new_ends)
		Sets comment.

		SYNOPSIS
		event_timed::init_comment()
		Event_timed::init_comment()
		thd THD - used for memory allocation
		comment the string.
		*/

		void
		event_timed::init_comment(THD thd, LEX_STRING set_comment)
		Event_timed::init_comment(THD thd, LEX_STRING set_comment)
		{
		DBUG_ENTER("event_timed::init_comment");
		DBUG_ENTER("Event_timed::init_comment");

		comment.str= strmake_root(thd->mem_root, set_comment->str,
		comment.length= set_comment->length);
		@@ -432,13 +432,13 @@ event_timed::init_comment(THD thd, LEX_STRING set_comment)
		Inits definer (definer_user and definer_host) during parsing.

		SYNOPSIS
		event_timed::init_definer()
		Event_timed::init_definer()
		*/

		int
		event_timed::init_definer(THD *thd)
		Event_timed::init_definer(THD *thd)
		{
		DBUG_ENTER("event_timed::init_definer");
		DBUG_ENTER("Event_timed::init_definer");

		DBUG_PRINT("info",("init definer_user thd->mem_root=0x%lx "
		"thd->sec_ctx->priv_user=0x%lx", thd->mem_root,
		@@ -473,7 +473,7 @@ event_timed::init_definer(THD *thd)
		Loads an event from a row from mysql.event

		SYNOPSIS
		event_timed::load_from_row(MEM_ROOT mem_root, TABLE table)
		Event_timed::load_from_row(MEM_ROOT mem_root, TABLE table)

		NOTES
		This method is silent on errors and should behave like that. Callers
		@@ -482,16 +482,16 @@ event_timed::init_definer(THD *thd)
		*/

		int
		event_timed::load_from_row(MEM_ROOT mem_root, TABLE table)
		Event_timed::load_from_row(MEM_ROOT mem_root, TABLE table)
		{
		longlong created;
		longlong modified;
		char *ptr;
		event_timed *et;
		Event_timed *et;
		uint len;
		bool res1, res2;

		DBUG_ENTER("event_timed::load_from_row");
		DBUG_ENTER("Event_timed::load_from_row");

		if (!table)
		goto error;
		@@ -698,7 +698,7 @@ bool get_next_time(TIME next, TIME start, int i_value, interval_type i_type)
		Computes next execution time.

		SYNOPSIS
		event_timed::compute_next_execution_time()
		Event_timed::compute_next_execution_time()

		NOTES
		The time is set in execute_at, if no more executions the latter is set to
		@@ -706,13 +706,13 @@ bool get_next_time(TIME next, TIME start, int i_value, interval_type i_type)
		*/

		bool
		event_timed::compute_next_execution_time()
		Event_timed::compute_next_execution_time()
		{
		TIME time_now;
		my_time_t now;
		int tmp;

		DBUG_ENTER("event_timed::compute_next_execution_time");
		DBUG_ENTER("Event_timed::compute_next_execution_time");

		if (status == MYSQL_EVENT_DISABLED)
		{
		@@ -918,12 +918,12 @@ event_timed::compute_next_execution_time()
		time according to thd->query_start(), so the THD's clock.

		SYNOPSIS
		event_timed::drop()
		Event_timed::drop()
		thd thread context
		*/

		void
		event_timed::mark_last_executed(THD *thd)
		Event_timed::mark_last_executed(THD *thd)
		{
		TIME time_now;

		@@ -942,7 +942,7 @@ event_timed::mark_last_executed(THD *thd)
		Drops the event

		SYNOPSIS
		event_timed::drop()
		Event_timed::drop()
		thd thread context

		RETURN VALUE
		@@ -955,11 +955,11 @@ event_timed::mark_last_executed(THD *thd)
		*/

		int
		event_timed::drop(THD *thd)
		Event_timed::drop(THD *thd)
		{
		TABLE *table;
		uint tmp= 0;
		DBUG_ENTER("event_timed::drop");
		DBUG_ENTER("Event_timed::drop");

		DBUG_RETURN(db_drop_event(thd, this, false, &tmp));
		}
		@@ -969,7 +969,7 @@ event_timed::drop(THD *thd)
		Saves status and last_executed_at to the disk if changed.

		SYNOPSIS
		event_timed::update_fields()
		Event_timed::update_fields()
		thd - thread context

		RETURN VALUE
		@@ -982,14 +982,14 @@ event_timed::drop(THD *thd)
		*/

		bool
		event_timed::update_fields(THD *thd)
		Event_timed::update_fields(THD *thd)
		{
		TABLE *table;
		Open_tables_state backup;
		int ret= 0;
		bool opened;

		DBUG_ENTER("event_timed::update_time_fields");
		DBUG_ENTER("Event_timed::update_time_fields");

		DBUG_PRINT("enter", ("name: %*s", name.length, name.str));

		@@ -1043,7 +1043,7 @@ extern LEX_STRING interval_type_to_name[];
		Get SHOW CREATE EVENT as string

		SYNOPSIS
		event_timed::get_create_event(THD thd, String buf)
		Event_timed::get_create_event(THD thd, String buf)
		thd Thread
		buf String*, should be already allocated. CREATE EVENT goes inside.

		@@ -1055,7 +1055,7 @@ extern LEX_STRING interval_type_to_name[];
		*/

		int
		event_timed::get_create_event(THD thd, String buf)
		Event_timed::get_create_event(THD thd, String buf)
		{
		int multipl= 0;
		char tmp_buff[128];
		@@ -1133,14 +1133,14 @@ event_timed::get_create_event(THD thd, String buf)
		*/

		int
		event_timed::execute(THD thd, MEM_ROOT mem_root)
		Event_timed::execute(THD thd, MEM_ROOT mem_root)
		{
		Security_context *save_ctx;
		/* this one is local and not needed after exec */
		Security_context security_ctx;
		int ret= 0;

		DBUG_ENTER("event_timed::execute");
		DBUG_ENTER("Event_timed::execute");
		DBUG_PRINT("info", (" EVEX EXECUTING event %s.%s [EXPR:%d]",
		dbname.str, name.str, (int) expression));

		@@ -1207,7 +1207,7 @@ event_timed::execute(THD thd, MEM_ROOT mem_root)
		/*
		Switches the security context
		Synopsis
		event_timed::change_security_context()
		Event_timed::change_security_context()
		thd - thread
		backup - where to store the old context

		@@ -1216,10 +1216,10 @@ event_timed::execute(THD thd, MEM_ROOT mem_root)
		1 - Error (generates error too)
		*/
		bool
		event_timed::change_security_context(THD thd, Security_context s_ctx,
		Event_timed::change_security_context(THD thd, Security_context s_ctx,
		Security_context **backup)
		{
		DBUG_ENTER("event_timed::change_security_context");
		DBUG_ENTER("Event_timed::change_security_context");
		DBUG_PRINT("info",("%s@%s@%s",definer_user.str,definer_host.str, dbname.str));
		#ifndef NO_EMBEDDED_ACCESS_CHECKS
		s_ctx->init();
		@@ -1240,15 +1240,15 @@ event_timed::change_security_context(THD thd, Security_context s_ctx,
		/*
		Restores the security context
		Synopsis
		event_timed::restore_security_context()
		Event_timed::restore_security_context()
		thd - thread
		backup - switch to this context
		*/

		void
		event_timed::restore_security_context(THD thd, Security_context backup)
		Event_timed::restore_security_context(THD thd, Security_context backup)
		{
		DBUG_ENTER("event_timed::change_security_context");
		DBUG_ENTER("Event_timed::change_security_context");
		#ifndef NO_EMBEDDED_ACCESS_CHECKS
		if (backup)
		thd->security_ctx= backup;
		@@ -1262,7 +1262,7 @@ event_timed::restore_security_context(THD thd, Security_context backup)
		sp_head object held by the event

		SYNOPSIS
		event_timed::compile()
		Event_timed::compile()
		thd thread context, used for memory allocation mostly
		mem_root if != NULL then this memory root is used for allocs
		instead of thd->mem_root
		@@ -1274,14 +1274,14 @@ event_timed::restore_security_context(THD thd, Security_context backup)
		*/

		int
		event_timed::compile(THD thd, MEM_ROOT mem_root)
		Event_timed::compile(THD thd, MEM_ROOT mem_root)
		{
		int ret= 0;
		MEM_ROOT *tmp_mem_root= 0;
		LEX *old_lex= thd->lex, lex;
		char *old_db;
		int old_db_length;
		event_timed *ett;
		Event_timed *ett;
		sp_name *spn;
		char *old_query;
		uint old_query_len;
		@@ -1293,7 +1293,7 @@ event_timed::compile(THD thd, MEM_ROOT mem_root)
		*old_collation_connection,
		*old_character_set_results;

		DBUG_ENTER("event_timed::compile");
		DBUG_ENTER("Event_timed::compile");

		show_create.length(0);

		@@ -1335,7 +1335,7 @@ event_timed::compile(THD thd, MEM_ROOT mem_root)

		thd->query= show_create.c_ptr();
		thd->query_length= show_create.length();
		DBUG_PRINT("event_timed::compile", ("query:%s",thd->query));
		DBUG_PRINT("Event_timed::compile", ("query:%s",thd->query));

		thd->lex= &lex;
		lex_start(thd, (uchar*)thd->query, thd->query_length);
		@@ -1407,7 +1407,7 @@ event_timed::compile(THD thd, MEM_ROOT mem_root)
		*/

		my_bool
		event_timed::can_spawn_now_n_lock(THD *thd)
		Event_timed::can_spawn_now_n_lock(THD *thd)
		{
		my_bool ret= FALSE;
		VOID(pthread_mutex_lock(&this->LOCK_running));
		@@ -1434,11 +1434,11 @@ extern pthread_attr_t connection_attrib;
		*/

		int
		event_timed::spawn_now(void * (thread_func)(void))
		Event_timed::spawn_now(void * (thread_func)(void))
		{
		int ret= EVENT_EXEC_STARTED;
		static uint exec_num= 0;
		DBUG_ENTER("event_timed::spawn_now");
		DBUG_ENTER("Event_timed::spawn_now");
		DBUG_PRINT("info", ("[%s.%s]", dbname.str, name.str));

		VOID(pthread_mutex_lock(&this->LOCK_running));
		@@ -1472,9 +1472,9 @@ event_timed::spawn_now(void * (thread_func)(void))


		void
		event_timed::spawn_thread_finish(THD *thd)
		Event_timed::spawn_thread_finish(THD *thd)
		{
		DBUG_ENTER("event_timed::spawn_thread_finish");
		DBUG_ENTER("Event_timed::spawn_thread_finish");
		VOID(pthread_mutex_lock(&this->LOCK_running));
		in_spawned_thread= false;
		if ((flags & EVENT_EXEC_NO_MORE) \|\| status == MYSQL_EVENT_DISABLED)
		@@ -1501,7 +1501,7 @@ event_timed::spawn_thread_finish(THD *thd)


		int
		event_timed::spawn_unlock(THD *thd)
		Event_timed::spawn_unlock(THD *thd)
		{
		int ret= 0;
		VOID(pthread_mutex_lock(&this->LOCK_running));