clickhouse-native 0.0.1

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

@@ -0,0 +1,118 @@
+#pragma once
+
+#include "column.h"
+#include "numeric.h"
+
+namespace clickhouse {
+
+class ColumnTime : public Column {
+public:
+    using ValueType = int32_t;
+
+    ColumnTime();
+    explicit ColumnTime(std::vector<int32_t>&& data);
+
+    /// Appends one element to the end of column.
+    void Append(ValueType value);
+
+    /// Returns element at given row number.
+    ValueType At(size_t n) const;
+    ValueType operator[](size_t n) const { return At(n); }
+
+    /// Get Raw Vector Contents
+    std::vector<int32_t>& GetWritableData();
+
+public:
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Returns the capacity of the column
+    size_t Capacity() 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;
+
+    /// Clear column data .
+    void Clear() override;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) 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:
+    ColumnTime(TypeRef type, std::shared_ptr<ColumnInt32> data);
+
+private:
+    std::shared_ptr<ColumnInt32> data_;
+};
+
+class ColumnTime64 : public Column {
+public:
+    using ValueType = int64_t;
+
+    explicit ColumnTime64(size_t precision);
+    ColumnTime64(size_t precision, std::vector<int64_t>&& data);
+
+    /// Appends one element to the end of column.
+    void Append(ValueType value);
+
+    /// Returns element at given row number.
+    ValueType At(size_t n) const;
+
+    ValueType operator[](size_t n) const { return At(n); }
+
+    /// Get Raw Vector Contents
+    std::vector<int64_t>& GetWritableData();
+
+public:
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Returns the capacity of the column
+    size_t Capacity() 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;
+
+    /// Clear column data .
+    void Clear() override;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) 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;
+
+    size_t GetPrecision() const { return precision_; };
+
+private:
+    ColumnTime64(TypeRef type, std::shared_ptr<ColumnInt64> data);
+
+private:
+    std::shared_ptr<ColumnInt64> data_;
+    const size_t precision_;
+};
+
+}

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

@@ -0,0 +1,106 @@
+#include "tuple.h"
+
+namespace clickhouse {
+
+static std::vector<TypeRef> CollectTypes(const std::vector<ColumnRef>& columns) {
+    std::vector<TypeRef> types;
+    for (const auto& col : columns) {
+        types.push_back(col->Type());
+    }
+    return types;
+}
+
+ColumnTuple::ColumnTuple(const std::vector<ColumnRef>& columns)
+    : Column(Type::CreateTuple(CollectTypes(columns)))
+    , columns_(columns)
+{
+}
+
+size_t ColumnTuple::TupleSize() const {
+    return columns_.size();
+}
+
+void ColumnTuple::Reserve(size_t new_cap) {
+    for (auto& column : columns_) {
+        column->Reserve(new_cap);
+    }  
+}
+
+void ColumnTuple::Append(ColumnRef column) {
+    if (!this->Type()->IsEqual(column->Type())) {
+        throw ValidationError(
+            "can't append column of type " + column->Type()->GetName() + " "
+            "to column type " + this->Type()->GetName());
+    }
+    const auto & source_tuple_column = column->As<ColumnTuple>();
+    for (size_t ci = 0; ci < columns_.size(); ++ci) {
+        columns_[ci]->Append((*source_tuple_column)[ci]);
+    }
+}
+size_t ColumnTuple::Size() const {
+    return columns_.empty() ? 0 : columns_[0]->Size();
+}
+
+ColumnRef ColumnTuple::Slice(size_t begin, size_t len) const {
+    std::vector<ColumnRef> sliced_columns;
+    sliced_columns.reserve(columns_.size());
+    for(const auto &column : columns_) {
+        sliced_columns.push_back(column->Slice(begin, len));
+    }
+
+    return std::make_shared<ColumnTuple>(sliced_columns);
+}
+
+ColumnRef ColumnTuple::CloneEmpty() const {
+    std::vector<ColumnRef> result_columns;
+    result_columns.reserve(columns_.size());
+
+    for(const auto &column : columns_) {
+        result_columns.push_back(column->CloneEmpty());
+    }
+
+    return std::make_shared<ColumnTuple>(result_columns);
+}
+
+bool ColumnTuple::LoadPrefix(InputStream* input, size_t rows) {
+    for (auto ci = columns_.begin(); ci != columns_.end(); ++ci) {
+        if (!(*ci)->LoadPrefix(input, rows)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool ColumnTuple::LoadBody(InputStream* input, size_t rows) {
+    for (auto ci = columns_.begin(); ci != columns_.end(); ++ci) {
+        if (!(*ci)->LoadBody(input, rows)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void ColumnTuple::SavePrefix(OutputStream* output) {
+    for (auto & column : columns_) {
+        column->SavePrefix(output);
+    }
+}
+
+void ColumnTuple::SaveBody(OutputStream* output) {
+    for (auto & column : columns_) {
+        column->SaveBody(output);
+    }
+}
+
+void ColumnTuple::Clear() {
+    columns_.clear();
+}
+
+void ColumnTuple::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnTuple &>(other);
+    columns_.swap(col.columns_);
+}
+
+}

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

@@ -0,0 +1,178 @@
+#pragma once
+
+#include "column.h"
+#include "utils.h"
+
+#include <vector>
+
+namespace clickhouse {
+
+/**
+ * Represents column of Tuple([T]).
+ */
+class ColumnTuple : public Column {
+public:
+    ColumnTuple(const std::vector<ColumnRef>& columns);
+
+    /// Returns count of columns in the tuple.
+    size_t TupleSize() const;
+
+    inline ColumnRef operator [] (size_t n) const {
+        return columns_[n];
+    }
+
+    inline ColumnRef At(size_t n) const {
+        return columns_[n];
+    }
+
+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, size_t) const override;
+    ColumnRef CloneEmpty() const override;
+    void Swap(Column& other) override;
+
+private:
+    std::vector<ColumnRef> columns_;
+};
+
+template <typename... Columns>
+class ColumnTupleT : public ColumnTuple {
+public:
+    using TupleOfColumns = std::tuple<std::shared_ptr<Columns>...>;
+
+    using ValueType = std::tuple<std::decay_t<decltype(std::declval<Columns>().At(0))>...>;
+
+    ColumnTupleT(std::tuple<std::shared_ptr<Columns>...> columns)
+        : ColumnTuple(TupleToVector(columns)), typed_columns_(std::move(columns)) {}
+
+    ColumnTupleT(std::vector<ColumnRef> columns)
+        : ColumnTuple(columns), typed_columns_(VectorToTuple(std::move(columns))) {}
+
+    ColumnTupleT(const std::initializer_list<ColumnRef> columns)
+        : ColumnTuple(columns), typed_columns_(VectorToTuple(std::move(columns))) {}
+
+    inline ValueType At(size_t index) const { return GetTupleOfValues(index); }
+
+    inline ValueType operator[](size_t index) const { return GetTupleOfValues(index); }
+
+    using ColumnTuple::Append;
+
+    template <typename... T>
+    inline void Append(std::tuple<T...> value) {
+        AppendTuple(std::move(value));
+    }
+
+    /** Create a ColumnTupleT from a ColumnTuple, 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(ColumnTuple&& col) {
+        if (col.TupleSize() != std::tuple_size_v<TupleOfColumns>) {
+            throw ValidationError("Can't wrap from " + col.GetType().GetName());
+        }
+        return std::make_shared<ColumnTupleT<Columns...>>(VectorToTuple(std::move(col)));
+    }
+
+    static auto Wrap(Column&& col) { return Wrap(std::move(dynamic_cast<ColumnTuple&&>(col))); }
+
+    // Helper to simplify integration with other APIs
+    static auto Wrap(ColumnRef&& col) { return Wrap(std::move(*col->AsStrict<ColumnTuple>())); }
+
+    ColumnRef Slice(size_t begin, size_t size) const override {
+        return Wrap(ColumnTuple::Slice(begin, size));
+    }
+
+    ColumnRef CloneEmpty() const override { return Wrap(ColumnTuple::CloneEmpty()); }
+
+    void Swap(Column& other) override {
+        auto& col = dynamic_cast<ColumnTupleT<Columns...>&>(other);
+        typed_columns_.swap(col.typed_columns_);
+        ColumnTuple::Swap(other);
+    }
+
+private:
+    template <typename T, size_t index = std::tuple_size_v<T>>
+    inline void AppendTuple([[maybe_unused]] T value) {
+        static_assert(index <= std::tuple_size_v<T>);
+        static_assert(std::tuple_size_v<TupleOfColumns> == std::tuple_size_v<T>);
+        if constexpr (index == 0) {
+            return;
+        } else {
+            std::get<index - 1>(typed_columns_)->Append(std::move(std::get<index - 1>(value)));
+            AppendTuple<T, index - 1>(std::move(value));
+        }
+    }
+
+    template <typename T, size_t index = std::tuple_size_v<T>>
+    inline static std::vector<ColumnRef> TupleToVector([[maybe_unused]] const T& value) {
+        static_assert(index <= std::tuple_size_v<T>);
+        if constexpr (index == 0) {
+            std::vector<ColumnRef> result;
+            result.reserve(std::tuple_size_v<T>);
+            return result;
+        } else {
+            auto result = TupleToVector<T, index - 1>(value);
+            result.push_back(std::get<index - 1>(value));
+            return result;
+        }
+    }
+
+    template <typename T, size_t column_index = std::tuple_size_v<TupleOfColumns>>
+    inline static auto VectorToTuple([[maybe_unused]] T columns) {
+        static_assert(column_index <= std::tuple_size_v<TupleOfColumns>);
+        if constexpr (column_index == 0) {
+            return std::make_tuple();
+        } else {
+            using ColumnType =
+                typename std::tuple_element<column_index - 1, TupleOfColumns>::type::element_type;
+            auto column = WrapColumn<ColumnType>(columns[column_index - 1]);
+            return std::tuple_cat(std::move(VectorToTuple<T, column_index - 1>(std::move(columns))),
+                                  std::make_tuple(std::move(column)));
+        }
+    }
+
+    template <size_t column_index = std::tuple_size_v<TupleOfColumns>>
+    inline auto GetTupleOfValues([[maybe_unused]]size_t index) const {
+        static_assert(column_index <= std::tuple_size_v<TupleOfColumns>);
+        if constexpr (column_index == 0) {
+            return std::make_tuple();
+        } else {
+            return std::tuple_cat(
+                std::move(GetTupleOfValues<column_index - 1>(index)),
+                std::move(std::make_tuple(std::get<column_index - 1>(typed_columns_)->At(index))));
+        }
+    }
+
+    TupleOfColumns typed_columns_;
+};
+
+}  // namespace clickhouse

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <algorithm>
+#include <vector>
+#include <memory>
+
+namespace clickhouse {
+
+template <typename T>
+std::vector<T> SliceVector(const std::vector<T>& vec, size_t begin, size_t len) {
+    std::vector<T> result;
+
+    if (begin < vec.size()) {
+        len = std::min(len, vec.size() - begin);
+        result.assign(vec.begin() + begin, vec.begin() + (begin + len));
+    }
+
+    return result;
+}
+
+template <typename T>
+struct HasWrapMethod {
+private:
+    static int detect(...);
+    template <typename U>
+    static decltype(U::Wrap(std::move(std::declval<ColumnRef>()))) detect(const U&);
+
+public:
+    static constexpr bool value = !std::is_same<int, decltype(detect(std::declval<T>()))>::value;
+};
+
+template <typename T>
+inline std::shared_ptr<T> WrapColumn(ColumnRef&& column) {
+    if constexpr (HasWrapMethod<T>::value) {
+        return T::Wrap(std::move(column));
+    } else {
+        return column->template AsStrict<T>();
+    }
+}
+
+}

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

@@ -0,0 +1,80 @@
+#include "uuid.h"
+#include "utils.h"
+#include "../exceptions.h"
+
+#include <stdexcept>
+
+namespace clickhouse {
+
+ColumnUUID::ColumnUUID()
+    : Column(Type::CreateUUID())
+    , data_(std::make_shared<ColumnUInt64>())
+{
+}
+
+ColumnUUID::ColumnUUID(ColumnRef data)
+    : Column(Type::CreateUUID())
+    , data_(data->As<ColumnUInt64>())
+{
+    if (data_->Size() % 2 != 0) {
+        throw ValidationError("number of entries must be even (two 64-bit numbers for each UUID)");
+    }
+}
+
+void ColumnUUID::Append(const UUID& value) {
+    data_->Append(value.first);
+    data_->Append(value.second);
+}
+
+void ColumnUUID::Clear() {
+    data_->Clear();
+}
+
+const UUID ColumnUUID::At(size_t n) const {
+    return UUID(data_->At(n * 2), data_->At(n * 2 + 1));
+}
+
+void ColumnUUID::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+void ColumnUUID::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnUUID>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnUUID::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows * 2);
+}
+
+void ColumnUUID::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+size_t ColumnUUID::Size() const {
+    return data_->Size() / 2;
+}
+
+ColumnRef ColumnUUID::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnUUID>(data_->Slice(begin * 2, len * 2));
+}
+
+ColumnRef ColumnUUID::CloneEmpty() const {
+    return std::make_shared<ColumnUUID>();
+}
+
+void ColumnUUID::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnUUID &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnUUID::GetItem(size_t index) const {
+    // We know that ColumnUInt64 stores it's data in continius memory region,
+    // and that every 2 values from data represent 1 UUID value.
+    const auto data_item_view = data_->GetItem(index * 2);
+
+    return ItemView{Type::UUID, std::string_view{data_item_view.data.data(), data_item_view.data.size() * 2}};
+}
+
+}

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

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "../base/uuid.h"
+#include "column.h"
+#include "numeric.h"
+
+namespace clickhouse {
+
+
+/**
+ * Represents a UUID column.
+ */
+class ColumnUUID : public Column {
+public:
+    ColumnUUID();
+
+    explicit ColumnUUID(ColumnRef data);
+
+    /// Appends one element to the end of column.
+    void Append(const UUID& value);
+
+    /// Returns element at given row number.
+    const UUID At(size_t n) const;
+
+    /// Returns element at given row number.
+    inline const UUID operator [] (size_t n) const { return At(n); }
+
+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) const override;
+
+private:
+    std::shared_ptr<ColumnUInt64> data_;
+};
+
+}