bk commit into 5.0 tree (kaa:1.2470) BUG#28121

[Alexey Kopytov]

Below is the list of changes that have just been committed into a local
5.0 repository of kaa. When kaa does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-05-03 18:40:34+04:00, kaa@stripped +4 -0
  Fix for bug #28121 "INSERT or UPDATE into DOUBLE(200,0) field being truncated to 31
digits"
  
  When storing a large number to a FLOAT or DOUBLE field with fixed length, it could be
incorrectly truncated if the field's length was greater than 31.
  
  This patch also does some code cleanups to be able to reuse code which is common between
Field_float::store() and Field_double::store().

  mysql-test/r/type_float.result@stripped, 2007-05-03 18:40:30+04:00, kaa@stripped +33 -0
    Added the testcase for bug #28121 "INSERT or UPDATE into DOUBLE(200,0) field being
truncated to 31 digits"

  mysql-test/t/type_float.test@stripped, 2007-05-03 18:40:30+04:00, kaa@stripped +20 -0
    Added the testcase for bug #28121 "INSERT or UPDATE into DOUBLE(200,0) field being
truncated to 31 digits"

  sql/field.cc@stripped, 2007-05-03 18:40:30+04:00, kaa@stripped +63 -91
    Moved common code from Field_float::store() and Field_double:store() to
Field_real::truncate()
    Fixed the algorithm to not truncate large input numbers if the field length is greater
than 31.
    Fixed rounding to not depend on FLT_MAX/DBL_MAX constants.

  sql/field.h@stripped, 2007-05-03 18:40:31+04:00, kaa@stripped +9 -10
    Moved not_fixed member from Field_double to Field_real to allow code reuse between
Field_float::store() and Field_double::store()
    Added truncate() method to Field_real which is used by both Field_float and
Field_double

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	kaa
# Host:	polly.local
# Root:	/home/kaa/src/maint/bug28121/my50-bug28121

--- 1.347/sql/field.cc	2007-04-29 07:50:29 +04:00
+++ 1.348/sql/field.cc	2007-05-03 18:40:30 +04:00
@@ -3675,56 +3675,9 @@ int Field_float::store(const char *from,
 
 int Field_float::store(double nr)
 {
-  float j;
-  int error= 0;
+  int error= truncate(&nr, FLT_MAX);
+  float j= nr;
 
-  if (isnan(nr))
-  {
-    j= 0;
-    set_null();
-    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-    error= 1;
-  }
-  else if (unsigned_flag && nr < 0)
-  {
-    j= 0;
-    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-    error= 1;
-  }
-  else
-  {
-    double max_value;
-    if (dec >= NOT_FIXED_DEC)
-    {
-      max_value= FLT_MAX;
-    }
-    else
-    {
-      uint tmp=min(field_length,array_elements(log_10)-1);
-      max_value= (log_10[tmp]-1)/log_10[dec];
-      /*
-	The following comparison is needed to not get an overflow if nr
-	is close to FLT_MAX
-      */
-      if (fabs(nr) < FLT_MAX/10.0e+32)
-	nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
-    }
-    if (nr < -max_value)
-    {
-      j= (float)-max_value;
-      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-      error= 1;
-    }
-    else if (nr > max_value)
-    {
-      j= (float)max_value;
-      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-      error= 1;
-    }
-    else
-      j= (float) nr;
-  }
-  
 #ifdef WORDS_BIGENDIAN
   if (table->s->db_low_byte_first)
   {
@@ -3963,48 +3916,7 @@ int Field_double::store(const char *from
 
 int Field_double::store(double nr)
 {
-  int error= 0;
-
-  if (isnan(nr))
-  {
-    nr= 0;
-    set_null();
-    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-    error= 1;
-  }
-  else if (unsigned_flag && nr < 0)
-  {
-    nr= 0;
-    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-    error= 1;
-  }
-  else 
-  {
-    double max_value;
-    if (not_fixed)
-    {
-      max_value= DBL_MAX;
-    }
-    else
-    {
-      uint tmp=min(field_length,array_elements(log_10)-1);
-      max_value= (log_10[tmp]-1)/log_10[dec];
-      if (fabs(nr) < DBL_MAX/10.0e+32)
-	nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
-    }
-    if (nr < -max_value)
-    {
-      nr= -max_value;
-      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-      error= 1;
-    }
-    else if (nr > max_value)
-    {
-      nr= max_value;
-      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
-      error= 1;
-    }
-  }
+  int error= truncate(&nr, DBL_MAX);
 
 #ifdef WORDS_BIGENDIAN
   if (table->s->db_low_byte_first)
@@ -4021,6 +3933,66 @@ int Field_double::store(double nr)
 int Field_double::store(longlong nr, bool unsigned_val)
 {
   return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr);
+}
+
+/*
+  If a field has fixed length, truncate the double argument pointed to by 'nr'
+  appropriately.
+  Also ensure that the argument is within [-max_value; max_value] range.
+*/
+
+int Field_real::truncate(double *nr, double max_value)
+{
+  int error= 0;
+  double res= *nr;
+  
+  if (isnan(res))
+  {
+    error= 1;
+    res= 0;
+    set_null();
+    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
+    goto end;
+  }
+  else if (unsigned_flag && *nr < 0)
+  {
+    error= 1;
+    res= 0;
+    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
+    goto end;
+  }
+
+  if (!not_fixed)
+  {
+    uint order= field_length - dec;
+    max_value= 1.0;
+    for (; order >= 100; order-= 100)
+      max_value*= 1e100;
+    for (; order >= 10; order-= 10)
+      max_value*= 1e10;
+    max_value*= log_10[order];
+    max_value-= 1.0 / log_10[dec];
+
+    double tmp= rint((res - floor(res)) * log_10[dec]) / log_10[dec];
+    res= floor(res) + tmp;
+  }
+  
+  if (res < -max_value)
+  {
+   res= -max_value;
+   set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
+   error= 1;
+  }
+  else if (res > max_value)
+  {
+    res= max_value;
+    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
+    error= 1;
+  }
+
+end:
+  *nr= res;
+  return error;
 }
 
 

--- 1.201/sql/field.h	2007-04-29 07:51:11 +04:00
+++ 1.202/sql/field.h	2007-05-03 18:40:31 +04:00
@@ -453,6 +453,7 @@ public:
 /* base class for float and double and decimal (old one) */
 class Field_real :public Field_num {
 public:
+  my_bool not_fixed;
 
   Field_real(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
              uchar null_bit_arg, utype unireg_check_arg,
@@ -460,12 +461,14 @@ public:
              struct st_table *table_arg,
              uint8 dec_arg, bool zero_arg, bool unsigned_arg)
     :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
-               field_name_arg, table_arg, dec_arg, zero_arg, unsigned_arg)
+               field_name_arg, table_arg, dec_arg, zero_arg, unsigned_arg),
+    not_fixed(dec_arg >= NOT_FIXED_DEC)
     {}
 
 
   int store_decimal(const my_decimal *);
   my_decimal *val_decimal(my_decimal *);
+  int truncate(double *nr, double max_length);
   uint32 max_display_length() { return field_length; }
 };
 
@@ -758,7 +761,6 @@ public:
 
 class Field_double :public Field_real {
 public:
-  my_bool not_fixed;
   Field_double(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
 	       uchar null_bit_arg,
 	       enum utype unireg_check_arg, const char *field_name_arg,
@@ -766,21 +768,18 @@ public:
 	       uint8 dec_arg,bool zero_arg,bool unsigned_arg)
     :Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                 unireg_check_arg, field_name_arg, table_arg,
-                dec_arg, zero_arg, unsigned_arg),
-     not_fixed(dec_arg >= NOT_FIXED_DEC)
+                dec_arg, zero_arg, unsigned_arg)
     {}
   Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
 	       struct st_table *table_arg, uint8 dec_arg)
     :Field_real((char*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
-                NONE, field_name_arg, table_arg, dec_arg, 0, 0),
-     not_fixed(dec_arg >= NOT_FIXED_DEC)
+                NONE, field_name_arg, table_arg, dec_arg, 0, 0)
     {}
   Field_double(uint32 len_arg, bool maybe_null_arg, const char *field_name_arg,
-	       struct st_table *table_arg, uint8 dec_arg, my_bool not_fixed_srg)
+	       struct st_table *table_arg, uint8 dec_arg, my_bool not_fixed_arg)
     :Field_real((char*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
-	        NONE, field_name_arg, table_arg, dec_arg, 0, 0), 
-    not_fixed(not_fixed_srg)
-    {}
+                NONE, field_name_arg, table_arg, dec_arg, 0, 0)
+    {not_fixed= not_fixed_arg; }
   enum_field_types type() const { return FIELD_TYPE_DOUBLE;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
   int  store(const char *to,uint length,CHARSET_INFO *charset);

--- 1.50/mysql-test/r/type_float.result	2007-03-22 12:56:40 +03:00
+++ 1.51/mysql-test/r/type_float.result	2007-05-03 18:40:30 +04:00
@@ -344,3 +344,36 @@ create table t1 (s1 float(0,2));
 ERROR 42000: For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column
's1').
 create table t1 (s1 float(1,2));
 ERROR 42000: For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column
's1').
+create table t1 (f1 double(200, 0));
+insert into t1 values (1e199), (-1e199);
+insert into t1 values (1e200), (-1e200);
+insert into t1 values (2e200), (-2e200);
+Warnings:
+Warning	1264	Out of range value adjusted for column 'f1' at row 1
+Warning	1264	Out of range value adjusted for column 'f1' at row 2
+select f1 + 0e0 from t1;
+f1 + 0e0
+1e+199
+-1e+199
+1e+200
+-1e+200
+1e+200
+-1e+200
+drop table t1;
+create table t1 (f1 float(30, 0));
+insert into t1 values (1e29), (-1e29);
+insert into t1 values (1e30), (-1e30);
+insert into t1 values (2e30), (-2e30);
+Warnings:
+Warning	1264	Out of range value adjusted for column 'f1' at row 1
+Warning	1264	Out of range value adjusted for column 'f1' at row 2
+select f1 + 0e0 from t1;
+f1 + 0e0
+1.0000000150475e+29
+-1.0000000150475e+29
+1.0000000150475e+30
+-1.0000000150475e+30
+1.0000000150475e+30
+-1.0000000150475e+30
+drop table t1;
+End of 5.0 tests

--- 1.32/mysql-test/t/type_float.test	2007-01-31 08:56:14 +03:00
+++ 1.33/mysql-test/t/type_float.test	2007-05-03 18:40:30 +04:00
@@ -222,3 +222,23 @@ drop table t1;
 create table t1 (s1 float(0,2));
 --error 1427
 create table t1 (s1 float(1,2));
+
+#
+# Bug #28121 "INSERT or UPDATE into DOUBLE(200,0) field being truncated to 31 digits"
+#
+
+create table t1 (f1 double(200, 0));
+insert into t1 values (1e199), (-1e199);
+insert into t1 values (1e200), (-1e200);
+insert into t1 values (2e200), (-2e200);
+select f1 + 0e0 from t1;
+drop table t1;
+
+create table t1 (f1 float(30, 0));
+insert into t1 values (1e29), (-1e29);
+insert into t1 values (1e30), (-1e30);
+insert into t1 values (2e30), (-2e30);
+select f1 + 0e0 from t1;
+drop table t1;
+
+--echo End of 5.0 tests