Merge mysql.com:/home/nick/mysql/repository/mysql-4.1

into mysql.com:/home/nick/mysql/mysql-4.1


BitKeeper/etc/ignore:
  auto-union
sql/sql_yacc.yy:
  Auto merged

27 files changed, 299 insertions, 166 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 8f61e053d27..d8742d487f9 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -4316,17 +4316,15 @@ int Field_blob::store(const char *from,uint len,CHARSET_INFO *cs)
 
 int Field_blob::store(double nr)
 {
-  value.set(nr);
-  return Field_blob::store(value.ptr(),(uint) value.length(),
-			   default_charset_info);
+  value.set(nr,2,my_thd_charset);
+  return Field_blob::store(value.ptr(),(uint) value.length(), value.charset());
 }
 
 
 int Field_blob::store(longlong nr)
 {
-  value.set(nr);
-  return Field_blob::store(value.ptr(), (uint) value.length(),
-			   default_charset_info);
+  value.set(nr,my_thd_charset);
+  return Field_blob::store(value.ptr(), (uint) value.length(), value.charset());
 }
 
 
@@ -5285,19 +5283,19 @@ Field *make_field(char *ptr, uint32 field_length,
 			  unireg_check, field_name, table);
   case FIELD_TYPE_DATE:
     return new Field_date(ptr,null_pos,null_bit,
-			  unireg_check, field_name, table);
+			  unireg_check, field_name, table, field_charset);
   case FIELD_TYPE_NEWDATE:
     return new Field_newdate(ptr,null_pos,null_bit,
-			     unireg_check, field_name, table);
+			     unireg_check, field_name, table, field_charset);
   case FIELD_TYPE_TIME:
     return new Field_time(ptr,null_pos,null_bit,
-			  unireg_check, field_name, table);
+			  unireg_check, field_name, table, field_charset);
   case FIELD_TYPE_DATETIME:
     return new Field_datetime(ptr,null_pos,null_bit,
-			      unireg_check, field_name, table);
+			      unireg_check, field_name, table, field_charset);
   case FIELD_TYPE_NULL:
     default:					// Impossible (Wrong version)
-    return new Field_null(ptr,field_length,unireg_check,field_name,table);
+    return new Field_null(ptr,field_length,unireg_check,field_name,table, field_charset);
   }
   return 0;					// Impossible (Wrong version)
 }
diff --git a/sql/field.h b/sql/field.h
index e4c1bd046ab..6505b2c8462 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -528,9 +528,9 @@ class Field_null :public Field_str {
 public:
   Field_null(char *ptr_arg, uint32 len_arg,
 	     enum utype unireg_check_arg, const char *field_name_arg,
-	     struct st_table *table_arg)
+	     struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str(ptr_arg, len_arg, null, 1,
-	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
+	       unireg_check_arg, field_name_arg, table_arg, cs)
     {}
   enum_field_types type() const { return FIELD_TYPE_NULL;}
   int  store(const char *to, uint length, CHARSET_INFO *cs) { null[0]=1; return 0; }
@@ -544,7 +544,7 @@ public:
   int cmp(const char *a, const char *b) { return 0;}
   void sort_string(char *buff, uint length)  {}
   uint32 pack_length() const { return 0; }
-  void sql_type(String &str) const { str.set("null",4,default_charset_info); }
+  void sql_type(String &str) const { str.set("null",4,my_thd_charset); }
   uint size_of() const { return sizeof(*this); }
 };
 
@@ -615,14 +615,14 @@ class Field_date :public Field_str {
 public:
   Field_date(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
 	     enum utype unireg_check_arg, const char *field_name_arg,
-	     struct st_table *table_arg)
+	     struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
-	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
+	       unireg_check_arg, field_name_arg, table_arg, cs)
     {}
   Field_date(bool maybe_null_arg, const char *field_name_arg,
-		 struct st_table *table_arg)
+		 struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str((char*) 0,10, maybe_null_arg ? (uchar*) "": 0,0,
-	       NONE, field_name_arg, table_arg, default_charset_info) {}
+	       NONE, field_name_arg, table_arg, cs) {}
   enum_field_types type() const { return FIELD_TYPE_DATE;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
   enum Item_result cmp_type () const { return INT_RESULT; }
@@ -645,9 +645,9 @@ class Field_newdate :public Field_str {
 public:
   Field_newdate(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
 		enum utype unireg_check_arg, const char *field_name_arg,
-		struct st_table *table_arg)
+		struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
-	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
+	       unireg_check_arg, field_name_arg, table_arg, cs)
     {}
   enum_field_types type() const { return FIELD_TYPE_DATE;}
   enum_field_types real_type() const { return FIELD_TYPE_NEWDATE; }
@@ -676,14 +676,14 @@ class Field_time :public Field_str {
 public:
   Field_time(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
 	     enum utype unireg_check_arg, const char *field_name_arg,
-	     struct st_table *table_arg)
+	     struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
-	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
+	       unireg_check_arg, field_name_arg, table_arg, cs)
     {}
   Field_time(bool maybe_null_arg, const char *field_name_arg,
-		 struct st_table *table_arg)
+		 struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str((char*) 0,8, maybe_null_arg ? (uchar*) "": 0,0,
-	       NONE, field_name_arg, table_arg, default_charset_info) {}
+	       NONE, field_name_arg, table_arg, cs) {}
   enum_field_types type() const { return FIELD_TYPE_TIME;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; }
   enum Item_result cmp_type () const { return INT_RESULT; }
@@ -708,14 +708,14 @@ class Field_datetime :public Field_str {
 public:
   Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
 		 enum utype unireg_check_arg, const char *field_name_arg,
-		 struct st_table *table_arg)
+		 struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
-	       unireg_check_arg, field_name_arg, table_arg, default_charset_info)
+	       unireg_check_arg, field_name_arg, table_arg, cs)
     {}
   Field_datetime(bool maybe_null_arg, const char *field_name_arg,
-		 struct st_table *table_arg)
+		 struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str((char*) 0,19, maybe_null_arg ? (uchar*) "": 0,0,
-	       NONE, field_name_arg, table_arg, default_charset_info) {}
+	       NONE, field_name_arg, table_arg, cs) {}
   enum_field_types type() const { return FIELD_TYPE_DATETIME;}
 #ifdef HAVE_LONG_LONG
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }
diff --git a/sql/filesort.cc b/sql/filesort.cc
index 6fb9c699ffc..13c48b745cd 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -950,7 +950,7 @@ sortlength(SORT_FIELD *sortorder, uint s_length)
 #ifdef USE_STRCOLL
 	if (!sortorder->item->binary())
 	{ 
-	  CHARSET_INFO *cs=sortorder->item->str_value.charset();
+	  CHARSET_INFO *cs=sortorder->item->charset();
 	  if (use_strnxfrm(cs))
 	    sortorder->length= sortorder->length*cs->strxfrm_multiply;
 	}
diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc
index 131e38a6bc3..6d5b469a913 100644
--- a/sql/ha_berkeley.cc
+++ b/sql/ha_berkeley.cc
@@ -194,12 +194,12 @@ bool berkeley_flush_logs()
   int error;
   bool result=0;
   DBUG_ENTER("berkeley_flush_logs");
-  if ((error=log_flush(db_env,0)))
+  if ((error=db_env->log_flush(db_env,0)))
   {
     my_error(ER_ERROR_DURING_FLUSH_LOGS,MYF(0),error); /* purecov: inspected */
     result=1; /* purecov: inspected */
   }
-  if ((error=txn_checkpoint(db_env,0,0,0)))
+  if ((error=db_env->txn_checkpoint(db_env,0,0,0)))
   {
     my_error(ER_ERROR_DURING_CHECKPOINT,MYF(0),error); /* purecov: inspected */
     result=1; /* purecov: inspected */
@@ -243,10 +243,8 @@ int berkeley_show_logs(THD *thd)
   init_alloc_root(&show_logs_root, 1024, 1024);
   my_pthread_setspecific_ptr(THR_MALLOC,&show_logs_root);
 
-  if ((error= log_archive(db_env, &all_logs, DB_ARCH_ABS | DB_ARCH_LOG,
-			  (void* (*)(size_t)) sql_alloc)) ||
-      (error= log_archive(db_env, &free_logs, DB_ARCH_ABS, 
-			  (void* (*)(size_t)) sql_alloc)))
+  if ((error= db_env->log_archive(db_env, &all_logs, DB_ARCH_ABS | DB_ARCH_LOG))
+      || (error= db_env->log_archive(db_env, &free_logs, DB_ARCH_ABS)))
   {
     DBUG_PRINT("error", ("log_archive failed (error %d)", error));
     db_env->err(db_env, error, "log_archive: DB_ARCH_ABS");
@@ -309,10 +307,10 @@ void berkeley_cleanup_log_files(void)
 
   /* XXX: Probably this should be done somewhere else, and
    * should be tunable by the user. */
-  if ((error = txn_checkpoint(db_env, 0, 0, 0)))
+  if ((error = db_env->txn_checkpoint(db_env, 0, 0, 0)))
     my_error(ER_ERROR_DURING_CHECKPOINT, MYF(0), error); /* purecov: inspected */
 
-  if ((error = log_archive(db_env, &names, DB_ARCH_ABS, NULL)) != 0)
+  if ((error = db_env->log_archive(db_env, &names, DB_ARCH_ABS)) != 0)
   {
     DBUG_PRINT("error", ("log_archive failed (error %d)", error)); /* purecov: inspected */
     db_env->err(db_env, error, "log_archive: DB_ARCH_ABS"); /* purecov: inspected */
@@ -512,9 +510,11 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked)
 			  berkeley_cmp_packed_key));
     if (!hidden_primary_key)
       file->app_private= (void*) (table->key_info+table->primary_key);
-    if ((error=(file->open(file, fn_format(name_buff,name,"", ha_berkeley_ext,
-					   2 | 4),
-			   "main", DB_BTREE, open_mode,0))))
+    if ((error= txn_begin(db_env, 0, (DB_TXN**) &transaction, 0)) ||
+	(error= (file->open(file, transaction,
+			    fn_format(name_buff, name, "", ha_berkeley_ext, 2 | 4),
+			    "main", DB_BTREE, open_mode, 0))) ||
+	(error= transaction->commit(transaction, 0)))
     {
       free_share(share,table, hidden_primary_key,1); /* purecov: inspected */
       my_free((char*) rec_buff,MYF(0)); /* purecov: inspected */
@@ -545,8 +545,10 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked)
 	(*ptr)->app_private= (void*) (table->key_info+i);
 	if (!(table->key_info[i].flags & HA_NOSAME))
 	  (*ptr)->set_flags(*ptr, DB_DUP);
-	if ((error=((*ptr)->open(*ptr, name_buff, part, DB_BTREE,
-				 open_mode, 0))))
+	if ((error= txn_begin(db_env, 0, (DB_TXN**) &transaction, 0)) ||
+	    (error=((*ptr)->open(*ptr, transaction, name_buff, part, DB_BTREE,
+				 open_mode, 0))) ||
+	    (error= transaction->commit(transaction, 0)))
 	{
 	  close();				/* purecov: inspected */
 	  my_errno=error;			/* purecov: inspected */
@@ -1836,7 +1838,7 @@ static int create_sub_table(const char *table_name, const char *sub_name,
   if (!(error=db_create(&file, db_env, 0)))
   {
     file->set_flags(file, flags);
-    error=(file->open(file, table_name, sub_name, type,
+    error=(file->open(file, NULL, table_name, sub_name, type,
 		      DB_THREAD | DB_CREATE, my_umask));
     if (error)
     {
@@ -1892,7 +1894,7 @@ int ha_berkeley::create(const char *name, register TABLE *form,
   DB *status_block;
   if (!db_create(&status_block, db_env, 0))
   {
-    if (!status_block->open(status_block, name_buff,
+    if (!status_block->open(status_block, NULL, name_buff,
 			    "status", DB_BTREE, DB_CREATE, 0))
     {
       char rec_buff[4+MAX_KEY*4];
@@ -2080,7 +2082,7 @@ int ha_berkeley::analyze(THD* thd, HA_CHECK_OPT* check_opt)
       free(stat);
       stat=0;
     }
-    if (key_file[i]->stat(key_file[i], (void*) &stat, 0, 0))
+    if (key_file[i]->stat(key_file[i], (void*) &stat, 0))
       goto err; /* purecov: inspected */
     share->rec_per_key[i]= (stat->bt_ndata /
 			    (stat->bt_nkeys ? stat->bt_nkeys : 1));
@@ -2093,7 +2095,7 @@ int ha_berkeley::analyze(THD* thd, HA_CHECK_OPT* check_opt)
       free(stat);
       stat=0;
     }
-    if (file->stat(file, (void*) &stat, 0, 0))
+    if (file->stat(file, (void*) &stat, 0))
       goto err; /* purecov: inspected */
   }
   pthread_mutex_lock(&share->mutex);
@@ -2296,7 +2298,7 @@ void ha_berkeley::get_status()
       fn_format(name_buff, share->table_name,"", ha_berkeley_ext, 2 | 4);
       if (!db_create(&share->status_block, db_env, 0))
       {
-	if (share->status_block->open(share->status_block, name_buff,
+	if (share->status_block->open(share->status_block, NULL, name_buff,
 				      "status", DB_BTREE, open_mode, 0))
 	{
 	  share->status_block->close(share->status_block, 0); /* purecov: inspected */
@@ -2372,7 +2374,7 @@ static void update_status(BDB_SHARE *share, TABLE *table)
       if (db_create(&share->status_block, db_env, 0)) /* purecov: inspected */
 	goto end; /* purecov: inspected */
       share->status_block->set_flags(share->status_block,0); /* purecov: inspected */
-      if (share->status_block->open(share->status_block,
+      if (share->status_block->open(share->status_block, NULL,
 				    fn_format(name_buff,share->table_name,"",
 					      ha_berkeley_ext,2 | 4),
 				    "status", DB_BTREE,
diff --git a/sql/item.cc b/sql/item.cc
index f8404f40421..7673aaf097e 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -132,7 +132,7 @@ void Item_field::set_field(Field *field_par)
   table_name=field_par->table_name;
   field_name=field_par->field_name;
   unsigned_flag=test(field_par->flags & UNSIGNED_FLAG);
-  str_value.set_charset(field_par->charset());
+  set_charset(field_par->charset());
 }
 
 const char *Item_ident::full_name() const
@@ -234,7 +234,7 @@ table_map Item_field::used_tables() const
 
 String *Item_int::val_str(String *str)
 {
-  str->set(value);
+  str->set(value, my_thd_charset);
   return str;
 }
 
@@ -242,7 +242,7 @@ void Item_int::print(String *str)
 {
   if (!name)
   {
-    str_value.set(value);
+    str_value.set(value, my_thd_charset);
     name=str_value.c_ptr();
   }
   str->append(name);
@@ -250,7 +250,7 @@ void Item_int::print(String *str)
 
 String *Item_uint::val_str(String *str)
 {
-  str->set((ulonglong) value);
+  str->set((ulonglong) value, my_thd_charset);
   return str;
 }
 
@@ -258,7 +258,7 @@ void Item_uint::print(String *str)
 {
   if (!name)
   {
-    str_value.set((ulonglong) value);
+    str_value.set((ulonglong) value, my_thd_charset);
     name=str_value.c_ptr();
   }
   str->append(name);
@@ -267,7 +267,7 @@ void Item_uint::print(String *str)
 
 String *Item_real::val_str(String *str)
 {
-  str->set(value,decimals);
+  str->set(value,decimals,my_thd_charset);
   return str;
 }
 
@@ -384,10 +384,10 @@ String *Item_param::val_str(String* str)
 { 
   switch (item_result_type) {
   case INT_RESULT:
-    str->set(int_value);
+    str->set(int_value, my_thd_charset);
     return str;
   case REAL_RESULT:
-    str->set(real_value);
+    str->set(real_value, 2, my_thd_charset);
     return str;
   default:
     return (String*) &str_value;
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 6fce3df683a..8b2b2fc83a3 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -228,11 +228,9 @@ Field *Item_func::tmp_table_field(TABLE *t_arg)
     break;
   case STRING_RESULT:
     if (max_length > 255)
-      res= new Field_blob(max_length, maybe_null, name, t_arg, 
-			  str_value.charset());
+      res= new Field_blob(max_length, maybe_null, name, t_arg, charset());
     else
-      res= new Field_string(max_length, maybe_null, name, t_arg, 
-			    str_value.charset());
+      res= new Field_string(max_length, maybe_null, name, t_arg, charset());
     break;
   }
   return res;
@@ -245,7 +243,7 @@ String *Item_real_func::val_str(String *str)
   if (null_value)
     return 0; /* purecov: inspected */
   else
-    str->set(nr,decimals);
+    str->set(nr,decimals,my_thd_charset);
   return str;
 }
 
@@ -258,9 +256,9 @@ String *Item_num_func::val_str(String *str)
     if (null_value)
       return 0; /* purecov: inspected */
     else if (!unsigned_flag)
-      str->set(nr);
+      str->set(nr,my_thd_charset);
     else
-      str->set((ulonglong) nr);
+      str->set((ulonglong) nr,my_thd_charset);
   }
   else
   {
@@ -268,7 +266,7 @@ String *Item_num_func::val_str(String *str)
     if (null_value)
       return 0; /* purecov: inspected */
     else
-      str->set(nr,decimals);
+      str->set(nr,decimals,my_thd_charset);
   }
   return str;
 }
@@ -288,9 +286,9 @@ String *Item_int_func::val_str(String *str)
   if (null_value)
     return 0;
   else if (!unsigned_flag)
-    str->set(nr);
+    str->set(nr,my_thd_charset);
   else
-    str->set((ulonglong) nr);
+    str->set((ulonglong) nr,my_thd_charset);
   return str;
 }
 
@@ -317,9 +315,9 @@ String *Item_num_op::val_str(String *str)
     if (null_value)
       return 0; /* purecov: inspected */
     else if (!unsigned_flag)
-      str->set(nr);
+      str->set(nr,my_thd_charset);
     else
-      str->set((ulonglong) nr);
+      str->set((ulonglong) nr,my_thd_charset);
   }
   else
   {
@@ -327,7 +325,7 @@ String *Item_num_op::val_str(String *str)
     if (null_value)
       return 0; /* purecov: inspected */
     else
-      str->set(nr,decimals);
+      str->set(nr,decimals,my_thd_charset);
   }
   return str;
 }
@@ -815,9 +813,9 @@ String *Item_func_min_max::val_str(String *str)
     if (null_value)
       return 0;
     else if (!unsigned_flag)
-      str->set(nr);
+      str->set(nr,my_thd_charset);
     else
-      str->set((ulonglong) nr);
+      str->set((ulonglong) nr,my_thd_charset);
     return str;
   }
   case REAL_RESULT:
@@ -826,7 +824,7 @@ String *Item_func_min_max::val_str(String *str)
     if (null_value)
       return 0; /* purecov: inspected */
     else
-      str->set(nr,decimals);
+      str->set(nr,decimals,my_thd_charset);
     return str;
   }
   case STRING_RESULT:
@@ -1449,7 +1447,7 @@ String *Item_func_udf_float::val_str(String *str)
   if (null_value)
     return 0;					/* purecov: inspected */
   else
-    str->set(nr,decimals);
+    str->set(nr,decimals,my_thd_charset);
   return str;
 }
 
@@ -1470,9 +1468,9 @@ String *Item_func_udf_int::val_str(String *str)
   if (null_value)
     return 0;
   else if (!unsigned_flag)
-    str->set(nr);
+    str->set(nr,my_thd_charset);
   else
-    str->set((ulonglong) nr);
+    str->set((ulonglong) nr,my_thd_charset);
   return str;
 }
 
@@ -2036,10 +2034,10 @@ Item_func_get_user_var::val_str(String *str)
     return NULL;
   switch (entry->type) {
   case REAL_RESULT:
-    str->set(*(double*) entry->value,decimals);
+    str->set(*(double*) entry->value,decimals,my_thd_charset);
     break;
   case INT_RESULT:
-    str->set(*(longlong*) entry->value);
+    str->set(*(longlong*) entry->value,my_thd_charset);
     break;
   case STRING_RESULT:
     if (str->copy(entry->value, entry->length-1))
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index c744e5ed77a..20b01c9f1e8 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -1469,7 +1469,7 @@ String *Item_func_format::val_str(String *str)
   if ((null_value=args[0]->null_value))
     return 0; /* purecov: inspected */
   dec= decimals ? decimals+1 : 0;
-  str->set(nr,decimals);
+  str->set(nr,decimals,my_thd_charset);
   str_length=str->length();
   if (nr < 0)
     str_length--;				// Don't count sign
diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h
index aab67f21649..14dadc96891 100644
--- a/sql/item_strfunc.h
+++ b/sql/item_strfunc.h
@@ -469,7 +469,7 @@ public:
    }
   void fix_length_and_dec() 
   { 
-    str_value.set_charset(my_charset_bin); 
+    set_charset(my_charset_bin); 
     max_length=args[0]->max_length; 
   }
   void print(String *str) { print_op(str); }
@@ -485,7 +485,7 @@ public:
   const char *func_name() const { return "load_file"; }
   void fix_length_and_dec()
   { 
-    str_value.set_charset(my_charset_bin);
+    set_charset(my_charset_bin);
     maybe_null=1; 
     max_length=MAX_BLOB_WIDTH;
   }
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 456ce5f22ba..82310710a9d 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -200,7 +200,7 @@ String *Item_exists_subselect::val_str(String *str)
     assign_null();
     return 0;
   }
-  str->set(value);
+  str->set(value,my_thd_charset);
   return str;
 }
 
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 46e6b146380..ae1a86845bf 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -93,7 +93,7 @@ Item_sum_num::val_str(String *str)
   double nr=val();
   if (null_value)
     return 0;
-  str->set(nr,decimals);
+  str->set(nr,decimals,my_thd_charset);
   return str;
 }
 
@@ -359,13 +359,13 @@ Item_sum_hybrid::val_str(String *str)
   case STRING_RESULT:
     return &value;
   case REAL_RESULT:
-    str->set(sum,decimals);
+    str->set(sum,decimals,my_thd_charset);
     break;
   case INT_RESULT:
     if (unsigned_flag)
-      str->set((ulonglong) sum_int);
+      str->set((ulonglong) sum_int,my_thd_charset);
     else
-      str->set((longlong) sum_int);
+      str->set((longlong) sum_int,my_thd_charset);
     break;
   }
   return str;					// Keep compiler happy
@@ -810,7 +810,7 @@ String *Item_avg_field::val_str(String *str)
   double nr=Item_avg_field::val();
   if (null_value)
     return 0;
-  str->set(nr,decimals);
+  str->set(nr,decimals,my_thd_charset);
   return str;
 }
 
@@ -847,7 +847,7 @@ String *Item_std_field::val_str(String *str)
   double nr=val();
   if (null_value)
     return 0;
-  str->set(nr,decimals);
+  str->set(nr,decimals,my_thd_charset);
   return str;
 }
 
@@ -1174,7 +1174,7 @@ String *Item_sum_udf_float::val_str(String *str)
   if (null_value)
     return 0;					/* purecov: inspected */
   else
-    str->set(nr,decimals);
+    str->set(nr,decimals,my_thd_charset);
   return str;
 }
 
@@ -1193,7 +1193,7 @@ String *Item_sum_udf_int::val_str(String *str)
   if (null_value)
     return 0;
   else
-    str->set(nr);
+    str->set(nr,my_thd_charset);
   return str;
 }
 
diff --git a/sql/item_timefunc.h b/sql/item_timefunc.h
index 94e8e6eba43..fab8ea9fa9c 100644
--- a/sql/item_timefunc.h
+++ b/sql/item_timefunc.h
@@ -67,7 +67,11 @@ public:
   Item_func_month(Item *a) :Item_func(a) {}
   longlong val_int();
   double val() { return (double) Item_func_month::val_int(); }
-  String *val_str(String *str) { str->set(val_int()); return null_value ? 0 : str;}
+  String *val_str(String *str) 
+  {
+    str->set(val_int(), my_thd_charset);
+    return null_value ? 0 : str;
+  }
   const char *func_name() const { return "month"; }
   enum Item_result result_type () const { return INT_RESULT; }
   void fix_length_and_dec() { decimals=0; max_length=2; maybe_null=1; }
@@ -172,7 +176,10 @@ public:
     :Item_func(a), odbc_type(type_arg) {}
   longlong val_int();
   double val() { return (double) val_int(); }
-  String *val_str(String *str) { str->set(val_int()); return null_value ? 0 : str;}
+  String *val_str(String *str) { 
+    str->set(val_int(), my_thd_charset);
+    return null_value ? 0 : str;
+  }
   const char *func_name() const { return "weekday"; }
   enum Item_result result_type () const { return INT_RESULT; }
   void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=1; }
@@ -236,7 +243,7 @@ public:
   }
   Field *tmp_table_field(TABLE *t_arg)
   {
-    return (!t_arg) ? result_field : new Field_date(maybe_null, name, t_arg);
+    return (!t_arg) ? result_field : new Field_date(maybe_null, name, t_arg, my_thd_charset);
   }  
 };
 
@@ -254,7 +261,7 @@ public:
   Field *tmp_table_field(TABLE *t_arg)
   {
     return  (!t_arg) ? result_field : new Field_datetime(maybe_null, name,
-							 t_arg);
+							 t_arg, my_thd_charset);
   }
 };
 
@@ -280,7 +287,8 @@ public:
   }
   Field *tmp_table_field(TABLE *t_arg)
   {
-    return (!t_arg) ? result_field : new Field_time(maybe_null, name, t_arg);
+    return (!t_arg) ? result_field : 
+    		      new Field_time(maybe_null, name, t_arg, my_thd_charset);
   }  
 };
 
@@ -372,7 +380,8 @@ public:
   }
   Field *tmp_table_field(TABLE *t_arg)
   {
-    return (!t_arg) ? result_field : new Field_time(maybe_null, name, t_arg);
+    return (!t_arg) ? result_field : 
+    		      new Field_time(maybe_null, name, t_arg, my_thd_charset);
   }
 };
 
@@ -436,7 +445,8 @@ public:
   }
   Field *tmp_table_field(TABLE *t_arg)
   {
-    return (!t_arg) ? result_field : new Field_date(maybe_null, name, t_arg);
+    return (!t_arg) ? result_field : 
+    		      new Field_date(maybe_null, name, t_arg, my_thd_charset);
   }  
 };
 
@@ -451,7 +461,8 @@ public:
   }
   Field *tmp_table_field(TABLE *t_arg)
   {
-    return (!t_arg) ? result_field : new Field_time(maybe_null, name, t_arg);
+    return (!t_arg) ? result_field : 
+    		      new Field_time(maybe_null, name, t_arg, my_thd_charset);
   }
 };
 
@@ -467,6 +478,6 @@ public:
   Field *tmp_table_field(TABLE *t_arg)
   {
     return (!t_arg) ? result_field : new Field_datetime(maybe_null, name,
-							t_arg);
+							t_arg, my_thd_charset);
   }
 };
diff --git a/sql/lock.cc b/sql/lock.cc
index aed0e1988ea..3b2444c8e9d 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -69,6 +69,12 @@ TODO:
 #include "mysql_priv.h"
 #include <hash.h>
 #include <assert.h>
+#include <ha_myisammrg.h>
+#ifndef MASTER
+#include "../srclib/myisammrg/myrg_def.h"
+#else
+#include "../myisammrg/myrg_def.h"
+#endif
 
 extern HASH open_cache;
 
@@ -154,6 +160,7 @@ retry:
       sql_lock=0;
     }
   }
+
   thd->lock_time();
   DBUG_RETURN (sql_lock);
 }
@@ -410,8 +417,12 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
 	return 0;
       }
     }
+    THR_LOCK_DATA **org_locks = locks;
     locks=table->file->store_lock(thd, locks, get_old_locks ? TL_IGNORE :
 				  lock_type);
+    if (locks)
+      for ( ; org_locks != locks ; org_locks++)
+	(*org_locks)->debug_print_param= (void *) table;
   }
   return sql_lock;
 }
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index f261c9f4632..b7dc51755fb 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -61,6 +61,8 @@ char* query_table_status(THD *thd,const char *db,const char *table_name);
 #endif
 #endif
 
+#define my_thd_charset	default_charset_info
+
 /***************************************************************************
   Configuration parameters
 ****************************************************************************/
diff --git a/sql/procedure.h b/sql/procedure.h
index 349908a8d84..3792d823b12 100644
--- a/sql/procedure.h
+++ b/sql/procedure.h
@@ -62,7 +62,7 @@ public:
   { value=atof(str); }
   double val() { return value; }
   longlong val_int() { return (longlong) value; }
-  String *val_str(String *s) { s->set(value,decimals); return s; }
+  String *val_str(String *s) { s->set(value,decimals,my_thd_charset); return s; }
   unsigned int size_of() { return sizeof(*this);}  
 };
 
@@ -80,7 +80,7 @@ public:
   { value=strtoll(str,NULL,10); }
   double val() { return (double) value; }
   longlong val_int() { return value; }
-  String *val_str(String *s) { s->set(value); return s; }
+  String *val_str(String *s) { s->set(value, my_thd_charset); return s; }
   unsigned int size_of() { return sizeof(*this);}  
 };
 
@@ -92,8 +92,8 @@ public:
     { this->max_length=length; }
   enum Item_result result_type () const { return STRING_RESULT; }
   enum_field_types field_type() const { return FIELD_TYPE_STRING; }
-  void set(double nr) { str_value.set(nr); }
-  void set(longlong nr) { str_value.set(nr); }
+  void set(double nr) { str_value.set(nr, 2, my_thd_charset); }
+  void set(longlong nr) { str_value.set(nr, my_thd_charset); }
   void set(const char *str, uint length) { str_value.copy(str,length); }
   double val() { return atof(str_value.ptr()); }
   longlong val_int() { return strtoll(str_value.ptr(),NULL,10); }
diff --git a/sql/sql_analyse.cc b/sql/sql_analyse.cc
index deb1e2821c1..d1ecdd029d5 100644
--- a/sql/sql_analyse.cc
+++ b/sql/sql_analyse.cc
@@ -903,7 +903,7 @@ int collect_real(double *element, element_count count __attribute__((unused)),
   else
     info->found = 1;
   info->str->append('\'');
-  s.set(*element, info->item->decimals);
+  s.set(*element, info->item->decimals, my_thd_charset);
   info->str->append(s);
   info->str->append('\'');
   return 0;
@@ -922,7 +922,7 @@ int collect_longlong(longlong *element,
   else
     info->found = 1;
   info->str->append('\'');
-  s.set(*element);
+  s.set(*element,default_charset_info);
   info->str->append(s);
   info->str->append('\'');
   return 0;
@@ -941,7 +941,7 @@ int collect_ulonglong(ulonglong *element,
   else
     info->found = 1;
   info->str->append('\'');
-  s.set(*element);
+  s.set(*element,default_charset_info);
   info->str->append(s);
   info->str->append('\'');
   return 0;
diff --git a/sql/sql_analyse.h b/sql/sql_analyse.h
index 403ddbe6fee..ada46374a15 100644
--- a/sql/sql_analyse.h
+++ b/sql/sql_analyse.h
@@ -128,10 +128,10 @@ public:
   String *avg(String *s, ha_rows rows)
   {
     if (!(rows - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
       s->set((ulonglong2double(sum) / ulonglong2double(rows - nulls)),
-	     DEC_IN_AVG);
+	     DEC_IN_AVG,my_thd_charset);
     return s;
   }
   friend int collect_string(String *element, element_count count,
@@ -160,26 +160,34 @@ public:
 
   void	 add();
   void	 get_opt_type(String*, ha_rows);
-  String *get_min_arg(String *s) { s->set(min_arg, item->decimals); return s; }
-  String *get_max_arg(String *s) { s->set(max_arg, item->decimals); return s; }
+  String *get_min_arg(String *s) 
+  { 
+    s->set(min_arg, item->decimals,my_thd_charset); 
+    return s; 
+  }
+  String *get_max_arg(String *s) 
+  { 
+    s->set(max_arg, item->decimals,my_thd_charset);
+    return s; 
+  }
   String *avg(String *s, ha_rows rows)
   {
     if (!(rows - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
-      s->set(((double)sum / (double) (rows - nulls)), item->decimals);
+      s->set(((double)sum / (double) (rows - nulls)), item->decimals,my_thd_charset);
     return s;
   }
   String *std(String *s, ha_rows rows)
   {
     double tmp = ulonglong2double(rows);
     if (!(tmp - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
     {
       double tmp2 = ((sum_sqr - sum * sum / (tmp - nulls)) /
 		     (tmp - nulls));
-      s->set(((double) tmp2 <= 0.0 ? 0.0 : sqrt(tmp2)), item->decimals);
+      s->set(((double) tmp2 <= 0.0 ? 0.0 : sqrt(tmp2)), item->decimals,my_thd_charset);
     }
     return s;
   }
@@ -206,26 +214,26 @@ public:
 
   void	 add();
   void	 get_opt_type(String*, ha_rows);
-  String *get_min_arg(String *s) { s->set(min_arg); return s; }
-  String *get_max_arg(String *s) { s->set(max_arg); return s; }
+  String *get_min_arg(String *s) { s->set(min_arg,my_thd_charset); return s; }
+  String *get_max_arg(String *s) { s->set(max_arg,my_thd_charset); return s; }
   String *avg(String *s, ha_rows rows)
   {
     if (!(rows - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
-      s->set(((double) sum / (double) (rows - nulls)), DEC_IN_AVG);
+      s->set(((double) sum / (double) (rows - nulls)), DEC_IN_AVG,my_thd_charset);
     return s;
   }
   String *std(String *s, ha_rows rows)
   {
     double tmp = ulonglong2double(rows);
     if (!(tmp - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
     {
       double tmp2 = ((sum_sqr - sum * sum / (tmp - nulls)) /
 		    (tmp - nulls));
-      s->set(((double) tmp2 <= 0.0 ? 0.0 : sqrt(tmp2)), DEC_IN_AVG);
+      s->set(((double) tmp2 <= 0.0 ? 0.0 : sqrt(tmp2)), DEC_IN_AVG,my_thd_charset);
     }
     return s;
   }
@@ -250,28 +258,28 @@ public:
 		(qsort_cmp2) compare_ulonglong2, 0, NULL, NULL); }
   void	 add();
   void	 get_opt_type(String*, ha_rows);
-  String *get_min_arg(String *s) { s->set(min_arg); return s; }
-  String *get_max_arg(String *s) { s->set(max_arg); return s; }
+  String *get_min_arg(String *s) { s->set(min_arg,my_thd_charset); return s; }
+  String *get_max_arg(String *s) { s->set(max_arg,my_thd_charset); return s; }
   String *avg(String *s, ha_rows rows)
   {
     if (!(rows - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
       s->set((ulonglong2double(sum) / ulonglong2double(rows - nulls)),
-	     DEC_IN_AVG);
+	     DEC_IN_AVG,my_thd_charset);
     return s;
   }
   String *std(String *s, ha_rows rows)
   {
     double tmp = ulonglong2double(rows);
     if (!(tmp - nulls))
-      s->set((double) 0.0, 1);
+      s->set((double) 0.0, 1,my_thd_charset);
     else
     {
       double tmp2 = ((ulonglong2double(sum_sqr) - 
 		     ulonglong2double(sum * sum) / (tmp - nulls)) /
 		     (tmp - nulls));
-      s->set(((double) tmp2 <= 0.0 ? 0.0 : sqrt(tmp2)), DEC_IN_AVG);
+      s->set(((double) tmp2 <= 0.0 ? 0.0 : sqrt(tmp2)), DEC_IN_AVG,my_thd_charset);
     }
     return s;
   }
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 8de536d066d..887ee262777 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -108,6 +108,7 @@ THD::THD():user_time(0), fatal_error(0),
   file_id = 0;
   cond_count=0;
   db_charset=default_charset_info;
+  thd_charset=default_charset_info;
   mysys_var=0;
 #ifndef DBUG_OFF
   dbug_sentry=THD_SENTRY_MAGIC;
diff --git a/sql/sql_class.h b/sql/sql_class.h
index e38a33f9ea7..d46826c928d 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -481,6 +481,7 @@ public:
   table_map  used_tables;
   USER_CONN *user_connect;
   CHARSET_INFO *db_charset;   
+  CHARSET_INFO *thd_charset;
   List	     <MYSQL_ERROR> warn_list;  
   uint	     warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END];
   uint	     total_warn_count, old_total_warn_count;
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 58b12bca00d..25a69f7e51b 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -592,7 +592,7 @@ bool mysql_change_db(THD *thd, const char *name)
   strmov(path+unpack_dirname(path,path), MY_DB_OPT_FILE);
   load_db_opt(path, &create);
   thd->db_charset=create.table_charset;
-
+  thd->thd_charset=thd->db_charset ? thd->db_charset : default_charset_info;
   DBUG_RETURN(0);
 }
 
diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc
index 81eade6edb7..9cc83a3835a 100644
--- a/sql/sql_derived.cc
+++ b/sql/sql_derived.cc
@@ -70,7 +70,7 @@ int mysql_derived(THD *thd, LEX *lex, SELECT_LEX_UNIT *unit, TABLE_LIST *t,
     
   if (tables_is_opened || !(res=open_and_lock_tables(thd,tables)))
   {
-    if (tables && setup_fields(thd,tables,item_list,0,0,1))
+    if (setup_fields(thd,tables,item_list,0,0,1))
     {
       res=-1;
       goto exit;
@@ -113,6 +113,7 @@ int mysql_derived(THD *thd, LEX *lex, SELECT_LEX_UNIT *unit, TABLE_LIST *t,
 	  t->table=table;
 	  table->derived_select_number= sl->select_number;
 	  sl->exclude();
+	  t->db= (tables && tables->db && tables->db[0]) ? t->db : thd->db;
 	  t->derived=(SELECT_LEX *)0; // just in case ...
 	}
       }
diff --git a/sql/sql_help.cc b/sql/sql_help.cc
index 72cf1fdff7d..d2bea9ba44b 100644
--- a/sql/sql_help.cc
+++ b/sql/sql_help.cc
@@ -361,8 +361,8 @@ int mysqld_help (THD *thd, const char *mask)
     }
     else if (count==1)
     {
-      if (res= get_all_names_for_category(thd, file_leafs,
-				     category_id,&function_list))
+      if ((res= get_all_names_for_category(thd, file_leafs,
+				     category_id,&function_list)))
 	goto end;
       List_iterator<String> it(function_list);
       String *cur_leaf, example;
@@ -371,8 +371,8 @@ int mysqld_help (THD *thd, const char *mask)
 	example.append(*cur_leaf);
 	example.append("\n",1);
       }
-      if (res= send_answer_1(thd, categories_list.head()->ptr(),
-				       "Y","",example.ptr()))
+      if ((res= send_answer_1(thd, categories_list.head()->ptr(),
+				       "Y","",example.ptr())))
 	goto end;
     }
     else	
@@ -387,8 +387,8 @@ int mysqld_help (THD *thd, const char *mask)
   }
   else if (count==1)
   {
-    if (res= send_answer_1(thd,name->ptr(),"N",
-			   description->ptr(), example->ptr()))
+    if ((res= send_answer_1(thd,name->ptr(),"N",
+			   description->ptr(), example->ptr())))
       goto end;
   }
   else if((res= send_header_2(thd)) ||
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 69f1eae9ac8..97714da0e8d 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -1388,10 +1388,14 @@ mysql_execute_command(THD *thd)
     for (TABLE_LIST *cursor= tables;
 	 cursor;
 	 cursor= cursor->next)
-      if (cursor->derived && mysql_derived(thd, lex,
+      if (cursor->derived && (res=mysql_derived(thd, lex,
 					   (SELECT_LEX_UNIT *)cursor->derived,
-					   cursor, 0))
+						cursor, 0)))
+      {  
+	if (res < 0)
+	  send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0);
 	DBUG_VOID_RETURN;
+      }
   }
   if ((lex->select_lex.next_select_in_list() && 
        lex->unit.create_total_list(thd, lex, &tables)) ||
@@ -2781,7 +2785,7 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
 	found=1;
       }
     }
-    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
+    else if (tables->db && check_access(thd,want_access,tables->db,&tables->grant.privilege,
 			  0, no_errors))
       return TRUE;
   }
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index b981ae329cd..8acb5fa5635 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -3624,9 +3624,9 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
       case STRING_RESULT:
 	if (item_sum->max_length > 255)
 	  return  new Field_blob(item_sum->max_length,maybe_null,
-				 item->name,table,item->str_value.charset());
+				 item->name,table,item->charset());
 	return	new Field_string(item_sum->max_length,maybe_null,
-				 item->name,table,item->str_value.charset());
+				 item->name,table,item->charset());
       }
     }
     thd->fatal_error=1;
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index 457e555463d..1276020e3c3 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -91,25 +91,29 @@ bool String::realloc(uint32 alloc_length)
   return FALSE;
 }
 
-bool String::set(longlong num)
+bool String::set(longlong num, CHARSET_INFO *cs)
 {
   if (alloc(21))
     return TRUE;
   str_length=(uint32) (longlong10_to_str(num,Ptr,-10)-Ptr);
+  str_charset=cs;
   return FALSE;
 }
 
-bool String::set(ulonglong num)
+bool String::set(ulonglong num, CHARSET_INFO *cs)
 {
   if (alloc(21))
     return TRUE;
   str_length=(uint32) (longlong10_to_str(num,Ptr,10)-Ptr);
+  str_charset=cs;
   return FALSE;
 }
 
-bool String::set(double num,uint decimals)
+bool String::set(double num,uint decimals, CHARSET_INFO *cs)
 {
   char buff[331];
+
+  str_charset=cs;
   if (decimals >= NOT_FIXED_DEC)
   {
     sprintf(buff,"%.14g",num);			// Enough for a DATETIME
diff --git a/sql/sql_string.h b/sql/sql_string.h
index e94981d22c3..c881cb22c5c 100644
--- a/sql/sql_string.h
+++ b/sql/sql_string.h
@@ -125,10 +125,9 @@ public:
     }
     str_charset=cs;
   }
-  bool set(longlong num);
-  /* bool set(long num); */
-  bool set(ulonglong num);
-  bool set(double num,uint decimals=2);
+  bool set(longlong num, CHARSET_INFO *cs);
+  bool set(ulonglong num, CHARSET_INFO *cs);
+  bool set(double num,uint decimals, CHARSET_INFO *cs);
   inline void free()
   {
     if (alloced)
diff --git a/sql/sql_test.cc b/sql/sql_test.cc
index 6ae07417e7d..b3bf47e7fd2 100644
--- a/sql/sql_test.cc
+++ b/sql/sql_test.cc
@@ -26,6 +26,23 @@
 /* Intern key cache variables */
 extern "C" pthread_mutex_t THR_LOCK_keycache;
 
+static const char *lock_descriptions[] =
+{
+  "No lock",
+  "Low priority read lock",
+  "Shared Read lock",
+  "High priority read lock",
+  "Read lock  without concurrent inserts",
+  "Write lock that allows other writers",
+  "Write lock, but allow reading",
+  "Concurrent insert lock",
+  "Lock Used by delayed insert",
+  "Low priority write lock",
+  "High priority write lock",
+  "Highest priority write lock"
+};
+
+
 #ifndef DBUG_OFF
 
 void
@@ -45,29 +62,11 @@ print_where(COND *cond,const char *info)
     DBUG_UNLOCK_FILE;
   }
 }
-
 	/* This is for debugging purposes */
 
 extern HASH open_cache;
 extern TABLE *unused_tables;
 
-static const char *lock_descriptions[] =
-{
-  "No lock",
-  "Low priority read lock",
-  "Shared Read lock",
-  "High priority read lock",
-  "Read lock  without concurrent inserts",
-  "Write lock that allows other writers",
-  "Write lock, but allow reading",
-  "Concurrent insert lock",
-  "Lock Used by delayed insert",
-  "Low priority write lock",
-  "High priority write lock",
-  "Highest priority write lock"
-};
-
-
 void print_cached_tables(void)
 {
   uint idx,count,unused;
@@ -203,6 +202,99 @@ TEST_join(JOIN *join)
 
 #endif
 
+typedef struct st_debug_lock
+{
+  ulong thread_id;
+  char table_name[FN_REFLEN];
+  bool waiting;
+  const char *lock_text;
+  enum thr_lock_type type;
+} TABLE_LOCK_INFO;
+
+static int dl_compare(TABLE_LOCK_INFO *a,TABLE_LOCK_INFO *b)
+{
+  if (a->thread_id > b->thread_id)
+    return 1;
+  if (a->thread_id < b->thread_id)
+    return -1;
+  if (a->waiting == b->waiting)
+    return 0;
+  else if (a->waiting)
+    return -1;
+  return 1;
+}
+
+static void push_locks_into_array(DYNAMIC_ARRAY *ar, THR_LOCK_DATA *data, bool wait, const char *text)
+{
+  if (data)
+  {
+    TABLE *table=(TABLE *)data->debug_print_param;
+    if (table && table->tmp_table == NO_TMP_TABLE)
+    {
+      TABLE_LOCK_INFO table_lock_info;
+      table_lock_info.thread_id=table->in_use->thread_id;
+      memcpy(table_lock_info.table_name, table->table_cache_key, table->key_length);
+      table_lock_info.table_name[strlen(table_lock_info.table_name)]='.';
+      table_lock_info.waiting=wait;
+      table_lock_info.lock_text=text;
+      table_lock_info.type=table->reginfo.lock_type; // obtainable also from THR_LOCK_DATA
+      VOID(push_dynamic(ar,(gptr) &table_lock_info));
+    }
+  }
+}
+/* 
+   Regarding MERGE tables:
+
+For now, the best option is to use the common TABLE *pointer for all
+cases;  The drawback is that for MERGE tables we will see many locks
+for the merge tables even if some of them are for individual tables.
+
+The way to solve this is to add to 'THR_LOCK' structure a pointer to
+the filename and use this when printing the data.
+(We can for now ignore this and just print the same name for all merge
+table parts;  Please add the above as a comment to the display_lock
+function so that we can easily add this if we ever need this.
+
+*/
+
+static void display_table_locks (void) 
+{
+  LIST *list;
+  DYNAMIC_ARRAY saved_table_locks;
+
+  VOID(my_init_dynamic_array(&saved_table_locks,sizeof(TABLE_LOCK_INFO),open_cache.records + 20,50));
+  VOID(pthread_mutex_lock(&THR_LOCK_lock));
+  for (list=thr_lock_thread_list ; list ; list=rest(list))
+  {
+    THR_LOCK *lock=(THR_LOCK*) list->data;
+
+    VOID(pthread_mutex_lock(&lock->mutex));
+    push_locks_into_array(&saved_table_locks, lock->write.data, false, "Locked - write");
+    push_locks_into_array(&saved_table_locks, lock->write_wait.data, true, "Waiting - write");
+    push_locks_into_array(&saved_table_locks, lock->read.data, false, "Locked - read");
+    push_locks_into_array(&saved_table_locks, lock->read_wait.data, true, "Waiting - read");
+    VOID(pthread_mutex_unlock(&lock->mutex));
+  }
+  VOID(pthread_mutex_unlock(&THR_LOCK_lock));
+  if (!saved_table_locks.elements) goto end;
+  
+  qsort((gptr) dynamic_element(&saved_table_locks,0,TABLE_LOCK_INFO *),saved_table_locks.elements,sizeof(TABLE_LOCK_INFO),(qsort_cmp) dl_compare);
+  freeze_size(&saved_table_locks);
+
+  puts("\nThread database.table_name          Locked/Waiting        Lock_type\n");
+  
+  for (uint i=0 ; i < saved_table_locks.elements ; i++)
+  {
+    TABLE_LOCK_INFO *dl_ptr=dynamic_element(&saved_table_locks,i,TABLE_LOCK_INFO*);
+    printf("%-8ld%-28.28s%-22s%s\n",
+	   dl_ptr->thread_id,dl_ptr->table_name,dl_ptr->lock_text,lock_descriptions[(int)dl_ptr->type]);
+  }
+  puts("\n\n");
+end:
+  delete_dynamic(&saved_table_locks);
+}
+
+
 void mysql_print_status(THD *thd)
 {
   char current_dir[FN_REFLEN];
@@ -268,6 +360,7 @@ Next alarm time: %lu\n",
 	 alarm_info.max_used_alarms,
 	 alarm_info.next_alarm_time);
 #endif
+  display_table_locks();
   fflush(stdout);
   if (thd)
     thd->proc_info="malloc";
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 7a387d539ff..9841e8254c8 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -712,7 +712,7 @@ help:
        LEX *lex= Lex;
        lex->sql_command= SQLCOM_HELP;
        lex->help_arg= $2.str;
-       }
+       };
 
 /* change master */
 
@@ -3295,13 +3295,13 @@ opt_ignore_lines:
 /* Common definitions */
 
 text_literal:
-	TEXT_STRING { $$ = new Item_string($1.str,$1.length,default_charset_info); }
+	TEXT_STRING { $$ = new Item_string($1.str,$1.length,current_thd->thd_charset); }
 	| UNDERSCORE_CHARSET TEXT_STRING { $$ = new Item_string($2.str,$2.length,Lex->charset); }
 	| text_literal TEXT_STRING
 	{ ((Item_string*) $1)->append($2.str,$2.length); };
 
 text_string:
-	TEXT_STRING	{ $$=  new String($1.str,$1.length,default_charset_info); }
+	TEXT_STRING	{ $$=  new String($1.str,$1.length,current_thd->thd_charset); }
 	| HEX_NUM
 	  {
 	    Item *tmp = new Item_varbinary($1.str,$1.length);