1 files changed, 244 insertions, 111 deletions

diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 805db107370..438bfdbcb73 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -35,6 +35,9 @@
 #endif
 #include <mysys_err.h>
 
+#include "sp_rcontext.h"
+#include "sp_cache.h"
+
 /*
   The following is used to initialise Table_ident with a internal
   table name
@@ -156,18 +159,23 @@ bool foreign_key_prefix(Key *a, Key *b)
 
 THD::THD()
   :user_time(0), global_read_lock(0), is_fatal_error(0),
-   last_insert_id_used(0),
-   insert_id_used(0), rand_used(0), time_zone_used(0),
-   in_lock_tables(0), bootstrap(0)
+   rand_used(0), time_zone_used(0),
+   last_insert_id_used(0), insert_id_used(0), clear_next_insert_id(0),
+   in_lock_tables(0), bootstrap(0), derived_tables_processing(FALSE),
+   spcont(NULL)
 {
   current_arena= this;
-  host= user= priv_user= db= ip=0;
+#ifndef DBUG_OFF
+  backup_arena= 0;
+#endif
+  host= user= priv_user= db= ip= 0;
+  catalog= (char*)"std"; // the only catalog we have for now
   host_or_ip= "connecting host";
   locked=some_tables_deleted=no_errors=password= 0;
-  killed=0;
   query_start_used= 0;
   count_cuted_fields= CHECK_FIELD_IGNORE;
-  db_length= col_access= 0;
+  killed= NOT_KILLED;
+  db_length= col_access=0;
   query_error= tmp_table_used= 0;
   next_insert_id=last_insert_id=0;
   open_tables= temporary_tables= handler_tables= derived_tables= 0;
@@ -186,26 +194,28 @@ THD::THD()
   variables.pseudo_thread_id= 0;
   one_shot_set= 0;
   file_id = 0;
+  query_id= 0;
   warn_id= 0;
   db_charset= global_system_variables.collation_database;
+  bzero(ha_data, sizeof(ha_data));
   mysys_var=0;
 #ifndef DBUG_OFF
   dbug_sentry=THD_SENTRY_MAGIC;
 #endif
-#ifndef EMBEDDED_LIBRARY  
+#ifndef EMBEDDED_LIBRARY
   net.vio=0;
 #endif
-  net.last_error[0]=0;				// If error on boot
+  net.last_error[0]=0;                          // If error on boot
+  net.query_cache_query=0;                      // If error on boot
   ull=0;
-  system_thread=cleanup_done=0;
+  system_thread= cleanup_done= abort_on_warning= no_warnings_for_error= 0;
   peer_port= 0;					// For SHOW PROCESSLIST
-  transaction.changed_tables = 0;
 #ifdef	__WIN__
   real_id = 0;
 #endif
 #ifdef SIGNAL_WITH_VIO_CLOSE
   active_vio = 0;
-#endif  
+#endif
   pthread_mutex_init(&LOCK_delete, MY_MUTEX_INIT_FAST);
 
   /* Variables with default values */
@@ -224,16 +234,17 @@ THD::THD()
   /* Initialize sub structures */
   init_sql_alloc(&warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
   user_connect=(USER_CONN *)0;
-  hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
+  hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
 	    (hash_get_key) get_var_key,
-	    (hash_free_key) free_user_var,0);
+	    (hash_free_key) free_user_var, 0);
+
+  sp_proc_cache= NULL;
+  sp_func_cache= NULL;
 
   /* For user vars replication*/
   if (opt_bin_log)
     my_init_dynamic_array(&user_var_events,
-			  sizeof(BINLOG_USER_VAR_EVENT *),
-			  16,
-			  16);
+			  sizeof(BINLOG_USER_VAR_EVENT *), 16, 16);
   else
     bzero((char*) &user_var_events, sizeof(user_var_events));
 
@@ -243,26 +254,9 @@ THD::THD()
   protocol_prep.init(this);
 
   tablespace_op=FALSE;
-#ifdef USING_TRANSACTIONS
-  bzero((char*) &transaction,sizeof(transaction));
-  /*
-    Binlog is always open (if needed) before a THD is created (including
-    bootstrap).
-  */
-  if (opt_using_transactions && mysql_bin_log.is_open())
-  {
-    if (open_cached_file(&transaction.trans_log,
-			 mysql_tmpdir, LOG_PREFIX, binlog_cache_size,
-			 MYF(MY_WME)))
-      killed=1;
-    transaction.trans_log.end_of_file= max_binlog_cache_size;
-  }
-#endif
-  init_sql_alloc(&transaction.mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
-  {
-    ulong tmp=sql_rnd_with_mutex();
-    randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::query_id);
-  }
+  ulong tmp=sql_rnd_with_mutex();
+  randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::query_id);
+  prelocked_mode= NON_PRELOCKED;
 }
 
 
@@ -295,6 +289,7 @@ void THD::init(void)
   bzero((char*) warn_count, sizeof(warn_count));
   total_warn_count= 0;
   update_charset();
+  bzero((char *) &status_var, sizeof(status_var));
 }
 
 
@@ -310,9 +305,12 @@ void THD::init_for_queries()
 
   reset_root_defaults(mem_root, variables.query_alloc_block_size,
                       variables.query_prealloc_size);
+#ifdef USING_TRANSACTIONS
   reset_root_defaults(&transaction.mem_root,
                       variables.trans_alloc_block_size,
                       variables.trans_prealloc_size);
+#endif
+  transaction.xid.null();
 }
 
 
@@ -333,9 +331,11 @@ void THD::change_user(void)
   cleanup_done= 0;
   init();
   stmt_map.reset();
-  hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
+  hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
 	    (hash_get_key) get_var_key,
 	    (hash_free_key) free_user_var, 0);
+  sp_cache_clear(&sp_proc_cache);
+  sp_cache_clear(&sp_func_cache);
 }
 
 
@@ -344,7 +344,10 @@ void THD::change_user(void)
 void THD::cleanup(void)
 {
   DBUG_ENTER("THD::cleanup");
-  ha_rollback(this);
+#ifdef ENABLE_WHEN_BINLOG_WILL_BE_ABLE_TO_PREPARE
+  if (transaction.xa_state != XA_PREPARED)
+#endif
+    ha_rollback(this);
   if (locked_tables)
   {
     lock=locked_tables; locked_tables=0;
@@ -359,6 +362,8 @@ void THD::cleanup(void)
   my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR));
   delete_dynamic(&user_var_events);
   hash_free(&user_vars);
+  sp_cache_clear(&sp_proc_cache);
+  sp_cache_clear(&sp_func_cache);
   if (global_read_lock)
     unlock_global_read_lock(this);
   if (ull)
@@ -368,6 +373,7 @@ void THD::cleanup(void)
     pthread_mutex_unlock(&LOCK_user_locks);
     ull= 0;
   }
+
   cleanup_done=1;
   DBUG_VOID_RETURN;
 }
@@ -380,24 +386,23 @@ THD::~THD()
   /* Ensure that no one is using THD */
   pthread_mutex_lock(&LOCK_delete);
   pthread_mutex_unlock(&LOCK_delete);
+  add_to_status(&global_status_var, &status_var);
 
   /* Close connection */
-#ifndef EMBEDDED_LIBRARY  
+#ifndef EMBEDDED_LIBRARY
   if (net.vio)
   {
     vio_delete(net.vio);
-    net_end(&net); 
+    net_end(&net);
   }
 #endif
   if (!cleanup_done)
     cleanup();
-#ifdef USING_TRANSACTIONS
-  if (opt_using_transactions)
-  {
-    close_cached_file(&transaction.trans_log);
-    ha_close_connection(this);
-  }
-#endif
+
+  ha_close_connection(this);
+
+  sp_cache_clear(&sp_proc_cache);
+  sp_cache_clear(&sp_func_cache);
 
   DBUG_PRINT("info", ("freeing host"));
   if (host != my_localhost)			// If not pointer to constant
@@ -407,11 +412,13 @@ THD::~THD()
   safeFree(ip);
   safeFree(db);
   free_root(&warn_root,MYF(0));
+#ifdef USING_TRANSACTIONS
   free_root(&transaction.mem_root,MYF(0));
+#endif
   mysys_var=0;					// Safety (shouldn't be needed)
   pthread_mutex_destroy(&LOCK_delete);
 #ifndef DBUG_OFF
-  dbug_sentry = THD_SENTRY_GONE;
+  dbug_sentry= THD_SENTRY_GONE;
 #endif  
   /* Reset stmt_backup.mem_root to not double-free memory from thd.mem_root */
   clear_alloc_root(&stmt_backup.main_mem_root);
@@ -419,14 +426,36 @@ THD::~THD()
 }
 
 
-void THD::awake(bool prepare_to_die)
+/*
+  Add to one status variable another status variable
+
+  NOTES
+    This function assumes that all variables are long/ulong.
+    If this assumption will change, then we have to explictely add
+    the other variables after the while loop
+*/
+
+void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var)
+{
+  ulong *end= (ulong*) ((byte*) to_var + offsetof(STATUS_VAR,
+						  last_system_status_var) +
+			sizeof(ulong));
+  ulong *to= (ulong*) to_var, *from= (ulong*) from_var;
+
+  while (to != end)
+    *(to++)+= *(from++);
+  /* it doesn't make sense to add last_query_cost values */
+}
+
+
+void THD::awake(THD::killed_state state_to_set)
 {
   THD_CHECK_SENTRY(this);
   safe_mutex_assert_owner(&LOCK_delete); 
 
-  if (prepare_to_die)
-    killed = 1;
-  thr_alarm_kill(real_id);
+  killed= state_to_set;
+  if (state_to_set != THD::KILL_QUERY)
+    thr_alarm_kill(real_id);
 #ifdef SIGNAL_WITH_VIO_CLOSE
   close_active_vio();
 #endif    
@@ -485,6 +514,24 @@ bool THD::store_globals()
 }
 
 
+/* Cleanup after a query */
+
+void THD::cleanup_after_query()
+{
+  if (clear_next_insert_id)
+  {
+    clear_next_insert_id= 0;
+    next_insert_id= 0;
+  }
+  /* Free Items that were created during this execution */
+  free_items(free_list);
+  /*
+    In the rest of code we assume that free_list never points to garbage:
+    Keep this predicate true.
+  */
+  free_list= 0;
+}
+
 /*
   Convert a string to another character set
 
@@ -592,7 +639,7 @@ void THD::add_changed_table(TABLE *table)
 
   DBUG_ASSERT((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
 	      table->file->has_transactions());
-  add_changed_table(table->table_cache_key, table->key_length);
+  add_changed_table(table->s->table_cache_key, table->s->key_length);
   DBUG_VOID_RETURN;
 }
 
@@ -646,8 +693,8 @@ CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, long key_length)
   if (!new_table)
   {
     my_error(EE_OUTOFMEMORY, MYF(ME_BELL),
-	     ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
-    killed= 1;
+             ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
+    killed= KILL_CONNECTION;
     return 0;
   }
 
@@ -674,15 +721,16 @@ int THD::send_explain_fields(select_result *result)
   item->maybe_null=1;
   field_list.push_back(item=new Item_empty_string("key", NAME_LEN, cs));
   item->maybe_null=1;
-  field_list.push_back(item=new Item_return_int("key_len",3,
-						MYSQL_TYPE_LONGLONG));
+  field_list.push_back(item=new Item_empty_string("key_len",
+						  NAME_LEN*MAX_KEY));
   item->maybe_null=1;
   field_list.push_back(item=new Item_empty_string("ref",
 						  NAME_LEN*MAX_REF_PARTS, cs));
   item->maybe_null=1;
   field_list.push_back(new Item_return_int("rows", 10, MYSQL_TYPE_LONGLONG));
   field_list.push_back(new Item_empty_string("Extra", 255, cs));
-  return (result->send_fields(field_list,1));
+  return (result->send_fields(field_list,
+                              Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF));
 }
 
 #ifdef SIGNAL_WITH_VIO_CLOSE
@@ -745,10 +793,13 @@ void THD::rollback_item_tree_changes()
 {
   I_List_iterator<Item_change_record> it(change_list);
   Item_change_record *change;
+  DBUG_ENTER("rollback_item_tree_changes");
+
   while ((change= it++))
     *change->place= change->old_value;
   /* We can forget about changes memory: it's allocated in runtime memroot */
   change_list.empty();
+  DBUG_VOID_RETURN;
 }
 
 
@@ -763,7 +814,7 @@ select_result::select_result()
 
 void select_result::send_error(uint errcode,const char *err)
 {
-  ::send_error(thd, errcode, err);
+  my_message(errcode, err, MYF(0));
 }
 
 
@@ -785,9 +836,9 @@ sql_exchange::sql_exchange(char *name,bool flag)
   escaped=    &default_escaped;
 }
 
-bool select_send::send_fields(List<Item> &list,uint flag)
+bool select_send::send_fields(List<Item> &list, uint flags)
 {
-  return thd->protocol->send_fields(&list,flag);
+  return thd->protocol->send_fields(&list, flags);
 }
 
 /* Send data to client. Returns 0 if ok */
@@ -806,7 +857,6 @@ bool select_send::send_data(List<Item> &items)
     InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
     by thd
   */
-  if (thd->transaction.all.innobase_tid)
     ha_release_temporary_latches(thd);
 #endif
 
@@ -841,7 +891,6 @@ bool select_send::send_eof()
   /* We may be passing the control from mysqld to the client: release the
      InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
      by thd */
-  if (thd->transaction.all.innobase_tid)
     ha_release_temporary_latches(thd);
 #endif
 
@@ -867,7 +916,7 @@ bool select_send::send_eof()
 
 void select_to_file::send_error(uint errcode,const char *err)
 {
-  ::send_error(thd,errcode,err);
+  my_message(errcode, err, MYF(0));
   if (file > 0)
   {
     (void) end_io_cache(&cache);
@@ -1191,7 +1240,7 @@ bool select_dump::send_data(List<Item> &items)
   }
   if (row_count++ > 1) 
   {
-    my_error(ER_TOO_MANY_ROWS, MYF(0));
+    my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
     goto err;
   }
   while ((item=li++))
@@ -1204,7 +1253,7 @@ bool select_dump::send_data(List<Item> &items)
     }
     else if (my_b_write(&cache,(byte*) res->ptr(),res->length()))
     {
-      my_error(ER_ERROR_ON_WRITE,MYF(0), path, my_errno);
+      my_error(ER_ERROR_ON_WRITE, MYF(0), path, my_errno);
       goto err;
     }
   }
@@ -1280,6 +1329,9 @@ bool select_max_min_finder_subselect::send_data(List<Item> &items)
       case STRING_RESULT:
 	op= &select_max_min_finder_subselect::cmp_str;
 	break;
+      case DECIMAL_RESULT:
+        op= &select_max_min_finder_subselect::cmp_decimal;
+        break;
       case ROW_RESULT:
         // This case should never be choosen
 	DBUG_ASSERT(0);
@@ -1296,15 +1348,14 @@ bool select_max_min_finder_subselect::send_data(List<Item> &items)
 bool select_max_min_finder_subselect::cmp_real()
 {
   Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
-  double val1= cache->val(), val2= maxmin->val();
+  double val1= cache->val_real(), val2= maxmin->val_real();
   if (fmax)
     return (cache->null_value && !maxmin->null_value) ||
       (!cache->null_value && !maxmin->null_value &&
        val1 > val2);
-  else
-    return (maxmin->null_value && !cache->null_value) ||
-      (!cache->null_value && !maxmin->null_value &&
-       val1 < val2);
+  return (maxmin->null_value && !cache->null_value) ||
+    (!cache->null_value && !maxmin->null_value &&
+     val1 < val2);
 }
 
 bool select_max_min_finder_subselect::cmp_int()
@@ -1315,10 +1366,23 @@ bool select_max_min_finder_subselect::cmp_int()
     return (cache->null_value && !maxmin->null_value) ||
       (!cache->null_value && !maxmin->null_value &&
        val1 > val2);
-  else
-    return (maxmin->null_value && !cache->null_value) ||
+  return (maxmin->null_value && !cache->null_value) ||
+    (!cache->null_value && !maxmin->null_value &&
+     val1 < val2);
+}
+
+bool select_max_min_finder_subselect::cmp_decimal()
+{
+  Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
+  my_decimal cval, *cvalue= cache->val_decimal(&cval);
+  my_decimal mval, *mvalue= maxmin->val_decimal(&mval);
+  if (fmax)
+    return (cache->null_value && !maxmin->null_value) ||
       (!cache->null_value && !maxmin->null_value &&
-       val1 < val2);
+       my_decimal_cmp(cvalue, mvalue) > 0) ;
+  return (maxmin->null_value && !cache->null_value) ||
+    (!cache->null_value && !maxmin->null_value &&
+     my_decimal_cmp(cvalue,mvalue) < 0);
 }
 
 bool select_max_min_finder_subselect::cmp_str()
@@ -1335,10 +1399,9 @@ bool select_max_min_finder_subselect::cmp_str()
     return (cache->null_value && !maxmin->null_value) ||
       (!cache->null_value && !maxmin->null_value &&
        sortcmp(val1, val2, cache->collation.collation) > 0) ;
-  else
-    return (maxmin->null_value && !cache->null_value) ||
-      (!cache->null_value && !maxmin->null_value &&
-       sortcmp(val1, val2, cache->collation.collation) < 0);
+  return (maxmin->null_value && !cache->null_value) ||
+    (!cache->null_value && !maxmin->null_value &&
+     sortcmp(val1, val2, cache->collation.collation) < 0);
 }
 
 bool select_exists_subselect::send_data(List<Item> &items)
@@ -1363,27 +1426,38 @@ bool select_exists_subselect::send_data(List<Item> &items)
 int select_dumpvar::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
 {
   List_iterator_fast<Item> li(list);
-  List_iterator_fast<LEX_STRING> gl(var_list);
+  List_iterator_fast<my_var> gl(var_list);
   Item *item;
-  LEX_STRING *ls;
+
+  local_vars.empty();				// Clear list if SP
+  unit= u;
+  row_count= 0;
+
   if (var_list.elements != list.elements)
   {
-    my_error(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT, MYF(0));
+    my_message(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT,
+               ER(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT), MYF(0));
     return 1;
   }
-  unit=u;
   while ((item=li++))
   {
-    ls= gl++;
-    Item_func_set_user_var *xx = new Item_func_set_user_var(*ls,item);
-    /*
-      Item_func_set_user_var can't substitute something else on its place =>
-      0 can be passed as last argument (reference on item)
-    */
-    xx->fix_fields(thd,(TABLE_LIST*) thd->lex->select_lex.table_list.first,
-		   0);
-    xx->fix_length_and_dec();
-    vars.push_back(xx);
+    my_var *mv= gl++;
+    if (mv->local)
+      (void)local_vars.push_back(new Item_splocal(mv->s, mv->offset));
+    else
+    {
+      Item_func_set_user_var *xx = new Item_func_set_user_var(mv->s, item);
+      /*
+        Item_func_set_user_var can't substitute something else on its place =>
+        0 can be passed as last argument (reference on item)
+        Item_func_set_user_var can't be fixed after creation, so we do not
+        check xx->fixed
+      */
+      xx->fix_fields(thd, (TABLE_LIST*) thd->lex->select_lex.table_list.first,
+		     0);
+      xx->fix_length_and_dec();
+      vars.push_back(xx);
+    }
   }
   return 0;
 }
@@ -1444,7 +1518,7 @@ Item_arena::Item_arena(bool init_mem_root)
 
 Item_arena::Type Item_arena::type() const
 {
-  DBUG_ASSERT("Item_arena::type()" == "abstract");
+  DBUG_ASSERT(0); /* Should never be called */
   return STATEMENT;
 }
 
@@ -1460,7 +1534,8 @@ Statement::Statement(THD *thd)
   allow_sum_func(0),
   lex(&main_lex),
   query(0),
-  query_length(0)
+  query_length(0),
+  cursor(0)
 {
   name.str= NULL;
 }
@@ -1478,7 +1553,8 @@ Statement::Statement()
   allow_sum_func(0),                            /* initialized later */
   lex(&main_lex),
   query(0),                                     /* these two are set */ 
-  query_length(0)                               /* in alloc_query() */
+  query_length(0),                              /* in alloc_query() */
+  cursor(0)
 {
 }
 
@@ -1497,6 +1573,7 @@ void Statement::set_statement(Statement *stmt)
   lex=            stmt->lex;
   query=          stmt->query;
   query_length=   stmt->query_length;
+  cursor=         stmt->cursor;
 }
 
 
@@ -1521,8 +1598,8 @@ void THD::end_statement()
   lex_end(lex);
   delete lex->result;
   lex->result= 0;
-  free_items(free_list);
-  free_list= 0;
+  /* Note that free_list is freed in cleanup_after_query() */
+
   /*
     Don't free mem_root, as mem_root is freed in the end of dispatch_command
     (once for any command).
@@ -1533,8 +1610,12 @@ void THD::end_statement()
 void Item_arena::set_n_backup_item_arena(Item_arena *set, Item_arena *backup)
 {
   DBUG_ENTER("Item_arena::set_n_backup_item_arena");
+  DBUG_ASSERT(backup_arena == 0);
   backup->set_item_arena(this);
   set_item_arena(set);
+#ifndef DBUG_OFF
+  backup_arena= 1;
+#endif
   DBUG_VOID_RETURN;
 }
 
@@ -1544,6 +1625,9 @@ void Item_arena::restore_backup_item_arena(Item_arena *set, Item_arena *backup)
   DBUG_ENTER("Item_arena::restore_backup_item_arena");
   set->set_item_arena(this);
   set_item_arena(backup);
+#ifndef DBUG_OFF
+  backup_arena= 0;
+#endif
 #ifdef NOT_NEEDED_NOW
   /*
     Reset backup mem_root to avoid its freeing.
@@ -1634,8 +1718,18 @@ int Statement_map::insert(Statement *statement)
 bool select_dumpvar::send_data(List<Item> &items)
 {
   List_iterator_fast<Item_func_set_user_var> li(vars);
+  List_iterator_fast<Item_splocal> var_li(local_vars);
+  List_iterator_fast<my_var> my_li(var_list);
+  List_iterator<Item> it(items);
   Item_func_set_user_var *xx;
+  Item_splocal *yy;
+  my_var *zz;
   DBUG_ENTER("send_data");
+  if (unit->offset_limit_cnt)
+  {						// using limit offset,count
+    unit->offset_limit_cnt--;
+    DBUG_RETURN(0);
+  }
 
   if (unit->offset_limit_cnt)
   {				          // Using limit offset,count
@@ -1644,29 +1738,39 @@ bool select_dumpvar::send_data(List<Item> &items)
   }
   if (row_count++) 
   {
-    my_error(ER_TOO_MANY_ROWS, MYF(0));
+    my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
     DBUG_RETURN(1);
   }
-  while ((xx=li++))
+  while ((zz=my_li++) && (it++))
   {
-    xx->check();
-    xx->update();
+    if (zz->local)
+    {
+      if ((yy=var_li++)) 
+      {
+	if (thd->spcont->set_item_eval(current_thd,
+				       yy->get_offset(), it.ref(), zz->type))
+	  DBUG_RETURN(1);
+      }
+    }
+    else
+    {
+      if ((xx=li++))
+      {
+        xx->check();
+	xx->update();
+      }
+    }
   }
   DBUG_RETURN(0);
 }
 
 bool select_dumpvar::send_eof()
 {
-  if (row_count)
-  {
-    ::send_ok(thd,row_count);
-    return 0;
-  }
-  else
-  {
-    my_error(ER_EMPTY_QUERY,MYF(0));
-    return 1;
-  }
+  if (! row_count)
+    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                 ER_SP_FETCH_NO_DATA, ER(ER_SP_FETCH_NO_DATA));
+  ::send_ok(thd,row_count);
+  return 0;
 }
 
 /****************************************************************************
@@ -1678,4 +1782,33 @@ void TMP_TABLE_PARAM::init()
   field_count= sum_func_count= func_count= hidden_field_count= 0;
   group_parts= group_length= group_null_parts= 0;
   quick_group= 1;
+  table_charset= 0;
+}
+
+
+void thd_increment_bytes_sent(ulong length)
+{
+  THD *thd=current_thd;
+  if (likely(thd != 0))
+  { /* current_thd==0 when close_connection() calls net_send_error() */
+    thd->status_var.bytes_sent+= length;
+  }
+}
+
+
+void thd_increment_bytes_received(ulong length)
+{
+  current_thd->status_var.bytes_received+= length;
+}
+
+
+void thd_increment_net_big_packet_count(ulong length)
+{
+  current_thd->status_var.net_big_packet_count+= length;
+}
+
+
+void THD::set_status_var_init()
+{
+  bzero((char*) &status_var, sizeof(status_var));
 }