Merge lp:~brianaker/drizzle/bug-592690 into lp:drizzle/7.0

[Brian Aker]

[lp:~brianaker/drizzle/bug-592690]

2078. By Brian Aker <brian@gir-3> on 2011-01-13

Merge in all of the fixes for definition to instance.

2079. By Brian Aker <brian@gir-3> on 2011-01-13

Merge in fix around API (we should be able to move to seeing errors directly
from SE interface (which solves the wishlist issue, and convoluted issues
around issuing errors).

2080. By Brian Aker <brian@gir-3> on 2011-01-13

Rollup of catalog patch.

2081. By Brian Aker <brian@gir-3> on 2011-01-13

Cleanup around alter table (mostly harmless stuff, though some lock move).

2082. By Brian Aker <brian@gir-3> on 2011-01-14

Rollup changes for trunk.

[Lee Bieber (kalebral-deactivatedaccount)]

Getting unit test failures:

FAILED  ] 4 tests, listed below:
[  FAILED  ] TimestampTest.is_valid_oneSecondAfterTimestampMaxOfRange_shouldReturn_False
[  FAILED  ] NanoTimestampTest.is_valid_oneMicroSecondAfterNanoTimestampMaxOfRange_shouldReturn_False
[  FAILED  ] MicroTimestampTest.is_valid_oneMicroSecondAfterMicroTimestampMaxOfRange_shouldReturn_False
[  FAILED  ] calendar_in_unix_epoch_range_test.OneSecondAfterMaxOfRange
[1/13/11 7:09:36 PM] Lee: brb, have to walk the dog

review: Needs Fixing

[lp:~brianaker/drizzle/bug-592690]

2083. By Lee Bieber on 2011-01-14

Merge Stewart - fix bug 582486: valgrind warning in drizzled::mysql_load

2084. By Lee Bieber on 2011-01-14

Merge Lee - fix rabbitmq test to use $TOP_SRCDIR instead of $TOP_BUILDDIR

2085. By Lee Bieber on 2011-01-14

Merge Stewart - track what is being called in the Storage Engine in storage_engine_api_tester

2086. By Lee Bieber on 2011-01-14

Merge Andrew - fix bug 702881: data_dictionary.tables row_format incorrect
Merge Marisa - Document new data types and change in build file to treat warnings as errors
Merge Lee - 690773: RabbitMQ plugin needs to start rabbitmq for its test

2087. By Lee Bieber on 2011-01-15

Merge Stewart - some documentation clean up
Merge Patrick - fix bug 693130: Tests depending on archive engine should be skipped if archive isn't enabled
Merge Patrick - fix bug 697292: The have_valgrind include file in the test has the opposite effect

2088. By Lee Bieber on 2011-01-15

Merge Monty - fix bug 702571: InnoDB should have file-per-table on by default
Merge Monty - fix bug 583375: support configure option to specify static/dynamic build for a plugin

2089. By Brian Aker on 2011-01-17

Rollup of all changes for identifier/error

2090. By Brian Aker on 2011-01-17

Rolls back patch on Inno/static build. Also removes experimental plugins
from test runs by default.

2091. By Brian Aker on 2011-01-18

First pass on fix for UTF-8, this checks all of our schema names.

2092. By Brian Aker on 2011-01-18

Add in reorder and see if this will speed up builds at all.

2093. By Brian Aker on 2011-01-18

Merge in update so that test-run.pl runs all of test/suite and fix for
create table like and FK.

2094. By Patrick Crews on 2011-01-18

Updated translations

2095. By Lee Bieber on 2011-01-18

Merge Brian - fix processlist test, was failing under lcov
Merge Marisa - fix bug 684803: Need to update Drizzledump documentation with migration conversions / caveats
Merge Marisa - fix bug #686641: Need to document removal of multi-table update/delete from Drizzle
Merge Monty - fix bug 567387: quotes now appearing around module name and author in data_dicionary view
Merge Monty - fix bug 658752: Incorrect datadir value being stored
Merge Andrew - fix bug 680872: max-connect-errors appears to be unused
Merge Stewart - Haildb updates, ANALYZE table as well as improved index statistics

2096. By Lee Bieber on 2011-01-19

Merge Shrews - Refactor the TransactionServices public interface
Merge Monty - fix bug 583375: support configure option to specify static/dynamic build for a plugin
Merge Shrews - fix bug 702505: transaction_reader utility does not check for errors from statement transformation
Merge Vijay - Convert structs to classes
Merge Joe - 702529: PRINT_TRANSACTION_MESSAGE udf does not output UUID

2097. By Brian Aker on 2011-01-19

Test cleanup for lcov

2098. By Brian Aker on 2011-01-20

Merge of all of the time fixes.

2099. By Brian Aker on 2011-01-20

Remove dead code.

2100. By Brian Aker on 2011-01-21

Merge in uint to int fixes in time type.

Unmerged revisions

=== modified file 'drizzled/calendar.cc'
--- drizzled/calendar.cc	2010-12-18 04:43:40 +0000
+++ drizzled/calendar.cc	2011-01-14 20:07:36 +0000
@@ -333,40 +333,24 @@
  * @param Minute
  * @param Second
  */
-bool in_unix_epoch_range(uint32_t year
-                       , uint32_t month
-                       , uint32_t day
-                       , uint32_t hour
-                       , uint32_t minute
-                       , uint32_t second)
+bool in_unix_epoch_range(uint32_t year,
+                         uint32_t month,
+                         uint32_t day,
+                         uint32_t hour,
+                         uint32_t minute,
+                         uint32_t second)
 {
+  (void)hour;
+  (void)minute;
+  (void)second;
+
   if (month == 0 || day == 0)
     return false;
-  if (year < UNIX_EPOCH_MAX_YEARS
-      && year >= UNIX_EPOCH_MIN_YEARS)
-    return true;
+
   if (year < UNIX_EPOCH_MIN_YEARS)
     return false;
-  if (year == UNIX_EPOCH_MAX_YEARS)
-  {
-    if (month > 1)
-      return false;
-    if (day > 19)
-      return false;
-    else if (day < 19)
-      return true;
-    else
-    {
-      /* We are on the final day of UNIX Epoch */
-      uint32_t seconds= (hour * 60 * 60)
-                      + (minute * 60)
-                      + (second);
-      if (seconds <= ((3 * 60 * 60) + (14 * 60) + 7))
-        return true;
-      return false;
-    }
-  }
-  return false;
+
+  return true;
 }
 
 /**

=== modified file 'drizzled/calendar.h'
--- drizzled/calendar.h	2010-12-18 04:43:40 +0000
+++ drizzled/calendar.h	2011-01-14 20:07:36 +0000
@@ -48,7 +48,6 @@
 #define GREGORIAN_START_MONTH 10
 #define GREGORIAN_START_DAY 15
 
-#define UNIX_EPOCH_MAX_YEARS 2038
 #define UNIX_EPOCH_MIN_YEARS 1970
 
 #define CALENDAR_YY_PART_YEAR 70

=== modified file 'drizzled/error.cc'
--- drizzled/error.cc	2011-01-13 09:25:42 +0000
+++ drizzled/error.cc	2011-01-14 20:07:36 +0000
@@ -468,6 +468,7 @@
   ADD_ERROR_MESSAGE(ER_LOAD_DATA_INVALID_COLUMN, N_("Invalid column reference (%-.64s) in LOAD DATA"));
   ADD_ERROR_MESSAGE(ER_INVALID_UNIX_TIMESTAMP_VALUE, N_("Received an invalid value '%s' for a UNIX timestamp."));
   ADD_ERROR_MESSAGE(ER_INVALID_DATETIME_VALUE, N_("Received an invalid datetime value '%s'."));
+  ADD_ERROR_MESSAGE(ER_INVALID_TIMESTAMP_VALUE, N_("Received an invalid timestamp value '%s'."));
   ADD_ERROR_MESSAGE(ER_INVALID_NULL_ARGUMENT, N_("Received a NULL argument for function '%s'."));
   ADD_ERROR_MESSAGE(ER_ARGUMENT_OUT_OF_RANGE, N_("Received an out-of-range argument '%s' for function '%s'."));
   ADD_ERROR_MESSAGE(ER_INVALID_ENUM_VALUE, N_("Received an invalid enum value '%s'."));

=== modified file 'drizzled/error_t.h'
--- drizzled/error_t.h	2011-01-13 09:25:42 +0000
+++ drizzled/error_t.h	2011-01-14 20:07:36 +0000
@@ -833,18 +833,8 @@
   ER_KILL_DENY_SELF_ERROR,
   ER_INVALID_ALTER_TABLE_FOR_NOT_NULL,
   ER_ADMIN_ACCESS,
-  ER_INVALID_UUID_VALUE,
-  ER_INVALID_UUID_TIME,
-  ER_CORRUPT_TABLE_DEFINITION_ENUM,
-  ER_CORRUPT_TABLE_DEFINITION_UNKNOWN_COLLATION,
-  ER_CORRUPT_TABLE_DEFINITION_UNKNOWN,
-  ER_INVALID_CAST_TO_SIGNED,
-  ER_INVALID_CAST_TO_UNSIGNED,
-  ER_SQL_KEYWORD,
-  ER_INVALID_BOOLEAN_VALUE,
   ER_ASSERT,
   ER_ASSERT_NULL,
-  ER_TABLE_DROP,
   ER_CATALOG_CANNOT_CREATE,
   ER_CATALOG_CANNOT_CREATE_PERMISSION,
   ER_CATALOG_CANNOT_DROP,
@@ -853,8 +843,20 @@
   ER_CATALOG_NO_DROP_LOCAL,
   ER_CATALOG_NO_LOCK,
   ER_CORRUPT_CATALOG_DEFINITION,
+  ER_CORRUPT_TABLE_DEFINITION_ENUM,
+  ER_CORRUPT_TABLE_DEFINITION_UNKNOWN,
+  ER_CORRUPT_TABLE_DEFINITION_UNKNOWN_COLLATION,
+  ER_INVALID_BOOLEAN_VALUE,
+  ER_INVALID_CAST_TO_SIGNED,
+  ER_INVALID_CAST_TO_UNSIGNED,
+  ER_INVALID_TIMESTAMP_VALUE,
+  ER_INVALID_UUID_TIME,
+  ER_INVALID_UUID_VALUE,
+  ER_SQL_KEYWORD,
+  ER_TABLE_DROP,
   ER_TABLE_DROP_ERROR_OCCURRED,
   ER_TABLE_PERMISSION_DENIED,
+
   ER_INVALID_CAST_TO_BOOLEAN,
 
   // Leave ER_INVALID_BOOLEAN_VALUE as LAST, and force people to use tags

=== modified file 'drizzled/field/date.cc'
--- drizzled/field/date.cc	2010-12-25 04:38:28 +0000
+++ drizzled/field/date.cc	2011-01-14 20:07:36 +0000
@@ -132,6 +132,7 @@
       time_type == DRIZZLE_TIMESTAMP_DATETIME)
   {
     tmp= ltime->year*10000 + ltime->month*100 + ltime->day;
+
     if (check_date(ltime, tmp != 0,
                    (TIME_FUZZY_DATE |
                     (current_session->variables.sql_mode &
@@ -139,16 +140,17 @@
     {
       char buff[MAX_DATE_STRING_REP_LENGTH];
       String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
-      make_date(ltime, &str);
+      ltime->convert(str, DRIZZLE_TIMESTAMP_DATE);
       set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
                            str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
     }
-    if (!error && ltime->time_type != DRIZZLE_TIMESTAMP_DATE &&
+
+    if (not error && ltime->time_type != DRIZZLE_TIMESTAMP_DATE &&
         (ltime->hour || ltime->minute || ltime->second || ltime->second_part))
     {
       char buff[MAX_DATE_STRING_REP_LENGTH];
       String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
-      make_datetime(ltime, &str);
+      ltime->convert(str);
       set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE,
                            ER_WARN_DATA_TRUNCATED,
                            str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);

=== modified file 'drizzled/field/epoch.cc'
--- drizzled/field/epoch.cc	2011-01-06 18:00:47 +0000
+++ drizzled/field/epoch.cc	2011-01-14 20:07:36 +0000
@@ -162,7 +162,7 @@
 
   if (not temporal.from_string(from, (size_t) len))
   {
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
+    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
     return 1;
   }
 
@@ -178,19 +178,33 @@
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE;
 
-  if (from < 0 || from > 99991231235959.0)
+  uint64_t from_tmp= (uint64_t)from;
+
+  Timestamp temporal;
+  if (not temporal.from_int64_t(from_tmp))
   {
-    /* Convert the double to a string using stringstream */
-    std::stringstream ss;
-    std::string tmp;
-    ss.precision(18); /* 18 places should be fine for error display of double input. */
-    ss << from; 
-    ss >> tmp;
+    /* Convert the integer to a string using boost::lexical_cast */
+    std::string tmp(boost::lexical_cast<std::string>(from));
 
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
+    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
     return 2;
   }
-  return Epoch::store((int64_t) rint(from), false);
+
+  time_t tmp;
+  temporal.to_time_t(tmp);
+
+  uint64_t tmp_micro= tmp;
+  pack_num(tmp_micro);
+
+  return 0;
+}
+
+int Epoch::store_decimal(const type::Decimal *value)
+{
+  double tmp;
+  value->convert(tmp);
+
+  return store(tmp);
 }
 
 int Epoch::store(int64_t from, bool)
@@ -202,12 +216,12 @@
    * if unable to create a valid DateTime.  
    */
   Timestamp temporal;
-  if (! temporal.from_int64_t(from))
+  if (not temporal.from_int64_t(from))
   {
     /* Convert the integer to a string using boost::lexical_cast */
     std::string tmp(boost::lexical_cast<std::string>(from));
 
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
+    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
     return 2;
   }
 

=== modified file 'drizzled/field/epoch.h'
--- drizzled/field/epoch.h	2011-01-06 18:00:47 +0000
+++ drizzled/field/epoch.h	2011-01-14 20:07:36 +0000
@@ -50,10 +50,13 @@
   enum_field_types type() const { return DRIZZLE_TYPE_TIMESTAMP;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }
   enum Item_result cmp_type () const { return INT_RESULT; }
-  int  store(const char *to,uint32_t length,
-             const CHARSET_INFO * const charset);
-  int  store(double nr);
-  int  store(int64_t nr, bool unsigned_val);
+
+  int store(const char *to,uint32_t length,
+            const CHARSET_INFO * const charset);
+  int store(double nr);
+  int store(int64_t nr, bool unsigned_val);
+  int store_decimal(const type::Decimal *value);
+
   int  reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; return 0; }
   double val_real(void);
   int64_t val_int(void);

=== modified file 'drizzled/field/microtime.cc'
--- drizzled/field/microtime.cc	2011-01-11 00:57:46 +0000
+++ drizzled/field/microtime.cc	2011-01-14 20:07:36 +0000
@@ -54,8 +54,8 @@
         unireg_check_arg,
         field_name_arg,
         share)
-  {
-  }
+{
+}
 
 Microtime::Microtime(bool maybe_null_arg,
                      const char *field_name_arg) :
@@ -74,7 +74,7 @@
 
   if (not temporal.from_string(from, (size_t) len))
   {
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
+    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
     return 1;
   }
 
@@ -109,19 +109,27 @@
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE;
 
-  if (from < 0 || from > 99991231235959.0)
+  uint64_t from_tmp= (uint64_t)from;
+  type::Time::usec_t fractional_seconds= (type::Time::usec_t)((from - from_tmp) * type::Time::FRACTIONAL_DIGITS) % type::Time::FRACTIONAL_DIGITS;
+
+  MicroTimestamp temporal;
+  if (not temporal.from_int64_t(from_tmp))
   {
-    /* Convert the double to a string using stringstream */
-    std::stringstream ss;
-    std::string tmp;
-    ss.precision(18); /* 18 places should be fine for error display of double input. */
-    ss << from; 
-    ss >> tmp;
+    /* Convert the integer to a string using boost::lexical_cast */
+    std::string tmp(boost::lexical_cast<std::string>(from));
 
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
+    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
     return 2;
   }
-  return Microtime::store((int64_t) rint(from), false);
+
+  time_t tmp;
+  temporal.to_time_t(tmp);
+
+  uint64_t tmp_micro= tmp;
+  pack_num(tmp_micro);
+  pack_num(fractional_seconds, ptr +8);
+
+  return 0;
 }
 
 int Microtime::store(int64_t from, bool)
@@ -134,7 +142,7 @@
     /* Convert the integer to a string using boost::lexical_cast */
     std::string tmp(boost::lexical_cast<std::string>(from));
 
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
+    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
     return 2;
   }
 
@@ -150,7 +158,33 @@
 
 double Microtime::val_real(void)
 {
-  return (double) Microtime::val_int();
+  uint64_t temp;
+  type::Time::usec_t micro_temp;
+
+  ASSERT_COLUMN_MARKED_FOR_READ;
+
+  unpack_num(temp);
+  unpack_num(micro_temp, ptr +8);
+
+  Timestamp temporal;
+  (void) temporal.from_time_t((time_t) temp);
+
+  /* We must convert into a "timestamp-formatted integer" ... */
+  int64_t result;
+  temporal.to_int64_t(&result);
+
+  result+= micro_temp % type::Time::FRACTIONAL_DIGITS;
+
+  return result;
+}
+
+type::Decimal *Microtime::val_decimal(type::Decimal *decimal_value)
+{
+  type::Time ltime;
+
+  get_date(&ltime, 0);
+
+  return date2_class_decimal(&ltime, decimal_value);
 }
 
 int64_t Microtime::val_int(void)
@@ -174,7 +208,7 @@
 String *Microtime::val_str(String *val_buffer, String *)
 {
   uint64_t temp= 0;
-  uint32_t micro_temp= 0;
+  type::Time::usec_t micro_temp= 0;
   char *to;
   int to_len= field_length + 1 + 8;
 
@@ -209,7 +243,7 @@
   unpack_num(temp);
   unpack_num(micro_temp, ptr +8);
   
-  memset(ltime, 0, sizeof(*ltime));
+  ltime->reset();
 
   Timestamp temporal;
   (void) temporal.from_time_t((time_t) temp);
@@ -225,12 +259,12 @@
   ltime->second= temporal.seconds();
   ltime->second_part= temporal.useconds();
 
-  return 0;
+  return false;
 }
 
 bool Microtime::get_time(type::Time *ltime)
 {
-  return Microtime::get_date(ltime,0);
+  return Microtime::get_date(ltime, 0);
 }
 
 int Microtime::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
@@ -275,7 +309,7 @@
 {
   Session *session= getTable() ? getTable()->in_use : current_session;
 
-  uint32_t fractional_seconds= 0;
+  type::Time::usec_t fractional_seconds= 0;
   uint64_t epoch_seconds= session->getCurrentTimestampEpoch(fractional_seconds);
 
   set_notnull();

=== modified file 'drizzled/field/microtime.h'
--- drizzled/field/microtime.h	2011-01-11 00:57:46 +0000
+++ drizzled/field/microtime.h	2011-01-14 20:07:36 +0000
@@ -56,9 +56,11 @@
   int store(int64_t nr, bool unsigned_val);
   int store_time(type::Time *ltime, enum enum_drizzle_timestamp_type t_type);
 
+  String *val_str(String*,String *);
   double val_real(void);
   int64_t val_int(void);
-  String *val_str(String*,String *);
+  type::Decimal *val_decimal(type::Decimal *decimal_value);
+
   int cmp(const unsigned char *,const unsigned char *);
   void sort_string(unsigned char *buff,uint32_t length);
   uint32_t pack_length() const { return 12; }

=== modified file 'drizzled/function/cast/time.cc'
--- drizzled/function/cast/time.cc	2010-12-25 04:38:28 +0000
+++ drizzled/function/cast/time.cc	2011-01-14 20:07:36 +0000
@@ -47,7 +47,8 @@
   if (not get_arg0_time(&ltime))
   {
     null_value= 0;
-    make_time(&ltime, str);
+    ltime.convert(*str, DRIZZLE_TIMESTAMP_TIME);
+
     return str;
   }
 

=== modified file 'drizzled/function/time/date_add_interval.cc'
--- drizzled/function/time/date_add_interval.cc	2011-01-06 23:23:07 +0000
+++ drizzled/function/time/date_add_interval.cc	2011-01-14 20:07:36 +0000
@@ -115,7 +115,7 @@
 
   if (ltime.time_type == DRIZZLE_TIMESTAMP_DATE)
   {
-    make_date(&ltime, str);
+    ltime.convert(*str, DRIZZLE_TIMESTAMP_DATE);
   }
   else if (ltime.second_part)
   {
@@ -135,7 +135,7 @@
   }
   else
   {
-    make_datetime(&ltime, str);
+    ltime.convert(*str);
   }
 
   return str;

=== modified file 'drizzled/function/time/from_unixtime.cc'
--- drizzled/function/time/from_unixtime.cc	2010-12-25 04:38:28 +0000
+++ drizzled/function/time/from_unixtime.cc	2011-01-14 20:07:36 +0000
@@ -54,7 +54,7 @@
     return 0;
   }
 
-  make_datetime(&time_tmp, str);
+  time_tmp.convert(*str);
 
   return str;
 }
@@ -73,7 +73,27 @@
 
 bool Item_func_from_unixtime::get_date(type::Time *ltime, uint32_t)
 {
-  uint64_t tmp= (uint64_t)(args[0]->val_int());
+  uint64_t tmp= 0;
+  type::Time::usec_t fractional_tmp= 0;
+
+  switch (args[0]->result_type()) {
+  case REAL_RESULT:
+  case ROW_RESULT:
+  case DECIMAL_RESULT:
+  case STRING_RESULT:
+    {
+      double double_tmp= args[0]->val_real();
+
+      tmp= (uint64_t)(double_tmp);
+      fractional_tmp=  (type::Time::usec_t)((double_tmp - tmp) * 1000000);
+
+      break;
+    }
+  case INT_RESULT:
+    tmp= (uint64_t)(args[0]->val_int());
+    break;
+  }
+
   /*
     "tmp > TIMESTAMP_MAX_VALUE" check also covers case of negative
     from_unixtime() argument since tmp is unsigned.
@@ -82,7 +102,7 @@
     return 1;
 
   Timestamp temporal;
-  if (! temporal.from_time_t((time_t) tmp))
+  if (not temporal.from_time_t((time_t) tmp))
   {
     null_value= true;
     std::string tmp_string(boost::lexical_cast<std::string>(tmp));
@@ -90,7 +110,7 @@
     return 0;
   }
   
-  memset(ltime, 0, sizeof(*ltime));
+  ltime->reset();
 
   ltime->year= temporal.years();
   ltime->month= temporal.months();
@@ -98,6 +118,7 @@
   ltime->hour= temporal.hours();
   ltime->minute= temporal.minutes();
   ltime->second= temporal.seconds();
+  ltime->second_part= fractional_tmp;
   ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
 
   return 0;

=== modified file 'drizzled/function/time/makedate.cc'
--- drizzled/function/time/makedate.cc	2010-12-25 04:38:28 +0000
+++ drizzled/function/time/makedate.cc	2011-01-14 20:07:36 +0000
@@ -58,7 +58,9 @@
     get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
     if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
       goto err;
-    make_date(&l_time, str);
+
+    l_time.convert(*str, DRIZZLE_TIMESTAMP_DATE);
+
     return str;
   }
 

=== modified file 'drizzled/function/time/now.cc'
--- drizzled/function/time/now.cc	2011-01-06 23:02:43 +0000
+++ drizzled/function/time/now.cc	2011-01-14 20:07:36 +0000
@@ -31,6 +31,7 @@
 {
   assert(fixed == 1);
   str_value.set(buff, buff_length, &my_charset_bin);
+
   return &str_value;
 }
 
@@ -40,14 +41,14 @@
   decimals= DATETIME_DEC;
   collation.set(&my_charset_bin);
   
-  memset(&ltime, 0, sizeof(type::Time));
+  ltime.reset();
 
   ltime.time_type= DRIZZLE_TIMESTAMP_DATETIME;
 
   store_now_in_TIME(&ltime);
   value= (int64_t) TIME_to_uint64_t_datetime(&ltime);
 
-  buff_length= (uint) my_datetime_to_str(&ltime, buff);
+  buff_length= (uint) my_TIME_to_str(&ltime, buff);
   max_length= buff_length;
 }
 

=== modified file 'drizzled/function/time/sysdate_local.cc'
--- drizzled/function/time/sysdate_local.cc	2010-12-25 04:38:28 +0000
+++ drizzled/function/time/sysdate_local.cc	2011-01-14 20:07:36 +0000
@@ -41,7 +41,7 @@
 {
   assert(fixed == 1);
   store_now_in_TIME(&ltime);
-  buff_length= (uint) my_datetime_to_str(&ltime, buff);
+  buff_length= (uint) my_TIME_to_str(&ltime, buff);
   str_value.set(buff, buff_length, &my_charset_bin);
   return &str_value;
 }

=== modified file 'drizzled/function/time/typecast.cc'
--- drizzled/function/time/typecast.cc	2010-12-25 04:38:28 +0000
+++ drizzled/function/time/typecast.cc	2011-01-14 20:07:36 +0000
@@ -214,7 +214,10 @@
       str->set_charset(&my_charset_bin);
     }
     else
-      make_datetime(&ltime, str);
+    {
+      ltime.convert(*str);
+    }
+
     return str;
   }
 
@@ -261,7 +264,8 @@
   if (!get_arg0_date(&ltime, TIME_FUZZY_DATE) &&
       !str->alloc(MAX_DATE_STRING_REP_LENGTH))
   {
-    make_date(&ltime, str);
+    ltime.convert(*str, DRIZZLE_TIMESTAMP_DATE);
+
     return str;
   }
 

=== modified file 'drizzled/session.h'
--- drizzled/session.h	2011-01-13 01:27:33 +0000
+++ drizzled/session.h	2011-01-14 20:07:36 +0000
@@ -1332,7 +1332,7 @@
     return (_start_timer - _epoch).total_seconds();
   }
 
-  time_t getCurrentTimestampEpoch(uint32_t &fraction_arg) const
+  time_t getCurrentTimestampEpoch(type::Time::usec_t &fraction_arg) const
   { 
     if (not _user_time.is_not_a_date_time())
     {

=== modified file 'drizzled/time_functions.cc'
--- drizzled/time_functions.cc	2010-12-25 04:38:28 +0000
+++ drizzled/time_functions.cc	2011-01-14 20:07:36 +0000
@@ -170,32 +170,6 @@
   to->second=   (int) from->tm_sec;
 }
 
-void make_time(const type::Time *l_time, String *str)
-{
-  str->alloc(MAX_DATE_STRING_REP_LENGTH);
-  uint32_t length= (uint32_t) my_time_to_str(l_time, str->c_ptr());
-  str->length(length);
-  str->set_charset(&my_charset_bin);
-}
-
-void make_date(const type::Time *l_time, String *str)
-{
-  str->alloc(MAX_DATE_STRING_REP_LENGTH);
-  uint32_t length= (uint32_t) my_date_to_str(l_time, str->c_ptr());
-  str->length(length);
-  str->set_charset(&my_charset_bin);
-}
-
-
-void make_datetime(const type::Time *l_time, String *str)
-{
-  str->alloc(MAX_DATE_STRING_REP_LENGTH);
-  uint32_t length= (uint32_t) my_datetime_to_str(l_time, str->c_ptr());
-  str->length(length);
-  str->set_charset(&my_charset_bin);
-}
-
-
 void make_truncated_value_warning(Session *session, 
                                   DRIZZLE_ERROR::enum_warning_level level,
                                   const char *str_val,
@@ -223,6 +197,7 @@
       type_str= "datetime";
       break;
   }
+
   if (field_name)
   {
     cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
@@ -233,12 +208,16 @@
   else
   {
     if (time_type > DRIZZLE_TIMESTAMP_ERROR)
+    {
       cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
                          ER(ER_TRUNCATED_WRONG_VALUE),
                          type_str, str.c_ptr());
+    }
     else
+    {
       cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
                          ER(ER_WRONG_VALUE), type_str, str.c_ptr());
+    }
   }
   push_warning(session, level,
                ER_TRUNCATED_WRONG_VALUE, warn_buff);

=== modified file 'drizzled/time_functions.h'
--- drizzled/time_functions.h	2010-12-26 00:07:57 +0000
+++ drizzled/time_functions.h	2011-01-14 20:07:36 +0000
@@ -92,12 +92,6 @@
 */
 void localtime_to_TIME(type::Time *to, struct tm *from);
 
-void make_time(const type::Time *l_time, String *str);
-
-void make_date(const type::Time *l_time, String *str);
-
-void make_datetime(const type::Time *l_time, String *str);
-
 void make_truncated_value_warning(Session *session, 
                                   DRIZZLE_ERROR::enum_warning_level level,
                                   const char *str_val,

=== modified file 'drizzled/type/decimal.cc'
--- drizzled/type/decimal.cc	2010-12-27 19:16:17 +0000
+++ drizzled/type/decimal.cc	2011-01-14 20:07:36 +0000
@@ -313,6 +313,10 @@
   return err;
 }
 
+void type::Decimal::convert(double &result) const
+{
+  decimal2double(static_cast<const decimal_t*>(this), &result);
+}
 
 type::Decimal *date2_class_decimal(type::Time *ltime, type::Decimal *dec)
 {
@@ -320,8 +324,10 @@
   date = (ltime->year*100L + ltime->month)*100L + ltime->day;
   if (ltime->time_type > DRIZZLE_TIMESTAMP_DATE)
     date= ((date*100L + ltime->hour)*100L+ ltime->minute)*100L + ltime->second;
+
   if (int2_class_decimal(E_DEC_FATAL_ERROR, date, false, dec))
     return dec;
+
   if (ltime->second_part)
   {
     dec->buf[(dec->intg-1) / 9 + 1]= ltime->second_part * 1000;

=== modified file 'drizzled/type/decimal.h'
--- drizzled/type/decimal.h	2010-12-27 19:16:17 +0000
+++ drizzled/type/decimal.h	2011-01-14 20:07:36 +0000
@@ -23,8 +23,13 @@
 {
 
 typedef enum
-{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR}
-  decimal_round_mode;
+{
+  TRUNCATE= 0,
+  HALF_EVEN,
+  HALF_UP,
+  CEILING,
+  FLOOR
+} decimal_round_mode;
 typedef int32_t decimal_digit_t;
 
 typedef struct st_decimal_t {
@@ -179,96 +184,96 @@
 
 namespace type {
 /**
-  type::Decimal class limits 'decimal_t' type to what we need in MySQL.
+  type Decimal class limits 'decimal_t' type to what we need in MySQL.
 
   It contains internally all necessary space needed by the instance so
   no extra memory is needed. One should call fix_buffer_pointer() function
   when he moves type::Decimal objects in memory.
 */
 
-class Decimal :public decimal_t
+class Decimal : public decimal_t
+{
+  decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
+
+public:
+
+  void init()
   {
-    decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
-
-  public:
-
-    void init()
-    {
-      len= DECIMAL_BUFF_LENGTH;
-      buf= buffer;
+    len= DECIMAL_BUFF_LENGTH;
+    buf= buffer;
 #if !defined (HAVE_VALGRIND)
-      /* Set buffer to 'random' value to find wrong buffer usage */
-      for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
-        buffer[i]= i;
+    /* Set buffer to 'random' value to find wrong buffer usage */
+    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
+      buffer[i]= i;
 #endif
-    }
-
-    Decimal()
-    {
-      init();
-    }
-    void fix_buffer_pointer() { buf= buffer; }
-    bool sign() const { return decimal_t::sign; }
-    void sign(bool s) { decimal_t::sign= s; }
-    uint32_t precision() const { return intg + frac; }
-
-    int val_int32(uint32_t mask, bool unsigned_flag, int64_t *l) const
-    {
-      type::Decimal rounded;
-      /* decimal_round can return only E_DEC_TRUNCATED */
-      decimal_round(static_cast<const decimal_t*>(this), &rounded, 0, HALF_UP);
-      return check_result(mask, (unsigned_flag ?
-                                 decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
-                                 decimal2int64_t(&rounded, l)));
-    }
-
-    int string_length() const
-    {
-      return decimal_string_size(this);
-    }
-
-    int val_binary(uint32_t mask, unsigned char *bin, int prec, int scale) const;
-
-
-    int set_zero()
-    {
-      decimal_make_zero(static_cast<decimal_t*> (this));
-      return 0;
-    }
-
-
-    bool is_zero() const
-    {
-      return decimal_is_zero(static_cast<const decimal_t*>(this));
-    }
-
-
-    int store(uint32_t mask, const char *from, uint32_t length, const CHARSET_INFO * charset);
-
-    int store(uint32_t mask, char *str, char **end)
-    {
-      return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(this), end));
-    }
-
-    int store(uint32_t mask, const String *str)
-    {
-      return store(mask, str->ptr(), str->length(), str->charset());
-    }
-
-    int check_result_and_overflow(uint32_t mask, int result)
-    {
-      if (check_result(mask, result) & E_DEC_OVERFLOW)
-      {
-        bool _sign= sign();
-        fix_buffer_pointer();
-        max_internal_decimal(this);
-        sign(_sign);
-      }
-      return result;
-}
-
-
-  };
+  }
+
+  Decimal()
+  {
+    init();
+  }
+  void fix_buffer_pointer() { buf= buffer; }
+  bool sign() const { return decimal_t::sign; }
+  void sign(bool s) { decimal_t::sign= s; }
+  uint32_t precision() const { return intg + frac; }
+
+  int val_int32(uint32_t mask, bool unsigned_flag, int64_t *l) const
+  {
+    type::Decimal rounded;
+    /* decimal_round can return only E_DEC_TRUNCATED */
+    decimal_round(static_cast<const decimal_t*>(this), &rounded, 0, HALF_UP);
+    return check_result(mask, (unsigned_flag ?
+                               decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
+                               decimal2int64_t(&rounded, l)));
+  }
+
+  int string_length() const
+  {
+    return decimal_string_size(this);
+  }
+
+  int val_binary(uint32_t mask, unsigned char *bin, int prec, int scale) const;
+
+
+  int set_zero()
+  {
+    decimal_make_zero(static_cast<decimal_t*> (this));
+    return 0;
+  }
+
+
+  bool is_zero() const
+  {
+    return decimal_is_zero(static_cast<const decimal_t*>(this));
+  }
+
+
+  int store(uint32_t mask, const char *from, uint32_t length, const CHARSET_INFO * charset);
+
+  int store(uint32_t mask, char *str, char **end)
+  {
+    return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(this), end));
+  }
+
+  int store(uint32_t mask, const String *str)
+  {
+    return store(mask, str->ptr(), str->length(), str->charset());
+  }
+
+  int check_result_and_overflow(uint32_t mask, int result)
+  {
+    if (check_result(mask, result) & E_DEC_OVERFLOW)
+    {
+      bool _sign= sign();
+      fix_buffer_pointer();
+      max_internal_decimal(this);
+      sign(_sign);
+    }
+    return result;
+  }
+
+  void convert(double &value) const;
+};
 
 } // type
 

=== modified file 'drizzled/type/time.cc'
--- drizzled/type/time.cc	2011-01-11 00:57:46 +0000
+++ drizzled/type/time.cc	2011-01-14 20:07:36 +0000
@@ -21,6 +21,7 @@
 #include "drizzled/charset_info.h"
 #include <drizzled/util/test.h>
 #include "drizzled/definitions.h"
+#include <drizzled/sql_string.h>
 
 #include <cstdio>
 #include <algorithm>
@@ -453,7 +454,9 @@
                                        DRIZZLE_TIMESTAMP_DATETIME));
 
 err:
-  memset(l_time, 0, sizeof(*l_time));
+
+  l_time->reset();
+
   return(DRIZZLE_TIMESTAMP_ERROR);
 }
 
@@ -883,18 +886,7 @@
     We are safe with shifts close to MAX_INT32, as there are no known
     time switches on Jan 2038 yet :)
   */
-  if ((t->year == TIMESTAMP_MAX_YEAR) && (t->month == 1) && (t->day > 4))
-  {
-    /*
-      Below we will pass (uint32_t) (t->day - shift) to calc_daynr.
-      As we don't want to get an overflow here, we will shift
-      only safe dates. That's why we have (t->day > 4) above.
-    */
-    t->day-= 2;
-    shift= 2;
-  }
 #ifdef TIME_T_UNSIGNED
-  else
   {
     /*
       We can get 0 in time_t representaion only on 1969, 31 of Dec or on
@@ -1039,7 +1031,7 @@
     number of characters written to 'to'
 */
 
-int my_time_to_str(const type::Time *l_time, char *to)
+static int my_time_to_str(const type::Time *l_time, char *to)
 {
   uint32_t extra_hours= 0;
   return sprintf(to, "%s%02u:%02u:%02u",
@@ -1049,7 +1041,7 @@
                          l_time->second);
 }
 
-int my_date_to_str(const type::Time *l_time, char *to)
+static int my_date_to_str(const type::Time *l_time, char *to)
 {
   return sprintf(to, "%04u-%02u-%02u",
                          l_time->year,
@@ -1057,7 +1049,7 @@
                          l_time->day);
 }
 
-int my_datetime_to_str(const type::Time *l_time, char *to)
+static int my_datetime_to_str(const type::Time *l_time, char *to)
 {
   return sprintf(to, "%04u-%02u-%02u %02u:%02u:%02u",
                          l_time->year,
@@ -1092,13 +1084,63 @@
   case DRIZZLE_TIMESTAMP_NONE:
   case DRIZZLE_TIMESTAMP_ERROR:
     to[0]='\0';
-    return 0;
-  default:
+  }
+
+  return 0;
+}
+
+namespace type {
+
+static void make_time(const type::Time *l_time, String *str)
+{
+  str->alloc(MAX_DATE_STRING_REP_LENGTH);
+  uint32_t length= (uint32_t) my_time_to_str(l_time, str->c_ptr());
+  str->length(length);
+  str->set_charset(&my_charset_bin);
+}
+
+static void make_date(const type::Time *l_time, String *str)
+{
+  str->alloc(MAX_DATE_STRING_REP_LENGTH);
+  uint32_t length= (uint32_t) my_date_to_str(l_time, str->c_ptr());
+  str->length(length);
+  str->set_charset(&my_charset_bin);
+}
+
+
+static void make_datetime(const type::Time *l_time, String *str)
+{
+  str->alloc(MAX_DATE_STRING_REP_LENGTH);
+  uint32_t length= (uint32_t) my_datetime_to_str(l_time, str->c_ptr());
+  str->length(length);
+  str->set_charset(&my_charset_bin);
+}
+
+
+
+void Time::convert(String &str, const enum_drizzle_timestamp_type arg)
+{
+  switch (arg) {
+  case DRIZZLE_TIMESTAMP_DATETIME:
+    make_datetime(this, &str);
+    break;
+
+  case DRIZZLE_TIMESTAMP_DATE:
+    make_date(this, &str);
+    break;
+
+  case DRIZZLE_TIMESTAMP_TIME:
+    make_time(this, &str);
+    break;
+
+  case DRIZZLE_TIMESTAMP_NONE:
+  case DRIZZLE_TIMESTAMP_ERROR:
     assert(0);
-    return 0;
+    break;
   }
 }
 
+}
 
 /*
   Convert datetime value specified as number to broken-down TIME
@@ -1132,7 +1174,7 @@
   long part1,part2;
 
   *was_cut= 0;
-  memset(time_res, 0, sizeof(*time_res));
+  time_res->reset();
   time_res->time_type=DRIZZLE_TIMESTAMP_DATE;
 
   if (nr == 0LL || nr >= 10000101000000LL)
@@ -1219,8 +1261,9 @@
 
 static uint64_t TIME_to_uint64_t_date(const type::Time *my_time)
 {
-  return (uint64_t) (my_time->year * 10000UL + my_time->month * 100UL +
-                      my_time->day);
+  return (uint64_t) (my_time->year * 10000UL +
+                     my_time->month * 100UL +
+                     my_time->day);
 }
 
 
@@ -1233,8 +1276,8 @@
 static uint64_t TIME_to_uint64_t_time(const type::Time *my_time)
 {
   return (uint64_t) (my_time->hour * 10000UL +
-                      my_time->minute * 100UL +
-                      my_time->second);
+                     my_time->minute * 100UL +
+                     my_time->second);
 }
 
 
@@ -1270,9 +1313,8 @@
   case DRIZZLE_TIMESTAMP_NONE:
   case DRIZZLE_TIMESTAMP_ERROR:
     return 0ULL;
-  default:
-    assert(0);
   }
+
   return 0;
 }
 

=== modified file 'drizzled/type/time.h'
--- drizzled/type/time.h	2011-01-11 00:57:46 +0000
+++ drizzled/type/time.h	2011-01-14 20:07:36 +0000
@@ -32,6 +32,8 @@
 # endif
 #endif
 
+#include <drizzled/sql_string.h>
+
 namespace drizzled
 {
 
@@ -39,7 +41,6 @@
 extern unsigned char days_in_month[];
 
 /* Time handling defaults */
-#define TIMESTAMP_MAX_YEAR 2038
 #define TIMESTAMP_MIN_YEAR (1900 + YY_PART_YEAR - 1)
 #define TIMESTAMP_MAX_VALUE INT32_MAX
 #define TIMESTAMP_MIN_VALUE 1
@@ -88,17 +89,31 @@
   bigger values.
 */
 namespace type {
+
 class Time
 {
 public:
+  typedef uint32_t usec_t;
+
   unsigned int year, month, day, hour, minute, second;
-  unsigned int second_part;
-  bool       neg;
+  usec_t second_part;
+  bool neg;
   enum enum_drizzle_timestamp_type time_type;
+
+  void reset()
+  {
+    year= month= day= hour= minute= second= second_part= 0;
+    neg= false;
+    time_type= DRIZZLE_TIMESTAMP_DATE;
+  }
+
+  void convert(drizzled::String &str, const enum_drizzle_timestamp_type arg= DRIZZLE_TIMESTAMP_DATETIME);
+
+  static const uint32_t FRACTIONAL_DIGITS= 1000000;
 };
+
 }
 
-
 bool check_date(const type::Time *ltime, bool not_zero_date,
                    uint32_t flags, int *was_cut);
 enum enum_drizzle_timestamp_type
@@ -110,8 +125,7 @@
 uint64_t TIME_to_uint64_t(const type::Time *);
 
 
-bool str_to_time(const char *str,uint32_t length, type::Time *l_time,
-                 int *warning);
+bool str_to_time(const char *str,uint32_t length, type::Time *l_time, int *warning);
 
 long calc_daynr(uint32_t year,uint32_t month,uint32_t day);
 uint32_t calc_days_in_year(uint32_t year);
@@ -135,10 +149,10 @@
 
 static inline bool validate_timestamp_range(const type::Time *t)
 {
-  if ((t->year > TIMESTAMP_MAX_YEAR || t->year < TIMESTAMP_MIN_YEAR) ||
-      (t->year == TIMESTAMP_MAX_YEAR && (t->month > 1 || t->day > 19)) ||
-      (t->year == TIMESTAMP_MIN_YEAR && (t->month < 12 || t->day < 31)))
+  if ((t->year < TIMESTAMP_MIN_YEAR) or (t->year == TIMESTAMP_MIN_YEAR && (t->month < 12 || t->day < 31)))
+  {
     return false;
+  }
 
   return true;
 }
@@ -159,9 +173,6 @@
 */
 #define MAX_DATE_STRING_REP_LENGTH 30
 
-int my_time_to_str(const type::Time *l_time, char *to);
-int my_date_to_str(const type::Time *l_time, char *to);
-int my_datetime_to_str(const type::Time *l_time, char *to);
 int my_TIME_to_str(const type::Time *l_time, char *to);
 
 /*

=== modified file 'plugin/csv/tests/t/uuid_type.test'
--- plugin/csv/tests/t/uuid_type.test	2010-12-17 22:39:43 +0000
+++ plugin/csv/tests/t/uuid_type.test	2011-01-14 20:07:36 +0000
@@ -19,7 +19,7 @@
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883aaaa");
 SELECT a FROM t1 ORDER BY a;
 
---error 1716
+--error ER_INVALID_UUID_VALUE
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883");
 SELECT a FROM t1 ORDER BY a;
 

=== modified file 'plugin/haildb/tests/r/type_timestamp.result'
--- plugin/haildb/tests/r/type_timestamp.result	2010-12-10 05:45:44 +0000
+++ plugin/haildb/tests/r/type_timestamp.result	2011-01-14 20:07:36 +0000
@@ -112,17 +112,17 @@
 drop table t1;
 create table t1 (ix timestamp);
 insert into t1 values (0),(20030101010160),(20030101016001),(20030101240101),(20030132010101),(20031301010101),(20031200000000),(20030000000000);
-ERROR HY000: Received an invalid value '0' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0'.
 select ix+0 from t1;
 ix+0
 truncate table t1;
 insert into t1 values ("00000000000000"),("20030101010160"),("20030101016001"),("20030101240101"),("20030132010101"),("20031301010101"),("20031200000000"),("20030000000000");
-ERROR HY000: Received an invalid value '00000000000000' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '00000000000000'.
 select ix+0 from t1;
 ix+0
 truncate table t1;
 insert into t1 values ("0000-00-00 00:00:00 some trailer"),("2003-01-01 00:00:00 some trailer");
-ERROR HY000: Received an invalid value '0000-00-00 00:00:00 some trailer' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0000-00-00 00:00:00 some trailer'.
 select ix+0 from t1;
 ix+0
 drop table t1;

=== modified file 'plugin/haildb/tests/t/type_timestamp.test'
--- plugin/haildb/tests/t/type_timestamp.test	2010-12-10 05:45:44 +0000
+++ plugin/haildb/tests/t/type_timestamp.test	2011-01-14 20:07:36 +0000
@@ -83,15 +83,15 @@
 # (for both strings and numbers)
 #
 create table t1 (ix timestamp);
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix timestamp
 insert into t1 values (0),(20030101010160),(20030101016001),(20030101240101),(20030132010101),(20031301010101),(20031200000000),(20030000000000);
 select ix+0 from t1;
 truncate table t1;
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix timestamp
 insert into t1 values ("00000000000000"),("20030101010160"),("20030101016001"),("20030101240101"),("20030132010101"),("20031301010101"),("20031200000000"),("20030000000000");
 select ix+0 from t1;
 truncate table t1;
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix timestamp
 insert into t1 values ("0000-00-00 00:00:00 some trailer"),("2003-01-01 00:00:00 some trailer");
 select ix+0 from t1;
 drop table t1;

=== modified file 'plugin/memory/tests/t/primary_key.test'
--- plugin/memory/tests/t/primary_key.test	2010-12-17 22:39:43 +0000
+++ plugin/memory/tests/t/primary_key.test	2011-01-14 20:07:36 +0000
@@ -21,7 +21,7 @@
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883aaaa");
 SELECT a FROM t1 ORDER BY a;
 
---error 1716
+--error ER_INVALID_UUID_VALUE
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883");
 SELECT a FROM t1 ORDER BY a;
 

=== modified file 'plugin/myisam/tests/r/mix2_myisam.result'
--- plugin/myisam/tests/r/mix2_myisam.result	2010-12-07 09:12:12 +0000
+++ plugin/myisam/tests/r/mix2_myisam.result	2011-01-14 20:07:36 +0000
@@ -873,10 +873,12 @@
 create TEMPORARY table t2 (col1 int,stamp TIMESTAMP,INDEX stamp_idx
 (stamp))ENGINE=MyISAM;
 insert into t1 values (1),(2),(3);
-insert into t2 values (1, 20020204130000),(2, 20020204130000),(4,20020204310000 ),(5,20020204230000);
-ERROR HY000: Received an invalid value '20020204310000' for a UNIX timestamp.
-SELECT col1 FROM t1 UNION SELECT col1 FROM t2 WHERE stamp <
-'20020204120000' GROUP BY col1;
+insert into t2 values (1, 20020204130000);
+insert into t2 values (2, 20020204130000);
+insert into t2 values (4, 20020204310000);
+ERROR HY000: Received an invalid timestamp value '20020204310000'.
+insert into t2 values (5, 20020204230000);
+SELECT col1 FROM t1 UNION SELECT col1 FROM t2 WHERE stamp < '20020204120000' GROUP BY col1;
 col1
 1
 2

=== modified file 'plugin/transaction_log/tests/r/transaction_log_data_type.result'
--- plugin/transaction_log/tests/r/transaction_log_data_type.result	2011-01-11 14:22:54 +0000
+++ plugin/transaction_log/tests/r/transaction_log_data_type.result	2011-01-14 20:07:36 +0000
@@ -3405,7 +3405,7 @@
 
 Testing MIN-1 TIMESTAMP
 INSERT INTO t1 (b) VALUES('1969-12-31 23:59:59');
-ERROR HY000: Received an invalid value '1969-12-31 23:59:59' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '1969-12-31 23:59:59'.
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
@@ -3460,16 +3460,15 @@
 
 Testing MAX+1 TIMESTAMP
 INSERT INTO t1 (b) VALUES('2038-01-19 03:14:08');
-ERROR HY000: Received an invalid value '2038-01-19 03:14:08' for a UNIX timestamp.
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-3
+4
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-3
+4
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3501,8 +3500,8 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "2"
-      insert_value: "2038-01-19 03:14:07"
+      insert_value: "3"
+      insert_value: "2038-01-19 03:14:08"
       is_null: false
       is_null: false
     }
@@ -3518,12 +3517,12 @@
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-4
+5
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-4
+5
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3555,7 +3554,7 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "3"
+      insert_value: "4"
       insert_value: "2000-01-01 12:15:59"
       is_null: false
       is_null: false
@@ -3572,12 +3571,12 @@
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-5
+6
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-5
+6
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3609,7 +3608,7 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "4"
+      insert_value: "5"
       insert_value: "1999-06-01 12:15:47"
       is_null: false
       is_null: false
@@ -3626,12 +3625,12 @@
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-6
+7
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-6
+7
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3663,7 +3662,7 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "5"
+      insert_value: "6"
       insert_value: ""
       is_null: false
       is_null: true
@@ -3677,16 +3676,16 @@
 
 Testing BAD INPUT TIMESTAMP1
 INSERT INTO t1 (b) VALUES('2000-01-01 25:00:00');
-ERROR HY000: Received an invalid value '2000-01-01 25:00:00' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '2000-01-01 25:00:00'.
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-6
+7
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-6
+7
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3718,7 +3717,7 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "5"
+      insert_value: "6"
       insert_value: ""
       is_null: false
       is_null: true
@@ -3732,16 +3731,16 @@
 
 Testing BAD INPUT TIMESTAMP2
 INSERT INTO t1 (b) VALUES('2000-01-01 12:60:00');
-ERROR HY000: Received an invalid value '2000-01-01 12:60:00' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '2000-01-01 12:60:00'.
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-6
+7
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-6
+7
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3773,7 +3772,7 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "5"
+      insert_value: "6"
       insert_value: ""
       is_null: false
       is_null: true
@@ -3787,16 +3786,16 @@
 
 Testing BAD INPUT TIMESTAMP3
 INSERT INTO t1 (b) VALUES('2000-01-01 12:00:65');
-ERROR HY000: Received an invalid value '2000-01-01 12:00:65' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '2000-01-01 12:00:65'.
 Check transaction_log_entries
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_ENTRIES;
 COUNT(*)
-6
+7
 
 Check transaction_log_transactions
 SELECT COUNT(*) FROM DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS;
 COUNT(*)
-6
+7
 Check transaction log contents
 SELECT PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS));
 PRINT_TRANSACTION_MESSAGE('transaction.log',(select max(entry_offset) from DATA_DICTIONARY.TRANSACTION_LOG_TRANSACTIONS))
@@ -3828,7 +3827,7 @@
     segment_id: 1
     end_segment: true
     record {
-      insert_value: "5"
+      insert_value: "6"
       insert_value: ""
       is_null: false
       is_null: true

=== modified file 'plugin/transaction_log/tests/t/transaction_log_data_type.test'
--- plugin/transaction_log/tests/t/transaction_log_data_type.test	2010-12-20 19:20:57 +0000
+++ plugin/transaction_log/tests/t/transaction_log_data_type.test	2011-01-14 20:07:36 +0000
@@ -470,13 +470,12 @@
 --echo
 
 --echo Testing MIN-1 TIMESTAMP
---ERROR 1685 
+--ERROR ER_INVALID_TIMESTAMP_VALUE 
 INSERT INTO t1 (b) VALUES('1969-12-31 23:59:59');
 --source ../plugin/transaction_log/tests/t/check_transaction_log.inc
 --echo
 
 --echo Testing MAX+1 TIMESTAMP
---ERROR 1685 
 INSERT INTO t1 (b) VALUES('2038-01-19 03:14:08');
 --source ../plugin/transaction_log/tests/t/check_transaction_log.inc
 --echo
@@ -497,19 +496,19 @@
 --echo
 
 --echo Testing BAD INPUT TIMESTAMP1
---ERROR 1685 
+--ERROR ER_INVALID_TIMESTAMP_VALUE 
 INSERT INTO t1 (b) VALUES('2000-01-01 25:00:00');
 --source ../plugin/transaction_log/tests/t/check_transaction_log.inc
 --echo
 
 --echo Testing BAD INPUT TIMESTAMP2
---ERROR 1685
+--ERROR ER_INVALID_TIMESTAMP_VALUE
 INSERT INTO t1 (b) VALUES('2000-01-01 12:60:00');
 --source ../plugin/transaction_log/tests/t/check_transaction_log.inc
 --echo
 
 --echo Testing BAD INPUT TIMESTAMP3
---ERROR 1685 
+--ERROR ER_INVALID_TIMESTAMP_VALUE 
 INSERT INTO t1 (b) VALUES('2000-01-01 12:00:65');
 --source ../plugin/transaction_log/tests/t/check_transaction_log.inc
 --echo

=== modified file 'tests/include/mix2.inc'
--- tests/include/mix2.inc	2010-12-07 09:12:12 +0000
+++ tests/include/mix2.inc	2011-01-14 20:07:36 +0000
@@ -929,11 +929,12 @@
 eval create $temp table t2 (col1 int,stamp TIMESTAMP,INDEX stamp_idx
 (stamp))ENGINE=$engine_type;
 insert into t1 values (1),(2),(3);
-# Note that timestamp 3 is wrong
---error 1685 # Bad timestamp
-insert into t2 values (1, 20020204130000),(2, 20020204130000),(4,20020204310000 ),(5,20020204230000);
-SELECT col1 FROM t1 UNION SELECT col1 FROM t2 WHERE stamp <
-'20020204120000' GROUP BY col1;
+insert into t2 values (1, 20020204130000);
+insert into t2 values (2, 20020204130000);
+--error ER_INVALID_TIMESTAMP_VALUE # Bad timestamp
+insert into t2 values (4, 20020204310000);
+insert into t2 values (5, 20020204230000);
+SELECT col1 FROM t1 UNION SELECT col1 FROM t2 WHERE stamp < '20020204120000' GROUP BY col1;
 drop table t1,t2;
 
 #

=== modified file 'tests/r/func_time.result'
--- tests/r/func_time.result	2011-01-08 10:35:13 +0000
+++ tests/r/func_time.result	2011-01-14 20:07:36 +0000
@@ -408,15 +408,18 @@
 unix_timestamp(from_unixtime(2147483648))
 NULL
 select unix_timestamp('2039-01-20 01:00:00');
-ERROR HY000: Received an invalid value '2039-01-20 01:00:00' for a UNIX timestamp.
+unix_timestamp('2039-01-20 01:00:00')
[phone]
 select unix_timestamp('1968-01-20 01:00:00');
 ERROR HY000: Received an invalid value '1968-01-20 01:00:00' for a UNIX timestamp.
 select unix_timestamp('2038-02-10 01:00:00');
-ERROR HY000: Received an invalid value '2038-02-10 01:00:00' for a UNIX timestamp.
+unix_timestamp('2038-02-10 01:00:00')
[phone]
 select unix_timestamp('1969-11-20 01:00:00');
 ERROR HY000: Received an invalid value '1969-11-20 01:00:00' for a UNIX timestamp.
 select unix_timestamp('2038-01-20 01:00:00');
-ERROR HY000: Received an invalid value '2038-01-20 01:00:00' for a UNIX timestamp.
+unix_timestamp('2038-01-20 01:00:00')
[phone]
 select unix_timestamp('1969-12-30 01:00:00');
 ERROR HY000: Received an invalid value '1969-12-30 01:00:00' for a UNIX timestamp.
 select unix_timestamp('2038-01-17 12:00:00');

=== modified file 'tests/r/insert.result'
--- tests/r/insert.result	2010-04-20 18:23:07 +0000
+++ tests/r/insert.result	2011-01-14 20:07:36 +0000
@@ -24,7 +24,7 @@
 insert into t1 values (default,default,default,default);
 insert into t1 values (default,default,default,default);
 insert into t1 values (4,0,"a",5);
-ERROR HY000: Received an invalid value '0' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0'.
 insert into t1 values (default,default,default,default);
 select a,t is not null,c,i from t1;
 a	t is not null	c	i

=== modified file 'tests/r/timezone.result'
--- tests/r/timezone.result	2009-02-28 20:43:31 +0000
+++ tests/r/timezone.result	2011-01-14 20:07:36 +0000
@@ -45,4 +45,5 @@
 unix_timestamp('2038-01-19 03:14:07')
 2147483647
 select unix_timestamp('2038-01-19 03:14:08');
-ERROR HY000: Received an invalid value '2038-01-19 03:14:08' for a UNIX timestamp.
+unix_timestamp('2038-01-19 03:14:08')
[phone]

=== modified file 'tests/r/type_timestamp.result'
--- tests/r/type_timestamp.result	2010-09-02 18:35:05 +0000
+++ tests/r/type_timestamp.result	2011-01-14 20:07:36 +0000
@@ -112,17 +112,17 @@
 drop table t1;
 create table t1 (ix timestamp);
 insert into t1 values (0),(20030101010160),(20030101016001),(20030101240101),(20030132010101),(20031301010101),(20031200000000),(20030000000000);
-ERROR HY000: Received an invalid value '0' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0'.
 select ix+0 from t1;
 ix+0
 truncate table t1;
 insert into t1 values ("00000000000000"),("20030101010160"),("20030101016001"),("20030101240101"),("20030132010101"),("20031301010101"),("20031200000000"),("20030000000000");
-ERROR HY000: Received an invalid value '00000000000000' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '00000000000000'.
 select ix+0 from t1;
 ix+0
 truncate table t1;
 insert into t1 values ("0000-00-00 00:00:00 some trailer"),("2003-01-01 00:00:00 some trailer");
-ERROR HY000: Received an invalid value '0000-00-00 00:00:00 some trailer' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0000-00-00 00:00:00 some trailer'.
 select ix+0 from t1;
 ix+0
 drop table t1;

=== modified file 'tests/suite/microtime_type/r/basic.result'
--- tests/suite/microtime_type/r/basic.result	2011-01-07 21:56:29 +0000
+++ tests/suite/microtime_type/r/basic.result	2011-01-14 20:07:36 +0000
@@ -112,17 +112,17 @@
 drop table t1;
 create table t1 (ix TIMESTAMP(6));
 insert into t1 values (0),(20030101010160),(20030101016001),(20030101240101),(20030132010101),(20031301010101),(20031200000000),(20030000000000);
-ERROR HY000: Received an invalid value '0' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0'.
 select ix+0 from t1;
 ix+0
 truncate table t1;
 insert into t1 values ("00000000000000"),("20030101010160"),("20030101016001"),("20030101240101"),("20030132010101"),("20031301010101"),("20031200000000"),("20030000000000");
-ERROR HY000: Received an invalid value '00000000000000' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '00000000000000'.
 select ix+0 from t1;
 ix+0
 truncate table t1;
 insert into t1 values ("0000-00-00 00:00:00 some trailer"),("2003-01-01 00:00:00 some trailer");
-ERROR HY000: Received an invalid value '0000-00-00 00:00:00 some trailer' for a UNIX timestamp.
+ERROR HY000: Received an invalid timestamp value '0000-00-00 00:00:00 some trailer'.
 select ix+0 from t1;
 ix+0
 drop table t1;

=== added file 'tests/suite/microtime_type/r/decimal.result'
--- tests/suite/microtime_type/r/decimal.result	1970-01-01 00:00:00 +0000
+++ tests/suite/microtime_type/r/decimal.result	2011-01-14 20:07:36 +0000
@@ -0,0 +1,19 @@
+CREATE TABLE t1 (    
+_value decimal(20,6)
+);
+INSERT INTO t1 VALUES ("20030101000000.90000"), ("20030101000000.00000"), ("20030101000000.123456") ;
+SELECT _value FROM t1;
+_value
+20030101000000.000000
+20030101000000.123456
+20030101000000.900000
+CREATE TABLE t2 (
+_value TIMESTAMP(6)
+);
+INSERT INTO t2 SELECT _value from t1;
+SELECT _value FROM t2;
+_value
[phone]:00:00.000000
[phone]:00:00.125000
[phone]:00:00.898437
+DROP TABLE t1,t2;

=== added file 'tests/suite/microtime_type/r/max.result'
--- tests/suite/microtime_type/r/max.result	1970-01-01 00:00:00 +0000
+++ tests/suite/microtime_type/r/max.result	2011-01-14 20:07:36 +0000
@@ -0,0 +1,8 @@
+CREATE TABLE t2 (
+_value TIMESTAMP(6)
+);
+INSERT into t2 VALUES ("20660101000000.00000");
+SELECT _value FROM t2;
+_value
[phone]:00:00.000000
+DROP TABLE t2;

=== modified file 'tests/suite/microtime_type/t/basic.test'
--- tests/suite/microtime_type/t/basic.test	2011-01-06 19:13:50 +0000
+++ tests/suite/microtime_type/t/basic.test	2011-01-14 20:07:36 +0000
@@ -83,15 +83,15 @@
 # (for both strings and numbers)
 #
 create table t1 (ix TIMESTAMP(6));
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix TIMESTAMP(6)
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix TIMESTAMP(6)
 insert into t1 values (0),(20030101010160),(20030101016001),(20030101240101),(20030132010101),(20031301010101),(20031200000000),(20030000000000);
 select ix+0 from t1;
 truncate table t1;
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix TIMESTAMP(6)
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix TIMESTAMP(6)
 insert into t1 values ("00000000000000"),("20030101010160"),("20030101016001"),("20030101240101"),("20030132010101"),("20031301010101"),("20031200000000"),("20030000000000");
 select ix+0 from t1;
 truncate table t1;
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix TIMESTAMP(6)
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix TIMESTAMP(6)
 insert into t1 values ("0000-00-00 00:00:00 some trailer"),("2003-01-01 00:00:00 some trailer");
 select ix+0 from t1;
 drop table t1;

=== added file 'tests/suite/microtime_type/t/decimal.test'
--- tests/suite/microtime_type/t/decimal.test	1970-01-01 00:00:00 +0000
+++ tests/suite/microtime_type/t/decimal.test	2011-01-14 20:07:36 +0000
@@ -0,0 +1,17 @@
+CREATE TABLE t1 (    
+    _value decimal(20,6)
+ );
+  
+INSERT INTO t1 VALUES ("20030101000000.90000"), ("20030101000000.00000"), ("20030101000000.123456") ;
+--sorted_result
+SELECT _value FROM t1;
+
+CREATE TABLE t2 (
+  _value TIMESTAMP(6)
+);
+  
+INSERT INTO t2 SELECT _value from t1;
+--sorted_result
+SELECT _value FROM t2;
+    
+DROP TABLE t1,t2;

=== added file 'tests/suite/microtime_type/t/max.test'
--- tests/suite/microtime_type/t/max.test	1970-01-01 00:00:00 +0000
+++ tests/suite/microtime_type/t/max.test	2011-01-14 20:07:36 +0000
@@ -0,0 +1,10 @@
+# Just a quick test to make sure we are not limited to the old max
+CREATE TABLE t2 (
+  _value TIMESTAMP(6)
+);
+
+INSERT into t2 VALUES ("20660101000000.00000");
+
+SELECT _value FROM t2;
+    
+DROP TABLE t2;

=== added file 'tests/suite/regression/r/592690.result'
--- tests/suite/regression/r/592690.result	1970-01-01 00:00:00 +0000
+++ tests/suite/regression/r/592690.result	2011-01-14 20:07:36 +0000
@@ -0,0 +1,3 @@
+select from_unixtime(1272945599.90000), from_unixtime(1272945599), from_unixtime("1272945599.90000");
+from_unixtime(1272945599.90000)	from_unixtime(1272945599)	from_unixtime("1272945599.90000")
[phone]:59:59.900000	2010-05-04 03:59:59	2010-05-04 03:59:59.900000

=== added file 'tests/suite/regression/t/592690.test'
--- tests/suite/regression/t/592690.test	1970-01-01 00:00:00 +0000
+++ tests/suite/regression/t/592690.test	2011-01-14 20:07:36 +0000
@@ -0,0 +1,2 @@
+# Decimal should be recorded properly from_unixtime();
+select from_unixtime(1272945599.90000), from_unixtime(1272945599), from_unixtime("1272945599.90000");

=== modified file 'tests/suite/uuid_type/t/insert_null_no_key.test'
--- tests/suite/uuid_type/t/insert_null_no_key.test	2010-12-17 08:22:10 +0000
+++ tests/suite/uuid_type/t/insert_null_no_key.test	2011-01-14 20:07:36 +0000
@@ -19,7 +19,7 @@
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883aaaa");
 SELECT a FROM t1 ORDER BY a;
 
---error 1716
+--error ER_INVALID_UUID_VALUE
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883");
 SELECT a FROM t1 ORDER BY a;
 

=== modified file 'tests/suite/uuid_type/t/primary_key.test'
--- tests/suite/uuid_type/t/primary_key.test	2010-12-17 08:22:10 +0000
+++ tests/suite/uuid_type/t/primary_key.test	2011-01-14 20:07:36 +0000
@@ -21,7 +21,7 @@
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883aaaa");
 SELECT a FROM t1 ORDER BY a;
 
---error 1716
+--error ER_INVALID_UUID_VALUE
 INSERT INTO t1 VALUES ("d9163f3c-6228-4f62-9c21-0af56883");
 SELECT a FROM t1 ORDER BY a;
 

=== modified file 'tests/t/func_time.test'
--- tests/t/func_time.test	2011-01-05 07:43:57 +0000
+++ tests/t/func_time.test	2011-01-14 20:07:36 +0000
@@ -242,19 +242,19 @@
 
 # check for invalid dates
 
-# bad year
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
+# Legal, Drizzle has 64bit timestamp
 select unix_timestamp('2039-01-20 01:00:00');
+
 --error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
 select unix_timestamp('1968-01-20 01:00:00');
-# bad month
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
+
 select unix_timestamp('2038-02-10 01:00:00');
+
 --error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
 select unix_timestamp('1969-11-20 01:00:00');
-# bad day
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
+
 select unix_timestamp('2038-01-20 01:00:00');
+
 --error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
 select unix_timestamp('1969-12-30 01:00:00');
 

=== modified file 'tests/t/insert.test'
--- tests/t/insert.test	2010-08-26 21:56:15 +0000
+++ tests/t/insert.test	2011-01-14 20:07:36 +0000
@@ -33,7 +33,7 @@
 create table t1 (a int not null auto_increment, primary key (a), t timestamp null, c char(10) default "hello", i int);
 insert into t1 values (default,default,default,default);
 insert into t1 values (default,default,default,default);
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad timestamp
 insert into t1 values (4,0,"a",5);
 insert into t1 values (default,default,default,default);
 select a,t is not null,c,i from t1;

=== modified file 'tests/t/timezone.test'
--- tests/t/timezone.test	2010-08-26 21:56:15 +0000
+++ tests/t/timezone.test	2011-01-14 20:07:36 +0000
@@ -54,11 +54,11 @@
 #
 # Test for fix for Bug#2523 Check that boundary dates are processed
 # correctly.
+# -- scratch the above, Drizzle allows for longer dates.
 #
 select unix_timestamp('1970-01-01 00:00:00');
 select unix_timestamp('1970-01-01 00:00:01');
 select unix_timestamp('2038-01-19 03:14:07');
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad timestamp
 select unix_timestamp('2038-01-19 03:14:08');
 
 # End of 4.1 tests

=== modified file 'tests/t/type_timestamp.test'
--- tests/t/type_timestamp.test	2010-08-26 21:56:15 +0000
+++ tests/t/type_timestamp.test	2011-01-14 20:07:36 +0000
@@ -83,15 +83,15 @@
 # (for both strings and numbers)
 #
 create table t1 (ix timestamp);
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix timestamp
 insert into t1 values (0),(20030101010160),(20030101016001),(20030101240101),(20030132010101),(20031301010101),(20031200000000),(20030000000000);
 select ix+0 from t1;
 truncate table t1;
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix timestamp
 insert into t1 values ("00000000000000"),("20030101010160"),("20030101016001"),("20030101240101"),("20030132010101"),("20031301010101"),("20031200000000"),("20030000000000");
 select ix+0 from t1;
 truncate table t1;
---error ER_INVALID_UNIX_TIMESTAMP_VALUE # Bad unix timestamp
+--error ER_INVALID_TIMESTAMP_VALUE # Bad unix timestamp
 insert into t1 values ("0000-00-00 00:00:00 some trailer"),("2003-01-01 00:00:00 some trailer");
 select ix+0 from t1;
 drop table t1;

=== modified file 'unittests/calendar_test.cc'
--- unittests/calendar_test.cc	2010-06-05 21:39:51 +0000
+++ unittests/calendar_test.cc	2011-01-14 20:07:36 +0000
@@ -115,7 +115,7 @@
 {
   uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 8;
 
-  ASSERT_FALSE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  ASSERT_TRUE(in_unix_epoch_range(year, month, day, hour, minute, second));
 }
 
 TEST(calendar_in_unix_epoch_range_test, InsideRange)

=== modified file 'unittests/micro_timestamp_test.cc'
--- unittests/micro_timestamp_test.cc	2011-01-05 17:21:13 +0000
+++ unittests/micro_timestamp_test.cc	2011-01-14 20:07:36 +0000
@@ -71,7 +71,7 @@
 
   result= micro_timestamp.is_valid();
 
-  ASSERT_FALSE(result);
+  ASSERT_TRUE(result);
 }
 
 TEST_F(MicroTimestampTest, is_valid_InsideOfMicroTimestampRange_shouldReturn_True)

=== modified file 'unittests/nano_timestamp_test.cc'
--- unittests/nano_timestamp_test.cc	2010-06-09 17:12:30 +0000
+++ unittests/nano_timestamp_test.cc	2011-01-14 20:07:36 +0000
@@ -71,7 +71,7 @@
 
   result= nano_timestamp.is_valid();
 
-  ASSERT_FALSE(result);
+  ASSERT_TRUE(result);
 }
 
 TEST_F(NanoTimestampTest, is_valid_InsideOfNanoTimestampRange_shouldReturn_True)

=== modified file 'unittests/timestamp_test.cc'
--- unittests/timestamp_test.cc	2010-12-21 20:27:48 +0000
+++ unittests/timestamp_test.cc	2011-01-14 20:07:36 +0000
@@ -225,7 +225,7 @@
   
   result= timestamp.is_valid();
   
-  ASSERT_FALSE(result);
+  ASSERT_TRUE(result);
 }
 
 TEST_F(TimestampTest, is_valid_InsideOfTimestampRange_shouldReturn_True)