bk commit into 5.1 tree (rburnett:1.2202)

[reggie]

Below is the list of changes that have just been committed into a local
5.1 repository of rburnett. When rburnett 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
  1.2202 06/06/21 17:51:54 rburnett@stripped +6 -0
  Merge bk-internal.mysql.com:/data0/bk/mysql-5.1
  into  bk-internal.mysql.com:/data0/bk/mysql-5.1-kt

  sql/share/errmsg.txt
    1.110 06/06/21 17:51:43 rburnett@stripped +0 -1

  sql/sql_delete.cc
    1.186 06/06/21 17:50:29 rburnett@stripped +0 -0
    Auto merged

  sql/set_var.h
    1.88 06/06/21 17:50:27 rburnett@stripped +0 -0
    Auto merged

  sql/set_var.cc
    1.177 06/06/21 17:50:27 rburnett@stripped +0 -0
    Auto merged

  sql/log.cc
    1.217 06/06/21 17:50:26 rburnett@stripped +0 -0
    Auto merged

  mysql-test/r/show_check.result
    1.96 06/06/21 17:50:26 rburnett@stripped +0 -0
    Auto merged

# 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:	rburnett
# Host:	bk-internal.mysql.com
# Root:	/data0/bk/mysql-5.1-kt/RESYNC

--- 1.216/sql/log.cc	2006-06-19 12:14:20 +02:00
+++ 1.217/sql/log.cc	2006-06-21 17:50:26 +02:00
@@ -37,9 +37,6 @@
 #define MAX_USER_HOST_SIZE 512
 #define MAX_TIME_SIZE 32
 
-/* we need this for log files intialization */
-extern char *opt_logname, *opt_slow_logname;
-
 LOGGER logger;
 
 MYSQL_BIN_LOG mysql_bin_log;
@@ -63,6 +60,13 @@
 };
 
 
+char *make_default_log_name(char *buff,const char* log_ext)
+{
+  strmake(buff, glob_hostname, FN_REFLEN-5);
+  return fn_format(buff, buff, mysql_data_home, log_ext,
+                   MYF(MY_UNPACK_FILENAME|MY_APPEND_EXT));
+}
+
 /*
   This is a POD. Please keep it that way!
 
@@ -256,8 +260,10 @@
 
 void Log_to_csv_event_handler::cleanup()
 {
-  close_log_table(QUERY_LOG_GENERAL, FALSE);
-  close_log_table(QUERY_LOG_SLOW, FALSE);
+  if (opt_log)
+    close_log_table(QUERY_LOG_GENERAL, FALSE);
+  if (opt_slow_log)
+    close_log_table(QUERY_LOG_SLOW, FALSE);
   logger.is_log_tables_initialized= FALSE;
 }
 
@@ -511,10 +517,10 @@
   if (!is_initialized)
   {
     if (opt_slow_log)
-      mysql_slow_log.open_slow_log(opt_slow_logname);
+      mysql_slow_log.open_slow_log(sys_var_slow_log_path.value);
 
     if (opt_log)
-      mysql_log.open_query_log(opt_logname);
+      mysql_log.open_query_log(sys_var_general_log_path.value);
 
     is_initialized= TRUE;
   }
@@ -531,8 +537,11 @@
 
 void Log_to_file_event_handler::flush()
 {
-  mysql_log.reopen_file();
-  mysql_slow_log.reopen_file();
+  /* reopen log files */
+  if (opt_log)
+    mysql_log.reopen_file();
+  if (opt_slow_log)
+    mysql_slow_log.reopen_file();
 }
 
 /*
@@ -652,10 +661,7 @@
   close_general_log.db= (char*) "mysql";
   close_general_log.db_length= 5;
 
-  /* reopen log files */
-  file_log_handler->flush();
-
-  /* flush tables, in the case they are enabled */
+  /* lock tables, in the case they are enabled */
   if (logger.is_log_tables_initialized)
   {
     /*
@@ -668,23 +674,29 @@
       Here we use one of the logger handler THD's. Simply because it
       seems appropriate.
     */
-    lock_and_wait_for_table_name(table_log_handler->general_log_thd,
-                                 &close_slow_log);
-    lock_and_wait_for_table_name(table_log_handler->general_log_thd,
-                                 &close_general_log);
+    if (opt_slow_log)
+      lock_and_wait_for_table_name(table_log_handler->general_log_thd,
+				   &close_slow_log);
+    if (opt_log)
+      lock_and_wait_for_table_name(table_log_handler->general_log_thd,
+				   &close_general_log);
+  }
 
-    /*
-      Deny others from logging to general and slow log,
-      while reopening tables.
-    */
-    logger.lock();
+  /*
+    Deny others from logging to general and slow log,
+    while reopening tables.
+  */
+  logger.lock();
+
+  /* reopen log files */
+  file_log_handler->flush();
 
+  /* flush tables, in the case they are enabled */
+  if (logger.is_log_tables_initialized)
     table_log_handler->flush(table_log_handler->general_log_thd,
                              &close_slow_log, &close_general_log);
-
-    /* end of log tables flush */
-    logger.unlock();
-  }
+  /* end of log flush */
+  logger.unlock();
   return FALSE;
 }
 
@@ -732,6 +744,11 @@
       return 0;
 
     lock();
+    if (!opt_slow_log)
+    {
+      unlock();
+      return 0;
+    }
 
     /* fill in user_host value: the format is "%s[%s] @ %s [%s]" */
     user_host_len= strxnmov(user_host_buff, MAX_USER_HOST_SIZE,
@@ -806,6 +823,11 @@
       id=0;                                     /* Log from connect handler */
 
     lock();
+    if (!opt_log)
+    {
+      unlock();
+      return 0;
+    }
     time_t current_time= time(NULL);
 
     user_host_len= strxnmov(user_host_buff, MAX_USER_HOST_SIZE,
@@ -909,26 +931,126 @@
 }
 
 
+bool LOGGER::activate_log_handler(THD* thd, uint log_type)
+{
+  bool res= 0;
+  lock();
+  switch (log_type) {
+  case QUERY_LOG_SLOW:
+    if (!opt_slow_log)
+    {
+      if ((res= reopen_log_table(log_type)))
+        goto err;
+      file_log_handler->get_mysql_slow_log()->
+        open_slow_log(sys_var_slow_log_path.value);
+      init_slow_log(log_output_options);
+      opt_slow_log= TRUE;
+    }
+    break;
+  case QUERY_LOG_GENERAL:
+    if (!opt_log)
+    {
+      if ((res= reopen_log_table(log_type)))
+        goto err;
+      file_log_handler->get_mysql_log()->
+        open_query_log(sys_var_general_log_path.value);
+      init_general_log(log_output_options);
+      opt_log= TRUE;
+    }
+    break;
+  default:
+    DBUG_ASSERT(0);
+  }
+err:
+  unlock();
+  return res;
+}
+
+
+void LOGGER::deactivate_log_handler(THD *thd, uint log_type)
+{
+  TABLE_LIST *table_list;
+  my_bool *tmp_opt= 0;
+  MYSQL_LOG *file_log;
+  THD *log_thd;
+
+  switch (log_type) {
+  case QUERY_LOG_SLOW:
+    table_list= &table_log_handler->slow_log;
+    tmp_opt= &opt_slow_log;
+    file_log= file_log_handler->get_mysql_slow_log();
+    log_thd= table_log_handler->slow_log_thd;
+    break;
+  case QUERY_LOG_GENERAL:
+    table_list= &table_log_handler->general_log;
+    tmp_opt= &opt_log;
+    file_log= file_log_handler->get_mysql_log();
+    log_thd= table_log_handler->general_log_thd;
+    break;
+  default:
+    DBUG_ASSERT(0);
+  }
+
+  if (!(*tmp_opt))
+    return;
+
+  if (is_log_tables_initialized)
+    lock_and_wait_for_table_name(log_thd, table_list);
+  lock();
+
+  if (is_log_tables_initialized)
+  {
+    VOID(pthread_mutex_lock(&LOCK_open));
+    close_log_table(log_type, TRUE);
+    table_list->table= 0;
+    query_cache_invalidate3(log_thd, table_list, 0);
+    unlock_table_name(log_thd, table_list);
+    VOID(pthread_mutex_unlock(&LOCK_open));
+  }
+  file_log->close(0);
+  *tmp_opt= FALSE;
+  unlock();
+}
+
+
 bool Log_to_csv_event_handler::flush(THD *thd, TABLE_LIST *close_slow_log,
                                      TABLE_LIST *close_general_log)
 {
   VOID(pthread_mutex_lock(&LOCK_open));
-  close_log_table(QUERY_LOG_GENERAL, TRUE);
-  close_log_table(QUERY_LOG_SLOW, TRUE);
-  close_general_log->next_local= close_slow_log;
-  query_cache_invalidate3(thd, close_general_log, 0);
-  unlock_table_name(thd, close_slow_log);
-  unlock_table_name(thd, close_general_log);
+  if (opt_log)
+  {
+    close_log_table(QUERY_LOG_GENERAL, TRUE);
+    query_cache_invalidate3(thd, close_general_log, 0);
+    unlock_table_name(thd, close_general_log);
+  }
+  if (opt_slow_log)
+  {
+    close_log_table(QUERY_LOG_SLOW, TRUE);
+    query_cache_invalidate3(thd, close_slow_log, 0);
+    unlock_table_name(thd, close_slow_log);
+  }
   VOID(pthread_mutex_unlock(&LOCK_open));
-  return reopen_log_table(QUERY_LOG_SLOW) ||
-         reopen_log_table(QUERY_LOG_GENERAL);
+  /*
+    we use | and not || here, to ensure that both reopen_log_table
+    are called, even if the first one fails
+  */
+  if ((opt_slow_log && reopen_log_table(QUERY_LOG_SLOW)) |
+      (opt_log && reopen_log_table(QUERY_LOG_GENERAL)))
+    return 1;
+  return 0;
 }
 
 /* the parameters are unused for the log tables */
 bool Log_to_csv_event_handler::init()
 {
-  /* we always open log tables. even if the logging is disabled */
-  return (open_log_table(QUERY_LOG_GENERAL) || open_log_table(QUERY_LOG_SLOW));
+  /*
+    we use | and not || here, to ensure that both open_log_table
+    are called, even if the first one fails
+  */
+  if ((opt_log && open_log_table(QUERY_LOG_GENERAL)) |
+      (opt_slow_log && open_log_table(QUERY_LOG_SLOW)))
+    return 1;
+  return 0;
 }
 
 int LOGGER::set_handlers(uint error_log_printer,

--- 1.185/sql/sql_delete.cc	2006-06-16 01:15:08 +02:00
+++ 1.186/sql/sql_delete.cc	2006-06-21 17:50:29 +02:00
@@ -911,7 +911,8 @@
   /* close log tables in use */
   if (!my_strcasecmp(system_charset_info, table_list->db, "mysql"))
   {
-    if (!my_strcasecmp(system_charset_info, table_list->table_name,
+    if (opt_log &&
+        !my_strcasecmp(system_charset_info, table_list->table_name,
                        "general_log"))
     {
       lock_logger= 1;
@@ -920,7 +921,8 @@
       closed_log_tables= closed_log_tables | QUERY_LOG_GENERAL;
     }
     else
-      if (!my_strcasecmp(system_charset_info, table_list->table_name,
+      if (opt_slow_log &&
+          !my_strcasecmp(system_charset_info, table_list->table_name,
                          "slow_log"))
       {
         lock_logger= 1;
@@ -961,10 +963,10 @@
     unlock_table_name(thd, table_list);
     VOID(pthread_mutex_unlock(&LOCK_open));
 
-    if (closed_log_tables & QUERY_LOG_SLOW)
+    if (opt_slow_log && (closed_log_tables & QUERY_LOG_SLOW))
       logger.reopen_log_table(QUERY_LOG_SLOW);
 
-    if (closed_log_tables & QUERY_LOG_GENERAL)
+    if (opt_log && (closed_log_tables & QUERY_LOG_GENERAL))
       logger.reopen_log_table(QUERY_LOG_GENERAL);
     if (lock_logger)
       logger.unlock();

--- 1.109/sql/share/errmsg.txt	2006-06-16 01:15:07 +02:00
+++ 1.110/sql/share/errmsg.txt	2006-06-21 17:51:43 +02:00
@@ -5835,5 +5835,7 @@
 ER_PARTITION_MERGE_ERROR
         eng "%s handler cannot be used in partitioned tables"
         swe "%s kan inte användas i en partitionerad tabell"
+ER_CANT_ACTIVATE_LOG
+        eng "Cannot activate '%-.64s' log."
 ER_RBR_NOT_AVAILABLE
         eng "The server was not built with row-based replication"

--- 1.95/mysql-test/r/show_check.result	2006-06-13 12:45:47 +02:00
+++ 1.96/mysql-test/r/show_check.result	2006-06-21 17:50:26 +02:00
@@ -148,14 +148,12 @@
 show open tables;
 Database	Table	In_use	Name_locked
 mysql	general_log	1	0
-mysql	slow_log	1	0
 create table t1(n int);
 insert into t1 values (1);
 show open tables;
 Database	Table	In_use	Name_locked
-mysql	general_log	1	0
-mysql	slow_log	1	0
 test	t1	0	0
+mysql	general_log	1	0
 drop table t1;
 create table t1 (a int not null, b VARCHAR(10), INDEX (b) ) AVG_ROW_LENGTH=10 CHECKSUM=1
COMMENT="test" ENGINE=MYISAM MIN_ROWS=10 MAX_ROWS=100 PACK_KEYS=1 DELAY_KEY_WRITE=1
ROW_FORMAT=fixed;
 show create table t1;
@@ -568,23 +566,21 @@
 1
 SHOW OPEN TABLES;
 Database	Table	In_use	Name_locked
-mysql	proc	0	0
+mysql	db	0	0
 test	urkunde	0	0
 mysql	time_zone	0	0
-mysql	db	0	0
+mysql	general_log	1	0
 test	txt1	0	0
-mysql	slow_log	1	0
+mysql	proc	0	0
 test	tyt2	0	0
-mysql	general_log	1	0
 mysql	user	0	0
 mysql	time_zone_name	0	0
 SHOW OPEN TABLES FROM mysql;
 Database	Table	In_use	Name_locked
-mysql	proc	0	0
-mysql	time_zone	0	0
 mysql	db	0	0
-mysql	slow_log	1	0
+mysql	time_zone	0	0
 mysql	general_log	1	0
+mysql	proc	0	0
 mysql	user	0	0
 mysql	time_zone_name	0	0
 SHOW OPEN TABLES FROM mysql LIKE 'u%';
@@ -598,16 +594,14 @@
 mysql	time_zone_name	0	0
 SHOW OPEN TABLES LIKE '%o%';
 Database	Table	In_use	Name_locked
-mysql	proc	0	0
 mysql	time_zone	0	0
-mysql	slow_log	1	0
 mysql	general_log	1	0
+mysql	proc	0	0
 mysql	time_zone_name	0	0
 FLUSH TABLES;
 SHOW OPEN TABLES;
 Database	Table	In_use	Name_locked
 mysql	general_log	1	0
-mysql	slow_log	1	0
 DROP TABLE txt1;
 DROP TABLE tyt2;
 DROP TABLE urkunde;

--- 1.176/sql/set_var.cc	2006-06-16 00:49:49 +02:00
+++ 1.177/sql/set_var.cc	2006-06-21 17:50:27 +02:00
@@ -55,6 +55,7 @@
 #include <my_getopt.h>
 #include <thr_alarm.h>
 #include <myisam.h>
+#include <my_dir.h>
 
 #include "event_scheduler.h"
 
@@ -164,6 +165,11 @@
 static byte *get_warning_count(THD *thd);
 static byte *get_prepared_stmt_count(THD *thd);
 static byte *get_tmpdir(THD *thd);
+static int  sys_check_log_path(THD *thd,  set_var *var);
+static bool sys_update_general_log_path(THD *thd, set_var * var);
+static void sys_default_general_log_path(THD *thd, enum_var_type type);
+static bool sys_update_slow_log_path(THD *thd, set_var * var);
+static void sys_default_slow_log_path(THD *thd, enum_var_type type);
 
 /*
   Variable definition list
@@ -681,6 +687,22 @@
 /* Global read-only variable describing server license */
 sys_var_const_str		sys_license("license", STRINGIFY_ARG(LICENSE));
 
+/* Global variables which enable|disable logging */
+sys_var_log_state sys_var_general_log("general_log", &opt_log,
+                                      QUERY_LOG_GENERAL);
+sys_var_log_state sys_var_slow_query_log("slow_query_log", &opt_slow_log,
+                                         QUERY_LOG_SLOW);
+sys_var_str sys_var_general_log_path("general_log_file", sys_check_log_path,
+				     sys_update_general_log_path,
+				     sys_default_general_log_path,
+				     opt_logname);
+sys_var_str sys_var_slow_log_path("slow_query_log_file", sys_check_log_path,
+				  sys_update_slow_log_path, 
+				  sys_default_slow_log_path,
+				  opt_slow_logname);
+sys_var_log_output sys_var_log_output_state("log_output", &log_output_options,
+					    &log_output_typelib, 0);
+
 #ifdef HAVE_REPLICATION
 static int show_slave_skip_errors(THD *thd, SHOW_VAR *var, char *buff)
 {
@@ -779,6 +801,8 @@
   {"ft_min_word_len",         (char*) &ft_min_word_len,             SHOW_LONG},
   {"ft_query_expansion_limit",(char*) &ft_query_expansion_limit,    SHOW_LONG},
   {"ft_stopword_file",        (char*) &ft_stopword_file,            SHOW_CHAR_PTR},
+  {sys_var_general_log.name, (char*) &opt_log,                      SHOW_MY_BOOL},
+  {sys_var_general_log_path.name, (char*) &sys_var_general_log_path,  SHOW_SYS},
   {sys_group_concat_max_len.name, (char*) &sys_group_concat_max_len,  SHOW_SYS},
   {sys_have_archive_db.name,  (char*) &have_archive_db,             SHOW_HAVE},
   {sys_have_berkeley_db.name, (char*) &have_berkeley_db,            SHOW_HAVE},
@@ -856,6 +880,7 @@
   {"log_bin",                 (char*) &opt_bin_log,                 SHOW_BOOL},
   {sys_trust_function_creators.name,(char*) &sys_trust_function_creators, SHOW_SYS},
   {"log_error",               (char*) log_error_file,               SHOW_CHAR},
+  {sys_var_log_output_state.name, (char*) &sys_var_log_output_state, SHOW_SYS},
   {sys_log_queries_not_using_indexes.name,
     (char*) &sys_log_queries_not_using_indexes, SHOW_SYS},
 #ifdef HAVE_REPLICATION
@@ -981,6 +1006,8 @@
   {sys_slave_trans_retries.name,(char*) &sys_slave_trans_retries,   SHOW_SYS},
 #endif
   {sys_slow_launch_time.name, (char*) &sys_slow_launch_time,        SHOW_SYS},
+  {sys_var_slow_query_log.name, (char*) &opt_slow_log,              SHOW_MY_BOOL},
+  {sys_var_slow_log_path.name, (char*) &sys_var_slow_log_path,      SHOW_SYS},
 #ifdef HAVE_SYS_UN_H
   {"socket",                  (char*) &mysqld_unix_port,             SHOW_CHAR_PTR},
 #endif
@@ -2518,6 +2545,206 @@
 end:
   pthread_mutex_unlock(&LOCK_global_system_variables);
   return error;
+}
+
+
+bool sys_var_log_state::update(THD *thd, set_var *var)
+{
+  bool res= 0;
+  pthread_mutex_lock(&LOCK_global_system_variables);
+  if (!var->save_result.ulong_value)
+    logger.deactivate_log_handler(thd, log_type);
+  else
+  {
+    if ((res= logger.activate_log_handler(thd, log_type)))
+    {
+      my_error(ER_CANT_ACTIVATE_LOG, MYF(0),
+               log_type == QUERY_LOG_GENERAL ? "general" :
+               "slow query");
+      goto err;
+    }
+  }
+err:
+  pthread_mutex_unlock(&LOCK_global_system_variables);
+  return res;
+}
+
+void sys_var_log_state::set_default(THD *thd, enum_var_type type)
+{
+  pthread_mutex_lock(&LOCK_global_system_variables);
+  logger.deactivate_log_handler(thd, log_type);
+  pthread_mutex_unlock(&LOCK_global_system_variables);
+}
+
+
+static int  sys_check_log_path(THD *thd,  set_var *var)
+{
+  char path[FN_REFLEN];
+  MY_STAT f_stat;
+  const char *var_path= var->value->str_value.ptr();
+  bzero(&f_stat, sizeof(MY_STAT));
+
+  (void) unpack_filename(path, var_path);
+  if (my_stat(path, &f_stat, MYF(0)))
+  {
+    /* Check if argument is a file and we have 'write' permission */
+    if (!MY_S_ISREG(f_stat.st_mode) ||
+        !(f_stat.st_mode & MY_S_IWRITE))
+      return -1;
+  }
+  else
+  {
+    /*
+      Check if directory exists and 
+      we have permission to create file & write to file
+    */
+    (void) dirname_part(path, var_path);
+    if (my_access(path, (F_OK|W_OK)))
+      return -1;
+  }
+  return 0;
+}
+
+
+bool update_sys_var_str_path(THD *thd, sys_var_str *var_str,
+			     set_var *var, const char *log_ext,
+			     bool log_state, uint log_type)
+{
+  MYSQL_QUERY_LOG *file_log;
+  char buff[FN_REFLEN];
+  char *res= 0, *old_value=(char *)(var ? var->value->str_value.ptr() : 0);
+  bool result= 0;
+  uint str_length= (var ? var->value->str_value.length() : 0);
+
+  switch (log_type) {
+  case QUERY_LOG_SLOW:
+    file_log= logger.get_slow_log_file_handler();
+    break;
+  case QUERY_LOG_GENERAL:
+    file_log= logger.get_log_file_handler();
+    break;
+  default:
+    DBUG_ASSERT(0);
+  }
+
+  if (!old_value)
+  {
+    old_value= make_default_log_name(buff, log_ext);
+    str_length= strlen(old_value);
+  }
+  if (!(res= my_strndup((byte*)old_value, str_length, MYF(MY_FAE+MY_WME))))
+  {
+    result= 1;
+    goto err;
+  }
+
+  pthread_mutex_lock(&LOCK_global_system_variables);
+  logger.lock();
+
+  if (file_log && log_state)
+    file_log->close(0);
+  old_value= var_str->value;
+  var_str->value= res;
+  var_str->value_length= str_length;
+  my_free(old_value, MYF(MY_ALLOW_ZERO_PTR));
+  if (file_log && log_state)
+  {
+    switch (log_type) {
+    case QUERY_LOG_SLOW:
+      file_log->open_slow_log(sys_var_general_log_path.value);
+      break;
+    case QUERY_LOG_GENERAL:
+      file_log->open_query_log(sys_var_general_log_path.value);
+      break;
+    default:
+      DBUG_ASSERT(0);
+    }
+  }
+
+  logger.unlock();
+  pthread_mutex_unlock(&LOCK_global_system_variables);
+
+err:
+  return result;
+}
+
+
+static bool sys_update_general_log_path(THD *thd, set_var * var)
+{
+  return update_sys_var_str_path(thd, &sys_var_general_log_path, 
+				 var, ".log", opt_log, QUERY_LOG_GENERAL);
+}
+
+
+static void sys_default_general_log_path(THD *thd, enum_var_type type)
+{
+  (void) update_sys_var_str_path(thd, &sys_var_general_log_path,
+				 0, ".log", opt_log, QUERY_LOG_GENERAL);
+}
+
+
+static bool sys_update_slow_log_path(THD *thd, set_var * var)
+{
+  return update_sys_var_str_path(thd, &sys_var_slow_log_path,
+				 var, "-slow.log", opt_slow_log,
+                                 QUERY_LOG_SLOW);
+}
+
+
+static void sys_default_slow_log_path(THD *thd, enum_var_type type)
+{
+  (void) update_sys_var_str_path(thd, &sys_var_slow_log_path,
+				 0, "-slow.log", opt_slow_log,
+                                 QUERY_LOG_SLOW);
+}
+
+
+bool sys_var_log_output::update(THD *thd, set_var *var)
+{
+  pthread_mutex_lock(&LOCK_global_system_variables);
+  logger.lock();
+  logger.init_slow_log(var->save_result.ulong_value);
+  logger.init_general_log(var->save_result.ulong_value);
+  *value= var->save_result.ulong_value;
+  logger.unlock();
+  pthread_mutex_unlock(&LOCK_global_system_variables);
+  return 0;
+}
+
+
+void sys_var_log_output::set_default(THD *thd, enum_var_type type)
+{
+  pthread_mutex_lock(&LOCK_global_system_variables);
+  logger.lock();
+  logger.init_slow_log(LOG_TABLE);
+  logger.init_general_log(LOG_TABLE);
+  *value= LOG_TABLE;
+  logger.unlock();
+  pthread_mutex_unlock(&LOCK_global_system_variables);
+}
+
+
+byte *sys_var_log_output::value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
+{
+  char buff[256];
+  String tmp(buff, sizeof(buff), &my_charset_latin1);
+  ulong length;
+  ulong val= *value;
+
+  tmp.length(0);
+  for (uint i= 0; val; val>>= 1, i++)
+  {
+    if (val & 1)
+    {
+      tmp.append(log_output_typelib.type_names[i],
+                 log_output_typelib.type_lengths[i]);
+      tmp.append(',');
+    }
+  }
+
+  if ((length= tmp.length()))
+    length--;
+  return (byte*) thd->strmake(tmp.ptr(), length);
 }
 
 

--- 1.87/sql/set_var.h	2006-06-16 00:49:49 +02:00
+++ 1.88/sql/set_var.h	2006-06-21 17:50:27 +02:00
@@ -262,7 +262,7 @@
 
 class sys_var_enum :public sys_var
 {
-  uint	*value; 
+  uint *value;
   TYPELIB *enum_names;
 public:
   sys_var_enum(const char *name_arg, uint *value_arg,
@@ -772,6 +772,38 @@
 };
 
 
+class sys_var_log_state :public sys_var_bool_ptr
+{
+  uint log_type;
+public:
+  sys_var_log_state(const char *name_arg, my_bool *value_arg, uint log_type_arg)
+    :sys_var_bool_ptr(name_arg, value_arg), log_type(log_type_arg) {}
+  bool update(THD *thd, set_var *var);
+  void set_default(THD *thd, enum_var_type type);
+};
+
+
+class sys_var_log_output :public sys_var
+{
+  uint *value;
+  TYPELIB *enum_names;
+public:
+  sys_var_log_output(const char *name_arg, uint *value_arg,
+                     TYPELIB *typelib, sys_after_update_func func)
+    :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
+  {}
+  bool check(THD *thd, set_var *var)
+  {
+    return check_set(thd, var, enum_names);
+  }
+  bool update(THD *thd, set_var *var);
+  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
+  bool check_update_type(Item_result type) { return 0; }
+  void set_default(THD *thd, enum_var_type type);
+  SHOW_TYPE type() { return SHOW_CHAR; }
+};
+
+
 /* Variable that you can only read from */
 
 class sys_var_readonly: public sys_var
@@ -1072,6 +1104,8 @@
 CHARSET_INFO *get_old_charset_by_name(const char *old_name);
 gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
 		NAMED_LIST **found);
+
+extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path;
 
 /* key_cache functions */
 KEY_CACHE *get_key_cache(LEX_STRING *cache_name);