From: Date: April 5 2006 2:55am
Subject: bk commit into 5.0 tree (jimw:1.2078) BUG#13601
List-Archive: http://lists.mysql.com/commits/4467
X-Bug: 13601
Message-Id: <20060405005505.5887EA8342@rama.trainedmonkey.com>

Below is the list of changes that have just been committed into a local
5.0 repository of jimw. When jimw 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
  1.2078 06/04/04 17:54:58 jimw@stripped +8 -0
  Bug #13601: Wrong int type for bit
    The wrong value was being reported as the field_length for BIT
    fields, resulting in confusion for at least Connector/J. The
    field_length is now always the number of bits in the field, as
    it should be.

  sql/key.cc
    1.36 06/04/04 17:54:54 jimw@stripped +2 -1
    Fix inappropriate use of field->field_length for BIT field.

  sql/ha_ndbcluster.cc
    1.235 06/04/04 17:54:54 jimw@stripped +1 -1
    Handle field_length of Field_bit actually being the display width (# of bits).

  sql/field.h
    1.174 06/04/04 17:54:54 jimw@stripped +6 -8
    Fix Field_bit::field_length to store the correct value, adding
    Field_bit::bytes_in_rec to remember the number of bytes used for
    storing the value. Remove Field_bit_as_char::create_length, as it
    is now redundant.

  sql/field.cc
    1.301 06/04/04 17:54:54 jimw@stripped +24 -29
    Fix Field_bit->field_length to actually report the display width, and
    store the bytes stored in the rec in the new bytes_in_rec member.

  mysql-test/t/type_bit_innodb.test
    1.5 06/04/04 17:54:53 jimw@stripped +12 -0
    Add new regression test

  mysql-test/t/type_bit.test
    1.15 06/04/04 17:54:53 jimw@stripped +12 -0
    Add new regression test

  mysql-test/r/type_bit_innodb.result
    1.4 06/04/04 17:54:53 jimw@stripped +9 -0
    Add new results

  mysql-test/r/type_bit.result
    1.16 06/04/04 17:54:53 jimw@stripped +9 -0
    Add new results

# 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:	jimw
# Host:	rama.(none)
# Root:	/home/jimw/my/mysql-5.0-13601

--- 1.300/sql/field.cc	2006-02-27 04:50:29 -08:00
+++ 1.301/sql/field.cc	2006-04-04 17:54:54 -07:00
@@ -7918,9 +7918,10 @@
                      uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
                      enum utype unireg_check_arg, const char *field_name_arg,
                      struct st_table *table_arg)
-  : Field(ptr_arg, len_arg >> 3, null_ptr_arg, null_bit_arg,
+  : Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
           unireg_check_arg, field_name_arg, table_arg),
-    bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7)
+    bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7),
+    bytes_in_rec(len_arg / 8)
 {
   /*
     Ensure that Field::eq() can distinguish between two different bit fields.
@@ -7956,14 +7957,14 @@
   int delta;
 
   for (; length && !*from; from++, length--);          // skip left 0's
-  delta= field_length - length;
+  delta= bytes_in_rec - length;
 
   if (delta < -1 ||
       (delta == -1 && (uchar) *from > ((1 << bit_len) - 1)) ||
       (!bit_len && delta < 0))
   {
     set_rec_bits(0xff, bit_ptr, bit_ofs, bit_len);
-    memset(ptr, 0xff, field_length);
+    memset(ptr, 0xff, bytes_in_rec);
     if (table->in_use->really_abort_on_warning())
       set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
     else
@@ -7991,7 +7992,7 @@
       set_rec_bits((uchar) *from, bit_ptr, bit_ofs, bit_len);
       from++;
     }
-    memcpy(ptr, from, field_length);
+    memcpy(ptr, from, bytes_in_rec);
   }
   return 0;
 }
@@ -8032,10 +8033,10 @@
   if (bit_len)
   {
     bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
-    bits<<= (field_length * 8);
+    bits<<= (bytes_in_rec * 8);
   }
 
-  switch (field_length) {
+  switch (bytes_in_rec) {
   case 0: return bits;
   case 1: return bits | (ulonglong) (uchar) ptr[0];
   case 2: return bits | mi_uint2korr(ptr);
@@ -8044,7 +8045,7 @@
   case 5: return bits | mi_uint5korr(ptr);
   case 6: return bits | mi_uint6korr(ptr);
   case 7: return bits | mi_uint7korr(ptr);
-  default: return mi_uint8korr(ptr + field_length - sizeof(longlong));
+  default: return mi_uint8korr(ptr + bytes_in_rec - sizeof(longlong));
   }
 }  
 
@@ -8097,7 +8098,7 @@
     if ((flag= (int) (bits_a - bits_b)))
       return flag;
   }
-  return memcmp(ptr, ptr + row_offset, field_length);
+  return memcmp(ptr, ptr + row_offset, bytes_in_rec);
 }
 
 
@@ -8109,7 +8110,7 @@
     *buff++= bits;
     length--;
   }
-  memcpy(buff, ptr, min(length, field_length));
+  memcpy(buff, ptr, min(length, bytes_in_rec));
 }
 
 
@@ -8117,22 +8118,22 @@
 {
   CHARSET_INFO *cs= res.charset();
   ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
-                                   "bit(%d)", 
-                                   (int) field_length * 8 + bit_len);
+                                   "bit(%d)", (int) field_length);
   res.length((uint) length);
 }
 
 
 char *Field_bit::pack(char *to, const char *from, uint max_length)
 {
-  uint length= min(field_length + (bit_len > 0), max_length);
+  DBUG_ASSERT(max_length);
+  uint length;
   if (bit_len)
   {
     uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
     *to++= bits;
-    length--;
   }
-  memcpy(to, from, length); 
+  length= min(bytes_in_rec, max_length - (bit_len > 0));
+  memcpy(to, from, length);
   return to + length;
 }
 
@@ -8144,8 +8145,8 @@
     set_rec_bits(*from, bit_ptr, bit_ofs, bit_len);
     from++;
   }
-  memcpy(to, from, field_length);
-  return from + field_length;
+  memcpy(to, from, bytes_in_rec);
+  return from + bytes_in_rec;
 }
 
 
@@ -8159,26 +8160,25 @@
                                      const char *field_name_arg,
                                      struct st_table *table_arg)
   : Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0,
-              0, unireg_check_arg, field_name_arg, table_arg),
-    create_length(len_arg)
+              0, unireg_check_arg, field_name_arg, table_arg)
 {
   bit_len= 0;
-  field_length= ((len_arg + 7) & ~7) / 8;
+  bytes_in_rec= (len_arg + 7) / 8;
 }
 
 
 int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
 {
   int delta;
-  uchar bits= create_length & 7;
+  uchar bits= field_length & 7;
 
   for (; length && !*from; from++, length--);          // skip left 0's
-  delta= field_length - length;
+  delta= bytes_in_rec - length;
 
   if (delta < 0 ||
       (delta == 0 && bits && (uint) (uchar) *from >= (uint) (1 << bits)))
   {
-    memset(ptr, 0xff, field_length);
+    memset(ptr, 0xff, bytes_in_rec);
     if (bits)
       *ptr&= ((1 << bits) - 1); /* set first byte */
     if (table->in_use->really_abort_on_warning())
@@ -8197,7 +8197,7 @@
 {
   CHARSET_INFO *cs= res.charset();
   ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
-                                   "bit(%d)", (int) create_length);
+                                   "bit(%d)", (int) field_length);
   res.length((uint) length);
 }
 
@@ -8923,11 +8923,6 @@
     geom_type= ((Field_geom*)old_field)->geom_type;
     break;
 #endif
-  case FIELD_TYPE_BIT:
-    length= (old_field->key_type() == HA_KEYTYPE_BIT) ?
-            ((Field_bit *) old_field)->bit_len + length * 8 :
-            ((Field_bit_as_char *) old_field)->create_length;
-    break;
   default:
     break;
   }

--- 1.173/sql/field.h	2006-02-27 10:26:21 -08:00
+++ 1.174/sql/field.h	2006-04-04 17:54:54 -07:00
@@ -1303,17 +1303,18 @@
   uchar *bit_ptr;     // position in record where 'uneven' bits store
   uchar bit_ofs;      // offset to 'uneven' high bits
   uint bit_len;       // number of 'uneven' high bits
+  uint bytes_in_rec;
   Field_bit(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
             uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
             enum utype unireg_check_arg, const char *field_name_arg,
             struct st_table *table_arg);
   enum_field_types type() const { return FIELD_TYPE_BIT; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BIT; }
-  uint32 key_length() const { return (uint32) field_length + (bit_len > 0); }
-  uint32 max_length() { return (uint32) field_length * 8 + bit_len; }
+  uint32 key_length() const { return (uint32) (field_length + 7) / 8; }
+  uint32 max_length() { return field_length; }
   uint size_of() const { return sizeof(*this); }
   Item_result result_type () const { return INT_RESULT; }
-  void reset(void) { bzero(ptr, field_length); }
+  void reset(void) { bzero(ptr, bytes_in_rec); }
   int store(const char *to, uint length, CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
@@ -1335,9 +1336,8 @@
   { Field_bit::store(buff, length, &my_charset_bin); }
   void sort_string(char *buff, uint length)
   { get_key_image(buff, length, itRAW); }
-  uint32 pack_length() const 
-  { return (uint32) field_length + (bit_len > 0); }
-  uint32 pack_length_in_rec() const { return field_length; }
+  uint32 pack_length() const { return (uint32) (field_length + 7) / 8; }
+  uint32 pack_length_in_rec() const { return bytes_in_rec; }
   void sql_type(String &str) const;
   char *pack(char *to, const char *from, uint max_length=~(uint) 0);
   const char *unpack(char* to, const char *from);
@@ -1354,13 +1354,11 @@
 
 class Field_bit_as_char: public Field_bit {
 public:
-  uchar create_length;
   Field_bit_as_char(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                     uchar null_bit_arg,
                     enum utype unireg_check_arg, const char *field_name_arg,
                     struct st_table *table_arg);
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
-  uint32 max_length() { return (uint32) create_length; }
   uint size_of() const { return sizeof(*this); }
   int store(const char *to, uint length, CHARSET_INFO *charset);
   int store(double nr) { return Field_bit::store(nr); }

--- 1.35/sql/key.cc	2005-11-20 10:47:00 -08:00
+++ 1.36/sql/key.cc	2006-04-04 17:54:54 -07:00
@@ -192,7 +192,8 @@
       Field_bit *field= (Field_bit *) (key_part->field);
       if (field->bit_len)
       {
-        uchar bits= *(from_key + key_part->length - field->field_length -1);
+        uchar bits= *(from_key + key_part->length -
+                      field->pack_length_in_rec() - 1);
         set_rec_bits(bits, to_record + key_part->null_offset +
                      (key_part->null_bit == 128),
                      field->bit_ofs, field->bit_len);

--- 1.234/sql/ha_ndbcluster.cc	2006-02-27 01:29:51 -08:00
+++ 1.235/sql/ha_ndbcluster.cc	2006-04-04 17:54:54 -07:00
@@ -3819,7 +3819,7 @@
     break;
   case MYSQL_TYPE_BIT:
   {
-    int no_of_bits= field->field_length*8 + ((Field_bit *) field)->bit_len;
+    int no_of_bits= field->field_length;
     col.setType(NDBCOL::Bit);
     if (!no_of_bits)
       col.setLength(1);

--- 1.15/mysql-test/r/type_bit.result	2006-01-26 08:54:27 -08:00
+++ 1.16/mysql-test/r/type_bit.result	2006-04-04 17:54:53 -07:00
@@ -564,3 +564,12 @@
 1	4	4
 2	2	2
 drop table t1, t2;
+create table t1 (a bit(7));
+insert into t1 values (0x60);
+select * from t1;
+Catalog	Database	Table	Table_alias	Column	Column_alias	Type	Length	Max length	Is_null	Flags	Decimals	Charsetnr
+def	test	t1	t1	a	a	16	7	1	Y	0	0	63
+a
+`
+drop table t1;
+End of 5.0 tests

--- 1.14/mysql-test/t/type_bit.test	2006-01-26 08:54:28 -08:00
+++ 1.15/mysql-test/t/type_bit.test	2006-04-04 17:54:53 -07:00
@@ -227,3 +227,15 @@
 select 1 from t1 join t2 on b1 = b2 group by b1 order by 1;
 select b1+0,sum(b1), sum(b2) from t1 join t2 on b1 = b2 group by b1 order by 1;
 drop table t1, t2;
+
+#
+# Bug #13601: Wrong field length reported for BIT fields
+#
+create table t1 (a bit(7));
+insert into t1 values (0x60);
+--enable_metadata
+select * from t1;
+--disable_metadata
+drop table t1;
+
+--echo End of 5.0 tests

--- 1.3/mysql-test/r/type_bit_innodb.result	2005-08-05 17:22:48 -07:00
+++ 1.4/mysql-test/r/type_bit_innodb.result	2006-04-04 17:54:53 -07:00
@@ -402,3 +402,12 @@
   `b` bit(10) default NULL
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1
 drop table t1;
+create table t1 (a bit(7)) engine=innodb;
+insert into t1 values (0x60);
+select * from t1;
+Catalog	Database	Table	Table_alias	Column	Column_alias	Type	Length	Max length	Is_null	Flags	Decimals	Charsetnr
+def	test	t1	t1	a	a	16	7	1	Y	0	0	63
+a
+`
+drop table t1;
+End of 5.0 tests

--- 1.4/mysql-test/t/type_bit_innodb.test	2005-08-08 11:42:06 -07:00
+++ 1.5/mysql-test/t/type_bit_innodb.test	2006-04-04 17:54:53 -07:00
@@ -133,3 +133,15 @@
 alter table t1 engine=innodb;
 show create table t1;
 drop table t1;
+
+#
+# Bug #13601: Wrong field length reported for BIT fields
+#
+create table t1 (a bit(7)) engine=innodb;
+insert into t1 values (0x60);
+--enable_metadata
+select * from t1;
+--disable_metadata
+drop table t1;
+
+--echo End of 5.0 tests