clickhouse-native 0.0.1

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

@@ -0,0 +1,285 @@
+#include "factory.h"
+
+#include "array.h"
+#include "date.h"
+#include "decimal.h"
+#include "enum.h"
+#include "geo.h"
+#include "ip4.h"
+#include "ip6.h"
+#include "lowcardinality.h"
+#include "lowcardinalityadaptor.h"
+#include "map.h"
+#include "nothing.h"
+#include "nullable.h"
+#include "numeric.h"
+#include "string.h"
+#include "./time.h" // `./` avoids possible conflicts with standard C time.h
+#include "tuple.h"
+#include "uuid.h"
+
+
+#include "../types/type_parser.h"
+
+#include "../exceptions.h"
+
+#include <stdexcept>
+#include <string>
+
+namespace clickhouse {
+namespace {
+
+// Like Python's list's []:
+// * 0 - first element
+// * 1 - second element
+// * -1 - last element
+// * -2 - one before last, etc.
+const auto& GetASTChildElement(const TypeAst & ast, int position) {
+    if (static_cast<size_t>(abs(position)) >= ast.elements.size())
+        throw ValidationError("AST child element index out of bounds: " + std::to_string(position));
+
+    if (position < 0)
+        position = static_cast<int>(ast.elements.size() + position);
+
+    return ast.elements[static_cast<size_t>(position)];
+}
+
+static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
+    switch (ast.code) {
+    case Type::Void:
+        return std::make_shared<ColumnNothing>();
+
+    case Type::UInt8:
+        return std::make_shared<ColumnUInt8>();
+    case Type::UInt16:
+        return std::make_shared<ColumnUInt16>();
+    case Type::UInt32:
+        return std::make_shared<ColumnUInt32>();
+    case Type::UInt64:
+        return std::make_shared<ColumnUInt64>();
+
+    case Type::Int8:
+        return std::make_shared<ColumnInt8>();
+    case Type::Int16:
+        return std::make_shared<ColumnInt16>();
+    case Type::Int32:
+        return std::make_shared<ColumnInt32>();
+    case Type::Int64:
+        return std::make_shared<ColumnInt64>();
+    case Type::Int128:
+        return std::make_shared<ColumnInt128>();
+    case Type::UInt128:
+        return std::make_shared<ColumnUInt128>();
+
+    case Type::Float32:
+        return std::make_shared<ColumnFloat32>();
+    case Type::Float64:
+        return std::make_shared<ColumnFloat64>();
+
+    case Type::Decimal:
+        return std::make_shared<ColumnDecimal>(GetASTChildElement(ast, 0).value, GetASTChildElement(ast, -1).value);
+    case Type::Decimal32:
+        return std::make_shared<ColumnDecimal>(9, GetASTChildElement(ast, 0).value);
+    case Type::Decimal64:
+        return std::make_shared<ColumnDecimal>(18, GetASTChildElement(ast, 0).value);
+    case Type::Decimal128:
+        return std::make_shared<ColumnDecimal>(38, GetASTChildElement(ast, 0).value);
+
+    case Type::String:
+        return std::make_shared<ColumnString>();
+    case Type::FixedString:
+        return std::make_shared<ColumnFixedString>(GetASTChildElement(ast, 0).value);
+
+    case Type::DateTime:
+        if (ast.elements.empty()) {
+            return std::make_shared<ColumnDateTime>();
+        } else {
+            return std::make_shared<ColumnDateTime>(GetASTChildElement(ast, 0).value_string);
+        }
+    case Type::DateTime64:
+        if (ast.elements.empty()) {
+            return nullptr;
+        }
+        if (ast.elements.size() == 1) {
+            return std::make_shared<ColumnDateTime64>(ast.elements[0].value);
+        } else {
+            return std::make_shared<ColumnDateTime64>(ast.elements[0].value, ast.elements[1].value_string);
+        }
+    case Type::Date:
+        return std::make_shared<ColumnDate>();
+    case Type::Date32:
+        return std::make_shared<ColumnDate32>();
+    case Type::IPv4:
+        return std::make_shared<ColumnIPv4>();
+    case Type::IPv6:
+        return std::make_shared<ColumnIPv6>();
+
+    case Type::UUID:
+        return std::make_shared<ColumnUUID>();
+
+    case Type::Point:
+        return std::make_shared<ColumnPoint>();
+
+    case Type::Ring:
+        return std::make_shared<ColumnRing>();
+
+    case Type::Polygon:
+        return std::make_shared<ColumnPolygon>();
+
+    case Type::MultiPolygon:
+        return std::make_shared<ColumnMultiPolygon>();
+
+    case Type::Time:
+        return std::make_shared<ColumnTime>();
+    case Type::Time64:
+        if (ast.elements.empty()) {
+            return nullptr;
+        }
+        return std::make_shared<ColumnTime64>(GetASTChildElement(ast, 0).value);
+    default:
+        return nullptr;
+    }
+}
+
+static ColumnRef CreateColumnFromAst(const TypeAst& ast, CreateColumnByTypeSettings settings) {
+    switch (ast.meta) {
+        case TypeAst::Array: {
+            return std::make_shared<ColumnArray>(
+                CreateColumnFromAst(GetASTChildElement(ast, 0), settings)
+            );
+        }
+
+        case TypeAst::Nullable: {
+            return std::make_shared<ColumnNullable>(
+                CreateColumnFromAst(GetASTChildElement(ast, 0), settings),
+                std::make_shared<ColumnUInt8>()
+            );
+        }
+
+        case TypeAst::Terminal: {
+            return CreateTerminalColumn(ast);
+        }
+
+        case TypeAst::Tuple: {
+            std::vector<ColumnRef> columns;
+
+            columns.reserve(ast.elements.size());
+            for (const auto& elem : ast.elements) {
+                if (auto col = CreateColumnFromAst(elem, settings)) {
+                    columns.push_back(col);
+                } else {
+                    return nullptr;
+                }
+            }
+
+            return std::make_shared<ColumnTuple>(columns);
+        }
+
+        case TypeAst::Enum: {
+            std::vector<Type::EnumItem> enum_items;
+            //ast.elements.size() minimum is 1.
+            if ((ast.elements.size() % 2) != 0) {
+                throw ValidationError(ast.name + " content is not correct");
+            }
+
+            enum_items.reserve(ast.elements.size() / 2);
+            for (size_t i = 0; i < ast.elements.size(); i += 2) {
+                enum_items.push_back(Type::EnumItem{
+                    ast.elements[i].value_string,
+                    static_cast<int16_t>(ast.elements[i + 1].value)
+                });
+            }
+
+            if (ast.code == Type::Enum8) {
+                return std::make_shared<ColumnEnum8>(
+                    Type::CreateEnum8(enum_items)
+                );
+            } else if (ast.code == Type::Enum16) {
+                return std::make_shared<ColumnEnum16>(
+                    Type::CreateEnum16(enum_items)
+                );
+            }
+            break;
+        }
+        case TypeAst::LowCardinality: {
+            const auto nested = GetASTChildElement(ast, 0);
+            if (settings.low_cardinality_as_wrapped_column) {
+                switch (nested.code) {
+                    // TODO (nemkov): update this to maximize code reuse.
+                    case Type::String:
+                        return std::make_shared<LowCardinalitySerializationAdaptor<ColumnString>>();
+                    case Type::FixedString:
+                        return std::make_shared<LowCardinalitySerializationAdaptor<ColumnFixedString>>(GetASTChildElement(nested, 0).value);
+                    case Type::Nullable:
+                        throw UnimplementedError("LowCardinality(" + nested.name + ") is not supported with LowCardinalityAsWrappedColumn on");
+                    default:
+                        throw UnimplementedError("LowCardinality(" + nested.name + ") is not supported");
+                }
+            }
+            else {
+                switch (nested.code) {
+                    // TODO (nemkov): update this to maximize code reuse.
+                    case Type::String:
+                        return std::make_shared<ColumnLowCardinalityT<ColumnString>>();
+                    case Type::FixedString:
+                        return std::make_shared<ColumnLowCardinalityT<ColumnFixedString>>(GetASTChildElement(nested, 0).value);
+                    case Type::Nullable:
+                        return std::make_shared<ColumnLowCardinality>(
+                            std::make_shared<ColumnNullable>(
+                                CreateColumnFromAst(GetASTChildElement(nested, 0), settings),
+                                std::make_shared<ColumnUInt8>()
+                            )
+                        );
+                    default:
+                        throw UnimplementedError("LowCardinality(" + nested.name + ") is not supported");
+                }
+            }
+        }
+        case TypeAst::SimpleAggregateFunction: {
+            return CreateTerminalColumn(GetASTChildElement(ast, -1));
+        }
+
+        case TypeAst::Map: {
+            if (ast.elements.size() != 2) {
+                throw ValidationError(ast.name + " content is not correct");
+            }
+
+            std::vector<ColumnRef> columns;
+
+            columns.reserve(ast.elements.size());
+            for (const auto& elem : ast.elements) {
+                if (auto col = CreateColumnFromAst(elem, settings)) {
+                    columns.push_back(col);
+                } else {
+                    return nullptr;
+                }
+            }
+
+            return std::make_shared<ColumnMap>(
+                std::make_shared<ColumnArray>(
+                    std::make_shared<ColumnTuple>(columns)));
+        }
+
+        case TypeAst::Assign:
+        case TypeAst::Null:
+        case TypeAst::Number:
+        case TypeAst::String:
+            break;
+    }
+
+    return nullptr;
+}
+
+} // namespace
+
+
+ColumnRef CreateColumnByType(const std::string& type_name, CreateColumnByTypeSettings settings) {
+    auto ast = ParseTypeName(type_name);
+    if (ast != nullptr) {
+        return CreateColumnFromAst(*ast, settings);
+    }
+
+    return nullptr;
+}
+
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "column.h"
+
+namespace clickhouse {
+
+struct CreateColumnByTypeSettings
+{
+    bool low_cardinality_as_wrapped_column = false;
+};
+
+ColumnRef CreateColumnByType(const std::string& type_name, CreateColumnByTypeSettings settings = {});
+
+}

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

@@ -0,0 +1,108 @@
+#include "geo.h"
+
+#include "utils.h"
+
+namespace {
+using namespace ::clickhouse;
+
+template <Type::Code type_code>
+TypeRef CreateGeoType() {
+    if constexpr (type_code == Type::Code::Point) {
+        return Type::CreatePoint();
+    } else if constexpr (type_code == Type::Code::Ring) {
+        return Type::CreateRing();
+    } else if constexpr (type_code == Type::Code::Polygon) {
+        return Type::CreatePolygon();
+    } else if constexpr (type_code == Type::Code::MultiPolygon) {
+        return Type::CreateMultiPolygon();
+    }
+}
+
+template <typename ColumnType>
+std::shared_ptr<ColumnType> CreateColumn() {
+    if constexpr (std::is_same_v<ColumnType, ColumnTupleT<ColumnFloat64, ColumnFloat64>>) {
+        return std::make_shared<ColumnTupleT<ColumnFloat64, ColumnFloat64>>(
+            std::make_tuple(std::make_shared<ColumnFloat64>(), std::make_shared<ColumnFloat64>()));
+    } else {
+        return std::make_shared<ColumnType>();
+    }
+}
+
+}  // namespace
+
+namespace clickhouse {
+
+template <typename NestedColumnType, Type::Code type_code>
+ColumnGeo<NestedColumnType, type_code>::ColumnGeo()
+    : Column(CreateGeoType<type_code>()),
+      data_(CreateColumn<NestedColumnType>()) {
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+ColumnGeo<NestedColumnType, type_code>::ColumnGeo(ColumnRef data)
+    : Column(CreateGeoType<type_code>())
+    , data_(WrapColumn<NestedColumnType>(std::move(data))) {
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+void ColumnGeo<NestedColumnType, type_code>::Clear() {
+    data_->Clear();
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+const typename ColumnGeo<NestedColumnType, type_code>::ValueType ColumnGeo<NestedColumnType, type_code>::At(size_t n) const {
+    return data_->At(n);
+}
+
+template<typename NestedColumnType, Type::Code type_code>
+void ColumnGeo<NestedColumnType, type_code>::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+void ColumnGeo<NestedColumnType, type_code>::Append(ColumnRef column) {
+    if (auto col = column->template As<ColumnGeo>()) {
+        data_->Append(col->data_->template As<Column>());
+    }
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+bool ColumnGeo<NestedColumnType, type_code>::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+void ColumnGeo<NestedColumnType, type_code>::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+size_t ColumnGeo<NestedColumnType, type_code>::Size() const {
+    return data_->Size();
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+ColumnRef ColumnGeo<NestedColumnType, type_code>::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnGeo>(data_->Slice(begin, len));
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+ColumnRef ColumnGeo<NestedColumnType, type_code>::CloneEmpty() const {
+    return std::make_shared<ColumnGeo>();
+}
+
+template <typename NestedColumnType, Type::Code type_code>
+void ColumnGeo<NestedColumnType, type_code>::Swap(Column& other) {
+    auto& col = dynamic_cast<ColumnGeo&>(other);
+    data_.swap(col.data_);
+}
+
+template class ColumnGeo<ColumnTupleT<ColumnFloat64, ColumnFloat64>, Type::Code::Point>;
+
+template class ColumnGeo<ColumnArrayT<ColumnPoint>, Type::Code::Ring>;
+
+template class ColumnGeo<ColumnArrayT<ColumnRing>, Type::Code::Polygon>;
+
+template class ColumnGeo<ColumnArrayT<ColumnPolygon>, Type::Code::MultiPolygon>;
+
+}  // namespace clickhouse

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

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "array.h"
+#include "column.h"
+#include "numeric.h"
+#include "tuple.h"
+
+namespace clickhouse {
+
+template <typename NestedColumnType, Type::Code type_code>
+class ColumnGeo : public Column {
+public:
+    using ValueType = typename NestedColumnType::ValueType;
+
+    ColumnGeo();
+
+    explicit ColumnGeo(ColumnRef data);
+
+    /// Appends one element to the end of column.
+    template <typename T = ValueType>
+    void Append(const T& value) {
+        data_->Append(value);
+    }
+
+    /// Returns element at given row number.
+    const ValueType At(size_t n) const;
+
+    /// Returns element at given row number.
+    inline const ValueType 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;
+
+private:
+    std::shared_ptr<NestedColumnType> data_;
+};
+
+// /**
+//  * Represents a Point column.
+//  */
+using ColumnPoint = ColumnGeo<ColumnTupleT<ColumnFloat64, ColumnFloat64>, Type::Code::Point>;
+
+/**
+ * Represents a Ring column.
+ */
+using ColumnRing = ColumnGeo<ColumnArrayT<ColumnPoint>, Type::Code::Ring>;
+
+/**
+ * Represents a Polygon column.
+ */
+using ColumnPolygon = ColumnGeo<ColumnArrayT<ColumnRing>, Type::Code::Polygon>;
+
+/**
+ * Represents a MultiPolygon column.
+ */
+using ColumnMultiPolygon = ColumnGeo<ColumnArrayT<ColumnPolygon>, Type::Code::MultiPolygon>;
+
+}  // namespace clickhouse

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

@@ -0,0 +1,117 @@
+#include "ip4.h"
+
+#include "../base/socket.h" // for platform-specific IPv4-related functions
+#include <stdexcept>
+
+namespace clickhouse {
+
+ColumnIPv4::ColumnIPv4()
+    : Column(Type::CreateIPv4())
+    , data_(std::make_shared<ColumnUInt32>())
+{
+}
+
+ColumnIPv4::ColumnIPv4(ColumnRef data)
+    : Column(Type::CreateIPv4())
+    , data_(data ? data->As<ColumnUInt32>() : nullptr)
+{
+    if (!data_)
+        throw ValidationError("Expecting ColumnUInt32, got " + (data ? data->GetType().GetName() : "null"));
+}
+
+ColumnIPv4::ColumnIPv4(std::vector<uint32_t>&& data)
+    : Column(Type::CreateIPv4())
+{
+    for (auto& addr : data) {
+        addr = htonl(addr);
+    }
+    data_ = std::make_shared<ColumnUInt32>(std::move(data));
+}
+
+void ColumnIPv4::Append(const std::string& str) {
+    uint32_t address;
+    if (inet_pton(AF_INET, str.c_str(), &address) != 1)
+        throw ValidationError("invalid IPv4 format, ip: " + str);
+    data_->Append(htonl(address));
+}
+
+void ColumnIPv4::Append(uint32_t ip) {
+    data_->Append(htonl(ip));
+}
+
+void ColumnIPv4::Append(in_addr ip) {
+    data_->Append(htonl(ip.s_addr));
+}
+
+void ColumnIPv4::Clear() {
+    data_->Clear();
+}
+
+in_addr ColumnIPv4::At(size_t n) const {
+    in_addr addr;
+    addr.s_addr = ntohl(data_->At(n));
+    return addr;
+}
+
+in_addr ColumnIPv4::operator [] (size_t n) const {
+    in_addr addr;
+    addr.s_addr = ntohl(data_->operator[](n));
+    return addr;
+}
+
+std::string ColumnIPv4::AsString(size_t n) const {
+    const auto& addr = this->At(n);
+    auto tmp_addr = addr;
+
+    char buf[INET_ADDRSTRLEN];
+    const char* ip_str = inet_ntop(AF_INET, &tmp_addr, buf, INET_ADDRSTRLEN);
+
+    if (ip_str == nullptr) {
+        throw std::system_error(
+                std::error_code(errno, std::generic_category()),
+                "Invalid IPv4 data");
+    }
+
+    return ip_str;
+}
+
+void ColumnIPv4::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+void ColumnIPv4::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnIPv4>()) {
+        data_->Append(col->data_);
+    }
+}
+
+bool ColumnIPv4::LoadBody(InputStream * input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnIPv4::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+size_t ColumnIPv4::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnIPv4::Slice(size_t begin, size_t len) const {
+    return std::make_shared<ColumnIPv4>(data_->Slice(begin, len));
+}
+
+ColumnRef ColumnIPv4::CloneEmpty() const {
+    return std::make_shared<ColumnIPv4>(data_->CloneEmpty());
+}
+
+void ColumnIPv4::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnIPv4 &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnIPv4::GetItem(size_t index) const {
+    return ItemView(Type::IPv4, data_->GetItem(index));
+}
+
+}

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

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "numeric.h"
+
+struct in_addr;
+
+namespace clickhouse {
+
+class ColumnIPv4 : public Column {
+public:
+    using DataType = in_addr;
+    using ValueType = in_addr;
+
+    ColumnIPv4();
+    /** Takes ownership of the data, expects ColumnUInt32.
+     * Modifying memory pointed by `data` from outside is UB.
+     *
+     * TODO: deprecate and remove as it is too dangerous and error-prone.
+     */
+    explicit ColumnIPv4(ColumnRef data);
+
+    explicit ColumnIPv4(std::vector<uint32_t>&& data);
+
+    /// Appends one element to the column.
+    void Append(const std::string& ip);
+
+    /// @params ip numeric value with host byte order.
+    void Append(uint32_t ip);
+
+    ///
+    void Append(in_addr ip);
+
+    /// Returns element at given row number.
+    in_addr At(size_t n) const;
+
+    /// Returns element at given row number.
+    in_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<ColumnUInt32> data_;
+};
+
+}