couchbase 3.4.2 → 3.4.4

data/ext/couchbase/couchbase/regexp_query.hxx

@@ -0,0 +1,82 @@
+/* -*- 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 <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * Finds documents containing terms that match the specified regular expression.
+ *
+ * Match documents where field `reviews.content` contains words starting with `"inter"`:
+ * @snippet test_unit_search.cxx search-regexp
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-regexp.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class regexp_query : public search_query
+{
+  public:
+    /**
+     * Create a new regexp query.
+     *
+     * @param regexp the input string to be matched against
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit regexp_query(std::string regexp)
+      : regexp_{ 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) -> regexp_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::string regexp_;
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/remove_options.hxx

@@ -115,8 +115,8 @@ initiate_remove_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string scope_name,
                           std::string collection_name,
                           std::string document_key,
-                          remove_options::built options,
-                          remove_handler&& handler);
+                          couchbase::remove_options::built options,
+                          couchbase::remove_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/replace_options.hxx

@@ -175,9 +175,9 @@ initiate_replace_operation(std::shared_ptr<couchbase::core::cluster> core,
                            std::string scope_name,
                            std::string collection_name,
                            std::string document_key,
-                           codec::encoded_value encoded,
-                           replace_options::built options,
-                           replace_handler&& handler);
+                           couchbase::codec::encoded_value encoded,
+                           couchbase::replace_options::built options,
+                           couchbase::replace_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/scope.hxx

@@ -18,7 +18,10 @@
 #pragma once
 
 #include <couchbase/analytics_options.hxx>
+#include <couchbase/collection.hxx>
 #include <couchbase/query_options.hxx>
+#include <couchbase/search_options.hxx>
+#include <couchbase/search_query.hxx>
 
 #include <memory>
 
@@ -133,6 +136,43 @@ class scope
         return future;
     }
 
+    /**
+     * Performs a query against the full text search services.
+     *
+     * @param index_name name of the search index
+     * @param query query object, see hierarchy of @ref search_query for more details.
+     * @param options options to customize the query request.
+     * @param handler the handler that implements @ref search_handler
+     *
+     * @exception errc::common::ambiguous_timeout
+     * @exception errc::common::unambiguous_timeout
+     *
+     * @see https://docs.couchbase.com/server/current/fts/fts-introduction.html
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void search_query(std::string index_name, const search_query& query, const search_options& options, search_handler&& handler) const;
+
+    /**
+     * Performs a query against the full text search services.
+     *
+     * @param index_name name of the search index
+     * @param query query object, see hierarchy of @ref search_query for more details.
+     * @param options options to customize the query request.
+     * @return future object that carries result of the operation
+     *
+     * @exception errc::common::ambiguous_timeout
+     * @exception errc::common::unambiguous_timeout
+     *
+     * @see https://docs.couchbase.com/server/current/fts/fts-introduction.html
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto search_query(std::string index_name, const class search_query& query, const search_options& options = {}) const
+      -> std::future<std::pair<search_error_context, search_result>>;
+
     /**
      * Performs a query against the analytics services.
      *

data/ext/couchbase/couchbase/search_date_range.hxx

@@ -0,0 +1,68 @@
+/* -*- 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 <chrono>
+#include <cinttypes>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * @since 1.0.0
+ * @committed
+ */
+class search_date_range
+{
+  public:
+    search_date_range(std::string name, std::optional<std::string> start, std::optional<std::string> end, std::uint64_t count)
+      : name_{ std::move(name) }
+      , start_{ std::move(start) }
+      , end_{ std::move(end) }
+      , count_{ count }
+    {
+    }
+
+    [[nodiscard]] auto name() const -> const std::string&
+    {
+        return name_;
+    }
+
+    [[nodiscard]] auto start() const -> const std::optional<std::string>&
+    {
+        return start_;
+    }
+
+    [[nodiscard]] auto end() const -> const std::optional<std::string>&
+    {
+        return end_;
+    }
+
+    [[nodiscard]] auto count() const -> std::uint64_t
+    {
+        return count_;
+    }
+
+  private:
+    std::string name_;
+    std::optional<std::string> start_;
+    std::optional<std::string> end_;
+    std::uint64_t count_;
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/search_error_context.hxx

@@ -0,0 +1,138 @@
+/* -*- 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/error_context.hxx>
+
+#include <cstdint>
+#include <memory>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class internal_search_error_context;
+#endif
+
+/**
+ * The error context returned with Search operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class search_error_context : public error_context
+{
+  public:
+    search_error_context();
+    explicit search_error_context(internal_search_error_context ctx);
+    search_error_context(search_error_context&& other);
+    search_error_context& operator=(search_error_context&& other);
+    search_error_context(const search_error_context& other) = delete;
+    search_error_context& operator=(const search_error_context& other) = delete;
+    ~search_error_context() override;
+
+    /**
+     * Returns status of the operation.
+     *
+     * @see couchbase::errc error codes that might be generated by the library
+     *
+     * @return error code or false-like value for success
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto ec() const -> std::error_code override;
+
+    /**
+     * The hostname/ip where this request got last dispatched to.
+     *
+     * @return address encoded as a string
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto last_dispatched_to() const -> const std::optional<std::string>& override;
+
+    /**
+     * The hostname/ip where this request got last dispatched from.
+     *
+     * @return address encoded as a string
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto last_dispatched_from() const -> const std::optional<std::string>& override;
+
+    /**
+     * The number of times the attached request has been retried.
+     *
+     * @return number of retries.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto retry_attempts() const -> std::size_t override;
+
+    /**
+     * Set of reasons recorded during retrying the operation.
+     *
+     * @return set of reasons (empty if the operation was not retried)
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto retry_reasons() const -> const std::set<retry_reason>& override;
+
+    /**
+     * Check if the operation was retried because of given reason.
+     *
+     * @param reason reason to check
+     * @return true if the reason exists in set of recorded reasons.
+     *
+     * @since 1.0.0
+     * @uncommitted
+     */
+    [[nodiscard]] auto retried_because_of(retry_reason reason) const -> bool override;
+
+    [[nodiscard]] auto index_name() const -> const std::string&;
+
+    [[nodiscard]] auto client_context_id() const -> const std::string&;
+
+    [[nodiscard]] auto query() const -> const std::string&;
+
+    [[nodiscard]] auto parameters() const -> const std::optional<std::string>&;
+
+    [[nodiscard]] auto method() const -> const std::string&;
+
+    [[nodiscard]] auto path() const -> const std::string&;
+
+    [[nodiscard]] auto http_status() const -> std::uint32_t;
+
+    [[nodiscard]] auto http_body() const -> const std::string&;
+
+    [[nodiscard]] auto hostname() const -> const std::string&;
+
+    [[nodiscard]] auto port() const -> std::uint16_t;
+
+    [[nodiscard]] auto error() const -> const std::string&;
+
+    [[nodiscard]] auto status() const -> const std::string&;
+
+  private:
+    std::unique_ptr<internal_search_error_context> internal_;
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/search_facet.hxx

@@ -0,0 +1,60 @@
+/* -*- 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 <cstdint>
+#include <string>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+struct encoded_search_facet;
+#endif
+
+/**
+ * Base class for full text facets of search queries.
+ */
+class search_facet
+{
+  public:
+    virtual ~search_facet() = default;
+
+    /**
+     * @return encoded representation of the search facet.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] virtual auto encode() const -> encoded_search_facet = 0;
+
+  protected:
+    search_facet(std::string field, std::uint32_t size)
+      : field_{ std::move(field) }
+      , size_{ size }
+    {
+    }
+
+    search_facet(std::string field)
+      : field_{ std::move(field) }
+    {
+    }
+
+    std::string field_;
+    std::optional<std::uint32_t> size_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/search_facet_result.hxx

@@ -0,0 +1,50 @@
+/* -*- 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/codec/tao_json_serializer.hxx>
+#include <couchbase/search_meta_data.hxx>
+
+#include "search_row.hxx"
+#include <chrono>
+#include <cinttypes>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * @since 1.0.0
+ * @committed
+ */
+class search_facet_result
+{
+  public:
+    virtual ~search_facet_result() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] virtual auto name() const -> const std::string& = 0;
+    [[nodiscard]] virtual auto field() const -> const std::string& = 0;
+    [[nodiscard]] virtual auto total() const -> std::uint64_t = 0;
+    [[nodiscard]] virtual auto missing() const -> std::uint64_t = 0;
+    [[nodiscard]] virtual auto other() const -> std::uint64_t = 0;
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/search_meta_data.hxx

@@ -0,0 +1,85 @@
+/* -*- 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/codec/json_transcoder.hxx>
+#include <couchbase/search_metrics.hxx>
+
+#include <cinttypes>
+#include <map>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class internal_search_meta_data;
+#endif
+
+/**
+ * Stores any non-rows results related to the execution of a particular N1QL search.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class search_meta_data
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @volatile
+     */
+    explicit search_meta_data(internal_search_meta_data internal);
+
+    /**
+     * Returns the client context identifier string set on the search request.
+     *
+     * @return client context identifier
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto client_context_id() const -> const std::string&;
+    /**
+     * Returns any warnings returned by the search engine.
+     *
+     * It returns an empty vector if no warnings were returned.
+     *
+     * @return vector of the reported warnings.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto errors() const -> const std::map<std::string, std::string>&;
+
+    /**
+     * Returns the {@link search_metrics} as returned by the search engine if enabled.
+     *
+     * @return metrics
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto metrics() const -> const search_metrics&;
+
+  private:
+    std::unique_ptr<internal_search_meta_data> internal_;
+};
+
+} // namespace couchbase

data/ext/couchbase/couchbase/search_metrics.hxx

@@ -0,0 +1,127 @@
+/* -*- 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 <chrono>
+#include <cinttypes>
+
+namespace couchbase
+{
+
+/**
+ * Search Metrics contains the search result metrics containing counts and timings
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class search_metrics
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    search_metrics() = default;
+
+    /**
+     * @since 1.0.0
+     * @volatile
+     */
+    search_metrics(std::chrono::nanoseconds took,
+                   std::uint64_t total_rows,
+                   std::uint64_t success_partition_count,
+                   std::uint64_t error_partition_count,
+                   std::uint64_t total_partition_count,
+                   double max_score)
+      : took_{ took }
+      , total_rows_{ total_rows }
+      , success_partition_count_{ success_partition_count }
+      , error_partition_count_{ error_partition_count }
+      , total_partition_count_{ total_partition_count }
+      , max_score_{ max_score }
+    {
+    }
+
+    /**
+     * The total time taken for the request, that is the time from when the request was received until the results were returned.
+     *
+     * @return total time duration
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto took() const -> std::chrono::nanoseconds
+    {
+        return took_;
+    }
+
+    /**
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto total_rows() const -> std::uint64_t
+    {
+        return total_rows_;
+    }
+
+    /**
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto success_partition_count() const -> std::uint64_t
+    {
+        return success_partition_count_;
+    }
+
+    /**
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto error_partition_count() const -> std::uint64_t
+    {
+        return error_partition_count_;
+    }
+
+    /**
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto total_partition_count() const -> std::uint64_t
+    {
+        return total_partition_count_;
+    }
+
+    /**
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto max_score() const -> double
+    {
+        return max_score_;
+    }
+
+  private:
+    std::chrono::nanoseconds took_{};
+    std::uint64_t total_rows_{};
+    std::uint64_t success_partition_count_{};
+    std::uint64_t error_partition_count_{};
+    std::uint64_t total_partition_count_{};
+    double max_score_{};
+};
+
+} // namespace couchbase