After merge fixes

Use server character set if --default-character-set is not used
Added convert_string() for more efficient alloc+character-set convert of strings


BitKeeper/deleted/.del-convert.result~a3b56e1db6f498e9:
  Delete: mysql-test/r/convert.result
BitKeeper/deleted/.del-convert.test~f4ceb743194dfe72:
  Delete: mysql-test/t/convert.test
BitKeeper/deleted/.del-make_win_src_distribution.old~5c9ebdc4a852b43b:
  Delete: scripts/make_win_src_distribution.old
client/mysql.cc:
  Use server character set if --default-character-set is not used
client/mysqltest.c:
  Code cleanup (merge identical code)
  More debug messages
heap/hp_create.c:
  After merge fix
include/m_ctype.h:
  After merge fix
include/my_global.h:
  Remove size_str (we already have size_s)
include/mysql_com.h:
  After merge fix
libmysql/libmysql.c:
  After merge fix
libmysqld/Makefile.am:
  After merge fix
mysql-test/r/auto_increment.result:
  After merge fix
mysql-test/r/create.result:
  After merge fix
mysql-test/r/ctype_latin1_de.result:
  After merge fix
mysql-test/r/distinct.result:
  After merge fix
mysql-test/r/drop.result:
  After merge fix
mysql-test/r/fulltext.result:
  After merge fix
mysql-test/r/func_gconcat.result:
  After merge fix
mysql-test/r/func_str.result:
  After merge fix
mysql-test/r/func_test.result:
  After merge fix
mysql-test/r/grant.result:
  After merge fix
mysql-test/r/group_by.result:
  After merge fix
mysql-test/r/handler.result:
  After merge fix
mysql-test/r/heap.result:
  After merge fix
mysql-test/r/heap_btree.result:
  After merge fix
mysql-test/r/heap_hash.result:
  After merge fix
mysql-test/r/innodb.result:
  After merge fix
mysql-test/r/insert.result:
  After merge fix
mysql-test/r/insert_select.result:
  After merge fix
mysql-test/r/join_outer.result:
  After merge fix
mysql-test/r/key.result:
  After merge fix
mysql-test/r/key_cache.result:
  After merge fix
mysql-test/r/loaddata.result:
  After merge fix
mysql-test/r/myisam.result:
  After merge fix
mysql-test/r/null.result:
  After merge fix
mysql-test/r/null_key.result:
  After merge fix
mysql-test/r/order_by.result:
  After merge fix
mysql-test/r/rpl_do_grant.result:
  After merge fix
mysql-test/r/rpl_error_ignored_table.result:
  After merge fix
mysql-test/r/rpl_ignore_grant.result:
  After merge fix
mysql-test/r/rpl_loaddata.result:
  After merge fix
mysql-test/r/rpl_log.result:
  After merge fix
mysql-test/r/rpl_log_pos.result:
  After merge fix
mysql-test/r/rpl_max_relay_size.result:
  After merge fix
mysql-test/r/rpl_replicate_do.result:
  After merge fix
mysql-test/r/rpl_reset_slave.result:
  After merge fix
mysql-test/r/rpl_rotate_logs.result:
  After merge fix
mysql-test/r/rpl_user_variables.result:
  After merge fix
mysql-test/r/select.result:
  After merge fix
mysql-test/r/select_safe.result:
  After merge fix
mysql-test/r/subselect.result:
  After merge fix
mysql-test/r/type_blob.result:
  After merge fix
mysql-test/r/type_decimal.result:
  After merge fix
mysql-test/r/type_float.result:
  After merge fix
mysql-test/r/type_ranges.result:
  After merge fix
mysql-test/r/type_time.result:
  After merge fix
mysql-test/r/type_uint.result:
  After merge fix
mysql-test/r/union.result:
  After merge fix
mysql-test/r/warnings.result:
  After merge fix
mysql-test/t/auto_increment.test:
  After merge fix
mysql-test/t/case.test:
  After merge fix
mysql-test/t/ctype_collate.test:
  After merge fix
mysql-test/t/ctype_latin1_de.test:
  After merge fix
mysql-test/t/drop.test:
  After merge fix
mysql-test/t/func_in.test:
  After merge fix
mysql-test/t/func_set.test:
  After merge fix
mysql-test/t/func_str.test:
  After merge fix
mysql-test/t/func_test.test:
  After merge fix
mysql-test/t/grant.test:
  After merge fix
mysql-test/t/group_by.test:
  After merge fix
mysql-test/t/handler.test:
  After merge fix
mysql-test/t/heap.test:
  After merge fix
mysql-test/t/heap_btree.test:
  After merge fix
mysql-test/t/heap_hash.test:
  After merge fix
mysql-test/t/innodb.test:
  After merge fix
mysql-test/t/insert_select.test:
  After merge fix
mysql-test/t/key.test:
  After merge fix
mysql-test/t/key_cache.test:
  After merge fix
mysql-test/t/lock_tables_lost_commit-master.opt:
  After merge fix
mysql-test/t/lock_tables_lost_commit.test:
  After merge fix
mysql-test/t/myisam.test:
  After merge fix
mysql-test/t/row.test:
  After merge fix
mysql-test/t/subselect.test:
  After merge fix
mysql-test/t/type_decimal.test:
  After merge fix
mysql-test/t/type_ranges.test:
  After merge fix
mysql-test/t/type_uint.test:
  After merge fix
mysql-test/t/variables.test:
  After merge fix
mysql-test/t/warnings.test:
  After merge fix
scripts/make_win_src_distribution.sh:
  after merge fixes
sql-common/client.c:
  After merge fix
  Change my_connect() to use poll()
  If character set is not given, use servers character set.
sql/field.cc:
  After merge fix
  Don't give warnings when storing data in fields in optimizer.
sql/ha_myisammrg.h:
  After merge fix
sql/log.cc:
  After merge fix
sql/log_event.cc:
  After merge fix
sql/mysqld.cc:
  After merge fix
sql/opt_range.cc:
  After merge fix
sql/set_var.cc:
  Code cleanup
  Fixed wrong usage of base_names (like medium.key_buffer) that caused core dumps
sql/set_var.h:
  Fixed wrong usage of base_names (like medium.key_buffer) that caused core dumps
sql/slave.cc:
  After merge fix
sql/sql_acl.cc:
  After merge fix
  Code cleanup
sql/sql_class.cc:
  Added convert_string() for more efficient alloc+character-set convert of strings
  Add cached flags to avoid calling mysql_charset_same() during parsing.
sql/sql_class.h:
  Added convert_string() for more efficient alloc+character-set convert of strings
  Add cached flags to avoid calling mysql_charset_same() during parsing.
sql/sql_handler.cc:
  After merge fix
sql/sql_lex.h:
  After merge fix
sql/sql_parse.cc:
  Optimize and fix memory reference errors reported by valgrind
sql/sql_repl.cc:
  After merge fix
sql/sql_yacc.yy:
  After merge fix
  Avoid calling mysql_charset_same() when parsing identifiers
strings/ctype-latin1.c:
  Port latin_de conversion code from 4.0

17 files changed, 299 insertions, 174 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 2f89dd43c3f..c972c116b1c 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -3905,7 +3905,8 @@ int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
   {
     memcpy(ptr,from,length);
     if (length < field_length)
-      field_charset->cset->fill(field_charset,ptr+length,field_length-length,' ');
+      field_charset->cset->fill(field_charset,ptr+length,field_length-length,
+				' ');
   }
   else
   {
@@ -3914,7 +3915,8 @@ int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
     {						// Check if we loosed some info
       const char *end=from+length;
       from+= field_length;
-      from+= field_charset->cset->scan(field_charset, from, end, MY_SEQ_SPACES);
+      from+= field_charset->cset->scan(field_charset, from, end,
+				       MY_SEQ_SPACES);
       if (from != end)
       {
         set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED);
@@ -5147,7 +5149,8 @@ int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
     from= tmpstr.ptr();
     length=  tmpstr.length();
   }
-  ulonglong tmp= find_set(typelib, from, length, &not_used, &not_used2, &set_warning);
+  ulonglong tmp= find_set(typelib, from, length, &not_used, &not_used2,
+			  &set_warning);
   if (!tmp && length && length < 22)
   {
     /* This is for reading numbers with LOAD DATA INFILE */
@@ -5157,10 +5160,14 @@ int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
 	tmp > (ulonglong) (((longlong) 1 << typelib->count) - (longlong) 1))
     {
       tmp=0;      
-      current_thd->cuted_fields++;
-      push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
-                          ER_WARN_DATA_TRUNCATED, ER(ER_WARN_DATA_TRUNCATED),
-                          field_name, 0);
+      THD *thd= current_thd;
+      if (thd->count_cuted_fields)
+      {
+	thd->cuted_fields++;
+	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
+			    ER_WARN_DATA_TRUNCATED, ER(ER_WARN_DATA_TRUNCATED),
+			    field_name, 0);
+      }
     }
   }
   store_type(tmp);
@@ -5496,7 +5503,10 @@ create_field::create_field(Field *old_field,Field *orig_field)
 void Field::set_warning(const uint level, const uint code)
 {
   THD *thd= current_thd;
-  thd->cuted_fields++;
-  push_warning_printf(thd, (MYSQL_ERROR::enum_warning_level) level, 
-                      code, ER(code), field_name, thd->row_count);
+  if (thd->count_cuted_fields)
+  {
+    thd->cuted_fields++;
+    push_warning_printf(thd, (MYSQL_ERROR::enum_warning_level) level, 
+			code, ER(code), field_name, thd->row_count);
+  }
 }
diff --git a/sql/ha_myisammrg.h b/sql/ha_myisammrg.h
index cfe4b47ef10..008f5339caf 100644
--- a/sql/ha_myisammrg.h
+++ b/sql/ha_myisammrg.h
@@ -40,8 +40,7 @@ class ha_myisammrg: public handler
   }
   ulong index_flags(uint inx) const
   {
-    ulong flags=(HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER |
-        HA_NOT_READ_PREFIX_LAST); // This - last - flag is ONLY for 4.0 !!!
+    ulong flags=(HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER);
     return (flags | ((table->key_info[inx].algorithm == HA_KEY_ALG_FULLTEXT) ?
 		     0 : HA_KEY_READ_ONLY));
   }
diff --git a/sql/log.cc b/sql/log.cc
index b3f7e753010..d3ba5b63e19 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -763,9 +763,6 @@ int MYSQL_LOG::purge_logs(const char *to_log,
   DBUG_ENTER("purge_logs");
   DBUG_PRINT("info",("to_log= %s",to_log));
 
-  if (no_rotate)
-    DBUG_RETURN(LOG_INFO_PURGE_NO_ROTATE);
-
   if (need_mutex)
     pthread_mutex_lock(&LOCK_index);
   if ((error=find_log_pos(&log_info, to_log, 0 /*no mutex*/)))
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 9f7d09785ac..3b04baf7ae7 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -102,13 +102,13 @@ static char *pretty_print_str(char *packet, char *str, int len)
   {
     char c;
     switch ((c=*str++)) {
-    case '\n': *pos++= '\'; *pos++= 'n'; break;
-    case '\r': *pos++= '\'; *pos++= 'r'; break;
-    case '\\': *pos++= '\'; *pos++= '\'; break;
-    case '\b': *pos++= '\'; *pos++= 'b'; break;
-    case '\t': *pos++= '\'; *pos++= 't'; break;
-    case '\'': *pos++= '\'; *pos++= '\''; break;
-    case 0   : *pos++= '\'; *pos++= '0'; break;
+    case '\n': *pos++= '\\'; *pos++= 'n'; break;
+    case '\r': *pos++= '\\'; *pos++= 'r'; break;
+    case '\\': *pos++= '\\'; *pos++= '\\'; break;
+    case '\b': *pos++= '\\'; *pos++= 'b'; break;
+    case '\t': *pos++= '\\'; *pos++= 't'; break;
+    case '\'': *pos++= '\\'; *pos++= '\''; break;
+    case 0   : *pos++= '\\'; *pos++= '0'; break;
     default:
       *pos++= c;
       break;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index b5afbb422d5..4305706f3dc 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -2176,7 +2176,7 @@ static int init_server_components()
   if (opt_update_log)
   {
     open_log(&mysql_update_log, glob_hostname, opt_update_logname, "",
-! 	     NullS, LOG_NEW, 0, 0, 0);
+	     NullS, LOG_NEW, 0, 0, 0);
     using_update_log=1;
   }
   if (opt_slow_log)
@@ -5470,7 +5470,11 @@ static void get_options(int argc,char **argv)
 			files_charset_info :
 			&my_charset_bin);
   /* QQ To be deleted when we have key cache variables in a struct */
-  keybuff_size= (((KEY_CACHE *) find_named(&key_caches, "default", 7))->size);
+  {
+    NAMED_LIST *not_used;
+    keybuff_size= (((KEY_CACHE *) find_named(&key_caches, "default", 7,
+					     &not_used))->size);
+  }
 }
 
 
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 839804b20d5..23fb36c0c91 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -2392,7 +2392,7 @@ QUICK_SELECT *get_quick_select_for_ref(TABLE *table, TABLE_REF *ref)
     return 0;
   if (cp_buffer_from_ref(ref))
   {
-    if (current_thd->fatal_error)
+    if (current_thd->is_fatal_error)
       return 0;					// End of memory
     return quick;				// empty range
   }
diff --git a/sql/set_var.cc b/sql/set_var.cc
index eebefc8b79c..499eed132a7 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -823,8 +823,10 @@ void fix_max_binlog_size(THD *thd, enum_var_type type)
   DBUG_PRINT("info",("max_binlog_size=%lu max_relay_log_size=%lu",
                      max_binlog_size, max_relay_log_size));
   mysql_bin_log.set_max_size(max_binlog_size);
+#ifdef REPLICATION
   if (!max_relay_log_size)
     active_mi->rli.relay_log.set_max_size(max_binlog_size);
+#endif
   DBUG_VOID_RETURN;
 }
 
@@ -1090,12 +1092,6 @@ err:
 }
 
 
-void sys_var_thd_conv_charset::set_default(THD *thd, enum_var_type type)
-{
-  thd->variables.convert_set= global_system_variables.convert_set; 
-}
-
-
 bool sys_var::check_set(THD *thd, set_var *var, TYPELIB *enum_names)
 {
   bool not_used;
@@ -1107,8 +1103,10 @@ bool sys_var::check_set(THD *thd, set_var *var, TYPELIB *enum_names)
   {
     if (!(res= var->value->val_str(&str)))
       goto err;
-    var->save_result.ulong_value= (ulong)
-      find_set(enum_names, res->c_ptr(), res->length(), &error, &error_len, &not_used);
+    var->save_result.ulong_value= ((ulong)
+				   find_set(enum_names, res->c_ptr(),
+					    res->length(), &error, &error_len,
+					    &not_used));
     if (error_len)
     {
       strmake(buff, error, min(sizeof(buff), error_len));
@@ -1254,16 +1252,17 @@ static my_old_conv old_conv[]=
 
 CHARSET_INFO *get_old_charset_by_name(const char *name)
 {
-  my_old_conv *c;
+  my_old_conv *conv;
  
-  for (c= old_conv; c->old_name; c++)
+  for (conv= old_conv; conv->old_name; conv++)
   {
-    if (!my_strcasecmp(&my_charset_latin1,name,c->old_name))
-      return get_charset_by_csname(c->new_name,MY_CS_PRIMARY,MYF(0));
+    if (!my_strcasecmp(&my_charset_latin1, name, conv->old_name))
+      return get_charset_by_csname(conv->new_name, MY_CS_PRIMARY, MYF(0));
   }
   return NULL;
 }
 
+
 bool sys_var_collation::check(THD *thd, set_var *var)
 {
   CHARSET_INFO *tmp;
@@ -1299,7 +1298,7 @@ bool sys_var_character_set::check(THD *thd, set_var *var)
     tmp= NULL;
   }
   else if (!(tmp=get_charset_by_csname(res->c_ptr(),MY_CS_PRIMARY,MYF(0))) &&
-      !(tmp=get_old_charset_by_name(res->c_ptr())))
+	   !(tmp=get_old_charset_by_name(res->c_ptr())))
   {
     my_error(ER_UNKNOWN_CHARACTER_SET, MYF(0), res->c_ptr());
     return 1;
@@ -1340,7 +1339,10 @@ void sys_var_character_set_connection::set_default(THD *thd,
  if (type == OPT_GLOBAL)
    global_system_variables.collation_connection= default_charset_info;
  else
+ {
    thd->variables.collation_connection= global_system_variables.collation_connection;
+   thd->update_charset();
+ }
 }
 
 
@@ -1359,11 +1361,16 @@ void sys_var_character_set_client::set_default(THD *thd, enum_var_type type)
  if (type == OPT_GLOBAL)
    global_system_variables.character_set_client= default_charset_info;
  else
-   thd->variables.character_set_client= global_system_variables.character_set_client;
+ {
+   thd->variables.character_set_client= (global_system_variables.
+					 character_set_client);
+   thd->update_charset();
+ }
 }
 
 
-CHARSET_INFO ** sys_var_character_set_results::ci_ptr(THD *thd, enum_var_type type)
+CHARSET_INFO **
+sys_var_character_set_results::ci_ptr(THD *thd, enum_var_type type)
 {
   if (type == OPT_GLOBAL)
     return &global_system_variables.character_set_results;
@@ -1377,11 +1384,16 @@ void sys_var_character_set_results::set_default(THD *thd, enum_var_type type)
  if (type == OPT_GLOBAL)
    global_system_variables.character_set_results= default_charset_info;
  else
-   thd->variables.character_set_results= global_system_variables.character_set_results;
+ {
+   thd->variables.character_set_results= (global_system_variables.
+					  character_set_results);
+   thd->update_charset();
+ }
 }
 
 
-CHARSET_INFO ** sys_var_character_set_server::ci_ptr(THD *thd, enum_var_type type)
+CHARSET_INFO **
+sys_var_character_set_server::ci_ptr(THD *thd, enum_var_type type)
 {
   if (type == OPT_GLOBAL)
     return &global_system_variables.character_set_server;
@@ -1395,7 +1407,11 @@ void sys_var_character_set_server::set_default(THD *thd, enum_var_type type)
  if (type == OPT_GLOBAL)
    global_system_variables.character_set_server= default_charset_info;
  else
-   thd->variables.character_set_server= global_system_variables.character_set_server;
+ {
+   thd->variables.character_set_server= (global_system_variables.
+					 character_set_server);
+   thd->update_charset();
+ }
 }
 
 
@@ -1414,7 +1430,10 @@ void sys_var_character_set_database::set_default(THD *thd, enum_var_type type)
  if (type == OPT_GLOBAL)
     global_system_variables.character_set_database= default_charset_info;
   else
+  {
     thd->variables.character_set_database= thd->db_charset;
+    thd->update_charset();
+  }
 }
 
 
@@ -1423,7 +1442,10 @@ bool sys_var_collation_connection::update(THD *thd, set_var *var)
   if (var->type == OPT_GLOBAL)
     global_system_variables.collation_connection= var->save_result.charset;
   else
+  {
     thd->variables.collation_connection= var->save_result.charset;
+    thd->update_charset();
+  }
   return 0;
 }
 
@@ -1443,38 +1465,47 @@ void sys_var_collation_connection::set_default(THD *thd, enum_var_type type)
  if (type == OPT_GLOBAL)
    global_system_variables.collation_connection= default_charset_info;
  else
-   thd->variables.collation_connection= global_system_variables.collation_connection;
+ {
+   thd->variables.collation_connection= (global_system_variables.
+					 collation_connection);
+   thd->update_charset();
+ }
 }
 
 
 bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
 {
   ulonglong tmp= var->value->val_int();
-  if (!base_name.length)
+  NAMED_LIST *list;
+  LEX_STRING *base_name= &var->base;
+
+  if (!base_name->length)
   {
-    base_name.str= (char*) "default";
-    base_name.length= 7;
+    /* We are using SET KEY_BUFFER_SIZE=# */
+    base_name->str= (char*) "default";
+    base_name->length= 7;
   }
-  KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, base_name.str,
-						base_name.length);
+  KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, base_name->str,
+						base_name->length, &list);
   if (!key_cache)
   {
     if (!tmp)					// Tried to delete cache
       return 0;					// Ok, nothing to do
-    if (!(key_cache= create_key_cache(base_name.str,
-				      base_name.length)))
+    if (!(key_cache= create_key_cache(base_name->str,
+				      base_name->length)))
       return 1;
   }
-  if (!tmp)
+  if (!tmp)					// Zero size means delete
   {
-    /* Delete not default key caches */
-    if (base_name.length != 7 || memcpy(base_name.str, "default", 7))
+    /* Don't delete the default key cache */
+    if (base_name->length != 7 || memcmp(base_name->str, "default", 7))
     {
       /*
-	QQ: Here we should move tables using this key cache to default
-	key cache
+	QQ: Here we should move tables that is using the found key cache
+	to the default key cache
       */
-      delete key_cache;
+      delete list;
+      my_free((char*) key_cache, MYF(0));
       return 0;
     }
   }
@@ -1487,6 +1518,7 @@ bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
   return 0;
 }
 
+
 static ulonglong zero=0;
 
 byte *sys_var_key_buffer_size::value_ptr(THD *thd, enum_var_type type,
@@ -1494,6 +1526,8 @@ byte *sys_var_key_buffer_size::value_ptr(THD *thd, enum_var_type type,
 {
   const char *name;
   uint length;
+  KEY_CACHE *key_cache;
+  NAMED_LIST *not_used;
 
   if (!base->str)
   {
@@ -1505,7 +1539,7 @@ byte *sys_var_key_buffer_size::value_ptr(THD *thd, enum_var_type type,
     name=   base->str;
     length= base->length;
   }
-  KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, name, length);
+  key_cache= (KEY_CACHE*) find_named(&key_caches, name, length, &not_used);
   if (!key_cache)
     return (byte*) &zero;
   return (byte*) &key_cache->size;
@@ -1527,6 +1561,7 @@ int set_var_collation_client::update(THD *thd)
   thd->variables.character_set_client= character_set_client;
   thd->variables.character_set_results= character_set_results;
   thd->variables.collation_connection= collation_connection;
+  thd->update_charset();
   thd->protocol_simple.init(thd);
   thd->protocol_prep.init(thd);
   return 0;
@@ -1860,17 +1895,18 @@ int sql_set_variables(THD *thd, List<set_var_base> *var_list)
 {
   int error= 0;
   List_iterator_fast<set_var_base> it(*var_list);
+  DBUG_ENTER("sql_set_variables");
 
   set_var_base *var;
   while ((var=it++))
   {
     if ((error=var->check(thd)))
-      return error;
+      DBUG_RETURN(error);
   }
   it.rewind();
   while ((var=it++))
     error|= var->update(thd);			// Returns 0, -1 or 1
-  return error;
+  DBUG_RETURN(error);
 }
 
 
@@ -2071,14 +2107,18 @@ ulong fix_sql_mode(ulong sql_mode)
   Named list handling
 ****************************************************************************/
 
-gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length)
+gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
+		NAMED_LIST **found)
 {
   I_List_iterator<NAMED_LIST> it(*list);
   NAMED_LIST *element;
   while ((element= it++))
   {
     if (element->cmp(name, length))
+    {
+      *found= element;
       return element->data;
+    }
   }
   return 0;
 }
@@ -2087,11 +2127,13 @@ gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length)
 void delete_elements(I_List<NAMED_LIST> *list, void (*free_element)(gptr))
 {
   NAMED_LIST *element;
+  DBUG_ENTER("delete_elements");
   while ((element= list->get()))
   {
     (*free_element)(element->data);
     delete element;
   }
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2100,7 +2142,8 @@ void delete_elements(I_List<NAMED_LIST> *list, void (*free_element)(gptr))
 static KEY_CACHE *create_key_cache(const char *name, uint length)
 {
   KEY_CACHE *key_cache;
-  DBUG_PRINT("info",("Creating key cache: %s", name));
+  DBUG_PRINT("info",("Creating key cache: %.*s  length: %d", length, name,
+		     length));
   if ((key_cache= (KEY_CACHE*) my_malloc(sizeof(KEY_CACHE),
 					 MYF(MY_ZEROFILL | MY_WME))))
   {
@@ -2116,8 +2159,9 @@ static KEY_CACHE *create_key_cache(const char *name, uint length)
 
 KEY_CACHE *get_or_create_key_cache(const char *name, uint length)
 {
+  NAMED_LIST *not_used;
   KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, name,
-						length);
+						length, &not_used);
   if (!key_cache)
     key_cache= create_key_cache(name, length);
   return key_cache;
diff --git a/sql/set_var.h b/sql/set_var.h
index f9c5d8f7822..f06b5ed22d3 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -47,18 +47,13 @@ public:
   struct my_option *option_limits;	/* Updated by by set_var_init() */
   uint name_length;			/* Updated by by set_var_init() */
   const char *name;
-  LEX_STRING base_name;			/* for structs */
   
   sys_after_update_func after_update;
   sys_var(const char *name_arg) :name(name_arg),after_update(0)
-  {
-    base_name.length=0;
-  }
+  {}
   sys_var(const char *name_arg,sys_after_update_func func)
     :name(name_arg),after_update(func)
-  {
-    base_name.length=0;
-  }
+  {}
   virtual ~sys_var() {}
   virtual bool check(THD *thd, set_var *var) { return 0; }
   bool check_enum(THD *thd, set_var *var, TYPELIB *enum_names);
@@ -167,7 +162,6 @@ public:
     return type != STRING_RESULT;		/* Only accept strings */
   }
   bool check_default(enum_var_type type) { return 0; }
-  void set_default(THD *thd, enum_var_type type);
 };
 
 
@@ -596,9 +590,11 @@ public:
     CHARSET_INFO *charset;
     ulong ulong_value;
   } save_result;
+  LEX_STRING base;			/* for structs */
 
-  set_var(enum_var_type type_arg, sys_var *var_arg, Item *value_arg)
-    :var(var_arg), type(type_arg)
+  set_var(enum_var_type type_arg, sys_var *var_arg, LEX_STRING *base_name_arg,
+	  Item *value_arg)
+    :var(var_arg), type(type_arg), base(*base_name_arg)
   {
     /*
       If the set value is a field, change it to a string to allow things like
@@ -677,12 +673,12 @@ public:
   gptr data;
 
   NAMED_LIST(I_List<NAMED_LIST> *links, const char *name_arg,
-	     uint name_length_arg, gptr data_arg):
-    name_length(name_length_arg), data(data_arg)
-    {
-      name=my_strdup(name_arg,MYF(MY_WME));
-      links->push_back(this);
-    }
+	     uint name_length_arg, gptr data_arg)
+    :name_length(name_length_arg), data(data_arg)
+  {
+    name= my_memdup(name_arg, name_length, MYF(MY_WME));
+    links->push_back(this);
+  }
   inline bool cmp(const char *name_cmp, uint length)
   {
     return length == name_length && !memcmp(name, name_cmp, length);
@@ -694,6 +690,13 @@ public:
 };
 
 
+/* For sql_yacc */
+struct sys_var_with_base
+{
+  sys_var *var;
+  LEX_STRING base_name;
+};
+
 /*
   Prototypes for helper functions
 */
@@ -706,7 +709,8 @@ void fix_delay_key_write(THD *thd, enum_var_type type);
 ulong fix_sql_mode(ulong sql_mode);
 extern sys_var_str sys_charset_system;
 CHARSET_INFO *get_old_charset_by_name(const char *old_name);
-gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length);
+gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
+		NAMED_LIST **found);
 void delete_elements(I_List<NAMED_LIST> *list, void (*free_element)(gptr));
 
 /* key_cache functions */
diff --git a/sql/slave.cc b/sql/slave.cc
index a6c86b08010..16d493f1667 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -1442,7 +1442,8 @@ Failed to open the existing relay log info file '%s' (errno %d)",
     {
       char llbuf[22];
       sql_print_error("Failed to open the relay log '%s' (relay_log_pos %s)",
-		      rli->relay_log_name, llstr(rli->relay_log_pos, llbuf));
+		      rli->group_relay_log_name,
+		      llstr(rli->group_relay_log_pos, llbuf));
       goto err;
     }
   }
@@ -3491,10 +3492,9 @@ Log_event* next_event(RELAY_LOG_INFO* rli)
 	it
       */
       DBUG_PRINT("info", ("\
-Before assert, my_b_tell(cur_log)=%s  rli->relay_log_pos=%s  rli->pending=%lu",
+Before assert, my_b_tell(cur_log)=%s  rli->event_relay_log_pos=%s",
                           llstr(my_b_tell(cur_log),llbuf1), 
-                          llstr(rli->relay_log_pos,llbuf2),
-                          rli->pending));
+                          llstr(rli->group_relay_log_pos,llbuf2)));
        DBUG_ASSERT(my_b_tell(cur_log) == rli->event_relay_log_pos);
     }
 #endif
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 08212bbf65b..9738c0c5d9e 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -2353,8 +2353,8 @@ int mysql_table_grant(THD *thd, TABLE_LIST *table_list,
 }
 
 
-int mysql_grant (THD *thd, const char *db, List <LEX_USER> &list,
-		 ulong rights, bool revoke_grant)
+int mysql_grant(THD *thd, const char *db, List <LEX_USER> &list,
+		ulong rights, bool revoke_grant)
 {
   List_iterator <LEX_USER> str_list (list);
   LEX_USER *Str;
@@ -2364,8 +2364,8 @@ int mysql_grant (THD *thd, const char *db, List <LEX_USER> &list,
   DBUG_ENTER("mysql_grant");
   if (!initialized)
   {
-    send_error(thd, ER_UNKNOWN_COM_ERROR);	/* purecov: tested */
-    return 1;					/* purecov: tested */
+    my_error(ER_UNKNOWN_COM_ERROR, MYF(0));	/* purecov: tested */
+    return -1;					/* purecov: tested */
   }
 
   if (lower_case_table_names && db)
@@ -2443,7 +2443,8 @@ int mysql_grant (THD *thd, const char *db, List <LEX_USER> &list,
       }
       else
       {
-	net_printf(&thd->net,ER_WRONG_USAGE,"DB GRANT","GLOBAL PRIVILEGES");
+	my_printf_error(ER_WRONG_USAGE, ER(ER_WRONG_USAGE), MYF(0),
+			"DB GRANT","GLOBAL PRIVILEGES");
 	result= -1;
       }
     }
@@ -2941,7 +2942,8 @@ int mysql_show_grants(THD *thd,LEX_USER *lex_user)
   ulong want_access;
   uint counter,index;
   int  error = 0;
-  ACL_USER *acl_user; ACL_DB *acl_db;
+  ACL_USER *acl_user;
+  ACL_DB *acl_db;
   char buff[1024];
   Protocol *protocol= thd->protocol;
   DBUG_ENTER("mysql_show_grants");
@@ -2993,11 +2995,11 @@ int mysql_show_grants(THD *thd,LEX_USER *lex_user)
 
   /* Add first global access grants */
   {
-    want_access=acl_user->access;
     String global(buff,sizeof(buff),&my_charset_latin1);
     global.length(0);
     global.append("GRANT ",6);
 
+    want_access= acl_user->access;
     if (test_all_bits(want_access, (GLOBAL_ACLS & ~ GRANT_ACL)))
       global.append("ALL PRIVILEGES",14);
     else if (!(want_access & ~GRANT_ACL))
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index c233ffd422a..c29e7ca2213 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -385,6 +385,59 @@ bool THD::store_globals()
 }
 
 
+/*
+  Convert a string to another character set
+
+  SYNOPSIS
+    convert_string()
+    to				Store new allocated string here
+    to_cs			New character set for allocated string
+    from			String to convert
+    from_length			Length of string to convert
+    from_cs			Original character set
+
+  NOTES
+    to will be 0-terminated to make it easy to pass to system funcs
+
+  RETURN
+    0	ok
+    1	End of memory.
+        In this case to->str will point to 0 and to->length will be 0.
+*/
+
+bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
+			 const char *from, uint from_length,
+			 CHARSET_INFO *from_cs)
+{
+  DBUG_ENTER("convert_string");
+  size_s new_length= to_cs->mbmaxlen * from_length;
+  if (!(to->str= alloc(new_length+1)))
+  {
+    to->length= 0;				// Safety fix
+    DBUG_RETURN(1);				// EOM
+  }
+  to->length= copy_and_convert((char*) to->str, new_length, to_cs,
+			       from, from_length, from_cs);
+  to->str[to->length]=0;			// Safety
+  DBUG_RETURN(0);
+}
+
+
+/*
+  Update some cache variables when character set changes
+*/
+
+void THD::update_charset()
+{
+  charset_is_system_charset= my_charset_same(charset(),system_charset_info);
+  charset_is_collation_connection= my_charset_same(charset(),
+						   variables.
+						   collation_connection);
+}
+
+
+
+
 /* routings to adding tables to list of changed in transaction tables */
 
 inline static void list_include(CHANGED_TABLE_LIST** prev,
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 414b4eac6a6..fe896a50c4f 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -571,6 +571,7 @@ public:
   bool	     volatile killed;
   bool       prepare_command;
   bool	     tmp_table_used;
+  bool	     charset_is_system_charset, charset_is_collation_connection;
 
   /*
     If we do a purge of binary logs, log index info of the threads
@@ -678,6 +679,9 @@ public:
       memcpy(ptr,str,size);
     return ptr;
   }
+  bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
+		      const char *from, uint from_length,
+		      CHARSET_INFO *from_cs);
   inline gptr trans_alloc(unsigned int size) 
   { 
     return alloc_root(&transaction.mem_root,size);
@@ -703,6 +707,7 @@ public:
     DBUG_PRINT("error",("Fatal error set"));
   }
   inline CHARSET_INFO *charset() { return variables.character_set_client; }
+  void update_charset();
 };
 
 /*
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index 0387f02e83f..93ab332bcd5 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -203,7 +203,7 @@ int mysql_ha_read(THD *thd, TABLE_LIST *tables,
       Item *item;
       for (key_len=0 ; (item=it_ke++) ; key_part++)
       {
-	if (item->fix_fields(thd, tables))
+	if (item->fix_fields(thd, tables, &item))
 	  goto err;
 	if (item->used_tables() & ~RAND_TABLE_BIT)
         {
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 03a0f7beda9..506818cdcf9 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -225,6 +225,8 @@ public:
   {
     return (void*) sql_alloc((uint) size);
   }
+  static void *operator new(size_t size, MEM_ROOT *mem_root)
+  { return (void*) alloc_root(mem_root, (uint) size); }
   static void operator delete(void *ptr,size_t size) {}
   st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
   virtual ~st_select_lex_node() {}
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index d9f6b93d2bb..e8df7c39c70 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -549,8 +549,8 @@ check_connections(THD *thd)
   NET *net= &thd->net;
   char *end, *user, *passwd, *db;
   char prepared_scramble[SCRAMBLE41_LENGTH+4];  /* Buffer for scramble&hash */
+  char db_buff[NAME_LEN+1];
   ACL_USER* cached_user=NULL; /* Initialise to NULL for first stage */
-  String convdb;
   DBUG_PRINT("info",("New connection received on %s",
 		     vio_description(net->vio)));
 
@@ -667,8 +667,18 @@ check_connections(THD *thd)
   {
     thd->client_capabilities|= ((ulong) uint2korr(net->read_pos+2)) << 16;
     thd->max_client_packet_length= uint4korr(net->read_pos+4);
+    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
+    /*
+      Use server character set and collation if
+      - client has not specified a character set
+      - client character set is the same as the servers
+      - client character set doesn't exists in server
+    */
     if (!(thd->variables.character_set_client=
-	  get_charset((uint) net->read_pos[8], MYF(0))))
+	  get_charset((uint) net->read_pos[8], MYF(0))) ||
+	!my_strcasecmp(&my_charset_latin1,
+		       global_system_variables.character_set_client->name,
+		       thd->variables.character_set_client->name))
     {
       thd->variables.character_set_client=
 	global_system_variables.character_set_client;
@@ -683,6 +693,7 @@ check_connections(THD *thd)
       thd->variables.collation_connection= 
 	thd->variables.character_set_client;
     }
+    thd->update_charset();
     end= (char*) net->read_pos+32;
   }
   else
@@ -735,10 +746,13 @@ check_connections(THD *thd)
   using_password= test(passwd[0]);
   if (thd->client_capabilities & CLIENT_CONNECT_WITH_DB)
   {
-    db=strend(passwd)+1;
-    convdb.copy(db, strlen(db), 
-		thd->variables.character_set_client, system_charset_info);
-    db= convdb.c_ptr();
+    db= strend(passwd)+1;
+    uint32 length= copy_and_convert(db_buff, sizeof(db_buff)-1,
+				    system_charset_info,
+				    db, strlen(db),
+				    thd->charset());
+    db_buff[length]= 0;
+    db= db_buff;
   }
 
   /* We can get only old hash at this point */
@@ -1140,15 +1154,15 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   thd->lex.select_lex.options=0;		// We store status here
   switch (command) {
   case COM_INIT_DB:
-    {
-      String convname;
-      statistic_increment(com_stat[SQLCOM_CHANGE_DB],&LOCK_status);
-      convname.copy(packet, strlen(packet),
-		    thd->variables.character_set_client, system_charset_info);
-      if (!mysql_change_db(thd,convname.c_ptr()))
-	mysql_log.write(thd,command,"%s",thd->db);
-      break;
-    }
+  {
+    LEX_STRING tmp;
+    statistic_increment(com_stat[SQLCOM_CHANGE_DB],&LOCK_status);
+    thd->convert_string(&tmp, system_charset_info,
+			packet, strlen(packet), thd->charset());
+    if (!mysql_change_db(thd, tmp.str))
+      mysql_log.write(thd,command,"%s",thd->db);
+    break;
+  }
 #ifndef EMBEDDED_LIBRARY
   case COM_REGISTER_SLAVE:
   {
@@ -1360,8 +1374,9 @@ restore_user:
 #else
   {
     char *fields, *pend;
-    String convname;
     TABLE_LIST table_list;
+    LEX_STRING conv_name;
+
     statistic_increment(com_stat[SQLCOM_SHOW_FIELDS],&LOCK_status);
     bzero((char*) &table_list,sizeof(table_list));
     if (!(table_list.db=thd->db))
@@ -1371,9 +1386,9 @@ restore_user:
     }
     thd->free_list=0;
     pend= strend(packet);
-    convname.copy(packet, pend-packet, 
-		  thd->variables.character_set_client, system_charset_info);
-    table_list.alias= table_list.real_name= convname.c_ptr();
+    thd->convert_string(&conv_name, system_charset_info,
+			packet, (uint) (pend-packet), thd->charset());
+    table_list.alias= table_list.real_name= conv_name.str;
     packet= pend+1;
     // command not cachable => no gap for data base name
     if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
@@ -2697,7 +2712,7 @@ mysql_execute_command(THD *thd)
 	goto error;				/* purecov: inspected */
       if (!thd->col_access && check_grant_db(thd,db))
       {
-	net_printf(&thd->net,ER_DBACCESS_DENIED_ERROR,
+	net_printf(thd, ER_DBACCESS_DENIED_ERROR,
 		   thd->priv_user,
 		   thd->priv_host,
 		   db);
@@ -3195,16 +3210,16 @@ mysql_execute_command(THD *thd)
     if (!ha_rollback_to_savepoint(thd, lex->savepoint_name))
     {
       if (thd->options & OPTION_STATUS_NO_TRANS_UPDATE)
-	send_warning(&thd->net,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
+	send_warning(thd, ER_WARNING_NOT_COMPLETE_ROLLBACK, 0);
       else
-	send_ok(&thd->net);
+	send_ok(thd);
     }
     else
       res= -1;
     break;
   case SQLCOM_SAVEPOINT:
     if (!ha_savepoint(thd, lex->savepoint_name))
-      send_ok(&thd->net);
+      send_ok(thd);
     else
       res= -1;
     break;
@@ -3584,7 +3599,7 @@ mysql_init_select(LEX *lex)
 bool
 mysql_new_select(LEX *lex, bool move_down)
 {
-  SELECT_LEX *select_lex = new SELECT_LEX();
+  SELECT_LEX *select_lex = new(&lex->thd->mem_root) SELECT_LEX();
   if (!select_lex)
     return 1;
   select_lex->select_number= ++lex->thd->select_number;
@@ -3658,7 +3673,7 @@ void mysql_init_multi_delete(LEX *lex)
   mysql_init_select(lex);
   lex->select_lex.select_limit= lex->unit.select_limit_cnt=
     HA_POS_ERROR;
-  lex->select->table_list.save_and_clear(&lex->auxilliary_table_list);
+  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
 }
 
 
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index faf128d5e02..3cdf033c477 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -295,14 +295,14 @@ int purge_master_logs(THD* thd, const char* to_log)
   char search_file_name[FN_REFLEN];
   if (!mysql_bin_log.is_open())
   {
-    send_ok();
+    send_ok(current_thd);
     return 0;
   }
 
   mysql_bin_log.make_log_name(search_file_name, to_log);
   return purge_error_message(thd,
 			     mysql_bin_log.purge_logs(search_file_name, 0, 1,
-						      1, NULL);
+						      1, NULL));
 }
 
 
@@ -998,7 +998,7 @@ int change_master(THD* thd, MASTER_INFO* mi)
   mi->rli.group_master_log_pos = mi->master_log_pos;
   DBUG_PRINT("info", ("master_log_pos: %d", (ulong) mi->master_log_pos));
   /* If changing RELAY_LOG_FILE or RELAY_LOG_POS, this will be nonsense: */
-  mi->rli.master_log_pos = mi->master_log_pos;
+  mi->rli.group_master_log_pos= mi->master_log_pos;
   strmake(mi->rli.group_master_log_name,mi->master_log_name,
 	  sizeof(mi->rli.group_master_log_name)-1);
   if (!mi->rli.group_master_log_name[0]) // uninitialized case
@@ -1210,7 +1210,7 @@ int show_binlogs(THD* thd)
   if (!mysql_bin_log.is_open())
   {
     //TODO:  Replace with ER() error message
-    send_error(net, 0, "You are not using binary logging");
+    send_error(thd, 0, "You are not using binary logging");
     return 1;
   }
 
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index f3631263735..a40dcc42183 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -67,9 +67,9 @@ inline Item *or_or_concat(THD *thd, Item* A, Item* B)
   TABLE_LIST *table_list;
   udf_func *udf;
   LEX_USER *lex_user;
-  sys_var *variable;
+  struct sys_var_with_base variable;
   Key::Keytype key_type;
-  enum ha_key_alg  key_alg;
+  enum ha_key_alg key_alg;
   enum db_type db_type;
   enum row_type row_type;
   enum ha_rkey_function ha_rkey_mode;
@@ -879,7 +879,7 @@ create:
 	  lex->name=0;
 	}
 	create2
-	  { Lex->select= &Lex->select_lex; }
+	  { Lex->current_select= &Lex->select_lex; }
 	| CREATE opt_unique_or_fulltext INDEX ident key_alg ON table_ident
 	  {
 	    LEX *lex=Lex;
@@ -942,15 +942,15 @@ create2:
 
 create2a:
         field_list ')' opt_create_table_options create3 {}
-	|  create_select ')' { Select->braces= 1;} union_opt {}
+	|  create_select ')' { Select->set_braces(1);} union_opt {}
         ;
 
 create3:
 	/* empty */ {}
 	| opt_duplicate opt_as     create_select
-          { Select->braces= 0;} opt_union {}
+          { Select->set_braces(0);} union_clause {}
 	| opt_duplicate opt_as '(' create_select ')'
-          { Select->braces= 1;} union_opt {}
+          { Select->set_braces(1);} union_opt {}
         ;
 
 create_select:
@@ -962,7 +962,7 @@ create_select:
 	      lex->sql_command= SQLCOM_INSERT_SELECT;
 	    else if (lex->sql_command == SQLCOM_REPLACE)
 	      lex->sql_command= SQLCOM_REPLACE_SELECT;
-	    lex->select->table_list.save_and_clear(&lex->save_list);
+	    lex->current_select->select_lex()->table_list.save_and_clear(&lex->save_list);
 	    mysql_init_select(lex);
 	    lex->current_select->parsing_place= SELECT_LEX_NODE::SELECT_LIST;
           }
@@ -971,7 +971,7 @@ create_select:
 	    Select->parsing_place= SELECT_LEX_NODE::NO_MATTER;
 	  }
 	  opt_select_from
-	  { Lex->select->table_list.push_front(&Lex->save_list); }
+	  { Lex->current_select->select_lex()->table_list.push_front(&Lex->save_list); }
         ;
 
 opt_as:
@@ -3434,7 +3434,7 @@ insert:
 	opt_ignore insert2
 	{
 	  Select->set_lock_for_tables($3);
-	  Lex->select= &Lex->select_lex;
+	  Lex->current_select= &Lex->select_lex;
 	}
 	insert_field_spec opt_insert_update
 	{}
@@ -3451,7 +3451,7 @@ replace:
 	replace_lock_option insert2
 	{
 	  Select->set_lock_for_tables($3);
-	  Lex->select= &Lex->select_lex;
+	  Lex->current_select= &Lex->select_lex;
 	}
 	insert_field_spec
 	{}
@@ -3507,8 +3507,8 @@ fields:
 insert_values:
 	VALUES	values_list  {}
 	| VALUE_SYM values_list  {}
-	|     create_select     { Select->braces= 0;} opt_union {}
-	| '(' create_select ')' { Select->braces= 1;} union_opt {}
+	|     create_select     { Select->set_braces(0);} union_clause {}
+	| '(' create_select ')' { Select->set_braces(1);} union_opt {}
         ;
 
 values_list:
@@ -4266,17 +4266,11 @@ IDENT_sys:
 	IDENT
 	{
 	  THD *thd= YYTHD;
-	  if (my_charset_same(thd->charset(),system_charset_info))
-	  {
-	    $$=$1;
-	  }
+	  if (thd->charset_is_system_charset)
+	    $$= $1;
 	  else
-	  {
-	    String ident;
-	    ident.copy($1.str,$1.length,thd->charset(),system_charset_info);
-	    $$.str= thd->strmake(ident.ptr(),ident.length());
-	    $$.length= ident.length();
-	  }
+	    thd->convert_string(&$$, system_charset_info,
+				$1.str, $1.length, thd->charset());
 	}
 	;
 
@@ -4284,17 +4278,11 @@ TEXT_STRING_sys:
 	TEXT_STRING
 	{
 	  THD *thd= YYTHD;
-	  if (my_charset_same(thd->charset(),system_charset_info))
-	  {
-	    $$=$1;
-	  }
+	  if (thd->charset_is_system_charset)
+	    $$= $1;
 	  else
-	  {
-	    String ident;
-	    ident.copy($1.str,$1.length,thd->charset(),system_charset_info);
-	    $$.str= thd->strmake(ident.ptr(),ident.length());
-	    $$.length= ident.length();
-	  }
+	    thd->convert_string(&$$, system_charset_info,
+				$1.str, $1.length, thd->charset());
 	}
 	;
 
@@ -4302,17 +4290,11 @@ TEXT_STRING_literal:
 	TEXT_STRING
 	{
 	  THD *thd= YYTHD;
-	  if (my_charset_same(thd->charset(),thd->variables.collation_connection))
-	  {
-	    $$=$1;
-	  }
+	  if (thd->charset_is_collation_connection)
+	    $$= $1;
 	  else
-	  {
-	    String ident;
-	    ident.copy($1.str,$1.length,thd->charset(),thd->variables.collation_connection);
-	    $$.str= thd->strmake(ident.ptr(),ident.length());
-	    $$.length= ident.length();
-	  }
+	    thd->convert_string(&$$, thd->variables.collation_connection,
+				$1.str, $1.length, thd->charset());
 	}
 	;
 
@@ -4321,9 +4303,9 @@ ident:
 	IDENT_sys	    { $$=$1; }
 	| keyword
 	{
-	  LEX *lex= Lex;
-	  $$.str= lex->thd->strmake($1.str,$1.length);
-	  $$.length=$1.length;
+	  THD *thd= YYTHD;
+	  $$.str=    thd->strmake($1.str, $1.length);
+	  $$.length= $1.length;
 	}
 	;
 
@@ -4590,18 +4572,24 @@ option_value:
 	| internal_variable_name equal set_expr_or_default
 	  {
 	    LEX *lex=Lex;
-	    lex->var_list.push_back(new set_var(lex->option_type, $1, $3));
+	    lex->var_list.push_back(new set_var(lex->option_type, $1.var,
+						&$1.base_name, $3));
 	  }
 	| '@' '@' opt_var_ident_type internal_variable_name equal set_expr_or_default
 	  {
 	    LEX *lex=Lex;
-	    lex->var_list.push_back(new set_var((enum_var_type) $3, $4, $6));
+	    lex->var_list.push_back(new set_var((enum_var_type) $3, $4.var,
+						&$4.base_name, $6));
 	  }
 	| TRANSACTION_SYM ISOLATION LEVEL_SYM isolation_types
 	  {
 	    LEX *lex=Lex;
+	    LEX_STRING tmp;
+	    tmp.str=0;
+	    tmp.length=0;
 	    lex->var_list.push_back(new set_var(lex->option_type,
 						find_sys_var("tx_isolation"),
+						&tmp,
 						new Item_int((int32) $4)));
 	  }
 	| charset old_or_new_charset_name_or_default
@@ -4646,7 +4634,9 @@ internal_variable_name:
 	  sys_var *tmp=find_sys_var($1.str, $1.length);
 	  if (!tmp)
 	    YYABORT;
-	  $$=tmp;
+	  $$.var= tmp;
+	  $$.base_name.str=0;
+	  $$.base_name.length=0;
 	}
 	| ident '.' ident
 	  {
@@ -4655,8 +4645,8 @@ internal_variable_name:
 	      YYABORT;
 	    if (!tmp->is_struct())
 	      net_printf(YYTHD, ER_VARIABLE_IS_NOT_STRUCT, $3.str);
-	    tmp->base_name= $1;
-	    $$=tmp;
+	    $$.var= tmp;
+	    $$.base_name= $1;
 	  }
 	| DEFAULT '.' ident
 	  {
@@ -4665,9 +4655,9 @@ internal_variable_name:
 	      YYABORT;
 	    if (!tmp->is_struct())
 	      net_printf(YYTHD, ER_VARIABLE_IS_NOT_STRUCT, $3.str);
-	    tmp->base_name.str= (char*) "default";
-	    tmp->base_name.length= 7;
-	    $$=tmp;
+	    $$.var= tmp;
+	    $$.base_name.str=    (char*) "default";
+	    $$.base_name.length= 7;
 	  }
         ;