Add support for Decimal column types

Author: abyss7

.clang-format

@@ -5,5 +5,7 @@ AccessModifierOffset: -4
 AlignConsecutiveAssignments: true
 AllowShortFunctionsOnASingleLine: InlineOnly
 ColumnLimit: 140
+DerivePointerAlignment: false
 FixNamespaceComments: true
-IndentWidth: 4
+IndentWidth: 4
+PointerAlignment: Left

clickhouse/CMakeLists.txt

@@ -8,6 +8,7 @@ ADD_LIBRARY (clickhouse-cpp-lib
 
     columns/array.cpp
     columns/date.cpp
+    columns/decimal.cpp
     columns/enum.cpp
     columns/factory.cpp
     columns/nullable.cpp

clickhouse/client.cpp

@@ -165,6 +165,8 @@ Client::Impl::Impl(const ClientOptions& opts)
     , buffered_output_(&socket_output_)
     , output_(&buffered_output_)
 {
+    // TODO: throw on big-endianness of platform
+
     for (int i = 0; ; ) {
         try {
             ResetConnection();

clickhouse/client.h

@@ -5,6 +5,7 @@
 
 #include "columns/array.h"
 #include "columns/date.h"
+#include "columns/decimal.h"
 #include "columns/enum.h"
 #include "columns/nullable.h"
 #include "columns/numeric.h"

clickhouse/columns/column.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "../base/input.h"
 #include "../base/coded.h"
+#include "../base/input.h"
 #include "../types/types.h"
 
 namespace clickhouse {
@@ -11,24 +11,19 @@ using ColumnRef = std::shared_ptr<class Column>;
 /**
  * An abstract base of all columns classes.
  */
-class Column : public std::enable_shared_from_this<Column>
-{
+class Column : public std::enable_shared_from_this<Column> {
 public:
-    explicit inline Column(TypeRef type)
-        : type_(type)
-    {
-    }
+    explicit inline Column(TypeRef type) : type_(type) {}
 
-    virtual ~Column()
-    { }
+    virtual ~Column() {}
 
-    /// Downcast pointer to the specific culumn's subtype.
+    /// Downcast pointer to the specific column's subtype.
     template <typename T>
     inline std::shared_ptr<T> As() {
         return std::dynamic_pointer_cast<T>(shared_from_this());
     }
 
-    /// Downcast pointer to the specific culumn's subtype.
+    /// Downcast pointer to the specific column's subtype.
     template <typename T>
     inline std::shared_ptr<const T> As() const {
         return std::dynamic_pointer_cast<const T>(shared_from_this());
@@ -45,7 +40,7 @@ class Column : public std::enable_shared_from_this<Column>
 
     /// Saves column data to output stream.
     virtual void Save(CodedOutputStream* output) = 0;
-    
+
     /// Clear column data .
     virtual void Clear() = 0;
 
@@ -59,4 +54,4 @@ class Column : public std::enable_shared_from_this<Column>
     TypeRef type_;
 };
 
-}
+}  // namespace clickhouse

clickhouse/columns/decimal.cpp

@@ -0,0 +1,74 @@
+#include "decimal.h"
+
+#include "numeric.h"
+
+namespace clickhouse {
+
+ColumnDecimal::ColumnDecimal(size_t precision, size_t scale) : Column(Type::CreateDecimal(precision, scale)) {
+    if (precision <= 9) {
+        data_ = ColumnRef(new ColumnInt32());
+    } else if (precision <= 18) {
+        data_ = ColumnRef(new ColumnInt64());
+    } else {
+        data_ = ColumnRef(new ColumnInt128());
+    }
+}
+
+void ColumnDecimal::Append(const Int128& value) {
+    if (data_->Type()->GetCode() == Type::Int32) {
+        data_->As<ColumnInt32>()->Append(static_cast<ColumnInt32::DataType>(value));
+    } else if (data_->Type()->GetCode() == Type::Int64) {
+        data_->As<ColumnInt64>()->Append(static_cast<ColumnInt64::DataType>(value));
+    } else {
+        data_->As<ColumnInt128>()->Append(static_cast<ColumnInt128::DataType>(value));
+    }
+}
+
+void ColumnDecimal::Append(const std::string &value) {
+    Int128 int_value = 0;
+    auto c = value.begin();
+    bool sign = true;
+
+    while (c != value.end()) {
+        if (*c == '-') {
+            sign = false;
+            if (c != value.begin()) {
+                break;
+            }
+        } else if (*c == '.') {
+            // TODO: compare distance with `scale`
+        } else if (*c >= '0' && *c <= '9') {
+            int_value = int_value * 10 + (*c - '0');
+        } else {
+            // TODO: throw exception on unexpected symbol
+        }
+        ++c;
+    }
+
+    if (c != value.end()) {
+        // TODO: throw exception about symbols after 'minus'
+    }
+
+    Append(sign ? int_value : -int_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);
+    }
+}
+
+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;
+}
+
+ColumnDecimal::ColumnDecimal(TypeRef type) : Column(type) {
+}
+
+} // namespace clickhouse

clickhouse/columns/decimal.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "column.h"
+
+namespace clickhouse {
+
+using Int128 = __int128;
+
+/**
+ * Represents a column of decimal type.
+ */
+
+class ColumnDecimal : public Column {
+public:
+    ColumnDecimal(size_t precision, size_t scale);
+
+    void Append(const Int128& value);
+    void Append(const std::string& value);
+
+    Int128 At(size_t i) const;
+
+public:
+    void Append(ColumnRef column) override { data_->Append(column); }
+    bool Load(CodedInputStream* input, size_t rows) override { return data_->Load(input, rows); }
+    void Save(CodedOutputStream* output) override { data_->Save(output); }
+    void Clear() override { data_->Clear(); }
+    size_t Size() const override { return data_->Size(); }
+    ColumnRef Slice(size_t begin, size_t len) override;
+
+private:
+    /// Depending on a precision it can be one of:
+    ///  - ColumnInt32
+    ///  - ColumnInt64
+    ///  - ColumnInt128
+    ColumnRef data_;
+
+    explicit ColumnDecimal(TypeRef type); // for `Slice(…)`
+};
+
+}  // namespace clickhouse

clickhouse/columns/factory.cpp

@@ -2,6 +2,7 @@
 
 #include "array.h"
 #include "date.h"
+#include "decimal.h"
 #include "enum.h"
 #include "nullable.h"
 #include "numeric.h"
@@ -52,6 +53,17 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
     case Type::Date:
         return std::make_shared<ColumnDate>();
 
+    case Type::Decimal32:
+        return std::make_shared<ColumnDecimal>(9, ast.elements.front().value);
+    case Type::Decimal64:
+        return std::make_shared<ColumnDecimal>(18, ast.elements.front().value);
+    case Type::Decimal128:
+        if (ast.elements.size() == 2) {
+            return std::make_shared<ColumnDecimal>(ast.elements.front().value, ast.elements.back().value);
+        } else if (ast.elements.size() == 1) {
+            return std::make_shared<ColumnDecimal>(38, ast.elements.front().value);
+        }
+
     default:
         return nullptr;
     }

clickhouse/columns/numeric.cpp

@@ -69,6 +69,7 @@ template class ColumnVector<int8_t>;
 template class ColumnVector<int16_t>;
 template class ColumnVector<int32_t>;
 template class ColumnVector<int64_t>;
+template class ColumnVector<__int128>;
 
 template class ColumnVector<uint8_t>;
 template class ColumnVector<uint16_t>;

clickhouse/columns/numeric.h

@@ -10,6 +10,8 @@ namespace clickhouse {
 template <typename T>
 class ColumnVector : public Column {
 public:
+    using DataType = T;
+
     ColumnVector();
 
     explicit ColumnVector(const std::vector<T>& data);
@@ -55,6 +57,7 @@ using ColumnInt8    = ColumnVector<int8_t>;
 using ColumnInt16   = ColumnVector<int16_t>;
 using ColumnInt32   = ColumnVector<int32_t>;
 using ColumnInt64   = ColumnVector<int64_t>;
+using ColumnInt128  = ColumnVector<__int128>;
 
 using ColumnFloat32 = ColumnVector<float>;
 using ColumnFloat64 = ColumnVector<double>;

clickhouse/types/type_parser.cpp

@@ -26,6 +26,10 @@ static const std::unordered_map<std::string, Type::Code> kTypeCode = {
     { "Enum8",       Type::Enum8 },
     { "Enum16",      Type::Enum16 },
     { "UUID",        Type::UUID },
+    { "Decimal32",   Type::Decimal32 },
+    { "Decimal64",   Type::Decimal64 },
+    { "Decimal128",  Type::Decimal128 },
+    { "Decimal",     Type::Decimal128 },
 };
 
 static Type::Code GetTypeCode(const std::string& name) {

clickhouse/types/type_parser.h

@@ -17,7 +17,7 @@ struct TypeAst {
         Number,
         Terminal,
         Tuple,
-        Enum
+        Enum,
     };
 
     /// Type's category.