couchbase 3.5.1 → 3.5.2

data/ext/couchbase/couchbase/transactions/attempt_context.hxx

@@ -19,6 +19,8 @@
 #include <couchbase/transactions/transaction_query_options.hxx>
 #include <couchbase/transactions/transaction_query_result.hxx>
 
+#include <stdexcept>
+
 namespace couchbase
 {
 class collection;
@@ -36,111 +38,160 @@ namespace transactions
 
 class attempt_context
 {
-  public:
-    /**
-     * Get a document from a collection.
-     *
-     * Fetch the document contents, in the form of a @ref transaction_get_result.   This can be used in subsequent calls
-     * to @ref attempt_context::replace or @ref attempt_context::remove
-     *
-     * @param coll The collection which contains the document.
-     * @param id The unique id of the document.
-     * @return The result of the operation, which is an @ref transaction_op_error_context and a @ref transaction_get_result.
-     */
-    virtual std::pair<transaction_op_error_context, transaction_get_result> get(const couchbase::collection& coll,
-                                                                                const std::string& id) = 0;
+public:
+  /**
+   * Get a document from a collection.
+   *
+   * Fetch the document contents, in the form of a @ref transaction_get_result.
+   * This can be used in subsequent calls to @ref attempt_context::replace or
+   * @ref attempt_context::remove
+   *
+   * @param coll The collection which contains the document.
+   * @param id The unique id of the document.
+   * @return The result of the operation, which is an @ref error and a @ref
+   * transaction_get_result.
+   */
+  virtual auto get(const couchbase::collection& coll,
+                   const std::string& id) -> std::pair<error, transaction_get_result> = 0;
+
+  /**
+   * Get a document copy from the selected server group.
+   *
+   * Fetch the document contents, in the form of a @ref transaction_get_result.
+   * It might be either replica or active copy of the document. One of the use
+   * cases for this method is to save on network costs by deploying SDK in the
+   * same availability zone as corresponding server group of the nodes.
+   *
+   * @param coll The collection which contains the document.
+   * @param id The unique id of the document.
+   * @return The result of the operation, which is an @ref error and a @ref
+   * transaction_get_result.
+   *
+   * @see network_options::preferred_server_group
+   * @see https://docs.couchbase.com/server/current/manage/manage-groups/manage-groups.html
+   */
+  virtual auto get_replica_from_preferred_server_group(const couchbase::collection& coll,
+                                                       const std::string& id)
+    -> std::pair<error, transaction_get_result> = 0;
 
-    /**
-     * Insert a document into a collection.
-     *
-     * Given an id and the content, this inserts a new document into a collection.   Note that currently this content can be either a
-     * <std::vector<std::byte>> or an object which can be serialized with the @ref codec::tao_json_serializer.
-     *
-     * @tparam Content Type of the contents of the document.
-     * @param coll Collection in which to insert document.
-     * @param id The unique id of the document.
-     * @param content The content of the document.
-     * @return The result of the operation, which is an @ref transaction_op_error_context and a @ref transaction_get_result.
-     */
-    template<typename Content>
-    std::pair<transaction_op_error_context, transaction_get_result> insert(const couchbase::collection& coll,
-                                                                           const std::string& id,
-                                                                           const Content& content)
-    {
-        if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
-            return insert_raw(coll, id, content);
-        } else {
-            return insert_raw(coll, id, codec::tao_json_serializer::serialize(content));
-        }
+  /**
+   * Insert a document into a collection.
+   *
+   * Given an id and the content, this inserts a new document into a collection.
+   * Note that currently this content can be either a <std::vector<std::byte>>
+   * or an object which can be serialized with the @ref
+   * codec::tao_json_serializer.
+   *
+   * @tparam Document Type of the contents of the document.
+   * @param coll Collection in which to insert document.
+   * @param id The unique id of the document.
+   * @param content The content of the document.
+   * @return The result of the operation, which is an @ref error and a @ref
+   * transaction_get_result.
+   */
+  template<typename Transcoder = codec::default_json_transcoder,
+           typename Document,
+           std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
+  auto insert(const couchbase::collection& coll,
+              const std::string& id,
+              const Document& content) -> std::pair<error, transaction_get_result>
+  {
+    codec::encoded_value data;
+    try {
+      data = Transcoder::encode(content);
+    } catch (std::system_error& e) {
+      return { error(e.code(), e.what()), {} };
+    } catch (std::runtime_error& e) {
+      return { error(errc::common::encoding_failure, e.what()), {} };
     }
+    return insert_raw(coll, id, data);
+  }
 
-    /**
-     * Replace the contents of a document in a collection.
-     *
-     * Replaces the contents of an existing document. Note that currently this content can be either a
-     * <std::vector<std::byte>> or an object which can be serialized with the @ref codec::tao_json_serializer.
+  /**
+   * Replace the contents of a document in a collection.
+   *
+   * Replaces the contents of an existing document. Note that currently this
+   content can be either a
+   * <std::vector<std::byte>> or an object which can be serialized with the @ref
+   codec::tao_json_serializer.
 
-     * @tparam Content Type of the contents of the document.
-     * @param doc Document whose content will be replaced.  This is gotten from a call to @ref attempt_context::get
-     * @param content New content of the document.
-     * @return The result of the operation, which is an @ref transaction_op_error_context and a @ref transaction_get_result.
-     */
-    template<typename Content>
-    std::pair<transaction_op_error_context, transaction_get_result> replace(const transaction_get_result& doc, const Content& content)
-    {
-        if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
-            return replace_raw(doc, content);
-        } else {
-            return replace_raw(doc, codec::tao_json_serializer::serialize(content));
-        }
+   * @tparam Content Type of the contents of the document.
+   * @param doc Document whose content will be replaced.  This is gotten from a
+   call to @ref attempt_context::get
+   * @param content New content of the document.
+   * @return The result of the operation, which is an @ref error and a @ref
+   transaction_get_result.
+   */
+  template<typename Transcoder = codec::default_json_transcoder,
+           typename Document,
+           std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
+  auto replace(const transaction_get_result& doc,
+               const Document& content) -> std::pair<error, transaction_get_result>
+  {
+    codec::encoded_value data;
+    try {
+      data = Transcoder::encode(content);
+    } catch (std::system_error& e) {
+      return { error(e.code(), e.what()), {} };
+    } catch (std::runtime_error& e) {
+      return { error(errc::common::encoding_failure, e.what()), {} };
     }
+    return replace_raw(doc, data);
+  }
 
-    /**
-     * Remove a document.
-     *
-     * Removes a document from a collection, where the document was gotten from a previous call to @ref attempt_context::get
-     *
-     * @param doc The document to remove.
-     * @return The result of the operation.
-     */
-    virtual transaction_op_error_context remove(const transaction_get_result& doc) = 0;
+  /**
+   * Remove a document.
+   *
+   * Removes a document from a collection, where the document was gotten from a
+   * previous call to
+   * @ref attempt_context::get
+   *
+   * @param doc The document to remove.
+   * @return The result of the operation.
+   */
+  virtual auto remove(const transaction_get_result& doc) -> error = 0;
 
-    /**
-     * Perform an unscoped query.
-     *
-     * @param statement The query statement.
-     * @param options Options for the query.
-     * @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 = {});
+  /**
+   * Perform an unscoped query.
+   *
+   * @param statement The query statement.
+   * @param options Options for the query.
+   * @return The result of the operation, with is an @ref error and a @ref
+   * transaction_query_result.
+   */
+  auto query(const std::string& statement, const transaction_query_options& options = {})
+    -> std::pair<error, transaction_query_result>;
 
-    /**
-     * Perform a scoped query.
-     *
-     * @param scope Scope for the query.
-     * @param statement The query statement.
-     * @param opts Options for the query.
-     * @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 scope& scope,
-                                                                            const std::string& statement,
-                                                                            const transaction_query_options& opts = {});
+  /**
+   * Perform a scoped query.
+   *
+   * @param scope Scope for the query.
+   * @param statement The query statement.
+   * @param opts Options for the query.
+   * @return The result of the operation, with is an @ref error and a @ref
+   * transaction_query_result.
+   */
+  auto query(const scope& scope,
+             const std::string& statement,
+             const transaction_query_options& opts = {})
+    -> std::pair<error, transaction_query_result>;
 
-    virtual ~attempt_context() = default;
+  virtual ~attempt_context() = default;
 
-  protected:
-    /** @private */
-    virtual std::pair<transaction_op_error_context, transaction_get_result> replace_raw(const transaction_get_result& doc,
-                                                                                        std::vector<std::byte> content) = 0;
-    /** @private */
-    virtual std::pair<transaction_op_error_context, transaction_get_result> insert_raw(const couchbase::collection& coll,
-                                                                                       const std::string& id,
-                                                                                       std::vector<std::byte> content) = 0;
-    /** @private */
-    virtual std::pair<transaction_op_error_context, transaction_query_result> do_public_query(const std::string& statement,
-                                                                                              const transaction_query_options& options,
-                                                                                              std::optional<std::string> query_context) = 0;
+protected:
+  /** @private */
+  virtual auto replace_raw(const transaction_get_result& doc, codec::encoded_value content)
+    -> std::pair<error, transaction_get_result> = 0;
+  /** @private */
+  virtual auto insert_raw(const couchbase::collection& coll,
+                          const std::string& id,
+                          codec::encoded_value document)
+    -> std::pair<error, transaction_get_result> = 0;
+  /** @private */
+  virtual auto do_public_query(const std::string& statement,
+                               const transaction_query_options& options,
+                               std::optional<std::string> query_context)
+    -> std::pair<error, transaction_query_result> = 0;
 };
 } // namespace transactions
 } // namespace couchbase

data/ext/couchbase/couchbase/transactions/transaction_get_result.hxx

@@ -22,11 +22,11 @@
 #include <couchbase/codec/tao_json_serializer.hxx>
 #include <couchbase/collection.hxx>
 #include <couchbase/result.hxx>
-#include <couchbase/transaction_op_error_context.hxx>
 
 // forward declarations...
 namespace couchbase::core::transactions
 {
+class attempt_context_impl;
 class transaction_get_result;
 class transaction_links;
 class document_metadata;
@@ -37,84 +37,56 @@ namespace couchbase::transactions
 
 class transaction_get_result
 {
-    friend class couchbase::core::transactions::transaction_get_result;
-
-  private:
-    std::shared_ptr<couchbase::core::transactions::transaction_get_result> base_{};
-
-    transaction_get_result(std::shared_ptr<couchbase::core::transactions::transaction_get_result> base)
-      : base_(base)
-    {
-    }
-
-  public:
-    /** @private */
-
-    transaction_get_result();
-    /**
-     * Content of the document.
-     *
-     * @return content of the document.
-     */
-    template<typename Content>
-    [[nodiscard]] Content content() const
-    {
-        return codec::tao_json_serializer::deserialize<Content>(content());
-    }
-
-    /**
-     * Content of the document as raw byte vector
-     *
-     * @return content
-     */
-    [[nodiscard]] const std::vector<std::byte>& content() const;
-
-    /**
-     * Copy content into document
-     * @param content
-     */
-    void content(std::vector<std::byte> content);
-
-    /**
-     * Move content into document
-     *
-     * @param content
-     */
-    void content(std::vector<std::byte>&& content);
-
-    /**
-     * Get document id.
-     *
-     * @return the id of this document.
-     */
-    [[nodiscard]] const std::string key() const;
-
-    /**
-     * Get the name of the bucket this document is in.
-     *
-     * @return name of the bucket which contains the document.
-     */
-    [[nodiscard]] const std::string bucket() const;
-
-    /**
-     * Get the name of the scope this document is in.
-     *
-     * @return name of the scope which contains the document.
-     */
-    [[nodiscard]] const std::string scope() const;
-
-    /**
-     * Get the name of the collection this document is in.
-     *
-     * @return name of the collection which contains the document.
-     */
-    [[nodiscard]] const std::string collection() const;
-
-    /**
-     * Get the CAS fot this document
-     *
-     * @return the CAS of the document.
-     */
-    [[nodiscard]] const couchbase::cas cas() const;
+public:
+  /**
+   * @private
+   */
+  transaction_get_result();
+
+  /**
+   * Content of the document.
+   *
+   * @return content of the document.
+   */
+  template<typename Document,
+           typename Transcoder = codec::default_json_transcoder,
+           std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
+           std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+  [[nodiscard]] auto content_as() const -> Document
+  {
+    return Transcoder::template decode<Document>(content());
+  }
+
+  template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
+  [[nodiscard]] auto content_as() const -> typename Transcoder::document_type
+  {
+    return Transcoder::decode(content());
+  }
+
+  /**
+   * Get document id.
+   *
+   * @return the id of this document.
+   */
+  [[nodiscard]] auto id() const -> const std::string&;
+
+private:
+  std::shared_ptr<couchbase::core::transactions::transaction_get_result> base_{};
+
+  explicit transaction_get_result(
+    std::shared_ptr<couchbase::core::transactions::transaction_get_result> base)
+    : base_(std::move(base))
+  {
+  }
+
+  [[nodiscard]] auto content() const -> const codec::encoded_value&;
+
+  friend class couchbase::core::transactions::transaction_get_result;
+  friend class couchbase::core::transactions::attempt_context_impl;
+
+  [[nodiscard]] auto bucket() const -> const std::string&;
+  [[nodiscard]] auto scope() const -> const std::string&;
+  [[nodiscard]] auto collection() const -> const std::string&;
+  [[nodiscard]] auto cas() const -> couchbase::cas;
 };
 } // namespace couchbase::transactions

data/ext/couchbase/couchbase/transactions/transaction_keyspace.hxx

@@ -23,39 +23,43 @@ 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);
+  transaction_keyspace(std::string bucket_name,
+                       std::string scope_name,
+                       std::string collection_name);
 
-    explicit transaction_keyspace(const std::string& bucket_name);
+  explicit transaction_keyspace(const std::string& bucket_name);
 
-    bool operator==(const transaction_keyspace& keyspace) const
-    {
-        return bucket == keyspace.bucket && scope == keyspace.scope && collection == keyspace.collection;
-    }
+  auto operator==(const transaction_keyspace& keyspace) const -> bool
+  {
+    return bucket == keyspace.bucket && scope == keyspace.scope &&
+           collection == keyspace.collection;
+  }
 
-    /**
-     * Check if a keyspace is valid.
-     *
-     * A valid transaction_keyspace must have the bucket, scope, and collection all set.   Note that both the scope and collection default
-     * to _default, but there is no default for the bucket so it must be set.
-     *
-     * @return true if valid.
-     */
-    bool valid();
+  /**
+   * Check if a keyspace is valid.
+   *
+   * A valid transaction_keyspace must have the bucket, scope, and collection all set.   Note that
+   * both the scope and collection default to _default, but there is no default for the bucket so it
+   * must be set.
+   *
+   * @return true if valid.
+   */
+  auto valid() -> bool;
 
-    /** @private */
-    template<typename OStream>
-    friend OStream& operator<<(OStream& os, const transaction_keyspace& keyspace)
-    {
-        os << "transaction_keyspace{";
-        os << "bucket: " << keyspace.bucket;
-        os << ", scope: " << keyspace.scope;
-        os << ", collection: " << keyspace.collection;
-        os << "}";
-        return os;
-    }
+  /** @private */
+  template<typename OStream>
+  friend auto operator<<(OStream& os, const transaction_keyspace& keyspace) -> OStream&
+  {
+    os << "transaction_keyspace{";
+    os << "bucket: " << keyspace.bucket;
+    os << ", scope: " << keyspace.scope;
+    os << ", collection: " << keyspace.collection;
+    os << "}";
+    return os;
+  }
 
-    std::string bucket;
-    std::string scope;
-    std::string collection;
+  std::string bucket;
+  std::string scope;
+  std::string collection;
 };
 } // namespace couchbase::transactions