diff --git a/sql/field.cc b/sql/field.cc
index a7d9106..801e191 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -9169,6 +9169,24 @@ static inline bool is_item_func(Item* x)
 }
 
 
+bool Create_type_attributes_st::check(const char *field_name) const
+{
+  if (length > MAX_FIELD_BLOBLENGTH)
+  {
+    my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), field_name, MAX_FIELD_BLOBLENGTH);
+    return true;
+  }
+
+  if (decimals >= NOT_FIXED_DEC)
+  {
+    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, field_name,
+             static_cast<ulong>(NOT_FIXED_DEC - 1));
+    return true;
+  }
+  return false;
+}
+
+
 bool Create_field::check(THD *thd)
 {
   const uint conditional_type_modifiers= AUTO_INCREMENT_FLAG;
@@ -9182,19 +9200,8 @@ bool Create_field::check(THD *thd)
     sql_type= (enum enum_field_types)MYSQL_TYPE_VIRTUAL;
   }
 
-  if (length > MAX_FIELD_BLOBLENGTH)
-  {
-    my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), field_name, MAX_FIELD_BLOBLENGTH);
-    DBUG_RETURN(1);
-  }
-
-  if (decimals >= NOT_FIXED_DEC)
-  {
-    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, field_name,
-             static_cast<ulong>(NOT_FIXED_DEC - 1));
-    DBUG_RETURN(TRUE);
-  }
-
+  if (Create_type_attributes_st::check(field_name))
+    DBUG_RETURN(true);
   if (def)
   {
     /*
@@ -9802,18 +9809,16 @@ Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
 /** Create a field suitable for create of table. */
 
 Create_field::Create_field(Field *old_field,Field *orig_field)
+ :Create_type_attributes(old_field)
 {
   field=      old_field;
   field_name=change=old_field->field_name;
-  length=     old_field->field_length;
   flags=      old_field->flags;
   unireg_check=old_field->unireg_check;
   pack_length=old_field->pack_length();
   key_length= old_field->key_length();
   sql_type=   old_field->real_type();
-  charset=    old_field->charset();		// May be NULL ptr
   comment=    old_field->comment;
-  decimals=   old_field->decimals();
   vcol_info=  old_field->vcol_info;
   create_if_not_exists= FALSE;
   stored_in_db= old_field->stored_in_db;
diff --git a/sql/field.h b/sql/field.h
index fdc00ed..55998e2 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -2833,11 +2833,25 @@ class Field_bit_as_char: public Field_bit {
 };
 
 
+class Create_type_attributes: public Sql_alloc,
+                              public Create_type_attributes_st
+{
+public:
+  Create_type_attributes() { init(); }
+  Create_type_attributes(const char *len, const char *dec, CHARSET_INFO *cs)
+  { set(len, dec, cs); }
+  Create_type_attributes(const Field *field)
+  { set(field->field_length, field->decimals(), field->charset()); }
+  Create_type_attributes(const Create_type_attributes_st &attr)
+  { set(attr.length, attr.decimals, attr.charset); }
+};
+
+
 /*
   Create field class for CREATE TABLE
 */
 
-class Create_field :public Sql_alloc
+class Create_field :public Create_type_attributes
 {
 public:
   const char *field_name;
@@ -2847,22 +2861,16 @@ class Create_field :public Sql_alloc
   Item *def, *on_update;                // Default value
   enum	enum_field_types sql_type;
   /*
-    At various stages in execution this can be length of field in bytes or
-    max number of characters. 
-  */
-  ulong length;
-  /*
     The value of `length' as set by parser: is the number of characters
     for most of the types, or of bytes for BLOBs or numeric types.
   */
   uint32 char_length;
-  uint  decimals, flags, pack_length, key_length;
+  uint  flags, pack_length, key_length;
   Field::utype unireg_check;
   TYPELIB *interval;			// Which interval to use
   TYPELIB *save_interval;               // Temporary copy for the above
                                         // Used only for UCS2 intervals
   List<String> interval_list;
-  CHARSET_INFO *charset;
   Field::geometry_type geom_type;
   Field *field;				// For alter table
   engine_option_value *option_list;
diff --git a/sql/item.h b/sql/item.h
index ff0c786..7e8039f 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -593,16 +593,22 @@ class Copy_query_with_rewrite
   { return copy_up_to(src_len); }
 };
 
-struct st_dyncall_create_def
+class DYNCALL_CREATE_DEF: public Create_type_attributes
 {
+public:
+  DYNCALL_CREATE_DEF(const char *len, const char *dec, CHARSET_INFO *cs)
+   :Create_type_attributes(len, dec, cs)
+  { }
+  DYNCALL_CREATE_DEF(const Create_type_attributes_st &attr)
+   :Create_type_attributes(attr)
+  { }
+  DYNCALL_CREATE_DEF()
+   :Create_type_attributes()
+  { }
   Item  *key, *value;
-  CHARSET_INFO *cs;
-  uint len, frac;
   DYNAMIC_COLUMN_TYPE type;
 };
 
-typedef struct st_dyncall_create_def DYNCALL_CREATE_DEF;
-
 
 typedef bool (Item::*Item_processor) (uchar *arg);
 /*
diff --git a/sql/item_create.cc b/sql/item_create.cc
index fa8249c..6175bd6 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -6017,22 +6017,10 @@ void item_create_cleanup()
 
 Item *
 create_func_cast(THD *thd, Item *a, Cast_target cast_type,
-                 const char *c_len, const char *c_dec,
-                 CHARSET_INFO *cs)
+                 const Create_type_attributes &attr)
 {
   Item *UNINIT_VAR(res);
-  ulonglong length= 0, decimals= 0;
-  int error;
   
-  /*
-    We don't have to check for error here as sql_yacc.yy has guaranteed
-    that the values are in range of ulonglong
-  */
-  if (c_len)
-    length= (ulonglong) my_strtoll10(c_len, NULL, &error);
-  if (c_dec)
-    decimals= (ulonglong) my_strtoll10(c_dec, NULL, &error);
-
   switch (cast_type) {
   case ITEM_CAST_BINARY:
     res= new (thd->mem_root) Item_func_binary(a);
@@ -6047,28 +6035,28 @@ void item_create_cleanup()
     res= new (thd->mem_root) Item_date_typecast(a);
     break;
   case ITEM_CAST_TIME:
-    if (decimals > MAX_DATETIME_PRECISION)
+    if (attr.decimals > MAX_DATETIME_PRECISION)
     {
-      wrong_precision_error(ER_TOO_BIG_PRECISION, a, decimals,
+      wrong_precision_error(ER_TOO_BIG_PRECISION, a, attr.decimals,
                             MAX_DATETIME_PRECISION);
       return 0;
     }
-    res= new (thd->mem_root) Item_time_typecast(a, (uint) decimals);
+    res= new (thd->mem_root) Item_time_typecast(a, (uint) attr.decimals);
     break;
   case ITEM_CAST_DATETIME:
-    if (decimals > MAX_DATETIME_PRECISION)
+    if (attr.decimals > MAX_DATETIME_PRECISION)
     {
-      wrong_precision_error(ER_TOO_BIG_PRECISION, a, decimals,
+      wrong_precision_error(ER_TOO_BIG_PRECISION, a, attr.decimals,
                             MAX_DATETIME_PRECISION);
       return 0;
     }
-    res= new (thd->mem_root) Item_datetime_typecast(a, (uint) decimals);
+    res= new (thd->mem_root) Item_datetime_typecast(a, (uint) attr.decimals);
     break;
   case ITEM_CAST_DECIMAL:
   {
     ulong len;
     uint dec;
-    if (get_length_and_scale(length, decimals, &len, &dec,
+    if (get_length_and_scale(attr.length, attr.decimals, &len, &dec,
                              DECIMAL_MAX_PRECISION, DECIMAL_MAX_SCALE,
                              a))
       return NULL;
@@ -6079,8 +6067,10 @@ void item_create_cleanup()
   {
     ulong len;
     uint dec;
+    ulonglong length= attr.length;
+    ulonglong decimals= attr.decimals;
 
-    if (!c_len)
+    if (!attr.length && !attr.decimals)
     {
       length=   DBL_DIG+7;
       decimals= NOT_FIXED_DEC;
@@ -6096,10 +6086,11 @@ void item_create_cleanup()
   case ITEM_CAST_CHAR:
   {
     int len= -1;
-    CHARSET_INFO *real_cs= (cs ? cs : thd->variables.collation_connection);
-    if (c_len)
+    CHARSET_INFO *real_cs= attr.charset ? attr.charset :
+                                          thd->variables.collation_connection;
+    if (attr.length_was_set_explicitly())
     {
-      if (length > MAX_FIELD_BLOBLENGTH)
+      if (attr.length > MAX_FIELD_BLOBLENGTH)
       {
         char buff[1024];
         String buf(buff, sizeof(buff), system_charset_info);
@@ -6107,7 +6098,7 @@ void item_create_cleanup()
                  MAX_FIELD_BLOBLENGTH);
         return NULL;
       }
-      len= (int) length;
+      len= (int) attr.length;
     }
     res= new (thd->mem_root) Item_char_typecast(a, len, real_cs);
     break;
@@ -6281,12 +6272,11 @@ Item *create_func_dyncol_delete(THD *thd, Item *str, List<Item> &nums)
 
 Item *create_func_dyncol_get(THD *thd,  Item *str, Item *num,
                              Cast_target cast_type,
-                             const char *c_len, const char *c_dec,
-                             CHARSET_INFO *cs)
+                             const Create_type_attributes &attr)
 {
   Item *res;
 
   if (!(res= new (thd->mem_root) Item_dyncol_get(str, num)))
     return res;                                 // Return NULL
-  return create_func_cast(thd, res, cast_type, c_len, c_dec, cs);
+  return create_func_cast(thd, res, cast_type, attr);
 }
diff --git a/sql/item_create.h b/sql/item_create.h
index 05fe48f..efee18e 100644
--- a/sql/item_create.h
+++ b/sql/item_create.h
@@ -165,8 +165,7 @@ class Create_udf_func : public Create_func
 */
 Item *
 create_func_cast(THD *thd, Item *a, Cast_target cast_type,
-                 const char *len, const char *dec,
-                 CHARSET_INFO *cs);
+                 const Create_type_attributes &attr);
 
 Item *create_temporal_literal(THD *thd,
                               const char *str, uint length,
@@ -192,8 +191,7 @@ Item *create_func_dyncol_add(THD *thd, Item *str,
 Item *create_func_dyncol_delete(THD *thd, Item *str, List<Item> &nums);
 Item *create_func_dyncol_get(THD *thd, Item *num, Item *str,
                              Cast_target cast_type,
-                             const char *c_len, const char *c_dec,
-                             CHARSET_INFO *cs);
+                             const Create_type_attributes &attr);
 Item *create_func_dyncol_json(THD *thd, Item *str);
 #endif
 
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index 9a3c758..72e3c99 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -4562,10 +4562,10 @@ void Item_func_dyncol_create::print_arguments(String *str,
     case DYN_COL_DYNCOL:
     case DYN_COL_STRING:
       str->append(STRING_WITH_LEN(" AS char"));
-      if (defs[i].cs)
+      if (defs[i].charset)
       {
         str->append(STRING_WITH_LEN(" charset "));
-        str->append(defs[i].cs->csname);
+        str->append(defs[i].charset->csname);
         str->append(' ');
       }
       break;
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 7eb38b1..62a5510 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -491,7 +491,6 @@ void lex_start(THD *thd)
   lex->parsing_options.reset();
   lex->empty_field_list_on_rset= 0;
   lex->select_lex.select_number= 1;
-  lex->length=0;
   lex->part_info= 0;
   lex->select_lex.in_sum_expr=0;
   lex->select_lex.ftfunc_list_alloc.empty();
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 409358d..fcbda9c 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -2355,8 +2355,34 @@ struct LEX: public Query_tables_list
   Explain_query *explain;
 
   // type information
-  char *length,*dec;
-  CHARSET_INFO *charset;
+  Create_type_attributes *last_attr;
+  CHARSET_INFO *charset() const { return last_attr->charset;  }
+  ulong length() const          { return last_attr->length;   }
+  uint dec() const              { return last_attr->decimals; }
+  bool length_was_set_explicitly() const
+  { return last_attr->length_was_set_explicitly(); }
+
+  void init_last_attributes(CHARSET_INFO *cs= NULL) { last_attr->init(cs); }
+  void set_length(ulong length) { last_attr->set_length(length); }
+  CHARSET_INFO *set_charset(CHARSET_INFO *cs)
+  { return last_attr->charset= cs; }
+  void set_explicit_length(const char *length)
+  { last_attr->set_explicit_length(length); }
+  void set_length_and_dec(const char *length, const char *decimals)
+  {
+    last_attr->set_length(length);
+    last_attr->set_decimals(decimals);
+  }
+  void set_length_and_dec(ulong length, uint decimals)
+  {
+    last_attr->set_length(length);
+    last_attr->set_decimals(decimals);
+  }
+  void set_charset_and_dec(CHARSET_INFO *cs, const char *decimals)
+  {
+    last_attr->set_charset(cs);
+    last_attr->set_decimals(decimals);
+  }
 
   LEX_STRING name;
   char *help_arg;
@@ -2782,8 +2808,7 @@ struct LEX: public Query_tables_list
 
   int print_explain(select_result_sink *output, uint8 explain_flags,
                     bool is_analyze, bool *printed_anything);
-
-  void init_last_field(Create_field *field, const char *name, CHARSET_INFO *cs);
+  void init_last_field(Create_field *field, const char *name);
   void set_last_field_type(enum enum_field_types type);
   bool set_bincmp(CHARSET_INFO *cs, bool bin);
 };
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 7b36d39..ff75b63 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -871,9 +871,10 @@ static void add_key_to_list(LEX *lex, LEX_STRING *field_name,
   lex->col_list.empty();
 }
 
-void LEX::init_last_field(Create_field *field, const char *name, CHARSET_INFO *cs)
+void LEX::init_last_field(Create_field *field, const char *name)
 {
   last_field= field;
+  last_attr= field;
 
   field->field_name= name;
   field->flags= 0;
@@ -885,30 +886,12 @@ void LEX::init_last_field(Create_field *field, const char *name, CHARSET_INFO *c
   field->comment= null_lex_str;
   field->vcol_info= 0;
   field->interval_list.empty();
-
-  /* reset LEX fields that are used in Create_field::set_and_check() */
-  length= 0;
-  dec= 0;
-  charset= cs;
 }
 
 void LEX::set_last_field_type(enum enum_field_types type)
 {
   last_field->sql_type= type;
   last_field->create_if_not_exists= check_exists;
-  last_field->charset= charset;
-
-  if (length)
-  {
-    int err;
-    last_field->length= (ulong)my_strtoll10(length, NULL, &err);
-    if (err)
-      last_field->length= ~0UL; // safety
-  }
-  else
-    last_field->length= 0;
-
-  last_field->decimals= dec ? (uint)atoi(dec) : 0;
 }
 
 bool LEX::set_bincmp(CHARSET_INFO *cs, bool bin)
@@ -919,16 +902,16 @@ bool LEX::set_bincmp(CHARSET_INFO *cs, bool bin)
      field charset is determined in get_sql_field_charset() much later.
      so we only set a flag here.
   */
-  if (!charset)
+  if (!charset())
   {
-    charset= cs;
+    set_charset(cs);
     last_field->flags|= bin ? BINCMP_FLAG : 0;
     return false;
   }
 
-  charset= bin ? find_bin_collation(cs ? cs : charset)
-               :                    cs ? cs : charset;
-  return charset == NULL;
+  set_charset(bin ? find_bin_collation(cs ? cs : charset())
+                  :                    cs ? cs : charset());
+  return charset() == NULL;
 }
 
 #define bincmp_collation(X,Y)           \
@@ -1836,7 +1819,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %type <ha_rkey_mode> handler_rkey_mode
 
-%type <cast_type> cast_type
+%type <cast_type> cast_type create_new_cast_type
 
 %type <symbol> keyword keyword_sp
 
@@ -2904,9 +2887,8 @@ sp_param_name_and_type:
             }
 
             sp_variable *spvar= spc->add_variable(thd, $1);
-
-            lex->init_last_field(&spvar->field_def, $1.str,
-                                 thd->variables.collation_database);
+            lex->init_last_field(&spvar->field_def, $1.str);
+            lex->init_last_attributes(thd->variables.collation_database);
             $<spvar>$= spvar;
           }
           type_with_opt_collate
@@ -3002,8 +2984,8 @@ sp_decl:
 
             lex->sphead->reset_lex(thd);
             pctx->declare_var_boundary($2);
-            thd->lex->init_last_field(&spvar->field_def, spvar->name.str,
-                                      thd->variables.collation_database);
+            thd->lex->init_last_field(&spvar->field_def, spvar->name.str);
+            thd->lex->init_last_attributes(thd->variables.collation_database);
           }
           type_with_opt_collate
           sp_opt_default
@@ -6071,7 +6053,7 @@ field_spec:
             if (!f)
               MYSQL_YYABORT;
 
-            lex->init_last_field(f, $1.str, NULL);
+            lex->init_last_field(f, $1.str);
           }
           field_type  { Lex->set_last_field_type($3); }
           field_def
@@ -6183,24 +6165,22 @@ field_type:
         | FLOAT_SYM float_options field_options
           {
             $$=MYSQL_TYPE_FLOAT;
-            if (Lex->length && !Lex->dec)
+            if (Lex->length_was_set_explicitly() && !Lex->dec())
             {
-              int err;
-              ulonglong tmp_length= my_strtoll10(Lex->length, NULL, &err);
-              if (err || tmp_length > PRECISION_FOR_DOUBLE)
+              if (Lex->length() > PRECISION_FOR_DOUBLE)
               {
                 my_error(ER_WRONG_FIELD_SPEC, MYF(0),
                          Lex->last_field->field_name);
                 MYSQL_YYABORT;
               }
-              else if (tmp_length > PRECISION_FOR_FLOAT)
+              else if (Lex->length() > PRECISION_FOR_FLOAT)
                 $$= MYSQL_TYPE_DOUBLE;
-              Lex->length= 0;
+              Lex->set_length(0);
             }
           }
         | BIT_SYM
           {
-            Lex->length= (char*) "1";
+            Lex->set_length(1);
             $$=MYSQL_TYPE_BIT;
           }
         | BIT_SYM field_length
@@ -6209,12 +6189,12 @@ field_type:
           }
         | BOOL_SYM
           {
-            Lex->length= (char*) "1";
+            Lex->set_length(1);
             $$=MYSQL_TYPE_TINY;
           }
         | BOOLEAN_SYM
           {
-            Lex->length= (char*) "1";
+            Lex->set_length(1);
             $$=MYSQL_TYPE_TINY;
           }
         | char field_length opt_binary
@@ -6223,7 +6203,7 @@ field_type:
           }
         | char opt_binary
           {
-            Lex->length= (char*) "1";
+            Lex->set_length(1);
             $$=MYSQL_TYPE_STRING;
           }
         | nchar field_length opt_bin_mod
@@ -6233,19 +6213,19 @@ field_type:
           }
         | nchar opt_bin_mod
           {
-            Lex->length= (char*) "1";
+            Lex->set_length(1);
             $$=MYSQL_TYPE_STRING;
             bincmp_collation(national_charset_info, $2);
           }
         | BINARY field_length
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_STRING;
           }
         | BINARY
           {
-            Lex->length= (char*) "1";
-            Lex->charset=&my_charset_bin;
+            Lex->set_length(1);
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_STRING;
           }
         | varchar field_length opt_binary
@@ -6259,19 +6239,17 @@ field_type:
           }
         | VARBINARY field_length
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$= MYSQL_TYPE_VARCHAR;
           }
         | YEAR_SYM opt_field_length field_options
           {
-            if (Lex->length)
+            if (Lex->length_was_set_explicitly())
             {
-              errno= 0;
-              ulong length= strtoul(Lex->length, NULL, 10);
-              if (errno == 0 && length <= MAX_FIELD_BLOBLENGTH && length != 4)
+              if (Lex->length() <= MAX_FIELD_BLOBLENGTH && Lex->length() != 4)
               {
                 char buff[sizeof("YEAR()") + MY_INT64_NUM_DECIMAL_DIGITS + 1];
-                my_snprintf(buff, sizeof(buff), "YEAR(%lu)", length);
+                my_snprintf(buff, sizeof(buff), "YEAR(%lu)", Lex->length());
                 push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
                                     ER_WARN_DEPRECATED_SYNTAX,
                                     ER(ER_WARN_DEPRECATED_SYNTAX),
@@ -6305,18 +6283,18 @@ field_type:
                 MYSQL_TYPE_DATETIME2 : MYSQL_TYPE_DATETIME; }
         | TINYBLOB
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_TINY_BLOB;
           }
         | BLOB_SYM opt_field_length
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_BLOB;
           }
         | spatial_type
           {
 #ifdef HAVE_SPATIAL
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             Lex->last_field->geom_type= $1;
             $$=MYSQL_TYPE_GEOMETRY;
 #else
@@ -6327,17 +6305,17 @@ field_type:
           }
         | MEDIUMBLOB
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_MEDIUM_BLOB;
           }
         | LONGBLOB
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_LONG_BLOB;
           }
         | LONG_SYM VARBINARY
           {
-            Lex->charset=&my_charset_bin;
+            Lex->set_charset(&my_charset_bin);
             $$=MYSQL_TYPE_MEDIUM_BLOB;
           }
         | LONG_SYM varchar opt_binary
@@ -6375,8 +6353,7 @@ spatial_type:
         | GEOMETRYCOLLECTION  { $$= Field::GEOM_GEOMETRYCOLLECTION; }
         | POINT_SYM
           {
-            Lex->length= const_cast<char*>(STRINGIFY_ARG
-                                           (MAX_LEN_GEOM_POINT_FIELD));
+            Lex->set_length(MAX_LEN_GEOM_POINT_FIELD);
             $$= Field::GEOM_POINT;
           }
         | MULTIPOINT          { $$= Field::GEOM_MULTIPOINT; }
@@ -6430,9 +6407,9 @@ real_type:
 
 float_options:
           /* empty */
-          { Lex->dec=Lex->length= (char*)0; }
+          { }
         | field_length
-          { Lex->dec= (char*)0; }
+          { }
         | precision
           {}
         ;
@@ -6440,9 +6417,7 @@ float_options:
 precision:
           '(' NUM ',' NUM ')'
           {
-            LEX *lex=Lex;
-            lex->length=$2.str;
-            lex->dec=$4.str;
+            Lex->set_length_and_dec($2.str, $4.str);
           }
         ;
 
@@ -6463,13 +6438,13 @@ field_option:
         ;
 
 field_length:
-          '(' LONG_NUM ')'      { Lex->length= $2.str; }
-        | '(' ULONGLONG_NUM ')' { Lex->length= $2.str; }
-        | '(' DECIMAL_NUM ')'   { Lex->length= $2.str; }
-        | '(' NUM ')'           { Lex->length= $2.str; };
+          '(' LONG_NUM ')'      { Lex->set_explicit_length($2.str); }
+        | '(' ULONGLONG_NUM ')' { Lex->set_explicit_length($2.str); }
+        | '(' DECIMAL_NUM ')'   { Lex->set_explicit_length($2.str); }
+        | '(' NUM ')'           { Lex->set_explicit_length($2.str); };
 
 opt_field_length:
-          /* empty */  { Lex->length=(char*) 0; /* use default length */ }
+          /* empty */  { /* use default length */ }
         | field_length { }
         ;
 
@@ -6527,10 +6502,10 @@ attribute:
         | COMMENT_SYM TEXT_STRING_sys { Lex->last_field->comment= $2; }
         | COLLATE_SYM collation_name
           {
-            if (Lex->charset && !my_charset_same(Lex->charset,$2))
+            if (Lex->charset() && !my_charset_same(Lex->charset(), $2))
             {
               my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
-                       $2->name,Lex->charset->csname);
+                       $2->name, Lex->charset()->csname);
               MYSQL_YYABORT;
             }
             else
@@ -6571,7 +6546,7 @@ type_with_opt_collate:
 
           if ($2)
           {
-            if (!(Lex->charset= merge_charset_and_collation(Lex->charset, $2)))
+            if (!(Lex->set_charset(merge_charset_and_collation(Lex->charset(), $2))))
               MYSQL_YYABORT;
           }
           Lex->set_last_field_type($1);
@@ -9006,117 +8981,54 @@ all_or_any:
         ;
 
 opt_dyncol_type:
-          /* empty */ 
-          {
-            LEX *lex= Lex;
-	    $$= DYN_COL_NULL; /* automatic type */
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
-	  }
+          /* empty */    { $$= DYN_COL_NULL; } /* automatic type */
         | AS dyncol_type { $$= $2; }
         ;
 
 dyncol_type:
-          INT_SYM
-          {
-            LEX *lex= Lex;
-            $$= DYN_COL_INT;
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
-          }
-        | UNSIGNED INT_SYM 
-          {
-            LEX *lex= Lex;
-            $$= DYN_COL_UINT;
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
-          }
-        | DOUBLE_SYM
-          {
-            LEX *lex= Lex;
-            $$= DYN_COL_DOUBLE;
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
-          }
-        | REAL
-          {
-            LEX *lex= Lex;
-            $$= DYN_COL_DOUBLE;
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
-          }
-        | FLOAT_SYM
-          {
-            LEX *lex= Lex;
-            $$= DYN_COL_DOUBLE;
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
-          }
-        | DECIMAL_SYM float_options
-          {
-            $$= DYN_COL_DECIMAL;
-            Lex->charset= NULL;
-          }
+          INT_SYM                   { $$= DYN_COL_INT;     }
+        | UNSIGNED INT_SYM          { $$= DYN_COL_UINT;    }
+        | DOUBLE_SYM                { $$= DYN_COL_DOUBLE;  }
+        | REAL                      { $$= DYN_COL_DOUBLE;  }
+        | FLOAT_SYM                 { $$= DYN_COL_DOUBLE;  }
+        | DECIMAL_SYM float_options { $$= DYN_COL_DECIMAL; }
+        | DATE_SYM                  { $$= DYN_COL_DATE;    }
         | char
-          { Lex->charset= thd->variables.collation_connection; }
+          { Lex->set_charset(thd->variables.collation_connection); }
           opt_binary
           {
-            LEX *lex= Lex;
             $$= DYN_COL_STRING;
-            lex->length= lex->dec= 0;
           }
         | nchar
           {
-            LEX *lex= Lex;
             $$= DYN_COL_STRING;
-            lex->charset= national_charset_info;
-            lex->length= lex->dec= 0;
-          }
-        | DATE_SYM
-          {
-            LEX *lex= Lex;
-            $$= DYN_COL_DATE;
-            lex->charset= NULL;
-            lex->length= lex->dec= 0;
+            Lex->set_charset(national_charset_info);
           }
         | TIME_SYM opt_field_length
           {
-            LEX *lex= Lex;
             $$= DYN_COL_TIME;
-            lex->charset= NULL;
-            lex->dec= lex->length;
-            lex->length= 0;
+            Lex->set_length_and_dec(0, Lex->length()); // Move length to dec
           }
         | DATETIME opt_field_length
           {
-            LEX *lex= Lex;
             $$= DYN_COL_DATETIME;
-            lex->charset= NULL;
-            lex->dec= lex->length;
-            lex->length= 0;
+            Lex->set_length_and_dec(0, Lex->length()); // Move length to dec
           }
         ;
 
 dyncall_create_element:
-   expr ',' expr opt_dyncol_type
+   expr ',' expr
    {
-     LEX *lex= Lex;
-     $$= (DYNCALL_CREATE_DEF *)
-       alloc_root(thd->mem_root, sizeof(DYNCALL_CREATE_DEF));
-     if ($$ == NULL)
+     if (!(Lex->last_attr= new DYNCALL_CREATE_DEF()))
        MYSQL_YYABORT;
+   }
+   opt_dyncol_type
+   {
+     LEX *lex= Lex;
+     $$= (DYNCALL_CREATE_DEF*) lex->last_attr;
      $$->key= $1;
      $$->value= $3;
-     $$->type= (DYNAMIC_COLUMN_TYPE)$4;
-     $$->cs= lex->charset;
-     if (lex->length)
-       $$->len= strtoul(lex->length, NULL, 10);
-     else
-       $$->len= 0;
-     if (lex->dec)
-       $$->frac= strtoul(lex->dec, NULL, 10);
-     else
-       $$->len= 0;
+     $$->type= (DYNAMIC_COLUMN_TYPE)$5;
    }
 
 dyncall_create_list:
@@ -9246,16 +9158,15 @@ simple_expr:
           }
         | BINARY simple_expr %prec NEG
           {
-            $$= create_func_cast(thd, $2, ITEM_CAST_CHAR, NULL, NULL,
-                                 &my_charset_bin);
+            $$= create_func_cast(thd, $2, ITEM_CAST_CHAR,
+                          Create_type_attributes(NULL, NULL, &my_charset_bin));
             if ($$ == NULL)
               MYSQL_YYABORT;
           }
-        | CAST_SYM '(' expr AS cast_type ')'
+        | CAST_SYM '(' expr AS create_new_cast_type ')'
           {
             LEX *lex= Lex;
-            $$= create_func_cast(thd, $3, $5, lex->length, lex->dec,
-                                 lex->charset);
+            $$= create_func_cast(thd, $3, $5, lex->last_attr[0]);
             if ($$ == NULL)
               MYSQL_YYABORT;
           }
@@ -9265,10 +9176,9 @@ simple_expr:
             if ($$ == NULL)
               MYSQL_YYABORT;
           }
-        | CONVERT_SYM '(' expr ',' cast_type ')'
+        | CONVERT_SYM '(' expr ',' create_new_cast_type ')'
           {
-            $$= create_func_cast(thd, $3, $5, Lex->length, Lex->dec,
-                                 Lex->charset);
+            $$= create_func_cast(thd, $3, $5, Lex->last_attr[0]);
             if ($$ == NULL)
               MYSQL_YYABORT;
           }
@@ -9700,12 +9610,10 @@ function_call_nonkeyword:
               MYSQL_YYABORT;
           }
         |
-          COLUMN_GET_SYM '(' expr ',' expr AS cast_type ')'
+          COLUMN_GET_SYM '(' expr ',' expr AS create_new_cast_type ')'
           {
             LEX *lex= Lex;
-            $$= create_func_dyncol_get(thd, $3, $5, $7,
-                                        lex->length, lex->dec,
-                                        lex->charset);
+            $$= create_func_dyncol_get(thd, $3, $5, $7, lex->last_attr[0]);
             if ($$ == NULL)
               MYSQL_YYABORT;
           }
@@ -10374,45 +10282,39 @@ in_sum_expr:
           }
         ;
 
+create_new_cast_type:
+        /* Empty*/ { Lex->last_attr= new Create_type_attributes(); }
+        cast_type  { $$= $2; }
+        ;
+
 cast_type:
           BINARY opt_field_length
-          { $$=ITEM_CAST_CHAR; Lex->charset= &my_charset_bin; Lex->dec= 0; }
+          { $$=ITEM_CAST_CHAR; Lex->set_charset(&my_charset_bin); }
         | CHAR_SYM opt_field_length
-          { Lex->charset= thd->variables.collation_connection; }
-          opt_binary
-          { $$=ITEM_CAST_CHAR; Lex->dec= 0; }
+          { Lex->set_charset(thd->variables.collation_connection); }
+          opt_binary                { $$=ITEM_CAST_CHAR; }
         | NCHAR_SYM opt_field_length
-          { $$=ITEM_CAST_CHAR; Lex->charset= national_charset_info; Lex->dec=0; }
-        | INT_SYM
-          { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
-        | SIGNED_SYM
-          { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
-        | SIGNED_SYM INT_SYM
-          { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
-        | UNSIGNED
-          { $$=ITEM_CAST_UNSIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
-        | UNSIGNED INT_SYM
-          { $$=ITEM_CAST_UNSIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
-        | DATE_SYM
-          { $$=ITEM_CAST_DATE; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
+          { $$=ITEM_CAST_CHAR; Lex->set_charset_and_dec(national_charset_info, 0); }
+        | INT_SYM                   { $$=ITEM_CAST_SIGNED_INT; }
+        | SIGNED_SYM                { $$=ITEM_CAST_SIGNED_INT; }
+        | SIGNED_SYM INT_SYM        { $$=ITEM_CAST_SIGNED_INT; }
+        | UNSIGNED                  { $$=ITEM_CAST_UNSIGNED_INT; }
+        | UNSIGNED INT_SYM          { $$=ITEM_CAST_UNSIGNED_INT; }
+        | DATE_SYM                  { $$=ITEM_CAST_DATE; }
         | TIME_SYM opt_field_length
           {
             $$=ITEM_CAST_TIME;
             LEX *lex= Lex;
-            lex->charset= NULL; lex->dec= lex->length; lex->length= (char*)0;
+            lex->set_length_and_dec(0, lex->length());
            }
         | DATETIME opt_field_length
           {
             $$=ITEM_CAST_DATETIME;
             LEX *lex= Lex;
-            lex->charset= NULL; lex->dec= lex->length; lex->length= (char*)0;
+            lex->set_length_and_dec(0, lex->length()); // Swap dec and length
            }
-        | DECIMAL_SYM float_options
-          { $$=ITEM_CAST_DECIMAL; Lex->charset= NULL; }
-        | DOUBLE_SYM
-          { Lex->charset= NULL; Lex->length= Lex->dec= 0;}
-          opt_precision
-          { $$=ITEM_CAST_DOUBLE; }
+        | DECIMAL_SYM float_options { $$=ITEM_CAST_DECIMAL; }
+        | DOUBLE_SYM opt_precision  { $$=ITEM_CAST_DOUBLE; }
 
 opt_expr_list:
           /* empty */ { $$= NULL; }
@@ -16184,8 +16086,8 @@ sf_tail:
           RETURNS_SYM /* $9 */
           { /* $10 */
             LEX *lex= Lex;
-            lex->init_last_field(&lex->sphead->m_return_field_def, NULL,
-                                 thd->variables.collation_database);
+            lex->init_last_field(&lex->sphead->m_return_field_def, NULL);
+            lex->init_last_attributes(thd->variables.collation_database);
           }
           type_with_opt_collate /* $11 */
           { /* $12 */
diff --git a/sql/structs.h b/sql/structs.h
index 99561c5..20af8e0 100644
--- a/sql/structs.h
+++ b/sql/structs.h
@@ -471,4 +471,72 @@ class Discrete_intervals_list {
   Discrete_interval* get_current() const { return current; };
 };
 
+
+struct Create_type_attributes_st
+{
+  bool m_length_was_set_explicitly;
+public:
+  /*
+    When in Create_field:
+    At various stages in execution this can be length of field in bytes or
+    max number of characters. 
+  */
+  ulong length;
+  uint decimals;
+  CHARSET_INFO *charset;
+
+  bool length_was_set_explicitly() const
+  { return m_length_was_set_explicitly; }
+
+  void init(CHARSET_INFO *cs= NULL)
+  {
+    charset= cs;
+    length= 0;
+    decimals= 0;
+    m_length_was_set_explicitly= false;
+  }
+  bool check(const char *field_name) const;
+  void set_charset(CHARSET_INFO *cs) { charset= cs; }
+  void set_decimals(uint dec)        { decimals= dec; }
+  void set_decimals(const char *dec) { decimals= dec ? (uint) atoi(dec) : 0; }
+  void set_length(const char *length_arg)
+  {
+    if (length_arg)
+    {
+      int err;
+      length= (ulong)my_strtoll10(length_arg, NULL, &err);
+      if (err)
+        length= ~0UL; // safety
+    }
+    else
+      length= 0;
+    m_length_was_set_explicitly= false;
+  }
+  void set(const char *length_arg, const char *dec_arg, CHARSET_INFO *cs)
+  {
+    charset= cs;
+    set_length(length_arg);
+    set_decimals(dec_arg);
+    m_length_was_set_explicitly= length_arg != NULL;
+  }
+  void set(ulong length_arg, uint dec_arg, CHARSET_INFO *cs)
+  {
+    charset= cs;
+    set_length(length_arg);
+    set_decimals(dec_arg);
+    m_length_was_set_explicitly= false;
+  }
+  void set_explicit_length(const char *length)
+  {    
+    set_length(length);
+    m_length_was_set_explicitly= true;
+  }
+  void set_length(ulong length_arg)
+  {
+    length= length_arg;
+    m_length_was_set_explicitly= false;
+  }
+};
+
+
 #endif /* STRUCTS_INCLUDED */
