clickhouse-native 0.0.1

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/types/types.h

@@ -0,0 +1,397 @@
+#pragma once
+
+#include "absl/numeric/int128.h"
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+namespace clickhouse {
+
+using Int128 = absl::int128;
+using UInt128 = absl::uint128;
+using Int64 = int64_t;
+
+using TypeRef = std::shared_ptr<class Type>;
+
+class Type {
+public:
+    enum Code {
+        Void = 0,
+        Int8,
+        Int16,
+        Int32,
+        Int64,
+        UInt8,
+        UInt16,
+        UInt32,
+        UInt64,
+        Float32,
+        Float64,
+        String,
+        FixedString,
+        DateTime,
+        Date,
+        Array,
+        Nullable,
+        Tuple,
+        Enum8,
+        Enum16,
+        UUID,
+        IPv4,
+        IPv6,
+        Int128,
+        UInt128,
+        Decimal,
+        Decimal32,
+        Decimal64,
+        Decimal128,
+        LowCardinality,
+        DateTime64,
+        Date32,
+        Map,
+        Point,
+        Ring,
+        Polygon,
+        MultiPolygon,
+        Time,
+        Time64,
+    };
+
+    using EnumItem = std::pair<std::string /* name */, int16_t /* value */>;
+
+protected:
+    Type(const Code code);
+
+public:
+    template <typename Derived>
+    auto* As() {
+        return static_cast<Derived*>(this);
+    }
+
+    template <typename Derived>
+    const auto* As() const {
+        return static_cast<const Derived*>(this);
+    }
+
+    /// Type's code.
+    Code GetCode() const { return code_; }
+
+    /// String representation of the type.
+    std::string GetName() const;
+
+    /// Is given type same as current one.
+    bool IsEqual(const Type& other) const {
+        // Types are equal only if both code_ and type_unique_id_ are equal.
+        return this == &other
+                // GetTypeUniqueId() is relatively heavy, so avoid calling it when comparing obviously different types.
+                || (this->GetCode() == other.GetCode() && this->GetTypeUniqueId() == other.GetTypeUniqueId());
+    }
+
+    bool IsEqual(const TypeRef& other) const { return IsEqual(*other); }
+
+    /// Simple name, doesn't depend on parameters and\or nested types, caller MUST NOT free returned value.
+    static const char* TypeName(Code);
+
+public:
+    static TypeRef CreateArray(TypeRef item_type);
+
+    static TypeRef CreateDate();
+
+    static TypeRef CreateDate32();
+
+    static TypeRef CreateDateTime(std::string timezone = std::string());
+
+    static TypeRef CreateDateTime64(size_t precision, std::string timezone = std::string());
+
+    static TypeRef CreateDecimal(size_t precision, size_t scale);
+
+    static TypeRef CreateIPv4();
+
+    static TypeRef CreateIPv6();
+
+    static TypeRef CreateNothing();
+
+    static TypeRef CreateNullable(TypeRef nested_type);
+
+    template <typename T>
+    static TypeRef CreateSimple();
+
+    static TypeRef CreateString();
+
+    static TypeRef CreateString(size_t n);
+
+    static TypeRef CreateTuple(const std::vector<TypeRef>& item_types);
+
+    static TypeRef CreateEnum8(const std::vector<EnumItem>& enum_items);
+
+    static TypeRef CreateEnum16(const std::vector<EnumItem>& enum_items);
+
+    static TypeRef CreateUUID();
+
+    static TypeRef CreateLowCardinality(TypeRef item_type);
+
+    static TypeRef CreateMap(TypeRef key_type, TypeRef value_type);
+
+    static TypeRef CreatePoint();
+
+    static TypeRef CreateRing();
+
+    static TypeRef CreatePolygon();
+
+    static TypeRef CreateMultiPolygon();
+
+    static TypeRef CreateTime();
+
+    static TypeRef CreateTime64(size_t precision);
+
+private:
+    uint64_t GetTypeUniqueId() const;
+
+    const Code code_;
+    mutable std::atomic<uint64_t> type_unique_id_;
+};
+
+inline bool operator==(const Type & left, const Type & right) {
+    if (&left == &right)
+        return true;
+    if (typeid(left) == typeid(right))
+        return left.IsEqual(right);
+    return false;
+}
+
+inline bool operator==(const TypeRef & left, const TypeRef & right) {
+    return *left == *right;
+}
+
+class ArrayType : public Type {
+public:
+    explicit ArrayType(TypeRef item_type);
+
+    std::string GetName() const { return std::string("Array(") + item_type_->GetName() + ")"; }
+
+    /// Type of array's elements.
+    inline TypeRef GetItemType() const { return item_type_; }
+
+private:
+    TypeRef item_type_;
+};
+
+class DecimalType : public Type {
+public:
+    DecimalType(size_t precision, size_t scale);
+
+    std::string GetName() const;
+    friend class EnumType;
+    friend class DateTimeType;
+
+    inline size_t GetScale() const { return scale_; }
+    inline size_t GetPrecision() const { return precision_; }
+
+private:
+    const size_t precision_, scale_;
+};
+
+namespace details
+{
+class TypeWithTimeZoneMixin
+{
+public:
+    TypeWithTimeZoneMixin(std::string timezone);
+
+    /// Timezone associated with a data column.
+    const std::string & Timezone() const;
+
+private:
+    std::string timezone_;
+};
+}
+
+class Time64Type : public Type {
+public:
+    explicit Time64Type(size_t precision);
+
+    std::string GetName() const;
+
+    inline size_t GetPrecision() const { return precision_; }
+
+private:
+    size_t precision_;
+};
+
+class DateTimeType : public Type, public details::TypeWithTimeZoneMixin {
+public:
+    explicit DateTimeType(std::string timezone);
+
+    std::string GetName() const;
+};
+
+class DateTime64Type: public Type, public details::TypeWithTimeZoneMixin {
+public:
+    explicit DateTime64Type(size_t precision, std::string timezone_);
+
+    std::string GetName() const;
+
+    inline size_t GetPrecision() const { return precision_; }
+private:
+    size_t precision_;
+};
+
+class EnumType : public Type {
+public:
+    EnumType(Type::Code type, const std::vector<EnumItem>& items);
+
+    std::string GetName() const;
+
+    /// Methods to work with enum types.
+    std::string_view GetEnumName(int16_t value) const;
+    int16_t GetEnumValue(const std::string& name) const;
+    bool HasEnumName(const std::string& name) const;
+    bool HasEnumValue(int16_t value) const;
+
+private:
+    using ValueToNameType     = std::map<int16_t, std::string_view>;
+    using NameToValueType     = std::map<std::string, int16_t>;
+    using ValueToNameIterator = ValueToNameType::const_iterator;
+
+    ValueToNameType value_to_name_;
+    NameToValueType name_to_value_;
+
+public:
+    ValueToNameIterator BeginValueToName() const;
+    ValueToNameIterator EndValueToName() const;
+};
+
+class FixedStringType : public Type {
+public:
+    explicit FixedStringType(size_t n);
+
+    std::string GetName() const { return std::string("FixedString(") + std::to_string(size_) + ")"; }
+
+    inline size_t GetSize() const { return size_; }
+
+private:
+    size_t size_;
+};
+
+class NullableType : public Type {
+public:
+    explicit NullableType(TypeRef nested_type);
+
+    std::string GetName() const { return std::string("Nullable(") + nested_type_->GetName() + ")"; }
+
+    /// Type of nested nullable element.
+    TypeRef GetNestedType() const { return nested_type_; }
+
+private:
+    TypeRef nested_type_;
+};
+
+class TupleType : public Type {
+public:
+    explicit TupleType(const std::vector<TypeRef>& item_types);
+
+    std::string GetName() const;
+
+    /// Type of nested Tuple element type.
+    std::vector<TypeRef> GetTupleType() const { return item_types_; }
+
+private:
+    std::vector<TypeRef> item_types_;
+};
+
+class LowCardinalityType : public Type {
+public:
+    explicit LowCardinalityType(TypeRef nested_type);
+    ~LowCardinalityType();
+
+    std::string GetName() const { return std::string("LowCardinality(") + nested_type_->GetName() + ")"; }
+
+    /// Type of nested nullable element.
+    TypeRef GetNestedType() const { return nested_type_; }
+
+private:
+    TypeRef nested_type_;
+};
+
+class MapType : public Type {
+public:
+    explicit MapType(TypeRef key_type, TypeRef value_type);
+
+    std::string GetName() const;
+
+    /// Type of keys.
+    TypeRef GetKeyType() const { return key_type_; }
+
+    /// Type of values.
+    TypeRef GetValueType() const { return value_type_; }
+
+private:
+    TypeRef key_type_;
+    TypeRef value_type_;
+};
+
+template <>
+inline TypeRef Type::CreateSimple<int8_t>() {
+    return TypeRef(new Type(Int8));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<int16_t>() {
+    return TypeRef(new Type(Int16));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<int32_t>() {
+    return TypeRef(new Type(Int32));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<int64_t>() {
+    return TypeRef(new Type(Int64));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<Int128>() {
+    return TypeRef(new Type(Int128));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<UInt128>() {
+    return TypeRef(new Type(UInt128));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<uint8_t>() {
+    return TypeRef(new Type(UInt8));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<uint16_t>() {
+    return TypeRef(new Type(UInt16));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<uint32_t>() {
+    return TypeRef(new Type(UInt32));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<uint64_t>() {
+    return TypeRef(new Type(UInt64));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<float>() {
+    return TypeRef(new Type(Float32));
+}
+
+template <>
+inline TypeRef Type::CreateSimple<double>() {
+    return TypeRef(new Type(Float64));
+}
+
+}  // namespace clickhouse

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/version.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#define CLICKHOUSE_CPP_VERSION_MAJOR 2
+#define CLICKHOUSE_CPP_VERSION_MINOR 6
+#define CLICKHOUSE_CPP_VERSION_PATCH 1
+
+#define CLICKHOUSE_CPP_VERSION_BUILD 0
+
+// Expecting each version component to be less than 99
+#define CLICKHOUSE_CPP_VERSION \
+    CLICKHOUSE_CPP_VERSION_MAJOR *   100 * 100 * 100 \
+    + CLICKHOUSE_CPP_VERSION_MINOR * 100 * 100 \
+    + CLICKHOUSE_CPP_VERSION_PATCH * 100 \
+    + CLICKHOUSE_CPP_VERSION_BUILD

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/Findcityhash.cmake

@@ -0,0 +1,26 @@
+find_path(cityhash_INCLUDE_DIR
+  NAMES city.h
+  DOC "cityhash include directory")
+mark_as_advanced(cityhash_INCLUDE_DIR)
+find_library(cityhash_LIBRARY
+  NAMES cityhash libcityhash
+  DOC "cityhash library")
+mark_as_advanced(cityhash_LIBRARY)
+
+# Unlike lz4, cityhash's version information does not seem to be available.
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(cityhash
+  REQUIRED_VARS cityhash_LIBRARY cityhash_INCLUDE_DIR)
+
+if (cityhash_FOUND)
+  set(cityhash_INCLUDE_DIRS "${cityhash_INCLUDE_DIR}")
+  set(cityhash_LIBRARIES "${cityhash_LIBRARY}")
+
+  if (NOT TARGET cityhash::cityhash)
+    add_library(cityhash::cityhash UNKNOWN IMPORTED)
+    set_target_properties(cityhash::cityhash PROPERTIES
+      IMPORTED_LOCATION "${cityhash_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${cityhash_INCLUDE_DIR}")
+  endif ()
+endif ()

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/Findlz4.cmake

@@ -0,0 +1,39 @@
+find_path(lz4_INCLUDE_DIR
+  NAMES lz4.h
+  DOC "lz4 include directory")
+mark_as_advanced(lz4_INCLUDE_DIR)
+find_library(lz4_LIBRARY
+  NAMES lz4 liblz4
+  DOC "lz4 library")
+mark_as_advanced(lz4_LIBRARY)
+
+if (lz4_INCLUDE_DIR)
+  file(STRINGS "${lz4_INCLUDE_DIR}/lz4.h" _lz4_version_lines
+    REGEX "#define[ \t]+LZ4_VERSION_(MAJOR|MINOR|RELEASE)")
+  string(REGEX REPLACE ".*LZ4_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lz4_version_major "${_lz4_version_lines}")
+  string(REGEX REPLACE ".*LZ4_VERSION_MINOR *\([0-9]*\).*" "\\1" _lz4_version_minor "${_lz4_version_lines}")
+  string(REGEX REPLACE ".*LZ4_VERSION_RELEASE *\([0-9]*\).*" "\\1" _lz4_version_release "${_lz4_version_lines}")
+  set(lz4_VERSION "${_lz4_version_major}.${_lz4_version_minor}.${_lz4_version_release}")
+  unset(_lz4_version_major)
+  unset(_lz4_version_minor)
+  unset(_lz4_version_release)
+  unset(_lz4_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(lz4
+  REQUIRED_VARS lz4_LIBRARY lz4_INCLUDE_DIR
+  VERSION_VAR lz4_VERSION)
+
+if (lz4_FOUND)
+  set(lz4_INCLUDE_DIRS "${lz4_INCLUDE_DIR}")
+  set(lz4_LIBRARIES "${lz4_LIBRARY}")
+
+  if (NOT TARGET lz4::lz4)
+    add_library(lz4::lz4 UNKNOWN IMPORTED)
+    set_target_properties(lz4::lz4 PROPERTIES
+      INCLUDE_DIRECTORIES ${lz4_INCLUDE_DIRS}
+      IMPORTED_LOCATION "${lz4_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${lz4_INCLUDE_DIR}")
+  endif ()
+endif ()

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/Findzstd.cmake

@@ -0,0 +1,39 @@
+find_path(zstd_INCLUDE_DIR
+  NAMES zstd.h
+  DOC "zstd include directory")
+mark_as_advanced(zstd_INCLUDE_DIR)
+find_library(zstd_LIBRARY
+  NAMES zstd libzstd
+  DOC "zstd library")
+mark_as_advanced(zstd_LIBRARY)
+
+if (zstd_INCLUDE_DIR)
+  file(STRINGS "${zstd_INCLUDE_DIR}/zstd.h" _zstd_version_lines
+    REGEX "#define[ \t]+ZSTD_VERSION_(MAJOR|MINOR|RELEASE)")
+  string(REGEX REPLACE ".*ZSTD_VERSION_MAJOR *\([0-9]*\).*" "\\1" _zstd_version_major "${_zstd_version_lines}")
+  string(REGEX REPLACE ".*ZSTD_VERSION_MINOR *\([0-9]*\).*" "\\1" _zstd_version_minor "${_zstd_version_lines}")
+  string(REGEX REPLACE ".*ZSTD_VERSION_RELEASE *\([0-9]*\).*" "\\1" _zstd_version_release "${_zstd_version_lines}")
+  set(zstd_VERSION "${_zstd_version_major}.${_zstd_version_minor}.${_zstd_version_release}")
+  unset(_zstd_version_major)
+  unset(_zstd_version_minor)
+  unset(_zstd_version_release)
+  unset(_zstd_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(zstd
+  REQUIRED_VARS zstd_LIBRARY zstd_INCLUDE_DIR
+  VERSION_VAR zstd_VERSION)
+
+if (zstd_FOUND)
+  set(zstd_INCLUDE_DIRS "${zstd_INCLUDE_DIR}")
+  set(zstd_LIBRARIES "${zstd_LIBRARY}")
+
+  if (NOT TARGET zstd::zstd)
+    add_library(zstd::zstd UNKNOWN IMPORTED)
+    set_target_properties(zstd::zstd PROPERTIES
+      INCLUDE_DIRECTORIES ${zstd_INCLUDE_DIRS}
+      IMPORTED_LOCATION "${zstd_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${zstd_INCLUDE_DIR}")
+  endif ()
+endif ()

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/cpp17.cmake

@@ -0,0 +1,8 @@
+MACRO (USE_CXX17)
+    IF (CMAKE_VERSION VERSION_LESS "3.1")
+      SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+    ELSE ()
+      SET (CMAKE_CXX_STANDARD 17)
+      SET (CMAKE_CXX_STANDARD_REQUIRED ON)
+    ENDIF ()
+ENDMACRO (USE_CXX17)

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/openssl.cmake

@@ -0,0 +1,8 @@
+MACRO (USE_OPENSSL)
+
+    IF (WITH_OPENSSL)
+        FIND_PACKAGE (OpenSSL REQUIRED)
+        ADD_COMPILE_DEFINITIONS (WITH_OPENSSL=1)
+    ENDIF ()
+
+ENDMACRO ()

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/subdirs.cmake

@@ -0,0 +1,5 @@
+FUNCTION (SUBDIRS)
+    FOREACH (dir ${ARGV})
+        ADD_SUBDIRECTORY (${dir})
+    ENDFOREACH(dir)
+ENDFUNCTION (SUBDIRS)

data/ext/clickhouse_native/vendor/clickhouse-cpp/cmake/version.cmake

@@ -0,0 +1,87 @@
+# Set version value for the project and validate that it matches version reported by git.
+
+# Reference values are taken from the version.h.
+# So even if the library code is decoupled from the cmake-specific project,
+# source files still have proper version information.
+
+function (regex_extract_matching_groups INPUT REGEX_STR)
+    string (REGEX MATCHALL "${REGEX_STR}" _ "${INPUT}")
+    if (NOT CMAKE_MATCH_0)
+        return()
+    endif()
+
+    set (MATCH_GROUP_INDEX 0)
+    foreach (OUTPUT_VAR ${ARGN})
+        math (EXPR MATCH_GROUP_INDEX "${MATCH_GROUP_INDEX}+1")
+        set (MATCH_GROUP_VALUE "${CMAKE_MATCH_${MATCH_GROUP_INDEX}}")
+        set ("${OUTPUT_VAR}" "${MATCH_GROUP_VALUE}" PARENT_SCOPE)
+    endforeach ()
+endfunction ()
+
+
+function(clickhouse_cpp_get_version)
+    # Extract all components of the version from the clickhouse/version.h
+
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/clickhouse/version.h VERSION_FILE_DATA)
+
+    foreach (VERSION_COMPONENT
+            IN ITEMS
+            CLICKHOUSE_CPP_VERSION_MAJOR
+            CLICKHOUSE_CPP_VERSION_MINOR
+            CLICKHOUSE_CPP_VERSION_PATCH
+            CLICKHOUSE_CPP_VERSION_BUILD)
+
+        regex_extract_matching_groups(
+            "${VERSION_FILE_DATA}"
+            "#define ${VERSION_COMPONENT} ([0-9]+)"
+            "${VERSION_COMPONENT}")
+
+        set ("${VERSION_COMPONENT}" "${${VERSION_COMPONENT}}" PARENT_SCOPE)
+    endforeach ()
+
+    set(CLICKHOUSE_CPP_VERSION "${CLICKHOUSE_CPP_VERSION_MAJOR}.${CLICKHOUSE_CPP_VERSION_MINOR}.${CLICKHOUSE_CPP_VERSION_PATCH}" PARENT_SCOPE)
+endfunction()
+
+clickhouse_cpp_get_version()
+
+function(clickhouse_cpp_check_library_version CHECK_MODE)
+## Verify that current tag matches the version
+
+    find_program (GIT git)
+    if (GIT)
+        execute_process(
+            COMMAND ${GIT} describe --tags
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_DESCRIBE_DATA
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+
+        regex_extract_matching_groups(
+            "${GIT_DESCRIBE_DATA}"
+            "^v([0-9]+)\\.([0-9]+)\\.([0-9]+)(\\-([0-9]+).*)?"
+            VERSION_FROM_GIT_DESCRIBE_MAJOR
+            VERSION_FROM_GIT_DESCRIBE_MINOR
+            VERSION_FROM_GIT_DESCRIBE_PATCH
+            CLICKHOUSE_CPP_VERSION_COMMIT
+        )
+
+        if (NOT (VERSION_FROM_GIT_DESCRIBE_MAJOR AND VERSION_FROM_GIT_DESCRIBE_MINOR AND VERSION_FROM_GIT_DESCRIBE_PATCH))
+            message (${CHECK_MODE} "version obtained from `git describe` doesn't look like a valid version: \"${GIT_DESCRIBE_DATA}\"")
+            return ()
+        endif ()
+
+      set (EXPECTED_CLICKHOUSE_CPP_VERSION "${VERSION_FROM_GIT_DESCRIBE_MAJOR}.${VERSION_FROM_GIT_DESCRIBE_MINOR}.${VERSION_FROM_GIT_DESCRIBE_PATCH}")
+      if (NOT "${EXPECTED_CLICKHOUSE_CPP_VERSION}" STREQUAL ${CLICKHOUSE_CPP_VERSION})
+          message(${CHECK_MODE} "update CLICKHOUSE_CPP_VERSION_ values in version.h.\n"
+"git reports version as \"${GIT_DESCRIBE_DATA}\","
+" hence expecting version to be ${EXPECTED_CLICKHOUSE_CPP_VERSION}, "
+" instead got ${CLICKHOUSE_CPP_VERSION}")
+      endif ()
+    else ()
+      message (${CHECK_MODE} "git is not found, can't verify library version")
+    endif ()
+
+    message("Version check passed: ${CLICKHOUSE_CPP_VERSION}")
+endfunction()
+
+# clickhouse_cpp_check_library_version()

data/ext/clickhouse_native/vendor/clickhouse-cpp/contrib/absl/absl/CMakeLists.txt

@@ -0,0 +1,9 @@
+ADD_LIBRARY (absl_int128 STATIC
+    numeric/int128.cc
+)
+
+TARGET_INCLUDE_DIRECTORIES (absl_int128
+    PUBLIC ${PROJECT_SOURCE_DIR}/contrib/absl
+)
+
+ADD_LIBRARY (absl::int128 ALIAS absl_int128)