class event_timed -> Event_timed

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

sql/event.cc

@@ -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

@@ -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

@@ -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

@@ -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

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

sql/sql_lex.h

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

sql/sql_show.cc

@@ -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;
   CHARSET_INFO *scs= system_charset_info;
   TIME time;
-  event_timed et;    
+  Event_timed et;    
   DBUG_ENTER("fill_events_copy_to_schema_tab");
 
   restore_record(sch_table, s->default_values);

sql/sql_yacc.yy

@@ -1343,7 +1343,7 @@ create:
 
             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;
 
             /*
@@ -4822,7 +4822,7 @@ alter:
           */
           {
             LEX *lex=Lex;
-            event_timed *et;
+            Event_timed *et;
 
             if (lex->et)
             {
@@ -4835,7 +4835,7 @@ alter:
             }
             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;
             lex->et = et;
 
@@ -4911,7 +4911,7 @@ opt_ev_rename_to: /* empty */ { $$= 0;}
           {
             LEX *lex=Lex;
             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;
           }
       ;
@@ -7734,7 +7734,7 @@ drop:
               YYABORT;
             }
 
-            if (!(lex->et= new event_timed()))
+            if (!(lex->et= new Event_timed()))
               YYABORT;
 	  
             if (!lex->et_compile_phase)
@@ -8458,7 +8458,7 @@ show_param:
           {
             Lex->sql_command = SQLCOM_SHOW_CREATE_EVENT;
             Lex->spname= $3;
-            Lex->et= new event_timed();
+            Lex->et= new Event_timed();
             if (!Lex->et)
               YYABORT;
             Lex->et->init_definer(YYTHD);