Change CHARSET_INFO character set and collaction names to LEX_CSTRING

This change removed 68 explict strlen() calls from the code.

The following renames was done to ensure we don't use the old names
when merging code from earlier releases, as using the new variables
for print function could result in crashes:
- charset->csname renamed to charset->cs_name
- charset->name renamed to charset->coll_name

Almost everything where mechanical changes except:
- Changed to use the new Protocol::store(LEX_CSTRING..) when possible
- Changed to use field->store(LEX_CSTRING*, CHARSET_INFO*) when possible
- Changed to use String->append(LEX_CSTRING&) when possible

Other things:
- There where compiler issues with ensuring that all character set names
  points to the same string: gcc doesn't allow one to use integer constants
  when defining global structures (constant char * pointers works fine).
  To get around this, I declared defines for each character set name
  length.

33 files changed, 182 insertions, 232 deletions

diff --git a/sql/event_db_repository.cc b/sql/event_db_repository.cc
index 8366f24b5f8..18cba99f92b 100644
--- a/sql/event_db_repository.cc
+++ b/sql/event_db_repository.cc
@@ -341,31 +341,27 @@ mysql_event_fill_row(THD *thd,
   }
 
   fields[ET_FIELD_CHARACTER_SET_CLIENT]->set_notnull();
-  rs|= fields[ET_FIELD_CHARACTER_SET_CLIENT]->store(
-    thd->variables.character_set_client->csname,
-    strlen(thd->variables.character_set_client->csname),
-    system_charset_info);
+  rs|= fields[ET_FIELD_CHARACTER_SET_CLIENT]->
+    store(&thd->variables.character_set_client->cs_name,
+          system_charset_info);
 
   fields[ET_FIELD_COLLATION_CONNECTION]->set_notnull();
-  rs|= fields[ET_FIELD_COLLATION_CONNECTION]->store(
-    thd->variables.collation_connection->name,
-    strlen(thd->variables.collation_connection->name),
-    system_charset_info);
+  rs|= fields[ET_FIELD_COLLATION_CONNECTION]->
+    store(&thd->variables.collation_connection->coll_name,
+          system_charset_info);
 
   {
     CHARSET_INFO *db_cl= get_default_db_collation(thd, et->dbname.str);
 
     fields[ET_FIELD_DB_COLLATION]->set_notnull();
-    rs|= fields[ET_FIELD_DB_COLLATION]->store(db_cl->name,
-                                              strlen(db_cl->name),
+    rs|= fields[ET_FIELD_DB_COLLATION]->store(&db_cl->coll_name,
                                               system_charset_info);
   }
 
   if (et->body_changed)
   {
     fields[ET_FIELD_BODY_UTF8]->set_notnull();
-    rs|= fields[ET_FIELD_BODY_UTF8]->store(sp->m_body_utf8.str,
-                                           sp->m_body_utf8.length,
+    rs|= fields[ET_FIELD_BODY_UTF8]->store(&sp->m_body_utf8,
                                            system_charset_info);
   }
 
diff --git a/sql/events.cc b/sql/events.cc
index 9f0aef885df..213f634fde0 100644
--- a/sql/events.cc
+++ b/sql/events.cc
@@ -740,14 +740,11 @@ send_show_create_event(THD *thd, Event_timed *et, Protocol *protocol)
   protocol->store(tz_name->ptr(), tz_name->length(), system_charset_info);
   protocol->store(show_str.ptr(), show_str.length(),
                   et->creation_ctx->get_client_cs());
-  protocol->store(et->creation_ctx->get_client_cs()->csname,
-                  strlen(et->creation_ctx->get_client_cs()->csname),
+  protocol->store(&et->creation_ctx->get_client_cs()->cs_name,
                   system_charset_info);
-  protocol->store(et->creation_ctx->get_connection_cl()->name,
-                  strlen(et->creation_ctx->get_connection_cl()->name),
+  protocol->store(&et->creation_ctx->get_connection_cl()->coll_name,
                   system_charset_info);
-  protocol->store(et->creation_ctx->get_db_cl()->name,
-                  strlen(et->creation_ctx->get_db_cl()->name),
+  protocol->store(&et->creation_ctx->get_db_cl()->coll_name,
                   system_charset_info);
 
   if (protocol->write())
diff --git a/sql/field.cc b/sql/field.cc
index 5958fab57b8..eaa7dc7bf05 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -7600,7 +7600,7 @@ void Field_string::sql_rpl_type(String *res) const
                                       res->alloced_length(),
                                       "char(%u octets) character set %s",
                                       field_length,
-                                      charset()->csname);
+                                      charset()->cs_name.str);
     res->length(length);
   }
   else
@@ -8049,7 +8049,7 @@ void Field_varstring::sql_rpl_type(String *res) const
                                       res->alloced_length(),
                                       "varchar(%u octets) character set %s",
                                       field_length,
-                                      charset()->csname);
+                                      charset()->cs_name.str);
     res->length(length);
   }
   else
diff --git a/sql/handler.cc b/sql/handler.cc
index e36fbcccd76..2a2213af1cc 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -7708,8 +7708,8 @@ bool HA_CREATE_INFO::check_conflicting_charset_declarations(CHARSET_INFO *cs)
   {
     my_error(ER_CONFLICTING_DECLARATIONS, MYF(0),
              "CHARACTER SET ", default_table_charset ?
-                               default_table_charset->csname : "DEFAULT",
-             "CHARACTER SET ", cs ? cs->csname : "DEFAULT");
+                               default_table_charset->cs_name.str : "DEFAULT",
+             "CHARACTER SET ", cs ? cs->cs_name.str : "DEFAULT");
     return true;
   }
   return false;
diff --git a/sql/item.cc b/sql/item.cc
index d90747bb12c..40583fd4359 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -2463,7 +2463,7 @@ bool DTCollation::aggregate(const DTCollation &dt, uint flags)
         set(dt);
         return 0;
       }
-      CHARSET_INFO *bin= get_charset_by_csname(collation->csname, 
+      CHARSET_INFO *bin= get_charset_by_csname(collation->cs_name.str,
                                                MY_CS_BINSORT,MYF(utf8_flag));
       set(bin, DERIVATION_NONE);
     }
@@ -2477,8 +2477,8 @@ static
 void my_coll_agg_error(DTCollation &c1, DTCollation &c2, const char *fname)
 {
   my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
-           c1.collation->name,c1.derivation_name(),
-           c2.collation->name,c2.derivation_name(),
+           c1.collation->coll_name.str, c1.derivation_name(),
+           c2.collation->coll_name.str, c2.derivation_name(),
            fname);
 }
 
@@ -2488,10 +2488,10 @@ void my_coll_agg_error(DTCollation &c1, DTCollation &c2, DTCollation &c3,
                        const char *fname)
 {
   my_error(ER_CANT_AGGREGATE_3COLLATIONS,MYF(0),
-  	   c1.collation->name,c1.derivation_name(),
-	   c2.collation->name,c2.derivation_name(),
-	   c3.collation->name,c3.derivation_name(),
-	   fname);
+           c1.collation->coll_name.str, c1.derivation_name(),
+           c2.collation->coll_name.str, c2.derivation_name(),
+           c3.collation->coll_name.str, c3.derivation_name(),
+           fname);
 }
 
 
@@ -3799,8 +3799,7 @@ void Item_string::print(String *str, enum_query_type query_type)
   if (print_introducer)
   {
     str->append('_');
-    str->append(collation.collation->csname,
-                strlen(collation.collation->csname));
+    str->append(collation.collation->cs_name);
   }
 
   str->append('\'');
@@ -6381,7 +6380,7 @@ String *Item::check_well_formed_result(String *str, bool send_error)
     if (send_error)
     {
       my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
-               cs->csname,  hexbuf);
+               cs->cs_name.str,  hexbuf);
       return 0;
     }
     if (thd->is_strict_mode())
@@ -6395,7 +6394,7 @@ String *Item::check_well_formed_result(String *str, bool send_error)
     }
     push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                         ER_INVALID_CHARACTER_STRING,
-                        ER_THD(thd, ER_INVALID_CHARACTER_STRING), cs->csname,
+                        ER_THD(thd, ER_INVALID_CHARACTER_STRING), cs->cs_name.str,
                         hexbuf);
   }
   return str;
@@ -6420,7 +6419,7 @@ String_copier_for_item::copy_with_warn(CHARSET_INFO *dstcs, String *dst,
                         ER_INVALID_CHARACTER_STRING,
                         ER_THD(m_thd, ER_INVALID_CHARACTER_STRING),
                         srccs == &my_charset_bin ?
-                        dstcs->csname : srccs->csname,
+                        dstcs->cs_name.str : srccs->cs_name.str,
                         err.ptr());
     return false;
   }
@@ -6433,7 +6432,7 @@ String_copier_for_item::copy_with_warn(CHARSET_INFO *dstcs, String *dst,
     push_warning_printf(m_thd, Sql_condition::WARN_LEVEL_WARN,
                         ER_CANNOT_CONVERT_CHARACTER,
                         ER_THD(m_thd, ER_CANNOT_CONVERT_CHARACTER),
-                        srccs->csname, buf, dstcs->csname);
+                        srccs->cs_name.str, buf, dstcs->cs_name.str);
     return false;
   }
   return false;
diff --git a/sql/item.h b/sql/item.h
index db8398936fd..b5e3c14be43 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -5349,9 +5349,9 @@ public:
         tmp.derivation == DERIVATION_NONE)
     {
       my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
-               (*a)->collation.collation->name,
+               (*a)->collation.collation->coll_name.str,
                (*a)->collation.derivation_name(),
-               (*b)->collation.collation->name,
+               (*b)->collation.collation->coll_name.str,
                (*b)->collation.derivation_name(),
                func_name());
       return true;
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index 5575c23859b..ec43ae81710 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -2940,8 +2940,7 @@ void Item_func_char::print(String *str, enum_query_type query_type)
   if (collation.collation != &my_charset_bin)
   {
     str->append(STRING_WITH_LEN(" using "));
-    str->append(collation.collation->csname,
-                strlen(collation.collation->csname));
+    str->append(collation.collation->cs_name);
   }
   str->append(')');
 }
@@ -3534,8 +3533,7 @@ void Item_func_conv_charset::print(String *str, enum_query_type query_type)
   str->append(STRING_WITH_LEN("convert("));
   args[0]->print(str, query_type);
   str->append(STRING_WITH_LEN(" using "));
-  str->append(collation.collation->csname,
-              strlen(collation.collation->csname));
+  str->append(collation.collation->cs_name);
   str->append(')');
 }
 
@@ -3554,7 +3552,8 @@ bool Item_func_set_collation::fix_length_and_dec()
   if (!my_charset_same(args[0]->collation.collation, m_set_collation))
   {
     my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
-             m_set_collation->name, args[0]->collation.collation->csname);
+             m_set_collation->coll_name.str,
+             args[0]->collation.collation->cs_name.str);
     return TRUE;
   }
   collation.set(m_set_collation, DERIVATION_EXPLICIT,
@@ -3575,7 +3574,7 @@ void Item_func_set_collation::print(String *str, enum_query_type query_type)
 {
   args[0]->print_parenthesised(str, query_type, precedence());
   str->append(STRING_WITH_LEN(" collate "));
-  str->append(m_set_collation->name, strlen(m_set_collation->name));
+  str->append(m_set_collation->coll_name);
 }
 
 String *Item_func_charset::val_str(String *str)
@@ -3585,7 +3584,7 @@ String *Item_func_charset::val_str(String *str)
 
   CHARSET_INFO *cs= args[0]->charset_for_protocol(); 
   null_value= 0;
-  str->copy(cs->csname, (uint) strlen(cs->csname),
+  str->copy(cs->cs_name.str, cs->cs_name.length,
 	    &my_charset_latin1, collation.collation, &dummy_errors);
   return str;
 }
@@ -3597,8 +3596,8 @@ String *Item_func_collation::val_str(String *str)
   CHARSET_INFO *cs= args[0]->charset_for_protocol(); 
 
   null_value= 0;
-  str->copy(cs->name, (uint) strlen(cs->name),
-	    &my_charset_latin1, collation.collation, &dummy_errors);
+  str->copy(cs->coll_name.str, cs->coll_name.length, &my_charset_latin1,
+            collation.collation, &dummy_errors);
   return str;
 }
 
@@ -4633,8 +4632,7 @@ void Item_func_dyncol_create::print_arguments(String *str,
       if (defs[i].cs)
       {
         str->append(STRING_WITH_LEN(" charset "));
-        const char *cs= defs[i].cs->csname;
-        str->append(cs, strlen(cs));
+        str->append(defs[i].cs->cs_name);
         str->append(' ');
       }
       break;
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index cd46992701b..8f382c0686d 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -2287,7 +2287,7 @@ void Item_char_typecast::print(String *str, enum_query_type query_type)
   if (cast_cs)
   {
     str->append(STRING_WITH_LEN(" charset "));
-    str->append(cast_cs->csname, strlen(cast_cs->csname));
+    str->append(cast_cs->cs_name);
   }
   str->append(')');
 }
diff --git a/sql/item_xmlfunc.cc b/sql/item_xmlfunc.cc
index 0f5cc1c1250..2f4d34afc6d 100644
--- a/sql/item_xmlfunc.cc
+++ b/sql/item_xmlfunc.cc
@@ -2792,7 +2792,7 @@ bool Item_xml_str_func::fix_fields(THD *thd, Item **ref)
     /* UCS2 is not supported */
     my_printf_error(ER_UNKNOWN_ERROR,
                     "Character set '%s' is not supported by XPATH",
-                    MYF(0), collation.collation->csname);
+                    MYF(0), collation.collation->cs_name.str);
     return true;
   }
 
diff --git a/sql/json_table.cc b/sql/json_table.cc
index bbcc73028d9..aebc52b0832 100644
--- a/sql/json_table.cc
+++ b/sql/json_table.cc
@@ -914,7 +914,7 @@ int Json_table_column::print(THD *thd, Field **f, String *str)
     if (str->append(column_type) ||
         ((*f)->has_charset() && m_explicit_cs &&
          (str->append(STRING_WITH_LEN(" CHARSET ")) ||
-          str->append(m_explicit_cs->csname, strlen(m_explicit_cs->csname)))) ||
+          str->append(&m_explicit_cs->cs_name))) ||
         str->append(m_column_type == PATH ? &path : &exists_path) ||
         print_path(str, &m_path))
       return 1;
diff --git a/sql/log_event_client.cc b/sql/log_event_client.cc
index 9d53611260b..3db66e4201f 100644
--- a/sql/log_event_client.cc
+++ b/sql/log_event_client.cc
@@ -1951,7 +1951,7 @@ bool Query_log_event::print_query_header(IO_CACHE* file,
     {
       /* for mysql client */
       if (my_b_printf(file, "/*!\\C %s */%s\n",
-                      cs_info->csname, print_event_info->delimiter))
+                      cs_info->cs_name.str, print_event_info->delimiter))
         goto err;
     }
     if (my_b_printf(file,"SET "
@@ -2502,7 +2502,7 @@ bool User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
       }
       else
         error= my_b_printf(&cache, ":=_%s %s COLLATE `%s`%s\n",
-                           cs->csname, hex_str, cs->name,
+                           cs->cs_name.str, hex_str, cs->coll_name.str,
                            print_event_info->delimiter);
       my_free(hex_str);
       if (unlikely(error))
@@ -3563,7 +3563,8 @@ void Table_map_log_event::print_columns(IO_CACHE *file,
     // Print column character set, except in text columns with binary collation
     if (cs != NULL &&
         (is_enum_or_set_type(real_type) || cs->number != my_charset_bin.number))
-      my_b_printf(file, " CHARSET %s COLLATE %s", cs->csname, cs->name);
+      my_b_printf(file, " CHARSET %s COLLATE %s", cs->cs_name.str,
+                  cs->coll_name.str);
     if (i != m_colcnt - 1) my_b_printf(file, ",\n#         ");
   }
   my_b_printf(file, ")");
diff --git a/sql/log_event_server.cc b/sql/log_event_server.cc
index 6ed79fa6b48..4c86acb909a 100644
--- a/sql/log_event_server.cc
+++ b/sql/log_event_server.cc
@@ -4215,7 +4215,7 @@ void User_var_log_event::pack_info(Protocol* protocol)
         char *beg, *end;
         if (user_var_append_name_part(protocol->thd, &buf, name, name_len) ||
             buf.append('_') ||
-            buf.append(cs->csname, strlen(cs->csname)) ||
+            buf.append(cs->cs_name) ||
             buf.append(' '))
           return;
         old_len= buf.length();
@@ -4226,7 +4226,7 @@ void User_var_log_event::pack_info(Protocol* protocol)
         end= str_to_hex(beg, val, val_len);
         buf.length(old_len + (end - beg));
         if (buf.append(STRING_WITH_LEN(" COLLATE ")) ||
-            buf.append(cs->name, strlen(cs->name)))
+            buf.append(cs->coll_name))
           return;
       }
       protocol->store(buf.ptr(), buf.length(), &my_charset_bin);
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 0c3e67fe0d6..f154c655de2 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -4148,7 +4148,7 @@ static int init_common_variables()
     {
       sql_print_error(ER_DEFAULT(ER_COLLATION_CHARSET_MISMATCH),
 		      default_collation_name,
-		      default_charset_info->csname);
+		      default_charset_info->cs_name.str);
       return 1;
     }
     default_charset_info= default_collation;
@@ -4166,8 +4166,8 @@ static int init_common_variables()
   {
     sql_print_warning("'%s' can not be used as client character set. "
                       "'%s' will be used as default client character set.",
-                      default_charset_info->csname,
-                      my_charset_latin1.csname);
+                      default_charset_info->cs_name.str,
+                      my_charset_latin1.cs_name.str);
     global_system_variables.collation_connection= &my_charset_latin1;
     global_system_variables.character_set_results= &my_charset_latin1;
     global_system_variables.character_set_client= &my_charset_latin1;
@@ -7512,7 +7512,7 @@ static void usage(void)
 						         MYF(utf8_flag | MY_WME))))
     exit(1);
   if (!default_collation_name)
-    default_collation_name= (char*) default_charset_info->name;
+    default_collation_name= (char*) default_charset_info->coll_name.str;
   print_version();
   puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
   puts("Starts the MariaDB database server.\n");
diff --git a/sql/protocol.h b/sql/protocol.h
index bb9de2215f2..1beb1175a11 100644
--- a/sql/protocol.h
+++ b/sql/protocol.h
@@ -99,11 +99,6 @@ public:
   bool send_result_set_row(List<Item> *row_items);
 
   bool store(I_List<i_string> *str_list);
-  /* This will be deleted in future commit */
-  bool store(const char *from, CHARSET_INFO *cs)
-  {
-    return store_string_or_null(from, cs);
-  }
   bool store_string_or_null(const char *from, CHARSET_INFO *cs);
   bool store_warning(const char *from, size_t length);
   String *storage_packet() { return packet; }
diff --git a/sql/set_var.cc b/sql/set_var.cc
index f2b20686514..8e2e8b12a06 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -1033,7 +1033,7 @@ int set_var_collation_client::check(THD *thd)
   if (!is_supported_parser_charset(character_set_client))
   {
     my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "character_set_client",
-             character_set_client->csname);
+             character_set_client->cs_name.str);
     return 1;
   }
   return 0;
diff --git a/sql/slave.cc b/sql/slave.cc
index 9eba7148637..09aa1f97936 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -2030,7 +2030,8 @@ maybe it is a *VERY OLD MASTER*.");
         (master_res= mysql_store_result(mysql)) &&
         (master_row= mysql_fetch_row(master_res)))
     {
-      if (strcmp(master_row[0], global_system_variables.collation_server->name))
+      if (strcmp(master_row[0],
+                 global_system_variables.collation_server->coll_name.str))
       {
         errmsg= "The slave I/O thread stops because master and slave have \
 different values for the COLLATION_SERVER global variable. The values must \
@@ -7205,16 +7206,16 @@ static int connect_to_master(THD* thd, MYSQL* mysql, Master_info* mi,
     charset, then set client charset to 'latin1' (default client charset).
   */
   if (is_supported_parser_charset(default_charset_info))
-    mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->csname);
+    mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->cs_name.str);
   else
   {
     sql_print_information("'%s' can not be used as client character set. "
                           "'%s' will be used as default client character set "
                           "while connecting to master.",
-                          default_charset_info->csname,
-                          default_client_charset_info->csname);
+                          default_charset_info->cs_name.str,
+                          default_client_charset_info->cs_name.str);
     mysql_options(mysql, MYSQL_SET_CHARSET_NAME,
-                  default_client_charset_info->csname);
+                  default_client_charset_info->cs_name.str);
   }
 
   /* This one is not strictly needed but we have it here for completeness */
@@ -7361,7 +7362,8 @@ MYSQL *rpl_connect_master(MYSQL *mysql)
   }
 #endif
 
-  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->csname);
+  mysql_options(mysql, MYSQL_SET_CHARSET_NAME,
+                default_charset_info->cs_name.str);
   /* This one is not strictly needed but we have it here for completeness */
   mysql_options(mysql, MYSQL_SET_CHARSET_DIR, (char *) charsets_dir);
 
diff --git a/sql/sp.cc b/sql/sp.cc
index c821ebe6480..12fb7e79cde 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -1075,14 +1075,12 @@ sp_returns_type(THD *thd, String &result, const sp_head *sp)
 
   if (field->has_charset())
   {
-    const char *name= field->charset()->csname;
     result.append(STRING_WITH_LEN(" CHARSET "));
-    result.append(name, strlen(name));
+    result.append(field->charset()->cs_name);
     if (!(field->charset()->state & MY_CS_PRIMARY))
     {
-      name= field->charset()->name;
       result.append(STRING_WITH_LEN(" COLLATE "));
-      result.append(name, strlen(name));
+      result.append(field->charset()->coll_name);
     }
   }
 
@@ -1428,22 +1426,19 @@ Sp_handler::sp_create_routine(THD *thd, const sp_head *sp) const
 
     table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]->set_notnull();
     store_failed= store_failed ||
-      table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]->store(
-        thd->charset()->csname,
-        strlen(thd->charset()->csname),
-        system_charset_info);
+      table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]->
+      store(&thd->charset()->cs_name, system_charset_info);
 
     table->field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]->set_notnull();
     store_failed= store_failed ||
-      table->field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]->store(
-        thd->variables.collation_connection->name,
-        strlen(thd->variables.collation_connection->name),
-        system_charset_info);
+      table->field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]->
+      store(&thd->variables.collation_connection->coll_name,
+            system_charset_info);
 
     table->field[MYSQL_PROC_FIELD_DB_COLLATION]->set_notnull();
     store_failed= store_failed ||
-      table->field[MYSQL_PROC_FIELD_DB_COLLATION]->store(
-        db_cs->name, strlen(db_cs->name), system_charset_info);
+      table->field[MYSQL_PROC_FIELD_DB_COLLATION]->
+      store(&db_cs->coll_name, system_charset_info);
 
     table->field[MYSQL_PROC_FIELD_BODY_UTF8]->set_notnull();
     store_failed= store_failed ||
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index d897a6b2f66..0812d61ced8 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -3110,9 +3110,12 @@ sp_head::show_create_routine(THD *thd, const Sp_handler *sph)
     protocol->store_null();
 
 
-  protocol->store(m_creation_ctx->get_client_cs()->csname, system_charset_info);
-  protocol->store(m_creation_ctx->get_connection_cl()->name, system_charset_info);
-  protocol->store(m_creation_ctx->get_db_cl()->name, system_charset_info);
+  protocol->store(&m_creation_ctx->get_client_cs()->cs_name,
+                  system_charset_info);
+  protocol->store(&m_creation_ctx->get_connection_cl()->coll_name,
+                  system_charset_info);
+  protocol->store(&m_creation_ctx->get_db_cl()->coll_name,
+                  system_charset_info);
 
   err_status= protocol->write();
 
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index fd528c749e5..ff927447c79 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -2344,7 +2344,7 @@ bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
   {
     my_error(ER_BAD_DATA, MYF(0),
              ErrConvString(from, from_length, from_cs).ptr(),
-             to_cs->csname);
+             to_cs->cs_name.str);
     DBUG_RETURN(true);
   }
   DBUG_RETURN(false);
@@ -2396,7 +2396,8 @@ public:
     if (most_important_error_pos())
     {
       ErrConvString err(src, src_length, &my_charset_bin);
-      my_error(ER_INVALID_CHARACTER_STRING, MYF(0), srccs->csname, err.ptr());
+      my_error(ER_INVALID_CHARACTER_STRING, MYF(0), srccs->cs_name.str,
+               err.ptr());
       return true;
     }
     return false;
@@ -2464,7 +2465,7 @@ bool THD::check_string_for_wellformedness(const char *str,
   if (wlen < length)
   {
     ErrConvString err(str, length, &my_charset_bin);
-    my_error(ER_INVALID_CHARACTER_STRING, MYF(0), cs->csname, err.ptr());
+    my_error(ER_INVALID_CHARACTER_STRING, MYF(0), cs->cs_name.str, err.ptr());
     return true;
   }
   return false;
diff --git a/sql/sql_connect.cc b/sql/sql_connect.cc
index e0119e50eaa..1da8c42d96e 100644
--- a/sql/sql_connect.cc
+++ b/sql/sql_connect.cc
@@ -798,7 +798,7 @@ bool thd_init_client_charset(THD *thd, uint cs_number)
     {
       /* Disallow non-supported parser character sets: UCS2, UTF16, UTF32 */
       my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "character_set_client",
-               cs->csname);
+               cs->cs_name.str);
       return true;
     }
     thd->org_charset= cs;
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index be90ee88a50..da232526cd1 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -506,9 +506,9 @@ static bool write_db_opt(THD *thd, const char *path,
   {
     ulong length;
     length= (ulong) (strxnmov(buf, sizeof(buf)-1, "default-character-set=",
-                              create->default_table_charset->csname,
+                              create->default_table_charset->cs_name.str,
                               "\ndefault-collation=",
-                              create->default_table_charset->name,
+                              create->default_table_charset->coll_name.str,
                               "\n", NullS) - buf);
 
     if (create->schema_comment)
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index b901548bf23..865318e3f05 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -867,7 +867,7 @@ static bool write_execute_load_query_log_event(THD *thd, const sql_exchange* ex,
      */
     qualify_db= db_arg;
   }
-  lle.print_query(thd, FALSE, (const char *) ex->cs?ex->cs->csname:NULL,
+  lle.print_query(thd, FALSE, (const char*) ex->cs ? ex->cs->cs_name.str : NULL,
                   &query_str, &fname_start, &fname_end, qualify_db);
 
   /*
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 8691a4e3436..7511f77d9c3 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -10444,7 +10444,8 @@ merge_charset_and_collation(CHARSET_INFO *cs, CHARSET_INFO *cl)
   {
     if (!my_charset_same(cs, cl))
     {
-      my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0), cl->name, cs->csname);
+      my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0), cl->coll_name.str,
+               cs->cs_name.str);
       return NULL;
     }
     return cl;
@@ -10456,7 +10457,7 @@ merge_charset_and_collation(CHARSET_INFO *cs, CHARSET_INFO *cl)
 */
 CHARSET_INFO *find_bin_collation(CHARSET_INFO *cs)
 {
-  const char *csname= cs->csname;
+  const char *csname= cs->cs_name.str;
   THD *thd= current_thd;
   myf utf8_flag= thd->get_utf8_flag();
 
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 8951ef82aa5..bd73220310f 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -1333,11 +1333,11 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list)
     buffer.set_charset(table_list->view_creation_ctx->get_client_cs());
     protocol->store(&buffer);
 
-    protocol->store(table_list->view_creation_ctx->get_client_cs()->csname,
+    protocol->store(&table_list->view_creation_ctx->get_client_cs()->cs_name,
                     system_charset_info);
 
-    protocol->store(table_list->view_creation_ctx->get_connection_cl()->name,
-                    system_charset_info);
+    protocol->store(&table_list->view_creation_ctx->get_connection_cl()->
+                    coll_name, system_charset_info);
   }
   else
     protocol->store(&buffer);
@@ -1440,13 +1440,11 @@ bool mysqld_show_create_db(THD *thd, LEX_CSTRING *dbname,
   {
     buffer.append(STRING_WITH_LEN(" /*!40100"));
     buffer.append(STRING_WITH_LEN(" DEFAULT CHARACTER SET "));
-    buffer.append(create.default_table_charset->csname,
-                  strlen(create.default_table_charset->csname));
+    buffer.append(create.default_table_charset->cs_name);
     if (!(create.default_table_charset->state & MY_CS_PRIMARY))
     {
       buffer.append(STRING_WITH_LEN(" COLLATE "));
-      buffer.append(create.default_table_charset->name,
-                    strlen(create.default_table_charset->name));
+      buffer.append(create.default_table_charset->coll_name);
     }
     buffer.append(STRING_WITH_LEN(" */"));
   }
@@ -1902,13 +1900,11 @@ static void add_table_options(THD *thd, TABLE *table,
         (create_info_arg->used_fields & HA_CREATE_USED_DEFAULT_CHARSET))
     {
       packet->append(STRING_WITH_LEN(" DEFAULT CHARSET="));
-      packet->append(share->table_charset->csname,
-                     strlen(share->table_charset->csname));
+      packet->append(share->table_charset->cs_name);
       if (!(share->table_charset->state & MY_CS_PRIMARY))
       {
         packet->append(STRING_WITH_LEN(" COLLATE="));
-        packet->append(table->s->table_charset->name,
-                       strlen(table->s->table_charset->name));
+        packet->append(table->s->table_charset->coll_name);
       }
     }
   }
@@ -2190,8 +2186,7 @@ int show_create_table_ex(THD *thd, TABLE_LIST *table_list,
       if (field->charset() != share->table_charset)
       {
 	packet->append(STRING_WITH_LEN(" CHARACTER SET "));
-	packet->append(field->charset()->csname,
-                       strlen(field->charset()->csname));
+	packet->append(field->charset()->cs_name);
       }
       /*
 	For string types dump collation name only if
@@ -2205,7 +2200,7 @@ int show_create_table_ex(THD *thd, TABLE_LIST *table_list,
            field->charset() != field->vcol_info->expr->collation.collation))
       {
 	packet->append(STRING_WITH_LEN(" COLLATE "));
-	packet->append(field->charset()->name, strlen(field->charset()->name));
+	packet->append(field->charset()->coll_name);
       }
     }
 
@@ -5309,9 +5304,9 @@ bool store_schema_schemata(THD* thd, TABLE *table, LEX_CSTRING *db_name,
 {
   restore_record(table, s->default_values);
   table->field[0]->store(STRING_WITH_LEN("def"), system_charset_info);
-  table->field[1]->store(db_name->str, db_name->length, system_charset_info);
-  table->field[2]->store(cs->csname, strlen(cs->csname), system_charset_info);
-  table->field[3]->store(cs->name, strlen(cs->name), system_charset_info);
+  table->field[1]->store(db_name, system_charset_info);
+  table->field[2]->store(&cs->cs_name, system_charset_info);
+  table->field[3]->store(&cs->coll_name, system_charset_info);
   if (schema_comment)
     table->field[5]->store(schema_comment->str, schema_comment->length,
                            system_charset_info);
@@ -5598,13 +5593,15 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables,
     if (str.length())
       table->field[19]->store(str.ptr()+1, str.length()-1, cs);
 
-    tmp_buff= (share->table_charset ?
-               share->table_charset->name : "default");
-
-    table->field[17]->store(tmp_buff, strlen(tmp_buff), cs);
+    LEX_CSTRING tmp_str;
+    if (share->table_charset)
+      tmp_str= share->table_charset->coll_name;
+    else
+      tmp_str= { STRING_WITH_LEN("default") };
+    table->field[17]->store(&tmp_str, cs);
 
     if (share->comment.str)
-      table->field[20]->store(share->comment.str, share->comment.length, cs);
+      table->field[20]->store(&share->comment, cs);
 
     /* Collect table info from the storage engine  */
 
@@ -5825,12 +5822,10 @@ static void store_column_type(TABLE *table, Field *field, CHARSET_INFO *cs,
   if (field->has_charset())
   {
     /* CHARACTER_SET_NAME column*/
-    tmp_buff= field->charset()->csname;
-    table->field[offset + 6]->store(tmp_buff, strlen(tmp_buff), cs);
+    table->field[offset + 6]->store(&field->charset()->cs_name, cs);
     table->field[offset + 6]->set_notnull();
     /* COLLATION_NAME column */
-    tmp_buff= field->charset()->name;
-    table->field[offset + 7]->store(tmp_buff, strlen(tmp_buff), cs);
+    table->field[offset + 7]->store(&field->charset()->coll_name, cs);
     table->field[offset + 7]->set_notnull();
   }
 }
@@ -6117,12 +6112,12 @@ int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond)
         (tmp_cs->state & MY_CS_AVAILABLE) &&
         !(tmp_cs->state & MY_CS_HIDDEN) &&
         !(wild && wild[0] &&
-	  wild_case_compare(scs, tmp_cs->csname,wild)))
+	  wild_case_compare(scs, tmp_cs->cs_name.str,wild)))
     {
       const char *comment;
       restore_record(table, s->default_values);
-      table->field[0]->store(tmp_cs->csname, strlen(tmp_cs->csname), scs);
-      table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
+      table->field[0]->store(&tmp_cs->cs_name, scs);
+      table->field[1]->store(&tmp_cs->coll_name, scs);
       comment= tmp_cs->comment ? tmp_cs->comment : "";
       table->field[2]->store(comment, strlen(comment), scs);
       table->field[3]->store((longlong) tmp_cs->mbmaxlen, TRUE);
@@ -6234,12 +6229,13 @@ int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond)
           !my_charset_same(tmp_cs, tmp_cl))
 	continue;
       if (!(wild && wild[0] &&
-	  wild_case_compare(scs, tmp_cl->name,wild)))
+	  wild_case_compare(scs, tmp_cl->coll_name.str, wild)))
       {
 	const char *tmp_buff;
 	restore_record(table, s->default_values);
-	table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
-        table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
+	table->field[0]->store(tmp_cl->coll_name.str, tmp_cl->coll_name.length,
+                               scs);
+        table->field[1]->store(&tmp_cl->cs_name, scs);
         table->field[2]->store((longlong) tmp_cl->number, TRUE);
         tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : "";
 	table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
@@ -6279,8 +6275,8 @@ int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond)
           !my_charset_same(tmp_cs,tmp_cl))
 	continue;
       restore_record(table, s->default_values);
-      table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
-      table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
+      table->field[0]->store(&tmp_cl->coll_name, scs);
+      table->field[1]->store(&tmp_cl->cs_name, scs);
       if (schema_table_store_record(thd, table))
         return 1;
     }
@@ -6883,15 +6879,10 @@ static int get_schema_views_record(THD *thd, TABLE_LIST *tables,
     else
       table->field[7]->store(STRING_WITH_LEN("INVOKER"), cs);
 
-    table->field[8]->store(tables->view_creation_ctx->get_client_cs()->csname,
-                           strlen(tables->view_creation_ctx->
-                                  get_client_cs()->csname), cs);
-
-    table->field[9]->store(tables->view_creation_ctx->
-                           get_connection_cl()->name,
-                           strlen(tables->view_creation_ctx->
-                                  get_connection_cl()->name), cs);
-
+    table->field[8]->store(&tables->view_creation_ctx->get_client_cs()->cs_name,
+                           cs);
+    table->field[9]->store(&tables->view_creation_ctx->
+                           get_connection_cl()->coll_name, cs);
     table->field[10]->store(view_algorithm(tables), cs);
 
     if (schema_table_store_record(thd, table))
@@ -7094,12 +7085,9 @@ static bool store_trigger(THD *thd, Trigger *trigger,
   sql_mode_string_representation(thd, trigger->sql_mode, &sql_mode_rep);
   table->field[17]->store(sql_mode_rep.str, sql_mode_rep.length, cs);
   table->field[18]->store(definer_buffer.str, definer_buffer.length, cs);
-  table->field[19]->store(trigger->client_cs_name.str,
-                          trigger->client_cs_name.length, cs);
-  table->field[20]->store(trigger->connection_cl_name.str,
-                          trigger->connection_cl_name.length, cs);
-  table->field[21]->store(trigger->db_cl_name.str,
-                          trigger->db_cl_name.length, cs);
+  table->field[19]->store(&trigger->client_cs_name, cs);
+  table->field[20]->store(&trigger->connection_cl_name, cs);
+  table->field[21]->store(&trigger->db_cl_name, cs);
 
   return schema_table_store_record(thd, table);
 }
@@ -7786,22 +7774,15 @@ copy_event_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table)
                       store(et.comment.str, et.comment.length, scs);
 
   sch_table->field[ISE_CLIENT_CS]->set_notnull();
-  sch_table->field[ISE_CLIENT_CS]->store(
-    et.creation_ctx->get_client_cs()->csname,
-    strlen(et.creation_ctx->get_client_cs()->csname),
-    scs);
-
+  sch_table->field[ISE_CLIENT_CS]->store(&et.creation_ctx->get_client_cs()->
+                                         cs_name, scs);
   sch_table->field[ISE_CONNECTION_CL]->set_notnull();
-  sch_table->field[ISE_CONNECTION_CL]->store(
-    et.creation_ctx->get_connection_cl()->name,
-    strlen(et.creation_ctx->get_connection_cl()->name),
-    scs);
-
+  sch_table->field[ISE_CONNECTION_CL]->store(&et.creation_ctx->
+                                             get_connection_cl()->coll_name,
+                                             scs);
   sch_table->field[ISE_DB_CL]->set_notnull();
-  sch_table->field[ISE_DB_CL]->store(
-    et.creation_ctx->get_db_cl()->name,
-    strlen(et.creation_ctx->get_db_cl()->name),
-    scs);
+  sch_table->field[ISE_DB_CL]->store(&et.creation_ctx->get_db_cl()->coll_name,
+                                     scs);
 
   if (schema_table_store_record(thd, sch_table))
     DBUG_RETURN(1);
@@ -9841,17 +9822,11 @@ static bool show_create_trigger_impl(THD *thd, Trigger *trigger)
            trg_sql_original_stmt.length,
            trg_client_cs);
 
-  p->store(trigger->client_cs_name.str,
-           trigger->client_cs_name.length,
-           system_charset_info);
+  p->store(&trigger->client_cs_name, system_charset_info);
 
-  p->store(trigger->connection_cl_name.str,
-           trigger->connection_cl_name.length,
-           system_charset_info);
+  p->store(&trigger->connection_cl_name, system_charset_info);
 
-  p->store(trigger->db_cl_name.str,
-           trigger->db_cl_name.length,
-           system_charset_info);
+  p->store(&trigger->db_cl_name, system_charset_info);
 
   if (trigger->create_time)
   {
diff --git a/sql/sql_string.h b/sql/sql_string.h
index a4f6c8592d2..809e8cb8275 100644
--- a/sql/sql_string.h
+++ b/sql/sql_string.h
@@ -183,7 +183,7 @@ public:
   }
   bool same_encoding(const Charset &other) const
   {
-    return !strcmp(m_charset->csname, other.m_charset->csname);
+    return my_charset_same(m_charset, other.m_charset);
   }
   /*
     Collation name without the character set name.
@@ -936,7 +936,7 @@ public:
   {
     return
       append('_')   ||
-      append(str->charset()->csname, strlen(str->charset()->csname)) ||
+      append(str->charset()->cs_name) ||
       append(STRING_WITH_LEN(" 0x")) ||
       append_hex(str->ptr(), (uint32) str->length());
   }
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 9b9a6653793..03ac4678b44 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -4658,13 +4658,13 @@ bool validate_comment_length(THD *thd, LEX_CSTRING *comment, size_t max_len,
       if (thd->is_strict_mode())
       {
          my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
-                  system_charset_info->csname, comment->str);
+                  system_charset_info->cs_name.str, comment->str);
          DBUG_RETURN(true);
       }
       push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                           ER_INVALID_CHARACTER_STRING,
                           ER_THD(thd, ER_INVALID_CHARACTER_STRING),
-                          system_charset_info->csname, comment->str);
+                          system_charset_info->cs_name.str, comment->str);
       comment->length= tmp_len;
       DBUG_RETURN(false);
     }
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index 6f1a21ab791..e78e4f1d90c 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -937,11 +937,9 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables,
       - connection collation contains pair {character set, collation};
       - database collation contains pair {character set, collation};
   */
-  lex_string_set(&trigger->client_cs_name, thd->charset()->csname);
-  lex_string_set(&trigger->connection_cl_name,
-                 thd->variables.collation_connection->name);
-  lex_string_set(&trigger->db_cl_name,
-                 get_default_db_collation(thd, tables->db.str)->name);
+  trigger->client_cs_name= thd->charset()->cs_name;
+  trigger->connection_cl_name= thd->variables.collation_connection->coll_name;
+  trigger->db_cl_name= get_default_db_collation(thd, tables->db.str)->coll_name;
 
   /* Add trigger in it's correct place */
   add_trigger(lex->trg_chistics.event,
@@ -1505,12 +1503,9 @@ bool Table_triggers_list::check_n_load(THD *thd, const LEX_CSTRING *db,
                                         lex.raw_trg_on_table_name_begin);
 
         /* Copy pointers to character sets to make trigger easier to use */
-        lex_string_set(&trigger->client_cs_name,
-                       creation_ctx->get_client_cs()->csname);
-        lex_string_set(&trigger->connection_cl_name,
-                       creation_ctx->get_connection_cl()->name);
-        lex_string_set(&trigger->db_cl_name,
-                       creation_ctx->get_db_cl()->name);
+        trigger->client_cs_name= creation_ctx->get_client_cs()->cs_name;
+        trigger->connection_cl_name= creation_ctx->get_connection_cl()->coll_name;
+        trigger->db_cl_name= creation_ctx->get_db_cl()->coll_name;
 
         /* event can only be TRG_EVENT_MAX in case of fatal parse errors */
         if (lex.trg_chistics.event != TRG_EVENT_MAX)
diff --git a/sql/sql_type.cc b/sql/sql_type.cc
index c5c34bac9f5..0700dcea9d4 100644
--- a/sql/sql_type.cc
+++ b/sql/sql_type.cc
@@ -6231,17 +6231,15 @@ String *Type_handler::
 
   StringBuffer<STRING_BUFFER_USUAL_SIZE> buf(result->charset());
   CHARSET_INFO *cs= thd->variables.character_set_client;
-  const char *res_cs_name= result->charset()->csname;
-  const char *collation_name= item->collation.collation->name;
 
   buf.append('_');
-  buf.append(res_cs_name, strlen(res_cs_name));
+  buf.append(result->charset()->cs_name);
   if (cs->escape_with_backslash_is_dangerous)
     buf.append(' ');
   append_query_string(cs, &buf, result->ptr(), result->length(),
                      thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES);
   buf.append(STRING_WITH_LEN(" COLLATE '"));
-  buf.append(collation_name, strlen(collation_name));
+  buf.append(item->collation.collation->coll_name);
   buf.append('\'');
   str->copy(buf);
 
@@ -9382,33 +9380,27 @@ LEX_CSTRING Charset::collation_specific_name() const
     for character sets and collations, so a collation
     name not necessarily starts with the character set name.
   */
-  LEX_CSTRING retval;
-  size_t csname_length= strlen(m_charset->csname);
-  if (strncmp(m_charset->name, m_charset->csname, csname_length))
-  {
-    retval.str= NULL;
-    retval.length= 0;
-    return retval;
-  }
-  const char *ptr= m_charset->name + csname_length;
-  retval.str= ptr;
-  retval.length= strlen(ptr);
-  return retval;
+  size_t cs_name_length= m_charset->cs_name.length;
+  if (strncmp(m_charset->coll_name.str, m_charset->cs_name.str,
+              cs_name_length))
+    return {NULL, 0};
+  const char *ptr= m_charset->coll_name.str + cs_name_length;
+  return {ptr, m_charset->coll_name.length - cs_name_length };
 }
 
 
 bool
 Charset::encoding_allows_reinterpret_as(const CHARSET_INFO *cs) const
 {
-  if (!strcmp(m_charset->csname, cs->csname))
+  if (my_charset_same(m_charset, cs))
     return true;
 
-  if (!strcmp(m_charset->csname, MY_UTF8MB3) &&
-      !strcmp(cs->csname, MY_UTF8MB4))
+  if (!strcmp(m_charset->cs_name.str, MY_UTF8MB3) &&
+      !strcmp(cs->cs_name.str, MY_UTF8MB4))
     return true;
 
   /*
-    Originally we allowed here instat ALTER for ASCII-to-LATIN1
+    Originally we allowed here instant ALTER for ASCII-to-LATIN1
     and UCS2-to-UTF16, but this was wrong:
     - MariaDB's ascii is not a subset for 8-bit character sets
       like latin1, because it allows storing bytes 0x80..0xFF as
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index fffe37a8054..139fc0f5e85 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -1094,11 +1094,10 @@ loop_out:
     frm-file.
   */
 
-  lex_string_set(&view->view_client_cs_name,
-                 view->view_creation_ctx->get_client_cs()->csname);
+  view->view_client_cs_name= view->view_creation_ctx->get_client_cs()->cs_name;
 
-  lex_string_set(&view->view_connection_cl_name,
-                 view->view_creation_ctx->get_connection_cl()->name);
+  view->view_connection_cl_name=
+    view->view_creation_ctx->get_connection_cl()->coll_name;
 
   if (!thd->make_lex_string(&view->view_body_utf8, is_query.ptr(),
                             is_query.length()))
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index d819767a6ca..f589bbf5b99 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -202,7 +202,7 @@ void _CONCAT_UNDERSCORED(turn_parser_debug_on,yyparse)()
     {  \
       if (unlikely(Lex->charset && !my_charset_same(Lex->charset,X)))  \
         my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),  \
-                          X->name,Lex->charset->csname));  \
+                          X->coll_name.str,Lex->charset->cs_name.str));  \
       Lex->charset= X;  \
     }  \
   } while(0)
@@ -6581,7 +6581,7 @@ attribute:
           {
             if (unlikely(Lex->charset && !my_charset_same(Lex->charset,$2)))
               my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),
-                                $2->name,Lex->charset->csname));
+                                $2->coll_name.str, Lex->charset->cs_name.str));
             Lex->last_field->charset= $2;
           }
         | serial_attribute
@@ -6799,7 +6799,7 @@ binary:
           {
             if (!my_charset_same(Lex->charset, $1))
               my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),
-                                Lex->charset->name, $1->csname));
+                                Lex->charset->coll_name.str, $1->cs_name.str));
           }
         | collate { }
         ;
@@ -7882,7 +7882,7 @@ alter_list_item:
             $5= $5 ? $5 : $4;
             if (unlikely(!my_charset_same($4,$5)))
               my_yyabort_error((ER_COLLATION_CHARSET_MISMATCH, MYF(0),
-                                $5->name, $4->csname));
+                                $5->coll_name.str, $4->cs_name.str));
             if (unlikely(Lex->create_info.add_alter_list_item_convert_to_charset($5)))
               MYSQL_YYABORT;
             Lex->alter_info.flags|= ALTER_CONVERT_TO;
@@ -16757,7 +16757,7 @@ option_value_no_option_type:
             if (unlikely(!my_charset_same(cs2, cs3)))
             {
               my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
-                       cs3->name, cs2->csname);
+                       cs3->coll_name.str, cs2->cs_name.str);
               MYSQL_YYABORT;
             }
             set_var_collation_client *var;
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
index 358f0078381..73fefeead50 100644
--- a/sql/sys_vars.cc
+++ b/sql/sys_vars.cc
@@ -789,12 +789,12 @@ static Sys_var_struct Sys_character_set_system(
        "character_set_system", "The character set used by the server "
        "for storing identifiers",
        READ_ONLY GLOBAL_VAR(system_charset_info), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(0));
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(0));
 
 static Sys_var_struct Sys_character_set_server(
        "character_set_server", "The default character set",
        SESSION_VAR(collation_server), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_not_null));
 
 static bool check_charset_db(sys_var *self, THD *thd, set_var *var)
@@ -809,7 +809,7 @@ static Sys_var_struct Sys_character_set_database(
        "character_set_database",
        "The character set used by the default database",
        SESSION_VAR(collation_database), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_db));
 
 static bool check_cs_client(sys_var *self, THD *thd, set_var *var)
@@ -833,7 +833,7 @@ static Sys_var_struct Sys_character_set_client(
        "character_set_client", "The character set for statements "
        "that arrive from the client",
        NO_SET_STMT SESSION_VAR(character_set_client), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_cs_client),
        ON_UPDATE(fix_thd_charset));
 // for check changing
@@ -844,7 +844,7 @@ static Sys_var_struct Sys_character_set_connection(
        "literals that do not have a character set introducer and for "
        "number-to-string conversion",
        NO_SET_STMT SESSION_VAR(collation_connection), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_charset_not_null),
        ON_UPDATE(fix_thd_charset));
 // for check changing
@@ -854,7 +854,7 @@ static Sys_var_struct Sys_character_set_results(
        "character_set_results", "The character set used for returning "
        "query results to the client",
        SESSION_VAR(character_set_results), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_charset));
 // for check changing
 export sys_var *Sys_character_set_results_ptr= &Sys_character_set_results;
@@ -862,7 +862,7 @@ export sys_var *Sys_character_set_results_ptr= &Sys_character_set_results;
 static Sys_var_struct Sys_character_set_filesystem(
        "character_set_filesystem", "The filesystem character set",
        NO_SET_STMT SESSION_VAR(character_set_filesystem), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, csname), DEFAULT(&character_set_filesystem),
+       offsetof(CHARSET_INFO, cs_name.str), DEFAULT(&character_set_filesystem),
        NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_charset_not_null),
        ON_UPDATE(fix_thd_charset));
 
@@ -908,7 +908,7 @@ static Sys_var_struct Sys_collation_connection(
        "collation_connection", "The collation of the connection "
        "character set",
        NO_SET_STMT SESSION_VAR(collation_connection), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, name), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, coll_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_not_null),
        ON_UPDATE(fix_thd_charset));
 
@@ -924,13 +924,13 @@ static Sys_var_struct Sys_collation_database(
        "collation_database", "The collation of the database "
        "character set",
        SESSION_VAR(collation_database), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, name), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, coll_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_db));
 
 static Sys_var_struct Sys_collation_server(
        "collation_server", "The server default collation",
        SESSION_VAR(collation_server), NO_CMD_LINE,
-       offsetof(CHARSET_INFO, name), DEFAULT(&default_charset_info),
+       offsetof(CHARSET_INFO, coll_name.str), DEFAULT(&default_charset_info),
        NO_MUTEX_GUARD, IN_BINLOG, ON_CHECK(check_collation_not_null));
 
 static Sys_var_uint Sys_column_compression_threshold(
diff --git a/sql/table.cc b/sql/table.cc
index fcbba0b0212..f907ae04f52 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -2580,8 +2580,9 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
         {
           // 3.23 or 4.0 string
           myf utf8_flag= thd->get_utf8_flag();
-          if (!(attr.charset= get_charset_by_csname(share->table_charset->csname,
-                                                         MY_CS_BINSORT,
+          if (!(attr.charset= get_charset_by_csname(share->table_charset->
+                                                    cs_name.str,
+                                                    MY_CS_BINSORT,
                                                     MYF(utf8_flag))))
             attr.charset= &my_charset_bin;
         }
@@ -5187,7 +5188,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
         error= TRUE;
       }
       else if (field_def->cset.str &&
-               strcmp(field->charset()->csname, field_def->cset.str))
+               strcmp(field->charset()->cs_name.str, field_def->cset.str))
       {
         report_error(0, "Incorrect definition of table %s.%s: "
                      "expected the type of column '%s' at position %d "
@@ -5195,7 +5196,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
                      "character set '%s'.", table->s->db.str,
                      table->alias.c_ptr(),
                      field_def->name.str, i, field_def->cset.str,
-                     field->charset()->csname);
+                     field->charset()->cs_name.str);
         error= TRUE;
       }
     }
diff --git a/sql/wsrep_sst.cc b/sql/wsrep_sst.cc
index f6bc0e7c63f..1cce8259d5c 100644
--- a/sql/wsrep_sst.cc
+++ b/sql/wsrep_sst.cc
@@ -1526,10 +1526,10 @@ static int sst_flush_tables(THD* thd)
   if (!is_supported_parser_charset(current_charset))
   {
       /* Do not use non-supported parser character sets */
-      WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->csname);
+      WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->cs_name.str);
       thd->variables.character_set_client= &my_charset_latin1;
       WSREP_WARN("For SST temporally setting character set to : %s",
-                 my_charset_latin1.csname);
+                 my_charset_latin1.cs_name.str);
   }
 
   if (run_sql_command(thd, "FLUSH TABLES WITH READ LOCK"))
@@ -1628,10 +1628,10 @@ static void sst_disallow_writes (THD* thd, bool yes)
   if (!is_supported_parser_charset(current_charset))
   {
       /* Do not use non-supported parser character sets */
-      WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->csname);
+      WSREP_WARN("Current client character set is non-supported parser character set: %s", current_charset->cs_name.str);
       thd->variables.character_set_client= &my_charset_latin1;
       WSREP_WARN("For SST temporally setting character set to : %s",
-                 my_charset_latin1.csname);
+                 my_charset_latin1.cs_name.str);
   }
 
   snprintf (query_str, query_max, "SET GLOBAL innodb_disallow_writes=%d",