interval.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/postgres/io/interval.hpp
/// @brief Time intervals I/O support
/// @ingroup userver_postgres_parse_and_format
 
#include <chrono>
 
#include <userver/storages/postgres/exceptions.hpp>
#include <userver/storages/postgres/io/buffer_io.hpp>
#include <userver/storages/postgres/io/buffer_io_base.hpp>
#include <userver/storages/postgres/io/integral_types.hpp>
#include <userver/storages/postgres/io/traits.hpp>
#include <userver/storages/postgres/io/type_mapping.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres::io {
 
namespace detail {
 
/// Internal structure for representing PostgreSQL interval type
struct Interval {
  using DurationType = std::chrono::microseconds;
 
  Integer months = 0;
  Integer days = 0;
  Bigint microseconds = 0;
 
  constexpr Interval() = default;
  constexpr Interval(Integer months, Integer days, Bigint microseconds)
      : months{months}, days{days}, microseconds{microseconds} {}
  constexpr explicit Interval(DurationType ms) : microseconds{ms.count()} {}
 
  constexpr bool operator==(const Interval& rhs) const {
    return months == rhs.months && days == rhs.days &&
           microseconds == rhs.microseconds;
  }
  constexpr bool operator!=(const Interval& rhs) const {
    return !(*this == rhs);
  }
 
  constexpr DurationType GetDuration() const {
    if (months != 0) throw UnsupportedInterval{};
    return std::chrono::duration_cast<DurationType>(
        std::chrono::microseconds{microseconds} +
        std::chrono::hours{days * 24});
  }
};
 
}  // namespace detail
 
template <>
struct BufferParser<detail::Interval>
    : detail::BufferParserBase<detail::Interval> {
  using BaseType = detail::BufferParserBase<detail::Interval>;
  using ValueType = typename BaseType::ValueType;
 
  using BaseType::BaseType;
 
  void operator()(const FieldBuffer& buffer) {
    ValueType tmp;
    std::size_t offset = 0;
    io::ReadBuffer(buffer.GetSubBuffer(offset, sizeof(Bigint),
                                       BufferCategory::kPlainBuffer),
                   tmp.microseconds);
    offset += sizeof(Bigint);
    io::ReadBuffer(buffer.GetSubBuffer(offset, sizeof(Integer),
                                       BufferCategory::kPlainBuffer),
                   tmp.days);
    offset += sizeof(Integer);
    io::ReadBuffer(buffer.GetSubBuffer(offset, sizeof(Integer),
                                       BufferCategory::kPlainBuffer),
                   tmp.months);
 
    std::swap(this->value, tmp);
  }
};
 
template <>
struct BufferFormatter<detail::Interval>
    : detail::BufferFormatterBase<detail::Interval> {
  using BaseType = detail::BufferFormatterBase<detail::Interval>;
 
  using BaseType::BaseType;
 
  template <typename Buffer>
  void operator()(const UserTypes& types, Buffer& buffer) const {
    io::WriteBuffer(types, buffer, this->value.microseconds);
    io::WriteBuffer(types, buffer, this->value.days);
    io::WriteBuffer(types, buffer, this->value.months);
  }
};
 
template <>
struct CppToSystemPg<detail::Interval>
    : PredefinedOid<PredefinedOids::kInterval> {};
 
}  // namespace storages::postgres::io
 
USERVER_NAMESPACE_END