couchbase 4.2.3 → 4.2.5-dev.1

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

@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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/search_query.hxx>
+
+#include <string>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * A doc_id query is a query that directly matches the documents whose ID have been provided. It can be combined within a conjunction_query
+ * to restrict matches on the set of documents.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class doc_id_query : public search_query
+{
+  public:
+    doc_id_query() = default;
+
+    /**
+     * Create a new doc_id query.
+     *
+     * @param ids the list of document IDs to be restricted against.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit doc_id_query(std::vector<std::string> ids)
+      : ids_{ std::move(ids) }
+    {
+    }
+
+    /**
+     * Create a new doc_id query.
+     *
+     * @param ids the list of document IDs to be restricted against.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    doc_id_query(std::initializer_list<std::string> ids)
+    {
+        ids_.reserve(ids.size());
+        doc_ids(ids);
+    }
+
+    /**
+     * Add IDs to the query.
+     *
+     * @param ids  the list of document identifiers to add
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto doc_ids(const std::vector<std::string>& ids) -> doc_id_query&
+    {
+        for (const auto& id : ids) {
+            ids_.push_back(id);
+        }
+        return *this;
+    }
+
+    /**
+     * Add ID to the query.
+     *
+     * @param id  the document identifier to add
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto doc_id(const std::string& id) -> doc_id_query&
+    {
+        ids_.push_back(id);
+        return *this;
+    }
+
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+
+  private:
+    std::vector<std::string> ids_{};
+};
+} // namespace couchbase

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

@@ -43,6 +43,7 @@ class error_context
      * @committed
      */
     error_context() = default;
+    virtual ~error_context() = default;
 
     /**
      * Creates and initializes error context with given parameters.
@@ -56,12 +57,14 @@ class error_context
      * @since 1.0.0
      * @internal
      */
-    error_context(std::error_code ec,
+    error_context(std::string operation_id,
+                  std::error_code ec,
                   std::optional<std::string> last_dispatched_to,
                   std::optional<std::string> last_dispatched_from,
                   std::size_t retry_attempts,
                   std::set<retry_reason> retry_reasons)
-      : ec_{ ec }
+      : operation_id_{ std::move(operation_id) }
+      , ec_{ ec }
       , last_dispatched_to_{ std::move(last_dispatched_to) }
       , last_dispatched_from_{ std::move(last_dispatched_from) }
       , retry_attempts_{ retry_attempts }
@@ -69,6 +72,11 @@ class error_context
     {
     }
 
+    [[nodiscard]] virtual auto operation_id() const -> const std::string&
+    {
+        return operation_id_;
+    }
+
     /**
      * Returns status of the operation.
      *
@@ -79,7 +87,7 @@ class error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto ec() const -> std::error_code
+    [[nodiscard]] virtual auto ec() const -> std::error_code
     {
         return ec_;
     }
@@ -105,7 +113,7 @@ class error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto last_dispatched_to() const -> const std::optional<std::string>&
+    [[nodiscard]] virtual auto last_dispatched_to() const -> const std::optional<std::string>&
     {
         return last_dispatched_to_;
     }
@@ -118,7 +126,7 @@ class error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto last_dispatched_from() const -> const std::optional<std::string>&
+    [[nodiscard]] virtual auto last_dispatched_from() const -> const std::optional<std::string>&
     {
         return last_dispatched_from_;
     }
@@ -131,7 +139,7 @@ class error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto retry_attempts() const -> std::size_t
+    [[nodiscard]] virtual auto retry_attempts() const -> std::size_t
     {
         return retry_attempts_;
     }
@@ -144,7 +152,7 @@ class error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto retry_reasons() const -> const std::set<retry_reason>&
+    [[nodiscard]] virtual auto retry_reasons() const -> const std::set<retry_reason>&
     {
         return retry_reasons_;
     }
@@ -158,12 +166,13 @@ class error_context
      * @since 1.0.0
      * @uncommitted
      */
-    [[nodiscard]] auto retried_because_of(retry_reason reason) const -> bool
+    [[nodiscard]] virtual auto retried_because_of(retry_reason reason) const -> bool
     {
         return retry_reasons_.count(reason) > 0;
     }
 
   private:
+    std::string operation_id_{};
     std::error_code ec_{};
     std::optional<std::string> last_dispatched_to_{};
     std::optional<std::string> last_dispatched_from_{};

package/deps/couchbase-cxx-client/couchbase/fmt/analytics_scan_consistency.hxx

@@ -0,0 +1,52 @@
+/* -*- 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/analytics_scan_consistency.hxx>
+
+#include <fmt/core.h>
+
+/**
+ * Helper for fmtlib to format @ref couchbase::analytics_scan_consistency objects.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+template<>
+struct fmt::formatter<couchbase::analytics_scan_consistency> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::analytics_scan_consistency mode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (mode) {
+            case couchbase::analytics_scan_consistency::not_bounded:
+                name = "not_bounded";
+                break;
+            case couchbase::analytics_scan_consistency::request_plus:
+                name = "request_plus";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-cxx-client/{core/topology/error_map_fmt.hxx → couchbase/fmt/key_value_error_map_attribute.hxx}

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include "error_map.hxx"
+#include <couchbase/key_value_error_map_attribute.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::api::key_value_error_map_attribute> {
+struct fmt::formatter<couchbase::key_value_error_map_attribute> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,62 +30,62 @@ struct fmt::formatter<couchbase::api::key_value_error_map_attribute> {
     }
 
     template<typename FormatContext>
-    auto format(couchbase::api::key_value_error_map_attribute attr, FormatContext& ctx) const
+    auto format(couchbase::key_value_error_map_attribute attr, FormatContext& ctx) const
     {
         string_view name = "unknown";
         switch (attr) {
-            case couchbase::api::key_value_error_map_attribute::success:
+            case couchbase::key_value_error_map_attribute::success:
                 name = "success";
                 break;
-            case couchbase::api::key_value_error_map_attribute::item_only:
+            case couchbase::key_value_error_map_attribute::item_only:
                 name = "item-only";
                 break;
-            case couchbase::api::key_value_error_map_attribute::invalid_input:
+            case couchbase::key_value_error_map_attribute::invalid_input:
                 name = "invalid-input";
                 break;
-            case couchbase::api::key_value_error_map_attribute::fetch_config:
+            case couchbase::key_value_error_map_attribute::fetch_config:
                 name = "fetch-config";
                 break;
-            case couchbase::api::key_value_error_map_attribute::conn_state_invalidated:
+            case couchbase::key_value_error_map_attribute::conn_state_invalidated:
                 name = "conn-state-invalidated";
                 break;
-            case couchbase::api::key_value_error_map_attribute::auth:
+            case couchbase::key_value_error_map_attribute::auth:
                 name = "auth";
                 break;
-            case couchbase::api::key_value_error_map_attribute::special_handling:
+            case couchbase::key_value_error_map_attribute::special_handling:
                 name = "special-handling";
                 break;
-            case couchbase::api::key_value_error_map_attribute::support:
+            case couchbase::key_value_error_map_attribute::support:
                 name = "support";
                 break;
-            case couchbase::api::key_value_error_map_attribute::temp:
+            case couchbase::key_value_error_map_attribute::temp:
                 name = "temp";
                 break;
-            case couchbase::api::key_value_error_map_attribute::internal:
+            case couchbase::key_value_error_map_attribute::internal:
                 name = "internal";
                 break;
-            case couchbase::api::key_value_error_map_attribute::retry_now:
+            case couchbase::key_value_error_map_attribute::retry_now:
                 name = "retry-now";
                 break;
-            case couchbase::api::key_value_error_map_attribute::retry_later:
+            case couchbase::key_value_error_map_attribute::retry_later:
                 name = "retry-later";
                 break;
-            case couchbase::api::key_value_error_map_attribute::subdoc:
+            case couchbase::key_value_error_map_attribute::subdoc:
                 name = "subdoc";
                 break;
-            case couchbase::api::key_value_error_map_attribute::dcp:
+            case couchbase::key_value_error_map_attribute::dcp:
                 name = "dcp";
                 break;
-            case couchbase::api::key_value_error_map_attribute::auto_retry:
+            case couchbase::key_value_error_map_attribute::auto_retry:
                 name = "auto-retry";
                 break;
-            case couchbase::api::key_value_error_map_attribute::item_locked:
+            case couchbase::key_value_error_map_attribute::item_locked:
                 name = "item-locked";
                 break;
-            case couchbase::api::key_value_error_map_attribute::item_deleted:
+            case couchbase::key_value_error_map_attribute::item_deleted:
                 name = "item-deleted";
                 break;
-            case couchbase::api::key_value_error_map_attribute::rate_limit:
+            case couchbase::key_value_error_map_attribute::rate_limit:
                 name = "rate-limit";
                 break;
         }

package/deps/couchbase-cxx-client/couchbase/fmt/search_scan_consistency.hxx

@@ -0,0 +1,49 @@
+/* -*- 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/search_scan_consistency.hxx>
+
+#include <fmt/core.h>
+
+/**
+ * Helper for fmtlib to format @ref couchbase::search_scan_consistency objects.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+template<>
+struct fmt::formatter<couchbase::search_scan_consistency> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::search_scan_consistency mode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (mode) {
+            case couchbase::search_scan_consistency::not_bounded:
+                name = "not_bounded";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

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

@@ -0,0 +1,107 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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/geo_point.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * This query finds all @ref geo_point indexed matches within a given area (identified by the list of @ref geo_point coordinates). Each of
+ * the pairs is taken to indicate one corner of a polygon. Documents are returned if they reference a location within the area of the
+ * polygon.
+ *
+ * The following query-body uses an array of @ref geo_point to specify the latitude and longitude of each of the corners of a polygon, known
+ * as polygon points. Here, the last-specified entry is identical to the initial, thus explicitly closing the box. However, specifying an
+ * explicit closure in this way is optional: the closure will be inferred by the Couchbase Server if not explicitly specified.
+ * @snippet test_unit_search.cxx search-geo-bounding-box
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-geo-bounded-rectangle.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class geo_bounding_box_query : public search_query
+{
+  public:
+    /**
+     * Create a new geo bounding box query.
+     *
+     * @param top_left the top left coordinates signify the bounding box area
+     * @param bottom_right the bottom right coordinates signify the bounding box area
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    geo_bounding_box_query(geo_point top_left, geo_point bottom_right)
+      : top_left_{ top_left }
+      , bottom_right_{ bottom_right }
+    {
+    }
+
+    /**
+     * Create a new geo distance query.
+     *
+     * @param top_left_latitude  latitude of the top left coordinate
+     * @param top_left_longitude  longitude of the top left coordinate
+     * @param bottom_right_latitude  latitude of the bottom right coordinate
+     * @param bottom_right_longitude  latitude of the bottom right coordinate
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    geo_bounding_box_query(double top_left_latitude, double top_left_longitude, double bottom_right_latitude, double bottom_right_longitude)
+      : top_left_{ geo_point{ top_left_latitude, top_left_longitude } }
+      , bottom_right_{ geo_point{ bottom_right_latitude, bottom_right_longitude } }
+    {
+    }
+
+    /**
+     * 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) -> geo_bounding_box_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;
+
+  private:
+    geo_point top_left_;
+    geo_point bottom_right_;
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

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

@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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/geo_point.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * This query finds all matches from a given location as @ref geo_point within the given distance. Both the point and the distance are
+ * required.
+ *
+ * The following query specifies a longitude of `-2.235143` and a latitude of `53.482358`. The target-field `geo` is specified, as is a
+ * distance of `100 miles`: this is the radius within which target-locations must reside for their documents to be returned.
+ * @snippet test_unit_search.cxx search-geo-distance
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-geo-point-distance.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class geo_distance_query : public search_query
+{
+  public:
+    /**
+     * Create a new geo distance query.
+     *
+     * @param location the location represents a point from which the distance is measured.
+     * @param distance the distance describes how far from the location the radius should be matched. For example, `"11km"`,
+     * `"11kilometers"`, `"3nm"`, `"3nauticalmiles"`, `"17mi"`, `"17miles"`, `"19m"`, `"19meters"`.
+     *
+     * @see https://github.com/blevesearch/bleve/blob/ae28975038cb25655da968e3f043210749ba382b/geo/geo_dist.go#L29-L37 list of distance
+     * units.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    geo_distance_query(geo_point location, std::string distance)
+      : location_{ location }
+      , distance_{ std::move(distance) }
+    {
+    }
+
+    /**
+     * Create a new geo distance query.
+     *
+     * @param latitude the location latitude
+     * @param longitude the location longitude
+     * @param distance the distance describes how far from the location the radius should be matched. For example, `"11km"`,
+     * `"11kilometers"`, `"3nm"`, `"3nauticalmiles"`, `"17mi"`, `"17miles"`, `"19m"`, `"19meters"`.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    geo_distance_query(double latitude, double longitude, std::string distance)
+      : location_{ geo_point{ latitude, longitude } }
+      , distance_{ std::move(distance) }
+    {
+    }
+
+    /**
+     * 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) -> geo_distance_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;
+
+  private:
+    geo_point location_;
+    std::string distance_;
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

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

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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
+
+namespace couchbase
+{
+/**
+ * Tuple representing geographical point.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+struct geo_point {
+    double latitude{ 0 };
+    double longitude{ 0 };
+};
+} // namespace couchbase