clickhouse-native 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80f06499c2088ed7d221e22eb2286da9db531eeb0322b94c65333cbeb6f0ecc6
-  data.tar.gz: 9ebf8a7b867cd4ca90aedb7d96f62f56e5121ac5f5bd36808a947a9ffe57cfc4
+  metadata.gz: 51aa32b5ec77367fcc08b8df05c2449bb8e99b7f1cc3b7cc331d83c408cea32c
+  data.tar.gz: 3b28a9d0cde5d7c827f212bb5ecde1d0dee21f5a8e4cc2faaa20de06534f59d5
 SHA512:
-  metadata.gz: bd5bfef33530626520a66fee2e14c4d1e07cbc9d6483cb6c0e8f53e65e93f5a14328bea4dbf08e35839227e4376fe0c67660d8b74e5f8d9c9503be570735e2c6
-  data.tar.gz: a9dc31d3f8ac4dd2b4d24d74847035917509604861b60e668b93a37cdcddd93de66ae086c45feb05052242679c21b1d2e1eb28afd3d1e6df65998a8b14d56d2b
+  metadata.gz: 825b57cd31290f4717a5e38d7b0d08c7949e455c23246913f1885db868a63b0b44a600f9527dd5f7175f889d1e9327f7b75af4ada2075aa5d2b7284f0b88184c
+  data.tar.gz: 6c178edde2ba5ffbd1bee2f439e8d5c2d3dd3932c80442b9da34090cfc3286388a2cf3b834ff43a476aa7c68d1aaedc91409b48287a3e940383d8f8d98a75222

data/ext/clickhouse_native/client.cpp

@@ -4,6 +4,7 @@
 #include <clickhouse/client.h>
 #include <clickhouse/columns/array.h>
 #include <clickhouse/columns/date.h>
+#include <clickhouse/columns/decimal.h>
 #include <clickhouse/columns/enum.h>
 #include <clickhouse/columns/factory.h>
 #include <clickhouse/columns/lowcardinality.h>
@@ -30,12 +31,21 @@ static VALUE rb_cClient;
 static VALUE err_base, err_connection, err_timeout, err_protocol,
              err_server, err_encoder, err_decoder, err_unsupported;
 
-// Internal exception used to tag encoder failures and drive them through
-// raise_mapped_ex -> err_encoder without rb_raising from inside a try block.
+// Internal exceptions used to tag encoder / decoder failures and drive
+// them through raise_mapped_ex -> err_encoder / err_unsupported /
+// err_decoder without rb_raising from inside a try block. Critically,
+// throwing (instead of rb_raise) lets the outer catch run
+// ResetConnection() so the pooled client doesn't stay mid-packet.
 namespace chn {
 class EncoderFailure : public clickhouse::Error {
     using clickhouse::Error::Error;
 };
+class UnsupportedType : public clickhouse::Error {
+    using clickhouse::Error::Error;
+};
+class DecoderFailure : public clickhouse::Error {
+    using clickhouse::Error::Error;
+};
 }  // namespace chn
 
 // ------------------------------------------------------------------
@@ -56,6 +66,12 @@ static void raise_mapped_ex(const std::exception& e) {
     if (dynamic_cast<const chn::EncoderFailure*>(&e)) {
         rb_raise(err_encoder, "%s", e.what());
     }
+    if (dynamic_cast<const chn::UnsupportedType*>(&e)) {
+        rb_raise(err_unsupported, "%s", e.what());
+    }
+    if (dynamic_cast<const chn::DecoderFailure*>(&e)) {
+        rb_raise(err_decoder, "%s", e.what());
+    }
     if (dynamic_cast<const ProtocolError*>(&e)) {
         rb_raise(err_protocol, "%s", e.what());
     }
@@ -99,6 +115,55 @@ static VALUE value_at(const ColumnRef& col, size_t idx) {
         case Type::Float32: return DBL2NUM(col->As<ColumnFloat32>()->At(idx));
         case Type::Float64: return DBL2NUM(col->As<ColumnFloat64>()->At(idx));
 
+        case Type::Decimal:
+        case Type::Decimal32:
+        case Type::Decimal64:
+        case Type::Decimal128: {
+            // ClickHouse stores decimals as scaled integers. clickhouse-cpp
+            // returns them as Int128. To preserve precision, we format the
+            // unscaled int into a string at the column's scale and construct
+            // a BigDecimal from it.
+            auto dec = col->As<ColumnDecimal>();
+            auto unscaled = dec->At(idx);  // Int128 (absl::int128)
+            size_t scale = type->As<DecimalType>()->GetScale();
+
+            bool neg = unscaled < 0;
+            absl::uint128 mag = neg
+                ? absl::uint128(-static_cast<absl::int128>(unscaled))
+                : absl::uint128(static_cast<absl::int128>(unscaled));
+
+            // Render magnitude in base 10, then place the decimal point.
+            char buf[48];
+            int len = 0;
+            if (mag == absl::uint128(0)) {
+                buf[len++] = '0';
+            } else {
+                while (mag > absl::uint128(0)) {
+                    absl::uint128 q = mag / absl::uint128(10);
+                    absl::uint128 r = mag - q * absl::uint128(10);
+                    buf[len++] = '0' + static_cast<int>(absl::Uint128Low64(r));
+                    mag = q;
+                }
+            }
+            // Pad with leading zeros so we have at least scale+1 digits.
+            while (static_cast<size_t>(len) <= scale) buf[len++] = '0';
+
+            std::string out;
+            out.reserve(len + 3);
+            if (neg) out.push_back('-');
+            for (int i = len - 1; i >= 0; i--) {
+                if (scale > 0 && static_cast<size_t>(i) == scale - 1) {
+                    // Insert decimal point before the last `scale` digits.
+                    out.push_back('.');
+                }
+                out.push_back(buf[i]);
+            }
+
+            VALUE rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+            return rb_funcall(rb_cBigDecimal, rb_intern("BigDecimal"), 1,
+                              rb_utf8_str_new(out.data(), out.size()));
+        }
+
         case Type::String: {
             auto sv = col->As<ColumnString>()->At(idx);
             return rb_utf8_str_new(sv.data(), sv.size());
@@ -149,7 +214,11 @@ static VALUE value_at(const ColumnRef& col, size_t idx) {
 
         case Type::LowCardinality: {
             auto lc = col->As<ColumnLowCardinality>();
-            auto sv = lc->GetItem(idx).AsBinaryData();
+            ItemView item = lc->GetItem(idx);
+            // For LowCardinality(Nullable(T)), clickhouse-cpp's GetItem returns
+            // a default-constructed ItemView (type == Void) for null rows.
+            if (item.type == Type::Void) return Qnil;
+            auto sv = item.AsBinaryData();
             return rb_utf8_str_new(sv.data(), sv.size());
         }
 
@@ -158,7 +227,7 @@ static VALUE value_at(const ColumnRef& col, size_t idx) {
             auto tuples = map_col->GetAsColumn(idx);
             auto tuple = tuples->As<ColumnTuple>();
             if (!tuple || tuple->TupleSize() != 2) {
-                rb_raise(err_decoder, "clickhouse-native: malformed Map column");
+                throw chn::DecoderFailure("clickhouse-native: malformed Map column");
             }
             auto keys = (*tuple)[0];
             auto vals = (*tuple)[1];
@@ -188,9 +257,10 @@ static VALUE value_at(const ColumnRef& col, size_t idx) {
         }
 
         default:
-            rb_raise(err_unsupported,
-                     "clickhouse-native: unsupported column type %s (code=%d)",
-                     type->GetName().c_str(), static_cast<int>(type->GetCode()));
+            throw chn::UnsupportedType(
+                std::string("clickhouse-native: unsupported column type ")
+                + type->GetName()
+                + " (code=" + std::to_string(static_cast<int>(type->GetCode())) + ")");
     }
     return Qnil;
 }
@@ -222,6 +292,26 @@ static void append_default(const ColumnRef& col) {
         case Type::Date32:      col->As<ColumnDate32>()->Append(0); return;
         case Type::DateTime:    col->As<ColumnDateTime>()->Append(0); return;
         case Type::DateTime64:  col->As<ColumnDateTime64>()->Append(0); return;
+        case Type::Decimal:
+        case Type::Decimal32:
+        case Type::Decimal64:
+        case Type::Decimal128:   col->As<ColumnDecimal>()->Append(std::string("0")); return;
+        case Type::LowCardinality: {
+            auto nested_type = type->As<LowCardinalityType>()->GetNestedType();
+            bool nullable = nested_type->GetCode() == Type::Nullable;
+            if (!nullable) {
+                auto lct = col->AsStrict<ColumnLowCardinalityT<ColumnString>>();
+                lct->Append(std::string_view());
+            } else {
+                auto tmp_inner = std::make_shared<ColumnString>();
+                auto tmp_nulls = std::make_shared<ColumnUInt8>();
+                tmp_inner->Append(std::string_view());
+                tmp_nulls->Append(1);
+                auto tmp = std::make_shared<ColumnNullable>(tmp_inner, tmp_nulls);
+                col->As<ColumnLowCardinality>()->Append(tmp);
+            }
+            return;
+        }
         case Type::Array: {
             auto inner_type = type->As<ArrayType>()->GetItemType();
             auto inner_col = CreateColumnByType(inner_type->GetName());
@@ -234,6 +324,51 @@ static void append_default(const ColumnRef& col) {
     }
 }
 
+// Detect a trailing timezone indicator: "Z", "+HHMM", "+HH:MM", or the
+// same with '-' (anywhere after the date portion, so the '-' inside
+// "YYYY-MM-DD" doesn't match). Used to decide whether a naked timestamp
+// string should be forced to UTC.
+static bool has_trailing_tz(const char* s, size_t len) {
+    if (len == 0) return false;
+    if (s[len - 1] == 'Z' || s[len - 1] == 'z') return true;
+    // walk backwards for a '+' or '-' within the last 6 chars (HH:MM / HHMM)
+    size_t limit = len > 6 ? len - 6 : 0;
+    for (size_t i = len; i-- > limit; ) {
+        if (i < 11) break;  // position must be past "YYYY-MM-DD "
+        if (s[i] == '+' || s[i] == '-') return true;
+    }
+    return false;
+}
+
+// Accepts a Time, a String (parsed via Time.parse), or a numeric (epoch
+// seconds). Mirrors how the HTTP gem's JSONEachRow coerced date cells.
+//
+// Naked timestamp strings (no trailing TZ indicator) are parsed as UTC —
+// CH's DateTime64(N, 'UTC') convention. Strings with explicit zones are
+// respected.
+static VALUE coerce_to_time(VALUE value) {
+    if (rb_obj_is_kind_of(value, rb_cTime)) return value;
+    if (RB_TYPE_P(value, T_STRING)) {
+        const char* p = RSTRING_PTR(value);
+        long n = RSTRING_LEN(value);
+        VALUE to_parse = value;
+        if (!has_trailing_tz(p, n)) {
+            std::string with_utc(p, n);
+            with_utc.append(" UTC");
+            to_parse = rb_utf8_str_new(with_utc.data(), with_utc.size());
+        }
+        return rb_funcall(rb_cTime, rb_intern("parse"), 1, to_parse);
+    }
+    if (RB_INTEGER_TYPE_P(value) || RB_FLOAT_TYPE_P(value)) {
+        return rb_funcall(rb_cTime, rb_intern("at"), 1, value);
+    }
+    // Date / DateTime / other responds to to_time
+    if (rb_respond_to(value, rb_intern("to_time"))) {
+        return rb_funcall(value, rb_intern("to_time"), 0);
+    }
+    throw chn::EncoderFailure("cannot coerce value to Time");
+}
+
 static int64_t time_to_datetime64_ticks(VALUE value, size_t prec) {
     VALUE to_i = rb_funcall(value, rb_intern("to_i"), 0);
     VALUE nsec = rb_funcall(value, rb_intern("nsec"), 0);
@@ -246,6 +381,29 @@ static int64_t time_to_datetime64_ticks(VALUE value, size_t prec) {
 
 static void append_value(const ColumnRef& col, VALUE value) {
     auto type = col->Type();
+    // Graceful nil handling for non-Nullable columns — mirrors how the HTTP
+    // gem's JSONEachRow insert silently coerced nil to the column default.
+    // Structural types (Nullable/Array/Map/Tuple/LowCardinality) have their
+    // own nil semantics handled below.
+    if (NIL_P(value)) {
+        auto code = type->GetCode();
+        // Structural types handle nil via their own semantics below.
+        if (code != Type::Nullable && code != Type::Array &&
+            code != Type::Map && code != Type::Tuple) {
+            append_default(col);
+            return;
+        }
+    }
+    // Bool columns come over the wire as UInt8. Ruby true/false are the
+    // natural inputs for Bool, so coerce here before the numeric cases run.
+    if (value == Qtrue) value = INT2FIX(1);
+    else if (value == Qfalse) value = INT2FIX(0);
+
+    // Symbol -> String: common for LowCardinality/String columns where
+    // callers naturally use :pt, :eur, etc. Matches how JSON serialization
+    // in the HTTP path rendered them.
+    if (SYMBOL_P(value)) value = rb_funcall(value, rb_intern("to_s"), 0);
+
     switch (type->GetCode()) {
         case Type::Int8:    col->As<ColumnInt8>()->Append(NUM2INT(value)); return;
         case Type::Int16:   col->As<ColumnInt16>()->Append(NUM2INT(value)); return;
@@ -272,23 +430,24 @@ static void append_value(const ColumnRef& col, VALUE value) {
         }
 
         case Type::Date: {
-            VALUE to_i = rb_funcall(value, rb_intern("to_i"), 0);
-            col->As<ColumnDate>()->Append(static_cast<std::time_t>(NUM2LL(to_i)));
+            VALUE t = coerce_to_time(value);
+            col->As<ColumnDate>()->Append(static_cast<std::time_t>(NUM2LL(rb_funcall(t, rb_intern("to_i"), 0))));
             return;
         }
         case Type::Date32: {
-            VALUE to_i = rb_funcall(value, rb_intern("to_i"), 0);
-            col->As<ColumnDate32>()->Append(static_cast<std::time_t>(NUM2LL(to_i)));
+            VALUE t = coerce_to_time(value);
+            col->As<ColumnDate32>()->Append(static_cast<std::time_t>(NUM2LL(rb_funcall(t, rb_intern("to_i"), 0))));
             return;
         }
         case Type::DateTime: {
-            VALUE to_i = rb_funcall(value, rb_intern("to_i"), 0);
-            col->As<ColumnDateTime>()->Append(static_cast<std::time_t>(NUM2LL(to_i)));
+            VALUE t = coerce_to_time(value);
+            col->As<ColumnDateTime>()->Append(static_cast<std::time_t>(NUM2LL(rb_funcall(t, rb_intern("to_i"), 0))));
             return;
         }
         case Type::DateTime64: {
             size_t prec = type->As<DateTime64Type>()->GetPrecision();
-            col->As<ColumnDateTime64>()->Append(time_to_datetime64_ticks(value, prec));
+            VALUE t = coerce_to_time(value);
+            col->As<ColumnDateTime64>()->Append(time_to_datetime64_ticks(t, prec));
             return;
         }
 
@@ -321,6 +480,63 @@ static void append_value(const ColumnRef& col, VALUE value) {
             return;
         }
 
+        case Type::Decimal:
+        case Type::Decimal32:
+        case Type::Decimal64:
+        case Type::Decimal128: {
+            // clickhouse-cpp's Decimal::Append(string) only scales up when a
+            // decimal point is present (see columns/decimal.cpp). "1" at
+            // scale 8 is parsed as unscaled 1 => 1e-8, not 1. Normalise
+            // through BigDecimal#to_s("F") so Integer / Float / BigDecimal
+            // all land as a fixed-point string.
+            VALUE bd = rb_funcall(rb_cObject, rb_intern("BigDecimal"), 1,
+                                  rb_funcall(value, rb_intern("to_s"), 0));
+            VALUE str = rb_funcall(bd, rb_intern("to_s"), 1,
+                                   rb_utf8_str_new_cstr("F"));
+            col->As<ColumnDecimal>()->Append(
+                std::string(RSTRING_PTR(str), RSTRING_LEN(str)));
+            return;
+        }
+
+        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.
+            auto nested_type = type->As<LowCardinalityType>()->GetNestedType();
+            bool nullable = nested_type->GetCode() == Type::Nullable;
+            auto inner_type = nullable
+                ? nested_type->As<NullableType>()->GetNestedType()
+                : nested_type;
+            auto inner_code = inner_type->GetCode();
+            if (inner_code != Type::String && inner_code != Type::FixedString) {
+                throw chn::EncoderFailure(
+                    "LowCardinality(" + nested_type->GetName() + ") insert not supported");
+            }
+            if (!nullable) {
+                auto lct = col->AsStrict<ColumnLowCardinalityT<ColumnString>>();
+                StringValue(value);
+                lct->Append(std::string_view(RSTRING_PTR(value), RSTRING_LEN(value)));
+                return;
+            }
+            // LowCardinality(Nullable(T)): the factory returns base
+            // ColumnLowCardinality wrapping ColumnNullable, not the templated
+            // T form. Build a one-row ColumnNullable<String> and Append it —
+            // the base class handles merging into the LC dictionary.
+            auto tmp_inner = std::make_shared<ColumnString>();
+            auto tmp_nulls = std::make_shared<ColumnUInt8>();
+            if (NIL_P(value)) {
+                tmp_inner->Append(std::string_view());
+                tmp_nulls->Append(1);
+            } else {
+                StringValue(value);
+                tmp_inner->Append(std::string_view(RSTRING_PTR(value), RSTRING_LEN(value)));
+                tmp_nulls->Append(0);
+            }
+            auto tmp = std::make_shared<ColumnNullable>(tmp_inner, tmp_nulls);
+            col->As<ColumnLowCardinality>()->Append(tmp);
+            return;
+        }
+
         default:
             throw chn::EncoderFailure(
                 "cannot insert into column of type " + type->GetName());
@@ -415,6 +631,9 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     rb_ivar_set(self, rb_intern("@host"), rb_utf8_str_new(host.data(), host.size()));
     rb_ivar_set(self, rb_intern("@port"), UINT2NUM(port));
     rb_ivar_set(self, rb_intern("@database"), rb_utf8_str_new(database.data(), database.size()));
+
+    VALUE logger = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("logger")), Qnil);
+    rb_ivar_set(self, rb_intern("@logger"), logger);
     return self;
 }
 
@@ -466,7 +685,8 @@ static VALUE ch_client_execute(VALUE self, VALUE rb_sql) {
 }
 
 // ------------------------------------------------------------------
-// query() — synchronous, GVL held (streaming query_each comes in Week 5)
+// query() — buffers all rows into an array; GVL is held for the duration.
+// See query_each below for a streaming, GVL-releasing variant.
 // ------------------------------------------------------------------
 
 static VALUE ch_client_query(VALUE self, VALUE rb_sql) {

data/ext/clickhouse_native/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "mkmf"
 require "fileutils"
 require "etc"
@@ -5,7 +7,11 @@ require "shellwords"
 
 EXT_DIR = __dir__
 VENDOR = File.expand_path("vendor/clickhouse-cpp", EXT_DIR)
-BUILD_DIR = File.expand_path("build", EXT_DIR)
+# Scope the cmake build dir by target arch so host and cross-compile
+# builds don't share a CMakeCache.txt (which burns in absolute paths
+# like the host cmake binary).
+ARCH = RbConfig::CONFIG["arch"] || "unknown"
+BUILD_DIR = File.expand_path("../../tmp/cpp-build-#{ARCH}", EXT_DIR)
 
 def fatal(msg)
   warn
@@ -46,6 +52,7 @@ unless find_executable("cmake")
 end
 
 cxx = ENV["CXX"] || RbConfig::CONFIG["CXX"] || "c++"
+cc = ENV["CC"] || RbConfig::CONFIG["CC"] || "cc"
 unless find_executable(cxx.split.first)
   fatal <<~MSG
     A C++17-capable compiler is required.
@@ -59,23 +66,49 @@ end
 
 FileUtils.mkdir_p(BUILD_DIR)
 
+darwin_cross = ARCH.include?("darwin") && Dir.exist?("/opt/osxcross")
+
+build_env = {}
+configure_args = [
+  "cmake",
+  "-S", VENDOR,
+  "-B", BUILD_DIR,
+  "-DCMAKE_C_COMPILER=#{cc.split.first}",
+  "-DCMAKE_CXX_COMPILER=#{cxx.split.first}",
+  "-DBUILD_SHARED_LIBS=OFF",
+  "-DBUILD_BENCHMARK=OFF",
+  "-DBUILD_TESTS=OFF",
+  "-DWITH_OPENSSL=OFF",
+  "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+  "-DCMAKE_BUILD_TYPE=Release"
+]
+
+if darwin_cross
+  # osxcross defaults MACOSX_DEPLOYMENT_TARGET to 10.13, but
+  # clickhouse-cpp calls std::optional::value() which libc++ marks
+  # unavailable below 10.14. Force the deployment target and disable
+  # libc++'s availability annotations.
+  build_env["MACOSX_DEPLOYMENT_TARGET"] = "10.15"
+  darwin_cxxflags = "-mmacosx-version-min=10.15 -D_LIBCPP_DISABLE_AVAILABILITY"
+  configure_args << "-DCMAKE_C_FLAGS=#{darwin_cxxflags}"
+  configure_args << "-DCMAKE_CXX_FLAGS=#{darwin_cxxflags}"
+  # Mach-O static archives need the osxcross ar/ranlib; the host's
+  # GNU ar leaves them without a table of contents that Apple's ld
+  # can read. cmake resolves relative FILEPATH to CWD, so use the
+  # absolute osxcross bindir.
+  prefix = cxx.split.first.sub(/-clang\+\+.*\z/, "")
+  osxcross_bin = "/opt/osxcross/target/bin"
+  configure_args << "-DCMAKE_AR=#{osxcross_bin}/#{prefix}-ar"
+  configure_args << "-DCMAKE_RANLIB=#{osxcross_bin}/#{prefix}-ranlib"
+end
+
 unless File.exist?(File.join(BUILD_DIR, "CMakeCache.txt"))
-  configure_args = [
-    "cmake",
-    "-S", VENDOR,
-    "-B", BUILD_DIR,
-    "-DBUILD_SHARED_LIBS=OFF",
-    "-DBUILD_BENCHMARK=OFF",
-    "-DBUILD_TESTS=OFF",
-    "-DWITH_OPENSSL=OFF",
-    "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
-    "-DCMAKE_BUILD_TYPE=Release",
-  ]
-  system(*configure_args) or fatal("cmake configure failed. See #{BUILD_DIR}/CMakeFiles/CMakeOutput.log")
+  system(build_env, *configure_args) or
+    fatal("cmake configure failed. See #{BUILD_DIR}/CMakeFiles/CMakeOutput.log")
 end
 
 jobs = ENV.fetch("MAKE_JOBS") { Etc.nprocessors.to_s }
-system("cmake", "--build", BUILD_DIR, "--parallel", jobs) or fatal("cmake build failed")
+system(build_env, "cmake", "--build", BUILD_DIR, "--parallel", jobs) or fatal("cmake build failed")
 
 inc_dirs = [
   VENDOR,
@@ -93,6 +126,12 @@ $CXXFLAGS = "#{$CXXFLAGS} -std=c++17 #{inc_dirs.map { |d| "-I#{d}" }.join(' ')}"
 $CPPFLAGS = "#{$CPPFLAGS} #{inc_dirs.map { |d| "-I#{d}" }.join(' ')}"
 $LDFLAGS = "#{$LDFLAGS} #{ordered_libs.map(&:shellescape).join(' ')}"
 
+if darwin_cross
+  darwin_flags = "-mmacosx-version-min=10.15 -D_LIBCPP_DISABLE_AVAILABILITY"
+  $CXXFLAGS = "#{$CXXFLAGS} #{darwin_flags}"
+  $LDFLAGS = "#{$LDFLAGS} -mmacosx-version-min=10.15"
+end
+
 have_library("c++") || have_library("stdc++")
 
 $objs = ["client.o"]

data/lib/clickhouse_native/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClickhouseNative
   class Client
     attr_reader :host, :port, :database
@@ -13,32 +15,20 @@ module ClickhouseNative
     # columns defaults to the first hash's keys (for Array<Hash>) or all table
     # columns in DDL order (for Array<Array>).
     # types may be supplied to skip the DESCRIBE lookup.
+    #
+    # Hash keys not present in the schema raise ArgumentError — if you need
+    # to insert a subset, pass `columns:` explicitly.
     def insert(table, rows, columns: nil, db_name: nil, types: nil)
       return 0 if rows.empty?
-      fq = db_name ? "#{db_name}.#{table}" : table
-
-      if types && columns
-        raise ArgumentError, "types and columns must have the same length" if columns.size != types.size
-        col_pairs = columns.zip(types).map { |n, t| [n.to_s, t] }
-      else
-        schema = describe_table(table, db_name: db_name)
-        type_by_name = schema.to_h { |c| [c[:name], c[:type]] }
-        columns ||= rows.first.is_a?(Hash) ? rows.first.keys.map(&:to_s) : schema.map { |c| c[:name] }
-        col_pairs = columns.map do |name|
-          name_s = name.to_s
-          t = type_by_name[name_s] or raise ArgumentError, "unknown column #{name_s.inspect} in #{fq}"
-          [name_s, t]
-        end
-      end
 
-      row_arrays =
-        if rows.first.is_a?(Hash)
-          col_pairs.map { |n, _| [n.to_sym, n] }.then do |lookup|
-            rows.map { |h| lookup.map { |sym, str| h.fetch(sym) { h[str] } } }
-          end
+      fq = db_name ? "#{db_name}.#{table}" : table
+      col_pairs =
+        if types && columns
+          zip_columns_and_types(columns, types)
         else
-          rows
+          columns_from_schema(table, rows, columns, db_name, fq)
         end
+      row_arrays = rows.first.is_a?(Hash) ? hash_rows_to_arrays(rows, col_pairs) : rows
 
       insert_block(fq, col_pairs, row_arrays)
     end
@@ -46,5 +36,31 @@ module ClickhouseNative
     def inspect
       "#<#{self.class} #{host}:#{port}/#{database}>"
     end
+
+    private
+
+    def zip_columns_and_types(columns, types)
+      if columns.size != types.size
+        raise ArgumentError, "types and columns must have the same length"
+      end
+      columns.zip(types).map { |n, t| [n.to_s, t] }
+    end
+
+    def columns_from_schema(table, rows, columns, db_name, fqn)
+      schema = describe_table(table, db_name: db_name)
+      type_by_name = schema.to_h { |c| [c[:name], c[:type]] }
+      columns ||= rows.first.is_a?(Hash) ? rows.first.keys.map(&:to_s) : schema.map { |c| c[:name] }
+      columns.map do |name|
+        name_s = name.to_s
+        t = type_by_name[name_s] or
+          raise ArgumentError, "unknown column #{name_s.inspect} in #{fqn}"
+        [name_s, t]
+      end
+    end
+
+    def hash_rows_to_arrays(rows, col_pairs)
+      lookup = col_pairs.map { |n, _| [n.to_sym, n] }
+      rows.map { |h| lookup.map { |sym, str| h.fetch(sym) { h[str] } } }
+    end
   end
 end

data/lib/clickhouse_native/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClickhouseNative
   class Error < StandardError; end
 

data/lib/clickhouse_native/logging.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ClickhouseNative
+  # Sequel-style logging wrapper. Prepended onto Client so it fires for the
+  # raw C-level execute/query/query_value/query_each/insert_block calls.
+  #
+  #   client = Client.new(..., logger: Rails.logger)
+  #   client.query("SELECT 1")
+  #   # => DEBUG  -- : (0.421ms) SELECT 1
+  #
+  # Errors are logged at ERROR with the elapsed time and exception class.
+  module Logging
+    LEVEL = :debug
+
+    def execute(sql)
+      log_sql(sql) { super }
+    end
+
+    def query(sql)
+      log_sql(sql) { super }
+    end
+
+    def query_value(sql)
+      log_sql(sql) { super }
+    end
+
+    def query_each(sql, &)
+      log_sql(sql) { super }
+    end
+
+    def insert_block(table, columns, rows)
+      col_list = columns.map(&:first).join(", ")
+      log_sql("INSERT INTO #{table} (#{col_list}) VALUES (#{rows.size} rows)") { super }
+    end
+
+    private
+
+    def log_sql(sql)
+      return yield unless @logger
+
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        result = yield
+        elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000
+        @logger.public_send(LEVEL, format("(%<ms>.3fms) %<sql>s", ms: elapsed_ms, sql: sql))
+        result
+      rescue => error
+        elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000
+        first_line = error.message.to_s.lines.first.to_s.strip
+        @logger.error(format(
+                        "(%<ms>.3fms) %<class>s: %<msg>s -- %<sql>s",
+                        ms: elapsed_ms, class: error.class, msg: first_line, sql: sql,
+                      ))
+        raise
+      end
+    end
+  end
+
+  class Client
+    attr_accessor :logger
+
+    prepend Logging
+  end
+end

data/lib/clickhouse_native/pool.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "connection_pool"
 
 module ClickhouseNative
   class Pool
     def initialize(host:, port:, database: "default", user: "default", password: "",
-                   compression: :none, pool_size: 5, pool_timeout: 5)
-      client_kwargs = {host:, port:, database:, user:, password:, compression:}
+                   compression: :none, logger: nil, pool_size: 5, pool_timeout: 5)
+      client_kwargs = { host:, port:, database:, user:, password:, compression:, logger: }
       @pool = ConnectionPool.new(size: pool_size, timeout: pool_timeout) do
         Client.new(**client_kwargs)
       end
     end
 
-    def with(&block)
-      @pool.with(&block)
+    def with(&)
+      @pool.with(&)
     end
 
     def execute(sql)

data/lib/clickhouse_native/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ClickhouseNative
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/lib/clickhouse_native.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
+require "time"
+require "bigdecimal"
 require "clickhouse_native/version"
 require "clickhouse_native/errors"
 require "clickhouse_native/clickhouse_native"
 require "clickhouse_native/client"
+require "clickhouse_native/logging"
 require "clickhouse_native/pool"
 
 module ClickhouseNative

metadata

@@ -1,84 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-native
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Yuri Smirnov
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.4'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.2'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler-dock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.9'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.13'
 description: A high-performance Ruby client for ClickHouse using the native binary
   protocol via a C++ extension wrapping clickhouse-cpp.
 email:
@@ -341,14 +286,16 @@ files:
 - ext/clickhouse_native/vendor/clickhouse-cpp/contrib/zstd/zstd/zstd.h
 - ext/clickhouse_native/vendor/clickhouse-cpp/contrib/zstd/zstd/zstd_errors.h
 - lib/clickhouse_native.rb
-- lib/clickhouse_native/clickhouse_native.bundle
 - lib/clickhouse_native/client.rb
 - lib/clickhouse_native/errors.rb
+- lib/clickhouse_native/logging.rb
 - lib/clickhouse_native/pool.rb
 - lib/clickhouse_native/version.rb
+homepage:
 licenses:
 - Apache-2.0
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -356,14 +303,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: ClickHouse Ruby driver over the native TCP protocol
 test_files: []