clickhouse-native 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1bf3fdd8bd132c0d19937f50055f56b5ab55f4bf383fafc63a74131ff435545
-  data.tar.gz: 4e6f233a2e250ee5c2c6c1e46ebf9a961416b69553aee7c2018afea619c1abab
+  metadata.gz: d3e2cb4cbe829d9afd7e30e0ac29ea828020896c93634852b4baef007348d3b0
+  data.tar.gz: e5f13079f4de6e64e545f49736a8da6832de954dfe82f1a4d105dd1228680887
 SHA512:
-  metadata.gz: a79cba4fd6ad33b75ec2eecadf87ec0e9fc163ff46874b2ad687f6d767405f7357fffe04a1af584a6716d0c1dcc3ba7171b201a46b130c327d87e3b5e04c52ad
-  data.tar.gz: 7ed472036327f17efceda43eac9f41cf7e6675e267711de5f974b2b75de88fcc5e557e7290ef1b0f00b084573fc4a8a5a88e49875d0b4fb83237302262b418f4
+  metadata.gz: 9998240b8ca84a4d28ad1fb956c0bf92e1893d4a9ce024fa443eefaa01efb35b657b55d8c2ce92718fd9224a5167fe0201a955f7147ab7499560a331906e2567
+  data.tar.gz: d097a39e1fa03b051a30fe1fb273a928b7e2e555e05945d32b22a9dd9dc1deaf280193b80ecae146d7d442d513bbfb6e638ba4b63589f5a58171ce4b25ba5b87

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>
@@ -188,6 +189,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 +339,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 +504,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: {
@@ -694,6 +721,50 @@ static CompressionMethod kwarg_compression(VALUE kwargs) {
              rb_id2name(sym));
 }
 
+// Stringify a Ruby setting value for the binary protocol's QuerySettings
+// payload (which is wire-string-typed). Bool maps to "1"/"0" the way the
+// HTTP gem rendered it; everything else goes through #to_s.
+static std::string stringify_setting_value(VALUE v) {
+    if (v == Qtrue)  return "1";
+    if (v == Qfalse) return "0";
+    VALUE s = rb_funcall(v, rb_intern("to_s"), 0);
+    StringValue(s);
+    return std::string(RSTRING_PTR(s), RSTRING_LEN(s));
+}
+
+static int apply_settings_cb(VALUE key, VALUE val, VALUE arg) {
+    auto* q = reinterpret_cast<Query*>(arg);
+    VALUE k = SYMBOL_P(key) ? rb_sym2str(key) : key;
+    StringValue(k);
+    q->SetSetting(
+        std::string(RSTRING_PTR(k), RSTRING_LEN(k)),
+        QuerySettingsField{stringify_setting_value(val), 0});
+    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.
+static void apply_settings(Query& q, VALUE kwargs) {
+    if (NIL_P(kwargs)) return;
+    VALUE settings = rb_hash_lookup2(kwargs, ID2SYM(rb_intern("settings")), Qnil);
+    if (NIL_P(settings)) return;
+    Check_Type(settings, T_HASH);
+    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);
+}
+
 // Client.new(host:, port:, database:, user:, password:)
 static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kwargs = Qnil;
@@ -734,7 +805,7 @@ static VALUE ch_client_initialize(int argc, VALUE* argv, VALUE self) {
 namespace {
 struct ExecuteNoGVL {
     Client* client;
-    std::string sql;
+    const Query* query;
     std::exception_ptr err;
 };
 }  // namespace
@@ -742,7 +813,7 @@ struct ExecuteNoGVL {
 static void* execute_no_gvl(void* data) {
     auto* a = static_cast<ExecuteNoGVL*>(data);
     try {
-        a->client->Execute(Query(a->sql));
+        a->client->Execute(*a->query);
     } catch (...) {
         a->err = std::current_exception();
     }
@@ -756,12 +827,17 @@ static void execute_unblock(void* data) {
     try { a->client->ResetConnection(); } catch (...) {}
 }
 
-static VALUE ch_client_execute(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_execute(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_sql, kwargs = Qnil;
+    rb_scan_args(argc, argv, "1:", &rb_sql, &kwargs);
     Check_Type(rb_sql, T_STRING);
     CHClient* c = as_client(self);
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
-    ExecuteNoGVL args{c->client.get(), std::string(StringValueCStr(rb_sql)), nullptr};
+    Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_settings(q, kwargs);
+
+    ExecuteNoGVL args{c->client.get(), &q, nullptr};
     rb_thread_call_without_gvl(execute_no_gvl, &args, execute_unblock, &args);
     if (args.err) {
         // clickhouse-cpp may leave the read stream partially consumed when the
@@ -779,16 +855,19 @@ static VALUE ch_client_execute(VALUE self, VALUE rb_sql) {
 // See query_each below for a streaming, GVL-releasing variant.
 // ------------------------------------------------------------------
 
-static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_query(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_sql, kwargs = Qnil;
+    rb_scan_args(argc, argv, "1:", &rb_sql, &kwargs);
     Check_Type(rb_sql, T_STRING);
     CHClient* c = as_client(self);
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
-    std::string sql(StringValueCStr(rb_sql));
     VALUE rows = rb_ary_new();
     try {
         std::vector<ID> col_ids;
-        c->client->Select(sql, [&](const Block& block) {
+        Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+        apply_read_settings(q, kwargs);
+        q.OnData([&](const Block& block) {
             size_t ncols = block.GetColumnCount();
             size_t nrows = block.GetRowCount();
             if (nrows == 0) return;
@@ -808,6 +887,7 @@ static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
                 rb_ary_push(rows, h);
             }
         });
+        c->client->Execute(q);
         return rows;
     } catch (const std::exception& e) {
         try { c->client->ResetConnection(); } catch (...) {}
@@ -820,21 +900,25 @@ static VALUE ch_client_query(VALUE self, VALUE rb_sql) {
 // query_value — returns the first cell of the first row, or nil
 // ------------------------------------------------------------------
 
-static VALUE ch_client_query_value(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_query_value(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_sql, kwargs = Qnil;
+    rb_scan_args(argc, argv, "1:", &rb_sql, &kwargs);
     Check_Type(rb_sql, T_STRING);
     CHClient* c = as_client(self);
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
-    std::string sql(StringValueCStr(rb_sql));
     try {
         VALUE out = Qnil;
         bool seen = false;
-        c->client->Select(sql, [&](const Block& block) {
+        Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+        apply_read_settings(q, kwargs);
+        q.OnData([&](const Block& block) {
             if (seen) return;
             if (block.GetRowCount() == 0 || block.GetColumnCount() == 0) return;
             out = value_at(block[0], 0, block.GetColumnType(0));
             seen = true;
         });
+        c->client->Execute(q);
         return out;
     } catch (const std::exception& e) {
         try { c->client->ResetConnection(); } catch (...) {}
@@ -958,7 +1042,7 @@ struct YieldBlockArgs {
 
 struct QueryEachNoGVL {
     Client* client;
-    std::string sql;
+    const Query* query;
     QueryEachState* state;
     std::exception_ptr err;
 };
@@ -1003,12 +1087,7 @@ static void* with_gvl_yield(void* data) {
 static void* query_each_no_gvl(void* data) {
     auto* a = static_cast<QueryEachNoGVL*>(data);
     try {
-        a->client->SelectCancelable(a->sql, [&](const Block& block) -> bool {
-            if (a->state->aborted) return false;
-            YieldBlockArgs ya{&block, a->state};
-            rb_thread_call_with_gvl(with_gvl_yield, &ya);
-            return !a->state->aborted;
-        });
+        a->client->Execute(*a->query);
     } catch (...) {
         a->err = std::current_exception();
     }
@@ -1021,19 +1100,24 @@ static void query_each_unblock(void* data) {
     try { a->client->ResetConnection(); } catch (...) {}
 }
 
-static VALUE ch_client_query_each(VALUE self, VALUE rb_sql) {
+static VALUE ch_client_query_each(int argc, VALUE* argv, VALUE self) {
     rb_need_block();
+    VALUE rb_sql, kwargs = Qnil;
+    rb_scan_args(argc, argv, "1:", &rb_sql, &kwargs);
     Check_Type(rb_sql, T_STRING);
     CHClient* c = as_client(self);
     if (!c->client) rb_raise(err_connection, "clickhouse-native: client is closed");
 
     QueryEachState state{rb_block_proc(), {}, 0, false};
-    QueryEachNoGVL args{
-        c->client.get(),
-        std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)),
-        &state,
-        nullptr,
-    };
+    Query q(std::string(RSTRING_PTR(rb_sql), RSTRING_LEN(rb_sql)));
+    apply_read_settings(q, kwargs);
+    q.OnDataCancelable([&state](const Block& block) -> bool {
+        if (state.aborted) return false;
+        YieldBlockArgs ya{&block, &state};
+        rb_thread_call_with_gvl(with_gvl_yield, &ya);
+        return !state.aborted;
+    });
+    QueryEachNoGVL args{c->client.get(), &q, &state, nullptr};
 
     rb_thread_call_without_gvl(query_each_no_gvl, &args, query_each_unblock, &args);
 
@@ -1139,13 +1223,13 @@ extern "C" void Init_clickhouse_native(void) {
     rb_define_method(rb_cClient, "initialize",
         reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_initialize), -1);
     rb_define_method(rb_cClient, "execute",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_execute), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_execute), -1);
     rb_define_method(rb_cClient, "query",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query), -1);
     rb_define_method(rb_cClient, "query_value",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_value), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_value), -1);
     rb_define_method(rb_cClient, "query_each",
-        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_each), 1);
+        reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_query_each), -1);
     rb_define_method(rb_cClient, "insert_block",
         reinterpret_cast<VALUE (*)(ANYARGS)>(ch_client_insert_block), 3);
     rb_define_method(rb_cClient, "ping",

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/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

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

@@ -14,13 +14,9 @@ on:
 
 env:
   BUILD_TYPE: Release
-  CLICKHOUSE_USER: default
-  CLICKHOUSE_PASSWORD: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_PASSWORD_SMT_PROD }}
-  CLICKHOUSE_SECURE_HOST: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_HOST_SMT_PROD }}
-  CLICKHOUSE_SECURE_PORT: 9440
-  CLICKHOUSE_SECURE_USER: default
-  CLICKHOUSE_SECURE_PASSWORD: ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_PASSWORD_SMT_PROD }}
-  CLICKHOUSE_SECURE_DB: default
+
+permissions:
+  contents: read
 
 jobs:
   build:
@@ -40,7 +36,7 @@ jobs:
           SSL_INSTALL: openssl
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 100
           fetch-tags: true
@@ -55,6 +51,7 @@ jobs:
         run: |
           cmake \
             -D CMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
+            -D CH_MAP_BOOL_TO_UINT8=OFF \
             -D BUILD_TESTS=ON \
             ${{matrix.SSL_CMAKE_OPTION}} \
             -S ${{github.workspace}} \
@@ -67,21 +64,25 @@ jobs:
             --config ${{env.BUILD_TYPE}} \
             --target all
 
-      - name: Start tls offoader proxy
-        # that mimics non-secure clickhouse running on localhost
-        # by tunneling queries to remote tls server
-        # (needed because we can't start real clickhouse instance on macOS)
+      - name: Install and start ClickHouse
+        working-directory: ${{ runner.temp }}
         run: |
-              wget https://github.com/filimonov/go-tlsoffloader/releases/download/v0.1.2/go-tlsoffloader_0.1.2_Darwin_x86_64.tar.gz
-              tar -xvzf go-tlsoffloader_0.1.2_Darwin_x86_64.tar.gz
-              ./go-tlsoffloader -l localhost:9000 -b ${{ secrets.INTEGRATIONS_TEAM_TESTS_CLOUD_HOST_SMT_PROD }}:9440 &
+          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: Test
         working-directory: ${{github.workspace}}/build/ut
-        env:
-          # It is impossible to start CH server in docker on macOS due to github actions limitations,
-          # so we use remote server to execute tests, some do not allow some features for anonymoust/free users:
-          # - system.query_log used by 'Client/ClientCase.Query_ID' and 'Client/ClientCase.ClientName'
-          # - system.opentelemetry_span_log is used by 'Client/ClientCase.TracingContext'
-          GTEST_FILTER: "-Client/ClientCase.Query_ID*:Client/ClientCase.TracingContext/*:Client/ClientCase.ClientName/*"
         run: ./clickhouse-cpp-ut ${GTEST_FILTER}