Merge mysql.com:/opt/local/work/tmp_merge

into mysql.com:/opt/local/work/mysql-5.1-merge mysql-test/r/trigger.result: Auto merged mysql-test/t/trigger.test: Auto merged sql/item.cc: Auto merged sql/item.h: Auto merged sql/item_create.cc: Auto merged sql/item_func.cc: Auto merged sql/mysql_priv.h: Auto merged sql/sp_head.h: Auto merged sql/sql_yacc.yy: Auto merged sql/mysqld.cc: Manual merge. sql/sp_head.cc: Manual merge. sql/sql_parse.cc: Manual merge.

Merge mysql.com:/opt/local/work/tmp_merge
into mysql.com:/opt/local/work/mysql-5.1-merge mysql-test/r/trigger.result: Auto merged mysql-test/t/trigger.test: Auto merged sql/item.cc: Auto merged sql/item.h: Auto merged sql/item_create.cc: Auto merged sql/item_func.cc: Auto merged sql/mysql_priv.h: Auto merged sql/sp_head.h: Auto merged sql/sql_yacc.yy: Auto merged sql/mysqld.cc: Manual merge. sql/sp_head.cc: Manual merge. sql/sql_parse.cc: Manual merge.
38c4f0b7 · unknown · a0aea60d · 70695997 · 38c4f0b7 · 38c4f0b7
Commit 38c4f0b7 authored Apr 23, 2006 by unknown
19 changed files
--- a/mysql-test/r/status.result
+++ b/mysql-test/r/status.result
@@ -23,3 +23,23 @@ select 1;
 show status like 'last_query_cost';
 Variable_name	Value
 Last_query_cost	0.000000
+FLUSH STATUS;
+SHOW STATUS LIKE 'max_used_connections';
+Variable_name	Value
+Max_used_connections	1
+SET @save_thread_cache_size=@@thread_cache_size;
+SET GLOBAL thread_cache_size=3;
+SHOW STATUS LIKE 'max_used_connections';
+Variable_name	Value
+Max_used_connections	3
+FLUSH STATUS;
+SHOW STATUS LIKE 'max_used_connections';
+Variable_name	Value
+Max_used_connections	2
+SHOW STATUS LIKE 'max_used_connections';
+Variable_name	Value
+Max_used_connections	3
+SHOW STATUS LIKE 'max_used_connections';
+Variable_name	Value
+Max_used_connections	4
+SET GLOBAL thread_cache_size=@save_thread_cache_size;
--- a/mysql-test/r/trigger.result
+++ b/mysql-test/r/trigger.result
@@ -952,3 +952,16 @@ load data infile '../std_data_ln/words.dat' into table t1 (a) set b:= f1();
 drop table t1;
 drop function f1;
 drop function f2;
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 (
+conn_id INT,
+trigger_conn_id INT
+);
+CREATE TRIGGER t1_bi BEFORE INSERT ON t1 FOR EACH ROW
+SET NEW.trigger_conn_id = CONNECTION_ID();
+INSERT INTO t1 (conn_id, trigger_conn_id) VALUES (CONNECTION_ID(), -1);
+INSERT INTO t1 (conn_id, trigger_conn_id) VALUES (CONNECTION_ID(), -1);
+SELECT * FROM t1 WHERE conn_id != trigger_conn_id;
+conn_id	trigger_conn_id
+DROP TRIGGER t1_bi;
+DROP TABLE t1;
--- a/mysql-test/t/status.test
+++ b/mysql-test/t/status.test
@@ -36,11 +36,111 @@ reap;
 show status like 'Table_lock%';
 drop table t1;
+disconnect con2;
+disconnect con1;
+connection default;
 # End of 4.1 tests
 #
-# lost_query_cost
+# last_query_cost
 #
 select 1;
 show status like 'last_query_cost';
+#
+# Test for Bug #15933 max_used_connections is wrong after FLUSH STATUS
+# if connections are cached
+#
+#
+# The first suggested fix from the bug report was chosen
+# (see http://bugs.mysql.com/bug.php?id=15933):
+#
+#   a) On flushing the status, set max_used_connections to
+#   threads_connected, not to 0.
+#
+#   b) Check if it is necessary to increment max_used_connections when
+#   taking a thread from the cache as well as when creating new threads
+#
+# Wait for at most $disconnect_timeout seconds for disconnects to finish.
+let $disconnect_timeout = 10;
+# Wait for any previous disconnects to finish.
+FLUSH STATUS;
+--disable_query_log
+--disable_result_log
+eval SET @wait_left = $disconnect_timeout;
+let $max_used_connections = `SHOW STATUS LIKE 'max_used_connections'`;
+eval SET @max_used_connections = SUBSTRING('$max_used_connections', 21)+0;
+let $wait_more = `SELECT @max_used_connections != 1 && @wait_left > 0`;
+while ($wait_more)
+{
+  sleep 1;
+  FLUSH STATUS;
+  SET @wait_left = @wait_left - 1;
+  let $max_used_connections = `SHOW STATUS LIKE 'max_used_connections'`;
+  eval SET @max_used_connections = SUBSTRING('$max_used_connections', 21)+0;
+  let $wait_more = `SELECT @max_used_connections != 1 && @wait_left > 0`;
+}
+--enable_query_log
+--enable_result_log
+# Prerequisite.
+SHOW STATUS LIKE 'max_used_connections';
+# Save original setting.
+SET @save_thread_cache_size=@@thread_cache_size;
+SET GLOBAL thread_cache_size=3;
+connect (con1,localhost,root,,);
+connect (con2,localhost,root,,);
+connection con1;
+disconnect con2;
+# Check that max_used_connections still reflects maximum value.
+SHOW STATUS LIKE 'max_used_connections';
+# Check that after flush max_used_connections equals to current number
+# of connections.  First wait for previous disconnect to finish.
+FLUSH STATUS;
+--disable_query_log
+--disable_result_log
+eval SET @wait_left = $disconnect_timeout;
+let $max_used_connections = `SHOW STATUS LIKE 'max_used_connections'`;
+eval SET @max_used_connections = SUBSTRING('$max_used_connections', 21)+0;
+let $wait_more = `SELECT @max_used_connections != 2 && @wait_left > 0`;
+while ($wait_more)
+{
+  sleep 1;
+  FLUSH STATUS;
+  SET @wait_left = @wait_left - 1;
+  let $max_used_connections = `SHOW STATUS LIKE 'max_used_connections'`;
+  eval SET @max_used_connections = SUBSTRING('$max_used_connections', 21)+0;
+  let $wait_more = `SELECT @max_used_connections != 2 && @wait_left > 0`;
+}
+--enable_query_log
+--enable_result_log
+# Check that we don't count disconnected thread any longer.
+SHOW STATUS LIKE 'max_used_connections';
+# Check that max_used_connections is updated when cached thread is
+# reused...
+connect (con2,localhost,root,,);
+SHOW STATUS LIKE 'max_used_connections';
+# ...and when new thread is created.
+connect (con3,localhost,root,,);
+SHOW STATUS LIKE 'max_used_connections';
+# Restore original setting.
+connection default;
+SET GLOBAL thread_cache_size=@save_thread_cache_size;
+disconnect con3;
+disconnect con2;
+disconnect con1;
+# End of 5.0 tests
--- a/mysql-test/t/trigger.test
+++ b/mysql-test/t/trigger.test
@@ -1114,3 +1114,31 @@ load data infile '../std_data_ln/words.dat' into table t1 (a) set b:= f1();
 drop table t1;
 drop function f1;
 drop function f2;
+#
+# Test for Bug #16461 connection_id() does not work properly inside trigger
+#
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+CREATE TABLE t1 (
+    conn_id INT,
+    trigger_conn_id INT
+);
+CREATE TRIGGER t1_bi BEFORE INSERT ON t1 FOR EACH ROW
+  SET NEW.trigger_conn_id = CONNECTION_ID();
+INSERT INTO t1 (conn_id, trigger_conn_id) VALUES (CONNECTION_ID(), -1);
+connect (con1,localhost,root,,);
+INSERT INTO t1 (conn_id, trigger_conn_id) VALUES (CONNECTION_ID(), -1);
+connection default;
+disconnect con1;
+SELECT * FROM t1 WHERE conn_id != trigger_conn_id;
+DROP TRIGGER t1_bi;
+DROP TABLE t1;
+# End of 5.0 tests
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -644,22 +644,6 @@ Item *Item_num::safe_charset_converter(CHARSET_INFO *tocs)
 }
-Item *Item_static_int_func::safe_charset_converter(CHARSET_INFO *tocs)
-{
-  Item_string *conv;
-  char buf[64];
-  String *s, tmp(buf, sizeof(buf), &my_charset_bin);
-  s= val_str(&tmp);
-  if ((conv= new Item_static_string_func(func_name, s->ptr(), s->length(),
-                                         s->charset())))
-  {
-    conv->str_value.copy();
-    conv->str_value.mark_as_const();
-  }
-  return conv;
-}
 Item *Item_static_float_func::safe_charset_converter(CHARSET_INFO *tocs)
 {
  Item_string *conv;

--- a/sql/item.h
+++ b/sql/item.h
@@ -1431,18 +1431,6 @@ class Item_int :public Item_num
 };
-class Item_static_int_func :public Item_int
-{
-  const char *func_name;
-public:
-  Item_static_int_func(const char *str_arg, longlong i, uint length)
-    :Item_int(NullS, i, length), func_name(str_arg)
-  {}
-  Item *safe_charset_converter(CHARSET_INFO *tocs);
-  void print(String *str) { str->append(func_name); }
-};
 class Item_uint :public Item_int
 {
 public:

--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -71,14 +71,8 @@ Item *create_func_ceiling(Item* a)
 Item *create_func_connection_id(void)
 {
-  THD *thd=current_thd;
+  current_thd->lex->safe_to_cache_query= 0;
-  thd->lex->safe_to_cache_query= 0;
+  return new Item_func_connection_id();
-  return new Item_static_int_func("connection_id()",
-                                  (longlong)
-                                  ((thd->slave_thread) ?
-                                   thd->variables.pseudo_thread_id :
-                                   thd->thread_id),
-                                  10);
 }
 Item *create_func_conv(Item* a, Item *b, Item *c)

--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -561,6 +561,31 @@ String *Item_int_func::val_str(String *str)
 }
+void Item_func_connection_id::fix_length_and_dec()
+{
+  Item_int_func::fix_length_and_dec();
+  max_length= 10;
+}
+bool Item_func_connection_id::fix_fields(THD *thd, Item **ref)
+{
+  if (Item_int_func::fix_fields(thd, ref))
+    return TRUE;
+  /*
+    To replicate CONNECTION_ID() properly we should use
+    pseudo_thread_id on slave, which contains the value of thread_id
+    on master.
+  */
+  value= ((thd->slave_thread) ?
+          thd->variables.pseudo_thread_id :
+          thd->thread_id);
+  return FALSE;
+}
 /*
  Check arguments here to determine result's type for a numeric
  function of two arguments.

--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -279,6 +279,18 @@ class Item_int_func :public Item_func
 };
+class Item_func_connection_id :public Item_int_func
+{
+  longlong value;
+public:
+  const char *func_name() const { return "connection_id"; }
+  void fix_length_and_dec();
+  bool fix_fields(THD *thd, Item **ref);
+  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
+};
 class Item_func_signed :public Item_int_func
 {
 public:

--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1408,6 +1408,7 @@ File open_binlog(IO_CACHE *log, const char *log_file_name,
 /* mysqld.cc */
 extern void MYSQLerror(const char*);
+void refresh_status(THD *thd);
 /* item_func.cc */
 extern bool check_reserved_words(LEX_STRING *name);

--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1755,17 +1755,6 @@ void end_thread(THD *thd, bool put_in_cache)
 }
-/* Start a cached thread. LOCK_thread_count is locked on entry */
-static void start_cached_thread(THD *thd)
-{
-  thread_cache.append(thd);
-  wake_thread++;
-  thread_count++;
-  pthread_cond_signal(&COND_thread_cache);
-}
 void flush_thread_cache()
 {
  (void) pthread_mutex_lock(&LOCK_thread_count);
@@ -3929,6 +3918,25 @@ static bool read_init_file(char *file_name)
 #ifndef EMBEDDED_LIBRARY
+/*
+  Create new thread to handle incoming connection.
+  SYNOPSIS
+    create_new_thread()
+      thd in/out    Thread handle of future thread.
+  DESCRIPTION
+    This function will create new thread to handle the incoming
+    connection.  If there are idle cached threads one will be used.
+    'thd' will be pushed into 'threads'.
+    In single-threaded mode (#define ONE_THREAD) connection will be
+    handled inside this function.
+  RETURN VALUE
+    none
+*/
 static void create_new_thread(THD *thd)
 {
  DBUG_ENTER("create_new_thread");
@@ -3952,11 +3960,12 @@ static void create_new_thread(THD *thd)
  thd->real_id=pthread_self();			// Keep purify happy
  /* Start a new thread to handle connection */
+  thread_count++;
 #ifdef ONE_THREAD
  if (test_flags & TEST_NO_THREADS)		// For debugging under Linux
  {
    thread_cache_size=0;			// Safety
-    thread_count++;
    threads.append(thd);
    thd->real_id=pthread_self();
    (void) pthread_mutex_unlock(&LOCK_thread_count);
@@ -3965,18 +3974,20 @@ static void create_new_thread(THD *thd)
  else
 #endif
  {
+    if (thread_count-delayed_insert_threads > max_used_connections)
+      max_used_connections=thread_count-delayed_insert_threads;
    if (cached_thread_count > wake_thread)
    {
-      start_cached_thread(thd);
+      thread_cache.append(thd);
+      wake_thread++;
+      pthread_cond_signal(&COND_thread_cache);
    }
    else
    {
      int error;
-      thread_count++;
      thread_created++;
      threads.append(thd);
-      if (thread_count-delayed_insert_threads > max_used_connections)
-        max_used_connections=thread_count-delayed_insert_threads;
      DBUG_PRINT("info",(("creating thread %d"), thd->thread_id));
      thd->connect_time = time(NULL);
      if ((error=pthread_create(&thd->real_id,&connection_attrib,
@@ -8047,7 +8058,37 @@ static void create_pid_file()
    (void) my_close(file, MYF(0));
  }
  sql_perror("Can't start server: can't create PID file");
-  exit(1);  
+  exit(1);
+}
+/* Clear most status variables */
+void refresh_status(THD *thd)
+{
+  pthread_mutex_lock(&LOCK_status);
+  /* We must update the global status before cleaning up the thread */
+  add_to_status(&global_status_var, &thd->status_var);
+  bzero((char*) &thd->status_var, sizeof(thd->status_var));
+  for (struct show_var_st *ptr=status_vars; ptr->name; ptr++)
+  {
+    if (ptr->type == SHOW_LONG)
+      *(ulong*) ptr->value= 0;
+  }
+  /* Reset the counters of all key caches (default and named). */
+  process_key_caches(reset_key_cache_counters);
+  pthread_mutex_unlock(&LOCK_status);
+  /*
+    Set max_used_connections to the number of currently open
+    connections.  Lock LOCK_thread_count out of LOCK_status to avoid
+    deadlocks.  Status reset becomes not atomic, but status data is
+    not exact anyway.
+  */
+  pthread_mutex_lock(&LOCK_thread_count);
+  max_used_connections= thread_count-delayed_insert_threads;
+  pthread_mutex_unlock(&LOCK_thread_count);
 }

--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -1229,7 +1229,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
  DBUG_PRINT("info", ("function %s", m_name.str));
  LINT_INIT(binlog_save_options);
-  params = m_pcont->context_pvars();
+  params= m_pcont->context_var_count();
  /*
    Check that the function is called with all specified arguments.
@@ -1412,7 +1412,7 @@ bool
 sp_head::execute_procedure(THD *thd, List<Item> *args)
 {
  bool err_status= FALSE;
-  uint params = m_pcont->context_pvars();
+  uint params = m_pcont->context_var_count();
  sp_rcontext *save_spcont, *octx;
  sp_rcontext *nctx = NULL;
  bool save_enable_slow_log= false;
@@ -1466,15 +1466,15 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
    for (uint i= 0 ; i < params ; i++)
    {
      Item *arg_item= it_args++;
-      sp_pvar_t *pvar= m_pcont->find_pvar(i);
+      sp_variable_t *spvar= m_pcont->find_variable(i);
      if (!arg_item)
        break;
-      if (!pvar)
+      if (!spvar)
        continue;
-      if (pvar->mode != sp_param_in)
+      if (spvar->mode != sp_param_in)
      {
        if (!arg_item->is_splocal() && !item_is_user_var(arg_item))
        {
@@ -1484,7 +1484,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
        }
      }
-      if (pvar->mode == sp_param_out)
+      if (spvar->mode == sp_param_out)
      {
        Item_null *null_item= new Item_null();
@@ -1560,9 +1560,9 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
      if (!arg_item)
        break;
-      sp_pvar_t *pvar= m_pcont->find_pvar(i);
+      sp_variable_t *spvar= m_pcont->find_variable(i);
-      if (pvar->mode == sp_param_in)
+      if (spvar->mode == sp_param_in)
        continue;
      if (arg_item->is_splocal())
@@ -2432,7 +2432,7 @@ sp_instr_set::print(String *str)
 {
  /* set name@offset ... */
  int rsrv = SP_INSTR_UINT_MAXLEN+6;
-  sp_pvar_t *var = m_ctx->find_pvar(m_offset);
+  sp_variable_t *var = m_ctx->find_variable(m_offset);
  /* 'var' should always be non-null, but just in case... */
  if (var)
@@ -3048,8 +3048,8 @@ sp_instr_cfetch::execute(THD *thd, uint *nextp)
 void
 sp_instr_cfetch::print(String *str)
 {
-  List_iterator_fast<struct sp_pvar> li(m_varlist);
+  List_iterator_fast<struct sp_variable> li(m_varlist);
-  sp_pvar_t *pv;
+  sp_variable_t *pv;
  LEX_STRING n;
  my_bool found= m_ctx->find_cursor(m_cursor, &n);
  /* cfetch name@offset vars... */

--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -44,7 +44,7 @@ class sp_instr;
 class sp_instr_opt_meta;
 class sp_instr_jump_if_not;
 struct sp_cond_type;
-struct sp_pvar;
+struct sp_variable;
 class sp_name : public Sql_alloc
 {
@@ -1075,7 +1075,7 @@ class sp_instr_cfetch : public sp_instr
  virtual void print(String *str);
-  void add_to_varlist(struct sp_pvar *var)
+  void add_to_varlist(struct sp_variable *var)
  {
    m_varlist.push_back(var);
  }
@@ -1083,7 +1083,7 @@ class sp_instr_cfetch : public sp_instr
 private:
  uint m_cursor;
-  List<struct sp_pvar> m_varlist;
+  List<struct sp_variable> m_varlist;
 }; // class sp_instr_cfetch : public sp_instr

--- a/sql/sp_pcontext.cc
+++ b/sql/sp_pcontext.cc
--- a/sql/sp_pcontext.h
+++ b/sql/sp_pcontext.h
@@ -29,22 +29,23 @@ typedef enum
  sp_param_inout
 } sp_param_mode_t;
-typedef struct sp_pvar
+typedef struct sp_variable
 {
  LEX_STRING name;
  enum enum_field_types type;
  sp_param_mode_t mode;
  /*
-    offset -- basically, this is an index of variable in the scope of root
+    offset -- this the index to the variable's value in the runtime frame.
-    parsing context. This means, that all variables in a stored routine
+    This is calculated during parsing and used when creating sp_instr_set
-    have distinct indexes/offsets.
+    instructions and Item_splocal items.
+    I.e. values are set/referred by array indexing in runtime.
  */
  uint offset;
  Item *dflt;
  create_field field_def;
-} sp_pvar_t;
+} sp_variable_t;
 #define SP_LAB_REF   0		// Unresolved reference (for goto)
@@ -76,9 +77,10 @@ typedef struct sp_cond_type
  uint mysqlerr;
 } sp_cond_type_t;
-/* Sanity check for SQLSTATEs. Will not check if it's really an existing
+/*
- * state (there are just too many), but will check length bad characters.
+  Sanity check for SQLSTATEs. Will not check if it's really an existing
- */
+  state (there are just too many), but will check length bad characters.
+*/
 extern bool
 sp_cond_check(LEX_STRING *sqlstate);
@@ -90,7 +92,17 @@ typedef struct sp_cond
 /*
-  This seems to be an "SP parsing context" or something.
+  The parse-time context, used to keep track on declared variables/parameters,
+  conditions, handlers, cursors and labels, during parsing.
+  sp_contexts are organized as a tree, with one object for each begin-end
+  block, plus a root-context for the parameters.
+  This is used during parsing for looking up defined names (e.g. declared
+  variables and visible labels), for error checking, and to calculate offsets
+  to be used at runtime. (During execution variable values, active handlers
+  and cursors, etc, are referred to by an index in a stack.)
+  The pcontext tree is also kept during execution and is used for error
+  checking (e.g. correct number of parameters), and in the future, used by
+  the debugger.
 */
 class sp_pcontext : public Sql_alloc
@@ -134,50 +146,64 @@ class sp_pcontext : public Sql_alloc
  // Parameters and variables
  //
+  /*
+    The maximum number of variables used in this and all child contexts
+    In the root, this gives us the number of slots needed for variables
+    during execution.
+  */
  inline uint
-  total_pvars()
+  max_var_index()
  {
-    return m_total_pvars;
+    return m_max_var_index;
  }
+  /*
+    The current number of variables used in the parents (from the root),
+    including this context.
+  */
  inline uint
-  current_pvars()
+  current_var_count()
  {
-    return m_poffset + m_pvar.elements;
+    return m_var_offset + m_vars.elements;
  }
+  /* The number of variables in this context alone */
  inline uint
-  context_pvars()
+  context_var_count()
  {
-    return m_pvar.elements;
+    return m_vars.elements;
  }
+  /* Map index in this pcontext to runtime offset */
  inline uint
-  pvar_context2index(uint i)
+  var_context2runtime(uint i)
  {
-    return m_poffset + i;
+    return m_var_offset + i;
  }
+  /* Set type of variable. 'i' is the offset from the top */
  inline void
  set_type(uint i, enum enum_field_types type)
  {
-    sp_pvar_t *p= find_pvar(i);
+    sp_variable_t *p= find_variable(i);
    if (p)
      p->type= type;
  }
+  /* Set default value of variable. 'i' is the offset from the top */
  inline void
  set_default(uint i, Item *it)
  {
-    sp_pvar_t *p= find_pvar(i);
+    sp_variable_t *p= find_variable(i);
    if (p)
      p->dflt= it;
  }
-  sp_pvar_t *
+  sp_variable_t *
-  push_pvar(LEX_STRING *name, enum enum_field_types type, sp_param_mode_t mode);
+  push_variable(LEX_STRING *name, enum enum_field_types type,
+                sp_param_mode_t mode);
  /*
    Retrieve definitions of fields from the current context and its
@@ -187,12 +213,12 @@ class sp_pcontext : public Sql_alloc
  retrieve_field_definitions(List<create_field> *field_def_lst);
  // Find by name
-  sp_pvar_t *
+  sp_variable_t *
-  find_pvar(LEX_STRING *name, my_bool scoped=0);
+  find_variable(LEX_STRING *name, my_bool scoped=0);
-  // Find by offset
+  // Find by offset (from the top)
-  sp_pvar_t *
+  sp_variable_t *
-  find_pvar(uint offset);
+  find_variable(uint offset);
  /*
    Set the current scope boundary (for default values).
@@ -280,7 +306,7 @@ class sp_pcontext : public Sql_alloc
  pop_cond(uint num)
  {
    while (num--)
-      pop_dynamic(&m_cond);
+      pop_dynamic(&m_conds);
  }
  sp_cond_type_t *
@@ -293,22 +319,22 @@ class sp_pcontext : public Sql_alloc
  inline void
  push_handler(sp_cond_type_t *cond)
  {
-    insert_dynamic(&m_handler, (gptr)&cond);
+    insert_dynamic(&m_handlers, (gptr)&cond);
  }
  bool
  find_handler(sp_cond_type *cond);
  inline uint
-  max_handlers()
+  max_handler_index()
  {
-    return m_hsubsize + m_handlers;
+    return m_max_handler_index + m_context_handlers;
  }
  inline void
  add_handlers(uint n)
  {
-    m_handlers+= n;
+    m_context_handlers+= n;
  }
  //
@@ -326,51 +352,51 @@ class sp_pcontext : public Sql_alloc
  find_cursor(uint offset, LEX_STRING *n);
  inline uint
-  max_cursors()
+  max_cursor_index()
  {
-    return m_csubsize + m_cursor.elements;
+    return m_max_cursor_index + m_cursors.elements;
  }
  inline uint
-  current_cursors()
+  current_cursor_count()
  {
-    return m_coffset + m_cursor.elements;
+    return m_cursor_offset + m_cursors.elements;
  }
 protected:
  /*
-    m_total_pvars -- number of variables (including all types of arguments)
+    m_max_var_index -- number of variables (including all types of arguments)
    in this context including all children contexts.
-    m_total_pvars >= m_pvar.elements.
+    m_max_var_index >= m_vars.elements.
-    m_total_pvars of the root parsing context contains number of all
+    m_max_var_index of the root parsing context contains number of all
    variables (including arguments) in all enclosed contexts.
  */
-  uint m_total_pvars;		
+  uint m_max_var_index;		
  // The maximum sub context's framesizes
-  uint m_csubsize;
+  uint m_max_cursor_index;
-  uint m_hsubsize;
+  uint m_max_handler_index;
-  uint m_handlers;		// No. of handlers in this context
+  uint m_context_handlers;      // No. of handlers in this context
 private:
  sp_pcontext *m_parent;	// Parent context
  /*
-    m_poffset -- basically, this is an index of the first variable in this
+    m_var_offset -- this is an index of the first variable in this
-    parsing context.
+                    parsing context.
-    m_poffset is 0 for root context.
+    m_var_offset is 0 for root context.
    Since now each variable is stored in separate place, no reuse is done,
-    so m_poffset is different for all enclosed contexts.
+    so m_var_offset is different for all enclosed contexts.
  */
-  uint m_poffset;
+  uint m_var_offset;
-  uint m_coffset;		// Cursor offset for this context
+  uint m_cursor_offset;		// Cursor offset for this context
  /*
    Boundary for finding variables in this context. This is the number
@@ -382,11 +408,11 @@ class sp_pcontext : public Sql_alloc
  int m_num_case_exprs;
-  DYNAMIC_ARRAY m_pvar;		// Parameters/variables
+  DYNAMIC_ARRAY m_vars;		// Parameters/variables
  DYNAMIC_ARRAY m_case_expr_id_lst; /* Stack of CASE expression ids. */
-  DYNAMIC_ARRAY m_cond;		// Conditions
+  DYNAMIC_ARRAY m_conds;        // Conditions
-  DYNAMIC_ARRAY m_cursor;	// Cursors
+  DYNAMIC_ARRAY m_cursors;	// Cursors
-  DYNAMIC_ARRAY m_handler;	// Handlers, for checking of duplicates
+  DYNAMIC_ARRAY m_handlers;	// Handlers, for checking for duplicates
  List<sp_label_t> m_label;	// The label list

--- a/sql/sp_rcontext.cc
+++ b/sql/sp_rcontext.cc
@@ -73,16 +73,16 @@ bool sp_rcontext::init(THD *thd)
  return
    !(m_handler=
-      (sp_handler_t*)thd->alloc(m_root_parsing_ctx->max_handlers() *
+      (sp_handler_t*)thd->alloc(m_root_parsing_ctx->max_handler_index() *
                                sizeof(sp_handler_t))) ||
    !(m_hstack=
-      (uint*)thd->alloc(m_root_parsing_ctx->max_handlers() *
+      (uint*)thd->alloc(m_root_parsing_ctx->max_handler_index() *
                        sizeof(uint))) ||
    !(m_in_handler=
-      (uint*)thd->alloc(m_root_parsing_ctx->max_handlers() *
+      (uint*)thd->alloc(m_root_parsing_ctx->max_handler_index() *
                        sizeof(uint))) ||
    !(m_cstack=
-      (sp_cursor**)thd->alloc(m_root_parsing_ctx->max_cursors() *
+      (sp_cursor**)thd->alloc(m_root_parsing_ctx->max_cursor_index() *
                              sizeof(sp_cursor*))) ||
    !(m_case_expr_holders=
      (Item_cache**)thd->calloc(m_root_parsing_ctx->get_num_case_exprs() *
@@ -105,12 +105,12 @@ sp_rcontext::init_var_table(THD *thd)
 {
  List<create_field> field_def_lst;
-  if (!m_root_parsing_ctx->total_pvars())
+  if (!m_root_parsing_ctx->max_var_index())
    return FALSE;
  m_root_parsing_ctx->retrieve_field_definitions(&field_def_lst);
-  DBUG_ASSERT(field_def_lst.elements == m_root_parsing_ctx->total_pvars());
+  DBUG_ASSERT(field_def_lst.elements == m_root_parsing_ctx->max_var_index());
  if (!(m_var_table= create_virtual_tmp_table(thd, field_def_lst)))
    return TRUE;
@@ -134,7 +134,7 @@ bool
 sp_rcontext::init_var_items()
 {
  uint idx;
-  uint num_vars= m_root_parsing_ctx->total_pvars();
+  uint num_vars= m_root_parsing_ctx->max_var_index();
  if (!(m_var_items= (Item**) sql_alloc(num_vars * sizeof (Item *))))
    return TRUE;
@@ -381,7 +381,7 @@ sp_cursor::destroy()
 int
-sp_cursor::fetch(THD *thd, List<struct sp_pvar> *vars)
+sp_cursor::fetch(THD *thd, List<struct sp_variable> *vars)
 {
  if (! server_side_cursor)
  {
@@ -528,9 +528,9 @@ int Select_fetch_into_spvars::prepare(List<Item> &fields, SELECT_LEX_UNIT *u)
 bool Select_fetch_into_spvars::send_data(List<Item> &items)
 {
-  List_iterator_fast<struct sp_pvar> pv_iter(*spvar_list);
+  List_iterator_fast<struct sp_variable> spvar_iter(*spvar_list);
  List_iterator_fast<Item> item_iter(items);
-  sp_pvar_t *pv;
+  sp_variable_t *spvar;
  Item *item;
  /* Must be ensured by the caller */
@@ -540,9 +540,9 @@ bool Select_fetch_into_spvars::send_data(List<Item> &items)
    Assign the row fetched from a server side cursor to stored
    procedure variables.
  */
-  for (; pv= pv_iter++, item= item_iter++; )
+  for (; spvar= spvar_iter++, item= item_iter++; )
  {
-    if (thd->spcont->set_variable(thd, pv->offset, item))
+    if (thd->spcont->set_variable(thd, spvar->offset, item))
      return TRUE;
  }
  return FALSE;

--- a/sql/sp_rcontext.h
+++ b/sql/sp_rcontext.h
@@ -24,7 +24,7 @@
 struct sp_cond_type;
 class sp_cursor;
-struct sp_pvar;
+struct sp_variable;
 class sp_lex_keeper;
 class sp_instr_cpush;
@@ -265,12 +265,12 @@ class sp_rcontext : public Sql_alloc
 class Select_fetch_into_spvars: public select_result_interceptor
 {
-  List<struct sp_pvar> *spvar_list;
+  List<struct sp_variable> *spvar_list;
  uint field_count;
 public:
  Select_fetch_into_spvars() {}               /* Remove gcc warning */
  uint get_field_count() { return field_count; }
-  void set_spvar_list(List<struct sp_pvar> *vars) { spvar_list= vars; }
+  void set_spvar_list(List<struct sp_variable> *vars) { spvar_list= vars; }
  virtual bool send_eof() { return FALSE; }
  virtual bool send_data(List<Item> &items);
@@ -307,7 +307,7 @@ class sp_cursor : public Sql_alloc
  }
  int
-  fetch(THD *, List<struct sp_pvar> *vars);
+  fetch(THD *, List<struct sp_variable> *vars);
  inline sp_instr_cpush *
  get_instr()

--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -68,7 +68,6 @@ static void decrease_user_connections(USER_CONN *uc);
 static bool check_db_used(THD *thd,TABLE_LIST *tables);
 static bool check_multi_update_lock(THD *thd);
 static void remove_escape(char *name);
-static void refresh_status(THD *thd);
 const char *any_db="*any*";	// Special symbol for check_access
@@ -6905,26 +6904,6 @@ void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
 }
-/* Clear most status variables */
-static void refresh_status(THD *thd)
-{
-  pthread_mutex_lock(&LOCK_status);
-  /* We must update the global status before cleaning up the thread */
-  add_to_status(&global_status_var, &thd->status_var);
-  bzero((char*) &thd->status_var, sizeof(thd->status_var));
-  for (SHOW_VAR *ptr= status_vars; ptr->name; ptr++)
-    if (ptr->type == SHOW_LONG) // note that SHOW_LONG_NOFLUSH variables are not reset
-      *(ulong*) ptr->value= 0;
-  /* Reset the counters of all key caches (default and named). */
-  process_key_caches(reset_key_cache_counters);
-  pthread_mutex_unlock(&LOCK_status);
-}
 	/* If pointer is not a null pointer, append filename to it */
 bool append_file_to_dir(THD *thd, const char **filename_ptr,

--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -1819,22 +1819,23 @@ sp_fdparam:
 	    LEX *lex= Lex;
 	    sp_pcontext *spc= lex->spcont;
-	    if (spc->find_pvar(&$1, TRUE))
+	    if (spc->find_variable(&$1, TRUE))
 	    {
 	      my_error(ER_SP_DUP_PARAM, MYF(0), $1.str);
 	      YYABORT;
 	    }
-	    sp_pvar_t *pvar= spc->push_pvar(&$1, (enum enum_field_types)$3,
+            sp_variable_t *spvar= spc->push_variable(&$1,
-                                            sp_param_in);
+                                                     (enum enum_field_types)$3,
+                                                     sp_param_in);
            if (lex->sphead->fill_field_definition(YYTHD, lex,
                                                   (enum enum_field_types) $3,
-                                                   &pvar->field_def))
+                                                   &spvar->field_def))
            {
              YYABORT;
            }
-            pvar->field_def.field_name= pvar->name.str;
+            spvar->field_def.field_name= spvar->name.str;
-            pvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
+            spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
 	  }
 	;
@@ -1855,22 +1856,23 @@ sp_pdparam:
 	    LEX *lex= Lex;
 	    sp_pcontext *spc= lex->spcont;
-	    if (spc->find_pvar(&$3, TRUE))
+	    if (spc->find_variable(&$3, TRUE))
 	    {
 	      my_error(ER_SP_DUP_PARAM, MYF(0), $3.str);
 	      YYABORT;
 	    }
-	    sp_pvar_t *pvar= spc->push_pvar(&$3, (enum enum_field_types)$4,
+            sp_variable_t *spvar= spc->push_variable(&$3,
-			                    (sp_param_mode_t)$1);
+                                                     (enum enum_field_types)$4,
+                                                     (sp_param_mode_t)$1);
            if (lex->sphead->fill_field_definition(YYTHD, lex,
                                                   (enum enum_field_types) $4,
-                                                   &pvar->field_def))
+                                                   &spvar->field_def))
            {
              YYABORT;
            }
-            pvar->field_def.field_name= pvar->name.str;
+            spvar->field_def.field_name= spvar->name.str;
-            pvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
+            spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
 	  }
 	;
@@ -1934,7 +1936,7 @@ sp_decl:
          {
            LEX *lex= Lex;
            sp_pcontext *pctx= lex->spcont;
-            uint num_vars= pctx->context_pvars();
+            uint num_vars= pctx->context_var_count();
            enum enum_field_types var_type= (enum enum_field_types) $4;
            Item *dflt_value_item= $5;
            create_field *create_field_op;
@@ -1947,23 +1949,23 @@ sp_decl:
            for (uint i = num_vars-$2 ; i < num_vars ; i++)
            {
-              uint var_idx= pctx->pvar_context2index(i);
+              uint var_idx= pctx->var_context2runtime(i);
-              sp_pvar_t *pvar= pctx->find_pvar(var_idx);
+              sp_variable_t *spvar= pctx->find_variable(var_idx);
-              if (!pvar)
+              if (!spvar)
                YYABORT;
-              pvar->type= var_type;
+              spvar->type= var_type;
-              pvar->dflt= dflt_value_item;
+              spvar->dflt= dflt_value_item;
              if (lex->sphead->fill_field_definition(YYTHD, lex, var_type,
-                                                     &pvar->field_def))
+                                                     &spvar->field_def))
              {
                YYABORT;
              }
-              pvar->field_def.field_name= pvar->name.str;
+              spvar->field_def.field_name= spvar->name.str;
-              pvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
+              spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
              /* The last instruction is responsible for freeing LEX. */
@@ -2000,7 +2002,7 @@ sp_decl:
 	    sp_pcontext *ctx= lex->spcont;
 	    sp_instr_hpush_jump *i=
              new sp_instr_hpush_jump(sp->instructions(), ctx, $2,
-	                              ctx->current_pvars());
+	                              ctx->current_var_count());
 	    sp->add_instr(i);
 	    sp->push_backpatch(i, ctx->push_label((char *)"", 0));
@@ -2017,7 +2019,7 @@ sp_decl:
 	    if ($2 == SP_HANDLER_CONTINUE)
 	    {
 	      i= new sp_instr_hreturn(sp->instructions(), ctx,
-	                              ctx->current_pvars());
+	                              ctx->current_var_count());
 	      sp->add_instr(i);
 	    }
 	    else
@@ -2048,7 +2050,7 @@ sp_decl:
 	      YYABORT;
 	    }
            i= new sp_instr_cpush(sp->instructions(), ctx, $5,
-                                  ctx->current_cursors());
+                                  ctx->current_cursor_count());
 	    sp->add_instr(i);
 	    ctx->push_cursor(&$2);
 	    $$.vars= $$.conds= $$.hndlrs= 0;
@@ -2203,12 +2205,12 @@ sp_decl_idents:
 	    LEX *lex= Lex;
 	    sp_pcontext *spc= lex->spcont;
-	    if (spc->find_pvar(&$1, TRUE))
+	    if (spc->find_variable(&$1, TRUE))
 	    {
 	      my_error(ER_SP_DUP_VAR, MYF(0), $1.str);
 	      YYABORT;
 	    }
-	    spc->push_pvar(&$1, (enum_field_types)0, sp_param_in);
+	    spc->push_variable(&$1, (enum_field_types)0, sp_param_in);
 	    $$= 1;
 	  }
 	| sp_decl_idents ',' ident
@@ -2218,12 +2220,12 @@ sp_decl_idents:
 	    LEX *lex= Lex;
 	    sp_pcontext *spc= lex->spcont;
-	    if (spc->find_pvar(&$3, TRUE))
+	    if (spc->find_variable(&$3, TRUE))
 	    {
 	      my_error(ER_SP_DUP_VAR, MYF(0), $3.str);
 	      YYABORT;
 	    }
-	    spc->push_pvar(&$3, (enum_field_types)0, sp_param_in);
+	    spc->push_variable(&$3, (enum_field_types)0, sp_param_in);
 	    $$= $1 + 1;
 	  }
 	;
@@ -2606,9 +2608,9 @@ sp_fetch_list:
 	    LEX *lex= Lex;
 	    sp_head *sp= lex->sphead;
 	    sp_pcontext *spc= lex->spcont;
-	    sp_pvar_t *spv;
+	    sp_variable_t *spv;
-	    if (!spc || !(spv = spc->find_pvar(&$1)))
+	    if (!spc || !(spv = spc->find_variable(&$1)))
 	    {
 	      my_error(ER_SP_UNDECLARED_VAR, MYF(0), $1.str);
 	      YYABORT;
@@ -2627,9 +2629,9 @@ sp_fetch_list:
 	    LEX *lex= Lex;
 	    sp_head *sp= lex->sphead;
 	    sp_pcontext *spc= lex->spcont;
-	    sp_pvar_t *spv;
+	    sp_variable_t *spv;
-	    if (!spc || !(spv = spc->find_pvar(&$3)))
+	    if (!spc || !(spv = spc->find_variable(&$3)))
 	    {
 	      my_error(ER_SP_UNDECLARED_VAR, MYF(0), $3.str);
 	      YYABORT;
@@ -7534,9 +7536,9 @@ select_var_ident:
           | ident_or_text
           {
             LEX *lex=Lex;
-	     sp_pvar_t *t;
+	     sp_variable_t *t;
-	     if (!lex->spcont || !(t=lex->spcont->find_pvar(&$1)))
+	     if (!lex->spcont || !(t=lex->spcont->find_variable(&$1)))
 	     {
 	       my_error(ER_SP_UNDECLARED_VAR, MYF(0), $1.str);
 	       YYABORT;
@@ -8973,10 +8975,10 @@ order_ident:
 simple_ident:
 	ident
 	{
-	  sp_pvar_t *spv;
+	  sp_variable_t *spv;
 	  LEX *lex = Lex;
          sp_pcontext *spc = lex->spcont;
-	  if (spc && (spv = spc->find_pvar(&$1)))
+	  if (spc && (spv = spc->find_variable(&$1)))
 	  {
            /* We're compiling a stored procedure and found a variable */
            Item_splocal *splocal;
@@ -9764,7 +9766,7 @@ sys_option_value:
          {
            /* An SP local variable */
            sp_pcontext *ctx= lex->spcont;
-            sp_pvar_t *spv;
+            sp_variable_t *spv;
            sp_instr_set *sp_set;
            Item *it;
            if ($1)
@@ -9773,7 +9775,7 @@ sys_option_value:
              YYABORT;
            }
-            spv= ctx->find_pvar(&$2.base_name);
+            spv= ctx->find_variable(&$2.base_name);
            if ($4)
              it= $4;
@@ -9822,7 +9824,7 @@ option_value:
 	    names.str= (char *)"names";
 	    names.length= 5;
-	    if (spc && spc->find_pvar(&names))
+	    if (spc && spc->find_variable(&names))
              my_error(ER_SP_BAD_VAR_SHADOW, MYF(0), names.str);
            else
              yyerror(ER(ER_SYNTAX_ERROR));
@@ -9852,7 +9854,7 @@ option_value:
 	    pw.str= (char *)"password";
 	    pw.length= 8;
-	    if (spc && spc->find_pvar(&pw))
+	    if (spc && spc->find_variable(&pw))
 	    {
              my_error(ER_SP_BAD_VAR_SHADOW, MYF(0), pw.str);
 	      YYABORT;
@@ -9874,10 +9876,10 @@ internal_variable_name:
 	{
 	  LEX *lex= Lex;
          sp_pcontext *spc= lex->spcont;
-	  sp_pvar_t *spv;
+	  sp_variable_t *spv;
 	  /* We have to lookup here since local vars can shadow sysvars */
-	  if (!spc || !(spv = spc->find_pvar(&$1)))
+	  if (!spc || !(spv = spc->find_variable(&$1)))
 	  {
            /* Not an SP local variable */
 	    sys_var *tmp=find_sys_var($1.str, $1.length);