couchbase 4.3.1 → 4.4.1-dev.1

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

@@ -27,148 +27,153 @@ namespace couchbase
 {
 class tracing_options
 {
-  public:
-    static constexpr std::size_t default_orphaned_sample_size{ 64 };
-    static constexpr std::chrono::milliseconds default_orphaned_emit_interval{ std::chrono::seconds{ 10 } };
-
-    static constexpr std::size_t default_threshold_sample_size{ 64 };
-    static constexpr std::chrono::milliseconds default_threshold_emit_interval{ std::chrono::seconds{ 10 } };
-    static constexpr std::chrono::milliseconds default_key_value_threshold{ 500 };
-    static constexpr std::chrono::milliseconds default_query_threshold{ std::chrono::seconds{ 1 } };
-    static constexpr std::chrono::milliseconds default_view_threshold{ std::chrono::seconds{ 1 } };
-    static constexpr std::chrono::milliseconds default_search_threshold{ std::chrono::seconds{ 1 } };
-    static constexpr std::chrono::milliseconds default_analytics_threshold{ std::chrono::seconds{ 1 } };
-    static constexpr std::chrono::milliseconds default_management_threshold{ std::chrono::seconds{ 1 } };
-    static constexpr std::chrono::milliseconds default_eventing_threshold{ std::chrono::seconds{ 1 } };
-
-    auto enable(bool enable) -> tracing_options&
-    {
-        enabled_ = enable;
-        return *this;
-    }
-
-    auto orphaned_emit_interval(std::chrono::milliseconds interval) -> tracing_options&
-    {
-        orphaned_emit_interval_ = interval;
-        return *this;
-    }
-
-    auto orphaned_sample_size(std::size_t number_or_samples) -> tracing_options&
-    {
-        orphaned_sample_size_ = number_or_samples;
-        return *this;
-    }
-
-    auto threshold_emit_interval(std::chrono::milliseconds interval) -> tracing_options&
-    {
-        threshold_emit_interval_ = interval;
-        return *this;
-    }
-
-    auto threshold_sample_size(std::size_t number_or_samples) -> tracing_options&
-    {
-        threshold_sample_size_ = number_or_samples;
-        return *this;
-    }
-
-    auto key_value_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        key_value_threshold_ = duration;
-        return *this;
-    }
-
-    auto query_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        query_threshold_ = duration;
-        return *this;
-    }
-
-    auto view_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        view_threshold_ = duration;
-        return *this;
-    }
-
-    auto search_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        search_threshold_ = duration;
-        return *this;
-    }
-
-    auto analytics_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        analytics_threshold_ = duration;
-        return *this;
-    }
-
-    auto management_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        management_threshold_ = duration;
-        return *this;
-    }
-
-    auto eventing_threshold(std::chrono::milliseconds duration) -> tracing_options&
-    {
-        eventing_threshold_ = duration;
-        return *this;
-    }
-
-    auto tracer(std::shared_ptr<tracing::request_tracer> custom_tracer) -> tracing_options&
-    {
-        tracer_ = std::move(custom_tracer);
-        return *this;
-    }
-
-    struct built {
-        bool enabled;
-        std::chrono::milliseconds orphaned_emit_interval;
-        std::size_t orphaned_sample_size;
-        std::chrono::milliseconds threshold_emit_interval;
-        std::size_t threshold_sample_size;
-        std::chrono::milliseconds key_value_threshold;
-        std::chrono::milliseconds query_threshold;
-        std::chrono::milliseconds view_threshold;
-        std::chrono::milliseconds search_threshold;
-        std::chrono::milliseconds analytics_threshold;
-        std::chrono::milliseconds management_threshold;
-        std::chrono::milliseconds eventing_threshold;
-        std::shared_ptr<tracing::request_tracer> tracer;
+public:
+  static constexpr std::size_t default_orphaned_sample_size{ 64 };
+  static constexpr std::chrono::milliseconds default_orphaned_emit_interval{ std::chrono::seconds{
+    10 } };
+
+  static constexpr std::size_t default_threshold_sample_size{ 64 };
+  static constexpr std::chrono::milliseconds default_threshold_emit_interval{ std::chrono::seconds{
+    10 } };
+  static constexpr std::chrono::milliseconds default_key_value_threshold{ 500 };
+  static constexpr std::chrono::milliseconds default_query_threshold{ std::chrono::seconds{ 1 } };
+  static constexpr std::chrono::milliseconds default_view_threshold{ std::chrono::seconds{ 1 } };
+  static constexpr std::chrono::milliseconds default_search_threshold{ std::chrono::seconds{ 1 } };
+  static constexpr std::chrono::milliseconds default_analytics_threshold{ std::chrono::seconds{
+    1 } };
+  static constexpr std::chrono::milliseconds default_management_threshold{ std::chrono::seconds{
+    1 } };
+  static constexpr std::chrono::milliseconds default_eventing_threshold{ std::chrono::seconds{
+    1 } };
+
+  auto enable(bool enable) -> tracing_options&
+  {
+    enabled_ = enable;
+    return *this;
+  }
+
+  auto orphaned_emit_interval(std::chrono::milliseconds interval) -> tracing_options&
+  {
+    orphaned_emit_interval_ = interval;
+    return *this;
+  }
+
+  auto orphaned_sample_size(std::size_t number_or_samples) -> tracing_options&
+  {
+    orphaned_sample_size_ = number_or_samples;
+    return *this;
+  }
+
+  auto threshold_emit_interval(std::chrono::milliseconds interval) -> tracing_options&
+  {
+    threshold_emit_interval_ = interval;
+    return *this;
+  }
+
+  auto threshold_sample_size(std::size_t number_or_samples) -> tracing_options&
+  {
+    threshold_sample_size_ = number_or_samples;
+    return *this;
+  }
+
+  auto key_value_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    key_value_threshold_ = duration;
+    return *this;
+  }
+
+  auto query_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    query_threshold_ = duration;
+    return *this;
+  }
+
+  auto view_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    view_threshold_ = duration;
+    return *this;
+  }
+
+  auto search_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    search_threshold_ = duration;
+    return *this;
+  }
+
+  auto analytics_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    analytics_threshold_ = duration;
+    return *this;
+  }
+
+  auto management_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    management_threshold_ = duration;
+    return *this;
+  }
+
+  auto eventing_threshold(std::chrono::milliseconds duration) -> tracing_options&
+  {
+    eventing_threshold_ = duration;
+    return *this;
+  }
+
+  auto tracer(std::shared_ptr<tracing::request_tracer> custom_tracer) -> tracing_options&
+  {
+    tracer_ = std::move(custom_tracer);
+    return *this;
+  }
+
+  struct built {
+    bool enabled;
+    std::chrono::milliseconds orphaned_emit_interval;
+    std::size_t orphaned_sample_size;
+    std::chrono::milliseconds threshold_emit_interval;
+    std::size_t threshold_sample_size;
+    std::chrono::milliseconds key_value_threshold;
+    std::chrono::milliseconds query_threshold;
+    std::chrono::milliseconds view_threshold;
+    std::chrono::milliseconds search_threshold;
+    std::chrono::milliseconds analytics_threshold;
+    std::chrono::milliseconds management_threshold;
+    std::chrono::milliseconds eventing_threshold;
+    std::shared_ptr<tracing::request_tracer> tracer;
+  };
+
+  [[nodiscard]] auto build() const -> built
+  {
+    return {
+      enabled_,
+      orphaned_emit_interval_,
+      orphaned_sample_size_,
+      threshold_emit_interval_,
+      threshold_sample_size_,
+      key_value_threshold_,
+      query_threshold_,
+      view_threshold_,
+      search_threshold_,
+      analytics_threshold_,
+      management_threshold_,
+      eventing_threshold_,
+      tracer_,
     };
-
-    [[nodiscard]] auto build() const -> built
-    {
-        return {
-            enabled_,
-            orphaned_emit_interval_,
-            orphaned_sample_size_,
-            threshold_emit_interval_,
-            threshold_sample_size_,
-            key_value_threshold_,
-            query_threshold_,
-            view_threshold_,
-            search_threshold_,
-            analytics_threshold_,
-            management_threshold_,
-            eventing_threshold_,
-            tracer_,
-        };
-    }
-
-  private:
-    bool enabled_{ true };
-    std::chrono::milliseconds orphaned_emit_interval_{ default_orphaned_emit_interval };
-    std::size_t orphaned_sample_size_{ default_orphaned_sample_size };
-
-    std::chrono::milliseconds threshold_emit_interval_{ default_threshold_emit_interval };
-    std::size_t threshold_sample_size_{ default_threshold_sample_size };
-    std::chrono::milliseconds key_value_threshold_{ default_key_value_threshold };
-    std::chrono::milliseconds query_threshold_{ default_query_threshold };
-    std::chrono::milliseconds view_threshold_{ default_view_threshold };
-    std::chrono::milliseconds search_threshold_{ default_search_threshold };
-    std::chrono::milliseconds analytics_threshold_{ default_analytics_threshold };
-    std::chrono::milliseconds management_threshold_{ default_management_threshold };
-    std::chrono::milliseconds eventing_threshold_{ default_eventing_threshold };
-
-    std::shared_ptr<tracing::request_tracer> tracer_{ nullptr };
+  }
+
+private:
+  bool enabled_{ true };
+  std::chrono::milliseconds orphaned_emit_interval_{ default_orphaned_emit_interval };
+  std::size_t orphaned_sample_size_{ default_orphaned_sample_size };
+
+  std::chrono::milliseconds threshold_emit_interval_{ default_threshold_emit_interval };
+  std::size_t threshold_sample_size_{ default_threshold_sample_size };
+  std::chrono::milliseconds key_value_threshold_{ default_key_value_threshold };
+  std::chrono::milliseconds query_threshold_{ default_query_threshold };
+  std::chrono::milliseconds view_threshold_{ default_view_threshold };
+  std::chrono::milliseconds search_threshold_{ default_search_threshold };
+  std::chrono::milliseconds analytics_threshold_{ default_analytics_threshold };
+  std::chrono::milliseconds management_threshold_{ default_management_threshold };
+  std::chrono::milliseconds eventing_threshold_{ default_eventing_threshold };
+
+  std::shared_ptr<tracing::request_tracer> tracer_{ nullptr };
 };
 } // namespace couchbase

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

@@ -26,135 +26,169 @@ class scope;
 
 namespace transactions
 {
-using async_result_handler = std::function<void(transaction_op_error_context, transaction_get_result)>;
-using async_query_handler = std::function<void(transaction_op_error_context, transaction_query_result)>;
-using async_err_handler = std::function<void(transaction_op_error_context)>;
+using async_result_handler = std::function<void(error, transaction_get_result)>;
+using async_query_handler = std::function<void(error, transaction_query_result)>;
+using async_err_handler = std::function<void(error)>;
 
 /**
  * The async_attempt_context is used for all asynchronous transaction operations
  *
- * In the example below, we get 3 documents in parallel, and update each when the get returns the document:
+ * In the example below, we get 3 documents in parallel, and update each when
+ * the get returns the document:
  *
  * @snippet test/test_transaction_examples.cxx simple-async-txn
  */
 class async_attempt_context
 {
 
-  public:
-    /**
-     * Get 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 async_attempt_context::replace or @ref async_attempt_context::remove
-     *
-     * @param coll The collection which contains the document.
-     * @param id The document id which is used to uniquely identify it.
-     * @param handler The handler which implements @ref async_result_handler
-     */
-    virtual void get(const collection& coll, std::string id, async_result_handler&& handler) = 0;
-    /**
-     * Remove a document from a collection.
-     *
-     * Removes a document from a collection, where the document was gotten from a previous call to @ref async_attempt_context::get
-     *
-     * @param doc The document to remove.
-     * @param handler The handler which implements @ref async_err_handler
-     */
-    virtual void remove(transaction_get_result doc, async_err_handler&& handler) = 0;
+public:
+  /**
+   * Get 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 async_attempt_context::replace
+   * or @ref async_attempt_context::remove
+   *
+   * @param coll The collection which contains the document.
+   * @param id The document id which is used to uniquely identify it.
+   * @param handler The handler which implements @ref async_result_handler
+   */
+  virtual void get(const collection& coll, std::string id, async_result_handler&& handler) = 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 document.
-     * @param coll Collection to insert the document into.
-     * @param id The document id.
-     * @param content The content of the document.
-     * @param handler The handler which implements @ref async_result_handler
-     */
-    template<typename Content>
-    void insert(const collection& coll, std::string id, Content&& content, async_result_handler&& handler)
-    {
-        if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
-            return insert_raw(std::forward<std::vector<std::byte>>(content), std::move(id), content, std::move(handler));
-        } else {
-            // TODO: transcoder support
-            return insert_raw(coll, std::move(id), codec::tao_json_serializer::serialize(content), std::move(handler));
-        }
-    }
-    /**
-     * 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 document
-     * @param doc Document whose content will be replaced.  This is gotten from a call to @ref async_attempt_context::get
-     * @param content New content of the document
-     * @param handler The handler which implements @ref async_result_handler
-     */
-    template<typename Content>
-    void replace(transaction_get_result doc, Content&& content, async_result_handler&& handler)
-    {
-        if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
-            return replace_raw(std::move(doc), std::forward<std::vector<std::byte>>(content), std::move(handler));
-        } else {
-            // TODO: transcoder support
-            return replace_raw(std::move(doc), codec::tao_json_serializer::serialize(content), std::move(handler));
-        }
-    }
-    /**
-     * Perform a query, within a scope.
-     *
-     * Performs a query given a specific scope.   Note that all subsequent transaction operations will be handled by the query service.
-     *
-     * @param scope Scope for the query.
-     * @param statement The query statement
-     * @param opts Options for the query
-     * @param handler Handler which implements @ref async_query_handler.
-     */
-    void query(const scope& scope, std::string statement, transaction_query_options opts, async_query_handler&& handler);
+  /**
+   * 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.
+   * @param handler The handler which implements @ref async_result_handler
+   *
+   * @see network_options::preferred_server_group
+   * @see https://docs.couchbase.com/server/current/manage/manage-groups/manage-groups.html
+   */
+  virtual void get_replica_from_preferred_server_group(const couchbase::collection& coll,
+                                                       const std::string& id,
+                                                       async_result_handler&& handler) = 0;
 
-    /**
-     * Perform a query.
-     *
-     * Performs an unscoped query.
-     *
-     * @param statement The query statement.
-     * @param opts Options for the query.
-     * @param handler Handler which implements @ref async_query_handler.
-     */
-    void query(std::string statement, transaction_query_options opts, async_query_handler&& handler)
-    {
-        return query(statement, opts, {}, std::move(handler));
-    };
-    /**
-     * Perform a query.
-     *
-     * Performs an unscoped query.
-     *
-     * @param statement The query statement.
-     * @param handler Handler which implements @ref async_query_handler
-     */
-    void query(std::string statement, async_query_handler&& handler)
-    {
-        return query(std::move(statement), {}, std::move(handler));
-    }
+  /**
+   * Remove a document from a collection.
+   *
+   * Removes a document from a collection, where the document was gotten from a
+   * previous call to
+   * @ref async_attempt_context::get
+   *
+   * @param doc The document to remove.
+   * @param handler The handler which implements @ref async_err_handler
+   */
+  virtual void remove(transaction_get_result doc, async_err_handler&& handler) = 0;
 
-    virtual ~async_attempt_context() = default;
+  /**
+   * 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 document.
+   * @param coll Collection to insert the document into.
+   * @param id The document id.
+   * @param content The content of the document.
+   * @param handler The handler which implements @ref async_result_handler
+   */
+  template<typename Transcoder = codec::default_json_transcoder,
+           typename Document,
+           std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
+  void insert(const collection& coll,
+              std::string id,
+              Document&& content,
+              async_result_handler&& handler)
+  {
+    return insert_raw(coll, id, Transcoder::encode(content), std::move(handler));
+  }
+  /**
+   * 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 document
+   * @param doc Document whose content will be replaced.  This is gotten from a
+   * call to @ref async_attempt_context::get
+   * @param content New content of the document
+   * @param handler The handler which implements @ref async_result_handler
+   */
+  template<typename Transcoder = codec::default_json_transcoder,
+           typename Document,
+           std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
+  void replace(transaction_get_result doc, Document&& content, async_result_handler&& handler)
+  {
+    return replace_raw(std::move(doc), Transcoder::encode(content), std::move(handler));
+  }
+  /**
+   * Perform a query, within a scope.
+   *
+   * Performs a query given a specific scope.   Note that all subsequent
+   * transaction operations will be handled by the query service.
+   *
+   * @param scope Scope for the query.
+   * @param statement The query statement
+   * @param opts Options for the query
+   * @param handler Handler which implements @ref async_query_handler.
+   */
+  void query(const scope& scope,
+             std::string statement,
+             transaction_query_options opts,
+             async_query_handler&& handler);
 
-  protected:
-    /** @private */
-    virtual void insert_raw(const collection& coll, std::string id, std::vector<std::byte> content, async_result_handler&& handler) = 0;
-    /** @private */
-    virtual void replace_raw(transaction_get_result doc, std::vector<std::byte> content, async_result_handler&& handler) = 0;
-    /** @private */
-    virtual void query(std::string statement,
-                       transaction_query_options opts,
-                       std::optional<std::string> query_context,
-                       async_query_handler&&) = 0;
+  /**
+   * Perform a query.
+   *
+   * Performs an unscoped query.
+   *
+   * @param statement The query statement.
+   * @param opts Options for the query.
+   * @param handler Handler which implements @ref async_query_handler.
+   */
+  void query(std::string statement, transaction_query_options opts, async_query_handler&& handler)
+  {
+    return query(std::move(statement), std::move(opts), {}, std::move(handler));
+  };
+  /**
+   * Perform a query.
+   *
+   * Performs an unscoped query.
+   *
+   * @param statement The query statement.
+   * @param handler Handler which implements @ref async_query_handler
+   */
+  void query(std::string statement, async_query_handler&& handler)
+  {
+    return query(std::move(statement), {}, std::move(handler));
+  }
+
+  virtual ~async_attempt_context() = default;
+
+protected:
+  /** @private */
+  virtual void insert_raw(const collection& coll,
+                          std::string id,
+                          codec::encoded_value content,
+                          async_result_handler&& handler) = 0;
+  /** @private */
+  virtual void replace_raw(transaction_get_result doc,
+                           codec::encoded_value content,
+                           async_result_handler&& handler) = 0;
+  /** @private */
+  virtual void query(std::string statement,
+                     transaction_query_options opts,
+                     std::optional<std::string> query_context,
+                     async_query_handler&&) = 0;
 };
 } // namespace transactions
 } // namespace couchbase