clickhouse-native 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f3cc163e6a966e97acca8801841c4512293870eaf1461d04cd3050a4aa4fd73
-  data.tar.gz: 0abc84555ec48af61ac6d56e526a22e1bb17ddf87ad417cba63bcfbf844a08ef
+  metadata.gz: 7e0bcd3868daa1a69af028ff62e4c0104c82ceac165acfa12f40418259d74929
+  data.tar.gz: e40d67544c4b9fb99fbf0ecebf655dd572055fc4d8301521cf0958af1a4531c1
 SHA512:
-  metadata.gz: fbf92ccd73e237a8855f158477c54c6a12b1a630e2cf2a145386b2d624bbc2080747c06e2a247c0e58a159b26c7192981309e1a769c9e6cf66d4badf82a7639c
-  data.tar.gz: ce7dc8ae0256db019528ae9d50b43710230a2f70939e82367a34d2c643a04a420199a689eec79dd11f845f6ea1b103ee7a8aba724881fe6432d57aa0aa4803e2
+  metadata.gz: ace9d3e809fa558064f42d2ee66bce667f8514fb06f88d2eb2e24c09f244994e32365acae4f3a3c110025f6a3de947a242d766a72fa72dfaa560fbaf8825c9a0
+  data.tar.gz: a935ba30d5f897254492157e82bf98be08e202cd8b619de923c43b0b25ae07f3112d98b20768152dcd44c605eb57db7220e70c240e318415c9992bfb7bd8bf1b

data/ext/clickhouse_native/client.cpp

@@ -694,6 +694,38 @@ static CompressionMethod kwarg_compression(VALUE kwargs) {
              rb_id2name(sym));
 }
 
+// Stringify a Ruby setting value for the binary protocol's QuerySettings
+// payload (which is wire-string-typed). Bool maps to "1"/"0" the way the
+// HTTP gem rendered it; everything else goes through #to_s.
+static std::string stringify_setting_value(VALUE v) {
+    if (v == Qtrue)  return "1";
+    if (v == Qfalse) return "0";
+    VALUE s = rb_funcall(v, rb_intern("to_s"), 0);
+    StringValue(s);
+    return std::string(RSTRING_PTR(s), RSTRING_LEN(s));
+}
+
+static int apply_settings_cb(VALUE key, VALUE val, VALUE arg) {
+    auto* q = reinterpret_cast<Query*>(arg);
+    VALUE k = SYMBOL_P(key) ? rb_sym2str(key) : key;
+    StringValue(k);
+    q->SetSetting(
+        std::string(RSTRING_PTR(k), RSTRING_LEN(k)),
+        QuerySettingsField{stringify_setting_value(val), 0});
+    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.
+static void apply_settings(Query& q, VALUE kwargs) {
+    if (NIL_P(kwargs)) return;
+    VALUE settings = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("settings")), Qnil);
+    if (NIL_P(settings)) return;
+    Check_Type(settings, T_HASH);
+    rb_hash_foreach(settings, apply_settings_cb, reinterpret_cast<VALUE>(&q));
+}
+
 // Client.new(host:, port:, database:, user:, password:)
 static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kwargs = Qnil;
@@ -734,7 +766,7 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
 namespace {
 struct ExecuteNoGVL {
     Client* client;
-    std::string sql;
+    const Query* query;
     std::exception_ptr err;
 };
 }  // namespace
@@ -742,7 +774,7 @@ struct ExecuteNoGVL {
 static void* execute_no_gvl(void* data) {
     auto* a = static_cast<ExecuteNoGVL*>(data);
     try {
-        a->client->Execute(Query(a->sql));
+        a->client->Execute(*a->query);
     } catch (...) {
         a->err = std::current_exception();
     }
@@ -756,12 +788,17 @@ static void execute_unblock(void* data) {
     try { a->client->ResetConnection(); } catch (...) {}
 }
 
-static VALUE ch_client_execute(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_execute(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");
 
-    ExecuteNoGVL args{c->client.get(), std::string(StringValueCStr(rb_sql)), nullptr};
+    Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_settings(q, kwargs);
+
+    ExecuteNoGVL args{c->client.get(), &q, nullptr};
     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
@@ -779,16 +816,19 @@ static VALUE ch_client_execute(VALUE self, VALUE rb_sql) {
 // See query_each below for a streaming, GVL-releasing variant.
 // ------------------------------------------------------------------
 
-static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
+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");
 
-    std::string sql(StringValueCStr(rb_sql));
     VALUE rows = rb_ary_new();
     try {
         std::vector<ID> col_ids;
-        c->client->Select(sql, [&](const Block& block) {
+        Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+        apply_settings(q, kwargs);
+        q.OnData([&](const Block& block) {
             size_t ncols = block.GetColumnCount();
             size_t nrows = block.GetRowCount();
             if (nrows == 0) return;
@@ -808,6 +848,7 @@ static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
                 rb_ary_push(rows, h);
             }
         });
+        c->client->Execute(q);
         return rows;
     } catch (const std::exception& e) {
         try { c->client->ResetConnection(); } catch (...) {}
@@ -820,21 +861,25 @@ static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
 // query_value — returns the first cell of the first row, or nil
 // ------------------------------------------------------------------
 
-static VALUE ch_client_query_value(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_query_value(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");
 
-    std::string sql(StringValueCStr(rb_sql));
     try {
         VALUE out = Qnil;
         bool seen = false;
-        c->client->Select(sql, [&](const Block& block) {
+        Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+        apply_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 (...) {}
@@ -958,7 +1003,7 @@ struct YieldBlockArgs {
 
 struct QueryEachNoGVL {
     Client* client;
-    std::string sql;
+    const Query* query;
     QueryEachState* state;
     std::exception_ptr err;
 };
@@ -1003,12 +1048,7 @@ static void* with_gvl_yield(void* data) {
 static void* query_each_no_gvl(void* data) {
     auto* a = static_cast<QueryEachNoGVL*>(data);
     try {
-        a->client->SelectCancelable(a->sql, [&](const Block& block) -> bool {
-            if (a->state->aborted) return false;
-            YieldBlockArgs ya{&block, a->state};
-            rb_thread_call_with_gvl(with_gvl_yield, &ya);
-            return !a->state->aborted;
-        });
+        a->client->Execute(*a->query);
     } catch (...) {
         a->err = std::current_exception();
     }
@@ -1021,19 +1061,24 @@ static void query_each_unblock(void* data) {
     try { a->client->ResetConnection(); } catch (...) {}
 }
 
-static VALUE ch_client_query_each(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
     rb_need_block();
+    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");
 
     QueryEachState state{rb_block_proc(), {}, 0, false};
-    QueryEachNoGVL args{
-        c->client.get(),
-        std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)),
-        &state,
-        nullptr,
-    };
+    Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_settings(q, kwargs);
+    q.OnDataCancelable([&state](const Block& block) -> bool {
+        if (state.aborted) return false;
+        YieldBlockArgs ya{&block, &state};
+        rb_thread_call_with_gvl(with_gvl_yield, &ya);
+        return !state.aborted;
+    });
+    QueryEachNoGVL args{c->client.get(), &q, &state, nullptr};
 
     rb_thread_call_without_gvl(query_each_no_gvl, &args, query_each_unblock, &args);
 
@@ -1139,13 +1184,13 @@ extern "C" void Init_clickhouse_native(void) {
     rb_define_method(rb_cClient, "initialize",
         reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_initialize), -1);
     rb_define_method(rb_cClient, "execute",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_execute), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_execute), -1);
     rb_define_method(rb_cClient, "query",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query), -1);
     rb_define_method(rb_cClient, "query_value",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_value), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_value), -1);
     rb_define_method(rb_cClient, "query_each",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_each), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_each), -1);
     rb_define_method(rb_cClient, "insert_block",
         reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_insert_block), 3);
     rb_define_method(rb_cClient, "ping",

data/lib/clickhouse_native/logging.rb

@@ -12,19 +12,19 @@ module ClickhouseNative
   module Logging
     LEVEL = :debug
 
-    def execute(sql)
+    def execute(sql, **opts)
       log_sql(sql) { super }
     end
 
-    def query(sql)
+    def query(sql, **opts)
       log_sql(sql) { super }
     end
 
-    def query_value(sql)
+    def query_value(sql, **opts)
       log_sql(sql) { super }
     end
 
-    def query_each(sql, &)
+    def query_each(sql, **opts, &)
       log_sql(sql) { super }
     end
 

data/lib/clickhouse_native/pool.rb

@@ -29,29 +29,44 @@ module ClickhouseNative
     # session settings), 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.
     def with
-      @pool.with do |client|
-        yield client
-      rescue
-        @pool.discard_current_connection(&:close)
+      attempts = 0
+      begin
+        @pool.with do |client|
+          yield client
+        rescue
+          @pool.discard_current_connection(&:close)
+          raise
+        end
+      rescue ConnectionError
+        attempts += 1
+        retry if attempts == 1
         raise
       end
     end
 
-    def execute(sql)
-      with { |c| c.execute(sql) }
+    def execute(sql, **opts)
+      with { |c| c.execute(sql, **opts) }
     end
 
-    def query(sql)
-      with { |c| c.query(sql) }
+    def query(sql, **opts)
+      with { |c| c.query(sql, **opts) }
     end
 
-    def query_each(sql, &block)
-      with { |c| c.query_each(sql, &block) }
+    def query_each(sql, **opts, &block)
+      with { |c| c.query_each(sql, **opts, &block) }
     end
 
-    def query_value(sql)
-      with { |c| c.query_value(sql) }
+    def query_value(sql, **opts)
+      with { |c| c.query_value(sql, **opts) }
     end
 
     def insert(table, rows, **opts)

data/lib/clickhouse_native/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Yuri Smirnov
@@ -310,7 +310,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: ClickHouse Ruby driver over the native TCP protocol
 test_files: []