clickhouse-native 0.10.0-aarch64-linux-gnu → 0.11.1-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b6a35f5fab1f2014008a5f31b4b4e1364d094ecbcfb755e7ada161e42846e2
-  data.tar.gz: f67f936383f7fade31eab0a93cc1c882d20c77735afdda6c222f6b36d31f7156
+  metadata.gz: '0928c0e76b392ebf13b29276176b1e0019b0987d1d911803bc39fb540728df0c'
+  data.tar.gz: 30ff3e3d0a692bb87993aaaf4ea5d3fccff7a1b1bfaf81bc88c8049cbcbed334
 SHA512:
-  metadata.gz: a3ef2222901d66eba3a02c1e1bce1e6a1b69836bb5494279434cb177cdf1903e28c267322b2cb1c71f9aeac6a3ee1c2e681c1af2e2a98e3b98e49a09fb3da140
-  data.tar.gz: 405ca090b8762f57075408c6dda431300c03bd0a6a8b0e3a947ccc00d7bc8740c6b2a8019816b81065dd72411068fc5ccbda06a8ba5f82785546fb81b2d6f5a6
+  metadata.gz: b8dba60e9036999618a1bf1156dd526784ce90235686b7760697998e7e1fe361e4a0c8ed434af196a8ab2df3672ba9c5b8ca0e9393b195816af31287907a6a52
+  data.tar.gz: '048be87562219797f37401b8b33d544687945e38c64ea322f727f751f5c829d787f3b437c7c2306f1752b082f00df442f35d0c2554ee292b1021082ee5cfa1ea'

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: aarch64-linux-gnu
 authors:
 - Yuri Smirnov