couchbase 4.2.1 → 4.2.2

package/deps/couchbase-cxx-client/couchbase/query_options.hxx

@@ -57,7 +57,6 @@ struct query_options : public common_options<query_options> {
         std::optional<std::chrono::milliseconds> scan_wait;
         std::optional<std::uint64_t> pipeline_batch;
         std::optional<std::uint64_t> pipeline_cap;
-        std::optional<std::string> scope_qualifier;
         std::optional<std::string> client_context_id;
         std::optional<query_scan_consistency> scan_consistency;
         std::vector<mutation_token> mutation_state;
@@ -91,7 +90,6 @@ struct query_options : public common_options<query_options> {
             scan_wait_,
             pipeline_batch_,
             pipeline_cap_,
-            scope_qualifier_,
             client_context_id_,
             scan_consistency_,
             mutation_state_,
@@ -342,19 +340,6 @@ struct query_options : public common_options<query_options> {
         return self();
     }
 
-    /**
-     * @param scope_qualifier
-     * @return this options builder for chaining purposes.
-     *
-     * @since 1.0.0
-     * @volatile
-     */
-    auto scope_qualifier(std::string scope_qualifier) -> query_options&
-    {
-        scope_qualifier_ = std::move(scope_qualifier);
-        return self();
-    }
-
     /**
      * Customizes the consistency guarantees for this query.
      *
@@ -549,7 +534,6 @@ struct query_options : public common_options<query_options> {
     std::optional<std::uint64_t> scan_cap_{};
     std::optional<std::uint64_t> pipeline_batch_{};
     std::optional<std::uint64_t> pipeline_cap_{};
-    std::optional<std::string> scope_qualifier_{};
     std::optional<std::string> client_context_id_{};
     std::optional<std::chrono::milliseconds> scan_wait_{};
     std::optional<query_scan_consistency> scan_consistency_{};
@@ -582,8 +566,7 @@ namespace impl
 void
 initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string statement,
-                         std::optional<std::string> bucket_name,
-                         std::optional<std::string> scope_name,
+                         std::optional<std::string> query_context,
                          query_options::built options,
                          query_handler&& handler);
 #endif

package/deps/couchbase-cxx-client/couchbase/scope.hxx

@@ -104,8 +104,11 @@ class scope
     template<typename Handler>
     void query(std::string statement, const query_options& options, Handler&& handler) const
     {
-        return core::impl::initiate_query_operation(
-          core_, std::move(statement), bucket_name_, name_, options.build(), std::forward<Handler>(handler));
+        return core::impl::initiate_query_operation(core_,
+                                                    std::move(statement),
+                                                    fmt::format("default:`{}`.`{}`", bucket_name_, name_),
+                                                    options.build(),
+                                                    std::forward<Handler>(handler));
     }
 
     /**

package/deps/couchbase-cxx-client/couchbase/tracing/request_tracer.hxx

@@ -72,6 +72,22 @@ class request_tracer
     request_tracer& operator=(request_tracer&& other) = default;
     virtual ~request_tracer() = default;
 
+    /**
+     * SDK invokes this method when cluster is ready to trace. Override it as NO-OP if no action is necessary.
+     */
+    virtual void start()
+    {
+        /* do nothing */
+    }
+
+    /**
+     * SDK invokes this method when cluster is closed. Override it as NO-OP if no action is necessary.
+     */
+    virtual void stop()
+    {
+        /* do nothing */
+    }
+
     virtual std::shared_ptr<request_span> start_span(std::string name, std::shared_ptr<request_span> parent = {}) = 0;
 };
 

package/deps/couchbase-cxx-client/couchbase/transactions/async_attempt_context.hxx

@@ -53,19 +53,26 @@ class async_attempt_context
 
     void query(const scope& scope, std::string statement, transaction_query_options opts, async_query_handler&& handler)
     {
-        opts.scope_qualifier(fmt::format("{}.{}", scope.bucket_name(), scope.name()));
-        return query(std::move(statement), std::move(opts), std::move(handler));
+        return query(std::move(statement), std::move(opts), fmt::format("{}.{}", scope.bucket_name(), scope.name()), std::move(handler));
     }
 
-    virtual void query(std::string statement, transaction_query_options opts, async_query_handler&& handler) = 0;
+    void query(std::string statement, transaction_query_options opts, async_query_handler&& handler)
+    {
+        return query(statement, opts, {}, std::move(handler));
+    };
+
     void query(std::string statement, async_query_handler&& handler)
     {
-        return query(statement, {}, std::move(handler));
+        return query(statement, {}, {}, std::move(handler));
     }
     virtual ~async_attempt_context() = default;
 
   protected:
     virtual void insert_raw(const collection& coll, std::string id, std::vector<std::byte> content, async_result_handler&& handler) = 0;
     virtual void replace_raw(transaction_get_result_ptr doc, std::vector<std::byte> content, async_result_handler&& handler) = 0;
+    virtual void query(std::string statement,
+                       transaction_query_options opts,
+                       std::optional<std::string> query_context,
+                       async_query_handler&&) = 0;
 };
 } // namespace couchbase::transactions

package/deps/couchbase-cxx-client/couchbase/transactions/attempt_context.hxx

@@ -50,13 +50,13 @@ class attempt_context
 
     transaction_query_result_ptr query(const std::string& statement, const transaction_query_options& options = {})
     {
-        return do_public_query(statement, options);
+        return do_public_query(statement, options, {});
     }
 
     transaction_query_result_ptr query(const scope& scope, std::string& statement, const transaction_query_options& opts = {})
     {
         auto new_opts = opts;
-        return query(statement, new_opts.scope_qualifier(fmt::format("{}.{}", scope.bucket_name(), scope.name())));
+        return do_public_query(statement, opts, fmt::format("{}.{}", scope.bucket_name(), scope.name()));
     }
 
     virtual ~attempt_context() = default;
@@ -66,6 +66,8 @@ class attempt_context
     virtual transaction_get_result_ptr insert_raw(const couchbase::collection& coll,
                                                   const std::string& id,
                                                   std::vector<std::byte> content) = 0;
-    virtual transaction_query_result_ptr do_public_query(const std::string& statement, const transaction_query_options& options) = 0;
+    virtual transaction_query_result_ptr do_public_query(const std::string& statement,
+                                                         const transaction_query_options& options,
+                                                         std::optional<std::string> query_context) = 0;
 };
 } // namespace couchbase::transactions

package/deps/couchbase-cxx-client/couchbase/transactions/transaction_keyspace.hxx

@@ -18,6 +18,7 @@
 #include "couchbase/collection.hxx"
 #include "couchbase/scope.hxx"
 
+#include <fmt/format.h>
 #include <string>
 #include <utility>
 
@@ -83,3 +84,18 @@ struct transaction_keyspace {
     }
 };
 } // namespace couchbase::transactions
+template<>
+struct fmt::formatter<couchbase::transactions::transaction_keyspace> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::transactions::transaction_keyspace& k, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(), "transaction_keyspace:{{ bucket: {}, scope: {}, collection: {} }}", k.bucket, k.scope, k.collection);
+    }
+};

package/deps/couchbase-cxx-client/couchbase/transactions/transaction_query_options.hxx

@@ -114,12 +114,6 @@ class transaction_query_options
         return *this;
     }
 
-    transaction_query_options& scope_qualifier(const std::string& scope)
-    {
-        opts_.scope_qualifier(scope);
-        return *this;
-    }
-
     transaction_query_options& metrics(bool metrics)
     {
         opts_.metrics(metrics);

package/deps/couchbase-cxx-client/couchbase/watch_query_indexes_options.hxx

@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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.
+ */
+
+#pragma once
+
+#include <couchbase/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class watch_query_indexes_options : public common_options<watch_query_indexes_options>
+{
+  public:
+    auto watch_primary(bool watch_primary) -> watch_query_indexes_options&
+    {
+        watch_primary_ = watch_primary;
+        return self();
+    }
+
+    template<typename T>
+    auto polling_interval(T duration)
+    {
+        polling_interval_ = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<watch_query_indexes_options>::built {
+        bool watch_primary{};
+        std::chrono::milliseconds polling_interval;
+    };
+
+    /**
+     * Validates options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options(), watch_primary_, polling_interval_ };
+    }
+
+  private:
+    bool watch_primary_{ false };
+    std::chrono::milliseconds polling_interval_{ 1000 };
+};
+
+/**
+ * The signature for the handler of the @ref query_index_manager#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using watch_query_indexes_handler = std::function<void(couchbase::manager_error_context)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+class query_context;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                             std::string bucket_name,
+                             std::vector<std::string> index_names,
+                             couchbase::watch_query_indexes_options::built options,
+                             query_context query_ctx,
+                             std::string collection_name,
+                             watch_query_indexes_handler&& handler);
+void
+initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                             std::string bucket_name,
+                             std::vector<std::string> index_names,
+                             couchbase::watch_query_indexes_options::built options,
+                             watch_query_indexes_handler&& handler);
+
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

package/deps/couchbase-cxx-client/examples/minimal.cxx

@@ -44,7 +44,9 @@ main()
     auto options = couchbase::cluster_options(username, password);
     options.apply_profile("wan_development");
     auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, options).get();
-    {
+    if (ec) {
+        std::cout << "Unable to connect to the cluster. ec: " << ec.message() << "\n";
+    } else {
         auto collection = cluster.bucket(bucket_name).scope(scope_name).collection(collection_name);
 
         const std::string document_id{ "minimal_example" };

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

@@ -29,6 +29,32 @@ static const tao::json::value basic_doc = {
 };
 static const std::vector<std::byte> basic_doc_json = couchbase::core::utils::json::generate_binary(basic_doc);
 
+TEST_CASE("integration: switching off mutation token", "[integration]")
+{
+    couchbase::core::cluster_options opts{};
+    opts.enable_mutation_tokens = false;
+    test::utils::integration_test_guard integration(opts);
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+
+    {
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(!resp.cas.empty());
+        REQUIRE(resp.token.sequence_number() == 0);
+        REQUIRE(resp.token.partition_uuid() == 0);
+        REQUIRE_FALSE(resp.token.partition_id() == 0);
+        REQUIRE_FALSE(resp.token.bucket_name().empty());
+    }
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.value == basic_doc_json);
+    }
+}
+
 TEST_CASE("integration: crud on default collection", "[integration]")
 {
     test::utils::integration_test_guard integration;
@@ -868,3 +894,49 @@ TEST_CASE("integration: exists with public API", "[integration]")
         REQUIRE_FALSE(resp.exists());
     }
 }
+
+TEST_CASE("integration: get with expiry with public API", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto collection = couchbase::cluster(integration.cluster)
+                        .bucket(integration.ctx.bucket)
+                        .scope(couchbase::scope::default_name)
+                        .collection(couchbase::collection::default_name);
+
+    auto id = test::utils::uniq_id("get_expiry");
+
+    auto get_options = couchbase::get_options{}.with_expiry(true);
+
+    SECTION("no expiry set on the document")
+    {
+        {
+            auto [ctx, resp] = collection.insert(id, basic_doc, {}).get();
+            REQUIRE_SUCCESS(ctx.ec());
+        }
+
+        {
+            auto [ctx, resp] = collection.get(id, get_options).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            REQUIRE_FALSE(resp.expiry_time().has_value());
+        }
+    }
+
+    SECTION("some expiry is set on the document")
+    {
+        auto the_expiry = std::chrono::system_clock::from_time_t(1878422400);
+        auto insert_options = couchbase::insert_options{}.expiry(the_expiry);
+        {
+            auto [ctx, resp] = collection.insert(id, basic_doc, insert_options).get();
+            REQUIRE_SUCCESS(ctx.ec());
+        }
+
+        {
+            auto [ctx, resp] = collection.get(id, get_options).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            REQUIRE(resp.expiry_time().has_value());
+            REQUIRE(resp.expiry_time().value() == the_expiry);
+        }
+    }
+}