Bug#31152942 ASSERTION ASSERT(NULLPTR != DYNAMIC_CAST<TARGET>(ARG)); GROUP BY JSON ARRAY.

There are two problems:

1. Field_typed_array field creates internal field for data
   conversion in Field_typed_array::init() and doesn't set
   convertion field index correctly while creating the field
   for temporary table.
Fixed by introducing new field method Field::set_field_index()
which updates convertion field index.

2. Convertion field and corresponding Item_field are created
   in TABLE::mem_root.
Fixed by replacing TABLE::mem_root with TABLE_SHARE's mem_root
for internal temporary tables.

Additional changes:

Public Field::field_index is replaced with private Field::m_field_index.
Added Field::field_index()/Field::set_field_index() methods.
Patch for 8.0 only.

Reviewed-by: Guilhem Bichot <[email protected]>

Author: Sergey Glukhov

sql/aggregate_check.cc

@@ -626,7 +626,7 @@ void Group_check::add_to_source_of_mat_table(Item_field *item_field,
   }
   // Find underlying expression of item_field, in SELECT list of mat_select
   Item *const expr_under =
-      mat_gc->select_expression(item_field->field->field_index);
+      mat_gc->select_expression(item_field->field->field_index());
 
   // non-nullability of tl's column in tl, is equal to that of expr_under.
   if (expr_under && !expr_under->maybe_null) mat_gc->non_null_in_source = true;
@@ -820,7 +820,7 @@ bool Group_check::is_in_fd_of_underlying(Item_ident *item) {
           Search if the expression inside 'item' is FD on them.
         */
         Item *const expr_under =
-            mat_gc->select_expression(item_field->field->field_index);
+            mat_gc->select_expression(item_field->field->field_index());
         /*
           expr_under is the expression underlying 'item'.
           (1) and (4) it is a deterministic expression of mat_gc source

sql/binlog.cc

@@ -11187,7 +11187,7 @@ void binlog_prepare_row_images(const THD *thd, TABLE *table) {
           Field *field = (*ptr);
           if ((field->type() == MYSQL_TYPE_BLOB) &&
               !field->is_flag_set(PRI_KEY_FLAG))
-            bitmap_clear_bit(&table->tmp_set, field->field_index);
+            bitmap_clear_bit(&table->tmp_set, field->field_index());
         }
         break;
       default:

sql/dd_table_share.cc

@@ -1010,7 +1010,7 @@ static bool fill_column_from_dd(THD *thd, TABLE_SHARE *share,
   //
   reg_field =
       make_field(*col_obj, charset, share, rec_pos, null_pos, null_bit_pos);
-  reg_field->field_index = field_nr;
+  reg_field->set_field_index(field_nr);
   reg_field->stored_in_db = true;
 
   // Handle generated columns

sql/error_handler.cc

@@ -247,7 +247,7 @@ Functional_index_error_handler::Functional_index_error_handler(
 
       for (uint j = 0; j < index.actual_key_parts; ++j) {
         const KEY_PART_INFO &key_part = index.key_part[j];
-        if (key_part.field->field_index == field->field_index) {
+        if (key_part.field->field_index() == field->field_index()) {
           m_functional_index_name.assign(index.name);
           return;
         }

sql/field.cc

@@ -1650,7 +1650,7 @@ Field::Field(uchar *ptr_arg, uint32 length_arg, uchar *null_ptr_arg,
   if (!is_nullable()) set_flag(NOT_NULL_FLAG);
   comment.str = "";
   comment.length = 0;
-  field_index = 0;
+  m_field_index = 0;
 }
 
 /**
@@ -7281,7 +7281,7 @@ const uchar *Field_blob::unpack(uchar *, const uchar *from, uint param_data) {
       param_data > 0 ? param_data & 0xFF : packlength;
   uint32 const length = get_length(from, master_packlength);
   DBUG_DUMP("packed", from, length + master_packlength);
-  bitmap_set_bit(table->write_set, field_index);
+  bitmap_set_bit(table->write_set, field_index());
   Field_blob::store(pointer_cast<const char *>(from) + master_packlength,
                     length, field_charset);
   DBUG_DUMP("field", ptr, pack_length() /* len bytes + ptr bytes */);
@@ -8895,7 +8895,7 @@ const uchar *Field_bit::unpack(uchar *to, const uchar *from, uint param_data) {
   */
   if ((from_bit_len > 0) && (from_len > 0))
     value[new_len - len] = value[new_len - len] & ((1U << from_bit_len) - 1);
-  bitmap_set_bit(table->write_set, field_index);
+  bitmap_set_bit(table->write_set, field_index());
   store(value, new_len, system_charset_info);
   return from + len;
 }
@@ -9833,10 +9833,17 @@ void Field_typed_array::init(TABLE *table_arg) {
       return;
   }
 
+  // Set mem_root for conversion field allocation.
+  MEM_ROOT *actual_mem_root =
+      (table_arg->s->table_category == TABLE_CATEGORY_TEMPORARY)
+          ? &table_arg->s->mem_root
+          : &table_arg->mem_root;
   // Create field for data conversion
   Field *conv_field = ::make_field(
-      // Allocate conversion field in table's mem_root
-      &table_arg->mem_root,
+      // Allocate conversion field in table's mem_root for non-temp
+      // tables. Allocate conversion field in TABLE_SHARE's mem_root
+      // for internal temporary tables.
+      actual_mem_root,
       nullptr,       // TABLE_SHARE, not needed
       nullptr,       // data buffer, isn't allocated yet
       field_length,  // field_length
@@ -9856,21 +9863,20 @@ void Field_typed_array::init(TABLE *table_arg) {
   );
   if (conv_field == nullptr) return;
   uchar *buf =
-      table_arg->mem_root.ArrayAlloc<uchar>(conv_field->pack_length() + 1);
+      actual_mem_root->ArrayAlloc<uchar>(conv_field->pack_length() + 1);
   if (buf == nullptr) return;
   if (type() == MYSQL_TYPE_NEWDECIMAL)
     (down_cast<Field_new_decimal *>(conv_field))->set_keep_precision(true);
   conv_field->move_field(buf + 1, buf, 0);
   // Allow conv_field to use table->in_use
   conv_field->table = table;
-  conv_field->field_index = field_index;
   conv_field->table_name = table_name;
+  conv_field->set_field_index(field_index());
 
-  // Swap arena so that the Item_field is allocated on TABLE::mem_root
-  // and so it does not end up in THD's item list which will have a different
-  // lifetime than TABLE::mem_root
-  Query_arena tmp_arena(&table_arg->mem_root,
-                        Query_arena::STMT_REGULAR_EXECUTION);
+  // Swap arena so that the Item_field is allocated on TABLE::mem_root for
+  // non-temp tables and so it does not end up in THD's item list which will
+  // have a different lifetime than TABLE::mem_root
+  Query_arena tmp_arena(actual_mem_root, Query_arena::STMT_REGULAR_EXECUTION);
   Query_arena backup_arena;
   current_thd->swap_query_arena(tmp_arena, &backup_arena);
   m_conv_item = new Item_field(conv_field);
@@ -9958,6 +9964,11 @@ void Field_typed_array::make_send_field(Send_field *field) const {
   field->type = MYSQL_TYPE_JSON;
 }
 
+void Field_typed_array::set_field_index(uint16 field_index) {
+  Field::set_field_index(field_index);
+  if (m_conv_item) m_conv_item->field->set_field_index(field_index);
+}
+
 Key_map Field::get_covering_prefix_keys() const {
   if (table == nullptr) {
     // This function might be called when creating functional indexes. In those
@@ -10137,7 +10148,7 @@ const uchar *Field::unpack_int64(uchar *to, const uchar *from) const {
 
 bool Field_longstr::is_updatable() const {
   DBUG_ASSERT(table && table->write_set);
-  return bitmap_is_set(table->write_set, field_index);
+  return bitmap_is_set(table->write_set, field_index());
 }
 
 Field_varstring::Field_varstring(uchar *ptr_arg, uint32 len_arg,

sql/field.h

@@ -306,10 +306,10 @@ inline type_conversion_status time_warning_to_type_conversion_status(
 
 #define ASSERT_COLUMN_MARKED_FOR_READ        \
   DBUG_ASSERT(!table || (!table->read_set || \
-                         bitmap_is_set(table->read_set, field_index)))
+                         bitmap_is_set(table->read_set, field_index())))
 #define ASSERT_COLUMN_MARKED_FOR_WRITE        \
   DBUG_ASSERT(!table || (!table->write_set || \
-                         bitmap_is_set(table->write_set, field_index)))
+                         bitmap_is_set(table->write_set, field_index())))
 
 /**
   Tests if field type is an integer
@@ -839,6 +839,7 @@ class Field {
 
  private:
   uint32 flags{0};
+  uint16 m_field_index;  // field number in fields array
 
  public:
   bool is_flag_set(unsigned flag) const { return flags & flag; }
@@ -847,8 +848,7 @@ class Field {
   // Avoid using this function as it makes it harder to change the internal
   // representation.
   uint32 all_flags() const { return flags; }
-  uint16 field_index;  // field number in fields array
-  uchar null_bit;      // Bit used to test null bit
+  uchar null_bit;  // Bit used to test null bit
   /**
     Bitmap of flags indicating if field value is auto-generated by default
     and/or on update, and in which way.
@@ -1844,6 +1844,22 @@ class Field {
     return (is_flag_set(BLOB_FLAG) || is_array()) && is_virtual_gcol();
   }
 
+  /**
+    Sets field index.
+
+    @param[in]  field_index  Field index.
+  */
+  virtual void set_field_index(uint16 field_index) {
+    m_field_index = field_index;
+  }
+
+  /**
+    Returns field index.
+
+    @returns Field index.
+  */
+  uint16 field_index() const { return m_field_index; }
+
  private:
   /**
      Retrieve the field metadata for fields.
@@ -4362,6 +4378,7 @@ class Field_typed_array final : public Field_json {
   }
   void sql_type(String &str) const final override;
   void make_send_field(Send_field *field) const final;
+  void set_field_index(uint16 f_index) final override;
 };
 
 class Field_enum : public Field_str {

sql/filesort.cc

@@ -2145,7 +2145,7 @@ Addon_fields *Filesort::get_addon_fields(
 
   for (Field **pfield = table->field; *pfield != nullptr; ++pfield) {
     Field *field = *pfield;
-    if (!bitmap_is_set(table->read_set, field->field_index)) continue;
+    if (!bitmap_is_set(table->read_set, field->field_index())) continue;
 
     // Having large blobs in addon fields could be very inefficient,
     // but small blobs are OK (where “small” is a bit fuzzy, and relative
@@ -2215,7 +2215,7 @@ Addon_fields *Filesort::get_addon_fields(
   Addon_fields_array::iterator addonf = m_sort_param.addon_fields->begin();
   for (Field **pfield = table->field; *pfield != nullptr; ++pfield) {
     Field *field = *pfield;
-    if (!bitmap_is_set(table->read_set, field->field_index)) continue;
+    if (!bitmap_is_set(table->read_set, field->field_index())) continue;
     DBUG_ASSERT(addonf != m_sort_param.addon_fields->end());
 
     addonf->field = field;

sql/handler.cc

@@ -8010,7 +8010,7 @@ static void extract_blob_space_and_length_from_record_buff(
   int num = 0;
   for (Field **vfield = table->vfield; *vfield; vfield++) {
     // Check if this field should be included
-    if (bitmap_is_set(fields, (*vfield)->field_index) &&
+    if (bitmap_is_set(fields, (*vfield)->field_index()) &&
         (*vfield)->is_virtual_gcol() && (*vfield)->type() == MYSQL_TYPE_BLOB) {
       auto field = down_cast<Field_blob *>(*vfield);
       blob_len_ptr_array[num].length = field->data_length();
@@ -8049,7 +8049,7 @@ static void copy_blob_data(const TABLE *table, const MY_BITMAP *const fields,
   uint num = 0;
   for (Field **vfield = table->vfield; *vfield; vfield++) {
     // Check if this field should be included
-    if (bitmap_is_set(fields, (*vfield)->field_index) &&
+    if (bitmap_is_set(fields, (*vfield)->field_index()) &&
         (*vfield)->is_virtual_gcol() && (*vfield)->type() == MYSQL_TYPE_BLOB) {
       DBUG_ASSERT(blob_len_ptr_array[num].length > 0);
       DBUG_ASSERT(blob_len_ptr_array[num].ptr != nullptr);
@@ -8130,9 +8130,9 @@ static bool my_eval_gcolumn_expr_helper(THD *thd, TABLE *table,
   for (Field **vfield_ptr = table->vfield; *vfield_ptr; vfield_ptr++) {
     Field *field = *vfield_ptr;
     // Validate that the field number is less than the bit map size
-    DBUG_ASSERT(field->field_index < fields->n_bits);
+    DBUG_ASSERT(field->field_index() < fields->n_bits);
 
-    if (bitmap_is_set(fields, field->field_index)) {
+    if (bitmap_is_set(fields, field->field_index())) {
       bitmap_union(&fields_to_evaluate, &field->gcol_info->base_columns_map);
       if (field->is_array()) {
         mv_field = field;
@@ -8162,7 +8162,7 @@ static bool my_eval_gcolumn_expr_helper(THD *thd, TABLE *table,
     Field *field = *vfield_ptr;
 
     // Check if we should evaluate this field
-    if (bitmap_is_set(&fields_to_evaluate, field->field_index) &&
+    if (bitmap_is_set(&fields_to_evaluate, field->field_index()) &&
         field->is_virtual_gcol()) {
       DBUG_ASSERT(field->gcol_info && field->gcol_info->expr_item->fixed);
 

sql/hash_join_buffer.cc

@@ -257,7 +257,7 @@ bool StoreFromTableBuffers(const TableCollection &tables, String *buffer) {
 
     for (const Column &column : tbl.columns) {
       DBUG_ASSERT(bitmap_is_set(column.field->table->read_set,
-                                column.field->field_index));
+                                column.field->field_index()));
       if (!column.field->is_null()) {
         // Store the data in packed format. The packed format will also
         // include the length of the data if needed.

sql/histograms/histogram.cc

@@ -699,7 +699,7 @@ static bool prepare_value_maps(
     // Overhead for each element
     *row_size_bytes += value_map->element_overhead();
 
-    value_maps.emplace(field->field_index,
+    value_maps.emplace(field->field_index(),
                        std::unique_ptr<histograms::Value_map_base>(value_map));
   }
 
@@ -755,7 +755,7 @@ static bool fill_value_maps(
   while (res == 0) {
     for (Field *field : fields) {
       histograms::Value_map_base *value_map =
-          value_maps.at(field->field_index).get();
+          value_maps.at(field->field_index()).get();
 
       switch (histograms::field_type_to_value_map_type(field)) {
         case histograms::Value_map_type::STRING: {
@@ -954,9 +954,9 @@ bool update_histogram(THD *thd, TABLE_LIST *table, const columns_set &columns,
     }
     resolved_fields.push_back(field);
 
-    bitmap_set_bit(tbl->read_set, field->field_index);
+    bitmap_set_bit(tbl->read_set, field->field_index());
     if (field->is_gcol()) {
-      bitmap_set_bit(tbl->write_set, field->field_index);
+      bitmap_set_bit(tbl->write_set, field->field_index());
       /*
         The base columns needs to be in the write set in case of nested
         generated columns:
@@ -1026,7 +1026,7 @@ bool update_histogram(THD *thd, TABLE_LIST *table, const columns_set &columns,
 
     std::string col_name(field->field_name);
     histograms::Histogram *histogram =
-        value_maps.at(field->field_index)
+        value_maps.at(field->field_index())
             ->build_histogram(
                 &local_mem_root, num_buckets,
                 std::string(table->db, table->db_length),