clickhouse-native 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e0bcd3868daa1a69af028ff62e4c0104c82ceac165acfa12f40418259d74929
-  data.tar.gz: e40d67544c4b9fb99fbf0ecebf655dd572055fc4d8301521cf0958af1a4531c1
+  metadata.gz: 984a63d34de19388f777cfe71ecd0a844d22f0b67b89e9fddfe07c5c0ac1cc05
+  data.tar.gz: 78f829e40f715aef0264e1419cb9b06b97faab1ac38f33329c5da6ada1dd251b
 SHA512:
-  metadata.gz: ace9d3e809fa558064f42d2ee66bce667f8514fb06f88d2eb2e24c09f244994e32365acae4f3a3c110025f6a3de947a242d766a72fa72dfaa560fbaf8825c9a0
-  data.tar.gz: a935ba30d5f897254492157e82bf98be08e202cd8b619de923c43b0b25ae07f3112d98b20768152dcd44c605eb57db7220e70c240e318415c9992bfb7bd8bf1b
+  metadata.gz: c579da78d2185108712c92e902217c2e508655533c2e78efc7e36ae358a826f809f41d884684b8fcb0e1b36749bc80be5f23b76c85ebf081423adb615d73928b
+  data.tar.gz: 93259646a6f150ed271202e3eaca075e0d1cf8d707aed5ac2ac9b530061de47cf1a65082289718857b367dd5b8d764c73cf270c34d080018ce8caac540d8bab6

data/ext/clickhouse_native/client.cpp

@@ -7,6 +7,7 @@
 #include <clickhouse/columns/decimal.h>
 #include <clickhouse/columns/enum.h>
 #include <clickhouse/columns/factory.h>
+#include <clickhouse/columns/json.h>
 #include <clickhouse/columns/lowcardinality.h>
 #include <clickhouse/columns/map.h>
 #include <clickhouse/columns/numeric.h>
@@ -16,11 +17,13 @@
 #include <clickhouse/exceptions.h>
 #include <clickhouse/types/types.h>
 
+#include <chrono>
 #include <cstdint>
 #include <exception>
 #include <memory>
 #include <string>
 #include <system_error>
+#include <utility>
 #include <vector>
 
 using namespace clickhouse;
@@ -188,6 +191,17 @@ static VALUE value_at(const ColumnRef& col, size_t idx, const std::string& decla
             return rb_utf8_str_new(sv.data(), sv.size());
         }
 
+        case Type::JSON: {
+            // clickhouse-cpp's ColumnJSON is string-backed (it relies on the
+            // server's output_format_native_write_json_as_string). Decode the
+            // raw JSON text into a Ruby object so a JSON column reads back like
+            // Map does — a Hash — rather than a string the caller must re-parse.
+            auto sv = col->As<ColumnJSON>()->At(idx);
+            VALUE str = rb_utf8_str_new(sv.data(), sv.size());
+            VALUE rb_mJSON = rb_const_get(rb_cObject, rb_intern("JSON"));
+            return rb_funcall(rb_mJSON, rb_intern("parse"), 1, str);
+        }
+
         case Type::Date: {
             // Return a Ruby Date so as_json/to_s gives "YYYY-MM-DD" instead of
             // a full ISO8601 timestamp. CH Date is days since 1970-01-01 UTC.
@@ -327,6 +341,8 @@ static void append_default(const ColumnRef& col) {
         case Type::Float64: col->As<ColumnFloat64>()->Append(0); return;
         case Type::String:      col->As<ColumnString>()->Append(std::string_view()); return;
         case Type::FixedString: col->As<ColumnFixedString>()->Append(std::string_view()); return;
+        // CH rejects an empty string as JSON; the empty value is "{}".
+        case Type::JSON:        col->As<ColumnJSON>()->Append(std::string_view("{}")); return;
         case Type::Date:        col->As<ColumnDate>()->Append(0); return;
         case Type::Date32:      col->As<ColumnDate32>()->Append(0); return;
         case Type::DateTime:    col->As<ColumnDateTime>()->Append(0); return;
@@ -490,6 +506,19 @@ static void append_value(const ColumnRef& col, VALUE value) {
             return;
         }
 
+        case Type::JSON: {
+            // A String is taken as already-serialized JSON text and passed
+            // through verbatim; anything else (Hash / Array / ...) is rendered
+            // via #to_json. nil is handled earlier via append_default ("{}").
+            VALUE str = RB_TYPE_P(value, T_STRING)
+                ? value
+                : rb_funcall(value, rb_intern("to_json"), 0);
+            StringValue(str);
+            col->As<ColumnJSON>()->Append(
+                std::string_view(RSTRING_PTR(str), RSTRING_LEN(str)));
+            return;
+        }
+
         case Type::Date:   col->As<ColumnDate>()->Append(static_cast<std::time_t>(coerce_to_date_epoch(value))); return;
         case Type::Date32: col->As<ColumnDate32>()->Append(static_cast<std::time_t>(coerce_to_date_epoch(value))); return;
         case Type::DateTime: {
@@ -639,6 +668,11 @@ static void append_value(const ColumnRef& col, VALUE value) {
 
 struct CHClient {
     std::unique_ptr<Client> client;
+    // Session settings applied to *every* query as per-query settings, rather
+    // than a one-time session `SET`. Per-query settings ride each query packet,
+    // so they survive a transparent ping_before_query reconnect (a fresh socket
+    // would otherwise lose a session-level SET and fall back to server defaults).
+    std::vector<std::pair<std::string, std::string>> default_settings;
 };
 
 static void ch_client_free(void* p) {
@@ -680,6 +714,18 @@ static uint16_t kwarg_uint16(VALUE kwargs, const char* key, uint16_t fallback) {
     return static_cast<uint16_t>(NUM2UINT(v));
 }
 
+static bool kwarg_bool(VALUE kwargs, const char* key, bool fallback) {
+    VALUE v = rb_hash_lookup2(kwargs, ID2SYM(rb_intern(key)), Qundef);
+    if (v == Qundef) return fallback;
+    return RTEST(v);
+}
+
+static unsigned int kwarg_uint(VALUE kwargs, const char* key, unsigned int fallback) {
+    VALUE v = rb_hash_lookup2(kwargs, ID2SYM(rb_intern(key)), Qundef);
+    if (v == Qundef || NIL_P(v)) return fallback;
+    return NUM2UINT(v);
+}
+
 static CompressionMethod kwarg_compression(VALUE kwargs) {
     VALUE v = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("compression")), Qundef);
     if (v == Qundef || NIL_P(v)) return CompressionMethod::None;
@@ -715,6 +761,16 @@ static int apply_settings_cb(VALUE key, VALUE val, VALUE arg) {
     return ST_CONTINUE;
 }
 
+// Collect a `settings:` Hash into a client's default_settings vector at
+// construction. Values are stringified the same way per-query settings are.
+static int collect_setting_cb(VALUE key, VALUE val, VALUE arg) {
+    auto* vec = reinterpret_cast<std::vector<std::pair<std::string, std::string>>*>(arg);
+    VALUE k = SYMBOL_P(key) ? rb_sym2str(key) : key;
+    StringValue(k);
+    vec->emplace_back(std::string(RSTRING_PTR(k), RSTRING_LEN(k)), stringify_setting_value(val));
+    return ST_CONTINUE;
+}
+
 // Read a `settings:` Hash out of the parsed kwargs and stamp each entry
 // onto `q` as a per-query setting. No-op if kwargs is nil or settings is
 // missing/empty. Raises TypeError if settings is not a Hash.
@@ -726,6 +782,28 @@ static void apply_settings(Query& q, VALUE kwargs) {
     rb_hash_foreach(settings, apply_settings_cb, reinterpret_cast<VALUE>(&q));
 }
 
+// Same as apply_settings, but first defaults
+// output_format_native_write_json_as_string=1 so JSON columns come back as
+// strings (clickhouse-cpp's ColumnJSON can only read them that way). The flag
+// is 0 (not "important"), so servers that don't know the setting ignore it
+// instead of erroring. User-supplied settings are applied afterwards and win,
+// so callers can still override it.
+static void apply_read_settings(Query& q, VALUE kwargs) {
+    q.SetSetting("output_format_native_write_json_as_string",
+                 QuerySettingsField{"1", 0});
+    apply_settings(q, kwargs);
+}
+
+// Stamp the client's construction-time `settings:` onto `q`. Marked important
+// (flag 1) so an unknown setting name errors — matching the old session `SET`,
+// which failed loudly instead of silently ignoring a typo'd setting. Applied
+// before per-call settings so an explicit `settings:` on the call still wins.
+static void apply_default_settings(Query& q, CHClient* c) {
+    for (const auto& kv : c->default_settings) {
+        q.SetSetting(kv.first, QuerySettingsField{kv.second, 1});
+    }
+}
+
 // Client.new(host:, port:, database:, user:, password:)
 static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kwargs = Qnil;
@@ -739,12 +817,35 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     std::string password = kwarg_str(kwargs, "password", "");
     CompressionMethod compression = kwarg_compression(kwargs);
 
+    // Connection-resilience defaults. Long-lived pooled connections get
+    // silently closed by the server (idle_connection_timeout) or an LB, so
+    // the next use of a checked-out client would otherwise hit recv()==0 and
+    // raise ConnectionError("closed: ..."). ping_before_query makes the driver
+    // ping first and transparently reconnect on a dead socket; tcp_keepalive
+    // keeps idle sockets healthy at the OS level. retry_timeout is the backoff
+    // before each reconnect attempt — kept low (1s) since a pooled reconnect
+    // to a live server should be quick and we don't want to stall queries.
+    bool ping_before_query = kwarg_bool(kwargs, "ping_before_query", true);
+    bool tcp_keepalive = kwarg_bool(kwargs, "tcp_keepalive", true);
+    unsigned int retry_timeout = kwarg_uint(kwargs, "retry_timeout", 1);
+
     CHClient* c = as_client(self);
+
+    VALUE settings = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("settings")), Qnil);
+    if (!NIL_P(settings)) {
+        Check_Type(settings, T_HASH);
+        rb_hash_foreach(settings, collect_setting_cb,
+                        reinterpret_cast<VALUE>(&c->default_settings));
+    }
+
     try {
         ClientOptions opts;
         opts.SetHost(host).SetPort(port)
             .SetDefaultDatabase(database).SetUser(user).SetPassword(password)
-            .SetCompressionMethod(compression);
+            .SetCompressionMethod(compression)
+            .SetPingBeforeQuery(ping_before_query)
+            .TcpKeepAlive(tcp_keepalive)
+            .SetRetryTimeout(std::chrono::seconds(retry_timeout));
         c->client = std::make_unique<Client>(opts);
     } catch (const std::exception& e) {
         raise_mapped_ex(e);
@@ -753,6 +854,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()));
+    rb_ivar_set(self, rb_intern("@ping_before_query"), ping_before_query ? Qtrue : Qfalse);
+    rb_ivar_set(self, rb_intern("@tcp_keepalive"), tcp_keepalive ? Qtrue : Qfalse);
+    rb_ivar_set(self, rb_intern("@retry_timeout"), UINT2NUM(retry_timeout));
 
     VALUE logger = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("logger")), Qnil);
     rb_ivar_set(self, rb_intern("@logger"), logger);
@@ -796,6 +900,7 @@ static VALUE ch_client_execute(int argc, VALUE* argv, VALUE self) {
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
     Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_default_settings(q, c);
     apply_settings(q, kwargs);
 
     ExecuteNoGVL args{c->client.get(), &q, nullptr};
@@ -827,7 +932,8 @@ static VALUE ch_client_query(int argc, VALUE* argv, VALUE self) {
     try {
         std::vector<ID> col_ids;
         Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
-        apply_settings(q, kwargs);
+        apply_default_settings(q, c);
+        apply_read_settings(q, kwargs);
         q.OnData([&](const Block& block) {
             size_t ncols = block.GetColumnCount();
             size_t nrows = block.GetRowCount();
@@ -872,7 +978,8 @@ static VALUE ch_client_query_value(int argc, VALUE* argv, VALUE self) {
         VALUE out = Qnil;
         bool seen = false;
         Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
-        apply_settings(q, kwargs);
+        apply_default_settings(q, c);
+        apply_read_settings(q, kwargs);
         q.OnData([&](const Block& block) {
             if (seen) return;
             if (block.GetRowCount() == 0 || block.GetColumnCount() == 0) return;
@@ -897,6 +1004,7 @@ struct InsertNoGVL {
     Client* client;
     const std::string* table;
     const Block* block;
+    const std::vector<std::pair<std::string, std::string>>* settings;
     std::exception_ptr err;
 };
 }  // namespace
@@ -904,7 +1012,7 @@ struct InsertNoGVL {
 static void* insert_no_gvl(void* data) {
     auto* a = static_cast<InsertNoGVL*>(data);
     try {
-        a->client->Insert(*a->table, *a->block);
+        a->client->Insert(*a->table, *a->block, *a->settings);
     } catch (...) {
         a->err = std::current_exception();
     }
@@ -970,7 +1078,7 @@ static VALUE ch_client_insert_block(VALUE self, VALUE rb_table, VALUE rb_columns
             block.AppendColumn(names[i], cols[i]);
         }
 
-        InsertNoGVL args{c->client.get(), &table, &block, nullptr};
+        InsertNoGVL args{c->client.get(), &table, &block, &c->default_settings, nullptr};
         rb_thread_call_without_gvl(insert_no_gvl, &args, insert_unblock, &args);
         if (args.err) {
             try { c->client->ResetConnection(); } catch (...) {}
@@ -1071,7 +1179,8 @@ static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
 
     QueryEachState state{rb_block_proc(), {}, 0, false};
     Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
-    apply_settings(q, kwargs);
+    apply_default_settings(q, c);
+    apply_read_settings(q, kwargs);
     q.OnDataCancelable([&state](const Block& block) -> bool {
         if (state.aborted) return false;
         YieldBlockArgs ya{&block, &state};

data/ext/clickhouse_native/extconf.rb

@@ -22,16 +22,39 @@ def fatal(msg)
   abort "clickhouse-native: cannot build extension"
 end
 
+# Bundler `git:` installs don't fetch submodules unless the Gemfile sets
+# `submodules: true`, which leaves vendor/clickhouse-cpp empty. When we're
+# sitting in a git checkout, fetch it ourselves so the build can proceed
+# without every consumer having to remember that flag. Released gems and
+# `submodules: recursive` checkouts already have the tree, so this is a no-op
+# there.
+unless File.exist?(File.join(VENDOR, "CMakeLists.txt"))
+  in_git_checkout = system(
+    "git", "-C", EXT_DIR, "rev-parse", "--is-inside-work-tree",
+    out: File::NULL, err: File::NULL
+  )
+  if in_git_checkout
+    warn "clickhouse-native: vendored clickhouse-cpp is missing; " \
+         "running `git submodule update --init --recursive`…"
+    system("git", "-C", EXT_DIR, "submodule", "update", "--init", "--recursive")
+  end
+end
+
 unless File.exist?(File.join(VENDOR, "CMakeLists.txt"))
   fatal <<~MSG
     clickhouse-cpp submodule not found at:
       #{VENDOR}
 
-    If you cloned this gem's repo, run:
+    Installing from a git source? Bundler skips submodules unless you add
+    `submodules: true` to the gem line:
+
+      gem "clickhouse-native", git: "...", submodules: true
+
+    From a manual clone, run:
       git submodule update --init --recursive
 
-    If you see this during `gem install`, please report a bug — the
-    gemspec should have bundled the submodule tree.
+    If you see this while installing a released gem from RubyGems, please
+    report a bug — the published .gem should bundle the submodule tree.
   MSG
 end
 
@@ -97,6 +120,10 @@ configure_args = [
   "-DBUILD_BENCHMARK=OFF",
   "-DBUILD_TESTS=OFF",
   "-DWITH_OPENSSL=OFF",
+  # clickhouse-cpp v2.6.2 added a distinct Bool column; this gem relies on
+  # Bool normalising to UInt8 (see the declared-type handling in client.cpp).
+  # Pin the upstream default ON so a future default flip can't break us.
+  "-DCH_MAP_BOOL_TO_UINT8=ON",
   "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
   "-DCMAKE_BUILD_TYPE=Release"
 ]

data/ext/clickhouse_native/patches/0002-carry-settings-into-insert.patch

@@ -0,0 +1,82 @@
+diff --git a/clickhouse/client.cpp b/clickhouse/client.cpp
+index 34a733d..c9732f4 100644
+--- a/clickhouse/client.cpp
++++ b/clickhouse/client.cpp
+@@ -211,7 +211,8 @@ public:
+ 
+     bool IsSelecting() const { return state_ == State::Selecting; }
+ 
+-    void Insert(const std::string& table_name, const std::string& query_id, const Block& block);
++    void Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                const std::vector<std::pair<std::string, std::string>>& settings = {});
+ 
+     Block BeginInsert(Query query);
+ 
+@@ -485,7 +486,8 @@ std::string NameToQueryString(const std::string &input)
+     return output;
+ }
+ 
+-void Client::Impl::Insert(const std::string& table_name, const std::string& query_id, const Block& block) {
++void Client::Impl::Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                          const std::vector<std::pair<std::string, std::string>>& settings) {
+     if (state_ == State::Inserting) {
+         throw ValidationError("cannot execute query while inserting, use SendInsertData instead");
+     }
+@@ -511,6 +513,9 @@ void Client::Impl::Insert(const std::string& table_name, const std::string& quer
+     }
+ 
+     Query query("INSERT INTO " + table_name + " ( " + fields_section.str() + " ) VALUES", query_id);
++    for (const auto& kv : settings) {
++        query.SetSetting(kv.first, QuerySettingsField{kv.second, 1});
++    }
+     SendQuery(query);
+ 
+     // Wait for a data packet and return
+@@ -1365,12 +1370,14 @@ bool Client::IsSelecting() const
+     return impl_->IsSelecting();
+ }
+ 
+-void Client::Insert(const std::string& table_name, const Block& block) {
+-    impl_->Insert(table_name, Query::default_query_id, block);
++void Client::Insert(const std::string& table_name, const Block& block,
++                    const std::vector<std::pair<std::string, std::string>>& settings) {
++    impl_->Insert(table_name, Query::default_query_id, block, settings);
+ }
+ 
+-void Client::Insert(const std::string& table_name, const std::string& query_id, const Block& block) {
+-    impl_->Insert(table_name, query_id, block);
++void Client::Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                    const std::vector<std::pair<std::string, std::string>>& settings) {
++    impl_->Insert(table_name, query_id, block, settings);
+ }
+ 
+ Block Client::BeginInsert(const std::string& query) {
+diff --git a/clickhouse/client.h b/clickhouse/client.h
+index a55fd74..6c6ff53 100644
+--- a/clickhouse/client.h
++++ b/clickhouse/client.h
+@@ -23,6 +23,8 @@
+ #include "columns/bool.h"
+ 
+ #include <chrono>
++#include <utility>
++#include <vector>
+ #include <cstdint>
+ #include <memory>
+ #include <ostream>
+@@ -298,8 +300,13 @@ public:
+     bool IsSelecting() const;
+ 
+     /// Intends for insert block of data into a table \p table_name.
+-    void Insert(const std::string& table_name, const Block& block);
+-    void Insert(const std::string& table_name, const std::string& query_id, const Block& block);
++    /// \p settings are applied to the generated INSERT query as per-query
++    /// settings (patched-in for clickhouse-native: lets a pooled client carry
++    /// its session settings into inserts without a session-level SET).
++    void Insert(const std::string& table_name, const Block& block,
++                const std::vector<std::pair<std::string, std::string>>& settings = {});
++    void Insert(const std::string& table_name, const std::string& query_id, const Block& block,
++                const std::vector<std::pair<std::string, std::string>>& settings = {});
+ 
+     /// Start an \p INSERT statement, insert batches of data, then finish the insert.
+     Block BeginInsert(const std::string& query);

data/ext/clickhouse_native/vendor/clickhouse-cpp/.github/workflows/bazel.yml

@@ -0,0 +1,120 @@
+name: Bazel
+
+on:
+  schedule:
+    - cron: '0 0 * * 1'
+  push:
+    branches: [ '*' ]
+  pull_request:
+    branches: [ master ]
+
+  release:
+    types:
+      - published
+      - prereleased
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, macos-latest, windows-latest]
+        tls: [boringssl, openssl, 'no']
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 100
+          fetch-tags: true
+
+      - name: Setup Bazel
+        uses: bazel-contrib/setup-bazel@0.15.0
+        with:
+          bazelisk-cache: true
+          disk-cache: true
+          repository-cache: true
+
+      - name: Build project
+        run: bazel build //... --@clickhouse-cpp-client//:tls=${{ matrix.tls }}
+
+      - name: Run unit tests
+        run: bazel test //ut:unit_tests --@clickhouse-cpp-client//:tls=${{ matrix.tls }} --test_output=errors
+
+      # //ut:e2e_tests is tagged `manual`, so `bazel build //...` above
+      # skips it; build it explicitly so the run step below doesn't pay
+      # for compilation under the running-server timeout.
+      - name: Build e2e tests
+        run: bazel build //ut:e2e_tests --@clickhouse-cpp-client//:tls=${{ matrix.tls }}
+
+      # The e2e suite needs a live server on localhost:9000. Each OS starts
+      # one the same way the CMake build's per-OS workflows do, since hosted
+      # runners can't all run a Linux container the same way:
+      #   * Linux   — docker-compose (linux.yml)
+      #   * macOS   — the native ClickHouse build run as a process (macos.yml)
+      #   * Windows — the Linux container under WSL2 + podman (windows_msvc.yml)
+      - name: Start ClickHouse (Linux, docker-compose)
+        if: runner.os == 'Linux'
+        uses: hoverkraft-tech/compose-action@v2.0.1
+        with:
+          compose-file: ci/docker-compose.yml
+          down-flags: --volumes
+
+      - name: Start ClickHouse (macOS, native binary)
+        if: runner.os == 'macOS'
+        working-directory: ${{ runner.temp }}
+        run: |
+          curl https://builds.clickhouse.com/25.12/macos-aarch64/clickhouse -o clickhouse
+          chmod +x ./clickhouse
+          sudo mkdir -p /var/lib/clickhouse /var/log/clickhouse-server
+          sudo chown -R "$USER" /var/lib/clickhouse /var/log/clickhouse-server
+          nohup ./clickhouse server --config-file="$GITHUB_WORKSPACE/ci/docker-compose/config.xml" > clickhouse.log 2>&1 &
+          for i in {1..60}; do
+            if curl -fsS http://localhost:8123/ > /dev/null; then
+              echo "ClickHouse is ready"
+              exit 0
+            fi
+            sleep 1
+          done
+          echo "ClickHouse failed to start"
+          tail -200 clickhouse.log || true
+          exit 1
+
+      - name: Enable WSL (Windows)
+        if: runner.os == 'Windows'
+        uses: Vampire/setup-wsl@v5
+        with:
+          distribution: Ubuntu-24.04
+          additional-packages:
+            podman
+            podman-compose
+
+      - name: Start ClickHouse (Windows, WSL + podman)
+        if: runner.os == 'Windows'
+        shell: wsl-bash {0}
+        run: |
+          cd $(wslpath -u "${{ github.workspace }}/ci/")
+          podman-compose up -d
+          timeout 60s bash -c \
+            'until curl -s -o /dev/null -w "%{http_code}" http://localhost:8123 | grep -q "200"; do sleep 2; done'
+          curl -s http://localhost:8123/?query=SELECT%20VERSION%28%29
+
+      - name: Wait for ClickHouse (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          for i in {1..60}; do
+            if curl -fsS http://localhost:8123/ > /dev/null; then
+              echo "ClickHouse is ready"
+              exit 0
+            fi
+            sleep 1
+          done
+          echo "ClickHouse failed to start"
+          exit 1
+
+      - name: Run e2e tests
+        run: bazel test //ut:e2e_tests --@clickhouse-cpp-client//:tls=${{ matrix.tls }} --test_output=errors

data/ext/clickhouse_native/vendor/clickhouse-cpp/.github/workflows/cross-repo-bug-relay.yml

@@ -0,0 +1,17 @@
+name: Relay bugs for cross-repo investigation
+
+# Relays newly-opened issues to ClickHouse/integrations-ai-playground for
+# cross-repo investigation.
+
+on:
+  issues:
+    types: [opened]
+
+permissions: {}
+
+jobs:
+  relay:
+    uses: ClickHouse/integrations-shared-workflows/.github/workflows/cross-repo-bug-relay.yml@main
+    secrets:
+      WORKFLOW_AUTH_PUBLIC_APP_ID: ${{ secrets.WORKFLOW_AUTH_PUBLIC_APP_ID }}
+      WORKFLOW_AUTH_PUBLIC_PRIVATE_KEY: ${{ secrets.WORKFLOW_AUTH_PUBLIC_PRIVATE_KEY }}

data/ext/clickhouse_native/vendor/clickhouse-cpp/.github/workflows/linux.yml

@@ -15,10 +15,9 @@ on:
 
 env:
   BUILD_TYPE: Release
-  CLICKHOUSE_SERVER_IMAGE: "clickhouse/clickhouse-server:25.10"
-  CLICKHOUSE_SECURE_HOST: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_HOST_SMT_PROD }}
-  CLICKHOUSE_SECURE_USER: default
-  CLICKHOUSE_SECURE_PASSWORD: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_PASSWORD_SMT_PROD }}
+
+permissions:
+  contents: read
 
 jobs:
   build:
@@ -83,7 +82,7 @@ jobs:
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 100
           fetch-tags: true
@@ -96,22 +95,13 @@ jobs:
             ${{matrix.COMPILER_INSTALL}} \
             ${{matrix.DEPENDENCIES_INSTALL}}
 
-      - name: Install dependencies - Docker
-        run: |
-          sudo apt remove -y docker docker-engine docker.io containerd runc
-          sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release
-          curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
-          echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-          sudo apt update -q
-          sudo apt install docker-ce docker-ce-cli containerd.io
-          sudo docker run hello-world
-
       - name: Configure project
         run: |
           cmake \
             -D CMAKE_C_COMPILER=${{matrix.C_COMPILER}} \
             -D CMAKE_CXX_COMPILER=${{matrix.CXX_COMPILER}} \
             -D CMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
+            -D CH_MAP_BOOL_TO_UINT8=OFF \
             -D BUILD_TESTS=ON \
             ${{matrix.SSL_CMAKE_OPTION}} \
             ${{matrix.DEPENDENCIES_CMAKE_OPTIONS}} \
@@ -125,15 +115,24 @@ jobs:
             --config ${{env.BUILD_TYPE}} \
             --target all
 
-      - name: Test - Start ClickHouse server in background
-        run: |
-          docker pull ${CLICKHOUSE_SERVER_IMAGE}
-          docker run -d --name clickhouse -p 9000:9000 -e CLICKHOUSE_SKIP_USER_SETUP=1 ${CLICKHOUSE_SERVER_IMAGE}
-          docker ps -a
-          docker stats -a --no-stream
-          ## Check and wait until CH is ready to accept connections
-          docker exec clickhouse bash -c 'for i in {1..10}; do echo checking if clickhouse server is started  attempt \#$i; if ( grep -q "<Information> Application: Ready for connections." /var/log/clickhouse-server/clickhouse-server.log ); then echo seems like clickhouse server is started; exit 0; fi; sleep 1; done; exit -1'
+      - name: Start ClickHouse in Docker
+        uses: hoverkraft-tech/compose-action@v2.0.1
+        with:
+          compose-file: ci/docker-compose.yml
+          down-flags: --volumes
 
+      - name: Check if ClickHouse is available
+        run: |
+          for i in {1..60}; do
+            if curl -fsS http://localhost:8123/ > /dev/null; then
+              echo "ClickHouse is ready"
+              exit 0
+            fi
+            sleep 1
+          done
+          echo "ClickHouse failed to start"
+          exit 1
+  
       - name: Test
         working-directory: ${{github.workspace}}/build/ut
         run: ./clickhouse-cpp-ut