ch_connect 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8625111f390ba7adf290bf889a5684c34003d1f318f421c62939ae13a310f569
-  data.tar.gz: 512cc470c691018ac249647c3dc46918490705392667bee72ebb5f49bb604b44
+  metadata.gz: 88e326f103cde2be1cd0ed39c0615ff2861020fb2f5d334fcb08ff012196cd3b
+  data.tar.gz: 0c6b12e11fdfec5626fefa1cbbcf81da8ed384f4983d1caf0466758adcb617db
 SHA512:
-  metadata.gz: 7157352591d8de2ff4f07228e2e57c9df16f0eb8ff4d75e68499bd07d402a082e938bbcaec2975ffba6dfdd697229f5c929925db13cffb643cd3001a275e7010
-  data.tar.gz: a5c4988858f866533fb27784af8c2a0f109e2432078d4ec819e644b55a45896d47c5fb07a0dd2225b9f2660e0f6cfe9ce880cad3b95dae59feb003b25d1c0bca
+  metadata.gz: fda2b6e230f5a66d66a0cd4189dc324f76713756c458bd67e06f1dc0873ec589c53980e497eaa9d37a5dd985ba0f8ef60264bafe8750b2d331ce33e93d12b574
+  data.tar.gz: eaa8b14dd4da0af03c2c3ab66825ab27c4770d0f7a7dd596deb4daa06a6b0fc3191a9454b4bd0f3411b3cbe1f85dd5eaf1ff2546a2e20c9160d7f94ae1572b43

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.4.1] - 2026-10-12
+
+- Improved large result decoding speed (about 1.9x faster for the 100K-row benchmark query) and reduced its allocations from 97 MB to 55 MB
+- Fixed quadratic re-parsing of large uncompressed result blocks (about 5x faster for multi-megabyte String columns)
+- Faster decoding of repeated `Date`/`Date32` values, `Nullable(String)`, `UUID`, and `Map` with String keys, and faster `Response#each`
+
+## [0.4.0] - 2026-10-06
+
+- Raised the minimum supported ClickHouse version to 23.3; connections to older servers are rejected during the handshake
+- Updated vendored clickhouse-c headers to `916cbf5`, adding sparse column decoding
+- Improved decimal decoding performance while preserving exact values across all decimal widths
+- Fixed decoding of geometry types, including Point, Ring, Polygon, MultiPolygon, LineString, and MultiLineString
+- Preserved complete UTF-8 server error messages during connection establishment
+
 ## [0.3.1] - 2026-08-19
 
 - Fixed LZ4 compression negotiation for ClickHouse users configured with `readonly = 1`

data/README.md

@@ -22,27 +22,27 @@ Speed (iterations/second, higher is better):
 
 | Scenario | ch_connect | click_house | clickhouse | click_house-client |
 |----------|------------|-------------|------------|--------------------|
-| Small queries (10 rows) | **962 i/s** | 363 i/s (2.7x slower) | 317 i/s (3.0x slower) | 372 i/s (2.6x slower) |
-| Large queries (100K rows) | **8.2 i/s** | 1.1 i/s (7.2x slower) | 0.6 i/s (14.1x slower) | 1.5 i/s (5.3x slower) |
+| Small queries (10 rows) | **1961 i/s** | 718 i/s (2.7x slower) | 524 i/s (3.7x slower) | 796 i/s (2.5x slower) |
+| Large queries (100K rows) | **14.2 i/s** | 1.4 i/s (10.5x slower) | 0.5 i/s (26.4x slower) | 1.8 i/s (8.0x slower) |
 
 Multi-threaded throughput (10K-row query, total queries/second):
 
 | Threads | ch_connect | click_house | clickhouse | click_house-client |
 |---------|------------|-------------|------------|--------------------|
-| 1 | **292 q/s** | 69 q/s | 117 q/s | 48 q/s |
-| 4 | **598 q/s** | 162 q/s | 319 q/s | 82 q/s |
-| 8 | **606 q/s** | 158 q/s | 321 q/s | 80 q/s |
+| 1 | **523 q/s** | 74 q/s | 140 q/s | 56 q/s |
+| 4 | **755 q/s** | 148 q/s | 306 q/s | 78 q/s |
+| 8 | **637 q/s** | 150 q/s | 326 q/s | 82 q/s |
 
 Memory allocated for a large query (lower is better):
 
 | Gem | Allocated |
 |-----|-----------|
-| ch_connect | **97 MB** |
+| ch_connect | **55 MB** |
 | click_house | 198 MB |
 | click_house-client | 210 MB |
 | clickhouse | 436 MB |
 
-A small query allocates approximately **3.2 KB / 32 Ruby objects**. See the [`benchmark/`](benchmark/) directory for the comparison suite and methodology.
+A small query allocates approximately **3.6 KB / 40 Ruby objects**. See the [`benchmark/`](benchmark/) directory for the comparison suite and methodology.
 
 ## Installation
 
@@ -52,7 +52,7 @@ Add the gem to your Gemfile:
 gem "ch_connect"
 ```
 
-The gem contains a native extension and currently requires MRI Ruby. LZ4 and ZSTD support are detected when the extension is built.
+The gem contains a native extension and requires MRI Ruby and ClickHouse 23.3 or newer. LZ4 and ZSTD support are detected when the extension is built.
 
 ## Configuration
 

data/ext/ch_connect_native/ch_connect_native.c

@@ -16,6 +16,7 @@
 #include <ruby/encoding.h>
 #include <ruby/intern.h>
 
+#include <inttypes.h>
 #include <limits.h>
 #include <string.h>
 #include <time.h>
@@ -40,8 +41,6 @@ static VALUE vAF_INET6;
 
 static ID id_jd;
 static ID id_new;
-static ID id_pow;
-static ID id_div;
 static ID id_BigDecimal;
 
 static VALUE sym_read_rows;
@@ -59,6 +58,9 @@ static VALUE sym_zstd;
 /* Julian day number of 1970-01-01 (Date.jd(2440588) == Date.new(1970, 1, 1)) */
 #define UNIX_EPOCH_JD 2440588
 
+/* Per-column Date cache slots; must be a power of two */
+#define DATE_CACHE_SIZE 256
+
 /* One immutable codec shared by all connections and threads: the built-in
  * adapters are stateless wrappers over the one-shot lz4/zstd functions. Both
  * slot pairs are filled (when available) so decode survives a server-side
@@ -136,6 +138,39 @@ load_i64le(const uint8_t *p)
     return v;
 }
 
+/* Little-endian two's complement value of 4, 8, 16 or 32 bytes as int64, when it fits. */
+static int
+load_decimal_i64(const uint8_t *p, size_t nbytes, int64_t *out)
+{
+    if (nbytes == 4) {
+        *out = load_i32le(p);
+        return 1;
+    }
+    int64_t v = load_i64le(p);
+    uint8_t sign = v < 0 ? 0xFF : 0x00;
+    for (size_t b = 8; b < nbytes; b++) {
+        if (p[b] != sign) return 0;
+    }
+    *out = v;
+    return 1;
+}
+
+/* "<unscaled>e-<scale>" for a decimal value. BigDecimal parses it exactly,
+ * without the intermediate BigDecimals of dividing by 10**scale. Only values
+ * outside the int64 range go through a Ruby Integer. */
+static VALUE
+decimal_literal(const uint8_t *p, size_t nbytes, int scale)
+{
+    int64_t v;
+    if (load_decimal_i64(p, nbytes, &v)) {
+        char buf[48];
+        int len = snprintf(buf, sizeof(buf), "%" PRId64 "e-%d", v, scale);
+        return rb_usascii_str_new(buf, len);
+    }
+    VALUE unscaled = rb_integer_unpack(p, nbytes, 1, 0, INTEGER_PACK_LITTLE_ENDIAN | INTEGER_PACK_2COMP);
+    return rb_str_catf(rb_big2str(unscaled, 10), "e-%d", scale);
+}
+
 static inline float
 load_f32le(const uint8_t *p)
 {
@@ -259,17 +294,23 @@ decode_fixed(const chc_column *col, const chc_type *t, long n_rows, native_state
         }
         break;
     }
-    case CHC_DATE: {
-        for (long i = 0; i < n_rows; i++) {
-            uint16_t days = load_u16le(data + i * 2);
-            rb_ary_push(ary, rb_funcall(cDate, id_jd, 1, LONG2NUM(UNIX_EPOCH_JD + (long)days)));
-        }
-        break;
-    }
+    case CHC_DATE:
     case CHC_DATE32: {
+        /* Date construction is a Ruby method call and columns usually repeat
+         * a handful of days, so reuse (immutable) Dates through a small
+         * direct-mapped cache. Every cached Date is already anchored by ary. */
+        long cache_days[DATE_CACHE_SIZE];
+        VALUE cache_vals[DATE_CACHE_SIZE];
+        for (int k = 0; k < DATE_CACHE_SIZE; k++) cache_vals[k] = Qundef;
         for (long i = 0; i < n_rows; i++) {
-            int32_t days = load_i32le(data + i * 4);
-            rb_ary_push(ary, rb_funcall(cDate, id_jd, 1, LONG2NUM(UNIX_EPOCH_JD + (long)days)));
+            long days = kind == CHC_DATE ? (long)load_u16le(data + i * 2)
+                                         : (long)load_i32le(data + i * 4);
+            unsigned long slot = (unsigned long)days & (DATE_CACHE_SIZE - 1);
+            if (cache_vals[slot] == Qundef || cache_days[slot] != days) {
+                cache_days[slot] = days;
+                cache_vals[slot] = rb_funcall(cDate, id_jd, 1, LONG2NUM(UNIX_EPOCH_JD + days));
+            }
+            rb_ary_push(ary, cache_vals[slot]);
         }
         break;
     }
@@ -299,18 +340,23 @@ decode_fixed(const chc_column *col, const chc_type *t, long n_rows, native_state
         break;
     }
     case CHC_UUID: {
-        char buf[37];
+        /* Each 8-byte half is little-endian on the wire; emit both halves
+         * most significant nibble first, with dashes after hex digits
+         * 8, 12, 16 and 20. */
+        static const char hex[] = "0123456789abcdef";
         for (long i = 0; i < n_rows; i++) {
             const uint8_t *p = data + i * 16;
-            uint64_t hi = load_u64le(p);
-            uint64_t lo = load_u64le(p + 8);
-            snprintf(buf, sizeof(buf), "%08llx-%04llx-%04llx-%04llx-%012llx",
-                     (unsigned long long)(hi >> 32),
-                     (unsigned long long)((hi >> 16) & 0xFFFF),
-                     (unsigned long long)(hi & 0xFFFF),
-                     (unsigned long long)(lo >> 48),
-                     (unsigned long long)(lo & 0xFFFFFFFFFFFFULL));
-            rb_ary_push(ary, rb_utf8_str_new(buf, 36));
+            uint64_t halves[2] = { load_u64le(p), load_u64le(p + 8) };
+            VALUE str = rb_utf8_str_new(NULL, 36);
+            char *out = RSTRING_PTR(str);
+            int o = 0;
+            for (int h = 0; h < 2; h++) {
+                for (int shift = 60; shift >= 0; shift -= 4) {
+                    if (o == 8 || o == 13 || o == 18 || o == 23) out[o++] = '-';
+                    out[o++] = hex[(halves[h] >> shift) & 0xF];
+                }
+            }
+            rb_ary_push(ary, str);
         }
         break;
     }
@@ -334,23 +380,9 @@ decode_fixed(const chc_column *col, const chc_type *t, long n_rows, native_state
     case CHC_DECIMAL128:
     case CHC_DECIMAL256: {
         int scale = chc_type_decimal_scale(t);
-        VALUE divisor = rb_funcall(INT2FIX(10), id_pow, 1, INT2FIX(scale));
+        size_t nbytes = kind == CHC_DECIMAL32 ? 4 : kind == CHC_DECIMAL64 ? 8 : kind == CHC_DECIMAL128 ? 16 : 32;
         for (long i = 0; i < n_rows; i++) {
-            VALUE unscaled;
-            if (kind == CHC_DECIMAL32) {
-                int32_t v = load_i32le(data + i * 4);
-                unscaled = INT2NUM(v);
-            } else if (kind == CHC_DECIMAL64) {
-                int64_t v = load_i64le(data + i * 8);
-                unscaled = LL2NUM(v);
-            } else {
-                size_t nbytes = (kind == CHC_DECIMAL128) ? 16 : 32;
-                unscaled = rb_integer_unpack(data + i * nbytes, nbytes, 1, 0,
-                                             INTEGER_PACK_LITTLE_ENDIAN |
-                                             INTEGER_PACK_2COMP);
-            }
-            VALUE bd = rb_funcall(rb_mKernel, id_BigDecimal, 1, unscaled);
-            rb_ary_push(ary, rb_funcall(bd, id_div, 1, divisor));
+            rb_ary_push(ary, rb_funcall(rb_mKernel, id_BigDecimal, 1, decimal_literal(data + i * nbytes, nbytes, scale)));
         }
         break;
     }
@@ -361,17 +393,98 @@ decode_fixed(const chc_column *col, const chc_type *t, long n_rows, native_state
     return ary;
 }
 
+/* null_map (optional) marks rows that a Nullable wrapper turns into nil, so
+ * their placeholder strings are never allocated. */
+static VALUE
+decode_string_column(const chc_column *col, long n_rows, const uint8_t *null_map)
+{
+    const uint8_t *data = chc_column_string_data(col);
+    const uint64_t *offsets = chc_column_string_offsets(col);
+    VALUE ary = rb_ary_new_capa(n_rows);
+
+    uint64_t start = 0;
+    for (long i = 0; i < n_rows; i++) {
+        uint64_t end = offsets[i];
+        if (null_map && null_map[i] == 1) rb_ary_push(ary, Qnil);
+        else rb_ary_push(ary, rb_utf8_str_new((const char *)data + start, (long)(end - start)));
+        start = end;
+    }
+    return ary;
+}
+
 static VALUE
-decode_string_column(const chc_column *col, long n_rows)
+decode_interned_string_column(const chc_column *col, long n_rows)
 {
     const uint8_t *data = chc_column_string_data(col);
     const uint64_t *offsets = chc_column_string_offsets(col);
+    rb_encoding *utf8 = rb_utf8_encoding();
     VALUE ary = rb_ary_new_capa(n_rows);
 
     uint64_t start = 0;
     for (long i = 0; i < n_rows; i++) {
         uint64_t end = offsets[i];
-        rb_ary_push(ary, rb_utf8_str_new((const char *)data + start, (long)(end - start)));
+        rb_ary_push(ary, rb_enc_interned_str((const char *)data + start, (long)(end - start), utf8));
+        start = end;
+    }
+    return ary;
+}
+
+static void
+raise_invalid_geometry(native_state *state, const char *detail)
+{
+    *state = NATIVE_BROKEN;
+    rb_raise(eConnectionError, "Invalid native geometry column: %s", detail);
+}
+
+/* clickhouse-c exposes geometry aliases as their wire-level Array/Tuple
+ * column tree, while the logical geometry type has no synthetic children. */
+static VALUE
+decode_geometry(const chc_column *col, long n_rows, int depth, native_state *state)
+{
+    if (n_rows == 0) return rb_ary_new();
+
+    if (depth == 0) {
+        if (chc_column_layout(col) != CHC_COL_TUPLE ||
+            chc_column_tuple_arity(col) != 2) {
+            raise_invalid_geometry(state, "Point must be a two-coordinate tuple");
+        }
+
+        const chc_column *x_col = chc_column_tuple_child(col, 0);
+        const chc_column *y_col = chc_column_tuple_child(col, 1);
+        size_t x_size = 0;
+        size_t y_size = 0;
+        const uint8_t *x = (const uint8_t *)chc_column_fixed_data(x_col, &x_size);
+        const uint8_t *y = (const uint8_t *)chc_column_fixed_data(y_col, &y_size);
+        if (!x || !y || x_size != 8 || y_size != 8) {
+            raise_invalid_geometry(state, "Point coordinates must be Float64 columns");
+        }
+
+        VALUE points = rb_ary_new_capa(n_rows);
+        for (long i = 0; i < n_rows; i++) {
+            VALUE point = rb_ary_new_capa(2);
+            rb_ary_push(point, DBL2NUM(load_f64le(x + i * 8)));
+            rb_ary_push(point, DBL2NUM(load_f64le(y + i * 8)));
+            rb_ary_push(points, point);
+        }
+        return points;
+    }
+
+    if (chc_column_layout(col) != CHC_COL_ARRAY) {
+        raise_invalid_geometry(state, "expected an Array layer");
+    }
+
+    const uint64_t *offsets = chc_column_array_offsets(col);
+    const chc_column *values_col = chc_column_array_values(col);
+    long total = (long)chc_column_n_rows(values_col);
+    VALUE elements = decode_geometry(values_col, total, depth - 1, state);
+    VALUE ary = rb_ary_new_capa(n_rows);
+    uint64_t start = 0;
+    for (long i = 0; i < n_rows; i++) {
+        uint64_t end = offsets[i];
+        if (end < start || end > (uint64_t)RARRAY_LEN(elements)) {
+            raise_invalid_geometry(state, "Array offset is out of bounds");
+        }
+        rb_ary_push(ary, rb_ary_subseq(elements, (long)start, (long)(end - start)));
         start = end;
     }
     return ary;
@@ -380,6 +493,21 @@ decode_string_column(const chc_column *col, long n_rows)
 static VALUE
 decode_column(const chc_column *col, const chc_type *t, long n_rows, native_state *state)
 {
+    switch (chc_type_kind(t)) {
+    case CHC_POINT:
+        return decode_geometry(col, n_rows, 0, state);
+    case CHC_RING:
+    case CHC_LINE_STRING:
+        return decode_geometry(col, n_rows, 1, state);
+    case CHC_POLYGON:
+    case CHC_MULTI_LINE_STRING:
+        return decode_geometry(col, n_rows, 2, state);
+    case CHC_MULTI_POLYGON:
+        return decode_geometry(col, n_rows, 3, state);
+    default:
+        break;
+    }
+
     if (n_rows == 0) {
         chc_kind kind = chc_type_kind(t);
         if (kind == CHC_STRING) return rb_ary_new();
@@ -398,12 +526,14 @@ decode_column(const chc_column *col, const chc_type *t, long n_rows, native_stat
         return decode_fixed(col, t, n_rows, state);
 
     case CHC_COL_STRING:
-        return decode_string_column(col, n_rows);
+        return decode_string_column(col, n_rows, NULL);
 
     case CHC_COL_NULLABLE: {
         const uint8_t *null_map = chc_column_null_map(col);
         const chc_column *inner = chc_column_nullable_inner(col);
         const chc_type *inner_t = chc_type_child(t, 0);
+        if (chc_column_layout(inner) == CHC_COL_STRING)
+            return decode_string_column(inner, n_rows, null_map);
         VALUE vals = decode_column(inner, inner_t, n_rows, state);
         for (long i = 0; i < n_rows; i++) {
             if (null_map[i] == 1) rb_ary_store(vals, i, Qnil);
@@ -422,7 +552,12 @@ decode_column(const chc_column *col, const chc_type *t, long n_rows, native_stat
             long total = (long)chc_column_n_rows(values_col);
             const chc_column *keys_col = chc_column_tuple_child(values_col, 0);
             const chc_column *vals_col = chc_column_tuple_child(values_col, 1);
-            VALUE keys = decode_column(keys_col, kt, total, state);
+            /* Hash#[]= dups and freezes unfrozen String keys; decoding them
+             * as interned (frozen, deduplicated) strings skips that copy, and
+             * map keys typically repeat across rows. */
+            VALUE keys = chc_column_layout(keys_col) == CHC_COL_STRING
+                ? decode_interned_string_column(keys_col, total)
+                : decode_column(keys_col, kt, total, state);
             VALUE vals = decode_column(vals_col, vt, total, state);
 
             VALUE ary = rb_ary_new_capa(n_rows);
@@ -435,7 +570,7 @@ decode_column(const chc_column *col, const chc_type *t, long n_rows, native_stat
                              "Map offset out of bounds at row %ld: %llu", i,
                              (unsigned long long)end);
                 }
-                VALUE hash = rb_hash_new();
+                VALUE hash = rb_hash_new_capa((long)(end - start));
                 for (uint64_t j = start; j < end; j++) {
                     rb_hash_aset(hash, RARRAY_AREF(keys, (long)j), RARRAY_AREF(vals, (long)j));
                 }
@@ -638,7 +773,8 @@ native_client_handshake_step(VALUE self)
 
     nc->state = NATIVE_ACTIVE;
     chc_err err = {0};
-    int rc = chc_async_handshake(nc->ac, &err);
+    chc_exception *exception = NULL;
+    int rc = chc_async_handshake(nc->ac, &exception, &err);
     if (rc == CHC_OK) {
         nc->state = NATIVE_READY;
         return sym_done;
@@ -646,6 +782,16 @@ native_client_handshake_step(VALUE self)
     if (rc == CHC_WOULD_BLOCK) return sym_want_read;
 
     nc->state = NATIVE_BROKEN;
+    if (exception) {
+        /* Anchor the server exception before allocating Ruby objects so close
+         * or GC can still release it if message construction raises. */
+        nc->pending_pkt.kind = CHC_PKT_EXCEPTION;
+        nc->pending_pkt.exception = exception;
+        VALUE msg = rb_utf8_str_new(exception->display_text,
+                                    (long)exception->display_text_len);
+        clear_pending(nc);
+        rb_exc_raise(rb_exc_new_str(eConnectionError, msg));
+    }
     rb_raise(eConnectionError, "%s", err.msg);
 }
 
@@ -808,13 +954,16 @@ native_client_decode_block(VALUE self, native_client_t *nc, chc_block *block)
                                 (long)n_rows, &nc->state);
         rb_ary_push(col_vals, cols[i]);
     }
+    /* row_vals only holds references that cols[] already anchors */
+    VALUE row_buf;
+    VALUE *row_vals = ALLOCV_N(VALUE, row_buf, n_cols);
     for (size_t r = 0; r < n_rows; r++) {
-        VALUE row = rb_ary_new_capa((long)n_cols);
         for (size_t c = 0; c < n_cols; c++) {
-            rb_ary_push(row, RARRAY_AREF(cols[c], (long)r));
+            row_vals[c] = RARRAY_AREF(cols[c], (long)r);
         }
-        rb_ary_push(rows, row);
+        rb_ary_push(rows, rb_ary_new_from_values((long)n_cols, row_vals));
     }
+    ALLOCV_END(row_buf);
     ALLOCV_END(cols_buf);
     RB_GC_GUARD(col_vals);
 }
@@ -880,7 +1029,7 @@ native_client_recv_step(VALUE self)
             nc->state = NATIVE_READY;
             return sym_done;
         }
-        /* PONG / TOTALS / EXTREMES / LOG / PROFILE_EVENTS — skip. */
+        /* PONG / TOTALS / EXTREMES / LOG / PROFILE_EVENTS / TIMEZONE_UPDATE — skip. */
     }
 }
 
@@ -969,8 +1118,6 @@ Init_ch_connect_native(void)
 
     id_jd = rb_intern("jd");
     id_new = rb_intern("new");
-    id_pow = rb_intern("**");
-    id_div = rb_intern("/");
     id_BigDecimal = rb_intern("BigDecimal");
 
     sym_read_rows = ID2SYM(rb_intern("read_rows"));

data/lib/ch_connect/connection.rb

@@ -27,6 +27,7 @@ module ChConnect
 
     READ_CHUNK = 64 * 1024
     WRITE_CHUNK = 64 * 1024
+    DRAIN_LIMIT = 16 * 1024 * 1024
     PARAM_ESCAPES = {
       "\0" => "\\0", "\a" => "\\a", "\b" => "\\b", "\e" => "\\e",
       "\f" => "\\f", "\n" => "\\n", "\r" => "\\r", "\t" => "\\t",
@@ -60,7 +61,7 @@ module ChConnect
         loop do
           case @client.recv_step
           when :done then break
-          when :want_read then @client.feed(read_chunk)
+          when :want_read then feed_available
           end
         end
         @client.take_result
@@ -191,6 +192,23 @@ module ChConnect
         end
       end
 
+      # Blocks for one chunk, then drains whatever else the socket already has
+      # buffered (up to DRAIN_LIMIT). An uncompressed Data block that ends
+      # mid-column is re-parsed from that column's start on the next
+      # recv_step, so retrying once per burst instead of once per chunk keeps
+      # large blocks from going quadratic.
+      def feed_available
+        @client.feed(read_chunk)
+        drained = 0
+        while drained < DRAIN_LIMIT
+          chunk = @socket.read_nonblock(READ_CHUNK, @read_buf, exception: false)
+          break unless chunk.is_a?(String)
+
+          @client.feed(chunk)
+          drained += chunk.bytesize
+        end
+      end
+
       # Reads into a reusable buffer: feed copies the bytes synchronously,
       # so the buffer never needs to survive past the next read.
       def read_chunk(timeout = @config.read_timeout)

data/lib/ch_connect/response.rb

@@ -17,7 +17,18 @@ module ChConnect
     def each
       return to_enum(:each) unless block_given?
 
-      rows.each { |row| yield columns.zip(row).to_h }
+      # An index loop avoids zip's per-row pair arrays (~3x faster under YJIT).
+      names = columns
+      count = names.size
+      rows.each do |row|
+        hash = {}
+        index = 0
+        while index < count
+          hash[names[index]] = row[index]
+          index += 1
+        end
+        yield hash
+      end
     end
   end
 end

data/lib/ch_connect/version.rb

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

data/vendor/clickhouse-c/VENDOR.md

@@ -1,9 +1,12 @@
 # Vendored: clickhouse-c
 
 - Source: https://github.com/ClickHouse/clickhouse-c
-- Commit: dd47d2882646aeba5a1946c62a229d57abea6c28 (cloned 2026-07-14)
+- Commit: 916cbf5ff41a218978bc073bca10f5b609a00081 (updated 2026-10-05)
 - License: Apache-2.0 (see LICENSE)
 
+The native client requires ClickHouse 23.3 or newer and advertises protocol
+revision 54465, including sparse column serialization support.
+
 Only the headers the extension includes are vendored: `clickhouse.h`,
 `clickhouse-compression.h`, `clickhouse-client.h`, `clickhouse-async.h`
 (plus LICENSE). Upstream's tests, docs, tools, and the `clickhouse-posix-io.h`
@@ -12,7 +15,7 @@ ioless (Ruby owns the socket and TLS).
 
 ## Local patches
 
-- `clickhouse.h` — `chc__col_read`, `case CHC_TUPLE`: ClickHouse serializes the
+- `clickhouse.h` — `chc__col_read_tuple`: ClickHouse serializes the
   empty `Tuple()` as one UInt8 (zero) per row (ClickHouse/ClickHouse#55061);
   upstream reads nothing and desyncs the stream. Marked with
   `LOCAL PATCH (ch_connect)`. Should be upstreamed.

data/vendor/clickhouse-c/clickhouse-async.h

@@ -47,8 +47,15 @@ int  chc_async_submit(chc_async_client *c, const void *buf, size_t len,
 void chc_async_pending_out(chc_async_client *c, const uint8_t **buf, size_t *len);
 void chc_async_consume_out(chc_async_client *c, size_t n);
 
-/* drive -- never block; CHC_WOULD_BLOCK = submit more / drain out */
-int  chc_async_handshake(chc_async_client *c, chc_err *err);
+/* Drive calls never block. CHC_WOULD_BLOCK requests more input or output
+ * draining
+ *
+ * Handshake rejection returns CHC_ERR_SERVER and leaves err->msg empty. When
+ * exc is not NULL, caller owns *exc and frees it with chc_exception_free.
+ * Other results leave *exc unchanged. Query exceptions still arrive as
+ * packets, but handshake rejection ends connection setup */
+int  chc_async_handshake(chc_async_client *c, chc_exception **exc,
+                         chc_err *err);
 int  chc_async_send_query(chc_async_client *c, const char *sql, size_t sql_len,
                           const char *query_id, size_t query_id_len, chc_err *err);
 int  chc_async_send_data(chc_async_client *c, const chc_block_builder *bb,
@@ -122,16 +129,7 @@ chc_async_client_init(chc_async_client **out, const chc_client_opts *opts,
     if (!c) return CHC_ERR_OOM;
 
     c->cli.al = al;
-    c->cli.client_version_major = opts->client_version_major;
-    c->cli.client_version_minor = opts->client_version_minor;
-    c->cli.client_version_patch = opts->client_version_patch;
-    c->cli.client_revision = opts->client_revision ? opts->client_revision
-                                                   : CHC_CLIENT_DEFAULT_REVISION;
-    c->cli.compression = opts->codec ? opts->compression : CHC_COMP_NONE;
-    c->cli.codec       = opts->codec;
-    /* Seed server.revision so block/packet framing is well-defined before the
-     * handshake completes; recv after handshake uses min(client, server). */
-    c->cli.server.revision = c->cli.client_revision;
+    chc__client_setup(&c->cli, opts);
 
     chc__mem_sink_init(&c->out, &c->out_io, al);
     c->cli.io = &c->out_io;
@@ -196,7 +194,7 @@ chc_async_consume_out(chc_async_client *c, size_t n)
 }
 
 int
-chc_async_handshake(chc_async_client *c, chc_err *err)
+chc_async_handshake(chc_async_client *c, chc_exception **exc, chc_err *err)
 {
     int rc;
     chc_client *cli = &c->cli;
@@ -209,7 +207,6 @@ chc_async_handshake(chc_async_client *c, chc_err *err)
                 .client_version_major = cli->client_version_major,
                 .client_version_minor = cli->client_version_minor,
                 .client_version_patch = cli->client_version_patch,
-                .client_revision = cli->client_revision,
                 .database = c->database,
                 .user = c->user,
                 .password = c->password,
@@ -222,27 +219,23 @@ chc_async_handshake(chc_async_client *c, chc_err *err)
 
         case CHC__HS_RECV_HELLO:
             chc__in_checkpoint(&cli->in);
-            rc = chc__client_recv_hello(cli, err);
+            rc = chc__client_recv_hello(cli, exc, err);
             if (rc == CHC_WOULD_BLOCK) { chc__in_rewind(&cli->in); return rc; }
             if (rc != CHC_OK) return rc;  /* server exception / protocol */
             chc_in_reset(&cli->in);
-            if (cli->server.revision > cli->client_revision)
-                cli->server.revision = cli->client_revision;
             c->hs_phase = CHC__HS_POST_HELLO;
             continue;
 
         case CHC__HS_POST_HELLO:
-            if (cli->server.revision >= CHC__REV_ADDENDUM) {
-                rc = chc__write_string(cli->io, "", 0, err);  /* quota_key */
-                if (rc != CHC_OK) return rc;
-            }
+            rc = chc__write_string(cli->io, "", 0, err);  /* quota_key */
+            if (rc != CHC_OK) return rc;
             rc = chc_client_send_ping(cli, err);
             if (rc != CHC_OK) return rc;
             c->hs_phase = CHC__HS_RECV_PONG;
             continue;
 
         case CHC__HS_RECV_PONG:
-            rc = chc__recv_pong(cli, err);  /* owns checkpoint/rewind */
+            rc = chc__recv_pong(cli, exc, err);  /* owns checkpoint/rewind */
             if (rc != CHC_OK) return rc;
             chc_in_reset(&cli->in);
             c->hs_phase = CHC__HS_DONE;