clickhouse-native 0.0.1

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/decimal.cpp

@@ -0,0 +1,255 @@
+#include "decimal.h"
+
+namespace
+{
+using namespace clickhouse;
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+template <typename T>
+inline bool addOverflow(const Int128 & l, const T & r, Int128 * result)
+{
+    __int128 res;
+    const auto ret_value = __builtin_add_overflow(static_cast<__int128>(l), static_cast<__int128>(r), &res);
+
+    *result = res;
+    return ret_value;
+}
+
+template <typename T>
+inline bool mulOverflow(const Int128 & l, const T & r, Int128 * result)
+{
+    __int128 res;
+    const auto ret_value = __builtin_mul_overflow(static_cast<__int128>(l), static_cast<__int128>(r), &res);
+
+    *result = res;
+    return ret_value;
+}
+
+#else
+template <typename T>
+inline bool getSignBit(const T & v)
+{
+    return v < static_cast<T>(0);
+}
+
+inline bool getSignBit(const Int128 & v)
+{
+//    static constexpr Int128 zero {};
+//    return v < zero;
+
+    // Sign of the whole absl::int128 value is determined by sign of higher 64 bits.
+    return absl::Int128High64(v) < 0;
+}
+
+inline bool addOverflow(const Int128 & l, const Int128 & r, Int128 * result)
+{
+    //    *result = l + r;
+    //    const auto result_sign = getSignBit(*result);
+    //    return l_sign == r_sign && l_sign != result_sign;
+
+    // Based on code from:
+    // https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow#INT32C.Ensurethatoperationsonsignedintegersdonotresultinoverflow-CompliantSolution
+    const auto r_positive = !getSignBit(r);
+
+    if ((r_positive && (l > (std::numeric_limits<Int128>::max() - r))) ||
+        (!r_positive && (l < (std::numeric_limits<Int128>::min() - r)))) {
+        return true;
+    }
+    *result = l + r;
+
+    return false;
+}
+
+template <typename T>
+inline bool mulOverflow(const Int128 & l, const T & r, Int128 * result)
+{
+    // Based on code from:
+    // https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow#INT32C.Ensurethatoperationsonsignedintegersdonotresultinoverflow-CompliantSolution.3
+    const auto l_positive = !getSignBit(l);
+    const auto r_positive = !getSignBit(r);
+
+    if (l_positive) {
+        if (r_positive) {
+            if (r != 0 && l > (std::numeric_limits<Int128>::max() / r)) {
+                return true;
+            }
+        } else {
+            if (l != 0 && r < (std::numeric_limits<Int128>::min() / l)) {
+                return true;
+            }
+        }
+    } else {
+        if (r_positive) {
+            if (r != 0 && l < (std::numeric_limits<Int128>::min() / r)) {
+                return true;
+            }
+        } else {
+            if (l != 0 && (r < (std::numeric_limits<Int128>::max() / l))) {
+                return true;
+            }
+        }
+    }
+
+    *result = l * r;
+    return false;
+}
+#endif
+
+}
+
+namespace clickhouse {
+
+ColumnDecimal::ColumnDecimal(size_t precision, size_t scale)
+    : Column(Type::CreateDecimal(precision, scale))
+{
+    if (precision <= 9) {
+        data_ = std::make_shared<ColumnInt32>();
+    } else if (precision <= 18) {
+        data_ = std::make_shared<ColumnInt64>();
+    } else {
+        data_ = std::make_shared<ColumnInt128>();
+    }
+    data_type_code_ = data_->Type()->GetCode();
+}
+
+ColumnDecimal::ColumnDecimal(TypeRef type, ColumnRef data)
+    : Column(type),
+      data_(data),
+      data_type_code_(data_->Type()->GetCode())
+{
+}
+
+void ColumnDecimal::Append(const Int128& value) {
+    switch (data_type_code_) {
+        case Type::Int32:
+            static_cast<ColumnInt32*>(data_.get())->Append(static_cast<int32_t>(value));
+            break;
+        case Type::Int64:
+            static_cast<ColumnInt64*>(data_.get())->Append(static_cast<int64_t>(value));
+            break;
+        default:
+            static_cast<ColumnInt128*>(data_.get())->Append(static_cast<Int128>(value));
+            break;
+    }
+}
+
+void ColumnDecimal::Append(const std::string& value) {
+    Int128 int_value = 0;
+    auto c = value.begin();
+    auto end = value.end();
+    bool sign = true;
+    bool has_dot = false;
+
+    size_t zeros = 0;
+
+    while (c != end) {
+        if (*c == '-') {
+            sign = false;
+            if (c != value.begin()) {
+                break;
+            }
+        } else if (*c == '.' && !has_dot) {
+            size_t distance = std::distance(c, end) - 1;
+            auto scale = type_->As<DecimalType>()->GetScale();
+
+            if (distance <= scale) {
+                zeros = scale - distance;
+            } else {
+                std::advance(end, scale - distance);
+            }
+
+            has_dot = true;
+        } else if (*c >= '0' && *c <= '9') {
+            if (mulOverflow(int_value, 10, &int_value) ||
+                addOverflow(int_value, *c - '0', &int_value)) {
+                throw AssertionError("value is too big for 128-bit integer");
+            }
+        } else {
+            throw ValidationError(std::string("unexpected symbol '") + (*c) + "' in decimal value");
+        }
+        ++c;
+    }
+
+    if (c != end) {
+        throw ValidationError("unexpected symbol '-' in decimal value");
+    }
+
+    while (zeros) {
+        if (mulOverflow(int_value, 10, &int_value)) {
+            throw AssertionError("value is too big for 128-bit integer");
+        }
+        --zeros;
+    }
+
+    Append(sign ? int_value : -int_value);
+}
+
+Int128 ColumnDecimal::At(size_t i) const {
+    switch (data_type_code_) {
+        case Type::Int32:
+            return static_cast<Int128>(static_cast<const ColumnInt32*>(data_.get())->At(i));
+        case Type::Int64:
+            return static_cast<Int128>(static_cast<const ColumnInt64*>(data_.get())->At(i));
+        case Type::Int128:
+            return static_cast<const ColumnInt128*>(data_.get())->At(i);
+        default:
+            throw ValidationError("Invalid data_ column type in ColumnDecimal");
+    }
+}
+
+void ColumnDecimal::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+void ColumnDecimal::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnDecimal>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnDecimal::LoadBody(InputStream * input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnDecimal::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+void ColumnDecimal::Clear() {
+    data_->Clear();
+}
+
+size_t ColumnDecimal::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnDecimal::Slice(size_t begin, size_t len) const {
+    // coundn't use std::make_shared since this c-tor is private
+    return ColumnRef{new ColumnDecimal(type_, data_->Slice(begin, len))};
+}
+
+ColumnRef ColumnDecimal::CloneEmpty() const {
+    // coundn't use std::make_shared since this c-tor is private
+    return ColumnRef{new ColumnDecimal(type_, data_->CloneEmpty())};
+}
+
+void ColumnDecimal::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnDecimal &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnDecimal::GetItem(size_t index) const {
+    return ItemView{GetType().GetCode(), data_->GetItem(index)};
+}
+
+size_t ColumnDecimal::GetScale() const
+{
+    return type_->As<DecimalType>()->GetScale();
+}
+
+size_t ColumnDecimal::GetPrecision() const
+{
+    return type_->As<DecimalType>()->GetPrecision();
+}
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/decimal.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "column.h"
+#include "numeric.h"
+
+namespace clickhouse {
+
+/**
+ * Represents a column of decimal type.
+ */
+class ColumnDecimal : public Column {
+public:
+    using ValueType = Int128;
+
+    ColumnDecimal(size_t precision, size_t scale);
+
+    void Append(const Int128& value);
+    void Append(const std::string& value);
+
+    Int128 At(size_t i) const;
+    inline auto operator[](size_t i) const { return At(i); }
+
+public:
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+    void Append(ColumnRef column) override;
+    bool LoadBody(InputStream* input, size_t rows) override;
+    void SaveBody(OutputStream* output) override;
+    void Clear() override;
+    size_t Size() const override;
+    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;
+
+    size_t GetScale() const;
+    size_t GetPrecision() const;
+
+private:
+    /// Depending on a precision it can be one of:
+    ///  - ColumnInt32
+    ///  - ColumnInt64
+    ///  - ColumnInt128
+    ColumnRef data_;
+    Type::Code data_type_code_;
+
+    explicit ColumnDecimal(TypeRef type, ColumnRef data);
+};
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/enum.cpp

@@ -0,0 +1,123 @@
+#include "enum.h"
+#include "utils.h"
+
+#include "../base/input.h"
+#include "../base/output.h"
+#include "../base/wire_format.h"
+
+namespace clickhouse {
+
+template <typename T>
+ColumnEnum<T>::ColumnEnum(TypeRef type)
+    : Column(type)
+{
+}
+
+template <typename T>
+ColumnEnum<T>::ColumnEnum(TypeRef type, const std::vector<T>& data)
+    : Column(type)
+    , data_(data)
+{
+}
+
+template <typename T>
+ColumnEnum<T>::ColumnEnum(TypeRef type, std::vector<T>&& data)
+    : Column(type)
+    , data_(std::move(data))
+{
+}
+
+template <typename T>
+void ColumnEnum<T>::Append(const T& value, bool checkValue) {
+    if  (checkValue) {
+        // TODO: type_->HasEnumValue(value), "Enum type doesn't have value " + std::to_string(value);
+    }
+    data_.push_back(value);
+}
+
+template <typename T>
+void ColumnEnum<T>::Append(const std::string& name) {
+    data_.push_back(static_cast<T>(type_->As<EnumType>()->GetEnumValue(name)));
+}
+
+template <typename T>
+void ColumnEnum<T>::Clear() {
+    data_.clear();
+}
+
+template <typename T>
+const T& ColumnEnum<T>::At(size_t n) const {
+    return data_.at(n);
+}
+
+template <typename T>
+std::string_view ColumnEnum<T>::NameAt(size_t n) const {
+    return type_->As<EnumType>()->GetEnumName(data_.at(n));
+}
+
+template <typename T>
+void ColumnEnum<T>::SetAt(size_t n, const T& value, bool checkValue) {
+    if (checkValue) {
+        // TODO: type_->HasEnumValue(value), "Enum type doesn't have value " + std::to_string(value);
+    }
+    data_.at(n) = value;
+}
+
+template <typename T>
+void ColumnEnum<T>::SetNameAt(size_t n, const std::string& name) {
+    data_.at(n) = static_cast<T>(type_->As<EnumType>()->GetEnumValue(name));
+}
+
+template<typename T>
+void ColumnEnum<T>::Reserve(size_t new_cap) {
+    data_.reserve(new_cap);
+}
+
+template <typename T>
+void ColumnEnum<T>::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnEnum<T>>()) {
+        data_.insert(data_.end(), col->data_.begin(), col->data_.end());
+    }
+}
+
+template <typename T>
+bool ColumnEnum<T>::LoadBody(InputStream* input, size_t rows) {
+    data_.resize(rows);
+    return WireFormat::ReadBytes(*input, data_.data(), data_.size() * sizeof(T));
+}
+
+template <typename T>
+void ColumnEnum<T>::SaveBody(OutputStream* output) {
+    WireFormat::WriteBytes(*output, data_.data(), data_.size() * sizeof(T));
+}
+
+template <typename T>
+size_t ColumnEnum<T>::Size() const {
+    return data_.size();
+}
+
+template <typename T>
+ColumnRef ColumnEnum<T>::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnEnum<T>>(type_, SliceVector(data_, begin, len));
+}
+
+template <typename T>
+ColumnRef ColumnEnum<T>::CloneEmpty() const {
+    return std::make_shared<ColumnEnum<T>>(type_);
+}
+
+template <typename T>
+void ColumnEnum<T>::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnEnum<T> &>(other);
+    data_.swap(col.data_);
+}
+
+template <typename T>
+ItemView ColumnEnum<T>::GetItem(size_t index) const {
+    return ItemView{type_->GetCode(), data_[index]};
+}
+
+template class ColumnEnum<int8_t>;
+template class ColumnEnum<int16_t>;
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/enum.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "column.h"
+
+namespace clickhouse {
+
+
+template <typename T>
+class ColumnEnum : public Column {
+public:
+    using ValueType = T;
+
+    ColumnEnum(TypeRef type);
+    ColumnEnum(TypeRef type, const std::vector<T>& data);
+    ColumnEnum(TypeRef type, std::vector<T>&& data);
+
+    /// Appends one element to the end of column.
+    void Append(const T& value, bool checkValue = false);
+    void Append(const std::string& name);
+
+    /// Returns element at given row number.
+    const T& At(size_t n) const;
+    std::string_view NameAt(size_t n) const;
+
+    /// Returns element at given row number.
+    inline const T& operator[] (size_t n) const { return At(n); }
+
+    /// Set element at given row number.
+    void SetAt(size_t n, const T& value, bool checkValue = false);
+    void SetNameAt(size_t n, const std::string& name);
+
+public:
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// 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::vector<T> data_;
+};
+
+using ColumnEnum8 = ColumnEnum<int8_t>;
+using ColumnEnum16 = ColumnEnum<int16_t>;
+
+}