Merge ahristov@bk-internal.mysql.com:/home/bk/mysql-5.1-new

into lmy004.:/work/mysql-5.1-bug16537

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