clickhouse-native 0.0.1

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

@@ -0,0 +1,87 @@
+
+#pragma once
+
+#include "column.h"
+#include "../base/input.h"
+
+#include <stdexcept>
+#include <utility>
+
+namespace clickhouse {
+
+/**
+ * Represents dummy column of NULLs.
+ */
+class ColumnNothing : public Column {
+public:
+    ColumnNothing()
+        : Column(Type::CreateNothing())
+        , size_(0)
+    {
+    }
+
+    explicit ColumnNothing(size_t n)
+        : Column(Type::CreateNothing())
+        , size_(n)
+    {
+    }
+
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t) override {};
+
+    /// Appends one element to the column.
+    void Append(std::unique_ptr<void*>) { ++size_; }
+
+    /// Returns element at given row number.
+    std::nullptr_t At(size_t) const { return nullptr; };
+
+    /// Returns element at given row number.
+    inline std::nullptr_t operator [] (size_t) const { return nullptr; };
+
+    /// Makes slice of the current column.
+    ColumnRef Slice(size_t, size_t len) const override {
+        return std::make_shared<ColumnNothing>(len);
+    }
+
+    ColumnRef CloneEmpty() const override {
+        return std::make_shared<ColumnNothing>();
+    }
+
+    ItemView GetItem(size_t /*index*/) const override { return ItemView{}; }
+
+public:
+    /// Appends content of given column to the end of current one.
+    void Append(ColumnRef column) override {
+        if (auto col = column->As<ColumnNothing>()) {
+            size_ += col->Size();
+        }
+    }
+
+    /// Loads column data from input stream.
+    bool LoadBody(InputStream* input, size_t rows) override {
+        input->Skip(rows);
+        size_ += rows;
+        return true;
+    }
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream*) override {
+        throw UnimplementedError("method SaveBody is not supported for Nothing column");
+    }
+
+    /// Clear column data .
+    void Clear() override { size_ = 0; }
+
+    /// Returns count of rows in the column.
+    size_t Size() const override { return size_; }
+
+    void Swap(Column& other) override {
+        auto & col = dynamic_cast<ColumnNothing &>(other);
+        std::swap(size_, col.size_);
+    }
+
+private:
+    size_t size_;
+};
+
+}

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

@@ -0,0 +1,109 @@
+#include "nullable.h"
+
+#include <assert.h>
+#include <stdexcept>
+
+namespace clickhouse {
+
+ColumnNullable::ColumnNullable(ColumnRef nested, ColumnRef nulls)
+    : Column(Type::CreateNullable(nested->Type()))
+    , nested_(nested)
+    , nulls_(nulls->As<ColumnUInt8>())
+{
+    if (nested_->Size() != nulls->Size()) {
+        throw ValidationError("count of elements in nested and nulls should be the same");
+    }
+}
+
+void ColumnNullable::Append(bool isnull)
+{
+    nulls_->Append(isnull ? 1 : 0);
+}
+
+
+bool ColumnNullable::IsNull(size_t n) const {
+    return nulls_->At(n) != 0;
+}
+
+ColumnRef ColumnNullable::Nested() const {
+    return nested_;
+}
+
+ColumnRef ColumnNullable::Nulls() const
+{
+       return nulls_;
+}
+
+void ColumnNullable::Reserve(size_t new_cap) {
+    nested_->Reserve(new_cap);
+    nulls_->Reserve(new_cap);
+}
+
+void ColumnNullable::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnNullable>()) {
+        if (!col->nested_->Type()->IsEqual(nested_->Type())) {
+            return;
+        }
+
+        nested_->Append(col->nested_);
+        nulls_->Append(col->nulls_);
+    }
+}
+
+void ColumnNullable::Clear() {
+    nested_->Clear();
+    nulls_->Clear();
+}
+
+bool ColumnNullable::LoadPrefix(InputStream* input, size_t rows) {
+    return nested_->LoadPrefix(input, rows);
+}
+
+bool ColumnNullable::LoadBody(InputStream* input, size_t rows) {
+    if (!nulls_->LoadBody(input, rows)) {
+        return false;
+    }
+    if (!nested_->LoadBody(input, rows)) {
+        return false;
+    }
+    return true;
+}
+
+void ColumnNullable::SavePrefix(OutputStream* output) {
+    nested_->SavePrefix(output);
+}
+
+void ColumnNullable::SaveBody(OutputStream* output) {
+    nulls_->SaveBody(output);
+    nested_->SaveBody(output);
+}
+
+size_t ColumnNullable::Size() const {
+    return nulls_->Size();
+}
+
+ColumnRef ColumnNullable::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnNullable>(nested_->Slice(begin, len), nulls_->Slice(begin, len));
+}
+
+ColumnRef ColumnNullable::CloneEmpty() const {
+    return std::make_shared<ColumnNullable>(nested_->CloneEmpty(), nulls_->CloneEmpty());
+}
+
+void ColumnNullable::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnNullable &>(other);
+    if (!nested_->Type()->IsEqual(col.nested_->Type()))
+        throw ValidationError("Can't swap() Nullable columns of different types.");
+
+    nested_.swap(col.nested_);
+    nulls_.swap(col.nulls_);
+}
+
+ItemView ColumnNullable::GetItem(size_t index) const  {
+    if (IsNull(index))
+        return ItemView();
+
+    return nested_->GetItem(index);
+}
+
+}

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

@@ -0,0 +1,153 @@
+#pragma once
+
+#include "column.h"
+#include "numeric.h"
+
+#include <optional>
+
+namespace clickhouse {
+
+/**
+ * Represents column of Nullable(T).
+ */
+class ColumnNullable : public Column {
+public:
+    ColumnNullable(ColumnRef nested, ColumnRef nulls);
+
+    /// Appends one null flag to the end of the column
+    void Append(bool isnull);
+
+    /// Returns null flag at given row number.
+    bool IsNull(size_t n) const;
+
+    /// Returns nested column.
+    ColumnRef Nested() const;
+
+    /// Returns nulls column.
+    ColumnRef Nulls() const;
+
+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 prefix from input stream.
+    bool LoadPrefix(InputStream* input, size_t rows) override;
+
+    /// Loads column data from input stream.
+    bool LoadBody(InputStream* input, size_t rows) override;
+
+    /// Saves column prefix to output stream.
+    void SavePrefix(OutputStream* output) 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&) override;
+
+    ItemView GetItem(size_t) const override;
+
+private:
+    ColumnRef nested_;
+    std::shared_ptr<ColumnUInt8> nulls_;
+};
+
+template <typename ColumnType>
+class ColumnNullableT : public ColumnNullable {
+public:
+    using NestedColumnType = ColumnType;
+    using ValueType = std::optional<std::decay_t<decltype(std::declval<NestedColumnType>().At(0))>>;
+
+    ColumnNullableT(std::shared_ptr<NestedColumnType> data, std::shared_ptr<ColumnUInt8> nulls)
+        : ColumnNullable(data, nulls)
+        , typed_nested_data_(data)
+    {}
+
+    explicit ColumnNullableT(std::shared_ptr<NestedColumnType> data)
+        : ColumnNullableT(data, FillNulls(data->Size()))
+    {}
+
+    template <typename ...Args>
+    explicit ColumnNullableT(Args &&... args)
+        : ColumnNullableT(std::make_shared<NestedColumnType>(std::forward<Args>(args)...))
+    {}
+
+    inline ValueType At(size_t index) const {
+        return IsNull(index) ? ValueType{} : ValueType{typed_nested_data_->At(index)};
+    }
+
+    inline ValueType operator[](size_t index) const { return At(index); }
+
+    /// Appends content of given column to the end of current one.
+    void Append(ColumnRef column) override {
+        ColumnNullable::Append(std::move(column));
+    }
+
+    inline void Append(ValueType value) {
+        ColumnNullable::Append(!value.has_value());
+        if (value.has_value()) {
+            typed_nested_data_->Append(std::move(*value));
+        } else {
+            typed_nested_data_->Append(typename ValueType::value_type{});
+        }
+    }
+
+    /** Create a ColumnNullableT from a ColumnNullable, without copying data and offsets, but by
+     * 'stealing' those from `col`.
+     *
+     *  Ownership of column internals is transferred to returned object, original (argument) object
+     *  MUST NOT BE USED IN ANY WAY, it is only safe to dispose it.
+     *
+     *  Throws an exception if `col` is of wrong type, it is safe to use original col in this case.
+     *  This is a static method to make such conversion verbose.
+     */
+    static auto Wrap(ColumnNullable&& col) {
+        return std::make_shared<ColumnNullableT<NestedColumnType>>(
+            col.Nested()->AsStrict<NestedColumnType>(),
+            col.Nulls()->AsStrict<ColumnUInt8>()) ;
+    }
+
+    static auto Wrap(Column&& col) { return Wrap(std::move(dynamic_cast<ColumnNullable&&>(col))); }
+
+    // Helper to simplify integration with other APIs
+    static auto Wrap(ColumnRef&& col) { return Wrap(std::move(*col->AsStrict<ColumnNullable>())); }
+
+    ColumnRef Slice(size_t begin, size_t size) const override {
+        return Wrap(ColumnNullable::Slice(begin, size));
+    }
+
+    ColumnRef CloneEmpty() const override { return Wrap(ColumnNullable::CloneEmpty()); }
+
+    void Swap(Column& other) override {
+        auto& col = dynamic_cast<ColumnNullableT<NestedColumnType>&>(other);
+        typed_nested_data_.swap(col.typed_nested_data_);
+        ColumnNullable::Swap(other);
+    }
+
+private:
+    static inline auto FillNulls(size_t n){
+        auto result = std::make_shared<ColumnUInt8>();
+        for (size_t i = 0; i < n; ++i) {
+            result->Append(0);
+        }
+        return result;
+    }
+
+    std::shared_ptr<NestedColumnType> typed_nested_data_;
+};
+
+template <typename T>
+constexpr bool IsNullable = std::is_base_of_v<ColumnNullable, T>;
+
+}

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

@@ -0,0 +1,126 @@
+#include "numeric.h"
+#include "utils.h"
+
+#include "../base/wire_format.h"
+
+namespace clickhouse {
+
+template <typename T>
+ColumnVector<T>::ColumnVector()
+    : Column(Type::CreateSimple<T>())
+{
+}
+
+template <typename T>
+ColumnVector<T>::ColumnVector(const std::vector<T> & data)
+    : Column(Type::CreateSimple<T>())
+    , data_(data)
+{
+}
+
+template <typename T>
+ColumnVector<T>::ColumnVector(std::vector<T> && data)
+    : Column(Type::CreateSimple<T>())
+    , data_(std::move(data))
+{
+}
+
+template <typename T>
+void ColumnVector<T>::Append(const T& value) {
+    data_.push_back(value);
+}
+
+template <typename T>
+void ColumnVector<T>::Erase(size_t pos, size_t count) {
+    const auto begin = std::min(pos, data_.size());
+    const auto last = begin + std::min(data_.size() - begin, count);
+
+    data_.erase(data_.begin() + begin, data_.begin() + last);
+}
+
+template <typename T>
+std::vector<T>& ColumnVector<T>::GetWritableData() {
+    return data_;
+}
+
+template <typename T>
+void ColumnVector<T>::Reserve(size_t new_cap) {
+    data_.reserve(new_cap);
+}
+
+template <typename T>
+size_t ColumnVector<T>::Capacity() const {
+    return data_.capacity();
+}
+
+template <typename T>
+void ColumnVector<T>::Clear() {
+    data_.clear();
+}
+
+template <typename T>
+const T& ColumnVector<T>::At(size_t n) const {
+    return data_.at(n);
+}
+
+template <typename T>
+void ColumnVector<T>::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnVector<T>>()) {
+        data_.insert(data_.end(), col->data_.begin(), col->data_.end());
+    }
+}
+
+template <typename T>
+bool ColumnVector<T>::LoadBody(InputStream* input, size_t rows) {
+    data_.resize(rows);
+
+    return WireFormat::ReadBytes(*input, data_.data(), data_.size() * sizeof(T));
+}
+
+template <typename T>
+void ColumnVector<T>::SaveBody(OutputStream* output) {
+    WireFormat::WriteBytes(*output, data_.data(), data_.size() * sizeof(T));
+}
+
+template <typename T>
+size_t ColumnVector<T>::Size() const {
+    return data_.size();
+}
+
+template <typename T>
+ColumnRef ColumnVector<T>::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnVector<T>>(SliceVector(data_, begin, len));
+}
+
+template <typename T>
+ColumnRef ColumnVector<T>::CloneEmpty() const {
+    return std::make_shared<ColumnVector<T>>();
+}
+
+template <typename T>
+void ColumnVector<T>::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnVector<T> &>(other);
+    data_.swap(col.data_);
+}
+
+template <typename T>
+ItemView ColumnVector<T>::GetItem(size_t index) const  {
+    return ItemView{type_->GetCode(), data_[index]};
+}
+
+template class ColumnVector<int8_t>;
+template class ColumnVector<int16_t>;
+template class ColumnVector<int32_t>;
+template class ColumnVector<int64_t>;
+
+template class ColumnVector<uint8_t>;
+template class ColumnVector<uint16_t>;
+template class ColumnVector<uint32_t>;
+template class ColumnVector<uint64_t>;
+template class ColumnVector<Int128>;
+template class ColumnVector<UInt128>;
+
+template class ColumnVector<float>;
+template class ColumnVector<double>;
+
+}

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

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "column.h"
+#include "absl/numeric/int128.h"
+
+namespace clickhouse {
+
+/**
+ * Represents various numeric columns.
+ */
+template <typename T>
+class ColumnVector : public Column {
+public:
+    using DataType = T;
+    using ValueType = T;
+
+    ColumnVector();
+
+    explicit ColumnVector(const std::vector<T>& data);
+    explicit ColumnVector(std::vector<T> && data);
+
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Appends one element to the end of column.
+    void Append(const T& value);
+
+    /// Returns element at given row number.
+    const T& At(size_t n) const;
+
+    /// Returns element at given row number.
+    inline const T& operator [] (size_t n) const { return At(n); }
+
+    void Erase(size_t pos, size_t count = 1);
+
+    /// Get Raw Vector Contents
+    std::vector<T>& GetWritableData();
+
+    /// Returns the capacity of the column
+    size_t Capacity() 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 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 Int128 = absl::int128;
+using UInt128 = absl::uint128;
+using Int64 = int64_t;
+
+using ColumnUInt8   = ColumnVector<uint8_t>;
+using ColumnUInt16  = ColumnVector<uint16_t>;
+using ColumnUInt32  = ColumnVector<uint32_t>;
+using ColumnUInt64  = ColumnVector<uint64_t>;
+using ColumnUInt128 = ColumnVector<UInt128>;
+
+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>;
+
+}