Merge lp:~stewart/drizzle/jay-and-stewart-remove-pack_flag into lp:~drizzle-trunk/drizzle/development

[Stewart Smith]

[Stewart Smith (stewart)]

Jay's pack_flag removal branch, plus fixes for Solaris Sparc (works on bitters) and complete removal of pack_flag from the table proto (it's still a bit inside the create table path though, it just doesn't exist in the table proto any more).

Jay's work was previously okayed except for failing on solaris sparc (which is fixed in this branch)

My stuff is new here.

[Jay Pipes (jaypipes)]

Nice work, Stewart. I looked over your commits and everything looked fine. Would be nice to also remove the remaining macros/#defines from definitions, but this is excellent progress.

review: Approve

[Stewart Smith (stewart)]

On Thu, Sep 24, 2009 at 07:10:01PM -0000, Jay Pipes wrote:
> Review: Approve
> Nice work, Stewart. I looked over your commits and everything looked
> fine. Would be nice to also remove the remaining macros/#defines from
> definitions, but this is excellent progress.

It's still used in some strange way in the create table path to produce
key_type (which is still stored in the table proto), so just ripping
those bits out leads to a not quite working server :(

next tree :) (as key_type must also go... or at least be converted to
something sane).

--
Stewart Smith

[Brian Aker (brianaker)]

Hi!

A few things:
make_field you pass "decimals" as an int. This is later used as a uint8_t though. Overflow for double/new_decimal.

new_decimal should just become "decimal".

For new variables, use a sized variable not just "int".

I'm not sure what to do about the format changes. They are good... but there are a lot of them that have nothing to do with the patch itself. It is good to fix these things, but there are a lot of them have nothing to do with the patch (which makes the patch very hard to follow). It would be nice if large scale changes in style were done as a patch, and core changes were done in another. Little bits here and there... but there are a lot of style changes going on that are not touching direct code. I'm not sure what to do about that for this patch.

Cheers,
   -Brian

review: Needs Fixing

[Jay Pipes (jaypipes)]

> I'm not sure what to do about the format changes. They are good... but there
> are a lot of them that have nothing to do with the patch itself. It is good to
> fix these things, but there are a lot of them have nothing to do with the
> patch (which makes the patch very hard to follow). It would be nice if large
> scale changes in style were done as a patch, and core changes were done in
> another. Little bits here and there... but there are a lot of style changes
> going on that are not touching direct code. I'm not sure what to do about that
> for this patch.

OK, point taken, and these style changes I will take responsibility for. For this patch, can you make an exception and try to follow along with the patch? I'd hate to have to redo this whole patch in order to pull out style changes. I will certainly take this to heart on future patches, though, rest assured.

This patch was, originally, smaller patches, and it wouldn't have been as big, but the original patch had the issue with the sum_distinct test case only on bitters, and it got bigger after that too...

In short, can we fix the issues with sized variables and new_decimal, and push this into the tree?

[Brian Aker (brianaker)]

Yes, we can skip the style for the moment.

I am still spending a bit more time on this. Looking at Decimal I see this:

    message NumericFieldOptions {
      optional bool is_autoincrement = 1 [default = false];
      optional int32 length = 2;
      optional int32 scale = 3;
      optional int32 precision = 4;
    }

Can any of those value be anything put positive? Are those size appropriate for those fields?

[Brian Aker (brianaker)]

And while I am at it:

    message StringFieldOptions {
      optional bool is_fixed_width = 1 [default = false];
      optional int32 length = 2;
      optional uint32 collation_id = 3;
      optional string collation = 4;
    }

length is limited to signed?

    message SetFieldOptions {
      required int32 count_elements = 1;
      optional uint32 collation_id = 2;
      optional string collation = 3;
      repeated bytes field_value = 4;
    }
Is this now deprecated?

[Stewart Smith (stewart)]

> And while I am at it:
>
> message StringFieldOptions {
> optional bool is_fixed_width = 1 [default = false];
> optional int32 length = 2;
> optional uint32 collation_id = 3;
> optional string collation = 4;
> }
>
> length is limited to signed?

unsigned may be an idea.

I also don't see any real reason why it should only be 32bits.

>
> message SetFieldOptions {
> required int32 count_elements = 1;
> optional uint32 collation_id = 2;
> optional string collation = 3;
> repeated bytes field_value = 4;
> }
> Is this now deprecated?

Yes. This is only the first in many-to-come table proto cleanup patches. The pack_flag part was one of the more critical though (makes it really hard to generate a table proto if you have to work otu what a pack_flag is meant to be)

=== modified file 'drizzled/common.h'
--- drizzled/common.h	2009-08-04 06:52:55 +0000
+++ drizzled/common.h	2009-09-28 07:40:31 +0000
@@ -166,7 +166,6 @@
 #define MULTIPLE_KEY_FLAG 8		/* Field is part of a key */
 #define BLOB_FLAG	16		/* Field is a blob */
 #define UNSIGNED_FLAG	32		/* Field is unsigned */
-#define DECIMAL_FLAG	64		/* Field is zerofill */
 #define BINARY_FLAG	128		/* Field is binary   */
 
 /* The following are only sent to new clients */

=== modified file 'drizzled/create_field.cc'
--- drizzled/create_field.cc	2009-08-31 23:50:37 +0000
+++ drizzled/create_field.cc	2009-09-28 07:40:31 +0000
@@ -150,8 +150,9 @@
   Init for a tmp table field. To be extended if need be.
 */
 void CreateField::init_for_tmp_table(enum_field_types sql_type_arg,
-                                      uint32_t length_arg, uint32_t decimals_arg,
-                                      bool maybe_null, bool is_unsigned)
+                                     uint32_t length_arg,
+                                     uint32_t decimals_arg,
+                                     bool maybe_null)
 {
   field_name= "";
   sql_type= sql_type_arg;
@@ -159,10 +160,13 @@
   unireg_check= Field::NONE;
   interval= 0;
   charset= &my_charset_bin;
-  pack_flag= (FIELDFLAG_NUMBER |
-              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
-              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
-              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
+  decimals= decimals_arg & FIELDFLAG_MAX_DEC;
+  pack_flag= 0;
+
+  if (! maybe_null)
+    flags= NOT_NULL_FLAG;
+  else
+    flags= 0;
 }
 
 bool CreateField::init(Session *,

=== modified file 'drizzled/create_field.h'
--- drizzled/create_field.h	2009-08-05 08:52:52 +0000
+++ drizzled/create_field.h	2009-09-28 07:40:31 +0000
@@ -82,8 +82,7 @@
   void init_for_tmp_table(enum_field_types sql_type_arg,
                           uint32_t max_length,
                           uint32_t decimals,
-                          bool maybe_null,
-                          bool is_unsigned);
+                          bool maybe_null);
 
   /**
     Initialize field definition for create.

=== modified file 'drizzled/definitions.h'
--- drizzled/definitions.h	2009-08-22 02:06:02 +0000
+++ drizzled/definitions.h	2009-09-28 07:40:31 +0000
@@ -23,8 +23,8 @@
  * Mostly constants and some macros/functions used by the server
  */
 
-#ifndef DRIZZLE_SERVER_DEFINITIONS_H
-#define DRIZZLE_SERVER_DEFINITIONS_H
+#ifndef DRIZZLED_DEFINITIONS_H
+#define DRIZZLED_DEFINITIONS_H
 
 #include <drizzled/enum.h>
 
@@ -578,42 +578,12 @@
  * The following are for the interface with the .frm file
  */
 
-#define FIELDFLAG_DECIMAL    1
-#define FIELDFLAG_BINARY    1  // Shares same flag
-#define FIELDFLAG_NUMBER    2
-#define FIELDFLAG_DECIMAL_POSITION      4
-#define FIELDFLAG_PACK      120  // Bits used for packing
-#define FIELDFLAG_INTERVAL    256     // mangled with decimals!
-#define FIELDFLAG_BLOB      1024  // mangled with decimals!
-
-#define FIELDFLAG_NO_DEFAULT    16384   /* sql */
-#define FIELDFLAG_SUM      ((uint32_t) 32768)// predit: +#fieldflag
-#define FIELDFLAG_MAYBE_NULL    ((uint32_t) 32768)// sql
-#define FIELDFLAG_HEX_ESCAPE    ((uint32_t) 0x10000)
 #define FIELDFLAG_PACK_SHIFT    3
-#define FIELDFLAG_DEC_SHIFT    8
 #define FIELDFLAG_MAX_DEC    31
 
 #define MTYP_TYPENR(type) (type & 127)  /* Remove bits from type */
 
-#define f_is_dec(x)     ((x) & FIELDFLAG_DECIMAL)
-#define f_is_num(x)     ((x) & FIELDFLAG_NUMBER)
-#define f_is_decimal_precision(x)  ((x) & FIELDFLAG_DECIMAL_POSITION)
-#define f_is_packed(x)  ((x) & FIELDFLAG_PACK)
 #define f_packtype(x)   (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
-#define f_decimals(x)   ((uint8_t) (((x) >> FIELDFLAG_DEC_SHIFT) & \
-                                     FIELDFLAG_MAX_DEC))
-#define f_is_alpha(x)   (!f_is_num(x))
-#define f_is_binary(x)  ((x) & FIELDFLAG_BINARY) // 4.0- compatibility
-#define f_is_enum(x)    (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == \
-                         FIELDFLAG_INTERVAL)
-#define f_is_blob(x)    (((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == \
-                         FIELDFLAG_BLOB)
-#define f_is_equ(x)     ((x) & (1+2+FIELDFLAG_PACK+31*256))
 #define f_settype(x)    (((int) x) << FIELDFLAG_PACK_SHIFT)
-#define f_maybe_null(x) (x & FIELDFLAG_MAYBE_NULL)
-#define f_no_default(x) (x & FIELDFLAG_NO_DEFAULT)
-#define f_is_hex_escape(x) ((x) & FIELDFLAG_HEX_ESCAPE)
-
-#endif /* DRIZZLE_SERVER_DEFINITIONS_H */
-
+
+#endif /* DRIZZLED_DEFINITIONS_H */

=== modified file 'drizzled/field.cc'
--- drizzled/field.cc	2009-07-29 23:25:20 +0000
+++ drizzled/field.cc	2009-09-28 07:40:31 +0000
@@ -1019,19 +1019,20 @@
                   MEM_ROOT *root,
                   unsigned char *ptr,
                   uint32_t field_length,
+                  bool is_nullable,
                   unsigned char *null_pos,
                   unsigned char null_bit,
-                  uint32_t pack_flag,
+                  uint8_t decimals,
                   enum_field_types field_type,
                   const CHARSET_INFO * field_charset,
                   Field::utype unireg_check,
                   TYPELIB *interval,
                   const char *field_name)
 {
-  if(!root)
+  if(! root)
     root= current_mem_root();
 
-  if (!f_maybe_null(pack_flag))
+  if (! is_nullable)
   {
     null_pos=0;
     null_bit=0;
@@ -1041,7 +1042,8 @@
     null_bit= ((unsigned char) 1) << null_bit;
   }
 
-  switch (field_type) {
+  switch (field_type) 
+  {
   case DRIZZLE_TYPE_DATE:
   case DRIZZLE_TYPE_DATETIME:
   case DRIZZLE_TYPE_TIMESTAMP:
@@ -1049,79 +1051,111 @@
   default: break;
   }
 
-  if (f_is_alpha(pack_flag))
+  if (field_type == DRIZZLE_TYPE_VARCHAR ||
+      field_type == DRIZZLE_TYPE_BLOB ||
+      field_type == DRIZZLE_TYPE_ENUM)
   {
-    if (!f_is_packed(pack_flag))
+    if (field_type == DRIZZLE_TYPE_VARCHAR)
+      return new (root) Field_varstring(ptr,field_length,
+                                  HA_VARCHAR_PACKLENGTH(field_length),
+                                  null_pos,null_bit,
+                                  field_name,
+                                  share,
+                                  field_charset);
+
+    if (field_type == DRIZZLE_TYPE_BLOB)
     {
-      if (field_type == DRIZZLE_TYPE_VARCHAR)
-        return new (root) Field_varstring(ptr,field_length,
-                                   HA_VARCHAR_PACKLENGTH(field_length),
-                                   null_pos,null_bit,
-                                   unireg_check, field_name,
+      return new (root) Field_blob(ptr,
+                                   null_pos,
+                                   null_bit,
+                                   field_name,
                                    share,
+                                   calc_pack_length(DRIZZLE_TYPE_LONG, 0),
                                    field_charset);
-      return 0;                                 // Error
     }
 
-    uint32_t pack_length=calc_pack_length((enum_field_types)
-				      f_packtype(pack_flag),
-				      field_length);
-
-    if (f_is_blob(pack_flag))
-      return new (root) Field_blob(ptr,null_pos,null_bit,
-			    unireg_check, field_name, share,
-			    pack_length, field_charset);
     if (interval)
     {
-      if (f_is_enum(pack_flag))
-      {
-        return new (root) Field_enum(ptr,field_length,null_pos,null_bit,
-				  unireg_check, field_name,
-				  get_enum_pack_length(interval->count),
-                                  interval, field_charset);
-      }
+      return new (root) Field_enum(ptr,
+                                   field_length,
+                                   null_pos,
+                                   null_bit,
+                                   field_name,
+                                   get_enum_pack_length(interval->count),
+                                   interval,
+                                   field_charset);
     }
   }
 
-  switch (field_type) {
+  switch (field_type)
+  {
   case DRIZZLE_TYPE_NEWDECIMAL:
-    return new (root) Field_new_decimal(ptr,field_length,null_pos,null_bit,
-                                 unireg_check, field_name,
-                                 f_decimals(pack_flag),
-                                 f_is_decimal_precision(pack_flag) != 0,
-                                 f_is_dec(pack_flag) == 0);
+    return new (root) Field_new_decimal(ptr,
+                                        field_length,
+                                        null_pos,
+                                        null_bit,
+                                        unireg_check,
+                                        field_name,
+                                        decimals,
+                                        false,
+                                        false /* is_unsigned */);
   case DRIZZLE_TYPE_DOUBLE:
-    return new (root) Field_double(ptr,field_length,null_pos,null_bit,
-			    unireg_check, field_name,
-			    f_decimals(pack_flag),
-			    false,
-			    f_is_dec(pack_flag)== 0);
+    return new (root) Field_double(ptr,
+                                   field_length,
+                                   null_pos,
+                                   null_bit,
+                                   unireg_check,
+                                   field_name,
+                                   decimals,
+                                   false,
+                                   false /* is_unsigned */);
   case DRIZZLE_TYPE_TINY:
     assert(0);
   case DRIZZLE_TYPE_LONG:
-    return new (root) Field_long(ptr,field_length,null_pos,null_bit,
-			   unireg_check, field_name,
-                           false,
-			   f_is_dec(pack_flag) == 0);
+    return new (root) Field_long(ptr,
+                                 field_length,
+                                 null_pos,
+                                 null_bit,
+                                 unireg_check,
+                                 field_name,
+                                 false,
+                                 false /* is_unsigned */);
   case DRIZZLE_TYPE_LONGLONG:
-    return new (root) Field_int64_t(ptr,field_length,null_pos,null_bit,
-			      unireg_check, field_name,
-                              false,
-			      f_is_dec(pack_flag) == 0);
+    return new (root) Field_int64_t(ptr,
+                                    field_length,
+                                    null_pos,
+                                    null_bit,
+                                    unireg_check,
+                                    field_name,
+                                    false,
+                                    false /* is_unsigned */);
   case DRIZZLE_TYPE_TIMESTAMP:
-    return new (root) Field_timestamp(ptr,field_length, null_pos, null_bit,
-                               unireg_check, field_name, share,
-                               field_charset);
+    return new (root) Field_timestamp(ptr,
+                                      field_length,
+                                      null_pos,
+                                      null_bit,
+                                      unireg_check,
+                                      field_name,
+                                      share,
+                                      field_charset);
   case DRIZZLE_TYPE_DATE:
-    return new (root) Field_date(ptr,null_pos,null_bit,
-			     unireg_check, field_name, field_charset);
+    return new (root) Field_date(ptr,
+                                 null_pos,
+                                 null_bit,
+                                 field_name,
+                                 field_charset);
   case DRIZZLE_TYPE_DATETIME:
-    return new (root) Field_datetime(ptr,null_pos,null_bit,
-			      unireg_check, field_name, field_charset);
+    return new (root) Field_datetime(ptr,
+                                     null_pos,
+                                     null_bit,
+                                     field_name,
+                                     field_charset);
   case DRIZZLE_TYPE_NULL:
-    return new (root) Field_null(ptr, field_length, unireg_check, field_name,
-                          field_charset);
-  default:					// Impossible (Wrong version)
+    return new (root) Field_null(ptr,
+                                 field_length,
+                                 field_name,
+                                 field_charset);
+  default: // Impossible (Wrong version)
     break;
   }
   return 0;

=== modified file 'drizzled/field.h'
--- drizzled/field.h	2009-08-05 08:52:52 +0000
+++ drizzled/field.h	2009-09-28 07:40:31 +0000
@@ -833,9 +833,10 @@
                   MEM_ROOT *root,
                   unsigned char *ptr,
                   uint32_t field_length,
+                  bool is_nullable,
                   unsigned char *null_pos,
                   unsigned char null_bit,
-                  uint32_t pack_flag,
+                  uint8_t decimals,
                   enum_field_types field_type,
                   const CHARSET_INFO * cs,
                   Field::utype unireg_check,

=== modified file 'drizzled/field/blob.cc'
--- drizzled/field/blob.cc	2009-07-11 08:51:36 +0000
+++ drizzled/field/blob.cc	2009-09-28 07:40:31 +0000
@@ -42,13 +42,19 @@
 ** packlength slot and may be from 1-4.
 ****************************************************************************/
 
-Field_blob::Field_blob(unsigned char *ptr_arg, unsigned char *null_ptr_arg, unsigned char null_bit_arg,
-		       enum utype unireg_check_arg, const char *field_name_arg,
-                       TableShare *share, uint32_t blob_pack_length,
-		       const CHARSET_INFO * const cs)
-  :Field_str(ptr_arg, blob_pack_length_to_max_length(blob_pack_length),
-                 null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
-                 cs),
+Field_blob::Field_blob(unsigned char *ptr_arg,
+                       unsigned char *null_ptr_arg,
+                       unsigned char null_bit_arg,
+		                   const char *field_name_arg,
+                       TableShare *share,
+                       uint32_t blob_pack_length,
+                       const CHARSET_INFO * const cs)
+  :Field_str(ptr_arg,
+             blob_pack_length_to_max_length(blob_pack_length),
+             null_ptr_arg,
+             null_bit_arg,
+             field_name_arg,
+             cs),
    packlength(blob_pack_length)
 {
   flags|= BLOB_FLAG;
@@ -56,7 +62,6 @@
   /* TODO: why do not fill table->s->blob_field array here? */
 }
 
-
 void Field_blob::store_length(unsigned char *i_ptr,
                               uint32_t i_packlength,
                               uint32_t i_number,
@@ -226,17 +231,6 @@
   if (value.alloc(new_length))
     goto oom_error;
 
-
-  if (f_is_hex_escape(flags))
-  {
-    copy_length= my_copy_with_hex_escaping(field_charset,
-                                           (char*) value.ptr(), new_length,
-                                            from, length);
-    Field_blob::store_length(copy_length);
-    tmp= value.ptr();
-    memmove(ptr + packlength, &tmp, sizeof(char*));
-    return 0;
-  }
   /*
     "length" is OK as "nchars" argument to well_formed_copy_nchars as this
     is never used to limit the length of the data. The cut of long data

=== modified file 'drizzled/field/blob.h'
--- drizzled/field/blob.h	2009-06-13 21:21:13 +0000
+++ drizzled/field/blob.h	2009-09-28 07:40:31 +0000
@@ -41,25 +41,41 @@
   using Field::val_int;
   using Field::val_str;
 
-
-  Field_blob(unsigned char *ptr_arg, unsigned char *null_ptr_arg, unsigned char null_bit_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
-	     TableShare *share, uint32_t blob_pack_length, const CHARSET_INFO * const cs);
-  Field_blob(uint32_t len_arg, bool maybe_null_arg, const char *field_name_arg,
+  Field_blob(unsigned char *ptr_arg,
+             unsigned char *null_ptr_arg,
+             unsigned char null_bit_arg,
+             const char *field_name_arg,
+             TableShare *share,
+             uint32_t blob_pack_length,
+             const CHARSET_INFO * const cs);
+  Field_blob(uint32_t len_arg,
+             bool maybe_null_arg,
+             const char *field_name_arg,
              const CHARSET_INFO * const cs)
-    :Field_str((unsigned char*) 0, len_arg, maybe_null_arg ? (unsigned char*) "": 0, 0,
-                   NONE, field_name_arg, cs),
+    :Field_str((unsigned char*) NULL,
+               len_arg,
+               maybe_null_arg ? (unsigned char *) "": 0,
+               0,
+               field_name_arg,
+               cs),
     packlength(4)
   {
     flags|= BLOB_FLAG;
   }
-  Field_blob(uint32_t len_arg, bool maybe_null_arg, const char *field_name_arg,
-	     const CHARSET_INFO * const cs, bool set_packlength)
-    :Field_str((unsigned char*) 0,len_arg, maybe_null_arg ? (unsigned char*) "": 0, 0,
-                   NONE, field_name_arg, cs)
+  Field_blob(uint32_t len_arg,
+             bool maybe_null_arg,
+             const char *field_name_arg,
+             const CHARSET_INFO * const cs,
+             bool set_packlength)
+    :Field_str((unsigned char*) NULL,
+               len_arg,
+               maybe_null_arg ? (unsigned char*) "": 0,
+               0,
+               field_name_arg,
+               cs),
+    packlength(4)
   {
     flags|= BLOB_FLAG;
-    packlength= 4;
     if (set_packlength)
     {
       uint32_t l_char_length= len_arg/cs->mbmaxlen;
@@ -69,8 +85,14 @@
     }
   }
   Field_blob(uint32_t packlength_arg)
-    :Field_str((unsigned char*) 0, 0, (unsigned char*) "", 0, NONE, "temp", system_charset_info),
-    packlength(packlength_arg) {}
+    :Field_str((unsigned char*) 0,
+               0,
+               (unsigned char*) "",
+               0,
+               "temp",
+               system_charset_info),
+    packlength(packlength_arg) 
+  {}
   enum_field_types type() const { return DRIZZLE_TYPE_BLOB;}
   enum ha_base_keytype key_type() const
     { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; }

=== modified file 'drizzled/field/date.h'
--- drizzled/field/date.h	2009-02-17 14:41:01 +0000
+++ drizzled/field/date.h	2009-09-28 07:40:31 +0000
@@ -31,17 +31,28 @@
   using Field::val_str;
   using Field::cmp;
 
-  Field_date(unsigned char *ptr_arg, unsigned char *null_ptr_arg,
+  Field_date(unsigned char *ptr_arg,
+             unsigned char *null_ptr_arg,
              unsigned char null_bit_arg,
-             enum utype unireg_check_arg, const char *field_name_arg,
-             const CHARSET_INFO * const cs)
-    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
-               unireg_check_arg, field_name_arg, cs)
-    {}
-  Field_date(bool maybe_null_arg, const char *field_name_arg,
-                const CHARSET_INFO * const cs)
-    :Field_str((unsigned char*) 0,10, maybe_null_arg ? (unsigned char*) "": 0,0,
-               NONE, field_name_arg, cs) {}
+             const char *field_name_arg,
+             const CHARSET_INFO * const cs)
+    :Field_str(ptr_arg,
+               10,
+               null_ptr_arg,
+               null_bit_arg,
+               field_name_arg,
+               cs)
+  {}
+  Field_date(bool maybe_null_arg,
+             const char *field_name_arg,
+             const CHARSET_INFO * const cs)
+    :Field_str((unsigned char*) 0,
+               10,
+               maybe_null_arg ? (unsigned char*) "": 0,
+               0,
+               field_name_arg,
+               cs) 
+  {}
   enum_field_types type() const { return DRIZZLE_TYPE_DATE;}
   enum_field_types real_type() const { return DRIZZLE_TYPE_DATE; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_UINT24; }

=== modified file 'drizzled/field/datetime.h'
--- drizzled/field/datetime.h	2009-02-20 08:45:29 +0000
+++ drizzled/field/datetime.h	2009-09-28 07:40:31 +0000
@@ -31,17 +31,28 @@
   using Field::val_str;
   using Field::cmp;
 
-  Field_datetime(unsigned char *ptr_arg, unsigned char *null_ptr_arg,
+  Field_datetime(unsigned char *ptr_arg,
+                 unsigned char *null_ptr_arg,
                  unsigned char null_bit_arg,
-                 enum utype unireg_check_arg, const char *field_name_arg,
-                 const CHARSET_INFO * const cs)
-    :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
-               unireg_check_arg, field_name_arg, cs)
-    {}
-  Field_datetime(bool maybe_null_arg, const char *field_name_arg,
-                 const CHARSET_INFO * const cs)
-    :Field_str((unsigned char*) 0,19, maybe_null_arg ? (unsigned char*) "": 0,0,
-               NONE, field_name_arg, cs) {}
+                 const char *field_name_arg,
+                 const CHARSET_INFO * const cs)
+    :Field_str(ptr_arg,
+               19,
+               null_ptr_arg,
+               null_bit_arg,
+               field_name_arg,
+               cs)
+  {}
+  Field_datetime(bool maybe_null_arg,
+                 const char *field_name_arg,
+                 const CHARSET_INFO * const cs)
+    :Field_str((unsigned char*) 0,
+               19,
+               maybe_null_arg ? (unsigned char*) "": 0,
+               0,
+               field_name_arg,
+               cs) 
+  {}
   enum_field_types type() const { return DRIZZLE_TYPE_DATETIME;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }
   enum Item_result cmp_type () const { return INT_RESULT; }
@@ -69,4 +80,3 @@
 };
 
 #endif
-

=== modified file 'drizzled/field/decimal.cc'
--- drizzled/field/decimal.cc	2009-07-10 00:01:50 +0000
+++ drizzled/field/decimal.cc	2009-09-28 07:40:31 +0000
@@ -32,14 +32,22 @@
 ****************************************************************************/
 
 Field_new_decimal::Field_new_decimal(unsigned char *ptr_arg,
-                                     uint32_t len_arg, unsigned char *null_ptr_arg,
+                                     uint32_t len_arg,
+                                     unsigned char *null_ptr_arg,
                                      unsigned char null_bit_arg,
                                      enum utype unireg_check_arg,
                                      const char *field_name_arg,
-                                     uint8_t dec_arg,bool zero_arg,
+                                     uint8_t 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, dec_arg, zero_arg, unsigned_arg)
+  :Field_num(ptr_arg,
+             len_arg,
+             null_ptr_arg,
+             null_bit_arg,
+             unireg_check_arg,
+             field_name_arg,
+             dec_arg, zero_arg,
+             unsigned_arg)
 {
   precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
   set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);
@@ -48,15 +56,20 @@
   bin_size= my_decimal_get_binary_size(precision, dec);
 }
 
-
 Field_new_decimal::Field_new_decimal(uint32_t len_arg,
                                      bool maybe_null_arg,
                                      const char *name,
                                      uint8_t dec_arg,
                                      bool unsigned_arg)
-  :Field_num((unsigned char*) 0, len_arg,
-             maybe_null_arg ? (unsigned char*) "": 0, 0,
-             NONE, name, dec_arg, 0, unsigned_arg)
+  :Field_num((unsigned char*) 0,
+             len_arg,
+             maybe_null_arg ? (unsigned char*) "": 0,
+             0,
+             NONE,
+             name,
+             dec_arg,
+             0,
+             unsigned_arg)
 {
   precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
   set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);

=== modified file 'drizzled/field/decimal.h'
--- drizzled/field/decimal.h	2009-06-05 22:51:06 +0000
+++ drizzled/field/decimal.h	2009-09-28 07:40:31 +0000
@@ -44,12 +44,19 @@
     So for example we need to count length from precision handling
     CREATE TABLE ( DECIMAL(x,y))
   */
-  Field_new_decimal(unsigned char *ptr_arg, uint32_t len_arg, unsigned char *null_ptr_arg,
+  Field_new_decimal(unsigned char *ptr_arg,
+                    uint32_t len_arg,
+                    unsigned char *null_ptr_arg,
                     unsigned char null_bit_arg,
-                    enum utype unireg_check_arg, const char *field_name_arg,
-                    uint8_t dec_arg, bool zero_arg, bool unsigned_arg);
-  Field_new_decimal(uint32_t len_arg, bool maybe_null_arg,
-                    const char *field_name_arg, uint8_t dec_arg,
+                    enum utype unireg_check_arg,
+                    const char *field_name_arg,
+                    uint8_t dec_arg,
+                    bool zero_arg,
+                    bool unsigned_arg);
+  Field_new_decimal(uint32_t len_arg,
+                    bool maybe_null_arg,
+                    const char *field_name_arg,
+                    uint8_t dec_arg,
                     bool unsigned_arg);
   enum_field_types type() const { return DRIZZLE_TYPE_NEWDECIMAL;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }

=== modified file 'drizzled/field/enum.h'
--- drizzled/field/enum.h	2009-03-16 15:20:27 +0000
+++ drizzled/field/enum.h	2009-09-28 07:40:31 +0000
@@ -36,17 +36,24 @@
 
   /** Internal storage for the string values of the ENUM */
   TYPELIB *typelib;
-  Field_enum(unsigned char *ptr_arg, uint32_t len_arg, unsigned char *null_ptr_arg,
+  Field_enum(unsigned char *ptr_arg,
+             uint32_t len_arg,
+             unsigned char *null_ptr_arg,
              unsigned char null_bit_arg,
-             enum utype unireg_check_arg, const char *field_name_arg,
+             const char *field_name_arg,
              uint32_t packlength_arg,
              TYPELIB *typelib_arg,
              const CHARSET_INFO * const charset_arg)
-    :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
-	       unireg_check_arg, field_name_arg, charset_arg),
-    packlength(packlength_arg),typelib(typelib_arg)
+    :Field_str(ptr_arg,
+               len_arg,
+               null_ptr_arg,
+               null_bit_arg,
+	             field_name_arg,
+               charset_arg),
+    packlength(packlength_arg),
+    typelib(typelib_arg)
   {
-      flags|=ENUM_FLAG;
+    flags|= ENUM_FLAG;
   }
   Field *new_field(MEM_ROOT *root, Table *new_table, bool keep_type);
   enum ha_base_keytype key_type() const;

=== modified file 'drizzled/field/null.h'
--- drizzled/field/null.h	2009-02-20 08:45:29 +0000
+++ drizzled/field/null.h	2009-09-28 07:40:31 +0000
@@ -27,7 +27,8 @@
  * Everything saved in this will disappear. It will always return NULL
  */
 
-class Field_null :public Field_str {
+class Field_null :public Field_str
+{
   static unsigned char null[1];
 public:
 
@@ -36,37 +37,81 @@
   using Field::cmp;
   using Field::val_int;
 
-  Field_null(unsigned char *ptr_arg, uint32_t len_arg,
-	     enum utype unireg_check_arg, const char *field_name_arg,
-	     const CHARSET_INFO * const cs)
-    :Field_str(ptr_arg, len_arg, null, 1,
-	       unireg_check_arg, field_name_arg, cs)
-    {}
-  enum_field_types type() const { return DRIZZLE_TYPE_NULL;}
+  Field_null(unsigned char *ptr_arg,
+             uint32_t len_arg,
+             const char *field_name_arg,
+             const CHARSET_INFO * const cs)
+    :Field_str(ptr_arg,
+               len_arg,
+               null,
+               1,
+	             field_name_arg,
+               cs)
+  {}
+  enum_field_types type() const
+  {
+    return DRIZZLE_TYPE_NULL;
+  }
   int  store(const char *, uint32_t, const CHARSET_INFO * const)
-  { null[0]=1; return 0; }
+  {
+    null[0]= 1;
+    return 0;
+  }
   int store(double)
-  { null[0]=1; return 0; }
+  {
+    null[0]= 1;
+    return 0;
+  }
   int store(int64_t, bool)
-  { null[0]=1; return 0; }
+  {
+    null[0]= 1;
+    return 0;
+  }
   int store_decimal(const my_decimal *)
-  { null[0]=1; return 0; }
+  {
+    null[0]= 1;
+    return 0;
+  }
   int reset(void)
-  { return 0; }
+  {
+    return 0;
+  }
   double val_real(void)
-  { return 0.0;}
+  {
+    return 0.0;
+  }
   int64_t val_int(void)
-  { return 0;}
-  my_decimal *val_decimal(my_decimal *) { return 0; }
+  {
+    return 0;
+  }
+  my_decimal *val_decimal(my_decimal *)
+  {
+    return 0;
+  }
   String *val_str(String *, String *value2)
-  { value2->length(0); return value2;}
-  int cmp(const unsigned char *, const unsigned char *) { return 0;}
-  void sort_string(unsigned char *, uint32_t)  {}
-  uint32_t pack_length() const { return 0; }
+  {
+    value2->length(0);
+    return value2;
+  }
+  int cmp(const unsigned char *, const unsigned char *)
+  {
+    return 0;
+  }
+  void sort_string(unsigned char *, uint32_t)
+  {}
+  uint32_t pack_length() const
+  {
+    return 0;
+  }
   void sql_type(String &str) const;
-  uint32_t size_of() const { return sizeof(*this); }
-  uint32_t max_display_length() { return 4; }
+  uint32_t size_of() const
+  {
+    return sizeof(*this);
+  }
+  uint32_t max_display_length()
+  {
+    return 4;
+  }
 };
 
 #endif
-

=== modified file 'drizzled/field/str.cc'
--- drizzled/field/str.cc	2009-07-10 00:01:50 +0000
+++ drizzled/field/str.cc	2009-09-28 07:40:31 +0000
@@ -26,17 +26,21 @@
 #include <drizzled/session.h>
 
 
-Field_str::Field_str(unsigned char *ptr_arg,uint32_t len_arg,
+Field_str::Field_str(unsigned char *ptr_arg,
+                     uint32_t len_arg,
                      unsigned char *null_ptr_arg,
-                     unsigned char null_bit_arg, utype unireg_check_arg,
+                     unsigned char null_bit_arg,
                      const char *field_name_arg,
                      const CHARSET_INFO * const charset_arg)
-  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
-         unireg_check_arg, field_name_arg)
+  :Field(ptr_arg, len_arg,
+         null_ptr_arg,
+         null_bit_arg,
+         Field::NONE,
+         field_name_arg)
 {
   field_charset= charset_arg;
   if (charset_arg->state & MY_CS_BINSORT)
-    flags|=BINARY_FLAG;
+    flags|= BINARY_FLAG;
   field_derivation= DERIVATION_IMPLICIT;
 }
 

=== modified file 'drizzled/field/str.h'
--- drizzled/field/str.h	2009-06-05 22:51:06 +0000
+++ drizzled/field/str.h	2009-09-28 07:40:31 +0000
@@ -33,10 +33,12 @@
   enum Derivation field_derivation;
   int  report_if_important_data(const char *ptr, const char *end);
 public:
-  Field_str(unsigned char *ptr_arg,uint32_t len_arg,
+  Field_str(unsigned char *ptr_arg,
+            uint32_t len_arg,
             unsigned char *null_ptr_arg,
-            unsigned char null_bit_arg, utype unireg_check_arg,
-            const char *field_name_arg, const CHARSET_INFO * const charset);
+            unsigned char null_bit_arg,
+            const char *field_name_arg,
+            const CHARSET_INFO * const charset);
   Item_result result_type () const { return STRING_RESULT; }
   uint32_t decimals() const { return NOT_FIXED_DEC; }
 

=== modified file 'drizzled/field/timestamp.cc'
--- drizzled/field/timestamp.cc	2009-07-10 00:01:50 +0000
+++ drizzled/field/timestamp.cc	2009-09-28 07:40:31 +0000
@@ -28,7 +28,6 @@
 
 #include "drizzled/temporal.h"
 
-
 /**
   TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to
   2038-01-01 00:00:00 UTC stored as number of seconds since Unix
@@ -73,20 +72,24 @@
   exception is different behavior of old/new timestamps during ALTER TABLE.
  */
 Field_timestamp::Field_timestamp(unsigned char *ptr_arg,
-                                 uint32_t ,
-                                 unsigned char *null_ptr_arg, unsigned char null_bit_arg,
+                                 uint32_t,
+                                 unsigned char *null_ptr_arg,
+                                 unsigned char null_bit_arg,
                                  enum utype unireg_check_arg,
                                  const char *field_name_arg,
                                  TableShare *share,
                                  const CHARSET_INFO * const cs)
   :Field_str(ptr_arg,
              drizzled::DateTime::MAX_STRING_LENGTH - 1 /* no \0 */,
-             null_ptr_arg, null_bit_arg,
-	     unireg_check_arg, field_name_arg, cs)
+             null_ptr_arg,
+             null_bit_arg,
+             field_name_arg,
+             cs)
 {
   /* For 4.0 MYD and 4.0 InnoDB compatibility */
   flags|= UNSIGNED_FLAG;
-  if (!share->timestamp_field && unireg_check != NONE)
+  unireg_check= unireg_check_arg;
+  if (! share->timestamp_field && unireg_check != NONE)
   {
     /* This timestamp has auto-update */
     share->timestamp_field= this;
@@ -99,15 +102,17 @@
 Field_timestamp::Field_timestamp(bool maybe_null_arg,
                                  const char *field_name_arg,
                                  const CHARSET_INFO * const cs)
-  :Field_str((unsigned char*) 0,
+  :Field_str((unsigned char*) NULL,
              drizzled::DateTime::MAX_STRING_LENGTH - 1 /* no \0 */,
-             maybe_null_arg ? (unsigned char*) "": 0, 0,
-	     NONE, field_name_arg, cs)
+             maybe_null_arg ? (unsigned char*) "": 0,
+             0,
+             field_name_arg,
+             cs)
 {
   /* For 4.0 MYD and 4.0 InnoDB compatibility */
   flags|= UNSIGNED_FLAG;
-    if (unireg_check != TIMESTAMP_DN_FIELD)
-      flags|= ON_UPDATE_NOW_FLAG;
+  if (unireg_check != TIMESTAMP_DN_FIELD)
+    flags|= ON_UPDATE_NOW_FLAG;
 }
 
 /**

=== modified file 'drizzled/field/timestamp.h'
--- drizzled/field/timestamp.h	2009-04-28 21:46:57 +0000
+++ drizzled/field/timestamp.h	2009-09-28 07:40:31 +0000
@@ -33,11 +33,16 @@
   using Field::val_str;
   using Field::cmp;
   using Field::store;
-  Field_timestamp(unsigned char *ptr_arg, uint32_t len_arg,
-                  unsigned char *null_ptr_arg, unsigned char null_bit_arg,
-                  enum utype unireg_check_arg, const char *field_name_arg,
-                  TableShare *share, const CHARSET_INFO * const cs);
-  Field_timestamp(bool maybe_null_arg, const char *field_name_arg,
+  Field_timestamp(unsigned char *ptr_arg,
+                  uint32_t len_arg,
+                  unsigned char *null_ptr_arg,
+                  unsigned char null_bit_arg,
+                  enum utype unireg_check_arg,
+                  const char *field_name_arg,
+                  TableShare *share,
+                  const CHARSET_INFO * const cs);
+  Field_timestamp(bool maybe_null_arg,
+                  const char *field_name_arg,
                   const CHARSET_INFO * const cs);
   enum_field_types type() const { return DRIZZLE_TYPE_TIMESTAMP;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }

=== modified file 'drizzled/field/varstring.cc'
--- drizzled/field/varstring.cc	2009-07-10 00:01:50 +0000
+++ drizzled/field/varstring.cc	2009-09-28 07:40:31 +0000
@@ -47,33 +47,39 @@
 const uint32_t Field_varstring::MAX_SIZE= UINT16_MAX;
 
 Field_varstring::Field_varstring(unsigned char *ptr_arg,
-                                 uint32_t len_arg, uint32_t length_bytes_arg,
+                                 uint32_t len_arg,
+                                 uint32_t length_bytes_arg,
                                  unsigned char *null_ptr_arg,
                                  unsigned char null_bit_arg,
-                                 enum utype unireg_check_arg,
                                  const char *field_name_arg,
                                  TableShare *share,
                                  const CHARSET_INFO * const cs)
-  :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
-                 unireg_check_arg, field_name_arg, cs),
+  :Field_str(ptr_arg,
+             len_arg,
+             null_ptr_arg,
+             null_bit_arg,
+             field_name_arg, cs),
    length_bytes(length_bytes_arg)
 {
   share->varchar_fields++;
 }
 
-Field_varstring::Field_varstring(uint32_t len_arg,bool maybe_null_arg,
+Field_varstring::Field_varstring(uint32_t len_arg,
+                                 bool maybe_null_arg,
                                  const char *field_name_arg,
                                  TableShare *share,
                                  const CHARSET_INFO * const cs)
-  :Field_str((unsigned char*) 0,len_arg,
-                 maybe_null_arg ? (unsigned char*) "": 0, 0,
-                 NONE, field_name_arg, cs),
+  :Field_str((unsigned char*) 0,
+             len_arg,
+             maybe_null_arg ? (unsigned char*) "": 0,
+             0,
+             field_name_arg,
+             cs),
    length_bytes(len_arg < 256 ? 1 :2)
 {
   share->varchar_fields++;
 }
 
-
 /**
    Save the field metadata for varstring fields.
 

=== modified file 'drizzled/field/varstring.h'
--- drizzled/field/varstring.h	2009-06-13 21:21:13 +0000
+++ drizzled/field/varstring.h	2009-09-28 07:40:31 +0000
@@ -41,13 +41,18 @@
   /* Store number of bytes used to store length (1 or 2) */
   uint32_t length_bytes;
   Field_varstring(unsigned char *ptr_arg,
-                  uint32_t len_arg, uint32_t length_bytes_arg,
-                  unsigned char *null_ptr_arg, unsigned char null_bit_arg,
-                  enum utype unireg_check_arg, const char *field_name_arg,
-                  TableShare *share, const CHARSET_INFO * const cs);
-  Field_varstring(uint32_t len_arg,bool maybe_null_arg,
-                  const char *field_name_arg,
-                  TableShare *share, const CHARSET_INFO * const cs);
+                  uint32_t len_arg,
+                  uint32_t length_bytes_arg,
+                  unsigned char *null_ptr_arg,
+                  unsigned char null_bit_arg,
+                  const char *field_name_arg,
+                  TableShare *share,
+                  const CHARSET_INFO * const cs);
+  Field_varstring(uint32_t len_arg,
+                  bool maybe_null_arg,
+                  const char *field_name_arg,
+                  TableShare *share,
+                  const CHARSET_INFO * const cs);
 
   enum_field_types type() const { return DRIZZLE_TYPE_VARCHAR; }
   enum ha_base_keytype key_type() const;

=== modified file 'drizzled/function/func.cc'
--- drizzled/function/func.cc	2009-08-31 23:50:37 +0000
+++ drizzled/function/func.cc	2009-09-28 07:40:31 +0000
@@ -461,11 +461,13 @@
   case STRING_RESULT:
     return make_string_field(table);
   case DECIMAL_RESULT:
-    field= new Field_new_decimal(
-                       my_decimal_precision_to_length(decimal_precision(),
-                                                      decimals,
-                                                      unsigned_flag),
-                       maybe_null, name, decimals, unsigned_flag);
+    field= new Field_new_decimal(my_decimal_precision_to_length(decimal_precision(),
+                                                                decimals,
+                                                                unsigned_flag),
+                                 maybe_null,
+                                 name,
+                                 decimals,
+                                 unsigned_flag);
     break;
   case ROW_RESULT:
   default:

=== modified file 'drizzled/item.cc'
--- drizzled/item.cc	2009-08-31 23:50:37 +0000
+++ drizzled/item.cc	2009-09-28 07:40:31 +0000
@@ -1153,8 +1153,14 @@
 
   switch (field_type()) {
   case DRIZZLE_TYPE_NEWDECIMAL:
-    field= new Field_new_decimal((unsigned char*) 0, max_length, null_ptr, 0,
-                                 Field::NONE, name, decimals, 0,
+    field= new Field_new_decimal((unsigned char*) 0,
+                                 max_length,
+                                 null_ptr,
+                                 0,
+                                 Field::NONE,
+                                 name,
+                                 decimals,
+                                 0,
                                  unsigned_flag);
     break;
   case DRIZZLE_TYPE_LONG:
@@ -1170,8 +1176,7 @@
 			    name, decimals, 0, unsigned_flag);
     break;
   case DRIZZLE_TYPE_NULL:
-    field= new Field_null((unsigned char*) 0, max_length, Field::NONE,
-			  name, &my_charset_bin);
+    field= new Field_null((unsigned char*) 0, max_length, name, &my_charset_bin);
     break;
   case DRIZZLE_TYPE_DATE:
     field= new Field_date(maybe_null, name, &my_charset_bin);
@@ -1581,8 +1586,11 @@
         len-= item->decimals - dec;             // corrected value fits
     }
 
-    new_field= new Field_new_decimal(len, maybe_null, item->name,
-                                     dec, item->unsigned_flag);
+    new_field= new Field_new_decimal(len,
+                                     maybe_null,
+                                     item->name,
+                                     dec,
+                                     item->unsigned_flag);
     break;
   }
   case ROW_RESULT:

=== modified file 'drizzled/item/insert_value.cc'
--- drizzled/item/insert_value.cc	2009-05-14 07:17:50 +0000
+++ drizzled/item/insert_value.cc	2009-09-28 07:40:31 +0000
@@ -83,8 +83,7 @@
   {
     Field *tmp_field= field_arg->field;
     /* charset doesn't matter here, it's to avoid sigsegv only */
-    tmp_field= new Field_null(0, 0, Field::NONE, field_arg->field->field_name,
-                          &my_charset_bin);
+    tmp_field= new Field_null(0, 0, field_arg->field->field_name, &my_charset_bin);
     if (tmp_field)
     {
       tmp_field->init(field_arg->field->table);

=== modified file 'drizzled/item/sum.cc'
--- drizzled/item/sum.cc	2009-07-31 20:29:49 +0000
+++ drizzled/item/sum.cc	2009-09-28 07:40:31 +0000
@@ -1022,8 +1022,7 @@
   assert(args[0]->fixed);
 
   field_def.init_for_tmp_table(table_field_type, args[0]->max_length,
-                               args[0]->decimals, args[0]->maybe_null,
-                               args[0]->unsigned_flag);
+                               args[0]->decimals, args[0]->maybe_null);
 
   if (! (table= create_virtual_tmp_table(session, field_list)))
     return(true);

=== modified file 'drizzled/item/type_holder.cc'
--- drizzled/item/type_holder.cc	2009-06-24 19:16:57 +0000
+++ drizzled/item/type_holder.cc	2009-09-28 07:40:31 +0000
@@ -232,10 +232,14 @@
   switch (fld_type) {
   case DRIZZLE_TYPE_ENUM:
     assert(enum_set_typelib);
-    field= new Field_enum((unsigned char *) 0, max_length, null_ptr, 0,
-                          Field::NONE, name,
+    field= new Field_enum((unsigned char *) 0,
+                          max_length,
+                          null_ptr,
+                          0,
+                          name,
                           get_enum_pack_length(enum_set_typelib->count),
-                          enum_set_typelib, collation.collation);
+                          enum_set_typelib,
+                          collation.collation);
     if (field)
       field->init(table);
     return field;

=== modified file 'drizzled/key.cc'
--- drizzled/key.cc	2009-07-30 02:39:13 +0000
+++ drizzled/key.cc	2009-09-28 07:40:31 +0000
@@ -287,8 +287,7 @@
       continue;
     }
     length= min((uint32_t) (key_end-key), store_length);
-    if (!(key_part->key_type & (FIELDFLAG_NUMBER+FIELDFLAG_BINARY+
-                                FIELDFLAG_PACK)))
+    if (key_part->field->type() == DRIZZLE_TYPE_VARCHAR)
     {
       const CHARSET_INFO * const cs= key_part->field->charset();
       uint32_t char_length= key_part->length / cs->mbmaxlen;

=== modified file 'drizzled/message/table.proto'
--- drizzled/message/table.proto	2009-06-09 20:24:17 +0000
+++ drizzled/message/table.proto	2009-09-28 07:40:31 +0000
@@ -155,8 +155,6 @@
     optional string comment = 16; /* Reserve 0-15 for frequently accessed attributes */
     optional SetFieldOptions set_options = 17;
     optional TimestampFieldOptions timestamp_options = 18;
-
-    optional uint32 pack_flag = 100; /* MUST DIE */
   }
 
   message Index {

=== modified file 'drizzled/sql_table.cc'
--- drizzled/sql_table.cc	2009-09-23 19:16:36 +0000
+++ drizzled/sql_table.cc	2009-09-28 07:40:31 +0000
@@ -832,27 +832,20 @@
 
   switch (sql_field->sql_type) {
   case DRIZZLE_TYPE_BLOB:
-    sql_field->pack_flag=FIELDFLAG_BLOB |
-      pack_length_to_packflag(sql_field->pack_length -
-                              portable_sizeof_char_ptr);
-    if (sql_field->charset->state & MY_CS_BINSORT)
-      sql_field->pack_flag|=FIELDFLAG_BINARY;
-    sql_field->length=8;			// Unireg field length
+    sql_field->pack_flag= pack_length_to_packflag(sql_field->pack_length - portable_sizeof_char_ptr);
+    sql_field->length= 8; // Unireg field length
     (*blob_columns)++;
     break;
   case DRIZZLE_TYPE_VARCHAR:
     sql_field->pack_flag=0;
-    if (sql_field->charset->state & MY_CS_BINSORT)
-      sql_field->pack_flag|=FIELDFLAG_BINARY;
     break;
   case DRIZZLE_TYPE_ENUM:
-    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
-      FIELDFLAG_INTERVAL;
-    if (sql_field->charset->state & MY_CS_BINSORT)
-      sql_field->pack_flag|=FIELDFLAG_BINARY;
-    if (check_duplicates_in_interval("ENUM",sql_field->field_name,
-                                 sql_field->interval,
-                                     sql_field->charset, &dup_val_count))
+    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length);
+    if (check_duplicates_in_interval("ENUM",
+                                     sql_field->field_name,
+                                     sql_field->interval,
+                                     sql_field->charset,
+                                     &dup_val_count))
       return 1;
     break;
   case DRIZZLE_TYPE_DATE:  // Rest of string types
@@ -861,11 +854,7 @@
     sql_field->pack_flag=f_settype((uint32_t) sql_field->sql_type);
     break;
   case DRIZZLE_TYPE_NEWDECIMAL:
-    sql_field->pack_flag=(FIELDFLAG_NUMBER |
-                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
-                           FIELDFLAG_DECIMAL) |
-                          (sql_field->flags & DECIMAL_FLAG ?  FIELDFLAG_DECIMAL_POSITION : 0) |
-                          (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
+    sql_field->pack_flag= 0;
     break;
   case DRIZZLE_TYPE_TIMESTAMP:
     /* We should replace old TIMESTAMP fields with their newer analogs */
@@ -885,17 +874,10 @@
     (*timestamps)++;
     /* fall-through */
   default:
-    sql_field->pack_flag=(FIELDFLAG_NUMBER |
-                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
-                           FIELDFLAG_DECIMAL) |
-                          f_settype((uint32_t) sql_field->sql_type) |
-                          (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
+    sql_field->pack_flag=(0 |
+                          f_settype((uint32_t) sql_field->sql_type));
     break;
   }
-  if (!(sql_field->flags & NOT_NULL_FLAG))
-    sql_field->pack_flag|= FIELDFLAG_MAYBE_NULL;
-  if (sql_field->flags & NO_DEFAULT_VALUE_FLAG)
-    sql_field->pack_flag|= FIELDFLAG_NO_DEFAULT;
   return 0;
 }
 
@@ -1375,45 +1357,44 @@
       }
       cols2.rewind();
       {
-	column->length*= sql_field->charset->mbmaxlen;
+        column->length*= sql_field->charset->mbmaxlen;
 
-	if (f_is_blob(sql_field->pack_flag))
-	{
-	  if (!(file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
-	  {
-	    my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
-	    return(true);
-	  }
-	  if (!column->length)
-	  {
-	    my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.str);
-	    return(true);
-	  }
-	}
-	if (!(sql_field->flags & NOT_NULL_FLAG))
-	{
-	  if (key->type == Key::PRIMARY)
-	  {
-	    /* Implicitly set primary key fields to NOT NULL for ISO conf. */
-	    sql_field->flags|= NOT_NULL_FLAG;
-	    sql_field->pack_flag&= ~FIELDFLAG_MAYBE_NULL;
+        if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
+        {
+          if (! (file->ha_table_flags() & HA_CAN_INDEX_BLOBS))
+          {
+            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
+            return true;
+          }
+          if (! column->length)
+          {
+            my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.str);
+            return true;
+          }
+        }
+        if (! (sql_field->flags & NOT_NULL_FLAG))
+        {
+          if (key->type == Key::PRIMARY)
+          {
+            /* Implicitly set primary key fields to NOT NULL for ISO conf. */
+            sql_field->flags|= NOT_NULL_FLAG;
             null_fields--;
-	  }
-	  else
+          }
+          else
           {
             key_info->flags|= HA_NULL_PART_KEY;
-            if (!(file->ha_table_flags() & HA_NULL_IN_KEY))
+            if (! (file->ha_table_flags() & HA_NULL_IN_KEY))
             {
               my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
-              return(true);
+              return true;
             }
           }
-	}
-	if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
-	{
-	  if (column_nr == 0 || (file->ha_table_flags() & HA_AUTO_PART_KEY))
-	    auto_increment--;			// Field is used
-	}
+        }
+        if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
+        {
+          if (column_nr == 0 || (file->ha_table_flags() & HA_AUTO_PART_KEY))
+            auto_increment--;			// Field is used
+        }
       }
 
       key_part_info->fieldnr= field;
@@ -1423,7 +1404,7 @@
 
       if (column->length)
       {
-	if (f_is_blob(sql_field->pack_flag))
+	if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
 	{
 	  if ((length=column->length) > max_key_length ||
 	      length > file->max_key_part_length())
@@ -1448,11 +1429,7 @@
 	  }
 	}
 	else if ((column->length > length ||
-                   !Field::type_can_have_key_part (sql_field->sql_type) ||
-		   ((f_is_packed(sql_field->pack_flag) ||
-		     ((file->ha_table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
-		      (key_info->flags & HA_NOSAME))) &&
-		    column->length != length)))
+            ! Field::type_can_have_key_part(sql_field->sql_type)))
 	{
 	  my_message(ER_WRONG_SUB_KEY, ER(ER_WRONG_SUB_KEY), MYF(0));
 	  return(true);
@@ -1490,13 +1467,13 @@
       if (!((*db_options) & HA_OPTION_NO_PACK_KEYS) &&
 	  (length >= KEY_DEFAULT_PACK_LENGTH &&
 	   (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR ||
-	    sql_field->pack_flag & FIELDFLAG_BLOB)))
+      sql_field->sql_type == DRIZZLE_TYPE_BLOB)))
       {
-	if ((column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB)) ||
+        if ((column_nr == 0 && sql_field->sql_type == DRIZZLE_TYPE_BLOB) ||
             sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)
-	  key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
-	else
-	  key_info->flags|= HA_PACK_KEY;
+          key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
+        else
+          key_info->flags|= HA_PACK_KEY;
       }
       /* Check if the key segment is partial, set the key flag accordingly */
       if (length != sql_field->key_length)

=== modified file 'drizzled/statement/alter_table.cc'
--- drizzled/statement/alter_table.cc	2009-09-24 06:23:51 +0000
+++ drizzled/statement/alter_table.cc	2009-09-28 07:40:31 +0000
@@ -396,8 +396,7 @@
          */
         if (! Field::type_can_have_key_part(cfield->field->type()) ||
             ! Field::type_can_have_key_part(cfield->sql_type) ||
-            (cfield->field->field_length == key_part_length &&
-             ! f_is_blob(key_part->key_type)) ||
+            (cfield->field->field_length == key_part_length) ||
             (cfield->length &&
              (cfield->length < key_part_length / key_part->field->charset()->mbmaxlen)))
           key_part_length= 0; /* Use whole field */

=== modified file 'drizzled/stored_key.h'
--- drizzled/stored_key.h	2009-07-10 00:01:50 +0000
+++ drizzled/stored_key.h	2009-09-28 07:40:31 +0000
@@ -53,9 +53,14 @@
         Key segments are always packed with a 2 byte length prefix.
         See mi_rkey for details.
       */
-      to_field= new Field_varstring(ptr, length, 2, null, 1,
-                                    Field::NONE, field_arg->field_name,
-                                    field_arg->table->s, field_arg->charset());
+      to_field= new Field_varstring(ptr,
+                                    length,
+                                    2,
+                                    null,
+                                    1,
+                                    field_arg->field_name,
+                                    field_arg->table->s,
+                                    field_arg->charset());
       to_field->init(field_arg->table);
     }
     else

=== modified file 'drizzled/table.cc'
--- drizzled/table.cc	2009-09-23 18:52:35 +0000
+++ drizzled/table.cc	2009-09-28 07:40:31 +0000
@@ -45,7 +45,7 @@
 #include <vector>
 #include <algorithm>
 
-
+using namespace drizzled;
 using namespace std;
 using namespace drizzled;
 
@@ -282,7 +282,7 @@
   int error= 0;
   handler *handler_file= NULL;
 
-  share->setTableProto(new(std::nothrow) message::Table(table));
+  share->setTableProto(new(nothrow) message::Table(table));
 
   share->storage_engine= ha_resolve_by_name(session, table.engine().name());
 
@@ -386,36 +386,35 @@
     {
       message::Table::Index::IndexOptions indx_options= indx.options();
       if (indx_options.pack_key())
-	keyinfo->flags|= HA_PACK_KEY;
+        keyinfo->flags|= HA_PACK_KEY;
 
       if (indx_options.var_length_key())
-	keyinfo->flags|= HA_VAR_LENGTH_PART;
+        keyinfo->flags|= HA_VAR_LENGTH_PART;
 
       if (indx_options.null_part_key())
-	keyinfo->flags|= HA_NULL_PART_KEY;
+        keyinfo->flags|= HA_NULL_PART_KEY;
 
       if (indx_options.binary_pack_key())
-	keyinfo->flags|= HA_BINARY_PACK_KEY;
+        keyinfo->flags|= HA_BINARY_PACK_KEY;
 
       if (indx_options.has_partial_segments())
-	keyinfo->flags|= HA_KEY_HAS_PART_KEY_SEG;
+        keyinfo->flags|= HA_KEY_HAS_PART_KEY_SEG;
 
       if (indx_options.auto_generated_key())
-	keyinfo->flags|= HA_GENERATED_KEY;
+        keyinfo->flags|= HA_GENERATED_KEY;
 
       if (indx_options.has_key_block_size())
       {
-	keyinfo->flags|= HA_USES_BLOCK_SIZE;
-	keyinfo->block_size= indx_options.key_block_size();
+        keyinfo->flags|= HA_USES_BLOCK_SIZE;
+        keyinfo->block_size= indx_options.key_block_size();
       }
       else
       {
-	keyinfo->block_size= 0;
+        keyinfo->block_size= 0;
       }
-
     }
 
-    switch(indx.type())
+    switch (indx.type())
     {
     case message::Table::Index::UNKNOWN_INDEX:
       keyinfo->algorithm= HA_KEY_ALG_UNDEF;
@@ -446,8 +445,8 @@
     keyinfo->rec_per_key= rec_per_key;
 
     for (unsigned int partnr= 0;
-	partnr < keyinfo->key_parts;
-	partnr++, key_part++)
+         partnr < keyinfo->key_parts;
+         partnr++, key_part++)
     {
       message::Table::Index::IndexPart part;
       part= indx.index_part(partnr);
@@ -462,7 +461,7 @@
       /* key_part->type ???? */
       key_part->key_part_flag= 0;
       if (part.has_in_reverse_order())
-	key_part->key_part_flag= part.in_reverse_order()? HA_REVERSE_SORT : 0;
+        key_part->key_part_flag= part.in_reverse_order()? HA_REVERSE_SORT : 0;
 
       key_part->length= part.compare_length();
 
@@ -470,10 +469,9 @@
 
       /* key_part->offset is set later */
       key_part->key_type= part.key_type();
-
     }
 
-    if (!indx.has_comment())
+    if (! indx.has_comment())
     {
       keyinfo->comment.length= 0;
       keyinfo->comment.str= NULL;
@@ -549,38 +547,34 @@
     case DRIZZLE_TYPE_BLOB:
     case DRIZZLE_TYPE_VARCHAR:
       {
-	message::Table::Field::StringFieldOptions field_options=
-	  pfield.string_options();
-
-	const CHARSET_INFO *cs= get_charset(field_options.has_collation_id()?
-					    field_options.collation_id() : 0);
-
-	if (!cs)
-	  cs= default_charset_info;
-
-	field_pack_length[fieldnr]=
-	  calc_pack_length(drizzle_field_type,
-			   field_options.length() * cs->mbmaxlen);
-
+        message::Table::Field::StringFieldOptions field_options= pfield.string_options();
+
+        const CHARSET_INFO *cs= get_charset(field_options.has_collation_id() ?
+                                            field_options.collation_id() : 0);
+
+        if (! cs)
+          cs= default_charset_info;
+
+        field_pack_length[fieldnr]= calc_pack_length(drizzle_field_type,
+                                                     field_options.length() * cs->mbmaxlen);
       }
       break;
     case DRIZZLE_TYPE_ENUM:
       {
-	message::Table::Field::SetFieldOptions field_options=
-	  pfield.set_options();
-
-	field_pack_length[fieldnr]=
-	  get_enum_pack_length(field_options.field_value_size());
-
-	interval_count++;
-	interval_parts+= field_options.field_value_size();
+        message::Table::Field::SetFieldOptions field_options= pfield.set_options();
+
+        field_pack_length[fieldnr]=
+          get_enum_pack_length(field_options.field_value_size());
+
+        interval_count++;
+        interval_parts+= field_options.field_value_size();
       }
       break;
     case DRIZZLE_TYPE_NEWDECIMAL:
       {
-	message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
-	field_pack_length[fieldnr]=
-	  my_decimal_get_binary_size(fo.precision(), fo.scale());
+        message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
+
+        field_pack_length[fieldnr]= my_decimal_get_binary_size(fo.precision(), fo.scale());
       }
       break;
     default:
@@ -590,7 +584,6 @@
 
     share->reclength+= field_pack_length[fieldnr];
     stored_columns_reclength+= field_pack_length[fieldnr];
-
   }
 
   /* data_offset added to stored_rec_length later */
@@ -599,7 +592,7 @@
   share->null_fields= null_fields;
 
   ulong null_bits= null_fields;
-  if (!table_options.pack_record())
+  if (! table_options.pack_record())
     null_bits++;
   ulong data_offset= (null_bits + 7)/8;
 
@@ -614,15 +607,15 @@
 
   unsigned char* record= NULL;
 
-  if (!(record= (unsigned char *) alloc_root(&share->mem_root,
-                                     rec_buff_length)))
+  if (! (record= (unsigned char *) alloc_root(&share->mem_root,
+                                              rec_buff_length)))
     abort();
 
   memset(record, 0, rec_buff_length);
 
   int null_count= 0;
 
-  if (!table_options.pack_record())
+  if (! table_options.pack_record())
   {
     null_count++; // one bit for delete mark.
     *record|= 1;
@@ -632,17 +625,17 @@
 
   if (interval_count)
   {
-    share->intervals= (TYPELIB*)alloc_root(&share->mem_root,
-					   interval_count*sizeof(TYPELIB));
+    share->intervals= (TYPELIB *) alloc_root(&share->mem_root,
+                                           interval_count*sizeof(TYPELIB));
   }
   else
     share->intervals= NULL;
 
-  share->fieldnames.type_names= (const char**)alloc_root(&share->mem_root,
-			          (share->fields+1)*sizeof(char*));
+  share->fieldnames.type_names= (const char **) alloc_root(&share->mem_root,
+                                                          (share->fields + 1) * sizeof(char*));
 
-  share->fieldnames.type_lengths= (unsigned int*) alloc_root(&share->mem_root,
-				  (share->fields+1)*sizeof(unsigned int));
+  share->fieldnames.type_lengths= (unsigned int *) alloc_root(&share->mem_root,
+                                                             (share->fields + 1) * sizeof(unsigned int));
 
   share->fieldnames.type_names[share->fields]= NULL;
   share->fieldnames.type_lengths[share->fields]= 0;
@@ -661,8 +654,8 @@
 
     /* field names */
     share->fieldnames.type_names[fieldnr]= strmake_root(&share->mem_root,
-							pfield.name().c_str(),
-							pfield.name().length());
+                                                        pfield.name().c_str(),
+                                                        pfield.name().length());
 
     share->fieldnames.type_lengths[fieldnr]= pfield.name().length();
 
@@ -672,19 +665,19 @@
 
     message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
-    const CHARSET_INFO *charset= get_charset(field_options.has_collation_id()?
-					     field_options.collation_id() : 0);
+    const CHARSET_INFO *charset= get_charset(field_options.has_collation_id() ?
+                                             field_options.collation_id() : 0);
 
-    if (!charset)
+    if (! charset)
       charset= default_charset_info;
 
     TYPELIB *t= &(share->intervals[interval_nr]);
 
     t->type_names= (const char**)alloc_root(&share->mem_root,
-			   (field_options.field_value_size()+1)*sizeof(char*));
+                                            (field_options.field_value_size() + 1) * sizeof(char*));
 
     t->type_lengths= (unsigned int*) alloc_root(&share->mem_root,
-		     (field_options.field_value_size()+1)*sizeof(unsigned int));
+                                                (field_options.field_value_size() + 1) * sizeof(unsigned int));
 
     t->type_names[field_options.field_value_size()]= NULL;
     t->type_lengths[field_options.field_value_size()]= 0;
@@ -695,15 +688,17 @@
     for (int n= 0; n < field_options.field_value_size(); n++)
     {
       t->type_names[n]= strmake_root(&share->mem_root,
-				     field_options.field_value(n).c_str(),
-				     field_options.field_value(n).length());
+                                     field_options.field_value(n).c_str(),
+                                     field_options.field_value(n).length());
 
-      /* Go ask the charset what the length is as for "" length=1
-	 and there's stripping spaces or some other crack going on.
+      /* 
+       * Go ask the charset what the length is as for "" length=1
+       * and there's stripping spaces or some other crack going on.
        */
       uint32_t lengthsp;
-      lengthsp= charset->cset->lengthsp(charset, t->type_names[n],
-					field_options.field_value(n).length());
+      lengthsp= charset->cset->lengthsp(charset,
+                                        t->type_names[n],
+                                        field_options.field_value(n).length());
       t->type_lengths[n]= lengthsp;
     }
     interval_nr++;
@@ -716,10 +711,14 @@
   bool use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
 
   if (use_hash)
-    use_hash= !hash_init(&share->name_hash,
-			 system_charset_info,
-			 share->fields, 0, 0,
-			 (hash_get_key) get_field_name, 0, 0);
+    use_hash= ! hash_init(&share->name_hash,
+                          system_charset_info,
+                          share->fields,
+                          0,
+                          0,
+                          (hash_get_key) get_field_name,
+                          0,
+                          0);
 
   unsigned char* null_pos= record;;
   int null_bit_pos= (table_options.pack_record()) ? 0 : 1;
@@ -730,7 +729,7 @@
 
     enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;
 
-    switch(pfield.format())
+    switch (pfield.format())
     {
     case message::Table::Field::DefaultFormat:
       column_format= COLUMN_FORMAT_TYPE_DEFAULT;
@@ -747,31 +746,31 @@
 
     Field::utype unireg_type= Field::NONE;
 
-    if (pfield.has_numeric_options()
-       && pfield.numeric_options().is_autoincrement())
+    if (pfield.has_numeric_options() &&
+        pfield.numeric_options().is_autoincrement())
     {
       unireg_type= Field::NEXT_NUMBER;
     }
 
-    if (pfield.has_options()
-       && pfield.options().has_default_value()
-       && pfield.options().default_value().compare("NOW()") == 0)
+    if (pfield.has_options() &&
+        pfield.options().has_default_value() &&
+        pfield.options().default_value().compare("NOW()") == 0)
     {
-      if (pfield.options().has_update_value()
-	 && pfield.options().update_value().compare("NOW()") == 0)
+      if (pfield.options().has_update_value() &&
+          pfield.options().update_value().compare("NOW()") == 0)
       {
-	unireg_type= Field::TIMESTAMP_DNUN_FIELD;
+        unireg_type= Field::TIMESTAMP_DNUN_FIELD;
       }
-      else if (!pfield.options().has_update_value())
+      else if (! pfield.options().has_update_value())
       {
-	unireg_type= Field::TIMESTAMP_DN_FIELD;
+      	unireg_type= Field::TIMESTAMP_DN_FIELD;
       }
       else
-	assert(1); // Invalid update value.
+      	assert(1); // Invalid update value.
     }
-    else if (pfield.has_options()
-	     && pfield.options().has_update_value()
-	     && pfield.options().update_value().compare("NOW()") == 0)
+    else if (pfield.has_options() &&
+             pfield.options().has_update_value() &&
+             pfield.options().update_value().compare("NOW()") == 0)
     {
       unireg_type= Field::TIMESTAMP_UN_FIELD;
     }
@@ -797,47 +796,67 @@
 
     const CHARSET_INFO *charset= &my_charset_bin;
 
-    if (field_type==DRIZZLE_TYPE_BLOB
-       || field_type==DRIZZLE_TYPE_VARCHAR)
-    {
-      message::Table::Field::StringFieldOptions field_options=
-	pfield.string_options();
-
-      charset= get_charset(field_options.has_collation_id()?
-			   field_options.collation_id() : 0);
-
-      if (!charset)
-	charset= default_charset_info;
-
-    }
-
-    if (field_type==DRIZZLE_TYPE_ENUM)
-    {
-      message::Table::Field::SetFieldOptions field_options=
-	pfield.set_options();
-
-      charset= get_charset(field_options.has_collation_id()?
-			   field_options.collation_id() : 0);
-
-      if (!charset)
-	charset= default_charset_info;
-
+    if (field_type == DRIZZLE_TYPE_BLOB ||
+        field_type == DRIZZLE_TYPE_VARCHAR)
+    {
+      message::Table::Field::StringFieldOptions field_options= pfield.string_options();
+
+      charset= get_charset(field_options.has_collation_id() ?
+                           field_options.collation_id() : 0);
+
+      if (! charset)
+      	charset= default_charset_info;
+    }
+
+    if (field_type == DRIZZLE_TYPE_ENUM)
+    {
+      message::Table::Field::SetFieldOptions field_options= pfield.set_options();
+
+      charset= get_charset(field_options.has_collation_id()?
+			   field_options.collation_id() : 0);
+
+      if (! charset)
+	      charset= default_charset_info;
+    }
+
+    uint8_t decimals= 0;
+    if (field_type == DRIZZLE_TYPE_NEWDECIMAL
+        || field_type == DRIZZLE_TYPE_DOUBLE)
+    {
+      message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
+
+      if (! pfield.has_numeric_options() || ! fo.has_scale())
+      {
+        /*
+          We don't write the default to table proto so
+          if no decimals specified for DOUBLE, we use the default.
+        */
+        decimals= NOT_FIXED_DEC;
+      }
+      else
+      {
+        if (fo.scale() > DECIMAL_MAX_SCALE)
+        {
+          error= 4;
+          goto err;
+        }
+	decimals= fo.scale();
+      }
     }
 
     Item *default_value= NULL;
 
-    if (pfield.options().has_default_value()
-       || pfield.options().has_default_null()
-       || pfield.options().has_default_bin_value())
+    if (pfield.options().has_default_value() ||
+        pfield.options().has_default_null()  ||
+        pfield.options().has_default_bin_value())
     {
       default_value= default_value_item(field_type,
-					charset,
-					pfield.options().default_null(),
-					&pfield.options().default_value(),
-					&pfield.options().default_bin_value());
+                                        charset,
+                                        pfield.options().default_null(),
+                                        &pfield.options().default_value(),
+                                        &pfield.options().default_bin_value());
     }
 
-    uint32_t pack_flag= pfield.pack_flag(); /* TODO: MUST DIE */
 
     Table temp_table; /* Use this so that BLOB DEFAULT '' works */
     memset(&temp_table, 0, sizeof(temp_table));
@@ -846,29 +865,31 @@
     temp_table.s->db_low_byte_first= 1; //handler->low_byte_first();
     temp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
 
-    Field* f= make_field(share, &share->mem_root,
-			 record+field_offsets[fieldnr]+data_offset,
-			 pfield.options().length(),
-			 null_pos,
-			 null_bit_pos,
-			 pack_flag,
-			 field_type,
-			 charset,
-			 (Field::utype) MTYP_TYPENR(unireg_type),
-			 ((field_type==DRIZZLE_TYPE_ENUM)?
-			 share->intervals+(interval_nr++)
-			 : (TYPELIB*) 0),
-			share->fieldnames.type_names[fieldnr]);
+    Field* f= make_field(share,
+                         &share->mem_root,
+                         record + field_offsets[fieldnr] + data_offset,
+                         pfield.options().length(),
+                         pfield.has_constraints() && pfield.constraints().is_nullable() ? true : false,
+                         null_pos,
+                         null_bit_pos,
+                         decimals,
+                         field_type,
+                         charset,
+                         (Field::utype) MTYP_TYPENR(unireg_type),
+                         ((field_type == DRIZZLE_TYPE_ENUM) ?
+                          share->intervals + (interval_nr++)
+                          : (TYPELIB*) 0),
+                         share->fieldnames.type_names[fieldnr]);
 
     share->field[fieldnr]= f;
 
     f->init(&temp_table); /* blob default values need table obj */
 
-    if (!(f->flags & NOT_NULL_FLAG))
+    if (! (f->flags & NOT_NULL_FLAG))
     {
       *f->null_ptr|= f->null_bit;
-      if (!(null_bit_pos= (null_bit_pos + 1) & 7))
-	null_pos++;
+      if (! (null_bit_pos= (null_bit_pos + 1) & 7)) /* @TODO Ugh. */
+        null_pos++;
       null_count++;
     }
 
@@ -878,15 +899,15 @@
       session->count_cuted_fields= CHECK_FIELD_WARN;
       int res= default_value->save_in_field(f, 1);
       session->count_cuted_fields= old_count_cuted_fields;
-      if (res != 0 && res != 3)
+      if (res != 0 && res != 3) /* @TODO Huh? */
       {
         my_error(ER_INVALID_DEFAULT, MYF(0), f->field_name);
         error= 1;
-	goto err;
+        goto err;
       }
     }
     else if (f->real_type() == DRIZZLE_TYPE_ENUM &&
-	    (f->flags & NOT_NULL_FLAG))
+             (f->flags & NOT_NULL_FLAG))
     {
       f->set_notnull();
       f->store((int64_t) 1, true);
@@ -900,11 +921,13 @@
 
     f->field_index= fieldnr;
     f->comment= comment;
-    if (!default_value
-       && !(f->unireg_check==Field::NEXT_NUMBER)
-       && (f->flags & NOT_NULL_FLAG)
-       && (f->real_type() != DRIZZLE_TYPE_TIMESTAMP))
+    if (! default_value &&
+        ! (f->unireg_check==Field::NEXT_NUMBER) &&
+        (f->flags & NOT_NULL_FLAG) &&
+        (f->real_type() != DRIZZLE_TYPE_TIMESTAMP))
+    {
       f->flags|= NO_DEFAULT_VALUE_FLAG;
+    }
 
     if (f->unireg_check == Field::NEXT_NUMBER)
       share->found_next_number_field= &(share->field[fieldnr]);
@@ -927,9 +950,11 @@
          partnr < keyinfo->key_parts;
          partnr++, key_part++)
     {
-      /* Fix up key_part->offset by adding data_offset.
-	 We really should compute offset as well.
-	 But at least this way we are a little better. */
+      /* 
+       * Fix up key_part->offset by adding data_offset.
+       * We really should compute offset as well.
+       * But at least this way we are a little better.
+       */
       key_part->offset= field_offsets[key_part->fieldnr-1] + data_offset;
     }
   }
@@ -942,61 +967,59 @@
   if (null_count & 7)
     *(record + null_count / 8)|= ~(((unsigned char) 1 << (null_count & 7)) - 1);
 
-  share->null_bytes= (null_pos - (unsigned char*) record +
-		      (null_bit_pos + 7) / 8);
+  share->null_bytes= (null_pos - (unsigned char*) record + (null_bit_pos + 7) / 8);
 
   share->last_null_bit_pos= null_bit_pos;
 
   free(field_offsets);
   free(field_pack_length);
 
-  if (!(handler_file= get_new_handler(share, session->mem_root,
-				     share->db_type())))
+  if (! (handler_file= get_new_handler(share,
+                                       session->mem_root,
+                                       share->db_type())))
     abort(); // FIXME
 
   /* Fix key stuff */
   if (share->key_parts)
   {
-    uint32_t primary_key=(uint32_t) (find_type((char*) "PRIMARY",
-				       &share->keynames, 3) - 1);
+    uint32_t primary_key= (uint32_t) (find_type((char*) "PRIMARY",
+                                                &share->keynames, 3) - 1); /* @TODO Huh? */
 
     int64_t ha_option= handler_file->ha_table_flags();
 
     keyinfo= share->key_info;
     key_part= keyinfo->key_part;
 
-    for (uint32_t key= 0 ; key < share->keys ; key++,keyinfo++)
+    for (uint32_t key= 0; key < share->keys; key++,keyinfo++)
     {
       uint32_t usable_parts= 0;
 
       if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
       {
-	/*
-	  If the UNIQUE key doesn't have NULL columns and is not a part key
-	  declare this as a primary key.
-	*/
-	primary_key=key;
-	for (uint32_t i= 0 ; i < keyinfo->key_parts ;i++)
-	{
-	  uint32_t fieldnr= key_part[i].fieldnr;
-	  if (!fieldnr ||
-	      share->field[fieldnr-1]->null_ptr ||
-	      share->field[fieldnr-1]->key_length() !=
-	      key_part[i].length)
-	  {
-	    primary_key=MAX_KEY;                // Can't be used
-	    break;
-	  }
-	}
+        /*
+          If the UNIQUE key doesn't have NULL columns and is not a part key
+          declare this as a primary key.
+        */
+        primary_key=key;
+        for (uint32_t i= 0; i < keyinfo->key_parts; i++)
+        {
+          uint32_t fieldnr= key_part[i].fieldnr;
+          if (! fieldnr ||
+              share->field[fieldnr-1]->null_ptr ||
+              share->field[fieldnr-1]->key_length() != key_part[i].length)
+          {
+            primary_key= MAX_KEY; // Can't be used
+            break;
+          }
+        }
       }
 
       for (uint32_t i= 0 ; i < keyinfo->key_parts ; key_part++,i++)
       {
         Field *field;
-	if (!key_part->fieldnr)
+        if (! key_part->fieldnr)
         {
-//          error= 4;                             // Wrong file
-	  abort(); // goto err;
+          abort(); // goto err;
         }
         field= key_part->field= share->field[key_part->fieldnr-1];
         key_part->type= field->key_type();
@@ -1076,24 +1099,23 @@
         set_if_bigger(share->max_unique_length,keyinfo->key_length);
     }
     if (primary_key < MAX_KEY &&
-	(share->keys_in_use.test(primary_key)))
+        (share->keys_in_use.test(primary_key)))
     {
       share->primary_key= primary_key;
       /*
-	If we are using an integer as the primary key then allow the user to
-	refer to it as '_rowid'
+        If we are using an integer as the primary key then allow the user to
+        refer to it as '_rowid'
       */
       if (share->key_info[primary_key].key_parts == 1)
       {
-	Field *field= share->key_info[primary_key].key_part[0].field;
-	if (field && field->result_type() == INT_RESULT)
+        Field *field= share->key_info[primary_key].key_part[0].field;
+        if (field && field->result_type() == INT_RESULT)
         {
           /* note that fieldnr here (and rowid_field_offset) starts from 1 */
-	  share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
+          share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
                                       fieldnr);
         }
       }
-
     }
     else
       share->primary_key = MAX_KEY; // we do not have a primary key
@@ -1131,7 +1153,7 @@
     for (k= 0, ptr= share->field ; *ptr ; ptr++, k++)
     {
       if ((*ptr)->flags & BLOB_FLAG)
-	(*save++)= k;
+        (*save++)= k;
     }
   }
 
@@ -2770,11 +2792,11 @@
       key_part_info->offset= field->offset(table->record[0]);
       key_part_info->length= (uint16_t) field->key_length();
       key_part_info->type=   (uint8_t) field->key_type();
-      key_part_info->key_type =
+      key_part_info->key_type= 
 	((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
 	 (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
 	 (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
-	0 : FIELDFLAG_BINARY;
+	0 : 1;
       if (!using_unique_constraint)
       {
 	cur_group->buff=(char*) group_buff;
@@ -2857,14 +2879,13 @@
                                                 0,
                                                 (unsigned char*) 0,
                                                 (uint32_t) 0,
-                                                Field::NONE,
                                                 NULL,
                                                 table->s,
                                                 &my_charset_bin);
       if (!key_part_info->field)
         goto err;
       key_part_info->field->init(table);
-      key_part_info->key_type=FIELDFLAG_BINARY;
+      key_part_info->key_type= 1; /* binary comparison */
       key_part_info->type=    HA_KEYTYPE_BINARY;
       key_part_info++;
     }
@@ -2898,7 +2919,7 @@
 	((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
 	 (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
 	 (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
-	0 : FIELDFLAG_BINARY;
+	0 : 1;
     }
   }
 
@@ -2981,12 +3002,19 @@
   List_iterator_fast<CreateField> it(field_list);
   while ((cdef= it++))
   {
-    *field= make_field(share, NULL, 0, cdef->length,
-                       (unsigned char*) (f_maybe_null(cdef->pack_flag) ? "" : 0),
-                       f_maybe_null(cdef->pack_flag) ? 1 : 0,
-                       cdef->pack_flag, cdef->sql_type, cdef->charset,
+    *field= make_field(share,
+                       NULL,
+                       0,
+                       cdef->length,
+                       (cdef->flags & NOT_NULL_FLAG) ? false : true,
+                       (unsigned char *) ((cdef->flags & NOT_NULL_FLAG) ? 0 : ""),
+                       (cdef->flags & NOT_NULL_FLAG) ? 0 : 1,
+                       cdef->decimals,
+                       cdef->sql_type,
+                       cdef->charset,
                        cdef->unireg_check,
-                       cdef->interval, cdef->field_name);
+                       cdef->interval,
+                       cdef->field_name);
     if (!*field)
       goto error;
     (*field)->init(table);
@@ -3151,8 +3179,7 @@
       seg->start=    keyinfo->key_part[i].offset;
       if (key_field->flags & BLOB_FLAG)
       {
-	seg->type=
-	((keyinfo->key_part[i].key_type & FIELDFLAG_BINARY) ?
+	seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?
 	 HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
 	seg->bit_start= (uint8_t)(key_field->pack_length()
                                   - share->blob_ptr_size);

=== modified file 'drizzled/table_proto_write.cc'
--- drizzled/table_proto_write.cc	2009-09-16 20:58:28 +0000
+++ drizzled/table_proto_write.cc	2009-09-28 07:40:31 +0000
@@ -59,9 +59,7 @@
     attribute= table_proto->add_field();
     attribute->set_name(field_arg->field_name);
 
-    attribute->set_pack_flag(field_arg->pack_flag); /* TODO: MUST DIE */
-
-    if(f_maybe_null(field_arg->pack_flag))
+    if(! (field_arg->flags & NOT_NULL_FLAG))
     {
       message::Table::Field::FieldConstraints *constraints;
 
@@ -77,7 +75,37 @@
       attribute->set_type(message::Table::Field::INTEGER);
       break;
     case DRIZZLE_TYPE_DOUBLE:
-      attribute->set_type(message::Table::Field::DOUBLE);
+      {
+        attribute->set_type(drizzled::message::Table::Field::DOUBLE);
+
+        /* 
+         * For DOUBLE, we only add a specific scale and precision iff
+         * the fixed decimal point has been specified...
+         */
+        if (field_arg->decimals != NOT_FIXED_DEC)
+        {
+          drizzled::message::Table::Field::NumericFieldOptions *numeric_field_options;
+          
+          numeric_field_options= attribute->mutable_numeric_options();
+          /* 
+           * Precision and scale are specified like so:
+           *
+           * DOUBLE(P,S)
+           *
+           * From the CreateField, we get the "length", which is the *total* length
+           * of the double storage space, including the decimal point if there is a
+           * scale argument and a 1 byte length header.  We also get the "decimals", 
+           * which is actually the scale (the number of numbers stored after the decimal point)
+           *
+           * Therefore, PRECISION= LENGTH - 1 - (SCALE ? SCALE + 1 : 0)
+           */
+          if (field_arg->decimals)
+            numeric_field_options->set_precision(field_arg->length - 2); /* One for the decimal, one for the header */
+          else
+            numeric_field_options->set_precision(field_arg->length - 1); /* for the header */
+          numeric_field_options->set_scale(field_arg->decimals);
+        }
+      }
       break;
     case DRIZZLE_TYPE_NULL  :
       assert(1); /* Not a user definable type */

=== modified file 'plugin/innobase/handler/handler0alter.cc'
--- plugin/innobase/handler/handler0alter.cc	2009-06-08 19:10:56 +0000
+++ plugin/innobase/handler/handler0alter.cc	2009-09-28 07:40:31 +0000
@@ -520,8 +520,7 @@
 		new_primary = TRUE;
 
 		while (key_part--) {
-			if (key_info->key_part[key_part].key_type
-			    & FIELDFLAG_MAYBE_NULL) {
+			if (key_info->key_part[key_part].null_bit == 0) {
 				new_primary = FALSE;
 				break;
 			}