Commit 58a6d96c authored by unknown's avatar unknown
Browse files

class event_timed -> Event_timed 

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
parent 0c4ef915

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));