Merge lp:~dedzone/drizzle/ded-rm-my into lp:~drizzle-trunk/drizzle/development

[Djellel E. Difallah]

file name changes:
my_tree => tree
my_var => var
my_time => drizzle_time
my_getopt => option
object changes:
my_option => option

ToDo list:
under ./drizzled/internal/ .. (todo)
./drizzled/my_hash.h needs to be merged with ./drizzled/hash.h
./drizzled/my_getsystime.cc (don't really now if it has to be changed .. but easy)

[Jay Pipes (jaypipes)]

Excellent work!

-jay

review: Approve

[Brian Aker (brianaker)]

Hi!

This code needs to be remerged with trunk.

Thanks!
   -Brian

review: Needs Fixing

[lp:~dedzone/drizzle/ded-rm-my]

1415. By Djellel E. Difallah <ded@ubuntu> on 2010-04-02

merge to trunk

=== modified file 'client/client_priv.h'
--- client/client_priv.h	2009-12-23 21:16:15 +0000
+++ client/client_priv.h	2010-04-02 06:48:30 +0000
@@ -19,7 +19,7 @@
 
 #include "config.h"
 #include <libdrizzle/drizzle_client.h>
-#include "drizzled/my_getopt.h"
+#include "drizzled/option.h"
 #include "drizzled/internal/my_sys.h"
 
 #include "client/get_password.h"

=== modified file 'client/drizzle.cc'
--- client/drizzle.cc	2010-04-01 06:29:46 +0000
+++ client/drizzle.cc	2010-04-02 06:48:30 +0000
@@ -1418,7 +1418,7 @@
 }
 #endif
 
-static struct my_option my_long_options[] =
+static struct option my_long_options[] =
 {
   {"help", '?', N_("Display this help and exit."), 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
     0, 0, 0, 0, 0},
@@ -1606,7 +1606,7 @@
 }
 
 
-static int get_one_option(int optid, const struct my_option *, char *argument)
+static int get_one_option(int optid, const struct option *, char *argument)
 {
   char *endchar= NULL;
   uint64_t temp_drizzle_port= 0;

=== modified file 'client/drizzledump.cc'
--- client/drizzledump.cc	2010-03-26 19:25:23 +0000
+++ client/drizzledump.cc	2010-04-02 06:48:30 +0000
@@ -155,7 +155,7 @@
 
 drizzled::hash_set<string> ignore_table;
 
-static struct my_option my_long_options[] =
+static struct option my_long_options[] =
 {
   {"all", 'a', "Deprecated. Use --create-options instead.",
     (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,
@@ -509,7 +509,7 @@
 } /* write_footer */
 
 
-static int get_one_option(int optid, const struct my_option *, char *argument)
+static int get_one_option(int optid, const struct option *, char *argument)
 {
   char *endchar= NULL;
   uint64_t temp_drizzle_port= 0;

=== modified file 'client/drizzleimport.cc'
--- client/drizzleimport.cc	2010-03-26 21:57:02 +0000
+++ client/drizzleimport.cc	2010-04-02 06:48:30 +0000
@@ -67,7 +67,7 @@
 static uint32_t opt_drizzle_port= 0;
 static int64_t opt_ignore_lines= -1;
 
-static struct my_option my_long_options[] =
+static struct option my_long_options[] =
 {
   {"columns", 'c',
    "Use only these columns to import the data to. Give the column names in a comma separated list. This is same as giving columns to LOAD DATA INFILE.",
@@ -170,7 +170,7 @@
   my_print_variables(my_long_options);
 }
 
-static int get_one_option(int optid, const struct my_option *, char *argument)
+static int get_one_option(int optid, const struct option *, char *argument)
 {
   char *endchar= NULL;
   uint64_t temp_drizzle_port= 0;

=== modified file 'client/drizzleslap.cc'
--- client/drizzleslap.cc	2010-03-25 09:08:56 +0000
+++ client/drizzleslap.cc	2010-04-02 06:48:30 +0000
@@ -528,7 +528,7 @@
 }
 
 
-static struct my_option my_long_options[] =
+static struct option my_long_options[] =
 {
   {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
    0, 0, 0, 0, 0, 0},
@@ -727,7 +727,7 @@
   my_print_help(my_long_options);
 }
 
-static int get_one_option(int optid, const struct my_option *, char *argument)
+static int get_one_option(int optid, const struct option *, char *argument)
 {
   char *endchar= NULL;
   uint64_t temp_drizzle_port= 0;

=== modified file 'client/drizzletest.cc'
--- client/drizzletest.cc	2010-03-26 21:45:29 +0000
+++ client/drizzletest.cc	2010-04-02 06:48:30 +0000
@@ -64,7 +64,7 @@
 /* Added this for string translation. */
 #include "drizzled/gettext.h"
 #include "drizzled/hash.h"
-#include "drizzled/my_time.h"
+#include "drizzled/drizzle_time.h"
 #include "drizzled/charset.h"
 
 #ifndef DRIZZLE_RETURN_SERVER_GONE
@@ -77,7 +77,7 @@
 extern "C"
 unsigned char *get_var_key(const unsigned char* var, size_t *len, bool);
 
-int get_one_option(int optid, const struct my_option *, char *argument);
+int get_one_option(int optid, const struct option *, char *argument);
 
 #define MAX_VAR_NAME_LENGTH    256
 #define MAX_COLUMNS            256
@@ -4578,7 +4578,7 @@
 }
 
 
-static struct my_option my_long_options[] =
+static struct option my_long_options[] =
 {
   {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
    0, 0, 0, 0, 0, 0},
@@ -4666,7 +4666,7 @@
   my_print_variables(my_long_options);
 }
 
-int get_one_option(int optid, const struct my_option *, char *argument)
+int get_one_option(int optid, const struct option *, char *argument)
 {
   char *endchar= NULL;
   uint64_t temp_drizzle_port= 0;

=== modified file 'drizzled/decimal.h'
--- drizzled/decimal.h	2010-03-28 03:03:18 +0000
+++ drizzled/decimal.h	2010-04-02 06:48:30 +0000
@@ -18,7 +18,7 @@
 #include <assert.h>
 #include <drizzled/sql_string.h>
 #include "drizzled/definitions.h"
-#include "drizzled/my_time.h"
+#include "drizzled/drizzle_time.h"
 namespace drizzled
 {
 

=== added file 'drizzled/drizzle_time.cc'
--- drizzled/drizzle_time.cc	1970-01-01 00:00:00 +0000
+++ drizzled/drizzle_time.cc	2010-04-02 06:48:30 +0000
@@ -0,0 +1,1260 @@
+/* Copyright (C) 2004-2006 MySQL AB
+
+ 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; version 2 of the License.
+
+ 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include "config.h"
+
+#include "drizzled/drizzle_time.h"
+
+#include "drizzled/internal/m_string.h"
+#include "drizzled/charset_info.h"
+#include <drizzled/util/test.h>
+#include "drizzled/definitions.h"
+
+#include <cstdio>
+#include <algorithm>
+
+using namespace std;
+
+namespace drizzled
+{
+
+static int check_time_range(DRIZZLE_TIME *my_time, int *warning);
+
+/* Windows version of localtime_r() is declared in my_ptrhead.h */
+
+uint64_t log_10_int[20]=
+{
+  1, 10, 100, 1000, 10000UL, 100000UL, 1000000UL, 10000000UL,
+  100000000ULL, 1000000000ULL, 10000000000ULL, 100000000000ULL,
+  1000000000000ULL, 10000000000000ULL, 100000000000000ULL,
+  1000000000000000ULL, 10000000000000000ULL, 100000000000000000ULL,
+  1000000000000000000ULL, 10000000000000000000ULL
+};
+
+
+/* Position for YYYY-DD-MM HH-MM-DD.FFFFFF AM in default format */
+
+static unsigned char internal_format_positions[]=
+{0, 1, 2, 3, 4, 5, 6, (unsigned char) 255};
+
+static char time_separator=':';
+
+static uint32_t const days_at_timestart=719528;	/* daynr at 1970.01.01 */
+unsigned char days_in_month[]= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
+
+/*
+  Offset of system time zone from UTC in seconds used to speed up
+  work of my_system_gmt_sec() function.
+*/
+static long my_time_zone=0;
+
+
+/* Calc days in one year. works with 0 <= year <= 99 */
+
+uint32_t calc_days_in_year(uint32_t year)
+{
+  return ((year & 3) == 0 && (year%100 || (year%400 == 0 && year)) ?
+          366 : 365);
+}
+
+/**
+  @brief Check datetime value for validity according to flags.
+
+  @param[in]  ltime          Date to check.
+  @param[in]  not_zero_date  ltime is not the zero date
+  @param[in]  flags          flags to check
+                             (see str_to_datetime() flags in drizzle_time.h)
+  @param[out] was_cut        set to 2 if value was invalid according to flags.
+                             (Feb 29 in non-leap etc.)  This remains unchanged
+                             if value is not invalid.
+
+  @details Here we assume that year and month is ok!
+    If month is 0 we allow any date. (This only happens if we allow zero
+    date parts in str_to_datetime())
+    Disallow dates with zero year and non-zero month and/or day.
+
+  @return
+    0  OK
+    1  error
+*/
+
+bool check_date(const DRIZZLE_TIME *ltime, bool not_zero_date,
+                   uint32_t flags, int *was_cut)
+{
+  if (not_zero_date)
+  {
+    if ((((flags & TIME_NO_ZERO_IN_DATE) || !(flags & TIME_FUZZY_DATE)) &&
+         (ltime->month == 0 || ltime->day == 0)) ||
+        (!(flags & TIME_INVALID_DATES) &&
+         ltime->month && ltime->day > days_in_month[ltime->month-1] &&
+         (ltime->month != 2 || calc_days_in_year(ltime->year) != 366 ||
+          ltime->day != 29)))
+    {
+      *was_cut= 2;
+      return true;
+    }
+  }
+  else if (flags & TIME_NO_ZERO_DATE)
+  {
+    /*
+      We don't set *was_cut here to signal that the problem was a zero date
+      and not an invalid date
+    */
+    return true;
+  }
+  return false;
+}
+
+
+/*
+  Convert a timestamp string to a DRIZZLE_TIME value.
+
+  SYNOPSIS
+    str_to_datetime()
+    str                 String to parse
+    length              Length of string
+    l_time              Date is stored here
+    flags               Bitmap of following items
+                        TIME_FUZZY_DATE    Set if we should allow partial dates
+                        TIME_DATETIME_ONLY Set if we only allow full datetimes.
+                        TIME_NO_ZERO_IN_DATE	Don't allow partial dates
+                        TIME_NO_ZERO_DATE	Don't allow 0000-00-00 date
+                        TIME_INVALID_DATES	Allow 2000-02-31
+    was_cut             0	Value OK
+			1       If value was cut during conversion
+			2	check_date(date,flags) considers date invalid
+
+  DESCRIPTION
+    At least the following formats are recogniced (based on number of digits)
+    YYMMDD, YYYYMMDD, YYMMDDHHMMSS, YYYYMMDDHHMMSS
+    YY-MM-DD, YYYY-MM-DD, YY-MM-DD HH.MM.SS
+    YYYYMMDDTHHMMSS  where T is a the character T (ISO8601)
+    Also dates where all parts are zero are allowed
+
+    The second part may have an optional .###### fraction part.
+
+  NOTES
+   This function should work with a format position vector as long as the
+   following things holds:
+   - All date are kept together and all time parts are kept together
+   - Date and time parts must be separated by blank
+   - Second fractions must come after second part and be separated
+     by a '.'.  (The second fractions are optional)
+   - AM/PM must come after second fractions (or after seconds if no fractions)
+   - Year must always been specified.
+   - If time is before date, then we will use datetime format only if
+     the argument consist of two parts, separated by space.
+     Otherwise we will assume the argument is a date.
+   - The hour part must be specified in hour-minute-second order.
+
+  RETURN VALUES
+    DRIZZLE_TIMESTAMP_NONE        String wasn't a timestamp, like
+                                [DD [HH:[MM:[SS]]]].fraction.
+                                l_time is not changed.
+    DRIZZLE_TIMESTAMP_DATE        DATE string (YY MM and DD parts ok)
+    DRIZZLE_TIMESTAMP_DATETIME    Full timestamp
+    DRIZZLE_TIMESTAMP_ERROR       Timestamp with wrong values.
+                                All elements in l_time is set to 0
+*/
+
+#define MAX_DATE_PARTS 8
+
+enum enum_drizzle_timestamp_type
+str_to_datetime(const char *str, uint32_t length, DRIZZLE_TIME *l_time,
+                uint32_t flags, int *was_cut)
+{
+  uint32_t field_length, year_length=4, digits, i, number_of_fields;
+  uint32_t date[MAX_DATE_PARTS], date_len[MAX_DATE_PARTS];
+  uint32_t add_hours= 0, start_loop;
+  uint32_t not_zero_date, allow_space;
+  bool is_internal_format;
+  const char *pos, *last_field_pos=NULL;
+  const char *end=str+length;
+  const unsigned char *format_position;
+  bool found_delimitier= 0, found_space= 0;
+  uint32_t frac_pos, frac_len;
+
+  *was_cut= 0;
+
+  /* Skip space at start */
+  for (; str != end && my_isspace(&my_charset_utf8_general_ci, *str) ; str++)
+    ;
+  if (str == end || ! my_isdigit(&my_charset_utf8_general_ci, *str))
+  {
+    *was_cut= 1;
+    return(DRIZZLE_TIMESTAMP_NONE);
+  }
+
+  is_internal_format= 0;
+  /* This has to be changed if want to activate different timestamp formats */
+  format_position= internal_format_positions;
+
+  /*
+    Calculate number of digits in first part.
+    If length= 8 or >= 14 then year is of format YYYY.
+    (YYYY-MM-DD,  YYYYMMDD, YYYYYMMDDHHMMSS)
+  */
+  for (pos=str;
+       pos != end && (my_isdigit(&my_charset_utf8_general_ci,*pos) || *pos == 'T');
+       pos++)
+    ;
+
+  digits= (uint32_t) (pos-str);
+  start_loop= 0;                                /* Start of scan loop */
+  date_len[format_position[0]]= 0;              /* Length of year field */
+  if (pos == end || *pos == '.')
+  {
+    /* Found date in internal format (only numbers like YYYYMMDD) */
+    year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
+    field_length= year_length;
+    is_internal_format= 1;
+    format_position= internal_format_positions;
+  }
+  else
+  {
+    if (format_position[0] >= 3)                /* If year is after HHMMDD */
+    {
+      /*
+        If year is not in first part then we have to determinate if we got
+        a date field or a datetime field.
+        We do this by checking if there is two numbers separated by
+        space in the input.
+      */
+      while (pos < end && !my_isspace(&my_charset_utf8_general_ci, *pos))
+        pos++;
+      while (pos < end && !my_isdigit(&my_charset_utf8_general_ci, *pos))
+        pos++;
+      if (pos == end)
+      {
+        if (flags & TIME_DATETIME_ONLY)
+        {
+          *was_cut= 1;
+          return(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;
+        start_loop= 5;                         /* Start with first date part */
+      }
+    }
+
+    field_length= format_position[0] == 0 ? 4 : 2;
+  }
+
+  /*
+    Only allow space in the first "part" of the datetime field and:
+    - after days, part seconds
+    - before and after AM/PM (handled by code later)
+
+    2003-03-03 20:00:20 AM
+    20:00:20.000000 AM 03-03-2000
+  */
+  i= max((uint32_t) format_position[0], (uint32_t) format_position[1]);
+  set_if_bigger(i, (uint32_t) format_position[2]);
+  allow_space= ((1 << i) | (1 << format_position[6]));
+  allow_space&= (1 | 2 | 4 | 8);
+
+  not_zero_date= 0;
+  for (i = start_loop;
+       i < MAX_DATE_PARTS-1 && str != end &&
+         my_isdigit(&my_charset_utf8_general_ci,*str);
+       i++)
+  {
+    const char *start= str;
+    uint32_t tmp_value= (uint32_t) (unsigned char) (*str++ - '0');
+    while (str != end && my_isdigit(&my_charset_utf8_general_ci,str[0]) &&
+           (!is_internal_format || --field_length))
+    {
+      tmp_value=tmp_value*10 + (uint32_t) (unsigned char) (*str - '0');
+      str++;
+    }
+    date_len[i]= (uint32_t) (str - start);
+    if (tmp_value > 999999)                     /* Impossible date part */
+    {
+      *was_cut= 1;
+      return(DRIZZLE_TIMESTAMP_NONE);
+    }
+    date[i]=tmp_value;
+    not_zero_date|= tmp_value;
+
+    /* Length of next field */
+    field_length= format_position[i+1] == 0 ? 4 : 2;
+
+    if ((last_field_pos= str) == end)
+    {
+      i++;                                      /* Register last found part */
+      break;
+    }
+    /* Allow a 'T' after day to allow CCYYMMDDT type of fields */
+    if (i == format_position[2] && *str == 'T')
+    {
+      str++;                                    /* ISO8601:  CCYYMMDDThhmmss */
+      continue;
+    }
+    if (i == format_position[5])                /* Seconds */
+    {
+      if (*str == '.')                          /* Followed by part seconds */
+      {
+        str++;
+        field_length= 6;                        /* 6 digits */
+      }
+      continue;
+    }
+    while (str != end &&
+           (my_ispunct(&my_charset_utf8_general_ci,*str) ||
+            my_isspace(&my_charset_utf8_general_ci,*str)))
+    {
+      if (my_isspace(&my_charset_utf8_general_ci,*str))
+      {
+        if (!(allow_space & (1 << i)))
+        {
+          *was_cut= 1;
+          return(DRIZZLE_TIMESTAMP_NONE);
+        }
+        found_space= 1;
+      }
+      str++;
+      found_delimitier= 1;                      /* Should be a 'normal' date */
+    }
+    /* Check if next position is AM/PM */
+    if (i == format_position[6])                /* Seconds, time for AM/PM */
+    {
+      i++;                                      /* Skip AM/PM part */
+      if (format_position[7] != 255)            /* If using AM/PM */
+      {
+        if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
+        {
+          if (str[0] == 'p' || str[0] == 'P')
+            add_hours= 12;
+          else if (str[0] != 'a' || str[0] != 'A')
+            continue;                           /* Not AM/PM */
+          str+= 2;                              /* Skip AM/PM */
+          /* Skip space after AM/PM */
+          while (str != end && my_isspace(&my_charset_utf8_general_ci,*str))
+            str++;
+        }
+      }
+    }
+    last_field_pos= str;
+  }
+  if (found_delimitier && !found_space && (flags & TIME_DATETIME_ONLY))
+  {
+    *was_cut= 1;
+    return(DRIZZLE_TIMESTAMP_NONE);          /* Can't be a datetime */
+  }
+
+  str= last_field_pos;
+
+  number_of_fields= i - start_loop;
+  while (i < MAX_DATE_PARTS)
+  {
+    date_len[i]= 0;
+    date[i++]= 0;
+  }
+
+  if (!is_internal_format)
+  {
+    year_length= date_len[(uint32_t) format_position[0]];
+    if (!year_length)                           /* Year must be specified */
+    {
+      *was_cut= 1;
+      return(DRIZZLE_TIMESTAMP_NONE);
+    }
+
+    l_time->year=               date[(uint32_t) format_position[0]];
+    l_time->month=              date[(uint32_t) format_position[1]];
+    l_time->day=                date[(uint32_t) format_position[2]];
+    l_time->hour=               date[(uint32_t) format_position[3]];
+    l_time->minute=             date[(uint32_t) format_position[4]];
+    l_time->second=             date[(uint32_t) format_position[5]];
+
+    frac_pos= (uint32_t) format_position[6];
+    frac_len= date_len[frac_pos];
+    if (frac_len < 6)
+      date[frac_pos]*= (uint32_t) log_10_int[6 - frac_len];
+    l_time->second_part= date[frac_pos];
+
+    if (format_position[7] != (unsigned char) 255)
+    {
+      if (l_time->hour > 12)
+      {
+        *was_cut= 1;
+        goto err;
+      }
+      l_time->hour= l_time->hour%12 + add_hours;
+    }
+  }
+  else
+  {
+    l_time->year=       date[0];
+    l_time->month=      date[1];
+    l_time->day=        date[2];
+    l_time->hour=       date[3];
+    l_time->minute=     date[4];
+    l_time->second=     date[5];
+    if (date_len[6] < 6)
+      date[6]*= (uint32_t) log_10_int[6 - date_len[6]];
+    l_time->second_part=date[6];
+  }
+  l_time->neg= 0;
+
+  if (year_length == 2 && not_zero_date)
+    l_time->year+= (l_time->year < YY_PART_YEAR ? 2000 : 1900);
+
+  if (number_of_fields < 3 ||
+      l_time->year > 9999 || l_time->month > 12 ||
+      l_time->day > 31 || l_time->hour > 23 ||
+      l_time->minute > 59 || l_time->second > 59)
+  {
+    /* Only give warning for a zero date if there is some garbage after */
+    if (!not_zero_date)                         /* If zero date */
+    {
+      for (; str != end ; str++)
+      {
+        if (!my_isspace(&my_charset_utf8_general_ci, *str))
+        {
+          not_zero_date= 1;                     /* Give warning */
+          break;
+        }
+      }
+    }
+    *was_cut= test(not_zero_date);
+    goto err;
+  }
+
+  if (check_date(l_time, not_zero_date != 0, flags, was_cut))
+    goto err;
+
+  l_time->time_type= (number_of_fields <= 3 ?
+                      DRIZZLE_TIMESTAMP_DATE : DRIZZLE_TIMESTAMP_DATETIME);
+
+  for (; str != end ; str++)
+  {
+    if (!my_isspace(&my_charset_utf8_general_ci,*str))
+    {
+      *was_cut= 1;
+      break;
+    }
+  }
+
+  return(l_time->time_type=
+              (number_of_fields <= 3 ? DRIZZLE_TIMESTAMP_DATE :
+                                       DRIZZLE_TIMESTAMP_DATETIME));
+
+err:
+  memset(l_time, 0, sizeof(*l_time));
+  return(DRIZZLE_TIMESTAMP_ERROR);
+}
+
+
+/*
+ Convert a time string to a DRIZZLE_TIME struct.
+
+  SYNOPSIS
+   str_to_time()
+   str                  A string in full TIMESTAMP format or
+                        [-] DAYS [H]H:MM:SS, [H]H:MM:SS, [M]M:SS, [H]HMMSS,
+                        [M]MSS or [S]S
+                        There may be an optional [.second_part] after seconds
+   length               Length of str
+   l_time               Store result here
+   warning              Set DRIZZLE_TIME_WARN_TRUNCATED flag if the input string
+                        was cut during conversion, and/or
+                        DRIZZLE_TIME_WARN_OUT_OF_RANGE flag, if the value is
+                        out of range.
+
+   NOTES
+     Because of the extra days argument, this function can only
+     work with times where the time arguments are in the above order.
+
+   RETURN
+     0  ok
+     1  error
+*/
+
+bool str_to_time(const char *str, uint32_t length, DRIZZLE_TIME *l_time,
+                    int *warning)
+{
+  uint32_t date[5];
+  uint64_t value;
+  const char *end=str+length, *end_of_days;
+  bool found_days,found_hours;
+  uint32_t state;
+
+  l_time->neg=0;
+  *warning= 0;
+  for (; str != end && my_isspace(&my_charset_utf8_general_ci,*str) ; str++)
+    length--;
+  if (str != end && *str == '-')
+  {
+    l_time->neg=1;
+    str++;
+    length--;
+  }
+  if (str == end)
+    return 1;
+
+  /* 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)
+    {
+      if (was_cut)
+        *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
+      return res == DRIZZLE_TIMESTAMP_ERROR;
+    }
+  }
+
+  /* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */
+  for (value=0; str != end && my_isdigit(&my_charset_utf8_general_ci,*str) ; str++)
+    value=value*10L + (long) (*str - '0');
+
+  /* Skip all space after 'days' */
+  end_of_days= str;
+  for (; str != end && my_isspace(&my_charset_utf8_general_ci, str[0]) ; str++)
+    ;
+
+  found_days=found_hours=0;
+  if ((uint32_t) (end-str) > 1 && str != end_of_days &&
+      my_isdigit(&my_charset_utf8_general_ci, *str))
+  {                                             /* Found days part */
+    date[0]= (uint32_t) value;
+    state= 1;                                   /* Assume next is hours */
+    found_days= 1;
+  }
+  else if ((end-str) > 1 &&  *str == time_separator &&
+           my_isdigit(&my_charset_utf8_general_ci, str[1]))
+  {
+    date[0]= 0;                                 /* Assume we found hours */
+    date[1]= (uint32_t) value;
+    state=2;
+    found_hours=1;
+    str++;                                      /* skip ':' */
+  }
+  else
+  {
+    /* String given as one number; assume HHMMSS format */
+    date[0]= 0;
+    date[1]= (uint32_t) (value/10000);
+    date[2]= (uint32_t) (value/100 % 100);
+    date[3]= (uint32_t) (value % 100);
+    state=4;
+    goto fractional;
+  }
+
+  /* Read hours, minutes and seconds */
+  for (;;)
+  {
+    for (value=0; str != end && my_isdigit(&my_charset_utf8_general_ci,*str) ; str++)
+      value=value*10L + (long) (*str - '0');
+    date[state++]= (uint32_t) value;
+    if (state == 4 || (end-str) < 2 || *str != time_separator ||
+        !my_isdigit(&my_charset_utf8_general_ci,str[1]))
+      break;
+    str++;                                      /* Skip time_separator (':') */
+  }
+
+  if (state != 4)
+  {                                             /* Not HH:MM:SS */
+    /* Fix the date to assume that seconds was given */
+    if (!found_hours && !found_days)
+    {
+      internal::bmove_upp((unsigned char*) (date+4), (unsigned char*) (date+state),
+                sizeof(long)*(state-1));
+      memset(date, 0, sizeof(long)*(4-state));
+    }
+    else
+      memset(date+state, 0, sizeof(long)*(4-state));
+  }
+
+fractional:
+  /* Get fractional second part */
+  if ((end-str) >= 2 && *str == '.' && my_isdigit(&my_charset_utf8_general_ci,str[1]))
+  {
+    int field_length= 5;
+    str++; value=(uint32_t) (unsigned char) (*str - '0');
+    while (++str != end && my_isdigit(&my_charset_utf8_general_ci, *str))
+    {
+      if (field_length-- > 0)
+        value= value*10 + (uint32_t) (unsigned char) (*str - '0');
+    }
+    if (field_length > 0)
+      value*= (long) log_10_int[field_length];
+    else if (field_length < 0)
+      *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
+    date[4]= (uint32_t) value;
+  }
+  else
+    date[4]=0;
+
+  /* Check for exponent part: E<gigit> | E<sign><digit> */
+  /* (may occur as result of %g formatting of time value) */
+  if ((end - str) > 1 &&
+      (*str == 'e' || *str == 'E') &&
+      (my_isdigit(&my_charset_utf8_general_ci, str[1]) ||
+       ((str[1] == '-' || str[1] == '+') &&
+        (end - str) > 2 &&
+        my_isdigit(&my_charset_utf8_general_ci, str[2]))))
+    return 1;
+
+  if (internal_format_positions[7] != 255)
+  {
+    /* Read a possible AM/PM */
+    while (str != end && my_isspace(&my_charset_utf8_general_ci, *str))
+      str++;
+    if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
+    {
+      if (str[0] == 'p' || str[0] == 'P')
+      {
+        str+= 2;
+        date[1]= date[1]%12 + 12;
+      }
+      else if (str[0] == 'a' || str[0] == 'A')
+        str+=2;
+    }
+  }
+
+  /* Integer overflow checks */
+  if (date[0] > UINT_MAX || date[1] > UINT_MAX ||
+      date[2] > UINT_MAX || date[3] > UINT_MAX ||
+      date[4] > UINT_MAX)
+    return 1;
+
+  l_time->year=         0;                      /* For protocol::store_time */
+  l_time->month=        0;
+  l_time->day=          date[0];
+  l_time->hour=         date[1];
+  l_time->minute=       date[2];
+  l_time->second=       date[3];
+  l_time->second_part=  date[4];
+  l_time->time_type= DRIZZLE_TIMESTAMP_TIME;
+
+  /* Check if the value is valid and fits into DRIZZLE_TIME range */
+  if (check_time_range(l_time, warning))
+    return 1;
+
+  /* Check if there is garbage at end of the DRIZZLE_TIME specification */
+  if (str != end)
+  {
+    do
+    {
+      if (!my_isspace(&my_charset_utf8_general_ci,*str))
+      {
+        *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
+        break;
+      }
+    } while (++str != end);
+  }
+  return 0;
+}
+
+
+/*
+  Check 'time' value to lie in the DRIZZLE_TIME range
+
+  SYNOPSIS:
+    check_time_range()
+    time     pointer to DRIZZLE_TIME value
+    warning  set DRIZZLE_TIME_WARN_OUT_OF_RANGE flag if the value is out of range
+
+  DESCRIPTION
+  If the time value lies outside of the range [-838:59:59, 838:59:59],
+  set it to the closest endpoint of the range and set
+  DRIZZLE_TIME_WARN_OUT_OF_RANGE flag in the 'warning' variable.
+
+  RETURN
+    0        time value is valid, but was possibly truncated
+    1        time value is invalid
+*/
+
+static int check_time_range(DRIZZLE_TIME *my_time, int *warning)
+{
+  int64_t hour;
+
+  if (my_time->minute >= 60 || my_time->second >= 60)
+    return 1;
+
+  hour= my_time->hour + (24*my_time->day);
+  if (hour <= TIME_MAX_HOUR &&
+      (hour != TIME_MAX_HOUR || my_time->minute != TIME_MAX_MINUTE ||
+       my_time->second != TIME_MAX_SECOND || !my_time->second_part))
+    return 0;
+
+  my_time->day= 0;
+  my_time->hour= TIME_MAX_HOUR;
+  my_time->minute= TIME_MAX_MINUTE;
+  my_time->second= TIME_MAX_SECOND;
+  my_time->second_part= 0;
+  *warning|= DRIZZLE_TIME_WARN_OUT_OF_RANGE;
+  return 0;
+}
+
+
+/*
+  Prepare offset of system time zone from UTC for my_system_gmt_sec() func.
+
+  SYNOPSIS
+    init_time()
+*/
+void init_time(void)
+{
+  time_t seconds;
+  struct tm *l_time,tm_tmp;
+  DRIZZLE_TIME my_time;
+  bool not_used;
+
+  seconds= (time_t) time((time_t*) 0);
+  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;
+  my_time.month=	(uint32_t) l_time->tm_mon+1;
+  my_time.day=		(uint32_t) l_time->tm_mday;
+  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.second_part=  0;
+  my_time.neg=          false;
+  my_system_gmt_sec(&my_time, &my_time_zone, &not_used); /* Init my_time_zone */
+}
+
+
+/*
+  Handle 2 digit year conversions
+
+  SYNOPSIS
+  year_2000_handling()
+  year     2 digit year
+
+  RETURN
+    Year between 1970-2069
+*/
+
+uint32_t year_2000_handling(uint32_t year)
+{
+  if ((year=year+1900) < 1900+YY_PART_YEAR)
+    year+=100;
+  return year;
+}
+
+
+/*
+  Calculate nr of day since year 0 in new date-system (from 1615)
+
+  SYNOPSIS
+    calc_daynr()
+    year		 Year (exact 4 digit year, no year conversions)
+    month		 Month
+    day			 Day
+
+  NOTES: 0000-00-00 is a valid date, and will return 0
+
+  RETURN
+    Days since 0000-00-00
+*/
+
+long calc_daynr(uint32_t year,uint32_t month,uint32_t day)
+{
+  long delsum;
+  int temp;
+
+  if (year == 0 && month == 0 && day == 0)
+    return(0);				/* Skip errors */
+  delsum= (long) (365L * year+ 31*(month-1) +day);
+  if (month <= 2)
+      year--;
+  else
+    delsum-= (long) (month*4+23)/10;
+  temp=(int) ((year/100+1)*3)/4;
+  return(delsum+(int) year/4-temp);
+} /* calc_daynr */
+
+
+/*
+  Convert time in DRIZZLE_TIME representation in system time zone to its
+  time_t form (number of seconds in UTC since begginning of Unix Epoch).
+
+  SYNOPSIS
+    my_system_gmt_sec()
+      t               - time value to be converted
+      my_timezone     - pointer to long where offset of system time zone
+                        from UTC will be stored for caching
+      in_dst_time_gap - set to true if time falls into spring time-gap
+
+  NOTES
+    The idea is to cache the time zone offset from UTC (including daylight
+    saving time) for the next call to make things faster. But currently we
+    just calculate this offset during startup (by calling init_time()
+    function) and use it all the time.
+    Time value provided should be legal time value (e.g. '2003-01-01 25:00:00'
+    is not allowed).
+
+  RETURN VALUE
+    Time in UTC seconds since Unix Epoch representation.
+*/
+time_t
+my_system_gmt_sec(const DRIZZLE_TIME *t_src, long *my_timezone,
+                  bool *in_dst_time_gap)
+{
+  uint32_t loop;
+  time_t tmp= 0;
+  int shift= 0;
+  DRIZZLE_TIME tmp_time;
+  DRIZZLE_TIME *t= &tmp_time;
+  struct tm *l_time,tm_tmp;
+  long diff, current_timezone;
+
+  /*
+    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(DRIZZLE_TIME));
+
+  if (!validate_timestamp_range(t))
+    return 0;
+
+  /*
+    Calculate the gmt time based on current time and timezone
+    The -1 on the end is to ensure that if have a date that exists twice
+    (like 2002-10-27 02:00:0 MET), we will find the initial date.
+
+    By doing -3600 we will have to call localtime_r() several times, but
+    I couldn't come up with a better way to get a repeatable result :(
+
+    We can't use mktime() as it's buggy on many platforms and not thread safe.
+
+    Note: this code assumes that our time_t estimation is not too far away
+    from real value (we assume that localtime_r(tmp) will return something
+    within 24 hrs from t) which is probably true for all current time zones.
+
+    Note2: For the dates, which have time_t representation close to
+    MAX_INT32 (efficient time_t limit for supported platforms), we should
+    do a small trick to avoid overflow. That is, convert the date, which is
+    two days earlier, and then add these days to the final value.
+
+    The same trick is done for the values close to 0 in time_t
+    representation for platfroms with unsigned time_t (QNX).
+
+    To be more verbose, here is a sample (extracted from the code below):
+    (calc_daynr(2038, 1, 19) - (long) days_at_timestart)*86400L + 4*3600L
+    would return -2147480896 because of the long type overflow. In result
+    we would get 1901 year in localtime_r(), which is an obvious error.
+
+    Alike problem raises with the dates close to Epoch. E.g.
+    (calc_daynr(1969, 12, 31) - (long) days_at_timestart)*86400L + 23*3600L
+    will give -3600.
+
+    On some platforms, (E.g. on QNX) time_t is unsigned and localtime(-3600)
+    wil give us a date around 2106 year. Which is no good.
+
+    Theoreticaly, there could be problems with the latter conversion:
+    there are at least two timezones, which had time switches near 1 Jan
+    of 1970 (because of political reasons). These are America/Hermosillo and
+    America/Mazatlan time zones. They changed their offset on
+    1970-01-01 08:00:00 UTC from UTC-8 to UTC-7. For these zones
+    the code below will give incorrect results for dates close to
+    1970-01-01, in the case OS takes into account these historical switches.
+    Luckily, it seems that we support only one platform with unsigned
+    time_t. It's QNX. And QNX does not support historical timezone data at all.
+    E.g. there are no /usr/share/zoneinfo/ files or any other mean to supply
+    historical information for localtime_r() etc. That is, the problem is not
+    relevant to QNX.
+
+    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
+      1970, 1 of Jan. For both dates we use shift, which is added
+      to t->day in order to step out a bit from the border.
+      This is required for platforms, where time_t is unsigned.
+      As far as I know, among the platforms we support it's only QNX.
+      Note: the order of below if-statements is significant.
+    */
+
+    if ((t->year == TIMESTAMP_MIN_YEAR + 1) && (t->month == 1)
+        && (t->day <= 10))
+    {
+      t->day+= 2;
+      shift= -2;
+    }
+
+    if ((t->year == TIMESTAMP_MIN_YEAR) && (t->month == 12)
+        && (t->day == 31))
+    {
+      t->year++;
+      t->month= 1;
+      t->day= 2;
+      shift= -2;
+    }
+  }
+#endif
+
+  tmp= (time_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);
+
+  current_timezone= my_time_zone;
+  localtime_r(&tmp,&tm_tmp);
+  l_time=&tm_tmp;
+  for (loop=0;
+       loop < 2 &&
+	 (t->hour != (uint32_t) l_time->tm_hour ||
+	  t->minute != (uint32_t) l_time->tm_min ||
+          t->second != (uint32_t) l_time->tm_sec);
+       loop++)
+  {					/* One check should be enough ? */
+    /* Get difference in days */
+    int days= t->day - l_time->tm_mday;
+    if (days < -1)
+      days= 1;					/* Month has wrapped */
+    else if (days > 1)
+      days= -1;
+    diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour)) +
+          (long) (60*((int) t->minute - (int) l_time->tm_min)) +
+          (long) ((int) t->second - (int) l_time->tm_sec));
+    current_timezone+= diff+3600;		/* Compensate for -3600 above */
+    tmp+= (time_t) diff;
+    localtime_r(&tmp,&tm_tmp);
+    l_time=&tm_tmp;
+  }
+  /*
+    Fix that if we are in the non existing daylight saving time hour
+    we move the start of the next real hour.
+
+    This code doesn't handle such exotical thing as time-gaps whose length
+    is more than one hour or non-integer (latter can theoretically happen
+    if one of seconds will be removed due leap correction, or because of
+    general time correction like it happened for Africa/Monrovia time zone
+    in year 1972).
+  */
+  if (loop == 2 && t->hour != (uint32_t) l_time->tm_hour)
+  {
+    int days= t->day - l_time->tm_mday;
+    if (days < -1)
+      days=1;					/* Month has wrapped */
+    else if (days > 1)
+      days= -1;
+    diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour))+
+	  (long) (60*((int) t->minute - (int) l_time->tm_min)) +
+          (long) ((int) t->second - (int) l_time->tm_sec));
+    if (diff == 3600)
+      tmp+=3600 - t->minute*60 - t->second;	/* Move to next hour */
+    else if (diff == -3600)
+      tmp-=t->minute*60 + t->second;		/* Move to previous hour */
+
+    *in_dst_time_gap= true;
+  }
+  *my_timezone= current_timezone;
+
+
+  /* shift back, if we were dealing with boundary dates */
+  tmp+= shift*86400L;
+
+  /*
+    This is possible for dates, which slightly exceed boundaries.
+    Conversion will pass ok for them, but we don't allow them.
+    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.
+  */
+  if ((tmp < TIMESTAMP_MIN_VALUE) || (tmp > TIMESTAMP_MAX_VALUE))
+    tmp= 0;
+
+  return (time_t) tmp;
+} /* my_system_gmt_sec */
+
+
+/* Set DRIZZLE_TIME structure to 0000-00-00 00:00:00.000000 */
+
+void set_zero_time(DRIZZLE_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.
+  This functions don't check that given DRIZZLE_TIME structure members are
+  in valid range. If they are not, return value won't reflect any
+  valid date either. Additionally, make_time doesn't take into
+  account time->day member: it's assumed that days have been converted
+  to hours already.
+
+  RETURN
+    number of characters written to 'to'
+*/
+
+static int my_time_to_str(const DRIZZLE_TIME *l_time, char *to)
+{
+  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);
+}
+
+int my_date_to_str(const DRIZZLE_TIME *l_time, char *to)
+{
+  return sprintf(to, "%04u-%02u-%02u",
+                         l_time->year,
+                         l_time->month,
+                         l_time->day);
+}
+
+int my_datetime_to_str(const DRIZZLE_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 DRIZZLE_TIME *l_time, char *to)
+{
+  switch (l_time->time_type) {
+  case DRIZZLE_TIMESTAMP_DATETIME:
+    return my_datetime_to_str(l_time, to);
+  case DRIZZLE_TIMESTAMP_DATE:
+    return my_date_to_str(l_time, to);
+  case DRIZZLE_TIMESTAMP_TIME:
+    return my_time_to_str(l_time, to);
+  case DRIZZLE_TIMESTAMP_NONE:
+  case DRIZZLE_TIMESTAMP_ERROR:
+    to[0]='\0';
+    return 0;
+  default:
+    assert(0);
+    return 0;
+  }
+}
+
+
+/*
+  Convert datetime value specified as number to broken-down TIME
+  representation and form value of DATETIME type as side-effect.
+
+  SYNOPSIS
+    number_to_datetime()
+      nr         - datetime value as number
+      time_res   - pointer for structure for broken-down representation
+      flags      - flags to use in validating date, as in str_to_datetime()
+      was_cut    0      Value ok
+                 1      If value was cut during conversion
+                 2      check_date(date,flags) considers date invalid
+
+  DESCRIPTION
+    Convert a datetime value of formats YYMMDD, YYYYMMDD, YYMMDDHHMSS,
+    YYYYMMDDHHMMSS to broken-down DRIZZLE_TIME representation. Return value in
+    YYYYMMDDHHMMSS format as side-effect.
+
+    This function also checks if datetime value fits in DATETIME range.
+
+  RETURN VALUE
+    -1              Timestamp with wrong values
+    anything else   DATETIME as integer in YYYYMMDDHHMMSS format
+    Datetime value in YYYYMMDDHHMMSS format.
+*/
+
+int64_t number_to_datetime(int64_t nr, DRIZZLE_TIME *time_res,
+                            uint32_t flags, int *was_cut)
+{
+  long part1,part2;
+
+  *was_cut= 0;
+  memset(time_res, 0, sizeof(*time_res));
+  time_res->time_type=DRIZZLE_TIMESTAMP_DATE;
+
+  if (nr == 0LL || nr >= 10000101000000LL)
+  {
+    time_res->time_type=DRIZZLE_TIMESTAMP_DATETIME;
+    goto ok;
+  }
+  if (nr < 101)
+    goto err;
+  if (nr <= (YY_PART_YEAR-1)*10000L+1231L)
+  {
+    nr= (nr+20000000L)*1000000L;                 /* YYMMDD, year: 2000-2069 */
+    goto ok;
+  }
+  if (nr < (YY_PART_YEAR)*10000L+101L)
+    goto err;
+  if (nr <= 991231L)
+  {
+    nr= (nr+19000000L)*1000000L;                 /* YYMMDD, year: 1970-1999 */
+    goto ok;
+  }
+  if (nr < 10000101L)
+    goto err;
+  if (nr <= 99991231L)
+  {
+    nr= nr*1000000L;
+    goto ok;
+  }
+  if (nr < 101000000L)
+    goto err;
+
+  time_res->time_type=DRIZZLE_TIMESTAMP_DATETIME;
+
+  if (nr <= (YY_PART_YEAR-1) * 10000000000LL + 1231235959LL)
+  {
+    nr= nr + 20000000000000LL;                   /* YYMMDDHHMMSS, 2000-2069 */
+    goto ok;
+  }
+  if (nr <  YY_PART_YEAR * 10000000000LL + 101000000LL)
+    goto err;
+  if (nr <= 991231235959LL)
+    nr= nr + 19000000000000LL;		/* YYMMDDHHMMSS, 1970-1999 */
+
+ ok:
+  part1=(long) (nr / 1000000LL);
+  part2=(long) (nr - (int64_t) part1 * 1000000LL);
+  time_res->year=  (int) (part1/10000L);  part1%=10000L;
+  time_res->month= (int) part1 / 100;
+  time_res->day=   (int) part1 % 100;
+  time_res->hour=  (int) (part2/10000L);  part2%=10000L;
+  time_res->minute=(int) part2 / 100;
+  time_res->second=(int) part2 % 100;
+
+  if (time_res->year <= 9999 && time_res->month <= 12 &&
+      time_res->day <= 31 && time_res->hour <= 23 &&
+      time_res->minute <= 59 && time_res->second <= 59 &&
+      !check_date(time_res, (nr != 0), flags, was_cut))
+    return nr;
+
+  /* Don't want to have was_cut get set if NO_ZERO_DATE was violated. */
+  if (!nr && (flags & TIME_NO_ZERO_DATE))
+    return -1LL;
+
+ err:
+  *was_cut= 1;
+  return -1LL;
+}
+
+
+/* Convert time value to integer in YYYYMMDDHHMMSS format */
+
+uint64_t TIME_to_uint64_t_datetime(const DRIZZLE_TIME *my_time)
+{
+  return ((uint64_t) (my_time->year * 10000UL +
+                       my_time->month * 100UL +
+                       my_time->day) * 1000000ULL +
+          (uint64_t) (my_time->hour * 10000UL +
+                       my_time->minute * 100UL +
+                       my_time->second));
+}
+
+
+/* Convert DRIZZLE_TIME value to integer in YYYYMMDD format */
+
+static uint64_t TIME_to_uint64_t_date(const DRIZZLE_TIME *my_time)
+{
+  return (uint64_t) (my_time->year * 10000UL + my_time->month * 100UL +
+                      my_time->day);
+}
+
+
+/*
+  Convert DRIZZLE_TIME value to integer in HHMMSS format.
+  This function doesn't take into account time->day member:
+  it's assumed that days have been converted to hours already.
+*/
+
+static uint64_t TIME_to_uint64_t_time(const DRIZZLE_TIME *my_time)
+{
+  return (uint64_t) (my_time->hour * 10000UL +
+                      my_time->minute * 100UL +
+                      my_time->second);
+}
+
+
+/*
+  Convert struct DRIZZLE_TIME (date and time split into year/month/day/hour/...
+  to a number in format YYYYMMDDHHMMSS (DATETIME),
+  YYYYMMDD (DATE)  or HHMMSS (TIME).
+
+  SYNOPSIS
+    TIME_to_uint64_t()
+
+  DESCRIPTION
+    The function is used when we need to convert value of time item
+    to a number if it's used in numeric context, i. e.:
+    SELECT NOW()+1, CURDATE()+0, CURTIMIE()+0;
+    SELECT ?+1;
+
+  NOTE
+    This function doesn't check that given DRIZZLE_TIME structure members are
+    in valid range. If they are not, return value won't reflect any
+    valid date either.
+*/
+
+uint64_t TIME_to_uint64_t(const DRIZZLE_TIME *my_time)
+{
+  switch (my_time->time_type) {
+  case DRIZZLE_TIMESTAMP_DATETIME:
+    return TIME_to_uint64_t_datetime(my_time);
+  case DRIZZLE_TIMESTAMP_DATE:
+    return TIME_to_uint64_t_date(my_time);
+  case DRIZZLE_TIMESTAMP_TIME:
+    return TIME_to_uint64_t_time(my_time);
+  case DRIZZLE_TIMESTAMP_NONE:
+  case DRIZZLE_TIMESTAMP_ERROR:
+    return 0ULL;
+  default:
+    assert(0);
+  }
+  return 0;
+}
+
+} /* namespace drizzled */

=== added file 'drizzled/drizzle_time.h'
--- drizzled/drizzle_time.h	1970-01-01 00:00:00 +0000
+++ drizzled/drizzle_time.h	2010-04-02 06:48:30 +0000
@@ -0,0 +1,194 @@
+/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2008 MySQL
+ *
+ *  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
+ */
+
+#ifndef DRIZZLED_DRIZZLE_TIME_H
+#define DRIZZLED_DRIZZLE_TIME_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
+
+namespace drizzled
+{
+
+extern uint64_t log_10_int[20];
+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
+
+/* two-digit years < this are 20..; >= this are 19.. */
+#define YY_PART_YEAR	   70
+
+/* Flags to str_to_datetime */
+#define TIME_FUZZY_DATE		1
+#define TIME_DATETIME_ONLY	2
+/* Must be same as MODE_NO_ZERO_IN_DATE */
+#define TIME_NO_ZERO_IN_DATE    (65536L*2*2*2*2*2*2*2)
+/* Must be same as MODE_NO_ZERO_DATE */
+#define TIME_NO_ZERO_DATE	(TIME_NO_ZERO_IN_DATE*2)
+#define TIME_INVALID_DATES	(TIME_NO_ZERO_DATE*2)
+
+#define DRIZZLE_TIME_WARN_TRUNCATED    1
+#define DRIZZLE_TIME_WARN_OUT_OF_RANGE 2
+
+/* Limits for the TIME data type */
+#define TIME_MAX_HOUR 838
+#define TIME_MAX_MINUTE 59
+#define TIME_MAX_SECOND 59
+#define TIME_MAX_VALUE (TIME_MAX_HOUR*10000 + TIME_MAX_MINUTE*100 + \
+                        TIME_MAX_SECOND)
+#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.
+
+  We assume that values in this structure are normalized, i.e. year <= 9999,
+  month <= 12, day <= 31, hour <= 23, hour <= 59, hour <= 59. Many functions
+  in server such as my_system_gmt_sec() or make_time() family of functions
+  rely on this (actually now usage of make_*() family relies on a bit weaker
+  restriction). Also functions that produce DRIZZLE_TIME as result ensure this.
+  There is one exception to this rule though if this structure holds time
+  value (time_type == DRIZZLE_TIMESTAMP_TIME) days and hour member can hold
+  bigger values.
+*/
+typedef struct st_drizzle_time
+{
+  unsigned int  year, month, day, hour, minute, second;
+  unsigned long second_part;
+  bool       neg;
+  enum enum_drizzle_timestamp_type time_type;
+} DRIZZLE_TIME;
+
+
+bool check_date(const DRIZZLE_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, DRIZZLE_TIME *l_time,
+                uint32_t flags, int *was_cut);
+int64_t number_to_datetime(int64_t nr, DRIZZLE_TIME *time_res,
+                            uint32_t flags, int *was_cut);
+uint64_t TIME_to_uint64_t_datetime(const DRIZZLE_TIME *);
+uint64_t TIME_to_uint64_t(const DRIZZLE_TIME *);
+
+
+bool str_to_time(const char *str,uint32_t length, DRIZZLE_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);
+uint32_t year_2000_handling(uint32_t year);
+
+void init_time(void);
+
+
+/*
+  Function to check sanity of a TIMESTAMP value
+
+  DESCRIPTION
+    Check if a given DRIZZLE_TIME value fits in TIMESTAMP range.
+    This function doesn't make precise check, but rather a rough
+    estimate.
+
+  RETURN VALUES
+    false   The value seems sane
+    true    The DRIZZLE_TIME value is definitely out of range
+*/
+
+static inline bool validate_timestamp_range(const DRIZZLE_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)))
+    return false;
+
+  return true;
+}
+
+time_t
+my_system_gmt_sec(const DRIZZLE_TIME *t, long *my_timezone,
+                  bool *in_dst_time_gap);
+
+void set_zero_time(DRIZZLE_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_date_to_str(const DRIZZLE_TIME *l_time, char *to);
+int my_datetime_to_str(const DRIZZLE_TIME *l_time, char *to);
+int my_TIME_to_str(const DRIZZLE_TIME *l_time, char *to);
+
+/*
+  Available interval types used in any statement.
+
+  'interval_type' must be sorted so that simple intervals comes first,
+  ie year, quarter, month, week, day, hour, etc. The order based on
+  interval size is also important and the intervals should be kept in a
+  large to smaller order. (get_interval_value() depends on this)
+
+  Note: If you change the order of elements in this enum you should fix
+  order of elements in 'interval_type_to_name' and 'interval_names'
+  arrays
+
+  See also interval_type_to_name, get_interval_value, interval_names
+*/
+
+enum interval_type
+{
+  INTERVAL_YEAR, INTERVAL_QUARTER, INTERVAL_MONTH, INTERVAL_WEEK, INTERVAL_DAY,
+  INTERVAL_HOUR, INTERVAL_MINUTE, INTERVAL_SECOND, INTERVAL_MICROSECOND,
+  INTERVAL_YEAR_MONTH, INTERVAL_DAY_HOUR, INTERVAL_DAY_MINUTE,
+  INTERVAL_DAY_SECOND, INTERVAL_HOUR_MINUTE, INTERVAL_HOUR_SECOND,
+  INTERVAL_MINUTE_SECOND, INTERVAL_DAY_MICROSECOND, INTERVAL_HOUR_MICROSECOND,
+  INTERVAL_MINUTE_MICROSECOND, INTERVAL_SECOND_MICROSECOND, INTERVAL_LAST
+};
+
+extern uint64_t my_getsystime(void);
+extern uint64_t my_micro_time(void);
+extern uint64_t my_micro_time_and_time(time_t *time_arg);
+
+} /* namespace drizzled */
+
+#endif /* DRIZZLED_DRIZZLE_TIME_H */

=== modified file 'drizzled/drizzled.cc'
--- drizzled/drizzled.cc	2010-03-26 21:36:11 +0000
+++ drizzled/drizzled.cc	2010-04-02 06:48:30 +0000
@@ -77,7 +77,7 @@
 
 #include <errno.h>
 #include <sys/stat.h>
-#include "drizzled/my_getopt.h"
+#include "drizzled/option.h"
 #ifdef HAVE_SYSENT_H
 #include <sysent.h>
 #endif
@@ -373,7 +373,7 @@
 extern "C" pthread_handler_t signal_hand(void *arg);
 static void drizzle_init_variables(void);
 static void get_options(int *argc,char **argv);
-int drizzled_get_one_option(int, const struct my_option *, char *);
+int drizzled_get_one_option(int, const struct option *, char *);
 static int init_thread_environment();
 static const char *get_relative_path(const char *path);
 static void fix_paths(string &progname);
@@ -1249,7 +1249,7 @@
   {
     int ho_error;
     char **tmp_argv= defaults_argv;
-    struct my_option no_opts[]=
+    struct option no_opts[]=
     {
       {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
     };
@@ -1401,7 +1401,7 @@
 };
 
 
-struct my_option my_long_options[] =
+struct option my_long_options[] =
 {
   {"help", '?', N_("Display this help and exit."),
    (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
@@ -1861,7 +1861,7 @@
 }
 
 
-int drizzled_get_one_option(int optid, const struct my_option *opt,
+int drizzled_get_one_option(int optid, const struct option *opt,
                              char *argument)
 {
   switch(optid) {

=== modified file 'drizzled/include.am'
--- drizzled/include.am	2010-03-31 22:35:54 +0000
+++ drizzled/include.am	2010-04-02 06:48:30 +0000
@@ -255,11 +255,11 @@
 			      drizzled/memory/sql_alloc.h \
 			      drizzled/memory/multi_malloc.h \
 			      drizzled/memory/root.h \
-			      drizzled/my_getopt.h \
+			      drizzled/option.h \
 			      drizzled/my_hash.h \
-			      drizzled/my_time.h \
-			      drizzled/my_tree.h \
-			      drizzled/my_var.h \
+			      drizzled/drizzle_time.h \
+			      drizzled/tree.h \
+			      drizzled/var.h \
 			      drizzled/name_resolution_context.h \
 			      drizzled/name_resolution_context_state.h \
 			      drizzled/named_savepoint.h \
@@ -634,8 +634,8 @@
 			   drizzled/lookup_symbol.cc \
 			   drizzled/my_getsystime.cc \
 			   drizzled/my_hash.cc \
-			   drizzled/my_time.cc \
-			   drizzled/my_tree.cc \
+			   drizzled/drizzle_time.cc \
+			   drizzled/tree.cc \
 			   drizzled/name_resolution_context_state.cc \
 			   drizzled/natural_join_column.cc \
 			   drizzled/optimizer/explain_plan.cc \
@@ -781,7 +781,7 @@
 
 drizzled_libdynamic_array_la_SOURCES = drizzled/dynamic_array.cc
 drizzled_liberror_la_SOURCES = drizzled/error.cc
-drizzled_libgetopt_la_SOURCES = drizzled/my_getopt.cc
+drizzled_libgetopt_la_SOURCES = drizzled/option.cc
 drizzled_libtypelib_la_SOURCES = drizzled/typelib.cc
 drizzled_libserialutil_la_SOURCES = drizzled/db.cc drizzled/table_proto_write.cc
 drizzled_libserialutil_la_CXXFLAGS= ${AM_CXXFLAGS} ${PROTOSKIP_WARNINGS}

=== modified file 'drizzled/item.h'
--- drizzled/item.h	2010-03-27 10:10:49 +0000
+++ drizzled/item.h	2010-04-02 06:48:30 +0000
@@ -21,7 +21,7 @@
 #define DRIZZLED_ITEM_H
 
 #include <drizzled/dtcollation.h>
-#include <drizzled/my_time.h>
+#include <drizzled/drizzle_time.h>
 #include <drizzled/decimal.h>
 #include <drizzled/sql_bitmap.h>
 #include <drizzled/sql_list.h>

=== modified file 'drizzled/item/sum.h'
--- drizzled/item/sum.h	2010-02-04 08:14:46 +0000
+++ drizzled/item/sum.h	2010-04-02 06:48:30 +0000
@@ -23,7 +23,7 @@
 /* classes for sum functions */
 
 
-#include "drizzled/my_tree.h"
+#include "drizzled/tree.h"
 #include <drizzled/hybrid_type.h>
 #include <drizzled/item.h>
 #include <drizzled/item/field.h>

=== removed file 'drizzled/my_getopt.cc'
--- drizzled/my_getopt.cc	2010-03-26 14:54:21 +0000
+++ drizzled/my_getopt.cc	1970-01-01 00:00:00 +0000
@@ -1,1289 +0,0 @@
-/* Copyright (C) 2002-2006 MySQL AB
-
-   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; version 2 of the License.
-
-   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-#include "config.h"
-#include "drizzled/internal/my_sys.h"
-#include <drizzled/gettext.h>
-
-#include "drizzled/internal/m_string.h"
-#include "drizzled/internal/my_sys.h"
-#include "drizzled/error.h"
-#include "drizzled/my_getopt.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <iostream>
-#include <algorithm>
-
-using namespace std;
-namespace drizzled
-{
-
-typedef void (*init_func_p)(const struct my_option *option, char **variable,
-    int64_t value);
-
-void default_reporter(enum loglevel level, const char *format, ...);
-my_error_reporter my_getopt_error_reporter= &default_reporter;
-
-static int findopt(char *optpat, uint32_t length,
-    const struct my_option **opt_res,
-    char **ffname);
-static int64_t getopt_ll(char *arg, const struct my_option *optp, int *err);
-static uint64_t getopt_ull(char *arg, const struct my_option *optp,
-    int *err);
-static size_t getopt_size(char *arg, const struct my_option *optp, int *err);
-static double getopt_double(char *arg, const struct my_option *optp, int *err);
-static void init_variables(const struct my_option *options,
-    init_func_p init_one_value);
-static void init_one_value(const struct my_option *option, char **variable,
-    int64_t value);
-static void fini_one_value(const struct my_option *option, char **variable,
-    int64_t value);
-static int setval(const struct my_option *opts, char* *value, char *argument,
-    bool set_maximum_value);
-static char *check_struct_option(char *cur_arg, char *key_name);
-
-/*
-   The following three variables belong to same group and the number and
-   order of their arguments must correspond to each other.
- */
-static const char *special_opt_prefix[]=
-{"skip", "disable", "enable", "maximum", "loose", 0};
-static const uint32_t special_opt_prefix_lengths[]=
-{ 4,      7,         6,        7,         5,      0};
-enum enum_special_opt
-{ OPT_SKIP, OPT_DISABLE, OPT_ENABLE, OPT_MAXIMUM, OPT_LOOSE};
-
-char *disabled_my_option= (char*) "0";
-
-/*
-   This is a flag that can be set in client programs. 1 means that
-   my_getopt will skip over options it does not know how to handle.
- */
-
-bool my_getopt_skip_unknown= 0;
-
-void default_reporter(enum loglevel level, const char *format, ...)
-{
-  va_list args;
-  va_start(args, format);
-  if (level == WARNING_LEVEL)
-    fprintf(stderr, "%s", _("Warning: "));
-  else if (level == INFORMATION_LEVEL)
-    fprintf(stderr, "%s", _("Info: "));
-  vfprintf(stderr, format, args);
-  va_end(args);
-  fputc('\n', stderr);
-  fflush(stderr);
-}
-
-/*
-function: handle_options
-
-Sort options; put options first, until special end of options (--), or
-until end of argv. Parse options; check that the given option matches with
-one of the options in struct 'my_option', return error in case of ambiguous
-or unknown option. Check that option was given an argument if it requires
-one. Call function 'get_one_option()' once for each option.
- */
-
-static getopt_get_addr_func getopt_get_addr;
-
-int handle_options(int *argc, char ***argv,
-    const struct my_option *longopts,
-    my_get_one_option get_one_option)
-{
-  uint32_t opt_found, argvpos= 0, length;
-  bool end_of_options= 0, must_be_var, set_maximum_value=false,
-       option_is_loose;
-  char **pos, **pos_end, *optend, *prev_found=NULL,
-       *opt_str, key_name[FN_REFLEN];
-  const struct my_option *optp;
-  char* *value;
-  int error, i;
-
-  /* handle_options() assumes arg0 (program name) always exists */
-  assert(argc && *argc >= 1);
-  assert(argv && *argv);
-  (*argc)--; /* Skip the program name */
-  (*argv)++; /*      --- || ----      */
-  init_variables(longopts, init_one_value);
-
-  for (pos= *argv, pos_end=pos+ *argc; pos != pos_end ; pos++)
-  {
-    char **first= pos;
-    char *cur_arg= *pos;
-    if (cur_arg[0] == '-' && cur_arg[1] && !end_of_options) /* must be opt */
-    {
-      char *argument=    0;
-      must_be_var=       0;
-      set_maximum_value= 0;
-      option_is_loose=   0;
-
-      cur_arg++;  /* skip '-' */
-      if (*cur_arg == '-' || *cur_arg == 'O') /* check for long option, */
-      {                                       /* --set-variable, or -O  */
-        if (*cur_arg == 'O')
-        {
-          must_be_var= 1;
-
-          if (!(*++cur_arg))	/* If not -Ovar=# */
-          {
-            /* the argument must be in next argv */
-            if (!*++pos)
-            {
-              my_getopt_error_reporter(ERROR_LEVEL,
-                  "%s: Option '-O' requires an argument",
-                  internal::my_progname);
-              return EXIT_ARGUMENT_REQUIRED;
-            }
-            cur_arg= *pos;
-            (*argc)--;
-          }
-        }
-        else if (!getopt_compare_strings(cur_arg, "-set-variable", 13))
-        {
-          must_be_var= 1;
-          if (cur_arg[13] == '=')
-          {
-            cur_arg+= 14;
-            if (!*cur_arg)
-            {
-              my_getopt_error_reporter(ERROR_LEVEL,
-                  "%s: Option '--set-variable' requires an argument",
-                  internal::my_progname);
-              return EXIT_ARGUMENT_REQUIRED;
-            }
-          }
-          else if (cur_arg[14]) /* garbage, or another option. break out */
-            must_be_var= 0;
-          else
-          {
-            /* the argument must be in next argv */
-            if (!*++pos)
-            {
-              my_getopt_error_reporter(ERROR_LEVEL,
-                  "%s: Option '--set-variable' requires an argument",
-                  internal::my_progname);
-              return EXIT_ARGUMENT_REQUIRED;
-            }
-            cur_arg= *pos;
-            (*argc)--;
-          }
-        }
-        else if (!must_be_var)
-        {
-          if (!*++cur_arg)	/* skip the double dash */
-          {
-            /* '--' means end of options, look no further */
-            end_of_options= 1;
-            (*argc)--;
-            continue;
-          }
-        }
-        opt_str= check_struct_option(cur_arg, key_name);
-        optend= strrchr(opt_str, '=');
-        if (optend != NULL)
-        {
-          length= (uint32_t) (optend - opt_str);
-          optend++;
-        }
-        else
-        {
-          length= static_cast<uint32_t>(strlen(opt_str));
-          optend= 0;
-        }
-
-        /*
-           Find first the right option. Return error in case of an ambiguous,
-           or unknown option
-         */
-        optp= longopts;
-        if (!(opt_found= findopt(opt_str, length, &optp, &prev_found)))
-        {
-          /*
-             Didn't find any matching option. Let's see if someone called
-             option with a special option prefix
-           */
-          if (!must_be_var)
-          {
-            if (optend)
-              must_be_var= 1; /* option is followed by an argument */
-            for (i= 0; special_opt_prefix[i]; i++)
-            {
-              if (!getopt_compare_strings(special_opt_prefix[i], opt_str,
-                    special_opt_prefix_lengths[i]) &&
-                  (opt_str[special_opt_prefix_lengths[i]] == '-' ||
-                   opt_str[special_opt_prefix_lengths[i]] == '_'))
-              {
-                /*
-                   We were called with a special prefix, we can reuse opt_found
-                 */
-                opt_str+= special_opt_prefix_lengths[i] + 1;
-                length-= special_opt_prefix_lengths[i] + 1;
-                if (i == OPT_LOOSE)
-                  option_is_loose= 1;
-                if ((opt_found= findopt(opt_str, length, &optp, &prev_found)))
-                {
-                  if (opt_found > 1)
-                  {
-                    my_getopt_error_reporter(ERROR_LEVEL,
-                        "%s: ambiguous option '--%s-%s' (--%s-%s)",
-                        internal::my_progname,
-                        special_opt_prefix[i],
-                        cur_arg, special_opt_prefix[i],
-                        prev_found);
-                    return EXIT_AMBIGUOUS_OPTION;
-                  }
-                  switch (i) {
-                    case OPT_SKIP:
-                    case OPT_DISABLE: /* fall through */
-                      /*
-                         double negation is actually enable again,
-                         for example: --skip-option=0 -> option = true
-                       */
-                      optend= (optend && *optend == '0' && !(*(optend + 1))) ?
-                        (char*) "1" : disabled_my_option;
-                      break;
-                    case OPT_ENABLE:
-                      optend= (optend && *optend == '0' && !(*(optend + 1))) ?
-                        disabled_my_option : (char*) "1";
-                      break;
-                    case OPT_MAXIMUM:
-                      set_maximum_value= true;
-                      must_be_var= true;
-                      break;
-                  }
-                  break; /* break from the inner loop, main loop continues */
-                }
-                i= -1; /* restart the loop */
-              }
-            }
-          }
-          if (!opt_found)
-          {
-            if (my_getopt_skip_unknown)
-            {
-              /*
-                 preserve all the components of this unknown option, this may
-                 occurr when the user provides options like: "-O foo" or
-                 "--set-variable foo" (note that theres a space in there)
-                 Generally, these kind of options are to be avoided
-               */
-              do {
-                (*argv)[argvpos++]= *first++;
-              } while (first <= pos);
-              continue;
-            }
-            if (must_be_var)
-            {
-              my_getopt_error_reporter(option_is_loose ?
-                  WARNING_LEVEL : ERROR_LEVEL,
-                  "%s: unknown variable '%s'",
-                  internal::my_progname, cur_arg);
-              if (!option_is_loose)
-                return EXIT_UNKNOWN_VARIABLE;
-            }
-            else
-            {
-              my_getopt_error_reporter(option_is_loose ?
-                  WARNING_LEVEL : ERROR_LEVEL,
-                  "%s: unknown option '--%s'",
-                  internal::my_progname, cur_arg);
-              if (!option_is_loose)
-                return EXIT_UNKNOWN_OPTION;
-            }
-            if (option_is_loose)
-            {
-              (*argc)--;
-              continue;
-            }
-          }
-        }
-        if (opt_found > 1)
-        {
-          if (must_be_var)
-          {
-            my_getopt_error_reporter(ERROR_LEVEL,
-                "%s: variable prefix '%s' is not unique",
-                internal::my_progname, opt_str);
-            return EXIT_VAR_PREFIX_NOT_UNIQUE;
-          }
-          else
-          {
-            my_getopt_error_reporter(ERROR_LEVEL,
-                "%s: ambiguous option '--%s' (%s, %s)",
-                internal::my_progname, opt_str, prev_found,
-                optp->name);
-            return EXIT_AMBIGUOUS_OPTION;
-          }
-        }
-        if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)
-        {
-          fprintf(stderr,
-              _("%s: %s: Option '%s' used, but is disabled\n"),
-              internal::my_progname,
-              option_is_loose ? _("WARNING") : _("ERROR"), opt_str);
-          if (option_is_loose)
-          {
-            (*argc)--;
-            continue;
-          }
-          return EXIT_OPTION_DISABLED;
-        }
-        if (must_be_var && (optp->var_type & GET_TYPE_MASK) == GET_NO_ARG)
-        {
-          my_getopt_error_reporter(ERROR_LEVEL,
-              "%s: option '%s' cannot take an argument",
-              internal::my_progname, optp->name);
-          return EXIT_NO_ARGUMENT_ALLOWED;
-        }
-        value= optp->var_type & GET_ASK_ADDR ?
-          (*getopt_get_addr)(key_name, (uint32_t) strlen(key_name), optp) : optp->value;
-
-        if (optp->arg_type == NO_ARG)
-        {
-          if (optend && (optp->var_type & GET_TYPE_MASK) != GET_BOOL)
-          {
-            my_getopt_error_reporter(ERROR_LEVEL,
-                "%s: option '--%s' cannot take an argument",
-                internal::my_progname, optp->name);
-            return EXIT_NO_ARGUMENT_ALLOWED;
-          }
-          if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL)
-          {
-            /*
-               Set bool to 1 if no argument or if the user has used
-               --enable-'option-name'.
-             *optend was set to '0' if one used --disable-option
-             */
-            (*argc)--;
-            if (!optend || *optend == '1' ||
-                !my_strcasecmp(&my_charset_utf8_general_ci, optend, "true"))
-              *((bool*) value)= (bool) 1;
-            else if (*optend == '0' ||
-                !my_strcasecmp(&my_charset_utf8_general_ci, optend, "false"))
-              *((bool*) value)= (bool) 0;
-            else
-            {
-              my_getopt_error_reporter(WARNING_LEVEL,
-                  "%s: ignoring option '--%s' due to "
-                  "invalid value '%s'",
-                  internal::my_progname,
-                  optp->name, optend);
-              continue;
-            }
-            error= get_one_option(optp->id, optp, *((bool*) value) ?
-                                  (char*) "1" : disabled_my_option);
-            if (error != 0)
-              return error;
-            else
-              continue;
-          }
-          argument= optend;
-        }
-        else if (optp->arg_type == OPT_ARG &&
-            (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
-        {
-          if (optend == disabled_my_option)
-            *((bool*) value)= (bool) 0;
-          else
-          {
-            if (!optend) /* No argument -> enable option */
-              *((bool*) value)= (bool) 1;
-            else
-              argument= optend;
-          }
-        }
-        else if (optp->arg_type == REQUIRED_ARG && !optend)
-        {
-          /* Check if there are more arguments after this one */
-          if (!*++pos)
-          {
-            my_getopt_error_reporter(ERROR_LEVEL,
-                "%s: option '--%s' requires an argument",
-                internal::my_progname, optp->name);
-            return EXIT_ARGUMENT_REQUIRED;
-          }
-          argument= *pos;
-          (*argc)--;
-        }
-        else
-          argument= optend;
-      }
-      else  /* must be short option */
-      {
-        for (optend= cur_arg; *optend; optend++)
-        {
-          opt_found= 0;
-          for (optp= longopts; optp->id; optp++)
-          {
-            if (optp->id == (int) (unsigned char) *optend)
-            {
-              /* Option recognized. Find next what to do with it */
-              opt_found= 1;
-              if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)
-              {
-                fprintf(stderr,
-                    _("%s: ERROR: Option '-%c' used, but is disabled\n"),
-                    internal::my_progname, optp->id);
-                return EXIT_OPTION_DISABLED;
-              }
-              if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL &&
-                  optp->arg_type == NO_ARG)
-              {
-                *((bool*) optp->value)= (bool) 1;
-                error= get_one_option(optp->id, optp, argument);
-                if (error != 0)
-                  return error;
-                else
-                  continue;
-
-              }
-              else if (optp->arg_type == REQUIRED_ARG ||
-                  optp->arg_type == OPT_ARG)
-              {
-                if (*(optend + 1))
-                {
-                  /* The rest of the option is option argument */
-                  argument= optend + 1;
-                  /* This is in effect a jump out of the outer loop */
-                  optend= (char*) " ";
-                }
-                else
-                {
-                  if (optp->arg_type == OPT_ARG)
-                  {
-                    if (optp->var_type == GET_BOOL)
-                      *((bool*) optp->value)= (bool) 1;
-                    error= get_one_option(optp->id, optp, argument);
-                    if (error != 0)
-                      return error;
-                    else
-                      continue;
-                  }
-                  /* Check if there are more arguments after this one */
-                  if (!pos[1])
-                  {
-                    my_getopt_error_reporter(ERROR_LEVEL,
-                        "%s: option '-%c' requires "
-                        "an argument",
-                        internal::my_progname, optp->id);
-                    return EXIT_ARGUMENT_REQUIRED;
-                  }
-                  argument= *++pos;
-                  (*argc)--;
-                  /* the other loop will break, because *optend + 1 == 0 */
-                }
-              }
-              if ((error= setval(optp, optp->value, argument,
-                      set_maximum_value)))
-              {
-                my_getopt_error_reporter(ERROR_LEVEL,
-                    "%s: Error while setting value '%s' "
-                    "to '%s'",
-                    internal::my_progname,
-                    argument, optp->name);
-                return error;
-              }
-              error= get_one_option(optp->id, optp, argument);
-              if (error != 0)
-                return error;
-              else
-                break;
-            }
-          }
-          if (!opt_found)
-          {
-            my_getopt_error_reporter(ERROR_LEVEL,
-                "%s: unknown option '-%c'",
-                internal::my_progname, *optend);
-            return EXIT_UNKNOWN_OPTION;
-          }
-        }
-        (*argc)--; /* option handled (short), decrease argument count */
-        continue;
-      }
-      if ((error= setval(optp, value, argument, set_maximum_value)))
-      {
-        my_getopt_error_reporter(ERROR_LEVEL,
-            "%s: Error while setting value '%s' to '%s'",
-            internal::my_progname, argument, optp->name);
-        return error;
-      }
-      error= get_one_option(optp->id, optp, argument);
-      if (error != 0)
-        return error;
-
-      (*argc)--; /* option handled (short or long), decrease argument count */
-    }
-    else /* non-option found */
-      (*argv)[argvpos++]= cur_arg;
-  }
-  /*
-     Destroy the first, already handled option, so that programs that look
-     for arguments in 'argv', without checking 'argc', know when to stop.
-     Items in argv, before the destroyed one, are all non-option -arguments
-     to the program, yet to be (possibly) handled.
-   */
-  (*argv)[argvpos]= 0;
-  return 0;
-}
-
-
-/*
-function: check_struct_option
-
-Arguments: Current argument under processing from argv and a variable
-where to store the possible key name.
-
-Return value: In case option is a struct option, returns a pointer to
-the current argument at the position where the struct option (key_name)
-ends, the next character after the dot. In case argument is not a struct
-option, returns a pointer to the argument.
-
-key_name will hold the name of the key, or 0 if not found.
- */
-
-static char *check_struct_option(char *cur_arg, char *key_name)
-{
-  char *ptr, *end;
-
-  ptr= strrchr(cur_arg + 1, '.'); /* Skip the first character */
-  end= strrchr(cur_arg, '=');
-
-  /*
-     If the first dot is after an equal sign, then it is part
-     of a variable value and the option is not a struct option.
-     Also, if the last character in the string before the ending
-     NULL, or the character right before equal sign is the first
-     dot found, the option is not a struct option.
-   */
-  if ((ptr != NULL) && (end != NULL) && (end - ptr > 1))
-  {
-    uint32_t len= (uint32_t) (ptr - cur_arg);
-    set_if_smaller(len, (uint32_t)FN_REFLEN-1);
-    strncpy(key_name, cur_arg, len);
-    return ++ptr;
-  }
-  key_name[0]= 0;
-  return cur_arg;
-}
-
-/*
-function: setval
-
-Arguments: opts, argument
-Will set the option value to given value
- */
-
-static int setval(const struct my_option *opts, char **value, char *argument,
-    bool set_maximum_value)
-{
-  int err= 0;
-
-  if (value && argument)
-  {
-    char* *result_pos= ((set_maximum_value) ?
-        opts->u_max_value : value);
-
-    if (!result_pos)
-      return EXIT_NO_PTR_TO_VARIABLE;
-
-    switch ((opts->var_type & GET_TYPE_MASK)) {
-      case GET_BOOL: /* If argument differs from 0, enable option, else disable */
-        *((bool*) result_pos)= (bool) atoi(argument) != 0;
-        break;
-      case GET_INT:
-        *((int32_t*) result_pos)= (int) getopt_ll(argument, opts, &err);
-        break;
-      case GET_UINT:
-      case GET_UINT32:
-        *((uint32_t*) result_pos)= (uint32_t) getopt_ull(argument, opts, &err);
-        break;
-      case GET_ULONG_IS_FAIL:
-        *((ulong*) result_pos)= (ulong) getopt_ull(argument, opts, &err);
-        break;
-      case GET_LONG:
-        *((long*) result_pos)= (long) getopt_ll(argument, opts, &err);
-        break;
-      case GET_LL:
-        *((int64_t*) result_pos)= getopt_ll(argument, opts, &err);
-        break;
-      case GET_ULL:
-      case GET_UINT64:
-        *((uint64_t*) result_pos)= getopt_ull(argument, opts, &err);
-        break;
-      case GET_SIZE:
-        *((size_t*) result_pos)= getopt_size(argument, opts, &err);
-        break;
-      case GET_DOUBLE:
-        *((double*) result_pos)= getopt_double(argument, opts, &err);
-        break;
-      case GET_STR:
-        *((char**) result_pos)= argument;
-        break;
-      case GET_STR_ALLOC:
-        if ((*((char**) result_pos)))
-          free((*(char**) result_pos));
-        if (!(*((char**) result_pos)= strdup(argument)))
-          return EXIT_OUT_OF_MEMORY;
-        break;
-      case GET_ENUM:
-        if (((*(int*)result_pos)= find_type(argument, opts->typelib, 2) - 1) < 0)
-          return EXIT_ARGUMENT_INVALID;
-        break;
-      case GET_SET:
-        *((uint64_t*)result_pos)= find_typeset(argument, opts->typelib, &err);
-        if (err)
-          return EXIT_ARGUMENT_INVALID;
-        break;
-      default:    /* dummy default to avoid compiler warnings */
-        break;
-    }
-    if (err)
-      return EXIT_UNKNOWN_SUFFIX;
-  }
-  return 0;
-}
-
-
-/*
-   Find option
-
-   SYNOPSIS
-   findopt()
-   optpat	Prefix of option to find (with - or _)
-   length	Length of optpat
-   opt_res	Options
-   ffname	Place for pointer to first found name
-
-   IMPLEMENTATION
-   Go through all options in the my_option struct. Return number
-   of options found that match the pattern and in the argument
-   list the option found, if any. In case of ambiguous option, store
-   the name in ffname argument
-
-   RETURN
-   0    No matching options
-#   Number of matching options
-ffname points to first matching option
- */
-
-static int findopt(char *optpat, uint32_t length,
-    const struct my_option **opt_res,
-    char **ffname)
-{
-  uint32_t count;
-  struct my_option *opt= (struct my_option *) *opt_res;
-
-  for (count= 0; opt->name; opt++)
-  {
-    if (!getopt_compare_strings(opt->name, optpat, length)) /* match found */
-    {
-      (*opt_res)= opt;
-      if (!opt->name[length])		/* Exact match */
-        return 1;
-      if (!count)
-      {
-        count= 1;
-        *ffname= (char *) opt->name;	/* We only need to know one prev */
-      }
-      else if (strcmp(*ffname, opt->name))
-      {
-        /*
-           The above test is to not count same option twice
-           (see mysql.cc, option "help")
-         */
-        count++;
-      }
-    }
-  }
-  return count;
-}
-
-
-/*
-function: compare_strings
-
-Works like strncmp, other than 1.) considers '-' and '_' the same.
-2.) Returns -1 if strings differ, 0 if they are equal
- */
-
-bool getopt_compare_strings(register const char *s, register const char *t,
-    uint32_t length)
-{
-  char const *end= s + length;
-  for (;s != end ; s++, t++)
-  {
-    if ((*s != '-' ? *s : '_') != (*t != '-' ? *t : '_'))
-      return 1;
-  }
-  return 0;
-}
-
-/*
-function: eval_num_suffix
-
-Transforms a number with a suffix to real number. Suffix can
-be k|K for kilo, m|M for mega or g|G for giga.
- */
-
-static int64_t eval_num_suffix(char *argument, int *error, char *option_name)
-{
-  char *endchar;
-  int64_t num;
-
-  *error= 0;
-  errno= 0;
-  num= strtoll(argument, &endchar, 10);
-  if (errno == ERANGE)
-  {
-    my_getopt_error_reporter(ERROR_LEVEL,
-        "Incorrect integer value: '%s'", argument);
-    *error= 1;
-    return 0;
-  }
-  if (*endchar == 'k' || *endchar == 'K')
-    num*= 1024L;
-  else if (*endchar == 'm' || *endchar == 'M')
-    num*= 1024L * 1024L;
-  else if (*endchar == 'g' || *endchar == 'G')
-    num*= 1024L * 1024L * 1024L;
-  else if (*endchar)
-  {
-    fprintf(stderr,
-        _("Unknown suffix '%c' used for variable '%s' (value '%s')\n"),
-        *endchar, option_name, argument);
-    *error= 1;
-    return 0;
-  }
-  return num;
-}
-
-/*
-function: getopt_ll
-
-Evaluates and returns the value that user gave as an argument
-to a variable. Recognizes (case insensitive) K as KILO, M as MEGA
-and G as GIGA bytes. Some values must be in certain blocks, as
-defined in the given my_option struct, this function will check
-that those values are honored.
-In case of an error, set error value in *err.
- */
-
-static int64_t getopt_ll(char *arg, const struct my_option *optp, int *err)
-{
-  int64_t num=eval_num_suffix(arg, err, (char*) optp->name);
-  return getopt_ll_limit_value(num, optp, NULL);
-}
-
-/*
-function: getopt_ll_limit_value
-
-Applies min/max/block_size to a numeric value of an option.
-Returns "fixed" value.
- */
-
-int64_t getopt_ll_limit_value(int64_t num, const struct my_option *optp,
-    bool *fix)
-{
-  int64_t old= num;
-  bool adjusted= false;
-  char buf1[255], buf2[255];
-  uint64_t block_size= (optp->block_size ? (uint64_t) optp->block_size : 1L);
-
-  if (num > 0 && ((uint64_t) num > (uint64_t) optp->max_value) &&
-      optp->max_value) /* if max value is not set -> no upper limit */
-  {
-    num= (uint64_t) optp->max_value;
-    adjusted= true;
-  }
-
-  switch ((optp->var_type & GET_TYPE_MASK)) {
-    case GET_INT:
-      if (num > (int64_t) INT_MAX)
-      {
-        num= ((int64_t) INT_MAX);
-        adjusted= true;
-      }
-      break;
-    case GET_LONG:
-      if (num > (int64_t) INT32_MAX)
-      {
-        num= ((int64_t) INT32_MAX);
-        adjusted= true;
-      }
-      break;
-    default:
-      assert((optp->var_type & GET_TYPE_MASK) == GET_LL);
-      break;
-  }
-
-  num= ((num - optp->sub_size) / block_size);
-  num= (int64_t) (num * block_size);
-
-  if (num < optp->min_value)
-  {
-    num= optp->min_value;
-    adjusted= true;
-  }
-
-  if (fix)
-    *fix= adjusted;
-  else if (adjusted)
-    my_getopt_error_reporter(WARNING_LEVEL,
-        "option '%s': signed value %s adjusted to %s",
-        optp->name, internal::llstr(old, buf1), internal::llstr(num, buf2));
-  return num;
-}
-
-/*
-function: getopt_ull
-
-This is the same as getopt_ll, but is meant for uint64_t
-values.
- */
-
-static uint64_t getopt_ull(char *arg, const struct my_option *optp, int *err)
-{
-  uint64_t num= eval_num_suffix(arg, err, (char*) optp->name);
-  return getopt_ull_limit_value(num, optp, NULL);
-}
-
-
-static size_t getopt_size(char *arg, const struct my_option *optp, int *err)
-{
-  return (size_t)getopt_ull(arg, optp, err);
-}
-
-
-
-uint64_t getopt_ull_limit_value(uint64_t num, const struct my_option *optp,
-    bool *fix)
-{
-  bool adjusted= false;
-  uint64_t old= num;
-  char buf1[255], buf2[255];
-
-  if ((uint64_t) num > (uint64_t) optp->max_value &&
-      optp->max_value) /* if max value is not set -> no upper limit */
-  {
-    num= (uint64_t) optp->max_value;
-    adjusted= true;
-  }
-
-  switch ((optp->var_type & GET_TYPE_MASK)) {
-    case GET_UINT:
-      if (num > (uint64_t) UINT_MAX)
-      {
-        num= ((uint64_t) UINT_MAX);
-        adjusted= true;
-      }
-      break;
-    case GET_UINT32:
-    case GET_ULONG_IS_FAIL:
-      if (num > (uint64_t) UINT32_MAX)
-      {
-        num= ((uint64_t) UINT32_MAX);
-        adjusted= true;
-      }
-      break;
-    case GET_SIZE:
-      if (num > (uint64_t) SIZE_MAX)
-      {
-        num= ((uint64_t) SIZE_MAX);
-        adjusted= true;
-      }
-      break;
-    default:
-      assert(((optp->var_type & GET_TYPE_MASK) == GET_ULL)
-          || ((optp->var_type & GET_TYPE_MASK) == GET_UINT64));
-      break;
-  }
-
-  if (optp->block_size > 1)
-  {
-    num/= (uint64_t) optp->block_size;
-    num*= (uint64_t) optp->block_size;
-  }
-
-  if (num < (uint64_t) optp->min_value)
-  {
-    num= (uint64_t) optp->min_value;
-    adjusted= true;
-  }
-
-  if (fix)
-    *fix= adjusted;
-  else if (adjusted)
-    my_getopt_error_reporter(WARNING_LEVEL,
-        "option '%s': unsigned value %s adjusted to %s",
-        optp->name, internal::ullstr(old, buf1), internal::ullstr(num, buf2));
-
-  return num;
-}
-
-
-/*
-   Get double value withing ranges
-
-   Evaluates and returns the value that user gave as an argument to a variable.
-
-   RETURN
-   decimal value of arg
-
-   In case of an error, prints an error message and sets *err to
-   EXIT_ARGUMENT_INVALID.  Otherwise err is not touched
- */
-
-static double getopt_double(char *arg, const struct my_option *optp, int *err)
-{
-  double num;
-  int error;
-  char *end= arg + 1000;                     /* Big enough as *arg is \0 terminated */
-  num= internal::my_strtod(arg, &end, &error);
-  if (end[0] != 0 || error)
-  {
-    fprintf(stderr,
-        _("%s: ERROR: Invalid decimal value for option '%s'\n"),
-        internal::my_progname, optp->name);
-    *err= EXIT_ARGUMENT_INVALID;
-    return 0.0;
-  }
-  if (optp->max_value && num > (double) optp->max_value)
-    num= (double) optp->max_value;
-  return max(num, (double) optp->min_value);
-}
-
-/*
-   Init one value to it's default values
-
-   SYNOPSIS
-   init_one_value()
-   option		Option to initialize
-   value		Pointer to variable
- */
-
-static void init_one_value(const struct my_option *option, char** variable,
-    int64_t value)
-{
-  switch ((option->var_type & GET_TYPE_MASK)) {
-    case GET_BOOL:
-      *((bool*) variable)= (bool) value;
-      break;
-    case GET_INT:
-      *((int*) variable)= (int) value;
-      break;
-    case GET_UINT:
-    case GET_ENUM:
-      *((uint*) variable)= (uint32_t) value;
-      break;
-    case GET_LONG:
-      *((long*) variable)= (long) value;
-      break;
-    case GET_UINT32:
-      *((uint32_t*) variable)= (uint32_t) value;
-      break;
-    case GET_ULONG_IS_FAIL:
-      *((ulong*) variable)= (ulong) value;
-      break;
-    case GET_LL:
-      *((int64_t*) variable)= (int64_t) value;
-      break;
-    case GET_SIZE:
-      *((size_t*) variable)= (size_t) value;
-      break;
-    case GET_ULL:
-    case GET_SET:
-    case GET_UINT64:
-      *((uint64_t*) variable)=  (uint64_t) value;
-      break;
-    case GET_DOUBLE:
-      *((double*) variable)=  (double) value;
-      break;
-    case GET_STR:
-      /*
-         Do not clear variable value if it has no default value.
-         The default value may already be set.
-NOTE: To avoid compiler warnings, we first cast int64_t to intptr_t,
-so that the value has the same size as a pointer.
-       */
-      if ((char*) (intptr_t) value)
-        *((char**) variable)= (char*) (intptr_t) value;
-      break;
-    case GET_STR_ALLOC:
-      /*
-         Do not clear variable value if it has no default value.
-         The default value may already be set.
-NOTE: To avoid compiler warnings, we first cast int64_t to intptr_t,
-so that the value has the same size as a pointer.
-       */
-      if ((char*) (intptr_t) value)
-      {
-        free((*(char**) variable));
-        char *tmpptr= strdup((char *) (intptr_t) value);
-        if (tmpptr != NULL)
-          *((char**) variable)= tmpptr;
-      }
-      break;
-    default: /* dummy default to avoid compiler warnings */
-      break;
-  }
-  return;
-}
-
-
-/*
-   Init one value to it's default values
-
-   SYNOPSIS
-   init_one_value()
-   option		Option to initialize
-   value		Pointer to variable
- */
-
-static void fini_one_value(const struct my_option *option, char **variable,
-    int64_t)
-{
-  switch ((option->var_type & GET_TYPE_MASK)) {
-    case GET_STR_ALLOC:
-      free((*(char**) variable));
-      *((char**) variable)= NULL;
-      break;
-    default: /* dummy default to avoid compiler warnings */
-      break;
-  }
-  return;
-}
-
-
-void my_cleanup_options(const struct my_option *options)
-{
-  init_variables(options, fini_one_value);
-}
-
-
-/*
-   initialize all variables to their default values
-
-   SYNOPSIS
-   init_variables()
-   options		Array of options
-
-   NOTES
-   We will initialize the value that is pointed to by options->value.
-   If the value is of type GET_ASK_ADDR, we will also ask for the address
-   for a value and initialize.
- */
-
-static void init_variables(const struct my_option *options,
-    init_func_p init_one_value)
-{
-  for (; options->name; options++)
-  {
-    char* *variable;
-    /*
-       We must set u_max_value first as for some variables
-       options->u_max_value == options->value and in this case we want to
-       set the value to default value.
-     */
-    if (options->u_max_value)
-      init_one_value(options, options->u_max_value, options->max_value);
-    if (options->value)
-      init_one_value(options, options->value, options->def_value);
-    if (options->var_type & GET_ASK_ADDR &&
-        (variable= (*getopt_get_addr)("", 0, options)))
-      init_one_value(options, variable, options->def_value);
-  }
-  return;
-}
-
-
-/*
-function: my_print_options
-
-Print help for all options and variables.
- */
-
-void my_print_help(const struct my_option *options)
-{
-  uint32_t col, name_space= 22, comment_space= 57;
-  const char *line_end;
-  const struct my_option *optp;
-
-  for (optp= options; optp->id; optp++)
-  {
-    if (optp->id < 256)
-    {
-      printf("  -%c%s", optp->id, strlen(optp->name) ? ", " : "  ");
-      col= 6;
-    }
-    else
-    {
-      printf("  ");
-      col= 2;
-    }
-    if (strlen(optp->name))
-    {
-      printf("--%s", optp->name);
-      col+= 2 + (uint32_t) strlen(optp->name);
-      if ((optp->var_type & GET_TYPE_MASK) == GET_STR ||
-          (optp->var_type & GET_TYPE_MASK) == GET_STR_ALLOC)
-      {
-        printf("%s=name%s ", optp->arg_type == OPT_ARG ? "[" : "",
-            optp->arg_type == OPT_ARG ? "]" : "");
-        col+= (optp->arg_type == OPT_ARG) ? 8 : 6;
-      }
-      else if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||
-          (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
-      {
-        putchar(' ');
-        col++;
-      }
-      else
-      {
-        printf("%s=#%s ", optp->arg_type == OPT_ARG ? "[" : "",
-            optp->arg_type == OPT_ARG ? "]" : "");
-        col+= (optp->arg_type == OPT_ARG) ? 5 : 3;
-      }
-      if (col > name_space && optp->comment && *optp->comment)
-      {
-        putchar('\n');
-        col= 0;
-      }
-    }
-    for (; col < name_space; col++)
-      putchar(' ');
-    if (optp->comment && *optp->comment)
-    {
-      const char *comment= _(optp->comment), *end= strchr(comment, '\0');
-
-      while ((uint32_t) (end - comment) > comment_space)
-      {
-        for (line_end= comment + comment_space; *line_end != ' '; line_end--)
-        {}
-        for (; comment != line_end; comment++)
-          putchar(*comment);
-        comment++; /* skip the space, as a newline will take it's place now */
-        putchar('\n');
-        for (col= 0; col < name_space; col++)
-          putchar(' ');
-      }
-      printf("%s", comment);
-    }
-    putchar('\n');
-    if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||
-        (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
-    {
-      if (optp->def_value != 0)
-      {
-        printf(_("%*s(Defaults to on; use --skip-%s to disable.)\n"), name_space, "", optp->name);
-      }
-    }
-  }
-}
-
-
-/*
-function: my_print_options
-
-Print variables.
- */
-
-void my_print_variables(const struct my_option *options)
-{
-  uint32_t name_space= 34, length, nr;
-  uint64_t bit, llvalue;
-  char buff[255];
-  const struct my_option *optp;
-
-  printf(_("\nVariables (--variable-name=value)\n"
-        "and boolean options {false|true}  Value (after reading options)\n"
-        "--------------------------------- -----------------------------\n"));
-  for (optp= options; optp->id; optp++)
-  {
-    char* *value= (optp->var_type & GET_ASK_ADDR ?
-        (*getopt_get_addr)("", 0, optp) : optp->value);
-    if (value)
-    {
-      printf("%s ", optp->name);
-      length= (uint32_t) strlen(optp->name)+1;
-      for (; length < name_space; length++)
-        putchar(' ');
-      switch ((optp->var_type & GET_TYPE_MASK)) {
-        case GET_SET:
-          if (!(llvalue= *(uint64_t*) value))
-            printf("%s\n", _("(No default value)"));
-          else
-            for (nr= 0, bit= 1; llvalue && nr < optp->typelib->count; nr++, bit<<=1)
-            {
-              if (!(bit & llvalue))
-                continue;
-              llvalue&= ~bit;
-              printf( llvalue ? "%s," : "%s\n", get_type(optp->typelib, nr));
-            }
-          break;
-        case GET_ENUM:
-          printf("%s\n", get_type(optp->typelib, *(uint*) value));
-          break;
-        case GET_STR:
-        case GET_STR_ALLOC:                    /* fall through */
-          printf("%s\n", *((char**) value) ? *((char**) value) :
-              _("(No default value)"));
-          break;
-        case GET_BOOL:
-          printf("%s\n", *((bool*) value) ? _("true") : _("false"));
-          break;
-        case GET_INT:
-          printf("%d\n", *((int*) value));
-          break;
-        case GET_UINT:
-          printf("%d\n", *((uint*) value));
-          break;
-        case GET_LONG:
-          printf("%ld\n", *((long*) value));
-          break;
-        case GET_UINT32:
-          printf("%u\n", *((uint32_t*) value));
-          break;
-        case GET_ULONG_IS_FAIL:
-          printf("%lu\n", *((ulong*) value));
-          break;
-        case GET_SIZE:
-          internal::int64_t2str((uint64_t)(*(size_t*)value), buff, 10);
-          printf("%s\n", buff);
-          break;
-        case GET_LL:
-          printf("%s\n", internal::llstr(*((int64_t*) value), buff));
-          break;
-        case GET_ULL:
-        case GET_UINT64:
-          internal::int64_t2str(*((uint64_t*) value), buff, 10);
-          printf("%s\n", buff);
-          break;
-        case GET_DOUBLE:
-          printf("%g\n", *(double*) value);
-          break;
-        default:
-          printf(_("(Disabled)\n"));
-          break;
-      }
-    }
-  }
-}
-
-} /* namespace drizzled */

=== removed file 'drizzled/my_getopt.h'
--- drizzled/my_getopt.h	2010-03-25 09:08:56 +0000
+++ drizzled/my_getopt.h	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-/* Copyright (C) 2002-2004 MySQL AB
-
-   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; version 2 of the License.
-
-   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-#ifndef DRIZZLED_MY_GETOPT_H
-#define DRIZZLED_MY_GETOPT_H
-
-#include "drizzled/typelib.h"
-
-namespace drizzled
-{
-
-#define GET_NO_ARG     1
-#define GET_BOOL       2
-#define GET_INT        3
-#define GET_UINT       4
-#define GET_LONG       5
-#define GET_UINT32     6
-#define GET_LL         7
-#define GET_ULL        8
-#define GET_STR        9
-#define GET_STR_ALLOC 10
-#define GET_DISABLED  11
-#define GET_ENUM      12
-#define GET_SET       13
-#define GET_DOUBLE    14
-#define GET_SIZE      15
-#define GET_UINT64    16
-#define GET_ULONG_IS_FAIL 17
-
-#define GET_ASK_ADDR	 128
-#define GET_TYPE_MASK	 127
-
-enum loglevel {
-   ERROR_LEVEL,
-   WARNING_LEVEL,
-   INFORMATION_LEVEL
-};
-
-enum get_opt_arg_type { NO_ARG, OPT_ARG, REQUIRED_ARG };
-
-struct st_typelib;
-
-struct my_option
-{
-  const char *name;                     /* Name of the option */
-  int        id;                        /* unique id or short option */
-  const char *comment;                  /* option comment, for autom. --help */
-  char      **value;                   /* The variable value */
-  char      **u_max_value;             /* The user def. max variable value */
-  struct st_typelib *typelib;           /* Pointer to possible values */
-  uint32_t     var_type;
-  enum get_opt_arg_type arg_type;
-  int64_t   def_value;                 /* Default value */
-  int64_t   min_value;                 /* Min allowed value */
-  int64_t   max_value;                 /* Max allowed value */
-  int64_t   sub_size;                  /* Subtract this from given value */
-  long       block_size;                /* Value should be a mult. of this */
-  void       *app_type;                 /* To be used by an application */
-};
-
-
-typedef int (* my_get_one_option) (int, const struct my_option *, char * );
-typedef void (* my_error_reporter) (enum loglevel level, const char *format, ... );
-typedef char ** (*getopt_get_addr_func)(const char *, uint32_t, const struct my_option *);
-
-extern char *disabled_my_option;
-extern bool my_getopt_skip_unknown;
-extern my_error_reporter my_getopt_error_reporter;
-
-extern int handle_options (int *argc, char ***argv,
-			   const struct my_option *longopts, my_get_one_option);
-extern void my_cleanup_options(const struct my_option *options);
-extern void my_print_help(const struct my_option *options);
-extern void my_print_variables(const struct my_option *options);
-
-uint64_t getopt_ull_limit_value(uint64_t num, const struct my_option *optp,
-                                 bool *fix);
-int64_t getopt_ll_limit_value(int64_t, const struct my_option *,
-                               bool *fix);
-bool getopt_compare_strings(const char *s, const char *t, uint32_t length);
-
-} /* namespace drizzled */
-
-#endif /* DRIZZLED_MY_GETOPT_H */
-

=== modified file 'drizzled/my_getsystime.cc'
--- drizzled/my_getsystime.cc	2010-02-04 08:14:46 +0000
+++ drizzled/my_getsystime.cc	2010-04-02 06:48:30 +0000
@@ -23,7 +23,7 @@
 */
 
 #include "config.h"
-#include "drizzled/my_time.h"
+#include "drizzled/drizzle_time.h"
 
 #if TIME_WITH_SYS_TIME
 # include <sys/time.h>

=== removed file 'drizzled/my_time.cc'
--- drizzled/my_time.cc	2010-02-04 08:14:46 +0000
+++ drizzled/my_time.cc	1970-01-01 00:00:00 +0000
@@ -1,1260 +0,0 @@
-/* Copyright (C) 2004-2006 MySQL AB
-
- 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; version 2 of the License.
-
- 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-#include "config.h"
-
-#include "drizzled/my_time.h"
-
-#include "drizzled/internal/m_string.h"
-#include "drizzled/charset_info.h"
-#include <drizzled/util/test.h>
-#include "drizzled/definitions.h"
-
-#include <cstdio>
-#include <algorithm>
-
-using namespace std;
-
-namespace drizzled
-{
-
-static int check_time_range(DRIZZLE_TIME *my_time, int *warning);
-
-/* Windows version of localtime_r() is declared in my_ptrhead.h */
-
-uint64_t log_10_int[20]=
-{
-  1, 10, 100, 1000, 10000UL, 100000UL, 1000000UL, 10000000UL,
-  100000000ULL, 1000000000ULL, 10000000000ULL, 100000000000ULL,
-  1000000000000ULL, 10000000000000ULL, 100000000000000ULL,
-  1000000000000000ULL, 10000000000000000ULL, 100000000000000000ULL,
-  1000000000000000000ULL, 10000000000000000000ULL
-};
-
-
-/* Position for YYYY-DD-MM HH-MM-DD.FFFFFF AM in default format */
-
-static unsigned char internal_format_positions[]=
-{0, 1, 2, 3, 4, 5, 6, (unsigned char) 255};
-
-static char time_separator=':';
-
-static uint32_t const days_at_timestart=719528;	/* daynr at 1970.01.01 */
-unsigned char days_in_month[]= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
-
-/*
-  Offset of system time zone from UTC in seconds used to speed up
-  work of my_system_gmt_sec() function.
-*/
-static long my_time_zone=0;
-
-
-/* Calc days in one year. works with 0 <= year <= 99 */
-
-uint32_t calc_days_in_year(uint32_t year)
-{
-  return ((year & 3) == 0 && (year%100 || (year%400 == 0 && year)) ?
-          366 : 365);
-}
-
-/**
-  @brief Check datetime value for validity according to flags.
-
-  @param[in]  ltime          Date to check.
-  @param[in]  not_zero_date  ltime is not the zero date
-  @param[in]  flags          flags to check
-                             (see str_to_datetime() flags in my_time.h)
-  @param[out] was_cut        set to 2 if value was invalid according to flags.
-                             (Feb 29 in non-leap etc.)  This remains unchanged
-                             if value is not invalid.
-
-  @details Here we assume that year and month is ok!
-    If month is 0 we allow any date. (This only happens if we allow zero
-    date parts in str_to_datetime())
-    Disallow dates with zero year and non-zero month and/or day.
-
-  @return
-    0  OK
-    1  error
-*/
-
-bool check_date(const DRIZZLE_TIME *ltime, bool not_zero_date,
-                   uint32_t flags, int *was_cut)
-{
-  if (not_zero_date)
-  {
-    if ((((flags & TIME_NO_ZERO_IN_DATE) || !(flags & TIME_FUZZY_DATE)) &&
-         (ltime->month == 0 || ltime->day == 0)) ||
-        (!(flags & TIME_INVALID_DATES) &&
-         ltime->month && ltime->day > days_in_month[ltime->month-1] &&
-         (ltime->month != 2 || calc_days_in_year(ltime->year) != 366 ||
-          ltime->day != 29)))
-    {
-      *was_cut= 2;
-      return true;
-    }
-  }
-  else if (flags & TIME_NO_ZERO_DATE)
-  {
-    /*
-      We don't set *was_cut here to signal that the problem was a zero date
-      and not an invalid date
-    */
-    return true;
-  }
-  return false;
-}
-
-
-/*
-  Convert a timestamp string to a DRIZZLE_TIME value.
-
-  SYNOPSIS
-    str_to_datetime()
-    str                 String to parse
-    length              Length of string
-    l_time              Date is stored here
-    flags               Bitmap of following items
-                        TIME_FUZZY_DATE    Set if we should allow partial dates
-                        TIME_DATETIME_ONLY Set if we only allow full datetimes.
-                        TIME_NO_ZERO_IN_DATE	Don't allow partial dates
-                        TIME_NO_ZERO_DATE	Don't allow 0000-00-00 date
-                        TIME_INVALID_DATES	Allow 2000-02-31
-    was_cut             0	Value OK
-			1       If value was cut during conversion
-			2	check_date(date,flags) considers date invalid
-
-  DESCRIPTION
-    At least the following formats are recogniced (based on number of digits)
-    YYMMDD, YYYYMMDD, YYMMDDHHMMSS, YYYYMMDDHHMMSS
-    YY-MM-DD, YYYY-MM-DD, YY-MM-DD HH.MM.SS
-    YYYYMMDDTHHMMSS  where T is a the character T (ISO8601)
-    Also dates where all parts are zero are allowed
-
-    The second part may have an optional .###### fraction part.
-
-  NOTES
-   This function should work with a format position vector as long as the
-   following things holds:
-   - All date are kept together and all time parts are kept together
-   - Date and time parts must be separated by blank
-   - Second fractions must come after second part and be separated
-     by a '.'.  (The second fractions are optional)
-   - AM/PM must come after second fractions (or after seconds if no fractions)
-   - Year must always been specified.
-   - If time is before date, then we will use datetime format only if
-     the argument consist of two parts, separated by space.
-     Otherwise we will assume the argument is a date.
-   - The hour part must be specified in hour-minute-second order.
-
-  RETURN VALUES
-    DRIZZLE_TIMESTAMP_NONE        String wasn't a timestamp, like
-                                [DD [HH:[MM:[SS]]]].fraction.
-                                l_time is not changed.
-    DRIZZLE_TIMESTAMP_DATE        DATE string (YY MM and DD parts ok)
-    DRIZZLE_TIMESTAMP_DATETIME    Full timestamp
-    DRIZZLE_TIMESTAMP_ERROR       Timestamp with wrong values.
-                                All elements in l_time is set to 0
-*/
-
-#define MAX_DATE_PARTS 8
-
-enum enum_drizzle_timestamp_type
-str_to_datetime(const char *str, uint32_t length, DRIZZLE_TIME *l_time,
-                uint32_t flags, int *was_cut)
-{
-  uint32_t field_length, year_length=4, digits, i, number_of_fields;
-  uint32_t date[MAX_DATE_PARTS], date_len[MAX_DATE_PARTS];
-  uint32_t add_hours= 0, start_loop;
-  uint32_t not_zero_date, allow_space;
-  bool is_internal_format;
-  const char *pos, *last_field_pos=NULL;
-  const char *end=str+length;
-  const unsigned char *format_position;
-  bool found_delimitier= 0, found_space= 0;
-  uint32_t frac_pos, frac_len;
-
-  *was_cut= 0;
-
-  /* Skip space at start */
-  for (; str != end && my_isspace(&my_charset_utf8_general_ci, *str) ; str++)
-    ;
-  if (str == end || ! my_isdigit(&my_charset_utf8_general_ci, *str))
-  {
-    *was_cut= 1;
-    return(DRIZZLE_TIMESTAMP_NONE);
-  }
-
-  is_internal_format= 0;
-  /* This has to be changed if want to activate different timestamp formats */
-  format_position= internal_format_positions;
-
-  /*
-    Calculate number of digits in first part.
-    If length= 8 or >= 14 then year is of format YYYY.
-    (YYYY-MM-DD,  YYYYMMDD, YYYYYMMDDHHMMSS)
-  */
-  for (pos=str;
-       pos != end && (my_isdigit(&my_charset_utf8_general_ci,*pos) || *pos == 'T');
-       pos++)
-    ;
-
-  digits= (uint32_t) (pos-str);
-  start_loop= 0;                                /* Start of scan loop */
-  date_len[format_position[0]]= 0;              /* Length of year field */
-  if (pos == end || *pos == '.')
-  {
-    /* Found date in internal format (only numbers like YYYYMMDD) */
-    year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
-    field_length= year_length;
-    is_internal_format= 1;
-    format_position= internal_format_positions;
-  }
-  else
-  {
-    if (format_position[0] >= 3)                /* If year is after HHMMDD */
-    {
-      /*
-        If year is not in first part then we have to determinate if we got
-        a date field or a datetime field.
-        We do this by checking if there is two numbers separated by
-        space in the input.
-      */
-      while (pos < end && !my_isspace(&my_charset_utf8_general_ci, *pos))
-        pos++;
-      while (pos < end && !my_isdigit(&my_charset_utf8_general_ci, *pos))
-        pos++;
-      if (pos == end)
-      {
-        if (flags & TIME_DATETIME_ONLY)
-        {
-          *was_cut= 1;
-          return(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;
-        start_loop= 5;                         /* Start with first date part */
-      }
-    }
-
-    field_length= format_position[0] == 0 ? 4 : 2;
-  }
-
-  /*
-    Only allow space in the first "part" of the datetime field and:
-    - after days, part seconds
-    - before and after AM/PM (handled by code later)
-
-    2003-03-03 20:00:20 AM
-    20:00:20.000000 AM 03-03-2000
-  */
-  i= max((uint32_t) format_position[0], (uint32_t) format_position[1]);
-  set_if_bigger(i, (uint32_t) format_position[2]);
-  allow_space= ((1 << i) | (1 << format_position[6]));
-  allow_space&= (1 | 2 | 4 | 8);
-
-  not_zero_date= 0;
-  for (i = start_loop;
-       i < MAX_DATE_PARTS-1 && str != end &&
-         my_isdigit(&my_charset_utf8_general_ci,*str);
-       i++)
-  {
-    const char *start= str;
-    uint32_t tmp_value= (uint32_t) (unsigned char) (*str++ - '0');
-    while (str != end && my_isdigit(&my_charset_utf8_general_ci,str[0]) &&
-           (!is_internal_format || --field_length))
-    {
-      tmp_value=tmp_value*10 + (uint32_t) (unsigned char) (*str - '0');
-      str++;
-    }
-    date_len[i]= (uint32_t) (str - start);
-    if (tmp_value > 999999)                     /* Impossible date part */
-    {
-      *was_cut= 1;
-      return(DRIZZLE_TIMESTAMP_NONE);
-    }
-    date[i]=tmp_value;
-    not_zero_date|= tmp_value;
-
-    /* Length of next field */
-    field_length= format_position[i+1] == 0 ? 4 : 2;
-
-    if ((last_field_pos= str) == end)
-    {
-      i++;                                      /* Register last found part */
-      break;
-    }
-    /* Allow a 'T' after day to allow CCYYMMDDT type of fields */
-    if (i == format_position[2] && *str == 'T')
-    {
-      str++;                                    /* ISO8601:  CCYYMMDDThhmmss */
-      continue;
-    }
-    if (i == format_position[5])                /* Seconds */
-    {
-      if (*str == '.')                          /* Followed by part seconds */
-      {
-        str++;
-        field_length= 6;                        /* 6 digits */
-      }
-      continue;
-    }
-    while (str != end &&
-           (my_ispunct(&my_charset_utf8_general_ci,*str) ||
-            my_isspace(&my_charset_utf8_general_ci,*str)))
-    {
-      if (my_isspace(&my_charset_utf8_general_ci,*str))
-      {
-        if (!(allow_space & (1 << i)))
-        {
-          *was_cut= 1;
-          return(DRIZZLE_TIMESTAMP_NONE);
-        }
-        found_space= 1;
-      }
-      str++;
-      found_delimitier= 1;                      /* Should be a 'normal' date */
-    }
-    /* Check if next position is AM/PM */
-    if (i == format_position[6])                /* Seconds, time for AM/PM */
-    {
-      i++;                                      /* Skip AM/PM part */
-      if (format_position[7] != 255)            /* If using AM/PM */
-      {
-        if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
-        {
-          if (str[0] == 'p' || str[0] == 'P')
-            add_hours= 12;
-          else if (str[0] != 'a' || str[0] != 'A')
-            continue;                           /* Not AM/PM */
-          str+= 2;                              /* Skip AM/PM */
-          /* Skip space after AM/PM */
-          while (str != end && my_isspace(&my_charset_utf8_general_ci,*str))
-            str++;
-        }
-      }
-    }
-    last_field_pos= str;
-  }
-  if (found_delimitier && !found_space && (flags & TIME_DATETIME_ONLY))
-  {
-    *was_cut= 1;
-    return(DRIZZLE_TIMESTAMP_NONE);          /* Can't be a datetime */
-  }
-
-  str= last_field_pos;
-
-  number_of_fields= i - start_loop;
-  while (i < MAX_DATE_PARTS)
-  {
-    date_len[i]= 0;
-    date[i++]= 0;
-  }
-
-  if (!is_internal_format)
-  {
-    year_length= date_len[(uint32_t) format_position[0]];
-    if (!year_length)                           /* Year must be specified */
-    {
-      *was_cut= 1;
-      return(DRIZZLE_TIMESTAMP_NONE);
-    }
-
-    l_time->year=               date[(uint32_t) format_position[0]];
-    l_time->month=              date[(uint32_t) format_position[1]];
-    l_time->day=                date[(uint32_t) format_position[2]];
-    l_time->hour=               date[(uint32_t) format_position[3]];
-    l_time->minute=             date[(uint32_t) format_position[4]];
-    l_time->second=             date[(uint32_t) format_position[5]];
-
-    frac_pos= (uint32_t) format_position[6];
-    frac_len= date_len[frac_pos];
-    if (frac_len < 6)
-      date[frac_pos]*= (uint32_t) log_10_int[6 - frac_len];
-    l_time->second_part= date[frac_pos];
-
-    if (format_position[7] != (unsigned char) 255)
-    {
-      if (l_time->hour > 12)
-      {
-        *was_cut= 1;
-        goto err;
-      }
-      l_time->hour= l_time->hour%12 + add_hours;
-    }
-  }
-  else
-  {
-    l_time->year=       date[0];
-    l_time->month=      date[1];
-    l_time->day=        date[2];
-    l_time->hour=       date[3];
-    l_time->minute=     date[4];
-    l_time->second=     date[5];
-    if (date_len[6] < 6)
-      date[6]*= (uint32_t) log_10_int[6 - date_len[6]];
-    l_time->second_part=date[6];
-  }
-  l_time->neg= 0;
-
-  if (year_length == 2 && not_zero_date)
-    l_time->year+= (l_time->year < YY_PART_YEAR ? 2000 : 1900);
-
-  if (number_of_fields < 3 ||
-      l_time->year > 9999 || l_time->month > 12 ||
-      l_time->day > 31 || l_time->hour > 23 ||
-      l_time->minute > 59 || l_time->second > 59)
-  {
-    /* Only give warning for a zero date if there is some garbage after */
-    if (!not_zero_date)                         /* If zero date */
-    {
-      for (; str != end ; str++)
-      {
-        if (!my_isspace(&my_charset_utf8_general_ci, *str))
-        {
-          not_zero_date= 1;                     /* Give warning */
-          break;
-        }
-      }
-    }
-    *was_cut= test(not_zero_date);
-    goto err;
-  }
-
-  if (check_date(l_time, not_zero_date != 0, flags, was_cut))
-    goto err;
-
-  l_time->time_type= (number_of_fields <= 3 ?
-                      DRIZZLE_TIMESTAMP_DATE : DRIZZLE_TIMESTAMP_DATETIME);
-
-  for (; str != end ; str++)
-  {
-    if (!my_isspace(&my_charset_utf8_general_ci,*str))
-    {
-      *was_cut= 1;
-      break;
-    }
-  }
-
-  return(l_time->time_type=
-              (number_of_fields <= 3 ? DRIZZLE_TIMESTAMP_DATE :
-                                       DRIZZLE_TIMESTAMP_DATETIME));
-
-err:
-  memset(l_time, 0, sizeof(*l_time));
-  return(DRIZZLE_TIMESTAMP_ERROR);
-}
-
-
-/*
- Convert a time string to a DRIZZLE_TIME struct.
-
-  SYNOPSIS
-   str_to_time()
-   str                  A string in full TIMESTAMP format or
-                        [-] DAYS [H]H:MM:SS, [H]H:MM:SS, [M]M:SS, [H]HMMSS,
-                        [M]MSS or [S]S
-                        There may be an optional [.second_part] after seconds
-   length               Length of str
-   l_time               Store result here
-   warning              Set DRIZZLE_TIME_WARN_TRUNCATED flag if the input string
-                        was cut during conversion, and/or
-                        DRIZZLE_TIME_WARN_OUT_OF_RANGE flag, if the value is
-                        out of range.
-
-   NOTES
-     Because of the extra days argument, this function can only
-     work with times where the time arguments are in the above order.
-
-   RETURN
-     0  ok
-     1  error
-*/
-
-bool str_to_time(const char *str, uint32_t length, DRIZZLE_TIME *l_time,
-                    int *warning)
-{
-  uint32_t date[5];
-  uint64_t value;
-  const char *end=str+length, *end_of_days;
-  bool found_days,found_hours;
-  uint32_t state;
-
-  l_time->neg=0;
-  *warning= 0;
-  for (; str != end && my_isspace(&my_charset_utf8_general_ci,*str) ; str++)
-    length--;
-  if (str != end && *str == '-')
-  {
-    l_time->neg=1;
-    str++;
-    length--;
-  }
-  if (str == end)
-    return 1;
-
-  /* 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)
-    {
-      if (was_cut)
-        *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
-      return res == DRIZZLE_TIMESTAMP_ERROR;
-    }
-  }
-
-  /* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */
-  for (value=0; str != end && my_isdigit(&my_charset_utf8_general_ci,*str) ; str++)
-    value=value*10L + (long) (*str - '0');
-
-  /* Skip all space after 'days' */
-  end_of_days= str;
-  for (; str != end && my_isspace(&my_charset_utf8_general_ci, str[0]) ; str++)
-    ;
-
-  found_days=found_hours=0;
-  if ((uint32_t) (end-str) > 1 && str != end_of_days &&
-      my_isdigit(&my_charset_utf8_general_ci, *str))
-  {                                             /* Found days part */
-    date[0]= (uint32_t) value;
-    state= 1;                                   /* Assume next is hours */
-    found_days= 1;
-  }
-  else if ((end-str) > 1 &&  *str == time_separator &&
-           my_isdigit(&my_charset_utf8_general_ci, str[1]))
-  {
-    date[0]= 0;                                 /* Assume we found hours */
-    date[1]= (uint32_t) value;
-    state=2;
-    found_hours=1;
-    str++;                                      /* skip ':' */
-  }
-  else
-  {
-    /* String given as one number; assume HHMMSS format */
-    date[0]= 0;
-    date[1]= (uint32_t) (value/10000);
-    date[2]= (uint32_t) (value/100 % 100);
-    date[3]= (uint32_t) (value % 100);
-    state=4;
-    goto fractional;
-  }
-
-  /* Read hours, minutes and seconds */
-  for (;;)
-  {
-    for (value=0; str != end && my_isdigit(&my_charset_utf8_general_ci,*str) ; str++)
-      value=value*10L + (long) (*str - '0');
-    date[state++]= (uint32_t) value;
-    if (state == 4 || (end-str) < 2 || *str != time_separator ||
-        !my_isdigit(&my_charset_utf8_general_ci,str[1]))
-      break;
-    str++;                                      /* Skip time_separator (':') */
-  }
-
-  if (state != 4)
-  {                                             /* Not HH:MM:SS */
-    /* Fix the date to assume that seconds was given */
-    if (!found_hours && !found_days)
-    {
-      internal::bmove_upp((unsigned char*) (date+4), (unsigned char*) (date+state),
-                sizeof(long)*(state-1));
-      memset(date, 0, sizeof(long)*(4-state));
-    }
-    else
-      memset(date+state, 0, sizeof(long)*(4-state));
-  }
-
-fractional:
-  /* Get fractional second part */
-  if ((end-str) >= 2 && *str == '.' && my_isdigit(&my_charset_utf8_general_ci,str[1]))
-  {
-    int field_length= 5;
-    str++; value=(uint32_t) (unsigned char) (*str - '0');
-    while (++str != end && my_isdigit(&my_charset_utf8_general_ci, *str))
-    {
-      if (field_length-- > 0)
-        value= value*10 + (uint32_t) (unsigned char) (*str - '0');
-    }
-    if (field_length > 0)
-      value*= (long) log_10_int[field_length];
-    else if (field_length < 0)
-      *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
-    date[4]= (uint32_t) value;
-  }
-  else
-    date[4]=0;
-
-  /* Check for exponent part: E<gigit> | E<sign><digit> */
-  /* (may occur as result of %g formatting of time value) */
-  if ((end - str) > 1 &&
-      (*str == 'e' || *str == 'E') &&
-      (my_isdigit(&my_charset_utf8_general_ci, str[1]) ||
-       ((str[1] == '-' || str[1] == '+') &&
-        (end - str) > 2 &&
-        my_isdigit(&my_charset_utf8_general_ci, str[2]))))
-    return 1;
-
-  if (internal_format_positions[7] != 255)
-  {
-    /* Read a possible AM/PM */
-    while (str != end && my_isspace(&my_charset_utf8_general_ci, *str))
-      str++;
-    if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
-    {
-      if (str[0] == 'p' || str[0] == 'P')
-      {
-        str+= 2;
-        date[1]= date[1]%12 + 12;
-      }
-      else if (str[0] == 'a' || str[0] == 'A')
-        str+=2;
-    }
-  }
-
-  /* Integer overflow checks */
-  if (date[0] > UINT_MAX || date[1] > UINT_MAX ||
-      date[2] > UINT_MAX || date[3] > UINT_MAX ||
-      date[4] > UINT_MAX)
-    return 1;
-
-  l_time->year=         0;                      /* For protocol::store_time */
-  l_time->month=        0;
-  l_time->day=          date[0];
-  l_time->hour=         date[1];
-  l_time->minute=       date[2];
-  l_time->second=       date[3];
-  l_time->second_part=  date[4];
-  l_time->time_type= DRIZZLE_TIMESTAMP_TIME;
-
-  /* Check if the value is valid and fits into DRIZZLE_TIME range */
-  if (check_time_range(l_time, warning))
-    return 1;
-
-  /* Check if there is garbage at end of the DRIZZLE_TIME specification */
-  if (str != end)
-  {
-    do
-    {
-      if (!my_isspace(&my_charset_utf8_general_ci,*str))
-      {
-        *warning|= DRIZZLE_TIME_WARN_TRUNCATED;
-        break;
-      }
-    } while (++str != end);
-  }
-  return 0;
-}
-
-
-/*
-  Check 'time' value to lie in the DRIZZLE_TIME range
-
-  SYNOPSIS:
-    check_time_range()
-    time     pointer to DRIZZLE_TIME value
-    warning  set DRIZZLE_TIME_WARN_OUT_OF_RANGE flag if the value is out of range
-
-  DESCRIPTION
-  If the time value lies outside of the range [-838:59:59, 838:59:59],
-  set it to the closest endpoint of the range and set
-  DRIZZLE_TIME_WARN_OUT_OF_RANGE flag in the 'warning' variable.
-
-  RETURN
-    0        time value is valid, but was possibly truncated
-    1        time value is invalid
-*/
-
-static int check_time_range(DRIZZLE_TIME *my_time, int *warning)
-{
-  int64_t hour;
-
-  if (my_time->minute >= 60 || my_time->second >= 60)
-    return 1;
-
-  hour= my_time->hour + (24*my_time->day);
-  if (hour <= TIME_MAX_HOUR &&
-      (hour != TIME_MAX_HOUR || my_time->minute != TIME_MAX_MINUTE ||
-       my_time->second != TIME_MAX_SECOND || !my_time->second_part))
-    return 0;
-
-  my_time->day= 0;
-  my_time->hour= TIME_MAX_HOUR;
-  my_time->minute= TIME_MAX_MINUTE;
-  my_time->second= TIME_MAX_SECOND;
-  my_time->second_part= 0;
-  *warning|= DRIZZLE_TIME_WARN_OUT_OF_RANGE;
-  return 0;
-}
-
-
-/*
-  Prepare offset of system time zone from UTC for my_system_gmt_sec() func.
-
-  SYNOPSIS
-    init_time()
-*/
-void init_time(void)
-{
-  time_t seconds;
-  struct tm *l_time,tm_tmp;
-  DRIZZLE_TIME my_time;
-  bool not_used;
-
-  seconds= (time_t) time((time_t*) 0);
-  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;
-  my_time.month=	(uint32_t) l_time->tm_mon+1;
-  my_time.day=		(uint32_t) l_time->tm_mday;
-  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.second_part=  0;
-  my_time.neg=          false;
-  my_system_gmt_sec(&my_time, &my_time_zone, &not_used); /* Init my_time_zone */
-}
-
-
-/*
-  Handle 2 digit year conversions
-
-  SYNOPSIS
-  year_2000_handling()
-  year     2 digit year
-
-  RETURN
-    Year between 1970-2069
-*/
-
-uint32_t year_2000_handling(uint32_t year)
-{
-  if ((year=year+1900) < 1900+YY_PART_YEAR)
-    year+=100;
-  return year;
-}
-
-
-/*
-  Calculate nr of day since year 0 in new date-system (from 1615)
-
-  SYNOPSIS
-    calc_daynr()
-    year		 Year (exact 4 digit year, no year conversions)
-    month		 Month
-    day			 Day
-
-  NOTES: 0000-00-00 is a valid date, and will return 0
-
-  RETURN
-    Days since 0000-00-00
-*/
-
-long calc_daynr(uint32_t year,uint32_t month,uint32_t day)
-{
-  long delsum;
-  int temp;
-
-  if (year == 0 && month == 0 && day == 0)
-    return(0);				/* Skip errors */
-  delsum= (long) (365L * year+ 31*(month-1) +day);
-  if (month <= 2)
-      year--;
-  else
-    delsum-= (long) (month*4+23)/10;
-  temp=(int) ((year/100+1)*3)/4;
-  return(delsum+(int) year/4-temp);
-} /* calc_daynr */
-
-
-/*
-  Convert time in DRIZZLE_TIME representation in system time zone to its
-  time_t form (number of seconds in UTC since begginning of Unix Epoch).
-
-  SYNOPSIS
-    my_system_gmt_sec()
-      t               - time value to be converted
-      my_timezone     - pointer to long where offset of system time zone
-                        from UTC will be stored for caching
-      in_dst_time_gap - set to true if time falls into spring time-gap
-
-  NOTES
-    The idea is to cache the time zone offset from UTC (including daylight
-    saving time) for the next call to make things faster. But currently we
-    just calculate this offset during startup (by calling init_time()
-    function) and use it all the time.
-    Time value provided should be legal time value (e.g. '2003-01-01 25:00:00'
-    is not allowed).
-
-  RETURN VALUE
-    Time in UTC seconds since Unix Epoch representation.
-*/
-time_t
-my_system_gmt_sec(const DRIZZLE_TIME *t_src, long *my_timezone,
-                  bool *in_dst_time_gap)
-{
-  uint32_t loop;
-  time_t tmp= 0;
-  int shift= 0;
-  DRIZZLE_TIME tmp_time;
-  DRIZZLE_TIME *t= &tmp_time;
-  struct tm *l_time,tm_tmp;
-  long diff, current_timezone;
-
-  /*
-    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(DRIZZLE_TIME));
-
-  if (!validate_timestamp_range(t))
-    return 0;
-
-  /*
-    Calculate the gmt time based on current time and timezone
-    The -1 on the end is to ensure that if have a date that exists twice
-    (like 2002-10-27 02:00:0 MET), we will find the initial date.
-
-    By doing -3600 we will have to call localtime_r() several times, but
-    I couldn't come up with a better way to get a repeatable result :(
-
-    We can't use mktime() as it's buggy on many platforms and not thread safe.
-
-    Note: this code assumes that our time_t estimation is not too far away
-    from real value (we assume that localtime_r(tmp) will return something
-    within 24 hrs from t) which is probably true for all current time zones.
-
-    Note2: For the dates, which have time_t representation close to
-    MAX_INT32 (efficient time_t limit for supported platforms), we should
-    do a small trick to avoid overflow. That is, convert the date, which is
-    two days earlier, and then add these days to the final value.
-
-    The same trick is done for the values close to 0 in time_t
-    representation for platfroms with unsigned time_t (QNX).
-
-    To be more verbose, here is a sample (extracted from the code below):
-    (calc_daynr(2038, 1, 19) - (long) days_at_timestart)*86400L + 4*3600L
-    would return -2147480896 because of the long type overflow. In result
-    we would get 1901 year in localtime_r(), which is an obvious error.
-
-    Alike problem raises with the dates close to Epoch. E.g.
-    (calc_daynr(1969, 12, 31) - (long) days_at_timestart)*86400L + 23*3600L
-    will give -3600.
-
-    On some platforms, (E.g. on QNX) time_t is unsigned and localtime(-3600)
-    wil give us a date around 2106 year. Which is no good.
-
-    Theoreticaly, there could be problems with the latter conversion:
-    there are at least two timezones, which had time switches near 1 Jan
-    of 1970 (because of political reasons). These are America/Hermosillo and
-    America/Mazatlan time zones. They changed their offset on
-    1970-01-01 08:00:00 UTC from UTC-8 to UTC-7. For these zones
-    the code below will give incorrect results for dates close to
-    1970-01-01, in the case OS takes into account these historical switches.
-    Luckily, it seems that we support only one platform with unsigned
-    time_t. It's QNX. And QNX does not support historical timezone data at all.
-    E.g. there are no /usr/share/zoneinfo/ files or any other mean to supply
-    historical information for localtime_r() etc. That is, the problem is not
-    relevant to QNX.
-
-    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
-      1970, 1 of Jan. For both dates we use shift, which is added
-      to t->day in order to step out a bit from the border.
-      This is required for platforms, where time_t is unsigned.
-      As far as I know, among the platforms we support it's only QNX.
-      Note: the order of below if-statements is significant.
-    */
-
-    if ((t->year == TIMESTAMP_MIN_YEAR + 1) && (t->month == 1)
-        && (t->day <= 10))
-    {
-      t->day+= 2;
-      shift= -2;
-    }
-
-    if ((t->year == TIMESTAMP_MIN_YEAR) && (t->month == 12)
-        && (t->day == 31))
-    {
-      t->year++;
-      t->month= 1;
-      t->day= 2;
-      shift= -2;
-    }
-  }
-#endif
-
-  tmp= (time_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);
-
-  current_timezone= my_time_zone;
-  localtime_r(&tmp,&tm_tmp);
-  l_time=&tm_tmp;
-  for (loop=0;
-       loop < 2 &&
-	 (t->hour != (uint32_t) l_time->tm_hour ||
-	  t->minute != (uint32_t) l_time->tm_min ||
-          t->second != (uint32_t) l_time->tm_sec);
-       loop++)
-  {					/* One check should be enough ? */
-    /* Get difference in days */
-    int days= t->day - l_time->tm_mday;
-    if (days < -1)
-      days= 1;					/* Month has wrapped */
-    else if (days > 1)
-      days= -1;
-    diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour)) +
-          (long) (60*((int) t->minute - (int) l_time->tm_min)) +
-          (long) ((int) t->second - (int) l_time->tm_sec));
-    current_timezone+= diff+3600;		/* Compensate for -3600 above */
-    tmp+= (time_t) diff;
-    localtime_r(&tmp,&tm_tmp);
-    l_time=&tm_tmp;
-  }
-  /*
-    Fix that if we are in the non existing daylight saving time hour
-    we move the start of the next real hour.
-
-    This code doesn't handle such exotical thing as time-gaps whose length
-    is more than one hour or non-integer (latter can theoretically happen
-    if one of seconds will be removed due leap correction, or because of
-    general time correction like it happened for Africa/Monrovia time zone
-    in year 1972).
-  */
-  if (loop == 2 && t->hour != (uint32_t) l_time->tm_hour)
-  {
-    int days= t->day - l_time->tm_mday;
-    if (days < -1)
-      days=1;					/* Month has wrapped */
-    else if (days > 1)
-      days= -1;
-    diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour))+
-	  (long) (60*((int) t->minute - (int) l_time->tm_min)) +
-          (long) ((int) t->second - (int) l_time->tm_sec));
-    if (diff == 3600)
-      tmp+=3600 - t->minute*60 - t->second;	/* Move to next hour */
-    else if (diff == -3600)
-      tmp-=t->minute*60 + t->second;		/* Move to previous hour */
-
-    *in_dst_time_gap= true;
-  }
-  *my_timezone= current_timezone;
-
-
-  /* shift back, if we were dealing with boundary dates */
-  tmp+= shift*86400L;
-
-  /*
-    This is possible for dates, which slightly exceed boundaries.
-    Conversion will pass ok for them, but we don't allow them.
-    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.
-  */
-  if ((tmp < TIMESTAMP_MIN_VALUE) || (tmp > TIMESTAMP_MAX_VALUE))
-    tmp= 0;
-
-  return (time_t) tmp;
-} /* my_system_gmt_sec */
-
-
-/* Set DRIZZLE_TIME structure to 0000-00-00 00:00:00.000000 */
-
-void set_zero_time(DRIZZLE_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.
-  This functions don't check that given DRIZZLE_TIME structure members are
-  in valid range. If they are not, return value won't reflect any
-  valid date either. Additionally, make_time doesn't take into
-  account time->day member: it's assumed that days have been converted
-  to hours already.
-
-  RETURN
-    number of characters written to 'to'
-*/
-
-static int my_time_to_str(const DRIZZLE_TIME *l_time, char *to)
-{
-  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);
-}
-
-int my_date_to_str(const DRIZZLE_TIME *l_time, char *to)
-{
-  return sprintf(to, "%04u-%02u-%02u",
-                         l_time->year,
-                         l_time->month,
-                         l_time->day);
-}
-
-int my_datetime_to_str(const DRIZZLE_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 DRIZZLE_TIME *l_time, char *to)
-{
-  switch (l_time->time_type) {
-  case DRIZZLE_TIMESTAMP_DATETIME:
-    return my_datetime_to_str(l_time, to);
-  case DRIZZLE_TIMESTAMP_DATE:
-    return my_date_to_str(l_time, to);
-  case DRIZZLE_TIMESTAMP_TIME:
-    return my_time_to_str(l_time, to);
-  case DRIZZLE_TIMESTAMP_NONE:
-  case DRIZZLE_TIMESTAMP_ERROR:
-    to[0]='\0';
-    return 0;
-  default:
-    assert(0);
-    return 0;
-  }
-}
-
-
-/*
-  Convert datetime value specified as number to broken-down TIME
-  representation and form value of DATETIME type as side-effect.
-
-  SYNOPSIS
-    number_to_datetime()
-      nr         - datetime value as number
-      time_res   - pointer for structure for broken-down representation
-      flags      - flags to use in validating date, as in str_to_datetime()
-      was_cut    0      Value ok
-                 1      If value was cut during conversion
-                 2      check_date(date,flags) considers date invalid
-
-  DESCRIPTION
-    Convert a datetime value of formats YYMMDD, YYYYMMDD, YYMMDDHHMSS,
-    YYYYMMDDHHMMSS to broken-down DRIZZLE_TIME representation. Return value in
-    YYYYMMDDHHMMSS format as side-effect.
-
-    This function also checks if datetime value fits in DATETIME range.
-
-  RETURN VALUE
-    -1              Timestamp with wrong values
-    anything else   DATETIME as integer in YYYYMMDDHHMMSS format
-    Datetime value in YYYYMMDDHHMMSS format.
-*/
-
-int64_t number_to_datetime(int64_t nr, DRIZZLE_TIME *time_res,
-                            uint32_t flags, int *was_cut)
-{
-  long part1,part2;
-
-  *was_cut= 0;
-  memset(time_res, 0, sizeof(*time_res));
-  time_res->time_type=DRIZZLE_TIMESTAMP_DATE;
-
-  if (nr == 0LL || nr >= 10000101000000LL)
-  {
-    time_res->time_type=DRIZZLE_TIMESTAMP_DATETIME;
-    goto ok;
-  }
-  if (nr < 101)
-    goto err;
-  if (nr <= (YY_PART_YEAR-1)*10000L+1231L)
-  {
-    nr= (nr+20000000L)*1000000L;                 /* YYMMDD, year: 2000-2069 */
-    goto ok;
-  }
-  if (nr < (YY_PART_YEAR)*10000L+101L)
-    goto err;
-  if (nr <= 991231L)
-  {
-    nr= (nr+19000000L)*1000000L;                 /* YYMMDD, year: 1970-1999 */
-    goto ok;
-  }
-  if (nr < 10000101L)
-    goto err;
-  if (nr <= 99991231L)
-  {
-    nr= nr*1000000L;
-    goto ok;
-  }
-  if (nr < 101000000L)
-    goto err;
-
-  time_res->time_type=DRIZZLE_TIMESTAMP_DATETIME;
-
-  if (nr <= (YY_PART_YEAR-1) * 10000000000LL + 1231235959LL)
-  {
-    nr= nr + 20000000000000LL;                   /* YYMMDDHHMMSS, 2000-2069 */
-    goto ok;
-  }
-  if (nr <  YY_PART_YEAR * 10000000000LL + 101000000LL)
-    goto err;
-  if (nr <= 991231235959LL)
-    nr= nr + 19000000000000LL;		/* YYMMDDHHMMSS, 1970-1999 */
-
- ok:
-  part1=(long) (nr / 1000000LL);
-  part2=(long) (nr - (int64_t) part1 * 1000000LL);
-  time_res->year=  (int) (part1/10000L);  part1%=10000L;
-  time_res->month= (int) part1 / 100;
-  time_res->day=   (int) part1 % 100;
-  time_res->hour=  (int) (part2/10000L);  part2%=10000L;
-  time_res->minute=(int) part2 / 100;
-  time_res->second=(int) part2 % 100;
-
-  if (time_res->year <= 9999 && time_res->month <= 12 &&
-      time_res->day <= 31 && time_res->hour <= 23 &&
-      time_res->minute <= 59 && time_res->second <= 59 &&
-      !check_date(time_res, (nr != 0), flags, was_cut))
-    return nr;
-
-  /* Don't want to have was_cut get set if NO_ZERO_DATE was violated. */
-  if (!nr && (flags & TIME_NO_ZERO_DATE))
-    return -1LL;
-
- err:
-  *was_cut= 1;
-  return -1LL;
-}
-
-
-/* Convert time value to integer in YYYYMMDDHHMMSS format */
-
-uint64_t TIME_to_uint64_t_datetime(const DRIZZLE_TIME *my_time)
-{
-  return ((uint64_t) (my_time->year * 10000UL +
-                       my_time->month * 100UL +
-                       my_time->day) * 1000000ULL +
-          (uint64_t) (my_time->hour * 10000UL +
-                       my_time->minute * 100UL +
-                       my_time->second));
-}
-
-
-/* Convert DRIZZLE_TIME value to integer in YYYYMMDD format */
-
-static uint64_t TIME_to_uint64_t_date(const DRIZZLE_TIME *my_time)
-{
-  return (uint64_t) (my_time->year * 10000UL + my_time->month * 100UL +
-                      my_time->day);
-}
-
-
-/*
-  Convert DRIZZLE_TIME value to integer in HHMMSS format.
-  This function doesn't take into account time->day member:
-  it's assumed that days have been converted to hours already.
-*/
-
-static uint64_t TIME_to_uint64_t_time(const DRIZZLE_TIME *my_time)
-{
-  return (uint64_t) (my_time->hour * 10000UL +
-                      my_time->minute * 100UL +
-                      my_time->second);
-}
-
-
-/*
-  Convert struct DRIZZLE_TIME (date and time split into year/month/day/hour/...
-  to a number in format YYYYMMDDHHMMSS (DATETIME),
-  YYYYMMDD (DATE)  or HHMMSS (TIME).
-
-  SYNOPSIS
-    TIME_to_uint64_t()
-
-  DESCRIPTION
-    The function is used when we need to convert value of time item
-    to a number if it's used in numeric context, i. e.:
-    SELECT NOW()+1, CURDATE()+0, CURTIMIE()+0;
-    SELECT ?+1;
-
-  NOTE
-    This function doesn't check that given DRIZZLE_TIME structure members are
-    in valid range. If they are not, return value won't reflect any
-    valid date either.
-*/
-
-uint64_t TIME_to_uint64_t(const DRIZZLE_TIME *my_time)
-{
-  switch (my_time->time_type) {
-  case DRIZZLE_TIMESTAMP_DATETIME:
-    return TIME_to_uint64_t_datetime(my_time);
-  case DRIZZLE_TIMESTAMP_DATE:
-    return TIME_to_uint64_t_date(my_time);
-  case DRIZZLE_TIMESTAMP_TIME:
-    return TIME_to_uint64_t_time(my_time);
-  case DRIZZLE_TIMESTAMP_NONE:
-  case DRIZZLE_TIMESTAMP_ERROR:
-    return 0ULL;
-  default:
-    assert(0);
-  }
-  return 0;
-}
-
-} /* namespace drizzled */

=== removed file 'drizzled/my_time.h'
--- drizzled/my_time.h	2010-02-04 08:14:46 +0000
+++ drizzled/my_time.h	1970-01-01 00:00:00 +0000
@@ -1,194 +0,0 @@
-/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2008 MySQL
- *
- *  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
- */
-
-#ifndef DRIZZLED_MY_TIME_H
-#define DRIZZLED_MY_TIME_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
-
-namespace drizzled
-{
-
-extern uint64_t log_10_int[20];
-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
-
-/* two-digit years < this are 20..; >= this are 19.. */
-#define YY_PART_YEAR	   70
-
-/* Flags to str_to_datetime */
-#define TIME_FUZZY_DATE		1
-#define TIME_DATETIME_ONLY	2
-/* Must be same as MODE_NO_ZERO_IN_DATE */
-#define TIME_NO_ZERO_IN_DATE    (65536L*2*2*2*2*2*2*2)
-/* Must be same as MODE_NO_ZERO_DATE */
-#define TIME_NO_ZERO_DATE	(TIME_NO_ZERO_IN_DATE*2)
-#define TIME_INVALID_DATES	(TIME_NO_ZERO_DATE*2)
-
-#define DRIZZLE_TIME_WARN_TRUNCATED    1
-#define DRIZZLE_TIME_WARN_OUT_OF_RANGE 2
-
-/* Limits for the TIME data type */
-#define TIME_MAX_HOUR 838
-#define TIME_MAX_MINUTE 59
-#define TIME_MAX_SECOND 59
-#define TIME_MAX_VALUE (TIME_MAX_HOUR*10000 + TIME_MAX_MINUTE*100 + \
-                        TIME_MAX_SECOND)
-#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.
-
-  We assume that values in this structure are normalized, i.e. year <= 9999,
-  month <= 12, day <= 31, hour <= 23, hour <= 59, hour <= 59. Many functions
-  in server such as my_system_gmt_sec() or make_time() family of functions
-  rely on this (actually now usage of make_*() family relies on a bit weaker
-  restriction). Also functions that produce DRIZZLE_TIME as result ensure this.
-  There is one exception to this rule though if this structure holds time
-  value (time_type == DRIZZLE_TIMESTAMP_TIME) days and hour member can hold
-  bigger values.
-*/
-typedef struct st_drizzle_time
-{
-  unsigned int  year, month, day, hour, minute, second;
-  unsigned long second_part;
-  bool       neg;
-  enum enum_drizzle_timestamp_type time_type;
-} DRIZZLE_TIME;
-
-
-bool check_date(const DRIZZLE_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, DRIZZLE_TIME *l_time,
-                uint32_t flags, int *was_cut);
-int64_t number_to_datetime(int64_t nr, DRIZZLE_TIME *time_res,
-                            uint32_t flags, int *was_cut);
-uint64_t TIME_to_uint64_t_datetime(const DRIZZLE_TIME *);
-uint64_t TIME_to_uint64_t(const DRIZZLE_TIME *);
-
-
-bool str_to_time(const char *str,uint32_t length, DRIZZLE_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);
-uint32_t year_2000_handling(uint32_t year);
-
-void init_time(void);
-
-
-/*
-  Function to check sanity of a TIMESTAMP value
-
-  DESCRIPTION
-    Check if a given DRIZZLE_TIME value fits in TIMESTAMP range.
-    This function doesn't make precise check, but rather a rough
-    estimate.
-
-  RETURN VALUES
-    false   The value seems sane
-    true    The DRIZZLE_TIME value is definitely out of range
-*/
-
-static inline bool validate_timestamp_range(const DRIZZLE_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)))
-    return false;
-
-  return true;
-}
-
-time_t
-my_system_gmt_sec(const DRIZZLE_TIME *t, long *my_timezone,
-                  bool *in_dst_time_gap);
-
-void set_zero_time(DRIZZLE_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_date_to_str(const DRIZZLE_TIME *l_time, char *to);
-int my_datetime_to_str(const DRIZZLE_TIME *l_time, char *to);
-int my_TIME_to_str(const DRIZZLE_TIME *l_time, char *to);
-
-/*
-  Available interval types used in any statement.
-
-  'interval_type' must be sorted so that simple intervals comes first,
-  ie year, quarter, month, week, day, hour, etc. The order based on
-  interval size is also important and the intervals should be kept in a
-  large to smaller order. (get_interval_value() depends on this)
-
-  Note: If you change the order of elements in this enum you should fix
-  order of elements in 'interval_type_to_name' and 'interval_names'
-  arrays
-
-  See also interval_type_to_name, get_interval_value, interval_names
-*/
-
-enum interval_type
-{
-  INTERVAL_YEAR, INTERVAL_QUARTER, INTERVAL_MONTH, INTERVAL_WEEK, INTERVAL_DAY,
-  INTERVAL_HOUR, INTERVAL_MINUTE, INTERVAL_SECOND, INTERVAL_MICROSECOND,
-  INTERVAL_YEAR_MONTH, INTERVAL_DAY_HOUR, INTERVAL_DAY_MINUTE,
-  INTERVAL_DAY_SECOND, INTERVAL_HOUR_MINUTE, INTERVAL_HOUR_SECOND,
-  INTERVAL_MINUTE_SECOND, INTERVAL_DAY_MICROSECOND, INTERVAL_HOUR_MICROSECOND,
-  INTERVAL_MINUTE_MICROSECOND, INTERVAL_SECOND_MICROSECOND, INTERVAL_LAST
-};
-
-extern uint64_t my_getsystime(void);
-extern uint64_t my_micro_time(void);
-extern uint64_t my_micro_time_and_time(time_t *time_arg);
-
-} /* namespace drizzled */
-
-#endif /* DRIZZLED_MY_TIME_H */

=== removed file 'drizzled/my_tree.cc'
--- drizzled/my_tree.cc	2010-02-04 08:14:46 +0000
+++ drizzled/my_tree.cc	1970-01-01 00:00:00 +0000
@@ -1,715 +0,0 @@
-/* Copyright (C) 2000 MySQL AB
-
-   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; version 2 of the License.
-
-   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-/*
-  Code for handling red-black (balanced) binary trees.
-  key in tree is allocated accrding to following:
-
-  1) If size < 0 then tree will not allocate keys and only a pointer to
-     each key is saved in tree.
-     compare and search functions uses and returns key-pointer
-
-  2) If size == 0 then there are two options:
-       - key_size != 0 to tree_insert: The key will be stored in the tree.
-       - key_size == 0 to tree_insert:  A pointer to the key is stored.
-     compare and search functions uses and returns key-pointer.
-
-  3) if key_size is given to init_tree then each node will continue the
-     key and calls to insert_key may increase length of key.
-     if key_size > sizeof(pointer) and key_size is a multiple of 8 (double
-     allign) then key will be put on a 8 alligned adress. Else
-     the key will be on adress (element+1). This is transparent for user
-     compare and search functions uses a pointer to given key-argument.
-
-  - If you use a free function for tree-elements and you are freeing
-    the element itself, you should use key_size = 0 to init_tree and
-    tree_search
-
-  The actual key in TREE_ELEMENT is saved as a pointer or after the
-  TREE_ELEMENT struct.
-  If one uses only pointers in tree one can use tree_set_pointer() to
-  change address of data.
-
-  Implemented by monty.
-*/
-
-/*
-  NOTE:
-  tree->compare function should be ALWAYS called as
-    (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element), key)
-  and not other way around, as
-    (*tree->compare)(custom_arg, key, ELEMENT_KEY(tree,element))
-*/
-
-#include "config.h"
-
-#include "drizzled/my_tree.h"
-#include "drizzled/internal/my_sys.h"
-#include "drizzled/internal/m_string.h"
-#include "drizzled/memory/root.h"
-
-#define BLACK		1
-#define RED		0
-#define DEFAULT_ALLOC_SIZE 8192
-#define DEFAULT_ALIGN_SIZE 8192
-
-#define ELEMENT_KEY(tree,element)\
-(tree->offset_to_key ? (void*)((unsigned char*) element+tree->offset_to_key) :\
-			*((void**) (element+1)))
-#define ELEMENT_CHILD(element, offs) (*(TREE_ELEMENT**)((char*)element + offs))
-
-namespace drizzled
-{
-
-
-static void delete_tree_element(TREE *,TREE_ELEMENT *);
-static int tree_walk_left_root_right(TREE *,TREE_ELEMENT *,
-				     tree_walk_action,void *);
-static int tree_walk_right_root_left(TREE *,TREE_ELEMENT *,
-				     tree_walk_action,void *);
-static void left_rotate(TREE_ELEMENT **parent,TREE_ELEMENT *leaf);
-static void right_rotate(TREE_ELEMENT **parent, TREE_ELEMENT *leaf);
-static void rb_insert(TREE *tree,TREE_ELEMENT ***parent,
-		      TREE_ELEMENT *leaf);
-static void rb_delete_fixup(TREE *tree,TREE_ELEMENT ***parent);
-
-
-void init_tree(TREE *tree, size_t default_alloc_size, uint32_t memory_limit,
-               uint32_t size, qsort_cmp2 compare, bool with_delete,
-	       tree_element_free free_element, void *custom_arg)
-{
-  if (default_alloc_size < DEFAULT_ALLOC_SIZE)
-    default_alloc_size= DEFAULT_ALLOC_SIZE;
-  default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
-  memset(&tree->null_element, 0, sizeof(tree->null_element));
-  tree->root= &tree->null_element;
-  tree->compare= compare;
-  tree->size_of_element= size > 0 ? (uint32_t) size : 0;
-  tree->memory_limit= memory_limit;
-  tree->free= free_element;
-  tree->allocated= 0;
-  tree->elements_in_tree= 0;
-  tree->custom_arg = custom_arg;
-  tree->null_element.colour= BLACK;
-  tree->null_element.left=tree->null_element.right= 0;
-  tree->flag= 0;
-  if (!free_element &&
-      (size <= sizeof(void*) || ((uint32_t) size & (sizeof(void*)-1))))
-  {
-    /*
-      We know that the data doesn't have to be aligned (like if the key
-      contains a double), so we can store the data combined with the
-      TREE_ELEMENT.
-    */
-    tree->offset_to_key= sizeof(TREE_ELEMENT); /* Put key after element */
-    /* Fix allocation size so that we don't lose any memory */
-    default_alloc_size/= (sizeof(TREE_ELEMENT)+size);
-    if (!default_alloc_size)
-      default_alloc_size= 1;
-    default_alloc_size*= (sizeof(TREE_ELEMENT)+size);
-  }
-  else
-  {
-    tree->offset_to_key= 0;		/* use key through pointer */
-    tree->size_of_element+= sizeof(void*);
-  }
-  if (! (tree->with_delete= with_delete))
-  {
-    init_alloc_root(&tree->mem_root, default_alloc_size);
-    tree->mem_root.min_malloc= (sizeof(TREE_ELEMENT)+tree->size_of_element);
-  }
-}
-
-static void free_tree(TREE *tree, myf free_flags)
-{
-  if (tree->root)				/* If initialized */
-  {
-    if (tree->with_delete)
-      delete_tree_element(tree,tree->root);
-    else
-    {
-      if (tree->free)
-      {
-        if (tree->memory_limit)
-          (*tree->free)(NULL, free_init, tree->custom_arg);
-	delete_tree_element(tree,tree->root);
-        if (tree->memory_limit)
-          (*tree->free)(NULL, free_end, tree->custom_arg);
-      }
-      free_root(&tree->mem_root, free_flags);
-    }
-  }
-  tree->root= &tree->null_element;
-  tree->elements_in_tree= 0;
-  tree->allocated= 0;
-}
-
-void delete_tree(TREE* tree)
-{
-  free_tree(tree, MYF(0)); /* free() mem_root if applicable */
-}
-
-void reset_tree(TREE* tree)
-{
-  /* do not free mem_root, just mark blocks as free */
-  free_tree(tree, MYF(memory::MARK_BLOCKS_FREE));
-}
-
-
-static void delete_tree_element(TREE *tree, TREE_ELEMENT *element)
-{
-  if (element != &tree->null_element)
-  {
-    delete_tree_element(tree,element->left);
-    if (tree->free)
-      (*tree->free)(ELEMENT_KEY(tree,element), free_free, tree->custom_arg);
-    delete_tree_element(tree,element->right);
-    if (tree->with_delete)
-      free((char*) element);
-  }
-}
-
-
-/*
-  insert, search and delete of elements
-
-  The following should be true:
-    parent[0] = & parent[-1][0]->left ||
-    parent[0] = & parent[-1][0]->right
-*/
-
-TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint32_t key_size,
-                          void* custom_arg)
-{
-  int cmp;
-  TREE_ELEMENT *element,***parent;
-
-  parent= tree->parents;
-  *parent = &tree->root; element= tree->root;
-  for (;;)
-  {
-    if (element == &tree->null_element ||
-	(cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
-                                key)) == 0)
-      break;
-    if (cmp < 0)
-    {
-      *++parent= &element->right; element= element->right;
-    }
-    else
-    {
-      *++parent = &element->left; element= element->left;
-    }
-  }
-  if (element == &tree->null_element)
-  {
-    size_t alloc_size= sizeof(TREE_ELEMENT)+key_size+tree->size_of_element;
-    tree->allocated+= alloc_size;
-
-    if (tree->memory_limit && tree->elements_in_tree
-                           && tree->allocated > tree->memory_limit)
-    {
-      reset_tree(tree);
-      return tree_insert(tree, key, key_size, custom_arg);
-    }
-
-    key_size+= tree->size_of_element;
-    if (tree->with_delete)
-      element= (TREE_ELEMENT *) malloc(alloc_size);
-    else
-      element= (TREE_ELEMENT *) alloc_root(&tree->mem_root,alloc_size);
-    if (!element)
-      return(NULL);
-    **parent= element;
-    element->left= element->right= &tree->null_element;
-    if (!tree->offset_to_key)
-    {
-      if (key_size == sizeof(void*))		 /* no length, save pointer */
-	*((void**) (element+1))= key;
-      else
-      {
-	*((void**) (element+1))= (void*) ((void **) (element+1)+1);
-	memcpy(*((void **) (element+1)),key, key_size - sizeof(void*));
-      }
-    }
-    else
-      memcpy((unsigned char*) element + tree->offset_to_key, key, key_size);
-    element->count= 1;			/* May give warning in purify */
-    tree->elements_in_tree++;
-    rb_insert(tree,parent,element);	/* rebalance tree */
-  }
-  else
-  {
-    if (tree->flag & TREE_NO_DUPS)
-      return(NULL);
-    element->count++;
-    /* Avoid a wrap over of the count. */
-    if (! element->count)
-      element->count--;
-  }
-
-  return element;
-}
-
-int tree_delete(TREE *tree, void *key, uint32_t key_size, void *custom_arg)
-{
-  int remove_colour;
-  TREE_ELEMENT *element,***parent, ***org_parent, *nod;
-  if (!tree->with_delete)
-    return 1;					/* not allowed */
-
-  parent= tree->parents;
-  *parent= &tree->root; element= tree->root;
-  for (;;)
-  {
-    int cmp;
-
-    if (element == &tree->null_element)
-      return 1;				/* Was not in tree */
-    if ((cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
-                                key)) == 0)
-      break;
-    if (cmp < 0)
-    {
-      *++parent= &element->right; element= element->right;
-    }
-    else
-    {
-      *++parent = &element->left; element= element->left;
-    }
-  }
-  if (element->left == &tree->null_element)
-  {
-    (**parent)= element->right;
-    remove_colour= element->colour;
-  }
-  else if (element->right == &tree->null_element)
-  {
-    (**parent)= element->left;
-    remove_colour= element->colour;
-  }
-  else
-  {
-    org_parent= parent;
-    *++parent= &element->right; nod= element->right;
-    while (nod->left != &tree->null_element)
-    {
-      *++parent= &nod->left; nod= nod->left;
-    }
-    (**parent)= nod->right;		/* unlink nod from tree */
-    remove_colour= nod->colour;
-    org_parent[0][0]= nod;		/* put y in place of element */
-    org_parent[1]= &nod->right;
-    nod->left= element->left;
-    nod->right= element->right;
-    nod->colour= element->colour;
-  }
-  if (remove_colour == BLACK)
-    rb_delete_fixup(tree,parent);
-  if (tree->free)
-    (*tree->free)(ELEMENT_KEY(tree,element), free_free, tree->custom_arg);
-  tree->allocated-= sizeof(TREE_ELEMENT) + tree->size_of_element + key_size;
-  free((unsigned char*) element);
-  tree->elements_in_tree--;
-
-  return 0;
-}
-
-void *tree_search_key(TREE *tree, const void *key,
-                      TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
-                      enum ha_rkey_function flag, void *custom_arg)
-{
-  TREE_ELEMENT *element= tree->root;
-  TREE_ELEMENT **last_left_step_parent= NULL, **last_right_step_parent= NULL;
-  TREE_ELEMENT **last_equal_element= NULL;
-
-/*
-  TODO: support for HA_READ_KEY_OR_PREV, HA_READ_PREFIX flags if needed.
-*/
-
-  *parents = &tree->null_element;
-  while (element != &tree->null_element)
-  {
-    int cmp;
-
-    *++parents= element;
-
-    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
-			       key)) == 0)
-    {
-      switch (flag) {
-      case HA_READ_KEY_EXACT:
-      case HA_READ_KEY_OR_NEXT:
-      case HA_READ_BEFORE_KEY:
-	last_equal_element= parents;
-	cmp= 1;
-	break;
-      case HA_READ_AFTER_KEY:
-	cmp= -1;
-	break;
-      case HA_READ_PREFIX_LAST:
-      case HA_READ_PREFIX_LAST_OR_PREV:
-	last_equal_element= parents;
-	cmp= -1;
-	break;
-      default:
-	return NULL;
-      }
-    }
-    if (cmp < 0) /* element < key */
-    {
-      last_right_step_parent= parents;
-      element= element->right;
-    }
-    else
-    {
-      last_left_step_parent= parents;
-      element= element->left;
-    }
-  }
-  switch (flag) {
-  case HA_READ_KEY_EXACT:
-  case HA_READ_PREFIX_LAST:
-    *last_pos= last_equal_element;
-    break;
-  case HA_READ_KEY_OR_NEXT:
-    *last_pos= last_equal_element ? last_equal_element : last_left_step_parent;
-    break;
-  case HA_READ_AFTER_KEY: