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

[Brian Aker]

[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]

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

[Lee Bieber (kalebral-deactivatedaccount)]

http://hudson.drizzle.org/view/Drizzle-build/job/drizzle-build-sparc-solaris10/1700/console

/bin/bash ./libtool --tag=CXX --mode=link CC -xlang=c99 -D_REENTRANT -mt -compat=5 -library=stlport4 -library=Crun -template=no%extdef -g0 -xO3 -xlibmil -xdepend -xbuiltin +w +w2 -xwe -xport64 -errtags=yes -erroff=attrskipunsup,doubunder,reftotemp,inllargeuse,truncwarn1,signextwarn,inllargeint -errwarn=%all -DBUILDING_DRIZZLED -D_REENTRANT -m64 -L/usr/local/lib/sparcv9 -L/usr/local/lib -o plugin/libcollation_dictionary_plugin.la plugin/collation_dictionary/plugin_libcollation_dictionary_plugin_la-character_sets.lo plugin/collation_dictionary/plugin_libcollation_dictionary_plugin_la-collations.lo plugin/collation_dictionary/plugin_libcollation_dictionary_plugin_la-dictionary.lo -lnsl -lpthread -lintl -lsocket -lrt -lintl -lumem
"drizzled/type/time.cc", line 1121: Error, notused: arg is defined but not used.
1 Error(s) detected.
gmake[2]: *** [drizzled/type/time.o] Error 1
gmake[2]: *** Waiting for unfinished jobs....

review: Needs Fixing

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

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.

=== modified file 'drizzled/calendar.cc'
--- drizzled/calendar.cc	2010-12-18 04:43:40 +0000
+++ drizzled/calendar.cc	2011-01-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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.cc'
--- drizzled/field.cc	2011-01-05 17:21:13 +0000
+++ drizzled/field.cc	2011-01-18 01:47:30 +0000
@@ -1015,7 +1015,7 @@
   char buff[40];
   String tmp(buff,sizeof(buff),&my_charset_bin),*res;
   if (!(res=val_str_internal(&tmp)) || str_to_datetime_with_warn(res->ptr(), res->length(),
-                                                                 ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
+                                                                 ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
   {
     return 1;
   }
@@ -1036,11 +1036,13 @@
   return 0;
 }
 
-int Field::store_time(type::Time *ltime, enum enum_drizzle_timestamp_type)
+int Field::store_time(type::Time *ltime, type::timestamp_t)
 {
-  char buff[MAX_DATE_STRING_REP_LENGTH];
-  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
-  return store(buff, length, &my_charset_bin);
+  String tmp;
+
+  ltime->convert(tmp);
+
+  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
 }
 
 bool Field::optimize_range(uint32_t idx, uint32_t)
@@ -1195,7 +1197,7 @@
                                  unsigned int code,
                                  const char *str, 
                                  uint32_t str_length,
-                                 enum enum_drizzle_timestamp_type ts_type, 
+                                 type::timestamp_t ts_type, 
                                  int cuted_increment)
 {
   Session *session= table ? table->in_use : current_session;
@@ -1209,7 +1211,7 @@
 void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
                                  uint32_t code,
                                  int64_t nr, 
-                                 enum enum_drizzle_timestamp_type ts_type,
+                                 type::timestamp_t ts_type,
                                  int cuted_increment)
 {
   Session *session= table ? table->in_use : current_session;
@@ -1226,7 +1228,7 @@
 void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
                                  const uint32_t code,
                                  double nr, 
-                                 enum enum_drizzle_timestamp_type ts_type)
+                                 type::timestamp_t ts_type)
 {
   Session *session= table ? table->in_use : current_session;
   if (session->really_abort_on_warning() ||

=== modified file 'drizzled/field.h'
--- drizzled/field.h	2011-01-13 01:04:53 +0000
+++ drizzled/field.h	2011-01-18 01:47:30 +0000
@@ -211,7 +211,7 @@
     @note
       Needs to be changed if/when we want to support different time formats.
   */
-  virtual int store_time(type::Time *ltime, enum enum_drizzle_timestamp_type t_type);
+  virtual int store_time(type::Time *ltime, type::timestamp_t t_type);
   virtual double val_real()=0;
   virtual int64_t val_int()=0;
   virtual type::Decimal *val_decimal(type::Decimal *);
@@ -644,7 +644,7 @@
                             uint32_t code,
                             const char *str,
                             uint32_t str_len,
-                            enum enum_drizzle_timestamp_type ts_type,
+                            type::timestamp_t ts_type,
                             int cuted_increment);
   /**
     Produce warning or note about integer datetime value saved into field.
@@ -663,7 +663,7 @@
   void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
                             uint32_t code,
                             int64_t nr,
-                            enum enum_drizzle_timestamp_type ts_type,
+                            type::timestamp_t ts_type,
                             int cuted_increment);
   /**
     Produce warning or note about double datetime data saved into field.
@@ -681,7 +681,7 @@
   void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
                             const uint32_t code,
                             double nr,
-                            enum enum_drizzle_timestamp_type ts_type);
+                            type::timestamp_t ts_type);
   bool check_overflow(int op_result)
   {
     return (op_result == E_DEC_OVERFLOW);

=== modified file 'drizzled/field/date.cc'
--- drizzled/field/date.cc	2010-12-25 04:38:28 +0000
+++ drizzled/field/date.cc	2011-01-18 01:47:30 +0000
@@ -124,34 +124,35 @@
 }
 
 int Field_date::store_time(type::Time *ltime,
-                              enum enum_drizzle_timestamp_type time_type)
+                           type::timestamp_t time_type)
 {
   long tmp;
   int error= 0;
-  if (time_type == DRIZZLE_TIMESTAMP_DATE ||
-      time_type == DRIZZLE_TIMESTAMP_DATETIME)
+  if (time_type == type::DRIZZLE_TIMESTAMP_DATE || time_type == 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 &
                      (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))), &error))
     {
-      char buff[MAX_DATE_STRING_REP_LENGTH];
+      char buff[type::Time::MAX_STRING_LENGTH];
       String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
-      make_date(ltime, &str);
+      ltime->convert(str, type::DRIZZLE_TIMESTAMP_DATE);
       set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
-                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
+                           str.ptr(), str.length(), type::DRIZZLE_TIMESTAMP_DATE, 1);
     }
-    if (!error && ltime->time_type != DRIZZLE_TIMESTAMP_DATE &&
+
+    if (not error && ltime->time_type != type::DRIZZLE_TIMESTAMP_DATE &&
         (ltime->hour || ltime->minute || ltime->second || ltime->second_part))
     {
-      char buff[MAX_DATE_STRING_REP_LENGTH];
+      char buff[type::Time::MAX_STRING_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);
+                           str.ptr(), str.length(), type::DRIZZLE_TIMESTAMP_DATE, 1);
       error= 3;
     }
   }
@@ -161,7 +162,9 @@
     error= 1;
     set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
   }
+
   int4store(ptr,tmp);
+
   return error;
 }
 
@@ -215,7 +218,7 @@
   ltime->day=		(int) (tmp%100);
   ltime->month= 	(int) (tmp/100%100);
   ltime->year= 		(int) (tmp/10000);
-  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
+  ltime->time_type= type::DRIZZLE_TIMESTAMP_DATE;
   ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
   return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
           1 : 0);

=== modified file 'drizzled/field/date.h'
--- drizzled/field/date.h	2010-12-25 04:38:28 +0000
+++ drizzled/field/date.h	2011-01-18 01:47:30 +0000
@@ -64,7 +64,7 @@
              const CHARSET_INFO * const charset);
   int  store(double nr);
   int  store(int64_t nr, bool unsigned_val);
-  int store_time(type::Time *ltime, enum enum_drizzle_timestamp_type type);
+  int store_time(type::Time *ltime, type::timestamp_t type);
   int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
   double val_real(void);
   int64_t val_int(void);

=== modified file 'drizzled/field/datetime.cc'
--- drizzled/field/datetime.cc	2010-12-25 04:38:28 +0000
+++ drizzled/field/datetime.cc	2011-01-18 01:47:30 +0000
@@ -121,7 +121,7 @@
   return 0;
 }
 
-int Field_datetime::store_time(type::Time *ltime, enum enum_drizzle_timestamp_type)
+int Field_datetime::store_time(type::Time *ltime, type::timestamp_t)
 {
   DateTime temporal;
 
@@ -134,11 +134,11 @@
 
   if (! temporal.is_valid())
   {
-    char tmp_string[MAX_DATE_STRING_REP_LENGTH];
+    char tmp_string[type::Time::MAX_STRING_LENGTH];
     size_t tmp_string_len;
 
-    tmp_string_len= temporal.to_string(tmp_string, MAX_DATE_STRING_REP_LENGTH);
-    assert(tmp_string_len < MAX_DATE_STRING_REP_LENGTH);
+    tmp_string_len= temporal.to_string(tmp_string, type::Time::MAX_STRING_LENGTH);
+    assert(tmp_string_len < type::Time::MAX_STRING_LENGTH);
     my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp_string);
     return 1;
   }
@@ -223,7 +223,7 @@
   part1=(uint32_t) (tmp/INT64_C(1000000));
   part2=(uint32_t) (tmp - (uint64_t) part1*INT64_C(1000000));
 
-  ltime->time_type=	DRIZZLE_TIMESTAMP_DATETIME;
+  ltime->time_type=	type::DRIZZLE_TIMESTAMP_DATETIME;
   ltime->neg=		0;
   ltime->second_part=	0;
   ltime->second=	(int) (part2%100);

=== modified file 'drizzled/field/datetime.h'
--- drizzled/field/datetime.h	2010-12-25 04:38:28 +0000
+++ drizzled/field/datetime.h	2011-01-18 01:47:30 +0000
@@ -63,7 +63,7 @@
   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_time(type::Time *ltime, enum enum_drizzle_timestamp_type type);
+  int store_time(type::Time *ltime, type::timestamp_t type);
   int reset(void)
   {
     ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0;

=== modified file 'drizzled/field/decimal.cc'
--- drizzled/field/decimal.cc	2010-12-27 19:16:17 +0000
+++ drizzled/field/decimal.cc	2011-01-18 01:47:30 +0000
@@ -258,7 +258,7 @@
 
 
 int Field_decimal::store_time(type::Time *ltime,
-                              enum enum_drizzle_timestamp_type )
+                              type::timestamp_t )
 {
   type::Decimal decimal_value;
   return store_value(date2_class_decimal(ltime, &decimal_value));

=== modified file 'drizzled/field/decimal.h'
--- drizzled/field/decimal.h	2010-12-25 04:38:28 +0000
+++ drizzled/field/decimal.h	2011-01-18 01:47:30 +0000
@@ -68,7 +68,7 @@
   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_time(type::Time *ltime, enum enum_drizzle_timestamp_type t_type);
+  int store_time(type::Time *ltime, type::timestamp_t t_type);
   int  store_decimal(const type::Decimal *);
   double val_real(void);
   int64_t val_int(void);

=== modified file 'drizzled/field/epoch.cc'
--- drizzled/field/epoch.cc	2011-01-06 18:00:47 +0000
+++ drizzled/field/epoch.cc	2011-01-18 01:47:30 +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;
   }
 
@@ -269,30 +283,21 @@
 bool Epoch::get_date(type::Time *ltime, uint32_t)
 {
   uint64_t temp;
+  type::Time::epoch_t time_temp;
 
   unpack_num(temp);
+  time_temp= temp;
   
-  memset(ltime, 0, sizeof(*ltime));
-
-  Timestamp temporal;
-  (void) temporal.from_time_t((time_t) temp);
-
-  /* @TODO Goodbye the below code when type::Time is finally gone.. */
-
-  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
-  ltime->year= temporal.years();
-  ltime->month= temporal.months();
-  ltime->day= temporal.days();
-  ltime->hour= temporal.hours();
-  ltime->minute= temporal.minutes();
-  ltime->second= temporal.seconds();
+  ltime->reset();
+
+  ltime->store(time_temp);
 
   return 0;
 }
 
 bool Epoch::get_time(type::Time *ltime)
 {
-  return Epoch::get_date(ltime,0);
+  return Epoch::get_date(ltime, 0);
 }
 
 int Epoch::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)

=== modified file 'drizzled/field/epoch.h'
--- drizzled/field/epoch.h	2011-01-06 18:00:47 +0000
+++ drizzled/field/epoch.h	2011-01-18 01:47:30 +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-18 01:47:30 +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;
   }
 
@@ -90,12 +90,12 @@
   return 0;
 }
 
-int Microtime::store_time(type::Time *ltime, enum enum_drizzle_timestamp_type )
+int Microtime::store_time(type::Time *ltime, type::timestamp_t )
 {
   long my_timezone;
   bool in_dst_time_gap;
 
-  time_t time_tmp= my_system_gmt_sec(ltime, &my_timezone, &in_dst_time_gap, true);
+  type::Time::epoch_t time_tmp= my_system_gmt_sec(ltime, &my_timezone, &in_dst_time_gap, true);
   uint64_t tmp_seconds= time_tmp;
   uint32_t tmp_micro= ltime->second_part;
 
@@ -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,29 +208,16 @@
 String *Microtime::val_str(String *val_buffer, String *)
 {
   uint64_t temp= 0;
-  uint32_t micro_temp= 0;
-  char *to;
-  int to_len= field_length + 1 + 8;
-
-  val_buffer->alloc(to_len);
-  to= (char *) val_buffer->ptr();
+  type::Time::usec_t micro_temp= 0;
 
   unpack_num(temp);
   unpack_num(micro_temp, ptr +8);
 
-  val_buffer->set_charset(&my_charset_bin);	/* Safety */
-
-  struct timeval buffer;
-  buffer.tv_sec= temp;
-  buffer.tv_usec= micro_temp;
-
-  MicroTimestamp temporal;
-  (void) temporal.from_timeval(buffer);
-
-  int rlen= temporal.to_string(to, to_len);
-  assert(rlen <= to_len);
-
-  val_buffer->length(rlen);
+  type::Time tmp_time;
+  tmp_time.store(temp, micro_temp);
+
+  tmp_time.convert(*val_buffer);
+
 
   return val_buffer;
 }
@@ -209,28 +230,16 @@
   unpack_num(temp);
   unpack_num(micro_temp, ptr +8);
   
-  memset(ltime, 0, sizeof(*ltime));
-
-  Timestamp temporal;
-  (void) temporal.from_time_t((time_t) temp);
-
-  /* @TODO Goodbye the below code when type::Time is finally gone.. */
-
-  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
-  ltime->year= temporal.years();
-  ltime->month= temporal.months();
-  ltime->day= temporal.days();
-  ltime->hour= temporal.hours();
-  ltime->minute= temporal.minutes();
-  ltime->second= temporal.seconds();
-  ltime->second_part= temporal.useconds();
-
-  return 0;
+  ltime->reset();
+
+  ltime->store(temp, micro_temp);
+
+  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 +284,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-18 01:47:30 +0000
@@ -54,11 +54,13 @@
             const CHARSET_INFO * const charset);
   int store(double nr);
   int store(int64_t nr, bool unsigned_val);
-  int store_time(type::Time *ltime, enum enum_drizzle_timestamp_type t_type);
+  int store_time(type::Time *ltime, type::timestamp_t 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/field/time.cc'
--- drizzled/field/time.cc	2010-12-25 04:38:28 +0000
+++ drizzled/field/time.cc	2011-01-18 01:47:30 +0000
@@ -101,14 +101,14 @@
   { 
     tmp= TIME_MAX_VALUE;
     set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
-                         ER_WARN_DATA_OUT_OF_RANGE, from, DRIZZLE_TIMESTAMP_TIME);
+                         ER_WARN_DATA_OUT_OF_RANGE, from, type::DRIZZLE_TIMESTAMP_TIME);
     error= 1;
   }
   else if (from < (double) - TIME_MAX_VALUE)
   { 
     tmp= -TIME_MAX_VALUE;
     set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
-                         ER_WARN_DATA_OUT_OF_RANGE, from, DRIZZLE_TIMESTAMP_TIME);
+                         ER_WARN_DATA_OUT_OF_RANGE, from, type::DRIZZLE_TIMESTAMP_TIME);
     error= 1;
   }
   else
@@ -123,7 +123,7 @@
       tmp=0;
       set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
                            ER_WARN_DATA_OUT_OF_RANGE, from,
-                           DRIZZLE_TIMESTAMP_TIME);
+                           type::DRIZZLE_TIMESTAMP_TIME);
       error= 1;
     }
   }
@@ -227,7 +227,7 @@
   drizzled::Time temporal;
   unpack_time(temporal);
 
-  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
+  ltime->time_type= type::DRIZZLE_TIMESTAMP_DATETIME;
   ltime->year= temporal.years();
   ltime->month= temporal.months();
   ltime->day= temporal.days();

=== modified file 'drizzled/field/uuid.cc'
--- drizzled/field/uuid.cc	2010-12-26 01:00:32 +0000
+++ drizzled/field/uuid.cc	2011-01-18 01:47:30 +0000
@@ -31,7 +31,6 @@
 #include "drizzled/internal/my_sys.h"
 #include "drizzled/session.h"
 #include "drizzled/table.h"
-#include "drizzled/temporal.h"
 
 namespace drizzled
 {
@@ -167,27 +166,17 @@
 
   if (uu.isTimeType())
   {
-    Timestamp temporal;
     struct timeval ret_tv;
 
-    ret_tv.tv_sec= ret_tv.tv_usec= 0;
+    memset(&ret_tv, 0, sizeof(struct timeval));
 
     uu.time(ret_tv);
 
-    temporal.from_time_t(ret_tv.tv_sec);
-
-    ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
-    ltime->year= temporal.years();
-    ltime->month= temporal.months();
-    ltime->day= temporal.days();
-    ltime->hour= temporal.hours();
-    ltime->minute= temporal.minutes();
-    ltime->second= temporal.seconds();
-    ltime->second_part= temporal.nseconds();
+    ltime->store(ret_tv);
 
     return false;
   }
-  memset(ltime, 0, sizeof(type::Time));
+  ltime->reset();
 
   return true;
 }

=== 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-18 01:47:30 +0000
@@ -31,10 +31,10 @@
 {
   bool res= get_arg0_time(ltime);
 
-  if (ltime->time_type == DRIZZLE_TIMESTAMP_DATETIME)
+  if (ltime->time_type == type::DRIZZLE_TIMESTAMP_DATETIME)
     ltime->year= ltime->month= ltime->day= 0;
 
-  ltime->time_type= DRIZZLE_TIMESTAMP_TIME;
+  ltime->time_type= type::DRIZZLE_TIMESTAMP_TIME;
 
   return res;
 }
@@ -47,7 +47,8 @@
   if (not get_arg0_time(&ltime))
   {
     null_value= 0;
-    make_time(&ltime, str);
+    ltime.convert(*str, type::DRIZZLE_TIMESTAMP_TIME);
+
     return str;
   }
 

=== modified file 'drizzled/function/time/curdate.cc'
--- drizzled/function/time/curdate.cc	2011-01-06 23:02:43 +0000
+++ drizzled/function/time/curdate.cc	2011-01-18 01:47:30 +0000
@@ -37,7 +37,7 @@
 
   /* We don't need to set second_part and neg because they already 0 */
   ltime.hour= ltime.minute= ltime.second= 0;
-  ltime.time_type= DRIZZLE_TIMESTAMP_DATE;
+  ltime.time_type= type::DRIZZLE_TIMESTAMP_DATE;
 
   /** 
    * @TODO Remove ltime completely when timezones are reworked.  Using this

=== modified file 'drizzled/function/time/date.cc'
--- drizzled/function/time/date.cc	2010-12-18 04:43:40 +0000
+++ drizzled/function/time/date.cc	2011-01-18 01:47:30 +0000
@@ -34,16 +34,16 @@
   if (! get_temporal(temporal))
     return (String *) NULL; /* get_temporal throws error. */
 
-  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
+  if (str->alloc(type::Time::MAX_STRING_LENGTH))
   {
     null_value= true;
     return (String *) NULL;
   }
 
   /* Convert the Date to a string and return it */
-  int new_length;
-  new_length= temporal.to_string(str->c_ptr(), MAX_DATE_STRING_REP_LENGTH);
-  assert(new_length < MAX_DATE_STRING_REP_LENGTH);
+  size_t new_length;
+  new_length= temporal.to_string(str->c_ptr(), type::Time::MAX_STRING_LENGTH);
+  assert(new_length < type::Time::MAX_STRING_LENGTH);
   str->length(new_length);
   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-18 01:47:30 +0000
@@ -113,9 +113,9 @@
   if (Item_date_add_interval::get_date(&ltime, TIME_NO_ZERO_DATE))
     return 0;
 
-  if (ltime.time_type == DRIZZLE_TIMESTAMP_DATE)
+  if (ltime.time_type == type::DRIZZLE_TIMESTAMP_DATE)
   {
-    make_date(&ltime, str);
+    ltime.convert(*str, type::DRIZZLE_TIMESTAMP_DATE);
   }
   else if (ltime.second_part)
   {
@@ -135,7 +135,7 @@
   }
   else
   {
-    make_datetime(&ltime, str);
+    ltime.convert(*str);
   }
 
   return str;
@@ -149,7 +149,7 @@
   if (Item_date_add_interval::get_date(&ltime, TIME_NO_ZERO_DATE))
     return (int64_t) 0;
   date = (ltime.year*100L + ltime.month)*100L + ltime.day;
-  return ltime.time_type == DRIZZLE_TIMESTAMP_DATE ? date :
+  return ltime.time_type == type::DRIZZLE_TIMESTAMP_DATE ? date :
     ((date*100L + ltime.hour)*100L+ ltime.minute)*100L + ltime.second;
 }
 

=== modified file 'drizzled/function/time/date_format.cc'
--- drizzled/function/time/date_format.cc	2010-12-25 04:38:28 +0000
+++ drizzled/function/time/date_format.cc	2011-01-18 01:47:30 +0000
@@ -36,7 +36,7 @@
 */
 
 static bool make_date_time(String *format, type::Time *l_time,
-                           enum enum_drizzle_timestamp_type type, String *str)
+                           type::timestamp_t type, String *str)
 {
   char intbuff[15];
   uint32_t hours_i;
@@ -74,7 +74,7 @@
                     system_charset_info);
         break;
       case 'W':
-        if (type == DRIZZLE_TIMESTAMP_TIME)
+        if (type == type::DRIZZLE_TIMESTAMP_TIME)
           return 1;
         weekday= calc_weekday(calc_daynr(l_time->year,l_time->month,
                               l_time->day),0);
@@ -83,7 +83,7 @@
                     system_charset_info);
         break;
       case 'a':
-        if (type == DRIZZLE_TIMESTAMP_TIME)
+        if (type == type::DRIZZLE_TIMESTAMP_TIME)
           return 1;
         weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
                              l_time->day),0);
@@ -92,7 +92,7 @@
                     system_charset_info);
         break;
       case 'D':
-	if (type == DRIZZLE_TIMESTAMP_TIME)
+	if (type == type::DRIZZLE_TIMESTAMP_TIME)
 	  return 1;
 	length= internal::int10_to_str(l_time->day, intbuff, 10) - intbuff;
 	str->append_with_prefill(intbuff, length, 1, '0');
@@ -159,7 +159,7 @@
 	str->append_with_prefill(intbuff, length, 2, '0');
 	break;
       case 'j':
-	if (type == DRIZZLE_TIMESTAMP_TIME)
+	if (type == type::DRIZZLE_TIMESTAMP_TIME)
 	  return 1;
 	length= internal::int10_to_str(calc_daynr(l_time->year,l_time->month,
 					l_time->day) -
@@ -205,7 +205,7 @@
       case 'u':
       {
 	uint32_t year;
-	if (type == DRIZZLE_TIMESTAMP_TIME)
+	if (type == type::DRIZZLE_TIMESTAMP_TIME)
 	  return 1;
 	length= internal::int10_to_str(calc_week(l_time,
 				       (*ptr) == 'U' ?
@@ -219,7 +219,7 @@
       case 'V':
       {
 	uint32_t year;
-	if (type == DRIZZLE_TIMESTAMP_TIME)
+	if (type == type::DRIZZLE_TIMESTAMP_TIME)
 	  return 1;
 	length= internal::int10_to_str(calc_week(l_time,
 				       ((*ptr) == 'V' ?
@@ -234,7 +234,7 @@
       case 'X':
       {
 	uint32_t year;
-	if (type == DRIZZLE_TIMESTAMP_TIME)
+	if (type == type::DRIZZLE_TIMESTAMP_TIME)
 	  return 1;
 	(void) calc_week(l_time,
 			 ((*ptr) == 'X' ?
@@ -246,7 +246,7 @@
       }
       break;
       case 'w':
-	if (type == DRIZZLE_TIMESTAMP_TIME)
+	if (type == type::DRIZZLE_TIMESTAMP_TIME)
 	  return 1;
 	weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
 					l_time->day),1);
@@ -410,12 +410,12 @@
     goto null_date;
 
   if (fixed_length)
-    size=max_length;
+    size= max_length;
   else
-    size=format_length(format);
+    size= format_length(format);
 
-  if (size < MAX_DATE_STRING_REP_LENGTH)
-    size= MAX_DATE_STRING_REP_LENGTH;
+  if (size < type::Time::MAX_STRING_LENGTH)
+    size= type::Time::MAX_STRING_LENGTH;
 
   if (format == str)
     str= &value;				// Save result here
@@ -426,8 +426,8 @@
   /* Create the result string */
   str->set_charset(collation.collation);
   if (not make_date_time(format, &l_time,
-                         is_time_format ? DRIZZLE_TIMESTAMP_TIME :
-                         DRIZZLE_TIMESTAMP_DATE,
+                         is_time_format ? type::DRIZZLE_TIMESTAMP_TIME :
+                         type::DRIZZLE_TIMESTAMP_DATE,
                          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-18 01:47:30 +0000
@@ -48,13 +48,13 @@
   if (get_date(&time_tmp, 0))
     return 0;
 
-  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
+  if (str->alloc(type::Time::MAX_STRING_LENGTH))
   {
     null_value= 1;
     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.
@@ -81,24 +101,8 @@
   if ((null_value= (args[0]->null_value || tmp > TIMESTAMP_MAX_VALUE)))
     return 1;
 
-  Timestamp temporal;
-  if (! temporal.from_time_t((time_t) tmp))
-  {
-    null_value= true;
-    std::string tmp_string(boost::lexical_cast<std::string>(tmp));
-    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(0), tmp_string.c_str());
-    return 0;
-  }
-  
-  memset(ltime, 0, sizeof(*ltime));
-
-  ltime->year= temporal.years();
-  ltime->month= temporal.months();
-  ltime->day= temporal.days();
-  ltime->hour= temporal.hours();
-  ltime->minute= temporal.minutes();
-  ltime->second= temporal.seconds();
-  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
+  ltime->reset();
+  ltime->store(tmp, fractional_tmp);
 
   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-18 01:47:30 +0000
@@ -56,9 +56,11 @@
   {
     null_value=0;
     get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
-    if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
+    if (str->alloc(type::Time::MAX_STRING_LENGTH))
       goto err;
-    make_date(&l_time, str);
+
+    l_time.convert(*str, type::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-18 01:47:30 +0000
@@ -31,6 +31,7 @@
 {
   assert(fixed == 1);
   str_value.set(buff, buff_length, &my_charset_bin);
+
   return &str_value;
 }
 
@@ -40,15 +41,18 @@
   decimals= DATETIME_DEC;
   collation.set(&my_charset_bin);
   
-  memset(&ltime, 0, sizeof(type::Time));
+  ltime.reset();
 
-  ltime.time_type= DRIZZLE_TIMESTAMP_DATETIME;
+  ltime.time_type= 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);
-  max_length= buff_length;
+  size_t length= type::Time::MAX_STRING_LENGTH;
+  ltime.convert(buff, length);
+
+  max_length= buff_length= length;
 }
 
 /**
@@ -61,15 +65,10 @@
   uint32_t fractional_seconds= 0;
   time_t tmp= session->getCurrentTimestampEpoch(fractional_seconds);
 
-  (void) cached_temporal.from_time_t(tmp);
-
-  now_time->year= cached_temporal.years();
-  now_time->month= cached_temporal.months();
-  now_time->day= cached_temporal.days();
-  now_time->hour= cached_temporal.hours();
-  now_time->minute= cached_temporal.minutes();
-  now_time->second= cached_temporal.seconds();
-  now_time->second_part= fractional_seconds;
+#if 0
+  now_time->store(tmp, fractional_seconds, true);
+#endif
+  now_time->store(tmp, fractional_seconds);
 }
 
 
@@ -83,15 +82,7 @@
   uint32_t fractional_seconds= 0;
   time_t tmp= session->getCurrentTimestampEpoch(fractional_seconds);
 
-  (void) cached_temporal.from_time_t(tmp);
-
-  now_time->year= cached_temporal.years();
-  now_time->month= cached_temporal.months();
-  now_time->day= cached_temporal.days();
-  now_time->hour= cached_temporal.hours();
-  now_time->minute= cached_temporal.minutes();
-  now_time->second= cached_temporal.seconds();
-  now_time->second_part= fractional_seconds;
+  now_time->store(tmp, fractional_seconds);
 }
 
 bool Item_func_now::get_temporal(DateTime &to)
@@ -100,8 +91,7 @@
   return true;
 }
 
-bool Item_func_now::get_date(type::Time *res,
-                             uint32_t )
+bool Item_func_now::get_date(type::Time *res, uint32_t )
 {
   *res= ltime;
   return 0;
@@ -111,7 +101,7 @@
 int Item_func_now::save_in_field(Field *to, bool )
 {
   to->set_notnull();
-  return to->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
+  return to->store_time(&ltime, type::DRIZZLE_TIMESTAMP_DATETIME);
 }
 
 } /* namespace drizzled */

=== modified file 'drizzled/function/time/now.h'
--- drizzled/function/time/now.h	2011-01-06 23:02:43 +0000
+++ drizzled/function/time/now.h	2011-01-18 01:47:30 +0000
@@ -33,7 +33,7 @@
 {
 protected:
   int64_t value;
-  char buff[20*2+32];   // +32 to make my_snprintf_{8bit|ucs2} happy
+  char buff[type::Time::MAX_STRING_LENGTH];
   uint32_t buff_length;
   type::Time ltime;
   DateTime cached_temporal;

=== 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-18 01:47:30 +0000
@@ -41,8 +41,12 @@
 {
   assert(fixed == 1);
   store_now_in_TIME(&ltime);
-  buff_length= (uint) my_datetime_to_str(&ltime, buff);
-  str_value.set(buff, buff_length, &my_charset_bin);
+
+  size_t length= type::Time::MAX_STRING_LENGTH;
+  ltime.convert(buff, length);
+  buff_length= length;
+  str_value.set(buff, length, &my_charset_bin);
+
   return &str_value;
 }
 
@@ -70,8 +74,7 @@
 }
 
 
-bool Item_func_sysdate_local::get_date(type::Time *res,
-                                       uint32_t )
+bool Item_func_sysdate_local::get_date(type::Time *res, uint32_t )
 {
   store_now_in_TIME(&ltime);
   *res= ltime;
@@ -83,7 +86,8 @@
 {
   store_now_in_TIME(&ltime);
   to->set_notnull();
-  to->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
+  to->store_time(&ltime, type::DRIZZLE_TIMESTAMP_DATETIME);
+
   return 0;
 }
 

=== 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-18 01:47:30 +0000
@@ -214,7 +214,10 @@
       str->set_charset(&my_charset_bin);
     }
     else
-      make_datetime(&ltime, str);
+    {
+      ltime.convert(*str);
+    }
+
     return str;
   }
 
@@ -240,15 +243,18 @@
 bool Item_date_typecast::get_date(type::Time *ltime, uint32_t )
 {
   bool res= get_arg0_date(ltime, TIME_FUZZY_DATE);
+
   ltime->hour= ltime->minute= ltime->second= ltime->second_part= 0;
-  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
+  ltime->time_type= type::DRIZZLE_TIMESTAMP_DATE;
+
   return res;
 }
 
 
 bool Item_date_typecast::get_time(type::Time *ltime)
 {
-  memset(ltime, 0, sizeof(type::Time));
+  ltime->reset();
+
   return args[0]->null_value;
 }
 
@@ -259,9 +265,10 @@
   type::Time ltime;
 
   if (!get_arg0_date(&ltime, TIME_FUZZY_DATE) &&
-      !str->alloc(MAX_DATE_STRING_REP_LENGTH))
+      !str->alloc(type::Time::MAX_STRING_LENGTH))
   {
-    make_date(&ltime, str);
+    ltime.convert(*str, type::DRIZZLE_TIMESTAMP_DATE);
+
     return str;
   }
 

=== modified file 'drizzled/item.cc'
--- drizzled/item.cc	2011-01-08 10:35:13 +0000
+++ drizzled/item.cc	2011-01-18 01:47:30 +0000
@@ -245,7 +245,7 @@
   if (get_time(&ltime))
     return set_field_to_null(field);
   field->set_notnull();
-  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_TIME);
+  return field->store_time(&ltime, type::DRIZZLE_TIMESTAMP_TIME);
 }
 
 int Item::save_date_in_field(Field *field)
@@ -254,7 +254,7 @@
   if (get_date(&ltime, TIME_FUZZY_DATE))
     return set_field_to_null(field);
   field->set_notnull();
-  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
+  return field->store_time(&ltime, type::DRIZZLE_TIMESTAMP_DATETIME);
 }
 
 /**
@@ -462,33 +462,38 @@
 
 bool Item::get_date(type::Time *ltime,uint32_t fuzzydate)
 {
-  if (result_type() == STRING_RESULT)
-  {
-    char buff[40];
-    String tmp(buff,sizeof(buff), &my_charset_bin),*res;
-    if (!(res=val_str(&tmp)) ||
-        str_to_datetime_with_warn(res->ptr(), res->length(),
-                                  ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
-      goto err;
-  }
-  else
-  {
-    int64_t value= val_int();
-    int was_cut;
-    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1L)
-    {
-      char buff[22], *end;
-      end= internal::int64_t10_to_str(value, buff, -10);
-      make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
-                                   buff, (int) (end-buff), DRIZZLE_TIMESTAMP_NONE,
-                                   NULL);
-      goto err;
-    }
-  }
-  return false;
-
-err:
-  memset(ltime, 0, sizeof(*ltime));
+  do
+  {
+    if (result_type() == STRING_RESULT)
+    {
+      char buff[40];
+      String tmp(buff,sizeof(buff), &my_charset_bin),*res;
+      if (!(res=val_str(&tmp)) ||
+          str_to_datetime_with_warn(res->ptr(), res->length(),
+                                    ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
+      {
+        break;
+      }
+    }
+    else
+    {
+      int64_t value= val_int();
+      int was_cut;
+      if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1L)
+      {
+        char buff[22], *end;
+        end= internal::int64_t10_to_str(value, buff, -10);
+        make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
+                                     buff, (int) (end-buff), type::DRIZZLE_TIMESTAMP_NONE, NULL);
+        break;
+      }
+    }
+
+    return false;
+  } while (0);
+
+  ltime->reset();
+
   return true;
 }
 
@@ -496,12 +501,13 @@
 {
   char buff[40];
   String tmp(buff,sizeof(buff),&my_charset_bin),*res;
-  if (!(res=val_str(&tmp)) ||
-      str_to_time_with_warn(res->ptr(), res->length(), ltime))
+  if (!(res=val_str(&tmp)) || str_to_time_with_warn(res->ptr(), res->length(), ltime))
   {
-    memset(ltime, 0, sizeof(*ltime));
+    ltime->reset();
+
     return true;
   }
+
   return false;
 }
 

=== modified file 'drizzled/item/cmpfunc.cc'
--- drizzled/item/cmpfunc.cc	2011-01-06 05:17:09 +0000
+++ drizzled/item/cmpfunc.cc	2011-01-18 01:47:30 +0000
@@ -697,20 +697,20 @@
 */
 
 static uint64_t
-get_date_from_str(Session *session, String *str, enum enum_drizzle_timestamp_type warn_type,
+get_date_from_str(Session *session, String *str, type::timestamp_t warn_type,
                   char *warn_name, bool *error_arg)
 {
   uint64_t value= 0;
   int error;
   type::Time l_time;
-  enum enum_drizzle_timestamp_type ret;
+  type::timestamp_t ret;
 
   ret= str_to_datetime(str->ptr(), str->length(), &l_time,
                        (TIME_FUZZY_DATE | MODE_INVALID_DATES |
                         (session->variables.sql_mode & MODE_NO_ZERO_DATE)),
                        &error);
 
-  if (ret == DRIZZLE_TIMESTAMP_DATETIME || ret == DRIZZLE_TIMESTAMP_DATE)
+  if (ret == type::DRIZZLE_TIMESTAMP_DATETIME || ret == type::DRIZZLE_TIMESTAMP_DATE)
   {
     /*
       Do not return yet, we may still want to throw a "trailing garbage"
@@ -993,8 +993,7 @@
   {
     bool error;
     enum_field_types f_type= warn_item->field_type();
-    enum enum_drizzle_timestamp_type t_type= f_type ==
-      DRIZZLE_TYPE_DATE ? DRIZZLE_TIMESTAMP_DATE : DRIZZLE_TIMESTAMP_DATETIME;
+    type::timestamp_t t_type= f_type == DRIZZLE_TYPE_DATE ? type::DRIZZLE_TIMESTAMP_DATE : type::DRIZZLE_TIMESTAMP_DATETIME;
     value= get_date_from_str(session, str, t_type, warn_item->name, &error);
     /*
       If str did not contain a valid date according to the current

=== modified file 'drizzled/plugin/client.cc'
--- drizzled/plugin/client.cc	2010-12-25 04:38:28 +0000
+++ drizzled/plugin/client.cc	2011-01-18 01:47:30 +0000
@@ -33,7 +33,7 @@
 
   switch (from->time_type)
   {
-  case DRIZZLE_TIMESTAMP_DATETIME:
+  case type::DRIZZLE_TIMESTAMP_DATETIME:
     length= snprintf(buff, (buff_len-length), "%04d-%02d-%02d %02d:%02d:%02d",
                     (int) from->year,
                     (int) from->month,
@@ -45,14 +45,14 @@
       length+= snprintf(buff+length, (buff_len-length), ".%06d", (int)from->second_part);
     break;
 
-  case DRIZZLE_TIMESTAMP_DATE:
+  case type::DRIZZLE_TIMESTAMP_DATE:
     length= snprintf(buff, (buff_len-length), "%04d-%02d-%02d",
                     (int) from->year,
                     (int) from->month,
                     (int) from->day);
     break;
 
-  case DRIZZLE_TIMESTAMP_TIME:
+  case type::DRIZZLE_TIMESTAMP_TIME:
     day= (from->year || from->month) ? 0 : from->day;
     length= snprintf(buff, (buff_len-length), "%s%02ld:%02d:%02d",
                     from->neg ? "-" : "",
@@ -63,8 +63,8 @@
       length+= snprintf(buff+length, (buff_len-length), ".%06d", (int)from->second_part);
     break;
 
-  case DRIZZLE_TIMESTAMP_NONE:
-  case DRIZZLE_TIMESTAMP_ERROR:
+  case type::DRIZZLE_TIMESTAMP_NONE:
+  case type::DRIZZLE_TIMESTAMP_ERROR:
   default:
     assert(0);
     return false;
@@ -77,6 +77,7 @@
 {
   if (from == NULL)
     return store();
+
   return store(from, strlen(from));
 }
 

=== modified file 'drizzled/session.h'
--- drizzled/session.h	2011-01-13 01:27:33 +0000
+++ drizzled/session.h	2011-01-18 01:47:30 +0000
@@ -1270,7 +1270,7 @@
   const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg);
   void exit_cond(const char* old_msg);
 
-  time_t query_start()
+  type::Time::epoch_t query_start()
   {
     return getCurrentTimestampEpoch();
   }
@@ -1306,9 +1306,9 @@
   /**
    * Returns the current micro-timestamp
    */
-  uint64_t getCurrentTimestamp(bool actual= true) const
+  type::Time::epoch_t getCurrentTimestamp(bool actual= true) const
   { 
-    uint64_t t_mark;
+    type::Time::epoch_t t_mark;
 
     if (actual)
     {
@@ -1324,7 +1324,7 @@
   }
 
   // We may need to set user on this
-  time_t getCurrentTimestampEpoch() const
+  type::Time::epoch_t getCurrentTimestampEpoch() const
   { 
     if (not _user_time.is_not_a_date_time())
       return (_user_time - _epoch).total_seconds();
@@ -1332,7 +1332,7 @@
     return (_start_timer - _epoch).total_seconds();
   }
 
-  time_t getCurrentTimestampEpoch(uint32_t &fraction_arg) const
+  type::Time::epoch_t getCurrentTimestampEpoch(type::Time::usec_t &fraction_arg) const
   { 
     if (not _user_time.is_not_a_date_time())
     {

=== modified file 'drizzled/sql_yacc.yy'
--- drizzled/sql_yacc.yy	2011-01-13 09:25:42 +0000
+++ drizzled/sql_yacc.yy	2011-01-18 01:47:30 +0000
@@ -373,7 +373,7 @@
   const drizzled::CHARSET_INFO *charset;
   drizzled::thr_lock_type lock_type;
   drizzled::interval_type interval, interval_time_st;
-  enum drizzled::enum_drizzle_timestamp_type date_time_type;
+  drizzled::type::timestamp_t date_time_type;
   drizzled::Select_Lex *select_lex;
   drizzled::chooser_compare_func_creator boolfunc2creator;
   struct drizzled::st_lex *lex;

=== modified file 'drizzled/temporal.cc'
--- drizzled/temporal.cc	2011-01-06 18:00:47 +0000
+++ drizzled/temporal.cc	2011-01-18 01:47:30 +0000
@@ -44,6 +44,8 @@
 #include "drizzled/time_functions.h"
 #include "time.h"
 
+#include <drizzled/util/gmtime.h>
+
 #include <time.h>
 
 #include <cstdio>
@@ -59,19 +61,18 @@
 extern std::vector<TemporalFormat *> known_date_formats;
 extern std::vector<TemporalFormat *> known_time_formats;
 
-Temporal::Temporal()
-:
-  _calendar(GREGORIAN)
-, _years(0)
-, _months(0)
-, _days(0)
-, _hours(0)
-, _minutes(0)
-, _seconds(0)
-, _epoch_seconds(0)
-, _useconds(0)
-, _nseconds(0)
-, _overflow(false)
+Temporal::Temporal() :
+  _calendar(GREGORIAN),
+  _years(0),
+  _months(0),
+  _days(0),
+  _hours(0),
+  _minutes(0),
+  _seconds(0),
+  _epoch_seconds(0),
+  _useconds(0),
+  _nseconds(0),
+  _overflow(false)
 {}
 
 uint64_t Temporal::_cumulative_seconds_in_time() const
@@ -100,7 +101,7 @@
 	}
 	
 	// Get the gmtime based on the local seconds since the Epoch
-	gm_time = gmtime_r(&local_secs, &gm__rec);
+	gm_time = util::gmtime(local_secs, &gm__rec);
 	gm_time->tm_isdst = 0;
 	
 	// Interpret gmtime as the local time and convert it to seconds since the Epoch
@@ -1290,7 +1291,7 @@
   struct tm broken_time;
   struct tm *result;
 
-  result= gmtime_r(&from, &broken_time);
+  result= util::gmtime(from, &broken_time);
   if (result != NULL)
   {
     _years= 0;
@@ -1314,7 +1315,7 @@
   struct tm broken_time;
   struct tm *result;
 
-  result= gmtime_r(&from, &broken_time);
+  result= util::gmtime(from, &broken_time);
   if (result != NULL)
   {
     _years= 1900 + broken_time.tm_year;
@@ -1338,7 +1339,7 @@
   struct tm broken_time;
   struct tm *result;
 
-  result= gmtime_r(&timeval_arg.tv_sec, &broken_time);
+  result= util::gmtime(timeval_arg.tv_sec, &broken_time);
   if (result != NULL)
   {
     _years= 1900 + broken_time.tm_year;
@@ -1364,7 +1365,7 @@
   struct tm broken_time;
   struct tm *result;
 
-  result= gmtime_r(&from, &broken_time);
+  result= util::gmtime(from, &broken_time);
   if (result != NULL)
   {
     _years= 1900 + broken_time.tm_year;

=== modified file 'drizzled/temporal_interval.cc'
--- drizzled/temporal_interval.cc	2010-12-25 04:38:28 +0000
+++ drizzled/temporal_interval.cc	2011-01-18 01:47:30 +0000
@@ -211,7 +211,7 @@
   case INTERVAL_DAY_MINUTE:
   case INTERVAL_DAY_HOUR:
     int64_t sec, days, daynr, microseconds, extra_sec;
-    ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME; // Return full date
+    ltime->time_type= type::DRIZZLE_TIMESTAMP_DATETIME; // Return full date
     microseconds= ltime->second_part + sign*second_part;
     extra_sec= microseconds/1000000L;
     microseconds= microseconds%1000000L;
@@ -241,8 +241,7 @@
     /* Day number from year 0 to 9999-12-31 */
     if ((uint64_t) daynr > MAX_DAY_NUMBER)
       goto invalid_date;
-    get_date_from_daynr((long) daynr, &ltime->year, &ltime->month,
-        &ltime->day);
+    get_date_from_daynr((long) daynr, &ltime->year, &ltime->month, &ltime->day);
     break;
   case INTERVAL_DAY:
   case INTERVAL_WEEK:

=== modified file 'drizzled/time_functions.cc'
--- drizzled/time_functions.cc	2010-12-25 04:38:28 +0000
+++ drizzled/time_functions.cc	2011-01-18 01:47:30 +0000
@@ -107,15 +107,15 @@
     {
       if (day_of_year > 31+28)
       {
-	day_of_year--;
-	if (day_of_year == 31+28)
-	  leap_day=1;		/* Handle leapyears leapday */
+        day_of_year--;
+        if (day_of_year == 31+28)
+          leap_day=1;		/* Handle leapyears leapday */
       }
     }
     *ret_month=1;
     for (month_pos= days_in_month ;
-	 day_of_year > (uint32_t) *month_pos ;
-	 day_of_year-= *(month_pos++), (*ret_month)++)
+         day_of_year > (uint32_t) *month_pos ;
+         day_of_year-= *(month_pos++), (*ret_month)++)
       ;
     *ret_year=year;
     *ret_day=day_of_year+leap_day;
@@ -124,14 +124,13 @@
 }
 
 
-enum enum_drizzle_timestamp_type
-str_to_datetime_with_warn(const char *str, 
-                          uint32_t length, 
-                          type::Time *l_time,
-                          uint32_t flags)
+type::timestamp_t str_to_datetime_with_warn(const char *str, 
+                                            uint32_t length, 
+                                            type::Time *l_time,
+                                            uint32_t flags)
 {
   int was_cut;
-  enum enum_drizzle_timestamp_type ts_type;
+  type::timestamp_t ts_type;
   Session *session= current_session;
 
   ts_type= str_to_datetime(str, length, l_time,
@@ -139,7 +138,7 @@
                                      (MODE_INVALID_DATES |
                                       MODE_NO_ZERO_DATE))),
                            &was_cut);
-  if (was_cut || ts_type <= DRIZZLE_TIMESTAMP_ERROR)
+  if (was_cut || ts_type <= type::DRIZZLE_TIMESTAMP_ERROR)
     make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
                                  str, length, ts_type,  NULL);
   return ts_type;
@@ -153,54 +152,16 @@
   bool ret_val= str_to_time(str, length, l_time, &warning);
   if (ret_val || warning)
     make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
-                                 str, length, DRIZZLE_TIMESTAMP_TIME, NULL);
+                                 str, length, type::DRIZZLE_TIMESTAMP_TIME, NULL);
   return ret_val;
 }
 
 
-void localtime_to_TIME(type::Time *to, struct tm *from)
-{
-  to->neg=0;
-  to->second_part=0;
-  to->year=	(int) ((from->tm_year+1900) % 10000);
-  to->month=	(int) from->tm_mon+1;
-  to->day=	(int) from->tm_mday;
-  to->hour=	(int) from->tm_hour;
-  to->minute=	(int) from->tm_min;
-  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,
 				                          uint32_t str_length,
-                                  enum enum_drizzle_timestamp_type time_type,
+                                  type::timestamp_t time_type,
                                   const char *field_name)
 {
   char warn_buff[DRIZZLE_ERRMSG_SIZE];
@@ -212,17 +173,20 @@
   str[str_length]= 0;               // Ensure we have end 0 for snprintf
 
   switch (time_type) {
-    case DRIZZLE_TIMESTAMP_DATE:
-      type_str= "date";
-      break;
-    case DRIZZLE_TIMESTAMP_TIME:
-      type_str= "time";
-      break;
-    case DRIZZLE_TIMESTAMP_DATETIME:  // FALLTHROUGH
-    default:
-      type_str= "datetime";
-      break;
+  case type::DRIZZLE_TIMESTAMP_DATE:
+    type_str= "date";
+    break;
+
+  case type::DRIZZLE_TIMESTAMP_TIME:
+    type_str= "time";
+    break;
+
+  case type::DRIZZLE_TIMESTAMP_DATETIME:  // FALLTHROUGH
+  default:
+    type_str= "datetime";
+    break;
   }
+
   if (field_name)
   {
     cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
@@ -232,13 +196,17 @@
   }
   else
   {
-    if (time_type > DRIZZLE_TIMESTAMP_ERROR)
+    if (time_type > 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);
@@ -258,30 +226,30 @@
     the second argument should be TIMESTAMP_TIME also.
     We should check it before calc_time_diff call.
   */
-  if (l_time1->time_type == DRIZZLE_TIMESTAMP_TIME)  // Time value
+  if (l_time1->time_type == type::DRIZZLE_TIMESTAMP_TIME)  // Time value
     days= (long)l_time1->day - l_sign * (long)l_time2->day;
   else
   {
     days= calc_daynr((uint32_t) l_time1->year,
-		     (uint32_t) l_time1->month,
-		     (uint32_t) l_time1->day);
-    if (l_time2->time_type == DRIZZLE_TIMESTAMP_TIME)
+                     (uint32_t) l_time1->month,
+                     (uint32_t) l_time1->day);
+    if (l_time2->time_type == type::DRIZZLE_TIMESTAMP_TIME)
       days-= l_sign * (long)l_time2->day;
     else
       days-= l_sign*calc_daynr((uint32_t) l_time2->year,
-			       (uint32_t) l_time2->month,
-			       (uint32_t) l_time2->day);
+                               (uint32_t) l_time2->month,
+                               (uint32_t) l_time2->day);
   }
 
   microseconds= ((int64_t)days*86400L +
                  (int64_t)(l_time1->hour*3600L +
-                            l_time1->minute*60L +
-                            l_time1->second) -
+                           l_time1->minute*60L +
+                           l_time1->second) -
                  l_sign*(int64_t)(l_time2->hour*3600L +
-                                   l_time2->minute*60L +
-                                   l_time2->second)) * 1000000L +
-                (int64_t)l_time1->second_part -
-                l_sign*(int64_t)l_time2->second_part;
+                                  l_time2->minute*60L +
+                                  l_time2->second)) * 1000000L +
+    (int64_t)l_time1->second_part -
+    l_sign*(int64_t)l_time2->second_part;
 
   neg= 0;
   if (microseconds < 0)

=== modified file 'drizzled/time_functions.h'
--- drizzled/time_functions.h	2010-12-26 00:07:57 +0000
+++ drizzled/time_functions.h	2011-01-18 01:47:30 +0000
@@ -73,10 +73,10 @@
   NOTE
     See description of str_to_datetime() for more information.
 */
-enum enum_drizzle_timestamp_type str_to_datetime_with_warn(const char *str, 
-                                                           uint32_t length,
-                                                           type::Time *l_time, 
-                                                           uint32_t flags);
+type::timestamp_t str_to_datetime_with_warn(const char *str, 
+                                            uint32_t length,
+                                            type::Time *l_time, 
+                                            uint32_t flags);
 
 /*
   Convert a time string to a type::Time struct and produce a warning
@@ -87,22 +87,11 @@
 */
 bool str_to_time_with_warn(const char *str, uint32_t length, type::Time *l_time);
 
-/*
-  Convert a system time structure to TIME
-*/
-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,
                                   uint32_t str_length, 
-                                  enum enum_drizzle_timestamp_type time_type,
+                                  type::timestamp_t time_type,
                                   const char *field_name);
 
 /*

=== modified file 'drizzled/type/decimal.cc'
--- drizzled/type/decimal.cc	2010-12-27 19:16:17 +0000
+++ drizzled/type/decimal.cc	2011-01-18 01:47:30 +0000
@@ -313,15 +313,21 @@
   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)
 {
   int64_t date;
   date = (ltime->year*100L + ltime->month)*100L + ltime->day;
-  if (ltime->time_type > DRIZZLE_TIMESTAMP_DATE)
+  if (ltime->time_type > 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-18 01:47:30 +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-18 01:47:30 +0000
@@ -17,10 +17,13 @@
 
 #include "drizzled/type/time.h"
 
+#include <drizzled/util/gmtime.h>
+
 #include "drizzled/internal/m_string.h"
 #include "drizzled/charset_info.h"
 #include <drizzled/util/test.h>
 #include "drizzled/definitions.h"
+#include <drizzled/sql_string.h>
 
 #include <cstdio>
 #include <algorithm>
@@ -171,7 +174,7 @@
 
 #define MAX_DATE_PARTS 8
 
-enum enum_drizzle_timestamp_type
+type::timestamp_t
 str_to_datetime(const char *str, uint32_t length, type::Time *l_time,
                 uint32_t flags, int *was_cut)
 {
@@ -194,7 +197,7 @@
   if (str == end || ! my_isdigit(&my_charset_utf8_general_ci, *str))
   {
     *was_cut= 1;
-    return(DRIZZLE_TIMESTAMP_NONE);
+    return(type::DRIZZLE_TIMESTAMP_NONE);
   }
 
   is_internal_format= 0;
@@ -241,7 +244,7 @@
         if (flags & TIME_DATETIME_ONLY)
         {
           *was_cut= 1;
-          return(DRIZZLE_TIMESTAMP_NONE);   /* Can't be a full datetime */
+          return(type::DRIZZLE_TIMESTAMP_NONE);   /* Can't be a full datetime */
         }
         /* Date field.  Set hour, minutes and seconds to 0 */
         date[0]= date[1]= date[2]= date[3]= date[4]= 0;
@@ -283,7 +286,7 @@
     if (tmp_value > 999999)                     /* Impossible date part */
     {
       *was_cut= 1;
-      return(DRIZZLE_TIMESTAMP_NONE);
+      return(type::DRIZZLE_TIMESTAMP_NONE);
     }
     date[i]=tmp_value;
     not_zero_date|= tmp_value;
@@ -320,7 +323,7 @@
         if (!(allow_space & (1 << i)))
         {
           *was_cut= 1;
-          return(DRIZZLE_TIMESTAMP_NONE);
+          return(type::DRIZZLE_TIMESTAMP_NONE);
         }
         found_space= 1;
       }
@@ -351,7 +354,7 @@
   if (found_delimitier && !found_space && (flags & TIME_DATETIME_ONLY))
   {
     *was_cut= 1;
-    return(DRIZZLE_TIMESTAMP_NONE);          /* Can't be a datetime */
+    return(type::DRIZZLE_TIMESTAMP_NONE);          /* Can't be a datetime */
   }
 
   str= last_field_pos;
@@ -369,7 +372,7 @@
     if (!year_length)                           /* Year must be specified */
     {
       *was_cut= 1;
-      return(DRIZZLE_TIMESTAMP_NONE);
+      return(type::DRIZZLE_TIMESTAMP_NONE);
     }
 
     l_time->year=               date[(uint32_t) format_position[0]];
@@ -437,7 +440,7 @@
     goto err;
 
   l_time->time_type= (number_of_fields <= 3 ?
-                      DRIZZLE_TIMESTAMP_DATE : DRIZZLE_TIMESTAMP_DATETIME);
+                      type::DRIZZLE_TIMESTAMP_DATE : type::DRIZZLE_TIMESTAMP_DATETIME);
 
   for (; str != end ; str++)
   {
@@ -449,12 +452,14 @@
   }
 
   return(l_time->time_type=
-              (number_of_fields <= 3 ? DRIZZLE_TIMESTAMP_DATE :
-                                       DRIZZLE_TIMESTAMP_DATETIME));
+              (number_of_fields <= 3 ? type::DRIZZLE_TIMESTAMP_DATE :
+                                       type::DRIZZLE_TIMESTAMP_DATETIME));
 
 err:
-  memset(l_time, 0, sizeof(*l_time));
-  return(DRIZZLE_TIMESTAMP_ERROR);
+
+  l_time->reset();
+
+  return(type::DRIZZLE_TIMESTAMP_ERROR);
 }
 
 
@@ -503,20 +508,19 @@
     length--;
   }
   if (str == end)
-    return 1;
+    return true;
 
   /* Check first if this is a full TIMESTAMP */
   if (length >= 12)
   {                                             /* Probably full timestamp */
     int was_cut;
-    enum enum_drizzle_timestamp_type
-      res= str_to_datetime(str, length, l_time,
-                           (TIME_FUZZY_DATE | TIME_DATETIME_ONLY), &was_cut);
-    if ((int) res >= (int) DRIZZLE_TIMESTAMP_ERROR)
+    type::timestamp_t res= str_to_datetime(str, length, l_time,
+                                           (TIME_FUZZY_DATE | TIME_DATETIME_ONLY), &was_cut);
+    if ((int) res >= (int) type::DRIZZLE_TIMESTAMP_ERROR)
     {
       if (was_cut)
         *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
-      return res == DRIZZLE_TIMESTAMP_ERROR;
+      return res == type::DRIZZLE_TIMESTAMP_ERROR;
     }
   }
 
@@ -644,7 +648,7 @@
   l_time->minute=       date[2];
   l_time->second=       date[3];
   l_time->second_part=  date[4];
-  l_time->time_type= DRIZZLE_TIMESTAMP_TIME;
+  l_time->time_type= type::DRIZZLE_TIMESTAMP_TIME;
 
   /* Check if the value is valid and fits into type::Time range */
   if (check_time_range(l_time, warning))
@@ -723,7 +727,7 @@
   bool not_used;
 
   seconds= (time_t) time((time_t*) 0);
-  localtime_r(&seconds,&tm_tmp);
+  localtime_r(&seconds, &tm_tmp);
   l_time= &tm_tmp;
   my_time_zone=		3600;		/* Comp. for -3600 in my_gmt_sec */
   my_time.year=		(uint32_t) l_time->tm_year+1900;
@@ -732,7 +736,7 @@
   my_time.hour=		(uint32_t) l_time->tm_hour;
   my_time.minute=	(uint32_t) l_time->tm_min;
   my_time.second=	(uint32_t) l_time->tm_sec;
-  my_time.time_type=	DRIZZLE_TIMESTAMP_NONE;
+  my_time.time_type=	type::DRIZZLE_TIMESTAMP_NONE;
   my_time.second_part=  0;
   my_time.neg=          false;
   my_system_gmt_sec(&my_time, &my_time_zone, &not_used); /* Init my_time_zone */
@@ -812,12 +816,12 @@
   RETURN VALUE
     Time in UTC seconds since Unix Epoch representation.
 */
-time_t
+type::Time::epoch_t
 my_system_gmt_sec(const type::Time *t_src, long *my_timezone,
                   bool *in_dst_time_gap, bool skip_timezone)
 {
   uint32_t loop;
-  time_t tmp= 0;
+  type::Time::epoch_t tmp= 0;
   int shift= 0;
   type::Time tmp_time;
   type::Time *t= &tmp_time;
@@ -828,9 +832,9 @@
     Use temp variable to avoid trashing input data, which could happen in
     case of shift required for boundary dates processing.
   */
-  memcpy(&tmp_time, t_src, sizeof(type::Time));
+  tmp_time= *t_src;
 
-  if (!validate_timestamp_range(t))
+  if (not validate_timestamp_range(t))
     return 0;
 
   /*
@@ -883,18 +887,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
@@ -923,7 +916,7 @@
   }
 #endif
 
-  tmp= (time_t) (((calc_daynr((uint32_t) t->year, (uint32_t) t->month, (uint32_t) t->day) -
+  tmp= (type::Time::epoch_t) (((calc_daynr((uint32_t) t->year, (uint32_t) t->month, (uint32_t) t->day) -
                    (long) days_at_timestart)*86400L + (long) t->hour*3600L +
                   (long) (t->minute*60 + t->second)) + (time_t) my_time_zone -
                  3600);
@@ -931,14 +924,14 @@
   current_timezone= my_time_zone;
   if (skip_timezone)
   {
-    gmtime_r(&tmp, &tm_tmp);
+    util::gmtime(tmp, &tm_tmp);
   }
   else
   {
-    localtime_r(&tmp,&tm_tmp);
+    util::localtime(tmp, &tm_tmp);
   }
 
-  l_time=&tm_tmp;
+  l_time= &tm_tmp;
   for (loop=0;
        loop < 2 &&
 	 (t->hour != (uint32_t) l_time->tm_hour ||
@@ -959,11 +952,11 @@
     tmp+= (time_t) diff;
     if (skip_timezone)
     {
-      gmtime_r(&tmp, &tm_tmp);
+      util::gmtime(tmp, &tm_tmp);
     }
     else
     {
-      localtime_r(&tmp, &tm_tmp);
+      util::localtime(tmp, &tm_tmp);
     }
     l_time=&tm_tmp;
   }
@@ -1006,26 +999,17 @@
     First check will pass for platforms with signed time_t.
     instruction above (tmp+= shift*86400L) could exceed
     MAX_INT32 (== TIMESTAMP_MAX_VALUE) and overflow will happen.
-    So, tmp < TIMESTAMP_MIN_VALUE will be triggered. On platfroms
-    with unsigned time_t tmp+= shift*86400L might result in a number,
-    larger then TIMESTAMP_MAX_VALUE, so another check will work.
+    So, tmp < TIMESTAMP_MIN_VALUE will be triggered.
   */
-  if ((tmp < TIMESTAMP_MIN_VALUE) || (tmp > TIMESTAMP_MAX_VALUE))
+  if (tmp < TIMESTAMP_MIN_VALUE)
+  {
     tmp= 0;
+  }
 
-  return (time_t) tmp;
+  return tmp;
 } /* my_system_gmt_sec */
 
 
-/* Set type::Time structure to 0000-00-00 00:00:00.000000 */
-
-void set_zero_time(type::Time *tm, enum enum_drizzle_timestamp_type time_type)
-{
-  memset(tm, 0, sizeof(*tm));
-  tm->time_type= time_type;
-}
-
-
 /*
   Functions to convert time/date/datetime value to a string,
   using default format.
@@ -1039,66 +1023,139 @@
     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)
 {
+  int32_t length;
   uint32_t extra_hours= 0;
-  return sprintf(to, "%s%02u:%02u:%02u",
-                         (l_time->neg ? "-" : ""),
-                         extra_hours+ l_time->hour,
-                         l_time->minute,
-                         l_time->second);
+
+  length= sprintf(to, "%s%02u:%02u:%02u",
+                  (l_time->neg ? "-" : ""),
+                  extra_hours+ l_time->hour,
+                  l_time->minute,
+                  l_time->second);
+  if (length < 0)
+    return 0;
+
+  return static_cast<size_t>(length); 
 }
 
-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",
+  int32_t length;
+  length= sprintf(to, "%04u-%02u-%02u",
                          l_time->year,
                          l_time->month,
                          l_time->day);
-}
-
-int my_datetime_to_str(const type::Time *l_time, char *to)
-{
-  return sprintf(to, "%04u-%02u-%02u %02u:%02u:%02u",
-                         l_time->year,
-                         l_time->month,
-                         l_time->day,
-                         l_time->hour,
-                         l_time->minute,
-                         l_time->second);
-}
-
-
-/*
-  Convert struct DATE/TIME/DATETIME value to string using built-in
-  MySQL time conversion formats.
-
-  SYNOPSIS
-    my_TIME_to_string()
-
-  NOTE
-    The string must have at least MAX_DATE_STRING_REP_LENGTH bytes reserved.
-*/
-
-int my_TIME_to_str(const type::Time *l_time, char *to)
-{
-  switch (l_time->time_type) {
+  if (length < 0)
+    return 0;
+
+  return static_cast<size_t>(length); 
+}
+
+static size_t my_datetime_to_str(const type::Time *l_time, char *to, size_t to_len)
+{
+  int32_t length;
+  length= snprintf(to, to_len,
+                   "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32
+                   " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
+                   l_time->year,
+                   l_time->month,
+                   l_time->day,
+                   l_time->hour,
+                   l_time->minute,
+                   l_time->second,
+                   l_time->second_part);
+  if (length < 0)
+    return 0;
+
+  return static_cast<size_t>(length); 
+}
+
+
+namespace type {
+
+void Time::store(const struct tm &from)
+{
+  _is_local_time= false;
+  neg= 0;
+  second_part= 0;
+  year=	(int32_t) ((from.tm_year+1900) % 10000);
+  month= (int32_t) from.tm_mon+1;
+  day= (int32_t) from.tm_mday;
+  hour=	(int32_t) from.tm_hour;
+  minute= (int32_t) from.tm_min;
+  second= (int32_t) from.tm_sec;
+
+  time_type= DRIZZLE_TIMESTAMP_DATETIME;
+}
+
+void Time::store(const struct timeval &from)
+{
+  store(from.tv_sec, (usec_t)from.tv_usec);
+  time_type= type::DRIZZLE_TIMESTAMP_DATETIME;
+}
+
+
+void Time::store(const time_t &from, bool use_localtime)
+{
+  store(from, 0, use_localtime);
+}
+
+void Time::store(const time_t &from_arg, const usec_t &from_fractional_seconds, bool use_localtime)
+{
+  epoch_t from= from_arg;
+
+  if (use_localtime)
+  {
+    util::localtime(from, *this);
+    _is_local_time= true;
+  }
+  else
+  {
+    util::gmtime(from, *this);
+  }
+
+  // Since time_t/epoch_t doesn't have fractional seconds, we have to
+  // collect them outside of the gmtime function.
+  second_part= from_fractional_seconds;
+  time_type= DRIZZLE_TIMESTAMP_DATETIME;
+}
+
+void Time::convert(String &str, timestamp_t arg)
+{
+  str.alloc(MAX_STRING_LENGTH);
+  size_t length= MAX_STRING_LENGTH;
+
+  convert(str.c_ptr(), length, arg);
+
+  str.length(length);
+  str.set_charset(&my_charset_bin);
+}
+
+void Time::convert(char *str, size_t &to_length, timestamp_t arg)
+{
+  switch (arg) {
   case DRIZZLE_TIMESTAMP_DATETIME:
-    return my_datetime_to_str(l_time, to);
+    to_length= my_datetime_to_str(this, str, to_length);
+    break;
+
   case DRIZZLE_TIMESTAMP_DATE:
-    return my_date_to_str(l_time, to);
+    to_length= (uint32_t) my_date_to_str(this, str);
+    break;
+
   case DRIZZLE_TIMESTAMP_TIME:
-    return my_time_to_str(l_time, to);
+    to_length= (uint32_t) my_time_to_str(this, str);
+    break;
+
   case DRIZZLE_TIMESTAMP_NONE:
   case DRIZZLE_TIMESTAMP_ERROR:
-    to[0]='\0';
-    return 0;
-  default:
     assert(0);
-    return 0;
+    to_length= 0;
+    break;
   }
 }
 
+}
 
 /*
   Convert datetime value specified as number to broken-down TIME
@@ -1132,12 +1189,12 @@
   long part1,part2;
 
   *was_cut= 0;
-  memset(time_res, 0, sizeof(*time_res));
-  time_res->time_type=DRIZZLE_TIMESTAMP_DATE;
+  time_res->reset();
+  time_res->time_type=type::DRIZZLE_TIMESTAMP_DATE;
 
   if (nr == 0LL || nr >= 10000101000000LL)
   {
-    time_res->time_type=DRIZZLE_TIMESTAMP_DATETIME;
+    time_res->time_type= type::DRIZZLE_TIMESTAMP_DATETIME;
     goto ok;
   }
   if (nr < 101)
@@ -1164,7 +1221,7 @@
   if (nr < 101000000L)
     goto err;
 
-  time_res->time_type=DRIZZLE_TIMESTAMP_DATETIME;
+  time_res->time_type= type::DRIZZLE_TIMESTAMP_DATETIME;
 
   if (nr <= (YY_PART_YEAR-1) * 10000000000LL + 1231235959LL)
   {
@@ -1219,8 +1276,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 +1291,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);
 }
 
 
@@ -1261,18 +1319,20 @@
 uint64_t TIME_to_uint64_t(const type::Time *my_time)
 {
   switch (my_time->time_type) {
-  case DRIZZLE_TIMESTAMP_DATETIME:
+  case type::DRIZZLE_TIMESTAMP_DATETIME:
     return TIME_to_uint64_t_datetime(my_time);
-  case DRIZZLE_TIMESTAMP_DATE:
+
+  case type::DRIZZLE_TIMESTAMP_DATE:
     return TIME_to_uint64_t_date(my_time);
-  case DRIZZLE_TIMESTAMP_TIME:
+
+  case type::DRIZZLE_TIMESTAMP_TIME:
     return TIME_to_uint64_t_time(my_time);
-  case DRIZZLE_TIMESTAMP_NONE:
-  case DRIZZLE_TIMESTAMP_ERROR:
+
+  case type::DRIZZLE_TIMESTAMP_NONE:
+  case type::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-18 01:47:30 +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
@@ -68,13 +69,6 @@
 #define TIME_MAX_VALUE_SECONDS (TIME_MAX_HOUR * 3600L + \
                                 TIME_MAX_MINUTE * 60L + TIME_MAX_SECOND)
 
-enum enum_drizzle_timestamp_type
-{
-  DRIZZLE_TIMESTAMP_NONE= -2, DRIZZLE_TIMESTAMP_ERROR= -1,
-  DRIZZLE_TIMESTAMP_DATE= 0, DRIZZLE_TIMESTAMP_DATETIME= 1, DRIZZLE_TIMESTAMP_TIME= 2
-};
-
-
 /*
   Structure which is used to represent datetime values inside Drizzle.
 
@@ -88,30 +82,117 @@
   bigger values.
 */
 namespace type {
+
+enum timestamp_t
+{
+  DRIZZLE_TIMESTAMP_NONE= -2, DRIZZLE_TIMESTAMP_ERROR= -1,
+  DRIZZLE_TIMESTAMP_DATE= 0, DRIZZLE_TIMESTAMP_DATETIME= 1, DRIZZLE_TIMESTAMP_TIME= 2
+};
+
+/*
+  datatime_t while being stored in an integer is actually a formatted value.
+*/
+struct datatime_t {
+  int64_t value;
+};
+
+
+
 class Time
 {
 public:
-  unsigned int year, month, day, hour, minute, second;
-  unsigned int second_part;
-  bool       neg;
-  enum enum_drizzle_timestamp_type time_type;
+  typedef uint32_t usec_t;
+  typedef int64_t epoch_t;
+
+  Time()
+  {
+    reset();
+  }
+
+  Time(uint32_t year_arg,
+       uint32_t month_arg,
+       uint32_t day_arg,
+       uint32_t hour_arg,
+       uint32_t minute_arg,
+       uint32_t second_arg,
+       usec_t second_part_arg,
+       timestamp_t type_arg) :
+    year(year_arg),
+    month(month_arg),
+    day(day_arg),
+    hour(hour_arg),
+    minute(minute_arg),
+    second(second_arg),
+    second_part(second_part_arg),
+    neg(false),
+    time_type(type_arg),
+    _is_local_time(false)
+  {
+  }
+
+  Time(uint32_t hour_arg,
+       uint32_t minute_arg,
+       uint32_t second_arg,
+       usec_t second_part_arg,
+       bool neg_arg) :
+    year(0),
+    month(0),
+    day(0),
+    hour(hour_arg),
+    minute(minute_arg),
+    second(second_arg),
+    second_part(second_part_arg),
+    neg(neg_arg),
+    time_type(DRIZZLE_TIMESTAMP_TIME),
+    _is_local_time(false)
+  {
+  }
+
+  uint32_t year, month, day, hour, minute, second;
+  usec_t second_part;
+  bool neg;
+  timestamp_t time_type;
+  bool _is_local_time;
+
+  void reset()
+  {
+    year= month= day= hour= minute= second= second_part= 0;
+    neg= false;
+    time_type= DRIZZLE_TIMESTAMP_DATE;
+    _is_local_time= false;
+  }
+
+  timestamp_t type() const
+  {
+    return time_type;
+  }
+
+  void convert(drizzled::String &str, timestamp_t arg= type::DRIZZLE_TIMESTAMP_DATETIME);
+  void convert(char *str, size_t &to_length, timestamp_t arg= type::DRIZZLE_TIMESTAMP_DATETIME);
+
+  void store(const type::Time::epoch_t &from, bool use_localtime= false);
+  void store(const type::Time::epoch_t &from, const usec_t &from_fractional_seconds, bool use_localtime= false);
+  void store(const struct tm &from);
+  void store(const struct timeval &from);
+
+  static const uint32_t FRACTIONAL_DIGITS= 1000000;
+  static const size_t MAX_STRING_LENGTH= 32;   // +32 to make my_snprintf_{8bit|ucs2} happy
 };
+
 }
 
-
 bool check_date(const type::Time *ltime, bool not_zero_date,
                    uint32_t flags, int *was_cut);
-enum enum_drizzle_timestamp_type
-str_to_datetime(const char *str, uint32_t length, type::Time *l_time,
-                uint32_t flags, int *was_cut);
+
+type::timestamp_t str_to_datetime(const char *str, uint32_t length, type::Time *l_time, uint32_t flags, int *was_cut);
+
 int64_t number_to_datetime(int64_t nr, type::Time *time_res,
                             uint32_t flags, int *was_cut);
 uint64_t TIME_to_uint64_t_datetime(const type::Time *);
 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 +216,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;
 }
@@ -147,23 +228,6 @@
 my_system_gmt_sec(const type::Time *t, long *my_timezone,
                   bool *in_dst_time_gap, bool skip_timezone= false);
 
-void set_zero_time(type::Time *tm, enum enum_drizzle_timestamp_type time_type);
-
-/*
-  Required buffer length for my_time_to_str, my_date_to_str,
-  my_datetime_to_str and TIME_to_string functions. Note, that the
-  caller is still responsible to check that given TIME structure
-  has values in valid ranges, otherwise size of the buffer could
-  be not enough. We also rely on the fact that even wrong values
-  sent using binary protocol fit in this buffer.
-*/
-#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);
-
 /*
   Available interval types used in any statement.
 

=== modified file 'drizzled/tztime.cc'
--- drizzled/tztime.cc	2010-12-25 04:38:28 +0000
+++ drizzled/tztime.cc	2011-01-18 01:47:30 +0000
@@ -49,9 +49,9 @@
 {
 public:
   Time_zone_system() {}                       /* Remove gcc warning */
-  virtual time_t TIME_to_gmt_sec(const type::Time *t,
-                                    bool *in_dst_time_gap) const;
-  virtual void gmt_sec_to_TIME(type::Time *tmp, time_t t) const;
+  virtual type::Time::epoch_t TIME_to_gmt_sec(const type::Time *t,
+                                              bool *in_dst_time_gap) const;
+  virtual void gmt_sec_to_TIME(type::Time *tmp, type::Time::epoch_t t) const;
   virtual const String * get_name() const;
 };
 
@@ -59,14 +59,14 @@
 /**
  * @brief
  * Converts local time in system time zone in type::Time representation
- * to its time_t representation.
+ * to its type::Time::epoch_t representation.
  *
  * @details
  * This method uses system function (localtime_r()) for conversion
- * local time in system time zone in type::Time structure to its time_t
+ * local time in system time zone in type::Time structure to its type::Time::epoch_t
  * representation. Unlike the same function for Time_zone_db class
  * it it won't handle unnormalized input properly. Still it will
- * return lowest possible time_t in case of ambiguity or if we
+ * return lowest possible type::Time::epoch_t in case of ambiguity or if we
  * provide time corresponding to the time-gap.
  *
  * You should call init_time() function before using this function.
@@ -78,9 +78,9 @@
  *                          spring time-gap) and is not touched otherwise.
  *
  * @return
- * Corresponding time_t value or 0 in case of error
+ * Corresponding type::Time::epoch_t value or 0 in case of error
  */
-time_t
+type::Time::epoch_t
 Time_zone_system::TIME_to_gmt_sec(const type::Time *t, bool *in_dst_time_gap) const
 {
   long not_used;
@@ -90,27 +90,22 @@
 
 /**
  * @brief
- * Converts time from UTC seconds since Epoch (time_t) representation
+ * Converts time from UTC seconds since Epoch (type::Time::epoch_t) representation
  * to system local time zone broken-down representation.
  *
  * @param    tmp   pointer to type::Time structure to fill-in
- * @param    t     time_t value to be converted
+ * @param    t     type::Time::epoch_t value to be converted
  *
- * Note: We assume that value passed to this function will fit into time_t range
+ * Note: We assume that value passed to this function will fit into type::Time::epoch_t range
  * supported by localtime_r. This conversion is putting restriction on
  * TIMESTAMP range in MySQL. If we can get rid of SYSTEM time zone at least
  * for interaction with client then we can extend TIMESTAMP range down to
  * the 1902 easily.
  */
 void
-Time_zone_system::gmt_sec_to_TIME(type::Time *tmp, time_t t) const
+Time_zone_system::gmt_sec_to_TIME(type::Time *tmp, type::Time::epoch_t t) const
 {
-  struct tm tmp_tm;
-  time_t tmp_t= (time_t)t;
-
-  localtime_r(&tmp_t, &tmp_tm);
-  localtime_to_TIME(tmp, &tmp_tm);
-  tmp->time_type= DRIZZLE_TIMESTAMP_DATETIME;
+  tmp->store(t);
 }
 
 

=== modified file 'drizzled/tztime.h'
--- drizzled/tztime.h	2010-12-25 04:38:28 +0000
+++ drizzled/tztime.h	2011-01-18 01:47:30 +0000
@@ -21,19 +21,10 @@
 #ifndef DRIZZLED_TZTIME_H
 #define DRIZZLED_TZTIME_H
 
-#if TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-#  include <sys/time.h>
-# else
-#  include <time.h>
-# endif
-#endif
-
 #include "drizzled/memory/sql_alloc.h"
 
+#include "drizzled/type/time.h"
+
 namespace drizzled
 {
 
@@ -45,7 +36,7 @@
 
 /**
   This class represents abstract time zone and provides
-  basic interface for type::Time <-> time_t conversion.
+  basic interface for type::Time <-> type::Time::epoch_t conversion.
   Actual time zones which are specified by DB, or via offset
   or use system functions are its descendants.
 */
@@ -55,17 +46,18 @@
   Time_zone() {}                              /* Remove gcc warning */
   /**
     Converts local time in broken down type::Time representation to
-    time_t (UTC seconds since Epoch) represenation.
+    type::Time::epoch_t (UTC seconds since Epoch) represenation.
     Returns 0 in case of error. Sets in_dst_time_gap to true if date provided
     falls into spring time-gap (or lefts it untouched otherwise).
   */
-  virtual time_t TIME_to_gmt_sec(const type::Time *t,
-                                 bool *in_dst_time_gap) const = 0;
+  virtual type::Time::epoch_t TIME_to_gmt_sec(const type::Time *t,
+                                              bool *in_dst_time_gap) const = 0;
   /**
-    Converts time in time_t representation to local time in
+    Converts time in type::Time::epoch_t representation to local time in
     broken down type::Time representation.
   */
-  virtual void   gmt_sec_to_TIME(type::Time *tmp, time_t t) const = 0;
+  virtual void gmt_sec_to_TIME(type::Time *tmp, type::Time::epoch_t t) const = 0;
+
   /**
     Because of constness of String returned by get_name() time zone name
     have to be already zeroended to be able to use String::ptr() instead

=== added file 'drizzled/util/gmtime.cc'
--- drizzled/util/gmtime.cc	1970-01-01 00:00:00 +0000
+++ drizzled/util/gmtime.cc	2011-01-18 01:47:30 +0000
@@ -0,0 +1,284 @@
+//
+// time.c
+//
+// Time routines
+//
+// Copyright (C) 2002 Michael Ringgaard. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 
+// 1. Redistributions of source code must retain the above copyright 
+//    notice, this list of conditions and the following disclaimer.  
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.  
+// 3. Neither the name of the project nor the names of its contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+// SUCH DAMAGE.
+// 
+
+#include "config.h"
+
+#include <drizzled/type/time.h>
+#include <drizzled/util/gmtime.h>
+
+namespace drizzled
+{
+namespace util
+{
+#define YEAR0                   1900
+#define EPOCH_YR                1970
+#define SECS_DAY                (24L * 60L * 60L)
+#define LEAPYEAR(year)          (!((year) % 4) && (((year) % 100) || !((year) % 400)))
+#define YEARSIZE(year)          (LEAPYEAR(year) ? 366 : 365)
+#define FIRSTSUNDAY(timp)       (((timp)->tm_yday - (timp)->tm_wday + 420) % 7)
+#define FIRSTDAYOF(timp)        (((timp)->tm_wday - (timp)->tm_yday + 420) % 7)
+
+#define TIME_MAX                INT64_MIN
+
+int _daylight = 0;                  // Non-zero if daylight savings time is used
+long _dstbias = 0;                  // Offset for Daylight Saving Time
+type::Time::epoch_t _timezone = 0;                 // Difference in seconds between GMT and local time
+const char *_tzname[2] = {"GMT", "GMT"};  // Standard/daylight savings time zone names
+
+const char *_days[] = 
+{
+  "Sunday", "Monday", "Tuesday", "Wednesday",
+  "Thursday", "Friday", "Saturday"
+};
+
+const char *_days_abbrev[] = 
+{
+  "Sun", "Mon", "Tue", "Wed", 
+  "Thu", "Fri", "Sat"
+};
+
+const char *_months[] = 
+{
+  "January", "February", "March",
+  "April", "May", "June",
+  "July", "August", "September",
+  "October", "November", "December"
+};
+
+const char *_months_abbrev[] = 
+{
+  "Jan", "Feb", "Mar",
+  "Apr", "May", "Jun",
+  "Jul", "Aug", "Sep",
+  "Oct", "Nov", "Dec"
+};
+
+const int _ytab[2][12] = 
+{
+  {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+  {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+};
+
+struct tm *gmtime(const type::Time::epoch_t &timer, struct tm *tmbuf)
+{
+  uint64_t dayclock, dayno;
+  int year = EPOCH_YR;
+
+  dayclock = (uint64_t) timer % SECS_DAY;
+  dayno = (uint64_t) timer / SECS_DAY;
+
+  tmbuf->tm_sec = dayclock % 60;
+  tmbuf->tm_min = (dayclock % 3600) / 60;
+  tmbuf->tm_hour = dayclock / 3600;
+  tmbuf->tm_wday = (dayno + 4) % 7; // Day 0 was a thursday
+  while (dayno >= (uint64_t) YEARSIZE(year)) 
+  {
+    dayno -= YEARSIZE(year);
+    year++;
+  }
+  tmbuf->tm_year = year - YEAR0;
+  tmbuf->tm_yday = dayno;
+  tmbuf->tm_mon = 0;
+  while (dayno >= (uint64_t) _ytab[LEAPYEAR(year)][tmbuf->tm_mon]) 
+  {
+    dayno -= _ytab[LEAPYEAR(year)][tmbuf->tm_mon];
+    tmbuf->tm_mon++;
+  }
+  tmbuf->tm_mday = dayno + 1;
+  tmbuf->tm_isdst = 0;
+
+  return tmbuf;
+}
+
+void gmtime(const type::Time::epoch_t &timer, type::Time &tmbuf)
+{
+  uint64_t dayclock, dayno;
+  int32_t year= EPOCH_YR;
+
+  tmbuf.reset();
+
+  dayclock= (uint64_t) timer % SECS_DAY;
+  dayno= (uint64_t) timer / SECS_DAY;
+
+  tmbuf.second= dayclock % 60;
+  tmbuf.minute= (dayclock % 3600) / 60;
+  tmbuf.hour= dayclock / 3600;
+  while (dayno >= (uint64_t) YEARSIZE(year)) 
+  {
+    dayno -= YEARSIZE(year);
+    year++;
+  }
+  tmbuf.year= year;
+  while (dayno >= (uint64_t) _ytab[LEAPYEAR(year)][tmbuf.month]) 
+  {
+    dayno -= _ytab[LEAPYEAR(year)][tmbuf.month];
+    tmbuf.month++;
+  }
+  tmbuf.month++;
+  tmbuf.day= dayno +1;
+  tmbuf.time_type= type::DRIZZLE_TIMESTAMP_DATETIME;
+}
+
+void localtime(const type::Time::epoch_t &timer, type::Time &tmbuf)
+{
+  type::Time::epoch_t t;
+
+  t = timer - _timezone;
+  return util::gmtime(t, tmbuf);
+}
+
+struct tm *localtime(const type::Time::epoch_t &timer, struct tm *tmbuf)
+{
+  type::Time::epoch_t t;
+
+  t = timer - _timezone;
+  return util::gmtime(t, tmbuf);
+}
+
+time_t mktime(struct tm *tmbuf)
+{
+  long day, year;
+  int tm_year;
+  int yday, month;
+  /*unsigned*/ long seconds;
+  int overflow;
+  long dst;
+
+  tmbuf->tm_min += tmbuf->tm_sec / 60;
+  tmbuf->tm_sec %= 60;
+  if (tmbuf->tm_sec < 0) 
+  {
+    tmbuf->tm_sec += 60;
+    tmbuf->tm_min--;
+  }
+  tmbuf->tm_hour += tmbuf->tm_min / 60;
+  tmbuf->tm_min = tmbuf->tm_min % 60;
+  if (tmbuf->tm_min < 0) 
+  {
+    tmbuf->tm_min += 60;
+    tmbuf->tm_hour--;
+  }
+  day = tmbuf->tm_hour / 24;
+  tmbuf->tm_hour= tmbuf->tm_hour % 24;
+  if (tmbuf->tm_hour < 0) 
+  {
+    tmbuf->tm_hour += 24;
+    day--;
+  }
+  tmbuf->tm_year += tmbuf->tm_mon / 12;
+  tmbuf->tm_mon %= 12;
+  if (tmbuf->tm_mon < 0) 
+  {
+    tmbuf->tm_mon += 12;
+    tmbuf->tm_year--;
+  }
+  day += (tmbuf->tm_mday - 1);
+  while (day < 0) 
+  {
+    if(--tmbuf->tm_mon < 0) 
+    {
+      tmbuf->tm_year--;
+      tmbuf->tm_mon = 11;
+    }
+    day += _ytab[LEAPYEAR(YEAR0 + tmbuf->tm_year)][tmbuf->tm_mon];
+  }
+  while (day >= _ytab[LEAPYEAR(YEAR0 + tmbuf->tm_year)][tmbuf->tm_mon]) 
+  {
+    day -= _ytab[LEAPYEAR(YEAR0 + tmbuf->tm_year)][tmbuf->tm_mon];
+    if (++(tmbuf->tm_mon) == 12) 
+    {
+      tmbuf->tm_mon = 0;
+      tmbuf->tm_year++;
+    }
+  }
+  tmbuf->tm_mday = day + 1;
+  year = EPOCH_YR;
+  if (tmbuf->tm_year < year - YEAR0) return (time_t) -1;
+  seconds = 0;
+  day = 0;                      // Means days since day 0 now
+  overflow = 0;
+
+  // Assume that when day becomes negative, there will certainly
+  // be overflow on seconds.
+  // The check for overflow needs not to be done for leapyears
+  // divisible by 400.
+  // The code only works when year (1970) is not a leapyear.
+  tm_year = tmbuf->tm_year + YEAR0;
+
+  if (TIME_MAX / 365 < tm_year - year) overflow++;
+  day = (tm_year - year) * 365;
+  if (TIME_MAX - day < (tm_year - year) / 4 + 1) overflow++;
+  day += (tm_year - year) / 4 + ((tm_year % 4) && tm_year % 4 < year % 4);
+  day -= (tm_year - year) / 100 + ((tm_year % 100) && tm_year % 100 < year % 100);
+  day += (tm_year - year) / 400 + ((tm_year % 400) && tm_year % 400 < year % 400);
+
+  yday = month = 0;
+  while (month < tmbuf->tm_mon)
+  {
+    yday += _ytab[LEAPYEAR(tm_year)][month];
+    month++;
+  }
+  yday += (tmbuf->tm_mday - 1);
+  if (day + yday < 0) overflow++;
+  day += yday;
+
+  tmbuf->tm_yday = yday;
+  tmbuf->tm_wday = (day + 4) % 7;               // Day 0 was thursday (4)
+
+  seconds = ((tmbuf->tm_hour * 60L) + tmbuf->tm_min) * 60L + tmbuf->tm_sec;
+
+  if ((TIME_MAX - seconds) / SECS_DAY < day) overflow++;
+  seconds += day * SECS_DAY;
+
+  // Now adjust according to timezone and daylight saving time
+  if (((_timezone > 0) && (TIME_MAX - _timezone < seconds))
+      || ((_timezone < 0) && (seconds < -_timezone)))
+          overflow++;
+  seconds += _timezone;
+
+  if (tmbuf->tm_isdst)
+    dst = _dstbias;
+  else 
+    dst = 0;
+
+  if (dst > seconds) overflow++;        // dst is always non-negative
+  seconds -= dst;
+
+  if (overflow) return (time_t) -1;
+
+  if ((time_t) seconds != seconds) return (time_t) -1;
+  return (time_t) seconds;
+}
+
+} /* namespace util */
+} /* namespace drizzled */

=== added file 'drizzled/util/gmtime.h'
--- drizzled/util/gmtime.h	1970-01-01 00:00:00 +0000
+++ drizzled/util/gmtime.h	2011-01-18 01:47:30 +0000
@@ -0,0 +1,46 @@
+/* - mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Brian Aker
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/*
+ * This is just the header file, the actual code is under a BSD license.
+ */
+
+#ifndef DRIZZLED_UTIL_GMTIME_H
+#define DRIZZLED_UTIL_GMTIME_H
+
+#include <time.h>
+
+namespace drizzled
+{
+
+namespace util
+{
+
+struct tm *gmtime(const type::Time::epoch_t &timer, struct tm *tmbuf);
+void gmtime(const type::Time::epoch_t &timer, type::Time &tmbuf);
+struct tm *localtime(const type::Time::epoch_t &timer, struct tm *tmbuf);
+void localtime(const type::Time::epoch_t &timer,  type::Time &tmbuf);
+time_t mktime(struct tm *tmbuf);
+
+} /* namespace util */
+} /* namespace drizzled */
+
+#endif /* DRIZZLED_UTIL_GMTIME_H */
+

=== modified file 'drizzled/util/include.am'
--- drizzled/util/include.am	2011-01-10 16:11:50 +0000
+++ drizzled/util/include.am	2011-01-18 01:47:30 +0000
@@ -20,6 +20,7 @@
                               drizzled/util/backtrace.h \
                               drizzled/util/convert.h \
                               drizzled/util/functors.h \
+                              drizzled/util/gmtime.h \
                               drizzled/util/tablename_to_filename.h \
                               drizzled/util/test.h \
                               drizzled/util/tokenize.h
@@ -28,5 +29,6 @@
 drizzled_util_libutil_la_SOURCES= \
                                   drizzled/util/backtrace.cc \
                                   drizzled/util/convert.cc \
+                                  drizzled/util/gmtime.cc \
                                   drizzled/util/tablename_to_filename.cc
 

=== 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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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/data_dictionary_like_info.result'
--- tests/r/data_dictionary_like_info.result	2010-12-29 21:23:43 +0000
+++ tests/r/data_dictionary_like_info.result	2011-01-18 01:47:30 +0000
@@ -308,7 +308,7 @@
 f5	NULL	NO
 f6	10	NO
 f7	NULL	NO
-f8	2006-01-01 00:00:00	NO
+f8	2006-01-01 00:00:00.000000	NO
 show columns from t1;
 Field	Type	Null	Default	Default_is_NULL	On_Update
 f1	VARCHAR	YES		YES	
@@ -318,7 +318,7 @@
 f5	BIGINT	NO		NO	
 f6	BIGINT	NO	10	NO	
 f7	DATETIME	NO		NO	
-f8	DATETIME	YES	2006-01-01 00:00:00	NO	
+f8	DATETIME	YES	2006-01-01 00:00:00.000000	NO	
 drop table t1;
 SET max_heap_table_size = DEFAULT;
 USE test;

=== 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-18 01:47:30 +0000
@@ -63,94 +63,94 @@
 NULL
 select date_add("1997-12-31 23:59:59",INTERVAL 1 SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL 1 SECOND)
-1998-01-01 00:00:00
[phone]:00:00.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 1 MINUTE);
 date_add("1997-12-31 23:59:59",INTERVAL 1 MINUTE)
-1998-01-01 00:00:59
[phone]:00:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 1 HOUR);
 date_add("1997-12-31 23:59:59",INTERVAL 1 HOUR)
-1998-01-01 00:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 1 DAY);
 date_add("1997-12-31 23:59:59",INTERVAL 1 DAY)
-1998-01-01 23:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 1 MONTH);
 date_add("1997-12-31 23:59:59",INTERVAL 1 MONTH)
-1998-01-31 23:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 1 YEAR);
 date_add("1997-12-31 23:59:59",INTERVAL 1 YEAR)
-1998-12-31 23:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1:1" MINUTE_SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL "1:1" MINUTE_SECOND)
-1998-01-01 00:01:00
[phone]:01:00.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1:1" HOUR_MINUTE);
 date_add("1997-12-31 23:59:59",INTERVAL "1:1" HOUR_MINUTE)
-1998-01-01 01:00:59
[phone]:00:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1:1" DAY_HOUR);
 date_add("1997-12-31 23:59:59",INTERVAL "1:1" DAY_HOUR)
-1998-01-02 00:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1 1" YEAR_MONTH);
 date_add("1997-12-31 23:59:59",INTERVAL "1 1" YEAR_MONTH)
-1999-01-31 23:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1:1:1" HOUR_SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL "1:1:1" HOUR_SECOND)
-1998-01-01 01:01:00
[phone]:01:00.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1 1:1" DAY_MINUTE);
 date_add("1997-12-31 23:59:59",INTERVAL "1 1:1" DAY_MINUTE)
-1998-01-02 01:00:59
[phone]:00:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "1 1:1:1" DAY_SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL "1 1:1:1" DAY_SECOND)
-1998-01-02 01:01:00
[phone]:01:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL 1 SECOND);
 date_sub("1998-01-01 00:00:00",INTERVAL 1 SECOND)
-1997-12-31 23:59:59
[phone]:59:59.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL 1 MINUTE);
 date_sub("1998-01-01 00:00:00",INTERVAL 1 MINUTE)
-1997-12-31 23:59:00
[phone]:59:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL 1 HOUR);
 date_sub("1998-01-01 00:00:00",INTERVAL 1 HOUR)
-1997-12-31 23:00:00
[phone]:00:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL 1 DAY);
 date_sub("1998-01-01 00:00:00",INTERVAL 1 DAY)
-1997-12-31 00:00:00
[phone]:00:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL 1 MONTH);
 date_sub("1998-01-01 00:00:00",INTERVAL 1 MONTH)
-1997-12-01 00:00:00
[phone]:00:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL 1 YEAR);
 date_sub("1998-01-01 00:00:00",INTERVAL 1 YEAR)
-1997-01-01 00:00:00
[phone]:00:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1:1" MINUTE_SECOND);
 date_sub("1998-01-01 00:00:00",INTERVAL "1:1" MINUTE_SECOND)
-1997-12-31 23:58:59
[phone]:58:59.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1:1" HOUR_MINUTE);
 date_sub("1998-01-01 00:00:00",INTERVAL "1:1" HOUR_MINUTE)
-1997-12-31 22:59:00
[phone]:59:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1:1" DAY_HOUR);
 date_sub("1998-01-01 00:00:00",INTERVAL "1:1" DAY_HOUR)
-1997-12-30 23:00:00
[phone]:00:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1 1" YEAR_MONTH);
 date_sub("1998-01-01 00:00:00",INTERVAL "1 1" YEAR_MONTH)
-1996-12-01 00:00:00
[phone]:00:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1:1:1" HOUR_SECOND);
 date_sub("1998-01-01 00:00:00",INTERVAL "1:1:1" HOUR_SECOND)
-1997-12-31 22:58:59
[phone]:58:59.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1 1:1" DAY_MINUTE);
 date_sub("1998-01-01 00:00:00",INTERVAL "1 1:1" DAY_MINUTE)
-1997-12-30 22:59:00
[phone]:59:00.000000
 select date_sub("1998-01-01 00:00:00",INTERVAL "1 1:1:1" DAY_SECOND);
 date_sub("1998-01-01 00:00:00",INTERVAL "1 1:1:1" DAY_SECOND)
-1997-12-30 22:58:59
[phone]:58:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 100000 SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL 100000 SECOND)
-1998-01-02 03:46:39
[phone]:46:39.000000
 select date_add("1997-12-31 23:59:59",INTERVAL -100000 MINUTE);
 date_add("1997-12-31 23:59:59",INTERVAL -100000 MINUTE)
-1997-10-23 13:19:59
[phone]:19:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 100000 HOUR);
 date_add("1997-12-31 23:59:59",INTERVAL 100000 HOUR)
-2009-05-29 15:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL -100000 DAY);
 date_add("1997-12-31 23:59:59",INTERVAL -100000 DAY)
-1724-03-17 23:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL 100000 MONTH);
 date_add("1997-12-31 23:59:59",INTERVAL 100000 MONTH)
 NULL
@@ -163,40 +163,40 @@
 Warning	1441	Datetime function: datetime field overflow
 select date_add("1997-12-31 23:59:59",INTERVAL "10000:1" MINUTE_SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL "10000:1" MINUTE_SECOND)
-1998-01-07 22:40:00
[phone]:40:00.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "-10000:1" HOUR_MINUTE);
 date_add("1997-12-31 23:59:59",INTERVAL "-10000:1" HOUR_MINUTE)
-1996-11-10 07:58:59
[phone]:58:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "10000:1" DAY_HOUR);
 date_add("1997-12-31 23:59:59",INTERVAL "10000:1" DAY_HOUR)
-2025-05-19 00:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "-100 1" YEAR_MONTH);
 date_add("1997-12-31 23:59:59",INTERVAL "-100 1" YEAR_MONTH)
-1897-11-30 23:59:59
[phone]:59:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "10000:99:99" HOUR_SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL "10000:99:99" HOUR_SECOND)
-1999-02-21 17:40:38
[phone]:40:38.000000
 select date_add("1997-12-31 23:59:59",INTERVAL " -10000 99:99" DAY_MINUTE);
 date_add("1997-12-31 23:59:59",INTERVAL " -10000 99:99" DAY_MINUTE)
-1970-08-11 19:20:59
[phone]:20:59.000000
 select date_add("1997-12-31 23:59:59",INTERVAL "10000 99:99:99" DAY_SECOND);
 date_add("1997-12-31 23:59:59",INTERVAL "10000 99:99:99" DAY_SECOND)
-2025-05-23 04:40:38
[phone]:40:38.000000
 select "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
 "1997-12-31 23:59:59" + INTERVAL 1 SECOND
-1998-01-01 00:00:00
[phone]:00:00.000000
 select INTERVAL 1 DAY + "1997-12-31";
 INTERVAL 1 DAY + "1997-12-31"
 1998-01-01
 select "1998-01-01 00:00:00" - INTERVAL 1 SECOND;
 "1998-01-01 00:00:00" - INTERVAL 1 SECOND
-1997-12-31 23:59:59
[phone]:59:59.000000
 select date_sub("1998-01-02",INTERVAL 31 DAY);
 date_sub("1998-01-02",INTERVAL 31 DAY)
 1997-12-02
 select date_add("1997-12-31",INTERVAL 1 SECOND);
 date_add("1997-12-31",INTERVAL 1 SECOND)
-1997-12-31 00:00:01
[phone]:00:01.000000
 select date_add("1997-12-31",INTERVAL 1 DAY);
 date_add("1997-12-31",INTERVAL 1 DAY)
 1998-01-01
@@ -302,13 +302,13 @@
 4
 SELECT "1900-01-01 00:00:00" + INTERVAL 2147483648 SECOND;
 "1900-01-01 00:00:00" + INTERVAL 2147483648 SECOND
-1968-01-20 03:14:08
[phone]:14:08.000000
 SELECT "1900-01-01 00:00:00" + INTERVAL "1:2147483647" MINUTE_SECOND;
 "1900-01-01 00:00:00" + INTERVAL "1:2147483647" MINUTE_SECOND
-1968-01-20 03:15:07
[phone]:15:07.000000
 SELECT "1900-01-01 00:00:00" + INTERVAL "100000000:214748364700" MINUTE_SECOND;
 "1900-01-01 00:00:00" + INTERVAL "100000000:214748364700" MINUTE_SECOND
-8895-03-27 22:11:40
[phone]:11:40.000000
 SELECT "1900-01-01 00:00:00" + INTERVAL "1000000000:214748364700" MINUTE_SECOND;
 "1900-01-01 00:00:00" + INTERVAL "1000000000:214748364700" MINUTE_SECOND
 NULL
@@ -382,7 +382,7 @@
 drop table t1,t2,t3;
 select @a:=FROM_UNIXTIME(1);
 @a:=FROM_UNIXTIME(1)
-1970-01-01 00:00:01
[phone]:00:01.000000
 select unix_timestamp(@a);
 unix_timestamp(@a)
 1
@@ -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');
@@ -432,7 +435,7 @@
 2001-01-02 03:04:05	2002-01-02 03:04:05	2003-01-02
 select date_add("1997-12-31",INTERVAL 1 SECOND);
 date_add("1997-12-31",INTERVAL 1 SECOND)
-1997-12-31 00:00:01
[phone]:00:01.000000
 select date_add("1997-12-31",INTERVAL "1 1" YEAR_MONTH);
 date_add("1997-12-31",INTERVAL "1 1" YEAR_MONTH)
 1999-01-31
@@ -659,7 +662,7 @@
 19971231.0
 select strcmp(date_sub(localtimestamp(), interval 0 hour), utc_timestamp())=0;
 strcmp(date_sub(localtimestamp(), interval 0 hour), utc_timestamp())=0
-0
+1
 select strcmp(date_format(date_sub(localtimestamp(), interval 0 hour),"%Y-%m-%d"), utc_date())=0;
 strcmp(date_format(date_sub(localtimestamp(), interval 0 hour),"%Y-%m-%d"), utc_date())=0
 1
@@ -838,10 +841,10 @@
 drop table t1;
 select DATE_ADD('20071108181000', INTERVAL 1 DAY);
 DATE_ADD('20071108181000', INTERVAL 1 DAY)
-2007-11-09 18:10:00
[phone]:10:00.000000
 select DATE_ADD(20071108181000,   INTERVAL 1 DAY);
 DATE_ADD(20071108181000,   INTERVAL 1 DAY)
-2007-11-09 18:10:00
[phone]:10:00.000000
 select DATE_ADD('20071108',       INTERVAL 1 DAY);
 DATE_ADD('20071108',       INTERVAL 1 DAY)
 2007-11-09
@@ -868,35 +871,35 @@
 End of 5.0 tests
 select date_sub("0050-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("0050-01-01 00:00:01",INTERVAL 2 SECOND)
-0049-12-31 23:59:59
+0049-12-31 23:59:59.000000
 select date_sub("0199-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("0199-01-01 00:00:01",INTERVAL 2 SECOND)
-0198-12-31 23:59:59
+0198-12-31 23:59:59.000000
 select date_add("0199-12-31 23:59:59",INTERVAL 2 SECOND);
 date_add("0199-12-31 23:59:59",INTERVAL 2 SECOND)
-0200-01-01 00:00:01
+0200-01-01 00:00:01.000000
 select date_sub("0200-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("0200-01-01 00:00:01",INTERVAL 2 SECOND)
-0199-12-31 23:59:59
+0199-12-31 23:59:59.000000
 select date_sub("0200-01-01 00:00:01",INTERVAL 1 SECOND);
 date_sub("0200-01-01 00:00:01",INTERVAL 1 SECOND)
-0200-01-01 00:00:00
+0200-01-01 00:00:00.000000
 select date_sub("0200-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("0200-01-01 00:00:01",INTERVAL 2 SECOND)
-0199-12-31 23:59:59
+0199-12-31 23:59:59.000000
 select date_add("2001-01-01 23:59:59",INTERVAL -2000 YEAR);
 date_add("2001-01-01 23:59:59",INTERVAL -2000 YEAR)
-0001-01-01 23:59:59
+0001-01-01 23:59:59.000000
 select date_sub("50-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("50-01-01 00:00:01",INTERVAL 2 SECOND)
-2049-12-31 23:59:59
[phone]:59:59.000000
 select date_sub("90-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("90-01-01 00:00:01",INTERVAL 2 SECOND)
-1989-12-31 23:59:59
[phone]:59:59.000000
 select date_sub("0069-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("0069-01-01 00:00:01",INTERVAL 2 SECOND)
-0068-12-31 23:59:59
+0068-12-31 23:59:59.000000
 select date_sub("0169-01-01 00:00:01",INTERVAL 2 SECOND);
 date_sub("0169-01-01 00:00:01",INTERVAL 2 SECOND)
-0168-12-31 23:59:59
+0168-12-31 23:59:59.000000
 End of 5.1 tests

=== modified file 'tests/r/information_schema.result'
--- tests/r/information_schema.result	2011-01-09 22:15:22 +0000
+++ tests/r/information_schema.result	2011-01-18 01:47:30 +0000
@@ -357,7 +357,7 @@
 f5	BIGINT	NO		NO	
 f6	BIGINT	NO	10	NO	
 f7	DATETIME	NO		NO	
-f8	DATETIME	YES	2006-01-01 00:00:00	NO	
+f8	DATETIME	YES	2006-01-01 00:00:00.000000	NO	
 drop table t1;
 SET max_heap_table_size = DEFAULT;
 USE test;

=== modified file 'tests/r/insert.result'
--- tests/r/insert.result	2010-04-20 18:23:07 +0000
+++ tests/r/insert.result	2011-01-18 01:47:30 +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/parser.result'
--- tests/r/parser.result	2010-09-13 22:32:32 +0000
+++ tests/r/parser.result	2011-01-18 01:47:30 +0000
@@ -439,7 +439,7 @@
 DROP TABLE IF EXISTS t1;
 SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
 "1997-12-31 23:59:59" + INTERVAL 1 SECOND
-1998-01-01 00:00:00
[phone]:00:00.000000
 SELECT 1 + INTERVAL(1,0,1,2) + 1;
 1 + INTERVAL(1,0,1,2) + 1
 4

=== modified file 'tests/r/timezone.result'
--- tests/r/timezone.result	2009-02-28 20:43:31 +0000
+++ tests/r/timezone.result	2011-01-18 01:47:30 +0000
@@ -3,7 +3,7 @@
 DROP TABLE IF EXISTS t1;
 select @a:=FROM_UNIXTIME(1);
 @a:=FROM_UNIXTIME(1)
-1970-01-01 00:00:01
[phone]:00:01.000000
 select unix_timestamp(@a);
 unix_timestamp(@a)
 1
@@ -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_datetime.result'
--- tests/r/type_datetime.result	2010-09-10 10:05:56 +0000
+++ tests/r/type_datetime.result	2011-01-18 01:47:30 +0000
@@ -180,7 +180,7 @@
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `da` DATE DEFAULT '1962-03-03',
-  `dt` DATETIME DEFAULT '1962-03-03 00:00:00'
+  `dt` DATETIME DEFAULT '1962-03-03 00:00:00.000000'
 ) ENGINE=DEFAULT COLLATE = utf8_general_ci
 insert into t1 values ();
 insert into t1 values ('2007-03-23 13:49:38','2007-03-23 13:49:38');
@@ -450,7 +450,7 @@
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `da` DATE DEFAULT '1962-03-03',
-  `dt` DATETIME DEFAULT '1962-03-03 00:00:00'
+  `dt` DATETIME DEFAULT '1962-03-03 00:00:00.000000'
 ) ENGINE=DEFAULT COLLATE = utf8_general_ci
 insert into t1 values ();
 insert into t1 values ('2007-03-23 13:49:38','2007-03-23 13:49:38');

=== 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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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-18 01:47:30 +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/plugin/client_test.cc'
--- unittests/plugin/client_test.cc	2010-12-26 00:07:57 +0000
+++ unittests/plugin/client_test.cc	2011-01-18 01:47:30 +0000
@@ -46,7 +46,7 @@
 TEST_F(ClientTest, store_drizzle_time_datetime)
 {
   //TODO: is the sign intentionally ignored in the case of a datetime?
-  type::Time dt= { 2010, 4, 5, 23, 45, 3, 777, true, DRIZZLE_TIMESTAMP_DATETIME};
+  type::Time dt(2010, 4, 5, 23, 45, 3, 777, type::DRIZZLE_TIMESTAMP_DATETIME);
   char expected[]= "2010-04-05 23:45:03.000777";
 
   client.store(&dt);
@@ -57,7 +57,7 @@
 TEST_F(ClientTest, store_drizzle_time_date)
 {
   //TODO: is the sign intentionally ignored in the case of a date?
-  type::Time dt= { 2010, 4, 5, 0, 0, 0, 0, true, DRIZZLE_TIMESTAMP_DATE};
+  type::Time dt(2010, 4, 5, 0, 0, 0, 0, type::DRIZZLE_TIMESTAMP_DATE);
   char expected[]= "2010-04-05";
   
   client.store(&dt);
@@ -67,7 +67,7 @@
 
 TEST_F(ClientTest, store_drizzle_time_time)
 {
-  type::Time dt= { 2010, 4, 5, 23, 45, 3, 777, true, DRIZZLE_TIMESTAMP_TIME};
+  type::Time dt(23, 45, 3, 777, true);
   char expected[]= "-23:45:03.000777";
   
   client.store(&dt);

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