clickhouse-native 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b77997a63f9cfed092a0c26eccaeb63e34aad3072d52aff9f20f0bfaeaaeffa7
-  data.tar.gz: ebdf9129e7e6bea78bc12dfe0b04246a14d7a03024bf49feb67dc43f3bf6435b
+  metadata.gz: 2f3cc163e6a966e97acca8801841c4512293870eaf1461d04cd3050a4aa4fd73
+  data.tar.gz: 0abc84555ec48af61ac6d56e526a22e1bb17ddf87ad417cba63bcfbf844a08ef
 SHA512:
-  metadata.gz: db47e0695db8a4e7d448372fafb0aaa3c6483909d787cf970d6cd5386199df779c68247eb638f6a83ea3e18e12f2a45c505121351459abe65ce9b08ce01f0653
-  data.tar.gz: f2c7c53106b186021a587e2b6a85991500cc322886b32392b6a32cc5da35e043914da6c43009804df8571496ce65f3e4e46c8497baf0b85ba2ecaaf4bde6ab9a
+  metadata.gz: fbf92ccd73e237a8855f158477c54c6a12b1a630e2cf2a145386b2d624bbc2080747c06e2a247c0e58a159b26c7192981309e1a769c9e6cf66d4badf82a7639c
+  data.tar.gz: ce7dc8ae0256db019528ae9d50b43710230a2f70939e82367a34d2c643a04a420199a689eec79dd11f845f6ea1b103ee7a8aba724881fe6432d57aa0aa4803e2

data/ext/clickhouse_native/client.cpp

@@ -296,6 +296,20 @@ static VALUE value_at(const ColumnRef& col, size_t idx, const std::string& decla
 
 static void append_value(const ColumnRef& col, VALUE value);
 
+// rb_hash_foreach callback: appends each key/value pair into the columns
+// passed via the context pointer. Used by the Map encoder.
+struct MapInsertCtx {
+    ColumnRef key_col;
+    ColumnRef val_col;
+};
+
+static int append_map_pair(VALUE key, VALUE val, VALUE arg) {
+    auto* ctx = reinterpret_cast<MapInsertCtx*>(arg);
+    append_value(ctx->key_col, key);
+    append_value(ctx->val_col, val);
+    return ST_CONTINUE;
+}
+
 // Append a zero/default value; used for the nested column of Nullable when
 // the flag is set to null. We never expose these bytes to the caller.
 static void append_default(const ColumnRef& col) {
@@ -539,8 +553,8 @@ static void append_value(const ColumnRef& col, VALUE value) {
 
         case Type::LowCardinality: {
             // Only LowCardinality(String) and LowCardinality(Nullable(String))
-            // are supported for insert in v1 — this covers the profile-service
-            // use case. Numeric LC dictionaries are rare and can wait.
+            // are supported for insert. Numeric LC dictionaries are rare and
+            // can wait.
             auto nested_type = type->As<LowCardinalityType>()->GetNestedType();
             bool nullable = nested_type->GetCode() == Type::Nullable;
             auto inner_type = nullable
@@ -576,6 +590,43 @@ static void append_value(const ColumnRef& col, VALUE value) {
             return;
         }
 
+        case Type::Map: {
+            // CH's wire format for Map(K, V) is Array(Tuple(K, V)). We build
+            // a one-row Map column holding all of this row's pairs and
+            // Append it to the target — ColumnMap exposes only Append(map),
+            // its underlying ColumnArray is private. Nil is treated as an
+            // empty map.
+            if (NIL_P(value)) value = rb_hash_new();
+            Check_Type(value, T_HASH);
+            auto map_type = type->As<MapType>();
+            auto key_type = map_type->GetKeyType();
+            auto val_type = map_type->GetValueType();
+
+            auto key_col = CreateColumnByType(key_type->GetName());
+            auto val_col = CreateColumnByType(val_type->GetName());
+            if (!key_col || !val_col) {
+                throw chn::EncoderFailure(
+                    "cannot create columns for Map(" + key_type->GetName() +
+                    ", " + val_type->GetName() + ")");
+            }
+
+            MapInsertCtx ctx{key_col, val_col};
+            rb_hash_foreach(value, append_map_pair, reinterpret_cast<VALUE>(&ctx));
+
+            auto src_tuple = std::make_shared<ColumnTuple>(
+                std::vector<ColumnRef>{key_col, val_col});
+
+            auto seed_tuple = std::make_shared<ColumnTuple>(std::vector<ColumnRef>{
+                CreateColumnByType(key_type->GetName()),
+                CreateColumnByType(val_type->GetName()),
+            });
+            auto seed_array = std::make_shared<ColumnArray>(seed_tuple);
+            seed_array->AppendAsColumn(src_tuple);
+
+            col->As<ColumnMap>()->Append(std::make_shared<ColumnMap>(seed_array));
+            return;
+        }
+
         default:
             throw chn::EncoderFailure(
                 "cannot insert into column of type " + type->GetName());

data/lib/clickhouse_native/pool.rb

@@ -4,8 +4,6 @@ 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: "",
@@ -23,19 +21,20 @@ module ClickhouseNative
       end
     end
 
-    # 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.
+    # On exception, discard the client rather than reuse it: an error
+    # path leaves the socket 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.
     def with
       @pool.with do |client|
-        reapply_settings_if_stale(client)
-        begin
-          yield client
-        rescue
-          client.instance_variable_set(STALE_IVAR, true)
-          raise
-        end
+        yield client
+      rescue
+        @pool.discard_current_connection(&:close)
+        raise
       end
     end
 
@@ -73,13 +72,6 @@ module ClickhouseNative
 
     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.5.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Yuri Smirnov
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 2.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 2.5.4
 description: A high-performance Ruby client for ClickHouse using the native binary
   protocol via a C++ extension wrapping clickhouse-cpp.
 email: