Add support for Time/Time64 columns

Author: slabko

clickhouse/CMakeLists.txt

@@ -21,6 +21,7 @@ SET ( clickhouse-cpp-lib-src
     columns/numeric.cpp
     columns/map.cpp
     columns/string.cpp
+    columns/time.cpp
     columns/tuple.cpp
     columns/uuid.cpp
 

clickhouse/client.h

@@ -17,6 +17,7 @@
 #include "columns/map.h"
 #include "columns/string.h"
 #include "columns/tuple.h"
+#include "columns/time.h"
 #include "columns/uuid.h"
 
 #include <chrono>

clickhouse/columns/factory.cpp

@@ -14,6 +14,7 @@
 #include "nullable.h"
 #include "numeric.h"
 #include "string.h"
+#include "./time.h" // `./` avoids possible conflicts with standard C time.h
 #include "tuple.h"
 #include "uuid.h"
 
@@ -108,7 +109,14 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
         return std::make_shared<ColumnDate>();
     case Type::Date32:
         return std::make_shared<ColumnDate32>();
-
+    case Type::Time:
+        return std::make_shared<ColumnTime>();
+    case Type::Time64:
+        if (ast.elements.empty()) {
+            throw AssertionError("Time64 type without precision");
+        } else {
+            return std::make_shared<ColumnTime64>(GetASTChildElement(ast, 0).value);
+        }
     case Type::IPv4:
         return std::make_shared<ColumnIPv4>();
     case Type::IPv6:

clickhouse/columns/itemview.cpp

@@ -59,13 +59,15 @@ void ItemView::ValidateData(Type::Code type, DataType data) {
         case Type::Code::Date32:
         case Type::Code::IPv4:
         case Type::Code::Decimal32:
+        case Type::Code::Time:
             return AssertSize({4});
 
         case Type::Code::Int64:
         case Type::Code::UInt64:
         case Type::Code::Float64:
         case Type::Code::DateTime64:
         case Type::Code::Decimal64:
+        case Type::Code::Time64:
             return AssertSize({8});
 
         case Type::Code::String:

clickhouse/columns/time.cpp

@@ -0,0 +1,139 @@
+#include "time.h"
+
+namespace clickhouse {
+
+ColumnTime::ColumnTime() 
+    : ColumnTime(Type::CreateTime(), std::make_shared<ColumnInt32>()) {}
+
+ColumnTime::ColumnTime(std::vector<int32_t>&& data)
+    : ColumnTime(Type::CreateTime(), std::make_shared<ColumnInt32>(std::move(data))) {}
+
+ColumnTime::ColumnTime(TypeRef type, std::shared_ptr<ColumnInt32> data)
+    : Column(std::move(type)),
+      data_(std::move(data))
+{}
+
+void ColumnTime::Append(ValueType value) {
+    data_->Append(value);
+}
+
+ColumnTime::ValueType ColumnTime::At(size_t n) const {
+    return data_->At(n);
+}
+
+void ColumnTime::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+void ColumnTime::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnTime>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnTime::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnTime::Clear() {
+    data_->Clear();
+}
+
+void ColumnTime::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+size_t ColumnTime::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnTime::Slice(size_t begin, size_t len) const {
+    auto sliced_data = data_->Slice(begin, len)->As<ColumnInt32>();
+    return ColumnRef{new ColumnTime(type_, sliced_data)};
+}
+
+ColumnRef ColumnTime::CloneEmpty() const {
+    return ColumnRef{new ColumnTime(type_, data_->CloneEmpty()->As<ColumnInt32>())};
+}
+
+void ColumnTime::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnTime &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnTime::GetItem(size_t index) const {
+    return ItemView{Type::Time, data_->GetItem(index)};
+}
+
+ColumnTime64::ColumnTime64(size_t precision) 
+    : ColumnTime64(Type::CreateTime64(precision), std::make_shared<ColumnInt64>())
+{}
+
+ColumnTime64::ColumnTime64(size_t precision, std::vector<int64_t>&& data)
+    : ColumnTime64(Type::CreateTime64(precision), std::make_shared<ColumnInt64>(std::move(data)))
+{}
+
+ColumnTime64::ColumnTime64(TypeRef type, std::shared_ptr<ColumnInt64> data)
+    : Column(std::move(type)),
+      data_(std::move(data)),
+      precision_{type_->As<Time64Type>()->GetPrecision()}
+{}
+
+void ColumnTime64::Append(ValueType value) {
+    data_->Append(value);
+}
+
+ColumnTime64::ValueType ColumnTime64::At(size_t n) const {
+    return data_->At(n);
+}
+
+void ColumnTime64::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+void ColumnTime64::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnTime64>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnTime64::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnTime64::Clear() {
+    data_->Clear();
+}
+
+void ColumnTime64::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+size_t ColumnTime64::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnTime64::Slice(size_t begin, size_t len) const {
+    auto sliced_data = data_->Slice(begin, len)->As<ColumnInt64>();
+    return ColumnRef{new ColumnTime64(type_, sliced_data)};
+}
+
+ColumnRef ColumnTime64::CloneEmpty() const {
+    return ColumnRef{new ColumnTime64(type_, data_->CloneEmpty()->As<ColumnInt64>())};
+}
+
+void ColumnTime64::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnTime64 &>(other);
+    if (col.GetPrecision() != GetPrecision()) {
+        throw ValidationError("Can't swap Time64 columns when precisions are not the same: "
+            + std::to_string(GetPrecision()) + "(this) != "
+            + std::to_string(col.GetPrecision()) + "(that)");
+    }
+    data_.swap(col.data_);
+}
+
+ItemView ColumnTime64::GetItem(size_t index) const {
+    return ItemView{Type::Time64, data_->GetItem(index)};
+}
+
+}  // namespace clickhouse

clickhouse/columns/time.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "column.h"
+#include "numeric.h"
+
+namespace clickhouse {
+
+class ColumnTime : public Column {
+public:
+    using ValueType = int32_t;
+
+    ColumnTime();
+    explicit ColumnTime(std::vector<int32_t>&& data);
+
+    /// Appends one element to the end of column.
+    void Append(ValueType value);
+
+    /// Returns element at given row number.
+    ValueType At(size_t n) const;
+
+    ValueType operator[](size_t n) const { return At(n); }
+
+public:
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Appends content of given column to the end of current one.
+    void Append(ColumnRef column) override;
+
+    /// Loads column data from input stream.
+    bool LoadBody(InputStream* input, size_t rows) override;
+
+    /// Clear column data .
+    void Clear() override;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) override;
+
+    /// Returns count of rows in the column.
+    size_t Size() const override;
+
+    /// Makes slice of the current column.
+    ColumnRef Slice(size_t begin, size_t len) const override;
+    ColumnRef CloneEmpty() const override;
+    void Swap(Column& other) override;
+
+    ItemView GetItem(size_t index) const override;
+
+private:
+    ColumnTime(TypeRef type, std::shared_ptr<ColumnInt32> data);
+
+private:
+    std::shared_ptr<ColumnInt32> data_;
+};
+
+class ColumnTime64 : public Column {
+public:
+    using ValueType = int64_t;
+
+    explicit ColumnTime64(size_t precision);
+    ColumnTime64(size_t precision, std::vector<int64_t>&& data);
+
+    /// Appends one element to the end of column.
+    void Append(ValueType value);
+
+    /// Returns element at given row number.
+    ValueType At(size_t n) const;
+
+    ValueType operator[](size_t n) const { return At(n); }
+
+public:
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Appends content of given column to the end of current one.
+    void Append(ColumnRef column) override;
+
+    /// Loads column data from input stream.
+    bool LoadBody(InputStream* input, size_t rows) override;
+
+    /// Clear column data .
+    void Clear() override;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) override;
+
+    /// Returns count of rows in the column.
+    size_t Size() const override;
+
+    /// Makes slice of the current column.
+    ColumnRef Slice(size_t begin, size_t len) const override;
+    ColumnRef CloneEmpty() const override;
+    void Swap(Column& other) override;
+
+    ItemView GetItem(size_t index) const override;
+
+    size_t GetPrecision() const { return precision_; };
+
+private:
+    ColumnTime64(TypeRef type, std::shared_ptr<ColumnInt64> data);
+
+private:
+    std::shared_ptr<ColumnInt64> data_;
+    const size_t precision_;
+};
+
+}

clickhouse/types/type_parser.cpp

@@ -65,6 +65,8 @@ static const std::unordered_map<std::string, Type::Code> kTypeCode = {
     { "Ring",        Type::Ring },
     { "Polygon",     Type::Polygon },
     { "MultiPolygon", Type::MultiPolygon },
+    { "Time",        Type::Time },
+    { "Time64",      Type::Time64 },
 };
 
 template <typename L, typename R>

clickhouse/types/types.cpp

@@ -52,6 +52,8 @@ const char* Type::TypeName(Type::Code code) {
         case Type::Code::Ring:           return "Ring";
         case Type::Code::Polygon:        return "Polygon";
         case Type::Code::MultiPolygon:   return "MultiPolygon";
+        case Type::Code::Time:           return "Time";
+        case Type::Code::Time64:         return "Time64";
     }
 
     return "Unknown type";
@@ -78,11 +80,14 @@ std::string Type::GetName() const {
         case IPv6:
         case Date:
         case Date32:
+        case Time:
         case Point:
         case Ring:
         case Polygon:
         case MultiPolygon:
             return TypeName(code_);
+        case Time64:
+            return As<Time64Type>()->GetName();
         case FixedString:
             return As<FixedStringType>()->GetName();
         case DateTime:
@@ -145,6 +150,8 @@ uint64_t Type::GetTypeUniqueId() const {
             return code_;
 
         case FixedString:
+        case Time:
+        case Time64:
         case DateTime:
         case DateTime64:
         case Array:
@@ -188,6 +195,14 @@ TypeRef Type::CreateDate32() {
     return TypeRef(new Type(Type::Date32));
 }
 
+TypeRef Type::CreateTime() {
+    return TypeRef(new Type(Type::Time));
+}
+
+TypeRef Type::CreateTime64(size_t precision) {
+    return TypeRef(new Time64Type(precision));
+}
+
 TypeRef Type::CreateDateTime(std::string timezone) {
     return TypeRef(new DateTimeType(std::move(timezone)));
 }
@@ -366,6 +381,18 @@ const std::string & TypeWithTimeZoneMixin::Timezone() const {
 }
 }
 
+/// class Time64
+Time64Type::Time64Type(size_t precision)
+    : Type(Time64), precision_{precision} {
+    if (precision_ > 9) {
+        throw ValidationError("Time64 precision is > 9");
+    }
+}
+
+std::string Time64Type::GetName() const {
+    return "Time64(" + std::to_string(precision_) + ")";
+}
+
 /// class DateTimeType
 DateTimeType::DateTimeType(std::string timezone)
     : Type(DateTime), details::TypeWithTimeZoneMixin(std::move(timezone)) {