Merge pull request #50 from Enmk/DateTime64

Add DateTime64 data type.

Author: traceon

.gitignore

@@ -274,3 +274,7 @@ BUCKAROO_DEPS
 
 # Visual Studio Code
 /.vscode/
+
+# Vim
+*.swp
+*.swo

README.md

@@ -7,7 +7,7 @@ C++ client for [Yandex ClickHouse](https://clickhouse.yandex/)
 
 * Array(T)
 * Date
-* DateTime
+* DateTime, DateTime64
 * Decimal32, Decimal64, Decimal128
 * Enum8, Enum16
 * FixedString(N)

clickhouse/columns/date.cpp

@@ -113,4 +113,73 @@ ItemView ColumnDateTime::GetItem(size_t index) const {
     return data_->GetItem(index);
 }
 
+ColumnDateTime64::ColumnDateTime64(size_t precision)
+    : ColumnDateTime64(Type::CreateDateTime64(precision), std::make_shared<ColumnDecimal>(18ul, precision))
+{}
+
+ColumnDateTime64::ColumnDateTime64(TypeRef type, std::shared_ptr<ColumnDecimal> data)
+    : Column(type),
+      data_(data),
+      precision_(type->As<DateTime64Type>()->GetPrecision())
+{}
+
+void ColumnDateTime64::Append(const Int64& value) {
+    // TODO: we need a type, which safely represents datetime.
+    // The precision of Poco.DateTime is not big enough.
+    data_->Append(value);
+}
+
+//void ColumnDateTime64::Append(const std::string& value) {
+//    data_->Append(value);
+//}
+
+Int64 ColumnDateTime64::At(size_t n) const {
+    return data_->At(n);
+}
+
+void ColumnDateTime64::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnDateTime64>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnDateTime64::Load(CodedInputStream* input, size_t rows) {
+    return data_->Load(input, rows);
+}
+
+void ColumnDateTime64::Save(CodedOutputStream* output) {
+    data_->Save(output);
+}
+
+void ColumnDateTime64::Clear() {
+    data_->Clear();
+}
+size_t ColumnDateTime64::Size() const {
+    return data_->Size();
+}
+
+ItemView ColumnDateTime64::GetItem(size_t index) const {
+    return data_->GetItem(index);
+}
+
+void ColumnDateTime64::Swap(Column& other) {
+    auto& col = dynamic_cast<ColumnDateTime64&>(other);
+    if (col.GetPrecision() != GetPrecision()) {
+        throw std::runtime_error("Can't swap DateTime64 columns when precisions are not the same: "
+                + std::to_string(GetPrecision()) + "(this) != " + std::to_string(col.GetPrecision()) + "(that)");
+    }
+
+    data_.swap(col.data_);
+}
+
+ColumnRef ColumnDateTime64::Slice(size_t begin, size_t len) {
+    auto sliced_data = data_->Slice(begin, len)->As<ColumnDecimal>();
+
+    return ColumnRef{new ColumnDateTime64(type_, sliced_data)};
+}
+
+size_t ColumnDateTime64::GetPrecision() const {
+    return precision_;
+}
+
 }

clickhouse/columns/date.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "decimal.h"
 #include "numeric.h"
 
 #include <ctime>
@@ -82,4 +83,52 @@ class ColumnDateTime : public Column {
     std::shared_ptr<ColumnUInt32> data_;
 };
 
+
+/** */
+class ColumnDateTime64 : public Column {
+public:
+    explicit ColumnDateTime64(size_t);
+
+    /// Appends one element to the end of column.
+    void Append(const Int64& value);
+    // It is a bit controversal: users might expect it to parse string of ISO8601 or some other human-friendly format,
+    // but current implemntation parses it as fractional integer with decimal point, e.g. "123.456".
+//    void Append(const std::string& value);
+
+    /// Returns element at given row number.
+    Int64 At(size_t n) const;
+
+public:
+    /// Appends content of given column to the end of current one.
+    void Append(ColumnRef column) override;
+
+    /// Loads column data from input stream.
+    bool Load(CodedInputStream* input, size_t rows) override;
+
+    /// Clear column data .
+    void Clear() override;
+
+    /// Saves column data to output stream.
+    void Save(CodedOutputStream* 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) override;
+
+    void Swap(Column& other) override;
+
+    ItemView GetItem(size_t index) const override;
+
+    size_t GetPrecision() const;
+
+private:
+    ColumnDateTime64(TypeRef type, std::shared_ptr<ColumnDecimal> data);
+
+private:
+    std::shared_ptr<ColumnDecimal> data_;
+    const size_t precision_;
+};
+
 }

clickhouse/columns/decimal.cpp

@@ -1,7 +1,5 @@
 #include "decimal.h"
 
-#include <iostream>
-
 namespace clickhouse {
 
 ColumnDecimal::ColumnDecimal(size_t precision, size_t scale)
@@ -16,8 +14,9 @@ ColumnDecimal::ColumnDecimal(size_t precision, size_t scale)
     }
 }
 
-ColumnDecimal::ColumnDecimal(TypeRef type)
-    : Column(type)
+ColumnDecimal::ColumnDecimal(TypeRef type, ColumnRef data)
+    : Column(type),
+      data_(data)
 {
 }
 
@@ -83,12 +82,15 @@ void ColumnDecimal::Append(const std::string& value) {
 }
 
 Int128 ColumnDecimal::At(size_t i) const {
-    if (data_->Type()->GetCode() == Type::Int32) {
-        return static_cast<Int128>(data_->As<ColumnInt32>()->At(i));
-    } else if (data_->Type()->GetCode() == Type::Int64) {
-        return static_cast<Int128>(data_->As<ColumnInt64>()->At(i));
-    } else {
-        return data_->As<ColumnInt128>()->At(i);
+    switch (data_->Type()->GetCode()) {
+        case Type::Int32:
+            return static_cast<Int128>(data_->As<ColumnInt32>()->At(i));
+        case Type::Int64:
+            return static_cast<Int128>(data_->As<ColumnInt64>()->At(i));
+        case Type::Int128:
+            return data_->As<ColumnInt128>()->At(i);
+        default:
+            throw std::runtime_error("Invalid data_ column type in ColumnDecimal");
     }
 }
 
@@ -115,9 +117,8 @@ size_t ColumnDecimal::Size() const {
 }
 
 ColumnRef ColumnDecimal::Slice(size_t begin, size_t len) {
-    std::shared_ptr<ColumnDecimal> slice(new ColumnDecimal(type_));
-    slice->data_ = data_->Slice(begin, len);
-    return slice;
+    // coundn't use std::make_shared since this c-tor is private
+    return ColumnRef{new ColumnDecimal(type_, data_->Slice(begin, len))};
 }
 
 void ColumnDecimal::Swap(Column& other) {
@@ -129,4 +130,14 @@ ItemView ColumnDecimal::GetItem(size_t index) const {
     return data_->GetItem(index);
 }
 
+size_t ColumnDecimal::GetScale() const
+{
+    return type_->As<DecimalType>()->GetScale();
+}
+
+size_t ColumnDecimal::GetPrecision() const
+{
+    return type_->As<DecimalType>()->GetPrecision();
+}
+
 }

clickhouse/columns/decimal.h

@@ -27,14 +27,17 @@ class ColumnDecimal : public Column {
     void Swap(Column& other) override;
     ItemView GetItem(size_t index) const override;
 
+    size_t GetScale() const;
+    size_t GetPrecision() const;
+
 private:
     /// Depending on a precision it can be one of:
     ///  - ColumnInt32
     ///  - ColumnInt64
     ///  - ColumnInt128
     ColumnRef data_;
 
-    explicit ColumnDecimal(TypeRef type); // for `Slice(…)`
+    explicit ColumnDecimal(TypeRef type, ColumnRef data);
 };
 
 }

clickhouse/columns/factory.cpp

@@ -65,6 +65,8 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
 
     case Type::DateTime:
         return std::make_shared<ColumnDateTime>();
+    case Type::DateTime64:
+        return std::make_shared<ColumnDateTime64>(ast.elements.front().value);
     case Type::Date:
         return std::make_shared<ColumnDate>();
 

clickhouse/columns/itemview.cpp

@@ -20,6 +20,7 @@ void ItemView::ValidateData(Type::Code type, DataType data) {
         ANY, /*String*/
         ANY, /*FixedString*/
         4,   /*DateTime*/
+        8,   /*DateTime64*/
         2,   /*Date*/
         ERR, /*Array*/
         ERR, /*Nullable*/

clickhouse/columns/numeric.cpp

@@ -10,12 +10,19 @@ ColumnVector<T>::ColumnVector()
 }
 
 template <typename T>
-ColumnVector<T>::ColumnVector(const std::vector<T>& data)
+ColumnVector<T>::ColumnVector(const std::vector<T> & data)
     : Column(Type::CreateSimple<T>())
     , data_(data)
 {
 }
 
+template <typename T>
+ColumnVector<T>::ColumnVector(std::vector<T> && data)
+    : Column(Type::CreateSimple<T>())
+    , data_(std::move(data))
+{
+}
+
 template <typename T>
 void ColumnVector<T>::Append(const T& value) {
     data_.push_back(value);

clickhouse/columns/numeric.h

@@ -15,6 +15,7 @@ class ColumnVector : public Column {
     ColumnVector();
 
     explicit ColumnVector(const std::vector<T>& data);
+    explicit ColumnVector(std::vector<T> && data);
 
     /// Appends one element to the end of column.
     void Append(const T& value);
@@ -54,6 +55,7 @@ class ColumnVector : public Column {
 };
 
 using Int128 = __int128;
+using Int64 = int64_t;
 
 using ColumnUInt8   = ColumnVector<uint8_t>;
 using ColumnUInt16  = ColumnVector<uint16_t>;