Merge pull request #175 from huyphams/support-date32

Support Date32 data type, tests will follow

Author: Enmk

clickhouse/columns/date.cpp

@@ -63,6 +63,66 @@ ItemView ColumnDate::GetItem(size_t index) const {
 
 
 
+ColumnDate32::ColumnDate32()
+    : Column(Type::CreateDate32())
+    , data_(std::make_shared<ColumnUInt32>())
+{
+}
+
+void ColumnDate32::Append(const std::time_t& value) {
+    /// TODO: This code is fundamentally wrong.
+    data_->Append(static_cast<uint16_t>(value / std::time_t(86400)));
+}
+
+void ColumnDate32::Clear() {
+    data_->Clear();
+}
+
+std::time_t ColumnDate32::At(size_t n) const {
+    return static_cast<std::time_t>(data_->At(n)) * 86400;
+}
+
+void ColumnDate32::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnDate32>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnDate32::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnDate32::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+size_t ColumnDate32::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnDate32::Slice(size_t begin, size_t len) const {
+    auto col = data_->Slice(begin, len)->As<ColumnUInt32>();
+    auto result = std::make_shared<ColumnDate32>();
+
+    result->data_->Append(col);
+
+    return result;
+}
+
+ColumnRef ColumnDate32::CloneEmpty() const {
+    return std::make_shared<ColumnDate32>();
+}
+
+void ColumnDate32::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnDate32 &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnDate32::GetItem(size_t index) const {
+    return data_->GetItem(index);
+}
+
+
 ColumnDateTime::ColumnDateTime()
     : Column(Type::CreateDateTime())
     , data_(std::make_shared<ColumnUInt32>())

clickhouse/columns/date.h

@@ -48,6 +48,48 @@ class ColumnDate : public Column {
     std::shared_ptr<ColumnUInt16> data_;
 };
 
+
+class ColumnDate32 : public Column {
+public:
+    using ValueType = std::time_t;
+
+    ColumnDate32();
+
+    /// Appends one element to the end of column.
+    /// TODO: The implementation is fundamentally wrong.
+    void Append(const std::time_t& value);
+
+    /// Returns element at given row number.
+    /// TODO: The implementation is fundamentally wrong.
+    std::time_t At(size_t n) const;
+
+    /// 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;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) override;
+
+    /// Clear column data .
+    void Clear() 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:
+    std::shared_ptr<ColumnUInt32> data_;
+};
+
+
 /** */
 class ColumnDateTime : public Column {
 public:

clickhouse/columns/factory.cpp

@@ -85,6 +85,8 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
         }
     case Type::Date:
         return std::make_shared<ColumnDate>();
+    case Type::Date32:
+        return std::make_shared<ColumnDate32>();    
 
     case Type::IPv4:
         return std::make_shared<ColumnIPv4>();

clickhouse/types/type_parser.cpp

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

clickhouse/types/types.cpp

@@ -45,6 +45,7 @@ const char* Type::TypeName(Type::Code code) {
         case Type::Code::Decimal128:     return "Decimal128";
         case Type::Code::LowCardinality: return "LowCardinality";
         case Type::Code::DateTime64:     return "DateTime64";
+        case Type::Code::Date32:         return "Date32";
     }
 
     return "Unknown type";
@@ -69,6 +70,7 @@ std::string Type::GetName() const {
         case IPv4:
         case IPv6:
         case Date:
+        case Date32:
             return TypeName(code_);
         case FixedString:
             return As<FixedStringType>()->GetName();
@@ -120,6 +122,7 @@ uint64_t Type::GetTypeUniqueId() const {
         case IPv4:
         case IPv6:
         case Date:
+        case Date32:
             // For simple types, unique ID is the same as Type::Code
             return code_;
 
@@ -162,6 +165,10 @@ TypeRef Type::CreateDate() {
     return TypeRef(new Type(Type::Date));
 }
 
+TypeRef Type::CreateDate32() {
+    return TypeRef(new Type(Type::Date32));
+}
+
 TypeRef Type::CreateDateTime(std::string timezone) {
     return TypeRef(new DateTimeType(std::move(timezone)));
 }

clickhouse/types/types.h

@@ -49,6 +49,7 @@ class Type {
         Decimal128,
         LowCardinality,
         DateTime64,
+        Date32,
     };
 
     using EnumItem = std::pair<std::string /* name */, int16_t /* value */>;
@@ -91,6 +92,8 @@ class Type {
 
     static TypeRef CreateDate();
 
+    static TypeRef CreateDate32();    
+
     static TypeRef CreateDateTime(std::string timezone = std::string());
 
     static TypeRef CreateDateTime64(size_t precision, std::string timezone = std::string());