couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/test/test_integration_meter.cxx

@@ -0,0 +1,180 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "test_helper_integration.hxx"
+
+#include "core/platform/uuid.h"
+
+class test_value_recorder : public couchbase::core::metrics::value_recorder
+{
+  public:
+    test_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags)
+      : name_(name)
+      , tags_(tags)
+    {
+    }
+    void record_value(std::int64_t value) override
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        values_.emplace_back(value);
+    }
+    std::map<std::string, std::string> tags() const
+    {
+        return tags_;
+    }
+    std::list<std::uint64_t> values()
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return values_;
+    }
+    void reset()
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        values_.clear();
+    }
+
+  private:
+    std::string name_;
+    std::map<std::string, std::string> tags_;
+    std::mutex mutex_;
+    std::list<std::uint64_t> values_;
+};
+
+class test_meter : public couchbase::core::metrics::meter
+{
+  public:
+    test_meter()
+      : couchbase::core::metrics::meter()
+    {
+    }
+    std::shared_ptr<couchbase::core::metrics::value_recorder> get_value_recorder(const std::string& name,
+                                                                                 const std::map<std::string, std::string>& tags) override
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = value_recorders_.equal_range(name);
+        if (it.first != it.second) {
+
+            for (auto itr = it.first; itr != it.second; itr++) {
+                if (tags == itr->second->tags())
+                    return itr->second;
+            }
+        }
+        return value_recorders_.insert({ name, std::make_shared<test_value_recorder>(name, tags) })->second;
+    }
+
+    void reset()
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        for (auto v : value_recorders_) {
+            v.second->reset();
+        }
+    }
+    std::list<std::shared_ptr<test_value_recorder>> get_recorders(const std::string& name)
+    {
+        std::list<std::shared_ptr<test_value_recorder>> retval;
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = value_recorders_.equal_range(name);
+        for (auto itr = it.first; itr != it.second; itr++) {
+            retval.push_back(itr->second);
+        }
+        return retval;
+    }
+
+  private:
+    std::multimap<std::string, std::shared_ptr<test_value_recorder>> value_recorders_;
+    std::mutex mutex_;
+};
+
+void
+assert_kv_recorder_tags(std::list<std::shared_ptr<test_value_recorder>> recorders, const std::string& op)
+{
+    // you'd expect one of these (only one) to have a matching op
+    REQUIRE(recorders.size() == 1);
+    REQUIRE(recorders.front()->tags()["db.couchbase.service"] == "kv");
+    // db.operation always _starts_ with the op -- like '<op> 0x<NN'
+    REQUIRE(recorders.front()->tags()["db.operation"].find(op, 0) == 0);
+}
+
+couchbase::core::document_id
+make_id(const test::utils::test_context& ctx, std::string key = "")
+{
+    if (key.empty()) {
+        key = test::utils::uniq_id("tracer");
+    }
+    return couchbase::core::document_id{ ctx.bucket, "_default", "_default", key };
+}
+
+TEST_CASE("integration: use external meter", "[integration]")
+{
+    couchbase::core::cluster_options opts{};
+    auto meter = std::make_shared<test_meter>();
+    opts.meter = meter;
+    test::utils::integration_test_guard guard(opts);
+    test::utils::open_bucket(guard.cluster, guard.ctx.bucket);
+    auto value = couchbase::core::utils::to_binary(R"({"some": "thing")");
+    auto existing_id = make_id(guard.ctx, "foo");
+    SECTION("add doc 'foo'")
+    {
+        couchbase::core::operations::upsert_request r{ existing_id, value };
+        auto response = test::utils::execute(guard.cluster, r);
+        REQUIRE_FALSE(response.ctx.ec());
+    }
+    SECTION("test KV ops")
+    {
+        SECTION("upsert")
+        {
+            meter->reset();
+            couchbase::core::operations::upsert_request r{ existing_id, value };
+            auto response = test::utils::execute(guard.cluster, r);
+            REQUIRE_FALSE(response.ctx.ec());
+            auto recorders = meter->get_recorders("db.couchbase.operations");
+            REQUIRE_FALSE(recorders.empty());
+            assert_kv_recorder_tags(recorders, "upsert");
+        }
+        SECTION("insert")
+        {
+            meter->reset();
+            couchbase::core::operations::insert_request r{ make_id(guard.ctx), value };
+            auto response = test::utils::execute(guard.cluster, r);
+            REQUIRE_FALSE(response.ctx.ec());
+            auto recorders = meter->get_recorders("db.couchbase.operations");
+            REQUIRE_FALSE(recorders.empty());
+            assert_kv_recorder_tags(recorders, "insert");
+        }
+        SECTION("replace")
+        {
+            meter->reset();
+            auto new_value = couchbase::core::utils::to_binary("{\"some\": \"thing else\"");
+            couchbase::core::operations::replace_request r{ existing_id, new_value };
+            auto response = test::utils::execute(guard.cluster, r);
+            REQUIRE_FALSE(response.ctx.ec());
+            auto recorders = meter->get_recorders("db.couchbase.operations");
+            REQUIRE_FALSE(recorders.empty());
+            assert_kv_recorder_tags(recorders, "replace");
+        }
+        SECTION("get")
+        {
+            meter->reset();
+            couchbase::core::operations::get_request r{ existing_id };
+            auto response = test::utils::execute(guard.cluster, r);
+            REQUIRE_FALSE(response.ctx.ec());
+            auto meters = meter->get_recorders("db.couchbase.operations");
+            REQUIRE_FALSE(meters.empty());
+            assert_kv_recorder_tags(meters, "get");
+        }
+    }
+}

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

@@ -19,8 +19,10 @@
 
 #include "utils/move_only_context.hxx"
 
-#include <couchbase/operations/management/collections.hxx>
-#include <couchbase/operations/management/query.hxx>
+#include "core/operations/management/collections.hxx"
+#include "core/operations/management/query.hxx"
+
+#include <couchbase/lookup_in_specs.hxx>
 
 TEST_CASE("integration: trivial non-data query", "[integration]")
 {
@@ -31,10 +33,9 @@ TEST_CASE("integration: trivial non-data query", "[integration]")
     }
 
     {
-        couchbase::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
+        couchbase::core::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 }
 
@@ -49,18 +50,17 @@ TEST_CASE("integration: query with handler capturing non-copyable object", "[int
     }
 
     {
-        couchbase::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
-        auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
+        couchbase::core::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::query_response>>();
         auto f = barrier->get_future();
         test::utils::move_only_context ctx("foobar");
-        auto handler = [barrier, ctx = std::move(ctx)](couchbase::operations::query_response&& resp) {
+        auto handler = [barrier, ctx = std::move(ctx)](couchbase::core::operations::query_response&& resp) {
             CHECK(ctx.payload() == "foobar");
             barrier->set_value(std::move(resp));
         };
         integration.cluster->execute(req, std::move(handler));
         auto resp = f.get();
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 }
 
@@ -80,88 +80,92 @@ TEST_CASE("integration: query on a collection", "[integration]")
         { "a", 1.0 },
         { "b", 2.0 },
     };
-    auto json = couchbase::utils::json::generate_binary(value);
+    auto json = couchbase::core::utils::json::generate_binary(value);
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         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 };
+        couchbase::core::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);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
         REQUIRE(created);
     }
 
     {
-        couchbase::operations::management::query_index_create_request req{};
+        couchbase::core::operations::management::query_index_create_request req{};
         req.bucket_name = integration.ctx.bucket;
         req.scope_name = scope_name;
         req.collection_name = collection_name;
         req.index_name = index_name;
         req.is_primary = true;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.http_body)
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     couchbase::mutation_token mutation_token;
 
     {
-        couchbase::document_id id{ integration.ctx.bucket, scope_name, collection_name, key };
-        couchbase::operations::insert_request req{ id, json };
+        couchbase::core::document_id id{ integration.ctx.bucket, scope_name, collection_name, key };
+        couchbase::core::operations::insert_request req{ id, json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         mutation_token = resp.token;
     }
 
     SECTION("correct scope and collection")
     {
-        couchbase::operations::query_request req{ fmt::format(R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
+        couchbase::core::operations::query_request req{ fmt::format(
+          R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
         req.bucket_name = integration.ctx.bucket;
         req.scope_name = scope_name;
         req.mutation_state = { mutation_token };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.size() == 1);
-        REQUIRE(value == couchbase::utils::json::parse(resp.rows[0]));
+        REQUIRE(value == couchbase::core::utils::json::parse(resp.rows[0]));
     }
 
     SECTION("missing scope")
     {
-        couchbase::operations::query_request req{ fmt::format(R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
+        couchbase::core::operations::query_request req{ fmt::format(
+          R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
         req.bucket_name = integration.ctx.bucket;
         req.scope_name = "missing_scope";
         req.mutation_state = { mutation_token };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::query_errc::index_failure);
+        REQUIRE(resp.ctx.ec == couchbase::errc::query::index_failure);
     }
 
     SECTION("missing collection")
     {
-        couchbase::operations::query_request req{ fmt::format(R"(SELECT a, b FROM missing_collection WHERE META().id = "{}")", key) };
+        couchbase::core::operations::query_request req{ fmt::format(R"(SELECT a, b FROM missing_collection WHERE META().id = "{}")", key) };
         req.bucket_name = integration.ctx.bucket;
         req.scope_name = scope_name;
         req.mutation_state = { mutation_token };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::query_errc::index_failure);
+        REQUIRE(resp.ctx.ec == couchbase::errc::query::index_failure);
     }
 
     SECTION("prepared")
     {
-        couchbase::operations::query_request req{ fmt::format(R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
+        couchbase::core::operations::query_request req{ fmt::format(
+          R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
         req.bucket_name = integration.ctx.bucket;
         req.scope_name = scope_name;
         req.mutation_state = { mutation_token };
         req.adhoc = false;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.size() == 1);
-        REQUIRE(value == couchbase::utils::json::parse(resp.rows[0]));
+        REQUIRE(value == couchbase::core::utils::json::parse(resp.rows[0]));
     }
 }
 
@@ -174,9 +178,9 @@ TEST_CASE("integration: read only with no results", "[integration]")
     }
 
     {
-        couchbase::operations::query_request req{ fmt::format("SELECT * FROM {} LIMIT 0", integration.ctx.bucket) };
+        couchbase::core::operations::query_request req{ fmt::format("SELECT * FROM {} LIMIT 0", integration.ctx.bucket) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.empty());
     }
 }
@@ -190,10 +194,9 @@ TEST_CASE("integration: invalid query", "[integration]")
     }
 
     {
-        couchbase::operations::query_request req{ "I'm not n1ql" };
+        couchbase::core::operations::query_request req{ "I'm not n1ql" };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message());
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::parsing_failure);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::parsing_failure);
     }
 }
 
@@ -207,7 +210,7 @@ TEST_CASE("integration: preserve expiry for mutatation query", "[integration]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{
+    couchbase::core::document_id id{
         integration.ctx.bucket,
         "_default",
         "_default",
@@ -215,39 +218,46 @@ TEST_CASE("integration: preserve expiry for mutatation query", "[integration]")
     };
 
     uint32_t expiry = std::numeric_limits<uint32_t>::max();
-    const char* expiry_path = "$document.exptime";
 
     {
-        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(R"({"foo":42})") };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(R"({"foo":42})") };
         req.expiry = expiry;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, expiry_path);
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "foo");
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::expiry_time).xattr(),
+              couchbase::lookup_in_specs::get("foo"),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(expiry == std::stoul(resp.fields[0].value));
-        REQUIRE("42" == resp.fields[1].value);
+        REQUIRE(expiry == std::stoul(test::utils::to_string(resp.fields[0].value)));
+        REQUIRE(couchbase::core::utils::to_binary("42") == resp.fields[1].value);
     }
 
     {
         std::string statement = fmt::format("UPDATE {} AS b USE KEYS '{}' SET b.foo = 43", integration.ctx.bucket, id.key());
-        couchbase::operations::query_request req{ statement };
+        couchbase::core::operations::query_request req{ statement };
         req.preserve_expiry = true;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, expiry_path);
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "foo");
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::expiry_time).xattr(),
+              couchbase::lookup_in_specs::get("foo"),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(expiry == std::stoul(resp.fields[0].value));
-        REQUIRE("43" == resp.fields[1].value);
+        REQUIRE(expiry == std::stoul(test::utils::to_string(resp.fields[0].value)));
+        REQUIRE(couchbase::core::utils::to_binary("43") == resp.fields[1].value);
     }
 }
 
@@ -260,15 +270,14 @@ TEST_CASE("integration: streaming query results", "[integration]")
     }
 
     {
-        couchbase::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
+        couchbase::core::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
         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;
+            return couchbase::core::utils::json::stream_control::next_row;
         };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(rows.size() == 1);
         REQUIRE(rows[0] == R"({"greeting":"ruby rules"})");
     }
@@ -283,19 +292,20 @@ TEST_CASE("integration: streaming query results with stop in the middle", "[inte
     }
 
     {
-        couchbase::operations::query_request req{ R"(SELECT * FROM  [{"tech": "C++"}, {"tech": "Ruby"}, {"tech": "Couchbase"}] AS data)" };
+        couchbase::core::operations::query_request req{
+            R"(SELECT * FROM  [{"tech": "C++"}, {"tech": "Ruby"}, {"tech": "Couchbase"}] AS data)"
+        };
         std::vector<std::string> rows{};
         req.row_callback = [&rows](std::string&& row) {
             bool should_stop = row.find("Ruby") != std::string::npos;
             rows.emplace_back(std::move(row));
             if (should_stop) {
-                return couchbase::utils::json::stream_control::stop;
+                return couchbase::core::utils::json::stream_control::stop;
             }
-            return couchbase::utils::json::stream_control::next_row;
+            return couchbase::core::utils::json::stream_control::next_row;
         };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(rows.size() == 2);
         REQUIRE(rows[0] == R"({"data":{"tech":"C++"}})");
         REQUIRE(rows[1] == R"({"data":{"tech":"Ruby"}})");
@@ -315,17 +325,16 @@ TEST_CASE("integration: streaming analytics results", "[integration]")
     }
 
     {
-        couchbase::operations::analytics_request req{
+        couchbase::core::operations::analytics_request req{
             R"(SELECT * FROM  [{"tech": "C++"}, {"tech": "Ruby"}, {"tech": "Couchbase"}] AS data)"
         };
         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;
+            return couchbase::core::utils::json::stream_control::next_row;
         };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(rows.size() == 3);
         REQUIRE(rows[0] == R"({ "data": { "tech": "C++" } })");
         REQUIRE(rows[1] == R"({ "data": { "tech": "Ruby" } })");
@@ -343,9 +352,9 @@ TEST_CASE("integration: sticking query to the service node", "[integration]")
 
     std::string node_to_stick_queries;
     {
-        couchbase::operations::query_request req{ R"(SELECT 42 AS answer)" };
+        couchbase::core::operations::query_request req{ R"(SELECT 42 AS answer)" };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.size() == 1);
         REQUIRE(resp.rows[0] == R"({"answer":42})");
         REQUIRE_FALSE(resp.served_by_node.empty());
@@ -360,7 +369,7 @@ TEST_CASE("integration: sticking query to the service node", "[integration]")
         threads.reserve(10);
         for (int i = 0; i < 10; ++i) {
             threads.emplace_back([i, &cluster = integration.cluster, node_to_stick_queries, &used_nodes, &used_nodes_mutex]() {
-                couchbase::operations::query_request req{ fmt::format(R"(SELECT {} AS answer)", i) };
+                couchbase::core::operations::query_request req{ fmt::format(R"(SELECT {} AS answer)", i) };
                 auto resp = test::utils::execute(cluster, req);
                 if (resp.ctx.ec || resp.served_by_node.empty() || resp.rows.size() != 1 ||
                     resp.rows[0] != fmt::format(R"({{"answer":{}}})", i)) {
@@ -381,7 +390,7 @@ TEST_CASE("integration: sticking query to the service node", "[integration]")
 
         for (int i = 0; i < 10; ++i) {
             threads.emplace_back([i, &cluster = integration.cluster, node_to_stick_queries, &used_nodes, &used_nodes_mutex]() {
-                couchbase::operations::query_request req{ fmt::format(R"(SELECT {} AS answer)", i) };
+                couchbase::core::operations::query_request req{ fmt::format(R"(SELECT {} AS answer)", i) };
                 req.send_to_node = node_to_stick_queries;
                 auto resp = test::utils::execute(cluster, req);
                 if (resp.ctx.ec || resp.served_by_node.empty() || resp.rows.size() != 1 ||
@@ -411,13 +420,47 @@ TEST_CASE("analytics create dataset")
     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) };
+    couchbase::core::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;
+        return couchbase::core::utils::json::stream_control::next_row;
     };
 
     auto resp = test::utils::execute(integration.cluster, req);
-    REQUIRE_FALSE(resp.ctx.ec);
+    REQUIRE_SUCCESS(resp.ctx.ec);
+}
+
+TEST_CASE("integration: prepared query", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    auto key = test::utils::uniq_id("foo");
+    tao::json::value value = {
+        { "a", 1.0 },
+        { "b", 2.0 },
+    };
+    auto json = couchbase::core::utils::json::generate_binary(value);
+
+    couchbase::mutation_token mutation_token;
+    {
+        couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", key };
+        couchbase::core::operations::insert_request req{ id, json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        mutation_token = resp.token;
+    }
+
+    {
+        couchbase::core::operations::query_request req{ fmt::format(
+          R"(SELECT a, b FROM {} WHERE META().id = "{}")", integration.ctx.bucket, key) };
+
+        req.mutation_state = { mutation_token };
+        req.adhoc = false;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        REQUIRE(resp.rows.size() == 1);
+        REQUIRE(value == couchbase::core::utils::json::parse(resp.rows[0]));
+    }
 }