Merge lp:~jaypipes/drizzle/fix-enum-error-control into lp:~drizzle-trunk/drizzle/development

[Jay Pipes]

[Jay Pipes (jaypipes)]

Fixes error control on ENUM field type

=== modified file 'drizzled/error.cc'
--- drizzled/error.cc	2009-03-06 05:23:46 +0000
+++ drizzled/error.cc	2009-03-16 15:20:27 +0000
@@ -1412,6 +1412,8 @@
 N_("Received an out-of-range argument '%s' for function '%s'."),
 /* ER_INVALID_TIME_VALUE */
 N_("Received an invalid time value '%s'."),
+/* ER_INVALID_ENUM_VALUE */
+N_("Received an invalid enum value '%s'.")
 };
 
 const char * error_message(unsigned int code)

=== modified file 'drizzled/error.h'
--- drizzled/error.h	2009-02-11 02:30:38 +0000
+++ drizzled/error.h	2009-03-16 15:20:27 +0000
@@ -720,7 +720,8 @@
   ER_INVALID_NEGATIVE_ARGUMENT,
   ER_ARGUMENT_OUT_OF_RANGE,
   ER_INVALID_TIME_VALUE,
-  ER_ERROR_LAST= ER_INVALID_TIME_VALUE
+  ER_INVALID_ENUM_VALUE,
+  ER_ERROR_LAST= ER_INVALID_ENUM_VALUE
 };
 
 #ifdef  __cplusplus

=== modified file 'drizzled/field/enum.cc'
--- drizzled/field/enum.cc	2009-02-21 00:18:15 +0000
+++ drizzled/field/enum.cc	2009-03-16 15:20:27 +0000
@@ -19,11 +19,14 @@
  */
 
 
-#include <drizzled/server_includes.h>
-#include <drizzled/field/enum.h>
-#include <drizzled/error.h>
-#include <drizzled/table.h>
-#include <drizzled/session.h>
+#include "drizzled/server_includes.h"
+#include "drizzled/field/enum.h"
+#include "drizzled/error.h"
+#include "drizzled/table.h"
+#include "drizzled/session.h"
+
+#include <sstream>
+#include <string>
 
 /****************************************************************************
 ** enum type.
@@ -33,12 +36,13 @@
 
 enum ha_base_keytype Field_enum::key_type() const
 {
-  switch (packlength) {
-  default: return HA_KEYTYPE_BINARY;
-  case 2: assert(1);
-  case 3: assert(1);
-  case 4: return HA_KEYTYPE_ULONG_INT;
-  case 8: return HA_KEYTYPE_ULONGLONG;
+  switch (packlength) 
+  {
+    default: return HA_KEYTYPE_BINARY;
+    case 2: assert(1);
+    case 3: assert(1);
+    case 4: return HA_KEYTYPE_ULONG_INT;
+    case 8: return HA_KEYTYPE_ULONGLONG;
   }
 }
 
@@ -79,85 +83,77 @@
   }
 }
 
-
 /**
-  @note
-    Storing a empty string in a enum field gives a warning
-    (if there isn't a empty value in the enum)
-*/
-
-int Field_enum::store(const char *from, uint32_t length, const CHARSET_INFO * const cs)
+ * Given a supplied string, looks up the string in the internal typelib
+ * and stores the found key.  Upon not finding an entry in the typelib, 
+ * we always throw an error.
+ */
+int Field_enum::store(const char *from, uint32_t length, const CHARSET_INFO * const)
 {
-  int err= 0;
-  uint32_t not_used;
-  char buff[STRING_BUFFER_USUAL_SIZE];
-  String tmpstr(buff,sizeof(buff), &my_charset_bin);
-
-  /* Convert character set if necessary */
-  if (String::needs_conversion(length, cs, field_charset, &not_used))
-  {
-    uint32_t dummy_errors;
-    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
-    from= tmpstr.ptr();
-    length=  tmpstr.length();
-  }
+  uint32_t tmp;
 
   /* Remove end space */
   length= field_charset->cset->lengthsp(field_charset, from, length);
-  uint32_t tmp=find_type2(typelib, from, length, field_charset);
-  if (!tmp)
+  tmp= find_type2(typelib, from, length, field_charset);
+  if (! tmp)
   {
-    if (length < 6) // Can't be more than 99999 enums
+    if (length < 6) /* Can't be more than 99999 enums */
     {
       /* This is for reading numbers with LOAD DATA INFILE */
-      char *end;
-      tmp=(uint32_t) my_strntoul(cs,from,length,10,&end,&err);
-      if (err || end != from+length || tmp > typelib->count)
+      /* Convert the string to an integer using stringstream */
+      std::stringstream ss;
+      ss << from;
+      ss >> tmp;
+
+      if (tmp == 0 || tmp > typelib->count)
       {
-	tmp=0;
-	set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
+        my_error(ER_INVALID_ENUM_VALUE, MYF(ME_FATALERROR), from);
+        return 1;
       }
-      if (!table->in_use->count_cuted_fields)
-        err= 0;
     }
     else
-      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
+    {
+      my_error(ER_INVALID_ENUM_VALUE, MYF(ME_FATALERROR), from);
+      return 1;
+    }
   }
   store_type((uint64_t) tmp);
-  return err;
-}
-
-
-int Field_enum::store(double nr)
-{
-  return Field_enum::store((int64_t) nr, false);
-}
-
-
-int Field_enum::store(int64_t nr,
-                      bool )
-{
-  int error= 0;
-  if ((uint64_t) nr > typelib->count || nr == 0)
+  return 0;
+}
+
+int Field_enum::store(double from)
+{
+  return Field_enum::store((int64_t) from, false);
+}
+
+/**
+ * @note MySQL allows 0 values, saying that 0 is "the index of the
+ * blank string error", whatever that means.  Uhm, Drizzle doesn't
+ * allow this.  To store an ENUM column value using an integer, you
+ * must specify the 1-based index of the enum column definition's 
+ * key.
+ */
+int Field_enum::store(int64_t from, bool)
+{
+  if (from <= 0 || (uint64_t) from > typelib->count)
   {
-    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
-    if (nr != 0 || table->in_use->count_cuted_fields)
-    {
-      nr= 0;
-      error= 1;
-    }
+    /* Convert the integer to a string using stringstream */
+    std::stringstream ss;
+    std::string tmp;
+    ss << from; ss >> tmp;
+
+    my_error(ER_INVALID_ENUM_VALUE, MYF(ME_FATALERROR), tmp.c_str());
+    return 1;
   }
-  store_type((uint64_t) (uint32_t) nr);
-  return error;
+  store_type((uint64_t) (uint32_t) from);
+  return 0;
 }
 
-
 double Field_enum::val_real(void)
 {
   return (double) Field_enum::val_int();
 }
 
-
 int64_t Field_enum::val_int(void)
 {
   switch (packlength) {
@@ -202,7 +198,6 @@
   return 0;					// impossible
 }
 
-
 /**
    Save the field metadata for enum fields.
 
@@ -221,9 +216,7 @@
   return 2;
 }
 
-
-String *Field_enum::val_str(String *,
-			    String *val_ptr)
+String *Field_enum::val_str(String *, String *val_ptr)
 {
   uint32_t tmp=(uint32_t) Field_enum::val_int();
   if (!tmp || tmp > typelib->count)
@@ -257,7 +250,6 @@
   }
 }
 
-
 void Field_enum::sql_type(String &res) const
 {
   char buffer[255];
@@ -281,7 +273,6 @@
   res.append(')');
 }
 
-
 Field *Field_enum::new_field(MEM_ROOT *root, Table *new_table,
                              bool keep_type)
 {

=== modified file 'drizzled/field/enum.h'
--- drizzled/field/enum.h	2009-02-20 08:45:29 +0000
+++ drizzled/field/enum.h	2009-03-16 15:20:27 +0000
@@ -18,12 +18,13 @@
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#ifndef DRIZZLE_SERVER_FIELD_ENUM
-#define DRIZZLE_SERVER_FIELD_ENUM
-
-#include <drizzled/field/str.h>
-
-class Field_enum :public Field_str {
+#ifndef DRIZZLED_FIELD_ENUM_H
+#define DRIZZLED_FIELD_ENUM_H
+
+#include "drizzled/field/str.h"
+
+class Field_enum :public Field_str 
+{
 protected:
   uint32_t packlength;
 public:
@@ -33,6 +34,7 @@
   using Field::val_str;
   using Field::cmp;
 
+  /** 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,
              unsigned char null_bit_arg,
@@ -47,35 +49,66 @@
       flags|=ENUM_FLAG;
   }
   Field *new_field(MEM_ROOT *root, Table *new_table, bool keep_type);
-  enum_field_types type() const { return DRIZZLE_TYPE_ENUM; }
-  enum Item_result cmp_type () const { return INT_RESULT; }
-  enum Item_result cast_to_int_type () const { return INT_RESULT; }
   enum ha_base_keytype key_type() const;
-  int  store(const char *to,uint32_t length, const CHARSET_INFO * const charset);
+  int  store(const char *to, uint32_t length, const CHARSET_INFO * const);
   int  store(double nr);
   int  store(int64_t nr, bool unsigned_val);
   double val_real(void);
   int64_t val_int(void);
-  String *val_str(String*,String *);
-  int cmp(const unsigned char *,const unsigned char *);
-  void sort_string(unsigned char *buff,uint32_t length);
-  uint32_t pack_length() const { return (uint32_t) packlength; }
+  String *val_str(String*, String *);
+  int cmp(const unsigned char *, const unsigned char *);
+  void sort_string(unsigned char *buff, uint32_t length);
   void store_type(uint64_t value);
   void sql_type(String &str) const;
-  uint32_t size_of() const { return sizeof(*this); }
-  enum_field_types real_type() const { return DRIZZLE_TYPE_ENUM; }
+  bool eq_def(Field *field);
+  enum_field_types type() const
+  {
+    return DRIZZLE_TYPE_ENUM;
+  }
+  enum Item_result cmp_type () const
+  {
+    return INT_RESULT;
+  }
+  enum Item_result cast_to_int_type () const
+  {
+    return INT_RESULT;
+  }
+  uint32_t pack_length() const
+  {
+    return (uint32_t) packlength;
+  }
+  uint32_t size_of() const
+  {
+    return sizeof(*this);
+  }
+  enum_field_types real_type() const
+  {
+    return DRIZZLE_TYPE_ENUM;
+  }
   uint32_t pack_length_from_metadata(uint32_t field_metadata)
-  { return (field_metadata & 0x00ff); }
-  uint32_t row_pack_length() { return pack_length(); }
-  virtual bool zero_pack() const { return 0; }
-  bool optimize_range(uint32_t, uint32_t)
-  { return 0; }
-  bool eq_def(Field *field);
-  bool has_charset(void) const { return true; }
+  {
+    return (field_metadata & 0x00ff);
+  }
+  uint32_t row_pack_length()
+  { 
+    return pack_length();
+  }
+  virtual bool zero_pack() const
+  {
+    return false;
+  }
+  bool optimize_range(uint32_t, uint32_t) 
+  {
+    return false;
+  }
+  bool has_charset(void) const
+  {
+    return true;
+  }
   /* enum and set are sorted as integers */
   const CHARSET_INFO *sort_charset(void) const { return &my_charset_bin; }
 private:
   int do_save_field_metadata(unsigned char *first_byte);
 };
 
-#endif
+#endif /* DRIZZLED_FIELD_ENUM_H */

=== modified file 'drizzled/sql_select.cc'
--- drizzled/sql_select.cc	2009-03-11 19:04:31 +0000
+++ drizzled/sql_select.cc	2009-03-16 15:20:27 +0000
@@ -2030,8 +2030,7 @@
   @todo
     When can we have here session->net.report_error not zero?
 */
-void
-JOIN::exec()
+void JOIN::exec()
 {
   List<Item> *columns_list= &fields_list;
   int      tmp_error;
@@ -2043,12 +2042,10 @@
   {                                           
     /* Only test of functions */
     if (select_options & SELECT_DESCRIBE)
-      select_describe(this, false, false, false,
-		      (zero_result_cause?zero_result_cause:"No tables used"));
+      select_describe(this, false, false, false, (zero_result_cause?zero_result_cause:"No tables used"));
     else
     {
-      result->send_fields(*columns_list,
-                          Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
+      result->send_fields(*columns_list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
       /*
         We have to test for 'conds' here as the WHERE may not be constant
         even if we don't have any tables for prepared statements or if
@@ -2096,8 +2093,7 @@
     return;
   }
 
-  if ((this->select_lex->options & OPTION_SCHEMA_TABLE) &&
-      get_schema_tables_result(this, PROCESSED_BY_JOIN_EXEC))
+  if ((this->select_lex->options & OPTION_SCHEMA_TABLE) && get_schema_tables_result(this, PROCESSED_BY_JOIN_EXEC))
     return;
 
   if (select_options & SELECT_DESCRIBE)
@@ -2109,28 +2105,20 @@
     */
     if (!order && !no_order && (!skip_sort_order || !need_tmp))
     {
-      /*
-	Reset 'order' to 'group_list' and reinit variables describing
-	'order'
-      */
+      /* Reset 'order' to 'group_list' and reinit variables describing 'order' */
       order= group_list;
       simple_order= simple_group;
       skip_sort_order= 0;
     }
-    if (order &&
-        (order != group_list || !(select_options & SELECT_BIG_RESULT)) &&
-	(const_tables == tables ||
- 	 ((simple_order || skip_sort_order) &&
-	  test_if_skip_sort_order(&join_tab[const_tables], order,
-				  select_limit, 0,
-                                  &join_tab[const_tables].table->
-                                    keys_in_use_for_query))))
-      order=0;
+    if (order && (order != group_list || !(select_options & SELECT_BIG_RESULT)))
+    {
+      if (const_tables == tables 
+        || ((simple_order || skip_sort_order) 
+          && test_if_skip_sort_order(&join_tab[const_tables], order, select_limit, 0, &join_tab[const_tables].table->keys_in_use_for_query)))
+      order= 0;
+    }
     having= tmp_having;
-    select_describe(this, need_tmp,
-		    order != 0 && !skip_sort_order,
-		    select_distinct,
-                    !tables ? "No tables used" : NULL);
+    select_describe(this, need_tmp, order != 0 && !skip_sort_order,  select_distinct, !tables ? "No tables used" : NULL);
     return;
   }
 
@@ -2162,8 +2150,7 @@
 
     /* Copy data to the temporary table */
     session->set_proc_info("Copying to tmp table");
-    if (!curr_join->sort_and_group &&
-        curr_join->const_tables != curr_join->tables)
+    if (! curr_join->sort_and_group && curr_join->const_tables != curr_join->tables)
       curr_join->join_tab[curr_join->const_tables].sorted= 0;
     if ((tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
     {
@@ -2182,17 +2169,17 @@
       items1= items0 + all_fields.elements;
       if (sort_and_group || curr_tmp_table->group)
       {
-	if (change_to_use_tmp_fields(session, items1,
-				     tmp_fields_list1, tmp_all_fields1,
-				     fields_list.elements, all_fields))
-	  return;
+        if (change_to_use_tmp_fields(session, items1,
+                  tmp_fields_list1, tmp_all_fields1,
+                  fields_list.elements, all_fields))
+          return;
       }
       else
       {
-	if (change_refs_to_tmp_fields(session, items1,
-				      tmp_fields_list1, tmp_all_fields1,
-				      fields_list.elements, all_fields))
-	  return;
+        if (change_refs_to_tmp_fields(session, items1,
+                    tmp_fields_list1, tmp_all_fields1,
+                    fields_list.elements, all_fields))
+          return;
       }
       curr_join->tmp_all_fields1= tmp_all_fields1;
       curr_join->tmp_fields_list1= tmp_fields_list1;
@@ -2204,23 +2191,21 @@
 
     if (sort_and_group || curr_tmp_table->group)
     {
-      curr_join->tmp_table_param.field_count+=
-	curr_join->tmp_table_param.sum_func_count+
-	curr_join->tmp_table_param.func_count;
-      curr_join->tmp_table_param.sum_func_count=
-	curr_join->tmp_table_param.func_count= 0;
+      curr_join->tmp_table_param.field_count+= curr_join->tmp_table_param.sum_func_count
+                                             + curr_join->tmp_table_param.func_count;
+      curr_join->tmp_table_param.sum_func_count= 0;
+      curr_join->tmp_table_param.func_count= 0;
     }
     else
     {
-      curr_join->tmp_table_param.field_count+=
-	curr_join->tmp_table_param.func_count;
+      curr_join->tmp_table_param.field_count+= curr_join->tmp_table_param.func_count;
       curr_join->tmp_table_param.func_count= 0;
     }
 
     if (curr_tmp_table->group)
     {						// Already grouped
       if (!curr_join->order && !curr_join->no_order && !skip_sort_order)
-	curr_join->order= curr_join->group_list;  /* order by group */
+        curr_join->order= curr_join->group_list;  /* order by group */
       curr_join->group_list= 0;
     }
 
@@ -2232,26 +2217,25 @@
       like SEC_TO_TIME(SUM(...)).
     */
 
-    if ((curr_join->group_list && (!test_if_subpart(curr_join->group_list, curr_join->order) || curr_join->select_distinct)) || (curr_join->select_distinct && curr_join->tmp_table_param.using_indirect_summary_function))
+    if ((curr_join->group_list && (!test_if_subpart(curr_join->group_list, curr_join->order) || curr_join->select_distinct)) 
+        || (curr_join->select_distinct && curr_join->tmp_table_param.using_indirect_summary_function))
     {					/* Must copy to another table */
       /* Free first data from old join */
       curr_join->join_free();
       if (make_simple_join(curr_join, curr_tmp_table))
-	return;
+      	return;
       calc_group_buffer(curr_join, group_list);
       count_field_types(select_lex, &curr_join->tmp_table_param,
 			curr_join->tmp_all_fields1,
 			curr_join->select_distinct && !curr_join->group_list);
-      curr_join->tmp_table_param.hidden_field_count=
-	(curr_join->tmp_all_fields1.elements-
-	 curr_join->tmp_fields_list1.elements);
-
+      curr_join->tmp_table_param.hidden_field_count= curr_join->tmp_all_fields1.elements
+                                                   - curr_join->tmp_fields_list1.elements;
 
       if (exec_tmp_table2)
-	curr_tmp_table= exec_tmp_table2;
+        curr_tmp_table= exec_tmp_table2;
       else
       {
-	/* group data to new table */
+        /* group data to new table */
 
         /*
           If the access method is loose index scan then all MIN/MAX
@@ -2261,32 +2245,32 @@
         if (curr_join->join_tab->is_using_loose_index_scan())
           curr_join->tmp_table_param.precomputed_group_by= true;
 
-	if (!(curr_tmp_table=
-	      exec_tmp_table2= create_tmp_table(session,
-						&curr_join->tmp_table_param,
-						*curr_all_fields,
-						(order_st*) 0,
-						curr_join->select_distinct &&
-						!curr_join->group_list,
-						1, curr_join->select_options,
-						HA_POS_ERROR,
-						(char *) "")))
-	  return;
-	curr_join->exec_tmp_table2= exec_tmp_table2;
+        if (!(curr_tmp_table=
+              exec_tmp_table2= create_tmp_table(session,
+                                                &curr_join->tmp_table_param,
+                                                *curr_all_fields,
+                                                (order_st*) 0,
+                                                curr_join->select_distinct &&
+                                                !curr_join->group_list,
+                                                1, curr_join->select_options,
+                                                HA_POS_ERROR,
+                                                (char *) "")))
+          return;
+        curr_join->exec_tmp_table2= exec_tmp_table2;
       }
       if (curr_join->group_list)
       {
-	session->set_proc_info("Creating sort index");
-	if (curr_join->join_tab == join_tab && save_join_tab())
-	{
-	  return;
-	}
-	if (create_sort_index(session, curr_join, curr_join->group_list,
-			      HA_POS_ERROR, HA_POS_ERROR, false) ||
-	    make_group_fields(this, curr_join))
-	{
-	  return;
-	}
+        session->set_proc_info("Creating sort index");
+        if (curr_join->join_tab == join_tab && save_join_tab())
+        {
+          return;
+        }
+        if (create_sort_index(session, curr_join, curr_join->group_list,
+                  HA_POS_ERROR, HA_POS_ERROR, false) ||
+            make_group_fields(this, curr_join))
+        {
+          return;
+        }
         sortorder= curr_join->sortorder;
       }
 
@@ -2294,30 +2278,30 @@
       tmp_error= -1;
       if (curr_join != this)
       {
-	if (sum_funcs2)
-	{
-	  curr_join->sum_funcs= sum_funcs2;
-	  curr_join->sum_funcs_end= sum_funcs_end2;
-	}
-	else
-	{
-	  curr_join->alloc_func_list();
-	  sum_funcs2= curr_join->sum_funcs;
-	  sum_funcs_end2= curr_join->sum_funcs_end;
-	}
+        if (sum_funcs2)
+        {
+          curr_join->sum_funcs= sum_funcs2;
+          curr_join->sum_funcs_end= sum_funcs_end2;
+        }
+        else
+        {
+          curr_join->alloc_func_list();
+          sum_funcs2= curr_join->sum_funcs;
+          sum_funcs_end2= curr_join->sum_funcs_end;
+        }
       }
-      if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,
-					1, true))
+      if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list, 1, true))
         return;
       curr_join->group_list= 0;
-      if (!curr_join->sort_and_group &&
-          curr_join->const_tables != curr_join->tables)
+
+      if (!curr_join->sort_and_group && (curr_join->const_tables != curr_join->tables))
         curr_join->join_tab[curr_join->const_tables].sorted= 0;
-      if (setup_sum_funcs(curr_join->session, curr_join->sum_funcs) ||
-	  (tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
+      
+      if (setup_sum_funcs(curr_join->session, curr_join->sum_funcs) 
+        || (tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
       {
-	error= tmp_error;
-	return;
+        error= tmp_error;
+        return;
       }
       end_read_record(&curr_join->join_tab->read_record);
       curr_join->const_tables= curr_join->tables; // Mark free for cleanup()
@@ -2326,19 +2310,18 @@
       // No sum funcs anymore
       if (!items2)
       {
-	items2= items1 + all_fields.elements;
-	if (change_to_use_tmp_fields(session, items2,
-				     tmp_fields_list2, tmp_all_fields2,
-				     fields_list.elements, tmp_all_fields1))
-	  return;
-	curr_join->tmp_fields_list2= tmp_fields_list2;
-	curr_join->tmp_all_fields2= tmp_all_fields2;
+        items2= items1 + all_fields.elements;
+        if (change_to_use_tmp_fields(session, items2,
+                  tmp_fields_list2, tmp_all_fields2,
+                  fields_list.elements, tmp_all_fields1))
+          return;
+        curr_join->tmp_fields_list2= tmp_fields_list2;
+        curr_join->tmp_all_fields2= tmp_all_fields2;
       }
       curr_fields_list= &curr_join->tmp_fields_list2;
       curr_all_fields= &curr_join->tmp_all_fields2;
       curr_join->set_items_ref_array(items2);
-      curr_join->tmp_table_param.field_count+=
-	curr_join->tmp_table_param.sum_func_count;
+      curr_join->tmp_table_param.field_count+= curr_join->tmp_table_param.sum_func_count;
       curr_join->tmp_table_param.sum_func_count= 0;
     }
     if (curr_tmp_table->distinct)
@@ -2349,10 +2332,12 @@
     {
       session->set_proc_info("Removing duplicates");
       if (curr_join->tmp_having)
-	curr_join->tmp_having->update_used_tables();
+        curr_join->tmp_having->update_used_tables();
+
       if (remove_duplicates(curr_join, curr_tmp_table,
 			    *curr_fields_list, curr_join->tmp_having))
-	return;
+      	return;
+      
       curr_join->tmp_having=0;
       curr_join->select_distinct=0;
     }
@@ -2360,29 +2345,26 @@
     if (make_simple_join(curr_join, curr_tmp_table))
       return;
     calc_group_buffer(curr_join, curr_join->group_list);
-    count_field_types(select_lex, &curr_join->tmp_table_param,
-                      *curr_all_fields, 0);
+    count_field_types(select_lex, &curr_join->tmp_table_param, *curr_all_fields, 0);
 
   }
 
   if (curr_join->group || curr_join->tmp_table_param.sum_func_count)
   {
     if (make_group_fields(this, curr_join))
-    {
       return;
-    }
-    if (!items3)
+
+    if (! items3)
     {
-      if (!items0)
-	init_items_ref_array();
+      if (! items0)
+        init_items_ref_array();
       items3= ref_pointer_array + (all_fields.elements*4);
       setup_copy_fields(session, &curr_join->tmp_table_param,
 			items3, tmp_fields_list3, tmp_all_fields3,
 			curr_fields_list->elements, *curr_all_fields);
       tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;
       tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;
-      tmp_table_param.save_copy_field_end=
-	curr_join->tmp_table_param.copy_field_end;
+      tmp_table_param.save_copy_field_end= curr_join->tmp_table_param.copy_field_end;
       curr_join->tmp_all_fields3= tmp_all_fields3;
       curr_join->tmp_fields_list3= tmp_fields_list3;
     }
@@ -2390,8 +2372,7 @@
     {
       curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;
       curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;
-      curr_join->tmp_table_param.copy_field_end=
-	tmp_table_param.save_copy_field_end;
+      curr_join->tmp_table_param.copy_field_end= tmp_table_param.save_copy_field_end;
     }
     curr_fields_list= &tmp_fields_list3;
     curr_all_fields= &tmp_all_fields3;
@@ -2407,8 +2388,7 @@
   {
     session->set_proc_info("Sorting result");
     /* If we have already done the group, add HAVING to sorted table */
-    if (curr_join->tmp_having && ! curr_join->group_list &&
-	! curr_join->sort_and_group)
+    if (curr_join->tmp_having && ! curr_join->group_list &&	! curr_join->sort_and_group)
     {
       // Some tables may have been const
       curr_join->tmp_having->update_used_tables();
@@ -2416,73 +2396,69 @@
       table_map used_tables= (curr_join->const_table_map |
 			      curr_table->table->map);
 
-      Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,
-						 used_tables,
-						 used_tables, 0);
+      Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having, used_tables, used_tables, 0);
       if (sort_table_cond)
       {
-	if (!curr_table->select)
-	  if (!(curr_table->select= new SQL_SELECT))
-	    return;
-	if (!curr_table->select->cond)
-	  curr_table->select->cond= sort_table_cond;
-	else					// This should never happen
-	{
-	  if (!(curr_table->select->cond=
-		new Item_cond_and(curr_table->select->cond,
-				  sort_table_cond)))
-	    return;
-	  /*
-	    Item_cond_and do not need fix_fields for execution, its parameters
-	    are fixed or do not need fix_fields, too
-	  */
-	  curr_table->select->cond->quick_fix_field();
-	}
-	curr_table->select_cond= curr_table->select->cond;
-	curr_table->select_cond->top_level_item();
-	curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having,
-						   ~ (table_map) 0,
-						   ~used_tables, 0);
+        if (!curr_table->select)
+          if (!(curr_table->select= new SQL_SELECT))
+            return;
+        if (!curr_table->select->cond)
+          curr_table->select->cond= sort_table_cond;
+        else					// This should never happen
+        {
+          if (!(curr_table->select->cond=
+          new Item_cond_and(curr_table->select->cond,
+                sort_table_cond)))
+            return;
+          /*
+            Item_cond_and do not need fix_fields for execution, its parameters
+            are fixed or do not need fix_fields, too
+          */
+          curr_table->select->cond->quick_fix_field();
+        }
+        curr_table->select_cond= curr_table->select->cond;
+        curr_table->select_cond->top_level_item();
+        curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having,
+                    ~ (table_map) 0,
+                    ~used_tables, 0);
       }
     }
     {
       if (group)
-	curr_join->select_limit= HA_POS_ERROR;
+        curr_join->select_limit= HA_POS_ERROR;
       else
       {
-	/*
-	  We can abort sorting after session->select_limit rows if we there is no
-	  WHERE clause for any tables after the sorted one.
-	*/
-	JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables+1];
-	JOIN_TAB *end_table= &curr_join->join_tab[curr_join->tables];
-	for (; curr_table < end_table ; curr_table++)
-	{
-	  /*
-	    table->keyuse is set in the case there was an original WHERE clause
-	    on the table that was optimized away.
-	  */
-	  if (curr_table->select_cond ||
-	      (curr_table->keyuse && !curr_table->first_inner))
-	  {
-	    /* We have to sort all rows */
-	    curr_join->select_limit= HA_POS_ERROR;
-	    break;
-	  }
-	}
+        /*
+          We can abort sorting after session->select_limit rows if we there is no
+          WHERE clause for any tables after the sorted one.
+        */
+        JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables+1];
+        JOIN_TAB *end_table= &curr_join->join_tab[curr_join->tables];
+        for (; curr_table < end_table ; curr_table++)
+        {
+          /*
+            table->keyuse is set in the case there was an original WHERE clause
+            on the table that was optimized away.
+          */
+          if (curr_table->select_cond ||
+              (curr_table->keyuse && !curr_table->first_inner))
+          {
+            /* We have to sort all rows */
+            curr_join->select_limit= HA_POS_ERROR;
+            break;
+          }
+        }
       }
       if (curr_join->join_tab == join_tab && save_join_tab())
-      {
-	return;
-      }
+        return;
       /*
-	Here we sort rows for order_st BY/GROUP BY clause, if the optimiser
-	chose FILESORT to be faster than INDEX SCAN or there is no
-	suitable index present.
-	Note, that create_sort_index calls test_if_skip_sort_order and may
-	finally replace sorting with index scan if there is a LIMIT clause in
-	the query. XXX: it's never shown in EXPLAIN!
-	OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.
+        Here we sort rows for order_st BY/GROUP BY clause, if the optimiser
+        chose FILESORT to be faster than INDEX SCAN or there is no
+        suitable index present.
+        Note, that create_sort_index calls test_if_skip_sort_order and may
+        finally replace sorting with index scan if there is a LIMIT clause in
+        the query. XXX: it's never shown in EXPLAIN!
+        OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.
       */
       if (create_sort_index(session, curr_join,
 			    curr_join->group_list ?
@@ -2491,7 +2467,8 @@
 			    (select_options & OPTION_FOUND_ROWS ?
 			     HA_POS_ERROR : unit->select_limit_cnt),
                             curr_join->group_list ? true : false))
-	return;
+        return;
+
       sortorder= curr_join->sortorder;
       if (curr_join->const_tables != curr_join->tables &&
           !curr_join->join_tab[curr_join->const_tables].table->sort.io_cache)
@@ -2514,13 +2491,11 @@
   curr_join->having= curr_join->tmp_having;
   curr_join->fields= curr_fields_list;
 
-  {
-    session->set_proc_info("Sending data");
-    result->send_fields(*curr_fields_list,
-                        Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
-    error= do_select(curr_join, curr_fields_list, NULL);
-    session->limit_found_rows= curr_join->send_records;
-  }
+  session->set_proc_info("Sending data");
+  result->send_fields(*curr_fields_list,
+                      Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
+  error= do_select(curr_join, curr_fields_list, NULL);
+  session->limit_found_rows= curr_join->send_records;
 
   /* Accumulate the counts from all join iterations of all join parts. */
   session->examined_row_count+= curr_join->examined_rows;
@@ -2530,24 +2505,19 @@
     for a derived table which is always materialized.
     Otherwise we would not be able to print the query  correctly.
   */
-  if (items0 &&
-      (session->lex->describe & DESCRIBE_EXTENDED) &&
-      select_lex->linkage == DERIVED_TABLE_TYPE)
+  if (items0 && (session->lex->describe & DESCRIBE_EXTENDED) && select_lex->linkage == DERIVED_TABLE_TYPE)
     set_items_ref_array(items0);
 
   return;
 }
 
-
 /**
   Clean up join.
 
   @return
     Return error that hold JOIN.
 */
-
-int
-JOIN::destroy()
+int JOIN::destroy()
 {
   select_lex->join= 0;
 
@@ -2557,7 +2527,7 @@
     {
       JOIN_TAB *tab, *end;
       for (tab= join_tab, end= tab+tables ; tab != end ; tab++)
-	tab->cleanup();
+        tab->cleanup();
     }
     tmp_join->tmp_join= 0;
     tmp_table_param.copy_field=0;
@@ -2575,8 +2545,6 @@
   return(error);
 }
 
-
-
 /**
   An entry point to single-unit select (a select without UNION).
 
@@ -3162,7 +3130,6 @@
   return(false);
 }
 
-
 /**
   Setup for execution all subqueries of a query, for which the optimizer
   chose hash semi-join.
@@ -3185,7 +3152,6 @@
   @retval false     success.
   @retval true      error occurred.
 */
-
 bool JOIN::setup_subquery_materialization()
 {
   for (Select_Lex_Unit *un= select_lex->first_inner_unit(); un;
@@ -3812,28 +3778,28 @@
       select->quick=0;
       if (records == 0 && s->table->reginfo.impossible_range)
       {
-	/*
-	  Impossible WHERE or ON expression
-	  In case of ON, we mark that the we match one empty NULL row.
-	  In case of WHERE, don't set found_const_table_map to get the
-	  caller to abort with a zero row result.
-	*/
-	join->const_table_map|= s->table->map;
-	set_position(join,const_count++,s,(KEYUSE*) 0);
-	s->type= JT_CONST;
-	if (*s->on_expr_ref)
-	{
-	  /* Generate empty row */
-	  s->info= "Impossible ON condition";
-	  found_const_table_map|= s->table->map;
-	  s->type= JT_CONST;
-	  mark_as_null_row(s->table);		// All fields are NULL
-	}
+        /*
+          Impossible WHERE or ON expression
+          In case of ON, we mark that the we match one empty NULL row.
+          In case of WHERE, don't set found_const_table_map to get the
+          caller to abort with a zero row result.
+        */
+        join->const_table_map|= s->table->map;
+        set_position(join,const_count++,s,(KEYUSE*) 0);
+        s->type= JT_CONST;
+        if (*s->on_expr_ref)
+        {
+          /* Generate empty row */
+          s->info= "Impossible ON condition";
+          found_const_table_map|= s->table->map;
+          s->type= JT_CONST;
+          mark_as_null_row(s->table);		// All fields are NULL
+        }
       }
       if (records != HA_POS_ERROR)
       {
-	s->found_records=records;
-	s->read_time= (ha_rows) (s->quick ? s->quick->read_time : 0.0);
+        s->found_records=records;
+        s->read_time= (ha_rows) (s->quick ? s->quick->read_time : 0.0);
       }
       delete select;
     }

=== modified file 'tests/r/strict.result'
--- tests/r/strict.result	2009-02-28 18:17:29 +0000
+++ tests/r/strict.result	2009-03-16 15:20:27 +0000
@@ -239,25 +239,22 @@
 CREATE TABLE t1 (col1 enum('red','blue','green'));
 INSERT INTO t1 VALUES ('red'),('blue'),('green');
 INSERT INTO t1 (col1) VALUES ('yellow');
-ERROR 01000: Data truncated for column 'col1' at row 1
+ERROR HY000: Received an invalid enum value 'yellow'.
 INSERT INTO t1 (col1) VALUES ('redd');
-ERROR 01000: Data truncated for column 'col1' at row 1
+ERROR HY000: Received an invalid enum value 'redd'.
 INSERT INTO t1 VALUES ('');
-ERROR 01000: Data truncated for column 'col1' at row 1
+ERROR HY000: Received an invalid enum value ''.
 UPDATE t1 SET col1 ='yellow' WHERE col1 ='green';
-ERROR 01000: Data truncated for column 'col1' at row 3
+ERROR HY000: Received an invalid enum value 'yellow'.
 INSERT IGNORE INTO t1 VALUES ('yellow');
-Warnings:
-Warning	1265	Data truncated for column 'col1' at row 1
+ERROR HY000: Received an invalid enum value 'yellow'.
 UPDATE IGNORE t1 SET col1 ='yellow' WHERE col1 ='blue';
-Warnings:
-Warning	1265	Data truncated for column 'col1' at row 2
+ERROR HY000: Received an invalid enum value 'yellow'.
 SELECT * FROM t1;
 col1
 red
-
+blue
 green
-
 DROP TABLE t1;
 CREATE TABLE t1 (col1 INT NOT NULL, col2 CHAR(5) NOT NULL, col3 DATE NOT NULL);
 INSERT INTO t1 VALUES (100, 'hello', '2004-08-20');

=== modified file 'tests/r/type_enum.result'
--- tests/r/type_enum.result	2009-03-03 21:05:10 +0000
+++ tests/r/type_enum.result	2009-03-16 15:20:27 +0000
@@ -1638,7 +1638,7 @@
 drop table t1;
 create table t1 (a enum ('0','1'));
 insert into t1 set a='foobar';
-ERROR 01000: Data truncated for column 'a' at row 1
+ERROR HY000: Received an invalid enum value 'foobar'.
 select * from t1;
 a
 update t1 set a = replace(a,'x','y');
@@ -1723,34 +1723,34 @@
 c1 ENUM('a', '', 'b')
 );
 INSERT INTO t1 (c1) VALUES (0), ('a'), (''), ('b');
-ERROR 01000: Data truncated for column 'c1' at row 1
+ERROR HY000: Received an invalid enum value '0'.
 INSERT INTO t1 (c1) VALUES (0), ('a'), (''), ('b');
-ERROR 01000: Data truncated for column 'c1' at row 1
+ERROR HY000: Received an invalid enum value '0'.
 INSERT INTO t1 (c1) VALUES ('a'), ('b');
 SELECT id, c1 + 0, c1 FROM t1;
 id	c1 + 0	c1
 1	1	a
 2	3	b
 ALTER TABLE t1 CHANGE c1 c1 ENUM('a', '') NOT NULL;
-ERROR 01000: Data truncated for column 'c1' at row 2
+ERROR HY000: Received an invalid enum value 'b'.
 ALTER TABLE t1 CHANGE c1 c1 ENUM('a', 'b') NOT NULL;
 SELECT id, c1 + 0, c1 FROM t1;
 id	c1 + 0	c1
 1	1	a
-2	2	b
+2	1	a
 DROP TABLE t1;
 End of 4.1 tests
 create table t1(f1 enum('a','b'), index(f1));
 insert into t1 values(''),(''),('a'),('b');
-ERROR 01000: Data truncated for column 'f1' at row 1
+ERROR HY000: Received an invalid enum value ''.
 select * from t1 where f1='';
-f1
+ERROR HY000: Received an invalid enum value ''.
 drop table t1;
 CREATE TABLE t1 (c1 ENUM('a', '', 'b'));
 INSERT INTO t1 (c1) VALUES ('b');
 INSERT INTO t1 (c1) VALUES ('');
 INSERT INTO t1 (c1) VALUES (0);
-ERROR 01000: Data truncated for column 'c1' at row 1
+ERROR HY000: Received an invalid enum value '0'.
 INSERT INTO t1 (c1) VALUES ('a');
 SELECT c1 + 0, COUNT(c1) FROM t1 GROUP BY c1;
 c1 + 0	COUNT(c1)
@@ -1766,7 +1766,7 @@
 DROP TABLE t1,t2;
 CREATE TABLE t1(a enum('a','b','c','d'));
 INSERT INTO t1 VALUES (4),(1),(0),(3);
-ERROR 01000: Data truncated for column 'a' at row 3
+ERROR HY000: Received an invalid enum value '0'.
 INSERT INTO t1 VALUES (4),(1),(2),(3);
 SELECT a FROM t1;
 a
@@ -1781,9 +1781,8 @@
 a
 ALTER TABLE t1 ADD PRIMARY KEY (a);
 EXPLAIN SELECT a FROM t1 WHERE a=0;
-id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Impossible WHERE noticed after reading const tables
+ERROR HY000: Received an invalid enum value '0'.
 SELECT a FROM t1 WHERE a=0;
-a
+ERROR HY000: Received an invalid enum value '0'.
 DROP TABLE t1;
 End of 5.1 tests

=== modified file 'tests/r/type_ranges.result'
--- tests/r/type_ranges.result	2009-02-28 17:48:22 +0000
+++ tests/r/type_ranges.result	2009-03-16 15:20:27 +0000
@@ -87,7 +87,7 @@
 insert into t1 values (0,1/3,3,3,3,3,3,3,3,3,3,3,3,3,NULL,'19970303','19970303101010','','','','3',3,3);
 ERROR 22001: Data too long for column 'string' at row 1
 insert into t1 values (0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,NULL,19970807,19970403090807,-1,-1,-1,'-1',-1,-1);
-ERROR 01000: Data truncated for column 'options' at row 1
+ERROR HY000: Received an invalid enum value '-1'.
 insert into t1 values (0,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,NULL,0,0,-4294967295,-4294967295,-4294967295,'-4294967295',0,"tree");
 ERROR 22001: Data too long for column 'string' at row 1
 insert into t1 values (0,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,4294967295,NULL,0,0,4294967295,4294967295,4294967295,'4294967295',0,0);

=== modified file 'tests/r/union.result'
--- tests/r/union.result	2009-02-28 20:43:31 +0000
+++ tests/r/union.result	2009-03-16 15:20:27 +0000
@@ -979,7 +979,7 @@
 create table t4 (a ENUM('aaa', 'bbb') NOT NULL);
 insert into t3 values (1);
 insert into t4 values (3);
-ERROR 01000: Data truncated for column 'a' at row 1
+ERROR HY000: Received an invalid enum value '3'.
 select "1" as a union select a from t1;
 a
 1

=== modified file 'tests/t/strict.test'
--- tests/t/strict.test	2009-02-21 16:00:06 +0000
+++ tests/t/strict.test	2009-03-16 15:20:27 +0000
@@ -169,15 +169,17 @@
 
 CREATE TABLE t1 (col1 enum('red','blue','green'));
 INSERT INTO t1 VALUES ('red'),('blue'),('green');
---error 1265
+--error 1691 # Bad enum
 INSERT INTO t1 (col1) VALUES ('yellow');
---error 1265
+--error 1691 # Bad enum
 INSERT INTO t1 (col1) VALUES ('redd');
---error 1265
+--error 1691 # Bad enum
 INSERT INTO t1 VALUES ('');
---error 1265
+--error 1691 # Bad enum
 UPDATE t1 SET col1 ='yellow' WHERE col1 ='green';
+--error 1691 # Bad enum
 INSERT IGNORE INTO t1 VALUES ('yellow');
+--error 1691 # Bad enum
 UPDATE IGNORE t1 SET col1 ='yellow' WHERE col1 ='blue';
 SELECT * FROM t1;
 DROP TABLE t1;

=== modified file 'tests/t/type_enum.test'
--- tests/t/type_enum.test	2009-03-03 03:03:39 +0000
+++ tests/t/type_enum.test	2009-03-16 15:20:27 +0000
@@ -30,7 +30,7 @@
 #
 
 create table t1 (a enum ('0','1'));
---error 1265 Data truncated for column a
+--error 1691 # Bad enum
 insert into t1 set a='foobar';
 select * from t1;
 update t1 set a = replace(a,'x','y');
@@ -163,15 +163,16 @@
   id INT AUTO_INCREMENT PRIMARY KEY,
   c1 ENUM('a', '', 'b')
 );
---error 1265
+--error 1691 # 0 is not valid way to insert.  Must use 1-based index of key.
 INSERT INTO t1 (c1) VALUES (0), ('a'), (''), ('b');
---error 1265
+--error 1691 # 0 is not valid way to insert.  Must use 1-based index of key.
 INSERT INTO t1 (c1) VALUES (0), ('a'), (''), ('b');
 INSERT INTO t1 (c1) VALUES ('a'), ('b');
 SELECT id, c1 + 0, c1 FROM t1;
 
---error 1265
+--error 1691 # Bad en
 ALTER TABLE t1 CHANGE c1 c1 ENUM('a', '') NOT NULL;
+# Below works because '' was not inserted in any statement above...
 ALTER TABLE t1 CHANGE c1 c1 ENUM('a', 'b') NOT NULL;
 SELECT id, c1 + 0, c1 FROM t1;
 
@@ -183,8 +184,9 @@
 # Bug#28729: Field_enum wrongly reported an error while storing an empty string.
 #
 create table t1(f1 enum('a','b'), index(f1));
---error 1265
+--error 1691 # Bad enum
 insert into t1 values(''),(''),('a'),('b');
+--error 1691 # Bad enum
 select * from t1 where f1='';
 drop table t1;
 
@@ -196,7 +198,7 @@
 CREATE TABLE t1 (c1 ENUM('a', '', 'b'));
 INSERT INTO t1 (c1) VALUES ('b');
 INSERT INTO t1 (c1) VALUES ('');
---error 1265
+--error 1691 # Bad enum 0
 INSERT INTO t1 (c1) VALUES (0);
 INSERT INTO t1 (c1) VALUES ('a');
 
@@ -212,18 +214,28 @@
 #
 
 CREATE TABLE t1(a enum('a','b','c','d'));
---error 1265  Data truncated for column 'a' at row 3
+--error 1691 # Bad enum 0
 INSERT INTO t1 VALUES (4),(1),(0),(3);
 INSERT INTO t1 VALUES (4),(1),(2),(3);
 
 SELECT a FROM t1;
 
+# @TODO There is currently no way to fix the below
+# oddity.  Basically, Field_enum::store() is *only* called
+# when there is key information for the ENUM in select_describe()
+# and therefore, when Field_enum::store() is called for 0, it
+# throws an error, but only when there is an ENUM primary key.
+#
+# This should go away entirely when we get rid of the Field::store()
+# mess in the optimizer with value objects.
 EXPLAIN SELECT a FROM t1 WHERE a=0;
 SELECT a FROM t1 WHERE a=0;
 
 ALTER TABLE t1 ADD PRIMARY KEY (a);
 
+--error 1691 # Bad enum 0
 EXPLAIN SELECT a FROM t1 WHERE a=0;
+--error 1691 # Bad enum 0
 SELECT a FROM t1 WHERE a=0;
 
 DROP TABLE t1;

=== modified file 'tests/t/type_ranges.test'
--- tests/t/type_ranges.test	2009-02-21 16:00:06 +0000
+++ tests/t/type_ranges.test	2009-03-16 15:20:27 +0000
@@ -59,7 +59,7 @@
 insert into t1 values (NULL,2,2,2,2,2,2,2,2,2,2,2,2,2,NULL,NULL,NULL,NULL,NULL,2,2,'two','one');
 --error 1406
 insert into t1 values (0,1/3,3,3,3,3,3,3,3,3,3,3,3,3,NULL,'19970303','19970303101010','','','','3',3,3);
---error 1265
+--error 1691 # Bad enum
 insert into t1 values (0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,NULL,19970807,19970403090807,-1,-1,-1,'-1',-1,-1);
 --error 1406
 insert into t1 values (0,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,-4294967295,NULL,0,0,-4294967295,-4294967295,-4294967295,'-4294967295',0,"tree");

=== modified file 'tests/t/union.test'
--- tests/t/union.test	2009-02-28 20:43:31 +0000
+++ tests/t/union.test	2009-03-16 15:20:27 +0000
@@ -573,7 +573,7 @@
 create table t3 (a ENUM('Yes', 'No') NOT NULL);
 create table t4 (a ENUM('aaa', 'bbb') NOT NULL);
 insert into t3 values (1);
---error 1265
+--error 1691 # Bad enum
 insert into t4 values (3);
 select "1" as a union select a from t1;
 select a as a from t1 union select "1";