MDEV-20052 Add a MEM_ROOT pointer argument to Type_handler::make_xxx_field()

1 files changed, 213 insertions, 151 deletions

diff --git a/sql/sql_type.cc b/sql/sql_type.cc
index 0268e36ca5b..5cecd9f50f7 100644
--- a/sql/sql_type.cc
+++ b/sql/sql_type.cc
@@ -2000,7 +2000,8 @@ Type_handler_int_result::make_num_distinct_aggregator_field(MEM_ROOT *mem_root,
 
 /***********************************************************************/
 
-Field *Type_handler_tiny::make_conversion_table_field(TABLE *table,
+Field *Type_handler_tiny::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
@@ -2011,84 +2012,91 @@ Field *Type_handler_tiny::make_conversion_table_field(TABLE *table,
     using conversions so it should be true also when using conversions.
   */
   bool unsigned_flag= ((Field_num*) target)->unsigned_flag;
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_tiny(NULL, 4 /*max_length*/, (uchar *) "", 1, Field::NONE,
                     &empty_clex_str, 0/*zerofill*/, unsigned_flag);
 }
 
 
-Field *Type_handler_short::make_conversion_table_field(TABLE *table,
+Field *Type_handler_short::make_conversion_table_field(MEM_ROOT *root,
+                                                       TABLE *table,
                                                        uint metadata,
                                                        const Field *target)
                                                        const
 {
   bool unsigned_flag= ((Field_num*) target)->unsigned_flag;
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_short(NULL, 6 /*max_length*/, (uchar *) "", 1, Field::NONE,
                      &empty_clex_str, 0/*zerofill*/, unsigned_flag);
 }
 
 
-Field *Type_handler_int24::make_conversion_table_field(TABLE *table,
+Field *Type_handler_int24::make_conversion_table_field(MEM_ROOT *root,
+                                                       TABLE *table,
                                                        uint metadata,
                                                        const Field *target)
                                                        const
 {
   bool unsigned_flag= ((Field_num*) target)->unsigned_flag;
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_medium(NULL, 9 /*max_length*/, (uchar *) "", 1, Field::NONE,
                       &empty_clex_str, 0/*zerofill*/, unsigned_flag);
 }
 
 
-Field *Type_handler_long::make_conversion_table_field(TABLE *table,
+Field *Type_handler_long::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
 {
   bool unsigned_flag= ((Field_num*) target)->unsigned_flag;
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_long(NULL, 11 /*max_length*/, (uchar *) "", 1, Field::NONE,
          &empty_clex_str, 0/*zerofill*/, unsigned_flag);
 }
 
 
-Field *Type_handler_longlong::make_conversion_table_field(TABLE *table,
+Field *Type_handler_longlong::make_conversion_table_field(MEM_ROOT *root,
+                                                          TABLE *table,
                                                           uint metadata,
                                                           const Field *target)
                                                           const
 {
   bool unsigned_flag= ((Field_num*) target)->unsigned_flag;
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_longlong(NULL, 20 /*max_length*/,(uchar *) "", 1, Field::NONE,
                         &empty_clex_str, 0/*zerofill*/, unsigned_flag);
 }
 
 
 
-Field *Type_handler_float::make_conversion_table_field(TABLE *table,
+Field *Type_handler_float::make_conversion_table_field(MEM_ROOT *root,
+                                                       TABLE *table,
                                                        uint metadata,
                                                        const Field *target)
                                                        const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_float(NULL, 12 /*max_length*/, (uchar *) "", 1, Field::NONE,
                      &empty_clex_str, 0/*dec*/, 0/*zerofill*/, 0/*unsigned_flag*/);
 }
 
 
-Field *Type_handler_double::make_conversion_table_field(TABLE *table,
+Field *Type_handler_double::make_conversion_table_field(MEM_ROOT *root,
+                                                        TABLE *table,
                                                         uint metadata,
                                                         const Field *target)
                                                         const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_double(NULL, 22 /*max_length*/, (uchar *) "", 1, Field::NONE,
                       &empty_clex_str, 0/*dec*/, 0/*zerofill*/, 0/*unsigned_flag*/);
 }
 
 
-Field *Type_handler_newdecimal::make_conversion_table_field(TABLE *table,
+Field *Type_handler_newdecimal::make_conversion_table_field(MEM_ROOT *root, 
+                                                            TABLE *table,
                                                             uint metadata,
                                                             const Field *target)
                                                             const
@@ -2097,13 +2105,14 @@ Field *Type_handler_newdecimal::make_conversion_table_field(TABLE *table,
   uint8 decimals= metadata & 0x00ff;
   uint32 max_length= my_decimal_precision_to_length(precision, decimals, false);
   DBUG_ASSERT(decimals <= DECIMAL_MAX_SCALE);
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_new_decimal(NULL, max_length, (uchar *) "", 1, Field::NONE,
                            &empty_clex_str, decimals, 0/*zerofill*/, 0/*unsigned*/);
 }
 
 
-Field *Type_handler_olddecimal::make_conversion_table_field(TABLE *table,
+Field *Type_handler_olddecimal::make_conversion_table_field(MEM_ROOT *root,
+                                                            TABLE *table,
                                                             uint metadata,
                                                             const Field *target)
                                                             const
@@ -2120,152 +2129,168 @@ Field *Type_handler_olddecimal::make_conversion_table_field(TABLE *table,
 }
 
 
-Field *Type_handler_year::make_conversion_table_field(TABLE *table,
+Field *Type_handler_year::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_year(NULL, 4, (uchar *) "", 1, Field::NONE, &empty_clex_str);
 }
 
 
-Field *Type_handler_null::make_conversion_table_field(TABLE *table,
+Field *Type_handler_null::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_null(NULL, 0, Field::NONE, &empty_clex_str, target->charset());
 }
 
 
-Field *Type_handler_timestamp::make_conversion_table_field(TABLE *table,
+Field *Type_handler_timestamp::make_conversion_table_field(MEM_ROOT *root,
+                                                           TABLE *table,
                                                            uint metadata,
                                                            const Field *target)
                                                            const
 {
-  return new_Field_timestamp(table->in_use->mem_root, NULL, (uchar *) "", 1,
-                           Field::NONE, &empty_clex_str, table->s, target->decimals());
+  return new_Field_timestamp(root, NULL, (uchar *) "", 1,
+                             Field::NONE, &empty_clex_str,
+                             table->s, target->decimals());
 }
 
 
-Field *Type_handler_timestamp2::make_conversion_table_field(TABLE *table,
+Field *Type_handler_timestamp2::make_conversion_table_field(MEM_ROOT *root,
+                                                            TABLE *table,
                                                             uint metadata,
                                                             const Field *target)
                                                             const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_timestampf(NULL, (uchar *) "", 1, Field::NONE,
                           &empty_clex_str, table->s, metadata);
 }
 
 
-Field *Type_handler_newdate::make_conversion_table_field(TABLE *table,
+Field *Type_handler_newdate::make_conversion_table_field(MEM_ROOT *root,
+                                                         TABLE *table,
                                                          uint metadata,
                                                          const Field *target)
                                                          const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_newdate(NULL, (uchar *) "", 1, Field::NONE, &empty_clex_str);
 }
 
 
-Field *Type_handler_date::make_conversion_table_field(TABLE *table,
+Field *Type_handler_date::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_date(NULL, (uchar *) "", 1, Field::NONE, &empty_clex_str);
 }
 
 
-Field *Type_handler_time::make_conversion_table_field(TABLE *table,
+Field *Type_handler_time::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
 {
-  return new_Field_time(table->in_use->mem_root, NULL, (uchar *) "", 1,
+  return new_Field_time(root, NULL, (uchar *) "", 1,
                         Field::NONE, &empty_clex_str, target->decimals());
 }
 
 
-Field *Type_handler_time2::make_conversion_table_field(TABLE *table,
+Field *Type_handler_time2::make_conversion_table_field(MEM_ROOT *root,
+                                                       TABLE *table,
                                                        uint metadata,
                                                        const Field *target)
                                                        const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_timef(NULL, (uchar *) "", 1, Field::NONE, &empty_clex_str, metadata);
 }
 
 
-Field *Type_handler_datetime::make_conversion_table_field(TABLE *table,
+Field *Type_handler_datetime::make_conversion_table_field(MEM_ROOT *root,
+                                                          TABLE *table,
                                                           uint metadata,
                                                           const Field *target)
                                                           const
 {
-  return new_Field_datetime(table->in_use->mem_root, NULL, (uchar *) "", 1,
+  return new_Field_datetime(root, NULL, (uchar *) "", 1,
                             Field::NONE, &empty_clex_str, target->decimals());
 }
 
 
-Field *Type_handler_datetime2::make_conversion_table_field(TABLE *table,
+Field *Type_handler_datetime2::make_conversion_table_field(MEM_ROOT *root,
+                                                           TABLE *table,
                                                            uint metadata,
                                                            const Field *target)
                                                            const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_datetimef(NULL, (uchar *) "", 1,
                          Field::NONE, &empty_clex_str, metadata);
 }
 
 
-Field *Type_handler_bit::make_conversion_table_field(TABLE *table,
+Field *Type_handler_bit::make_conversion_table_field(MEM_ROOT *root,
+                                                     TABLE *table,
                                                      uint metadata,
                                                      const Field *target)
                                                      const
 {
   DBUG_ASSERT((metadata & 0xff) <= 7);
   uint32 max_length= 8 * (metadata >> 8U) + (metadata & 0x00ff);
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_bit_as_char(NULL, max_length, (uchar *) "", 1,
                            Field::NONE, &empty_clex_str);
 }
 
 
-Field *Type_handler_string::make_conversion_table_field(TABLE *table,
+Field *Type_handler_string::make_conversion_table_field(MEM_ROOT *root,
+                                                        TABLE *table,
                                                         uint metadata,
                                                         const Field *target)
                                                         const
 {
   /* This is taken from Field_string::unpack. */
   uint32 max_length= (((metadata >> 4) & 0x300) ^ 0x300) + (metadata & 0x00ff);
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_string(NULL, max_length, (uchar *) "", 1,
                       Field::NONE, &empty_clex_str, target->charset());
 }
 
 
-Field *Type_handler_varchar::make_conversion_table_field(TABLE *table,
+Field *Type_handler_varchar::make_conversion_table_field(MEM_ROOT *root,
+                                                         TABLE *table,
                                                          uint metadata,
                                                          const Field *target)
                                                          const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_varstring(NULL, metadata, HA_VARCHAR_PACKLENGTH(metadata),
                          (uchar *) "", 1, Field::NONE, &empty_clex_str,
                          table->s, target->charset());
 }
 
 
-Field *Type_handler_varchar_compressed::make_conversion_table_field(TABLE *table,
+Field *Type_handler_varchar_compressed::make_conversion_table_field(
+                                                         MEM_ROOT *root, 
+                                                         TABLE *table,
                                                          uint metadata,
                                                          const Field *target)
                                                          const
 {
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_varstring_compressed(NULL, metadata,
                                     HA_VARCHAR_PACKLENGTH(metadata),
                                     (uchar *) "", 1, Field::NONE,
@@ -2276,7 +2301,9 @@ Field *Type_handler_varchar_compressed::make_conversion_table_field(TABLE *table
 
 
 
-Field *Type_handler_blob_compressed::make_conversion_table_field(TABLE *table,
+Field *Type_handler_blob_compressed::make_conversion_table_field(
+                                                      MEM_ROOT *root, 
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
@@ -2284,7 +2311,7 @@ Field *Type_handler_blob_compressed::make_conversion_table_field(TABLE *table,
   uint pack_length= metadata & 0x00ff;
   if (pack_length < 1 || pack_length > 4)
     return NULL; // Broken binary log?
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_blob_compressed(NULL, (uchar *) "", 1, Field::NONE,
                                &empty_clex_str,
                                table->s, pack_length, target->charset(),
@@ -2292,14 +2319,15 @@ Field *Type_handler_blob_compressed::make_conversion_table_field(TABLE *table,
 }
 
 
-Field *Type_handler_enum::make_conversion_table_field(TABLE *table,
+Field *Type_handler_enum::make_conversion_table_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       uint metadata,
                                                       const Field *target)
                                                       const
 {
   DBUG_ASSERT(target->type() == MYSQL_TYPE_STRING);
   DBUG_ASSERT(target->real_type() == MYSQL_TYPE_ENUM);
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_enum(NULL, target->field_length,
                     (uchar *) "", 1, Field::NONE, &empty_clex_str,
                     metadata & 0x00ff/*pack_length()*/,
@@ -2307,14 +2335,15 @@ Field *Type_handler_enum::make_conversion_table_field(TABLE *table,
 }
 
 
-Field *Type_handler_set::make_conversion_table_field(TABLE *table,
+Field *Type_handler_set::make_conversion_table_field(MEM_ROOT *root,
+                                                     TABLE *table,
                                                      uint metadata,
                                                      const Field *target)
                                                      const
 {
   DBUG_ASSERT(target->type() == MYSQL_TYPE_STRING);
   DBUG_ASSERT(target->real_type() == MYSQL_TYPE_SET);
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_set(NULL, target->field_length,
                    (uchar *) "", 1, Field::NONE, &empty_clex_str,
                    metadata & 0x00ff/*pack_length()*/,
@@ -2322,7 +2351,7 @@ Field *Type_handler_set::make_conversion_table_field(TABLE *table,
 }
 
 
-Field *Type_handler_enum::make_schema_field(TABLE *table,
+Field *Type_handler_enum::make_schema_field(MEM_ROOT *root, TABLE *table,
                                             const Record_addr &addr,
                                             const ST_FIELD_INFO &def,
                                             bool show_field) const
@@ -2334,7 +2363,7 @@ Field *Type_handler_enum::make_schema_field(TABLE *table,
     Assume I_S columns don't have non-ASCII characters in names.
     If we eventually want to, Typelib::max_char_length() must be implemented.
   */
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_enum(addr.ptr(), (uint32) typelib->max_octet_length(),
                     addr.null_ptr(), addr.null_bit(),
                     Field::NONE, &name,
@@ -2995,49 +3024,53 @@ uint32 Type_handler_enum::calc_pack_length(uint32 length) const
 
 
 /*************************************************************************/
-Field *Type_handler::make_and_init_table_field(const LEX_CSTRING *name,
+Field *Type_handler::make_and_init_table_field(MEM_ROOT *root,
+                                               const LEX_CSTRING *name,
                                                const Record_addr &addr,
                                                const Type_all_attributes &attr,
                                                TABLE *table) const
 {
-  Field *field= make_table_field(name, addr, attr, table);
+  Field *field= make_table_field(root, name, addr, attr, table);
   if (field)
     field->init(table);
   return field;
 }
 
 
-Field *Type_handler_tiny::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_tiny::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_tiny(addr.ptr(), attr.max_char_length(),
                     addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name, 0/*zerofill*/, attr.unsigned_flag);
 }
 
 
-Field *Type_handler_short::make_table_field(const LEX_CSTRING *name,
-                                           const Record_addr &addr,
-                                           const Type_all_attributes &attr,
-                                           TABLE *table) const
+Field *Type_handler_short::make_table_field(MEM_ROOT *root,
+                                            const LEX_CSTRING *name,
+                                            const Record_addr &addr,
+                                            const Type_all_attributes &attr,
+                                            TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_short(addr.ptr(), attr.max_char_length(),
                      addr.null_ptr(), addr.null_bit(),
                      Field::NONE, name, 0/*zerofill*/, attr.unsigned_flag);
 }
 
 
-Field *Type_handler_int24::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_int24::make_table_field(MEM_ROOT *root,
+                                            const LEX_CSTRING *name,
                                             const Record_addr &addr,
                                             const Type_all_attributes &attr,
                                             TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_medium(addr.ptr(), attr.max_char_length(),
                       addr.null_ptr(), addr.null_bit(),
                       Field::NONE, name,
@@ -3045,24 +3078,26 @@ Field *Type_handler_int24::make_table_field(const LEX_CSTRING *name,
 }
 
 
-Field *Type_handler_long::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_long::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_long(addr.ptr(), attr.max_char_length(),
                     addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name, 0/*zerofill*/, attr.unsigned_flag);
 }
 
 
-Field *Type_handler_longlong::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_longlong::make_table_field(MEM_ROOT *root,
+                                               const LEX_CSTRING *name,
                                                const Record_addr &addr,
                                                const Type_all_attributes &attr,
                                                TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_longlong(addr.ptr(), attr.max_char_length(),
                         addr.null_ptr(), addr.null_bit(),
                         Field::NONE, name,
@@ -3070,12 +3105,13 @@ Field *Type_handler_longlong::make_table_field(const LEX_CSTRING *name,
 }
 
 
-Field *Type_handler_vers_trx_id::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_vers_trx_id::make_table_field(MEM_ROOT *root,
+                                               const LEX_CSTRING *name,
                                                const Record_addr &addr,
                                                const Type_all_attributes &attr,
                                                TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_vers_trx_id(addr.ptr(), attr.max_char_length(),
                         addr.null_ptr(), addr.null_bit(),
                         Field::NONE, name,
@@ -3083,12 +3119,13 @@ Field *Type_handler_vers_trx_id::make_table_field(const LEX_CSTRING *name,
 }
 
 
-Field *Type_handler_float::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_float::make_table_field(MEM_ROOT *root,
+                                            const LEX_CSTRING *name,
                                             const Record_addr &addr,
                                             const Type_all_attributes &attr,
                                             TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_float(addr.ptr(), attr.max_char_length(),
                      addr.null_ptr(), addr.null_bit(),
                      Field::NONE, name,
@@ -3096,12 +3133,13 @@ Field *Type_handler_float::make_table_field(const LEX_CSTRING *name,
 }
 
 
-Field *Type_handler_double::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_double::make_table_field(MEM_ROOT *root,
+                                             const LEX_CSTRING *name,
                                              const Record_addr &addr,
                                              const Type_all_attributes &attr,
                                              TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_double(addr.ptr(), attr.max_char_length(),
                       addr.null_ptr(), addr.null_bit(),
                       Field::NONE, name,
@@ -3110,7 +3148,8 @@ Field *Type_handler_double::make_table_field(const LEX_CSTRING *name,
 
 
 Field *
-Type_handler_olddecimal::make_table_field(const LEX_CSTRING *name,
+Type_handler_olddecimal::make_table_field(MEM_ROOT *root,
+                                          const LEX_CSTRING *name,
                                           const Record_addr &addr,
                                           const Type_all_attributes &attr,
                                           TABLE *table) const
@@ -3123,7 +3162,7 @@ Type_handler_olddecimal::make_table_field(const LEX_CSTRING *name,
     in make_field() in field.cc, to open old tables with old decimal.
   */
   DBUG_ASSERT(0);
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_decimal(addr.ptr(), attr.max_length,
                        addr.null_ptr(), addr.null_bit(),
                        Field::NONE, name, (uint8) attr.decimals,
@@ -3132,7 +3171,8 @@ Type_handler_olddecimal::make_table_field(const LEX_CSTRING *name,
 
 
 Field *
-Type_handler_newdecimal::make_table_field(const LEX_CSTRING *name,
+Type_handler_newdecimal::make_table_field(MEM_ROOT *root,
+                                          const LEX_CSTRING *name,
                                           const Record_addr &addr,
                                           const Type_all_attributes &attr,
                                           TABLE *table) const
@@ -3171,50 +3211,54 @@ Type_handler_newdecimal::make_table_field(const LEX_CSTRING *name,
       /* Corrected value fits. */
       len= required_length;
   }
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_new_decimal(addr.ptr(), len, addr.null_ptr(), addr.null_bit(),
                            Field::NONE, name,
                            dec, 0/*zerofill*/, attr.unsigned_flag);
 }
 
 
-Field *Type_handler_year::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_year::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_year(addr.ptr(), attr.max_length,
                     addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name);
 }
 
 
-Field *Type_handler_null::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_null::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_null(addr.ptr(), attr.max_length,
                     Field::NONE, name, attr.collation.collation);
 }
 
 
-Field *Type_handler_timestamp::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_timestamp::make_table_field(MEM_ROOT *root,
+                                                const LEX_CSTRING *name,
                                                 const Record_addr &addr,
                                                 const Type_all_attributes &attr,
                                                 TABLE *table) const
 
 {
-  return new_Field_timestamp(table->in_use->mem_root,
+  return new_Field_timestamp(root,
                              addr.ptr(), addr.null_ptr(), addr.null_bit(),
                              Field::NONE, name, table->s, attr.decimals);
 }
 
 
-Field *Type_handler_timestamp2::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_timestamp2::make_table_field(MEM_ROOT *root,
+                                                 const LEX_CSTRING *name,
                                                  const Record_addr &addr,
                                                  const Type_all_attributes &attr,
                                                  TABLE *table) const
@@ -3224,25 +3268,27 @@ Field *Type_handler_timestamp2::make_table_field(const LEX_CSTRING *name,
     Will be changed to "new Field_timestampf" when we reuse
     make_table_field() for make_field() purposes in field.cc.
   */
-  return new_Field_timestamp(table->in_use->mem_root,
+  return new_Field_timestamp(root,
                              addr.ptr(), addr.null_ptr(), addr.null_bit(),
                              Field::NONE, name, table->s, attr.decimals);
 }
 
 
-Field *Type_handler_newdate::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_newdate::make_table_field(MEM_ROOT *root,
+                                              const LEX_CSTRING *name,
                                               const Record_addr &addr,
                                               const Type_all_attributes &attr,
                                               TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_newdate(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                        Field::NONE, name);
 }
 
 
-Field *Type_handler_date::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_date::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
@@ -3253,25 +3299,27 @@ Field *Type_handler_date::make_table_field(const LEX_CSTRING *name,
     for make_field() in field.cc
   */
   DBUG_ASSERT(0);
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_date(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name);
 }
 
 
-Field *Type_handler_time::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_time::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 
 {
-  return new_Field_time(table->in_use->mem_root,
+  return new_Field_time(root,
                         addr.ptr(), addr.null_ptr(), addr.null_bit(),
                         Field::NONE, name, attr.decimals);
 }
 
 
-Field *Type_handler_time2::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_time2::make_table_field(MEM_ROOT *root,
+                                            const LEX_CSTRING *name,
                                             const Record_addr &addr,
                                             const Type_all_attributes &attr,
                                             TABLE *table) const
@@ -3282,25 +3330,27 @@ Field *Type_handler_time2::make_table_field(const LEX_CSTRING *name,
     Will be changed to "new Field_timef" when we reuse
     make_table_field() for make_field() purposes in field.cc.
   */
-  return new_Field_time(table->in_use->mem_root,
+  return new_Field_time(root,
                         addr.ptr(), addr.null_ptr(), addr.null_bit(),
                         Field::NONE, name, attr.decimals);
 }
 
 
-Field *Type_handler_datetime::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_datetime::make_table_field(MEM_ROOT *root,
+                                               const LEX_CSTRING *name,
                                                const Record_addr &addr,
                                                const Type_all_attributes &attr,
                                                TABLE *table) const
 
 {
-  return new_Field_datetime(table->in_use->mem_root,
+  return new_Field_datetime(root,
                             addr.ptr(), addr.null_ptr(), addr.null_bit(),
                             Field::NONE, name, attr.decimals);
 }
 
 
-Field *Type_handler_datetime2::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_datetime2::make_table_field(MEM_ROOT *root,
+                                                const LEX_CSTRING *name,
                                                 const Record_addr &addr,
                                                 const Type_all_attributes &attr,
                                                 TABLE *table) const
@@ -3309,45 +3359,48 @@ Field *Type_handler_datetime2::make_table_field(const LEX_CSTRING *name,
     Will be changed to "new Field_datetimef" when we reuse
     make_table_field() for make_field() purposes in field.cc.
   */
-  return new_Field_datetime(table->in_use->mem_root,
+  return new_Field_datetime(root,
                             addr.ptr(), addr.null_ptr(), addr.null_bit(),
                             Field::NONE, name, attr.decimals);
 }
 
 
-Field *Type_handler_bit::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_bit::make_table_field(MEM_ROOT *root,
+                                          const LEX_CSTRING *name,
                                           const Record_addr &addr,
                                           const Type_all_attributes &attr,
                                           TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_bit_as_char(addr.ptr(), attr.max_length,
                            addr.null_ptr(), addr.null_bit(),
                            Field::NONE, name);
 }
 
 
-Field *Type_handler_string::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_string::make_table_field(MEM_ROOT *root,
+                                             const LEX_CSTRING *name,
                                              const Record_addr &addr,
                                              const Type_all_attributes &attr,
                                              TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_string(addr.ptr(), attr.max_length,
                       addr.null_ptr(), addr.null_bit(),
                       Field::NONE, name, attr.collation);
 }
 
 
-Field *Type_handler_varchar::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_varchar::make_table_field(MEM_ROOT *root,
+                                              const LEX_CSTRING *name,
                                               const Record_addr &addr,
                                               const Type_all_attributes &attr,
                                               TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_varstring(addr.ptr(), attr.max_length,
                          HA_VARCHAR_PACKLENGTH(attr.max_length),
                          addr.null_ptr(), addr.null_bit(),
@@ -3356,26 +3409,28 @@ Field *Type_handler_varchar::make_table_field(const LEX_CSTRING *name,
 }
 
 
-Field *Type_handler_tiny_blob::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_tiny_blob::make_table_field(MEM_ROOT *root,
+                                                const LEX_CSTRING *name,
                                                 const Record_addr &addr,
                                                 const Type_all_attributes &attr,
                                                 TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_blob(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name, table->s,
                     1, attr.collation);
 }
 
 
-Field *Type_handler_blob::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_blob::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_blob(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name, table->s,
                     2, attr.collation);
@@ -3383,40 +3438,43 @@ Field *Type_handler_blob::make_table_field(const LEX_CSTRING *name,
 
 
 Field *
-Type_handler_medium_blob::make_table_field(const LEX_CSTRING *name,
+Type_handler_medium_blob::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_blob(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name, table->s,
                     3, attr.collation);
 }
 
 
-Field *Type_handler_long_blob::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_long_blob::make_table_field(MEM_ROOT *root,
+                                                const LEX_CSTRING *name,
                                                 const Record_addr &addr,
                                                 const Type_all_attributes &attr,
                                                 TABLE *table) const
 
 {
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_blob(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name, table->s,
                     4, attr.collation);
 }
 
 
-Field *Type_handler_enum::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_enum::make_table_field(MEM_ROOT *root,
+                                           const LEX_CSTRING *name,
                                            const Record_addr &addr,
                                            const Type_all_attributes &attr,
                                            TABLE *table) const
 {
   const TYPELIB *typelib= attr.get_typelib();
   DBUG_ASSERT(typelib);
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_enum(addr.ptr(), attr.max_length,
                     addr.null_ptr(), addr.null_bit(),
                     Field::NONE, name,
@@ -3425,7 +3483,8 @@ Field *Type_handler_enum::make_table_field(const LEX_CSTRING *name,
 }
 
 
-Field *Type_handler_set::make_table_field(const LEX_CSTRING *name,
+Field *Type_handler_set::make_table_field(MEM_ROOT *root,
+                                          const LEX_CSTRING *name,
                                           const Record_addr &addr,
                                           const Type_all_attributes &attr,
                                           TABLE *table) const
@@ -3433,7 +3492,7 @@ Field *Type_handler_set::make_table_field(const LEX_CSTRING *name,
 {
   const TYPELIB *typelib= attr.get_typelib();
   DBUG_ASSERT(typelib);
-  return new (table->in_use->mem_root)
+  return new (root)
          Field_set(addr.ptr(), attr.max_length,
                    addr.null_ptr(), addr.null_bit(),
                    Field::NONE, name,
@@ -3444,13 +3503,13 @@ Field *Type_handler_set::make_table_field(const LEX_CSTRING *name,
 
 /*************************************************************************/
 
-Field *Type_handler_float::make_schema_field(TABLE *table,
-                                              const Record_addr &addr,
-                                              const ST_FIELD_INFO &def,
-                                              bool show_field) const
+Field *Type_handler_float::make_schema_field(MEM_ROOT *root, TABLE *table,
+                                             const Record_addr &addr,
+                                             const ST_FIELD_INFO &def,
+                                             bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
      Field_float(addr.ptr(), def.char_length(),
                   addr.null_ptr(), addr.null_bit(),
                   Field::NONE, &name,
@@ -3459,13 +3518,13 @@ Field *Type_handler_float::make_schema_field(TABLE *table,
 }
 
 
-Field *Type_handler_double::make_schema_field(TABLE *table,
+Field *Type_handler_double::make_schema_field(MEM_ROOT *root, TABLE *table,
                                               const Record_addr &addr,
                                               const ST_FIELD_INFO &def,
                                               bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
      Field_double(addr.ptr(), def.char_length(),
                   addr.null_ptr(), addr.null_bit(),
                   Field::NONE, &name,
@@ -3474,7 +3533,8 @@ Field *Type_handler_double::make_schema_field(TABLE *table,
 }
 
 
-Field *Type_handler_decimal_result::make_schema_field(TABLE *table,
+Field *Type_handler_decimal_result::make_schema_field(MEM_ROOT *root,
+                                                      TABLE *table,
                                                       const Record_addr &addr,
                                                       const ST_FIELD_INFO &def,
                                                       bool show_field) const
@@ -3484,14 +3544,14 @@ Field *Type_handler_decimal_result::make_schema_field(TABLE *table,
   uint prec= def.decimal_precision();
   DBUG_ASSERT(dec <= DECIMAL_MAX_SCALE);
   uint32 len= my_decimal_precision_to_length(prec, dec, def.unsigned_flag());
-  return new (table->in_use->mem_root)
+  return new (root)
      Field_new_decimal(addr.ptr(), len, addr.null_ptr(), addr.null_bit(),
                        Field::NONE, &name,
                        (uint8) dec, 0/*zerofill*/, def.unsigned_flag());
 }
 
 
-Field *Type_handler_blob_common::make_schema_field(TABLE *table,
+Field *Type_handler_blob_common::make_schema_field(MEM_ROOT *root, TABLE *table,
                                                    const Record_addr &addr,
                                                    const ST_FIELD_INFO &def,
                                                    bool show_field) const
@@ -3499,19 +3559,19 @@ Field *Type_handler_blob_common::make_schema_field(TABLE *table,
   LEX_CSTRING name= def.name();
   if (show_field)
   {
-    return new (table->in_use->mem_root)
+    return new (root)
        Field_blob(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                   Field::NONE, &name, table->s,
                   length_bytes(),
                   &my_charset_bin);
   }
   else
-    return new (table->in_use->mem_root)
+    return new (root)
       Field_null(addr.ptr(), 0, Field::NONE, &name, &my_charset_bin);
 }
 
 
-Field *Type_handler_varchar::make_schema_field(TABLE *table,
+Field *Type_handler_varchar::make_schema_field(MEM_ROOT *root, TABLE *table,
                                                const Record_addr &addr,
                                                const ST_FIELD_INFO &def,
                                                bool show_field) const
@@ -3521,7 +3581,7 @@ Field *Type_handler_varchar::make_schema_field(TABLE *table,
   uint32 octet_length= (uint32) def.char_length() * 3;
   if (octet_length > MAX_FIELD_VARCHARLENGTH)
   {
-    Field *field= new (table->in_use->mem_root)
+    Field *field= new (root)
       Field_blob(addr.ptr(), addr.null_ptr(), addr.null_bit(), Field::NONE,
                  &name, table->s, 4, system_charset_info);
     if (field)
@@ -3530,7 +3590,7 @@ Field *Type_handler_varchar::make_schema_field(TABLE *table,
   }
   else if (show_field)
   {
-    return new (table->in_use->mem_root)
+    return new (root)
       Field_varstring(addr.ptr(), octet_length,
                       HA_VARCHAR_PACKLENGTH(octet_length),
                       addr.null_ptr(), addr.null_bit(),
@@ -3538,96 +3598,97 @@ Field *Type_handler_varchar::make_schema_field(TABLE *table,
                       table->s, system_charset_info);
   }
   else
-    return new (table->in_use->mem_root)
+    return new (root)
       Field_null(addr.ptr(), 0, Field::NONE, &name, system_charset_info);
 }
 
 
-Field *Type_handler_tiny::make_schema_field(TABLE *table,
+Field *Type_handler_tiny::make_schema_field(MEM_ROOT *root, TABLE *table,
                                             const Record_addr &addr,
                                             const ST_FIELD_INFO &def,
                                             bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
            Field_tiny(addr.ptr(), def.char_length(),
                       addr.null_ptr(), addr.null_bit(), Field::NONE, &name,
                       0/*zerofill*/, def.unsigned_flag());
 }
 
 
-Field *Type_handler_short::make_schema_field(TABLE *table,
+Field *Type_handler_short::make_schema_field(MEM_ROOT *root, TABLE *table,
                                              const Record_addr &addr,
                                              const ST_FIELD_INFO &def,
                                              bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
            Field_short(addr.ptr(), def.char_length(),
                        addr.null_ptr(), addr.null_bit(), Field::NONE, &name,
                        0/*zerofill*/, def.unsigned_flag());
 }
 
 
-Field *Type_handler_long::make_schema_field(TABLE *table,
+Field *Type_handler_long::make_schema_field(MEM_ROOT *root, TABLE *table,
                                             const Record_addr &addr,
                                             const ST_FIELD_INFO &def,
                                             bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
            Field_long(addr.ptr(), def.char_length(),
                       addr.null_ptr(), addr.null_bit(), Field::NONE, &name,
                       0/*zerofill*/, def.unsigned_flag());
 }
 
 
-Field *Type_handler_longlong::make_schema_field(TABLE *table,
+Field *Type_handler_longlong::make_schema_field(MEM_ROOT *root, TABLE *table,
                                                 const Record_addr &addr,
                                                 const ST_FIELD_INFO &def,
                                                 bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
            Field_longlong(addr.ptr(), def.char_length(),
                           addr.null_ptr(), addr.null_bit(), Field::NONE, &name,
                           0/*zerofill*/, def.unsigned_flag());
 }
 
 
-Field *Type_handler_date_common::make_schema_field(TABLE *table,
+Field *Type_handler_date_common::make_schema_field(MEM_ROOT *root, TABLE *table,
                                                    const Record_addr &addr,
                                                    const ST_FIELD_INFO &def,
                                                    bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new (table->in_use->mem_root)
+  return new (root)
            Field_newdate(addr.ptr(), addr.null_ptr(), addr.null_bit(),
                          Field::NONE, &name);
 }
 
 
-Field *Type_handler_time_common::make_schema_field(TABLE *table,
+Field *Type_handler_time_common::make_schema_field(MEM_ROOT *root, TABLE *table,
                                                    const Record_addr &addr,
                                                    const ST_FIELD_INFO &def,
                                                    bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new_Field_time(table->in_use->mem_root,
+  return new_Field_time(root,
                         addr.ptr(), addr.null_ptr(), addr.null_bit(),
                         Field::NONE, &name, def.fsp());
 }
 
 
-Field *Type_handler_datetime_common::make_schema_field(TABLE *table,
+Field *Type_handler_datetime_common::make_schema_field(MEM_ROOT *root,
+                                                       TABLE *table,
                                                        const Record_addr &addr,
                                                        const ST_FIELD_INFO &def,
                                                        bool show_field) const
 {
   LEX_CSTRING name= def.name();
-  return new_Field_datetime(table->in_use->mem_root,
-                             addr.ptr(), addr.null_ptr(), addr.null_bit(),
-                             Field::NONE, &name, def.fsp());
+  return new_Field_datetime(root,
+                            addr.ptr(), addr.null_ptr(), addr.null_bit(),
+                            Field::NONE, &name, def.fsp());
 }
 
 
@@ -7270,7 +7331,8 @@ void Type_handler_datetime_common::Item_param_set_param_func(Item_param *param,
   param->set_param_datetime(pos, len);
 }
 
-Field *Type_handler_blob_common::make_conversion_table_field(TABLE *table,
+Field *Type_handler_blob_common::make_conversion_table_field(MEM_ROOT *root,
+                                                            TABLE *table,
                                                             uint metadata,
                                                             const Field *target)
                                                             const
@@ -7278,7 +7340,7 @@ Field *Type_handler_blob_common::make_conversion_table_field(TABLE *table,
   uint pack_length= metadata & 0x00ff;
   if (pack_length < 1 || pack_length > 4)
     return NULL; // Broken binary log?
-  return new(table->in_use->mem_root)
+  return new(root)
          Field_blob(NULL, (uchar *) "", 1, Field::NONE, &empty_clex_str,
                     table->s, pack_length, target->charset());
 }