couchbase 3.4.2 → 3.4.3

data/ext/couchbase/core/impl/search.cxx

@@ -0,0 +1,191 @@
+/* -*- 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.
+ */
+
+#include <couchbase/cluster.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/scope.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/document_search.hxx"
+#include "core/utils/json.hxx"
+#include "encoded_search_facet.hxx"
+#include "encoded_search_query.hxx"
+#include "encoded_search_sort.hxx"
+#include "internal_date_range_facet_result.hxx"
+#include "internal_numeric_range_facet_result.hxx"
+#include "internal_search_error_context.hxx"
+#include "internal_search_meta_data.hxx"
+#include "internal_search_result.hxx"
+#include "internal_search_row.hxx"
+#include "internal_search_row_location.hxx"
+#include "internal_search_row_locations.hxx"
+#include "internal_term_facet_result.hxx"
+
+namespace couchbase
+{
+static std::optional<core::search_highlight_style>
+map_highlight_style(const std::optional<couchbase::highlight_style>& style)
+{
+    if (style) {
+        switch (style.value()) {
+            case highlight_style::html:
+                return core::search_highlight_style::html;
+            case highlight_style::ansi:
+                return core::search_highlight_style::ansi;
+        }
+    }
+    return {};
+}
+
+static std::optional<core::search_scan_consistency>
+map_scan_consistency(const std::optional<couchbase::search_scan_consistency>& scan_consistency)
+{
+    if (scan_consistency == search_scan_consistency::not_bounded) {
+        return core::search_scan_consistency::not_bounded;
+    }
+    return {};
+}
+
+static std::vector<std::string>
+map_sort(const std::vector<std::shared_ptr<search_sort>>& sort, const std::vector<std::string>& sort_string)
+{
+    std::vector<std::string> sort_specs{};
+    sort_specs.reserve(sort.size() + sort_string.size());
+
+    for (const auto& s : sort) {
+        auto encoded = s->encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode search sort object");
+        }
+        sort_specs.emplace_back(core::utils::json::generate(encoded.sort));
+    }
+
+    for (const auto& s : sort_string) {
+        sort_specs.emplace_back(core::utils::json::generate(s));
+    }
+
+    return sort_specs;
+}
+
+static std::map<std::string, std::string>
+map_facets(const std::map<std::string, std::shared_ptr<search_facet>, std::less<>>& facets)
+{
+    std::map<std::string, std::string> core_facets{};
+
+    for (const auto& [name, f] : facets) {
+        auto encoded = f->encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode search facet object in request");
+        }
+        core_facets[name] = core::utils::json::generate(encoded.facet);
+    }
+
+    return core_facets;
+}
+
+static std::map<std::string, couchbase::core::json_string>
+map_raw(std::map<std::string, codec::binary, std::less<>>& raw)
+{
+    std::map<std::string, couchbase::core::json_string> core_raw{};
+    for (const auto& [name, value] : raw) {
+        core_raw[name] = value;
+    }
+    return core_raw;
+}
+
+static core::operations::search_request
+build_search_request(std::string index_name,
+                     const search_query& query,
+                     search_options::built options,
+                     std::optional<std::string> /* bucket_name */,
+                     std::optional<std::string> /* scope_name */)
+{
+    auto encoded = query.encode();
+    if (encoded.ec) {
+        throw std::system_error(encoded.ec, fmt::format("unable to encode search query for index \"{}\"", index_name));
+    }
+    core::operations::search_request request{
+        std::move(index_name),
+        core::utils::json::generate_binary(encoded.query),
+        options.limit,
+        options.skip,
+        options.explain,
+        options.disable_scoring,
+        options.include_locations,
+        map_highlight_style(options.highlight_style),
+        options.highlight_fields,
+        options.fields,
+        options.collections,
+        map_scan_consistency(options.scan_consistency),
+        options.mutation_state,
+        map_sort(options.sort, options.sort_string),
+        map_facets(options.facets),
+        map_raw(options.raw),
+        {},
+        options.client_context_id,
+        options.timeout,
+    };
+    return request;
+}
+
+void
+cluster::search_query(std::string index_name,
+                      const class search_query& query,
+                      const search_options& options,
+                      search_handler&& handler) const
+{
+    auto request = build_search_request(std::move(index_name), query, options.build(), {}, {});
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::search_response resp) mutable {
+        handler(search_error_context{ internal_search_error_context{ resp } }, search_result{ internal_search_result{ resp } });
+    });
+}
+
+auto
+cluster::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>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<search_error_context, search_result>>>();
+    search_query(std::move(index_name), query, options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
+
+void
+scope::search_query(std::string index_name, const class search_query& query, const search_options& options, search_handler&& handler) const
+{
+    auto request = build_search_request(std::move(index_name), query, options.build(), bucket_name_, name_);
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::search_response resp) mutable {
+        return handler(search_error_context{ internal_search_error_context{ resp } }, search_result{ internal_search_result{ resp } });
+    });
+}
+
+auto
+scope::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>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<search_error_context, search_result>>>();
+    auto future = barrier->get_future();
+    search_query(std::move(index_name), query, options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+} // namespace couchbase

data/ext/couchbase/core/impl/search_error_context.cxx

@@ -0,0 +1,147 @@
+/* -*- 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.
+ */
+
+#include "internal_search_error_context.hxx"
+
+#include <couchbase/search_error_context.hxx>
+
+namespace couchbase
+{
+search_error_context::search_error_context()
+  : internal_{ nullptr }
+{
+}
+
+search_error_context::search_error_context(internal_search_error_context ctx)
+  : internal_{ std::make_unique<internal_search_error_context>(std::move(ctx)) }
+{
+}
+
+search_error_context::search_error_context(search_error_context&& other) = default;
+
+search_error_context&
+search_error_context::operator=(search_error_context&& other) = default;
+
+search_error_context::~search_error_context() = default;
+
+auto
+search_error_context::ec() const -> std::error_code
+{
+    return internal_->ec();
+}
+
+auto
+search_error_context::last_dispatched_to() const -> const std::optional<std::string>&
+{
+    return internal_->last_dispatched_to();
+}
+
+auto
+search_error_context::last_dispatched_from() const -> const std::optional<std::string>&
+{
+    return internal_->last_dispatched_from();
+}
+
+auto
+search_error_context::retry_attempts() const -> std::size_t
+{
+    return internal_->retry_attempts();
+}
+
+auto
+search_error_context::retry_reasons() const -> const std::set<retry_reason>&
+{
+    return internal_->retry_reasons();
+}
+
+auto
+search_error_context::retried_because_of(retry_reason reason) const -> bool
+{
+    return internal_->retried_because_of(reason);
+}
+
+auto
+search_error_context::index_name() const -> const std::string&
+{
+    return internal_->index_name();
+}
+
+auto
+search_error_context::client_context_id() const -> const std::string&
+{
+    return internal_->client_context_id();
+}
+
+auto
+search_error_context::query() const -> const std::string&
+{
+    return internal_->query();
+}
+
+auto
+search_error_context::parameters() const -> const std::optional<std::string>&
+{
+    return internal_->parameters();
+}
+
+auto
+search_error_context::method() const -> const std::string&
+{
+    return internal_->method();
+}
+
+auto
+search_error_context::path() const -> const std::string&
+{
+    return internal_->path();
+}
+
+auto
+search_error_context::http_status() const -> std::uint32_t
+{
+    return internal_->http_status();
+}
+
+auto
+search_error_context::http_body() const -> const std::string&
+{
+    return internal_->http_body();
+}
+
+auto
+search_error_context::hostname() const -> const std::string&
+{
+    return internal_->hostname();
+}
+
+auto
+search_error_context::port() const -> std::uint16_t
+{
+    return internal_->port();
+}
+auto
+search_error_context::error() const -> const std::string&
+{
+    return internal_->error();
+}
+
+auto
+search_error_context::status() const -> const std::string&
+{
+    return internal_->status();
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_meta_data.cxx

@@ -0,0 +1,46 @@
+/* -*- 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.
+ */
+
+#include "internal_search_meta_data.hxx"
+
+#include <couchbase/search_meta_data.hxx>
+
+namespace couchbase
+{
+search_meta_data::search_meta_data(internal_search_meta_data internal)
+  : internal_{ std::make_unique<internal_search_meta_data>(std::move(internal)) }
+{
+}
+
+auto
+search_meta_data::client_context_id() const -> const std::string&
+{
+    return internal_->client_context_id();
+}
+
+auto
+search_meta_data::errors() const -> const std::map<std::string, std::string>&
+{
+    return internal_->errors();
+}
+
+auto
+search_meta_data::metrics() const -> const search_metrics&
+{
+    return internal_->metrics();
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_result.cxx

@@ -0,0 +1,66 @@
+/* -*- 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.
+ */
+
+#include "internal_search_result.hxx"
+
+#include "internal_date_range_facet_result.hxx"
+#include "internal_numeric_range_facet_result.hxx"
+#include "internal_search_meta_data.hxx"
+#include "internal_search_row.hxx"
+#include "internal_search_row_location.hxx"
+#include "internal_search_row_locations.hxx"
+#include "internal_term_facet_result.hxx"
+
+#include <couchbase/search_result.hxx>
+
+namespace couchbase
+{
+search_result::search_result()
+  : internal_{ nullptr }
+{
+}
+
+search_result::search_result(internal_search_result internal)
+  : internal_{ std::make_unique<internal_search_result>(std::move(internal)) }
+{
+}
+
+search_result::~search_result() = default;
+
+search_result&
+search_result::operator=(search_result&&) noexcept = default;
+
+search_result::search_result(search_result&&) noexcept = default;
+
+auto
+search_result::meta_data() const -> const search_meta_data&
+{
+    return internal_->meta_data();
+}
+
+auto
+search_result::rows() const -> const std::vector<search_row>&
+{
+    return internal_->rows();
+}
+
+auto
+search_result::facets() const -> const std::map<std::string, std::shared_ptr<search_facet_result>>&
+{
+    return internal_->facets();
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_row.cxx

@@ -0,0 +1,74 @@
+/* -*- 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.
+ */
+
+#include "internal_search_row.hxx"
+
+#include "internal_search_row_location.hxx"
+#include "internal_search_row_locations.hxx"
+
+#include <couchbase/search_row.hxx>
+
+namespace couchbase
+{
+search_row::search_row(internal_search_row internal)
+  : internal_{ std::make_unique<internal_search_row>(std::move(internal)) }
+
+{
+}
+
+auto
+search_row::index() const -> const std::string&
+{
+    return internal_->index();
+}
+
+auto
+search_row::id() const -> const std::string&
+{
+    return internal_->id();
+}
+
+auto
+search_row::score() const -> double
+{
+    return internal_->score();
+}
+
+auto
+search_row::fields() const -> const codec::binary&
+{
+    return internal_->fields();
+}
+
+auto
+search_row::explanation() const -> const codec::binary&
+{
+    return internal_->explanation();
+}
+
+auto
+search_row::locations() const -> const std::optional<search_row_locations>&
+{
+    return internal_->locations();
+}
+
+auto
+search_row::fragments() const -> const std::map<std::string, std::vector<std::string>>&
+{
+    return internal_->fragments();
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_row_location.cxx

@@ -0,0 +1,64 @@
+/* -*- 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.
+ */
+
+#include "internal_search_row_location.hxx"
+
+#include <couchbase/search_row_location.hxx>
+
+namespace couchbase
+{
+search_row_location::search_row_location(internal_search_row_location internal)
+  : internal_{ std::make_unique<internal_search_row_location>(std::move(internal)) }
+{
+}
+
+auto
+search_row_location::field() const -> const std::string&
+{
+    return internal_->location.field;
+}
+
+auto
+search_row_location::term() const -> const std::string&
+{
+    return internal_->location.term;
+}
+
+auto
+search_row_location::position() const -> const std::uint64_t&
+{
+    return internal_->location.position;
+}
+
+auto
+search_row_location::start_offset() const -> const std::uint64_t&
+{
+    return internal_->location.start_offset;
+}
+
+auto
+search_row_location::end_offset() const -> const std::uint64_t&
+{
+    return internal_->location.end_offset;
+}
+
+auto
+search_row_location::array_positions() const -> const std::optional<std::vector<std::uint64_t>>&
+{
+    return internal_->location.array_positions;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_row_locations.cxx

@@ -0,0 +1,66 @@
+/* -*- 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.
+ */
+
+#include "internal_search_row_locations.hxx"
+
+#include "internal_search_row_location.hxx"
+
+#include <couchbase/search_row_locations.hxx>
+
+namespace couchbase
+{
+search_row_locations::search_row_locations(internal_search_row_locations internal)
+  : internal_{ std::make_unique<internal_search_row_locations>(std::move(internal)) }
+{
+}
+
+auto
+search_row_locations::get(const std::string& field) const -> std::vector<search_row_location>
+{
+    return internal_->get(field);
+}
+
+auto
+search_row_locations::get(const std::string& field, const std::string& term) const -> std::vector<search_row_location>
+{
+    return internal_->get(field, term);
+}
+
+auto
+search_row_locations::get_all() const -> std::vector<search_row_location>
+{
+    return internal_->get_all();
+}
+
+auto
+search_row_locations::fields() const -> std::vector<std::string>
+{
+    return internal_->fields();
+}
+
+auto
+search_row_locations::terms() const -> std::set<std::string>
+{
+    return internal_->terms();
+}
+
+auto
+search_row_locations::terms_for(const std::string& field) const -> std::vector<std::string>
+{
+    return internal_->terms_for(field);
+}
+} // namespace couchbase