clickhouse-native 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3e2cb4cbe829d9afd7e30e0ac29ea828020896c93634852b4baef007348d3b0
-  data.tar.gz: e5f13079f4de6e64e545f49736a8da6832de954dfe82f1a4d105dd1228680887
+  metadata.gz: dbc7f982fc96317d6b6721bc7162e22d01eac4f4fc9edb307443d24fdee59032
+  data.tar.gz: 824150b24641414bfc0ccc4a6e37aa521b768bb73423c1bda9c1bfbefc466044
 SHA512:
-  metadata.gz: 9998240b8ca84a4d28ad1fb956c0bf92e1893d4a9ce024fa443eefaa01efb35b657b55d8c2ce92718fd9224a5167fe0201a955f7147ab7499560a331906e2567
-  data.tar.gz: d097a39e1fa03b051a30fe1fb273a928b7e2e555e05945d32b22a9dd9dc1deaf280193b80ecae146d7d442d513bbfb6e638ba4b63589f5a58171ce4b25ba5b87
+  metadata.gz: 6cda8a41d58816d63aa064ae3008b20980d35be6f695ff04433bc760ec28c0a286b707bdeb725d5691ac8245533c05d90df4c9c5b3eb13af6b860a179d9349db
+  data.tar.gz: caf00f391e65eb920a2d917316fa05c1569b7aac7c89f83a122b149c3305a3b0b40b6dc02afa5bd1cebcd78f0897700d5a2f9fbafb2c0d327da973dd3bc542f6

data/ext/clickhouse_native/client.cpp

@@ -17,11 +17,13 @@
 #include <clickhouse/exceptions.h>
 #include <clickhouse/types/types.h>
 
+#include <chrono>
 #include <cstdint>
 #include <exception>
 #include <memory>
 #include <string>
 #include <system_error>
+#include <utility>
 #include <vector>
 
 using namespace clickhouse;
@@ -666,6 +668,11 @@ static void append_value(const ColumnRef& col, VALUE value) {
 
 struct CHClient {
     std::unique_ptr<Client> client;
+    // Session settings applied to *every* query as per-query settings, rather
+    // than a one-time session `SET`. Per-query settings ride each query packet,
+    // so they survive a transparent ping_before_query reconnect (a fresh socket
+    // would otherwise lose a session-level SET and fall back to server defaults).
+    std::vector<std::pair<std::string, std::string>> default_settings;
 };
 
 static void ch_client_free(void* p) {
@@ -707,6 +714,18 @@ static uint16_t kwarg_uint16(VALUE kwargs, const char* key, uint16_t fallback) {
     return static_cast<uint16_t>(NUM2UINT(v));
 }
 
+static bool kwarg_bool(VALUE kwargs, const char* key, bool fallback) {
+    VALUE v = rb_hash_lookup2(kwargs, ID2SYM(rb_intern(key)), Qundef);
+    if (v == Qundef) return fallback;
+    return RTEST(v);
+}
+
+static unsigned int kwarg_uint(VALUE kwargs, const char* key, unsigned int fallback) {
+    VALUE v = rb_hash_lookup2(kwargs, ID2SYM(rb_intern(key)), Qundef);
+    if (v == Qundef || NIL_P(v)) return fallback;
+    return NUM2UINT(v);
+}
+
 static CompressionMethod kwarg_compression(VALUE kwargs) {
     VALUE v = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("compression")), Qundef);
     if (v == Qundef || NIL_P(v)) return CompressionMethod::None;
@@ -742,6 +761,16 @@ static int apply_settings_cb(VALUE key, VALUE val, VALUE arg) {
     return ST_CONTINUE;
 }
 
+// Collect a `settings:` Hash into a client's default_settings vector at
+// construction. Values are stringified the same way per-query settings are.
+static int collect_setting_cb(VALUE key, VALUE val, VALUE arg) {
+    auto* vec = reinterpret_cast<std::vector<std::pair<std::string, std::string>>*>(arg);
+    VALUE k = SYMBOL_P(key) ? rb_sym2str(key) : key;
+    StringValue(k);
+    vec->emplace_back(std::string(RSTRING_PTR(k), RSTRING_LEN(k)), stringify_setting_value(val));
+    return ST_CONTINUE;
+}
+
 // Read a `settings:` Hash out of the parsed kwargs and stamp each entry
 // onto `q` as a per-query setting. No-op if kwargs is nil or settings is
 // missing/empty. Raises TypeError if settings is not a Hash.
@@ -765,6 +794,16 @@ static void apply_read_settings(Query& q, VALUE kwargs) {
     apply_settings(q, kwargs);
 }
 
+// Stamp the client's construction-time `settings:` onto `q`. Marked important
+// (flag 1) so an unknown setting name errors — matching the old session `SET`,
+// which failed loudly instead of silently ignoring a typo'd setting. Applied
+// before per-call settings so an explicit `settings:` on the call still wins.
+static void apply_default_settings(Query& q, CHClient* c) {
+    for (const auto& kv : c->default_settings) {
+        q.SetSetting(kv.first, QuerySettingsField{kv.second, 1});
+    }
+}
+
 // Client.new(host:, port:, database:, user:, password:)
 static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kwargs = Qnil;
@@ -778,12 +817,35 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     std::string password = kwarg_str(kwargs, "password", "");
     CompressionMethod compression = kwarg_compression(kwargs);
 
+    // Connection-resilience defaults. Long-lived pooled connections get
+    // silently closed by the server (idle_connection_timeout) or an LB, so
+    // the next use of a checked-out client would otherwise hit recv()==0 and
+    // raise ConnectionError("closed: ..."). ping_before_query makes the driver
+    // ping first and transparently reconnect on a dead socket; tcp_keepalive
+    // keeps idle sockets healthy at the OS level. retry_timeout is the backoff
+    // before each reconnect attempt — kept low (1s) since a pooled reconnect
+    // to a live server should be quick and we don't want to stall queries.
+    bool ping_before_query = kwarg_bool(kwargs, "ping_before_query", true);
+    bool tcp_keepalive = kwarg_bool(kwargs, "tcp_keepalive", true);
+    unsigned int retry_timeout = kwarg_uint(kwargs, "retry_timeout", 1);
+
     CHClient* c = as_client(self);
+
+    VALUE settings = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("settings")), Qnil);
+    if (!NIL_P(settings)) {
+        Check_Type(settings, T_HASH);
+        rb_hash_foreach(settings, collect_setting_cb,
+                        reinterpret_cast<VALUE>(&c->default_settings));
+    }
+
     try {
         ClientOptions opts;
         opts.SetHost(host).SetPort(port)
             .SetDefaultDatabase(database).SetUser(user).SetPassword(password)
-            .SetCompressionMethod(compression);
+            .SetCompressionMethod(compression)
+            .SetPingBeforeQuery(ping_before_query)
+            .TcpKeepAlive(tcp_keepalive)
+            .SetRetryTimeout(std::chrono::seconds(retry_timeout));
         c->client = std::make_unique<Client>(opts);
     } catch (const std::exception& e) {
         raise_mapped_ex(e);
@@ -792,6 +854,9 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     rb_ivar_set(self, rb_intern("@host"), rb_utf8_str_new(host.data(), host.size()));
     rb_ivar_set(self, rb_intern("@port"), UINT2NUM(port));
     rb_ivar_set(self, rb_intern("@database"), rb_utf8_str_new(database.data(), database.size()));
+    rb_ivar_set(self, rb_intern("@ping_before_query"), ping_before_query ? Qtrue : Qfalse);
+    rb_ivar_set(self, rb_intern("@tcp_keepalive"), tcp_keepalive ? Qtrue : Qfalse);
+    rb_ivar_set(self, rb_intern("@retry_timeout"), UINT2NUM(retry_timeout));
 
     VALUE logger = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("logger")), Qnil);
     rb_ivar_set(self, rb_intern("@logger"), logger);
@@ -807,6 +872,7 @@ struct ExecuteNoGVL {
     Client* client;
     const Query* query;
     std::exception_ptr err;
+    bool cancelled;
 };
 }  // namespace
 
@@ -820,11 +886,16 @@ static void* execute_no_gvl(void* data) {
     return nullptr;
 }
 
+// Unblock functions run on the *interrupting* thread while the blocked thread
+// is still inside Client::Execute(). CancelInFlight() only shuts the socket
+// down; ResetConnection() would free the very streams that thread is reading
+// (Thread#kill from Parallel.in_threads, Timeout, Sidekiq shutdown), which
+// reads back as a garbage packet type and then segfaults. The blocked call
+// returns EOF, raises, and the pool discards the client.
 static void execute_unblock(void* data) {
-    // The only safe abort clickhouse-cpp exposes is tearing the connection.
-    // On interrupt we kill the socket; the pool will discard this client.
     auto* a = static_cast<ExecuteNoGVL*>(data);
-    try { a->client->ResetConnection(); } catch (...) {}
+    a->cancelled = true;
+    try { a->client->CancelInFlight(); } catch (...) {}
 }
 
 static VALUE ch_client_execute(int argc, VALUE* argv, VALUE self) {
@@ -835,15 +906,23 @@ static VALUE ch_client_execute(int argc, VALUE* argv, VALUE self) {
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
     Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_default_settings(q, c);
     apply_settings(q, kwargs);
 
-    ExecuteNoGVL args{c->client.get(), &q, nullptr};
+    ExecuteNoGVL args{c->client.get(), &q, nullptr, false};
     rb_thread_call_without_gvl(execute_no_gvl, &args, execute_unblock, &args);
     if (args.err) {
         // clickhouse-cpp may leave the read stream partially consumed when the
         // server exception or an unsupported-type error is thrown mid-block.
         // Reset so the next call on this Client starts from a clean protocol.
-        try { c->client->ResetConnection(); } catch (...) {}
+        // Not after a cancel: that socket is already shut down and the caller
+        // discards the client, so the connect+handshake buys nothing. A
+        // Thread#kill or Timeout never gets here at all — step 5 of
+        // rb_thread_call_without_gvl delivers the interrupt before it returns —
+        // so this covers what is left: an unblock function that fires without a
+        // longjmp behind it, from a trap handler that does not raise or an
+        // interrupt Thread.handle_interrupt has deferred.
+        if (!args.cancelled) { try { c->client->ResetConnection(); } catch (...) {} }
         try { std::rethrow_exception(args.err); }
         catch (const std::exception& e) { raise_mapped_ex(e); }
     }
@@ -866,6 +945,7 @@ static VALUE ch_client_query(int argc, VALUE* argv, VALUE self) {
     try {
         std::vector<ID> col_ids;
         Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+        apply_default_settings(q, c);
         apply_read_settings(q, kwargs);
         q.OnData([&](const Block& block) {
             size_t ncols = block.GetColumnCount();
@@ -911,6 +991,7 @@ static VALUE ch_client_query_value(int argc, VALUE* argv, VALUE self) {
         VALUE out = Qnil;
         bool seen = false;
         Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+        apply_default_settings(q, c);
         apply_read_settings(q, kwargs);
         q.OnData([&](const Block& block) {
             if (seen) return;
@@ -936,14 +1017,16 @@ struct InsertNoGVL {
     Client* client;
     const std::string* table;
     const Block* block;
+    const std::vector<std::pair<std::string, std::string>>* settings;
     std::exception_ptr err;
+    bool cancelled;
 };
 }  // namespace
 
 static void* insert_no_gvl(void* data) {
     auto* a = static_cast<InsertNoGVL*>(data);
     try {
-        a->client->Insert(*a->table, *a->block);
+        a->client->Insert(*a->table, *a->block, *a->settings);
     } catch (...) {
         a->err = std::current_exception();
     }
@@ -952,7 +1035,8 @@ static void* insert_no_gvl(void* data) {
 
 static void insert_unblock(void* data) {
     auto* a = static_cast<InsertNoGVL*>(data);
-    try { a->client->ResetConnection(); } catch (...) {}
+    a->cancelled = true;
+    try { a->client->CancelInFlight(); } catch (...) {}
 }
 
 static VALUE ch_client_insert_block(VALUE self, VALUE rb_table, VALUE rb_columns, VALUE rb_rows) {
@@ -1009,10 +1093,10 @@ static VALUE ch_client_insert_block(VALUE self, VALUE rb_table, VALUE rb_columns
             block.AppendColumn(names[i], cols[i]);
         }
 
-        InsertNoGVL args{c->client.get(), &table, &block, nullptr};
+        InsertNoGVL args{c->client.get(), &table, &block, &c->default_settings, nullptr, false};
         rb_thread_call_without_gvl(insert_no_gvl, &args, insert_unblock, &args);
         if (args.err) {
-            try { c->client->ResetConnection(); } catch (...) {}
+            if (!args.cancelled) { try { c->client->ResetConnection(); } catch (...) {} }
             try { std::rethrow_exception(args.err); }
             catch (const std::exception& e) { raise_mapped_ex(e); }
         }
@@ -1045,6 +1129,7 @@ struct QueryEachNoGVL {
     const Query* query;
     QueryEachState* state;
     std::exception_ptr err;
+    bool cancelled;
 };
 }  // namespace
 
@@ -1097,7 +1182,8 @@ static void* query_each_no_gvl(void* data) {
 static void query_each_unblock(void* data) {
     auto* a = static_cast<QueryEachNoGVL*>(data);
     a->state->aborted = true;
-    try { a->client->ResetConnection(); } catch (...) {}
+    a->cancelled = true;
+    try { a->client->CancelInFlight(); } catch (...) {}
 }
 
 static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
@@ -1110,6 +1196,7 @@ static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
 
     QueryEachState state{rb_block_proc(), {}, 0, false};
     Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_default_settings(q, c);
     apply_read_settings(q, kwargs);
     q.OnDataCancelable([&state](const Block& block) -> bool {
         if (state.aborted) return false;
@@ -1117,12 +1204,12 @@ static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
         rb_thread_call_with_gvl(with_gvl_yield, &ya);
         return !state.aborted;
     });
-    QueryEachNoGVL args{c->client.get(), &q, &state, nullptr};
+    QueryEachNoGVL args{c->client.get(), &q, &state, nullptr, false};
 
     rb_thread_call_without_gvl(query_each_no_gvl, &args, query_each_unblock, &args);
 
     if (args.err) {
-        try { c->client->ResetConnection(); } catch (...) {}
+        if (!args.cancelled) { try { c->client->ResetConnection(); } catch (...) {} }
         if (state.exc_tag) rb_jump_tag(state.exc_tag);
         try { std::rethrow_exception(args.err); }
         catch (const std::exception& e) { raise_mapped_ex(e); }

data/ext/clickhouse_native/patches/0002-carry-settings-into-insert.patch

@@ -0,0 +1,82 @@
+diff --git a/clickhouse/client.cpp b/clickhouse/client.cpp
+index 34a733d..c9732f4 100644
+--- a/clickhouse/client.cpp
++++ b/clickhouse/client.cpp
+@@ -211,7 +211,8 @@ public:
+ 
+     bool IsSelecting() const { return state_ == State::Selecting; }
+ 
+-    void Insert(const std::string& table_name, const std::string& query_id, const Block& block);
++    void Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                const std::vector<std::pair<std::string, std::string>>& settings = {});
+ 
+     Block BeginInsert(Query query);
+ 
+@@ -485,7 +486,8 @@ std::string NameToQueryString(const std::string &input)
+     return output;
+ }
+ 
+-void Client::Impl::Insert(const std::string& table_name, const std::string& query_id, const Block& block) {
++void Client::Impl::Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                          const std::vector<std::pair<std::string, std::string>>& settings) {
+     if (state_ == State::Inserting) {
+         throw ValidationError("cannot execute query while inserting, use SendInsertData instead");
+     }
+@@ -511,6 +513,9 @@ void Client::Impl::Insert(const std::string& table_name, const std::string& quer
+     }
+ 
+     Query query("INSERT INTO " + table_name + " ( " + fields_section.str() + " ) VALUES", query_id);
++    for (const auto& kv : settings) {
++        query.SetSetting(kv.first, QuerySettingsField{kv.second, 1});
++    }
+     SendQuery(query);
+ 
+     // Wait for a data packet and return
+@@ -1365,12 +1370,14 @@ bool Client::IsSelecting() const
+     return impl_->IsSelecting();
+ }
+ 
+-void Client::Insert(const std::string& table_name, const Block& block) {
+-    impl_->Insert(table_name, Query::default_query_id, block);
++void Client::Insert(const std::string& table_name, const Block& block,
++                    const std::vector<std::pair<std::string, std::string>>& settings) {
++    impl_->Insert(table_name, Query::default_query_id, block, settings);
+ }
+ 
+-void Client::Insert(const std::string& table_name, const std::string& query_id, const Block& block) {
+-    impl_->Insert(table_name, query_id, block);
++void Client::Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                    const std::vector<std::pair<std::string, std::string>>& settings) {
++    impl_->Insert(table_name, query_id, block, settings);
+ }
+ 
+ Block Client::BeginInsert(const std::string& query) {
+diff --git a/clickhouse/client.h b/clickhouse/client.h
+index a55fd74..6c6ff53 100644
+--- a/clickhouse/client.h
++++ b/clickhouse/client.h
+@@ -23,6 +23,8 @@
+ #include "columns/bool.h"
+ 
+ #include <chrono>
++#include <utility>
++#include <vector>
+ #include <cstdint>
+ #include <memory>
+ #include <ostream>
+@@ -298,8 +300,13 @@ public:
+     bool IsSelecting() const;
+ 
+     /// 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);
++    /// \p settings are applied to the generated INSERT query as per-query
++    /// settings (patched-in for clickhouse-native: lets a pooled client carry
++    /// its session settings into inserts without a session-level SET).
++    void Insert(const std::string& table_name, const Block& block,
++                const std::vector<std::pair<std::string, std::string>>& settings = {});
++    void Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                const std::vector<std::pair<std::string, std::string>>& settings = {});
+ 
+     /// Start an \p INSERT statement, insert batches of data, then finish the insert.
+     Block BeginInsert(const std::string& query);

data/ext/clickhouse_native/patches/0003-cancelable-socket.patch

@@ -0,0 +1,136 @@
+diff --git a/clickhouse/base/socket.cpp b/clickhouse/base/socket.cpp
+index 3bb1aa5..f188d3f 100644
+--- a/clickhouse/base/socket.cpp
++++ b/clickhouse/base/socket.cpp
+@@ -345,6 +345,19 @@ Socket::~Socket() {
+     Close();
+ }
+ 
++void Socket::Cancel() {
++    if (handle_ == INVALID_SOCKET) {
++        return;
++    }
++    // shutdown(), not close(): the descriptor stays valid, so a concurrent
++    // reader returns EOF instead of racing a reused fd number.
++#if defined(_win_)
++    shutdown(handle_, SD_BOTH);
++#else
++    ::shutdown(handle_, SHUT_RDWR);
++#endif
++}
++
+ void Socket::Close() {
+     CloseSocket(handle_);
+     handle_ = INVALID_SOCKET;
+diff --git a/clickhouse/base/socket.h b/clickhouse/base/socket.h
+index 9bd9ca3..0234b1e 100644
+--- a/clickhouse/base/socket.h
++++ b/clickhouse/base/socket.h
+@@ -80,6 +80,12 @@ public:
+ 
+     virtual std::unique_ptr<InputStream> makeInputStream() const = 0;
+     virtual std::unique_ptr<OutputStream> makeOutputStream() const = 0;
++
++    /// Unblock a thread parked in recv()/send() on this socket. Unlike
++    /// closing or replacing the socket it destroys nothing, so it is safe
++    /// to call from another thread while the owner is mid-read: the owner
++    /// sees EOF and unwinds through its own frames.
++    virtual void Cancel() {}
+ };
+ 
+ 
+@@ -123,6 +129,8 @@ public:
+     std::unique_ptr<InputStream> makeInputStream() const override;
+     std::unique_ptr<OutputStream> makeOutputStream() const override;
+ 
++    void Cancel() override;
++
+ protected:
+     Socket(const Socket&) = delete;
+     Socket& operator = (const Socket&) = delete;
+diff --git a/clickhouse/client.cpp b/clickhouse/client.cpp
+index c9732f4..88c9b84 100644
+--- a/clickhouse/client.cpp
++++ b/clickhouse/client.cpp
+@@ -9,6 +9,7 @@
+ #include "columns/factory.h"
+ 
+ #include <cassert>
++#include <mutex>
+ #include <optional>
+ #include <sstream>
+ #include <system_error>
+@@ -226,6 +227,8 @@ public:
+ 
+     void ResetConnection();
+ 
++    void CancelInFlight();
++
+     void ResetConnectionEndpoint();
+ 
+     const ServerInfo& GetServerInfo() const;
+@@ -313,6 +316,11 @@ private:
+ 
+     std::unique_ptr<SocketFactory> socket_factory_;
+ 
++    /// Guards socket_ against CancelInFlight() on another thread. Covers the
++    /// swap in ResetConnection() and the displaced socket's destructor, so a
++    /// canceller can never shutdown() an fd that is closing or already reissued.
++    std::mutex socket_mutex_;
++
+     std::unique_ptr<InputStream> input_;
+     std::unique_ptr<OutputStream> output_;
+     std::unique_ptr<SocketBase> socket_;
+@@ -610,8 +618,24 @@ void Client::Impl::Ping() {
+     }
+ }
+ 
++void Client::Impl::CancelInFlight() {
++    std::lock_guard<std::mutex> lock(socket_mutex_);
++    if (socket_) {
++        socket_->Cancel();
++    }
++}
++
+ void Client::Impl::ResetConnection() {
+-    InitializeStreams(socket_factory_->connect(options_, current_endpoint_.value()));
++    auto fresh = socket_factory_->connect(options_, current_endpoint_.value());
++    {
++        // InitializeStreams swaps, so `fresh` comes back holding the *old*
++        // socket; reset it here so its destructor runs under the lock too.
++        // Left to itself it would die in this function's full-expression,
++        // outside any lock, which is the window CancelInFlight() must not hit.
++        std::lock_guard<std::mutex> lock(socket_mutex_);
++        InitializeStreams(std::move(fresh));
++        fresh.reset();
++    }
+     state_ = State::Idle;
+ 
+     if (!Handshake()) {
+@@ -1408,6 +1432,10 @@ void Client::ResetConnection() {
+     impl_->ResetConnection();
+ }
+ 
++void Client::CancelInFlight() {
++    impl_->CancelInFlight();
++}
++
+ void Client::ResetConnectionEndpoint() {
+     impl_->ResetConnectionEndpoint();
+ }
+diff --git a/clickhouse/client.h b/clickhouse/client.h
+index 6c6ff53..27be58c 100644
+--- a/clickhouse/client.h
++++ b/clickhouse/client.h
+@@ -326,6 +326,11 @@ public:
+     /// Reset connection with initial params.
+     void ResetConnection();
+ 
++    /// Unblock a thread parked in an Execute()/Insert() socket read.
++    /// Destroys nothing, so unlike ResetConnection() it is safe to call
++    /// from another thread while a query is still in flight.
++    void CancelInFlight();
++
+     const ServerInfo& GetServerInfo() const;
+ 
+     /// Get current connected endpoint.

data/lib/clickhouse_native/client.rb

@@ -2,7 +2,7 @@
 
 module ClickhouseNative
   class Client
-    attr_reader :host, :port, :database
+    attr_reader :host, :port, :database, :ping_before_query, :tcp_keepalive, :retry_timeout
 
     def describe_table(table, db_name: nil)
       fq = db_name ? "#{db_name}.#{table}" : table

data/lib/clickhouse_native/pool.rb

@@ -8,44 +8,54 @@ module ClickhouseNative
 
     def initialize(host:, port:, database: "default", user: "default", password: "",
                    compression: :none, logger: nil, settings: {},
-                   pool_size: 5, pool_timeout: 5)
+                   pool_size: 5, pool_timeout: 5,
+                   ping_before_query: true, tcp_keepalive: true, retry_timeout: 1)
       @host = host
       @port = port
       @database = database
-      client_kwargs = { host:, port:, database:, user:, password:, compression:, logger: }
-      @set_sql = settings_sql(settings)
+      client_kwargs = {
+        host:, port:, database:, user:, password:, compression:, logger:, settings:,
+        ping_before_query:, tcp_keepalive:, retry_timeout:
+      }
       @pool = ConnectionPool.new(size: pool_size, timeout: pool_timeout) do
-        client = Client.new(**client_kwargs)
-        client.execute(@set_sql) if @set_sql
-        client
+        Client.new(**client_kwargs)
       end
     end
 
-    # On exception, discard the client rather than reuse it: an error
-    # path leaves the socket in an unknown state. The C++ binding issues
+    # On an aborted operation, discard the client rather than reuse it: the
+    # socket is left in an unknown state. The C++ binding issues
     # ResetConnection, but a subsequent send can still surface buffered
     # protocol errors from the prior aborted operation — those get
-    # attributed to whatever SQL we tried next (e.g. the SET reapplying
-    # session settings), producing misleading log lines and re-raises in
-    # unrelated code. A fresh socket + handshake is cheap relative to
-    # debugging that.
+    # attributed to whatever SQL we tried next, producing misleading log
+    # lines and re-raises in unrelated code. A fresh socket + handshake is
+    # cheap relative to debugging that.
     #
     # ConnectionError gets one automatic retry: pooled connections that
     # have been idle long enough for the server / an LB to FIN them
-    # surface as "closed" on the very next recv (errno 0, message
-    # "closed: Success"). Discarding and re-checking out lands a fresh
-    # socket and the operation succeeds. The retry only triggers when
-    # the dead-connection error fired before any data was sent, so
-    # write operations don't risk double-execution from this path.
+    # surface as "closed" on the very next recv (errno is whatever stale
+    # value was left in the thread — "closed: Success", "closed: Operation
+    # now in progress", etc. all mean the same recv()==0). Discarding and
+    # re-checking out lands a fresh socket and the operation succeeds. The
+    # retry only triggers when the dead-connection error fired before any
+    # data was sent, so write operations don't risk double-execution.
+    #
+    # This is the backstop: with ping_before_query on (the default) the
+    # driver already pings and transparently reconnects a dead socket
+    # before running the query, so most stale connections never surface as
+    # a ConnectionError here at all. This retry still covers the residual
+    # race (socket dies between the ping and the query).
+    #
+    # A bare `rescue` is not enough to spot an abandoned query. Timeout and
+    # Sidekiq shutdown raise off Exception rather than StandardError, and
+    # Thread#kill raises nothing at all — Parallel.in_threads kills every
+    # sibling worker the moment one of them fails. Miss those and the
+    # connection goes back in with the server still streaming a response at
+    # it; the next checkout reads that leftover as its own, which surfaces
+    # as a bogus packet type far from here.
     def with
       attempts = 0
       begin
-        @pool.with do |client|
-          yield client
-        rescue
-          @pool.discard_current_connection(&:close)
-          raise
-        end
+        @pool.with { |client| discard_unless_clean { yield client } }
       rescue ConnectionError
         attempts += 1
         retry if attempts == 1
@@ -87,18 +97,27 @@ module ClickhouseNative
 
     private
 
-    # Render a `SET key1 = val1, key2 = val2` statement once at pool setup
-    # so every checked-out connection starts with the same session
-    # settings. Matches how the HTTP driver injected global_params per
-    # request. Values: Integer / Float render bare; anything else is
-    # quoted as a SQL string literal.
-    def settings_sql(settings)
-      return nil if settings.nil? || settings.empty?
-      parts = settings.map do |k, v|
-        literal = v.is_a?(Numeric) ? v.to_s : "'#{v.to_s.gsub("'", "''")}'"
-        "#{k} = #{literal}"
+    # Keep the client only when the block either finished or left of its own
+    # accord. A `break` out of a streaming read is deliberate, and the binding
+    # has already reconnected the client on its way out (query_each resets the
+    # connection before rb_jump_tag), so it is good to reuse — discarding would
+    # buy a second connect on top of the one already paid. An exception is an
+    # abort, and so is Thread#kill: it raises nothing, so no rescue ever sees
+    # it, and its only trace is an "aborting" thread while ensure runs.
+    def discard_unless_clean
+      finished = false
+      begin
+        result = yield
+        finished = true
+        result
+      rescue Exception # rubocop:disable Lint/RescueException
+        @pool.discard_current_connection(&:close)
+        raise
+      ensure
+        if !finished && Thread.current.status == "aborting"
+          @pool.discard_current_connection(&:close)
+        end
       end
-      "SET #{parts.join(', ')}"
     end
   end
 end

data/lib/clickhouse_native/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClickhouseNative
-  VERSION = "0.10.0"
+  VERSION = "0.11.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Yuri Smirnov
@@ -35,6 +35,8 @@ files:
 - ext/clickhouse_native/client.cpp
 - ext/clickhouse_native/extconf.rb
 - ext/clickhouse_native/patches/0001-preserve-declared-column-type.patch
+- ext/clickhouse_native/patches/0002-carry-settings-into-insert.patch
+- ext/clickhouse_native/patches/0003-cancelable-socket.patch
 - ext/clickhouse_native/vendor/clickhouse-cpp/.clang-format
 - ext/clickhouse_native/vendor/clickhouse-cpp/.git
 - ext/clickhouse_native/vendor/clickhouse-cpp/.gitattributes
@@ -323,7 +325,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: ClickHouse Ruby driver over the native TCP protocol
 test_files: []