List:Commits« Previous MessageNext Message »
From:Chad MILLER Date:January 31 2007 2:43pm
Subject:bk commit into 5.0 tree (cmiller:1.2383)
View as plain text  
Below is the list of changes that have just been committed into a local
5.0 repository of cmiller. When cmiller does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-01-31 09:43:18-05:00, cmiller@stripped +24 -0
  Use lowercase "thd_proc_info()", just like the 5.1 line does.
  
  Wrap the DBUG statements in "do {  } while (0)" so that they behave
  syntactically like a single C statement and cause no surprises when
  using them.

  include/my_dbug.h@stripped, 2007-01-31 09:43:14-05:00, cmiller@stripped +6 -6
    Make DBUG macros behave syntactically as if each was a distinct single 
    statement.

  myisam/mi_open.c@stripped, 2007-01-31 09:43:14-05:00, cmiller@stripped +1 -1
    Add semicolon to statement.

  ndb/src/ndbapi/DictCache.cpp@stripped, 2007-01-31 09:43:14-05:00, cmiller@stripped +1 -1
    Add semicolon to statement.

  sql/ha_archive.cc@stripped, 2007-01-31 09:43:14-05:00, cmiller@stripped +2 -2
    Use 5.1-compatible case.

  sql/ha_myisam.cc@stripped, 2007-01-31 09:43:14-05:00, cmiller@stripped +12 -12
    Use 5.1-compatible case.

  sql/ha_myisammrg.cc@stripped, 2007-01-31 09:43:14-05:00, cmiller@stripped +1 -1
    Add semicolon to statement.

  sql/ha_ndbcluster.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +2 -2
    Add semicolon to statement.

  sql/item_cmpfunc.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +1 -1
    Add semicolon to statement.

  sql/item_func.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +4 -4
    Use 5.1-compatible case.

  sql/lock.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +4 -4
    Use 5.1-compatible case.

  sql/log_event.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +4 -4
    Use 5.1-compatible case.

  sql/repl_failsafe.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +3 -3
    Use 5.1-compatible case.

  sql/slave.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +3 -3
    Use 5.1-compatible case.

  sql/sp_head.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +2 -2
    Use 5.1-compatible case.

  sql/sql_base.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +12 -12
    Use 5.1-compatible case.

  sql/sql_cache.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +11 -11
    Add semicolon to DBUG statements.
    
    Use the thd_proc_info case that is compatible with 5.1.

  sql/sql_delete.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +6 -6
    Use 5.1-compatible case.

  sql/sql_insert.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +19 -19
    Use 5.1-compatible case.

  sql/sql_repl.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +1 -1
    Use 5.1-compatible case.

  sql/sql_select.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +22 -23
    Use 5.1-compatible case.

  sql/sql_show.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +1 -1
    Use 5.1-compatible case.

  sql/sql_table.cc@stripped, 2007-01-31 09:43:15-05:00, cmiller@stripped +10 -10
    Use 5.1-compatible case.

  sql/sql_update.cc@stripped, 2007-01-31 09:43:16-05:00, cmiller@stripped +7 -7
    Use 5.1-compatible case.

  sql/sql_view.cc@stripped, 2007-01-31 09:43:16-05:00, cmiller@stripped +1 -1
    Use 5.1-compatible case.

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	cmiller
# Host:	zippy.cornsilk.net
# Root:	/home/cmiller/work/mysql/mysql-5.0-community-2--bug24795

--- 1.21/include/my_dbug.h	2007-01-31 09:43:25 -05:00
+++ 1.22/include/my_dbug.h	2007-01-31 09:43:25 -05:00
@@ -50,12 +50,12 @@ extern	void _db_unlock_file(void);
 		    &_db_framep_)
 #define DBUG_LEAVE \
 	(_db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_))
-#define DBUG_RETURN(a1) {DBUG_LEAVE; return(a1);}
-#define DBUG_VOID_RETURN {DBUG_LEAVE; return;}
+#define DBUG_RETURN(a1) do {DBUG_LEAVE; return(a1);} while(0)
+#define DBUG_VOID_RETURN do {DBUG_LEAVE; return;} while(0)
 #define DBUG_EXECUTE(keyword,a1) \
-	{if (_db_on_) {if (_db_keyword_ (keyword)) { a1 }}}
+	do {if (_db_on_) {if (_db_keyword_ (keyword)) { a1 }}} while(0)
 #define DBUG_PRINT(keyword,arglist) \
-	{if (_db_on_) {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;}}
+	do {if (_db_on_) {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;}} while(0)
 #define DBUG_PUSH(a1) _db_push_ (a1)
 #define DBUG_POP() _db_pop_ ()
 #define DBUG_PROCESS(a1) (_db_process_ = a1)
@@ -63,7 +63,7 @@ extern	void _db_unlock_file(void);
 #define DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1))
 #define DBUG_LONGJMP(a1,a2) (_db_longjmp_ (), longjmp (a1, a2))
 #define DBUG_DUMP(keyword,a1,a2)\
-	{if (_db_on_) {_db_dump_(__LINE__,keyword,a1,a2);}}
+	do {if (_db_on_) {_db_dump_(__LINE__,keyword,a1,a2);}} while(0)
 #define DBUG_IN_USE (_db_fp_ && _db_fp_ != stderr)
 #define DEBUGGER_OFF _no_db_=1;_db_on_=0;
 #define DEBUGGER_ON  _no_db_=0
@@ -73,7 +73,7 @@ extern	void _db_unlock_file(void);
 #define DBUG_OUTPUT(A) { _db_output_(A); }
 #define DBUG_ASSERT(A) assert(A)
 #define DBUG_EXECUTE_IF(keyword,a1) \
-        {if (_db_on_) {if (_db_strict_keyword_ (keyword)) { a1 }}}
+        do {if (_db_on_) {if (_db_strict_keyword_ (keyword)) { a1 }}} while(0)
 #else						/* No debugger */
 
 #define DBUG_ENTER(a1)

--- 1.102/myisam/mi_open.c	2007-01-31 09:43:25 -05:00
+++ 1.103/myisam/mi_open.c	2007-01-31 09:43:25 -05:00
@@ -196,7 +196,7 @@ MI_INFO *mi_open(const char *name, int m
     if (len != MI_BASE_INFO_SIZE)
     {
       DBUG_PRINT("warning",("saved_base_info_length: %d  base_info_length: %d",
-			    len,MI_BASE_INFO_SIZE))
+			    len,MI_BASE_INFO_SIZE));
     }
     disk_pos= (char*) 
       my_n_base_info_read((uchar*) disk_cache + base_pos, &share->base);

--- 1.173/sql/ha_myisam.cc	2007-01-31 09:43:25 -05:00
+++ 1.174/sql/ha_myisam.cc	2007-01-31 09:43:25 -05:00
@@ -339,7 +339,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_
   MYISAM_SHARE* share = file->s;
   const char *old_proc_info=thd->proc_info;
 
-  THD_PROC_INFO(thd, "Checking table");
+  thd_proc_info(thd, "Checking table");
   myisamchk_init(&param);
   param.thd = thd;
   param.op_name =   "check";
@@ -413,7 +413,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_
     file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
   }
 
-  THD_PROC_INFO(thd, old_proc_info);
+  thd_proc_info(thd, old_proc_info);
   return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK;
 }
 
@@ -679,22 +679,22 @@ int ha_myisam::repair(THD *thd, MI_CHECK
         char buf[40];
         /* TODO: respect myisam_repair_threads variable */
         my_snprintf(buf, 40, "Repair with %d threads", my_count_bits(key_map));
-        THD_PROC_INFO(thd, buf);
+        thd_proc_info(thd, buf);
         error = mi_repair_parallel(&param, file, fixed_name,
             param.testflag & T_QUICK);
-        THD_PROC_INFO(thd, "Repair done"); // to reset proc_info, as
+        thd_proc_info(thd, "Repair done"); // to reset proc_info, as
                                       // it was pointing to local buffer
       }
       else
       {
-        THD_PROC_INFO(thd, "Repair by sorting");
+        thd_proc_info(thd, "Repair by sorting");
         error = mi_repair_by_sort(&param, file, fixed_name,
             param.testflag & T_QUICK);
       }
     }
     else
     {
-      THD_PROC_INFO(thd, "Repair with keycache");
+      thd_proc_info(thd, "Repair with keycache");
       param.testflag &= ~T_REP_BY_SORT;
       error=  mi_repair(&param, file, fixed_name,
 			param.testflag & T_QUICK);
@@ -708,7 +708,7 @@ int ha_myisam::repair(THD *thd, MI_CHECK
 	(share->state.changed & STATE_NOT_SORTED_PAGES))
     {
       optimize_done=1;
-      THD_PROC_INFO(thd, "Sorting index");
+      thd_proc_info(thd, "Sorting index");
       error=mi_sort_index(&param,file,fixed_name);
     }
     if (!statistics_done && (local_testflag & T_STATISTICS))
@@ -716,14 +716,14 @@ int ha_myisam::repair(THD *thd, MI_CHECK
       if (share->state.changed & STATE_NOT_ANALYZED)
       {
 	optimize_done=1;
-	THD_PROC_INFO(thd, "Analyzing");
+	thd_proc_info(thd, "Analyzing");
 	error = chk_key(&param, file);
       }
       else
 	local_testflag&= ~T_STATISTICS;		// Don't update statistics
     }
   }
-  THD_PROC_INFO(thd, "Saving state");
+  thd_proc_info(thd, "Saving state");
   if (!error)
   {
     if ((share->state.changed & STATE_CHANGED) || mi_is_crashed(file))
@@ -761,7 +761,7 @@ int ha_myisam::repair(THD *thd, MI_CHECK
     file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
     update_state_info(&param, file, 0);
   }
-  THD_PROC_INFO(thd, old_proc_info);
+  thd_proc_info(thd, old_proc_info);
   if (!thd->locked_tables)
     mi_lock_database(file,F_UNLCK);
   DBUG_RETURN(error ? HA_ADMIN_FAILED :
@@ -986,7 +986,7 @@ int ha_myisam::enable_indexes(uint mode)
     THD *thd=current_thd;
     MI_CHECK param;
     const char *save_proc_info=thd->proc_info;
-    THD_PROC_INFO(thd, "Creating index");
+    thd_proc_info(thd, "Creating index");
     myisamchk_init(&param);
     param.op_name= "recreating_index";
     param.testflag= (T_SILENT | T_REP_BY_SORT | T_QUICK |
@@ -1011,7 +1011,7 @@ int ha_myisam::enable_indexes(uint mode)
         thd->clear_error();
     }
     info(HA_STATUS_CONST);
-    THD_PROC_INFO(thd, save_proc_info);
+    thd_proc_info(thd, save_proc_info);
   }
   else
   {

--- 1.87/sql/ha_myisammrg.cc	2007-01-31 09:43:25 -05:00
+++ 1.88/sql/ha_myisammrg.cc	2007-01-31 09:43:25 -05:00
@@ -96,7 +96,7 @@ int ha_myisammrg::open(const char *name,
     DBUG_PRINT("info", ("ha_myisammrg::open exit %d", my_errno));
     return (my_errno ? my_errno : -1);
   }
-  DBUG_PRINT("info", ("ha_myisammrg::open myrg_extrafunc..."))
+  DBUG_PRINT("info", ("ha_myisammrg::open myrg_extrafunc..."));
   myrg_extrafunc(file, query_cache_invalidate_by_MyISAM_filename_ref);
   if (!(test_if_locked == HA_OPEN_WAIT_IF_LOCKED ||
 	test_if_locked == HA_OPEN_ABORT_IF_LOCKED))

--- 1.228/sql/item_cmpfunc.cc	2007-01-31 09:43:25 -05:00
+++ 1.229/sql/item_cmpfunc.cc	2007-01-31 09:43:25 -05:00
@@ -3006,7 +3006,7 @@ longlong Item_is_not_null_test::val_int(
   }
   if (args[0]->is_null())
   {
-    DBUG_PRINT("info", ("null"))
+    DBUG_PRINT("info", ("null"));
     owner->was_null|= 1;
     DBUG_RETURN(0);
   }

--- 1.323/sql/item_func.cc	2007-01-31 09:43:25 -05:00
+++ 1.324/sql/item_func.cc	2007-01-31 09:43:25 -05:00
@@ -3204,7 +3204,7 @@ void debug_sync_point(const char* lock_n
     Structure is now initialized.  Try to get the lock.
     Set up control struct to allow others to abort locks
   */
-  THD_PROC_INFO(thd, "User lock");
+  thd_proc_info(thd, "User lock");
   thd->mysys_var->current_mutex= &LOCK_user_locks;
   thd->mysys_var->current_cond=  &ull->cond;
 
@@ -3229,7 +3229,7 @@ void debug_sync_point(const char* lock_n
   }
   pthread_mutex_unlock(&LOCK_user_locks);
   pthread_mutex_lock(&thd->mysys_var->mutex);
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond=  0;
   pthread_mutex_unlock(&thd->mysys_var->mutex);
@@ -3310,7 +3310,7 @@ longlong Item_func_get_lock::val_int()
     Structure is now initialized.  Try to get the lock.
     Set up control struct to allow others to abort locks.
   */
-  THD_PROC_INFO(thd, "User lock");
+  thd_proc_info(thd, "User lock");
   thd->mysys_var->current_mutex= &LOCK_user_locks;
   thd->mysys_var->current_cond=  &ull->cond;
 
@@ -3348,7 +3348,7 @@ longlong Item_func_get_lock::val_int()
   pthread_mutex_unlock(&LOCK_user_locks);
 
   pthread_mutex_lock(&thd->mysys_var->mutex);
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond=  0;
   pthread_mutex_unlock(&thd->mysys_var->mutex);

--- 1.93/sql/lock.cc	2007-01-31 09:43:25 -05:00
+++ 1.94/sql/lock.cc	2007-01-31 09:43:25 -05:00
@@ -150,7 +150,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, 
       }
     }
 
-    THD_PROC_INFO(thd, "System lock");
+    thd_proc_info(thd, "System lock");
     if (lock_external(thd, tables, count))
     {
       /* Clear the lock type of all lock data to avoid reusage. */
@@ -159,7 +159,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, 
       sql_lock=0;
       break;
     }
-    THD_PROC_INFO(thd, "Table lock");
+    thd_proc_info(thd, "Table lock");
     thd->locked=1;
     /* Copy the lock data array. thr_multi_lock() reorders its contens. */
     memcpy(sql_lock->locks + sql_lock->lock_count, sql_lock->locks,
@@ -193,7 +193,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, 
       thd->locked=0;
       break;
     }
-    THD_PROC_INFO(thd, 0);
+    thd_proc_info(thd, 0);
 
     /* some table was altered or deleted. reopen tables marked deleted */
     mysql_unlock_tables(thd,sql_lock);
@@ -208,7 +208,7 @@ retry:
     if (wait_for_tables(thd))
       break;					// Couldn't open tables
   }
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   if (thd->killed)
   {
     thd->send_kill_message();

--- 1.218/sql/log_event.cc	2007-01-31 09:43:25 -05:00
+++ 1.219/sql/log_event.cc	2007-01-31 09:43:25 -05:00
@@ -4265,7 +4265,7 @@ int Create_file_log_event::exec_event(st
   bzero((char*)&file, sizeof(file));
   fname_buf= strmov(proc_info, "Making temp file ");
   ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
-  THD_PROC_INFO(thd, proc_info);
+  thd_proc_info(thd, proc_info);
   my_delete(fname_buf, MYF(0)); // old copy may exist already
   if ((fd= my_create(fname_buf, CREATE_MODE,
 		     O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
@@ -4319,7 +4319,7 @@ err:
     end_io_cache(&file);
   if (fd >= 0)
     my_close(fd, MYF(0));
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   return error ? 1 : Log_event::exec_event(rli);
 }
 #endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
@@ -4439,7 +4439,7 @@ int Append_block_log_event::exec_event(s
 
   fname= strmov(proc_info, "Making temp file ");
   slave_load_file_stem(fname, file_id, server_id, ".data");
-  THD_PROC_INFO(thd, proc_info);
+  thd_proc_info(thd, proc_info);
   if (get_create_or_append())
   {
     my_delete(fname, MYF(0)); // old copy may exist already
@@ -4473,7 +4473,7 @@ int Append_block_log_event::exec_event(s
 err:
   if (fd >= 0)
     my_close(fd, MYF(0));
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   DBUG_RETURN(error ? error : Log_event::exec_event(rli));
 }
 #endif

--- 1.288/sql/slave.cc	2007-01-31 09:43:25 -05:00
+++ 1.289/sql/slave.cc	2007-01-31 09:43:25 -05:00
@@ -2924,9 +2924,9 @@ static int init_slave_thread(THD* thd, S
 #endif
 
   if (thd_type == SLAVE_THD_SQL)
-    THD_PROC_INFO(thd, "Waiting for the next event in relay log");
+    thd_proc_info(thd, "Waiting for the next event in relay log");
   else
-    THD_PROC_INFO(thd, "Waiting for master update");
+    thd_proc_info(thd, "Waiting for master update");
   thd->version=refresh_version;
   thd->set_time();
   DBUG_RETURN(0);
@@ -3545,7 +3545,7 @@ dump");
       }
 
       mi->slave_running= MYSQL_SLAVE_RUN_NOT_CONNECT;
-      THD_PROC_INFO(thd, "Waiting to reconnect after a failed binlog dump request");
+      thd_proc_info(thd, "Waiting to reconnect after a failed binlog dump request");
 #ifdef SIGNAL_WITH_VIO_CLOSE
       thd->clear_active_vio();
 #endif

--- 1.362/sql/sql_base.cc	2007-01-31 09:43:25 -05:00
+++ 1.363/sql/sql_base.cc	2007-01-31 09:43:25 -05:00
@@ -306,7 +306,7 @@ bool close_cached_tables(THD *thd, bool 
     */
     thd->mysys_var->current_mutex= &LOCK_open;
     thd->mysys_var->current_cond= &COND_refresh;
-    THD_PROC_INFO(thd, "Flushing tables");
+    thd_proc_info(thd, "Flushing tables");
 
     close_old_data_files(thd,thd->open_tables,1,1);
     mysql_ha_flush(thd, tables, MYSQL_HA_REOPEN_ON_USAGE | MYSQL_HA_FLUSH_ALL,
@@ -348,7 +348,7 @@ bool close_cached_tables(THD *thd, bool 
     pthread_mutex_lock(&thd->mysys_var->mutex);
     thd->mysys_var->current_mutex= 0;
     thd->mysys_var->current_cond= 0;
-    THD_PROC_INFO(thd, 0);
+    thd_proc_info(thd, 0);
     pthread_mutex_unlock(&thd->mysys_var->mutex);
   }
   DBUG_RETURN(result);
@@ -1070,7 +1070,7 @@ void wait_for_refresh(THD *thd)
   thd->mysys_var->current_mutex= &LOCK_open;
   thd->mysys_var->current_cond= &COND_refresh;
   proc_info=thd->proc_info;
-  THD_PROC_INFO(thd, "Waiting for table");
+  thd_proc_info(thd, "Waiting for table");
   if (!thd->killed)
     (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
 
@@ -1078,7 +1078,7 @@ void wait_for_refresh(THD *thd)
   pthread_mutex_lock(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= 0;
   thd->mysys_var->current_cond= 0;
-  THD_PROC_INFO(thd,  proc_info);
+  thd_proc_info(thd,  proc_info);
   pthread_mutex_unlock(&thd->mysys_var->mutex);
   DBUG_VOID_RETURN;
 }
@@ -1783,7 +1783,7 @@ bool wait_for_tables(THD *thd)
   bool result;
   DBUG_ENTER("wait_for_tables");
 
-  THD_PROC_INFO(thd, "Waiting for tables");
+  thd_proc_info(thd, "Waiting for tables");
   pthread_mutex_lock(&LOCK_open);
   while (!thd->killed)
   {
@@ -1799,12 +1799,12 @@ bool wait_for_tables(THD *thd)
   else
   {
     /* Now we can open all tables without any interference */
-    THD_PROC_INFO(thd, "Reopen tables");
+    thd_proc_info(thd, "Reopen tables");
     thd->version= refresh_version;
     result=reopen_tables(thd,0,0);
   }
   pthread_mutex_unlock(&LOCK_open);
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   DBUG_RETURN(result);
 }
 
@@ -2103,7 +2103,7 @@ int open_tables(THD *thd, TABLE_LIST **s
  restart:
   *counter= 0;
   query_tables_last_own= 0;
-  THD_PROC_INFO(thd, "Opening tables");
+  thd_proc_info(thd, "Opening tables");
 
   /*
     If we are not already executing prelocked statement and don't have
@@ -2283,7 +2283,7 @@ process_view_routines:
   }
 
  err:
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
 
   if (query_tables_last_own)
@@ -2357,7 +2357,7 @@ TABLE *open_ltable(THD *thd, TABLE_LIST 
   bool refresh;
   DBUG_ENTER("open_ltable");
 
-  THD_PROC_INFO(thd, "Opening table");
+  thd_proc_info(thd, "Opening table");
   thd->current_tablenr= 0;
   /* open_ltable can be used only for BASIC TABLEs */
   table_list->required_type= FRMTYPE_TABLE;
@@ -2391,7 +2391,7 @@ TABLE *open_ltable(THD *thd, TABLE_LIST 
 	  table= 0;
     }
   }
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
   DBUG_RETURN(table);
 }
 
@@ -5436,7 +5436,7 @@ int init_ftfuncs(THD *thd, SELECT_LEX *s
     List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
     Item_func_match *ifm;
     DBUG_PRINT("info",("Performing FULLTEXT search"));
-    THD_PROC_INFO(thd, "FULLTEXT initialization");
+    thd_proc_info(thd, "FULLTEXT initialization");
 
     while ((ifm=li++))
       ifm->init_search(no_order);

--- 1.98/sql/sql_cache.cc	2007-01-31 09:43:25 -05:00
+++ 1.99/sql/sql_cache.cc	2007-01-31 09:43:25 -05:00
@@ -315,13 +315,13 @@ TODO list:
 #define MUTEX_UNLOCK(M) {DBUG_PRINT("lock", ("mutex unlock 0x%lx",\
   (ulong)(M))); pthread_mutex_unlock(M);}
 #define RW_WLOCK(M) {DBUG_PRINT("lock", ("rwlock wlock 0x%lx",(ulong)(M))); \
-  if (!rw_wrlock(M)) DBUG_PRINT("lock", ("rwlock wlock ok")) \
+  if (!rw_wrlock(M)) DBUG_PRINT("lock", ("rwlock wlock ok")); \
   else DBUG_PRINT("lock", ("rwlock wlock FAILED %d", errno)); }
 #define RW_RLOCK(M) {DBUG_PRINT("lock", ("rwlock rlock 0x%lx", (ulong)(M))); \
-  if (!rw_rdlock(M)) DBUG_PRINT("lock", ("rwlock rlock ok")) \
+  if (!rw_rdlock(M)) DBUG_PRINT("lock", ("rwlock rlock ok")); \
   else DBUG_PRINT("lock", ("rwlock wlock FAILED %d", errno)); }
 #define RW_UNLOCK(M) {DBUG_PRINT("lock", ("rwlock unlock 0x%lx",(ulong)(M))); \
-  if (!rw_unlock(M)) DBUG_PRINT("lock", ("rwlock unlock ok")) \
+  if (!rw_unlock(M)) DBUG_PRINT("lock", ("rwlock unlock ok")); \
   else DBUG_PRINT("lock", ("rwlock unlock FAILED %d", errno)); }
 #define STRUCT_LOCK(M) {DBUG_PRINT("lock", ("%d struct lock...",__LINE__)); \
   pthread_mutex_lock(M);DBUG_PRINT("lock", ("struct lock OK"));}
@@ -688,7 +688,7 @@ void query_cache_abort(NET *net)
                                    net->query_cache_query);
   if (query_block)			// Test if changed by other thread
   {
-    THD_PROC_INFO(thd, "storing result in query cache");
+    thd_proc_info(thd, "storing result in query cache");
     DUMP(&query_cache);
     BLOCK_LOCK_WR(query_block);
     // The following call will remove the lock on query_block
@@ -726,7 +726,7 @@ void query_cache_end_of_result(THD *thd)
   query_block= ((Query_cache_block*) thd->net.query_cache_query);
   if (query_block)
   {
-    THD_PROC_INFO(thd, "storing result in query cache");
+    thd_proc_info(thd, "storing result in query cache");
     DUMP(&query_cache);
     BLOCK_LOCK_WR(query_block);
     Query_cache_query *header= query_block->query();
@@ -1091,7 +1091,7 @@ Query_cache::send_result_to_client(THD *
     DBUG_PRINT("qcache", ("No active database"));
   }
 
-  THD_PROC_INFO(thd, "checking query cache for query");
+  thd_proc_info(thd, "checking query cache for query");
 
   // fill all gaps between fields with 0 to get repeatable key
   bzero(&flags, QUERY_CACHE_FLAGS_SIZE);
@@ -1167,7 +1167,7 @@ sql mode: 0x%lx, sort len: %lu, conncat 
   }
       
   // Check access;
-  THD_PROC_INFO(thd, "checking privileges on cached query");
+  thd_proc_info(thd, "checking privileges on cached query");
   block_table= query_block->table(0);
   block_table_end= block_table+query_block->n_tables;
   for (; block_table != block_table_end; block_table++)
@@ -1260,7 +1260,7 @@ sql mode: 0x%lx, sort len: %lu, conncat 
     Send cached result to client
   */
 #ifndef EMBEDDED_LIBRARY
-  THD_PROC_INFO(thd, "sending cached result to client");
+  thd_proc_info(thd, "sending cached result to client");
   do
   {
     DBUG_PRINT("qcache", ("Results  (len: %lu  used: %lu  headers: %lu)",
@@ -1342,7 +1342,7 @@ void Query_cache::invalidate(CHANGED_TAB
   DBUG_ENTER("Query_cache::invalidate (changed table list)");
   if (tables_used)
   {
-    THD_PROC_INFO(thd, "invalidating query cache entries (table list)");
+    thd_proc_info(thd, "invalidating query cache entries (table list)");
     STRUCT_LOCK(&structure_guard_mutex);
     if (query_cache_size > 0 && !flush_in_progress)
     {
@@ -1377,7 +1377,7 @@ void Query_cache::invalidate_locked_for_
   DBUG_ENTER("Query_cache::invalidate_locked_for_write");
   if (tables_used)
   {
-    THD_PROC_INFO(thd, "invalidating query cache entries (table)");
+    thd_proc_info(thd, "invalidating query cache entries (table)");
     STRUCT_LOCK(&structure_guard_mutex);
     if (query_cache_size > 0 && !flush_in_progress)
     {
@@ -1427,7 +1427,7 @@ void Query_cache::invalidate(THD *thd, c
   STRUCT_LOCK(&structure_guard_mutex);
   if (query_cache_size > 0 && !flush_in_progress)
   {
-    THD_PROC_INFO(thd, "invalidating query cache entries (key)");
+    thd_proc_info(thd, "invalidating query cache entries (key)");
     using_transactions= using_transactions &&
       (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN));
     if (using_transactions) // used for innodb => has_transactions() is TRUE

--- 1.189/sql/sql_delete.cc	2007-01-31 09:43:25 -05:00
+++ 1.190/sql/sql_delete.cc	2007-01-31 09:43:25 -05:00
@@ -54,7 +54,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *
     table->file->print_error(error, MYF(0));
     DBUG_RETURN(error);
   }
-  THD_PROC_INFO(thd, "init");
+  thd_proc_info(thd, "init");
   table->map=1;
 
   if (mysql_prepare_delete(thd, table_list, &conds))
@@ -205,7 +205,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *
 
   deleted=0L;
   init_ftfuncs(thd, select_lex, 1);
-  THD_PROC_INFO(thd, "updating");
+  thd_proc_info(thd, "updating");
 
   if (table->triggers)
     table->triggers->mark_fields_used(thd, TRG_EVENT_DELETE);
@@ -261,7 +261,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *
   }
   if (thd->killed && !error)
     error= 1;					// Aborted
-  THD_PROC_INFO(thd,  "end");
+  thd_proc_info(thd,  "end");
   end_read_record(&info);
   free_io_cache(table);				// Will not do any harm
   if (options & OPTION_QUICK)
@@ -485,7 +485,7 @@ multi_delete::prepare(List<Item> &values
   DBUG_ENTER("multi_delete::prepare");
   unit= u;
   do_delete= 1;
-  THD_PROC_INFO(thd, "deleting from main table");
+  thd_proc_info(thd, "deleting from main table");
   DBUG_RETURN(0);
 }
 
@@ -749,7 +749,7 @@ int multi_delete::do_deletes()
 
 bool multi_delete::send_eof()
 {
-  THD_PROC_INFO(thd, "deleting from reference tables");
+  thd_proc_info(thd, "deleting from reference tables");
 
   /* Does deletes for the last n - 1 tables, returns 0 if ok */
   int local_error= do_deletes();		// returns 0 if success
@@ -758,7 +758,7 @@ bool multi_delete::send_eof()
   local_error= local_error || error;
 
   /* reset used flags */
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
 
   /*
     We must invalidate the query cache before binlog writing and

--- 1.212/sql/sql_insert.cc	2007-01-31 09:43:25 -05:00
+++ 1.213/sql/sql_insert.cc	2007-01-31 09:43:25 -05:00
@@ -397,7 +397,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *t
   if (res || thd->is_fatal_error)
     DBUG_RETURN(TRUE);
 
-  THD_PROC_INFO(thd, "init");
+  thd_proc_info(thd, "init");
   thd->used_tables=0;
   values= its++;
 
@@ -470,7 +470,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *t
 
   error=0;
   id=0;
-  THD_PROC_INFO(thd, "update");
+  thd_proc_info(thd, "update");
   if (duplic != DUP_ERROR || ignore)
     table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
   if (duplic == DUP_REPLACE)
@@ -676,7 +676,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *t
       thd->lock=0;
     }
   }
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
   table->next_number_field=0;
   thd->count_cuted_fields= CHECK_FIELD_IGNORE;
   thd->next_insert_id=0;			// Reset this if wrongly used
@@ -1407,7 +1407,7 @@ I_List<delayed_insert> delayed_threads;
 
 delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list)
 {
-  THD_PROC_INFO(thd, "waiting for delay_list");
+  thd_proc_info(thd, "waiting for delay_list");
   pthread_mutex_lock(&LOCK_delayed_insert);	// Protect master list
   I_List_iterator<delayed_insert> it(delayed_threads);
   delayed_insert *tmp;
@@ -1444,7 +1444,7 @@ static TABLE *delayed_get_table(THD *thd
     */
     if (delayed_insert_threads >= thd->variables.max_insert_delayed_threads)
       DBUG_RETURN(0);
-    THD_PROC_INFO(thd, "Creating delayed handler");
+    thd_proc_info(thd, "Creating delayed handler");
     pthread_mutex_lock(&LOCK_delayed_create);
     /*
       The first search above was done without LOCK_delayed_create.
@@ -1486,13 +1486,13 @@ static TABLE *delayed_get_table(THD *thd
       }
 
       /* Wait until table is open */
-      THD_PROC_INFO(thd, "waiting for handler open");
+      thd_proc_info(thd, "waiting for handler open");
       while (!tmp->thd.killed && !tmp->table && !thd->killed)
       {
 	pthread_cond_wait(&tmp->cond_client,&tmp->mutex);
       }
       pthread_mutex_unlock(&tmp->mutex);
-      THD_PROC_INFO(thd, "got old table");
+      thd_proc_info(thd, "got old table");
       if (tmp->thd.killed)
       {
 	if (tmp->thd.is_fatal_error)
@@ -1552,13 +1552,13 @@ TABLE *delayed_insert::get_local_table(T
   tables_in_use++;
   if (!thd.lock)				// Table is not locked
   {
-    THD_PROC_INFO(client_thd, "waiting for handler lock");
+    thd_proc_info(client_thd, "waiting for handler lock");
     pthread_cond_signal(&cond);			// Tell handler to lock table
     while (!dead && !thd.lock && ! client_thd->killed)
     {
       pthread_cond_wait(&cond_client,&mutex);
     }
-    THD_PROC_INFO(client_thd, "got handler lock");
+    thd_proc_info(client_thd, "got handler lock");
     if (client_thd->killed)
       goto error;
     if (dead)
@@ -1576,7 +1576,7 @@ TABLE *delayed_insert::get_local_table(T
     bytes. Since the table copy is used for creating one record only,
     the other record buffers and alignment are unnecessary.
   */
-  THD_PROC_INFO(client_thd, "allocating local table");
+  thd_proc_info(client_thd, "allocating local table");
   copy= (TABLE*) client_thd->alloc(sizeof(*copy)+
 				   (table->s->fields+1)*sizeof(Field**)+
 				   table->s->reclength);
@@ -1656,11 +1656,11 @@ static int write_delayed(THD *thd,TABLE 
   delayed_insert *di=thd->di;
   DBUG_ENTER("write_delayed");
 
-  THD_PROC_INFO(thd, "waiting for handler insert");
+  thd_proc_info(thd, "waiting for handler insert");
   pthread_mutex_lock(&di->mutex);
   while (di->stacked_inserts >= delayed_queue_size && !thd->killed)
     pthread_cond_wait(&di->cond_client,&di->mutex);
-  THD_PROC_INFO(thd, "storing row into queue");
+  thd_proc_info(thd, "storing row into queue");
 
   if (thd->killed || !(row= new delayed_row(duplic, ignore, log_on)))
     goto err;
@@ -1869,7 +1869,7 @@ pthread_handler_t handle_delayed_insert(
       /* Information for pthread_kill */
       di->thd.mysys_var->current_mutex= &di->mutex;
       di->thd.mysys_var->current_cond= &di->cond;
-      THD_PROC_INFO(&(di->thd), "Waiting for INSERT");
+      thd_proc_info(&(di->thd), "Waiting for INSERT");
 
       DBUG_PRINT("info",("Waiting for someone to insert rows"));
       while (!thd->killed)
@@ -1904,7 +1904,7 @@ pthread_handler_t handle_delayed_insert(
       pthread_mutex_unlock(&di->thd.mysys_var->mutex);
       pthread_mutex_lock(&di->mutex);
     }
-    THD_PROC_INFO(&(di->thd), 0);
+    thd_proc_info(&(di->thd), 0);
 
     if (di->tables_in_use && ! thd->lock)
     {
@@ -2023,7 +2023,7 @@ bool delayed_insert::handle_inserts(void
 
   table->next_number_field=table->found_next_number_field;
 
-  THD_PROC_INFO(&thd, "upgrading lock");
+  thd_proc_info(&thd, "upgrading lock");
   if (thr_upgrade_write_delay_lock(*thd.lock->locks))
   {
     /* This can only happen if thread is killed by shutdown */
@@ -2031,7 +2031,7 @@ bool delayed_insert::handle_inserts(void
     goto err;
   }
 
-  THD_PROC_INFO(&thd, "insert");
+  thd_proc_info(&thd, "insert");
   max_rows= delayed_insert_limit;
   if (thd.killed || table->s->version != refresh_version)
   {
@@ -2149,7 +2149,7 @@ bool delayed_insert::handle_inserts(void
       {
 	if (tables_in_use)
 	  pthread_cond_broadcast(&cond_client); // If waiting clients
-	THD_PROC_INFO(&thd, "reschedule");
+	thd_proc_info(&thd, "reschedule");
 	pthread_mutex_unlock(&mutex);
 	if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))
 	{
@@ -2168,14 +2168,14 @@ bool delayed_insert::handle_inserts(void
 	if (!using_bin_log)
 	  table->file->extra(HA_EXTRA_WRITE_CACHE);
 	pthread_mutex_lock(&mutex);
-	THD_PROC_INFO(&thd, "insert");
+	thd_proc_info(&thd, "insert");
       }
       if (tables_in_use)
 	pthread_cond_broadcast(&cond_client);	// If waiting clients
     }
   }
 
-  THD_PROC_INFO(&thd, 0);
+  thd_proc_info(&thd, 0);
   table->next_number_field=0;
   pthread_mutex_unlock(&mutex);
   if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))

--- 1.479/sql/sql_select.cc	2007-01-31 09:43:25 -05:00
+++ 1.480/sql/sql_select.cc	2007-01-31 09:43:25 -05:00
@@ -598,7 +598,7 @@ JOIN::optimize()
   if (thd->lex->orig_sql_command != SQLCOM_SHOW_STATUS)
     thd->status_var.last_query_cost= 0.0;
 
-  THD_PROC_INFO(thd, "optimizing");
+  thd_proc_info(thd, "optimizing");
   row_limit= ((select_distinct || order || group_list) ? HA_POS_ERROR :
 	      unit->select_limit_cnt);
   /* select_limit is used to decide if we are likely to scan the whole table */
@@ -745,7 +745,7 @@ JOIN::optimize()
   sort_by_table= get_sort_by_table(order, group_list, select_lex->leaf_tables);
 
   /* Calculate how to do the join */
-  THD_PROC_INFO(thd, "statistics");
+  thd_proc_info(thd, "statistics");
   if (make_join_statistics(this, select_lex->leaf_tables, conds, &keyuse) ||
       thd->is_fatal_error)
   {
@@ -755,7 +755,7 @@ JOIN::optimize()
 
   /* Remove distinct if only const tables */
   select_distinct= select_distinct && (const_tables != tables);
-  THD_PROC_INFO(thd, "preparing");
+  thd_proc_info(thd, "preparing");
   if (result->initialize_tables(this))
   {
     DBUG_PRINT("error",("Error: initialize_tables() failed"));
@@ -1102,10 +1102,9 @@ JOIN::optimize()
         join_tab[const_tables].type != JT_REF_OR_NULL &&
         (order && simple_order || group_list && simple_group))
     {
-      if (add_ref_to_table_cond(thd,&join_tab[const_tables])) {
+      if (add_ref_to_table_cond(thd,&join_tab[const_tables]))
         DBUG_RETURN(1);
       }
-    }
     
     if (!(select_options & SELECT_BIG_RESULT) &&
         ((group_list &&
@@ -1162,7 +1161,7 @@ JOIN::optimize()
   if (need_tmp)
   {
     DBUG_PRINT("info",("Creating tmp table"));
-    THD_PROC_INFO(thd, "creating temporary table");
+    thd_proc_info(thd, "creating temporary table");
 
     init_items_ref_array();
 
@@ -1213,7 +1212,7 @@ JOIN::optimize()
     if (group_list && simple_group)
     {
       DBUG_PRINT("info",("Sorting for group"));
-      THD_PROC_INFO(thd, "sorting for group");
+      thd_proc_info(thd, "sorting for group");
       if (create_sort_index(thd, this, group_list,
 			    HA_POS_ERROR, HA_POS_ERROR) ||
 	  alloc_group_fields(this, group_list) ||
@@ -1235,7 +1234,7 @@ JOIN::optimize()
       if (!group_list && ! exec_tmp_table1->distinct && order && simple_order)
       {
         DBUG_PRINT("info",("Sorting for order"));
-        THD_PROC_INFO(thd, "Sorting for order");
+        thd_proc_info(thd, "Sorting for order");
         if (create_sort_index(thd, this, order,
                               HA_POS_ERROR, HA_POS_ERROR))
         {
@@ -1364,7 +1363,7 @@ JOIN::exec()
   int      tmp_error;
   DBUG_ENTER("JOIN::exec");
 
-  THD_PROC_INFO(thd, "executing");
+  thd_proc_info(thd, "executing");
   error= 0;
   if (procedure)
   {
@@ -1504,7 +1503,7 @@ JOIN::exec()
     curr_tmp_table= exec_tmp_table1;
 
     /* Copy data to the temporary table */
-    THD_PROC_INFO(thd, "Copying to tmp table");
+    thd_proc_info(thd, "Copying to tmp table");
     DBUG_PRINT("info", ("%s", thd->proc_info));
     if ((tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table, 0)))
     {
@@ -1627,7 +1626,7 @@ JOIN::exec()
       }
       if (curr_join->group_list)
       {
-	THD_PROC_INFO(thd,  "Creating sort index");
+	thd_proc_info(thd,  "Creating sort index");
 	if (curr_join->join_tab == join_tab && save_join_tab())
 	{
 	  DBUG_VOID_RETURN;
@@ -1641,7 +1640,7 @@ JOIN::exec()
         sortorder= curr_join->sortorder;
       }
       
-      THD_PROC_INFO(thd, "Copying to group table");
+      thd_proc_info(thd, "Copying to group table");
       DBUG_PRINT("info", ("%s", thd->proc_info));
       tmp_error= -1;
       if (curr_join != this)
@@ -1697,7 +1696,7 @@ JOIN::exec()
     curr_join->join_free();			/* Free quick selects */
     if (curr_join->select_distinct && ! curr_join->group_list)
     {
-      THD_PROC_INFO(thd, "Removing duplicates");
+      thd_proc_info(thd, "Removing duplicates");
       if (curr_join->tmp_having)
 	curr_join->tmp_having->update_used_tables();
       if (remove_duplicates(curr_join, curr_tmp_table,
@@ -1758,7 +1757,7 @@ JOIN::exec()
   if (curr_join->group_list || curr_join->order)
   {
     DBUG_PRINT("info",("Sorting for send_fields"));
-    THD_PROC_INFO(thd, "Sorting result");
+    thd_proc_info(thd, "Sorting result");
     /* If we have already done the group, add HAVING to sorted table */
     if (curr_join->tmp_having && ! curr_join->group_list && 
 	! curr_join->sort_and_group)
@@ -1882,7 +1881,7 @@ JOIN::exec()
   }
   else
   {
-    THD_PROC_INFO(thd, "Sending data");
+    thd_proc_info(thd, "Sending data");
     DBUG_PRINT("info", ("%s", thd->proc_info));
     result->send_fields((procedure ? curr_join->procedure_fields_list :
                          *curr_fields_list),
@@ -2030,7 +2029,7 @@ mysql_select(THD *thd, Item ***rref_poin
   {
     if (!(join= new JOIN(thd, fields, select_options, result)))
 	DBUG_RETURN(TRUE);
-    THD_PROC_INFO(thd, "init");
+    thd_proc_info(thd, "init");
     thd->used_tables=0;                         // Updated by setup_fields
     if (err= join->prepare(rref_pointer_array, tables, wild_num,
                            conds, og_num, order, group, having, proc_param,
@@ -2075,9 +2074,9 @@ mysql_select(THD *thd, Item ***rref_poin
 err:
   if (free_join)
   {
-    THD_PROC_INFO(thd, "cleaning up");
+    thd_proc_info(thd, "cleaning up");
     err|= select_lex->cleanup();
-    THD_PROC_INFO(thd, "end");
+    thd_proc_info(thd, "end");
     DBUG_RETURN(err || thd->net.report_error);
   }
   DBUG_RETURN(join->error);
@@ -9807,7 +9806,7 @@ free_tmp_table(THD *thd, TABLE *entry)
   DBUG_PRINT("enter",("table: %s",entry->alias));
 
   save_proc_info=thd->proc_info;
-  THD_PROC_INFO(thd, "removing tmp table");
+  thd_proc_info(thd, "removing tmp table");
 
   if (entry->file)
   {
@@ -9835,7 +9834,7 @@ free_tmp_table(THD *thd, TABLE *entry)
     bitmap_clear_bit(&temp_pool, entry->temp_pool_slot);
 
   free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
-  THD_PROC_INFO(thd, save_proc_info);
+  thd_proc_info(thd, save_proc_info);
 
   DBUG_VOID_RETURN;
 }
@@ -9865,7 +9864,7 @@ bool create_myisam_from_heap(THD *thd, T
     DBUG_RETURN(1);				// End of memory
 
   save_proc_info=thd->proc_info;
-  THD_PROC_INFO(thd, "converting HEAP to MyISAM");
+  thd_proc_info(thd, "converting HEAP to MyISAM");
 
   if (create_myisam_tmp_table(&new_table,param,
 			      thd->lex->select_lex.options | thd->options))
@@ -9918,7 +9917,7 @@ bool create_myisam_from_heap(THD *thd, T
   table->s= &table->share_not_to_be_used;
   table->file->change_table_ptr(table);
   if (save_proc_info)
-    THD_PROC_INFO(thd, (!strcmp(save_proc_info,"Copying to tmp table") ?
+    thd_proc_info(thd, (!strcmp(save_proc_info,"Copying to tmp table") ?
                      "Copying to tmp table on disk" : save_proc_info));
   DBUG_RETURN(0);
 
@@ -9931,7 +9930,7 @@ bool create_myisam_from_heap(THD *thd, T
   new_table.file->delete_table(new_table.s->table_name);
   delete new_table.file;
  err2:
-  THD_PROC_INFO(thd, save_proc_info);
+  thd_proc_info(thd, save_proc_info);
   DBUG_RETURN(1);
 }
 

--- 1.336/sql/sql_show.cc	2007-01-31 09:43:25 -05:00
+++ 1.337/sql/sql_show.cc	2007-01-31 09:43:25 -05:00
@@ -1349,7 +1349,7 @@ void mysqld_list_processes(THD *thd,cons
 
 #if !defined(DONT_USE_THR_ALARM) && ! defined(SCO)
         if (pthread_kill(tmp->real_id,0))
-          THD_PROC_INFO(tmp, "*** DEAD ***");        // This shouldn't happen
+          thd_proc_info(tmp, "*** DEAD ***");        // This shouldn't happen
 #endif
 #ifdef EXTRA_DEBUG
         thd_info->start_time= tmp->time_after_lock;

--- 1.330/sql/sql_table.cc	2007-01-31 09:43:25 -05:00
+++ 1.331/sql/sql_table.cc	2007-01-31 09:43:25 -05:00
@@ -1729,7 +1729,7 @@ bool mysql_create_table(THD *thd,const c
     }
   }
 
-  THD_PROC_INFO(thd, "creating table");
+  thd_proc_info(thd, "creating table");
   create_info->table_existed= 0;		// Mark that table is created
 
   if (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)
@@ -1760,7 +1760,7 @@ bool mysql_create_table(THD *thd,const c
 
 end:
   VOID(pthread_mutex_unlock(&LOCK_open));
-  THD_PROC_INFO(thd, "After create");
+  thd_proc_info(thd, "After create");
   DBUG_RETURN(error);
 
 warn:
@@ -2879,7 +2879,7 @@ mysql_discard_or_import_tablespace(THD *
     ALTER TABLE
   */
 
-  THD_PROC_INFO(thd, "discard_or_import_tablespace");
+  thd_proc_info(thd, "discard_or_import_tablespace");
 
   discard= test(tablespace_op == DISCARD_TABLESPACE);
 
@@ -2896,7 +2896,7 @@ mysql_discard_or_import_tablespace(THD *
 
   error=table->file->discard_or_import_tablespace(discard);
 
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
 
   if (error)
     goto err;
@@ -3007,7 +3007,7 @@ bool mysql_alter_table(THD *thd,char *ne
   frm_type_enum frm_type;
   DBUG_ENTER("mysql_alter_table");
 
-  THD_PROC_INFO(thd, "init");
+  thd_proc_info(thd, "init");
   table_name=table_list->table_name;
   alias= (lower_case_table_names == 2) ? table_list->alias : table_name;
 
@@ -3142,7 +3142,7 @@ view_err:
     DBUG_RETURN(TRUE);
   }
   
-  THD_PROC_INFO(thd, "setup");
+  thd_proc_info(thd, "setup");
   if (!(alter_info->flags & ~(ALTER_RENAME | ALTER_KEYS_ONOFF)) &&
       !table->s->tmp_table) // no need to touch frm
   {
@@ -3173,7 +3173,7 @@ view_err:
 
     if (!error && (new_name != table_name || new_db != db))
     {
-      THD_PROC_INFO(thd, "rename");
+      thd_proc_info(thd, "rename");
       /* Then do a 'simple' rename of the table */
       if (!access(new_name_buff,F_OK))
       {
@@ -3627,7 +3627,7 @@ view_err:
   /* We don't want update TIMESTAMP fields during ALTER TABLE. */
   thd->count_cuted_fields= CHECK_FIELD_WARN;	// calc cuted fields
   thd->cuted_fields=0L;
-  THD_PROC_INFO(thd, "copy to tmp table");
+  thd_proc_info(thd, "copy to tmp table");
   next_insert_id=thd->next_insert_id;		// Remember for logging
   copied=deleted=0;
   if (new_table && !new_table->s->is_view)
@@ -3711,7 +3711,7 @@ view_err:
     from the cache, free all locks, close the old table and remove it.
   */
 
-  THD_PROC_INFO(thd, "rename result table");
+  thd_proc_info(thd, "rename result table");
   my_snprintf(old_name, sizeof(old_name), "%s2-%lx-%lx", tmp_file_prefix,
 	      current_pid, thd->thread_id);
   if (lower_case_table_names)
@@ -3822,7 +3822,7 @@ view_err:
     broadcast_refresh();
     goto err;
   }
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
   if (mysql_bin_log.is_open())
   {
     thd->clear_error();

--- 1.208/sql/sql_update.cc	2007-01-31 09:43:25 -05:00
+++ 1.209/sql/sql_update.cc	2007-01-31 09:43:25 -05:00
@@ -166,7 +166,7 @@ int mysql_update(THD *thd,
        mysql_handle_derived(thd->lex, &mysql_derived_filling)))
     DBUG_RETURN(1);
 
-  THD_PROC_INFO(thd, "init");
+  thd_proc_info(thd, "init");
   table= table_list->table;
   table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
 
@@ -358,7 +358,7 @@ int mysql_update(THD *thd,
       else
         init_read_record_idx(&info, thd, table, 1, used_index);
 
-      THD_PROC_INFO(thd, "Searching rows for update");
+      thd_proc_info(thd, "Searching rows for update");
       uint tmp_limit= limit;
 
       while (!(error=info.read_record(&info)) && !thd->killed)
@@ -423,7 +423,7 @@ int mysql_update(THD *thd,
   updated= found= 0;
   thd->count_cuted_fields= CHECK_FIELD_WARN;		/* calc cuted fields */
   thd->cuted_fields=0L;
-  THD_PROC_INFO(thd, "Updating");
+  thd_proc_info(thd, "Updating");
   query_id=thd->query_id;
 
   transactional_table= table->file->has_transactions();
@@ -511,7 +511,7 @@ int mysql_update(THD *thd,
   end_read_record(&info);
   free_io_cache(table);				// If ORDER BY
   delete select;
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
   VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
 
   /*
@@ -959,7 +959,7 @@ int multi_update::prepare(List<Item> &no
 
   thd->count_cuted_fields= CHECK_FIELD_WARN;
   thd->cuted_fields=0L;
-  THD_PROC_INFO(thd, "updating main table");
+  thd_proc_info(thd, "updating main table");
 
   tables_to_update= get_table_map(fields);
 
@@ -1511,11 +1511,11 @@ err2:
 bool multi_update::send_eof()
 {
   char buff[STRING_BUFFER_USUAL_SIZE];
-  THD_PROC_INFO(thd, "updating reference tables");
+  thd_proc_info(thd, "updating reference tables");
 
   /* Does updates for the last n - 1 tables, returns 0 if ok */
   int local_error = (table_count) ? do_updates(0) : 0;
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
 
   /* We must invalidate the query cache before binlog writing and
   ha_autocommit_... */

--- 1.102/sql/sql_view.cc	2007-01-31 09:43:25 -05:00
+++ 1.103/sql/sql_view.cc	2007-01-31 09:43:25 -05:00
@@ -588,7 +588,7 @@ bool mysql_create_view(THD *thd, TABLE_L
   DBUG_RETURN(0);
 
 err:
-  THD_PROC_INFO(thd, "end");
+  thd_proc_info(thd, "end");
   lex->link_first_table_back(view, link_to_local);
   unit->cleanup();
   DBUG_RETURN(res || thd->net.report_error);

--- 1.80/sql/ha_archive.cc	2007-01-31 09:43:25 -05:00
+++ 1.81/sql/ha_archive.cc	2007-01-31 09:43:25 -05:00
@@ -1205,7 +1205,7 @@ int ha_archive::check(THD* thd, HA_CHECK
   ha_rows count= share->rows_recorded;
   DBUG_ENTER("ha_archive::check");
 
-  THD_PROC_INFO(thd, "Checking table");
+  thd_proc_info(thd, "Checking table");
   /* Flush any waiting data */
   gzflush(share->archive_write, Z_SYNC_FLUSH);
 
@@ -1229,7 +1229,7 @@ int ha_archive::check(THD* thd, HA_CHECK
 
   my_free((char*)buf, MYF(0));
 
-  THD_PROC_INFO(thd, old_proc_info);
+  thd_proc_info(thd, old_proc_info);
 
   if ((rc && rc != HA_ERR_END_OF_FILE) || count)  
   {

--- 1.20/ndb/src/ndbapi/DictCache.cpp	2007-01-31 09:43:25 -05:00
+++ 1.21/ndb/src/ndbapi/DictCache.cpp	2007-01-31 09:43:25 -05:00
@@ -284,7 +284,7 @@ GlobalDictCache::drop(NdbTableImpl * tab
       ver.m_refCount--;
       ver.m_status = DROPPED;
       if(ver.m_refCount == 0){
-        DBUG_PRINT("info", ("refCount is zero, deleting m_impl"))
+        DBUG_PRINT("info", ("refCount is zero, deleting m_impl"));
 	delete ver.m_impl;
 	vers->erase(i);
       }

--- 1.292/sql/ha_ndbcluster.cc	2007-01-31 09:43:26 -05:00
+++ 1.293/sql/ha_ndbcluster.cc	2007-01-31 09:43:26 -05:00
@@ -5821,14 +5821,14 @@ ha_ndbcluster::register_query_cache_tabl
 
   if (!is_autocommit)
   {
-    DBUG_PRINT("exit", ("Can't register table during transaction"))
+    DBUG_PRINT("exit", ("Can't register table during transaction"));
     DBUG_RETURN(FALSE);
   }
 
   if (ndb_get_commitcount(thd, m_dbname, m_tabname, &commit_count))
   {
     *engine_data= 0;
-    DBUG_PRINT("exit", ("Error, could not get commitcount"))
+    DBUG_PRINT("exit", ("Error, could not get commitcount"));
     DBUG_RETURN(FALSE);
   }
   *engine_data= commit_count;

--- 1.229/sql/sp_head.cc	2007-01-31 09:43:26 -05:00
+++ 1.230/sql/sp_head.cc	2007-01-31 09:43:26 -05:00
@@ -2387,9 +2387,9 @@ sp_lex_keeper::reset_lex_and_exec_core(T
 
   m_lex->unit.cleanup();
 
-  THD_PROC_INFO(thd, "closing tables");
+  thd_proc_info(thd, "closing tables");
   close_thread_tables(thd);
-  THD_PROC_INFO(thd, 0);
+  thd_proc_info(thd, 0);
 
   if (m_lex->query_tables_own_last)
   {

--- 1.64/sql/repl_failsafe.cc	2007-01-31 09:43:26 -05:00
+++ 1.65/sql/repl_failsafe.cc	2007-01-31 09:43:26 -05:00
@@ -91,7 +91,7 @@ static int init_failsafe_rpl_thread(THD*
   if (thd->variables.max_join_size == HA_POS_ERROR)
     thd->options|= OPTION_BIG_SELECTS;
 
-  THD_PROC_INFO(thd, "Thread initialized");
+  thd_proc_info(thd, "Thread initialized");
   thd->version=refresh_version;
   thd->set_time();
   DBUG_RETURN(0);
@@ -597,7 +597,7 @@ pthread_handler_t handle_failsafe_rpl(vo
   {
     bool break_req_chain = 0;
     pthread_cond_wait(&COND_rpl_status, &LOCK_rpl_status);
-    THD_PROC_INFO(thd, "Processing request");
+    thd_proc_info(thd, "Processing request");
     while (!break_req_chain)
     {
       switch (rpl_status) {
@@ -941,7 +941,7 @@ bool load_master_data(THD* thd)
       goto err;
     }
   }
-  THD_PROC_INFO(thd, "purging old relay logs");
+  thd_proc_info(thd, "purging old relay logs");
   if (purge_relay_logs(&active_mi->rli,thd,
 		       0 /* not only reset, but also reinit */,
 		       &errmsg))

--- 1.156/sql/sql_repl.cc	2007-01-31 09:43:26 -05:00
+++ 1.157/sql/sql_repl.cc	2007-01-31 09:43:26 -05:00
@@ -1196,7 +1196,7 @@ bool change_master(THD* thd, MASTER_INFO
   if (need_relay_log_purge)
   {
     relay_log_purge= 1;
-    THD_PROC_INFO(thd, "Purging old relay logs");
+    thd_proc_info(thd, "Purging old relay logs");
     if (purge_relay_logs(&mi->rli, thd,
 			 0 /* not only reset, but also reinit */,
 			 &errmsg))
Thread
bk commit into 5.0 tree (cmiller:1.2383)Chad MILLER31 Jan