← Back to team overview

maria-developers team mailing list archive

Please review MDEV-8092 Change Create_field::field from "const char *" to LEX_CSTRING

 

  Hi Serg,

Please review a patch for MDEV-8092.

Thanks.



Perhaps something interesting, about #3 in the task description.

I added a debug output and collected some statistics
for "mtr --suite=main", to check how these changes can
potentially affect another task:
MDEV-7954 my_strcasecmp_utf8() takes 0.19% in OLTP RO


Here are the results:

my_strcasecmp_utf8() is now called 18,709,905 times total during
"mtr --suite=main"


9,200,498 of those are called to compare Field/Create_field names in Column_name::eq_name().


And 3,855,751 calls of my_strcasecmp_utf8() are now optimized away,
because eq_name() immediately return "false" if the two name lengths
are different.

So before this change there were 18,709,905 +  3,855,751 = 22,565,656
calls of my_strcasecmp_utf8().

Looks roughly like 17% improvement in name comparison.
diff --git a/plugin/feedback/feedback.cc b/plugin/feedback/feedback.cc
index dcfa9e0..5e69778 100644
--- a/plugin/feedback/feedback.cc
+++ b/plugin/feedback/feedback.cc
@@ -94,7 +94,7 @@ static COND* make_cond(THD *thd, TABLE_LIST *tables, LEX_STRING *filter)
   Item_cond_or *res= NULL;
   Name_resolution_context nrc;
   const char *db= tables->db, *table= tables->alias,
-             *field= tables->table->field[0]->field_name;
+             *field= tables->table->field[0]->name().ptr();
   CHARSET_INFO *cs= &my_charset_latin1;
 
   if (!filter->str)
diff --git a/plugin/handler_socket/handlersocket/database.cpp b/plugin/handler_socket/handlersocket/database.cpp
index 8ea7b50..88c7877 100644
--- a/plugin/handler_socket/handlersocket/database.cpp
+++ b/plugin/handler_socket/handlersocket/database.cpp
@@ -1088,8 +1088,8 @@ dbcontext::parse_fields(TABLE *const table, const char *str,
     Field **fld = 0;
     size_t j = 0;
     for (fld = table->field; *fld; ++fld, ++j) {
-      DBG_FLD(fprintf(stderr, "f %s\n", (*fld)->field_name));
-      string_ref fn((*fld)->field_name, strlen((*fld)->field_name));
+      DBG_FLD(fprintf(stderr, "f %s\n", (*fld)->name().ptr()));
+      string_ref fn((*fld)->name().ptr(), (*fld)->name().length());
       if (fn == fldnms[i]) {
 	break;
       }
@@ -1099,7 +1099,7 @@ dbcontext::parse_fields(TABLE *const table, const char *str,
 	std::string(fldnms[i].begin(), fldnms[i].size()).c_str()));
       return false;
     }
-    DBG_FLD(fprintf(stderr, "FLD %s %zu\n", (*fld)->field_name, j));
+    DBG_FLD(fprintf(stderr, "FLD %s %zu\n", (*fld)->name().ptr(), j));
     flds.push_back(j);
   }
   return true;
diff --git a/sql/event_db_repository.cc b/sql/event_db_repository.cc
index e39f727..60019cd 100644
--- a/sql/event_db_repository.cc
+++ b/sql/event_db_repository.cc
@@ -379,14 +379,14 @@ mysql_event_fill_row(THD *thd,
 
   if (rs)
   {
-    my_error(ER_EVENT_STORE_FAILED, MYF(0), fields[f_num]->field_name, rs);
+    my_error(ER_EVENT_STORE_FAILED, MYF(0), fields[f_num]->name().ptr(), rs);
     DBUG_RETURN(TRUE);
   }
 
   DBUG_RETURN(FALSE);
 
 err_truncate:
-  my_error(ER_EVENT_DATA_TOO_LONG, MYF(0), fields[f_num]->field_name);
+  my_error(ER_EVENT_DATA_TOO_LONG, MYF(0), fields[f_num]->name().ptr());
   DBUG_RETURN(TRUE);
 }
 
@@ -1223,7 +1223,7 @@ Event_db_repository::check_system_tables(THD *thd)
   else
   {
     if (tables.table->s->fields < event_priv_column_position ||
-        strncmp(tables.table->field[event_priv_column_position]->field_name,
+        strncmp(tables.table->field[event_priv_column_position]->name().ptr(),
                 STRING_WITH_LEN("Event_priv")))
     {
       sql_print_error("mysql.user has no `Event_priv` column at position %d",
diff --git a/sql/field.cc b/sql/field.cc
index 29c9625..9527eb0 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -1327,7 +1327,7 @@ bool Field::can_optimize_range(const Item_bool_func *cond,
 */
 Field_num::Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
                      uchar null_bit_arg, utype unireg_check_arg,
-                     const char *field_name_arg,
+                     const Column_name& field_name_arg,
                      uint8 dec_arg, bool zero_arg, bool unsigned_arg)
   :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
          unireg_check_arg, field_name_arg),
@@ -1641,9 +1641,11 @@ String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
 /// This is used as a table name when the table structure is not set up
 Field::Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
 	     uchar null_bit_arg,
-	     utype unireg_check_arg, const char *field_name_arg)
-  :ptr(ptr_arg), null_ptr(null_ptr_arg), table(0), orig_table(0),
-  table_name(0), field_name(field_name_arg), option_list(0),
+	     utype unireg_check_arg, const Column_name &field_name_arg)
+  :Column_name(field_name_arg),
+  ptr(ptr_arg), null_ptr(null_ptr_arg), table(0), orig_table(0),
+  table_name(0),
+  option_list(0),
   option_struct(0), key_start(0), part_of_key(0),
   part_of_key_not_clustered(0), part_of_sortkey(0),
   unireg_check(unireg_check_arg), field_length(length_arg),
@@ -1896,14 +1898,14 @@ void Field::make_field(Send_field *field)
   if (orig_table && orig_table->alias.ptr())
   {
     field->table_name= orig_table->alias.ptr();
-    field->org_col_name= field_name;
+    field->org_col_name= name().ptr();
   }
   else
   {
     field->table_name= "";
     field->org_col_name= "";
   }
-  field->col_name= field_name;
+  field->col_name= name().ptr();
   field->charsetnr= charset()->number;
   field->length=field_length;
   field->type=type();
@@ -2009,13 +2011,13 @@ bool Field_num::get_date(MYSQL_TIME *ltime,ulonglong fuzzydate)
   longlong nr= val_int();
   bool neg= !(flags & UNSIGNED_FLAG) && nr < 0;
   return int_to_datetime_with_warn(neg, neg ? -nr : nr, ltime, fuzzydate,
-                                   field_name);
+                                   name().ptr());
 }
 
 
 Field_str::Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
                      uchar null_bit_arg, utype unireg_check_arg,
-                     const char *field_name_arg, CHARSET_INFO *charset_arg)
+                     const Column_name& field_name_arg, CHARSET_INFO *charset_arg)
   :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
          unireg_check_arg, field_name_arg)
 {
@@ -2890,7 +2892,7 @@ Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
                                      uint32 len_arg, uchar *null_ptr_arg,
                                      uchar null_bit_arg,
                                      enum utype unireg_check_arg,
-                                     const char *field_name_arg,
+                                     const Column_name& field_name_arg,
                                      uint8 dec_arg,bool zero_arg,
                                      bool unsigned_arg)
   :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
@@ -2906,7 +2908,7 @@ Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
 
 Field_new_decimal::Field_new_decimal(uint32 len_arg,
                                      bool maybe_null_arg,
-                                     const char *name,
+                                     const Column_name &name,
                                      uint8 dec_arg,
                                      bool unsigned_arg)
   :Field_num((uchar*) 0, len_arg,
@@ -3242,7 +3244,7 @@ bool Field_new_decimal::get_date(MYSQL_TIME *ltime, ulonglong fuzzydate)
 {
   my_decimal value;
   return decimal_to_datetime_with_warn(val_decimal(&value),
-                                       ltime, fuzzydate, field_name);
+                                       ltime, fuzzydate, name().ptr());
 }
 
 
@@ -3412,7 +3414,7 @@ Item *Field_new_decimal::get_equal_const_item(THD *thd, const Context &ctx,
         Field_time::get_equal_const_item().
       */
       my_decimal_round(E_DEC_FATAL_ERROR, val, decimals(), true, &val_buffer2);
-      return new (thd->mem_root) Item_decimal(thd, field_name, &val_buffer2,
+      return new (thd->mem_root) Item_decimal(thd, name().ptr(), &val_buffer2,
                                               decimals(), field_length);
     }
     break;
@@ -4720,7 +4722,7 @@ bool Field_real::get_date(MYSQL_TIME *ltime,ulonglong fuzzydate)
 {
   ASSERT_COLUMN_MARKED_FOR_READ;
   double nr= val_real();
-  return double_to_datetime_with_warn(nr, ltime, fuzzydate, field_name);
+  return double_to_datetime_with_warn(nr, ltime, fuzzydate, name().ptr());
 }
 
 
@@ -4875,7 +4877,7 @@ void Field_double::sql_type(String &res) const
 Field_timestamp::Field_timestamp(uchar *ptr_arg, uint32 len_arg,
                                  uchar *null_ptr_arg, uchar null_bit_arg,
 				 enum utype unireg_check_arg,
-				 const char *field_name_arg,
+				 const Column_name& field_name_arg,
 				 TABLE_SHARE *share)
   :Field_temporal(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                   unireg_check_arg, field_name_arg)
@@ -5821,7 +5823,7 @@ bool Field_time::check_zero_in_date_with_warn(ulonglong fuzzydate)
     THD *thd= get_thd();
     push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
-                        ER_THD(thd, ER_WARN_DATA_OUT_OF_RANGE), field_name,
+                        ER_THD(thd, ER_WARN_DATA_OUT_OF_RANGE), name().ptr(),
                         thd->get_stmt_da()->current_row_for_warning());
     return true;
   }
@@ -6199,7 +6201,7 @@ bool Field_year::get_date(MYSQL_TIME *ltime,ulonglong fuzzydate)
   if (tmp || field_length != 4)
     tmp+= 1900;
   return int_to_datetime_with_warn(false, tmp * 10000,
-                                    ltime, fuzzydate, field_name);
+                                    ltime, fuzzydate, name().ptr());
 }
 
 
@@ -7055,7 +7057,7 @@ check_field_for_37426(const void *param_arg)
   Check_field_param *param= (Check_field_param*) param_arg;
   DBUG_ASSERT(param->field->real_type() == MYSQL_TYPE_STRING);
   DBUG_PRINT("debug", ("Field %s - type: %d, size: %d",
-                       param->field->field_name,
+                       param->field->name().ptr(),
                        param->field->real_type(),
                        param->field->row_pack_length()));
   return param->field->row_pack_length() > 255;
@@ -7138,7 +7140,7 @@ uchar *Field_string::pack(uchar *to, const uchar *from, uint max_length)
 {
   uint length=      MY_MIN(field_length,max_length);
   uint local_char_length= max_length/field_charset->mbmaxlen;
-  DBUG_PRINT("debug", ("Packing field '%s' - length: %u ", field_name, length));
+  DBUG_PRINT("debug", ("Packing field '%s' - length: %u ", name().ptr(), length));
 
   if (length > local_char_length)
     local_char_length= my_charpos(field_charset, from, from+length,
@@ -7310,7 +7312,7 @@ Field *Field_string::make_new_field(MEM_ROOT *root, TABLE *new_table,
   if (type() != MYSQL_TYPE_VAR_STRING || keep_type)
     field= Field::make_new_field(root, new_table, keep_type);
   else if ((field= new (root) Field_varstring(field_length, maybe_null(),
-                                              field_name,
+                                              name(),
                                               new_table->s, charset())))
   {
     /*
@@ -7782,7 +7784,7 @@ void Field_varstring::hash(ulong *nr, ulong *nr2)
 ****************************************************************************/
 
 Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-		       enum utype unireg_check_arg, const char *field_name_arg,
+		       enum utype unireg_check_arg, const Column_name& field_name_arg,
                        TABLE_SHARE *share, uint blob_pack_length,
 		       CHARSET_INFO *cs)
   :Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
@@ -8093,7 +8095,7 @@ Field *Field_blob::new_key_field(MEM_ROOT *root, TABLE *new_table,
 {
   Field_varstring *res= new (root) Field_varstring(new_ptr, length, 2,
                                       new_null_ptr, new_null_bit, Field::NONE,
-                                      field_name, table->s, charset());
+                                      name(), table->s, charset());
   res->init(new_table);
   return res;
 }
@@ -8446,7 +8448,7 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
                       MYF(0),
                       Geometry::ci_collection[geom_type]->m_name.str,
                       Geometry::ci_collection[wkb_type]->m_name.str,
-                      field_name,
+                      name().ptr(),
                       (ulong) table->in_use->get_stmt_da()->
                       current_row_for_warning());
       goto err_exit;
@@ -9033,7 +9035,7 @@ bool Field_enum::can_optimize_keypart_ref(const Item_bool_func *cond,
 
 Field_bit::Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                      uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
-                     enum utype unireg_check_arg, const char *field_name_arg)
+                     enum utype unireg_check_arg, const Column_name& field_name_arg)
   : Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
           unireg_check_arg, field_name_arg),
     bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7),
@@ -9548,7 +9550,7 @@ void Field_bit::set_default()
 Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg,
                                      uchar *null_ptr_arg, uchar null_bit_arg,
                                      enum utype unireg_check_arg,
-                                     const char *field_name_arg)
+                                     const Column_name& field_name_arg)
   :Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, 0,
              unireg_check_arg, field_name_arg)
 {
@@ -9662,7 +9664,7 @@ void Column_definition::init_for_tmp_table(enum_field_types sql_type_arg,
 {
   DBUG_ENTER("Create_field::init_for_tmp_table");
 
-  field_name= "";
+  set_name(empty_lex_str);
   sql_type= sql_type_arg;
   char_length= length= length_arg;;
   unireg_check= Field::NONE;
@@ -9787,21 +9789,21 @@ bool Column_definition::check(THD *thd)
     */
     if (vcol_info->expr_item->walk(&Item::check_vcol_func_processor, 0, NULL))
     {
-      my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), field_name);
+      my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), name().ptr());
       DBUG_RETURN(TRUE);
     }
   }
 
   if (length > MAX_FIELD_BLOBLENGTH)
   {
-    my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), field_name, MAX_FIELD_BLOBLENGTH);
+    my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), name().ptr(), MAX_FIELD_BLOBLENGTH);
     DBUG_RETURN(1);
   }
 
   if (decimals >= NOT_FIXED_DEC)
   {
     my_error(ER_TOO_BIG_SCALE, MYF(0), static_cast<ulonglong>(decimals),
-             field_name, static_cast<ulong>(NOT_FIXED_DEC - 1));
+             name().ptr(), static_cast<ulong>(NOT_FIXED_DEC - 1));
     DBUG_RETURN(TRUE);
   }
 
@@ -9819,7 +9821,7 @@ bool Column_definition::check(THD *thd)
          (mysql_type_to_time_type(sql_type) != MYSQL_TIMESTAMP_DATETIME) ||
          def->decimals < length))
     {
-      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
+      my_error(ER_INVALID_DEFAULT, MYF(0), name().ptr());
       DBUG_RETURN(1);
     }
     else if (def->type() == Item::NULL_ITEM)
@@ -9827,13 +9829,13 @@ bool Column_definition::check(THD *thd)
       def= 0;
       if ((flags & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) == NOT_NULL_FLAG)
       {
-	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
+	my_error(ER_INVALID_DEFAULT, MYF(0), name().ptr());
 	DBUG_RETURN(1);
       }
     }
     else if (flags & AUTO_INCREMENT_FLAG)
     {
-      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
+      my_error(ER_INVALID_DEFAULT, MYF(0), name().ptr());
       DBUG_RETURN(1);
     }
   }
@@ -9861,7 +9863,7 @@ bool Column_definition::check(THD *thd)
       (mysql_type_to_time_type(sql_type) != MYSQL_TIMESTAMP_DATETIME ||
        on_update->decimals < length))
   {
-    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
+    my_error(ER_INVALID_ON_UPDATE, MYF(0), name().ptr());
     DBUG_RETURN(1);
   }
 
@@ -9899,13 +9901,13 @@ bool Column_definition::check(THD *thd)
     my_decimal_trim(&length, &decimals);
     if (length > DECIMAL_MAX_PRECISION)
     {
-      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, field_name,
+      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, name().ptr(),
                DECIMAL_MAX_PRECISION);
       DBUG_RETURN(TRUE);
     }
     if (length < decimals)
     {
-      my_error(ER_M_BIGGER_THAN_D, MYF(0), field_name);
+      my_error(ER_M_BIGGER_THAN_D, MYF(0), name().ptr());
       DBUG_RETURN(TRUE);
     }
     length=
@@ -9939,7 +9941,7 @@ bool Column_definition::check(THD *thd)
       if (res->length() || thd->is_strict_mode())
       {
         my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
-                 field_name); /* purecov: inspected */
+                 name().ptr()); /* purecov: inspected */
         DBUG_RETURN(TRUE);
       }
       else
@@ -9950,7 +9952,7 @@ bool Column_definition::check(THD *thd)
         push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                             ER_BLOB_CANT_HAVE_DEFAULT,
                             ER_THD(thd, ER_BLOB_CANT_HAVE_DEFAULT),
-                            field_name);
+                            name().ptr());
       }
       def= 0;
     }
@@ -9972,7 +9974,7 @@ bool Column_definition::check(THD *thd)
     if (length < decimals &&
         decimals != NOT_FIXED_DEC)
     {
-      my_error(ER_M_BIGGER_THAN_D, MYF(0), field_name);
+      my_error(ER_M_BIGGER_THAN_D, MYF(0), name().ptr());
       DBUG_RETURN(TRUE);
     }
     break;
@@ -9986,7 +9988,7 @@ bool Column_definition::check(THD *thd)
     if (length < decimals &&
         decimals != NOT_FIXED_DEC)
     {
-      my_error(ER_M_BIGGER_THAN_D, MYF(0), field_name);
+      my_error(ER_M_BIGGER_THAN_D, MYF(0), name().ptr());
       DBUG_RETURN(TRUE);
     }
     break;
@@ -9994,7 +9996,7 @@ bool Column_definition::check(THD *thd)
   case MYSQL_TYPE_TIMESTAMP2:
     if (length > MAX_DATETIME_PRECISION)
     {
-      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, field_name,
+      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, name().ptr(),
                MAX_DATETIME_PRECISION);
       DBUG_RETURN(TRUE);
     }
@@ -10012,7 +10014,7 @@ bool Column_definition::check(THD *thd)
   case MYSQL_TYPE_TIME2:
     if (length > MAX_DATETIME_PRECISION)
     {
-      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, field_name,
+      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, name().ptr(),
                MAX_DATETIME_PRECISION);
       DBUG_RETURN(TRUE);
     }
@@ -10022,7 +10024,7 @@ bool Column_definition::check(THD *thd)
   case MYSQL_TYPE_DATETIME2:
     if (length > MAX_DATETIME_PRECISION)
     {
-      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, field_name,
+      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, name().ptr(),
                MAX_DATETIME_PRECISION);
       DBUG_RETURN(TRUE);
     }
@@ -10044,7 +10046,7 @@ bool Column_definition::check(THD *thd)
         length= 1;
       if (length > MAX_BIT_FIELD_LENGTH)
       {
-        my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), field_name,
+        my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), name().ptr(),
                  static_cast<ulong>(MAX_BIT_FIELD_LENGTH));
         DBUG_RETURN(TRUE);
       }
@@ -10089,12 +10091,12 @@ bool Column_definition::check(THD *thd)
               sql_type == MYSQL_TYPE_STRING) ?  ER_TOO_BIG_FIELDLENGTH :
                                                 ER_TOO_BIG_DISPLAYWIDTH,
               MYF(0),
-              field_name, max_field_charlength); /* purecov: inspected */
+              name().ptr(), max_field_charlength); /* purecov: inspected */
     DBUG_RETURN(TRUE);
   }
   if ((~allowed_type_modifier) & flags & conditional_type_modifiers)
   {
-    my_error(ER_WRONG_FIELD_SPEC, MYF(0), field_name);
+    my_error(ER_WRONG_FIELD_SPEC, MYF(0), name().ptr());
     DBUG_RETURN(TRUE);
   }
 
@@ -10197,7 +10199,7 @@ Field *make_field(TABLE_SHARE *share,
 		  Field::geometry_type geom_type, uint srid,
 		  Field::utype unireg_check,
 		  TYPELIB *interval,
-		  const char *field_name)
+		  const Column_name &field_name)
 {
   uchar *UNINIT_VAR(bit_ptr);
   uchar UNINIT_VAR(bit_offset);
@@ -10240,8 +10242,7 @@ Field *make_field(TABLE_SHARE *share,
           field_type == MYSQL_TYPE_VAR_STRING)
         return new (mem_root)
           Field_string(ptr,field_length,null_pos,null_bit,
-                       unireg_check, field_name,
-                       field_charset);
+                       unireg_check, field_name, field_charset);
       if (field_type == MYSQL_TYPE_VARCHAR)
         return new (mem_root)
           Field_varstring(ptr,field_length,
@@ -10426,9 +10427,9 @@ Field *make_field(TABLE_SHARE *share,
 /** Create a field suitable for create of table. */
 
 Column_definition::Column_definition(THD *thd, Field *old_field,
-                                               Field *orig_field)
+                                               Field *orig_field):
+  Column_name(old_field)
 {
-  field_name= old_field->field_name;
   length=     old_field->field_length;
   flags=      old_field->flags;
   unireg_check=old_field->unireg_check;
@@ -10647,7 +10648,7 @@ Field::set_warning(Sql_condition::enum_warning_level level, uint code,
   if (thd->count_cuted_fields)
   {
     thd->cuted_fields+= cut_increment;
-    push_warning_printf(thd, level, code, ER_THD(thd, code), field_name,
+    push_warning_printf(thd, level, code, ER_THD(thd, code), name().ptr(),
                         thd->get_stmt_da()->current_row_for_warning());
     return 0;
   }
@@ -10680,7 +10681,7 @@ void Field::set_datetime_warning(Sql_condition::enum_warning_level level,
 {
   THD *thd= get_thd();
   if (thd->really_abort_on_warning() && level >= Sql_condition::WARN_LEVEL_WARN)
-    make_truncated_value_warning(thd, level, str, ts_type, field_name);
+    make_truncated_value_warning(thd, level, str, ts_type, name().ptr());
   else
     set_warning(level, code, cuted_increment);
 }
@@ -10693,7 +10694,7 @@ void Field::set_warning_truncated_wrong_value(const char *type_arg,
   push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                       ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
                       ER_THD(thd, ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
-                      type_arg, value, field_name,
+                      type_arg, value, name().ptr(),
                       static_cast<ulong>(thd->get_stmt_da()->
                       current_row_for_warning()));
 }
@@ -10761,7 +10762,7 @@ bool Field::validate_value_in_record_with_warn(THD *thd, const uchar *record)
     push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                         ER_INVALID_DEFAULT_VALUE_FOR_FIELD,
                         ER_THD(thd, ER_INVALID_DEFAULT_VALUE_FOR_FIELD),
-                        ErrConvString(&tmp).ptr(), field_name);
+                        ErrConvString(&tmp).ptr(), name().ptr());
   }
   dbug_tmp_restore_column_map(table->read_set, old_map);
   return rc;
diff --git a/sql/field.h b/sql/field.h
index 0591914..a40e307 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -537,6 +537,115 @@ inline bool is_temporal_type_with_time(enum_field_types type)
 }
 
 
+/**
+  @class Name
+  An arbitrary SQL name, consisting of a NULL-terminated string
+  and its length.
+  Later it can be reused for table and schema names.
+*/
+class Name
+{
+  const char *m_str;
+  uint m_length;
+  /**
+    Maximum possible hard length limit that can ever come to the constructors.
+    Classes that use Name can have stricter length limits.
+  */
+  uint max_name_length() const { return UINT_MAX32; }
+  /**
+    Check that the members are syncronized:
+    - either it's a NULL string (str==NULL and length==0)
+    - or a null-terminated string:  str[legnth]=='\0'
+  */
+  bool in_sync() const
+  {
+    return (!m_str && !m_length) ||
+           (m_str[m_length] == '\0');
+  }
+public:
+  Name(const char *str, uint length):
+    m_str(str), m_length(length)
+  {
+    DBUG_ASSERT(length <= max_name_length());
+    DBUG_ASSERT(in_sync());
+  }
+  Name(const LEX_STRING &str):
+    m_str(str.str), m_length(str.length)
+  {
+    DBUG_ASSERT(str.length <= max_name_length());
+    DBUG_ASSERT(in_sync());
+  }
+  void set_name(const Name &other)
+  {
+    *this= other;
+    DBUG_ASSERT(in_sync());
+  }
+  const char *ptr() const { return m_str; }
+  uint length() const { return m_length; }
+  const Name &name() const { return *this; }
+};
+
+
+/**
+  @class Column_name
+  A parent class for a number of classes that refer to a column by its name.
+  Character set of the strings are system_charset_info (utf8).
+  Column names are compared case insensitively.
+
+  Currently used in:
+  - Field
+  - Column_definition
+  - Key_part_spec
+  Having Column_name as a common parent class for the above classes makes it
+  easy to copy and compare their names
+  (e.g. between Field and Column_definition), as well as construct each other.
+*/
+class Column_name: public Name
+{
+public:
+  Column_name(const Column_name &other):
+    Name(other)
+  { }
+  Column_name(const Column_name *other):
+    Name(*other)
+  { }
+  Column_name(const Name &other):
+    Name(other)
+  { }
+  Column_name(const LEX_STRING &other):
+    Name(other.str, other.length)
+  { }  
+  Column_name(const LEX_CSTRING &other):
+    Name(other.str, other.length)
+  { }
+  Column_name(const char *str, uint length):
+    Name(str, length)
+  { }
+  /**
+    - This constructor is used to create Fields from Items.
+      We should eventually to reuse Column_name in Item
+      and remove this constructor.
+    - Spider also uses this constructor in a few places in spd_sys_table.cc,
+      to create Field_blob.
+  */
+  Column_name(const char *str):
+    Name(str, str ? strlen(str) : 0)
+  { }
+  bool eq_name(const char *other) const
+  {
+    return !my_strcasecmp(system_charset_info, other, ptr());
+  }
+  bool eq_name(const Column_name *other) const
+  {
+    return length() == other->length() && eq_name(other->ptr());
+  }
+  bool eq_name(const Column_name &other) const
+  {
+    return length() == other.length() && eq_name(other.ptr());
+  }
+};
+
+
 /*
   Virtual_column_info is the class to contain additional
   characteristics that is specific for a virtual/computed
@@ -602,7 +711,7 @@ class Virtual_column_info: public Sql_alloc
   }
 };
 
-class Field: public Value_source
+class Field: public Value_source, public Column_name
 {
   Field(const Item &);				/* Prevent use of these */
   void operator=(Field &);
@@ -628,7 +737,6 @@ class Field: public Value_source
   TABLE *table;                                 // Pointer for table
   TABLE *orig_table;                            // Pointer to original table
   const char * const *table_name;
-  const char *field_name;
   /** reference to the list of options or NULL */
   engine_option_value *option_list;
   ha_field_option_struct *option_struct;   /* structure with parsed options */
@@ -716,7 +824,7 @@ class Field: public Value_source
 
   Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
         uchar null_bit_arg, utype unireg_check_arg,
-        const char *field_name_arg);
+        const Column_name &field_name_arg);
   virtual ~Field() {}
   /* Store functions returns 1 on overflow and -1 on fatal error */
   virtual int  store(const char *to, uint length,CHARSET_INFO *cs)=0;
@@ -1473,7 +1581,7 @@ class Field_num :public Field {
   bool zerofill,unsigned_flag;	// Purify cannot handle bit fields
   Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 	    uchar null_bit_arg, utype unireg_check_arg,
-	    const char *field_name_arg,
+	    const Column_name& field_name_arg,
             uint8 dec_arg, bool zero_arg, bool unsigned_arg);
   enum Item_result result_type () const { return INT_RESULT; }
   enum Derivation derivation(void) const { return DERIVATION_NUMERIC; }
@@ -1520,7 +1628,7 @@ class Field_str :public Field {
                                         const Item_equal *item_equal);
   Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 	    uchar null_bit_arg, utype unireg_check_arg,
-	    const char *field_name_arg, CHARSET_INFO *charset);
+	    const Column_name& field_name_arg, CHARSET_INFO *charset);
   Item_result result_type () const { return STRING_RESULT; }
   uint decimals() const { return NOT_FIXED_DEC; }
   int  store(double nr);
@@ -1577,7 +1685,7 @@ class Field_longstr :public Field_str
 public:
   Field_longstr(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                 uchar null_bit_arg, utype unireg_check_arg,
-                const char *field_name_arg, CHARSET_INFO *charset_arg)
+                const Column_name& field_name_arg, CHARSET_INFO *charset_arg)
     :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
                field_name_arg, charset_arg)
     {}
@@ -1612,7 +1720,7 @@ class Field_real :public Field_num {
 
   Field_real(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
              uchar null_bit_arg, utype unireg_check_arg,
-             const char *field_name_arg,
+             const Column_name& field_name_arg,
              uint8 dec_arg, bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
                field_name_arg, dec_arg, zero_arg, unsigned_arg),
@@ -1634,7 +1742,7 @@ class Field_decimal :public Field_real {
 public:
   Field_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 		uchar null_bit_arg,
-		enum utype unireg_check_arg, const char *field_name_arg,
+		enum utype unireg_check_arg, const Column_name& field_name_arg,
 		uint8 dec_arg,bool zero_arg,bool unsigned_arg)
     :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                 unireg_check_arg, field_name_arg,
@@ -1678,10 +1786,10 @@ class Field_new_decimal :public Field_num {
   */
   Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                     uchar null_bit_arg,
-                    enum utype unireg_check_arg, const char *field_name_arg,
+                    enum utype unireg_check_arg, const Column_name& field_name_arg,
                     uint8 dec_arg, bool zero_arg, bool unsigned_arg);
   Field_new_decimal(uint32 len_arg, bool maybe_null_arg,
-                    const char *field_name_arg, uint8 dec_arg,
+                    const Column_name& field_name_arg, uint8 dec_arg,
                     bool unsigned_arg);
   enum_field_types type() const { return MYSQL_TYPE_NEWDECIMAL;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
@@ -1727,7 +1835,7 @@ class Field_tiny :public Field_num {
 public:
   Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	     uchar null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
+	     enum utype unireg_check_arg, const Column_name &field_name_arg,
 	     bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 	       unireg_check_arg, field_name_arg,
@@ -1771,13 +1879,13 @@ class Field_short :public Field_num {
 public:
   Field_short(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	      uchar null_bit_arg,
-	      enum utype unireg_check_arg, const char *field_name_arg,
+	      enum utype unireg_check_arg, const Column_name& field_name_arg,
 	      bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 	       unireg_check_arg, field_name_arg,
 	       0, zero_arg,unsigned_arg)
     {}
-  Field_short(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
+  Field_short(uint32 len_arg,bool maybe_null_arg, const Column_name& field_name_arg,
 	      bool unsigned_arg)
     :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 	       NONE, field_name_arg, 0, 0, unsigned_arg)
@@ -1811,7 +1919,7 @@ class Field_medium :public Field_num {
 public:
   Field_medium(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	      uchar null_bit_arg,
-	      enum utype unireg_check_arg, const char *field_name_arg,
+	      enum utype unireg_check_arg, const Column_name& field_name_arg,
 	      bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 	       unireg_check_arg, field_name_arg,
@@ -1845,13 +1953,13 @@ class Field_long :public Field_num {
 public:
   Field_long(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	     uchar null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
+	     enum utype unireg_check_arg, const Column_name& field_name_arg,
 	     bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 	       unireg_check_arg, field_name_arg,
 	       0, zero_arg,unsigned_arg)
     {}
-  Field_long(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
+  Field_long(uint32 len_arg,bool maybe_null_arg, const Column_name& field_name_arg,
 	     bool unsigned_arg)
     :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 	       NONE, field_name_arg,0,0,unsigned_arg)
@@ -1890,14 +1998,14 @@ class Field_longlong :public Field_num {
 public:
   Field_longlong(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	      uchar null_bit_arg,
-	      enum utype unireg_check_arg, const char *field_name_arg,
+	      enum utype unireg_check_arg, const Column_name& field_name_arg,
 	      bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 	       unireg_check_arg, field_name_arg,
 	       0, zero_arg,unsigned_arg)
     {}
   Field_longlong(uint32 len_arg,bool maybe_null_arg,
-		 const char *field_name_arg,
+		 const Column_name& field_name_arg,
 		  bool unsigned_arg)
     :Field_num((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 	       NONE, field_name_arg,0,0,unsigned_arg)
@@ -1939,13 +2047,13 @@ class Field_float :public Field_real {
 public:
   Field_float(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	      uchar null_bit_arg,
-	      enum utype unireg_check_arg, const char *field_name_arg,
+	      enum utype unireg_check_arg, const Column_name& field_name_arg,
               uint8 dec_arg,bool zero_arg,bool unsigned_arg)
     :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                 unireg_check_arg, field_name_arg,
                 dec_arg, zero_arg, unsigned_arg)
     {}
-  Field_float(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
+  Field_float(uint32 len_arg, bool maybe_null_arg, const Column_name& field_name_arg,
 	      uint8 dec_arg)
     :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
                 NONE, field_name_arg, dec_arg, 0, 0)
@@ -1974,18 +2082,18 @@ class Field_double :public Field_real {
 public:
   Field_double(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	       uchar null_bit_arg,
-	       enum utype unireg_check_arg, const char *field_name_arg,
+	       enum utype unireg_check_arg, const Column_name& field_name_arg,
 	       uint8 dec_arg,bool zero_arg,bool unsigned_arg)
     :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                 unireg_check_arg, field_name_arg,
                 dec_arg, zero_arg, unsigned_arg)
     {}
-  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
+  Field_double(uint32 len_arg, bool maybe_null_arg, const Column_name& field_name_arg,
 	       uint8 dec_arg)
     :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
                 NONE, field_name_arg, dec_arg, 0, 0)
     {}
-  Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
+  Field_double(uint32 len_arg, bool maybe_null_arg, const Column_name& field_name_arg,
 	       uint8 dec_arg, bool not_fixed_arg)
     :Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
                 NONE, field_name_arg, dec_arg, 0, 0)
@@ -2016,7 +2124,7 @@ class Field_null :public Field_str {
   static uchar null[1];
 public:
   Field_null(uchar *ptr_arg, uint32 len_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
+	     enum utype unireg_check_arg, const Column_name& field_name_arg,
 	     CHARSET_INFO *cs)
     :Field_str(ptr_arg, len_arg, null, 1,
 	       unireg_check_arg, field_name_arg, cs)
@@ -2063,7 +2171,7 @@ class Field_temporal: public Field {
 public:
   Field_temporal(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
                  uchar null_bit_arg, utype unireg_check_arg,
-                 const char *field_name_arg)
+                 const Column_name &field_name_arg)
     :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
                field_name_arg)
     { flags|= BINARY_FLAG; }
@@ -2129,7 +2237,7 @@ class Field_temporal_with_date: public Field_temporal {
   Field_temporal_with_date(uchar *ptr_arg, uint32 len_arg,
                            uchar *null_ptr_arg, uchar null_bit_arg,
                            utype unireg_check_arg,
-                           const char *field_name_arg)
+                           const Column_name& field_name_arg)
     :Field_temporal(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                     unireg_check_arg, field_name_arg)
     {}
@@ -2149,7 +2257,7 @@ class Field_timestamp :public Field_temporal {
 public:
   Field_timestamp(uchar *ptr_arg, uint32 len_arg,
                   uchar *null_ptr_arg, uchar null_bit_arg,
-		  enum utype unireg_check_arg, const char *field_name_arg,
+		  enum utype unireg_check_arg, const Column_name& field_name_arg,
 		  TABLE_SHARE *share);
   enum_field_types type() const { return MYSQL_TYPE_TIMESTAMP;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
@@ -2232,7 +2340,7 @@ class Field_timestamp_with_dec :public Field_timestamp {
   Field_timestamp_with_dec(uchar *ptr_arg,
                            uchar *null_ptr_arg, uchar null_bit_arg,
                            enum utype unireg_check_arg,
-                           const char *field_name_arg,
+                           const Column_name& field_name_arg,
                            TABLE_SHARE *share, uint dec_arg) :
   Field_timestamp(ptr_arg,
                   MAX_DATETIME_WIDTH + dec_arg + MY_TEST(dec_arg), null_ptr_arg,
@@ -2266,7 +2374,7 @@ class Field_timestamp_hires :public Field_timestamp_with_dec {
   Field_timestamp_hires(uchar *ptr_arg,
                         uchar *null_ptr_arg, uchar null_bit_arg,
                         enum utype unireg_check_arg,
-                        const char *field_name_arg,
+                        const Column_name& field_name_arg,
                         TABLE_SHARE *share, uint dec_arg) :
   Field_timestamp_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
                            unireg_check_arg, field_name_arg, share, dec_arg)
@@ -2294,7 +2402,7 @@ class Field_timestampf :public Field_timestamp_with_dec {
   Field_timestampf(uchar *ptr_arg,
                    uchar *null_ptr_arg, uchar null_bit_arg,
                    enum utype unireg_check_arg,
-                   const char *field_name_arg,
+                   const Column_name& field_name_arg,
                    TABLE_SHARE *share, uint dec_arg) :
     Field_timestamp_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
                              unireg_check_arg, field_name_arg, share, dec_arg)
@@ -2326,7 +2434,7 @@ class Field_year :public Field_tiny {
 public:
   Field_year(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	     uchar null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg)
+	     enum utype unireg_check_arg, const Column_name& field_name_arg)
     :Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 		unireg_check_arg, field_name_arg, 1, 1)
     {}
@@ -2350,7 +2458,7 @@ class Field_date :public Field_temporal_with_date {
   bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, ulonglong fuzzydate) const;
 public:
   Field_date(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg)
+	     enum utype unireg_check_arg, const Column_name& field_name_arg)
     :Field_temporal_with_date(ptr_arg, MAX_DATE_WIDTH, null_ptr_arg, null_bit_arg,
                               unireg_check_arg, field_name_arg) {}
   enum_field_types type() const { return MYSQL_TYPE_DATE;}
@@ -2385,7 +2493,7 @@ class Field_newdate :public Field_temporal_with_date {
   bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, ulonglong fuzzydate) const;
 public:
   Field_newdate(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-		enum utype unireg_check_arg, const char *field_name_arg)
+		enum utype unireg_check_arg, const Column_name& field_name_arg)
     :Field_temporal_with_date(ptr_arg, MAX_DATE_WIDTH, null_ptr_arg, null_bit_arg,
                               unireg_check_arg, field_name_arg)
     {}
@@ -2423,7 +2531,7 @@ class Field_time :public Field_temporal {
 public:
   Field_time(uchar *ptr_arg, uint length_arg, uchar *null_ptr_arg,
              uchar null_bit_arg, enum utype unireg_check_arg,
-             const char *field_name_arg)
+             const Column_name& field_name_arg)
     :Field_temporal(ptr_arg, length_arg, null_ptr_arg, null_bit_arg,
                     unireg_check_arg, field_name_arg), curdays(0)
     {}
@@ -2462,7 +2570,7 @@ class Field_time_with_dec :public Field_time {
   uint dec;
 public:
   Field_time_with_dec(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-                      enum utype unireg_check_arg, const char *field_name_arg,
+                      enum utype unireg_check_arg, const Column_name& field_name_arg,
                       uint dec_arg)
     :Field_time(ptr_arg, MIN_TIME_WIDTH + dec_arg + MY_TEST(dec_arg),
                 null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg),
@@ -2486,7 +2594,7 @@ class Field_time_hires :public Field_time_with_dec {
   void store_TIME(MYSQL_TIME *ltime);
 public:
   Field_time_hires(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-             enum utype unireg_check_arg, const char *field_name_arg,
+             enum utype unireg_check_arg, const Column_name& field_name_arg,
              uint dec_arg)
     :Field_time_with_dec(ptr_arg, null_ptr_arg,
                          null_bit_arg, unireg_check_arg, field_name_arg,
@@ -2517,7 +2625,7 @@ class Field_timef :public Field_time_with_dec {
   }
 public:
   Field_timef(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-             enum utype unireg_check_arg, const char *field_name_arg,
+             enum utype unireg_check_arg, const Column_name& field_name_arg,
              uint dec_arg)
     :Field_time_with_dec(ptr_arg, null_ptr_arg,
                          null_bit_arg, unireg_check_arg, field_name_arg,
@@ -2559,7 +2667,7 @@ class Field_datetime :public Field_temporal_with_date {
 public:
   Field_datetime(uchar *ptr_arg, uint length_arg, uchar *null_ptr_arg,
                  uchar null_bit_arg, enum utype unireg_check_arg,
-                 const char *field_name_arg)
+                 const Column_name& field_name_arg)
     :Field_temporal_with_date(ptr_arg, length_arg, null_ptr_arg, null_bit_arg,
                               unireg_check_arg, field_name_arg)
     {}
@@ -2626,7 +2734,7 @@ class Field_datetime_with_dec :public Field_datetime {
 public:
   Field_datetime_with_dec(uchar *ptr_arg, uchar *null_ptr_arg,
                           uchar null_bit_arg, enum utype unireg_check_arg,
-                          const char *field_name_arg, uint dec_arg)
+                          const Column_name& field_name_arg, uint dec_arg)
     :Field_datetime(ptr_arg, MAX_DATETIME_WIDTH + dec_arg + MY_TEST(dec_arg),
                     null_ptr_arg, null_bit_arg, unireg_check_arg,
                     field_name_arg), dec(dec_arg)
@@ -2662,7 +2770,7 @@ class Field_datetime_hires :public Field_datetime_with_dec {
 public:
   Field_datetime_hires(uchar *ptr_arg, uchar *null_ptr_arg,
                        uchar null_bit_arg, enum utype unireg_check_arg,
-                       const char *field_name_arg, uint dec_arg)
+                       const Column_name& field_name_arg, uint dec_arg)
     :Field_datetime_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
                              unireg_check_arg, field_name_arg, dec_arg)
   {
@@ -2690,7 +2798,7 @@ class Field_datetimef :public Field_datetime_with_dec {
 public:
   Field_datetimef(uchar *ptr_arg, uchar *null_ptr_arg,
                   uchar null_bit_arg, enum utype unireg_check_arg,
-                  const char *field_name_arg, uint dec_arg)
+                  const Column_name& field_name_arg, uint dec_arg)
     :Field_datetime_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
                              unireg_check_arg, field_name_arg, dec_arg)
   {}
@@ -2720,7 +2828,8 @@ class Field_datetimef :public Field_datetime_with_dec {
 
 static inline Field_timestamp *
 new_Field_timestamp(MEM_ROOT *root,uchar *ptr, uchar *null_ptr, uchar null_bit,
-                    enum Field::utype unireg_check, const char *field_name,
+                    enum Field::utype unireg_check,
+                    const Column_name& field_name,
                     TABLE_SHARE *share, uint dec)
 {
   if (dec==0)
@@ -2736,7 +2845,7 @@ new_Field_timestamp(MEM_ROOT *root,uchar *ptr, uchar *null_ptr, uchar null_bit,
 
 static inline Field_time *
 new_Field_time(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
-               enum Field::utype unireg_check, const char *field_name,
+               enum Field::utype unireg_check, const Column_name &field_name,
                uint dec)
 {
   if (dec == 0)
@@ -2752,7 +2861,7 @@ new_Field_time(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
 static inline Field_datetime *
 new_Field_datetime(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
                    enum Field::utype unireg_check,
-                   const char *field_name, uint dec)
+                   const Column_name &field_name, uint dec)
 {
   if (dec == 0)
     return new (root)
@@ -2775,12 +2884,12 @@ class Field_string :public Field_longstr {
   bool can_alter_field_type;
   Field_string(uchar *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
 	       uchar null_bit_arg,
-	       enum utype unireg_check_arg, const char *field_name_arg,
+	       enum utype unireg_check_arg, const Column_name& field_name_arg,
 	       CHARSET_INFO *cs)
     :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                    unireg_check_arg, field_name_arg, cs),
      can_alter_field_type(1) {};
-  Field_string(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
+  Field_string(uint32 len_arg,bool maybe_null_arg, const Column_name& field_name_arg,
                CHARSET_INFO *cs)
     :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                    NONE, field_name_arg, cs),
@@ -2863,7 +2972,7 @@ class Field_varstring :public Field_longstr {
   Field_varstring(uchar *ptr_arg,
                   uint32 len_arg, uint length_bytes_arg,
                   uchar *null_ptr_arg, uchar null_bit_arg,
-		  enum utype unireg_check_arg, const char *field_name_arg,
+		  enum utype unireg_check_arg, const Column_name& field_name_arg,
 		  TABLE_SHARE *share, CHARSET_INFO *cs)
     :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                    unireg_check_arg, field_name_arg, cs),
@@ -2872,7 +2981,7 @@ class Field_varstring :public Field_longstr {
     share->varchar_fields++;
   }
   Field_varstring(uint32 len_arg,bool maybe_null_arg,
-                  const char *field_name_arg,
+                  const Column_name& field_name_arg,
                   TABLE_SHARE *share, CHARSET_INFO *cs)
     :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                    NONE, field_name_arg, cs),
@@ -2948,9 +3057,9 @@ class Field_blob :public Field_longstr {
   
 public:
   Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
+	     enum utype unireg_check_arg, const Column_name& field_name_arg,
 	     TABLE_SHARE *share, uint blob_pack_length, CHARSET_INFO *cs);
-  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
+  Field_blob(uint32 len_arg,bool maybe_null_arg, const Column_name& field_name_arg,
              CHARSET_INFO *cs)
     :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                    NONE, field_name_arg, cs),
@@ -2958,7 +3067,7 @@ class Field_blob :public Field_longstr {
   {
     flags|= BLOB_FLAG;
   }
-  Field_blob(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
+  Field_blob(uint32 len_arg,bool maybe_null_arg, const Column_name& field_name_arg,
 	     CHARSET_INFO *cs, bool set_packlength)
     :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
                    NONE, field_name_arg, cs)
@@ -2974,7 +3083,9 @@ class Field_blob :public Field_longstr {
     }
   }
   Field_blob(uint32 packlength_arg)
-    :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE, "temp", system_charset_info),
+    :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE,
+                   Column_name(C_STRING_WITH_LEN("temp")),
+                   system_charset_info),
     packlength(packlength_arg) {}
   /* Note that the default copy constructor is used, in clone() */
   enum_field_types type() const { return MYSQL_TYPE_BLOB;}
@@ -3104,13 +3215,13 @@ class Field_geom :public Field_blob {
   enum storage_type storage;
 
   Field_geom(uchar *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
+	     enum utype unireg_check_arg, const Column_name& field_name_arg,
 	     TABLE_SHARE *share, uint blob_pack_length,
 	     enum geometry_type geom_type_arg, uint field_srid)
      :Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, unireg_check_arg, 
                  field_name_arg, share, blob_pack_length, &my_charset_bin)
   { geom_type= geom_type_arg; srid= field_srid; }
-  Field_geom(uint32 len_arg,bool maybe_null_arg, const char *field_name_arg,
+  Field_geom(uint32 len_arg,bool maybe_null_arg, const Column_name& field_name_arg,
 	     TABLE_SHARE *share, enum geometry_type geom_type_arg)
     :Field_blob(len_arg, maybe_null_arg, field_name_arg, &my_charset_bin)
   { geom_type= geom_type_arg; srid= 0; }
@@ -3160,7 +3271,7 @@ class Field_enum :public Field_str {
   TYPELIB *typelib;
   Field_enum(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
              uchar null_bit_arg,
-             enum utype unireg_check_arg, const char *field_name_arg,
+             enum utype unireg_check_arg, const Column_name& field_name_arg,
              uint packlength_arg,
              TYPELIB *typelib_arg,
              CHARSET_INFO *charset_arg)
@@ -3226,7 +3337,7 @@ class Field_set :public Field_enum {
 public:
   Field_set(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	    uchar null_bit_arg,
-	    enum utype unireg_check_arg, const char *field_name_arg,
+	    enum utype unireg_check_arg, const Column_name& field_name_arg,
 	    uint32 packlength_arg,
 	    TYPELIB *typelib_arg, CHARSET_INFO *charset_arg)
     :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
@@ -3274,7 +3385,7 @@ class Field_bit :public Field {
   uint bytes_in_rec;
   Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
             uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
-            enum utype unireg_check_arg, const char *field_name_arg);
+            enum utype unireg_check_arg, const Column_name& field_name_arg);
   enum_field_types type() const { return MYSQL_TYPE_BIT; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BIT; }
   uint32 key_length() const { return (uint32) (field_length + 7) / 8; }
@@ -3404,7 +3515,7 @@ class Field_bit_as_char: public Field_bit {
 public:
   Field_bit_as_char(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                     uchar null_bit_arg,
-                    enum utype unireg_check_arg, const char *field_name_arg);
+                    enum utype unireg_check_arg, const Column_name& field_name_arg);
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
   uint size_of() const { return sizeof(*this); }
   int store(const char *to, uint length, CHARSET_INFO *charset);
@@ -3417,13 +3528,13 @@ class Field_bit_as_char: public Field_bit {
 
 extern const LEX_STRING null_lex_str;
 
+
 /*
   Create field class for CREATE TABLE
 */
-class Column_definition: public Sql_alloc
+class Column_definition: public Sql_alloc, public Column_name
 {
 public:
-  const char *field_name;
   LEX_STRING comment;			// Comment for field
   Item *def, *on_update;                // Default value
   enum	enum_field_types sql_type;
@@ -3458,6 +3569,7 @@ class Column_definition: public Sql_alloc
   Virtual_column_info *vcol_info;
 
   Column_definition():
+    Column_name(null_lex_str),
     comment(null_lex_str),
     def(0), on_update(0), sql_type(MYSQL_TYPE_NULL),
     flags(0), pack_length(0), key_length(0), interval(0),
@@ -3526,7 +3638,7 @@ class Create_field :public Column_definition
   { }
   Create_field(THD *thd, Field *old_field, Field *orig_field):
     Column_definition(thd, old_field, orig_field),
-    change(old_field->field_name), after(0),
+    change(old_field->name().ptr()), after(0),
     field(old_field), create_if_not_exists(false)
   { }
   /* Used to make a clone of this object for ALTER/CREATE TABLE */
@@ -3603,7 +3715,7 @@ Field *make_field(TABLE_SHARE *share, MEM_ROOT *mem_root,
 		  CHARSET_INFO *cs,
 		  Field::geometry_type geom_type, uint srid,
 		  Field::utype unireg_check,
-		  TYPELIB *interval, const char *field_name);
+		  TYPELIB *interval, const Column_name &field_name);
 uint pack_length_to_packflag(uint type);
 enum_field_types get_blob_type_from_length(ulong length);
 uint32 calc_pack_length(enum_field_types type,uint32 length);
diff --git a/sql/field_conv.cc b/sql/field_conv.cc
index 0ad8cee..287e8f6 100644
--- a/sql/field_conv.cc
+++ b/sql/field_conv.cc
@@ -139,7 +139,7 @@ set_field_to_null(Field *field)
     return 0;
   case CHECK_FIELD_ERROR_FOR_NULL:
     if (!field->table->in_use->no_errors)
-      my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name);
+      my_error(ER_BAD_NULL_ERROR, MYF(0), field->name().ptr());
     return -1;
   }
   DBUG_ASSERT(0); // impossible
@@ -208,7 +208,7 @@ set_field_to_null_with_conversions(Field *field, bool no_conversions)
     return 0;
   case CHECK_FIELD_ERROR_FOR_NULL:
     if (!field->table->in_use->no_errors)
-      my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name);
+      my_error(ER_BAD_NULL_ERROR, MYF(0), field->name().ptr());
     return -1;
   }
   DBUG_ASSERT(0); // impossible
diff --git a/sql/filesort.cc b/sql/filesort.cc
index 917b9de..762b6f5 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -538,7 +538,7 @@ const char* dbug_print_table_row(TABLE *table)
     else
       output.append(",");
 
-    output.append((*pfield)->field_name? (*pfield)->field_name: "NULL");
+    output.append((*pfield)->name().ptr()? (*pfield)->name().ptr(): "NULL");
   }
 
   output.append(")=(");
@@ -589,7 +589,7 @@ static void dbug_print_record(TABLE *table, bool print_rowid)
   
   fprintf(DBUG_FILE, "record (");
   for (pfield= table->field; *pfield ; pfield++)
-    fprintf(DBUG_FILE, "%s%s", (*pfield)->field_name, (pfield[1])? ", ":"");
+    fprintf(DBUG_FILE, "%s%s", (*pfield)->name().ptr(), (pfield[1])? ", ":"");
   fprintf(DBUG_FILE, ") = ");
 
   fprintf(DBUG_FILE, "(");
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index 5d789fa..ff559d4 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -7944,7 +7944,7 @@ void ha_partition::append_row_to_str(String &str)
     {
       Field *field= key_part->field;
       str.append(" ");
-      str.append(field->field_name);
+      str.append(field->name().ptr());
       str.append(":");
       field_unpack(&str, field, rec, 0, false);
     }
@@ -7964,7 +7964,7 @@ void ha_partition::append_row_to_str(String &str)
     {
       Field *field= *field_ptr;
       str.append(" ");
-      str.append(field->field_name);
+      str.append(field->name().ptr());
       str.append(":");
       field_unpack(&str, field, rec, 0, false);
     }
diff --git a/sql/handler.cc b/sql/handler.cc
index 193d36a..5d27a84 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -3545,7 +3545,7 @@ void handler::print_error(int error, myf errflag)
     break;
   case HA_ERR_AUTOINC_ERANGE:
     textno= error;
-    my_error(textno, errflag, table->next_number_field->field_name,
+    my_error(textno, errflag, table->next_number_field->name().ptr(),
              table->in_use->get_stmt_da()->current_row_for_warning());
     DBUG_VOID_RETURN;
     break;
diff --git a/sql/item.cc b/sql/item.cc
index 18879a8..fb4019d 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -855,7 +855,7 @@ bool Item_ident::collect_outer_ref_processor(uchar *param)
 bool Item_field::collect_item_field_processor(uchar *arg)
 {
   DBUG_ENTER("Item_field::collect_item_field_processor");
-  DBUG_PRINT("info", ("%s", field->field_name ? field->field_name : "noname"));
+  DBUG_PRINT("info", ("%s", field->name().ptr() ? field->name().ptr() : "noname"));
   List<Item_field> *item_list= (List<Item_field>*) arg;
   List_iterator<Item_field> item_list_it(*item_list);
   Item_field *curr_item;
@@ -872,7 +872,7 @@ bool Item_field::collect_item_field_processor(uchar *arg)
 bool Item_field::add_field_to_set_processor(uchar *arg)
 {
   DBUG_ENTER("Item_field::add_field_to_set_processor");
-  DBUG_PRINT("info", ("%s", field->field_name ? field->field_name : "noname"));
+  DBUG_PRINT("info", ("%s", field->name().ptr() ? field->name().ptr() : "noname"));
   TABLE *table= (TABLE *) arg;
   if (field->table == table)
     bitmap_set_bit(&table->tmp_set, field->field_index);
@@ -2173,7 +2173,7 @@ void Item_ident_for_show::make_field(THD *thd, Send_field *tmp_field)
 {
   tmp_field->table_name= tmp_field->org_table_name= table_name;
   tmp_field->db_name= db_name;
-  tmp_field->col_name= tmp_field->org_col_name= field->field_name;
+  tmp_field->col_name= tmp_field->org_col_name= field->name().ptr();
   tmp_field->charsetnr= field->charset()->number;
   tmp_field->length=field->field_length;
   tmp_field->type=field->type();
@@ -2185,7 +2185,7 @@ void Item_ident_for_show::make_field(THD *thd, Send_field *tmp_field)
 /**********************************************/
 
 Item_field::Item_field(THD *thd, Field *f)
-  :Item_ident(thd, 0, NullS, *f->table_name, f->field_name),
+  :Item_ident(thd, 0, NullS, *f->table_name, f->name().ptr()),
    item_equal(0),
    have_privileges(0), any_privileges(0)
 {
@@ -2208,7 +2208,7 @@ Item_field::Item_field(THD *thd, Field *f)
 
 Item_field::Item_field(THD *thd, Name_resolution_context *context_arg,
                        Field *f)
-  :Item_ident(thd, context_arg, f->table->s->db.str, *f->table_name, f->field_name),
+  :Item_ident(thd, context_arg, f->table->s->db.str, *f->table_name, f->name().ptr()),
    item_equal(0),
    have_privileges(0), any_privileges(0)
 {
@@ -2338,7 +2338,7 @@ void Item_field::set_field(Field *field_par)
   maybe_null=field->maybe_null();
   decimals= field->decimals();
   table_name= *field_par->table_name;
-  field_name= field_par->field_name;
+  field_name= field_par->name().ptr();
   db_name= field_par->table->s->db.str;
   alias_name_used= field_par->table->alias_name_used;
   unsigned_flag= MY_TEST(field_par->flags & UNSIGNED_FLAG);
@@ -2363,8 +2363,8 @@ void Item_field::set_field(Field *field_par)
 void Item_field::reset_field(Field *f)
 {
   set_field(f);
-  /* 'name' is pointing at field->field_name of old field */
-  name= (char*) f->field_name;
+  /* 'name' is pointing at field->name().ptr() of old field */
+  name= (char*) f->name().ptr();
 }
 
 
@@ -8124,7 +8124,7 @@ bool Item_default_value::fix_fields(THD *thd, Item **items)
   field_arg= (Item_field *)real_arg;
   if (field_arg->field->flags & NO_DEFAULT_VALUE_FLAG)
   {
-    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), field_arg->field->field_name);
+    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), field_arg->field->name().ptr());
     goto error;
   }
   if (!(def_field= (Field*) thd->alloc(field_arg->field->size_of())))
@@ -8188,7 +8188,7 @@ int Item_default_value::save_in_field(Field *field_arg, bool no_conversions)
                             Sql_condition::WARN_LEVEL_WARN,
                             ER_NO_DEFAULT_FOR_FIELD,
                             ER_THD(thd, ER_NO_DEFAULT_FOR_FIELD),
-                            field_arg->field_name);
+                            field_arg->name().ptr());
       }
       return 1;
     }
@@ -8284,8 +8284,8 @@ bool Item_insert_value::fix_fields(THD *thd, Item **items)
   {
     Field *tmp_field= field_arg->field;
     /* charset doesn't matter here, it's to avoid sigsegv only */
-    tmp_field= new Field_null(0, 0, Field::NONE, field_arg->field->field_name,
-                          &my_charset_bin);
+    tmp_field= new Field_null(0, 0, Field::NONE, field_arg->field->name(),
+                              &my_charset_bin);
     if (tmp_field)
     {
       tmp_field->init(field_arg->field->table);
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index f232d77..381ee0b 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -5854,10 +5854,10 @@ void Ordered_key::print(String *str)
   str->append(", (");
   for (i= 0; i < key_column_count - 1; i++)
   {
-    str->append(key_columns[i]->field->field_name);
+    str->append(key_columns[i]->field->name().ptr());
     str->append(", ");
   }
-  str->append(key_columns[i]->field->field_name);
+  str->append(key_columns[i]->field->name().ptr());
   str->append("), ");
 
   str->append("null_bitmap: (bits=");
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 7e6753e..20450f9 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -4401,7 +4401,7 @@ static void print_partitioning_index(KEY_PART *parts, KEY_PART *parts_end)
   fprintf(DBUG_FILE, "partitioning INDEX(");
   for (KEY_PART *p=parts; p != parts_end; p++)
   {
-    fprintf(DBUG_FILE, "%s%s", p==parts?"":" ,", p->field->field_name);
+    fprintf(DBUG_FILE, "%s%s", p==parts?"":" ,", p->field->name().ptr());
   }
   fputs(");\n", DBUG_FILE);
   DBUG_UNLOCK_FILE;
@@ -4440,7 +4440,7 @@ static void dbug_print_segment_range(SEL_ARG *arg, KEY_PART *part)
       fputs(" <= ", DBUG_FILE);
   }
 
-  fprintf(DBUG_FILE, "%s", part->field->field_name);
+  fprintf(DBUG_FILE, "%s", part->field->name().ptr());
 
   if (!(arg->max_flag & NO_MAX_RANGE))
   {
@@ -4479,7 +4479,7 @@ static void dbug_print_singlepoint_range(SEL_ARG **start, uint num)
   for (SEL_ARG **arg= start; arg != end; arg++)
   {
     Field *field= (*arg)->field;
-    fprintf(DBUG_FILE, "%s%s=", (arg==start)?"":", ", field->field_name);
+    fprintf(DBUG_FILE, "%s%s=", (arg==start)?"":", ", field->name().ptr());
     dbug_print_field(field);
   }
   fputs("\n", DBUG_FILE);
diff --git a/sql/opt_subselect.cc b/sql/opt_subselect.cc
index 4b21ffe..ea0ca68 100644
--- a/sql/opt_subselect.cc
+++ b/sql/opt_subselect.cc
@@ -4012,8 +4012,9 @@ SJ_TMP_TABLE::create_sj_weedout_tmp_table(THD *thd)
       For the sake of uniformity, always use Field_varstring (altough we could
       use Field_string for shorter keys)
     */
-    field= new Field_varstring(uniq_tuple_length_arg, FALSE, "rowids", share,
-                               &my_charset_bin);
+    field= new Field_varstring(uniq_tuple_length_arg, FALSE,
+                               Column_name(C_STRING_WITH_LEN("rowids")),
+                               share, &my_charset_bin);
     if (!field)
       DBUG_RETURN(0);
     field->table= table;
diff --git a/sql/opt_table_elimination.cc b/sql/opt_table_elimination.cc
index 912ef4a..71fbc16 100644
--- a/sql/opt_table_elimination.cc
+++ b/sql/opt_table_elimination.cc
@@ -1843,7 +1843,7 @@ void Dep_analysis_context::dbug_print_deps()
               (long)(eq_mod - equality_mods),
               str.c_ptr(),
               eq_mod->field->table->table->alias.c_ptr(),
-              eq_mod->field->field->field_name);
+              eq_mod->field->field->name().ptr());
     }
     else
     {
@@ -1867,7 +1867,7 @@ void Dep_analysis_context::dbug_print_deps()
       {
         fprintf(DBUG_FILE, "    field %s.%s ->",
                 table_dep->table->alias.c_ptr(),
-                field_dep->field->field_name);
+                field_dep->field->name().ptr());
         uint ofs= field_dep->bitmap_offset;
         for (uint bit= ofs; bit < ofs + n_equality_mods; bit++)
         {
diff --git a/sql/rpl_record.cc b/sql/rpl_record.cc
index 208b2b6..4830ba1 100644
--- a/sql/rpl_record.cc
+++ b/sql/rpl_record.cc
@@ -107,7 +107,7 @@ pack_row(TABLE *table, MY_BITMAP const* cols,
                               field->max_data_length());
         DBUG_PRINT("debug", ("field: %s; real_type: %d, pack_ptr: 0x%lx;"
                              " pack_ptr':0x%lx; bytes: %d",
-                             field->field_name, field->real_type(),
+                             field->name().ptr(), field->real_type(),
                              (ulong) old_pack_ptr, (ulong) pack_ptr,
                              (int) (pack_ptr - old_pack_ptr)));
         DBUG_DUMP("packed_data", old_pack_ptr, pack_ptr - old_pack_ptr);
@@ -254,7 +254,7 @@ unpack_row(rpl_group_info *rgi,
       conv_field ? conv_field : *field_ptr;
     DBUG_PRINT("debug", ("Conversion %srequired for field '%s' (#%ld)",
                          conv_field ? "" : "not ",
-                         (*field_ptr)->field_name,
+                         (*field_ptr)->name().ptr(),
                          (long) (field_ptr - begin_ptr)));
     DBUG_ASSERT(f != NULL);
 
@@ -305,7 +305,7 @@ unpack_row(rpl_group_info *rgi,
           push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                               ER_BAD_NULL_ERROR,
                               ER_THD(thd, ER_BAD_NULL_ERROR),
-                              f->field_name);
+                              f->name().ptr());
         }
       }
       else
@@ -323,7 +323,7 @@ unpack_row(rpl_group_info *rgi,
         pack_ptr= f->unpack(f->ptr, pack_ptr, row_end, metadata);
 	DBUG_PRINT("debug", ("field: %s; metadata: 0x%x;"
                              " pack_ptr: 0x%lx; pack_ptr': 0x%lx; bytes: %d",
-                             f->field_name, metadata,
+                             f->name().ptr(), metadata,
                              (ulong) old_pack_ptr, (ulong) pack_ptr,
                              (int) (pack_ptr - old_pack_ptr)));
         if (!pack_ptr)
@@ -338,7 +338,7 @@ unpack_row(rpl_group_info *rgi,
             WSREP_WARN("ROW event unpack field: %s  metadata: 0x%x;"
                        " pack_ptr: 0x%lx; conv_table %p conv_field %p table %s"
                        " row_end: 0x%lx",
-                       f->field_name, metadata,
+                       f->name().ptr(), metadata,
                        (ulong) old_pack_ptr, conv_table, conv_field,
                        (table_found) ? "found" : "not found", (ulong)row_end
             );
@@ -347,7 +347,7 @@ unpack_row(rpl_group_info *rgi,
           rgi->rli->report(ERROR_LEVEL, ER_SLAVE_CORRUPT_EVENT,
                       rgi->gtid_info(),
                       "Could not read field '%s' of table '%s.%s'",
-                      f->field_name, table->s->db.str,
+                      f->name().ptr(), table->s->db.str,
                       table->s->table_name.str);
           DBUG_RETURN(ER_SLAVE_CORRUPT_EVENT);
         }
@@ -370,7 +370,7 @@ unpack_row(rpl_group_info *rgi,
         conv_field->sql_type(source_type);
         conv_field->val_str(&value_string);
         DBUG_PRINT("debug", ("Copying field '%s' of type '%s' with value '%s'",
-                             (*field_ptr)->field_name,
+                             (*field_ptr)->name().ptr(),
                              source_type.c_ptr_safe(), value_string.c_ptr_safe()));
 #endif
         copy.set(*field_ptr, f, TRUE);
@@ -381,7 +381,7 @@ unpack_row(rpl_group_info *rgi,
         (*field_ptr)->sql_type(target_type);
         (*field_ptr)->val_str(&value_string);
         DBUG_PRINT("debug", ("Value of field '%s' of type '%s' is now '%s'",
-                             (*field_ptr)->field_name,
+                             (*field_ptr)->name().ptr(),
                              target_type.c_ptr_safe(), value_string.c_ptr_safe()));
 #endif
       }
@@ -483,7 +483,7 @@ int prepare_record(TABLE *const table, const uint skip, const bool check)
                           Sql_condition::WARN_LEVEL_WARN,
                           ER_NO_DEFAULT_FOR_FIELD,
                           ER_THD(thd, ER_NO_DEFAULT_FOR_FIELD),
-                          f->field_name);
+                          f->name().ptr());
     }
   }
 
diff --git a/sql/rpl_record_old.cc b/sql/rpl_record_old.cc
index 5b87637..8765915 100644
--- a/sql/rpl_record_old.cc
+++ b/sql/rpl_record_old.cc
@@ -143,7 +143,7 @@ unpack_row_old(rpl_group_info *rgi,
       {
         rgi->rli->report(ERROR_LEVEL, ER_SLAVE_CORRUPT_EVENT, NULL,
                     "Could not read field `%s` of table `%s`.`%s`",
-                    f->field_name, table->s->db.str,
+                    f->name().ptr(), table->s->db.str,
                     table->s->table_name.str);
         return(ER_SLAVE_CORRUPT_EVENT);
       }
@@ -186,7 +186,7 @@ unpack_row_old(rpl_group_info *rgi,
       rgi->rli->report(ERROR_LEVEL, ER_NO_DEFAULT_FOR_FIELD, NULL,
                   "Field `%s` of table `%s`.`%s` "
                   "has no default value and cannot be NULL",
-                  (*field_ptr)->field_name, table->s->db.str,
+                  (*field_ptr)->name().ptr(), table->s->db.str,
                   table->s->table_name.str);
       error = ER_NO_DEFAULT_FOR_FIELD;
     }
diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc
index 1c48d6b..866fc50 100644
--- a/sql/rpl_utility.cc
+++ b/sql/rpl_utility.cc
@@ -846,7 +846,7 @@ table_def::compatible_with(THD *thd, rpl_group_info *rgi,
     {
       DBUG_PRINT("debug", ("Checking column %d -"
                            " field '%s' can be converted - order: %d",
-                           col, field->field_name, order));
+                           col, field->name().ptr(), order));
       DBUG_ASSERT(order >= -1 && order <= 1);
 
       /*
@@ -876,7 +876,7 @@ table_def::compatible_with(THD *thd, rpl_group_info *rgi,
     {
       DBUG_PRINT("debug", ("Checking column %d -"
                            " field '%s' can not be converted",
-                           col, field->field_name));
+                           col, field->name().ptr()));
       DBUG_ASSERT(col < size() && col < table->s->fields);
       DBUG_ASSERT(table->s->db.str && table->s->table_name.str);
       DBUG_ASSERT(table->in_use);
@@ -912,7 +912,7 @@ table_def::compatible_with(THD *thd, rpl_group_info *rgi,
         table->field[col]->sql_type(target_type);
         DBUG_PRINT("debug", ("Field %s - conversion required."
                              " Source type: '%s', Target type: '%s'",
-                             tmp_table->field[col]->field_name,
+                             tmp_table->field[col]->name().ptr(),
                              source_type.c_ptr_safe(), target_type.c_ptr_safe()));
       }
   }
@@ -988,7 +988,7 @@ TABLE *table_def::create_conversion_table(THD *thd, rpl_group_info *rgi,
                       " column Name: %s.%s.%s.",
                       target_table->s->db.str,
                       target_table->s->table_name.str,
-                      target_table->field[col]->field_name);
+                      target_table->field[col]->name().ptr());
       goto err;
 
     case MYSQL_TYPE_TINY_BLOB:
@@ -1017,7 +1017,8 @@ TABLE *table_def::create_conversion_table(THD *thd, rpl_group_info *rgi,
 
     DBUG_PRINT("debug", ("sql_type: %d, target_field: '%s', max_length: %d, decimals: %d,"
                          " maybe_null: %d, unsigned_flag: %d, pack_length: %u",
-                         binlog_type(col), target_table->field[col]->field_name,
+                         binlog_type(col),
+                         target_table->field[col]->name().ptr(),
                          max_length, decimals, TRUE, unsigned_flag,
                          pack_length));
     field_def->init_for_tmp_table(type(col),
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index cf0b8e8..0ab32e5 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -883,7 +883,9 @@ sp_head::create_result_field(uint field_max_length, const char *field_name,
                       m_return_field_def.geom_type, m_return_field_def.srid,
                       Field::NONE,                  /* unreg check */
                       m_return_field_def.interval,
-                      field_name ? field_name : (const char *) m_name.str);
+                      field_name ?
+                      Column_name(field_name, strlen(field_name)) :
+                      Column_name(m_name));
 
   field->vcol_info= m_return_field_def.vcol_info;
   if (field)
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 5c3b7c2..1060dc3 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -6322,7 +6322,7 @@ find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
   /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
   if (cached_field_index < table->s->fields &&
       !my_strcasecmp(system_charset_info,
-                     table->field[cached_field_index]->field_name, name))
+                     table->field[cached_field_index]->name().ptr(), name))
     field_ptr= table->field + cached_field_index;
   else if (table->s->name_hash.records)
   {
@@ -6342,7 +6342,7 @@ find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
     if (!(field_ptr= table->field))
       DBUG_RETURN((Field *)0);
     for (; *field_ptr; ++field_ptr)
-      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
+      if (!my_strcasecmp(system_charset_info, (*field_ptr)->name().ptr(), name))
         break;
   }
 
@@ -6598,7 +6598,7 @@ Field *find_field_in_table_sef(TABLE *table, const char *name)
     if (!(field_ptr= table->field))
       return (Field *)0;
     for (; *field_ptr; ++field_ptr)
-      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
+      if (!my_strcasecmp(system_charset_info, (*field_ptr)->name().ptr(), name))
         break;
   }
   if (field_ptr)
@@ -6793,7 +6793,7 @@ find_field_in_tables(THD *thd, Item_ident *item,
         if (cur_field)
         {
           Field *nf=new Field_null(NULL,0,Field::NONE,
-                                   cur_field->field_name,
+                                   cur_field->name(),
                                    &my_charset_bin);
           nf->init(cur_table->table);
           cur_field= nf;
@@ -8787,7 +8787,7 @@ fill_record(THD *thd, TABLE *table_arg, List<Item> &fields, List<Item> &values,
       push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                           ER_WARNING_NON_DEFAULT_VALUE_FOR_VIRTUAL_COLUMN,
                           ER_THD(thd, ER_WARNING_NON_DEFAULT_VALUE_FOR_VIRTUAL_COLUMN),
-                          rfield->field_name, table->s->table_name.str);
+                          rfield->name().ptr(), table->s->table_name.str);
     }
     if (rfield->stored_in_db() &&
         (value->save_in_field(rfield, 0)) < 0 && !ignore_errors)
@@ -8939,7 +8939,7 @@ fill_record(THD *thd, TABLE *table, Field **ptr, List<Item> &values,
       push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                           ER_WARNING_NON_DEFAULT_VALUE_FOR_VIRTUAL_COLUMN,
                           ER_THD(thd, ER_WARNING_NON_DEFAULT_VALUE_FOR_VIRTUAL_COLUMN),
-                          field->field_name, table->s->table_name.str);
+                          field->name().ptr(), table->s->table_name.str);
     }
 
     if (use_value)
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 6656a84..0b24f4a 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -100,12 +100,6 @@ extern "C" void free_user_var(user_var_entry *entry)
   my_free(entry);
 }
 
-bool Key_part_spec::operator==(const Key_part_spec& other) const
-{
-  return length == other.length &&
-         !my_strcasecmp(system_charset_info, field_name.str,
-                        other.field_name.str);
-}
 
 /**
   Construct an (almost) deep copy of this key. Only those
@@ -231,12 +225,10 @@ bool Foreign_key::validate(List<Create_field> &table_fields)
   {
     it.rewind();
     while ((sql_field= it++) &&
-           my_strcasecmp(system_charset_info,
-                         column->field_name.str,
-                         sql_field->field_name)) {}
+           !sql_field->eq_name(column)) { }
     if (!sql_field)
     {
-      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name);
+      my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->name().ptr());
       DBUG_RETURN(TRUE);
     }
     if (type == Key::FOREIGN_KEY && sql_field->vcol_info)
diff --git a/sql/sql_class.h b/sql/sql_class.h
index ae240ae..9b7727b 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -229,17 +229,16 @@ typedef struct st_copy_info {
 } COPY_INFO;
 
 
-class Key_part_spec :public Sql_alloc {
+class Key_part_spec :public Sql_alloc, public Column_name {
 public:
-  LEX_STRING field_name;
   uint length;
-  Key_part_spec(const LEX_STRING &name, uint len)
-    : field_name(name), length(len)
+  Key_part_spec(const Column_name &name, uint len)
+    :Column_name(name), length(len)
   {}
-  Key_part_spec(const char *name, const size_t name_len, uint len)
-    : length(len)
-  { field_name.str= (char *)name; field_name.length= name_len; }
-  bool operator==(const Key_part_spec& other) const;
+  bool operator==(const Key_part_spec& other) const
+  {
+    return eq_name(other);
+  }
   /**
     Construct a copy of this Key_part_spec. field_name is copied
     by-pointer as it is known to never change. At the same time
diff --git a/sql/sql_explain.cc b/sql/sql_explain.cc
index 8b3e672..e2fb910 100644
--- a/sql/sql_explain.cc
+++ b/sql/sql_explain.cc
@@ -1104,7 +1104,7 @@ void Explain_index_use::set(MEM_ROOT *mem_root, KEY *key, uint key_len_arg)
   uint len= 0;
   for (uint i= 0; i < key->usable_key_parts; i++)
   {
-    key_parts_list.append_str(mem_root, key->key_part[i].field->field_name);
+    key_parts_list.append_str(mem_root, key->key_part[i].field->name().ptr());
     len += key->key_part[i].store_length;
     if (len >= key_len_arg)
       break;
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index aa2cae5..c002f36 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -279,7 +279,7 @@ static int check_insert_fields(THD *thd, TABLE_LIST *table_list,
 
     if (check_unique && thd->dup_field)
     {
-      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), thd->dup_field->field_name);
+      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), thd->dup_field->name().ptr());
       DBUG_RETURN(-1);
     }
     if (table->default_field)
@@ -1948,7 +1948,7 @@ int check_that_all_fields_are_given_values(THD *thd, TABLE *entry,
         push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                             ER_NO_DEFAULT_FOR_FIELD,
                             ER_THD(thd, ER_NO_DEFAULT_FOR_FIELD),
-                            (*field)->field_name);
+                            (*field)->name().ptr());
       }
       err= 1;
     }
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 9eddd6d..a41357e 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -2850,7 +2850,8 @@ struct LEX: public Query_tables_list
                     bool is_analyze, bool *printed_anything);
   void restore_set_statement_var();
 
-  void init_last_field(Column_definition *field, const char *name, CHARSET_INFO *cs);
+  void init_last_field(Column_definition *field,
+                       const LEX_STRING &name, CHARSET_INFO *cs);
   void set_last_field_type(const Lex_field_type_st &type);
   bool set_bincmp(CHARSET_INFO *cs, bool bin);
   // Check if "KEY IF NOT EXISTS name" used outside of ALTER context
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index eb13e3f..9daf770 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -981,7 +981,7 @@ read_sep_field(THD *thd, COPY_INFO &info, TABLE_LIST *table_list,
           Field *field= ((Item_field *)real_item)->field;
           if (field->reset())
           {
-            my_error(ER_WARN_NULL_TO_NOTNULL, MYF(0), field->field_name,
+            my_error(ER_WARN_NULL_TO_NOTNULL, MYF(0), field->name().ptr(),
                      thd->get_stmt_da()->current_row_for_warning());
             DBUG_RETURN(1);
           }
@@ -1060,7 +1060,7 @@ read_sep_field(THD *thd, COPY_INFO &info, TABLE_LIST *table_list,
           Field *field= ((Item_field *)real_item)->field;
           if (field->reset())
           {
-            my_error(ER_WARN_NULL_TO_NOTNULL, MYF(0),field->field_name,
+            my_error(ER_WARN_NULL_TO_NOTNULL, MYF(0),field->name().ptr(),
                      thd->get_stmt_da()->current_row_for_warning());
             DBUG_RETURN(1);
           }
diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc
index 832f218..dbdf4f8 100644
--- a/sql/sql_partition.cc
+++ b/sql/sql_partition.cc
@@ -517,9 +517,7 @@ static bool set_up_field_array(THD *thd, TABLE *table,
           do
           {
             field_name= it++;
-            if (!my_strcasecmp(system_charset_info,
-                               field_name,
-                               field->field_name))
+            if (field->eq_name(field_name))
               break;
           } while (++inx < num_fields);
           if (inx == num_fields)
@@ -2178,9 +2176,7 @@ static Create_field* get_sql_field(char *field_name,
 
   while ((sql_field= it++))
   {
-    if (!(my_strcasecmp(system_charset_info,
-                        sql_field->field_name,
-                        field_name)))
+    if (sql_field->eq_name(field_name))
     {
       DBUG_RETURN(sql_field);
     }
@@ -2242,7 +2238,7 @@ static int add_column_list_values(File fptr, partition_info *part_info,
             return 1;
           }
           if (check_part_field(sql_field->sql_type,
-                               sql_field->field_name,
+                               sql_field->name().ptr(),
                                &result_type,
                                &need_cs_check))
             return 1;
@@ -2256,7 +2252,7 @@ static int add_column_list_values(File fptr, partition_info *part_info,
           Field *field= part_info->part_field_array[i];
           result_type= field->result_type();
           if (check_part_field(field->real_type(),
-                               field->field_name,
+                               field->name().ptr(),
                                &result_type,
                                &need_cs_check))
             return 1;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 6a12c05..b3a19f1 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -15656,7 +15656,7 @@ Field *create_tmp_field_from_field(THD *thd, Field *org_field,
       (org_field->flags & BLOB_FLAG))
     new_field= new Field_varstring(convert_blob_length,
                                    org_field->maybe_null(),
-                                   org_field->field_name, table->s,
+                                   org_field->name(), table->s,
                                    org_field->charset());
   else
     new_field= org_field->make_new_field(thd->mem_root, table,
@@ -15668,7 +15668,7 @@ Field *create_tmp_field_from_field(THD *thd, Field *org_field,
     if (item)
       item->result_field= new_field;
     else
-      new_field->field_name= name;
+      new_field->set_name(Name(name, name ? strlen(name) : 0));
     new_field->flags|= (org_field->flags & NO_DEFAULT_VALUE_FLAG);
     if (org_field->maybe_null() || (item && item->maybe_null))
       new_field->flags&= ~NOT_NULL_FLAG;	// Because of outer join
@@ -16824,7 +16824,7 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
                                              (uchar*) 0,
                                              (uint) 0,
                                              Field::NONE,
-                                             NullS, &my_charset_bin);
+                                             null_lex_str, &my_charset_bin);
       if (!key_part_info->field)
         goto err;
       key_part_info->field->init(table);
@@ -16986,7 +16986,7 @@ TABLE *create_virtual_tmp_table(THD *thd, List<Column_definition> &field_list)
                        f_maybe_null(cdef->pack_flag) ? 1 : 0,
                        cdef->pack_flag, cdef->sql_type, cdef->charset,
                        cdef->geom_type, cdef->srid, cdef->unireg_check,
-                       cdef->interval, cdef->field_name);
+                       cdef->interval, cdef->name());
     if (!*field)
       goto error;
     (*field)->init(table);
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 1fb57d1..c640e90 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -419,7 +419,7 @@ static int get_geometry_column_record(THD *thd, TABLE_LIST *tables,
       /*G_TABLE_NAME*/
       table->field[6]->store(table_name->str, table_name->length, cs);
       /*G_GEOMETRY_COLUMN*/
-      table->field[7]->store(field->field_name, strlen(field->field_name), cs);
+      table->field[7]->store(field->name().ptr(), field->name().length(), cs);
       /*STORAGE_TYPE*/
       table->field[8]->store(1LL, TRUE); /*Always 1 (binary implementation)*/
       /*GEOMETRY_TYPE*/
@@ -1346,7 +1346,7 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
   for (ptr=table->field ; (field= *ptr); ptr++)
   {
     if (!wild || !wild[0] ||
-        !wild_case_compare(system_charset_info, field->field_name,wild))
+        !wild_case_compare(system_charset_info, field->name().ptr(), wild))
     {
       if (table_list->view)
         field_list.push_back(new (mem_root)
@@ -1808,7 +1808,7 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
       packet->append(STRING_WITH_LEN(",\n"));
 
     packet->append(STRING_WITH_LEN("  "));
-    append_identifier(thd,packet,field->field_name, strlen(field->field_name));
+    append_identifier(thd,packet, field->name().ptr(), field->name().length());
     packet->append(' ');
     // check for surprises from the previous call to Field::sql_type()
     if (type.ptr() != tmp)
@@ -1933,8 +1933,8 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
         packet->append(',');
 
       if (key_part->field)
-        append_identifier(thd,packet,key_part->field->field_name,
-			  strlen(key_part->field->field_name));
+        append_identifier(thd,packet,key_part->field->name().ptr(),
+			  key_part->field->name().length());
       if (key_part->field &&
           (key_part->length !=
            table->field[key_part->fieldnr-1]->key_length() &&
@@ -5288,7 +5288,7 @@ static int get_schema_column_record(THD *thd, TABLE_LIST *tables,
     DEBUG_SYNC(thd, "get_schema_column");
 
     if (wild && wild[0] &&
-        wild_case_compare(system_charset_info, field->field_name,wild))
+        wild_case_compare(system_charset_info, field->name().ptr(), wild))
       continue;
 
     count++;
@@ -5301,7 +5301,7 @@ static int get_schema_column_record(THD *thd, TABLE_LIST *tables,
                  &tables->grant.privilege, 0, 0, MY_TEST(tables->schema_table));
     col_access= get_column_grant(thd, &tables->grant,
                                  db_name->str, table_name->str,
-                                 field->field_name) & COL_ACLS;
+                                 field->name().ptr()) & COL_ACLS;
     if (!tables->schema_table && !col_access)
       continue;
     char *end= tmp;
@@ -5319,8 +5319,7 @@ static int get_schema_column_record(THD *thd, TABLE_LIST *tables,
     table->field[0]->store(STRING_WITH_LEN("def"), cs);
     table->field[1]->store(db_name->str, db_name->length, cs);
     table->field[2]->store(table_name->str, table_name->length, cs);
-    table->field[3]->store(field->field_name, strlen(field->field_name),
-                           cs);
+    table->field[3]->store(field->name().ptr(), field->name().length(), cs);
     table->field[4]->store((longlong) count, TRUE);
 
     if (get_field_default_value(thd, field, &type, 0))
@@ -5645,7 +5644,7 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
                         (uchar*) "", 0, field_def->pack_flag,
                         field_def->sql_type, field_def->charset,
                         field_def->geom_type, field_def->srid, Field::NONE,
-                        field_def->interval, "");
+                        field_def->interval, empty_lex_str);
 
       field->table= &tbl;
       tbl.in_use= thd;
@@ -5698,7 +5697,7 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table,
                         (uchar*) "", 0, field_def->pack_flag,
                         field_def->sql_type, field_def->charset,
                         field_def->geom_type, field_def->srid, Field::NONE,
-                        field_def->interval, spvar->name.str);
+                        field_def->interval, spvar->name);
 
       field->table= &tbl;
       tbl.in_use= thd;
@@ -5796,7 +5795,7 @@ bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table,
                             (uchar*) "", 0, field_def->pack_flag,
                             field_def->sql_type, field_def->charset,
                             field_def->geom_type, field_def->srid, Field::NONE,
-                            field_def->interval, "");
+                            field_def->interval, empty_lex_str);
 
           field->table= &tbl;
           tbl.in_use= thd;
@@ -5971,7 +5970,7 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
         table->field[4]->store(db_name->str, db_name->length, cs);
         table->field[5]->store(key_info->name, strlen(key_info->name), cs);
         table->field[6]->store((longlong) (j+1), TRUE);
-        str=(key_part->field ? key_part->field->field_name :
+        str=(key_part->field ? key_part->field->name().ptr() :
              "?unknown field?");
         table->field[7]->store(str, strlen(str), cs);
         if (show_table->file)
@@ -6415,8 +6414,8 @@ static int get_schema_key_column_usage_record(THD *thd,
           store_key_column_usage(table, db_name, table_name,
                                  key_info->name,
                                  strlen(key_info->name),
-                                 key_part->field->field_name,
-                                 strlen(key_part->field->field_name),
+                                 key_part->field->name().ptr(),
+                                 key_part->field->name().length(),
                                  (longlong) f_idx);
           if (schema_table_store_record(thd, table))
             DBUG_RETURN(1);
diff --git a/sql/sql_statistics.cc b/sql/sql_statistics.cc
index 324741f..3bf9a77 100644
--- a/sql/sql_statistics.cc
+++ b/sql/sql_statistics.cc
@@ -839,8 +839,7 @@ class Column_stat: public Stat_table
   void set_key_fields(Field *col)
   {
     set_full_table_name();
-    const char *column_name= col->field_name;
-    column_name_field->store(column_name, strlen(column_name),
+    column_name_field->store(col->name().ptr(), col->name().length(),
                              system_charset_info);  
     table_field= col;
   }
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 40032c3..7f8c18f 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -2937,7 +2937,7 @@ int prepare_create_field(Column_definition *sql_field,
           MAX_FIELD_CHARLENGTH)
       {
         my_printf_error(ER_TOO_BIG_FIELDLENGTH, ER(ER_TOO_BIG_FIELDLENGTH),
-                        MYF(0), sql_field->field_name,
+                        MYF(0), sql_field->name().ptr(),
                         static_cast<ulong>(MAX_FIELD_CHARLENGTH));
         DBUG_RETURN(1);
       }
@@ -2955,7 +2955,7 @@ int prepare_create_field(Column_definition *sql_field,
     if (sql_field->charset->state & MY_CS_BINSORT)
       sql_field->pack_flag|=FIELDFLAG_BINARY;
     sql_field->unireg_check=Field::INTERVAL_FIELD;
-    if (check_duplicates_in_interval("ENUM",sql_field->field_name,
+    if (check_duplicates_in_interval("ENUM", sql_field->name().ptr(),
                                      sql_field->interval,
                                      sql_field->charset, &dup_val_count))
       DBUG_RETURN(1);
@@ -2966,14 +2966,14 @@ int prepare_create_field(Column_definition *sql_field,
     if (sql_field->charset->state & MY_CS_BINSORT)
       sql_field->pack_flag|=FIELDFLAG_BINARY;
     sql_field->unireg_check=Field::BIT_FIELD;
-    if (check_duplicates_in_interval("SET",sql_field->field_name,
+    if (check_duplicates_in_interval("SET", sql_field->name().ptr(),
                                      sql_field->interval,
                                      sql_field->charset, &dup_val_count))
       DBUG_RETURN(1);
     /* Check that count of unique members is not more then 64 */
     if (sql_field->interval->count -  dup_val_count > sizeof(longlong)*8)
     {
-       my_error(ER_TOO_BIG_SET, MYF(0), sql_field->field_name);
+       my_error(ER_TOO_BIG_SET, MYF(0), sql_field->name().ptr());
        DBUG_RETURN(1);
     }
     break;
@@ -3082,7 +3082,7 @@ void promote_first_timestamp_column(List<Create_field> *column_definitions)
         DBUG_PRINT("info", ("First TIMESTAMP column '%s' was promoted to "
                             "DEFAULT CURRENT_TIMESTAMP ON UPDATE "
                             "CURRENT_TIMESTAMP",
-                            column_definition->field_name
+                            column_definition->name().ptr()
                             ));
         column_definition->unireg_check= Field::TIMESTAMP_DNUN_FIELD;
       }
@@ -3152,8 +3152,7 @@ static void check_duplicate_key(THD *thd,
 
       DBUG_ASSERT(c1 && c2);
 
-      if (my_strcasecmp(system_charset_info,
-                        c1->field_name.str, c2->field_name.str) ||
+      if (!c1->eq_name(c2) ||
           (c1->length != c2->length))
       {
         all_columns_are_identical= false;
@@ -3270,7 +3269,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
       if (sql_field->def == NULL)
       {
         /* Could not convert */
-        my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
+        my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->name().ptr());
         DBUG_RETURN(TRUE);
       }
     }
@@ -3349,7 +3348,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
           {
             if ((sql_field->flags & NOT_NULL_FLAG) != 0)
             {
-              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
+              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->name().ptr());
               DBUG_RETURN(TRUE);
             }
 
@@ -3365,7 +3364,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 
           if (not_found)
           {
-            my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
+            my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->name().ptr());
             DBUG_RETURN(TRUE);
           }
         }
@@ -3383,7 +3382,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
           {
             if ((sql_field->flags & NOT_NULL_FLAG) != 0)
             {
-              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
+              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->name().ptr());
               DBUG_RETURN(TRUE);
             }
 
@@ -3394,7 +3393,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
             def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));
             if (find_type2(interval, def->ptr(), def->length(), cs) == 0) /* not found */
             {
-              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
+              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->name().ptr());
               DBUG_RETURN(TRUE);
             }
           }
@@ -3421,18 +3420,16 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
     if (!(sql_field->flags & NOT_NULL_FLAG))
       null_fields++;
 
-    if (check_column_name(sql_field->field_name))
+    if (check_column_name(sql_field->name().ptr()))
     {
-      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
+      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->name().ptr());
       DBUG_RETURN(TRUE);
     }
 
     /* Check if we have used the same field name before */
     for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
     {
-      if (my_strcasecmp(system_charset_info,
-			sql_field->field_name,
-			dup_field->field_name) == 0)
+      if (sql_field->eq_name(dup_field))
       {
 	/*
 	  If this was a CREATE ... SELECT statement, accept a field
@@ -3440,7 +3437,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 	*/
 	if (field_no < select_field_pos || dup_no >= select_field_pos)
 	{
-	  my_error(ER_DUP_FIELDNAME, MYF(0), sql_field->field_name);
+	  my_error(ER_DUP_FIELDNAME, MYF(0), sql_field->name().ptr());
 	  DBUG_RETURN(TRUE);
 	}
 	else
@@ -3775,24 +3772,20 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 
       it.rewind();
       field=0;
-      while ((sql_field=it++) &&
-	     my_strcasecmp(system_charset_info,
-			   column->field_name.str,
-			   sql_field->field_name))
+      while ((sql_field=it++) && !sql_field->eq_name(column->name()))
 	field++;
       if (!sql_field)
       {
-	my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
+	my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->name().ptr());
 	DBUG_RETURN(TRUE);
       }
       while ((dup_column= cols2++) != column)
       {
-        if (!my_strcasecmp(system_charset_info,
-	     	           column->field_name.str, dup_column->field_name.str))
+        if (column->eq_name(dup_column))
 	{
-	  my_printf_error(ER_DUP_FIELDNAME,
-			  ER_THD(thd, ER_DUP_FIELDNAME),MYF(0),
-			  column->field_name.str);
+          my_printf_error(ER_DUP_FIELDNAME,
+                          ER_THD(thd, ER_DUP_FIELDNAME),MYF(0),
+                          column->name().ptr());
 	  DBUG_RETURN(TRUE);
 	}
       }
@@ -3806,7 +3799,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 	    sql_field->charset->mbminlen > 1 || // ucs2 doesn't work yet
 	    (ft_key_charset && sql_field->charset != ft_key_charset))
 	{
-	    my_error(ER_BAD_FT_COLUMN, MYF(0), column->field_name.str);
+	    my_error(ER_BAD_FT_COLUMN, MYF(0), column->name().ptr());
 	    DBUG_RETURN(-1);
 	}
 	ft_key_charset=sql_field->charset;
@@ -3842,7 +3835,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 	{
 	  if (!(file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
 	  {
-	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str,
+	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->name().ptr(),
                      file->table_type());
 	    DBUG_RETURN(TRUE);
 	  }
@@ -3851,7 +3844,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
             column->length= MAX_LEN_GEOM_POINT_FIELD;
 	  if (!column->length)
 	  {
-	    my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.str);
+	    my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->name().ptr());
 	    DBUG_RETURN(TRUE);
 	  }
 	}
@@ -3893,7 +3886,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
             key_info->flags|= HA_NULL_PART_KEY;
             if (!(file->ha_table_flags() & HA_NULL_IN_KEY))
             {
-              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
+              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->name().ptr());
               DBUG_RETURN(TRUE);
             }
             if (key->type == Key::SPATIAL)
@@ -3968,7 +3961,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
       else if (key_part_length == 0 && (sql_field->flags & NOT_NULL_FLAG))
       {
 	my_error(ER_WRONG_KEY_COLUMN, MYF(0), file->table_type(),
-                 column->field_name.str);
+                 column->name().ptr());
 	  DBUG_RETURN(TRUE);
       }
       if (key_part_length > file->max_key_part_length() &&
@@ -4027,7 +4020,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
 	  primary_key=1;
 	}
 	else if (!(key_name= key->name.str))
-	  key_name=make_unique_key_name(thd, sql_field->field_name,
+	  key_name=make_unique_key_name(thd, sql_field->name().ptr(),
 					*key_info_buffer, key_info);
 	if (check_if_keyname_exists(key_name, *key_info_buffer, key_info))
 	{
@@ -4126,7 +4119,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
             'column_name TIMESTAMP DEFAULT 0'.
       */
 
-      my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
+      my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->name().ptr());
       DBUG_RETURN(TRUE);
     }
   }
@@ -4248,7 +4241,7 @@ static bool prepare_blob_field(THD *thd, Column_definition *sql_field)
 
     if (sql_field->def || thd->is_strict_mode())
     {
-      my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), sql_field->field_name,
+      my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), sql_field->name().ptr(),
                static_cast<ulong>(MAX_FIELD_VARCHARLENGTH /
                                   sql_field->charset->mbmaxlen));
       DBUG_RETURN(1);
@@ -4256,7 +4249,7 @@ static bool prepare_blob_field(THD *thd, Column_definition *sql_field)
     sql_field->sql_type= MYSQL_TYPE_BLOB;
     sql_field->flags|= BLOB_FLAG;
     my_snprintf(warn_buff, sizeof(warn_buff), ER_THD(thd, ER_AUTO_CONVERT),
-                sql_field->field_name,
+                sql_field->name().ptr(),
                 (sql_field->charset == &my_charset_bin) ? "VARBINARY" :
                 "VARCHAR",
                 (sql_field->charset == &my_charset_bin) ? "BLOB" : "TEXT");
@@ -5671,8 +5664,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
       */
       for (f_ptr=table->field; *f_ptr; f_ptr++)
       {
-        if (my_strcasecmp(system_charset_info,
-              sql_field->field_name, (*f_ptr)->field_name) == 0)
+        if (sql_field->eq_name(*f_ptr))
           goto drop_create_field;
       }
       {
@@ -5684,8 +5676,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
         Create_field *chk_field;
         while ((chk_field= chk_it++) && chk_field != sql_field)
         {
-          if (my_strcasecmp(system_charset_info,
-                sql_field->field_name, chk_field->field_name) == 0)
+          if (sql_field->eq_name(chk_field))
             goto drop_create_field;
         }
       }
@@ -5693,7 +5684,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
 drop_create_field:
       push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
                           ER_DUP_FIELDNAME, ER_THD(thd, ER_DUP_FIELDNAME),
-                          sql_field->field_name);
+                          sql_field->name().ptr());
       it.remove();
       if (alter_info->create_list.is_empty())
       {
@@ -5720,8 +5711,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
       */
       for (f_ptr=table->field; *f_ptr; f_ptr++)
       {
-        if (my_strcasecmp(system_charset_info,
-              sql_field->change, (*f_ptr)->field_name) == 0)
+        if ((*f_ptr)->eq_name(sql_field->change))
         {
           break;
         }
@@ -5762,8 +5752,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
         */
         for (f_ptr=table->field; *f_ptr; f_ptr++)
         {
-          if (my_strcasecmp(system_charset_info,
-                            drop->name, (*f_ptr)->field_name) == 0)
+          if ((*f_ptr)->eq_name(drop->name))
           {
             remove_drop= FALSE;
             break;
@@ -5866,7 +5855,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
           List_iterator<Key_part_spec> part_it(key->columns);
           Key_part_spec *kp;
           if ((kp= part_it++))
-            keyname= kp->field_name.str;
+            keyname= kp->name().ptr();
           if (keyname == NULL)
             continue;
         }
@@ -5907,7 +5896,7 @@ handle_if_exists_options(THD *thd, TABLE *table, Alter_info *alter_info)
             List_iterator<Key_part_spec> part_it(chk_key->columns);
             Key_part_spec *kp;
             if ((kp= part_it++))
-              chkname= kp->field_name.str;
+              chkname= kp->name().ptr();
             if (keyname == NULL)
               continue;
           }
@@ -6241,13 +6230,12 @@ static bool fill_alter_inplace_info(THD *thd,
       }
 
       /* Check if field was renamed */
-      if (my_strcasecmp(system_charset_info, field->field_name,
-                        new_field->field_name))
+      if (!new_field->eq_name(field))
       {
         field->flags|= FIELD_IS_RENAMED;
         ha_alter_info->handler_flags|= Alter_inplace_info::ALTER_COLUMN_NAME;
         rename_column_in_stat_tables(thd, table, field,
-                                     new_field->field_name);
+                                     new_field->name().ptr());
       }
 
       /* Check that NULL behavior is same for old and new fields */
@@ -6678,9 +6666,7 @@ bool mysql_compare_tables(TABLE *table,
       create_info->table_options|= HA_OPTION_PACK_RECORD;
 
     /* Check if field was renamed */
-    if (my_strcasecmp(system_charset_info,
-		      field->field_name,
-		      tmp_new_field->field_name))
+    if (!tmp_new_field->eq_name(field))
       DBUG_RETURN(false);
 
     /* Evaluate changes bitmap and send to check_if_incompatible_data() */
@@ -7355,7 +7341,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
     while ((drop=drop_it++))
     {
       if (drop->type == Alter_drop::COLUMN &&
-	  !my_strcasecmp(system_charset_info,field->field_name, drop->name))
+          field->eq_name(drop->name))
       {
 	/* Reset auto_increment value if it was dropped */
 	if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
@@ -7379,7 +7365,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
     while ((def=def_it++))
     {
       if (def->change &&
-	  !my_strcasecmp(system_charset_info,field->field_name, def->change))
+          field->eq_name(def->change))
 	break;
     }
     if (def)
@@ -7420,7 +7406,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
       Alter_column *alter;
       while ((alter=alter_it++))
       {
-	if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
+	if (field->eq_name(alter->name))
 	  break;
       }
       if (alter)
@@ -7500,7 +7486,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
         find_it.rewind();
         while ((find=find_it++))
         {
-          if (!my_strcasecmp(system_charset_info, def->after, find->field_name))
+          if (find->eq_name(def->after))
             break;
         }
         if (!find)
@@ -7570,7 +7556,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
     {
       if (!key_part->field)
 	continue;				// Wrong field (from UNIREG)
-      const char *key_part_name=key_part->field->field_name;
+      const Column_name *key_part_name= key_part->field;
       Create_field *cfield;
       uint key_part_length;
 
@@ -7579,12 +7565,10 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
       {
 	if (cfield->change)
 	{
-	  if (!my_strcasecmp(system_charset_info, key_part_name,
-			     cfield->change))
+	  if (key_part_name->eq_name(cfield->change))
 	    break;
 	}
-	else if (!my_strcasecmp(system_charset_info,
-				key_part_name, cfield->field_name))
+	else if (cfield->eq_name(key_part_name))
 	  break;
       }
       if (!cfield)
@@ -7631,9 +7615,7 @@ mysql_prepare_alter_table(THD *thd, TABLE *table,
 	  key_part_length= 0;			// Use whole field
       }
       key_part_length /= key_part->field->charset()->mbmaxlen;
-      key_parts.push_back(new Key_part_spec(cfield->field_name,
-                                            strlen(cfield->field_name),
-					    key_part_length),
+      key_parts.push_back(new Key_part_spec(*cfield, key_part_length),
                           thd->mem_root);
     }
     if (table->s->tmp_table == NO_TMP_TABLE)
@@ -7783,10 +7765,7 @@ static Create_field *get_field_by_old_name(Alter_info *alter_info,
 
   while ((new_field= new_field_it++))
   {
-    if (new_field->field &&
-        (my_strcasecmp(system_charset_info,
-                       new_field->field->field_name,
-                       old_name) == 0))
+    if (new_field->field && new_field->field->eq_name(old_name))
       break;
   }
   return new_field;
@@ -7841,8 +7820,7 @@ fk_check_column_changes(THD *thd, Alter_info *alter_info,
     {
       Field *old_field= new_field->field;
 
-      if (my_strcasecmp(system_charset_info, old_field->field_name,
-                        new_field->field_name))
+      if (!new_field->eq_name(old_field))
       {
         /*
           Copy algorithm doesn't support proper renaming of columns in
@@ -9222,7 +9200,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
     thd->abort_on_warning= true;
     make_truncated_value_warning(thd, Sql_condition::WARN_LEVEL_WARN,
                                  f_val, strlength(f_val), t_type,
-                                 alter_ctx.datetime_field->field_name);
+                                 alter_ctx.datetime_field->name().ptr());
     thd->abort_on_warning= save_abort_on_warning;
   }
 
diff --git a/sql/sql_test.cc b/sql/sql_test.cc
index 8e75258..7977b08 100644
--- a/sql/sql_test.cc
+++ b/sql/sql_test.cc
@@ -135,7 +135,7 @@ void TEST_filesort(SORT_FIELD *sortorder,uint s_length)
 	out.append(*sortorder->field->table_name);
 	out.append('.');
       }
-      out.append(sortorder->field->field_name ? sortorder->field->field_name:
+      out.append(sortorder->field->name().ptr() ? sortorder->field->name().ptr():
 		 "tmp_table_column");
     }
     else
@@ -236,11 +236,11 @@ static void print_keyuse(KEYUSE *keyuse)
   keyuse->val->print(&str, QT_ORDINARY);
   str.append('\0');
   if (keyuse->is_for_hash_join())
-    fieldname= keyuse->table->field[keyuse->keypart]->field_name;
+    fieldname= keyuse->table->field[keyuse->keypart]->name().ptr();
   else if (keyuse->keypart == FT_KEYPART)
     fieldname= "FT_KEYPART";
   else
-    fieldname= key_info->key_part[keyuse->keypart].field->field_name;
+    fieldname= key_info->key_part[keyuse->keypart].field->name().ptr();
   ll2str(keyuse->used_tables, buf2, 16, 0); 
   fprintf(DBUG_FILE, "KEYUSE: %s.%s=%s  optimize: %u  used_tables: %s "
           "ref_table_rows: %lu  keypart_map: %0lx\n",
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 7787768..87f4402 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -855,12 +855,13 @@ static void add_key_to_list(LEX *lex, LEX_STRING *field_name,
   lex->alter_info.key_list.push_back(key, mem_root);
 }
 
-void LEX::init_last_field(Column_definition *field, const char *field_name,
-         CHARSET_INFO *cs)
+void LEX::init_last_field(Column_definition *field,
+                          const LEX_STRING &field_name,
+                          CHARSET_INFO *cs)
 {
   last_field= field;
 
-  field->field_name= field_name;
+  field->set_name(field_name);
 
   /* reset LEX fields that are used in Create_field::set_and_check() */
   charset= cs;
@@ -2935,7 +2936,7 @@ sp_param_name_and_type:
 
             sp_variable *spvar= spc->add_variable(thd, $1);
 
-            lex->init_last_field(&spvar->field_def, $1.str,
+            lex->init_last_field(&spvar->field_def, $1,
                                  thd->variables.collation_database);
             $<spvar>$= spvar;
           }
@@ -2948,7 +2949,7 @@ sp_param_name_and_type:
             {
               MYSQL_YYABORT;
             }
-            spvar->field_def.field_name= spvar->name.str;
+            spvar->field_def.set_name(spvar->name);
             spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
 
             $$= spvar;
@@ -3030,7 +3031,7 @@ sp_decl:
 
             lex->sphead->reset_lex(thd);
             pctx->declare_var_boundary($2);
-            thd->lex->init_last_field(&spvar->field_def, spvar->name.str,
+            thd->lex->init_last_field(&spvar->field_def, spvar->name,
                                       thd->variables.collation_database);
           }
           type_with_opt_collate
@@ -3062,8 +3063,8 @@ sp_decl:
                 spvar->field_def= *lex->last_field;
 
               spvar->default_value= dflt_value_item;
-              spvar->field_def.field_name= spvar->name.str;
-            
+              spvar->field_def.set_name(spvar->name);
+
               if (lex->sphead->fill_field_definition(thd, lex,
                                                      &spvar->field_def))
               {
@@ -6133,7 +6134,7 @@ field_spec:
             if (!f)
               MYSQL_YYABORT;
 
-            lex->init_last_field(f, $1.str, NULL);
+            lex->init_last_field(f, $1, NULL);
             $<create_field>$= f;
           }
           field_type  { Lex->set_last_field_type($3); }
@@ -6254,7 +6255,7 @@ field_type:
               if (err || tmp_length > PRECISION_FOR_DOUBLE)
               {
                 my_error(ER_WRONG_FIELD_SPEC, MYF(0),
-                         Lex->last_field->field_name);
+                         Lex->last_field->name().ptr());
                 MYSQL_YYABORT;
               }
               else if (tmp_length > PRECISION_FOR_FLOAT)
@@ -7591,7 +7592,7 @@ alter_list_item:
           {
             Lex->alter_info.flags|= Alter_info::ALTER_CHANGE_COLUMN;
             Lex->create_last_non_select_table= Lex->last_table();
-            $4->change= $4->field_name;
+            $4->change= $4->name().ptr();
             $4->after= $5;
           }
         | DROP opt_column opt_if_exists_table_element field_ident opt_restrict
@@ -16330,7 +16331,8 @@ sf_tail:
           RETURNS_SYM /* $9 */
           { /* $10 */
             LEX *lex= Lex;
-            lex->init_last_field(&lex->sphead->m_return_field_def, NULL,
+            lex->init_last_field(&lex->sphead->m_return_field_def,
+                                 null_lex_str,
                                  thd->variables.collation_database);
           }
           type_with_opt_collate /* $11 */
diff --git a/sql/table.cc b/sql/table.cc
index 933cfaa..a37a39d 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -198,8 +198,8 @@ View_creation_ctx * View_creation_ctx::create(THD *thd,
 static uchar *get_field_name(Field **buff, size_t *length,
                              my_bool not_used __attribute__((unused)))
 {
-  *length= (uint) strlen((*buff)->field_name);
-  return (uchar*) (*buff)->field_name;
+  *length= (uint) (*buff)->name().length();
+  return (uchar*) (*buff)->name().ptr();
 }
 
 
@@ -3757,7 +3757,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
     {
       Field *field= table->field[i];
 
-      if (strncmp(field->field_name, field_def->name.str,
+      if (strncmp(field->name().ptr(), field_def->name.str,
                   field_def->name.length))
       {
         /*
@@ -3769,7 +3769,7 @@ Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
                      "expected column '%s' at position %d, found '%s'.",
                      table->s->db.str, table->alias.c_ptr(),
                      field_def->name.str, i,
-                     field->field_name);
+                     field->name().ptr());
       }
       field->sql_type(sql_type);
       /*
@@ -5312,7 +5312,7 @@ void Field_iterator_view::set(TABLE_LIST *table)
 
 const char *Field_iterator_table::name()
 {
-  return (*ptr)->field_name;
+  return (*ptr)->name().ptr();
 }
 
 
@@ -6917,11 +6917,11 @@ int update_virtual_fields(THD *thd, TABLE *table,
     {
       /* Compute the actual value of the virtual fields */
       error= vcol_info->expr_item->save_in_field(vfield, 0);
-      DBUG_PRINT("info", ("field '%s' - updated", vfield->field_name));
+      DBUG_PRINT("info", ("field '%s' - updated", vfield->name().ptr()));
     }
     else
     {
-      DBUG_PRINT("info", ("field '%s' - skipped", vfield->field_name));
+      DBUG_PRINT("info", ("field '%s' - skipped", vfield->name().ptr()));
     }
   }
   thd->reset_arena_for_cached_items(0);
diff --git a/sql/unireg.cc b/sql/unireg.cc
index f565fc9..d1f5980 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -517,7 +517,7 @@ static bool pack_header(THD *thd, uchar *forminfo,
   while ((field=it++))
   {
     if (validate_comment_length(thd, &field->comment, COLUMN_COMMENT_MAXLEN,
-                                ER_TOO_LONG_FIELD_COMMENT, field->field_name))
+                                ER_TOO_LONG_FIELD_COMMENT, field->name().ptr()))
        DBUG_RETURN(1);
 
     if (field->vcol_info)
@@ -565,7 +565,7 @@ static bool pack_header(THD *thd, uchar *forminfo,
     length=field->pack_length;
     if ((uint) field->offset+ (uint) data_offset+ length > reclength)
       reclength=(uint) (field->offset+ data_offset + length);
-    n_length+= (ulong) strlen(field->field_name)+1;
+    n_length+= (ulong) field->name().length() + 1;
     field->interval_id=0;
     field->save_interval= 0;
     if (field->interval)
@@ -713,7 +713,7 @@ static size_t packed_fields_length(List<Create_field> &create_fields)
                FRM_VCOL_HEADER_SIZE(field->interval);
     }
     length+= FCOMP;
-    length+= strlen(field->field_name)+1;
+    length+= field->name().length() + 1;
     length+= field->comment.length;
   }
   length++;
@@ -785,7 +785,7 @@ static bool pack_fields(uchar *buff, List<Create_field> &create_fields,
   it.rewind();
   while ((field=it++))
   {
-    buff= (uchar*)strmov((char*) buff, field->field_name);
+    buff= (uchar*)strmov((char*) buff, field->name().ptr());
     *buff++=NAMES_SEP_CHAR;
   }
   *buff++= 0;
@@ -934,7 +934,7 @@ static bool make_empty_rec(THD *thd, uchar *buff, uint table_options,
                                 field->unireg_check,
                                 field->save_interval ? field->save_interval :
                                 field->interval, 
-                                field->field_name);
+                                field->name());
     if (!regfield)
     {
       error= 1;
@@ -961,7 +961,7 @@ static bool make_empty_rec(THD *thd, uchar *buff, uint table_options,
       /* If not ok or warning of level 'note' */
       if (res != 0 && res != 3)
       {
-        my_error(ER_INVALID_DEFAULT, MYF(0), regfield->field_name);
+        my_error(ER_INVALID_DEFAULT, MYF(0), regfield->name().ptr());
         error= 1;
         delete regfield; //To avoid memory leak
         goto err;
diff --git a/storage/cassandra/ha_cassandra.cc b/storage/cassandra/ha_cassandra.cc
index aa4a9bb..3fb8e11 100644
--- a/storage/cassandra/ha_cassandra.cc
+++ b/storage/cassandra/ha_cassandra.cc
@@ -411,7 +411,7 @@ int ha_cassandra::check_field_options(Field **fields)
     {
       if (dyncol_set || (*field)->type() != MYSQL_TYPE_BLOB)
       {
-         my_error(ER_WRONG_FIELD_SPEC, MYF(0), (*field)->field_name);
+         my_error(ER_WRONG_FIELD_SPEC, MYF(0), (*field)->name().ptr());
          DBUG_RETURN(HA_WRONG_CREATE_OPTION);
       }
       dyncol_set= 1;
@@ -1497,14 +1497,14 @@ bool ha_cassandra::setup_field_converters(Field **field_arg, uint n_fields)
     for (field= field_arg + 1, i= 1; *field; field++, i++)
     {
       if ((!dyncol_set || dyncol_field != i) &&
-          !strcmp((*field)->field_name, col_name))
+          !strcmp((*field)->name().ptr(), col_name))
       {
         n_mapped++;
         ColumnDataConverter **conv= field_converters + (*field)->field_index;
         if (!(*conv= map_field_to_validator(*field, col_type)))
         {
           se->print_error("Failed to map column %s to datatype %s",
-                          (*field)->field_name, col_type);
+                          (*field)->name().ptr(), col_type);
           my_error(ER_INTERNAL_ERROR, MYF(0), se->error_str());
           DBUG_RETURN(true);
         }
@@ -1543,7 +1543,7 @@ bool ha_cassandra::setup_field_converters(Field **field_arg, uint n_fields)
     DBUG_ASSERT(first_unmapped);
 
     se->print_error("Field `%s` could not be mapped to any field in Cassandra",
-                    first_unmapped->field_name);
+                    first_unmapped->name().ptr());
     my_error(ER_INTERNAL_ERROR, MYF(0), se->error_str());
     DBUG_RETURN(true);
   }
@@ -1552,14 +1552,14 @@ bool ha_cassandra::setup_field_converters(Field **field_arg, uint n_fields)
     Setup type conversion for row_key.
   */
   se->get_rowkey_type(&col_name, &col_type);
-  if (col_name && strcmp(col_name, (*field_arg)->field_name))
+  if (col_name && strcmp(col_name, (*field_arg)->name().ptr()))
   {
     se->print_error("PRIMARY KEY column must match Cassandra's name '%s'",
                     col_name);
     my_error(ER_INTERNAL_ERROR, MYF(0), se->error_str());
     DBUG_RETURN(true);
   }
-  if (!col_name && strcmp("rowkey", (*field_arg)->field_name))
+  if (!col_name && strcmp("rowkey", (*field_arg)->name().ptr()))
   {
     se->print_error("target column family has no key_alias defined, "
                     "PRIMARY KEY column must be named 'rowkey'");
@@ -1742,14 +1742,14 @@ int ha_cassandra::read_cassandra_columns(bool unpack_pk)
     {
       uint fieldnr= (*field)->field_index;
       if ((!dyncol_set || dyncol_field != fieldnr) &&
-          !strcmp((*field)->field_name, cass_name))
+          !strcmp((*field)->name().ptr(), cass_name))
       {
         found= 1;
         (*field)->set_notnull();
         if (field_converters[fieldnr]->cassandra_to_mariadb(cass_value,
                                                             cass_value_len))
         {
-          print_conversion_error((*field)->field_name, cass_value,
+          print_conversion_error((*field)->name().ptr(), cass_value,
                                  cass_value_len);
           res=1;
           goto err;
@@ -1770,7 +1770,7 @@ int ha_cassandra::read_cassandra_columns(bool unpack_pk)
         se->print_error("Unable to convert value for field `%s`"
                         " from Cassandra's data format. Name"
                         " length exceed limit of %u: '%s'",
-                        table->field[dyncol_field]->field_name,
+                        table->field[dyncol_field]->name().ptr(),
                         (uint)MAX_NAME_LENGTH, cass_name);
         my_error(ER_INTERNAL_ERROR, MYF(0), se->error_str());
         res=1;
@@ -1782,7 +1782,7 @@ int ha_cassandra::read_cassandra_columns(bool unpack_pk)
         se->print_error("Unable to convert value for field `%s`"
                         " from Cassandra's data format. Sum of all names"
                         " length exceed limit of %lu",
-                        table->field[dyncol_field]->field_name,
+                        table->field[dyncol_field]->name().ptr(),
                         cass_name, (uint)MAX_TOTAL_NAME_LENGTH);
         my_error(ER_INTERNAL_ERROR, MYF(0), se->error_str());
         res=1;
@@ -1841,7 +1841,7 @@ int ha_cassandra::read_cassandra_columns(bool unpack_pk)
     se->get_read_rowkey(&cass_value, &cass_value_len);
     if (rowkey_converter->cassandra_to_mariadb(cass_value, cass_value_len))
     {
-      print_conversion_error((*field)->field_name, cass_value, cass_value_len);
+      print_conversion_error((*field)->name().ptr(), cass_value, cass_value_len);
       res=1;
       goto err;
     }
@@ -1953,7 +1953,7 @@ int ha_cassandra::write_row(uchar *buf)
   if (rowkey_converter->mariadb_to_cassandra(&cass_key, &cass_key_len))
   {
     my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
-             rowkey_converter->field->field_name, insert_lineno);
+             rowkey_converter->field->name().ptr(), insert_lineno);
     dbug_tmp_restore_column_map(table->read_set, old_map);
     DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
   }
@@ -1987,11 +1987,11 @@ int ha_cassandra::write_row(uchar *buf)
                                                     &cass_data_len))
       {
         my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
-                 field_converters[i]->field->field_name, insert_lineno);
+                 field_converters[i]->field->name().ptr(), insert_lineno);
         dbug_tmp_restore_column_map(table->read_set, old_map);
         DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
       }
-      se->add_insert_column(field_converters[i]->field->field_name, 0,
+      se->add_insert_column(field_converters[i]->field->name().ptr(), 0,
                             cass_data, cass_data_len);
     }
   }
@@ -2074,7 +2074,7 @@ int ha_cassandra::rnd_init(bool scan)
   {
     se->clear_read_columns();
     for (uint i= 1; i < table->s->fields; i++)
-      se->add_read_column(table->field[i]->field_name);
+      se->add_read_column(table->field[i]->name().ptr());
   }
 
   se->read_batch_size= THDVAR(table->in_use, rnd_batch_size);
@@ -2355,7 +2355,7 @@ class Column_name_enumerator_impl : public Column_name_enumerator
     if (idx == obj->table->s->fields)
       return NULL;
     else
-      return obj->table->field[idx++]->field_name;
+      return obj->table->field[idx++]->name().ptr();
   }
 };
 
@@ -2386,7 +2386,7 @@ int ha_cassandra::update_row(const uchar *old_data, uchar *new_data)
   if (rowkey_converter->mariadb_to_cassandra(&new_key, &new_key_len))
   {
     my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
-             rowkey_converter->field->field_name, insert_lineno);
+             rowkey_converter->field->name().ptr(), insert_lineno);
     dbug_tmp_restore_column_map(table->read_set, old_map);
     DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
   }
@@ -2449,11 +2449,11 @@ int ha_cassandra::update_row(const uchar *old_data, uchar *new_data)
       if (field_converters[i]->mariadb_to_cassandra(&cass_data, &cass_data_len))
       {
         my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
-                 field_converters[i]->field->field_name, insert_lineno);
+                 field_converters[i]->field->name().ptr(), insert_lineno);
         dbug_tmp_restore_column_map(table->read_set, old_map);
         DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
       }
-      se->add_insert_column(field_converters[i]->field->field_name, 0,
+      se->add_insert_column(field_converters[i]->field->name().ptr(), 0,
                             cass_data, cass_data_len);
     }
   }
diff --git a/storage/connect/ha_connect.cc b/storage/connect/ha_connect.cc
index 926a77f..bef1639 100644
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -1342,7 +1342,7 @@ void *ha_connect::GetColumnOption(PGLOBAL g, void *field, PCOLINFO pcf)
   pcf->Flags= 0;
 
   // Now get column information
-  pcf->Name= (char*)fp->field_name;
+  pcf->Name= (char*)fp->name().ptr();
 
   if (fop && fop->special) {
     pcf->Fieldfmt= (char*)fop->special;
@@ -1539,7 +1539,7 @@ PIXDEF ha_connect::GetIndexInfo(TABLE_SHARE *s)
 
     // Get the the key parts info
     for (int k= 0; (unsigned)k < kp.user_defined_key_parts; k++) {
-      pn= (char*)kp.key_part[k].field->field_name;
+      pn= (char*)kp.key_part[k].field->name().ptr();
       name= PlugDup(g, pn);
 
       // Allocate the key part description block
@@ -1655,7 +1655,7 @@ int ha_connect::GetColNameLen(Field *fp)
   if (fop && fop->special)
     n= strlen(fop->special) + 1;
   else
-    n= strlen(fp->field_name);
+    n= fp->name_length();
 
   return n;
 } // end of GetColNameLen
@@ -1667,7 +1667,7 @@ char *ha_connect::GetColName(Field *fp)
 {
   PFOS fop= GetFieldOptionStruct(fp);
 
-  return (fop && fop->special) ? fop->special : (char*)fp->field_name;
+  return (fop && fop->special) ? fop->special : (char*)fp->name().ptr();
 } // end of GetColName
 
 /****************************************************************************/
@@ -1682,7 +1682,7 @@ void ha_connect::AddColName(char *cp, Field *fp)
     // The prefix * mark the column as "special"
     strcat(strcpy(cp, "*"), strupr(fop->special));
   else
-    strcpy(cp, (char*)fp->field_name);
+    strcpy(cp, (char*)fp->name().ptr());
 
 } // end of AddColName
 #endif // 0
@@ -1768,12 +1768,12 @@ int ha_connect::OpenTable(PGLOBAL g, bool del)
 
     for (field= table->field; fp= *field; field++) {
       if (bitmap_is_set(map, fp->field_index)) {
-        n1+= (strlen(fp->field_name) + 1);
+        n1+= (fp->name().length() + 1);
         k1++;
         } // endif
 
       if (ump && bitmap_is_set(ump, fp->field_index)) {
-        n2+= (strlen(fp->field_name) + 1);
+        n2+= (fp->name().length() + 1);
         k2++;
         } // endif
 
@@ -1784,8 +1784,8 @@ int ha_connect::OpenTable(PGLOBAL g, bool del)
 
       for (field= table->field; fp= *field; field++)
         if (bitmap_is_set(map, fp->field_index)) {
-          strcpy(p, (char*)fp->field_name);
-          p+= (strlen(p) + 1);
+          strcpy(p, (char*)fp->name().ptr());
+          p+= (fp->name().length() + 1);
           } // endif used field
 
       *p= '\0';          // mark end of list
@@ -1796,7 +1796,7 @@ int ha_connect::OpenTable(PGLOBAL g, bool del)
 
       for (field= table->field; fp= *field; field++)
         if (bitmap_is_set(ump, fp->field_index)) {
-          strcpy(p, (char*)fp->field_name);
+          strcpy(p, (char*)fp->name().ptr());
 
           if (part_id && bitmap_is_set(part_id, fp->field_index)) {
             // Trying to update a column used for partitioning
@@ -1861,9 +1861,9 @@ bool ha_connect::CheckColumnList(PGLOBAL g)
   if ((rc= setjmp(g->jumper[++g->jump_level])) == 0) {
     for (field= table->field; fp= *field; field++)
       if (bitmap_is_set(map, fp->field_index)) {
-        if (!(colp= tdbp->ColDB(g, (PSZ)fp->field_name, 0))) {
+        if (!(colp= tdbp->ColDB(g, (PSZ)fp->name().ptr(), 0))) {
           sprintf(g->Message, "Column %s not found in %s", 
-                  fp->field_name, tdbp->GetName());
+                  fp->name().ptr(), tdbp->GetName());
           brc= true;
           goto fin;
           } // endif colp
@@ -1953,14 +1953,14 @@ int ha_connect::MakeRecord(char *buf)
       // This is a used field, fill the buffer with value
       for (colp= tdbp->GetColumns(); colp; colp= colp->GetNext())
         if ((!mrr || colp->GetKcol()) &&
-            !stricmp(colp->GetName(), (char*)fp->field_name))
+            !stricmp(colp->GetName(), (char*)fp->name().ptr()))
           break;
 
       if (!colp) {
         if (mrr)
           continue;
 
-        htrc("Column %s not found\n", fp->field_name);
+        htrc("Column %s not found\n", fp->name().ptr());
         dbug_tmp_restore_column_map(table->write_set, org_bitmap);
         DBUG_RETURN(HA_ERR_WRONG_IN_RECORD);
         } // endif colp
@@ -2016,7 +2016,7 @@ int ha_connect::MakeRecord(char *buf)
 
           sprintf(buf, "Out of range value %.140s for column '%s' at row %ld",
             value->GetCharString(val),
-            fp->field_name, 
+            fp->name().ptr(),
             thd->get_stmt_da()->current_row_for_warning());
 
           push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, buf);
@@ -2074,11 +2074,11 @@ int ha_connect::ScanRecord(PGLOBAL g, uchar *)
                              && tdbp->GetAmType() != TYPE_AM_ODBC) ||
         bitmap_is_set(table->write_set, fp->field_index)) {
       for (colp= tp->GetSetCols(); colp; colp= colp->GetNext())
-        if (!stricmp(colp->GetName(), fp->field_name))
+        if (!stricmp(colp->GetName(), fp->name().ptr()))
           break;
 
       if (!colp) {
-        htrc("Column %s not found\n", fp->field_name);
+        htrc("Column %s not found\n", fp->name().ptr());
         rc= HA_ERR_WRONG_IN_RECORD;
         goto err;
       } else
@@ -2270,10 +2270,10 @@ bool ha_connect::MakeKeyWhere(PGLOBAL g, PSTRG qry, OPVAL vop, char q,
 
 			if (q) {
 				oom|= qry->Append(q);
-				oom|= qry->Append((PSZ)fp->field_name);
+				oom|= qry->Append((PSZ)fp->name().ptr());
 				oom|= qry->Append(q);
 			}	else
-				oom|= qry->Append((PSZ)fp->field_name);
+				oom|= qry->Append((PSZ)fp->name().ptr());
 
 			switch (ranges[i]->flag) {
 			case HA_READ_KEY_EXACT:
@@ -2530,7 +2530,7 @@ PFIL ha_connect::CondFilter(PGLOBAL g, Item *cond)
           return NULL;
 
         if (pField->field->table != table ||
-            !(colp[i]= tdbp->ColDB(g, (PSZ)pField->field->field_name, 0)))
+            !(colp[i]= tdbp->ColDB(g, (PSZ)pField->field->name().ptr(), 0)))
           return NULL;  // Column does not belong to this table
 
 				// These types are not yet implemented (buggy)
@@ -2548,7 +2548,7 @@ PFIL ha_connect::CondFilter(PGLOBAL g, Item *cond)
 
         if (trace) {
           htrc("Field index=%d\n", pField->field->field_index);
-          htrc("Field name=%s\n", pField->field->field_name);
+          htrc("Field name=%s\n", pField->field->name().ptr());
           } // endif trace
 
       } else {
@@ -2760,11 +2760,11 @@ PCFIL ha_connect::CheckCond(PGLOBAL g, PCFIL filp, const Item *cond)
         } else if (tty == TYPE_AM_TBL)
           return NULL;
         else
-          fnm= pField->field->field_name;
+          fnm= pField->field->name().ptr();
 
         if (trace) {
           htrc("Field index=%d\n", pField->field->field_index);
-          htrc("Field name=%s\n", pField->field->field_name);
+          htrc("Field name=%s\n", pField->field->name().ptr());
           htrc("Field type=%d\n", pField->field->type());
           htrc("Field_type=%d\n", args[i]->field_type());
           } // endif trace
@@ -5991,7 +5991,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
 
     if (fp->flags & (BLOB_FLAG | ENUM_FLAG | SET_FLAG)) {
       sprintf(g->Message, "Unsupported type for column %s",
-                          fp->field_name);
+                          fp->name().ptr());
       my_message(ER_UNKNOWN_ERROR, g->Message, MYF(0));
       rc= HA_ERR_INTERNAL_ERROR;
       DBUG_RETURN(rc);
@@ -6027,11 +6027,11 @@ int ha_connect::create(const char *name, TABLE *table_arg,
       case MYSQL_TYPE_STRING:
         if (!fp->field_length) {
           sprintf(g->Message, "Unsupported 0 length for column %s",
-                              fp->field_name);
+                              fp->name().ptr());
           rc= HA_ERR_INTERNAL_ERROR;
           my_printf_error(ER_UNKNOWN_ERROR,
                           "Unsupported 0 length for column %s",
-                          MYF(0), fp->field_name);
+                          MYF(0), fp->name().ptr());
           DBUG_RETURN(rc);
           } // endif fp
 
@@ -6046,12 +6046,12 @@ int ha_connect::create(const char *name, TABLE *table_arg,
       case MYSQL_TYPE_BLOB:
       case MYSQL_TYPE_GEOMETRY:
       default:
-//      fprintf(stderr, "Unsupported type column %s\n", fp->field_name);
+//      fprintf(stderr, "Unsupported type column %s\n", fp->name().ptr());
         sprintf(g->Message, "Unsupported type for column %s",
-                            fp->field_name);
+                            fp->name().ptr());
         rc= HA_ERR_INTERNAL_ERROR;
         my_printf_error(ER_UNKNOWN_ERROR, "Unsupported type for column %s",
-                        MYF(0), fp->field_name);
+                        MYF(0), fp->name().ptr());
         DBUG_RETURN(rc);
         break;
       } // endswitch type
@@ -6066,12 +6066,12 @@ int ha_connect::create(const char *name, TABLE *table_arg,
     if (dbf) {
       bool b= false;
 
-      if ((b= strlen(fp->field_name) > 10))
+      if ((b= fp->name().length() > 10))
         sprintf(g->Message, "DBF: Column name '%s' is too long (max=10)",
-                            fp->field_name);
+                            fp->name().ptr());
       else if ((b= fp->field_length > 255))
         sprintf(g->Message, "DBF: Column length too big for '%s' (max=255)",
-                            fp->field_name);
+                            fp->name().ptr());
 
       if (b) {
         my_message(ER_UNKNOWN_ERROR, g->Message, MYF(0));
diff --git a/storage/connect/tabutil.cpp b/storage/connect/tabutil.cpp
index 331a7f4..f4f2ccf 100644
--- a/storage/connect/tabutil.cpp
+++ b/storage/connect/tabutil.cpp
@@ -171,7 +171,7 @@ PQRYRES TabColumns(PGLOBAL g, THD *thd, const char *db,
 
     // Get column name
     crp = qrp->Colresp;                    // Column_Name
-    colname = (char *)fp->field_name;
+    colname = (char *)fp->name().ptr();
     crp->Kdata->SetValue(colname, i);
 
     chset = (char *)fp->charset()->name;
diff --git a/storage/example/ha_example.cc b/storage/example/ha_example.cc
index 3a5b269..91f87e4 100644
--- a/storage/example/ha_example.cc
+++ b/storage/example/ha_example.cc
@@ -896,7 +896,7 @@ int ha_example::create(const char *name, TABLE *table_arg,
     ha_field_option_struct *field_options= (*field)->option_struct;
     DBUG_ASSERT(field_options);
     DBUG_PRINT("info", ("field: %s  complex: '%-.64s'",
-                         (*field)->field_name,
+                         (*field)->name().ptr(),
                          (field_options->complex_param_to_parse_it_in_engine ?
                           field_options->complex_param_to_parse_it_in_engine :
                           "<NULL>")));
@@ -975,7 +975,7 @@ ha_example::check_if_supported_inplace_alter(TABLE* altered_table,
       {
         push_warning_printf(ha_thd(), Sql_condition::WARN_LEVEL_NOTE,
                             ER_UNKNOWN_ERROR, "EXAMPLE DEBUG: Field %`s COMPLEX '%s' -> '%s'",
-                            table->s->field[i]->field_name,
+                            table->s->field[i]->name().ptr(),
                             f_old->complex_param_to_parse_it_in_engine,
                             f_new->complex_param_to_parse_it_in_engine);
       }
diff --git a/storage/federated/ha_federated.cc b/storage/federated/ha_federated.cc
index e75c3ca..20143c49 100644
--- a/storage/federated/ha_federated.cc
+++ b/storage/federated/ha_federated.cc
@@ -579,6 +579,12 @@ static bool append_ident(String *string, const char *name, size_t length,
 }
 
 
+bool append_ident(String *string, const Name &name, const char quote)
+{
+  return append_ident(string, name.ptr(), name.length(), quote);
+}
+
+
 static int parse_url_error(FEDERATED_SHARE *share, TABLE *table, int error_num)
 {
   char buf[FEDERATED_QUERY_BUFFER_SIZE];
@@ -973,8 +979,7 @@ uint ha_federated::convert_row_to_internal_format(uchar *record,
 static bool emit_key_part_name(String *to, KEY_PART_INFO *part)
 {
   DBUG_ENTER("emit_key_part_name");
-  if (append_ident(to, part->field->field_name, 
-                   strlen(part->field->field_name), ident_quote_char))
+  if (append_ident(to, part->field->name(), ident_quote_char))
     DBUG_RETURN(1);                           // Out of memory
   DBUG_RETURN(0);
 }
@@ -1535,8 +1540,7 @@ static FEDERATED_SHARE *get_share(const char *table_name, TABLE *table)
     query.append(STRING_WITH_LEN("SELECT "));
     for (field= table->field; *field; field++)
     {
-      append_ident(&query, (*field)->field_name, 
-                   strlen((*field)->field_name), ident_quote_char);
+      append_ident(&query, (*field)->name(), ident_quote_char);
       query.append(STRING_WITH_LEN(", "));
     }
     /* chops off trailing comma */
@@ -1767,8 +1771,7 @@ bool ha_federated::append_stmt_insert(String *query)
     if (bitmap_is_set(table->write_set, (*field)->field_index))
     {
       /* append the field name */
-      append_ident(&insert_string, (*field)->field_name, 
-                   strlen((*field)->field_name), ident_quote_char);
+      append_ident(&insert_string, (*field)->name(), ident_quote_char);
 
       /* append commas between both fields and fieldnames */
       /*
@@ -2181,9 +2184,7 @@ int ha_federated::update_row(const uchar *old_data, uchar *new_data)
   {
     if (bitmap_is_set(table->write_set, (*field)->field_index))
     {
-      size_t field_name_length= strlen((*field)->field_name);
-      append_ident(&update_string, (*field)->field_name, field_name_length,
-                   ident_quote_char);
+      append_ident(&update_string, (*field)->name(), ident_quote_char);
       update_string.append(STRING_WITH_LEN(" = "));
 
       if ((*field)->is_null())
@@ -2207,9 +2208,7 @@ int ha_federated::update_row(const uchar *old_data, uchar *new_data)
 
     if (bitmap_is_set(table->read_set, (*field)->field_index))
     {
-      size_t field_name_length= strlen((*field)->field_name);
-      append_ident(&where_string, (*field)->field_name, field_name_length,
-                   ident_quote_char);
+      append_ident(&where_string, (*field)->name(), ident_quote_char);
       if (field_in_record_is_null(table, *field, (char*) old_data))
         where_string.append(STRING_WITH_LEN(" IS NULL "));
       else
@@ -2290,8 +2289,7 @@ int ha_federated::delete_row(const uchar *buf)
     found++;
     if (bitmap_is_set(table->read_set, cur_field->field_index))
     {
-      append_ident(&delete_string, (*field)->field_name,
-                   strlen((*field)->field_name), ident_quote_char);
+      append_ident(&delete_string, (*field)->name(), ident_quote_char);
       data_string.length(0);
       if (cur_field->is_null())
       {
diff --git a/storage/federatedx/ha_federatedx.cc b/storage/federatedx/ha_federatedx.cc
index 28b9b33..6566721 100644
--- a/storage/federatedx/ha_federatedx.cc
+++ b/storage/federatedx/ha_federatedx.cc
@@ -518,6 +518,12 @@ bool append_ident(String *string, const char *name, uint length,
 }
 
 
+bool append_ident(String *string, const Name &name, const char quote)
+{
+  return append_ident(string, name.ptr(), name.length(), quote);
+}
+
+
 static int parse_url_error(FEDERATEDX_SHARE *share, TABLE_SHARE *table_s,
                            int error_num)
 {
@@ -894,8 +900,7 @@ uint ha_federatedx::convert_row_to_internal_format(uchar *record,
 static bool emit_key_part_name(String *to, KEY_PART_INFO *part)
 {
   DBUG_ENTER("emit_key_part_name");
-  if (append_ident(to, part->field->field_name, 
-                   strlen(part->field->field_name), ident_quote_char))
+  if (append_ident(to, part->field->name(), ident_quote_char))
     DBUG_RETURN(1);                           // Out of memory
   DBUG_RETURN(0);
 }
@@ -1597,8 +1602,7 @@ static FEDERATEDX_SHARE *get_share(const char *table_name, TABLE *table)
     query.append(STRING_WITH_LEN("SELECT "));
     for (field= table->field; *field; field++)
     {
-      append_ident(&query, (*field)->field_name, 
-                   strlen((*field)->field_name), ident_quote_char);
+      append_ident(&query, (*field)->name(), ident_quote_char);
       query.append(STRING_WITH_LEN(", "));
     }
     /* chops off trailing comma */
@@ -1911,8 +1915,7 @@ bool ha_federatedx::append_stmt_insert(String *query)
     if (bitmap_is_set(table->write_set, (*field)->field_index))
     {
       /* append the field name */
-      append_ident(&insert_string, (*field)->field_name, 
-                   strlen((*field)->field_name), ident_quote_char);
+      append_ident(&insert_string, (*field)->name(), ident_quote_char);
 
       /* append commas between both fields and fieldnames */
       /*
@@ -2339,9 +2342,7 @@ int ha_federatedx::update_row(const uchar *old_data, uchar *new_data)
   {
     if (bitmap_is_set(table->write_set, (*field)->field_index))
     {
-      uint field_name_length= strlen((*field)->field_name);
-      append_ident(&update_string, (*field)->field_name, field_name_length,
-                   ident_quote_char);
+      append_ident(&update_string, (*field)->name(), ident_quote_char);
       update_string.append(STRING_WITH_LEN(" = "));
 
       if ((*field)->is_null())
@@ -2365,9 +2366,7 @@ int ha_federatedx::update_row(const uchar *old_data, uchar *new_data)
 
     if (bitmap_is_set(table->read_set, (*field)->field_index))
     {
-      uint field_name_length= strlen((*field)->field_name);
-      append_ident(&where_string, (*field)->field_name, field_name_length,
-                   ident_quote_char);
+      append_ident(&where_string, (*field)->name(), ident_quote_char);
       if (field_in_record_is_null(table, *field, (char*) old_data))
         where_string.append(STRING_WITH_LEN(" IS NULL "));
       else
@@ -2452,8 +2451,7 @@ int ha_federatedx::delete_row(const uchar *buf)
     found++;
     if (bitmap_is_set(table->read_set, cur_field->field_index))
     {
-      append_ident(&delete_string, (*field)->field_name,
-                   strlen((*field)->field_name), ident_quote_char);
+      append_ident(&delete_string, (*field)->name(), ident_quote_char);
       data_string.length(0);
       if (cur_field->is_null())
       {
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index daa649a..cbdda04 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -5384,7 +5384,7 @@ ha_innobase::innobase_initialize_autoinc()
 
 		ut_a(prebuilt->trx == thd_to_trx(user_thd));
 
-		col_name = field->field_name;
+		col_name = field->name().ptr();
 		index = innobase_get_index(table->s->next_number_index);
 
 		/* Execute SELECT MAX(col_name) FROM TABLE; */
@@ -8212,7 +8212,7 @@ calc_row_difference(
 		if (field_mysql_type == MYSQL_TYPE_LONGLONG
 		    && prebuilt->table->fts
 		    && innobase_strcasecmp(
-			field->field_name, FTS_DOC_ID_COL_NAME) == 0) {
+			field->name().ptr(), FTS_DOC_ID_COL_NAME) == 0) {
 			doc_id = (doc_id_t) mach_read_from_n_little_endian(
 				n_ptr, 8);
 			if (doc_id == 0) {
@@ -10360,7 +10360,7 @@ create_table_check_doc_id_col(
 
 		col_len = field->pack_length();
 
-		if (innobase_strcasecmp(field->field_name,
+		if (innobase_strcasecmp(field->name().ptr(),
 					FTS_DOC_ID_COL_NAME) == 0) {
 
 			/* Note the name is case sensitive due to
@@ -10368,7 +10368,7 @@ create_table_check_doc_id_col(
 			if (col_type == DATA_INT
 			    && !field->real_maybe_null()
 			    && col_len == sizeof(doc_id_t)
-			    && (strcmp(field->field_name,
+			    && (strcmp(field->name().ptr(),
 				      FTS_DOC_ID_COL_NAME) == 0)) {
 				*doc_id_col = i;
 			} else {
@@ -10380,7 +10380,7 @@ create_table_check_doc_id_col(
 					"of BIGINT NOT NULL type, and named "
 					"in all capitalized characters");
 				my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-					 field->field_name);
+					 field->name().ptr());
 				*doc_id_col = ULINT_UNDEFINED;
 			}
 
@@ -10525,7 +10525,7 @@ create_table_def(
 				"column type and try to re-create "
 				"the table with an appropriate "
 				"column type.",
-				table->name, field->field_name);
+				table->name, field->name().ptr());
 			goto err_col;
 		}
 
@@ -10575,9 +10575,9 @@ create_table_def(
 
 		/* First check whether the column to be added has a
 		system reserved name. */
-		if (dict_col_name_is_reserved(field->field_name)){
+		if (dict_col_name_is_reserved(field->name().ptr())){
 			my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-				 field->field_name);
+				 field->name().ptr());
 err_col:
 			dict_mem_table_free(table);
 			mem_heap_free(heap);
@@ -10588,7 +10588,7 @@ create_table_def(
 		}
 
 		dict_mem_table_add_col(table, heap,
-			field->field_name,
+			field->name().ptr(),
 			col_type,
 			dtype_form_prtype(
 				(ulint) field->type()
@@ -10666,7 +10666,7 @@ create_index(
 		for (ulint i = 0; i < key->user_defined_key_parts; i++) {
 			KEY_PART_INFO*	key_part = key->key_part + i;
 			dict_mem_index_add_field(
-				index, key_part->field->field_name, 0);
+				index, key_part->field->name().ptr(), 0);
 		}
 
 		DBUG_RETURN(convert_error_code_to_mysql(
@@ -10717,8 +10717,8 @@ create_index(
 			field = form->field[j];
 
 			if (0 == innobase_strcasecmp(
-				    field->field_name,
-				    key_part->field->field_name)) {
+				    field->name().ptr(),
+				    key_part->field->name().ptr())) {
 				/* Found the corresponding column */
 
 				goto found;
@@ -10751,7 +10751,7 @@ create_index(
 					"inappropriate data type. Table "
 					"name %s, column name %s.",
 					table_name,
-					key_part->field->field_name);
+					key_part->field->name().ptr());
 
 				prefix_len = 0;
 			}
@@ -10762,7 +10762,7 @@ create_index(
 		field_lengths[i] = key_part->length;
 
 		dict_mem_index_add_field(
-			index, key_part->field->field_name, prefix_len);
+			index, key_part->field->name().ptr(), prefix_len);
 	}
 
 	ut_ad(key->flags & HA_FULLTEXT || !(index->type & DICT_FTS));
@@ -11240,7 +11240,7 @@ innobase_table_flags(
 		/* Do a pre-check on FTS DOC ID index */
 		if (!(key->flags & HA_NOSAME)
 		    || strcmp(key->name, FTS_DOC_ID_INDEX_NAME)
-		    || strcmp(key->key_part[0].field->field_name,
+		    || strcmp(key->key_part[0].field->name().ptr(),
 			      FTS_DOC_ID_COL_NAME)) {
 			fts_doc_id_index_bad = key->name;
 		}
diff --git a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc
index ae082b2..3b1362a 100644
--- a/storage/innobase/handler/handler0alter.cc
+++ b/storage/innobase/handler/handler0alter.cc
@@ -479,7 +479,7 @@ ha_innobase::check_if_supported_inplace_alter(
 			    && innobase_fulltext_exist(altered_table)
 			    && !my_strcasecmp(
 				    system_charset_info,
-				    key_part->field->field_name,
+				    key_part->field->name().ptr(),
 				    FTS_DOC_ID_COL_NAME)) {
 				ha_alter_info->unsupported_reason = innobase_get_err_msg(
 					ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS);
@@ -536,7 +536,7 @@ ha_innobase::check_if_supported_inplace_alter(
 
 			if (!my_strcasecmp(
 				    system_charset_info,
-				    (*fp)->field_name,
+				    (*fp)->name().ptr(),
 				    FTS_DOC_ID_COL_NAME)) {
 				ha_alter_info->unsupported_reason = innobase_get_err_msg(
 					ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS);
@@ -805,7 +805,7 @@ innobase_find_equiv_index(
 			}
 
 			if (innobase_strcasecmp(col_names[j],
-						key_part.field->field_name)) {
+						key_part.field->name().ptr())) {
 				/* Name mismatch */
 				goto no_match;
 			}
@@ -928,7 +928,7 @@ innobase_get_foreign_key_info(
 			/* Get all the foreign key column info for the
 			current table */
 			while ((column = key_part_iterator++)) {
-				column_names[i] = column->field_name.str;
+				column_names[i] = column->name().ptr();
 				ut_ad(i < MAX_NUM_FK_COLUMNS);
 				i++;
 			}
@@ -1029,7 +1029,7 @@ innobase_get_foreign_key_info(
 
 			while ((column = key_part_iterator++)) {
 				referenced_column_names[i] =
-					column->field_name.str;
+					column->name().ptr();
 				ut_ad(i < MAX_NUM_FK_COLUMNS);
 				i++;
 			}
@@ -1463,7 +1463,7 @@ innobase_check_index_keys(
 				}
 
 				my_error(ER_WRONG_KEY_COLUMN, MYF(0), "InnoDB",
-					 field->field_name);
+					 field->name().ptr());
 				return(ER_WRONG_KEY_COLUMN);
 			}
 
@@ -1479,7 +1479,7 @@ innobase_check_index_keys(
 				}
 
 				my_error(ER_WRONG_KEY_COLUMN, MYF(0), "InnoDB",
-					 field->field_name);
+					 field->name().ptr());
 				return(ER_WRONG_KEY_COLUMN);
 			}
 		}
@@ -1518,7 +1518,7 @@ innobase_create_index_field_def(
 	ut_a(field);
 
 	index_field->col_no = key_part->fieldnr;
-	index_field->col_name = altered_table ? field->field_name : fields[key_part->fieldnr]->field_name;
+	index_field->col_name = altered_table ? field->name().ptr() : fields[key_part->fieldnr]->name().ptr();
 
 	col_type = get_innobase_type_from_mysql_type(&is_unsigned, field);
 
@@ -1641,19 +1641,19 @@ innobase_fts_check_doc_id_col(
                                  stored_in_db()))
                           sql_idx++;
 		if (my_strcasecmp(system_charset_info,
-				  field->field_name, FTS_DOC_ID_COL_NAME)) {
+				  field->name().ptr(), FTS_DOC_ID_COL_NAME)) {
 			continue;
 		}
 
-		if (strcmp(field->field_name, FTS_DOC_ID_COL_NAME)) {
+		if (strcmp(field->name().ptr(), FTS_DOC_ID_COL_NAME)) {
 			my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-				 field->field_name);
+				 field->name().ptr());
 		} else if (field->type() != MYSQL_TYPE_LONGLONG
 			   || field->pack_length() != 8
 			   || field->real_maybe_null()
 			   || !(field->flags & UNSIGNED_FLAG)) {
 			my_error(ER_INNODB_FT_WRONG_DOCID_COLUMN, MYF(0),
-				 field->field_name);
+				 field->name().ptr());
 		} else {
 			*fts_doc_col_no = i;
 		}
@@ -1724,7 +1724,7 @@ innobase_fts_check_doc_id_index(
 			if ((key.flags & HA_NOSAME)
 			    && key.user_defined_key_parts == 1
 			    && !strcmp(key.name, FTS_DOC_ID_INDEX_NAME)
-			    && !strcmp(key.key_part[0].field->field_name,
+			    && !strcmp(key.key_part[0].field->name().ptr(),
 				       FTS_DOC_ID_COL_NAME)) {
 				if (fts_doc_col_no) {
 					*fts_doc_col_no = ULINT_UNDEFINED;
@@ -1803,7 +1803,7 @@ innobase_fts_check_doc_id_index_in_def(
 		if (!(key->flags & HA_NOSAME)
 		    || key->user_defined_key_parts != 1
 		    || strcmp(key->name, FTS_DOC_ID_INDEX_NAME)
-		    || strcmp(key->key_part[0].field->field_name,
+		    || strcmp(key->key_part[0].field->name().ptr(),
 			      FTS_DOC_ID_COL_NAME)) {
 			return(FTS_INCORRECT_DOC_ID_INDEX);
 		}
@@ -2415,7 +2415,7 @@ innobase_check_foreigns(
 		if (!new_field || (new_field->flags & NOT_NULL_FLAG)) {
 			if (innobase_check_foreigns_low(
 				    user_table, drop_fk, n_drop_fk,
-				    (*fp)->field_name, !new_field)) {
+				    (*fp)->name().ptr(), !new_field)) {
 				return(true);
 			}
 		}
@@ -2642,7 +2642,7 @@ innobase_get_col_names(
 
 		for (uint old_i = 0; table->field[old_i]; old_i++) {
 			if (new_field->field == table->field[old_i]) {
-				cols[old_i] = new_field->field_name;
+				cols[old_i] = new_field->name().ptr();
 				break;
 			}
 		}
@@ -2920,7 +2920,7 @@ prepare_inplace_alter_table_dict(
 					dict_mem_table_free(
 						ctx->new_table);
 					my_error(ER_WRONG_KEY_COLUMN, MYF(0),
-						 field->field_name);
+						 field->name().ptr());
 					goto new_clustered_failed;
 				}
 			} else {
@@ -2947,16 +2947,16 @@ prepare_inplace_alter_table_dict(
 				}
 			}
 
-			if (dict_col_name_is_reserved(field->field_name)) {
+			if (dict_col_name_is_reserved(field->name().ptr())) {
 				dict_mem_table_free(ctx->new_table);
 				my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-					 field->field_name);
+					 field->name().ptr());
 				goto new_clustered_failed;
 			}
 
 			dict_mem_table_add_col(
 				ctx->new_table, ctx->heap,
-				field->field_name,
+				field->name().ptr(),
 				col_type,
 				dtype_form_prtype(field_type, charset_no),
 				col_len);
@@ -3546,7 +3546,7 @@ ha_innobase::prepare_inplace_alter_table(
 			cf_it.rewind();
 			while (Create_field* cf = cf_it++) {
 				if (cf->field == *fp) {
-					name = cf->field_name;
+					name = cf->name().ptr();
 					goto check_if_ok_to_rename;
 				}
 			}
@@ -3556,7 +3556,7 @@ ha_innobase::prepare_inplace_alter_table(
 			/* Prohibit renaming a column from FTS_DOC_ID
 			if full-text indexes exist. */
 			if (!my_strcasecmp(system_charset_info,
-					   (*fp)->field_name,
+					   (*fp)->name().ptr(),
 					   FTS_DOC_ID_COL_NAME)
 			    && innobase_fulltext_exist(altered_table)) {
 				my_error(ER_INNODB_FT_WRONG_DOCID_COLUMN,
@@ -4697,8 +4697,8 @@ innobase_rename_columns_try(
 			if (cf->field == *fp) {
 				if (innobase_rename_column_try(
 					    ctx->old_table, trx, table_name, i,
-					    cf->field->field_name,
-					    cf->field_name,
+					    cf->field->name().ptr(),
+					    cf->name().ptr(),
 					    ctx->need_rebuild())) {
 					return(true);
 				}
@@ -4745,8 +4745,8 @@ innobase_rename_columns_cache(
 		while (Create_field* cf = cf_it++) {
 			if (cf->field == *fp) {
 				dict_mem_table_col_rename(user_table, i,
-							  cf->field->field_name,
-							  cf->field_name);
+							  cf->field->name().ptr(),
+							  cf->name().ptr());
 				goto processed_field;
 			}
 		}
@@ -4806,7 +4806,7 @@ commit_get_autoinc(
 		dict_table_autoinc_lock(ctx->old_table);
 
 		err = row_search_max_autoinc(
-			index, autoinc_field->field_name, &max_value_table);
+			index, autoinc_field->name().ptr(), &max_value_table);
 
 		if (err != DB_SUCCESS) {
 			ut_ad(0);
diff --git a/storage/mroonga/ha_mroonga.cpp b/storage/mroonga/ha_mroonga.cpp
index 9266d2d..c2be5aa 100644
--- a/storage/mroonga/ha_mroonga.cpp
+++ b/storage/mroonga/ha_mroonga.cpp
@@ -3213,7 +3213,7 @@ int ha_mroonga::storage_create(const char *name, TABLE *table,
     int key_parts = KEY_N_KEY_PARTS(key_info);
     if (key_parts == 1) {
       Field *pkey_field = key_info->key_part[0].field;
-      const char *column_name = pkey_field->field_name;
+      const char *column_name = pkey_field->name().ptr();
       is_id = (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0);
 
       grn_builtin_type gtype = mrn_grn_type_from_field(ctx, pkey_field, false);
@@ -3307,8 +3307,8 @@ int ha_mroonga::storage_create(const char *name, TABLE *table,
   uint n_columns = table->s->fields;
   for (uint i = 0; i < n_columns; i++) {
     Field *field = table->s->field[i];
-    const char *column_name = field->field_name;
-    int column_name_size = strlen(column_name);
+    const char *column_name = field->name().ptr();
+    int column_name_size = field->name().length();
 
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
       continue;
@@ -3374,7 +3374,7 @@ int ha_mroonga::storage_create_validate_pseudo_column(TABLE *table)
   n_columns = table->s->fields;
   for (i = 0; i < n_columns; i++) {
     Field *field = table->s->field[i];
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
       switch (field->type()) {
       case MYSQL_TYPE_TINY :
@@ -3422,18 +3422,18 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
     }
     List_iterator<Key_part_spec> key_part_col_iterator(key->columns);
     Key_part_spec *key_part_col = key_part_col_iterator++;
-    LEX_STRING field_name = key_part_col->field_name;
-    DBUG_PRINT("info", ("mroonga: field_name=%s", field_name.str));
-    DBUG_PRINT("info", ("mroonga: field->field_name=%s", field->field_name));
-    if (strcmp(field->field_name, field_name.str))
+    Name field_name= key_part_col->name();
+    DBUG_PRINT("info", ("mroonga: field_name.ptr()=%s", field_name.ptr()));
+    DBUG_PRINT("info", ("mroonga: field->name().ptr()=%s", field->name().ptr()));
+    if (strcmp(field->name().ptr(), field_name.ptr()))
     {
       continue;
     }
     Foreign_key *fk = (Foreign_key *) key;
     List_iterator<Key_part_spec> key_part_ref_col_iterator(fk->ref_columns);
     Key_part_spec *key_part_ref_col = key_part_ref_col_iterator++;
-    LEX_STRING ref_field_name = key_part_ref_col->field_name;
-    DBUG_PRINT("info", ("mroonga: ref_field_name=%s", ref_field_name.str));
+    Name ref_field_name = key_part_ref_col->name();
+    DBUG_PRINT("info", ("mroonga: ref_field_name.ptr()=%s", ref_field_name.ptr()));
 #ifdef MRN_FOREIGN_KEY_USE_CONST_STRING
     LEX_CSTRING ref_db_name = fk->ref_db;
 #else
@@ -3537,7 +3537,7 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
       DBUG_RETURN(false);
     }
     Field *ref_field = &ref_key_info->key_part->field[0];
-    if (strcmp(ref_field->field_name, ref_field_name.str)) {
+    if (strcmp(ref_field->name().ptr(), ref_field_name.ptr())) {
       mrn_open_mutex_lock(table->s);
       mrn_free_tmp_table_share(tmp_ref_table_share);
       mrn_open_mutex_unlock(table->s);
@@ -3546,7 +3546,7 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
       char err_msg[MRN_BUFFER_SIZE];
       sprintf(err_msg,
               "refference column [%s.%s.%s] is not used for primary key",
-              table->s->db.str, ref_table_name.str, ref_field_name.str);
+              table->s->db.str, ref_table_name.str, ref_field_name.ptr());
       my_message(error, err_msg, MYF(0));
       DBUG_RETURN(false);
     }
@@ -3554,8 +3554,8 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
     mrn_free_tmp_table_share(tmp_ref_table_share);
     mrn_open_mutex_unlock(table->s);
     grn_obj_flags col_flags = GRN_OBJ_PERSISTENT;
-    column = grn_column_create(ctx, table_obj, field->field_name,
-                               strlen(field->field_name),
+    column = grn_column_create(ctx, table_obj, field->name().ptr(),
+                               field->name().length(),
                                NULL, col_flags, grn_table_ref);
     if (ctx->rc) {
       grn_obj_unlink(ctx, grn_table_ref);
@@ -3564,7 +3564,7 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
       DBUG_RETURN(false);
     }
 
-    mrn::IndexColumnName index_column_name(grn_table_name, field->field_name);
+    mrn::IndexColumnName index_column_name(grn_table_name, field->name().ptr());
     grn_obj_flags ref_col_flags = GRN_OBJ_COLUMN_INDEX | GRN_OBJ_PERSISTENT;
     column_ref = grn_column_create(ctx, grn_table_ref,
                                    index_column_name.c_str(),
@@ -3618,7 +3618,7 @@ int ha_mroonga::storage_create_validate_index(TABLE *table)
       continue;
     }
     Field *field = key_info->key_part[0].field;
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
       if (key_info->algorithm == HA_KEY_ALG_HASH) {
         continue; // hash index is ok
@@ -3755,8 +3755,8 @@ int ha_mroonga::storage_create_index(TABLE *table, const char *grn_table_name,
   bool is_multiple_column_index = KEY_N_KEY_PARTS(key_info) > 1;
   if (!is_multiple_column_index) {
     Field *field = key_info->key_part[0].field;
-    column_name = field->field_name;
-    column_name_size = strlen(column_name);
+    column_name = field->name().ptr();
+    column_name_size = field->name().length();
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
       // skipping _id virtual column
       DBUG_RETURN(0);
@@ -3813,8 +3813,8 @@ int ha_mroonga::storage_create_index(TABLE *table, const char *grn_table_name,
       int j, n_key_parts = KEY_N_KEY_PARTS(key_info);
       for (j = 0; j < n_key_parts; j++) {
         Field *field = key_info->key_part[j].field;
-        const char *column_name = field->field_name;
-        int column_name_size = strlen(column_name);
+        const char *column_name = field->name().ptr();
+        int column_name_size = field->name().length();
         grn_obj *source_column = grn_obj_column(ctx, grn_table,
                                                 column_name, column_name_size);
         grn_id source_id = grn_obj_id(ctx, source_column);
@@ -4113,8 +4113,8 @@ int ha_mroonga::wrapper_open_indexes(const char *name)
       /* just for backward compatibility before 1.0. */
       Field *field = key_info->key_part[0].field;
       grn_index_columns[i] = grn_obj_column(ctx, grn_index_tables[i],
-                                            field->field_name,
-                                            strlen(field->field_name));
+                                            field->name().ptr(),
+                                            field->name().length());
     }
 
     if (ctx->rc) {
@@ -4291,8 +4291,8 @@ int ha_mroonga::storage_open_columns(void)
 
   for (int i = 0; i < n_columns; i++) {
     Field *field = table->field[i];
-    const char *column_name = field->field_name;
-    int column_name_size = strlen(column_name);
+    const char *column_name = field->name().ptr();
+    int column_name_size = field->name().length();
     if (table_share->blob_fields)
     {
       blob_buffers[i].set_charset(field->charset());
@@ -4406,8 +4406,8 @@ int ha_mroonga::storage_open_indexes(const char *name)
           /* just for backward compatibility before 1.0. */
           Field *field = key_info->key_part[0].field;
           grn_index_columns[i] = grn_obj_column(ctx, grn_index_tables[i],
-                                                field->field_name,
-                                                strlen(field->field_name));
+                                                field->name().ptr(),
+                                                field->name().length());
         }
       }
     }
@@ -5398,7 +5398,7 @@ int ha_mroonga::storage_write_row(uchar *buf)
   mrn::DebugColumnAccess debug_column_access(table, table->read_set);
   for (i = 0; i < n_columns; i++) {
     Field *field = table->field[i];
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
 
     if (field->is_null()) continue;
 
@@ -5492,7 +5492,7 @@ int ha_mroonga::storage_write_row(uchar *buf)
   GRN_VOID_INIT(&colbuf);
   for (i = 0; i < n_columns; i++) {
     Field *field = table->field[i];
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
 
     if (field->is_null())
       continue;
@@ -6004,7 +6004,7 @@ int ha_mroonga::storage_update_row(const uchar *old_data, uchar *new_data)
 
   for (i = 0; i < n_columns; i++) {
     Field *field = table->field[i];
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
 
     if (bitmap_is_set(table->write_set, field->field_index)) {
       if (field->is_null()) continue;
@@ -6041,7 +6041,7 @@ int ha_mroonga::storage_update_row(const uchar *old_data, uchar *new_data)
   GRN_VOID_INIT(&colbuf);
   for (i = 0; i < n_columns; i++) {
     Field *field = table->field[i];
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
     if (bitmap_is_set(table->write_set, field->field_index)) {
       mrn::DebugColumnAccess debug_column_access(table, table->read_set);
       DBUG_PRINT("info", ("mroonga: update column %d(%d)",i,field->field_index));
@@ -6062,7 +6062,7 @@ int ha_mroonga::storage_update_row(const uchar *old_data, uchar *new_data)
         bool have_pkey = false;
         for (j = 0; j < KEY_N_KEY_PARTS(pkey_info); j++) {
           Field *pkey_field = pkey_info->key_part[j].field;
-          if (strcmp(pkey_field->field_name, column_name) == 0) {
+          if (strcmp(pkey_field->name().ptr(), column_name) == 0) {
             if (!replacing_) {
               char message[MRN_BUFFER_SIZE];
               snprintf(message, MRN_BUFFER_SIZE,
@@ -6731,7 +6731,7 @@ ha_rows ha_mroonga::storage_records_in_range(uint key_nr, key_range *range_min,
     DBUG_RETURN(row_count);
   } else {
     Field *field = key_info->key_part[0].field;
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
     mrn_change_encoding(ctx, field->charset());
 
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
@@ -7023,7 +7023,7 @@ int ha_mroonga::storage_index_read_map(uchar *buf, const uchar *key,
       DBUG_RETURN(error);
 
     if (find_flag == HA_READ_KEY_EXACT) {
-      const char *column_name = field->field_name;
+      const char *column_name = field->name().ptr();
 
       key_min = key_min_entity;
       key_max = key_min_entity;
@@ -7575,7 +7575,7 @@ int ha_mroonga::storage_read_range_first(const key_range *start_key,
     }
   } else {
     Field *field = key_info->key_part[0].field;
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
     error = mrn_change_encoding(ctx, field->charset());
     if (error)
       DBUG_RETURN(error);
@@ -9105,7 +9105,7 @@ grn_obj *ha_mroonga::find_column_type(Field *field, MRN_SHARE *mrn_share, int i,
       char error_message[MRN_BUFFER_SIZE];
       snprintf(error_message, MRN_BUFFER_SIZE,
                "unknown custom Groonga type name for <%s> column: <%s>",
-               field->field_name, grn_type_name);
+               field->name().ptr(), grn_type_name);
       GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
       my_message(error_code, error_message, MYF(0));
 
@@ -9783,8 +9783,8 @@ bool ha_mroonga::is_primary_key_field(Field *field) const
     DBUG_RETURN(false);
   }
 
-  if (strcmp(field->field_name,
-             key_info->key_part[0].field->field_name) == 0) {
+  if (strcmp(field->name().ptr(),
+             key_info->key_part[0].field->name().ptr()) == 0) {
     DBUG_RETURN(true);
   } else {
     DBUG_RETURN(false);
@@ -9887,8 +9887,8 @@ void ha_mroonga::check_fast_order_limit(grn_table_sort_key **sort_keys,
       if (item->type() == Item::FIELD_ITEM)
       {
         Field *field = static_cast<Item_field *>(item)->field;
-        const char *column_name = field->field_name;
-        int column_name_size = strlen(column_name);
+        const char *column_name = field->name().ptr();
+        int column_name_size = field->name().length();
 
         if (should_normalize(field))
         {
@@ -10981,11 +10981,11 @@ void ha_mroonga::storage_store_fields(uchar *buf, grn_id record_id)
 
     if (bitmap_is_set(table->read_set, field->field_index) ||
         bitmap_is_set(table->write_set, field->field_index)) {
-      const char *column_name = field->field_name;
+      const char *column_name = field->name().ptr();
 
       if (ignoring_no_key_columns) {
         KEY *key_info = &(table->s->key_info[active_index]);
-        if (strcmp(key_info->key_part[0].field->field_name, column_name)) {
+        if (strcmp(key_info->key_part[0].field->name().ptr(), column_name)) {
           continue;
         }
       }
@@ -10998,7 +10998,7 @@ void ha_mroonga::storage_store_fields(uchar *buf, grn_id record_id)
         field->set_notnull();
         field->store((int)record_id);
       } else if (primary_key_field &&
-                 strcmp(primary_key_field->field_name, column_name) == 0) {
+                 strcmp(primary_key_field->name().ptr(), column_name) == 0) {
         // for primary key column
         storage_store_field_column(field, true, i, record_id);
       } else {
@@ -11461,7 +11461,7 @@ int ha_mroonga::storage_encode_key_set(Field *field, const uchar *key,
   MRN_DBUG_ENTER_METHOD();
   int error = 0;
   Field_set unpacker((uchar *)key, field->field_length, (uchar *)(key - 1),
-                     field->null_bit, field->unireg_check, field->field_name,
+                     field->null_bit, field->unireg_check, field->name(),
                      field->pack_length(),
                      static_cast<Field_set*>(field)->typelib,
                      static_cast<Field_set*>(field)->charset());
@@ -12896,7 +12896,7 @@ int ha_mroonga::storage_rename_foreign_key(MRN_SHARE *tmp_share,
   MRN_DBUG_ENTER_METHOD();
   for (i = 0; i < n_columns; ++i) {
     Field *field = tmp_table_share->field[i];
-    const char *column_name = field->field_name;
+    const char *column_name = field->name().ptr();
     uint column_name_size = strlen(column_name);
 
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
@@ -14563,8 +14563,8 @@ bool ha_mroonga::storage_inplace_alter_table_add_column(
     }
 
     Field *field = altered_table->s->field[i];
-    const char *column_name = field->field_name;
-    int column_name_size = strlen(column_name);
+    const char *column_name = field->name().ptr();
+    int column_name_size = field->name().length();
 
     int error = mrn_add_column_param(tmp_share, field, i);
     if (error) {
@@ -14644,8 +14644,8 @@ bool ha_mroonga::storage_inplace_alter_table_drop_column(
       continue;
     }
 
-    const char *column_name = field->field_name;
-    int column_name_size = strlen(column_name);
+    const char *column_name = field->name().ptr();
+    int column_name_size = field->name().length();
 
     grn_obj *column_obj;
     column_obj = grn_obj_column(ctx, table_obj, column_name, column_name_size);
@@ -14689,7 +14689,7 @@ bool ha_mroonga::storage_inplace_alter_table_rename_column(
     List_iterator_fast<Create_field> create_fields(alter_info->create_list);
     while (Create_field *create_field = create_fields++) {
       if (create_field->field == field) {
-        new_name = create_field->field_name;
+        new_name = create_field->name().ptr();
         break;
       }
     }
@@ -14698,7 +14698,7 @@ bool ha_mroonga::storage_inplace_alter_table_rename_column(
       continue;
     }
 
-    const char *old_name = field->field_name;
+    const char *old_name = field->name().ptr();
     grn_obj *column_obj;
     column_obj = grn_obj_column(ctx, table_obj, old_name, strlen(old_name));
     if (column_obj) {
@@ -15871,8 +15871,8 @@ char *ha_mroonga::storage_get_foreign_key_create_info()
   create_info_str.length(0);
   for (i = 0; i < n_columns; ++i) {
     Field *field = table_share->field[i];
-    const char *column_name = field->field_name;
-    uint column_name_size = strlen(column_name);
+    const char *column_name = field->name().ptr();
+    uint column_name_size = field->name().length();
 
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
       continue;
@@ -15946,8 +15946,8 @@ char *ha_mroonga::storage_get_foreign_key_create_info()
     uint ref_pkey_nr = tmp_ref_table_share->primary_key;
     KEY *ref_key_info = &tmp_ref_table_share->key_info[ref_pkey_nr];
     Field *ref_field = &ref_key_info->key_part->field[0];
-    append_identifier(ha_thd(), &create_info_str, ref_field->field_name,
-                      strlen(ref_field->field_name));
+    append_identifier(ha_thd(), &create_info_str, ref_field->name().ptr(),
+                      ref_field->name().length());
     mrn_open_mutex_lock(table_share);
     mrn_free_tmp_table_share(tmp_ref_table_share);
     mrn_open_mutex_unlock(table_share);
@@ -16078,8 +16078,8 @@ int ha_mroonga::storage_get_foreign_key_list(THD *thd,
   MRN_DBUG_ENTER_METHOD();
   for (i = 0; i < n_columns; ++i) {
     Field *field = table_share->field[i];
-    const char *column_name = field->field_name;
-    uint column_name_size = strlen(column_name);
+    const char *column_name = field->name().ptr();
+    uint column_name_size = field->name().length();
 
     if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
       continue;
@@ -16153,8 +16153,8 @@ int ha_mroonga::storage_get_foreign_key_list(THD *thd,
     KEY *ref_key_info = &tmp_ref_table_share->key_info[ref_pkey_nr];
     Field *ref_field = &ref_key_info->key_part->field[0];
     LEX_STRING *ref_col_name = thd_make_lex_string(thd, NULL,
-                                                   ref_field->field_name,
-                                                   strlen(ref_field->field_name),
+                                                   ref_field->name().ptr(),
+                                                   ref_field->name().length(),
                                                    TRUE);
     f_key_info.referenced_fields.push_back(ref_col_name);
     mrn_open_mutex_lock(table_share);
diff --git a/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp b/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp
index c7ef9dd..fcdd059 100644
--- a/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp
+++ b/storage/mroonga/lib/mrn_multiple_column_key_codec.cpp
@@ -678,7 +678,7 @@ namespace mrn {
                             "data: <%.*s>",
                             normalized_length,
                             UINT_MAX16,
-                            field->field_name,
+                            field->name().ptr(),
                             blob_data_length, blob_data);
         memcpy(grn_key, normalized, blob_data_length);
         new_blob_data_length = blob_data_length;
diff --git a/storage/sequence/sequence.cc b/storage/sequence/sequence.cc
index 7b20615..efcadce 100644
--- a/storage/sequence/sequence.cc
+++ b/storage/sequence/sequence.cc
@@ -418,7 +418,7 @@ create_group_by_handler(THD *thd, Query *query)
     if (field->table != query->from->table)
       return 0;
     /* Check that we are using a SUM() on the primary key */
-    if (strcmp(field->field_name, "seq"))
+    if (strcmp(field->name().ptr(), "seq"))
       return 0;
   }
 
diff --git a/storage/sphinx/ha_sphinx.cc b/storage/sphinx/ha_sphinx.cc
index 568d369..2206822 100644
--- a/storage/sphinx/ha_sphinx.cc
+++ b/storage/sphinx/ha_sphinx.cc
@@ -1027,7 +1027,7 @@ static bool ParseUrl ( CSphSEShare * share, TABLE * table, bool bCreate )
 
 			for ( int i=0; i<share->m_iTableFields; i++ )
 			{
-				share->m_sTableField[i] = sphDup ( table->field[i]->field_name );
+				share->m_sTableField[i] = sphDup ( table->field[i]->name().ptr() );
 				share->m_eTableFieldType[i] = table->field[i]->type();
 			}
 		}
@@ -2321,7 +2321,7 @@ int ha_sphinx::write_row ( byte * )
 
 	for ( Field ** ppField = table->field; *ppField; ppField++ )
 	{
-		sQuery.append ( (*ppField)->field_name );
+		sQuery.append ( (*ppField)->name().ptr() );
 		if ( ppField[1] )
 			sQuery.append ( ", " );
 	}
@@ -3417,7 +3417,7 @@ int ha_sphinx::create ( const char * name, TABLE * table, HA_CREATE_INFO * )
 			if ( eType!=MYSQL_TYPE_TIMESTAMP && !IsIntegerFieldType(eType) && eType!=MYSQL_TYPE_VARCHAR && eType!=MYSQL_TYPE_FLOAT )
 			{
 				my_snprintf ( sError, sizeof(sError), "%s: %dth column (attribute %s) MUST be integer, bigint, timestamp, varchar, or float",
-					name, i+1, table->field[i]->field_name );
+					name, i+1, table->field[i]->name().ptr() );
 				break;
 			}
 		}
@@ -3429,10 +3429,10 @@ int ha_sphinx::create ( const char * name, TABLE * table, HA_CREATE_INFO * )
 		if (
 			table->s->keys!=1 ||
 			table->key_info[0].user_defined_key_parts!=1 ||
-			strcasecmp ( table->key_info[0].key_part[0].field->field_name, table->field[2]->field_name ) )
+			strcasecmp ( table->key_info[0].key_part[0].field->name().ptr(), table->field[2]->name().ptr() ) )
 		{
 			my_snprintf ( sError, sizeof(sError), "%s: there must be an index on '%s' column",
-				name, table->field[2]->field_name );
+				name, table->field[2]->name().ptr() );
 			break;
 		}
 
@@ -3447,7 +3447,7 @@ int ha_sphinx::create ( const char * name, TABLE * table, HA_CREATE_INFO * )
 		sError[0] = '\0';
 
 		// check that 1st column is id, is of int type, and has an index
-		if ( strcmp ( table->field[0]->field_name, "id" ) )
+		if ( strcmp ( table->field[0]->name().ptr(), "id" ) )
 		{
 			my_snprintf ( sError, sizeof(sError), "%s: 1st column must be called 'id'", name );
 			break;
@@ -3463,7 +3463,7 @@ int ha_sphinx::create ( const char * name, TABLE * table, HA_CREATE_INFO * )
 		if (
 			table->s->keys!=1 ||
 			table->key_info[0].user_defined_key_parts!=1 ||
-			strcasecmp ( table->key_info[0].key_part[0].field->field_name, "id" ) )
+			strcasecmp ( table->key_info[0].key_part[0].field->name().ptr(), "id" ) )
 		{
 			my_snprintf ( sError, sizeof(sError), "%s: 'id' column must be indexed", name );
 			break;
@@ -3476,7 +3476,7 @@ int ha_sphinx::create ( const char * name, TABLE * table, HA_CREATE_INFO * )
 			if ( eType!=MYSQL_TYPE_TIMESTAMP && !IsIntegerFieldType(eType) && eType!=MYSQL_TYPE_VARCHAR && eType!=MYSQL_TYPE_FLOAT )
 			{
 				my_snprintf ( sError, sizeof(sError), "%s: column %d(%s) is of unsupported type (use int/bigint/timestamp/varchar/float)",
-					name, i+1, table->field[i]->field_name );
+					name, i+1, table->field[i]->name().ptr() );
 				break;
 			}
 		}
diff --git a/storage/spider/ha_spider.cc b/storage/spider/ha_spider.cc
index b4602e5..a5028c7 100644
--- a/storage/spider/ha_spider.cc
+++ b/storage/spider/ha_spider.cc
@@ -7711,7 +7711,7 @@ int ha_spider::cmp_ref(
     ) {
       if ((ret = (*field)->cmp_binary_offset(ptr_diff)))
       {
-        DBUG_PRINT("info",("spider different at %s", (*field)->field_name));
+        DBUG_PRINT("info",("spider different at %s", (*field)->name().ptr()));
         break;
       }
     }
diff --git a/storage/spider/spd_db_conn.cc b/storage/spider/spd_db_conn.cc
index 30ad38e..0f69cbe 100644
--- a/storage/spider/spd_db_conn.cc
+++ b/storage/spider/spd_db_conn.cc
@@ -2774,7 +2774,7 @@ int spider_db_fetch_row(
 ) {
   int error_num;
   DBUG_ENTER("spider_db_fetch_row");
-  DBUG_PRINT("info", ("spider field_name %s", field->field_name));
+  DBUG_PRINT("info", ("spider field_name %s", field->name().ptr()));
   DBUG_PRINT("info", ("spider fieldcharset %s", field->charset()->csname));
   field->move_field_offset(ptr_diff);
   error_num = row->store_to_field(field, share->access_charset);
@@ -2897,7 +2897,7 @@ int spider_db_fetch_table(
         my_bitmap_map *tmp_map =
           dbug_tmp_use_all_columns(table, table->write_set);
 #endif
-        DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->field_name));
+        DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->name().ptr()));
         if ((error_num =
           spider_db_fetch_row(share, *field, row, ptr_diff)))
           DBUG_RETURN(error_num);
@@ -3068,7 +3068,7 @@ int spider_db_fetch_key(
       my_bitmap_map *tmp_map =
         dbug_tmp_use_all_columns(table, table->write_set);
 #endif
-      DBUG_PRINT("info", ("spider bitmap is set %s", field->field_name));
+      DBUG_PRINT("info", ("spider bitmap is set %s", field->name().ptr()));
       if ((error_num =
         spider_db_fetch_row(share, field, row, ptr_diff)))
         DBUG_RETURN(error_num);
@@ -3182,7 +3182,7 @@ int spider_db_fetch_minimum_columns(
         my_bitmap_map *tmp_map =
           dbug_tmp_use_all_columns(table, table->write_set);
 #endif
-        DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->field_name));
+        DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->name().ptr()));
         if ((error_num = spider_db_fetch_row(share, *field, row, ptr_diff)))
           DBUG_RETURN(error_num);
 #ifndef DBUG_OFF
@@ -5035,7 +5035,7 @@ int spider_db_seek_tmp_table(
       my_bitmap_map *tmp_map =
         dbug_tmp_use_all_columns(table, table->write_set);
 #endif
-      DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->field_name));
+      DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->name().ptr()));
       if ((error_num =
         spider_db_fetch_row(spider->share, *field, row, ptr_diff)))
         DBUG_RETURN(error_num);
@@ -5122,7 +5122,7 @@ int spider_db_seek_tmp_key(
       my_bitmap_map *tmp_map =
         dbug_tmp_use_all_columns(table, table->write_set);
 #endif
-      DBUG_PRINT("info", ("spider bitmap is set %s", field->field_name));
+      DBUG_PRINT("info", ("spider bitmap is set %s", field->name().ptr()));
       if ((error_num =
         spider_db_fetch_row(spider->share, field, row, ptr_diff)))
         DBUG_RETURN(error_num);
@@ -5212,7 +5212,7 @@ int spider_db_seek_tmp_minimum_columns(
       my_bitmap_map *tmp_map =
         dbug_tmp_use_all_columns(table, table->write_set);
 #endif
-      DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->field_name));
+      DBUG_PRINT("info", ("spider bitmap is set %s", (*field)->name().ptr()));
       if ((error_num =
         spider_db_fetch_row(spider->share, *field, row, ptr_diff)))
         DBUG_RETURN(error_num);
@@ -5224,7 +5224,7 @@ int spider_db_seek_tmp_minimum_columns(
     else if (bitmap_is_set(table->read_set, (*field)->field_index))
     {
       DBUG_PRINT("info", ("spider bitmap is cleared %s",
-        (*field)->field_name));
+        (*field)->name().ptr()));
       bitmap_clear_bit(table->read_set, (*field)->field_index);
     }
   }
@@ -9474,7 +9474,7 @@ int spider_db_udf_copy_key_row(
   int error_num;
   DBUG_ENTER("spider_db_udf_copy_key_row");
   if ((error_num = spider_db_append_name_with_quote_str(str,
-    (char *) field->field_name, dbton_id)))
+    (char *) field->name().ptr(), dbton_id)))
     DBUG_RETURN(error_num);
   if (str->reserve(joint_length + *length + SPIDER_SQL_AND_LEN))
     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
diff --git a/storage/spider/spd_db_mysql.cc b/storage/spider/spd_db_mysql.cc
index 92f9525..1101eed 100644
--- a/storage/spider/spd_db_mysql.cc
+++ b/storage/spider/spd_db_mysql.cc
@@ -4415,7 +4415,7 @@ int spider_mysql_share::create_column_name_str()
     str->init_calc_mem(89);
     str->set_charset(spider_share->access_charset);
     if ((error_num = spider_db_append_name_with_quote_str(str,
-      (char *) (*field)->field_name, dbton_id)))
+      (char *) (*field)->name().ptr(), dbton_id)))
       goto error;
   }
   DBUG_RETURN(0);
@@ -11731,7 +11731,7 @@ int spider_mysql_copy_table::append_table_columns(
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
     sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
     if ((error_num = spider_db_append_name_with_quote_str(&sql,
-      (char *) (*field)->field_name, spider_dbton_mysql.dbton_id)))
+      (char *) (*field)->name().ptr(), spider_dbton_mysql.dbton_id)))
       DBUG_RETURN(error_num);
     if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -11860,7 +11860,7 @@ int spider_mysql_copy_table::append_key_order_str(
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
         sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
         if ((error_num = spider_db_append_name_with_quote_str(&sql,
-          (char *) field->field_name, spider_dbton_mysql.dbton_id)))
+          (char *) field->name().ptr(), spider_dbton_mysql.dbton_id)))
           DBUG_RETURN(error_num);
         if (key_part->key_part_flag & HA_REVERSE_SORT)
         {
@@ -11890,7 +11890,7 @@ int spider_mysql_copy_table::append_key_order_str(
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
         sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
         if ((error_num = spider_db_append_name_with_quote_str(&sql,
-          (char *) field->field_name, spider_dbton_mysql.dbton_id)))
+          (char *) field->name().ptr(), spider_dbton_mysql.dbton_id)))
           DBUG_RETURN(error_num);
         if (key_part->key_part_flag & HA_REVERSE_SORT)
         {
@@ -12020,7 +12020,7 @@ int spider_mysql_copy_table::copy_key_row(
     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
   sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
   if ((error_num = spider_db_append_name_with_quote_str(&sql,
-    (char *) field->field_name, spider_dbton_mysql.dbton_id)))
+    (char *) field->name().ptr(), spider_dbton_mysql.dbton_id)))
     DBUG_RETURN(error_num);
   if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + joint_length + *length +
     SPIDER_SQL_AND_LEN))
diff --git a/storage/xtradb/handler/ha_innodb.cc b/storage/xtradb/handler/ha_innodb.cc
index 4aa5457..48a54e6 100644
--- a/storage/xtradb/handler/ha_innodb.cc
+++ b/storage/xtradb/handler/ha_innodb.cc
@@ -5867,7 +5867,7 @@ ha_innobase::innobase_initialize_autoinc()
 
 		ut_a(prebuilt->trx == thd_to_trx(user_thd));
 
-		col_name = field->field_name;
+		col_name = field->name().ptr();
 		index = innobase_get_index(table->s->next_number_index);
 
 		/* Execute SELECT MAX(col_name) FROM TABLE; */
@@ -8727,7 +8727,7 @@ calc_row_difference(
 		if (field_mysql_type == MYSQL_TYPE_LONGLONG
 		    && prebuilt->table->fts
 		    && innobase_strcasecmp(
-			field->field_name, FTS_DOC_ID_COL_NAME) == 0) {
+			field->name().ptr(), FTS_DOC_ID_COL_NAME) == 0) {
 			doc_id = (doc_id_t) mach_read_from_n_little_endian(
 				n_ptr, 8);
 			if (doc_id == 0) {
@@ -10921,7 +10921,7 @@ create_table_check_doc_id_col(
 
 		col_len = field->pack_length();
 
-		if (innobase_strcasecmp(field->field_name,
+		if (innobase_strcasecmp(field->name().ptr(),
 					FTS_DOC_ID_COL_NAME) == 0) {
 
 			/* Note the name is case sensitive due to
@@ -10929,7 +10929,7 @@ create_table_check_doc_id_col(
 			if (col_type == DATA_INT
 			    && !field->real_maybe_null()
 			    && col_len == sizeof(doc_id_t)
-			    && (strcmp(field->field_name,
+			    && (strcmp(field->name().ptr(),
 				      FTS_DOC_ID_COL_NAME) == 0)) {
 				*doc_id_col = i;
 			} else {
@@ -10941,7 +10941,7 @@ create_table_check_doc_id_col(
 					"of BIGINT NOT NULL type, and named "
 					"in all capitalized characters");
 				my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-					 field->field_name);
+					 field->name().ptr());
 				*doc_id_col = ULINT_UNDEFINED;
 			}
 
@@ -11087,7 +11087,7 @@ create_table_def(
 				"column type and try to re-create "
 				"the table with an appropriate "
 				"column type.",
-				table->name, field->field_name);
+				table->name, field->name().ptr());
 			goto err_col;
 		}
 
@@ -11137,9 +11137,9 @@ create_table_def(
 
 		/* First check whether the column to be added has a
 		system reserved name. */
-		if (dict_col_name_is_reserved(field->field_name)){
+		if (dict_col_name_is_reserved(field->name().ptr())){
 			my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-				 field->field_name);
+				 field->name().ptr());
 err_col:
 			dict_mem_table_free(table);
 			mem_heap_free(heap);
@@ -11150,7 +11150,7 @@ create_table_def(
 		}
 
 		dict_mem_table_add_col(table, heap,
-			field->field_name,
+			field->name().ptr(),
 			col_type,
 			dtype_form_prtype(
 				(ulint) field->type()
@@ -11228,7 +11228,7 @@ create_index(
 		for (ulint i = 0; i < key->user_defined_key_parts; i++) {
 			KEY_PART_INFO*	key_part = key->key_part + i;
 			dict_mem_index_add_field(
-				index, key_part->field->field_name, 0);
+				index, key_part->field->name().ptr(), 0);
 		}
 
 		DBUG_RETURN(convert_error_code_to_mysql(
@@ -11279,8 +11279,8 @@ create_index(
 			field = form->field[j];
 
 			if (0 == innobase_strcasecmp(
-				    field->field_name,
-				    key_part->field->field_name)) {
+				    field->name().ptr(),
+				    key_part->field->name().ptr())) {
 				/* Found the corresponding column */
 
 				goto found;
@@ -11313,7 +11313,7 @@ create_index(
 					"inappropriate data type. Table "
 					"name %s, column name %s.",
 					table_name,
-					key_part->field->field_name);
+					key_part->field->name().ptr());
 
 				prefix_len = 0;
 			}
@@ -11324,7 +11324,7 @@ create_index(
 		field_lengths[i] = key_part->length;
 
 		dict_mem_index_add_field(
-			index, key_part->field->field_name, prefix_len);
+			index, key_part->field->name().ptr(), prefix_len);
 	}
 
 	ut_ad(key->flags & HA_FULLTEXT || !(index->type & DICT_FTS));
@@ -11799,7 +11799,7 @@ innobase_table_flags(
 		/* Do a pre-check on FTS DOC ID index */
 		if (!(key->flags & HA_NOSAME)
 		    || strcmp(key->name, FTS_DOC_ID_INDEX_NAME)
-		    || strcmp(key->key_part[0].field->field_name,
+		    || strcmp(key->key_part[0].field->name().ptr(),
 			      FTS_DOC_ID_COL_NAME)) {
 			fts_doc_id_index_bad = key->name;
 		}
diff --git a/storage/xtradb/handler/handler0alter.cc b/storage/xtradb/handler/handler0alter.cc
index 2f89bf7..9cefdf3 100644
--- a/storage/xtradb/handler/handler0alter.cc
+++ b/storage/xtradb/handler/handler0alter.cc
@@ -484,7 +484,7 @@ ha_innobase::check_if_supported_inplace_alter(
 			    && innobase_fulltext_exist(altered_table)
 			    && !my_strcasecmp(
 				    system_charset_info,
-				    key_part->field->field_name,
+				    key_part->field->name().ptr(),
 				    FTS_DOC_ID_COL_NAME)) {
 				ha_alter_info->unsupported_reason = innobase_get_err_msg(
 					ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS);
@@ -541,7 +541,7 @@ ha_innobase::check_if_supported_inplace_alter(
 
 			if (!my_strcasecmp(
 				    system_charset_info,
-				    (*fp)->field_name,
+				    (*fp)->name().ptr(),
 				    FTS_DOC_ID_COL_NAME)) {
 				ha_alter_info->unsupported_reason = innobase_get_err_msg(
 					ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS);
@@ -810,7 +810,7 @@ innobase_find_equiv_index(
 			}
 
 			if (innobase_strcasecmp(col_names[j],
-						key_part.field->field_name)) {
+						key_part.field->name().ptr())) {
 				/* Name mismatch */
 				goto no_match;
 			}
@@ -932,7 +932,7 @@ innobase_get_foreign_key_info(
 			/* Get all the foreign key column info for the
 			current table */
 			while ((column = key_part_iterator++)) {
-				column_names[i] = column->field_name.str;
+				column_names[i] = column->name().ptr();
 				ut_ad(i < MAX_NUM_FK_COLUMNS);
 				i++;
 			}
@@ -1033,7 +1033,7 @@ innobase_get_foreign_key_info(
 
 			while ((column = key_part_iterator++)) {
 				referenced_column_names[i] =
-					column->field_name.str;
+					column->name().ptr();
 				ut_ad(i < MAX_NUM_FK_COLUMNS);
 				i++;
 			}
@@ -1466,7 +1466,7 @@ innobase_check_index_keys(
 				}
 
 				my_error(ER_WRONG_KEY_COLUMN, MYF(0), "InnoDB",
-					 field->field_name);
+					 field->name().ptr());
 				return(ER_WRONG_KEY_COLUMN);
 			}
 
@@ -1482,7 +1482,7 @@ innobase_check_index_keys(
 				}
 
 				my_error(ER_WRONG_KEY_COLUMN, MYF(0), "InnoDB",
-					 field->field_name);
+					 field->name().ptr());
 				return(ER_WRONG_KEY_COLUMN);
 			}
 		}
@@ -1521,7 +1521,7 @@ innobase_create_index_field_def(
 	ut_a(field);
 
 	index_field->col_no = key_part->fieldnr;
-	index_field->col_name = altered_table ? field->field_name : fields[key_part->fieldnr]->field_name;
+	index_field->col_name = altered_table ? field->name().ptr() : fields[key_part->fieldnr]->name().ptr();
 
 	col_type = get_innobase_type_from_mysql_type(&is_unsigned, field);
 
@@ -1645,19 +1645,19 @@ innobase_fts_check_doc_id_col(
                                  stored_in_db()))
                           sql_idx++;
 		if (my_strcasecmp(system_charset_info,
-				  field->field_name, FTS_DOC_ID_COL_NAME)) {
+				  field->name().ptr(), FTS_DOC_ID_COL_NAME)) {
 			continue;
 		}
 
-		if (strcmp(field->field_name, FTS_DOC_ID_COL_NAME)) {
+		if (strcmp(field->name().ptr(), FTS_DOC_ID_COL_NAME)) {
 			my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-				 field->field_name);
+				 field->name().ptr());
 		} else if (field->type() != MYSQL_TYPE_LONGLONG
 			   || field->pack_length() != 8
 			   || field->real_maybe_null()
 			   || !(field->flags & UNSIGNED_FLAG)) {
 			my_error(ER_INNODB_FT_WRONG_DOCID_COLUMN, MYF(0),
-				 field->field_name);
+				 field->name().ptr());
 		} else {
 			*fts_doc_col_no = i;
 		}
@@ -1728,7 +1728,7 @@ innobase_fts_check_doc_id_index(
 			if ((key.flags & HA_NOSAME)
 			    && key.user_defined_key_parts == 1
 			    && !strcmp(key.name, FTS_DOC_ID_INDEX_NAME)
-			    && !strcmp(key.key_part[0].field->field_name,
+			    && !strcmp(key.key_part[0].field->name().ptr(),
 				       FTS_DOC_ID_COL_NAME)) {
 				if (fts_doc_col_no) {
 					*fts_doc_col_no = ULINT_UNDEFINED;
@@ -1807,7 +1807,7 @@ innobase_fts_check_doc_id_index_in_def(
 		if (!(key->flags & HA_NOSAME)
 		    || key->user_defined_key_parts != 1
 		    || strcmp(key->name, FTS_DOC_ID_INDEX_NAME)
-		    || strcmp(key->key_part[0].field->field_name,
+		    || strcmp(key->key_part[0].field->name().ptr(),
 			      FTS_DOC_ID_COL_NAME)) {
 			return(FTS_INCORRECT_DOC_ID_INDEX);
 		}
@@ -2419,7 +2419,7 @@ innobase_check_foreigns(
 		if (!new_field || (new_field->flags & NOT_NULL_FLAG)) {
 			if (innobase_check_foreigns_low(
 				    user_table, drop_fk, n_drop_fk,
-				    (*fp)->field_name, !new_field)) {
+				    (*fp)->name().ptr(), !new_field)) {
 				return(true);
 			}
 		}
@@ -2646,7 +2646,7 @@ innobase_get_col_names(
 
 		for (uint old_i = 0; table->field[old_i]; old_i++) {
 			if (new_field->field == table->field[old_i]) {
-				cols[old_i] = new_field->field_name;
+				cols[old_i] = new_field->name().ptr();
 				break;
 			}
 		}
@@ -2930,7 +2930,7 @@ prepare_inplace_alter_table_dict(
 					dict_mem_table_free(
 						ctx->new_table);
 					my_error(ER_WRONG_KEY_COLUMN, MYF(0),
-						 field->field_name);
+						 field->name().ptr());
 					goto new_clustered_failed;
 				}
 			} else {
@@ -2957,16 +2957,16 @@ prepare_inplace_alter_table_dict(
 				}
 			}
 
-			if (dict_col_name_is_reserved(field->field_name)) {
+			if (dict_col_name_is_reserved(field->name().ptr())) {
 				dict_mem_table_free(ctx->new_table);
 				my_error(ER_WRONG_COLUMN_NAME, MYF(0),
-					 field->field_name);
+					 field->name().ptr());
 				goto new_clustered_failed;
 			}
 
 			dict_mem_table_add_col(
 				ctx->new_table, ctx->heap,
-				field->field_name,
+				field->name().ptr(),
 				col_type,
 				dtype_form_prtype(field_type, charset_no),
 				col_len);
@@ -3565,7 +3565,7 @@ ha_innobase::prepare_inplace_alter_table(
 			cf_it.rewind();
 			while (Create_field* cf = cf_it++) {
 				if (cf->field == *fp) {
-					name = cf->field_name;
+					name = cf->name().ptr();
 					goto check_if_ok_to_rename;
 				}
 			}
@@ -3575,7 +3575,7 @@ ha_innobase::prepare_inplace_alter_table(
 			/* Prohibit renaming a column from FTS_DOC_ID
 			if full-text indexes exist. */
 			if (!my_strcasecmp(system_charset_info,
-					   (*fp)->field_name,
+					   (*fp)->name().ptr(),
 					   FTS_DOC_ID_COL_NAME)
 			    && innobase_fulltext_exist(altered_table)) {
 				my_error(ER_INNODB_FT_WRONG_DOCID_COLUMN,
@@ -4716,8 +4716,8 @@ innobase_rename_columns_try(
 			if (cf->field == *fp) {
 				if (innobase_rename_column_try(
 					    ctx->old_table, trx, table_name, i,
-					    cf->field->field_name,
-					    cf->field_name,
+					    cf->field->name().ptr(),
+					    cf->name().ptr(),
 					    ctx->need_rebuild())) {
 					return(true);
 				}
@@ -4764,8 +4764,8 @@ innobase_rename_columns_cache(
 		while (Create_field* cf = cf_it++) {
 			if (cf->field == *fp) {
 				dict_mem_table_col_rename(user_table, i,
-							  cf->field->field_name,
-							  cf->field_name);
+							  cf->field->name().ptr(),
+							  cf->name().ptr());
 				goto processed_field;
 			}
 		}
@@ -4825,7 +4825,7 @@ commit_get_autoinc(
 		dict_table_autoinc_lock(ctx->old_table);
 
 		err = row_search_max_autoinc(
-			index, autoinc_field->field_name, &max_value_table);
+			index, autoinc_field->name().ptr(), &max_value_table);
 
 		if (err != DB_SUCCESS) {
 			ut_ad(0);

Follow ups