WIP: [Issue-36] Add DateTime64 data type.

.gitignore

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

clickhouse/columns/date.cpp

@@ -113,4 +113,69 @@ ItemView ColumnDateTime::GetItem(size_t index) const {
     return data_->GetItem(index);
 }
 
+
+ColumnDateTime64::ColumnDateTime64()
+    : Column(Type::CreateDateTime64(3ul))
+    , data_(std::make_shared<ColumnDecimal>(18ul, 3ul))
+{}
+
+ColumnDateTime64::ColumnDateTime64(size_t precision)
+    : Column(Type::CreateDateTime64(precision))
+    , data_(std::make_shared<ColumnDecimal>(18ul, precision))
+{}
+
+
+void ColumnDateTime64::Append(const Int128& value) {
+    data_->Append(value);
+}
+
+void ColumnDateTime64::Append(const std::string& value) {
+    data_->Append(value);
+}
+
+
+Int128 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);
+    data_.swap(col.data_);
+}
+
+ColumnRef ColumnDateTime64::Slice(size_t begin, size_t len) {
+    auto col = data_->Slice(begin, len)->As<ColumnDecimal>();
+    size_t precision = col->Type()->As<DateTime64Type>()->GetPrecision();
+    auto result = std::make_shared<ColumnDateTime64>(precision); // TODO FIXME
+
+    result->data_->Append(col);
+
+    return result;
+}
+
 }

clickhouse/columns/date.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "decimal.h"
 #include "numeric.h"
 
 #include <ctime>
@@ -82,4 +83,44 @@ class ColumnDateTime : public Column {
     std::shared_ptr<ColumnUInt32> data_;
 };
 
+
+/** */
+class ColumnDateTime64 : public Column {
+public:
+    ColumnDateTime64();
+    ColumnDateTime64(size_t);
+
+    /// Appends one element to the end of column.
+    void Append(const Int128& value);
+    void Append(const std::string& value);
+
+    /// Returns element at given row number.
+    Int128 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;
+private:
+    std::shared_ptr<ColumnDecimal> 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/types/type_parser.cpp

@@ -30,6 +30,7 @@ static const std::unordered_map<std::string, Type::Code> kTypeCode = {
     { "String",      Type::String },
     { "FixedString", Type::FixedString },
     { "DateTime",    Type::DateTime },
+    { "DateTime64",  Type::DateTime64 },
     { "Date",        Type::Date },
     { "Array",       Type::Array },
     { "Nullable",    Type::Nullable },

clickhouse/types/types.cpp

@@ -45,6 +45,8 @@ std::string Type::GetName() const {
             return "IPv6";
         case DateTime:
             return "DateTime";
+        case DateTime64:
+            return As<DateTime64Type>()->GetName();
         case Date:
             return "Date";
         case Array:
@@ -81,6 +83,10 @@ TypeRef Type::CreateDateTime() {
     return TypeRef(new Type(Type::DateTime));
 }
 
+TypeRef Type::CreateDateTime64(size_t precision) {
+    return TypeRef(new DateTime64Type(precision));
+}
+
 TypeRef Type::CreateDecimal(size_t precision, size_t scale) {
     return TypeRef(new DecimalType(precision, scale));
 }
@@ -219,6 +225,19 @@ EnumType::ValueToNameIterator EnumType::EndValueToName() const {
     return value_to_name_.end();
 }
 
+/// class DateTime64Type
+
+DateTime64Type::DateTime64Type(size_t precision) : Type(DateTime64), precision_(precision) {}
+
+std::string DateTime64Type::GetName() const {
+    std::string datetime64_representation;
+    datetime64_representation.reserve(14);
+    datetime64_representation += "DateTime64(";
+    datetime64_representation += std::to_string(precision_);
+    datetime64_representation += ")";
+    return datetime64_representation;
+}
+
 /// class FixedStringType
 
 FixedStringType::FixedStringType(size_t n) : Type(FixedString), size_(n) {

clickhouse/types/types.h

@@ -26,6 +26,7 @@ class Type {
         String,
         FixedString,
         DateTime,
+        DateTime64,
         Date,
         Array,
         Nullable,
@@ -76,6 +77,8 @@ class Type {
 
     static TypeRef CreateDateTime();
 
+    static TypeRef CreateDateTime64(size_t precision);
+
     static TypeRef CreateDecimal(size_t precision, size_t scale);
 
     static TypeRef CreateIPv4();
@@ -144,6 +147,18 @@ class DecimalType : public Type {
     const size_t precision_, scale_;
 };
 
+class DateTime64Type: public Type {
+public:
+    DateTime64Type(size_t precision);
+
+    std::string GetName() const;
+
+    inline size_t GetPrecision() const { return precision_; }
+
+private:
+    size_t precision_;
+};
+
 class EnumType : public Type {
 public:
     EnumType(Type::Code type, const std::vector<EnumItem>& items);