~drizzle-trunk/drizzle/development

/* -*- mode: c++ c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems, Inc.

 *

 *  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/microtime.h>

#include <drizzled/error.h>

#include <drizzled/tztime.h>

#include <drizzled/table.h>

#include <drizzled/session.h>

#include <math.h>

#include <sstream>

#include <boost/date_time/posix_time/posix_time.hpp>

#include "drizzled/temporal.h"

namespace drizzled

{

namespace field

{

static boost::posix_time::ptime _epoch(boost::gregorian::date(1970, 1, 1));

Microtime::Microtime(unsigned char *ptr_arg,

                     unsigned char *null_ptr_arg,

                     unsigned char null_bit_arg,

                     enum utype unireg_check_arg,

                     const char *field_name_arg,

                     drizzled::TableShare *share) :

  Epoch(ptr_arg,

        null_ptr_arg,

        null_bit_arg,

        unireg_check_arg,

        field_name_arg,

        share)

  {

  }

Microtime::Microtime(bool maybe_null_arg,

                     const char *field_name_arg) :

  Epoch(maybe_null_arg,

        field_name_arg)

{

}

int Microtime::store(const char *from,

                     uint32_t len,

                     const CHARSET_INFO * const )

{

  MicroTimestamp temporal;

  ASSERT_COLUMN_MARKED_FOR_WRITE;

  if (not temporal.from_string(from, (size_t) len))

  {

    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);

    return 1;

  }

  struct timeval tmp;

  temporal.to_timeval(tmp);

  uint64_t tmp_seconds= tmp.tv_sec;

  uint32_t tmp_micro= tmp.tv_usec;

  pack_num(tmp_seconds);

  pack_num(tmp_micro, ptr +8);

  return 0;

}

int Microtime::store_time(type::Time *ltime, enum enum_drizzle_timestamp_type )

{

  long my_timezone;

  bool in_dst_time_gap;

  time_t time_tmp= my_system_gmt_sec(ltime, &my_timezone, &in_dst_time_gap, true);

  uint64_t tmp_seconds= time_tmp;

  uint32_t tmp_micro= ltime->second_part;

  pack_num(tmp_seconds);

  pack_num(tmp_micro, ptr +8);

  return 0;

}

int Microtime::store(double from)

{

  ASSERT_COLUMN_MARKED_FOR_WRITE;

  if (from < 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_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());

    return 2;

  }

  return Microtime::store((int64_t) rint(from), false);

}

int Microtime::store(int64_t from, bool)

{

  ASSERT_COLUMN_MARKED_FOR_WRITE;

  MicroTimestamp temporal;

  if (not temporal.from_int64_t(from))

  {

    /* Convert the integer to a string using boost::lexical_cast */

    std::string tmp(boost::lexical_cast<std::string>(from));

    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());

    return 2;

  }

  time_t tmp;

  temporal.to_time_t(tmp);

  uint64_t tmp_micro= tmp;

  pack_num(tmp_micro);

  pack_num(static_cast<uint32_t>(0), ptr +8);

  return 0;

}

double Microtime::val_real(void)

{

  return (double) Microtime::val_int();

}

int64_t Microtime::val_int(void)

{

  uint64_t temp;

  ASSERT_COLUMN_MARKED_FOR_READ;

  unpack_num(temp);

  Timestamp temporal;

  (void) temporal.from_time_t((time_t) temp);

  /* We must convert into a "timestamp-formatted integer" ... */

  int64_t result;

  temporal.to_int64_t(&result);

  return result;

}

String *Microtime::val_str(String *val_buffer, String *)

{

  uint64_t temp= 0;

  uint32_t micro_temp= 0;

  char *to;

  int to_len= field_length + 1 + 8;

  val_buffer->alloc(to_len);

  to= (char *) val_buffer->ptr();

  unpack_num(temp);

  unpack_num(micro_temp, ptr +8);

  val_buffer->set_charset(&my_charset_bin);	/* Safety */

  struct timeval buffer;

  buffer.tv_sec= temp;

  buffer.tv_usec= micro_temp;

  MicroTimestamp temporal;

  (void) temporal.from_timeval(buffer);

  int rlen= temporal.to_string(to, to_len);

  assert(rlen <= to_len);

  val_buffer->length(rlen);

  return val_buffer;

}

bool Microtime::get_date(type::Time *ltime, uint32_t)

{

  uint64_t temp;

  uint32_t micro_temp= 0;

  unpack_num(temp);

  unpack_num(micro_temp, ptr +8);

  memset(ltime, 0, sizeof(*ltime));

  Timestamp temporal;

  (void) temporal.from_time_t((time_t) temp);

  /* @TODO Goodbye the below code when type::Time is finally gone.. */

  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;

  ltime->year= temporal.years();

  ltime->month= temporal.months();

  ltime->day= temporal.days();

  ltime->hour= temporal.hours();

  ltime->minute= temporal.minutes();

  ltime->second= temporal.seconds();

  ltime->second_part= temporal.useconds();

  return 0;

}

bool Microtime::get_time(type::Time *ltime)

{

  return Microtime::get_date(ltime,0);

}

int Microtime::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)

{

  uint64_t a,b;

  uint32_t a_micro, b_micro;

  unpack_num(a, a_ptr);

  unpack_num(a_micro, a_ptr +8);

  unpack_num(b, b_ptr);

  unpack_num(b_micro, b_ptr +8);

  if (a == b)

    return (a_micro < b_micro) ? -1 : (a_micro > b_micro) ? 1 : 0;

  return (a < b) ? -1 : (a > b) ? 1 : 0;

}

void Microtime::sort_string(unsigned char *to,uint32_t )

{

#ifdef WORDS_BIGENDIAN

  if ((not getTable()) or (not getTable()->getShare()->db_low_byte_first))

  {

    std::reverse_copy(to, to+pack_length(), ptr);

    std::reverse_copy(to +8, to+pack_length(), ptr +8);

  }

  else

#endif

  {

    memcpy(to, ptr, pack_length());

  }

}

void Microtime::sql_type(String &res) const

{

  res.set_ascii(STRING_WITH_LEN("microsecond timestamp"));

}

void Microtime::set_time()

{

  Session *session= getTable() ? getTable()->in_use : current_session;

  uint32_t fractional_seconds= 0;

  uint64_t epoch_seconds= session->getCurrentTimestampEpoch(fractional_seconds);

  set_notnull();

  pack_num(epoch_seconds);

  pack_num(fractional_seconds, ptr +8);

}

long Microtime::get_timestamp(bool *null_value)

{

  if ((*null_value= is_null()))

    return 0;

  uint64_t tmp;

  return unpack_num(tmp);

}

} /* namespace field */

} /* namespace drizzled */