~drizzle-trunk/drizzle/development

/* - 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
 */

#include <config.h>
#include <boost/lexical_cast.hpp>

#include <drizzled/field/date.h>
#include <drizzled/error.h>
#include <drizzled/table.h>
#include <drizzled/temporal.h>
#include <drizzled/session.h>
#include <drizzled/time_functions.h>
#include <drizzled/current_session.h>
#include <drizzled/system_variables.h>

#include <math.h>

#include <sstream>
#include <string>

namespace drizzled
{


/****************************************************************************
** Drizzle date type stored in 3 bytes
** In number context: YYYYMMDD
****************************************************************************/

/*
  Store string into a date field

  SYNOPSIS
    Field_date::store()
    from                Date string
    len                 Length of date field
    cs                  Character set (not used)

  RETURN
    0  ok
    1  Value was cut during conversion
    2  Wrong date string
    3  Datetime value that was cut (warning level NOTE)
       This is used by opt_range.cc:get_mm_leaf(). Note that there is a
       nearly-identical class Field_date doesn't ever return 3 from its
       store function.
*/
int Field_date::store(const char *from,
                         uint32_t len,
                         const charset_info_st * const )
{
  /* 
   * Try to create a DateTime from the supplied string.  Throw an error
   * if unable to create a valid DateTime.  A DateTime is used so that
   * automatic conversion from the higher-storage DateTime can be used
   * and matches on datetime format strings can occur.
   */
  ASSERT_COLUMN_MARKED_FOR_WRITE;
  DateTime temporal;
  if (! temporal.from_string(from, (size_t) len))
  {
    my_error(ER_INVALID_DATE_VALUE, MYF(ME_FATALERROR), from);
    return 2;
  }
  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
  uint32_t int_value= (temporal.years() * 10000) + (temporal.months() * 100) + temporal.days();
  int4store(ptr, int_value);
  return 0;
}

int Field_date::store(double from)
{
  ASSERT_COLUMN_MARKED_FOR_WRITE;
  if (from < 0.0 || from > 99991231235959.0)
  {
    /* Convert the double to a string using stringstream */
    std::stringstream ss;
    std::string tmp;
    ss.precision(18); /* 18 places should be fine for error display of double input. */
    ss << from; ss >> tmp;

    my_error(ER_INVALID_DATE_VALUE, MYF(ME_FATALERROR), tmp.c_str());
    return 2;
  }
  return Field_date::store((int64_t) rint(from), false);
}

int Field_date::store(int64_t from, bool)
{
  /* 
   * Try to create a DateTime from the supplied integer.  Throw an error
   * if unable to create a valid DateTime.  
   */
  ASSERT_COLUMN_MARKED_FOR_WRITE;
  DateTime temporal;
  if (! temporal.from_int64_t(from))
  {
    /* Convert the integer to a string using boost::lexical_cast */
    std::string tmp(boost::lexical_cast<std::string>(from)); 

    my_error(ER_INVALID_DATE_VALUE, MYF(ME_FATALERROR), tmp.c_str());
    return 2;
  }

  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
  uint32_t int_value= (temporal.years() * 10000) + (temporal.months() * 100) + temporal.days();
  int4store(ptr, int_value);

  return 0;
}

int Field_date::store_time(type::Time &ltime,
                           type::timestamp_t time_type)
{
  long tmp;
  int error= 0;
  if (time_type == type::DRIZZLE_TIMESTAMP_DATE || time_type == type::DRIZZLE_TIMESTAMP_DATETIME)
  {
    tmp= ltime.year*10000 + ltime.month*100 + ltime.day;

    Session *session= getTable() ? getTable()->in_use : current_session;
    type::cut_t cut_error= type::VALID;
    if (ltime.check(tmp != 0,
                     (TIME_FUZZY_DATE |
                      (session->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))), cut_error))
    {
      char buff[type::Time::MAX_STRING_LENGTH];
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
      ltime.convert(str, type::DRIZZLE_TIMESTAMP_DATE);
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
                           str.ptr(), str.length(), type::DRIZZLE_TIMESTAMP_DATE, 1);
    }

    error= static_cast<int>(cut_error);

    if (not error && ltime.time_type != type::DRIZZLE_TIMESTAMP_DATE &&
        (ltime.hour || ltime.minute || ltime.second || ltime.second_part))
    {
      char buff[type::Time::MAX_STRING_LENGTH];
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
      ltime.convert(str);
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE,
                           ER_WARN_DATA_TRUNCATED,
                           str.ptr(), str.length(), type::DRIZZLE_TIMESTAMP_DATE, 1);
      error= 3;
    }
  }
  else
  {
    tmp=0;
    error= 1;
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  }

  int4store(ptr,tmp);

  return error;
}

double Field_date::val_real(void) const
{
  return (double) Field_date::val_int();
}

int64_t Field_date::val_int(void) const
{
  uint32_t j;

  ASSERT_COLUMN_MARKED_FOR_READ;

  j= uint4korr(ptr);

  return (int64_t) j;
}

String *Field_date::val_str(String *val_buffer, String *) const
{
  val_buffer->alloc(field_length);
  val_buffer->length(field_length);
  uint32_t tmp=(uint32_t) uint4korr(ptr);
  int32_t part;
  char *pos=(char*) val_buffer->ptr()+10;

  ASSERT_COLUMN_MARKED_FOR_READ;

  /* Open coded to get more speed */
  *pos--=0;					// End NULL
  part=(int32_t) (tmp % 100);
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
  part=(int32_t) (tmp/100%100);
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
  part=(int32_t) (tmp/10000);
  *pos--= (char) ('0'+part%10); part/=10;
  *pos--= (char) ('0'+part%10); part/=10;
  *pos--= (char) ('0'+part%10); part/=10;
  *pos=   (char) ('0'+part);
  return val_buffer;
}

bool Field_date::get_date(type::Time &ltime, uint32_t fuzzydate) const
{
  uint32_t tmp=(uint32_t) uint4korr(ptr);
  ltime.day=		(int) (tmp%100);
  ltime.month= 	(int) (tmp/100%100);
  ltime.year= 		(int) (tmp/10000);
  ltime.time_type= type::DRIZZLE_TIMESTAMP_DATE;
  ltime.hour= ltime.minute= ltime.second= ltime.second_part= ltime.neg= 0;

  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime.month || !ltime.day)) ?
          1 : 0);
}

bool Field_date::get_time(type::Time &ltime) const
{
  return Field_date::get_date(ltime ,0);
}

int Field_date::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
{
  uint32_t a,b;
  a=(uint32_t) uint4korr(a_ptr);
  b=(uint32_t) uint4korr(b_ptr);
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_date::sort_string(unsigned char *to,uint32_t )
{
  to[0] = ptr[3];
  to[1] = ptr[2];
  to[2] = ptr[1];
  to[3] = ptr[0];
}

} /* namespace drizzled */