MDEV-19197 Move ASSERT_COLUMN_MARKED_FOR_XXX as methods to Field

2 files changed, 151 insertions, 142 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 14b57b73ecc..4a93464b2e8 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -58,19 +58,25 @@ const char field_separator=',';
                         ((ulong) ((1LL << MY_MIN(arg, 4) * 8) - 1))
 
 // Column marked for read or the field set to read out or record[0] or [1]
-#define ASSERT_COLUMN_MARKED_FOR_READ                              \
-  DBUG_ASSERT(!table ||                                            \
-              (!table->read_set ||                                 \
-               bitmap_is_set(table->read_set, field_index) ||      \
-               (!(ptr >= table->record[0] &&                       \
-                  ptr < table->record[0] + table->s->reclength))))
-
-#define ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED                   \
-  DBUG_ASSERT(is_stat_field || !table ||                             \
-              (!table->write_set ||                                  \
-               bitmap_is_set(table->write_set, field_index) ||       \
-               (!(ptr >= table->record[0] &&                         \
-                  ptr < table->record[0] + table->s->reclength))))
+inline bool Field::marked_for_read() const
+{
+  return !table ||
+         (!table->read_set ||
+          bitmap_is_set(table->read_set, field_index) ||
+          (!(ptr >= table->record[0] &&
+          ptr < table->record[0] + table->s->reclength)));
+}
+
+
+inline bool Field::marked_for_write_or_computed() const
+{
+  return is_stat_field || !table ||
+         (!table->write_set ||
+          bitmap_is_set(table->write_set, field_index) ||
+          (!(ptr >= table->record[0] &&
+          ptr < table->record[0] + table->s->reclength)));
+}
+
 
 #define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
 
@@ -1686,7 +1692,7 @@ int Field::warn_if_overflow(int op_result)
 
 String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   CHARSET_INFO *cs= &my_charset_bin;
   uint length;
   longlong value= val_int();
@@ -2034,7 +2040,7 @@ longlong Field::convert_decimal2longlong(const my_decimal *val,
 
 int Field_int::store_decimal(const my_decimal *val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int err= 0;
   longlong i= convert_decimal2longlong(val, unsigned_flag, &err);
   return MY_TEST(err | store(i, unsigned_flag));
@@ -2057,7 +2063,7 @@ int Field_int::store_decimal(const my_decimal *val)
 
 my_decimal* Field_int::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong nr= val_int();
   int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
   return decimal_value;
@@ -2066,7 +2072,7 @@ my_decimal* Field_int::val_decimal(my_decimal *decimal_value)
 
 bool Field_int::get_date(MYSQL_TIME *ltime,date_mode_t fuzzydate)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   Longlong_hybrid nr(val_int(), (flags & UNSIGNED_FLAG));
   return int_to_datetime_with_warn(get_thd(), nr, ltime,
                                    fuzzydate, table->s, field_name.str);
@@ -2075,7 +2081,7 @@ bool Field_int::get_date(MYSQL_TIME *ltime,date_mode_t fuzzydate)
 
 bool Field_vers_trx_id::get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate, ulonglong trx_id)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   DBUG_ASSERT(ltime);
   if (!table || !table->s)
     return true;
@@ -2201,7 +2207,7 @@ void Field_num::make_send_field(Send_field *field)
 
 int Field_str::store_decimal(const my_decimal *d)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   double val;
   /* TODO: use decimal2string? */
   int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
@@ -2212,7 +2218,7 @@ int Field_str::store_decimal(const my_decimal *d)
 
 my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong nr= val_int();
   int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
   return decimal_value;
@@ -2271,7 +2277,7 @@ bool Field::get_date(MYSQL_TIME *to, date_mode_t mode)
 
 int Field::store_time_dec(const MYSQL_TIME *ltime, uint dec)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   char buff[MAX_DATE_STRING_REP_LENGTH];
   uint length= (uint) my_TIME_to_str(ltime, buff, dec);
   /* Avoid conversion when field character set is ASCII compatible */
@@ -2528,7 +2534,7 @@ void Field_decimal::overflow(bool negative)
 
 int Field_decimal::store(const char *from_arg, size_t len, CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   char buff[STRING_BUFFER_USUAL_SIZE];
   String tmp(buff,sizeof(buff), &my_charset_bin);
   const uchar *from= (uchar*) from_arg;
@@ -2894,7 +2900,7 @@ int Field_decimal::store(const char *from_arg, size_t len, CHARSET_INFO *cs)
 
 int Field_decimal::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   if (unsigned_flag && nr < 0)
   {
     overflow(1);
@@ -2932,7 +2938,7 @@ int Field_decimal::store(double nr)
 
 int Field_decimal::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   char buff[22];
   uint length, int_part;
   char fyllchar;
@@ -2968,7 +2974,7 @@ int Field_decimal::store(longlong nr, bool unsigned_val)
 
 double Field_decimal::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int not_used;
   char *end_not_used;
   return my_strntod(&my_charset_bin, (char*) ptr, field_length, &end_not_used,
@@ -2977,7 +2983,7 @@ double Field_decimal::val_real(void)
 
 longlong Field_decimal::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int not_used;
   if (unsigned_flag)
     return my_strntoull(&my_charset_bin, (char*) ptr, field_length, 10, NULL,
@@ -2990,7 +2996,7 @@ longlong Field_decimal::val_int(void)
 String *Field_decimal::val_str(String *val_buffer __attribute__((unused)),
 			       String *val_ptr)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   uchar *str;
   size_t tmp_length;
 
@@ -3175,7 +3181,7 @@ void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
 bool Field_new_decimal::store_value(const my_decimal *decimal_value,
                                     int *native_error)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   DBUG_ENTER("Field_new_decimal::store_value");
 #ifndef DBUG_OFF
@@ -3233,7 +3239,7 @@ bool Field_new_decimal::store_value(const my_decimal *decimal_value)
 int Field_new_decimal::store(const char *from, size_t length,
                              CHARSET_INFO *charset_arg)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   my_decimal decimal_value;
   THD *thd= get_thd();
   DBUG_ENTER("Field_new_decimal::store(char*)");
@@ -3317,7 +3323,7 @@ int Field_new_decimal::store(const char *from, size_t length,
 
 int Field_new_decimal::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   my_decimal decimal_value;
   int err;
   THD *thd= get_thd();
@@ -3342,7 +3348,7 @@ int Field_new_decimal::store(double nr)
 
 int Field_new_decimal::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   my_decimal decimal_value;
   int err;
 
@@ -3364,7 +3370,7 @@ int Field_new_decimal::store(longlong nr, bool unsigned_val)
 
 int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   return store_value(decimal_value);
 }
 
@@ -3378,7 +3384,7 @@ int Field_new_decimal::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
 
 my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   DBUG_ENTER("Field_new_decimal::val_decimal");
   binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
                     precision, dec);
@@ -3581,7 +3587,7 @@ int Field_int::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
 
 int Field_tiny::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error;
   longlong rnd;
   
@@ -3593,7 +3599,7 @@ int Field_tiny::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_tiny::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   nr=rint(nr);
   if (unsigned_flag)
@@ -3636,7 +3642,7 @@ int Field_tiny::store(double nr)
 
 int Field_tiny::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
 
   if (unsigned_flag)
@@ -3681,7 +3687,7 @@ int Field_tiny::store(longlong nr, bool unsigned_val)
 
 double Field_tiny::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int tmp= unsigned_flag ? (int) ptr[0] :
     (int) ((signed char*) ptr)[0];
   return (double) tmp;
@@ -3690,7 +3696,7 @@ double Field_tiny::val_real(void)
 
 longlong Field_tiny::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int tmp= unsigned_flag ? (int) ptr[0] :
     (int) ((signed char*) ptr)[0];
   return (longlong) tmp;
@@ -3700,7 +3706,7 @@ longlong Field_tiny::val_int(void)
 String *Field_tiny::val_str(String *val_buffer,
 			    String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   long nr= unsigned_flag ? (long) ptr[0] : (long) ((signed char*) ptr)[0];
   return val_str_from_long(val_buffer, 5, -10, nr);
 }
@@ -3741,7 +3747,7 @@ void Field_tiny::sql_type(String &res) const
 
 int Field_short::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int store_tmp;
   int error;
   longlong rnd;
@@ -3755,7 +3761,7 @@ int Field_short::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_short::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   int16 res;
   nr=rint(nr);
@@ -3800,7 +3806,7 @@ int Field_short::store(double nr)
 
 int Field_short::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   int16 res;
 
@@ -3848,7 +3854,7 @@ int Field_short::store(longlong nr, bool unsigned_val)
 
 double Field_short::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   short j;
   j=sint2korr(ptr);
   return unsigned_flag ? (double) (unsigned short) j : (double) j;
@@ -3856,7 +3862,7 @@ double Field_short::val_real(void)
 
 longlong Field_short::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   short j;
   j=sint2korr(ptr);
   return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
@@ -3866,7 +3872,7 @@ longlong Field_short::val_int(void)
 String *Field_short::val_str(String *val_buffer,
 			     String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   short j= sint2korr(ptr);
   long nr= unsigned_flag ? (long) (unsigned short) j : (long) j;
   return val_str_from_long(val_buffer, 7, -10, nr);
@@ -3915,7 +3921,7 @@ void Field_short::sql_type(String &res) const
 
 int Field_medium::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int store_tmp;
   int error;
   longlong rnd;
@@ -3929,7 +3935,7 @@ int Field_medium::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_medium::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   nr=rint(nr);
   if (unsigned_flag)
@@ -3975,7 +3981,7 @@ int Field_medium::store(double nr)
 
 int Field_medium::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
 
   if (unsigned_flag)
@@ -4024,7 +4030,7 @@ int Field_medium::store(longlong nr, bool unsigned_val)
 
 double Field_medium::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
   return (double) j;
 }
@@ -4032,7 +4038,7 @@ double Field_medium::val_real(void)
 
 longlong Field_medium::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
   return (longlong) j;
 }
@@ -4041,7 +4047,7 @@ longlong Field_medium::val_int(void)
 String *Field_medium::val_str(String *val_buffer,
 			      String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   long nr= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
   return val_str_from_long(val_buffer, 10, -10, nr);
 }
@@ -4067,7 +4073,7 @@ String *Field_int::val_str_from_long(String *val_buffer,
 
 bool Field_medium::send_binary(Protocol *protocol)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return protocol->store_long(Field_medium::val_int());
 }
 
@@ -4113,7 +4119,7 @@ void Field_medium::sql_type(String &res) const
 
 int Field_long::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   long store_tmp;
   int error;
   longlong rnd;
@@ -4127,7 +4133,7 @@ int Field_long::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_long::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   int32 res;
   nr=rint(nr);
@@ -4172,7 +4178,7 @@ int Field_long::store(double nr)
 
 int Field_long::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   int32 res;
 
@@ -4218,7 +4224,7 @@ int Field_long::store(longlong nr, bool unsigned_val)
 
 double Field_long::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int32 j;
   j=sint4korr(ptr);
   return unsigned_flag ? (double) (uint32) j : (double) j;
@@ -4226,7 +4232,7 @@ double Field_long::val_real(void)
 
 longlong Field_long::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int32 j;
   /* See the comment in Field_long::store(long long) */
   DBUG_ASSERT(!table || table->in_use == current_thd);
@@ -4238,7 +4244,7 @@ longlong Field_long::val_int(void)
 String *Field_long::val_str(String *val_buffer,
 			    String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   long nr= unsigned_flag ? (long) uint4korr(ptr) : sint4korr(ptr);
   return val_str_from_long(val_buffer, 12, unsigned_flag ? 10 : -10, nr);
 }
@@ -4246,7 +4252,7 @@ String *Field_long::val_str(String *val_buffer,
 
 bool Field_long::send_binary(Protocol *protocol)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return protocol->store_long(Field_long::val_int());
 }
 
@@ -4286,7 +4292,7 @@ void Field_long::sql_type(String &res) const
 
 int Field_longlong::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   char *end;
   ulonglong tmp;
@@ -4309,7 +4315,7 @@ int Field_longlong::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_longlong::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   Converter_double_to_longlong conv(nr, unsigned_flag);
 
   if (unlikely(conv.error()))
@@ -4322,7 +4328,7 @@ int Field_longlong::store(double nr)
 
 int Field_longlong::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
 
   if (unlikely(nr < 0))                         // Only possible error
@@ -4346,7 +4352,7 @@ int Field_longlong::store(longlong nr, bool unsigned_val)
 
 double Field_longlong::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong j;
   j=sint8korr(ptr);
   /* The following is open coded to avoid a bug in gcc 3.3 */
@@ -4361,7 +4367,7 @@ double Field_longlong::val_real(void)
 
 longlong Field_longlong::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong j;
   j=sint8korr(ptr);
   return j;
@@ -4391,7 +4397,7 @@ String *Field_longlong::val_str(String *val_buffer,
 
 bool Field_longlong::send_binary(Protocol *protocol)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
 }
 
@@ -4433,14 +4439,14 @@ void Field_longlong::sql_type(String &res) const
 
 void Field_longlong::set_max()
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   set_notnull();
   int8store(ptr, unsigned_flag ? ULONGLONG_MAX : LONGLONG_MAX);
 }
 
 bool Field_longlong::is_max()
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   if (unsigned_flag)
   {
     ulonglong j;
@@ -4470,7 +4476,7 @@ int Field_float::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_float::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= truncate_double(&nr, field_length,
                              not_fixed ? NOT_FIXED_DEC : dec,
                              unsigned_flag, FLT_MAX);
@@ -4499,7 +4505,7 @@ int Field_float::store(longlong nr, bool unsigned_val)
 
 double Field_float::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   float j;
   float4get(j,ptr);
   return ((double) j);
@@ -4516,7 +4522,7 @@ longlong Field_float::val_int(void)
 String *Field_float::val_str(String *val_buffer,
 			     String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   DBUG_ASSERT(!zerofill || field_length <= MAX_FIELD_CHARLENGTH);
   float nr;
   float4get(nr,ptr);
@@ -4598,7 +4604,7 @@ void Field_float::sort_string(uchar *to,uint length __attribute__((unused)))
 
 bool Field_float::send_binary(Protocol *protocol)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
 }
 
@@ -4649,7 +4655,7 @@ int Field_double::store(const char *from,size_t len,CHARSET_INFO *cs)
 
 int Field_double::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= truncate_double(&nr, field_length,
                              not_fixed ? NOT_FIXED_DEC : dec,
                              unsigned_flag, DBL_MAX);
@@ -4803,7 +4809,7 @@ int Field_real::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
 
 double Field_double::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   double j;
   float8get(j,ptr);
   return j;
@@ -4821,7 +4827,7 @@ longlong Field_double::val_int_from_real(bool want_unsigned_result)
 
 my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value);
   return decimal_value;
 }
@@ -4829,7 +4835,7 @@ my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
 
 bool Field_real::get_date(MYSQL_TIME *ltime,date_mode_t fuzzydate)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   double nr= val_real();
   return double_to_datetime_with_warn(get_thd(), nr, ltime, fuzzydate,
                                       table->s, field_name.str);
@@ -4859,7 +4865,7 @@ Item *Field_real::get_equal_const_item(THD *thd, const Context &ctx,
 String *Field_double::val_str(String *val_buffer,
 			      String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   DBUG_ASSERT(!zerofill || field_length <= MAX_FIELD_CHARLENGTH);
   double nr;
   float8get(nr,ptr);
@@ -5017,7 +5023,7 @@ int Field_timestamp::save_in_field(Field *to)
 my_time_t Field_timestamp::get_timestamp(const uchar *pos,
                                          ulong *sec_part) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   *sec_part= 0;
   return sint4korr(pos);
 }
@@ -5025,7 +5031,7 @@ my_time_t Field_timestamp::get_timestamp(const uchar *pos,
 
 bool Field_timestamp::val_native(Native *to)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   my_time_t sec= (my_time_t) sint4korr(ptr);
   return Timestamp_or_zero_datetime(Timestamp(sec, 0), sec == 0).
            to_native(to, 0);
@@ -5035,7 +5041,7 @@ bool Field_timestamp::val_native(Native *to)
 int Field_timestamp::store_TIME_with_warning(THD *thd, const Datetime *dt,
                                              const ErrConv *str, int was_cut)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   static const Timestamp zero(0, 0);
 
   // Handle totally bad values
@@ -5439,7 +5445,7 @@ void Field_timestamp_hires::store_TIMEVAL(const timeval &tv)
 my_time_t Field_timestamp_hires::get_timestamp(const uchar *pos,
                                                ulong *sec_part) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   *sec_part= (long)sec_part_unshift(read_bigendian(pos+4, sec_part_bytes(dec)), dec);
   return mi_uint4korr(pos);
 }
@@ -5447,7 +5453,7 @@ my_time_t Field_timestamp_hires::get_timestamp(const uchar *pos,
 
 bool Field_timestamp_hires::val_native(Native *to)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   struct timeval tm;
   tm.tv_sec= mi_uint4korr(ptr);
   tm.tv_usec= (ulong) sec_part_unshift(read_bigendian(ptr+4, sec_part_bytes(dec)), dec);
@@ -5533,7 +5539,7 @@ void Field_timestampf::store_TIMEVAL(const timeval &tm)
 void Field_timestampf::set_max()
 {
   DBUG_ENTER("Field_timestampf::set_max");
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   DBUG_ASSERT(dec == TIME_SECOND_PART_DIGITS);
 
   set_notnull();
@@ -5546,7 +5552,7 @@ void Field_timestampf::set_max()
 bool Field_timestampf::is_max()
 {
   DBUG_ENTER("Field_timestampf::is_max");
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
 
   DBUG_RETURN(mi_sint4korr(ptr) == TIMESTAMP_MAX_VALUE &&
               mi_sint3korr(ptr + 4) == TIME_MAX_SECOND_PART);
@@ -5564,7 +5570,7 @@ my_time_t Field_timestampf::get_timestamp(const uchar *pos,
 
 bool Field_timestampf::val_native(Native *to)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   // Check if it's '0000-00-00 00:00:00' rather than a real timestamp
   if (ptr[0] == 0 && ptr[1] == 0 && ptr[2] == 0 && ptr[3] == 0)
   {
@@ -5618,7 +5624,7 @@ int Field_datetime::store_TIME_with_warning(const Datetime *dt,
                                             const ErrConv *str,
                                             int was_cut)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   // Handle totally bad values
   if (!dt->is_valid_datetime())
     return store_invalid_with_warning(str, was_cut, "datetime");
@@ -5765,7 +5771,7 @@ Item *Field_temporal::get_equal_const_item_datetime(THD *thd,
 int Field_time::store_TIME_with_warning(const Time *t,
                                         const ErrConv *str, int warn)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   // Handle totally bad values
   if (!t->is_valid_time())
     return store_invalid_with_warning(str, warn, "time");
@@ -5867,14 +5873,14 @@ Field *Field_time::new_key_field(MEM_ROOT *root, TABLE *new_table,
 
 double Field_time::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   uint32 j= (uint32) uint3korr(ptr);
   return (double) j;
 }
 
 longlong Field_time::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return (longlong) sint3korr(ptr);
 }
 
@@ -5888,7 +5894,7 @@ longlong Field_time::val_int(void)
 String *Field_time::val_str(String *str,
 			    String *unused __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   MYSQL_TIME ltime;
   get_date(&ltime, Datetime::Options(TIME_TIME_ONLY, get_thd()));
   str->alloc(field_length + 1);
@@ -6110,7 +6116,7 @@ Item *Field_time::get_equal_const_item(THD *thd, const Context &ctx,
 
 longlong Field_time_with_dec::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   MYSQL_TIME ltime;
   get_date(&ltime, Time::Options(TIME_TIME_ONLY, get_thd()));
   longlong val= TIME_to_ulonglong_time(&ltime);
@@ -6119,7 +6125,7 @@ longlong Field_time_with_dec::val_int(void)
 
 double Field_time_with_dec::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   MYSQL_TIME ltime;
   get_date(&ltime, Time::Options(TIME_TIME_ONLY, get_thd()));
   return TIME_to_double(&ltime);
@@ -6194,7 +6200,7 @@ bool Field_timef::get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate)
 
 int Field_year::store(const char *from, size_t len,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   char *end;
   int error;
   longlong nr= cs->cset->strntoull10rnd(cs, from, len, 0, &end, &error);
@@ -6242,7 +6248,7 @@ int Field_year::store(double nr)
 
 int Field_year::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155)
   {
     *ptr= 0;
@@ -6274,7 +6280,7 @@ int Field_year::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
 
 bool Field_year::send_binary(Protocol *protocol)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   ulonglong tmp= Field_year::val_int();
   return protocol->store_short(tmp);
 }
@@ -6288,7 +6294,7 @@ double Field_year::val_real(void)
 
 longlong Field_year::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   DBUG_ASSERT(field_length == 2 || field_length == 4);
   int tmp= (int) ptr[0];
   if (field_length != 4)
@@ -6337,7 +6343,7 @@ int Field_date_common::store_TIME_with_warning(const Datetime *dt,
                                                const ErrConv *str,
                                                int was_cut)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   // Handle totally bad values
   if (!dt->is_valid_datetime())
     return store_invalid_with_warning(str, was_cut, "date");
@@ -6422,7 +6428,7 @@ bool Field_date::send_binary(Protocol *protocol)
 
 double Field_date::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int32 j;
   j=sint4korr(ptr);
   return (double) (uint32) j;
@@ -6431,7 +6437,7 @@ double Field_date::val_real(void)
 
 longlong Field_date::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int32 j;
   j=sint4korr(ptr);
   return (longlong) (uint32) j;
@@ -6441,7 +6447,7 @@ longlong Field_date::val_int(void)
 bool Field_date::get_TIME(MYSQL_TIME *ltime, const uchar *pos,
                           date_mode_t fuzzydate) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int32 tmp= sint4korr(pos);
   ltime->year= (int) ((uint32) tmp/10000L % 10000);
   ltime->month= (int) ((uint32) tmp/100 % 100);
@@ -6513,14 +6519,14 @@ bool Field_newdate::send_binary(Protocol *protocol)
 
 double Field_newdate::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return (double) Field_newdate::val_int();
 }
 
 
 longlong Field_newdate::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   ulong j= uint3korr(ptr);
   j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
   return (longlong) j;
@@ -6530,7 +6536,7 @@ longlong Field_newdate::val_int(void)
 String *Field_newdate::val_str(String *val_buffer,
 			       String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   val_buffer->alloc(field_length);
   val_buffer->length(field_length);
   uint32 tmp=(uint32) uint3korr(ptr);
@@ -6560,7 +6566,7 @@ String *Field_newdate::val_str(String *val_buffer,
 bool Field_newdate::get_TIME(MYSQL_TIME *ltime, const uchar *pos,
                              date_mode_t fuzzydate) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   uint32 tmp=(uint32) uint3korr(pos);
   ltime->day=   tmp & 31;
   ltime->month= (tmp >> 5) & 15;
@@ -6681,7 +6687,7 @@ double Field_datetime::val_real(void)
 
 longlong Field_datetime::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong j;
   j=sint8korr(ptr);
   return j;
@@ -6694,7 +6700,7 @@ String *Field_datetime::val_str(String *val_buffer,
   val_buffer->alloc(field_length);
   val_buffer->length(field_length);
 
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   ulonglong tmp;
   long part1,part2;
   char *pos;
@@ -6737,7 +6743,7 @@ String *Field_datetime::val_str(String *val_buffer,
 bool Field_datetime::get_TIME(MYSQL_TIME *ltime, const uchar *pos,
                               date_mode_t fuzzydate) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong tmp= sint8korr(pos);
   uint32 part1,part2;
   part1=(uint32) (tmp/1000000LL);
@@ -6851,7 +6857,7 @@ String *Field_datetime_with_dec::val_str(String *str,
 bool Field_datetime_hires::get_TIME(MYSQL_TIME *ltime, const uchar *pos,
                                     date_mode_t fuzzydate) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   ulonglong packed= read_bigendian(pos, Field_datetime_hires::pack_length());
   unpack_time(sec_part_unshift(packed, dec), ltime, MYSQL_TIMESTAMP_DATETIME);
   return validate_MMDD(packed, ltime->month, ltime->day, fuzzydate);
@@ -6891,7 +6897,7 @@ void Field_datetimef::store_TIME(const MYSQL_TIME *ltime)
 bool Field_datetimef::get_TIME(MYSQL_TIME *ltime, const uchar *pos,
                                date_mode_t fuzzydate) const
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   longlong tmp= my_datetime_packed_from_binary(pos, dec);
   TIME_from_longlong_datetime_packed(ltime, tmp);
   return validate_MMDD(tmp, ltime->month, ltime->day, fuzzydate);
@@ -6996,7 +7002,7 @@ Field_longstr::report_if_important_data(const char *pstr, const char *end,
 
 int Field_string::store(const char *from, size_t length,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   uint copy_length;
   int rc;
 
@@ -7042,7 +7048,7 @@ int Field_str::store(longlong nr, bool unsigned_val)
 
 int Field_str::store(double nr)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
   uint local_char_length= MY_MIN(sizeof(buff),
                                  field_length / field_charset->mbmaxlen);
@@ -7178,7 +7184,7 @@ Field_string::Warn_filter_string::Warn_filter_string(const THD *thd,
 
 double Field_string::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   return Converter_strntod_with_warn(get_thd(),
                                      Warn_filter_string(thd, this),
@@ -7190,7 +7196,7 @@ double Field_string::val_real(void)
 
 longlong Field_string::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   return Converter_strntoll_with_warn(thd, Warn_filter_string(thd, this),
                                       Field_string::charset(),
@@ -7202,7 +7208,7 @@ longlong Field_string::val_int(void)
 String *Field_string::val_str(String *val_buffer __attribute__((unused)),
 			      String *val_ptr)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   /* See the comment for Field_long::store(long long) */
   DBUG_ASSERT(!table || table->in_use == current_thd);
   size_t length;
@@ -7220,7 +7226,7 @@ String *Field_string::val_str(String *val_buffer __attribute__((unused)),
 
 my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   Converter_str2my_decimal_with_warn(thd,
                                      Warn_filter_string(thd, this),
@@ -7553,7 +7559,7 @@ int Field_varstring::save_field_metadata(uchar *metadata_ptr)
 
 int Field_varstring::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   uint copy_length;
   int rc;
 
@@ -7570,7 +7576,7 @@ int Field_varstring::store(const char *from,size_t length,CHARSET_INFO *cs)
 
 double Field_varstring::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   return Converter_strntod_with_warn(thd, Warn_filter(thd),
                                      Field_varstring::charset(),
@@ -7581,7 +7587,7 @@ double Field_varstring::val_real(void)
 
 longlong Field_varstring::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   return Converter_strntoll_with_warn(thd, Warn_filter(thd),
                                       Field_varstring::charset(),
@@ -7593,7 +7599,7 @@ longlong Field_varstring::val_int(void)
 String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
 				 String *val_ptr)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   val_ptr->set((const char*) get_data(), get_length(), field_charset);
   return val_ptr;
 }
@@ -7601,7 +7607,7 @@ String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
 
 my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   Converter_str2my_decimal_with_warn(thd, Warn_filter(thd),
                                      E_DEC_FATAL_ERROR,
@@ -8104,7 +8110,7 @@ String *Field_longstr::uncompress(String *val_buffer, String *val_ptr,
 int Field_varstring_compressed::store(const char *from, size_t length,
                                       CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   uint compressed_length;
   int rc= compress((char*) get_data(), field_length, from, (uint) length,
                    Field_varstring_compressed::max_display_length(),
@@ -8117,14 +8123,14 @@ int Field_varstring_compressed::store(const char *from, size_t length,
 
 String *Field_varstring_compressed::val_str(String *val_buffer, String *val_ptr)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return uncompress(val_buffer, val_ptr, get_data(), get_length());
 }
 
 
 double Field_varstring_compressed::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   String buf;
   val_str(&buf, &buf);
@@ -8135,7 +8141,7 @@ double Field_varstring_compressed::val_real(void)
 
 longlong Field_varstring_compressed::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   String buf;
   val_str(&buf, &buf);
@@ -8236,7 +8242,7 @@ int Field_blob::copy_value(Field_blob *from)
 
 int Field_blob::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   size_t copy_length, new_length;
   uint copy_len;
   char *tmp;
@@ -8332,7 +8338,7 @@ oom_error:
 
 double Field_blob::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   char *blob;
   memcpy(&blob, ptr+packlength, sizeof(char*));
   if (!blob)
@@ -8346,7 +8352,7 @@ double Field_blob::val_real(void)
 
 longlong Field_blob::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   char *blob;
   memcpy(&blob, ptr+packlength, sizeof(char*));
   if (!blob)
@@ -8361,7 +8367,7 @@ longlong Field_blob::val_int(void)
 String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
 			    String *val_ptr)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   char *blob;
   memcpy(&blob, ptr+packlength, sizeof(char*));
   if (!blob)
@@ -8374,7 +8380,7 @@ String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
 
 my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   const char *blob;
   size_t length;
   memcpy(&blob, ptr+packlength, sizeof(const uchar*));
@@ -8760,7 +8766,7 @@ void Field_blob::make_send_field(Send_field *field)
 int Field_blob_compressed::store(const char *from, size_t length,
                                  CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   uint compressed_length;
   uint max_length= max_data_length();
   uint to_length= (uint) MY_MIN(max_length,
@@ -8787,14 +8793,14 @@ oom:
 
 String *Field_blob_compressed::val_str(String *val_buffer, String *val_ptr)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return uncompress(val_buffer, val_ptr, get_ptr(), get_length());
 }
 
 
 double Field_blob_compressed::val_real(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   String buf;
   val_str(&buf, &buf);
@@ -8805,7 +8811,7 @@ double Field_blob_compressed::val_real(void)
 
 longlong Field_blob_compressed::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   THD *thd= get_thd();
   String buf;
   val_str(&buf, &buf);
@@ -9111,7 +9117,7 @@ void Field_enum::store_type(ulonglong value)
 
 int Field_enum::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int err= 0;
   char buff[STRING_BUFFER_USUAL_SIZE];
   String tmpstr(buff,sizeof(buff), &my_charset_bin);
@@ -9163,7 +9169,7 @@ int Field_enum::store(double nr)
 
 int Field_enum::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   if ((ulonglong) nr > typelib->count || nr == 0)
   {
@@ -9187,7 +9193,7 @@ double Field_enum::val_real(void)
 
 longlong Field_enum::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   return read_lowendian(ptr, packlength);
 }
 
@@ -9294,7 +9300,7 @@ Field *Field_enum::make_new_field(MEM_ROOT *root, TABLE *new_table,
 
 int Field_set::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   bool got_warning= 0;
   int err= 0;
   char *not_used;
@@ -9334,7 +9340,7 @@ int Field_set::store(const char *from,size_t length,CHARSET_INFO *cs)
 
 int Field_set::store(longlong nr, bool unsigned_val)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int error= 0;
   ulonglong max_nr;
 
@@ -9734,7 +9740,7 @@ uint Field_bit::is_equal(Create_field *new_field)
                        
 int Field_bit::store(const char *from, size_t length, CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int delta;
 
   for (; length && !*from; from++, length--)          // skip left 0's
@@ -9811,7 +9817,7 @@ double Field_bit::val_real(void)
 
 longlong Field_bit::val_int(void)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   ulonglong bits= 0;
   if (bit_len)
   {
@@ -9836,7 +9842,7 @@ longlong Field_bit::val_int(void)
 String *Field_bit::val_str(String *val_buffer,
                            String *val_ptr __attribute__((unused)))
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   char buff[sizeof(longlong)];
   uint length= MY_MIN(pack_length(), sizeof(longlong));
   ulonglong bits= val_int();
@@ -9852,7 +9858,7 @@ String *Field_bit::val_str(String *val_buffer,
 
 my_decimal *Field_bit::val_decimal(my_decimal *deciaml_value)
 {
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  DBUG_ASSERT(marked_for_read());
   int2my_decimal(E_DEC_FATAL_ERROR, val_int(), 1, deciaml_value);
   return deciaml_value;
 }
@@ -10170,7 +10176,7 @@ Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg,
 
 int Field_bit_as_char::store(const char *from, size_t length, CHARSET_INFO *cs)
 {
-  ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
+  DBUG_ASSERT(marked_for_write_or_computed());
   int delta;
   uchar bits= (uchar) (field_length & 7);
 
diff --git a/sql/field.h b/sql/field.h
index aeed8ae5a64..8bd7343931b 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -627,6 +627,9 @@ public:
   static void operator delete(void *ptr, MEM_ROOT *mem_root)
   { DBUG_ASSERT(0); }
 
+  bool marked_for_read() const;
+  bool marked_for_write_or_computed() const;
+
   /**
      Used by System Versioning.
    */