~drizzle-trunk/drizzle/development

/* 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

#include "config.h"

#include "drizzled/type/time.h"

#include <drizzled/util/gmtime.h>

#include "drizzled/internal/m_string.h"

#include "drizzled/charset_info.h"

#include <drizzled/util/test.h>

#include "drizzled/definitions.h"

#include <drizzled/sql_string.h>

#include <cstdio>

#include <algorithm>

using namespace std;

namespace drizzled

{

static int check_time_range(type::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

*/

static bool check_date(const type::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;

}

namespace type {

bool Time::check(bool not_zero_date, uint32_t flags, int *was_cut) const

{

  return check_date(this, not_zero_date, flags, was_cut);

}

} // namespace type

/*

  Convert a timestamp string to a type::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

type::timestamp_t

str_to_datetime(const char *str, uint32_t length, type::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(type::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(type::DRIZZLE_TIMESTAMP_NONE);   /* Can't be a full datetime */

        }

        /* Date field.  Set hour, minutes and seconds to 0 */

        date[0]= date[1]= date[2]= date[3]= date[4]= 0;

        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(type::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(type::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(type::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(type::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 ?

                      type::DRIZZLE_TIMESTAMP_DATE : type::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 ? type::DRIZZLE_TIMESTAMP_DATE :

                                       type::DRIZZLE_TIMESTAMP_DATETIME));

err:

  l_time->reset();

  return(type::DRIZZLE_TIMESTAMP_ERROR);

}

/*

 Convert a time string to a type::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, type::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 true;

  /* Check first if this is a full TIMESTAMP */

  if (length >= 12)

  {                                             /* Probably full timestamp */

    int was_cut;

    type::timestamp_t res= str_to_datetime(str, length, l_time,

                                           (TIME_FUZZY_DATE | TIME_DATETIME_ONLY), &was_cut);

    if ((int) res >= (int) type::DRIZZLE_TIMESTAMP_ERROR)

    {

      if (was_cut)

        *warning|= DRIZZLE_TIME_WARN_TRUNCATED;

      return res == type::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= type::DRIZZLE_TIMESTAMP_TIME;

  /* Check if the value is valid and fits into type::Time range */

  if (check_time_range(l_time, warning))

  {

    return 1;

  }

  /* Check if there is garbage at end of the type::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 type::Time range

  SYNOPSIS:

    check_time_range()

    time     pointer to type::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(type::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;

  type::Time my_time;

  bool not_used;

  seconds= (time_t) time((time_t*) 0);