diff --git a/plugin/feedback/sender_thread.cc b/plugin/feedback/sender_thread.cc
index 943443f60fe..9a8e7775d01 100644
--- a/plugin/feedback/sender_thread.cc
+++ b/plugin/feedback/sender_thread.cc
@@ -47,7 +47,7 @@ static int table_to_string(TABLE *table, String *result)
 
   res= table->file->ha_rnd_init(1);
 
-  dbug_tmp_use_all_columns(table, table->read_set);
+  dbug_tmp_use_all_columns(table, &table->read_set);
 
   while(!res && !table->file->ha_rnd_next(table->record[0]))
   {
diff --git a/sql/field.cc b/sql/field.cc
index 571f4bfb1e5..76d9a3ccf95 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -7976,11 +7976,10 @@ uint Field_varstring::get_key_image(uchar *buff, uint length,
 {
   String val;
   uint local_char_length;
-  my_bitmap_map *old_map;
 
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   val_str(&val, &val);
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   local_char_length= val.charpos(length / field_charset->mbmaxlen);
   if (local_char_length < val.length())
@@ -11496,7 +11495,7 @@ key_map Field::get_possible_keys()
 
 bool Field::validate_value_in_record_with_warn(THD *thd, const uchar *record)
 {
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
+    MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   bool rc;
   if ((rc= validate_value_in_record(thd, record)))
   {
@@ -11508,7 +11507,7 @@ bool Field::validate_value_in_record_with_warn(THD *thd, const uchar *record)
                         ER_THD(thd, ER_INVALID_DEFAULT_VALUE_FOR_FIELD),
                         ErrConvString(&tmp).ptr(), field_name.str);
   }
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
   return rc;
 }
 
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index 88385900e5e..bf9d6af997f 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -4278,7 +4278,7 @@ int ha_partition::write_row(uchar * buf)
   int error;
   longlong func_value;
   bool have_auto_increment= table->next_number_field && buf == table->record[0];
-  my_bitmap_map *old_map;
+  MY_BITMAP *old_map;
   THD *thd= ha_thd();
   sql_mode_t saved_sql_mode= thd->variables.sql_mode;
   bool saved_auto_inc_field_not_null= table->auto_increment_field_not_null;
@@ -4320,9 +4320,9 @@ int ha_partition::write_row(uchar * buf)
     }
   }
 
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   error= m_part_info->get_partition_id(m_part_info, &part_id, &func_value);
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
   if (unlikely(error))
   {
     m_part_info->err_value= func_value;
@@ -11191,13 +11191,12 @@ int ha_partition::bulk_update_row(const uchar *old_data, const uchar *new_data,
   int error= 0;
   uint32 part_id;
   longlong func_value;
-  my_bitmap_map *old_map;
   DBUG_ENTER("ha_partition::bulk_update_row");
 
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   error= m_part_info->get_partition_id(m_part_info, &part_id,
                                        &func_value);
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
   if (unlikely(error))
   {
     m_part_info->err_value= func_value;
diff --git a/sql/item.cc b/sql/item.cc
index a9f34787f86..cd81aca7e37 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -1624,9 +1624,9 @@ int Item::save_in_field_no_warnings(Field *field, bool no_conversions)
   Sql_mode_save sql_mode(thd);
   thd->variables.sql_mode&= ~(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE);
   thd->variables.sql_mode|= MODE_INVALID_DATES;
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   res= save_in_field(field, no_conversions);
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   return res;
 }
 
@@ -6051,7 +6051,7 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
   Field *from_field= (Field *)not_found_field;
   bool outer_fixed= false;
   SELECT_LEX *select= thd->lex->current_select;
-  
+
   if (select && select->in_tvc)
   {
     my_error(ER_FIELD_REFERENCE_IN_TVC, MYF(0), full_name());
@@ -6947,7 +6947,7 @@ Item *Item_string::make_odbc_literal(THD *thd, const LEX_CSTRING *typestr)
 }
 
 
-static int save_int_value_in_field (Field *field, longlong nr, 
+static int save_int_value_in_field (Field *field, longlong nr,
                                     bool null_value, bool unsigned_flag)
 {
   if (null_value)
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index df5521f2a1a..ebb1c480abb 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -345,13 +345,13 @@ static bool convert_const_to_int(THD *thd, Item_field *field_item,
     TABLE *table= field->table;
     Sql_mode_save sql_mode(thd);
     Check_level_instant_set check_level_save(thd, CHECK_FIELD_IGNORE);
-    my_bitmap_map *old_maps[2] = { NULL, NULL };
+    MY_BITMAP *old_maps[2] = { NULL, NULL };
     ulonglong UNINIT_VAR(orig_field_val); /* original field value if valid */
 
     /* table->read_set may not be set if we come here from a CREATE TABLE */
     if (table && table->read_set)
       dbug_tmp_use_all_columns(table, old_maps,
-                               table->read_set, table->write_set);
+                               &table->read_set, &table->write_set);
     /* For comparison purposes allow invalid dates like 2000-01-32 */
     thd->variables.sql_mode= (thd->variables.sql_mode & ~MODE_NO_ZERO_DATE) |
                              MODE_INVALID_DATES;
@@ -392,7 +392,7 @@ static bool convert_const_to_int(THD *thd, Item_field *field_item,
       DBUG_ASSERT(!result);
     }
     if (table && table->read_set)
-      dbug_tmp_restore_column_maps(table->read_set, table->write_set, old_maps);
+      dbug_tmp_restore_column_maps(&table->read_set, &table->write_set, old_maps);
   }
   return result;
 }
@@ -3101,7 +3101,7 @@ bool Item_func_decode_oracle::fix_length_and_dec()
 /*
   Aggregate all THEN and ELSE expression types
   and collations when string result
-  
+
   @param THD       - current thd
   @param start     - an element in args to start aggregating from
 */
diff --git a/sql/key.cc b/sql/key.cc
index adff6975631..6f0a1112497 100644
--- a/sql/key.cc
+++ b/sql/key.cc
@@ -244,14 +244,13 @@ void key_restore(uchar *to_record, const uchar *from_key, KEY *key_info,
     else if (key_part->key_part_flag & HA_VAR_LENGTH_PART)
     {
       Field *field= key_part->field;
-      my_bitmap_map *old_map;
       my_ptrdiff_t ptrdiff= to_record - field->table->record[0];
       field->move_field_offset(ptrdiff);
       key_length-= HA_KEY_BLOB_LENGTH;
       length= MY_MIN(key_length, key_part->length);
-      old_map= dbug_tmp_use_all_columns(field->table, field->table->write_set);
+      MY_BITMAP *old_map= dbug_tmp_use_all_columns(field->table, &field->table->write_set);
       field->set_key_image(from_key, length);
-      dbug_tmp_restore_column_map(field->table->write_set, old_map);
+      dbug_tmp_restore_column_map(&field->table->write_set, old_map);
       from_key+= HA_KEY_BLOB_LENGTH;
       field->move_field_offset(-ptrdiff);
     }
@@ -419,7 +418,7 @@ void field_unpack(String *to, Field *field, const uchar *rec, uint max_length,
 
 void key_unpack(String *to, TABLE *table, KEY *key)
 {
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   DBUG_ENTER("key_unpack");
 
   to->length(0);
@@ -443,7 +442,7 @@ void key_unpack(String *to, TABLE *table, KEY *key)
     field_unpack(to, key_part->field, table->record[0], key_part->length,
                  MY_TEST(key_part->key_part_flag & HA_PART_KEY_SEG));
  }
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
   DBUG_VOID_RETURN;
 }
 
diff --git a/sql/log_event.cc b/sql/log_event.cc
index e344fc8894f..d072402a00b 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -13699,11 +13699,11 @@ int Rows_log_event::update_sequence()
     /* This event come from a setval function executed on the master.
        Update the sequence next_number and round, like we do with setval()
     */
-    my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
-                                                     table->read_set);
+    MY_BITMAP *old_map= dbug_tmp_use_all_columns(table,
+                                                 &table->read_set);
     longlong nextval= table->field[NEXT_FIELD_NO]->val_int();
     longlong round= table->field[ROUND_FIELD_NO]->val_int();
-    dbug_tmp_restore_column_map(table->read_set, old_map);
+    dbug_tmp_restore_column_map(&table->read_set, old_map);
 
     return table->s->sequence->set_value(table, nextval, round, 0) > 0;
   }
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 2204500e3b5..30c74799b6f 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -3264,8 +3264,7 @@ bool calculate_cond_selectivity_for_table(THD *thd, TABLE *table, Item **cond)
 
 void store_key_image_to_rec(Field *field, uchar *ptr, uint len)
 {
-  /* Do the same as print_key() does */ 
-  my_bitmap_map *old_map;
+  /* Do the same as print_key() does */
 
   if (field->real_maybe_null())
   {
@@ -3277,10 +3276,10 @@ void store_key_image_to_rec(Field *field, uchar *ptr, uint len)
     field->set_notnull();
     ptr++;
   }    
-  old_map= dbug_tmp_use_all_columns(field->table,
-                                    field->table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(field->table,
+                                    &field->table->write_set);
   field->set_key_image(ptr, len); 
-  dbug_tmp_restore_column_map(field->table->write_set, old_map);
+  dbug_tmp_restore_column_map(&field->table->write_set, old_map);
 }
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
@@ -3495,7 +3494,7 @@ bool prune_partitions(THD *thd, TABLE *table, Item *pprune_cond)
   PART_PRUNE_PARAM prune_param;
   MEM_ROOT alloc;
   RANGE_OPT_PARAM  *range_par= &prune_param.range_param;
-  my_bitmap_map *old_sets[2];
+  MY_BITMAP *old_sets[2];
 
   prune_param.part_info= part_info;
   init_sql_alloc(&alloc, "prune_partitions",
@@ -3512,7 +3511,7 @@ bool prune_partitions(THD *thd, TABLE *table, Item *pprune_cond)
   }
 
   dbug_tmp_use_all_columns(table, old_sets, 
-                           table->read_set, table->write_set);
+                           &table->read_set, &table->write_set);
   range_par->thd= thd;
   range_par->table= table;
   /* range_par->cond doesn't need initialization */
@@ -3609,7 +3608,7 @@ all_used:
   retval= FALSE; // some partitions are used
   mark_all_partitions_as_used(prune_param.part_info);
 end:
-  dbug_tmp_restore_column_maps(table->read_set, table->write_set, old_sets);
+  dbug_tmp_restore_column_maps(&table->read_set, &table->write_set, old_sets);
   thd->no_errors=0;
   thd->mem_root= range_par->old_root;
   free_root(&alloc,MYF(0));			// Return memory & allocator
@@ -14852,8 +14851,8 @@ static void
 print_sel_arg_key(Field *field, const uchar *key, String *out)
 {
   TABLE *table= field->table;
-  my_bitmap_map *old_sets[2];
-  dbug_tmp_use_all_columns(table, old_sets, table->read_set, table->write_set);
+  MY_BITMAP *old_sets[2];
+  dbug_tmp_use_all_columns(table, old_sets, &table->read_set, &table->write_set);
 
   if (field->real_maybe_null())
   {
@@ -14873,7 +14872,7 @@ print_sel_arg_key(Field *field, const uchar *key, String *out)
     field->val_str(out);
 
 end:
-  dbug_tmp_restore_column_maps(table->read_set, table->write_set, old_sets);
+  dbug_tmp_restore_column_maps(&table->read_set, &table->write_set, old_sets);
 }
 
 
@@ -14968,9 +14967,9 @@ print_key(KEY_PART *key_part, const uchar *key, uint used_length)
   const uchar *key_end= key+used_length;
   uint store_length;
   TABLE *table= key_part->field->table;
-  my_bitmap_map *old_sets[2];
+  MY_BITMAP *old_sets[2];
 
-  dbug_tmp_use_all_columns(table, old_sets, table->read_set, table->write_set);
+  dbug_tmp_use_all_columns(table, old_sets, &table->read_set, &table->write_set);
 
   for (; key < key_end; key+=store_length, key_part++)
   {
@@ -14997,7 +14996,7 @@ print_key(KEY_PART *key_part, const uchar *key, uint used_length)
     if (key+store_length < key_end)
       fputc('/',DBUG_FILE);
   }
-  dbug_tmp_restore_column_maps(table->read_set, table->write_set, old_sets);
+  dbug_tmp_restore_column_maps(&table->read_set, &table->write_set, old_sets);
 }
 
 
@@ -15005,16 +15004,16 @@ static void print_quick(QUICK_SELECT_I *quick, const key_map *needed_reg)
 {
   char buf[MAX_KEY/8+1];
   TABLE *table;
-  my_bitmap_map *old_sets[2];
+  MY_BITMAP *old_sets[2];
   DBUG_ENTER("print_quick");
   if (!quick)
     DBUG_VOID_RETURN;
   DBUG_LOCK_FILE;
 
   table= quick->head;
-  dbug_tmp_use_all_columns(table, old_sets, table->read_set, table->write_set);
+  dbug_tmp_use_all_columns(table, old_sets, &table->read_set, &table->write_set);
   quick->dbug_dump(0, TRUE);
-  dbug_tmp_restore_column_maps(table->read_set, table->write_set, old_sets);
+  dbug_tmp_restore_column_maps(&table->read_set, &table->write_set, old_sets);
 
   fprintf(DBUG_FILE,"other_keys: 0x%s:\n", needed_reg->print(buf));
 
diff --git a/sql/partition_info.cc b/sql/partition_info.cc
index 9f08964e62c..a8459438be7 100644
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -1449,13 +1449,13 @@ void partition_info::print_no_partition_found(TABLE *table_arg, myf errflag)
       buf_ptr= (char*)"from column_list";
     else
     {
-      my_bitmap_map *old_map= dbug_tmp_use_all_columns(table_arg, table_arg->read_set);
+      MY_BITMAP *old_map= dbug_tmp_use_all_columns(table_arg, &table_arg->read_set);
       if (part_expr->null_value)
         buf_ptr= (char*)"NULL";
       else
         longlong10_to_str(err_value, buf,
                      part_expr->unsigned_flag ? 10 : -10);
-      dbug_tmp_restore_column_map(table_arg->read_set, old_map);
+      dbug_tmp_restore_column_map(&table_arg->read_set, old_map);
     }
     my_error(ER_NO_PARTITION_FOR_GIVEN_VALUE, errflag, buf_ptr);
   }
diff --git a/sql/protocol.cc b/sql/protocol.cc
index 3f4e251403b..26cc686ad0a 100644
--- a/sql/protocol.cc
+++ b/sql/protocol.cc
@@ -1251,15 +1251,15 @@ bool Protocol_text::store(Field *field)
   CHARSET_INFO *tocs= this->thd->variables.character_set_results;
 #ifdef DBUG_ASSERT_EXISTS
   TABLE *table= field->table;
-  my_bitmap_map *old_map= 0;
+  MY_BITMAP *old_map= 0;
   if (table->file)
-    old_map= dbug_tmp_use_all_columns(table, table->read_set);
+    old_map= dbug_tmp_use_all_columns(table, &table->read_set);
 #endif
 
   field->val_str(&str);
 #ifdef DBUG_ASSERT_EXISTS
   if (old_map)
-    dbug_tmp_restore_column_map(table->read_set, old_map);
+    dbug_tmp_restore_column_map(&table->read_set, old_map);
 #endif
 
   return store_string_aux(str.ptr(), str.length(), str.charset(), tocs);
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index 9fdfd612c96..967b85496ac 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -689,7 +689,6 @@ mysql_ha_fix_cond_and_key(SQL_HANDLER *handler,
 
       for (keypart_map= key_len=0 ; (item=it_ke++) ; key_part++)
       {
-        my_bitmap_map *old_map;
 	/* note that 'item' can be changed by fix_fields() call */
         if (item->fix_fields_if_needed_for_scalar(thd, it_ke.ref()))
           return 1;
@@ -701,9 +700,9 @@ mysql_ha_fix_cond_and_key(SQL_HANDLER *handler,
         }
         if (!in_prepare)
         {
-          old_map= dbug_tmp_use_all_columns(table, table->write_set);
+          MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
           (void) item->save_in_field(key_part->field, 1);
-          dbug_tmp_restore_column_map(table->write_set, old_map);
+          dbug_tmp_restore_column_map(&table->write_set, old_map);
         }
         key_len+= key_part->store_length;
         keypart_map= (keypart_map << 1) | 1;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 8baac124b71..7e084cafa05 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -1770,7 +1770,7 @@ JOIN::optimize_inner()
             join->optimization_state == JOIN::OPTIMIZATION_PHASE_1_DONE &&
             join->with_two_phase_optimization)
           continue;
-        /* 
+        /*
           Do not push conditions from where into materialized inner tables
           of outer joins: this is not valid.
         */
@@ -1981,7 +1981,7 @@ setup_subq_exit:
   if (with_two_phase_optimization)
     optimization_state= JOIN::OPTIMIZATION_PHASE_1_DONE;
   else
-  { 
+  {
     if (optimize_stage2())
       DBUG_RETURN(1);
   }
@@ -2001,11 +2001,11 @@ int JOIN::optimize_stage2()
 
   if (unlikely(thd->check_killed()))
     DBUG_RETURN(1);
-  
+
   /* Generate an execution plan from the found optimal join order. */
   if (get_best_combination())
     DBUG_RETURN(1);
-  
+
   if (select_lex->handle_derived(thd->lex, DT_OPTIMIZE))
     DBUG_RETURN(1);
 
@@ -3625,7 +3625,7 @@ bool JOIN::setup_subquery_caches()
     if (tmp_having)
     {
       DBUG_ASSERT(having == NULL);
-      if (!(tmp_having= 
+      if (!(tmp_having=
             tmp_having->transform(thd,
                                   &Item::expr_cache_insert_transformer,
                                   NULL)))
@@ -6476,7 +6476,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   Special treatment for ft-keys.
 */
 
-bool sort_and_filter_keyuse(THD *thd, DYNAMIC_ARRAY *keyuse, 
+bool sort_and_filter_keyuse(THD *thd, DYNAMIC_ARRAY *keyuse,
                             bool skip_unprefixed_keyparts)
 {
   KEYUSE key_end, *prev, *save_pos, *use;
@@ -7499,7 +7499,7 @@ best_access_path(JOIN      *join,
   pos->loosescan_picker.loosescan_key= MAX_KEY;
   pos->use_join_buffer= best_uses_jbuf;
   pos->spl_plan= spl_plan;
-   
+
   loose_scan_opt.save_to_position(s, loose_scan_pos);
 
   if (!best_key &&
@@ -9592,7 +9592,7 @@ bool JOIN::check_two_phase_optimization(THD *thd)
     return true;
   return false;
 }
-  
+
 
 bool JOIN::inject_cond_into_where(Item *injected_cond)
 {
@@ -9623,7 +9623,7 @@ bool JOIN::inject_cond_into_where(Item *injected_cond)
       and_args->push_back(elem, thd->mem_root);
     }
   }
-  
+
   return false;
 
 }
@@ -17252,7 +17252,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
         item->maybe_null= save_maybe_null;
         result->field_name= orig_item->name;
       }
-    } 
+    }
     else if (table_cant_handle_bit_fields && field->field->type() ==
              MYSQL_TYPE_BIT)
     {
@@ -23314,7 +23314,7 @@ bool
 cp_buffer_from_ref(THD *thd, TABLE *table, TABLE_REF *ref)
 {
   Check_level_instant_set check_level_save(thd, CHECK_FIELD_IGNORE);
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   bool result= 0;
 
   for (store_key **copy=ref->key_copy ; *copy ; copy++)
@@ -23325,7 +23325,7 @@ cp_buffer_from_ref(THD *thd, TABLE *table, TABLE_REF *ref)
       break;
     }
   }
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   return result;
 }
 
@@ -24997,7 +24997,7 @@ bool JOIN::rollup_init()
   {
     if (!(rollup.null_items[i]= new (thd->mem_root) Item_null_result(thd)))
       return true;
-    
+
     List<Item> *rollup_fields= &rollup.fields[i];
     rollup_fields->empty();
     rollup.ref_pointer_arrays[i]= Ref_ptr_array(ref_array, all_fields.elements);
@@ -25505,7 +25505,7 @@ bool JOIN_TAB::save_explain_data(Explain_table_access *eta,
   {
     JOIN_TAB *ctab= bush_children->start;
     /* table */
-    size_t len= my_snprintf(table_name_buffer, 
+    size_t len= my_snprintf(table_name_buffer,
                          sizeof(table_name_buffer)-1,
                          "<subquery%d>", 
                          ctab->emb_sj_nest->sj_subq_pred->get_identifier());
@@ -26631,7 +26631,7 @@ void TABLE_LIST::print(THD *thd, table_map eliminated_tables, String *str,
 void st_select_lex::print(THD *thd, String *str, enum_query_type query_type)
 {
   DBUG_ASSERT(thd);
-  
+
   if (tvc)
   {
     tvc->print(thd, str, query_type);
diff --git a/sql/sql_select.h b/sql/sql_select.h
index d207363a9ba..06cc86b5710 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -1920,8 +1920,8 @@ class store_key_field: public store_key
   enum store_key_result copy_inner()
   {
     TABLE *table= copy_field.to_field->table;
-    my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
-                                                     table->write_set);
+    MY_BITMAP *old_map= dbug_tmp_use_all_columns(table,
+                                                 &table->write_set);
 
     /* 
       It looks like the next statement is needed only for a simplified
@@ -1932,7 +1932,7 @@ class store_key_field: public store_key
     bzero(copy_field.to_ptr,copy_field.to_length);
 
     copy_field.do_copy(&copy_field);
-    dbug_tmp_restore_column_map(table->write_set, old_map);
+    dbug_tmp_restore_column_map(&table->write_set, old_map);
     null_key= to_field->is_null();
     return err != 0 ? STORE_KEY_FATAL : STORE_KEY_OK;
   }
@@ -1967,8 +1967,8 @@ public:
   enum store_key_result copy_inner()
   {
     TABLE *table= to_field->table;
-    my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
-                                                     table->write_set);
+    MY_BITMAP *old_map= dbug_tmp_use_all_columns(table,
+                                                 &table->write_set);
     int res= FALSE;
 
     /* 
@@ -1989,7 +1989,7 @@ public:
     */
     if (!res && table->in_use->is_error())
       res= 1; /* STORE_KEY_FATAL */
-    dbug_tmp_restore_column_map(table->write_set, old_map);
+    dbug_tmp_restore_column_map(&table->write_set, old_map);
     null_key= to_field->is_null() || item->null_value;
     return ((err != 0 || res < 0 || res > 2) ? STORE_KEY_FATAL : 
             (store_key_result) res);
@@ -2025,8 +2025,8 @@ protected:
     {
       inited=1;
       TABLE *table= to_field->table;
-      my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
-                                                       table->write_set);
+      MY_BITMAP *old_map= dbug_tmp_use_all_columns(table,
+                                                   &table->write_set);
       if ((res= item->save_in_field(to_field, 1)))
       {       
         if (!err)
@@ -2038,7 +2038,7 @@ protected:
         */
       if (!err && to_field->table->in_use->is_error())
         err= 1; /* STORE_KEY_FATAL */
-      dbug_tmp_restore_column_map(table->write_set, old_map);
+      dbug_tmp_restore_column_map(&table->write_set, old_map);
     }
     null_key= to_field->is_null() || item->null_value;
     return (err > 2 ? STORE_KEY_FATAL : (store_key_result) err);
diff --git a/sql/sql_sequence.cc b/sql/sql_sequence.cc
index ffdb4b54c16..11125c0a619 100644
--- a/sql/sql_sequence.cc
+++ b/sql/sql_sequence.cc
@@ -136,7 +136,7 @@ bool sequence_definition::check_and_adjust(bool set_reserved_until)
 
 void sequence_definition::read_fields(TABLE *table)
 {
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   reserved_until= table->field[0]->val_int();
   min_value=      table->field[1]->val_int();
   max_value=      table->field[2]->val_int();
@@ -145,7 +145,7 @@ void sequence_definition::read_fields(TABLE *table)
   cache=          table->field[5]->val_int();
   cycle=          table->field[6]->val_int();
   round=          table->field[7]->val_int();
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
   used_fields= ~(uint) 0;
   print_dbug();
 }
@@ -157,7 +157,7 @@ void sequence_definition::read_fields(TABLE *table)
 
 void sequence_definition::store_fields(TABLE *table)
 {
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
 
   /* zero possible delete markers & null bits */
   memcpy(table->record[0], table->s->default_values, table->s->null_bytes);
@@ -170,7 +170,7 @@ void sequence_definition::store_fields(TABLE *table)
   table->field[6]->store((longlong) cycle != 0, 0);
   table->field[7]->store((longlong) round, 1);
 
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   print_dbug();
 }
 
@@ -527,12 +527,11 @@ int SEQUENCE::read_initial_values(TABLE *table)
 int SEQUENCE::read_stored_values(TABLE *table)
 {
   int error;
-  my_bitmap_map *save_read_set;
   DBUG_ENTER("SEQUENCE::read_stored_values");
 
-  save_read_set= tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *save_read_set= tmp_use_all_columns(table, &table->read_set);
   error= table->file->ha_read_first_row(table->record[0], MAX_KEY);
-  tmp_restore_column_map(table->read_set, save_read_set);
+  tmp_restore_column_map(&table->read_set, save_read_set);
 
   if (unlikely(error))
   {
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 9a5141fa414..2bb52788dcd 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -2139,7 +2139,6 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
                            !foreign_db_mode;
   bool check_options= !(sql_mode & MODE_IGNORE_BAD_TABLE_OPTIONS) &&
                       !create_info_arg;
-  my_bitmap_map *old_map;
   handlerton *hton;
   int error= 0;
   DBUG_ENTER("show_create_table");
@@ -2206,7 +2205,7 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
     We have to restore the read_set if we are called from insert in case
     of row based replication.
   */
-  old_map= tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= tmp_use_all_columns(table, &table->read_set);
 
   bool not_the_first_field= false;
   for (ptr=table->field ; (field= *ptr); ptr++)
@@ -2492,7 +2491,7 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
     }
   }
 #endif
-  tmp_restore_column_map(table->read_set, old_map);
+  tmp_restore_column_map(&table->read_set, old_map);
   DBUG_RETURN(error);
 }
 
@@ -5824,7 +5823,7 @@ static bool print_anchor_data_type(const Spvar_definition *def,
   Let's print it according to the current sql_mode.
   It will make output in line with the value in mysql.proc.param_list,
   so both I_S.XXX.DTD_IDENTIFIER and mysql.proc.param_list use the same notation:
-  default or Oracle, according to the sql_mode at the SP creation time. 
+  default or Oracle, according to the sql_mode at the SP creation time.
   The caller must make sure to set thd->variables.sql_mode to the routine sql_mode.
 */
 static bool print_anchor_dtd_identifier(THD *thd, const Spvar_definition *def,
diff --git a/sql/sql_statistics.cc b/sql/sql_statistics.cc
index a84e2449a55..13532f5f171 100644
--- a/sql/sql_statistics.cc
+++ b/sql/sql_statistics.cc
@@ -1043,9 +1043,8 @@ public:
   {
     char buff[MAX_FIELD_WIDTH];
     String val(buff, sizeof(buff), &my_charset_bin);
-    my_bitmap_map *old_map;
 
-    old_map= dbug_tmp_use_all_columns(stat_table, stat_table->read_set);
+    MY_BITMAP *old_map= dbug_tmp_use_all_columns(stat_table, &stat_table->read_set);
     for (uint i= COLUMN_STAT_MIN_VALUE; i <= COLUMN_STAT_HISTOGRAM; i++)
     {  
       Field *stat_field= stat_table->field[i];
@@ -1103,7 +1102,7 @@ public:
         }
       }
     }
-    dbug_tmp_restore_column_map(stat_table->read_set, old_map);
+    dbug_tmp_restore_column_map(&stat_table->read_set, old_map);
   }
 
 
diff --git a/sql/table.h b/sql/table.h
index 1134610284b..bcad713b06c 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -2987,25 +2987,25 @@ typedef struct st_open_table_list{
 } OPEN_TABLE_LIST;
 
 
-static inline my_bitmap_map *tmp_use_all_columns(TABLE *table,
-                                                 MY_BITMAP *bitmap)
+static inline MY_BITMAP *tmp_use_all_columns(TABLE *table,
+                                             MY_BITMAP **bitmap)
 {
-  my_bitmap_map *old= bitmap->bitmap;
-  bitmap->bitmap= table->s->all_set.bitmap;
+  MY_BITMAP *old= *bitmap;
+  *bitmap= &table->s->all_set;
   return old;
 }
 
 
-static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
-                                          my_bitmap_map *old)
+static inline void tmp_restore_column_map(MY_BITMAP **bitmap,
+                                          MY_BITMAP *old)
 {
-  bitmap->bitmap= old;
+  *bitmap= old;
 }
 
 /* The following is only needed for debugging */
 
-static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table,
-                                                      MY_BITMAP *bitmap)
+static inline MY_BITMAP *dbug_tmp_use_all_columns(TABLE *table,
+                                                      MY_BITMAP **bitmap)
 {
 #ifdef DBUG_ASSERT_EXISTS
   return tmp_use_all_columns(table, bitmap);
@@ -3014,8 +3014,8 @@ static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table,
 #endif
 }
 
-static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap,
-                                               my_bitmap_map *old)
+static inline void dbug_tmp_restore_column_map(MY_BITMAP **bitmap,
+                                               MY_BITMAP *old)
 {
 #ifdef DBUG_ASSERT_EXISTS
   tmp_restore_column_map(bitmap, old);
@@ -3028,22 +3028,22 @@ static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap,
   Provide for the possiblity of the read set being the same as the write set
 */
 static inline void dbug_tmp_use_all_columns(TABLE *table,
-                                            my_bitmap_map **save,
-                                            MY_BITMAP *read_set,
-                                            MY_BITMAP *write_set)
+                                            MY_BITMAP **save,
+                                            MY_BITMAP **read_set,
+                                            MY_BITMAP **write_set)
 {
 #ifdef DBUG_ASSERT_EXISTS
-  save[0]= read_set->bitmap;
-  save[1]= write_set->bitmap;
+  save[0]= *read_set;
+  save[1]= *write_set;
   (void) tmp_use_all_columns(table, read_set);
   (void) tmp_use_all_columns(table, write_set);
 #endif
 }
 
 
-static inline void dbug_tmp_restore_column_maps(MY_BITMAP *read_set,
-                                                MY_BITMAP *write_set,
-                                                my_bitmap_map **old)
+static inline void dbug_tmp_restore_column_maps(MY_BITMAP **read_set,
+                                                MY_BITMAP **write_set,
+                                                MY_BITMAP **old)
 {
 #ifdef DBUG_ASSERT_EXISTS
   tmp_restore_column_map(read_set, old[0]);
diff --git a/storage/archive/ha_archive.cc b/storage/archive/ha_archive.cc
index c25a1c00c87..f540bbaa4f1 100644
--- a/storage/archive/ha_archive.cc
+++ b/storage/archive/ha_archive.cc
@@ -1547,7 +1547,7 @@ int ha_archive::optimize(THD* thd, HA_CHECK_OPT* check_opt)
       share->rows_recorded= 0;
       stats.auto_increment_value= 1;
       share->archive_write.auto_increment= 0;
-      my_bitmap_map *org_bitmap= tmp_use_all_columns(table, table->read_set);
+      MY_BITMAP *org_bitmap= tmp_use_all_columns(table, &table->read_set);
 
       while (!(rc= get_row(&archive, table->record[0])))
       {
@@ -1568,7 +1568,7 @@ int ha_archive::optimize(THD* thd, HA_CHECK_OPT* check_opt)
         }
       }
 
-      tmp_restore_column_map(table->read_set, org_bitmap);
+      tmp_restore_column_map(&table->read_set, org_bitmap);
       share->rows_recorded= (ha_rows)writer.rows;
     }
 
diff --git a/storage/cassandra/ha_cassandra.cc b/storage/cassandra/ha_cassandra.cc
index 4f9e207235f..56af4bfd40a 100644
--- a/storage/cassandra/ha_cassandra.cc
+++ b/storage/cassandra/ha_cassandra.cc
@@ -1641,18 +1641,18 @@ int ha_cassandra::index_read_map(uchar *buf, const uchar *key,
 
   char *cass_key;
   int cass_key_len;
-  my_bitmap_map *old_map;
+  MY_BITMAP *old_map;
 
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  old_map= dbug_tmp_use_all_columns(table, &table->read_set);
 
   if (rowkey_converter->mariadb_to_cassandra(&cass_key, &cass_key_len))
   {
     /* We get here when making lookups like uuid_column='not-an-uuid' */
-    dbug_tmp_restore_column_map(table->read_set, old_map);
+    dbug_tmp_restore_column_map(&table->read_set, old_map);
     DBUG_RETURN(HA_ERR_KEY_NOT_FOUND);
   }
 
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   bool found;
   if (se->get_slice(cass_key, cass_key_len, &found))
@@ -1726,8 +1726,8 @@ int ha_cassandra::read_cassandra_columns(bool unpack_pk)
     cassandra_to_mariadb() calls will use field->store(...) methods, which
     require that the column is in the table->write_set
   */
-  my_bitmap_map *old_map;
-  old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map;
+  old_map= dbug_tmp_use_all_columns(table, &table->write_set);
 
   /* Start with all fields being NULL */
   for (field= table->field + 1; *field; field++)
@@ -1848,7 +1848,7 @@ int ha_cassandra::read_cassandra_columns(bool unpack_pk)
   }
 
 err:
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   return res;
 }
 
@@ -1933,7 +1933,7 @@ void ha_cassandra::free_dynamic_row(DYNAMIC_COLUMN_VALUE **vals,
 
 int ha_cassandra::write_row(uchar *buf)
 {
-  my_bitmap_map *old_map;
+  MY_BITMAP *old_map;
   int ires;
   DBUG_ENTER("ha_cassandra::write_row");
 
@@ -1943,7 +1943,7 @@ int ha_cassandra::write_row(uchar *buf)
   if (!doing_insert_batch)
     se->clear_insert_buffer();
 
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  old_map= dbug_tmp_use_all_columns(table, &table->read_set);
 
   insert_lineno++;
 
@@ -1954,7 +1954,7 @@ int ha_cassandra::write_row(uchar *buf)
   {
     my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
              rowkey_converter->field->field_name.str, insert_lineno);
-    dbug_tmp_restore_column_map(table->read_set, old_map);
+    dbug_tmp_restore_column_map(&table->read_set, old_map);
     DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
   }
   se->start_row_insert(cass_key, cass_key_len);
@@ -1977,7 +1977,7 @@ int ha_cassandra::write_row(uchar *buf)
       free_dynamic_row(&vals, &names);
       if (rc)
       {
-        dbug_tmp_restore_column_map(table->read_set, old_map);
+        dbug_tmp_restore_column_map(&table->read_set, old_map);
         DBUG_RETURN(rc);
       }
     }
@@ -1988,7 +1988,7 @@ int ha_cassandra::write_row(uchar *buf)
       {
         my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
                  field_converters[i]->field->field_name.str, insert_lineno);
-        dbug_tmp_restore_column_map(table->read_set, old_map);
+        dbug_tmp_restore_column_map(&table->read_set, old_map);
         DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
       }
       se->add_insert_column(field_converters[i]->field->field_name.str, 0,
@@ -1996,7 +1996,7 @@ int ha_cassandra::write_row(uchar *buf)
     }
   }
 
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   bool res;
 
@@ -2263,8 +2263,8 @@ bool ha_cassandra::mrr_start_read()
 {
   uint key_len;
 
-  my_bitmap_map *old_map;
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map;
+  old_map= dbug_tmp_use_all_columns(table, &table->read_set);
 
   se->new_lookup_keys();
 
@@ -2288,7 +2288,7 @@ bool ha_cassandra::mrr_start_read()
       break;
   }
 
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   return se->multiget_slice();
 }
@@ -2366,7 +2366,7 @@ int ha_cassandra::update_row(const uchar *old_data, const uchar *new_data)
   LEX_STRING *oldnames, *names;
   uint oldcount, count;
   String oldvalcol, valcol;
-  my_bitmap_map *old_map;
+  MY_BITMAP *old_map;
   int res;
   DBUG_ENTER("ha_cassandra::update_row");
   /* Currently, it is guaranteed that new_data == table->record[0] */
@@ -2374,7 +2374,7 @@ int ha_cassandra::update_row(const uchar *old_data, const uchar *new_data)
   /* For now, just rewrite the full record */
   se->clear_insert_buffer();
 
-  old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  old_map= dbug_tmp_use_all_columns(table, &table->read_set);
 
   char *old_key;
   int old_key_len;
@@ -2387,7 +2387,7 @@ int ha_cassandra::update_row(const uchar *old_data, const uchar *new_data)
   {
     my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
              rowkey_converter->field->field_name.str, insert_lineno);
-    dbug_tmp_restore_column_map(table->read_set, old_map);
+    dbug_tmp_restore_column_map(&table->read_set, old_map);
     DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
   }
 
@@ -2450,7 +2450,7 @@ int ha_cassandra::update_row(const uchar *old_data, const uchar *new_data)
       {
         my_error(ER_WARN_DATA_OUT_OF_RANGE, MYF(0),
                  field_converters[i]->field->field_name.str, insert_lineno);
-        dbug_tmp_restore_column_map(table->read_set, old_map);
+        dbug_tmp_restore_column_map(&table->read_set, old_map);
         DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
       }
       se->add_insert_column(field_converters[i]->field->field_name.str, 0,
@@ -2477,7 +2477,7 @@ int ha_cassandra::update_row(const uchar *old_data, const uchar *new_data)
     }
   }
 
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   res= se->do_insert();
 
diff --git a/storage/connect/ha_connect.cc b/storage/connect/ha_connect.cc
index 74951090787..f7117af030d 100644
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -1387,7 +1387,7 @@ PCSZ ha_connect::GetStringOption(PCSZ opname, PCSZ sdef)
   PTOS options= GetTableOptionStruct();
 
   if (!stricmp(opname, "Connect")) {
-    LEX_CSTRING cnc= (tshp) ? tshp->connect_string 
+    LEX_CSTRING cnc= (tshp) ? tshp->connect_string
                            : table->s->connect_string;
 
     if (cnc.length)
@@ -2157,7 +2157,6 @@ int ha_connect::MakeRecord(char *buf)
   int            rc= 0;
   Field*        *field;
   Field         *fp;
-  my_bitmap_map *org_bitmap;
   CHARSET_INFO  *charset= tdbp->data_charset();
 //MY_BITMAP      readmap;
   MY_BITMAP     *map;
@@ -2172,7 +2171,7 @@ int ha_connect::MakeRecord(char *buf)
             *table->def_read_set.bitmap, *table->def_write_set.bitmap);
 
   // Avoid asserts in field::store() for columns that are not updated
-  org_bitmap= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->write_set);
 
   // This is for variable_length rows
   memset(buf, 0, table->s->null_bytes);
@@ -2199,7 +2198,7 @@ int ha_connect::MakeRecord(char *buf)
           continue;
 
         htrc("Column %s not found\n", fp->field_name.str);
-        dbug_tmp_restore_column_map(table->write_set, org_bitmap);
+        dbug_tmp_restore_column_map(&table->write_set, org_bitmap);
         DBUG_RETURN(HA_ERR_WRONG_IN_RECORD);
         } // endif colp
 
@@ -2259,7 +2258,7 @@ int ha_connect::MakeRecord(char *buf)
 
           sprintf(buf, "Out of range value %.140s for column '%s' at row %ld",
             value->GetCharString(val),
-            fp->field_name.str, 
+            fp->field_name.str,
             thd->get_stmt_da()->current_row_for_warning());
 
           push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, buf);
@@ -2282,7 +2281,7 @@ int ha_connect::MakeRecord(char *buf)
     memcpy(buf, table->record[0], table->s->stored_rec_length);
 
   // This is copied from ha_tina and is necessary to avoid asserts
-  dbug_tmp_restore_column_map(table->write_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->write_set, org_bitmap);
   DBUG_RETURN(rc);
 } // end of MakeRecord
 
@@ -2302,7 +2301,7 @@ int ha_connect::ScanRecord(PGLOBAL g, const uchar *)
 //PTDBASE tp= (PTDBASE)tdbp;
   String  attribute(attr_buffer, sizeof(attr_buffer),
                     table->s->table_charset);
-  my_bitmap_map *bmap= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *bmap= dbug_tmp_use_all_columns(table, &table->read_set);
   const CHARSET_INFO *charset= tdbp->data_charset();
   String  data_charset_value(data_buffer, sizeof(data_buffer),  charset);
 
@@ -2424,7 +2423,7 @@ int ha_connect::ScanRecord(PGLOBAL g, const uchar *)
     } // endfor field
 
  err:
-  dbug_tmp_restore_column_map(table->read_set, bmap);
+  dbug_tmp_restore_column_map(&table->read_set, bmap);
   return rc;
 } // end of ScanRecord
 
@@ -2472,7 +2471,7 @@ bool ha_connect::MakeKeyWhere(PGLOBAL g, PSTRG qry, OPVAL vop, char q,
 	OPVAL            op;
 	Field           *fp;
 	const key_range *ranges[2];
-	my_bitmap_map   *old_map;
+	MY_BITMAP    *old_map;
 	KEY             *kfp;
   KEY_PART_INFO   *kpart;
 
@@ -2489,7 +2488,7 @@ bool ha_connect::MakeKeyWhere(PGLOBAL g, PSTRG qry, OPVAL vop, char q,
 		both= ranges[0] && ranges[1];
 
 	kfp= &table->key_info[active_index];
-	old_map= dbug_tmp_use_all_columns(table, table->write_set);
+	old_map= dbug_tmp_use_all_columns(table, &table->write_set);
 
 	for (i= 0; i <= 1; i++) {
 		if (ranges[i] == NULL)
@@ -2584,11 +2583,11 @@ bool ha_connect::MakeKeyWhere(PGLOBAL g, PSTRG qry, OPVAL vop, char q,
   if ((oom= qry->IsTruncated()))
     strcpy(g->Message, "Out of memory");
 
-	dbug_tmp_restore_column_map(table->write_set, old_map);
+	dbug_tmp_restore_column_map(&table->write_set, old_map);
 	return oom;
 
 err:
-	dbug_tmp_restore_column_map(table->write_set, old_map);
+	dbug_tmp_restore_column_map(&table->write_set, old_map);
 	return true;
 } // end of MakeKeyWhere
 
diff --git a/storage/csv/ha_tina.cc b/storage/csv/ha_tina.cc
index 3a9bbc2766f..86b9d853424 100644
--- a/storage/csv/ha_tina.cc
+++ b/storage/csv/ha_tina.cc
@@ -528,7 +528,7 @@ int ha_tina::encode_quote(const uchar *buf)
   String attribute(attribute_buffer, sizeof(attribute_buffer),
                    &my_charset_bin);
   bool ietf_quotes= table_share->option_struct->ietf_quotes;
-  my_bitmap_map *org_bitmap= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
   buffer.length(0);
 
   for (Field **field=table->field ; *field ; field++)
@@ -606,7 +606,7 @@ int ha_tina::encode_quote(const uchar *buf)
 
   //buffer.replace(buffer.length(), 0, "\n", 1);
 
-  dbug_tmp_restore_column_map(table->read_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
   return (buffer.length());
 }
 
@@ -659,7 +659,6 @@ int ha_tina::find_current_row(uchar *buf)
 {
   my_off_t end_offset, curr_offset= current_position;
   int eoln_len;
-  my_bitmap_map *org_bitmap;
   int error;
   bool read_all;
   bool ietf_quotes= table_share->option_struct->ietf_quotes;
@@ -679,7 +678,7 @@ int ha_tina::find_current_row(uchar *buf)
   /* We must read all columns in case a table is opened for update */
   read_all= !bitmap_is_clear_all(table->write_set);
   /* Avoid asserts in ::store() for columns that are not going to be updated */
-  org_bitmap= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->write_set);
   error= HA_ERR_CRASHED_ON_USAGE;
 
   memset(buf, 0, table->s->null_bytes);
@@ -857,7 +856,7 @@ int ha_tina::find_current_row(uchar *buf)
   error= 0;
 
 err:
-  dbug_tmp_restore_column_map(table->write_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->write_set, org_bitmap);
 
   DBUG_RETURN(error);
 }
diff --git a/storage/federated/ha_federated.cc b/storage/federated/ha_federated.cc
index 79e70ce5123..0190ad80fca 100644
--- a/storage/federated/ha_federated.cc
+++ b/storage/federated/ha_federated.cc
@@ -936,7 +936,7 @@ uint ha_federated::convert_row_to_internal_format(uchar *record,
 {
   ulong *lengths;
   Field **field;
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   DBUG_ENTER("ha_federated::convert_row_to_internal_format");
 
   lengths= mysql_fetch_lengths(result);
@@ -965,7 +965,7 @@ uint ha_federated::convert_row_to_internal_format(uchar *record,
     }
     (*field)->move_field_offset(-old_ptr);
   }
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   DBUG_RETURN(0);
 }
 
@@ -1293,14 +1293,13 @@ bool ha_federated::create_where_from_key(String *to,
   char tmpbuff[FEDERATED_QUERY_BUFFER_SIZE];
   String tmp(tmpbuff, sizeof(tmpbuff), system_charset_info);
   const key_range *ranges[2]= { start_key, end_key };
-  my_bitmap_map *old_map;
   DBUG_ENTER("ha_federated::create_where_from_key");
 
   tmp.length(0); 
   if (start_key == NULL && end_key == NULL)
     DBUG_RETURN(1);
 
-  old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   for (uint i= 0; i <= 1; i++)
   {
     bool needs_quotes;
@@ -1477,7 +1476,7 @@ prepare_for_next_key_part:
                   tmp.c_ptr_quick()));
     }
   }
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
 
   if (both_not_null)
     if (tmp.append(STRING_WITH_LEN(") ")))
@@ -1492,7 +1491,7 @@ prepare_for_next_key_part:
   DBUG_RETURN(0);
 
 err:
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   DBUG_RETURN(1);
 }
 
@@ -1841,7 +1840,7 @@ int ha_federated::write_row(uchar *buf)
   String insert_field_value_string(insert_field_value_buffer,
                                    sizeof(insert_field_value_buffer),
                                    &my_charset_bin);
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   DBUG_ENTER("ha_federated::write_row");
 
   values_string.length(0);
@@ -1895,7 +1894,7 @@ int ha_federated::write_row(uchar *buf)
       values_string.append(STRING_WITH_LEN(", "));
     }
   }
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   /*
     if there were no fields, we don't want to add a closing paren
@@ -2203,7 +2202,7 @@ int ha_federated::update_row(const uchar *old_data, const uchar *new_data)
       else
       {
         /* otherwise = */
-        my_bitmap_map *old_map= tmp_use_all_columns(table, table->read_set);
+        MY_BITMAP *old_map= tmp_use_all_columns(table, &table->read_set);
         bool needs_quote= (*field)->str_needs_quotes();
 	(*field)->val_str(&field_value);
         if (needs_quote)
@@ -2212,7 +2211,7 @@ int ha_federated::update_row(const uchar *old_data, const uchar *new_data)
         if (needs_quote)
           update_string.append(value_quote_char);
         field_value.length(0);
-        tmp_restore_column_map(table->read_set, old_map);
+        tmp_restore_column_map(&table->read_set, old_map);
       }
       update_string.append(STRING_WITH_LEN(", "));
     }
diff --git a/storage/federatedx/ha_federatedx.cc b/storage/federatedx/ha_federatedx.cc
index 18756cff17c..9bf66d00f78 100644
--- a/storage/federatedx/ha_federatedx.cc
+++ b/storage/federatedx/ha_federatedx.cc
@@ -862,7 +862,7 @@ uint ha_federatedx::convert_row_to_internal_format(uchar *record,
   ulong *lengths;
   Field **field;
   int column= 0;
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   Time_zone *saved_time_zone= table->in_use->variables.time_zone;
   DBUG_ENTER("ha_federatedx::convert_row_to_internal_format");
 
@@ -891,7 +891,7 @@ uint ha_federatedx::convert_row_to_internal_format(uchar *record,
     (*field)->move_field_offset(-old_ptr);
   }
   table->in_use->variables.time_zone= saved_time_zone;
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   DBUG_RETURN(0);
 }
 
@@ -1220,7 +1220,6 @@ bool ha_federatedx::create_where_from_key(String *to,
   String tmp(tmpbuff, sizeof(tmpbuff), system_charset_info);
   const key_range *ranges[2]= { start_key, end_key };
   Time_zone *saved_time_zone= table->in_use->variables.time_zone;
-  my_bitmap_map *old_map;
   DBUG_ENTER("ha_federatedx::create_where_from_key");
 
   tmp.length(0); 
@@ -1228,7 +1227,7 @@ bool ha_federatedx::create_where_from_key(String *to,
     DBUG_RETURN(1);
 
   table->in_use->variables.time_zone= UTC;
-  old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   for (uint i= 0; i <= 1; i++)
   {
     bool needs_quotes;
@@ -1404,7 +1403,7 @@ prepare_for_next_key_part:
                   tmp.c_ptr_quick()));
     }
   }
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   table->in_use->variables.time_zone= saved_time_zone;
 
   if (both_not_null)
@@ -1420,7 +1419,7 @@ prepare_for_next_key_part:
   DBUG_RETURN(0);
 
 err:
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
   table->in_use->variables.time_zone= saved_time_zone;
   DBUG_RETURN(1);
 }
@@ -1995,7 +1994,7 @@ int ha_federatedx::write_row(uchar *buf)
                                    sizeof(insert_field_value_buffer),
                                    &my_charset_bin);
   Time_zone *saved_time_zone= table->in_use->variables.time_zone;
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   DBUG_ENTER("ha_federatedx::write_row");
 
   table->in_use->variables.time_zone= UTC;
@@ -2050,7 +2049,7 @@ int ha_federatedx::write_row(uchar *buf)
       values_string.append(STRING_WITH_LEN(", "));
     }
   }
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
   table->in_use->variables.time_zone= saved_time_zone;
 
   /*
@@ -2375,7 +2374,7 @@ int ha_federatedx::update_row(const uchar *old_data, const uchar *new_data)
       else
       {
         /* otherwise = */
-        my_bitmap_map *old_map= tmp_use_all_columns(table, table->read_set);
+        MY_BITMAP *old_map= tmp_use_all_columns(table, &table->read_set);
         bool needs_quote= (*field)->str_needs_quotes();
 	(*field)->val_str(&field_value);
         if (needs_quote)
@@ -2384,7 +2383,7 @@ int ha_federatedx::update_row(const uchar *old_data, const uchar *new_data)
         if (needs_quote)
           update_string.append(value_quote_char);
         field_value.length(0);
-        tmp_restore_column_map(table->read_set, old_map);
+        tmp_restore_column_map(&table->read_set, old_map);
       }
       update_string.append(STRING_WITH_LEN(", "));
     }
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index 848591234f4..f172273e11e 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -21126,11 +21126,11 @@ innobase_get_computed_value(
 
 	field = dtuple_get_nth_v_field(row, col->v_pos);
 
-	my_bitmap_map*	old_write_set = dbug_tmp_use_all_columns(mysql_table, mysql_table->write_set);
-	my_bitmap_map*	old_read_set = dbug_tmp_use_all_columns(mysql_table, mysql_table->read_set);
+	MY_BITMAP *old_write_set = dbug_tmp_use_all_columns(mysql_table, &mysql_table->write_set);
+	MY_BITMAP *old_read_set = dbug_tmp_use_all_columns(mysql_table, &mysql_table->read_set);
 	ret = mysql_table->update_virtual_field(mysql_table->field[col->m_col.ind]);
-	dbug_tmp_restore_column_map(mysql_table->read_set, old_read_set);
-	dbug_tmp_restore_column_map(mysql_table->write_set, old_write_set);
+	dbug_tmp_restore_column_map(&mysql_table->read_set, old_read_set);
+	dbug_tmp_restore_column_map(&mysql_table->write_set, old_write_set);
 
 	if (ret != 0) {
 		DBUG_RETURN(NULL);
diff --git a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc
index 6d4e545248a..dddcb9ceae0 100644
--- a/storage/innobase/handler/handler0alter.cc
+++ b/storage/innobase/handler/handler0alter.cc
@@ -2397,9 +2397,9 @@ innobase_row_to_mysql(
 		}
 	}
 	if (table->vfield) {
-		my_bitmap_map*	old_vcol_set = tmp_use_all_columns(table, table->vcol_set);
+		MY_BITMAP *old_vcol_set = tmp_use_all_columns(table, &table->vcol_set);
 		table->update_virtual_fields(table->file, VCOL_UPDATE_FOR_READ);
-		tmp_restore_column_map(table->vcol_set, old_vcol_set);
+		tmp_restore_column_map(&table->vcol_set, old_vcol_set);
 	}
 }
 
diff --git a/storage/mroonga/lib/mrn_debug_column_access.cpp b/storage/mroonga/lib/mrn_debug_column_access.cpp
index 778300a33d6..5e875953b57 100644
--- a/storage/mroonga/lib/mrn_debug_column_access.cpp
+++ b/storage/mroonga/lib/mrn_debug_column_access.cpp
@@ -24,13 +24,13 @@ namespace mrn {
     : table_(table),
       bitmap_(bitmap) {
 #ifdef DBUG_ASSERT_EXISTS
-    map_ = dbug_tmp_use_all_columns(table_, bitmap_);
+    map_ = dbug_tmp_use_all_columns(table_, &bitmap_);
 #endif
   }
 
   DebugColumnAccess::~DebugColumnAccess() {
 #ifdef DBUG_ASSERT_EXISTS
-    dbug_tmp_restore_column_map(bitmap_, map_);
+    dbug_tmp_restore_column_map(&bitmap_, map_);
 #endif
   }
 }
diff --git a/storage/mroonga/lib/mrn_debug_column_access.hpp b/storage/mroonga/lib/mrn_debug_column_access.hpp
index 7c2fd60344e..77fe05f383c 100644
--- a/storage/mroonga/lib/mrn_debug_column_access.hpp
+++ b/storage/mroonga/lib/mrn_debug_column_access.hpp
@@ -27,7 +27,7 @@ namespace mrn {
     TABLE *table_;
     MY_BITMAP *bitmap_;
 #ifdef DBUG_ASSERT_EXISTS
-    my_bitmap_map *map_;
+    MY_BITMAP *map_;
 #endif
   public:
     DebugColumnAccess(TABLE *table, MY_BITMAP *bitmap);
diff --git a/storage/oqgraph/ha_oqgraph.cc b/storage/oqgraph/ha_oqgraph.cc
index 3cb47e204a0..398f48a80ac 100644
--- a/storage/oqgraph/ha_oqgraph.cc
+++ b/storage/oqgraph/ha_oqgraph.cc
@@ -908,7 +908,7 @@ int ha_oqgraph::index_read_idx(byte * buf, uint index, const byte * key,
   bmove_align(buf, table->s->default_values, table->s->reclength);
   key_restore(buf, (byte*) key, key_info, key_len);
 
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->read_set);
   my_ptrdiff_t ptrdiff= buf - table->record[0];
 
   if (ptrdiff)
@@ -937,7 +937,7 @@ int ha_oqgraph::index_read_idx(byte * buf, uint index, const byte * key,
           field[1]->move_field_offset(-ptrdiff);
           field[2]->move_field_offset(-ptrdiff);
         }
-        dbug_tmp_restore_column_map(table->read_set, old_map);
+        dbug_tmp_restore_column_map(&table->read_set, old_map);
         return error_code(oqgraph::NO_MORE_DATA);
       }
     }
@@ -962,7 +962,7 @@ int ha_oqgraph::index_read_idx(byte * buf, uint index, const byte * key,
     field[1]->move_field_offset(-ptrdiff);
     field[2]->move_field_offset(-ptrdiff);
   }
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   // Keep the latch around so we can use it in the query result later -
   // See fill_record().
@@ -995,7 +995,7 @@ int ha_oqgraph::fill_record(byte *record, const open_query::row &row)
 
   bmove_align(record, table->s->default_values, table->s->reclength);
 
-  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map= dbug_tmp_use_all_columns(table, &table->write_set);
   my_ptrdiff_t ptrdiff= record - table->record[0];
 
   if (ptrdiff)
@@ -1071,7 +1071,7 @@ int ha_oqgraph::fill_record(byte *record, const open_query::row &row)
     field[4]->move_field_offset(-ptrdiff);
     field[5]->move_field_offset(-ptrdiff);
   }
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
 
   return 0;
 }
diff --git a/storage/perfschema/pfs_engine_table.cc b/storage/perfschema/pfs_engine_table.cc
index 08ad7d31c88..46937d00ecf 100644
--- a/storage/perfschema/pfs_engine_table.cc
+++ b/storage/perfschema/pfs_engine_table.cc
@@ -188,17 +188,15 @@ ha_rows PFS_engine_table_share::get_row_count(void) const
 int PFS_engine_table_share::write_row(TABLE *table, unsigned char *buf,
                                       Field **fields) const
 {
-  my_bitmap_map *org_bitmap;
-
   if (m_write_row == NULL)
   {
     return HA_ERR_WRONG_COMMAND;
   }
 
   /* We internally read from Fields to support the write interface */
-  org_bitmap= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
   int result= m_write_row(table, buf, fields);
-  dbug_tmp_restore_column_map(table->read_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
 
   return result;
 }
@@ -256,7 +254,6 @@ int PFS_engine_table::read_row(TABLE *table,
                                unsigned char *buf,
                                Field **fields)
 {
-  my_bitmap_map *org_bitmap;
   Field *f;
   Field **fields_reset;
 
@@ -264,7 +261,7 @@ int PFS_engine_table::read_row(TABLE *table,
   bool read_all= !bitmap_is_clear_all(table->write_set);
 
   /* We internally write to Fields to support the read interface */
-  org_bitmap= dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->write_set);
 
   /*
     Some callers of the storage engine interface do not honor the
@@ -276,7 +273,7 @@ int PFS_engine_table::read_row(TABLE *table,
     f->reset();
 
   int result= read_row_values(table, buf, fields, read_all);
-  dbug_tmp_restore_column_map(table->write_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->write_set, org_bitmap);
 
   return result;
 }
@@ -294,12 +291,10 @@ int PFS_engine_table::update_row(TABLE *table,
                                  const unsigned char *new_buf,
                                  Field **fields)
 {
-  my_bitmap_map *org_bitmap;
-
   /* We internally read from Fields to support the write interface */
-  org_bitmap= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
   int result= update_row_values(table, old_buf, new_buf, fields);
-  dbug_tmp_restore_column_map(table->read_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
 
   return result;
 }
@@ -308,12 +303,10 @@ int PFS_engine_table::delete_row(TABLE *table,
                                  const unsigned char *buf,
                                  Field **fields)
 {
-  my_bitmap_map *org_bitmap;
-
   /* We internally read from Fields to support the delete interface */
-  org_bitmap= dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
   int result= delete_row_values(table, buf, fields);
-  dbug_tmp_restore_column_map(table->read_set, org_bitmap);
+  dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
 
   return result;
 }
diff --git a/storage/rocksdb/ha_rocksdb.cc b/storage/rocksdb/ha_rocksdb.cc
index c4275054322..1922d6212f9 100644
--- a/storage/rocksdb/ha_rocksdb.cc
+++ b/storage/rocksdb/ha_rocksdb.cc
@@ -6116,8 +6116,7 @@ ulonglong ha_rocksdb::load_auto_incr_value_from_index() {
     Field *field =
         table->key_info[table->s->next_number_index].key_part[0].field;
     ulonglong max_val = rdb_get_int_col_max_value(field);
-    my_bitmap_map *const old_map =
-        dbug_tmp_use_all_columns(table, table->read_set);
+    MY_BITMAP *const old_map = dbug_tmp_use_all_columns(table, &table->read_set);
     last_val = field->val_int();
     if (last_val != max_val) {
       last_val++;
@@ -6132,7 +6131,7 @@ ulonglong ha_rocksdb::load_auto_incr_value_from_index() {
       }
     }
 #endif
-    dbug_tmp_restore_column_map(table->read_set, old_map);
+    dbug_tmp_restore_column_map(&table->read_set, old_map);
   }
 
   m_keyread_only = save_keyread_only;
@@ -6169,15 +6168,15 @@ void ha_rocksdb::update_auto_incr_val_from_field() {
   field = table->key_info[table->s->next_number_index].key_part[0].field;
   max_val = rdb_get_int_col_max_value(field);
 
-  my_bitmap_map *const old_map =
-      dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *const old_map =
+      dbug_tmp_use_all_columns(table, &table->read_set);
   new_val = field->val_int();
   // don't increment if we would wrap around
   if (new_val != max_val) {
     new_val++;
   }
 
-  dbug_tmp_restore_column_map(table->read_set, old_map);
+  dbug_tmp_restore_column_map(&table->read_set, old_map);
 
   // Only update if positive value was set for auto_incr column.
   if (new_val <= max_val) {
diff --git a/storage/rocksdb/rdb_datadic.cc b/storage/rocksdb/rdb_datadic.cc
index 0d43d4da5c4..3f9417385fe 100644
--- a/storage/rocksdb/rdb_datadic.cc
+++ b/storage/rocksdb/rdb_datadic.cc
@@ -1488,12 +1488,12 @@ void Rdb_key_def::pack_with_make_sort_key(
   DBUG_ASSERT(*dst != nullptr);
 
   const int max_len = fpi->m_max_image_len;
-  my_bitmap_map *old_map;
+  MY_BITMAP*old_map;
 
   old_map= dbug_tmp_use_all_columns(field->table,
-                                    field->table->read_set);
+                                    &field->table->read_set);
   field->sort_string(*dst, max_len);
-  dbug_tmp_restore_column_map(field->table->read_set, old_map);
+  dbug_tmp_restore_column_map(&field->table->read_set, old_map);
   *dst += max_len;
 }
 
diff --git a/storage/sequence/sequence.cc b/storage/sequence/sequence.cc
index b9f5d02bd51..8eae98955c3 100644
--- a/storage/sequence/sequence.cc
+++ b/storage/sequence/sequence.cc
@@ -115,13 +115,13 @@ THR_LOCK_DATA **ha_seq::store_lock(THD *thd, THR_LOCK_DATA **to,
 
 void ha_seq::set(unsigned char *buf)
 {
-  my_bitmap_map *old_map = dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *old_map = dbug_tmp_use_all_columns(table, &table->write_set);
   my_ptrdiff_t offset = (my_ptrdiff_t) (buf - table->record[0]);
   Field *field = table->field[0];
   field->move_field_offset(offset);
   field->store(cur, true);
   field->move_field_offset(-offset);
-  dbug_tmp_restore_column_map(table->write_set, old_map);
+  dbug_tmp_restore_column_map(&table->write_set, old_map);
 }
 
 int ha_seq::rnd_init(bool scan)
diff --git a/storage/sphinx/ha_sphinx.cc b/storage/sphinx/ha_sphinx.cc
index 4092cfcb514..0e5ba383caf 100644
--- a/storage/sphinx/ha_sphinx.cc
+++ b/storage/sphinx/ha_sphinx.cc
@@ -3048,7 +3048,7 @@ int ha_sphinx::get_rec ( byte * buf, const byte *, uint )
 	}
 
 	#if MYSQL_VERSION_ID>50100
-	my_bitmap_map * org_bitmap = dbug_tmp_use_all_columns ( table, table->write_set );
+	MY_BITMAP * org_bitmap = dbug_tmp_use_all_columns ( table, &table->write_set );
 	#endif
 	Field ** field = table->field;
 
@@ -3194,7 +3194,7 @@ int ha_sphinx::get_rec ( byte * buf, const byte *, uint )
 	m_iCurrentPos++;
 
 	#if MYSQL_VERSION_ID > 50100
-	dbug_tmp_restore_column_map ( table->write_set, org_bitmap );
+	dbug_tmp_restore_column_map ( &table->write_set, org_bitmap );
 	#endif
 
 	SPH_RET(0);
diff --git a/storage/spider/ha_spider.cc b/storage/spider/ha_spider.cc
index 2b993fa7e9c..0f222577515 100644
--- a/storage/spider/ha_spider.cc
+++ b/storage/spider/ha_spider.cc
@@ -9951,12 +9951,12 @@ int ha_spider::write_row(
       if (!table->auto_increment_field_not_null)
       {
 #ifndef DBUG_OFF
-        my_bitmap_map *tmp_map =
-          dbug_tmp_use_all_columns(table, table->write_set);
+        MY_BITMAP *tmp_map =
+          dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
         table->next_number_field->store((longlong) 0, TRUE);
 #ifndef DBUG_OFF
-        dbug_tmp_restore_column_map(table->write_set, tmp_map);
+        dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
         force_auto_increment = FALSE;
         table->file->insert_id_for_cur_row = 0;
@@ -9964,13 +9964,13 @@ int ha_spider::write_row(
     } else if (auto_increment_mode == 2)
     {
 #ifndef DBUG_OFF
-      my_bitmap_map *tmp_map =
-        dbug_tmp_use_all_columns(table, table->write_set);
+      MY_BITMAP *tmp_map =
+        dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
       table->next_number_field->store((longlong) 0, TRUE);
       table->auto_increment_field_not_null = FALSE;
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->write_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
       force_auto_increment = FALSE;
       table->file->insert_id_for_cur_row = 0;
diff --git a/storage/spider/spd_db_conn.cc b/storage/spider/spd_db_conn.cc
index cea85b46657..424f22d46ee 100644
--- a/storage/spider/spd_db_conn.cc
+++ b/storage/spider/spd_db_conn.cc
@@ -1673,7 +1673,7 @@ int spider_db_append_key_where_internal(
   DBUG_PRINT("info", ("spider end_key_part_map=%lu", end_key_part_map));
 
 #ifndef DBUG_OFF
-  my_bitmap_map *tmp_map = dbug_tmp_use_all_columns(table, table->read_set);
+  MY_BITMAP *tmp_map = dbug_tmp_use_all_columns(table, &table->read_set);
 #endif
 
   if (sql_kind == SPIDER_SQL_KIND_HANDLER)
@@ -2481,7 +2481,7 @@ end:
   if (sql_kind == SPIDER_SQL_KIND_SQL)
     dbton_hdl->set_order_pos(sql_type);
 #ifndef DBUG_OFF
-  dbug_tmp_restore_column_map(table->read_set, tmp_map);
+  dbug_tmp_restore_column_map(&table->read_set, tmp_map);
 #endif
   DBUG_RETURN(0);
 }
@@ -3002,8 +3002,8 @@ int spider_db_fetch_table(
         bitmap_is_set(table->write_set, (*field)->field_index)
       )) {
 #ifndef DBUG_OFF
-        my_bitmap_map *tmp_map =
-          dbug_tmp_use_all_columns(table, table->write_set);
+        MY_BITMAP *tmp_map =
+          dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
         DBUG_PRINT("info", ("spider bitmap is set %s",
           SPIDER_field_name_str(*field)));
@@ -3011,7 +3011,7 @@ int spider_db_fetch_table(
           spider_db_fetch_row(share, *field, row, ptr_diff)))
           DBUG_RETURN(error_num);
 #ifndef DBUG_OFF
-        dbug_tmp_restore_column_map(table->write_set, tmp_map);
+        dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
       } else {
         DBUG_PRINT("info", ("spider bitmap is not set %s",
@@ -3182,8 +3182,8 @@ int spider_db_fetch_key(
       bitmap_is_set(table->write_set, field->field_index)
     )) {
 #ifndef DBUG_OFF
-      my_bitmap_map *tmp_map =
-        dbug_tmp_use_all_columns(table, table->write_set);
+      MY_BITMAP *tmp_map =
+        dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
       DBUG_PRINT("info", ("spider bitmap is set %s",
         SPIDER_field_name_str(field)));
@@ -3191,7 +3191,7 @@ int spider_db_fetch_key(
         spider_db_fetch_row(share, field, row, ptr_diff)))
         DBUG_RETURN(error_num);
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->write_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
     }
     row->next();
@@ -3306,15 +3306,15 @@ int spider_db_fetch_minimum_columns(
         bitmap_is_set(table->write_set, (*field)->field_index)
       )) {
 #ifndef DBUG_OFF
-        my_bitmap_map *tmp_map =
-          dbug_tmp_use_all_columns(table, table->write_set);
+        MY_BITMAP *tmp_map =
+          dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
         DBUG_PRINT("info", ("spider bitmap is set %s",
           SPIDER_field_name_str(*field)));
         if ((error_num = spider_db_fetch_row(share, *field, row, ptr_diff)))
           DBUG_RETURN(error_num);
 #ifndef DBUG_OFF
-        dbug_tmp_restore_column_map(table->write_set, tmp_map);
+        dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
       }
       row->next();
@@ -5472,8 +5472,8 @@ int spider_db_seek_tmp_table(
       bitmap_is_set(table->write_set, (*field)->field_index)
     )) {
 #ifndef DBUG_OFF
-      my_bitmap_map *tmp_map =
-        dbug_tmp_use_all_columns(table, table->write_set);
+      MY_BITMAP *tmp_map =
+        dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
       DBUG_PRINT("info", ("spider bitmap is set %s",
         SPIDER_field_name_str(*field)));
@@ -5481,7 +5481,7 @@ int spider_db_seek_tmp_table(
         spider_db_fetch_row(spider->share, *field, row, ptr_diff)))
         DBUG_RETURN(error_num);
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->write_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
     }
     row->next();
@@ -5560,8 +5560,8 @@ int spider_db_seek_tmp_key(
       bitmap_is_set(table->write_set, field->field_index)
     )) {
 #ifndef DBUG_OFF
-      my_bitmap_map *tmp_map =
-        dbug_tmp_use_all_columns(table, table->write_set);
+      MY_BITMAP *tmp_map =
+        dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
       DBUG_PRINT("info", ("spider bitmap is set %s",
         SPIDER_field_name_str(field)));
@@ -5569,7 +5569,7 @@ int spider_db_seek_tmp_key(
         spider_db_fetch_row(spider->share, field, row, ptr_diff)))
         DBUG_RETURN(error_num);
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->write_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
     }
     row->next();
@@ -5651,8 +5651,8 @@ int spider_db_seek_tmp_minimum_columns(
         bitmap_is_set(table->write_set, (*field)->field_index)));
 */
 #ifndef DBUG_OFF
-      my_bitmap_map *tmp_map =
-        dbug_tmp_use_all_columns(table, table->write_set);
+      MY_BITMAP *tmp_map =
+        dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
       DBUG_PRINT("info", ("spider bitmap is set %s",
         SPIDER_field_name_str(*field)));
@@ -5661,7 +5661,7 @@ int spider_db_seek_tmp_minimum_columns(
         DBUG_RETURN(error_num);
       row->next();
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->write_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
     }
     else if (bitmap_is_set(table->read_set, (*field)->field_index))
@@ -9363,7 +9363,7 @@ int spider_db_open_item_string(
   {
     THD *thd = NULL;
     TABLE *table;
-    my_bitmap_map *saved_map;
+    MY_BITMAP *saved_map;
     Time_zone *saved_time_zone;
     String str_value;
     char tmp_buf[MAX_FIELD_WIDTH];
@@ -9392,7 +9392,7 @@ int spider_db_open_item_string(
         */
         table = field->table;
         thd = table->in_use;
-        saved_map = dbug_tmp_use_all_columns(table, table->write_set);
+        saved_map = dbug_tmp_use_all_columns(table, &table->write_set);
         item->save_in_field(field, FALSE);
         saved_time_zone = thd->variables.time_zone;
         thd->variables.time_zone = UTC;
@@ -9428,7 +9428,7 @@ end:
     if (thd)
     {
       thd->variables.time_zone = saved_time_zone;
-      dbug_tmp_restore_column_map(table->write_set, saved_map);
+      dbug_tmp_restore_column_map(&table->write_set, saved_map);
     }
   }
 
@@ -9470,7 +9470,7 @@ int spider_db_open_item_int(
   {
     THD *thd = NULL;
     TABLE *table;
-    my_bitmap_map *saved_map;
+    MY_BITMAP *saved_map;
     Time_zone *saved_time_zone;
     String str_value;
     bool print_quoted_string;
@@ -9498,7 +9498,7 @@ int spider_db_open_item_int(
       */
       table = field->table;
       thd = table->in_use;
-      saved_map = dbug_tmp_use_all_columns(table, table->write_set);
+      saved_map = dbug_tmp_use_all_columns(table, &table->write_set);
       item->save_in_field(field, FALSE);
       saved_time_zone = thd->variables.time_zone;
       thd->variables.time_zone = UTC;
@@ -9544,7 +9544,7 @@ end:
     if (thd)
     {
       thd->variables.time_zone = saved_time_zone;
-      dbug_tmp_restore_column_map(table->write_set, saved_map);
+      dbug_tmp_restore_column_map(&table->write_set, saved_map);
     }
   }
 
@@ -9864,8 +9864,8 @@ int spider_db_udf_fetch_table(
     DBUG_RETURN(HA_ERR_END_OF_FILE);
 
 #ifndef DBUG_OFF
-  my_bitmap_map *tmp_map =
-    dbug_tmp_use_all_columns(table, table->write_set);
+  MY_BITMAP *tmp_map =
+    dbug_tmp_use_all_columns(table, &table->write_set);
 #endif
   for (
     roop_count = 0,
@@ -9878,7 +9878,7 @@ int spider_db_udf_fetch_table(
       spider_db_udf_fetch_row(trx, *field, row)))
     {
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->write_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
       DBUG_RETURN(error_num);
     }
@@ -9888,7 +9888,7 @@ int spider_db_udf_fetch_table(
   for (; roop_count < set_off; roop_count++, field++)
     (*field)->set_default();
 #ifndef DBUG_OFF
-  dbug_tmp_restore_column_map(table->write_set, tmp_map);
+  dbug_tmp_restore_column_map(&table->write_set, tmp_map);
 #endif
   table->status = 0;
   DBUG_RETURN(0);
diff --git a/storage/spider/spd_db_mysql.cc b/storage/spider/spd_db_mysql.cc
index cac6b063ad0..ce6aef63fd8 100644
--- a/storage/spider/spd_db_mysql.cc
+++ b/storage/spider/spd_db_mysql.cc
@@ -8181,8 +8181,7 @@ int spider_mbase_handler::append_update_set(
         mysql_share->append_column_name(str, (*fields)->field_index);
         str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
 #ifndef DBUG_OFF
-        my_bitmap_map *tmp_map = dbug_tmp_use_all_columns(table,
-          table->read_set);
+        MY_BITMAP *tmp_map = dbug_tmp_use_all_columns(table, &table->read_set);
 #endif
         if (
           spider_db_mbase_utility->
@@ -8191,12 +8190,12 @@ int spider_mbase_handler::append_update_set(
           str->reserve(SPIDER_SQL_COMMA_LEN)
         ) {
 #ifndef DBUG_OFF
-          dbug_tmp_restore_column_map(table->read_set, tmp_map);
+          dbug_tmp_restore_column_map(&table->read_set, tmp_map);
 #endif
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
         }
 #ifndef DBUG_OFF
-        dbug_tmp_restore_column_map(table->read_set, tmp_map);
+        dbug_tmp_restore_column_map(&table->read_set, tmp_map);
 #endif
       }
       str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
@@ -10888,8 +10887,8 @@ int spider_mbase_handler::append_insert_values(
       bitmap_is_set(table->read_set, (*field)->field_index)
     ) {
 #ifndef DBUG_OFF
-      my_bitmap_map *tmp_map =
-        dbug_tmp_use_all_columns(table, table->read_set);
+      MY_BITMAP *tmp_map =
+        dbug_tmp_use_all_columns(table, &table->read_set);
 #endif
       add_value = TRUE;
       DBUG_PRINT("info",("spider is_null()=%s",
@@ -10911,7 +10910,7 @@ int spider_mbase_handler::append_insert_values(
         if (str->reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN))
         {
 #ifndef DBUG_OFF
-          dbug_tmp_restore_column_map(table->read_set, tmp_map);
+          dbug_tmp_restore_column_map(&table->read_set, tmp_map);
 #endif
           str->length(0);
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -10925,7 +10924,7 @@ int spider_mbase_handler::append_insert_values(
           str->reserve(SPIDER_SQL_COMMA_LEN)
         ) {
 #ifndef DBUG_OFF
-          dbug_tmp_restore_column_map(table->read_set, tmp_map);
+          dbug_tmp_restore_column_map(&table->read_set, tmp_map);
 #endif
           str->length(0);
           DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -10933,7 +10932,7 @@ int spider_mbase_handler::append_insert_values(
       }
       str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
 #ifndef DBUG_OFF
-      dbug_tmp_restore_column_map(table->read_set, tmp_map);
+      dbug_tmp_restore_column_map(&table->read_set, tmp_map);
 #endif
     }
   }
diff --git a/storage/tokudb/ha_tokudb.cc b/storage/tokudb/ha_tokudb.cc
index 2f13e4cdbb9..cc61aa85598 100644
--- a/storage/tokudb/ha_tokudb.cc
+++ b/storage/tokudb/ha_tokudb.cc
@@ -2313,7 +2313,7 @@ int ha_tokudb::pack_row_in_buff(
     int r = ENOSYS;
     memset((void *) row, 0, sizeof(*row));
 
-    my_bitmap_map *old_map = dbug_tmp_use_all_columns(table, table->write_set);
+    MY_BITMAP *old_map = dbug_tmp_use_all_columns(table, &table->write_set);
     
     // Copy null bytes
     memcpy(row_buff, record, table_share->null_bytes);
@@ -2362,7 +2362,7 @@ int ha_tokudb::pack_row_in_buff(
     row->size = (size_t) (var_field_data_ptr - row_buff);
     r = 0;
 
-    dbug_tmp_restore_column_map(table->write_set, old_map);
+    dbug_tmp_restore_column_map(&table->write_set, old_map);
     return r;
 }
 
@@ -2758,7 +2758,7 @@ DBT* ha_tokudb::create_dbt_key_from_key(
 {
     uint32_t size = 0;
     uchar* tmp_buff = buff;
-    my_bitmap_map *old_map = dbug_tmp_use_all_columns(table, table->write_set);
+    MY_BITMAP *old_map = dbug_tmp_use_all_columns(table, &table->write_set);
 
     key->data = buff;
 
@@ -2797,7 +2797,7 @@ DBT* ha_tokudb::create_dbt_key_from_key(
 
     key->size = size;
     DBUG_DUMP("key", (uchar *) key->data, key->size);
-    dbug_tmp_restore_column_map(table->write_set, old_map);
+    dbug_tmp_restore_column_map(&table->write_set, old_map);
     return key;
 }
 
@@ -2890,7 +2890,7 @@ DBT* ha_tokudb::pack_key(
     KEY* key_info = &table->key_info[keynr];
     KEY_PART_INFO* key_part = key_info->key_part;
     KEY_PART_INFO* end = key_part + key_info->user_defined_key_parts;
-    my_bitmap_map* old_map = dbug_tmp_use_all_columns(table, table->write_set);
+    MY_BITMAP* old_map = dbug_tmp_use_all_columns(table, &table->write_set);
 
     memset((void *) key, 0, sizeof(*key));
     key->data = buff;
@@ -2927,7 +2927,7 @@ DBT* ha_tokudb::pack_key(
 
     key->size = (buff - (uchar *) key->data);
     DBUG_DUMP("key", (uchar *) key->data, key->size);
-    dbug_tmp_restore_column_map(table->write_set, old_map);
+    dbug_tmp_restore_column_map(&table->write_set, old_map);
     DBUG_RETURN(key);
 }
 
@@ -2955,7 +2955,7 @@ DBT* ha_tokudb::pack_ext_key(
     KEY* key_info = &table->key_info[keynr];
     KEY_PART_INFO* key_part = key_info->key_part;
     KEY_PART_INFO* end = key_part + key_info->user_defined_key_parts;
-    my_bitmap_map* old_map = dbug_tmp_use_all_columns(table, table->write_set);
+    MY_BITMAP* old_map = dbug_tmp_use_all_columns(table, &table->write_set);
 
     memset((void *) key, 0, sizeof(*key));
     key->data = buff;
@@ -3034,7 +3034,7 @@ DBT* ha_tokudb::pack_ext_key(
 
     key->size = (buff - (uchar *) key->data);
     DBUG_DUMP("key", (uchar *) key->data, key->size);
-    dbug_tmp_restore_column_map(table->write_set, old_map);
+    dbug_tmp_restore_column_map(&table->write_set, old_map);
     DBUG_RETURN(key);
 }
 #endif  // defined(TOKU_INCLUDE_EXTENDED_KEYS) && TOKU_INCLUDE_EXTENDED_KEYS