clickhouse-native 0.0.1

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

@@ -0,0 +1,108 @@
+#include "ip6.h"
+#include "../base/socket.h" // for IPv6 platform-specific stuff
+#include "../exceptions.h"
+
+#include <stdexcept>
+
+namespace clickhouse {
+
+static_assert(sizeof(struct in6_addr) == 16, "sizeof in6_addr should be 16 bytes");
+
+ColumnIPv6::ColumnIPv6()
+    : Column(Type::CreateIPv6())
+    , data_(std::make_shared<ColumnFixedString>(16))
+{
+}
+
+ColumnIPv6::ColumnIPv6(ColumnRef data)
+    : Column(Type::CreateIPv6())
+    , data_(data ? data->As<ColumnFixedString>() : nullptr)
+{
+    if (!data_ || data_->FixedSize() != sizeof(in6_addr))
+        throw ValidationError("Expecting ColumnFixedString(16), got " + (data ? data->GetType().GetName() : "null"));
+}
+
+void ColumnIPv6::Append(const std::string_view& str) {
+    unsigned char buf[16];
+    if (inet_pton(AF_INET6, str.data(), buf) != 1) {
+        throw ValidationError("invalid IPv6 format, ip: " + std::string(str));
+    }
+    data_->Append(std::string_view((const char*)buf, 16));
+}
+
+void ColumnIPv6::Append(const in6_addr* addr) {
+    data_->Append(std::string_view((const char*)addr->s6_addr, 16));
+}
+
+void ColumnIPv6::Append(const in6_addr& addr) {
+    Append(&addr);
+}
+
+void ColumnIPv6::Clear() {
+    data_->Clear();
+}
+
+std::string ColumnIPv6::AsString (size_t n) const {
+    const auto& addr = this->At(n);
+    auto tmp_addr = addr;
+
+    char buf[INET6_ADDRSTRLEN];
+    const char* ip_str = inet_ntop(AF_INET6, &tmp_addr, buf, INET6_ADDRSTRLEN);
+
+    if (ip_str == nullptr) {
+        throw std::system_error(
+                std::error_code(errno, std::generic_category()),
+                "Invalid IPv6 data");
+    }
+
+    return ip_str;
+}
+
+in6_addr ColumnIPv6::At(size_t n) const {
+    return *reinterpret_cast<const in6_addr*>(data_->At(n).data());
+}
+
+in6_addr ColumnIPv6::operator [] (size_t n) const {
+    return *reinterpret_cast<const in6_addr*>(data_->At(n).data());
+}
+
+void ColumnIPv6::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+void ColumnIPv6::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnIPv6>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnIPv6::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnIPv6::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+size_t ColumnIPv6::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnIPv6::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnIPv6>(data_->Slice(begin, len));
+}
+
+ColumnRef ColumnIPv6::CloneEmpty() const {
+    return std::make_shared<ColumnIPv6>(data_->CloneEmpty());
+}
+
+void ColumnIPv6::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnIPv6 &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnIPv6::GetItem(size_t index) const {
+    return ItemView{Type::IPv6, data_->GetItem(index)};
+}
+
+}

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

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "string.h"
+#include <memory>
+
+struct in6_addr;
+
+namespace clickhouse {
+
+class ColumnIPv6 : public Column {
+public:
+    using DataType = in6_addr;
+    using ValueType = in6_addr;
+
+    ColumnIPv6();
+    /** Takes ownership of the data, expects ColumnFixedString.
+     * Modifying memory pointed by `data` from outside is UB.
+     *
+     * TODO: deprecate and remove as it is too dangerous and error-prone.
+     */
+    explicit ColumnIPv6(ColumnRef data);
+
+    /// Appends one element to the column.
+    void Append(const std::string_view& str);
+
+    void Append(const in6_addr* addr);
+    void Append(const in6_addr& addr);
+
+    /// Returns element at given row number.
+    in6_addr At(size_t n) const;
+
+    /// Returns element at given row number.
+    in6_addr operator [] (size_t n) const;
+
+    std::string AsString(size_t n) 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 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::shared_ptr<ColumnFixedString> data_;
+};
+
+}

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

@@ -0,0 +1,101 @@
+#include "../columns/itemview.h"
+
+#include <algorithm>
+#include <sstream>
+
+namespace {
+
+template <typename Container>
+std::string ContainerToString(Container container, const char * separator = ", ") {
+    std::stringstream sstr;
+    const auto end = std::end(container);
+    for (auto i = std::begin(container); i != end; /*intentionally no ++i*/) {
+        const auto & elem = *i;
+        sstr << elem;
+
+        if (++i != end) {
+            sstr << separator;
+        }
+    }
+
+    return sstr.str();
+}
+
+}
+
+namespace clickhouse {
+
+void ItemView::ValidateData(Type::Code type, DataType data) {
+
+    auto AssertSize = [type, &data](std::initializer_list<int> allowed_sizes) -> void {
+        const auto end = std::end(allowed_sizes);
+        if (std::find(std::begin(allowed_sizes), end, static_cast<int>(data.size())) == end) {
+            throw AssertionError(std::string("ItemView value size mismatch for ")
+                    + Type::TypeName(type)
+                    + " expected: " + ContainerToString(allowed_sizes, " or ")
+                    + ", got: " + std::to_string(data.size()));
+        }
+    };
+
+    switch (type) {
+        case Type::Code::Void:
+            return AssertSize({0});
+
+        case Type::Code::Int8:
+        case Type::Code::UInt8:
+        case Type::Code::Enum8:
+            return AssertSize({1});
+
+        case Type::Code::Int16:
+        case Type::Code::UInt16:
+        case Type::Code::Date:
+        case Type::Code::Enum16:
+            return AssertSize({2});
+
+        case Type::Code::Int32:
+        case Type::Code::UInt32:
+        case Type::Code::Float32:
+        case Type::Code::DateTime:
+        case Type::Code::Date32:
+        case Type::Code::IPv4:
+        case Type::Code::Decimal32:
+        case Type::Code::Time:
+            return AssertSize({4});
+
+        case Type::Code::Int64:
+        case Type::Code::UInt64:
+        case Type::Code::Float64:
+        case Type::Code::DateTime64:
+        case Type::Code::Decimal64:
+        case Type::Code::Time64:
+            return AssertSize({8});
+
+        case Type::Code::String:
+        case Type::Code::FixedString:
+            // value can be of any size
+            return;
+
+        case Type::Code::Array:
+        case Type::Code::Nullable:
+        case Type::Code::Tuple:
+        case Type::Code::LowCardinality:
+        case Type::Code::Map:
+            throw AssertionError("Unsupported type in ItemView: " + std::string(Type::TypeName(type)));
+
+        case Type::Code::IPv6:
+        case Type::Code::UUID:
+        case Type::Code::UInt128:
+        case Type::Code::Int128:
+        case Type::Code::Decimal128:
+            return AssertSize({16});
+
+        case Type::Code::Decimal:
+            // Could be either Decimal32, Decimal64 or Decimal128
+            return AssertSize({4, 8, 16});
+
+        default:
+            throw UnimplementedError("Unknown type code:" + std::to_string(static_cast<int>(type)));
+    }
+}
+
+}

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

@@ -0,0 +1,86 @@
+#pragma once
+
+#include "../types/types.h"
+#include "../exceptions.h"
+
+#include <string_view>
+#include <stdexcept>
+#include <type_traits>
+
+namespace clickhouse {
+
+/** ItemView is a view on a data stored in Column, safe-ish interface for reading values from Column.
+ *
+ * Data is not owned (hence the name View) and will be invalidated on column update, load
+ * or destruction (basically on calling any non-const method of Column).
+ * `type` reflects what is stored in `data` and can be almost any value-type
+ * (except Nullable, Array, Tuple, LowCardinality).
+ *
+ */
+struct ItemView {
+    using DataType = std::string_view;
+
+    const Type::Code type;
+    const DataType data;
+
+private:
+    template <typename T>
+    inline auto ConvertToStorageValue(const T& t) {
+        if constexpr (std::is_same_v<std::string_view, T> || std::is_same_v<std::string, T>) {
+            return std::string_view{t};
+        } else if constexpr (std::is_fundamental_v<T> || std::is_same_v<Int128, std::decay_t<T>> || std::is_same_v<UInt128, std::decay_t<T>>) {
+            return std::string_view{reinterpret_cast<const char*>(&t), sizeof(T)};
+        } else {
+            static_assert(!std::is_same_v<T, T>, "Unknown type, which can't be stored in ItemView");
+            return;
+        }
+    }
+
+public:
+    ItemView(Type::Code type, DataType data)
+        : type(type),
+          data(data)
+    {
+        ValidateData(type, data);
+    }
+
+    ItemView(Type::Code type, ItemView other)
+        : type(type),
+          data(other.data)
+    {
+        ValidateData(type, data);
+    }
+
+    explicit ItemView()
+        : ItemView(Type::Void, std::string_view{})
+    {}
+
+    template <typename T>
+    explicit ItemView(Type::Code type, const T & value)
+        : ItemView(type, ConvertToStorageValue(value))
+    {}
+
+    template <typename T>
+    auto get() const {
+        using ValueType = std::remove_cv_t<std::decay_t<T>>;
+        if constexpr (std::is_same_v<std::string_view, ValueType> || std::is_same_v<std::string, ValueType>) {
+            return data;
+        } else if constexpr (std::is_fundamental_v<ValueType> || std::is_same_v<Int128, ValueType> || std::is_same_v<UInt128, ValueType>) {
+            if (sizeof(ValueType) == data.size()) {
+                return *reinterpret_cast<const T*>(data.data());
+            } else {
+                throw AssertionError("Incompatitable value type and size. Requested size: "
+                        + std::to_string(sizeof(ValueType)) + " stored size: " + std::to_string(data.size()));
+            }
+        }
+    }
+
+    inline std::string_view AsBinaryData() const {
+        return data;
+    }
+
+    // Validate that value matches type, will throw an exception if validation fails.
+    static void ValidateData(Type::Code type, DataType data);
+};
+
+}