clickhouse-native 0.0.1

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

@@ -0,0 +1,320 @@
+#pragma once
+
+#include "query.h"
+#include "exceptions.h"
+
+#include "columns/array.h"
+#include "columns/date.h"
+#include "columns/decimal.h"
+#include "columns/enum.h"
+#include "columns/geo.h"
+#include "columns/ip4.h"
+#include "columns/ip6.h"
+#include "columns/lowcardinality.h"
+#include "columns/nothing.h"
+#include "columns/nullable.h"
+#include "columns/numeric.h"
+#include "columns/map.h"
+#include "columns/string.h"
+#include "columns/tuple.h"
+#include "columns/time.h"
+#include "columns/uuid.h"
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <optional>
+
+typedef struct ssl_ctx_st SSL_CTX;
+
+namespace clickhouse {
+
+struct ServerInfo {
+    std::string name;
+    std::string timezone;
+    std::string display_name;
+    uint64_t    version_major;
+    uint64_t    version_minor;
+    uint64_t    version_patch;
+    uint64_t    revision;
+};
+
+/// Methods of block compression.
+enum class CompressionMethod : int8_t {
+    None = -1,
+    LZ4  = 1,
+    ZSTD = 2,
+};
+
+struct Endpoint {
+    std::string host;
+    uint16_t port = 9000;
+    inline bool operator==(const Endpoint& right) const {
+        return host == right.host && port == right.port;
+    }
+};
+
+enum class EndpointsIterationAlgorithm {
+    RoundRobin = 0,
+};
+
+struct ClientOptions {
+    // Setter goes first, so it is possible to apply 'deprecated' annotation safely.
+#define DECLARE_FIELD(name, type, setter, default_value) \
+    inline auto & setter(const type& value) { \
+        name = value; \
+        return *this; \
+    } \
+    type name = default_value
+
+    /// Hostname of the server.
+    DECLARE_FIELD(host, std::string, SetHost, std::string());
+    /// Service port.
+    DECLARE_FIELD(port, uint16_t, SetPort, 9000);
+
+    /** Set endpoints (host+port), only one is used.
+     * Client tries to connect to those endpoints one by one, on the round-robin basis:
+     * first default enpoint (set via SetHost() + SetPort()), then each of endpoints, from begin() to end(),
+     * the first one to establish connection is used for the rest of the session.
+     * If port isn't specified, default(9000) value will be used.
+     */
+    DECLARE_FIELD(endpoints, std::vector<Endpoint>, SetEndpoints, {});
+
+    /// Default database.
+    DECLARE_FIELD(default_database, std::string, SetDefaultDatabase, "default");
+    /// User name.
+    DECLARE_FIELD(user, std::string, SetUser, "default");
+    /// Access password.
+    DECLARE_FIELD(password, std::string, SetPassword, std::string());
+
+    /// By default all exceptions received during query execution will be
+    /// passed to OnException handler.  Set rethrow_exceptions to true to
+    /// enable throwing exceptions with standard c++ exception mechanism.
+    DECLARE_FIELD(rethrow_exceptions, bool, SetRethrowException, true);
+
+    /// Ping server every time before execute any query.
+    DECLARE_FIELD(ping_before_query, bool, SetPingBeforeQuery, false);
+    /// Count of retry to send request to server.
+    DECLARE_FIELD(send_retries, unsigned int, SetSendRetries, 1);
+    /// Amount of time to wait before next retry.
+    DECLARE_FIELD(retry_timeout, std::chrono::seconds, SetRetryTimeout, std::chrono::seconds(5));
+
+    /// Compression method.
+    DECLARE_FIELD(compression_method, CompressionMethod, SetCompressionMethod, CompressionMethod::None);
+
+    /// TCP Keep alive options
+    DECLARE_FIELD(tcp_keepalive, bool, TcpKeepAlive, false);
+    DECLARE_FIELD(tcp_keepalive_idle, std::chrono::seconds, SetTcpKeepAliveIdle, std::chrono::seconds(60));
+    DECLARE_FIELD(tcp_keepalive_intvl, std::chrono::seconds, SetTcpKeepAliveInterval, std::chrono::seconds(5));
+    DECLARE_FIELD(tcp_keepalive_cnt, unsigned int, SetTcpKeepAliveCount, 3);
+
+    // TCP options
+    DECLARE_FIELD(tcp_nodelay, bool, TcpNoDelay, true);
+
+    /// Connection socket connect timeout. If the timeout is negative then the connect operation will never timeout.
+    DECLARE_FIELD(connection_connect_timeout, std::chrono::milliseconds, SetConnectionConnectTimeout, std::chrono::seconds(5));
+
+    /// Connection socket timeout. If the timeout is set to zero then the operation will never timeout.
+    DECLARE_FIELD(connection_recv_timeout, std::chrono::milliseconds, SetConnectionRecvTimeout, std::chrono::milliseconds(0));
+    DECLARE_FIELD(connection_send_timeout, std::chrono::milliseconds, SetConnectionSendTimeout, std::chrono::milliseconds(0));
+
+    /** It helps to ease migration of the old codebases, which can't afford to switch
+    * to using ColumnLowCardinalityT or ColumnLowCardinality directly,
+    * but still want to benefit from smaller on-wire LowCardinality bandwidth footprint.
+    *
+    * @see LowCardinalitySerializationAdaptor, CreateColumnByType
+    */
+    [[deprecated("Makes implementation of LC(X) harder and code uglier. Will be removed in next major release (3.0) ")]]
+    DECLARE_FIELD(backward_compatibility_lowcardinality_as_wrapped_column, bool, SetBakcwardCompatibilityFeatureLowCardinalityAsWrappedColumn, false);
+
+    /** Set max size data to compress if compression enabled.
+     *
+     *  Allows choosing tradeoff between RAM\CPU:
+     *  - Lower value reduces RAM usage, but slightly increases CPU usage.
+     *  - Higher value increases RAM usage but slightly decreases CPU usage.
+     */
+    DECLARE_FIELD(max_compression_chunk_size, unsigned int, SetMaxCompressionChunkSize, 65535);
+
+    struct SSLOptions {
+        /** There are two ways to configure an SSL connection:
+         *  - provide a pre-configured SSL_CTX, which is not modified and not owned by the Client.
+         *  - provide a set of options and allow the Client to create and configure SSL_CTX by itself.
+         */
+
+        /** Pre-configured SSL-context for SSL-connection.
+         *  If NOT null client DONES NOT take ownership of context and it must be valid for client lifetime.
+         *  If null client initlaizes OpenSSL and creates his own context, initializes it using
+         *  other options, like path_to_ca_files, path_to_ca_directory, use_default_ca_locations, etc.
+         *
+         *  Either way context is used to create an SSL-connection, which is then configured with
+         *  whatever was provided as `configuration`, `host_flags`, `skip_verification` and `use_sni`.
+         */
+        SSL_CTX * ssl_context = nullptr;
+        auto & SetExternalSSLContext(SSL_CTX * new_ssl_context) {
+            ssl_context = new_ssl_context;
+            return *this;
+        }
+
+        /** Means to validate the server-supplied certificate against trusted Certificate Authority (CA).
+         *  If no CAs are configured, the server's identity can't be validated, and the Client would err.
+         *  See https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_default_verify_paths.html
+        */
+        /// Load default CA certificates from default locations.
+        DECLARE_FIELD(use_default_ca_locations, bool, SetUseDefaultCALocations, true);
+        /// Path to the CA files to verify server certificate, may be empty.
+        DECLARE_FIELD(path_to_ca_files, std::vector<std::string>, SetPathToCAFiles, {});
+        /// Path to the directory with CA files used to validate server certificate, may be empty.
+        DECLARE_FIELD(path_to_ca_directory, std::string, SetPathToCADirectory, "");
+
+        /** Min and max protocol versions to use, set with SSL_CTX_set_min_proto_version and SSL_CTX_set_max_proto_version
+         *  for details see https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_min_proto_version.html
+         */
+        DECLARE_FIELD(min_protocol_version, int, SetMinProtocolVersion, DEFAULT_VALUE);
+        DECLARE_FIELD(max_protocol_version, int, SetMaxProtocolVersion, DEFAULT_VALUE);
+
+        /** Options to be set with SSL_CTX_set_options,
+         * for details see https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_options.html
+        */
+        DECLARE_FIELD(context_options, int, SetContextOptions, DEFAULT_VALUE);
+
+        /** Use SNI at ClientHello
+         */
+        DECLARE_FIELD(use_sni, bool, SetUseSNI, true);
+
+        /** Skip SSL session verification (server's certificate, etc).
+         *
+         *  WARNING: settig to true will bypass all SSL session checks, which
+         *  is dangerous, but can be used against self-signed certificates, e.g. for testing purposes.
+         */
+        DECLARE_FIELD(skip_verification, bool, SetSkipVerification, false);
+
+        /** Mode of verifying host ssl certificate against name of the host, set with SSL_set_hostflags.
+         *  For details see https://www.openssl.org/docs/man1.1.1/man3/SSL_set_hostflags.html
+         */
+        DECLARE_FIELD(host_flags, int, SetHostVerifyFlags, DEFAULT_VALUE);
+
+        struct CommandAndValue {
+            std::string command;
+            std::optional<std::string> value = std::nullopt;
+        };
+        /** Extra configuration options, set with SSL_CONF_cmd.
+         *  For deatils see https://www.openssl.org/docs/man1.1.1/man3/SSL_CONF_cmd.html
+         *
+         *  Takes multiple pairs of command-value strings, all commands are supported,
+         *  and prefix is empty.
+         *  i.e. pass `sigalgs` or `SignatureAlgorithms` instead of `-sigalgs`.
+         *
+         *  Rewrites any other options/flags if set in other ways.
+         */
+        DECLARE_FIELD(configuration, std::vector<CommandAndValue>, SetConfiguration, {});
+
+        static const int DEFAULT_VALUE = -1;
+    };
+
+    // By default SSL is turned off.
+    std::optional<SSLOptions> ssl_options = std::nullopt;
+
+    // Will throw an exception if client was built without SSL support.
+    ClientOptions& SetSSLOptions(SSLOptions options);
+
+#undef DECLARE_FIELD
+};
+
+std::ostream& operator<<(std::ostream& os, const ClientOptions& options);
+std::ostream& operator<<(std::ostream& os, const Endpoint& options);
+
+class SocketFactory;
+
+struct ExternalTable {
+  const std::string_view name;
+  const Block& data;
+};
+
+using ExternalTables = std::vector<ExternalTable>;
+
+/**
+ *
+ */
+class Client {
+public:
+     Client(const ClientOptions& opts);
+     Client(const ClientOptions& opts,
+            std::unique_ptr<SocketFactory> socket_factory);
+    ~Client();
+
+    /// Intends for execute arbitrary queries.
+    void Execute(const Query& query);
+
+    /// Intends for execute select queries.  Data will be returned with
+    /// one or more call of \p cb.
+    void Select(const std::string& query, SelectCallback cb);
+    void Select(const std::string& query, const std::string& query_id, SelectCallback cb);
+
+    /// Executes a select query which can be canceled by returning false from
+    /// the data handler function \p cb.
+    void SelectCancelable(const std::string& query, SelectCancelableCallback cb);
+    void SelectCancelable(const std::string& query, const std::string& query_id, SelectCancelableCallback cb);
+
+    // The same as Select but with an external data
+    // required for the query, see https://clickhouse.com/docs/engines/table-engines/special/external-data
+    void SelectWithExternalData(const std::string& query, const ExternalTables& external_tables, SelectCallback cb);
+    void SelectWithExternalData(const std::string& query, const std::string& query_id, const ExternalTables& external_tables, SelectCallback cb);
+
+    // The same as SelectWithExternalData but can be canceled by returning false from
+    // the data handler function \p cb.
+    void SelectWithExternalDataCancelable(const std::string& query, const ExternalTables& external_tables, SelectCancelableCallback cb);
+    void SelectWithExternalDataCancelable(const std::string& query, const std::string& query_id, const ExternalTables& external_tables, SelectCancelableCallback cb);
+
+    /// Alias for Execute.
+    void Select(const Query& query);
+
+    /// Intends for insert block of data into a table \p table_name.
+    void Insert(const std::string& table_name, const Block& block);
+    void Insert(const std::string& table_name, const std::string& query_id, const Block& block);
+
+    /// Start an \p INSERT statement, insert batches of data, then finish the insert.
+    Block BeginInsert(const std::string& query);
+    Block BeginInsert(const std::string& query, const std::string& query_id);
+
+    /// Insert data using a \p block returned by \p BeginInsert.
+    void SendInsertBlock(const Block& block);
+
+    /// End an \p INSERT session started by \p BeginInsert.
+    void EndInsert();
+
+    /// Ping server for aliveness.
+    void Ping();
+
+    /// Reset connection with initial params.
+    void ResetConnection();
+
+    const ServerInfo& GetServerInfo() const;
+
+    /// Get current connected endpoint.
+    /// In case when client is not connected to any endpoint, nullopt will returned.
+    const std::optional<Endpoint>& GetCurrentEndpoint() const;
+
+    // Try to connect to different endpoints one by one only one time. If it doesn't work, throw an exception.
+    void ResetConnectionEndpoint();
+
+    struct Version
+    {
+        uint16_t major;
+        uint16_t minor;
+        uint16_t patch;
+        uint16_t build;
+        const char * extra;
+    };
+
+    static Version GetVersion();
+
+private:
+    const ClientOptions options_;
+
+    class Impl;
+    std::unique_ptr<Impl> impl_;
+};
+
+}

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

@@ -0,0 +1,175 @@
+#include "array.h"
+#include "numeric.h"
+
+#include <stdexcept>
+
+namespace clickhouse {
+
+namespace {
+std::shared_ptr<ColumnUInt64> make_single_offset(size_t value) {
+    auto res = std::make_shared<ColumnUInt64>();
+    if (value != 0) {
+        res->Append(value);
+    }
+    return res;
+}
+}  // namespace
+
+ColumnArray::ColumnArray(ColumnRef data) : ColumnArray(data, make_single_offset(data->Size())) {
+}
+
+ColumnArray::ColumnArray(ColumnRef data, std::shared_ptr<ColumnUInt64> offsets)
+    : Column(Type::CreateArray(data->Type()))
+    , data_(data)
+    , offsets_(offsets)
+{
+    const auto rows            = offsets_->Size();
+    const auto expected_values = rows > 0 ? offsets_->At(rows - 1) : 0;
+    std::uint64_t prev         = 0;
+    // Ensure the offset array is internally consistent
+    for (const auto& o : offsets_->GetWritableData()) {
+        if (o < prev) {
+            throw ValidationError("offsets must be monotonically increasing");
+        }
+        prev = o;
+    }
+    if (data_->Size() != expected_values) {
+        throw ValidationError("Mismatch between data and offsets: Expected " + std::to_string(expected_values) +
+                              " values in data, but got " + std::to_string(data_->Size()));
+    }
+}
+
+ColumnArray::ColumnArray(ColumnArray&& other)
+    : Column(other.Type())
+    , data_(std::move(other.data_))
+    , offsets_(std::move(other.offsets_))
+{
+}
+
+void ColumnArray::AppendAsColumn(ColumnRef array) {
+    // appending data may throw (i.e. due to ype check failure), so do it first to avoid partly modified state.
+    data_->Append(array);
+    AddOffset(array->Size());
+}
+
+ColumnRef ColumnArray::GetAsColumn(size_t n) const {
+    if (n >= Size())
+        throw ValidationError("Index is out ouf bounds: " + std::to_string(n));
+
+    return data_->Slice(GetOffset(n), GetSize(n));
+}
+
+ColumnRef ColumnArray::Slice(size_t begin, size_t size) const {
+    if (size && begin + size > Size())
+        throw ValidationError("Slice indexes are out of bounds");
+
+    auto sliced_data = data_->Slice(GetOffset(begin), GetOffset(begin + size) - GetOffset(begin));
+    auto offsets     = std::make_shared<ColumnUInt64>();
+    auto offset      = uint64_t{0};
+    for (size_t i = 0; i < size; i++) {
+        offset += GetSize(begin + i);
+        offsets->Append(offset);
+    }
+
+    return std::make_shared<ColumnArray>(std::move(sliced_data), std::move(offsets));
+}
+
+ColumnRef ColumnArray::CloneEmpty() const {
+    return std::make_shared<ColumnArray>(data_->CloneEmpty());
+}
+
+void ColumnArray::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+    offsets_->Reserve(new_cap);
+}
+
+void ColumnArray::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnArray>()) {
+        for (size_t i = 0; i < col->Size(); ++i) {
+            AppendAsColumn(col->GetAsColumn(i));
+        }
+    }
+}
+
+bool ColumnArray::LoadPrefix(InputStream* input, size_t rows) {
+    if (!rows) {
+        return true;
+    }
+
+    return data_->LoadPrefix(input, rows);
+}
+
+bool ColumnArray::LoadBody(InputStream* input, size_t rows) {
+    if (!rows) {
+        return true;
+    }
+    if (!offsets_->LoadBody(input, rows)) {
+        return false;
+    }
+    const auto nested_rows = (*offsets_)[rows - 1];
+    if (nested_rows == 0) {
+        return true;
+    }
+    if (!data_->LoadBody(input, nested_rows)) {
+        return false;
+    }
+    return true;
+}
+
+void ColumnArray::SavePrefix(OutputStream* output) {
+    data_->SavePrefix(output);
+}
+
+void ColumnArray::SaveBody(OutputStream* output) {
+    offsets_->SaveBody(output);
+    if (data_->Size() > 0) {
+        data_->SaveBody(output);
+    }
+}
+
+void ColumnArray::Clear() {
+    offsets_->Clear();
+    data_->Clear();
+}
+
+size_t ColumnArray::Size() const {
+    return offsets_->Size();
+}
+
+void ColumnArray::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnArray &>(other);
+    data_.swap(col.data_);
+    offsets_.swap(col.offsets_);
+}
+
+void ColumnArray::OffsetsIncrease(size_t n) {
+    offsets_->Append(n);
+}
+
+size_t ColumnArray::GetOffset(size_t n) const {
+
+    return (n == 0) ? 0 : (*offsets_)[n - 1];
+}
+
+void ColumnArray::AddOffset(size_t n) {
+    if (offsets_->Size() == 0) {
+        offsets_->Append(n);
+    } else {
+        offsets_->Append((*offsets_)[offsets_->Size() - 1] + n);
+    }
+}
+
+size_t ColumnArray::GetSize(size_t n) const {
+    return (n == 0) ? (*offsets_)[n] : ((*offsets_)[n] - (*offsets_)[n - 1]);
+}
+
+ColumnRef ColumnArray::GetData() {
+    return data_;
+}
+
+void ColumnArray::Reset() {
+    data_.reset();
+    offsets_.reset();
+}
+
+}