clickhouse-native 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 984a63d34de19388f777cfe71ecd0a844d22f0b67b89e9fddfe07c5c0ac1cc05
-  data.tar.gz: 78f829e40f715aef0264e1419cb9b06b97faab1ac38f33329c5da6ada1dd251b
+  metadata.gz: d4bbe836a1758637fb9dd0a157505037b8bc45d42d253d261b3a349cecaf9716
+  data.tar.gz: 7c0cd5bbea6944c2c0672780088d4342cdf207227bce2c52f388986e9b26bf15
 SHA512:
-  metadata.gz: c579da78d2185108712c92e902217c2e508655533c2e78efc7e36ae358a826f809f41d884684b8fcb0e1b36749bc80be5f23b76c85ebf081423adb615d73928b
-  data.tar.gz: 93259646a6f150ed271202e3eaca075e0d1cf8d707aed5ac2ac9b530061de47cf1a65082289718857b367dd5b8d764c73cf270c34d080018ce8caac540d8bab6
+  metadata.gz: e3abc7862bbf8125ca8168d5a28337ebdf1e11c1f8a2965fff597ccaa4d27eaea70f2116d93b54d2822f6f6fd3fca237e8a864d1cf30e91c0195bb4e730f22be
+  data.tar.gz: 101b7ecc586641e3c0df0f14f0dbd977a450d578e029fbc220f1b86218d4e84ef4a22d5c29eaec1c1e463db96e5fdc9a2b26fb5efdfa0cf1c6780a40aee1d047

data/ext/clickhouse_native/client.cpp

@@ -804,6 +804,64 @@ static void apply_default_settings(Query& q, CHClient* c) {
     }
 }
 
+// ------------------------------------------------------------------
+// Connect / reconnect, off the GVL
+// ------------------------------------------------------------------
+
+namespace {
+struct ResetNoGVL {
+    Client* client;
+    std::exception_ptr err;
+    bool ran;
+};
+
+struct ConnectNoGVL {
+    const ClientOptions* opts;
+    std::unique_ptr<Client>* out;
+    std::exception_ptr err;
+};
+}  // namespace
+
+static void* connect_no_gvl(void* data) {
+    auto* a = static_cast<ConnectNoGVL*>(data);
+    try { *a->out = std::make_unique<Client>(*a->opts); }
+    catch (...) { a->err = std::current_exception(); }
+    return nullptr;
+}
+
+static void* reset_no_gvl(void* data) {
+    auto* a = static_cast<ResetNoGVL*>(data);
+    a->ran = true;
+    try { a->client->ResetConnection(); } catch (...) { a->err = std::current_exception(); }
+    return nullptr;
+}
+
+// ResetConnection() opens a fresh socket and re-handshakes, so it blocks on the
+// network exactly like a query does. Every error path calls it, which is when
+// the server is least likely to answer promptly - the worst moment to be
+// holding the GVL. No unblock function: there is no in-flight query to cancel,
+// and the half-built connection is this thread's.
+//
+// _gvl2, not the ordinary one: every caller is already reporting some other
+// error, and the ordinary variant checks pending interrupts as it retakes the
+// GVL and can longjmp out. That would jump between an rb_protect tag and the
+// rb_jump_tag meant to re-raise it, or out of the active catch handler in
+// insert_block, and would lose the error the caller came here to report.
+//
+// _gvl2 declines to run `func` at all when an interrupt is already pending,
+// though, so the reset is not guaranteed - and one caller needs it to happen:
+// the `break` out of query_each keeps its client, on the understanding that
+// the reset here left it clean (see Pool#discard_unless_clean). Falling back
+// to the plain call covers that. Holding the GVL for a reconnect is the lesser
+// evil against handing back a connection with a reply still draining into it.
+// Failures stay swallowed either way: the pool discards on every other path.
+static void reset_connection_no_gvl(Client* client) {
+    if (!client) return;
+    ResetNoGVL args{client, nullptr, false};
+    rb_thread_call_without_gvl2(reset_no_gvl, &args, nullptr, nullptr);
+    if (!args.ran) { try { client->ResetConnection(); } catch (...) {} }
+}
+
 // Client.new(host:, port:, database:, user:, password:)
 static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kwargs = Qnil;
@@ -838,7 +896,7 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
                         reinterpret_cast<VALUE>(&c->default_settings));
     }
 
-    try {
+    {
         ClientOptions opts;
         opts.SetHost(host).SetPort(port)
             .SetDefaultDatabase(database).SetUser(user).SetPassword(password)
@@ -846,9 +904,17 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
             .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);
+        // The constructor connects and handshakes, and retries for
+        // SetRetryTimeout seconds against an unreachable host - long enough to
+        // freeze every other thread if it ran under the GVL. No unblock
+        // function: there is no in-flight query to cancel, and the socket being
+        // built belongs to this thread.
+        ConnectNoGVL args{&opts, &c->client, nullptr};
+        rb_thread_call_without_gvl(connect_no_gvl, &args, nullptr, nullptr);
+        if (args.err) {
+            try { std::rethrow_exception(args.err); }
+            catch (const std::exception& e) { raise_mapped_ex(e); }
+        }
     }
 
     rb_ivar_set(self, rb_intern("@host"), rb_utf8_str_new(host.data(), host.size()));
@@ -872,6 +938,7 @@ struct ExecuteNoGVL {
     Client* client;
     const Query* query;
     std::exception_ptr err;
+    bool cancelled;
 };
 }  // namespace
 
@@ -885,11 +952,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) {
@@ -903,13 +975,20 @@ static VALUE ch_client_execute(int argc, VALUE* argv, VALUE self) {
     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) reset_connection_no_gvl(c->client.get());
         try { std::rethrow_exception(args.err); }
         catch (const std::exception& e) { raise_mapped_ex(e); }
     }
@@ -917,82 +996,171 @@ static VALUE ch_client_execute(int argc, VALUE* argv, VALUE self) {
 }
 
 // ------------------------------------------------------------------
-// query() — buffers all rows into an array; GVL is held for the duration.
-// See query_each below for a streaming, GVL-releasing variant.
+// query() / query_value() — buffer the result, releasing the GVL while the
+// server streams. The data callback is the only part that needs Ruby, so it
+// takes the GVL back per block (as query_each does) rather than the whole
+// call holding it: a multi-second read otherwise stops every other thread in
+// the process, which starves timers and lock heartbeats.
 // ------------------------------------------------------------------
 
-static VALUE ch_client_query(int argc, VALUE* argv, VALUE self) {
-    VALUE rb_sql, kwargs = Qnil;
-    rb_scan_args(argc, argv, "1:", &rb_sql, &kwargs);
-    Check_Type(rb_sql, T_STRING);
-    CHClient* c = as_client(self);
-    if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
+namespace {
+struct CollectState {
+    VALUE rows;              // Qnil for query_value, which keeps `out` instead
+    VALUE out;
+    bool first_only;
+    bool seen;
+    std::vector<ID> col_ids;
+    int exc_tag;
+    std::exception_ptr cpp_err;
+    bool aborted;
+};
+
+struct CollectBlockArgs {
+    const Block* block;
+    CollectState* state;
+};
+
+struct QueryNoGVL {
+    Client* client;
+    const Query* query;
+    CollectState* state;
+    std::exception_ptr err;
+    bool cancelled;
+};
+}  // namespace
+
+// The decode throw is caught here, inside the frame rb_protect calls, so it
+// never unwinds through rb_protect itself - doing that walks a setjmp frame
+// whose epilogue never runs and takes the interpreter down. Carried out via
+// state instead; run_buffered_query rethrows it after the no-GVL region.
+static VALUE collect_rows_body(VALUE arg) {
+    auto* args = reinterpret_cast<CollectBlockArgs*>(arg);
+    const Block& block = *args->block;
+    auto* state = args->state;
 
-    VALUE rows = rb_ary_new();
     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();
-            size_t nrows = block.GetRowCount();
-            if (nrows == 0) return;
-            if (col_ids.empty()) {
-                col_ids.reserve(ncols);
-                for (size_t i = 0; i < ncols; i++) {
-                    const std::string& name = block.GetColumnName(i);
-                    col_ids.push_back(rb_intern2(name.data(), name.size()));
-                }
+        size_t ncols = block.GetColumnCount();
+        size_t nrows = block.GetRowCount();
+        if (nrows == 0 || ncols == 0) return Qnil;
+
+        if (state->first_only) {
+            if (!state->seen) {
+                state->out = value_at(block[0], 0, block.GetColumnType(0));
+                state->seen = true;
             }
-            for (size_t r = 0; r < nrows; r++) {
-                VALUE h = rb_hash_new();
-                for (size_t cc = 0; cc < ncols; cc++) {
-                    rb_hash_aset(h, ID2SYM(col_ids[cc]),
-                                 value_at(block[cc], r, block.GetColumnType(cc)));
-                }
-                rb_ary_push(rows, h);
+            return Qnil;
+        }
+
+        if (state->col_ids.empty()) {
+            state->col_ids.reserve(ncols);
+            for (size_t i = 0; i < ncols; i++) {
+                const std::string& name = block.GetColumnName(i);
+                state->col_ids.push_back(rb_intern2(name.data(), name.size()));
             }
-        });
-        c->client->Execute(q);
-        return rows;
-    } catch (const std::exception& e) {
-        try { c->client->ResetConnection(); } catch (...) {}
-        raise_mapped_ex(e);
+        }
+        for (size_t r = 0; r < nrows; r++) {
+            VALUE h = rb_hash_new();
+            for (size_t cc = 0; cc < ncols; cc++) {
+                rb_hash_aset(h, ID2SYM(state->col_ids[cc]),
+                             value_at(block[cc], r, block.GetColumnType(cc)));
+            }
+            rb_ary_push(state->rows, h);
+        }
+    } catch (...) {
+        state->cpp_err = std::current_exception();
+        state->aborted = true;
     }
     return Qnil;
 }
 
-// ------------------------------------------------------------------
-// query_value — returns the first cell of the first row, or nil
-// ------------------------------------------------------------------
+static void* with_gvl_collect(void* data) {
+    auto* args = static_cast<CollectBlockArgs*>(data);
+    int tag = 0;
+    rb_protect(collect_rows_body, reinterpret_cast<VALUE>(args), &tag);
+    if (tag != 0) {
+        args->state->exc_tag = tag;
+        args->state->aborted = true;
+    }
+    return nullptr;
+}
 
-static VALUE ch_client_query_value(int argc, VALUE* argv, VALUE self) {
+static void* query_no_gvl(void* data) {
+    auto* a = static_cast<QueryNoGVL*>(data);
+    try {
+        a->client->Execute(*a->query);
+    } catch (...) {
+        a->err = std::current_exception();
+    }
+    return nullptr;
+}
+
+// See execute_unblock: cancel the in-flight query, never tear the streams down
+// from another thread.
+static void query_unblock(void* data) {
+    auto* a = static_cast<QueryNoGVL*>(data);
+    a->state->aborted = true;
+    a->cancelled = true;
+    try { a->client->CancelInFlight(); } catch (...) {}
+}
+
+static VALUE run_buffered_query(VALUE self, int argc, VALUE* argv, bool first_only) {
     VALUE rb_sql, kwargs = Qnil;
     rb_scan_args(argc, argv, "1:", &rb_sql, &kwargs);
     Check_Type(rb_sql, T_STRING);
     CHClient* c = as_client(self);
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
-    try {
-        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;
-            if (block.GetRowCount() == 0 || block.GetColumnCount() == 0) return;
-            out = value_at(block[0], 0, block.GetColumnType(0));
-            seen = true;
-        });
-        c->client->Execute(q);
-        return out;
-    } catch (const std::exception& e) {
-        try { c->client->ResetConnection(); } catch (...) {}
-        raise_mapped_ex(e);
+    // `state` lives on this thread's machine stack, and that is what marks
+    // state.rows and state.out while the GVL is dropped below: the GC scans the
+    // stack conservatively, and the context saved at the release covers the
+    // no-GVL window. Moving CollectState off the stack would remove the only
+    // thing keeping the result alive.
+    CollectState state{first_only ? Qnil : rb_ary_new(), Qnil,
+                       first_only, false, {}, 0, nullptr, 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;
+        // query_value keeps reading to leave the connection clean, but has
+        // nothing left to do once it holds its cell - taking the GVL per block
+        // to discard it costs a round trip each time on a large result.
+        if (state.first_only && state.seen) return true;
+        CollectBlockArgs ca{&block, &state};
+        rb_thread_call_with_gvl(with_gvl_collect, &ca);
+        return !state.aborted;
+    });
+    QueryNoGVL args{c->client.get(), &q, &state, nullptr, false};
+
+    rb_thread_call_without_gvl(query_no_gvl, &args, query_unblock, &args);
+
+    // A decode throw caught in the data callback is the real error; the read
+    // that follows it only reports the abort, so this is checked first.
+    if (state.cpp_err) {
+        reset_connection_no_gvl(c->client.get());
+        try { std::rethrow_exception(state.cpp_err); }
+        catch (const std::exception& e) { raise_mapped_ex(e); }
     }
-    return Qnil;
+    if (args.err) {
+        if (!args.cancelled) reset_connection_no_gvl(c->client.get());
+        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); }
+    }
+    if (state.exc_tag) {
+        reset_connection_no_gvl(c->client.get());
+        rb_jump_tag(state.exc_tag);
+    }
+
+    return first_only ? state.out : state.rows;
+}
+
+static VALUE ch_client_query(int argc, VALUE* argv, VALUE self) {
+    return run_buffered_query(self, argc, argv, false);
+}
+
+static VALUE ch_client_query_value(int argc, VALUE* argv, VALUE self) {
+    return run_buffered_query(self, argc, argv, true);
 }
 
 // ------------------------------------------------------------------
@@ -1006,6 +1174,7 @@ struct InsertNoGVL {
     const Block* block;
     const std::vector<std::pair<std::string, std::string>>* settings;
     std::exception_ptr err;
+    bool cancelled;
 };
 }  // namespace
 
@@ -1021,7 +1190,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) {
@@ -1078,15 +1248,15 @@ 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, &c->default_settings, 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) reset_connection_no_gvl(c->client.get());
             try { std::rethrow_exception(args.err); }
             catch (const std::exception& e) { raise_mapped_ex(e); }
         }
     } catch (const std::exception& e) {
-        try { c->client->ResetConnection(); } catch (...) {}
+        reset_connection_no_gvl(c->client.get());
         raise_mapped_ex(e);
     }
     return LONG2NUM(nrows);
@@ -1101,6 +1271,7 @@ struct QueryEachState {
     VALUE user_proc;
     std::vector<ID> col_ids;
     int exc_tag;
+    std::exception_ptr cpp_err;
     bool aborted;
 };
 
@@ -1114,30 +1285,39 @@ struct QueryEachNoGVL {
     const Query* query;
     QueryEachState* state;
     std::exception_ptr err;
+    bool cancelled;
 };
 }  // namespace
 
+// See collect_rows_body: the decode throw is caught inside this frame so it
+// never unwinds through rb_protect.
 static VALUE yield_rows_body(VALUE arg) {
     auto* args = reinterpret_cast<YieldBlockArgs*>(arg);
     const Block& block = *args->block;
     auto* state = args->state;
-    size_t ncols = block.GetColumnCount();
-    size_t nrows = block.GetRowCount();
-    if (nrows == 0) return Qnil;
-    if (state->col_ids.empty() && ncols > 0) {
-        state->col_ids.reserve(ncols);
-        for (size_t i = 0; i < ncols; i++) {
-            const std::string& name = block.GetColumnName(i);
-            state->col_ids.push_back(rb_intern2(name.data(), name.size()));
+
+    try {
+        size_t ncols = block.GetColumnCount();
+        size_t nrows = block.GetRowCount();
+        if (nrows == 0) return Qnil;
+        if (state->col_ids.empty() && ncols > 0) {
+            state->col_ids.reserve(ncols);
+            for (size_t i = 0; i < ncols; i++) {
+                const std::string& name = block.GetColumnName(i);
+                state->col_ids.push_back(rb_intern2(name.data(), name.size()));
+            }
         }
-    }
-    for (size_t r = 0; r < nrows; r++) {
-        VALUE h = rb_hash_new();
-        for (size_t cc = 0; cc < ncols; cc++) {
-            rb_hash_aset(h, ID2SYM(state->col_ids[cc]),
-                         value_at(block[cc], r, block.GetColumnType(cc)));
+        for (size_t r = 0; r < nrows; r++) {
+            VALUE h = rb_hash_new();
+            for (size_t cc = 0; cc < ncols; cc++) {
+                rb_hash_aset(h, ID2SYM(state->col_ids[cc]),
+                             value_at(block[cc], r, block.GetColumnType(cc)));
+            }
+            rb_funcall(state->user_proc, rb_intern("call"), 1, h);
         }
-        rb_funcall(state->user_proc, rb_intern("call"), 1, h);
+    } catch (...) {
+        state->cpp_err = std::current_exception();
+        state->aborted = true;
     }
     return Qnil;
 }
@@ -1166,7 +1346,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) {
@@ -1177,7 +1358,7 @@ static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
     CHClient* c = as_client(self);
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
-    QueryEachState state{rb_block_proc(), {}, 0, false};
+    QueryEachState state{rb_block_proc(), {}, 0, nullptr, false};
     Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
     apply_default_settings(q, c);
     apply_read_settings(q, kwargs);
@@ -1187,18 +1368,25 @@ 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);
 
+    // A decode throw caught in the data callback is the real error; the read
+    // that follows it only reports the abort, so this is checked first.
+    if (state.cpp_err) {
+        reset_connection_no_gvl(c->client.get());
+        try { std::rethrow_exception(state.cpp_err); }
+        catch (const std::exception& e) { raise_mapped_ex(e); }
+    }
     if (args.err) {
-        try { c->client->ResetConnection(); } catch (...) {}
+        if (!args.cancelled) reset_connection_no_gvl(c->client.get());
         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); }
     }
     if (state.exc_tag) {
-        try { c->client->ResetConnection(); } catch (...) {}
+        reset_connection_no_gvl(c->client.get());
         rb_jump_tag(state.exc_tag);
     }
     return self;
@@ -1253,7 +1441,7 @@ static VALUE ch_client_server_version(VALUE self) {
 static VALUE ch_client_reset_connection(VALUE self) {
     CHClient* c = as_client(self);
     if (!c->client) return Qnil;
-    try { c->client->ResetConnection(); } catch (...) {}
+    reset_connection_no_gvl(c->client.get());
     return Qtrue;
 }
 

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/pool.rb

@@ -22,8 +22,8 @@ module ClickhouseNative
       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, producing misleading log
@@ -44,15 +44,18 @@ module ClickhouseNative
     # 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
@@ -91,5 +94,30 @@ module ClickhouseNative
     def describe_table(table, db_name: nil)
       with { |c| c.describe_table(table, db_name:) }
     end
+
+    private
+
+    # 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
+    end
   end
 end

data/lib/clickhouse_native/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Yuri Smirnov
@@ -36,6 +36,7 @@ files:
 - 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