couchbase 3.4.2 → 3.4.4

data/ext/couchbase/couchbase/date_range_query.hxx

@@ -0,0 +1,265 @@
+/* -*- 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/match_operator.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <chrono>
+#include <cstdint>
+#include <ctime>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * The date range query finds documents containing a date value in the specified field within the specified range. Either start or end can
+ * be omitted, but not both.
+ *
+ * Match documents where field `review_date` falls within the range ("2001-10-09T10:20:30-08:00", "2016-10-31")
+ * @snippet test_unit_search.cxx search-date-range
+ *
+ * It also works with `std::tm` and `std::chrono::system_clock::time_point`.
+ * @snippet test_unit_search.cxx search-date-range-tm
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-date-range.html server documentation.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class date_range_query : public search_query
+{
+  public:
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  start limit time point
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::chrono::system_clock::time_point value) -> date_range_query&;
+
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value start limit as a `tm` (broken down timestamp)
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::tm value) -> date_range_query&;
+
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  start limit time point
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::chrono::system_clock::time_point value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value start limit as a `tm` (broken down timestamp)
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::tm value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set preformatted date as lower limit.
+     *
+     * @param value  start limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::string value) -> date_range_query&
+    {
+        start_ = std::move(value);
+        return *this;
+    }
+
+    /**
+     * Set preformatted date as lower limit.
+     *
+     * @param value  start limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::string value, bool inclusive) -> date_range_query&
+    {
+        start_ = std::move(value);
+        inclusive_start_ = inclusive;
+        return *this;
+    }
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  end limit time point
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::chrono::system_clock::time_point value) -> date_range_query&;
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value end limit as a `tm` (broken down timestamp)
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::tm value) -> date_range_query&;
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  end limit time point
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::chrono::system_clock::time_point value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value end limit as a `tm` (broken down timestamp)
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::tm value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set preformatted date as upper limit.
+     *
+     * @param value  end limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::string value)
+    {
+        end_ = std::move(value);
+        return *this;
+    }
+
+    /**
+     * Set preformatted date as upper limit.
+     *
+     * @param value  end limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::string value, bool inclusive) -> date_range_query&
+    {
+        end_ = std::move(value);
+        inclusive_end_ = inclusive;
+        return *this;
+    }
+
+    /**
+     * Enable custom date parser.
+     *
+     * @param parser_name name of the custom date parser
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto date_time_parser(std::string parser_name) -> date_range_query&
+    {
+        date_time_parser_ = std::move(parser_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) -> date_range_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:
+    std::optional<std::string> start_{};
+    std::optional<std::string> end_{};
+    std::optional<bool> inclusive_start_{};
+    std::optional<bool> inclusive_end_{};
+    std::optional<std::string> date_time_parser_{};
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/disjunction_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/search_query.hxx>
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * The disjunction query is a compound query. The result documents must satisfy a configurable minimal (@ref min) number of child queries.
+ * By default this min is set to 1.
+ *
+ * At execution, a conjunction query that has no child queries is not allowed and will fail fast.
+ *
+ * Match documents with at least one (see @ref min) of the following conditions is satisfied:
+ * * `"location"` in the field `reviews.content`
+ * * `true` in the field `free_breakfast`.
+ *
+ * @snippet test_unit_search.cxx search-disjunction
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-conjuncts-disjuncts.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class disjunction_query : public search_query
+{
+  public:
+    /**
+     * Create a disjunction query.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries sequence of query arguments
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    explicit disjunction_query(SearchQuery&&... queries)
+    {
+        or_else(std::forward<SearchQuery>(queries)...);
+    }
+
+    /**
+     * Add one or more queries to add to the disjunction.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries sequence of query arguments
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    auto or_else(SearchQuery... queries) -> disjunction_query&
+    {
+        (disjuncts_.emplace_back(std::make_shared<SearchQuery>(std::move(queries))), ...);
+        return *this;
+    }
+
+    /**
+     * Set the minimum number of child queries that must be satisfied for the disjunction query.
+     *
+     * @param number_of_queries minimum number of child queries.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto min(std::uint32_t number_of_queries) -> disjunction_query&
+    {
+        min_ = number_of_queries;
+        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::shared_ptr<search_query>> disjuncts_{};
+    std::uint32_t min_{ 1 };
+};
+} // namespace couchbase

data/ext/couchbase/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

data/ext/couchbase/couchbase/drop_bucket_options.hxx

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

data/ext/couchbase/couchbase/drop_primary_query_index_options.hxx

@@ -96,34 +96,4 @@ class drop_primary_query_index_options : public common_options<drop_primary_quer
  */
 
 using drop_primary_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                  std::string bucket_name,
-                                  couchbase::drop_primary_query_index_options::built options,
-                                  query_context query_ctx,
-                                  std::string collection_name,
-                                  drop_primary_query_index_handler&& handler);
-
-void
-initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                  std::string bucket_name,
-                                  couchbase::drop_primary_query_index_options::built options,
-                                  drop_primary_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

data/ext/couchbase/couchbase/drop_query_index_options.hxx

@@ -82,35 +82,4 @@ class drop_query_index_options : public common_options<drop_query_index_options>
  */
 
 using drop_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string index_name,
-                          couchbase::drop_query_index_options::built options,
-                          query_context query_ctx,
-                          std::string collection_name,
-                          drop_query_index_handler&& handler);
-void
-initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string index_name,
-                          couchbase::drop_query_index_options::built options,
-                          drop_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

data/ext/couchbase/couchbase/error_codes.hxx

@@ -599,8 +599,7 @@ enum class key_value {
     // KV Code: 0xd6
     cannot_revive_living_document = 131,
 
-    range_scan_cancelled = 132,
-    range_scan_vb_uuid_not_equal = 133,
+    mutation_token_outdated = 133,
     range_scan_completed = 134,
 };
 

data/ext/couchbase/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_{};