clickhouse-native 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbf19153b9c176c74fb8f20afb63e729234e03d3c8603b68746c474cabd53fe4
-  data.tar.gz: a8400e1c62470dce319fd655e4fa90a930848e1e76134cc2dec02c978b6fb011
+  metadata.gz: 7bd4c34d5b234b7e69e31760baf997bf26b11ed5409564ff7c8aeb900a9799b7
+  data.tar.gz: 96cc5dd2feea27635c14f90e05818ceddcfa2cf76dfdab1cb77c7b9332b9ef59
 SHA512:
-  metadata.gz: d48367dcae10c7921dfd2021a8e99af178e97708a314f15d3c30a38c33118ba027e47fc8eef2a5eaa60f3c257a2f6ecb6c2b48565cfa045d23f79da77691026d
-  data.tar.gz: 7080239fb14c0b7e1a0787942ea1a000749d36732744253dd9d1c7705bafea055970efb0a7f0163b480282b92b9e6abe520a36f044db8cf609b0de4587b50930
+  metadata.gz: 39abed1faa63eadd6a1f56f2be45f943cf3037fc01c4e9f235863e64e2dc4eea643731be9428ae872b2be72412262ca151d9e73bde1104ae1d3c21aa80212f5c
+  data.tar.gz: 7090e04f9b60c7b07b46c57e9117df800f5e94c21ab7b630de4ba4e58fb11822fe4a40a722c2133796a29bbd1107e7d1ab80ab9df0a5f5ae552d2258babc7f0f

data/ext/clickhouse_native/client.cpp

@@ -101,7 +101,22 @@ static int64_t pow10_i64(size_t n) {
     return r;
 }
 
-static VALUE value_at(const ColumnRef& col, size_t idx) {
+static VALUE value_at(const ColumnRef& col, size_t idx, const std::string& declared_type = {}) {
+    // clickhouse-cpp normalises Bool -> UInt8 at column-construction time,
+    // so at the codec layer we see UInt8 and can't tell Bool apart without
+    // the declared type string that came over the wire. The patched vendor
+    // tree preserves it on Block; we consume it here for top-level columns.
+    // Nested occurrences (Array(Bool), Map(_, Bool)) are not handled — the
+    // declared type for nested children is not threaded through recursion.
+    if (declared_type == "Bool") {
+        return col->As<ColumnUInt8>()->At(idx) ? Qtrue : Qfalse;
+    }
+    if (declared_type == "Nullable(Bool)") {
+        auto n = col->As<ColumnNullable>();
+        if (n->IsNull(idx)) return Qnil;
+        return n->Nested()->As<ColumnUInt8>()->At(idx) ? Qtrue : Qfalse;
+    }
+
     auto type = col->Type();
     switch (type->GetCode()) {
         case Type::Int8:    return INT2NUM(col->As<ColumnInt8>()->At(idx));
@@ -736,7 +751,8 @@ static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
             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));
+                    rb_hash_aset(h, ID2SYM(col_ids[cc]),
+                                 value_at(block[cc], r, block.GetColumnType(cc)));
                 }
                 rb_ary_push(rows, h);
             }
@@ -765,7 +781,7 @@ static VALUE ch_client_query_value(VALUE self, VALUE rb_sql) {
         c->client->Select(sql, [&](const Block& block) {
             if (seen) return;
             if (block.GetRowCount() == 0 || block.GetColumnCount() == 0) return;
-            out = value_at(block[0], 0);
+            out = value_at(block[0], 0, block.GetColumnType(0));
             seen = true;
         });
         return out;
@@ -914,7 +930,8 @@ static VALUE yield_rows_body(VALUE arg) {
     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));
+            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);
     }

data/ext/clickhouse_native/extconf.rb

@@ -35,6 +35,24 @@ unless File.exist?(File.join(VENDOR, "CMakeLists.txt"))
   MSG
 end
 
+# Apply in-tree patches to the vendored clickhouse-cpp before CMake
+# configures/builds it. Patches are idempotent: skip any that already
+# apply in reverse (meaning they've been applied previously).
+PATCHES_DIR = File.expand_path("patches", EXT_DIR)
+if Dir.exist?(PATCHES_DIR)
+  Dir[File.join(PATCHES_DIR, "*.patch")].each do |patch|
+    # -R --check: does the patch apply in reverse? If yes, already applied.
+    already_applied = system(
+      "patch", "-R", "--dry-run", "-p1", "-s", "-f",
+      "-d", VENDOR, "-i", patch,
+      out: File::NULL, err: File::NULL
+    )
+    next if already_applied
+    system("patch", "-p1", "-s", "-f", "-d", VENDOR, "-i", patch) or
+      fatal("failed to apply patch: #{patch}")
+  end
+end
+
 unless find_executable("cmake")
   fatal <<~MSG
     CMake is required to build the vendored clickhouse-cpp library

data/ext/clickhouse_native/patches/0001-preserve-declared-column-type.patch

@@ -0,0 +1,74 @@
+diff --git a/clickhouse/block.cpp b/clickhouse/block.cpp
+index 519cfa4..15334c5 100644
+--- a/clickhouse/block.cpp
++++ b/clickhouse/block.cpp
+@@ -53,13 +53,17 @@ Block::Block(size_t cols, size_t rows)
+ Block::~Block() = default;
+ 
+ void Block::AppendColumn(const std::string& name, const ColumnRef& col) {
++    AppendColumn(name, col, std::string());
++}
++
++void Block::AppendColumn(const std::string& name, const ColumnRef& col, const std::string& type) {
+     if (columns_.empty()) {
+         rows_ = col->Size();
+     } else if (col->Size() != rows_) {
+         throw ValidationError("all columns in block must have same count of rows. Name: ["+name+"], rows: ["+std::to_string(rows_)+"], columns: [" + std::to_string(col->Size())+"]");
+     }
+ 
+-    columns_.push_back(ColumnItem{name, col});
++    columns_.push_back(ColumnItem{name, col, type});
+ }
+ 
+ /// Count of columns in the block.
+diff --git a/clickhouse/block.h b/clickhouse/block.h
+index a32cd02..d2263cb 100644
+--- a/clickhouse/block.h
++++ b/clickhouse/block.h
+@@ -67,6 +67,11 @@ public:
+ 
+     /// Append named column to the block.
+     void AppendColumn(const std::string& name, const ColumnRef& col);
++    /// Same, but preserves the declared wire type string (e.g. "Bool",
++    /// "Nullable(Bool)") alongside the column. clickhouse-cpp normalises
++    /// some types at column construction (Bool -> UInt8, etc.), so keep the
++    /// original for callers who need to recover the true declared type.
++    void AppendColumn(const std::string& name, const ColumnRef& col, const std::string& type);
+ 
+     /// Count of columns in the block.
+     size_t GetColumnCount() const;
+@@ -85,6 +90,13 @@ public:
+         return columns_.at(idx).name;
+     }
+ 
++    /// Declared wire type string for the column at `idx` (e.g. "Bool",
++    /// "Nullable(Bool)"). Empty for columns appended via the two-arg
++    /// AppendColumn overload.
++    const std::string& GetColumnType(size_t idx) const {
++        return columns_.at(idx).type;
++    }
++
+     /// Convenience method to wipe out all rows from all columns
+     void Clear();
+ 
+@@ -103,6 +115,7 @@ private:
+     struct ColumnItem {
+         std::string name;
+         ColumnRef   column;
++        std::string type;
+     };
+ 
+     BlockInfo info_;
+diff --git a/clickhouse/client.cpp b/clickhouse/client.cpp
+index a8c8ea6..d81f636 100644
+--- a/clickhouse/client.cpp
++++ b/clickhouse/client.cpp
+@@ -784,7 +784,7 @@ bool Client::Impl::ReadBlock(InputStream& input, Block* block) {
+                 throw ProtocolError("can't load column '" + name + "' of type " + type);
+             }
+ 
+-            block->AppendColumn(name, col);
++            block->AppendColumn(name, col, type);
+         } else {
+             throw UnimplementedError(std::string("unsupported column type: ") + type);
+         }

data/lib/clickhouse_native/pool.rb

@@ -4,6 +4,8 @@ require "connection_pool"
 
 module ClickhouseNative
   class Pool
+    STALE_IVAR = :@clickhouse_native_settings_stale
+
     attr_reader :host, :port, :database
 
     def initialize(host:, port:, database: "default", user: "default", password: "",
@@ -13,52 +15,71 @@ module ClickhouseNative
       @port = port
       @database = database
       client_kwargs = { host:, port:, database:, user:, password:, compression:, logger: }
-      set_sql = settings_sql(settings)
+      @set_sql = settings_sql(settings)
       @pool = ConnectionPool.new(size: pool_size, timeout: pool_timeout) do
         client = Client.new(**client_kwargs)
-        client.execute(set_sql) if set_sql
+        client.execute(@set_sql) if @set_sql
         client
       end
     end
 
-    def with(&)
-      @pool.with(&)
+    # Yields a client with the pool's session settings applied. If the
+    # previous checkout raised (which, in this gem's C++ bindings, always
+    # triggers a ResetConnection that wipes the session), re-apply the SET
+    # before yielding. Exceptions re-raise after marking the client stale.
+    def with
+      @pool.with do |client|
+        reapply_settings_if_stale(client)
+        begin
+          yield client
+        rescue
+          client.instance_variable_set(STALE_IVAR, true)
+          raise
+        end
+      end
     end
 
     def execute(sql)
-      @pool.with { |c| c.execute(sql) }
+      with { |c| c.execute(sql) }
     end
 
     def query(sql)
-      @pool.with { |c| c.query(sql) }
+      with { |c| c.query(sql) }
     end
 
     def query_each(sql, &block)
-      @pool.with { |c| c.query_each(sql, &block) }
+      with { |c| c.query_each(sql, &block) }
     end
 
     def query_value(sql)
-      @pool.with { |c| c.query_value(sql) }
+      with { |c| c.query_value(sql) }
     end
 
     def insert(table, rows, **opts)
-      @pool.with { |c| c.insert(table, rows, **opts) }
+      with { |c| c.insert(table, rows, **opts) }
     end
 
     def ping
-      @pool.with(&:ping)
+      with(&:ping)
     end
 
     def server_version
-      @pool.with(&:server_version)
+      with(&:server_version)
     end
 
     def describe_table(table, db_name: nil)
-      @pool.with { |c| c.describe_table(table, db_name:) }
+      with { |c| c.describe_table(table, db_name:) }
     end
 
     private
 
+    def reapply_settings_if_stale(client)
+      return unless @set_sql
+      return unless client.instance_variable_get(STALE_IVAR)
+      client.execute(@set_sql)
+      client.instance_variable_set(STALE_IVAR, false)
+    end
+
     # 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

data/lib/clickhouse_native/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Yuri Smirnov
@@ -34,6 +34,7 @@ extra_rdoc_files: []
 files:
 - ext/clickhouse_native/client.cpp
 - ext/clickhouse_native/extconf.rb
+- ext/clickhouse_native/patches/0001-preserve-declared-column-type.patch
 - ext/clickhouse_native/vendor/clickhouse-cpp/.clang-format
 - ext/clickhouse_native/vendor/clickhouse-cpp/.git
 - ext/clickhouse_native/vendor/clickhouse-cpp/.gitattributes