mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 03:52:35 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

class event_timed -> Event_timed

Browse source 
fix for bug#17793 (Scheduler uses class event_timed should be Event_timed)


sql/event.cc:
  class event_timed -> Event_timed
sql/event.h:
  class event_timed -> Event_timed
sql/event_executor.cc:
  class event_timed -> Event_timed
sql/event_priv.h:
  class event_timed -> Event_timed
sql/event_timed.cc:
  class event_timed -> Event_timed
sql/sql_lex.h:
  class event_timed -> Event_timed
sql/sql_show.cc:
  class event_timed -> Event_timed
sql/sql_yacc.yy:
  class event_timed -> Event_timed
This commit is contained in:
unknown 2006-02-28 18:33:38 +01:00
parent 0c4ef91556
commit 58a6d96c8f
8 changed files with 128 additions and 128 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
sql/event.cc
View file

@ -49,11 +49,11 @@
- Consider using conditional variable when doing shutdown instead of - Consider using conditional variable when doing shutdown instead of
waiting till all worker threads end. 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 - Add logging to file
- Move comparison code to class event_timed - Move comparison code to class Event_timed
Warning: Warning:
- For now parallel execution is not possible because the same sp_head cannot be - 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 Synopsis
event_timed_compare() event_timed_compare()
a - first event_timed object a - first Event_timed object
b - second event_timed object b - second Event_timed object
RETURNS: RETURNS:
-1 - a->execute_at < b->execute_at -1 - a->execute_at < b->execute_at
@ -294,14 +294,14 @@ my_time_compare(TIME *a, TIME *b)
*/ */
int 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); 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 Used as callback for the prioritized queue when shifting
elements inside. elements inside.
@ -309,8 +309,8 @@ event_timed_compare(event_timed *a, event_timed *b)
event_timed_compare() event_timed_compare()
vptr - not used (set it to NULL) vptr - not used (set it to NULL)
a - first event_timed object a - first Event_timed object
b - second event_timed object b - second Event_timed object
RETURNS: RETURNS:
-1 - a->execute_at < b->execute_at -1 - a->execute_at < b->execute_at
@ -324,7 +324,7 @@ event_timed_compare(event_timed *a, event_timed *b)
int int
event_timed_compare_q(void *vptr, byte* a, byte *b) 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 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, return evex_db_find_event_by_name(thd, et->dbname, et->name,
et->definer, table); et->definer, table);
@ -600,7 +600,7 @@ evex_db_find_event_by_name(THD *thd, const LEX_STRING dbname,
*/ */
static int 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; enum evex_table_field field_num;
@ -707,7 +707,7 @@ trunc_err:
SYNOPSIS SYNOPSIS
db_create_event() db_create_event()
thd THD 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 create_if_not - if an warning should be generated in case event exists
rows_affected - how many rows were affected rows_affected - how many rows were affected
@ -720,7 +720,7 @@ trunc_err:
*/ */
static int 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) uint *rows_affected)
{ {
int ret= 0; int ret= 0;
@ -855,7 +855,7 @@ err:
*/ */
static int 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; TABLE *table;
int ret= EVEX_OPEN_TABLE_FAILED; int ret= EVEX_OPEN_TABLE_FAILED;
@ -954,13 +954,13 @@ err:
*/ */
static int 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 *tbl, MEM_ROOT *root)
{ {
TABLE *table; TABLE *table;
int ret; int ret;
char *ptr; char *ptr;
event_timed *et=NULL; Event_timed *et=NULL;
DBUG_ENTER("db_find_event"); DBUG_ENTER("db_find_event");
DBUG_PRINT("enter", ("name: %*s", name->m_name.length, name->m_name.str)); 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); my_error(ER_EVENT_DOES_NOT_EXIST, MYF(0), name->m_name.str);
goto done; goto done;
} }
et= new event_timed; et= new Event_timed;
/* /*
1)The table should not be closed beforehand. ::load_from_row() only loads 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; int ret= 0;
MEM_ROOT *tmp_mem_root; MEM_ROOT *tmp_mem_root;
event_timed *ett; Event_timed *ett;
Open_tables_state backup; Open_tables_state backup;
DBUG_ENTER("db_load_and_compile_event"); DBUG_ENTER("db_load_and_compile_event");
@ -1089,7 +1089,7 @@ done:
use_lock - whether to lock the mutex LOCK_event_arrays or not in case it use_lock - whether to lock the mutex LOCK_event_arrays or not in case it
has been already locked outside has been already locked outside
is_drop - if an event is currently being executed then we can also delete 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 drop itself if this parameter is set to TRUE. It's false on
ALTER EVENT. 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) 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, DBUG_PRINT("info", ("[%s.%s]==[%s.%s]?",db->str,name->str, et->dbname.str,
et->name.str)); et->name.str));
if (!sortcmp_lex_string(*name, et->name, system_charset_info) && if (!sortcmp_lex_string(*name, et->name, system_charset_info) &&
@ -1168,7 +1168,7 @@ done:
*/ */
int 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) uint *rows_affected)
{ {
int ret = 0; int ret = 0;
@ -1213,7 +1213,7 @@ done:
*/ */
int 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) uint *rows_affected)
{ {
int ret, i; int ret, i;
@ -1267,7 +1267,7 @@ done:
rows_affected affected number of rows is returned heres 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) uint *rows_affected)
{ {
TABLE *table; TABLE *table;
@ -1308,7 +1308,7 @@ int db_drop_event(THD *thd, event_timed *et, bool drop_if_exists,
done: 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. we have to close our thread tables.
*/ */
close_thread_tables(thd); close_thread_tables(thd);
@ -1330,7 +1330,7 @@ done:
*/ */
int 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) uint *rows_affected)
{ {
TABLE *table; TABLE *table;
@ -1373,7 +1373,7 @@ int
evex_show_create_event(THD *thd, sp_name *spn, LEX_STRING definer) evex_show_create_event(THD *thd, sp_name *spn, LEX_STRING definer)
{ {
int ret; int ret;
event_timed *et= NULL; Event_timed *et= NULL;
Open_tables_state backup; Open_tables_state backup;
DBUG_ENTER("evex_update_event"); 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 1. Go through the in-memory cache, if the scheduler is working
and for every event whose dbname matches the database we drop and for every event whose dbname matches the database we drop
check whether is currently in execution: 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 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 it is being executed, which is 99% of the time in the thread
but there are some initiliazations before and after the but there are some initiliazations before and after the
anonymous SP is being called. So if we delete in this moment anonymous SP is being called. So if we delete in this moment
-=> *boom*, so we have to check whether the thread has been -=> *boom*, so we have to check whether the thread has been
spawned and can_spawn() is the right method. 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. 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) 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)) if (sortcmp_lex_string(et->dbname, db_lex, system_charset_info))
continue; continue;
@ -1561,7 +1561,7 @@ skip_memory:
LEX_STRING et_db_lex= {et_db, strlen(et_db)}; LEX_STRING et_db_lex= {et_db, strlen(et_db)};
if (!sortcmp_lex_string(et_db_lex, db_lex, system_charset_info)) if (!sortcmp_lex_string(et_db_lex, db_lex, system_charset_info))
{ {
event_timed ett; Event_timed ett;
char *ptr; char *ptr;
if ((ptr= get_field(thd->mem_root, table->field[EVEX_FIELD_STATUS])) if ((ptr= get_field(thd->mem_root, table->field[EVEX_FIELD_STATUS]))

18
sql/event.h
View file

@ -76,10 +76,10 @@ enum evex_table_field
EVEX_FIELD_COUNT /* a cool trick to count the number of fields :) */ 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 */ Event_timed(const Event_timed &); /* Prevent use of these */
void operator=(event_timed &); void operator=(Event_timed &);
my_bool in_spawned_thread; my_bool in_spawned_thread;
ulong locked_by_thread_id; ulong locked_by_thread_id;
my_bool running; my_bool running;
@ -122,7 +122,7 @@ public:
bool free_sphead_on_delete; bool free_sphead_on_delete;
uint flags;//all kind of purposes 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), running(0), status_changed(false),
last_executed_changed(false), expression(0), created(0), last_executed_changed(false), expression(0), created(0),
modified(0), on_completion(MYSQL_EVENT_ON_COMPLETION_DROP), modified(0), on_completion(MYSQL_EVENT_ON_COMPLETION_DROP),
@ -135,7 +135,7 @@ public:
init(); init();
} }
~event_timed() ~Event_timed()
{ {
pthread_mutex_destroy(&this->LOCK_running); pthread_mutex_destroy(&this->LOCK_running);
if (free_sphead_on_delete) if (free_sphead_on_delete)
@ -259,15 +259,15 @@ protected:
int 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); uint *rows_affected);
int 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); uint *rows_affected);
int 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); uint *rows_affected);
int int
@ -296,7 +296,7 @@ shutdown_events();
// auxiliary // auxiliary
int int
event_timed_compare(event_timed **a, event_timed **b); event_timed_compare(Event_timed **a, Event_timed **b);

28
sql/event_executor.cc
View file

@ -55,7 +55,7 @@ static int
evex_load_events_from_db(THD *thd); evex_load_events_from_db(THD *thd);
bool 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 TODO Andrey: Check for command line option whether to start
@ -316,7 +316,7 @@ init_event_thread(THD* thd)
static int static int
executor_wait_till_next_event_exec(THD *thd) executor_wait_till_next_event_exec(THD *thd)
{ {
event_timed *et; Event_timed *et;
TIME time_now; TIME time_now;
int t2sleep; int t2sleep;
@ -331,7 +331,7 @@ executor_wait_till_next_event_exec(THD *thd)
VOID(pthread_mutex_unlock(&LOCK_event_arrays)); VOID(pthread_mutex_unlock(&LOCK_event_arrays));
DBUG_RETURN(WAIT_STATUS_EMPTY_QUEUE); 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); DBUG_ASSERT(et);
if (et->status == MYSQL_EVENT_DISABLED) 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 && while (t2sleep-- && !thd->killed && event_executor_running_global_var &&
evex_queue_num_elements(EVEX_EQ_NAME) && 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")); DBUG_PRINT("evex main thread",("will sleep a bit more"));
my_sleep(1000000); my_sleep(1000000);
@ -371,7 +371,7 @@ executor_wait_till_next_event_exec(THD *thd)
int ret= WAIT_STATUS_READY; int ret= WAIT_STATUS_READY;
if (!evex_queue_num_elements(EVEX_EQ_NAME)) if (!evex_queue_num_elements(EVEX_EQ_NAME))
ret= WAIT_STATUS_EMPTY_QUEUE; 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; ret= WAIT_STATUS_NEW_TOP_EVENT;
if (thd->killed && event_executor_running_global_var) if (thd->killed && event_executor_running_global_var)
ret= WAIT_STATUS_STOP_EXECUTOR; ret= WAIT_STATUS_STOP_EXECUTOR;
@ -470,7 +470,7 @@ event_executor_main(void *arg)
while (!thd->killed) while (!thd->killed)
{ {
TIME time_now; TIME time_now;
event_timed *et; Event_timed *et;
cnt++; cnt++;
DBUG_PRINT("info", ("EVEX External Loop %d thd->k", cnt)); DBUG_PRINT("info", ("EVEX External Loop %d thd->k", cnt));
@ -519,7 +519,7 @@ restart_ticking:
DBUG_PRINT("evex main thread",("empty queue")); DBUG_PRINT("evex main thread",("empty queue"));
continue; 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")); DBUG_PRINT("evex main thread",("got event from the queue"));
if (!et->execute_at_null && my_time_compare(&time_now,&et->execute_at) == -1) if (!et->execute_at_null && my_time_compare(&time_now,&et->execute_at) == -1)
@ -621,7 +621,7 @@ finish:
VOID(pthread_mutex_lock(&LOCK_event_arrays)); VOID(pthread_mutex_lock(&LOCK_event_arrays));
for (i= 0; i < evex_queue_num_elements(EVEX_EQ_NAME); ++i) 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(); et->free_sp();
delete et; delete et;
} }
@ -666,14 +666,14 @@ err_no_thd:
SYNOPSIS SYNOPSIS
event_executor_worker() event_executor_worker()
arg The event_timed object to be processed arg The Event_timed object to be processed
*/ */
pthread_handler_t pthread_handler_t
event_executor_worker(void *event_void) event_executor_worker(void *event_void)
{ {
THD *thd; /* needs to be first for thread_stack */ 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; MEM_ROOT worker_mem_root;
DBUG_ENTER("event_executor_worker"); DBUG_ENTER("event_executor_worker");
@ -771,7 +771,7 @@ err_no_thd:
/* /*
Loads all ENABLED events from mysql.event into the prioritized Loads all ENABLED events from mysql.event into the prioritized
queue. Called during scheduler main thread initialization. Compiles 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. from mysql.event.
SYNOPSIS SYNOPSIS
@ -808,8 +808,8 @@ evex_load_events_from_db(THD *thd)
init_read_record(&read_record_info, thd, table ,NULL,1,0); init_read_record(&read_record_info, thd, table ,NULL,1,0);
while (!(read_record_info.read_record(&read_record_info))) while (!(read_record_info.read_record(&read_record_info)))
{ {
event_timed *et; Event_timed *et;
if (!(et= new event_timed)) if (!(et= new Event_timed))
{ {
DBUG_PRINT("evex_load_events_from_db", ("Out of memory")); DBUG_PRINT("evex_load_events_from_db", ("Out of memory"));
ret= -1; ret= -1;
@ -941,7 +941,7 @@ static sql_print_xxx_func sql_print_xxx_handlers[3] =
*/ */
bool bool
evex_print_warnings(THD *thd, event_timed *et) evex_print_warnings(THD *thd, Event_timed *et)
{ {
MYSQL_ERROR *err; MYSQL_ERROR *err;
DBUG_ENTER("evex_show_warnings"); DBUG_ENTER("evex_show_warnings");

2
sql/event_priv.h
View file

@ -44,7 +44,7 @@ evex_db_find_event_by_name(THD *thd, const LEX_STRING dbname,
int int
event_timed_compare_q(void *vptr, byte* a, byte *b); 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); uint *rows_affected);

126
sql/event_timed.cc
View file

@ -26,13 +26,13 @@ extern int yyparse(void *thd);
Init all member variables Init all member variables
SYNOPSIS SYNOPSIS
event_timed::init() Event_timed::init()
*/ */
void 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.str= name.str= body.str= comment.str= 0;
dbname.length= name.length= body.length= comment.length= 0; dbname.length= name.length= body.length= comment.length= 0;
@ -56,15 +56,15 @@ event_timed::init()
Set a name of the event Set a name of the event
SYNOPSIS SYNOPSIS
event_timed::init_name() Event_timed::init_name()
thd THD thd THD
spn the name extracted in the parser spn the name extracted in the parser
*/ */
void 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 */ uint n; /* Counter for nul trimming */
/* During parsing, we must use thd->mem_root */ /* During parsing, we must use thd->mem_root */
MEM_ROOT *root= 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. Set body of the event - what should be executed.
SYNOPSIS SYNOPSIS
event_timed::init_body() Event_timed::init_body()
thd THD thd THD
NOTE NOTE
@ -109,9 +109,9 @@ event_timed::init_name(THD *thd, sp_name *spn)
*/ */
void 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, DBUG_PRINT("info", ("body=[%s] body_begin=0x%ld end=0x%ld", body_begin,
body_begin, thd->lex->ptr)); body_begin, thd->lex->ptr));
@ -136,7 +136,7 @@ event_timed::init_body(THD *thd)
Set time for execution for one time events. Set time for execution for one time events.
SYNOPSIS SYNOPSIS
event_timed::init_execute_at() Event_timed::init_execute_at()
expr when (datetime) expr when (datetime)
RETURN VALUE RETURN VALUE
@ -147,14 +147,14 @@ event_timed::init_body(THD *thd)
*/ */
int int
event_timed::init_execute_at(THD *thd, Item *expr) Event_timed::init_execute_at(THD *thd, Item *expr)
{ {
my_bool not_used; my_bool not_used;
TIME ltime; TIME ltime;
my_time_t my_time_tmp; my_time_t my_time_tmp;
TIME 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)) if (expr->fix_fields(thd, &expr))
DBUG_RETURN(EVEX_PARSE_ERROR); 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. Set time for execution for transient events.
SYNOPSIS SYNOPSIS
event_timed::init_interval() Event_timed::init_interval()
expr how much? expr how much?
new_interval what is the interval new_interval what is the interval
@ -204,13 +204,13 @@ event_timed::init_execute_at(THD *thd, Item *expr)
*/ */
int 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; longlong tmp;
String value; String value;
INTERVAL interval; INTERVAL interval;
DBUG_ENTER("event_timed::init_interval"); DBUG_ENTER("Event_timed::init_interval");
if (expr->fix_fields(thd, &expr)) if (expr->fix_fields(thd, &expr))
DBUG_RETURN(EVEX_PARSE_ERROR); DBUG_RETURN(EVEX_PARSE_ERROR);
@ -289,7 +289,7 @@ event_timed::init_interval(THD *thd, Item *expr, interval_type new_interval)
Set activation time. Set activation time.
SYNOPSIS SYNOPSIS
event_timed::init_starts() Event_timed::init_starts()
expr how much? expr how much?
interval what is the interval interval what is the interval
@ -307,12 +307,12 @@ event_timed::init_interval(THD *thd, Item *expr, interval_type new_interval)
*/ */
int int
event_timed::init_starts(THD *thd, Item *new_starts) Event_timed::init_starts(THD *thd, Item *new_starts)
{ {
my_bool not_used; my_bool not_used;
TIME ltime, time_tmp; TIME ltime, time_tmp;
DBUG_ENTER("event_timed::init_starts"); DBUG_ENTER("Event_timed::init_starts");
if (new_starts->fix_fields(thd, &new_starts)) if (new_starts->fix_fields(thd, &new_starts))
DBUG_RETURN(EVEX_PARSE_ERROR); DBUG_RETURN(EVEX_PARSE_ERROR);
@ -346,7 +346,7 @@ event_timed::init_starts(THD *thd, Item *new_starts)
Set deactivation time. Set deactivation time.
SYNOPSIS SYNOPSIS
event_timed::init_ends() Event_timed::init_ends()
thd THD thd THD
new_ends when? new_ends when?
@ -365,12 +365,12 @@ event_timed::init_starts(THD *thd, Item *new_starts)
*/ */
int int
event_timed::init_ends(THD *thd, Item *new_ends) Event_timed::init_ends(THD *thd, Item *new_ends)
{ {
TIME ltime, ltime_now; TIME ltime, ltime_now;
my_bool not_used; my_bool not_used;
DBUG_ENTER("event_timed::init_ends"); DBUG_ENTER("Event_timed::init_ends");
if (new_ends->fix_fields(thd, &new_ends)) if (new_ends->fix_fields(thd, &new_ends))
DBUG_RETURN(EVEX_PARSE_ERROR); DBUG_RETURN(EVEX_PARSE_ERROR);
@ -411,15 +411,15 @@ event_timed::init_ends(THD *thd, Item *new_ends)
Sets comment. Sets comment.
SYNOPSIS SYNOPSIS
event_timed::init_comment() Event_timed::init_comment()
thd THD - used for memory allocation thd THD - used for memory allocation
comment the string. comment the string.
*/ */
void 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.str= strmake_root(thd->mem_root, set_comment->str,
comment.length= set_comment->length); 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. Inits definer (definer_user and definer_host) during parsing.
SYNOPSIS SYNOPSIS
event_timed::init_definer() Event_timed::init_definer()
*/ */
int 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 " DBUG_PRINT("info",("init definer_user thd->mem_root=0x%lx "
"thd->sec_ctx->priv_user=0x%lx", thd->mem_root, "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 Loads an event from a row from mysql.event
SYNOPSIS SYNOPSIS
event_timed::load_from_row(MEM_ROOT *mem_root, TABLE *table) Event_timed::load_from_row(MEM_ROOT *mem_root, TABLE *table)
NOTES NOTES
This method is silent on errors and should behave like that. Callers This method is silent on errors and should behave like that. Callers
@ -482,16 +482,16 @@ event_timed::init_definer(THD *thd)
*/ */
int 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 created;
longlong modified; longlong modified;
char *ptr; char *ptr;
event_timed *et; Event_timed *et;
uint len; uint len;
bool res1, res2; bool res1, res2;
DBUG_ENTER("event_timed::load_from_row"); DBUG_ENTER("Event_timed::load_from_row");
if (!table) if (!table)
goto error; 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. Computes next execution time.
SYNOPSIS SYNOPSIS
event_timed::compute_next_execution_time() Event_timed::compute_next_execution_time()
NOTES NOTES
The time is set in execute_at, if no more executions the latter is set to 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 bool
event_timed::compute_next_execution_time() Event_timed::compute_next_execution_time()
{ {
TIME time_now; TIME time_now;
my_time_t now; my_time_t now;
int tmp; int tmp;
DBUG_ENTER("event_timed::compute_next_execution_time"); DBUG_ENTER("Event_timed::compute_next_execution_time");
if (status == MYSQL_EVENT_DISABLED) if (status == MYSQL_EVENT_DISABLED)
{ {
@ -918,12 +918,12 @@ err:
time according to thd->query_start(), so the THD's clock. time according to thd->query_start(), so the THD's clock.
SYNOPSIS SYNOPSIS
event_timed::drop() Event_timed::drop()
thd thread context thd thread context
*/ */
void void
event_timed::mark_last_executed(THD *thd) Event_timed::mark_last_executed(THD *thd)
{ {
TIME time_now; TIME time_now;
@ -942,7 +942,7 @@ event_timed::mark_last_executed(THD *thd)
Drops the event Drops the event
SYNOPSIS SYNOPSIS
event_timed::drop() Event_timed::drop()
thd thread context thd thread context
RETURN VALUE RETURN VALUE
@ -955,11 +955,11 @@ event_timed::mark_last_executed(THD *thd)
*/ */
int int
event_timed::drop(THD *thd) Event_timed::drop(THD *thd)
{ {
TABLE *table; TABLE *table;
uint tmp= 0; uint tmp= 0;
DBUG_ENTER("event_timed::drop"); DBUG_ENTER("Event_timed::drop");
DBUG_RETURN(db_drop_event(thd, this, false, &tmp)); 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. Saves status and last_executed_at to the disk if changed.
SYNOPSIS SYNOPSIS
event_timed::update_fields() Event_timed::update_fields()
thd - thread context thd - thread context
RETURN VALUE RETURN VALUE
@ -982,14 +982,14 @@ event_timed::drop(THD *thd)
*/ */
bool bool
event_timed::update_fields(THD *thd) Event_timed::update_fields(THD *thd)
{ {
TABLE *table; TABLE *table;
Open_tables_state backup; Open_tables_state backup;
int ret= 0; int ret= 0;
bool opened; 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)); 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 Get SHOW CREATE EVENT as string
SYNOPSIS SYNOPSIS
event_timed::get_create_event(THD *thd, String *buf) Event_timed::get_create_event(THD *thd, String *buf)
thd Thread thd Thread
buf String*, should be already allocated. CREATE EVENT goes inside. buf String*, should be already allocated. CREATE EVENT goes inside.
@ -1055,7 +1055,7 @@ extern LEX_STRING interval_type_to_name[];
*/ */
int int
event_timed::get_create_event(THD *thd, String *buf) Event_timed::get_create_event(THD *thd, String *buf)
{ {
int multipl= 0; int multipl= 0;
char tmp_buff[128]; char tmp_buff[128];
@ -1133,14 +1133,14 @@ event_timed::get_create_event(THD *thd, String *buf)
*/ */
int int
event_timed::execute(THD *thd, MEM_ROOT *mem_root) Event_timed::execute(THD *thd, MEM_ROOT *mem_root)
{ {
Security_context *save_ctx; Security_context *save_ctx;
/* this one is local and not needed after exec */ /* this one is local and not needed after exec */
Security_context security_ctx; Security_context security_ctx;
int ret= 0; int ret= 0;
DBUG_ENTER("event_timed::execute"); DBUG_ENTER("Event_timed::execute");
DBUG_PRINT("info", (" EVEX EXECUTING event %s.%s [EXPR:%d]", DBUG_PRINT("info", (" EVEX EXECUTING event %s.%s [EXPR:%d]",
dbname.str, name.str, (int) expression)); dbname.str, name.str, (int) expression));
@ -1207,7 +1207,7 @@ done:
/* /*
Switches the security context Switches the security context
Synopsis Synopsis
event_timed::change_security_context() Event_timed::change_security_context()
thd - thread thd - thread
backup - where to store the old context backup - where to store the old context
@ -1216,10 +1216,10 @@ done:
1 - Error (generates error too) 1 - Error (generates error too)
*/ */
bool 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) 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)); DBUG_PRINT("info",("%s@%s@%s",definer_user.str,definer_host.str, dbname.str));
#ifndef NO_EMBEDDED_ACCESS_CHECKS #ifndef NO_EMBEDDED_ACCESS_CHECKS
s_ctx->init(); s_ctx->init();
@ -1240,15 +1240,15 @@ event_timed::change_security_context(THD *thd, Security_context *s_ctx,
/* /*
Restores the security context Restores the security context
Synopsis Synopsis
event_timed::restore_security_context() Event_timed::restore_security_context()
thd - thread thd - thread
backup - switch to this context backup - switch to this context
*/ */
void 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 #ifndef NO_EMBEDDED_ACCESS_CHECKS
if (backup) if (backup)
thd->security_ctx= 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 sp_head object held by the event
SYNOPSIS SYNOPSIS
event_timed::compile() Event_timed::compile()
thd thread context, used for memory allocation mostly thd thread context, used for memory allocation mostly
mem_root if != NULL then this memory root is used for allocs mem_root if != NULL then this memory root is used for allocs
instead of thd->mem_root instead of thd->mem_root
@ -1274,14 +1274,14 @@ event_timed::restore_security_context(THD *thd, Security_context *backup)
*/ */
int int
event_timed::compile(THD *thd, MEM_ROOT *mem_root) Event_timed::compile(THD *thd, MEM_ROOT *mem_root)
{ {
int ret= 0; int ret= 0;
MEM_ROOT *tmp_mem_root= 0; MEM_ROOT *tmp_mem_root= 0;
LEX *old_lex= thd->lex, lex; LEX *old_lex= thd->lex, lex;
char *old_db; char *old_db;
int old_db_length; int old_db_length;
event_timed *ett; Event_timed *ett;
sp_name *spn; sp_name *spn;
char *old_query; char *old_query;
uint old_query_len; uint old_query_len;
@ -1293,7 +1293,7 @@ event_timed::compile(THD *thd, MEM_ROOT *mem_root)
*old_collation_connection, *old_collation_connection,
*old_character_set_results; *old_character_set_results;
DBUG_ENTER("event_timed::compile"); DBUG_ENTER("Event_timed::compile");
show_create.length(0); 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= show_create.c_ptr();
thd->query_length= show_create.length(); 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; thd->lex= &lex;
lex_start(thd, (uchar*)thd->query, thd->query_length); lex_start(thd, (uchar*)thd->query, thd->query_length);
@ -1407,7 +1407,7 @@ done:
*/ */
my_bool my_bool
event_timed::can_spawn_now_n_lock(THD *thd) Event_timed::can_spawn_now_n_lock(THD *thd)
{ {
my_bool ret= FALSE; my_bool ret= FALSE;
VOID(pthread_mutex_lock(&this->LOCK_running)); VOID(pthread_mutex_lock(&this->LOCK_running));
@ -1434,11 +1434,11 @@ extern pthread_attr_t connection_attrib;
*/ */
int int
event_timed::spawn_now(void * (*thread_func)(void*)) Event_timed::spawn_now(void * (*thread_func)(void*))
{ {
int ret= EVENT_EXEC_STARTED; int ret= EVENT_EXEC_STARTED;
static uint exec_num= 0; 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)); DBUG_PRINT("info", ("[%s.%s]", dbname.str, name.str));
VOID(pthread_mutex_lock(&this->LOCK_running)); VOID(pthread_mutex_lock(&this->LOCK_running));
@ -1472,9 +1472,9 @@ event_timed::spawn_now(void * (*thread_func)(void*))
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)); VOID(pthread_mutex_lock(&this->LOCK_running));
in_spawned_thread= false; in_spawned_thread= false;
if ((flags & EVENT_EXEC_NO_MORE) || status == MYSQL_EVENT_DISABLED) if ((flags & EVENT_EXEC_NO_MORE) || status == MYSQL_EVENT_DISABLED)
@ -1501,7 +1501,7 @@ event_timed::spawn_thread_finish(THD *thd)
int int
event_timed::spawn_unlock(THD *thd) Event_timed::spawn_unlock(THD *thd)
{ {
int ret= 0; int ret= 0;
VOID(pthread_mutex_lock(&this->LOCK_running)); VOID(pthread_mutex_lock(&this->LOCK_running));

4
sql/sql_lex.h
View file

@ -27,7 +27,7 @@ class sp_instr;
class sp_pcontext; class sp_pcontext;
class st_alter_tablespace; class st_alter_tablespace;
class partition_info; class partition_info;
class event_timed; class Event_timed;
#ifdef MYSQL_SERVER #ifdef MYSQL_SERVER
/* /*
@ -932,7 +932,7 @@ typedef struct st_lex
st_sp_chistics sp_chistics; st_sp_chistics sp_chistics;
event_timed *et; Event_timed *et;
bool et_compile_phase; bool et_compile_phase;
bool only_view; /* used for SHOW CREATE TABLE/VIEW */ bool only_view; /* used for SHOW CREATE TABLE/VIEW */

2
sql/sql_show.cc
View file

@ -3936,7 +3936,7 @@ fill_events_copy_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table)
const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS; const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
CHARSET_INFO *scs= system_charset_info; CHARSET_INFO *scs= system_charset_info;
TIME time; TIME time;
event_timed et; Event_timed et;
DBUG_ENTER("fill_events_copy_to_schema_tab"); DBUG_ENTER("fill_events_copy_to_schema_tab");
restore_record(sch_table, s->default_values); restore_record(sch_table, s->default_values);

12
sql/sql_yacc.yy
View file

@ -1343,7 +1343,7 @@ create:
lex->create_info.options= $3; lex->create_info.options= $3;
if (!(lex->et= new event_timed())) // implicitly calls event_timed::init() if (!(lex->et= new Event_timed())) // implicitly calls Event_timed::init()
YYABORT; YYABORT;
/* /*
@ -4822,7 +4822,7 @@ alter:
*/ */
{ {
LEX *lex=Lex; LEX *lex=Lex;
event_timed *et; Event_timed *et;
if (lex->et) if (lex->et)
{ {
@ -4835,7 +4835,7 @@ alter:
} }
lex->spname= 0;//defensive programming lex->spname= 0;//defensive programming
if (!(et= new event_timed()))// implicitly calls event_timed::init() if (!(et= new Event_timed()))// implicitly calls Event_timed::init()
YYABORT; YYABORT;
lex->et = et; lex->et = et;
@ -4911,7 +4911,7 @@ opt_ev_rename_to: /* empty */ { $$= 0;}
{ {
LEX *lex=Lex; LEX *lex=Lex;
lex->spname= $3; //use lex's spname to hold the new name lex->spname= $3; //use lex's spname to hold the new name
//the original name is in the event_timed object //the original name is in the Event_timed object
$$= 1; $$= 1;
} }
; ;
@ -7734,7 +7734,7 @@ drop:
YYABORT; YYABORT;
} }
if (!(lex->et= new event_timed())) if (!(lex->et= new Event_timed()))
YYABORT; YYABORT;
if (!lex->et_compile_phase) if (!lex->et_compile_phase)
@ -8458,7 +8458,7 @@ show_param:
{ {
Lex->sql_command = SQLCOM_SHOW_CREATE_EVENT; Lex->sql_command = SQLCOM_SHOW_CREATE_EVENT;
Lex->spname= $3; Lex->spname= $3;
Lex->et= new event_timed(); Lex->et= new Event_timed();
if (!Lex->et) if (!Lex->et)
YYABORT; YYABORT;
Lex->et->init_definer(YYTHD); Lex->et->init_definer(YYTHD);