clickhouse-native 0.0.1

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/query.cpp

@@ -0,0 +1,25 @@
+#include "query.h"
+
+namespace clickhouse {
+
+const std::string Query::default_query_id = {};
+
+Query::Query()
+{ }
+
+Query::Query(const char* query, const char* query_id)
+    : query_(query)
+    , query_id_(query_id ? std::string(query_id): default_query_id)
+{
+}
+
+Query::Query(const std::string& query, const std::string& query_id)
+    : query_(query)
+    , query_id_(query_id)
+{
+}
+
+Query::~Query()
+{ }
+
+}

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

@@ -0,0 +1,246 @@
+#pragma once
+
+#include "block.h"
+#include "server_exception.h"
+
+#include "base/open_telemetry.h"
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace clickhouse {
+
+struct QuerySettingsField {
+    enum Flags : uint64_t
+    {
+        IMPORTANT = 0x01,
+        CUSTOM = 0x02,
+        OBSOLETE = 0x04,
+    };
+    std::string value;
+    uint64_t flags{0};
+};
+
+using QuerySettings = std::unordered_map<std::string, QuerySettingsField>;
+using QueryParamValue = std::optional<std::string>;
+using QueryParams = std::unordered_map<std::string, QueryParamValue>;
+
+struct Profile {
+    uint64_t rows = 0;
+    uint64_t blocks = 0;
+    uint64_t bytes = 0;
+    uint64_t rows_before_limit = 0;
+    bool applied_limit = false;
+    bool calculated_rows_before_limit = false;
+};
+
+
+struct Progress {
+    uint64_t rows = 0;
+    uint64_t bytes = 0;
+    uint64_t total_rows = 0;
+    uint64_t written_rows = 0;
+    uint64_t written_bytes = 0;
+};
+
+
+class QueryEvents {
+public:
+    virtual ~QueryEvents()
+    { }
+
+    /// Some data was received.
+    virtual void OnData(const Block& block) = 0;
+    virtual bool OnDataCancelable(const Block& block) = 0;
+
+    virtual void OnServerException(const Exception& e) = 0;
+
+    virtual void OnProfile(const Profile& profile) = 0;
+
+    virtual void OnProgress(const Progress& progress) = 0;
+
+    /** Handle query execution logs provided by server.
+     *  Amount of logs regulated by `send_logs_level` setting.
+     *  By-default only `fatal` log events are sent to the client side.
+     */
+    virtual void OnServerLog(const Block& block) = 0;
+
+    /// Handle query execution profile events.
+    virtual void OnProfileEvents(const Block& block) = 0;
+
+    virtual void OnFinish() = 0;
+};
+
+
+using ExceptionCallback        = std::function<void(const Exception& e)>;
+using ProgressCallback         = std::function<void(const Progress& progress)>;
+using SelectCallback           = std::function<void(const Block& block)>;
+using SelectCancelableCallback = std::function<bool(const Block& block)>;
+using SelectServerLogCallback  = std::function<bool(const Block& block)>;
+using ProfileEventsCallback    = std::function<bool(const Block& block)>;
+using ProfileCallback          = std::function<void(const Profile& profile)>;
+
+
+class Query : public QueryEvents {
+public:
+     Query();
+     Query(const char* query, const char* query_id = nullptr);
+     Query(const std::string& query, const std::string& query_id = default_query_id);
+    ~Query() override;
+
+    ///
+    inline const std::string& GetText() const {
+        return query_;
+    }
+
+    inline const std::string& GetQueryID() const {
+        return query_id_;
+    }
+
+    inline const QuerySettings& GetQuerySettings() const {
+        return query_settings_;
+    }
+
+    /// Set per query settings
+    inline Query& SetQuerySettings(QuerySettings query_settings) {
+        query_settings_ = std::move(query_settings);
+        return *this;
+    }
+
+    /// Set per query setting
+    inline Query& SetSetting(const std::string& key, const QuerySettingsField& value) {
+        query_settings_[key] = value;
+        return *this;
+    }
+
+    inline const QueryParams& GetParams() const { return query_params_; }
+
+    inline Query& SetParams(QueryParams query_params) {
+        query_params_ = std::move(query_params);
+        return *this;
+    }
+
+    inline Query& SetParam(const std::string& name, const QueryParamValue& value) {
+        query_params_[name] = value;
+        return *this;
+    }
+
+    inline const std::optional<open_telemetry::TracingContext>& GetTracingContext() const {
+        return tracing_context_;
+    }
+
+    /// Set tracing context for open telemetry signals
+    inline Query& SetTracingContext(open_telemetry::TracingContext tracing_context) {
+        tracing_context_ = std::move(tracing_context);
+        return *this;
+    }
+
+    /// Set handler for receiving result data.
+    inline Query& OnData(SelectCallback cb) {
+        select_cb_ = std::move(cb);
+        return *this;
+    }
+
+    inline Query& OnDataCancelable(SelectCancelableCallback cb) {
+        select_cancelable_cb_ = std::move(cb);
+        return *this;
+    }
+
+    /// Set handler for receiving server's exception.
+    inline Query& OnException(ExceptionCallback cb) {
+        exception_cb_ = std::move(cb);
+        return *this;
+    }
+
+    /// Set handler for receiving a progress of query execution.
+    inline Query& OnProgress(ProgressCallback cb) {
+        progress_cb_ = std::move(cb);
+        return *this;
+    }
+
+    /// Set handler for receiving a server log of query exceution.
+    inline Query& OnServerLog(SelectServerLogCallback cb) {
+        select_server_log_cb_ = std::move(cb);
+        return *this;
+    }
+
+    /// Set handler for receiving profile events.
+    inline Query& OnProfileEvents(ProfileEventsCallback cb) {
+        profile_events_callback_cb_ = std::move(cb);
+        return *this;
+    }
+
+    inline Query& OnProfile(ProfileCallback cb) {
+        profile_callback_cb_ = std::move(cb);
+        return *this;
+    }
+
+    static const std::string default_query_id;
+
+private:
+    void OnData(const Block& block) override {
+        if (select_cb_) {
+            select_cb_(block);
+        }
+    }
+
+    bool OnDataCancelable(const Block& block) override {
+        if (select_cancelable_cb_) {
+            return select_cancelable_cb_(block);
+        } else {
+            return true;
+        }
+    }
+
+    void OnServerException(const Exception& e) override {
+        if (exception_cb_) {
+            exception_cb_(e);
+        }
+    }
+
+    void OnProfile(const Profile& profile) override {
+        if (profile_callback_cb_)
+            profile_callback_cb_(profile);
+    }
+
+    void OnProgress(const Progress& progress) override {
+        if (progress_cb_) {
+            progress_cb_(progress);
+        }
+    }
+
+    void OnServerLog(const Block& block) override {
+        if (select_server_log_cb_) {
+            select_server_log_cb_(block);
+        }
+    }
+
+    void OnProfileEvents(const Block& block) override {
+        if (profile_events_callback_cb_) {
+            profile_events_callback_cb_(block);
+        }
+    }
+
+    void OnFinish() override {
+    }
+
+private:
+    const std::string query_;
+    const std::string query_id_;
+    std::optional<open_telemetry::TracingContext> tracing_context_;
+    QuerySettings query_settings_;
+    QueryParams query_params_;
+    ExceptionCallback exception_cb_;
+    ProgressCallback progress_cb_;
+    SelectCallback select_cb_;
+    SelectCancelableCallback select_cancelable_cb_;
+    SelectServerLogCallback select_server_log_cb_;
+    ProfileEventsCallback profile_events_callback_cb_;
+    ProfileCallback profile_callback_cb_;
+};
+
+}

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

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+namespace clickhouse {
+struct Exception {
+    int code = 0;
+    std::string name;
+    std::string display_text;
+    std::string stack_trace;
+    /// Pointer to nested exception.
+    std::unique_ptr<Exception> nested;
+};
+
+}

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

@@ -0,0 +1,314 @@
+#include "type_parser.h"
+
+#include "clickhouse/exceptions.h"
+#include "clickhouse/base/platform.h" // for _win_
+
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <mutex>
+#include <unordered_map>
+
+#if defined _win_
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+
+
+namespace clickhouse {
+
+bool TypeAst::operator==(const TypeAst & other) const {
+    return meta == other.meta
+        && code == other.code
+        && name == other.name
+        && value == other.value
+        && std::equal(elements.begin(), elements.end(), other.elements.begin(), other.elements.end());
+}
+
+static const std::unordered_map<std::string, Type::Code> kTypeCode = {
+    { "Void",        Type::Void },
+    { "Int8",        Type::Int8 },
+    { "Int16",       Type::Int16 },
+    { "Int32",       Type::Int32 },
+    { "Int64",       Type::Int64 },
+    { "Bool",        Type::UInt8 },
+    { "UInt8",       Type::UInt8 },
+    { "UInt16",      Type::UInt16 },
+    { "UInt32",      Type::UInt32 },
+    { "UInt64",      Type::UInt64 },
+    { "Float32",     Type::Float32 },
+    { "Float64",     Type::Float64 },
+    { "String",      Type::String },
+    { "FixedString", Type::FixedString },
+    { "DateTime",    Type::DateTime },
+    { "DateTime64",  Type::DateTime64 },
+    { "Date",        Type::Date },
+    { "Date32",      Type::Date32 },
+    { "Array",       Type::Array },
+    { "Nullable",    Type::Nullable },
+    { "Tuple",       Type::Tuple },
+    { "Enum8",       Type::Enum8 },
+    { "Enum16",      Type::Enum16 },
+    { "UUID",        Type::UUID },
+    { "IPv4",        Type::IPv4 },
+    { "IPv6",        Type::IPv6 },
+    { "Int128",      Type::Int128 },
+    { "UInt128",     Type::UInt128 },
+    { "Decimal",     Type::Decimal },
+    { "Decimal32",   Type::Decimal32 },
+    { "Decimal64",   Type::Decimal64 },
+    { "Decimal128",  Type::Decimal128 },
+    { "LowCardinality", Type::LowCardinality },
+    { "Map",         Type::Map },
+    { "Point",       Type::Point },
+    { "Ring",        Type::Ring },
+    { "Polygon",     Type::Polygon },
+    { "MultiPolygon", Type::MultiPolygon },
+    { "Time",        Type::Time },
+    { "Time64",      Type::Time64 },
+};
+
+template <typename L, typename R>
+inline int CompateStringsCaseInsensitive(const L& left, const R& right) {
+    int64_t size_diff = left.size() - right.size();
+    if (size_diff != 0)
+        return size_diff > 0 ? 1 : -1;
+
+#if defined _win_
+    return _strnicmp(left.data(), right.data(), left.size());
+#else
+    return strncasecmp(left.data(), right.data(), left.size());
+#endif
+}
+
+static Type::Code GetTypeCode(const std::string& name) {
+    auto it = kTypeCode.find(name);
+    if (it != kTypeCode.end()) {
+        return it->second;
+    }
+
+    return Type::Void;
+}
+
+static TypeAst::Meta GetTypeMeta(const StringView& name) {
+    if (name == "Array") {
+        return TypeAst::Array;
+    }
+
+    if (name == "Null") {
+        return TypeAst::Null;
+    }
+
+    if (name == "Nullable") {
+        return TypeAst::Nullable;
+    }
+
+    if (name == "Tuple") {
+        return TypeAst::Tuple;
+    }
+
+    if (name == "Enum8" || name == "Enum16") {
+        return TypeAst::Enum;
+    }
+
+    if (name == "LowCardinality") {
+        return TypeAst::LowCardinality;
+    }
+
+    if (name == "SimpleAggregateFunction") {
+        return TypeAst::SimpleAggregateFunction;
+    }
+
+    if (name == "Map") {
+        return TypeAst::Map;
+    }
+
+    return TypeAst::Terminal;
+}
+
+bool ValidateAST(const TypeAst& ast) {
+    // Void terminal that is not actually "void" produced when unknown type is encountered.
+    if (ast.meta == TypeAst::Terminal
+            && ast.code == Type::Void
+            && CompateStringsCaseInsensitive(ast.name, std::string_view("void")) != 0)
+        //throw UnimplementedError("Unsupported type: " + ast.name);
+        return false;
+
+    return true;
+}
+
+
+TypeParser::TypeParser(const StringView& name)
+    : cur_(name.data())
+    , end_(name.data() + name.size())
+    , type_(nullptr)
+{
+}
+
+TypeParser::~TypeParser() = default;
+
+bool TypeParser::Parse(TypeAst* type) {
+    type_ = type;
+    open_elements_.push(type_);
+
+    size_t processed_tokens = 0;
+    do {
+        const Token & token = NextToken();
+        switch (token.type) {
+            case Token::QuotedString:
+            {
+                type_->meta = TypeAst::Terminal;
+                if (token.value.length() < 1)
+                    type_->value_string = {};
+                else
+                    type_->value_string = token.value.substr(1, token.value.length() - 2).to_string();
+                type_->code = Type::String;
+                break;
+            }
+            case Token::Name:
+                type_->meta = GetTypeMeta(token.value);
+                type_->name = token.value.to_string();
+                type_->code = GetTypeCode(type_->name);
+                break;
+            case Token::Number:
+                type_->meta = TypeAst::Number;
+                type_->value = std::stol(token.value.to_string());
+                break;
+            case Token::String:
+                type_->meta = TypeAst::String;
+                type_->value_string = std::string(token.value);
+                break;
+            case Token::LPar:
+                type_->elements.emplace_back(TypeAst());
+                open_elements_.push(type_);
+                type_ = &type_->elements.back();
+                break;
+            case Token::RPar:
+                type_ = open_elements_.top();
+                open_elements_.pop();
+                break;
+            case Token::Assign:
+            case Token::Comma:
+                type_ = open_elements_.top();
+                open_elements_.pop();
+                type_->elements.emplace_back(TypeAst());
+                open_elements_.push(type_);
+                type_ = &type_->elements.back();
+                break;
+            case Token::EOS:
+            {
+                // Ubalanced braces, brackets, etc is an error.
+                if (open_elements_.size() != 1)
+                    return false;
+
+                // Empty input string, no tokens produced
+                if (processed_tokens == 0)
+                    return false;
+
+                return ValidateAST(*type);
+            }
+            case Token::Invalid:
+                return false;
+        }
+        ++processed_tokens;
+    } while (true);
+}
+
+TypeParser::Token TypeParser::NextToken() {
+    for (; cur_ < end_; ++cur_) {
+        switch (*cur_) {
+            case ' ':
+            case '\n':
+            case '\t':
+            case '\0':
+                continue;
+            case '=':
+                return Token{Token::Assign, StringView(cur_++, 1)};
+            case '(':
+                return Token{Token::LPar, StringView(cur_++, 1)};
+            case ')':
+                return Token{Token::RPar, StringView(cur_++, 1)};
+            case ',':
+                return Token{Token::Comma, StringView(cur_++, 1)};
+            case '\'':
+            {
+                const auto end_quote_length = 1;
+                const StringView end_quote{cur_, end_quote_length};
+                // Fast forward to the closing quote.
+                const auto start = cur_++;
+                for (; cur_ < end_ - end_quote_length; ++cur_) {
+                    // TODO (nemkov): handle escaping ?
+                    if (end_quote == StringView{cur_, end_quote_length}) {
+                        cur_ += end_quote_length;
+
+                        return Token{Token::QuotedString, StringView{start, cur_}};
+                    }
+                }
+                return Token{Token::QuotedString, StringView(cur_++, 1)};
+            }
+
+            default: {
+                const char* st = cur_;
+
+                if (*cur_ == '\'') {
+                    for (st = ++cur_; cur_ < end_; ++cur_) {
+                        if (*cur_ == '\'') {
+                            return Token{Token::String, StringView(st, cur_++ - st)};
+                        }
+                    }
+
+                    return Token{Token::Invalid, StringView()};
+                }
+
+                if (isalpha(*cur_) || *cur_ == '_') {
+                    for (; cur_ < end_; ++cur_) {
+                        if (!isalpha(*cur_) && !isdigit(*cur_) && *cur_ != '_') {
+                            break;
+                        }
+                    }
+
+                    return Token{Token::Name, StringView(st, cur_)};
+                }
+
+                if (isdigit(*cur_) || *cur_ == '-') {
+                    for (++cur_; cur_ < end_; ++cur_) {
+                        if (!isdigit(*cur_)) {
+                            break;
+                        }
+                    }
+
+                    return Token{Token::Number, StringView(st, cur_)};
+                }
+
+                return Token{Token::Invalid, StringView()};
+            }
+        }
+    }
+
+    return Token{Token::EOS, StringView()};
+}
+
+
+const TypeAst* ParseTypeName(const std::string& type_name) {
+    // Cache for type_name.
+    // Usually we won't have too many type names in the cache, so do not try to
+    // limit cache size.
+    static std::map<std::string, TypeAst> ast_cache;
+    static std::mutex lock;
+
+    std::lock_guard<std::mutex> guard(lock);
+    auto it = ast_cache.find(type_name);
+    if (it != ast_cache.end()) {
+        return &it->second;
+    }
+
+    auto& ast = ast_cache[type_name];
+    if (TypeParser(type_name).Parse(&ast)) {
+        return &ast;
+    }
+    ast_cache.erase(type_name);
+    return nullptr;
+}
+
+}

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

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "../base/string_view.h"
+#include "types.h"
+
+#include <list>
+#include <stack>
+#include <string>
+
+namespace clickhouse {
+
+struct TypeAst {
+    enum Meta {
+        Array,
+        Assign,
+        Null,
+        Nullable,
+        Number,
+        String,
+        Terminal,
+        Tuple,
+        Enum,
+        LowCardinality,
+        SimpleAggregateFunction,
+        Map
+    };
+
+    /// Type's category.
+    Meta meta;
+    Type::Code code;
+    /// Type's name.
+    /// Need to cache TypeAst, so can't use StringView for name.
+    std::string name;
+    /// Value associated with the node,
+    /// used for fixed-width types and enum values.
+    int64_t value = 0;
+    std::string value_string;
+    /// Subelements of the type.
+    /// Used to store enum's names and values as well.
+    std::vector<TypeAst> elements;
+
+    bool operator==(const TypeAst & other) const;
+    inline bool operator!=(const TypeAst & other) const {
+        return !(*this == other);
+    }
+};
+
+
+class TypeParser {
+
+    struct Token {
+        enum Type {
+            Invalid = 0,
+            Assign,
+            Name,
+            Number,
+            String,
+            LPar,
+            RPar,
+            Comma,
+            QuotedString, // string with quotation marks included
+            EOS,
+        };
+
+        Type type;
+        StringView value;
+    };
+
+public:
+    explicit TypeParser(const StringView& name);
+    ~TypeParser();
+
+    bool Parse(TypeAst* type);
+
+private:
+    Token NextToken();
+
+private:
+    const char* cur_;
+    const char* end_;
+
+    TypeAst* type_;
+    std::stack<TypeAst*> open_elements_;
+};
+
+
+const TypeAst* ParseTypeName(const std::string& type_name);
+
+}