couchbase 4.2.8 → 4.2.10

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

@@ -19,7 +19,12 @@
 #include <couchbase/transactions/transaction_query_options.hxx>
 #include <couchbase/transactions/transaction_query_result.hxx>
 
-namespace couchbase::transactions
+namespace couchbase
+{
+class collection;
+class scope;
+
+namespace transactions
 {
 /**
  * The attempt_context is used for all synchronous transaction operations
@@ -108,10 +113,7 @@ class attempt_context
      * @return The result of the operation, with is an @ref transaction_op_error_context and a @ref transaction_query_result.
      */
     std::pair<transaction_op_error_context, transaction_query_result> query(const std::string& statement,
-                                                                            const transaction_query_options& options = {})
-    {
-        return do_public_query(statement, options, {});
-    }
+                                                                            const transaction_query_options& options = {});
 
     /**
      * Perform a scoped query.
@@ -123,10 +125,7 @@ class attempt_context
      */
     std::pair<transaction_op_error_context, transaction_query_result> query(const scope& scope,
                                                                             const std::string& statement,
-                                                                            const transaction_query_options& opts = {})
-    {
-        return do_public_query(statement, opts, fmt::format("{}.{}", scope.bucket_name(), scope.name()));
-    }
+                                                                            const transaction_query_options& opts = {});
 
     virtual ~attempt_context() = default;
 
@@ -143,4 +142,5 @@ class attempt_context
                                                                                               const transaction_query_options& options,
                                                                                               std::optional<std::string> query_context) = 0;
 };
-} // namespace couchbase::transactions
+} // namespace transactions
+} // namespace couchbase

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

@@ -15,12 +15,7 @@
  */
 #pragma once
 
-#include "couchbase/collection.hxx"
-#include "couchbase/scope.hxx"
-
-#include <fmt/format.h>
 #include <string>
-#include <utility>
 
 namespace couchbase::transactions
 {
@@ -28,44 +23,15 @@ namespace couchbase::transactions
  * @brief  Offline, serializable representation of a bucket, scope, and collection
  */
 struct transaction_keyspace {
+    transaction_keyspace(std::string bucket_name, std::string scope_name, std::string collection_name);
 
-    std::string bucket;
-    std::string scope{ couchbase::scope::default_name };
-    std::string collection{ couchbase::collection::default_name };
+    explicit transaction_keyspace(const std::string& bucket_name);
 
-    transaction_keyspace(const transaction_keyspace&) = default;
-    transaction_keyspace(transaction_keyspace&&) = default;
-    transaction_keyspace& operator=(const transaction_keyspace& keyspace)
-    {
-        if (this != &keyspace) {
-            bucket = keyspace.bucket;
-            scope = keyspace.scope;
-            collection = keyspace.collection;
-        }
-        return *this;
-    }
-    bool operator==(const transaction_keyspace& keyspace)
+    bool operator==(const transaction_keyspace& keyspace) const
     {
         return bucket == keyspace.bucket && scope == keyspace.scope && collection == keyspace.collection;
     }
 
-    transaction_keyspace(std::string bucket_name, std::string scope_name, std::string collection_name)
-      : bucket(std::move(bucket_name))
-      , scope(std::move(scope_name))
-      , collection(std::move(collection_name))
-    {
-        if (scope.empty()) {
-            scope = couchbase::scope::default_name;
-        }
-        if (collection.empty()) {
-            collection = couchbase::collection::default_name;
-        }
-    }
-
-    explicit transaction_keyspace(const std::string& bucket_name)
-      : transaction_keyspace{ bucket_name, couchbase::scope::default_name, couchbase::collection::default_name }
-    {
-    }
     /**
      * Check if a keyspace is valid.
      *
@@ -74,10 +40,7 @@ struct transaction_keyspace {
      *
      * @return true if valid.
      */
-    bool valid()
-    {
-        return !bucket.empty() && !scope.empty() && !collection.empty();
-    }
+    bool valid();
 
     /** @private */
     template<typename OStream>
@@ -90,22 +53,9 @@ struct transaction_keyspace {
         os << "}";
         return os;
     }
+
+    std::string bucket;
+    std::string scope;
+    std::string collection;
 };
 } // namespace couchbase::transactions
-
-/** @private */
-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_options.hxx

@@ -16,13 +16,18 @@
 
 #pragma once
 
+#include <couchbase/durability_level.hxx>
 #include <couchbase/query_scan_consistency.hxx>
 #include <couchbase/transactions/transactions_config.hxx>
 
 #include <chrono>
 #include <optional>
 
-namespace couchbase::transactions
+namespace couchbase
+{
+class collection;
+
+namespace transactions
 {
 /**
  * The transaction_options can be passed in to override some elements of the global @ref transactions_config.
@@ -40,11 +45,8 @@ class transaction_options
      * @param level Durability level for this transaction.
      * @return reference to this object, convenient for chaining operations.
      */
-    transaction_options& durability_level(durability_level level)
-    {
-        durability_ = level;
-        return *this;
-    }
+    transaction_options& durability_level(durability_level level);
+
     /**
      * Get the durability if it has been set.
      *
@@ -52,10 +54,8 @@ class transaction_options
      *
      * @return durability if set.
      */
-    std::optional<couchbase::durability_level> durability_level()
-    {
-        return durability_;
-    }
+    [[nodiscard]] std::optional<couchbase::durability_level> durability_level() const;
+
     /**
      * Set the @ref query_scan_consistency for this transaction.
      *
@@ -64,11 +64,8 @@ class transaction_options
      * @param scan_consistency The desired @ref query_scan_consistency for this transaction.
      * @return reference to this object, convenient for chaining operations.
      */
-    transaction_options& scan_consistency(query_scan_consistency scan_consistency)
-    {
-        scan_consistency_ = scan_consistency;
-        return *this;
-    }
+    transaction_options& scan_consistency(query_scan_consistency scan_consistency);
+
     /**
      * Get the scan_consistency if it has been set.
      *
@@ -76,55 +73,28 @@ class transaction_options
      *
      * @return The scan_consistency, if set.
      */
-    std::optional<query_scan_consistency> scan_consistency()
-    {
-        return scan_consistency_;
-    }
-    /**
-     * Set the timeout for key-value operations for this transaction.
-     *
-     * @param kv_timeout Desired key-value timeout.
-     * @return reference to this object, convenient for chaining operations.
-     */
-    transaction_options& kv_timeout(std::chrono::milliseconds kv_timeout)
-    {
-        kv_timeout_ = kv_timeout;
-        return *this;
-    }
-
-    /**
-     * Get the key-value timeout if it has been set.
-     *
-     * @return The key-value timeout, if set.
-     */
-    std::optional<std::chrono::milliseconds> kv_timeout()
-    {
-        return kv_timeout_;
-    }
+    [[nodiscard]] std::optional<query_scan_consistency> scan_consistency() const;
 
     /**
-     * Set the expiration time for this transaction.
+     * Set the timeout for this transaction.
      *
-     * @tparam T expiration time type, e.g. @ref std::chrono::milliseconds, or similar
-     * @param expiration_time Desired expiration time.
+     * @tparam T timeout type, e.g. @ref std::chrono::milliseconds, or similar
+     * @param timeout Desired timeout
      * @return reference to this object, convenient for chaining operations.
      */
     template<typename T>
-    transaction_options& expiration_time(T expiration_time)
+    transaction_options& timeout(T timeout)
     {
-        expiration_time_ = std::chrono::duration_cast<std::chrono::nanoseconds>(expiration_time);
+        timeout_ = std::chrono::duration_cast<std::chrono::nanoseconds>(timeout);
         return *this;
     }
 
     /**
-     * Get the expiration time, if set.
+     * Get the timeout, if set.
      *
-     * @return the expiration time, if set.
+     * @return the timeout, if set.
      */
-    std::optional<std::chrono::nanoseconds> expiration_time()
-    {
-        return expiration_time_;
-    }
+    std::optional<std::chrono::nanoseconds> timeout();
 
     /**
      * Set the metadata collection to use for this transaction
@@ -136,11 +106,8 @@ class transaction_options
      * @param coll The desired collection to use.
      * @return reference to this object, convenient for chaining operations.
      */
-    transaction_options& metadata_collection(const couchbase::collection& coll)
-    {
-        metadata_collection_.emplace(coll.bucket_name(), coll.scope_name(), coll.name());
-        return *this;
-    }
+    transaction_options& metadata_collection(const couchbase::collection& coll);
+
     /**
      * Set metadata collection to use for this transaction
      *
@@ -157,30 +124,21 @@ class transaction_options
      *
      * @return the metadata collection, as a @ref transaction_keyspace, if set.
      */
-    std::optional<transaction_keyspace> metadata_collection()
-    {
-        return metadata_collection_;
-    }
+    [[nodiscard]] std::optional<transaction_keyspace> metadata_collection() const;
 
     /** @private */
     transaction_options& test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
-                                        std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
-    {
-        attempt_context_hooks_ = hooks;
-        cleanup_hooks_ = cleanup_hooks;
-        return *this;
-    }
+                                        std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks);
     /** @private */
     [[nodiscard]] transactions_config::built apply(const transactions_config::built& conf) const;
 
   private:
     std::optional<couchbase::durability_level> durability_;
     std::optional<couchbase::query_scan_consistency> scan_consistency_;
-    std::optional<std::chrono::milliseconds> kv_timeout_;
-    std::optional<std::chrono::nanoseconds> expiration_time_;
+    std::optional<std::chrono::nanoseconds> timeout_;
     std::optional<transaction_keyspace> metadata_collection_;
     std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
     std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
 };
-
-} // namespace couchbase::transactions
+} // namespace transactions
+} // namespace couchbase

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

@@ -15,8 +15,6 @@
  */
 #pragma once
 
-// TODO: remove this when moving the wrap_request call
-#include "core/operations/document_query.hxx"
 #include <couchbase/query_options.hxx>
 
 // NOTE: when query is in public api, we will hold a query_options struct instead, and
@@ -57,6 +55,7 @@ class transaction_query_options
         opts_.raw(key, value);
         return *this;
     }
+
     /**
      * Set ad_hoc.
      *
@@ -71,6 +70,7 @@ class transaction_query_options
         opts_.adhoc(value);
         return *this;
     }
+
     /**
      * Set the query_scan_consistency for this query.
      *
@@ -98,6 +98,7 @@ class transaction_query_options
         opts_.profile(mode);
         return *this;
     }
+
     /**
      * Set a client id for this query.
      *
@@ -139,6 +140,7 @@ class transaction_query_options
         opts_.readonly(readonly);
         return *this;
     }
+
     /**
      * Set the scan cap for this query.
      *
@@ -152,6 +154,7 @@ class transaction_query_options
         opts_.scan_cap(cap);
         return *this;
     }
+
     /**
      * Set pipeline_batch size for this query.
      *
@@ -195,6 +198,7 @@ class transaction_query_options
         opts_.positional_parameters(parameters...);
         return *this;
     }
+
     /**
      * Set named parameters for this query.
      *
@@ -210,6 +214,7 @@ class transaction_query_options
         opts_.named_parameters(parameters...);
         return *this;
     }
+
     /**
      * Set metrics for this query.
      *

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

@@ -15,10 +15,11 @@
  */
 #pragma once
 
+#include <couchbase/transactions/transaction_keyspace.hxx>
+
 #include <chrono>
 #include <list>
 
-#include <couchbase/transactions/transaction_keyspace.hxx>
 namespace couchbase::transactions
 {
 /**

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

@@ -1,3 +1,4 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
  *     Copyright 2021-Present Couchbase, Inc.
  *
@@ -15,6 +16,7 @@
  */
 #pragma once
 
+#include <couchbase/durability_level.hxx>
 #include <couchbase/transactions/transaction_keyspace.hxx>
 #include <couchbase/transactions/transactions_cleanup_config.hxx>
 #include <couchbase/transactions/transactions_query_config.hxx>
@@ -77,55 +79,28 @@ class transactions_config
     }
 
     /**
-     * @brief Set kv_timeout
-     *
-     * @see kv_timeout()
-     * @param duration An std::chrono::duration representing the desired default kv operation timeout.
-     * @return reference to this, so calls can be chained.
-     */
-    template<typename T>
-    transactions_config& kv_timeout(T duration)
-    {
-        kv_timeout_ = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
-        return *this;
-    }
-
-    /**
-     * @brief Get kv_timeout
-     *
-     * This is the default kv operation timeout used throughout the transactions.  Note all the operations
-     * have an options class which allows you to override this value for a particular operation, if desired.
-     *
-     * @return The default kv operation timeout.
-     */
-    [[nodiscard]] std::optional<std::chrono::milliseconds> kv_timeout() const
-    {
-        return kv_timeout_;
-    }
-
-    /**
-     * @brief Get expiration time for transactions
+     * @brief Get the timeout for transactions
      *
      * Transactions can conflict (or other operations on those documents), and may retry.
      * This is the maximum time a transaction can take, including any retries.  The transaction will throw
      * an @ref transaction_expired and rollback when this occurs.
      *
-     * @return expiration time for transactions.
+     * @return timeout for transactions.
      */
-    [[nodiscard]] std::chrono::nanoseconds expiration_time() const
+    [[nodiscard]] std::chrono::nanoseconds timeout() const
     {
-        return expiration_time_;
+        return timeout_;
     }
     /**
-     * @brief Set the expiration time for transactions.
+     * @brief Set the timeout for transactions.
      *
      * @param duration desired expiration for transactions.
      * @return reference to this, so calls can be chained.
      */
     template<typename T>
-    transactions_config& expiration_time(T duration)
+    transactions_config& timeout(T duration)
     {
-        expiration_time_ = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
+        timeout_ = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
         return *this;
     }
 
@@ -234,8 +209,7 @@ class transactions_config
     /** @private */
     struct built {
         couchbase::durability_level level;
-        std::chrono::nanoseconds expiration_time;
-        std::optional<std::chrono::milliseconds> kv_timeout;
+        std::chrono::nanoseconds timeout;
         std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks;
         std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks;
         std::optional<couchbase::transactions::transaction_keyspace> metadata_collection;
@@ -248,8 +222,7 @@ class transactions_config
 
   private:
     couchbase::durability_level level_{ couchbase::durability_level::majority };
-    std::chrono::nanoseconds expiration_time_{ std::chrono::seconds(15) };
-    std::optional<std::chrono::milliseconds> kv_timeout_;
+    std::chrono::nanoseconds timeout_{ std::chrono::seconds(15) };
     std::shared_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
     std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
     std::optional<couchbase::transactions::transaction_keyspace> metadata_collection_;

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

@@ -0,0 +1,43 @@
+/* -*- 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 <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct unfreeze_plan_search_index_options : public common_options<unfreeze_plan_search_index_options> {
+  public:
+    struct built : public common_options<unfreeze_plan_search_index_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using unfreeze_plan_search_index_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -70,28 +70,4 @@ struct unlock_options : public common_options<unlock_options> {
  * @uncommitted
  */
 using unlock_handler = std::function<void(couchbase::key_value_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_unlock_operation(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          std::string document_key,
-                          couchbase::cas cas,
-                          couchbase::unlock_options::built options,
-                          couchbase::unlock_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -17,26 +17,55 @@
 
 #pragma once
 
-#include <functional>
+#include <couchbase/common_options.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <cstdint>
 #include <memory>
 #include <optional>
-#include <string>
 
 namespace couchbase
 {
 struct update_collection_options : public common_options<update_collection_options> {
   public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
     struct built : public common_options<update_collection_options>::built {
     };
 
+    /**
+     * Validates the 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() };
     }
 };
 
+/**
+ * The settings that should be updated for the collection
+ */
 struct update_collection_settings {
-    std::optional<std::uint32_t> max_expiry{};
+    /**
+     * The maximum expiry, in seconds, for documents in this collection. Values greater than or equal to -1 are valid.
+     * Value of 0 sets max_expiry to the bucket-level setting and value of -1 to set it as no-expiry.
+     */
+    std::optional<std::int32_t> max_expiry{};
+
+    /**
+     * Whether history retention should be enabled.
+     */
     std::optional<bool> history{};
 };
 

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

@@ -131,28 +131,4 @@ struct upsert_options : public common_durability_options<upsert_options> {
  * @uncommitted
  */
 using upsert_handler = std::function<void(couchbase::key_value_error_context, mutation_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_upsert_operation(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          std::string document_key,
-                          couchbase::codec::encoded_value encoded,
-                          couchbase::upsert_options::built options,
-                          couchbase::upsert_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase