couchbase 3.5.1 → 3.5.2

data/ext/couchbase/couchbase/vector_query.hxx

@@ -23,77 +23,97 @@ namespace couchbase
 {
 /**
  * @since 1.0.0
- * @volatile
+ * @committed
  */
 class vector_query
 {
-  public:
-    /**
-     * Creates a vector query
-     *
-     * @param vector_field_name the document field that contains the vector
-     * @param vector_query the vector query to run. Cannot be empty.
-     *
-     * @since 1.0.0
-     * @volatile
-     */
-    vector_query(std::string vector_field_name, std::vector<double> vector_query)
-      : vector_field_name_{ std::move(vector_field_name) }
-      , vector_query_{ std::move(vector_query) }
-    {
-        if (vector_query_.empty()) {
-            throw std::invalid_argument("the vector_query cannot be empty");
-        }
+public:
+  /**
+   * Creates a vector query
+   *
+   * @param vector_field_name the document field that contains the vector
+   * @param vector_query the vector query to run. Cannot be empty.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  vector_query(std::string vector_field_name, std::vector<double> vector_query)
+    : vector_field_name_{ std::move(vector_field_name) }
+    , vector_query_{ std::move(vector_query) }
+  {
+    if (vector_query_.value().empty()) {
+      throw std::invalid_argument("the vector_query cannot be empty");
     }
+  }
 
-    /**
-     * The number of results that will be returned from this vector query. Defaults to 3.
-     *
-     * @param num_candidates the number of results returned
-     *
-     * @return this vector_query for chaining purposes
-     *
-     * @since 1.0.0
-     * @volatile
-     */
-    auto num_candidates(std::uint32_t num_candidates) -> vector_query&
-    {
-        if (num_candidates < 1) {
-            throw std::invalid_argument("The num_candidates cannot be less than 1");
-        }
-        num_candidates_ = num_candidates;
-        return *this;
+  /**
+   * Creates a vector query
+   *
+   * @param vector_field_name the document field that contains the vector
+   * @param base64_vector_query a base64-encoded sequence of little-endian IEEE 754 floats
+   *
+   * @snippet test/test_unit_search.cxx base64-vector-query
+   * @since 1.0.0
+   * @committed
+   */
+  vector_query(std::string vector_field_name, std::string base64_vector_query)
+    : vector_field_name_{ std::move(vector_field_name) }
+    , base64_vector_query_{ std::move(base64_vector_query) }
+  {
+    if (base64_vector_query_.value().empty()) {
+      throw std::invalid_argument("the base64_vector_query cannot be empty");
     }
+  }
 
-    /**
-     * The boost parameter is used to increase the relative weight of a clause (with a boost greater than 1) or decrease the relative weight
-     * (with a boost between 0 and 1).
-     *
-     * @param boost boost value
-     *
-     * @return this vector_query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @volatile
-     */
-    auto boost(double boost) -> vector_query&
-    {
-        boost_ = boost;
-        return *this;
+  /**
+   * The number of results that will be returned from this vector query. Defaults to 3.
+   *
+   * @param num_candidates the number of results returned
+   *
+   * @return this vector_query for chaining purposes
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto num_candidates(std::uint32_t num_candidates) -> vector_query&
+  {
+    if (num_candidates < 1) {
+      throw std::invalid_argument("The num_candidates cannot be less than 1");
     }
+    num_candidates_ = num_candidates;
+    return *this;
+  }
 
-    /**
-     * @return encoded representation of the query.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query;
+  /**
+   * The boost parameter is used to increase the relative weight of a clause (with a boost greater
+   * than 1) or decrease the relative weight (with a boost between 0 and 1).
+   *
+   * @param boost boost value
+   *
+   * @return this vector_query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto boost(double boost) -> vector_query&
+  {
+    boost_ = boost;
+    return *this;
+  }
 
-  private:
-    std::string vector_field_name_;
-    std::vector<double> vector_query_;
-    std::uint32_t num_candidates_{ 3 };
-    std::optional<double> boost_{};
+  /**
+   * @return encoded representation of the query.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query;
+
+private:
+  std::string vector_field_name_;
+  std::uint32_t num_candidates_{ 3 };
+  std::optional<std::vector<double>> vector_query_{};
+  std::optional<std::string> base64_vector_query_{};
+  std::optional<double> boost_{};
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/vector_search.hxx

@@ -26,60 +26,64 @@ namespace couchbase
  * A vector_search allows one or more @ref vector_query to be executed.
  *
  * @since 1.0.0
- * @volatile
+ * @committed
  */
 class vector_search
 {
-  public:
-    /**
-     * Will execute all of the provided vector_queries, using the specified options
-     *
-     * @param vector_queries vector queries to be run
-     * @param options options to use on the vector queries
-     *
-     * @since 1.0.0
-     * @volatile
-     */
-    explicit vector_search(std::vector<vector_query> vector_queries, vector_search_options options = {})
-      : vector_queries_{ std::move(vector_queries) }
-      , options_{ options.build() }
-    {
+public:
+  /**
+   * Will execute all of the provided vector_queries, using the specified options
+   *
+   * @param vector_queries vector queries to be run
+   * @param options options to use on the vector queries
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  explicit vector_search(std::vector<vector_query> vector_queries,
+                         vector_search_options options = {})
+    : vector_queries_{ std::move(vector_queries) }
+    , options_{ options.build() }
+  {
+    if (vector_queries_.empty()) {
+      throw std::invalid_argument("At least one vector query must be specified");
     }
+  }
 
-    /**
-     * Will execute a singe vector_query, using default options
-     *
-     * @param query the query to be run
-     *
-     * @since 1.0.0
-     * @volatile
-     */
-    explicit vector_search(vector_query query)
-      : vector_queries_{ std::vector<vector_query>{ std::move(query) } }
-    {
-    }
+  /**
+   * Will execute a single vector_query, using default options
+   *
+   * @param query the query to be run
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  explicit vector_search(vector_query query)
+    : vector_queries_{ std::vector<vector_query>{ std::move(query) } }
+  {
+  }
 
-    /**
-     * Fetches the vector_search_options
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] vector_search_options::built options() const
-    {
-        return options_;
-    }
+  /**
+   * Fetches the vector_search_options
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] vector_search_options::built options() const
+  {
+    return options_;
+  }
 
-    /**
-     * @return encoded representation of the vector_search.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query;
+  /**
+   * @return encoded representation of the vector_search.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query;
 
-  private:
-    std::vector<vector_query> vector_queries_;
-    vector_search_options::built options_{};
+private:
+  std::vector<vector_query> vector_queries_;
+  vector_search_options::built options_{};
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/vector_search_options.hxx

@@ -19,7 +19,10 @@
 
 namespace couchbase
 {
-enum class vector_query_combination { combination_and, combination_or };
+enum class vector_query_combination {
+  combination_and,
+  combination_or
+};
 
 /**
  * Options related to executing a @ref vector_search
@@ -29,48 +32,49 @@ enum class vector_query_combination { combination_and, combination_or };
  */
 struct vector_search_options {
 
-    /**
-     * Immutable value object representing consistent options
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    struct built {
-        std::optional<vector_query_combination> combination;
-    };
+  /**
+   * Immutable value object representing consistent options
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  struct built {
+    std::optional<vector_query_combination> combination;
+  };
 
-    /**
-     * 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 { combination_ };
-    }
+  /**
+   * 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 { combination_ };
+  }
 
-    /**
-     * Sets how the vector query results are combined.
-     *
-     * @param combination @ref vector_query_combination
-     * @return this for chaining purposes
-     *
-     * @since 1.0.0
-     * @volatile
-     *
-     */
-    auto query_combination(vector_query_combination combination) -> vector_search_options&
-    {
-        combination_ = combination;
-        return *this;
-    }
+  /**
+   * Sets how the vector query results are combined.
+   *
+   * @param combination @ref vector_query_combination
+   * @return this for chaining purposes
+   *
+   * @since 1.0.0
+   * @volatile
+   *
+   */
+  auto query_combination(vector_query_combination combination) -> vector_search_options&
+  {
+    combination_ = combination;
+    return *this;
+  }
 
-  private:
-    std::optional<vector_query_combination> combination_{};
+private:
+  std::optional<vector_query_combination> combination_{};
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/wan_development_configuration_profile.hxx

@@ -27,18 +27,18 @@ namespace couchbase
 {
 class wan_development_configuration_profile : public configuration_profile
 {
-  public:
-    void apply(cluster_options& options) override
-    {
-        auto& timeouts = options.timeouts();
-        timeouts.key_value_timeout(std::chrono::seconds(20));
-        timeouts.key_value_durable_timeout(std::chrono::seconds(20));
-        timeouts.connect_timeout(std::chrono::seconds(20));
-        timeouts.view_timeout(std::chrono::minutes(2));
-        timeouts.query_timeout(std::chrono::minutes(2));
-        timeouts.analytics_timeout(std::chrono::minutes(2));
-        timeouts.search_timeout(std::chrono::minutes(2));
-        timeouts.management_timeout(std::chrono::minutes(2));
-    }
+public:
+  void apply(cluster_options& options) override
+  {
+    auto& timeouts = options.timeouts();
+    timeouts.key_value_timeout(std::chrono::seconds(20));
+    timeouts.key_value_durable_timeout(std::chrono::seconds(20));
+    timeouts.connect_timeout(std::chrono::seconds(20));
+    timeouts.view_timeout(std::chrono::minutes(2));
+    timeouts.query_timeout(std::chrono::minutes(2));
+    timeouts.analytics_timeout(std::chrono::minutes(2));
+    timeouts.search_timeout(std::chrono::minutes(2));
+    timeouts.management_timeout(std::chrono::minutes(2));
+  }
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/watch_query_indexes_options.hxx

@@ -19,7 +19,6 @@
 
 #include <couchbase/common_options.hxx>
 #include <couchbase/error_codes.hxx>
-#include <couchbase/manager_error_context.hxx>
 
 #include <optional>
 #include <string>
@@ -28,49 +27,50 @@ 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();
-    }
+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();
-    }
+  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;
-    };
+  /**
+   * 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_ };
-    }
+  /**
+   * 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 };
+private:
+  bool watch_primary_{ false };
+  std::chrono::milliseconds polling_interval_{ 1000 };
 };
 
 /**
@@ -80,5 +80,5 @@ class watch_query_indexes_options : public common_options<watch_query_indexes_op
  * @uncommitted
  */
 
-using watch_query_indexes_handler = std::function<void(couchbase::manager_error_context)>;
+using watch_query_indexes_handler = std::function<void(error)>;
 } // namespace couchbase

data/ext/couchbase/couchbase/wildcard_query.hxx

@@ -25,59 +25,60 @@
 namespace couchbase
 {
 /**
- * A wildcard query is a query in which term the character `*` will match `0..n` occurrences of any characters and `?` will match `1`
- * occurrence of any character.
+ * A wildcard query is a query in which term the character `*` will match `0..n` occurrences of any
+ * characters and `?` will match `1` occurrence of any character.
  *
  * Match documents where field `reviews.content` contains words starting with `"inter"`:
  * @snippet test_unit_search.cxx search-wildcard
  *
- * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-wildcard.html server documentation
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-wildcard.html server
+ * documentation
  *
  * @since 1.0.0
  * @committed
  */
 class wildcard_query : public search_query
 {
-  public:
-    /**
-     * Create a new wildcard query.
-     *
-     * @param regexp the wildcard-containing term to be analyzed and searched
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    explicit wildcard_query(std::string regexp)
-      : wildcard_{ std::move(regexp) }
-    {
-    }
+public:
+  /**
+   * Create a new wildcard query.
+   *
+   * @param regexp the wildcard-containing term to be analyzed and searched
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  explicit wildcard_query(std::string regexp)
+    : wildcard_{ std::move(regexp) }
+  {
+  }
 
-    /**
-     * If a field is specified, only terms in that field will be matched.
-     *
-     * @param field_name name of the field to be matched
-     *
-     * @return this query for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto field(std::string field_name) -> wildcard_query&
-    {
-        field_ = std::move(field_name);
-        return *this;
-    }
+  /**
+   * If a field is specified, only terms in that field will be matched.
+   *
+   * @param field_name name of the field to be matched
+   *
+   * @return this query for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto field(std::string field_name) -> wildcard_query&
+  {
+    field_ = std::move(field_name);
+    return *this;
+  }
 
-    /**
-     * @return encoded representation of the query.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto encode() const -> encoded_search_query override;
+  /**
+   * @return encoded representation of the query.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto encode() const -> encoded_search_query override;
 
-  private:
-    std::string wildcard_;
-    std::optional<std::string> field_{};
+private:
+  std::string wildcard_;
+  std::optional<std::string> field_{};
 };
 } // namespace couchbase