timestamp-value.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#ifndef IMPALA_RUNTIME_TIMESTAMP_VALUE_H
#define IMPALA_RUNTIME_TIMESTAMP_VALUE_H

#include <ctime>
#include <string>

#include <boost/cstdint.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <gflags/gflags.h>

#include "runtime/timestamp-parse-util.h"
#include "udf/udf.h"
#include "util/hash-util.h"

DECLARE_bool(use_local_tz_for_unix_timestamp_conversions);

namespace impala {

//
//
//
//
class TimestampValue {
 public:
  TimestampValue() {}

  TimestampValue(const boost::gregorian::date& d,
      const boost::posix_time::time_duration& t)
      : time_(t),
        date_(d) {}
  TimestampValue(const boost::posix_time::ptime& t)
      : time_(t.time_of_day()),
        date_(t.date()) {}
  TimestampValue(const TimestampValue& tv) : time_(tv.time_), date_(tv.date_) {}
  TimestampValue(const char* str, int len);
  TimestampValue(const char* str, int len, const DateTimeFormatContext& dt_ctx);

  template <typename Number>
  explicit TimestampValue(Number unix_time) {
    *this = UnixTimeToPtime(unix_time);
  }

  TimestampValue(int64_t unix_time, int64_t nanos) {
    boost::posix_time::ptime temp = UnixTimeToPtime(unix_time);
    temp += boost::posix_time::nanoseconds(nanos);
    *this = temp;
  }

  explicit TimestampValue(double unix_time) {
    const time_t unix_time_whole = unix_time;
    boost::posix_time::ptime temp = UnixTimeToPtime(unix_time_whole);
    temp += boost::posix_time::nanoseconds((unix_time - unix_time_whole) / ONE_BILLIONTH);
    *this = temp;
  }

  static TimestampValue LocalTime() {
    return TimestampValue(boost::posix_time::microsec_clock::local_time());
  }

  static TimestampValue FromTimestampVal(const impala_udf::TimestampVal& udf_value) {
    DCHECK(!udf_value.is_null);
    TimestampValue value;
    memcpy(&value.date_, &udf_value.date, sizeof(value.date_));
    memcpy(&value.time_, &udf_value.time_of_day, sizeof(value.time_));
    return value;
  }

  void ToTimestampVal(impala_udf::TimestampVal* tv) const {
    DCHECK(HasDateOrTime());
    memcpy(&tv->date, &date_, sizeof(date_));
    memcpy(&tv->time_of_day, &time_, sizeof(time_));
    tv->is_null = false;
  }

  void ToPtime(boost::posix_time::ptime* ptp) const {
    *ptp = boost::posix_time::ptime(date_, time_);
  }

  bool HasDate() const { return !date_.is_special(); }
  bool HasTime() const { return !time_.is_special(); }
  bool HasDateOrTime() const { return HasDate() || HasTime(); }
  bool HasDateAndTime() const { return HasDate() && HasTime(); }

  std::string DebugString() const {
    std::stringstream ss;
    if (HasDate()) {
      ss << boost::gregorian::to_iso_extended_string(date_);
    }
    if (HasTime()) {
      if (HasDate()) ss << " ";
      ss << boost::posix_time::to_simple_string(time_);
    }
    return ss.str();
  }

  int Format(const DateTimeFormatContext& dt_ctx, int len, char* buff);

  time_t ToUnixTime() const {
    DCHECK(HasDate());
    const boost::posix_time::ptime temp(date_, time_);
    tm temp_tm = boost::posix_time::to_tm(temp);
    if (FLAGS_use_local_tz_for_unix_timestamp_conversions) {
      return mktime(&temp_tm);
    } else {
      return timegm(&temp_tm);
    }
  }

  double ToSubsecondUnixTime() const {
    double temp = ToUnixTime();
    if (LIKELY(HasTime())) {
      temp += time_.fractional_seconds() * ONE_BILLIONTH;
    }
    return temp;
  }

  void UtcToLocal();

  void set_date(const boost::gregorian::date d) { date_ = d; }
  void set_time(const boost::posix_time::time_duration t) { time_ = t; }
  const boost::gregorian::date& date() const { return date_; }
  const boost::posix_time::time_duration& time() const { return time_; }

  TimestampValue& operator=(const boost::posix_time::ptime& ptime) {
    date_ = ptime.date();
    time_ = ptime.time_of_day();
    return *this;
  }

  bool operator==(const TimestampValue& other) const {
    return date_ == other.date_ && time_ == other.time_;
  }

  bool operator!=(const TimestampValue& other) const { return !(*this == other); }

  bool operator<(const TimestampValue& other) const {
    return date_ < other.date_ || (date_ == other.date_ && time_ < other.time_);
  }

  bool operator<=(const TimestampValue& other) const {
    return *this < other || *this == other; }

  bool operator>(const TimestampValue& other) const {
    return date_ > other.date_ || (date_ == other.date_ && time_ > other.time_);
  }

  bool operator>=(const TimestampValue& other) const {
    return *this > other || *this == other;
  }

  static size_t Size() {
    return sizeof(boost::posix_time::time_duration) + sizeof(boost::gregorian::date);
  }

  inline uint32_t Hash(int seed = 0) const {
    uint32_t hash = HashUtil::Hash(&time_, sizeof(time_), seed);
    return HashUtil::Hash(&date_, sizeof(date_), hash);
  }

  static const char* LLVM_CLASS_NAME;

 private:
  friend class UnusedClass;

  static const double ONE_BILLIONTH;


  boost::posix_time::time_duration time_;

  boost::gregorian::date date_;

  boost::posix_time::ptime UnixTimeToPtime(time_t unix_time) const {
    tm temp_tm;
    if (FLAGS_use_local_tz_for_unix_timestamp_conversions) {
      if (UNLIKELY(localtime_r(&unix_time, &temp_tm) == NULL)) {
        return boost::posix_time::ptime(boost::posix_time::not_a_date_time);
      }
    } else {
      if (UNLIKELY(gmtime_r(&unix_time, &temp_tm) == NULL)) {
        return boost::posix_time::ptime(boost::posix_time::not_a_date_time);
      }
    }
    try {
      return boost::posix_time::ptime_from_tm(temp_tm);
    } catch (std::exception& e) {
      return boost::posix_time::ptime(boost::posix_time::not_a_date_time);
    }
  }
};

inline std::size_t hash_value(const TimestampValue& v) {
  return v.Hash();
}

std::ostream& operator<<(std::ostream& os, const TimestampValue& timestamp_value);
}

#endif