couchbase 3.4.1 → 3.4.3

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

@@ -0,0 +1,56 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/numeric_range_query.hxx>
+
+#include <couchbase/error_codes.hxx>
+
+namespace couchbase
+{
+auto
+numeric_range_query::encode() const -> encoded_search_query
+{
+    if (!min_ && !max_) {
+        return { errc::common::invalid_argument };
+    }
+
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+    if (min_.has_value()) {
+        built.query["min"] = min_.value();
+        if (inclusive_min_.has_value()) {
+            built.query["inclusive_min"] = inclusive_min_.value();
+        }
+    }
+    if (max_.has_value()) {
+        built.query["max"] = max_.value();
+        if (inclusive_max_.has_value()) {
+            built.query["inclusive_max"] = inclusive_max_.value();
+        }
+    }
+
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,42 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/phrase_query.hxx>
+
+#include <tao/json/contrib/traits.hpp>
+
+namespace couchbase
+{
+auto
+phrase_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+
+    built.query["terms"] = terms_;
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,40 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/prefix_query.hxx>
+
+namespace couchbase
+{
+auto
+prefix_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+
+    built.query["prefix"] = prefix_;
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    return built;
+}
+} // namespace couchbase

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

@@ -152,10 +152,10 @@ build_result(operations::query_response& resp)
 }
 
 static core::operations::query_request
-build_query_request(query_options::built options)
+build_query_request(std::string statement, query_options::built options)
 {
     operations::query_request request{
-        "",
+        std::move(statement),
         options.adhoc,
         options.metrics,
         options.readonly,
@@ -222,8 +222,9 @@ build_transaction_query_result(operations::query_response resp, std::error_code
 core::operations::query_request
 build_transaction_query_request(query_options::built opts)
 {
-    return build_query_request(opts);
+    return build_query_request("", opts);
 }
+
 void
 initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string statement,
@@ -231,8 +232,7 @@ initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          query_options::built options,
                          query_handler&& handler)
 {
-    auto request = build_query_request(options);
-    request.statement = std::move(statement);
+    auto request = build_query_request(std::move(statement), options);
     if (query_context) {
         request.query_context = std::move(query_context);
     }

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

@@ -0,0 +1,37 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/query_string_query.hxx>
+
+namespace couchbase
+{
+auto
+query_string_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    built.query["query"] = query_;
+
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,40 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/regexp_query.hxx>
+
+namespace couchbase
+{
+auto
+regexp_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+
+    built.query["regexp"] = regexp_;
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    return built;
+}
+} // namespace couchbase

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