clickhouse-native 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2ae7d2e92132e0d22bb51146348282c7009d4db404faf7c980a22bde81c6e34
-  data.tar.gz: e3075a98f28385d5a7b47fa909f3d3290124ec7299c0fafa9126aabb1e50ea91
+  metadata.gz: d1bf3fdd8bd132c0d19937f50055f56b5ab55f4bf383fafc63a74131ff435545
+  data.tar.gz: 4e6f233a2e250ee5c2c6c1e46ebf9a961416b69553aee7c2018afea619c1abab
 SHA512:
-  metadata.gz: 3297b9411533624dc51a944f3f7b1af442c57887da09d8eccd9659e13c946493746d1b4116dff9636b4a19e480754d1b73a932e2b65960a49ea92f646e2c0d9f
-  data.tar.gz: ac467f35eb0fc86e92b1630ed671305d410926513025ab44b0e66eae8050283df0a28c768ed91700027a7c42418c3063bdde9fbdfa8b70d62e2f58e02a7c45e4
+  metadata.gz: a79cba4fd6ad33b75ec2eecadf87ec0e9fc163ff46874b2ad687f6d767405f7357fffe04a1af584a6716d0c1dcc3ba7171b201a46b130c327d87e3b5e04c52ad
+  data.tar.gz: 7ed472036327f17efceda43eac9f41cf7e6675e267711de5f974b2b75de88fcc5e557e7290ef1b0f00b084573fc4a8a5a88e49875d0b4fb83237302262b418f4

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

@@ -29,11 +29,26 @@ 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

data/lib/clickhouse_native/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Yuri Smirnov