couchbase 4.0.0 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/test_integration_query.cxx

@@ -80,30 +80,24 @@ TEST_CASE("integration: query on a collection", "[integration]")
         { "a", 1.0 },
         { "b", 2.0 },
     };
-    auto json = couchbase::utils::json::generate(value);
-
-    uint64_t scope_uid;
-    uint64_t collection_uid;
+    auto json = couchbase::utils::json::generate_binary(value);
 
     {
         couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        scope_uid = resp.uid;
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
     {
         couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        collection_uid = resp.uid;
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
-    auto current_manifest_uid = std::max(collection_uid, scope_uid);
-    auto created =
-      test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, current_manifest_uid);
-    REQUIRE(created);
-
     {
         couchbase::operations::management::query_index_create_request req{};
         req.bucket_name = integration.ctx.bucket;
@@ -224,7 +218,7 @@ TEST_CASE("integration: preserve expiry for mutatation query", "[integration]")
     const char* expiry_path = "$document.exptime";
 
     {
-        couchbase::operations::upsert_request req{ id, R"({"foo":42})" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(R"({"foo":42})") };
         req.expiry = expiry;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -405,3 +399,25 @@ TEST_CASE("integration: sticking query to the service node", "[integration]")
         REQUIRE(std::set(used_nodes.begin(), used_nodes.end()).size() == 1);
     }
 }
+
+TEST_CASE("analytics create dataset")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics() || !integration.has_analytics_service() ||
+        !integration.cluster_version().supports_collections()) {
+        return;
+    }
+    if (!integration.cluster_version().supports_gcccp()) {
+        test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    }
+    couchbase::operations::analytics_request req{ fmt::format("CREATE DATAVERSE `{}`.`test-scope` IF NOT EXISTS", integration.ctx.bucket) };
+    std::vector<std::string> rows{};
+    req.row_callback = [&rows](std::string&& row) {
+        rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    };
+
+    auto resp = test::utils::execute(integration.cluster, req);
+    REQUIRE_FALSE(resp.ctx.ec);
+}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/test_integration_subdoc.cxx

@@ -92,10 +92,9 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    std::string value_json{ R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})" };
-    auto value = couchbase::utils::json::parse(value_json);
 
     {
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -178,7 +177,7 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
     SECTION("non json")
     {
         couchbase::document_id non_json_id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("non_json") };
-        std::string non_json_doc{ "string" };
+        auto non_json_doc = couchbase::utils::to_binary("string");
 
         {
             couchbase::operations::insert_request req{ non_json_id, non_json_doc };
@@ -247,11 +246,10 @@ TEST_CASE("integration: subdoc store", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
-    couchbase::protocol::cas cas{};
+    couchbase::cas cas{};
 
     {
-        std::string value_json{ R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})" };
-        auto value = couchbase::utils::json::parse(value_json);
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -291,7 +289,7 @@ TEST_CASE("integration: subdoc store", "[integration]")
     SECTION("bad cas")
     {
         couchbase::operations::mutate_in_request req{ id };
-        req.cas = couchbase::protocol::cas{ cas.value + 1 };
+        req.cas = couchbase::cas{ cas.value + 1 };
         req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "newpath", "123");
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::cas_mismatch);
@@ -410,8 +408,7 @@ TEST_CASE("integration: subdoc unique", "[integration]")
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-        auto value = couchbase::utils::json::parse(value_json);
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -467,8 +464,7 @@ TEST_CASE("integration: subdoc counter", "[integration]")
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-        auto value = couchbase::utils::json::parse(value_json);
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -570,10 +566,9 @@ TEST_CASE("integration: subdoc multi lookup", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
 
     {
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -630,10 +625,9 @@ TEST_CASE("integration: subdoc multi mutation", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
 
     {
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -673,10 +667,9 @@ TEST_CASE("integration: subdoc expiry")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
 
     {
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -696,10 +689,9 @@ TEST_CASE("integration: subdoc get count", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
 
     {
+        auto value_json = couchbase::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -733,9 +725,9 @@ TEST_CASE("integration: subdoc insert error consistency", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_err") };
 
-    couchbase::protocol::cas cas;
+    couchbase::cas cas{};
     {
-        couchbase::operations::insert_request req{ id, "{}" };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("{}") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
         cas = resp.cas;
@@ -756,7 +748,7 @@ TEST_CASE("integration: subdoc insert error consistency", "[integration]")
     {
         couchbase::operations::mutate_in_request req{ id };
         req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "foo", "42");
-        req.cas = couchbase::protocol::cas{ cas.value + 1 };
+        req.cas = couchbase::cas{ cas.value + 1 };
         req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::invalid_argument);
@@ -767,7 +759,7 @@ TEST_CASE("integration: subdoc insert error consistency", "[integration]")
     {
         couchbase::operations::mutate_in_request req{ id };
         req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "foo", "42");
-        req.cas = couchbase::protocol::cas{ cas.value + 1 };
+        req.cas = couchbase::cas{ cas.value + 1 };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::cas_mismatch);
     }
@@ -783,7 +775,7 @@ TEST_CASE("integration: subdoc remove with empty path", "[integration]")
 
     // create initial document
     {
-        std::string initial_value{ R"({"bar":"foo"})" };
+        auto initial_value = couchbase::utils::to_binary(R"({"bar":"foo"})");
         couchbase::operations::insert_request req{ id, initial_value };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -801,7 +793,7 @@ TEST_CASE("integration: subdoc remove with empty path", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == value);
+        REQUIRE(resp.value == couchbase::utils::to_binary(value));
     }
 
     // remove with empty path removes the document
@@ -839,7 +831,7 @@ TEST_CASE("integration: subdoc top level array", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "[1]");
+        REQUIRE(resp.value == couchbase::utils::to_binary("[1]"));
     }
 
     // try to add number 1 but only if it is not in the array yet
@@ -862,7 +854,7 @@ TEST_CASE("integration: subdoc top level array", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "[1,42]");
+        REQUIRE(resp.value == couchbase::utils::to_binary("[1,42]"));
     }
 
     // add number 2 to the end of the array
@@ -878,7 +870,7 @@ TEST_CASE("integration: subdoc top level array", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "[1,42,2]");
+        REQUIRE(resp.value == couchbase::utils::to_binary("[1,42,2]"));
     }
 
     // check size of the top-level array
@@ -890,4 +882,4 @@ TEST_CASE("integration: subdoc top level array", "[integration]")
         REQUIRE(resp.fields.size() == 1);
         REQUIRE(resp.fields[0].value == "3");
     }
-}
+}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/test_unit_json_streaming_lexer.cxx

@@ -113,3 +113,122 @@ TEST_CASE("unit: json_streaming_lexer parse query result", "[unit]")
     REQUIRE(result.rows.size() == 3);
     REQUIRE(result.meta == chunks[0] + chunks[4]);
 }
+
+TEST_CASE("unit: json_streaming_lexer parse query result in multiple chunks", "[unit]")
+{
+    test::utils::init_logger();
+
+    const std::vector<std::string> chunks{
+        /* 0 */
+        R"({"requestID": "34a4e4b2-3f69-4bf8-a6e2-ae06798de3d9","clientContextID": "dfea5193-ead9-4ac2-5558-8fd5c4631959","signature": {"greeting":"string"},"results": [{"greeting":"ruby rules"}],"status": "success","profile": {"phaseTimes": {"authorize":"10.473µs","instantiate":"10.29µs","parse":"183.413µs","plan":"19.155µs","project":"5.712µs","run":"43.258µs","stream":"7.078µs"},"phaseOperators": {"authorize":1,"project":1,"stream":1},"requestTime": "2022-05-11T11:01:14.943Z","servicingHost": "10.112.220.101:8091","executionTimings": {"#operator":"Authorize","#stats":{"#phaseSwitches":4,"execTime":"1.372µs","servTime":"9.101µs"},"privileges":{"List":[]},"~child":{"#operator":"Sequence","#stats":{"#phaseSwitches":2,"execTime":"838ns"},"~children":[{"#operator":"DummyScan","#stats":{"#itemsOut":1,"#phaseSwitches":3,"execTime":"794ns","kernTime":"514ns"},"optimizer_estimates":{"cardinality":1,"cost":1.0842021724855044e-19,"fr_cost":1.0842021724855044e-19,"size":1}},{"#operator":"InitialProject","#stats":{"#itemsIn":1,"#itemsOut":1,"#phaseSwitches":8,"execTime":"110.717µs","kernTime":"4.786µs","state":"running"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1},"result_terms":[{"as":"greeting","expr":"\"ruby rules\""}]},{"#operator":"Stream","#stats":{"#itemsIn":)",
+        /* 1 */
+        R"(1,"#itemsOut":1,"#phaseSwitches":2,"execTime":"7.078µs"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1}}]},"~versions":["7.1.0-N1QL","7.1.0-2534-enterprise"]},"optimizerEstimates": {"cardinality":1,"cost":0.001}}})"
+    };
+
+    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    query_result result{};
+    lexer.on_row([&result](std::string&& row) {
+        result.rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    });
+    lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
+        result.ec = ec;
+        result.number_of_rows = number_of_rows;
+        result.meta = std::move(meta);
+    });
+    for (const auto& chunk : chunks) {
+        lexer.feed(chunk);
+    }
+    REQUIRE_FALSE(result.ec);
+    REQUIRE(result.number_of_rows == 1);
+    REQUIRE(result.rows.size() == 1);
+
+    const auto* expected_meta =
+      R"({"requestID": "34a4e4b2-3f69-4bf8-a6e2-ae06798de3d9","clientContextID": "dfea5193-ead9-4ac2-5558-8fd5c4631959","signature": {"greeting":"string"},"results": [],"status": "success","profile": {"phaseTimes": {"authorize":"10.473µs","instantiate":"10.29µs","parse":"183.413µs","plan":"19.155µs","project":"5.712µs","run":"43.258µs","stream":"7.078µs"},"phaseOperators": {"authorize":1,"project":1,"stream":1},"requestTime": "2022-05-11T11:01:14.943Z","servicingHost": "10.112.220.101:8091","executionTimings": {"#operator":"Authorize","#stats":{"#phaseSwitches":4,"execTime":"1.372µs","servTime":"9.101µs"},"privileges":{"List":[]},"~child":{"#operator":"Sequence","#stats":{"#phaseSwitches":2,"execTime":"838ns"},"~children":[{"#operator":"DummyScan","#stats":{"#itemsOut":1,"#phaseSwitches":3,"execTime":"794ns","kernTime":"514ns"},"optimizer_estimates":{"cardinality":1,"cost":1.0842021724855044e-19,"fr_cost":1.0842021724855044e-19,"size":1}},{"#operator":"InitialProject","#stats":{"#itemsIn":1,"#itemsOut":1,"#phaseSwitches":8,"execTime":"110.717µs","kernTime":"4.786µs","state":"running"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1},"result_terms":[{"as":"greeting","expr":"\"ruby rules\""}]},{"#operator":"Stream","#stats":{"#itemsIn":1,"#itemsOut":1,"#phaseSwitches":2,"execTime":"7.078µs"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1}}]},"~versions":["7.1.0-N1QL","7.1.0-2534-enterprise"]},"optimizerEstimates": {"cardinality":1,"cost":0.001}}})";
+
+    REQUIRE(result.meta == expected_meta);
+}
+
+TEST_CASE("unit: json_streaming_lexer parse chunked metadata trailer", "[unit]")
+{
+    test::utils::init_logger();
+
+    const std::vector<std::string> chunks{
+        /* 0 */
+        R"({"requestID": "2640a5b5-2e67-44e7-86ec-31cc388b7427","results": [42],)",
+        /* 1 */
+        R"("clientContextID":)",
+        /* 2 */
+        R"("730ecac3-e8d0-4d6e-4ed9-e2d4abd1d7b9",)",
+        /* 3 */
+        R"("status": "success"})",
+    };
+    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    query_result result{};
+    lexer.on_row([&result](std::string&& row) {
+        result.rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    });
+    lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
+        result.ec = ec;
+        result.number_of_rows = number_of_rows;
+        result.meta = std::move(meta);
+    });
+    for (const auto& chunk : chunks) {
+        lexer.feed(chunk);
+    }
+    REQUIRE_FALSE(result.ec);
+    REQUIRE(result.number_of_rows == 1);
+    REQUIRE(result.rows.size() == 1);
+    const auto* expected_meta =
+      R"({"requestID": "2640a5b5-2e67-44e7-86ec-31cc388b7427","results": [],"clientContextID":"730ecac3-e8d0-4d6e-4ed9-e2d4abd1d7b9","status": "success"})";
+    REQUIRE(result.meta == expected_meta);
+    REQUIRE(result.rows[0] == R"(42)");
+}
+
+TEST_CASE("unit: json_streaming_lexer parse payload with missing results", "[unit]")
+{
+    test::utils::init_logger();
+
+    std::string chunk = R"(
+{
+
+	"requestID": "d07c0cde-cd80-4620-bb6b-d0641f272420",
+	"clientContextID": "a7bbe750-20a2-4e46-eb67-315e3733b2a8",
+	"signature": {
+		"*": "*"
+	},
+	"plans":{},
+	"status": "success",
+	"metrics": {
+		"elapsedTime": "6.56579ms",
+		"executionTime": "5.552905ms",
+		"resultCount": 0,
+		"resultSize": 0,
+		"processedObjects": 0
+	}
+}
+)";
+    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    query_result result{};
+    bool on_row_handler_executed = false;
+    lexer.on_row([&result, &on_row_handler_executed](std::string&& row) {
+        on_row_handler_executed = true;
+        result.rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    });
+    bool on_complete_handler_excecuted = false;
+    lexer.on_complete([&result, &on_complete_handler_excecuted](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
+        on_complete_handler_excecuted = true;
+        result.ec = ec;
+        result.number_of_rows = number_of_rows;
+        result.meta = std::move(meta);
+    });
+    lexer.feed(chunk);
+    REQUIRE_FALSE(on_row_handler_executed);
+    REQUIRE(on_complete_handler_excecuted);
+    REQUIRE_FALSE(result.ec);
+    REQUIRE(result.number_of_rows == 0);
+    REQUIRE(result.rows.empty());
+    REQUIRE(result.meta == chunk);
+}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/tools/tool_kv_loader.cxx

@@ -20,7 +20,6 @@
 #include "../utils/uniq_id.hxx"
 
 #include <couchbase/logger/logger.hxx>
-#include <couchbase/utils/json.hxx>
 
 #include <spdlog/details/os.h>
 
@@ -53,7 +52,7 @@ dump_stats(asio::steady_timer& timer, std::chrono::system_clock::time_point star
         }
         auto diff = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - start_time).count();
         std::uint64_t ops = total;
-        fmt::print(stderr, "\rrate: {} ops/s\r", diff == 0 ? ops : ops / static_cast<std::uint64_t>(diff));
+        fmt::print(stderr, "\rrate: {} ops/s, total: {}\r", diff == 0 ? ops : ops / static_cast<std::uint64_t>(diff), ops);
         return dump_stats(timer, start_time, total);
     });
 }
@@ -70,11 +69,24 @@ main()
 
     auto ctx = test::utils::test_context::load_from_environment();
 
+    bool send_queries = false;
+    if (auto val = spdlog::details::os::getenv("TEST_SEND_QUERIES"); !val.empty()) {
+        std::vector<std::string> truth = {
+            "YES", "Y", "TRUE", "T", "ON", "1", "yes", "y", "true", "t", "on",
+        };
+        send_queries = std::any_of(truth.begin(), truth.end(), [&val](auto& t) { return t == val; });
+    }
+
     std::size_t number_of_io_threads = 4;
     if (auto val = spdlog::details::os::getenv("TEST_NUMBER_OF_IO_THREADS"); !val.empty()) {
         number_of_io_threads = std::stoul(val, nullptr, 10);
     }
-    LOG_INFO("number_of_threads: {}, username: {}, connection_string: {}", number_of_io_threads, ctx.username, ctx.connection_string);
+    LOG_INFO("send_queries: {}, number_of_threads: {}, username: \"{}\", connection_string: \"{}\", bucket: \"{}\"",
+             send_queries,
+             number_of_io_threads,
+             ctx.username,
+             ctx.connection_string,
+             ctx.bucket);
 
     auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
     couchbase::cluster_credentials auth{};
@@ -122,7 +134,8 @@ main()
              hit_chance_for_upsert,
              hit_chance_for_get);
 
-    const std::string json_doc = R"({
+    const auto json_doc = couchbase::utils::to_binary(R"({
+  "type": "fake_profile",
   "random": 91,
   "random float": 16.439,
   "bool": false,
@@ -160,7 +173,7 @@ main()
   "Mildrid": {
     "age": 33
   }
-})";
+})");
 
     const auto start_time = std::chrono::system_clock::now();
 
@@ -211,6 +224,16 @@ main()
                 });
             } break;
         }
+        if (send_queries) {
+            couchbase::operations::query_request req{ fmt::format("SELECT COUNT(*) FROM `{}` WHERE type = \"fake_profile\"", ctx.bucket) };
+            cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::operations::query_response&& resp) {
+                ++total;
+                if (resp.ctx.ec) {
+                    std::scoped_lock lock(errors_mutex);
+                    ++errors[resp.ctx.ec];
+                }
+            });
+        }
     }
     const auto finish_time = std::chrono::system_clock::now();
     stats_timer.cancel();
@@ -223,6 +246,7 @@ main()
                std::chrono::duration_cast<std::chrono::milliseconds>(total_time).count());
     auto diff = std::chrono::duration_cast<std::chrono::seconds>(total_time).count();
     fmt::print("total rate: {} ops/s\n", total / static_cast<std::uint64_t>(diff));
+    std::scoped_lock lock(errors_mutex);
     if (!errors.empty()) {
         fmt::print("error stats:\n");
         for (auto [ec, count] : errors) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -45,7 +45,7 @@ integration_test_guard::~integration_test_guard()
     io_thread.join();
 }
 
-const couchbase::operations::management::bucket_info&
+const couchbase::operations::management::bucket_describe_response::bucket_info&
 integration_test_guard::load_bucket_info(const std::string& bucket_name, bool refresh)
 {
     if (info.count(bucket_name) > 0 && !refresh) {
@@ -66,7 +66,7 @@ integration_test_guard::load_bucket_info(const std::string& bucket_name, bool re
     return info[bucket_name];
 }
 
-const couchbase::operations::management::cluster_info&
+const couchbase::operations::management::cluster_describe_response::cluster_info&
 integration_test_guard::load_cluster_info(bool refresh)
 {
     if (cluster_info && !refresh) {
@@ -105,7 +105,7 @@ integration_test_guard::cluster_version()
     if (runtime_version.empty()) {
         return ctx.version;
     }
-    auto parsed_version = server_version::parse(runtime_version);
+    auto parsed_version = server_version::parse(runtime_version, ctx.deployment);
     if (parsed_version.major == 0) {
         /* the build does not specify version properly */
         return ctx.version;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/integration_test_guard.hxx

@@ -20,8 +20,8 @@
 #include "integration_shortcuts.hxx"
 #include "test_context.hxx"
 
+#include <couchbase/management/bucket_settings.hxx>
 #include <couchbase/operations/management/bucket_describe.hxx>
-#include <couchbase/operations/management/bucket_settings.hxx>
 #include <couchbase/operations/management/cluster_describe.hxx>
 
 #include <optional>
@@ -34,12 +34,13 @@ class integration_test_guard
     integration_test_guard();
     ~integration_test_guard();
 
-    inline const couchbase::operations::management::bucket_info& load_bucket_info(bool refresh = false)
+    inline const couchbase::operations::management::bucket_describe_response::bucket_info& load_bucket_info(bool refresh = false)
     {
         return load_bucket_info(ctx.bucket, refresh);
     }
 
-    const couchbase::operations::management::bucket_info& load_bucket_info(const std::string& bucket_name, bool refresh = false);
+    const couchbase::operations::management::bucket_describe_response::bucket_info& load_bucket_info(const std::string& bucket_name,
+                                                                                                     bool refresh = false);
 
     inline std::size_t number_of_nodes()
     {
@@ -61,12 +62,12 @@ class integration_test_guard
         return load_bucket_info(bucket_name).number_of_replicas;
     }
 
-    inline couchbase::operations::management::bucket_settings::storage_backend_type storage_backend()
+    inline couchbase::management::cluster::bucket_storage_backend storage_backend()
     {
         return load_bucket_info(ctx.bucket).storage_backend;
     }
 
-    const couchbase::operations::management::cluster_info& load_cluster_info(bool refresh = false);
+    const couchbase::operations::management::cluster_describe_response::cluster_info& load_cluster_info(bool refresh = false);
 
     inline bool has_service(couchbase::service_type service)
     {
@@ -99,7 +100,7 @@ class integration_test_guard
     test_context ctx;
     couchbase::origin origin;
 
-    std::map<std::string, couchbase::operations::management::bucket_info, std::less<>> info{};
-    std::optional<couchbase::operations::management::cluster_info> cluster_info{};
+    std::map<std::string, couchbase::operations::management::bucket_describe_response::bucket_info, std::less<>> info{};
+    std::optional<couchbase::operations::management::cluster_describe_response::cluster_info> cluster_info{};
 };
 } // namespace test::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/server_version.cxx

@@ -22,11 +22,12 @@
 namespace test::utils
 {
 server_version
-server_version::parse(const std::string& str)
+server_version::parse(const std::string& str, const deployment_type deployment)
 {
     std::regex version_regex(R"((\d+).(\d+).(\d+)(-(\d+))?(-(.+))?)");
     std::smatch version_match{};
     server_version ver{};
+    ver.deployment = deployment;
     if (std::regex_match(str, version_match, version_regex) && version_match.ready()) {
         ver.major = std::stoul(version_match[1]);
         ver.minor = std::stoul(version_match[2]);

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/server_version.hxx

@@ -25,6 +25,8 @@ namespace test::utils
 
 enum class server_edition { unknown, enterprise, community };
 
+enum class deployment_type { on_prem, capella, elixir };
+
 struct server_version {
     unsigned long major{ 0 };
     unsigned long minor{ 0 };
@@ -32,8 +34,9 @@ struct server_version {
     unsigned long build{ 0 };
     bool developer_preview{ false };
     server_edition edition{ server_edition::unknown };
+    deployment_type deployment{ deployment_type::on_prem };
 
-    static server_version parse(const std::string& str);
+    static server_version parse(const std::string& str, const deployment_type deployment);
 
     [[nodiscard]] bool is_alice() const
     {
@@ -86,7 +89,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_storage_backend() const
     {
-        return is_neo();
+        return is_neo() && is_enterprise();
     }
 
     [[nodiscard]] bool supports_preserve_expiry() const
@@ -101,7 +104,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_user_groups() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return supports_user_management() && (is_mad_hatter() || is_cheshire_cat() || is_neo()) && is_enterprise();
     }
 
     [[nodiscard]] bool supports_query_index_management() const
@@ -111,7 +114,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_analytics() const
     {
-        return is_alice() || is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return is_enterprise() && (is_alice() || is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics_pending_mutations() const
@@ -146,7 +149,32 @@ struct server_version {
 
     [[nodiscard]] bool supports_eventing_functions() const
     {
-        return is_cheshire_cat() || is_neo();
+        return is_enterprise() && (is_cheshire_cat() || is_neo()) && deployment == deployment_type::on_prem;
+    }
+
+    [[nodiscard]] bool is_enterprise() const
+    {
+        return edition == server_edition::enterprise;
+    }
+
+    [[nodiscard]] bool is_community() const
+    {
+        return edition == server_edition::community;
+    }
+
+    [[nodiscard]] bool supports_bucket_management() const
+    {
+        return deployment == deployment_type::on_prem;
+    }
+
+    [[nodiscard]] bool supports_user_management() const
+    {
+        return deployment == deployment_type::on_prem;
+    }
+
+    [[nodiscard]] bool supports_views() const
+    {
+        return deployment == deployment_type::on_prem;
     }
 };