~tsarev/percona-server/slow_extended_tests_fixes

# name       : userstat.patch

# introduced : 11 or before

# maintainer : Yasufumi

#

#!!! notice !!!

# Any small change to this file in the main branch

# should be done or reviewed by the maintainer!

diff -ruN a/configure b/configure

--- a/configure	2010-08-27 14:28:05.621275596 +0900

+++ b/configure	2010-08-27 15:10:33.736074033 +0900

@@ -38009,7 +38009,7 @@

   realpath rename rint rwlock_init setupterm \

   shmget shmat shmdt shmctl sigaction sigemptyset sigaddset \

   sighold sigset sigthreadmask port_create sleep \

-  snprintf socket stpcpy strcasecmp strerror strsignal strnlen strpbrk strstr \

+  snprintf socket strsep stpcpy strcasecmp strerror strsignal strnlen strpbrk strstr \

   strtol strtoll strtoul strtoull tell tempnam thr_setconcurrency vidattr \

   posix_fallocate backtrace backtrace_symbols backtrace_symbols_fd printstack

 do

diff -ruN a/configure.in b/configure.in

--- a/configure.in	2010-08-04 02:24:24.000000000 +0900

+++ b/configure.in	2010-08-27 15:10:33.737073307 +0900

@@ -2086,7 +2086,7 @@

   realpath rename rint rwlock_init setupterm \

   shmget shmat shmdt shmctl sigaction sigemptyset sigaddset \

   sighold sigset sigthreadmask port_create sleep \

-  snprintf socket stpcpy strcasecmp strerror strsignal strnlen strpbrk strstr \

+  snprintf socket strsep stpcpy strcasecmp strerror strsignal strnlen strpbrk strstr \

   strtol strtoll strtoul strtoull tell tempnam thr_setconcurrency vidattr \

   posix_fallocate backtrace backtrace_symbols backtrace_symbols_fd printstack)

diff -ruN a/include/config.h.in b/include/config.h.in

--- a/include/config.h.in	2010-08-04 02:28:40.000000000 +0900

+++ b/include/config.h.in	2010-08-27 15:10:33.740077919 +0900

@@ -802,6 +802,9 @@

 /* Define to 1 if you have the <stdlib.h> header file. */

 #undef HAVE_STDLIB_H

+/* Define to 1 if you have the `strsep' function. */

+#undef HAVE_STRSEP

+

 /* Define to 1 if you have the `stpcpy' function. */

 #undef HAVE_STPCPY

diff -ruN a/include/mysql/plugin.h b/include/mysql/plugin.h

--- a/include/mysql/plugin.h	2010-08-27 14:38:08.682439958 +0900

+++ b/include/mysql/plugin.h	2010-08-27 15:10:33.742003842 +0900

@@ -705,6 +705,9 @@

 unsigned long thd_log_slow_verbosity(const MYSQL_THD thd);

 int thd_opt_slow_log();

 #define EXTENDED_SLOWLOG

+

+#define EXTENDED_FOR_USERSTAT

+

 /**

   Create a temporary file.

diff -ruN a/include/mysql_com.h b/include/mysql_com.h

--- a/include/mysql_com.h	2010-08-04 02:24:30.000000000 +0900

+++ b/include/mysql_com.h	2010-08-27 15:10:33.743072186 +0900

@@ -29,6 +29,7 @@

 #define SERVER_VERSION_LENGTH 60

 #define SQLSTATE_LENGTH 5

+#define LIST_PROCESS_HOST_LEN 64

 /*

   USER_HOST_BUFF_SIZE -- length of string buffer, that is enough to contain

@@ -115,6 +116,12 @@

 					   thread */

 #define REFRESH_MASTER          128     /* Remove all bin logs in the index

 					   and truncate the index */

+#define REFRESH_TABLE_STATS     256     /* Refresh table stats hash table */

+#define REFRESH_INDEX_STATS     512     /* Refresh index stats hash table */

+#define REFRESH_USER_STATS      1024    /* Refresh user stats hash table */

+#define REFRESH_SLOW_QUERY_LOG  2048    /* Flush slow query log and rotate*/

+#define REFRESH_CLIENT_STATS    4096    /* Refresh client stats hash table */

+#define REFRESH_THREAD_STATS    8192    /* Refresh thread stats hash table */

 /* The following can't be set with mysql_refresh() */

 #define REFRESH_READ_LOCK	16384	/* Lock tables for read */

diff -ruN a/patch_info/userstats.info b/patch_info/userstats.info

--- /dev/null	1970-01-01 09:00:00.000000000 +0900

+++ b/patch_info/userstats.info	2010-08-27 15:10:33.744161257 +0900

@@ -0,0 +1,11 @@

+File=userstats.patch

+Name=SHOW USER/TABLE/INDEX statistics

+Version=V2

+Author=Google

+License=GPL

+Comment=Added INFORMATION_SCHEMA.*_STATISTICS

+2008-12-01

+YK: fix behavior for prepared statements

+

+2008-11-26

+YK: add switch variable "userstat_running" to control INFORMATION_SCHEMA.*_STATISTICS (default:OFF)

diff -ruN a/sql/handler.cc b/sql/handler.cc

--- a/sql/handler.cc	2010-08-04 02:24:27.000000000 +0900

+++ b/sql/handler.cc	2010-08-27 15:10:33.749058856 +0900

@@ -1194,6 +1194,8 @@

     if (cookie)

       tc_log->unlog(cookie, xid);

     DBUG_EXECUTE_IF("crash_commit_after", abort(););

+    if (is_real_trans)

+      thd->diff_commit_trans++;

 end:

     if (rw_trans)

       start_waiting_global_read_lock(thd);

@@ -1324,6 +1326,8 @@

   /* Always cleanup. Even if there nht==0. There may be savepoints. */

   if (is_real_trans)

     thd->transaction.cleanup();

+

+  thd->diff_rollback_trans++;

 #endif /* USING_TRANSACTIONS */

   if (all)

     thd->transaction_rollback_request= FALSE;

@@ -1762,6 +1766,7 @@

     ha_info->reset(); /* keep it conveniently zero-filled */

   }

   trans->ha_list= sv->ha_list;

+  thd->diff_rollback_trans++;

   DBUG_RETURN(error);

 }

@@ -2122,6 +2127,8 @@

       dup_ref=ref+ALIGN_SIZE(ref_length);

     cached_table_flags= table_flags();

   }

+  rows_read = rows_changed = 0;

+  memset(index_rows_read, 0, sizeof(index_rows_read));

   DBUG_RETURN(error);

 }

@@ -3571,6 +3578,111 @@

   return;

 }

+// Updates the global table stats with the TABLE this handler represents.

+void handler::update_global_table_stats() {

+  if (!opt_userstat_running) {

+    rows_read = rows_changed = 0;

+    return;

+  }

+

+  if (!rows_read && !rows_changed) return;  // Nothing to update.

+  // table_cache_key is db_name + '\0' + table_name + '\0'.

+  if (!table->s || !table->s->table_cache_key.str || !table->s->table_name.str) return;

+

+  TABLE_STATS* table_stats;

+  char key[NAME_LEN * 2 + 2];

+  // [db] + '.' + [table]

+  sprintf(key, "%s.%s", table->s->table_cache_key.str, table->s->table_name.str);

+

+  pthread_mutex_lock(&LOCK_global_table_stats);

+  // Gets the global table stats, creating one if necessary.

+  if (!(table_stats = (TABLE_STATS*)hash_search(&global_table_stats,

+                                                (uchar*)key,

+                                                strlen(key)))) {

+    if (!(table_stats = ((TABLE_STATS*)

+                         my_malloc(sizeof(TABLE_STATS), MYF(MY_WME | MY_ZEROFILL))))) {

+      // Out of memory.

+      sql_print_error("Allocating table stats failed.");

+      goto end;

+    }

+    strncpy(table_stats->table, key, sizeof(table_stats->table));

+    table_stats->rows_read = 0;

+    table_stats->rows_changed = 0;

+    table_stats->rows_changed_x_indexes = 0;

+    table_stats->engine_type = (int) ht->db_type;

+

+    if (my_hash_insert(&global_table_stats, (uchar*)table_stats)) {

+      // Out of memory.

+      sql_print_error("Inserting table stats failed.");

+      my_free((char*)table_stats, 0);

+      goto end;

+    }

+  }

+  // Updates the global table stats.

+  table_stats->rows_read += rows_read;

+  table_stats->rows_changed += rows_changed;

+  table_stats->rows_changed_x_indexes +=

+      rows_changed * (table->s->keys ? table->s->keys : 1);

+  current_thd->diff_total_read_rows += rows_read;

+  rows_read = rows_changed = 0;

+end:

+  pthread_mutex_unlock(&LOCK_global_table_stats);

+}

+

+// Updates the global index stats with this handler's accumulated index reads.

+void handler::update_global_index_stats() {

+  // table_cache_key is db_name + '\0' + table_name + '\0'.

+  if (!table->s || !table->s->table_cache_key.str || !table->s->table_name.str) return;

+

+  if (!opt_userstat_running) {

+    for (uint x = 0; x < table->s->keys; x++) {

+      index_rows_read[x] = 0;

+    }

+    return;

+  }

+

+  for (uint x = 0; x < table->s->keys; x++) {

+    if (index_rows_read[x]) {

+      // Rows were read using this index.

+      KEY* key_info = &table->key_info[x];

+

+      if (!key_info->name) continue;

+

+      INDEX_STATS* index_stats;

+      char key[NAME_LEN * 3 + 3];

+      // [db] + '.' + [table] + '.' + [index]

+      sprintf(key, "%s.%s.%s",  table->s->table_cache_key.str,

+              table->s->table_name.str, key_info->name);

+

+      pthread_mutex_lock(&LOCK_global_index_stats);

+      // Gets the global index stats, creating one if necessary.

+      if (!(index_stats = (INDEX_STATS*)hash_search(&global_index_stats,

+                                                    (uchar*)key,

+                                                    strlen(key)))) {

+        if (!(index_stats = ((INDEX_STATS*)

+                             my_malloc(sizeof(INDEX_STATS), MYF(MY_WME | MY_ZEROFILL))))) {

+          // Out of memory.

+          sql_print_error("Allocating index stats failed.");

+          goto end;

+        }

+        strncpy(index_stats->index, key, sizeof(index_stats->index));

+        index_stats->rows_read = 0;

+

+        if (my_hash_insert(&global_index_stats, (uchar*)index_stats)) {

+          // Out of memory.

+          sql_print_error("Inserting index stats failed.");

+          my_free((char*)index_stats, 0);

+          goto end;

+        }

+      }

+      // Updates the global index stats.

+      index_stats->rows_read += index_rows_read[x];

+      index_rows_read[x] = 0;

+end:

+      pthread_mutex_unlock(&LOCK_global_index_stats);

+    }

+  }

+}

 /****************************************************************************

 ** Some general functions that isn't in the handler class

diff -ruN a/sql/handler.h b/sql/handler.h

--- a/sql/handler.h	2010-08-04 02:24:27.000000000 +0900

+++ b/sql/handler.h	2010-08-27 15:10:33.753058869 +0900

@@ -30,6 +30,10 @@

 #define USING_TRANSACTIONS

+#if MAX_KEY > 128

+#error MAX_KEY is too large.  Values up to 128 are supported.

+#endif

+

 // the following is for checking tables

 #define HA_ADMIN_ALREADY_DONE	  1

@@ -1121,6 +1125,9 @@

   bool locked;

   bool implicit_emptied;                /* Can be !=0 only if HEAP */

   const COND *pushed_cond;

+  ulonglong rows_read;

+  ulonglong rows_changed;

+  ulonglong index_rows_read[MAX_KEY];

   /**

     next_insert_id is the next value which should be inserted into the

     auto_increment column: in a inserting-multi-row statement (like INSERT

@@ -1158,9 +1165,11 @@

     ref_length(sizeof(my_off_t)),

     ft_handler(0), inited(NONE),

     locked(FALSE), implicit_emptied(0),

-    pushed_cond(0), next_insert_id(0), insert_id_for_cur_row(0),

+    pushed_cond(0), rows_read(0), rows_changed(0), next_insert_id(0), insert_id_for_cur_row(0),

     auto_inc_intervals_count(0)

-    {}

+    {

+      memset(index_rows_read, 0, sizeof(index_rows_read));

+    }

   virtual ~handler(void)

   {

     DBUG_ASSERT(locked == FALSE);

@@ -1284,6 +1293,8 @@

   {

     table= table_arg;

     table_share= share;

+    rows_read = rows_changed = 0;

+    memset(index_rows_read, 0, sizeof(index_rows_read));

   }

   virtual double scan_time()

   { return ulonglong2double(stats.data_file_length) / IO_SIZE + 2; }

@@ -1628,6 +1639,8 @@

   virtual bool is_crashed() const  { return 0; }

   virtual bool auto_repair() const { return 0; }

+  void update_global_table_stats();

+  void update_global_index_stats();

 #define CHF_CREATE_FLAG 0

 #define CHF_DELETE_FLAG 1

diff -ruN a/sql/lex.h b/sql/lex.h

--- a/sql/lex.h	2010-08-27 14:29:26.009071592 +0900

+++ b/sql/lex.h	2010-08-27 15:10:33.755063742 +0900

@@ -106,6 +106,7 @@

   { "CHECKSUM",		SYM(CHECKSUM_SYM)},

   { "CIPHER",		SYM(CIPHER_SYM)},

   { "CLIENT",		SYM(CLIENT_SYM)},

+  { "CLIENT_STATISTICS",	SYM(CLIENT_STATS_SYM)},

   { "CLOSE",		SYM(CLOSE_SYM)},

   { "COALESCE",		SYM(COALESCE)},

   { "CODE",             SYM(CODE_SYM)},

@@ -245,6 +246,7 @@

   { "IN",		SYM(IN_SYM)},

   { "INDEX",		SYM(INDEX_SYM)},

   { "INDEXES",		SYM(INDEXES)},

+  { "INDEX_STATISTICS",	SYM(INDEX_STATS_SYM)},

   { "INFILE",		SYM(INFILE)},

   { "INITIAL_SIZE",	SYM(INITIAL_SIZE_SYM)},

   { "INNER",		SYM(INNER_SYM)},

@@ -478,6 +480,7 @@

   { "SIGNED",		SYM(SIGNED_SYM)},

   { "SIMPLE",		SYM(SIMPLE_SYM)},

   { "SLAVE",            SYM(SLAVE)},

+  { "SLOW",             SYM(SLOW_SYM)},

   { "SNAPSHOT",         SYM(SNAPSHOT_SYM)},

   { "SMALLINT",		SYM(SMALLINT)},

   { "SOCKET",		SYM(SOCKET_SYM)},

@@ -527,12 +530,14 @@

   { "TABLES",		SYM(TABLES)},

   { "TABLESPACE",	        SYM(TABLESPACE)},

   { "TABLE_CHECKSUM",	SYM(TABLE_CHECKSUM_SYM)},

+  { "TABLE_STATISTICS",	SYM(TABLE_STATS_SYM)},

   { "TEMPORARY",	SYM(TEMPORARY)},

   { "TEMPTABLE",	SYM(TEMPTABLE_SYM)},

   { "TERMINATED",	SYM(TERMINATED)},

   { "TEXT",		SYM(TEXT_SYM)},

   { "THAN",             SYM(THAN_SYM)},

   { "THEN",		SYM(THEN_SYM)},

+  { "THREAD_STATISTICS",	SYM(THREAD_STATS_SYM)},

   { "TIME",		SYM(TIME_SYM)},

   { "TIMESTAMP",	SYM(TIMESTAMP)},

   { "TIMESTAMPADD",     SYM(TIMESTAMP_ADD)},

@@ -568,6 +573,7 @@

   { "USE",		SYM(USE_SYM)},

   { "USER",		SYM(USER)},

   { "USER_RESOURCES",	SYM(RESOURCES)},

+  { "USER_STATISTICS",	SYM(USER_STATS_SYM)},

   { "USE_FRM",		SYM(USE_FRM)},

   { "USING",		SYM(USING)},

   { "UTC_DATE",         SYM(UTC_DATE_SYM)},

diff -ruN a/sql/log.cc b/sql/log.cc

--- a/sql/log.cc	2010-08-27 14:43:41.986138797 +0900

+++ b/sql/log.cc	2010-08-27 15:10:33.761058932 +0900

@@ -826,6 +826,13 @@

     mysql_slow_log.reopen_file();

 }

+void Log_to_file_event_handler::flush_slow_log()

+{

+  /* reopen slow log file */

+  if (opt_slow_log)

+    mysql_slow_log.reopen_file();

+}

+

 /*

   Log error with all enabled log event handlers

@@ -937,6 +944,21 @@

   return rc;

 }

+bool LOGGER::flush_slow_log(THD *thd)

+{

+  /*

+    Now we lock logger, as nobody should be able to use logging routines while

+    log tables are closed

+  */

+  logger.lock_exclusive();

+

+  /* reopen log files */

+  file_log_handler->flush_slow_log();

+

+  /* end of log flush */

+  logger.unlock();

+  return 0;

+}

 /*

   Log slow query with all enabled log event handlers

@@ -4491,6 +4513,8 @@

                              thd->first_successful_insert_id_in_prev_stmt_for_binlog);

           if (e.write(file))

             goto err;

+          if (file == &log_file)

+            thd->binlog_bytes_written += e.data_written;

         }

         if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0)

         {

@@ -4502,12 +4526,16 @@

                              minimum());

           if (e.write(file))

             goto err;

+          if (file == &log_file)

+            thd->binlog_bytes_written += e.data_written;

         }

         if (thd->rand_used)

         {

           Rand_log_event e(thd,thd->rand_saved_seed1,thd->rand_saved_seed2);

           if (e.write(file))

             goto err;

+          if (file == &log_file)

+            thd->binlog_bytes_written += e.data_written;

         }

         if (thd->user_var_events.elements)

         {

@@ -4523,6 +4551,8 @@

                                  user_var_event->charset_number);

             if (e.write(file))

               goto err;

+            if (file == &log_file)

+              thd->binlog_bytes_written += e.data_written;

           }

         }

       }

@@ -4535,6 +4565,8 @@

     if (event_info->write(file) || 

         DBUG_EVALUATE_IF("injecting_fault_writing", 1, 0))

       goto err;

+    if (file == &log_file)

+      thd->binlog_bytes_written += event_info->data_written;

     if (file == &log_file) // we are writing to the real log (disk)

     {

@@ -4680,7 +4712,7 @@

     be reset as a READ_CACHE to be able to read the contents from it.

  */

-int MYSQL_BIN_LOG::write_cache(IO_CACHE *cache, bool lock_log, bool sync_log)

+int MYSQL_BIN_LOG::write_cache(THD *thd, IO_CACHE *cache, bool lock_log, bool sync_log)

 {

   Mutex_sentry sentry(lock_log ? &LOCK_log : NULL);

@@ -4728,6 +4760,7 @@

       /* write the first half of the split header */

       if (my_b_write(&log_file, header, carry))

         return ER_ERROR_ON_WRITE;

+      thd->binlog_bytes_written += carry;

       /*

         copy fixed second half of header to cache so the correct

@@ -4796,6 +4829,7 @@

     /* Write data to the binary log file */

     if (my_b_write(&log_file, cache->read_pos, length))

       return ER_ERROR_ON_WRITE;

+    thd->binlog_bytes_written += length;

     cache->read_pos=cache->read_end;		// Mark buffer used up

   } while ((length= my_b_fill(cache)));

@@ -4918,21 +4952,24 @@

       */

       if (qinfo.write(&log_file))

         goto err;

+      thd->binlog_bytes_written += qinfo.data_written;

       DBUG_EXECUTE_IF("crash_before_writing_xid",

                       {

-                        if ((write_error= write_cache(cache, false, true)))

+                        if ((write_error= write_cache(thd, cache, false, true)))

                           DBUG_PRINT("info", ("error writing binlog cache: %d",

                                                write_error));

                         DBUG_PRINT("info", ("crashing before writing xid"));

                         abort();

                       });

-      if ((write_error= write_cache(cache, false, false)))

+      if ((write_error= write_cache(thd, cache, false, false)))

         goto err;

       if (commit_event && commit_event->write(&log_file))

         goto err;

+      if (commit_event)

+        thd->binlog_bytes_written += commit_event->data_written;

       if (incident && write_incident(thd, FALSE))

         goto err;

diff -ruN a/sql/log.h b/sql/log.h

--- a/sql/log.h	2010-08-27 14:38:08.690071101 +0900

+++ b/sql/log.h	2010-08-27 15:13:33.762976324 +0900

@@ -361,7 +361,7 @@

   bool write(THD *thd, IO_CACHE *cache, Log_event *commit_event, bool incident);

   bool write_incident(THD *thd, bool lock);

-  int  write_cache(IO_CACHE *cache, bool lock_log, bool flush_and_sync);

+  int  write_cache(THD *thd, IO_CACHE *cache, bool lock_log, bool flush_and_sync);

   void set_write_error(THD *thd);

   bool check_write_error(THD *thd);

@@ -499,6 +499,7 @@

                            const char *sql_text, uint sql_text_len,

                            CHARSET_INFO *client_cs);

   void flush();

+  void flush_slow_log();

   void init_pthread_objects();

   MYSQL_QUERY_LOG *get_mysql_slow_log() { return &mysql_slow_log; }

   MYSQL_QUERY_LOG *get_mysql_log() { return &mysql_log; }

@@ -543,6 +544,7 @@

   void init_base();

   void init_log_tables();

   bool flush_logs(THD *thd);

+  bool flush_slow_log(THD *thd);

   /* Perform basic logger cleanup. this will leave e.g. error log open. */

   void cleanup_base();

   /* Free memory. Nothing could be logged after this function is called */

diff -ruN a/sql/mysql_priv.h b/sql/mysql_priv.h

--- a/sql/mysql_priv.h	2010-08-27 14:38:08.699057407 +0900

+++ b/sql/mysql_priv.h	2010-08-27 15:10:33.805058568 +0900

@@ -1139,7 +1139,17 @@

 bool multi_delete_set_locks_and_link_aux_tables(LEX *lex);

 void init_max_user_conn(void);

 void init_update_queries(void);

+void init_global_user_stats(void);

+void init_global_table_stats(void);

+void init_global_index_stats(void);

+void init_global_client_stats(void);

+void init_global_thread_stats(void);

 void free_max_user_conn(void);

+void free_global_user_stats(void);

+void free_global_table_stats(void);

+void free_global_index_stats(void);

+void free_global_client_stats(void);

+void free_global_thread_stats(void);

 pthread_handler_t handle_bootstrap(void *arg);

 int mysql_execute_command(THD *thd);

 bool do_command(THD *thd);

@@ -2014,6 +2024,7 @@

 extern ulong max_connect_errors, connect_timeout;

 extern ulong slave_net_timeout, slave_trans_retries;

 extern uint max_user_connections;

+extern ulonglong denied_connections;

 extern ulong what_to_log,flush_time;

 extern ulong query_buff_size;

 extern ulong max_prepared_stmt_count, prepared_stmt_count;

@@ -2067,6 +2078,7 @@

 extern my_bool opt_slave_compressed_protocol, use_temp_pool;

 extern ulong slave_exec_mode_options;

 extern my_bool opt_readonly, lower_case_file_system;

+extern my_bool opt_userstat_running, opt_thread_statistics;

 extern my_bool opt_enable_named_pipe, opt_sync_frm, opt_allow_suspicious_udfs;

 extern my_bool opt_secure_auth;

 extern char* opt_secure_file_priv;

@@ -2131,6 +2143,15 @@

 extern struct system_variables max_system_variables;

 extern struct system_status_var global_status_var;

 extern struct rand_struct sql_rand;

+extern HASH global_user_stats;

+extern HASH global_client_stats;

+extern HASH global_thread_stats;

+extern pthread_mutex_t LOCK_global_user_client_stats;

+extern HASH global_table_stats;

+extern pthread_mutex_t LOCK_global_table_stats;

+extern HASH global_index_stats;

+extern pthread_mutex_t LOCK_global_index_stats;

+extern pthread_mutex_t LOCK_stats;

 extern const char *opt_date_time_formats[];

 extern KNOWN_DATE_TIME_FORMAT known_date_time_formats[];

diff -ruN a/sql/mysqld.cc b/sql/mysqld.cc

--- a/sql/mysqld.cc	2010-08-27 14:43:41.996021369 +0900

+++ b/sql/mysqld.cc	2010-08-27 15:10:33.772058694 +0900

@@ -533,6 +533,7 @@

 uint    opt_debug_sync_timeout= 0;

 #endif /* defined(ENABLED_DEBUG_SYNC) */

 my_bool opt_old_style_user_limits= 0, trust_function_creators= 0;

+my_bool opt_userstat_running= 0, opt_thread_statistics= 0;

 /*

   True if there is at least one per-hour limit for some user, so we should

   check them before each query (and possibly reset counters when hour is

@@ -581,6 +582,7 @@

 ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;

 ulong max_connections, max_connect_errors;

 uint  max_user_connections= 0;

+ulonglong denied_connections = 0;

 /**

   Limit of the total number of prepared statements in the server.

   Is necessary to protect the server against out-of-memory attacks.

@@ -682,6 +684,10 @@

 	        LOCK_global_system_variables,

 		LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,

                 LOCK_connection_count;

+pthread_mutex_t LOCK_stats;

+pthread_mutex_t LOCK_global_user_client_stats;

+pthread_mutex_t LOCK_global_table_stats;

+pthread_mutex_t LOCK_global_index_stats;

 /**

   The below lock protects access to two global server variables:

   max_prepared_stmt_count and prepared_stmt_count. These variables

@@ -1367,6 +1373,11 @@

   x_free(opt_secure_file_priv);

   bitmap_free(&temp_pool);

   free_max_user_conn();

+  free_global_user_stats();

+  free_global_client_stats();

+  free_global_thread_stats();

+  free_global_table_stats();

+  free_global_index_stats();

 #ifdef HAVE_REPLICATION

   end_slave_list();

 #endif

@@ -1483,6 +1494,10 @@

   (void) pthread_cond_destroy(&COND_thread_cache);

   (void) pthread_cond_destroy(&COND_flush_thread_cache);

   (void) pthread_cond_destroy(&COND_manager);

+  (void) pthread_mutex_destroy(&LOCK_stats);

+  (void) pthread_mutex_destroy(&LOCK_global_user_client_stats);

+  (void) pthread_mutex_destroy(&LOCK_global_table_stats);

+  (void) pthread_mutex_destroy(&LOCK_global_index_stats);

 }

 #endif /*EMBEDDED_LIBRARY*/

@@ -3172,6 +3187,7 @@

   {"show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},

   {"show_binlogs",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},

   {"show_charsets",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},

+  {"show_client_statistics",(char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CLIENT_STATS]), SHOW_LONG_STATUS},

   {"show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},

   {"show_column_types",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLUMN_TYPES]), SHOW_LONG_STATUS},

   {"show_contributors",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CONTRIBUTORS]), SHOW_LONG_STATUS},

@@ -3193,6 +3209,7 @@

 #endif

   {"show_function_status", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS_FUNC]), SHOW_LONG_STATUS},

   {"show_grants",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_GRANTS]), SHOW_LONG_STATUS},

+  {"show_index_statistics",(char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_INDEX_STATS]), SHOW_LONG_STATUS},

   {"show_keys",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_KEYS]), SHOW_LONG_STATUS},

   {"show_master_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_MASTER_STAT]), SHOW_LONG_STATUS},

   {"show_new_master",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_NEW_MASTER]), SHOW_LONG_STATUS},

@@ -3211,9 +3228,12 @@

   {"show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},

   {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},

   {"show_storage_engines", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STORAGE_ENGINES]), SHOW_LONG_STATUS},

+  {"show_table_statistics",(char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATS]), SHOW_LONG_STATUS},

   {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},

   {"show_tables",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLES]), SHOW_LONG_STATUS},

+  {"show_thread_statistics",(char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_THREAD_STATS]), SHOW_LONG_STATUS},

   {"show_triggers",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TRIGGERS]), SHOW_LONG_STATUS},

+  {"show_user_statistics", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_USER_STATS]), SHOW_LONG_STATUS},

   {"show_variables",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_VARIABLES]), SHOW_LONG_STATUS},

   {"show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},

   {"slave_start",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_START]), SHOW_LONG_STATUS},

@@ -3652,6 +3672,10 @@

 #endif

   (void) pthread_mutex_init(&LOCK_server_started, MY_MUTEX_INIT_FAST);

   (void) pthread_cond_init(&COND_server_started,NULL);

+  (void) pthread_mutex_init(&LOCK_stats, MY_MUTEX_INIT_FAST);

+  (void) pthread_mutex_init(&LOCK_global_user_client_stats, MY_MUTEX_INIT_FAST);

+  (void) pthread_mutex_init(&LOCK_global_table_stats, MY_MUTEX_INIT_FAST);

+  (void) pthread_mutex_init(&LOCK_global_index_stats, MY_MUTEX_INIT_FAST);

   sp_cache_init();

 #ifdef HAVE_EVENT_SCHEDULER

   Events::init_mutexes();

@@ -4053,6 +4077,9 @@

   if (!errmesg[0][0])

     unireg_abort(1);

+  init_global_table_stats();

+  init_global_index_stats();

+

   /* We have to initialize the storage engines before CSV logging */

   if (ha_init())

   {

@@ -4199,6 +4226,9 @@

   init_max_user_conn();

   init_update_queries();

+  init_global_user_stats();

+  init_global_client_stats();

+  init_global_thread_stats();

   DBUG_RETURN(0);

 }

@@ -5016,6 +5046,7 @@

     DBUG_PRINT("error",("Too many connections"));

     close_connection(thd, ER_CON_COUNT_ERROR, 1);

+    statistic_increment(denied_connections, &LOCK_status);

     delete thd;

     DBUG_VOID_RETURN;

   }

@@ -5800,6 +5831,8 @@

   OPT_SLAVE_EXEC_MODE,

   OPT_GENERAL_LOG_FILE,

   OPT_SLOW_QUERY_LOG_FILE,

+  OPT_USERSTAT_RUNNING,

+  OPT_THREAD_STATISTICS,

   OPT_USE_GLOBAL_LONG_QUERY_TIME,

   OPT_USE_GLOBAL_LOG_SLOW_CONTROL,

   OPT_SLOW_QUERY_LOG_MICROSECONDS_TIMESTAMP,

@@ -7292,6 +7325,14 @@

    &max_system_variables.net_wait_timeout, 0, GET_ULONG,

    REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),

    0, 1, 0},

+  {"userstat_running", OPT_USERSTAT_RUNNING,

+   "Control USER_STATISTICS, CLIENT_STATISTICS, THREAD_STATISTICS, INDEX_STATISTICS and TABLE_STATISTICS running",

+   (uchar**) &opt_userstat_running, (uchar**) &opt_userstat_running,

+   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

+  {"thread_statistics", OPT_THREAD_STATISTICS,

+   "Control TABLE_STATISTICS running, when userstat_running is enabled",

+   (uchar**) &opt_thread_statistics, (uchar**) &opt_thread_statistics,

+   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},

   {"binlog-direct-non-transactional-updates", OPT_BINLOG_DIRECT_NON_TRANS_UPDATE,

    "Causes updates to non-transactional engines using statement format to be "

    "written directly to binary log. Before using this option, make sure that "

diff -ruN a/sql/set_var.cc b/sql/set_var.cc

--- a/sql/set_var.cc	2010-08-27 14:43:42.004008722 +0900

+++ b/sql/set_var.cc	2010-08-27 15:10:33.809988740 +0900

@@ -554,6 +554,10 @@

 static sys_var_thd_ulong	sys_read_buff_size(&vars, "read_buffer_size",

 					   &SV::read_buff_size);

 static sys_var_opt_readonly	sys_readonly(&vars, "read_only", &opt_readonly);

+static sys_var_bool_ptr		sys_userstat_running(&vars, "userstat_running",

+						     &opt_userstat_running);

+static sys_var_bool_ptr		sys_thread_statistics(&vars, "thread_statistics",

+						      &opt_thread_statistics);

 static sys_var_thd_ulong	sys_read_rnd_buff_size(&vars, "read_rnd_buffer_size",

 					       &SV::read_rnd_buff_size);

 static sys_var_thd_ulong	sys_div_precincrement(&vars, "div_precision_increment",

diff -ruN a/sql/sql_base.cc b/sql/sql_base.cc

--- a/sql/sql_base.cc	2010-08-04 02:24:34.000000000 +0900

+++ b/sql/sql_base.cc	2010-08-27 15:10:33.818058934 +0900

@@ -1382,6 +1382,12 @@

   DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str,

                         table->s->table_name.str, (long) table));

+  if(table->file)

+  {

+    table->file->update_global_table_stats();

+    table->file->update_global_index_stats();

+  }

+

   *table_ptr=table->next;

   /*

     When closing a MERGE parent or child table, detach the children first.

@@ -1922,6 +1928,8 @@

   DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'",

                           table->s->db.str, table->s->table_name.str));

+  table->file->update_global_table_stats();

+  table->file->update_global_index_stats();

   free_io_cache(table);

   closefrm(table, 0);

   if (delete_table)

diff -ruN a/sql/sql_class.cc b/sql/sql_class.cc

--- a/sql/sql_class.cc	2010-08-27 14:38:08.741990000 +0900

+++ b/sql/sql_class.cc	2010-08-27 15:10:33.825058007 +0900

@@ -704,6 +704,13 @@

   mysys_var=0;

   binlog_evt_union.do_union= FALSE;

   enable_slow_log= 0;

+  busy_time = 0;

+  cpu_time = 0;

+  bytes_received = 0;

+  bytes_sent = 0;

+  binlog_bytes_written = 0;

+  updated_row_count = 0;

+  sent_row_count_2 = 0;

 #ifndef DBUG_OFF

   dbug_sentry=THD_SENTRY_MAGIC;

 #endif

@@ -907,6 +914,7 @@

   reset_current_stmt_binlog_row_based();

   bzero((char *) &status_var, sizeof(status_var));

   sql_log_bin_toplevel= options & OPTION_BIN_LOG;

+  reset_stats();

 #if defined(ENABLED_DEBUG_SYNC)

   /* Initialize the Debug Sync Facility. See debug_sync.cc. */

@@ -914,6 +922,84 @@

 #endif /* defined(ENABLED_DEBUG_SYNC) */

 }

+// Resets stats in a THD.

+void THD::reset_stats(void) {

+  current_connect_time = time(NULL);

+  last_global_update_time = current_connect_time;

+  reset_diff_stats();

+}

+

+// Resets the 'diff' stats, which are used to update global stats.

+void THD::reset_diff_stats(void) {

+  diff_total_busy_time = 0;

+  diff_total_cpu_time = 0;

+  diff_total_bytes_received = 0;

+  diff_total_bytes_sent = 0;

+  diff_total_binlog_bytes_written = 0;

+  diff_total_sent_rows = 0;

+  diff_total_updated_rows = 0;

+  diff_total_read_rows = 0;

+  diff_select_commands = 0;

+  diff_update_commands = 0;

+  diff_other_commands = 0;

+  diff_commit_trans = 0;

+  diff_rollback_trans = 0;

+  diff_denied_connections = 0;

+  diff_lost_connections = 0;

+  diff_access_denied_errors = 0;

+  diff_empty_queries = 0;

+}

+

+// Updates 'diff' stats of a THD.

+void THD::update_stats(bool ran_command) {

+  if (opt_userstat_running) {

+  diff_total_busy_time += busy_time;

+  diff_total_cpu_time += cpu_time;

+  diff_total_bytes_received += bytes_received;

+  diff_total_bytes_sent += bytes_sent;

+  diff_total_binlog_bytes_written += binlog_bytes_written;

+  diff_total_sent_rows += sent_row_count_2;

+  diff_total_updated_rows += updated_row_count;

+  // diff_total_read_rows is updated in handler.cc.

+

+  if (ran_command) {

+    // The replication thread has the COM_CONNECT command.

+    if ((old_command == COM_QUERY || command == COM_CONNECT) &&

+        (lex->sql_command >= 0 && lex->sql_command < SQLCOM_END)) {

+      // A SQL query.

+      if (lex->sql_command == SQLCOM_SELECT) {

+        diff_select_commands++;

+        if (!sent_row_count_2)

+          diff_empty_queries++;

+      } else if (! sql_command_flags[lex->sql_command] & CF_STATUS_COMMAND) {

+        // 'SHOW ' commands become SQLCOM_SELECT.

+        diff_other_commands++;

+        // 'SHOW ' commands shouldn't inflate total sent row count.

+        diff_total_sent_rows -= sent_row_count_2;

+      } else if (is_update_query(lex->sql_command)) {

+        diff_update_commands++;

+      } else {

+        diff_other_commands++;

+      }

+    }

+  }

+  // diff_commit_trans is updated in handler.cc.

+  // diff_rollback_trans is updated in handler.cc.

+  // diff_denied_connections is updated in sql_parse.cc.

+  // diff_lost_connections is updated in sql_parse.cc.

+  // diff_access_denied_errors is updated in sql_parse.cc.

+

+  /* reset counters to zero to avoid double-counting since values

+     are already store in diff_total_*. */

+  }

+  busy_time = 0;

+  cpu_time = 0;

+  bytes_received = 0;

+  bytes_sent = 0;

+  binlog_bytes_written = 0;

+  updated_row_count = 0;

+  sent_row_count_2 = 0;

+}

 /*

   Init THD for query processing.

@@ -1545,6 +1631,32 @@

 }

 #endif

+char *THD::get_client_host_port(THD *client)

+{

+  Security_context *client_sctx= client->security_ctx;

+  char *client_host= NULL;

+

+  if (client->peer_port && (client_sctx->host || client_sctx->ip) &&

+      security_ctx->host_or_ip[0])

+  {

+    if ((client_host= (char *) this->alloc(LIST_PROCESS_HOST_LEN+1)))

+      my_snprintf((char *) client_host, LIST_PROCESS_HOST_LEN,

+                  "%s:%u", client_sctx->host_or_ip, client->peer_port);

+  }

+  else

+    client_host= this->strdup(client_sctx->host_or_ip[0] ?

+                              client_sctx->host_or_ip :

+                              client_sctx->host ? client_sctx->host : "");

+

+  return client_host;

+}

+

+const char *get_client_host(THD *client)

+{

+  return client->security_ctx->host_or_ip[0] ?

+      client->security_ctx->host_or_ip :

+      client->security_ctx->host ? client->security_ctx->host : "";

+}

 struct Item_change_record: public ilink

 {

@@ -1732,6 +1844,7 @@

     buffer.set(buff, sizeof(buff), &my_charset_bin);

   }

   thd->sent_row_count++;

+  thd->sent_row_count_2++;

   if (thd->is_error())

   {

     protocol->remove_last_row();

@@ -1836,6 +1949,7 @@

 select_export::~select_export()

 {

   thd->sent_row_count=row_count;

+  thd->sent_row_count_2=row_count;

 }

@@ -2868,6 +2982,7 @@

   if (likely(thd != 0))

   { /* current_thd==0 when close_connection() calls net_send_error() */

     thd->status_var.bytes_sent+= length;

+    thd->bytes_sent+= length;

   }

 }

@@ -2875,6 +2990,7 @@

 void thd_increment_bytes_received(ulong length)

 {

   current_thd->status_var.bytes_received+= length;

+  current_thd->bytes_received+= length;

 }

diff -ruN a/sql/sql_class.h b/sql/sql_class.h

--- a/sql/sql_class.h	2010-08-27 14:43:42.008006390 +0900

+++ b/sql/sql_class.h	2010-08-27 15:10:33.830058443 +0900

@@ -1435,6 +1435,8 @@

     first byte of the packet in do_command()

   */

   enum enum_server_command command;

+  // Used to save the command, before it is set to COM_SLEEP.

+  enum enum_server_command old_command;

   uint32     server_id;

   uint32     file_id;			// for LOAD DATA INFILE

   /* remote (peer) port */

@@ -1828,6 +1830,8 @@

   /* variables.transaction_isolation is reset to this after each commit */

   enum_tx_isolation session_tx_isolation;

   enum_check_fields count_cuted_fields;

+  ha_rows    updated_row_count;

+  ha_rows    sent_row_count_2; /* for userstat */

   DYNAMIC_ARRAY user_var_events;        /* For user variables replication */

   MEM_ROOT      *user_var_events_alloc; /* Allocate above array elements here */

@@ -1916,6 +1920,49 @@

   */

   LOG_INFO*  current_linfo;

   NET*       slave_net;			// network connection from slave -> m.

+

+  /*

+    Used to update global user stats.  The global user stats are updated

+    occasionally with the 'diff' variables.  After the update, the 'diff'

+    variables are reset to 0.

+   */

+  // Time when the current thread connected to MySQL.

+  time_t current_connect_time;

+  // Last time when THD stats were updated in global_user_stats.

+  time_t last_global_update_time;

+  // Busy (non-idle) time for just one command.

+  double busy_time;

+  // Busy time not updated in global_user_stats yet.

+  double diff_total_busy_time;

+  // Cpu (non-idle) time for just one thread.

+  double cpu_time;

+  // Cpu time not updated in global_user_stats yet.

+  double diff_total_cpu_time;

+  /* bytes counting */

+  ulonglong bytes_received;

+  ulonglong diff_total_bytes_received;

+  ulonglong bytes_sent;

+  ulonglong diff_total_bytes_sent;

+  ulonglong binlog_bytes_written;

+  ulonglong diff_total_binlog_bytes_written;

+

+  // Number of rows not reflected in global_user_stats yet.

+  ha_rows diff_total_sent_rows, diff_total_updated_rows, diff_total_read_rows;

+  // Number of commands not reflected in global_user_stats yet.

+  ulonglong diff_select_commands, diff_update_commands, diff_other_commands;

+  // Number of transactions not reflected in global_user_stats yet.

+  ulonglong diff_commit_trans, diff_rollback_trans;

+  // Number of connection errors not reflected in global_user_stats yet.

+  ulonglong diff_denied_connections, diff_lost_connections;

+  // Number of db access denied, not reflected in global_user_stats yet.

+  ulonglong diff_access_denied_errors;

+  // Number of queries that return 0 rows

+  ulonglong diff_empty_queries;

+

+  // Per account query delay in miliseconds. When not 0, sleep this number of

+  // milliseconds before every SQL command.

+  ulonglong query_delay_millis;

+

   /* Used by the sys_var class to store temporary values */

   union

   {

@@ -1981,6 +2028,11 @@

     alloc_root. 

   */

   void init_for_queries();

+  void reset_stats(void);

+  void reset_diff_stats(void);

+  // ran_command is true when this is called immediately after a

+  // command has been run.

+  void update_stats(bool ran_command);

   void change_user(void);

   void cleanup(void);

   void cleanup_after_query();

@@ -2351,9 +2403,15 @@

     *p_db= strmake(db, db_length);

     *p_db_length= db_length;

     return FALSE;

+

+  // Returns string as 'IP:port' for the client-side of the connnection represented

+  // by 'client' as displayed by SHOW PROCESSLIST. Allocates memory from the heap of

+  // this THD and that is not reclaimed immediately, so use sparingly. May return NULL.

   }

   thd_scheduler scheduler;

+  char *get_client_host_port(THD *client);

+

 public:

   inline Internal_error_handler *get_internal_handler()

   { return m_internal_handler; }

@@ -2438,6 +2496,9 @@

   LEX_STRING invoker_host;

 };

+// Returns string as 'IP' for the client-side of the connection represented by

+// 'client'. Does not allocate memory. May return "".

+const char *get_client_host(THD *client);

 /** A short cut for thd->main_da.set_ok_status(). */

diff -ruN a/sql/sql_connect.cc b/sql/sql_connect.cc

--- a/sql/sql_connect.cc	2010-08-27 14:38:08.750990238 +0900

+++ b/sql/sql_connect.cc	2010-08-27 15:10:33.834058369 +0900

@@ -42,6 +42,24 @@

 extern void win_install_sigabrt_handler();

 #endif

+// Increments connection count for user.

+static int increment_connection_count(THD* thd, bool use_lock);

+

+// Uses the THD to update the global stats by user name and client IP

+void update_global_user_stats(THD* thd, bool create_user, time_t now);

+

+HASH global_user_stats;

+HASH global_client_stats;

+HASH global_thread_stats;

+// Protects global_user_stats and global_client_stats

+extern pthread_mutex_t LOCK_global_user_client_stats;

+

+HASH global_table_stats;

+extern pthread_mutex_t LOCK_global_table_stats;

+

+HASH global_index_stats;

+extern pthread_mutex_t LOCK_global_index_stats;

+

 /*

   Get structure for logging connection data for the current user

 */

@@ -99,6 +117,563 @@

 }

+extern "C" uchar *get_key_user_stats(USER_STATS *user_stats, size_t *length,

+                         my_bool not_used __attribute__((unused)))

+{

+  *length = strlen(user_stats->user);

+  return (uchar*)user_stats->user;

+}

+

+extern "C" uchar *get_key_thread_stats(THREAD_STATS *thread_stats, size_t *length,

+                         my_bool not_used __attribute__((unused)))

+{

+  *length = sizeof(my_thread_id);

+  return (uchar*)&(thread_stats->id);

+}

+

+void free_user_stats(USER_STATS* user_stats)

+{

+  my_free((char*)user_stats, MYF(0));

+}

+

+void free_thread_stats(THREAD_STATS* thread_stats)

+{

+  my_free((char*)thread_stats, MYF(0));

+}

+

+void init_user_stats(USER_STATS *user_stats,

+                     const char *user,

+                     const char *priv_user,

+                     uint total_connections,

+                     uint concurrent_connections,

+                     time_t connected_time,

+                     double busy_time,

+                     double cpu_time,

+                     ulonglong bytes_received,

+                     ulonglong bytes_sent,