temporal.h

Go to the documentation of this file.

/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008-2009 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
 */

#pragma once

#define DRIZZLE_MAX_SECONDS 59
#define DRIZZLE_MAX_SECONDS_WITH_LEAP 61
#define DRIZZLE_MAX_MINUTES 59
#define DRIZZLE_MAX_HOURS 23
#define DRIZZLE_MAX_DAYS 31
#define DRIZZLE_MAX_MONTHS 12
#define DRIZZLE_MAX_YEARS_SQL 9999
#define DRIZZLE_MAX_YEARS_EPOCH 2038
#define DRIZZLE_MIN_SECONDS 0
#define DRIZZLE_MIN_MINUTES 0
#define DRIZZLE_MIN_HOURS 0
#define DRIZZLE_MIN_DAYS 1
#define DRIZZLE_MIN_MONTHS 1
#define DRIZZLE_MIN_YEARS_SQL 1
#define DRIZZLE_MIN_YEARS_EPOCH 1970

#define DRIZZLE_SECONDS_IN_MINUTE 60
#define DRIZZLE_SECONDS_IN_HOUR (60*60)
#define DRIZZLE_SECONDS_IN_DAY (60*60*24)
#define DRIZZLE_NANOSECONDS_IN_MICROSECOND 1000

#define DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING 40

#define DRIZZLE_YY_PART_YEAR  70

#include <drizzled/calendar.h>
#include <drizzled/common_fwd.h>
#include <cassert>
#include <ostream>

namespace drizzled {

class DRIZZLED_API Temporal
{
protected:
  enum calendar _calendar;
  uint32_t _years;
  uint32_t _months;
  uint32_t _days;
  uint32_t _hours;
  uint32_t _minutes;
  uint32_t _seconds;
  time_t _epoch_seconds;
  uint32_t _useconds;
  uint32_t _nseconds;
  bool _overflow;
  uint64_t _cumulative_seconds_in_time() const;
  inline void _reset()
  {
    _years= _months= _days= _hours= _minutes=
      _seconds= _epoch_seconds= _useconds= _nseconds= 0;
  }

public:
  Temporal();
  virtual ~Temporal() {}

  inline enum calendar calendar() const {return _calendar;}
  inline void set_nseconds(const uint32_t nsecond) {_nseconds= nsecond;}
  inline uint32_t nseconds() const {return _nseconds;}
  inline void set_useconds(const uint32_t usecond) {_useconds= usecond;}
  inline uint32_t useconds() const {return _useconds;}
  void set_epoch_seconds();
  inline void set_epoch_seconds(const uint32_t epoch_second)
  {_epoch_seconds= epoch_second;}
  inline time_t epoch_seconds() const {return _epoch_seconds;}
  inline void set_seconds(const uint32_t second) {_seconds= second;}
  inline uint32_t seconds() const {return _seconds;}
  inline void set_minutes(const uint32_t minute) {_minutes= minute;}
  inline uint32_t minutes() const {return _minutes;}
  inline void set_hours(const uint32_t hour) {_hours= hour;}
  inline uint32_t hours() const {return _hours;}
  inline void set_days(const uint32_t day) {_days= day;}
  inline uint32_t days() const {return _days;}
  inline void set_months(const uint32_t month) {_months= month;}
  inline uint32_t months() const {return _months;}
  inline void set_years(const uint32_t year) {_years= year;}
  inline uint32_t years() const {return _years;}
  inline bool overflow() const {return _overflow;}

  virtual bool is_valid_date() const= 0;
  virtual bool is_valid_datetime() const= 0;
  virtual bool is_valid_time() const= 0;
  virtual bool is_valid_timestamp() const= 0;

  virtual bool is_valid() const= 0;

  friend class TemporalFormat;
};

class DRIZZLED_API Date: public Temporal
{
public:
  Date() :Temporal() {}
  virtual bool operator==(const Date &rhs);
  virtual bool operator!=(const Date &rhs);
  virtual bool operator>(const Date &rhs);
  virtual bool operator>=(const Date &rhs);
  virtual bool operator<(const Date &rhs);
  virtual bool operator<=(const Date &rhs);

  virtual bool operator==(const DateTime &rhs);
  virtual bool operator!=(const DateTime &rhs);
  virtual bool operator>(const DateTime &rhs);
  virtual bool operator>=(const DateTime &rhs);
  virtual bool operator<(const DateTime &rhs);
  virtual bool operator<=(const DateTime &rhs);

  virtual bool operator==(const Timestamp &rhs);
  virtual bool operator!=(const Timestamp &rhs);
  virtual bool operator>(const Timestamp &rhs);
  virtual bool operator>=(const Timestamp &rhs);
  virtual bool operator<(const Timestamp &rhs);
  virtual bool operator<=(const Timestamp &rhs);

  const Date operator-(const Date &rhs);
  const Date operator+(const Date &rhs);
  Date& operator+=(const Date &rhs);
  Date& operator-=(const Date &rhs);

  const Date operator-(const Time &rhs);
  const Date operator+(const Time &rhs);
  Date& operator-=(const Time &rhs);
  Date& operator+=(const Time &rhs);


  const Date operator-(const DateTime &rhs);
  const Date operator+(const DateTime &rhs);
  Date& operator+=(const DateTime &rhs);
  Date& operator-=(const DateTime &rhs);


  Date& operator=(const DateTime &rhs);

  virtual bool is_valid_date() const {return is_valid();}
  virtual bool is_valid_datetime() const {return is_valid();}
  virtual bool is_valid_time() const {return false;}
  virtual bool is_valid_timestamp() const
  {
    return is_valid() && in_unix_epoch();
  }

  virtual bool is_valid() const;
  /* Returns whether the Date (or subclass) instance is in the Unix Epoch. */
  virtual bool in_unix_epoch() const;

  virtual int to_string(char *to, size_t to_len) const;

  static const int MAX_STRING_LENGTH= 11;

  virtual bool from_string(const char *from, size_t from_len);

  virtual void to_int64_t(int64_t *to) const;

  virtual void to_int32_t(int32_t *to) const;

  virtual bool from_int32_t(const int32_t from);

  void to_julian_day_number(int64_t *to) const;

  bool from_julian_day_number(const int64_t from);

  virtual void to_tm(struct tm *to) const;

  virtual bool from_tm(const struct tm *from);

  virtual void to_time_t(time_t &to) const;

  virtual bool from_time_t(const time_t from);

  virtual void to_decimal(type::Decimal *to) const;

  friend class TemporalInterval;
  friend class Timestamp;
};

/* Forward declare needed for friendship */
class DateTime;

class DRIZZLED_API Time: public Temporal
{
public:
  Time() :Temporal() {}
  /* Maximum number of seconds in 23:59:59 (24 * 60 * 60) */
  static const uint32_t MAX_CUMULATIVE_SECONDS= 86400L;

  bool operator==(const Time &rhs);
  bool operator!=(const Time &rhs);
  bool operator>(const Time &rhs);
  bool operator>=(const Time &rhs);
  bool operator<(const Time &rhs);
  bool operator<=(const Time &rhs);
  const Time operator-(const Time &rhs);
  const Time operator+(const Time &rhs);
  Time& operator-=(const Time &rhs);
  Time& operator+=(const Time &rhs);

  bool is_valid_date() const {return false;}
  bool is_valid_datetime() const {return false;}
  bool is_valid_time() const {return is_valid();}
  bool is_valid_timestamp() const {return false;}

  bool is_valid() const;
  bool is_fuzzy_valid() const;

  int to_string(char *to, size_t to_len) const;

  static const int MAX_STRING_LENGTH= 9;


  bool from_string(const char *from, size_t from_len);

  void to_int32_t(int32_t *to) const;

  void to_uint64_t(uint64_t &to) const;

  bool from_int32_t(const int32_t from);

  bool from_time_t(const time_t from);

  void to_decimal(type::Decimal *to) const;

  friend class Date;
  friend class DateTime;
};

class DRIZZLED_API DateTime: public Date
{
public:
  DateTime() :Date() {}

  friend class TemporalInterval;

  bool in_unix_epoch() const;
  virtual bool is_valid() const;

  void to_int32_t(int32_t *) const {assert(0);}
  bool from_int32_t(int32_t) {assert(0); return false;}

  virtual int to_string(char *to, size_t to_len) const;

  static const int MAX_STRING_LENGTH= 27;

  bool from_string(const char *from, size_t from_len);

  void to_int64_t(int64_t *to) const;

  bool from_time_t(const time_t from);
  bool from_timeval(struct timeval &_timeval);

  bool from_int64_t(const int64_t from, bool convert);

  bool from_int64_t(const int64_t from) {
    return from_int64_t(from, true);
  }

  void to_tm(struct tm *to) const;

  void to_decimal(type::Decimal *to) const;

  friend class Timestamp;
};

class DRIZZLED_API Timestamp: public DateTime
{
public:
  Timestamp() :DateTime() {}

  bool operator==(const Date &rhs);
  bool operator!=(const Date &rhs);
  bool operator>(const Date &rhs);
  bool operator>=(const Date &rhs);
  bool operator<(const Date &rhs);
  bool operator<=(const Date &rhs);

  bool operator==(const DateTime &rhs);
  bool operator!=(const DateTime &rhs);
  bool operator>(const DateTime &rhs);
  bool operator>=(const DateTime &rhs);
  bool operator<(const DateTime &rhs);
  bool operator<=(const DateTime &rhs);

  bool operator==(const Timestamp &rhs);
  bool operator!=(const Timestamp &rhs);
  bool operator>(const Timestamp &rhs);
  bool operator>=(const Timestamp &rhs);
  bool operator<(const Timestamp &rhs);
  bool operator<=(const Timestamp &rhs);

  bool is_valid_timestamp() const {return is_valid();}
  virtual bool is_valid() const;

  void to_time_t(time_t &to) const;
};

std::ostream& operator<<(std::ostream& os, const Timestamp& subject);

class DRIZZLED_API MicroTimestamp: public Timestamp
{
public:
  MicroTimestamp() :Timestamp() {}
  bool is_valid() const;

  int to_string(char *to, size_t to_len) const;

  static const int MAX_STRING_LENGTH= 27;

  void to_timeval(struct timeval &to) const;
};

class DRIZZLED_API NanoTimestamp: public Timestamp
{
public:
  NanoTimestamp() :Timestamp() {}
  bool is_valid() const;

  void to_timespec(struct timespec *to) const;
};

} /* end namespace drizzled */