Support Date32 data type.

Author: huyphams

clickhouse/columns/date.cpp

@@ -59,6 +59,63 @@ 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::Load(InputStream* input, size_t rows) {
+    return data_->Load(input, rows);
+}
+
+void ColumnDate32::Save(OutputStream* output) {
+    data_->Save(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<ColumnUInt16>();
+    auto result = std::make_shared<ColumnDate32>();
+
+    result->data_->Append(col);
+
+    return result;
+}
+
+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,49 @@ 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 Load(InputStream* input, size_t rows) override;
+
+    /// Saves column data to output stream.
+    void Save(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;
+
+    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

@@ -57,6 +57,8 @@ std::string Type::GetName() const {
             return As<DateTime64Type>()->GetName();
         case Date:
             return "Date";
+        case Date32:
+            return "Date32";
         case Array:
             return As<ArrayType>()->GetName();
         case Nullable:
@@ -101,6 +103,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_;
 
@@ -143,6 +146,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

@@ -34,6 +34,7 @@ class Type {
         FixedString,
         DateTime,
         Date,
+        Date32,
         Array,
         Nullable,
         Tuple,
@@ -88,6 +89,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());