couchbase 3.4.2 → 3.4.4

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

@@ -0,0 +1,100 @@
+/* -*- 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_manager_error_context.hxx"
+
+#include <couchbase/manager_error_context.hxx>
+
+namespace couchbase
+{
+manager_error_context::manager_error_context()
+  : internal_{ nullptr }
+{
+}
+
+manager_error_context::manager_error_context(internal_manager_error_context ctx)
+  : internal_{ std::make_unique<internal_manager_error_context>(std::move(ctx)) }
+{
+}
+
+manager_error_context::manager_error_context(manager_error_context&& other) = default;
+
+manager_error_context&
+manager_error_context::operator=(manager_error_context&& other) = default;
+
+manager_error_context::~manager_error_context() = default;
+
+auto
+manager_error_context::ec() const -> std::error_code
+{
+    return internal_->ec();
+}
+
+auto
+manager_error_context::last_dispatched_from() const -> const std::optional<std::string>&
+{
+    return internal_->last_dispatched_from();
+}
+
+auto
+manager_error_context::last_dispatched_to() const -> const std::optional<std::string>&
+{
+    return internal_->last_dispatched_to();
+}
+
+auto
+manager_error_context::retry_attempts() const -> std::size_t
+{
+    return internal_->retry_attempts();
+}
+
+auto
+manager_error_context::retry_reasons() const -> const std::set<retry_reason>&
+{
+    return internal_->retry_reasons();
+}
+
+auto
+manager_error_context::retried_because_of(couchbase::retry_reason reason) const -> bool
+{
+    return internal_->retried_because_of(reason);
+}
+
+auto
+manager_error_context::path() const -> const std::string&
+{
+    return internal_->path();
+}
+
+auto
+manager_error_context::content() const -> const std::string&
+{
+    return internal_->content();
+}
+
+auto
+manager_error_context::client_context_id() const -> const std::string&
+{
+    return internal_->client_context_id();
+}
+
+auto
+manager_error_context::http_status() const -> std::uint32_t
+{
+    return internal_->http_status();
+}
+} // namespace couchbase

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

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

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

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

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

@@ -0,0 +1,43 @@
+/* -*- 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/match_phrase_query.hxx>
+
+namespace couchbase
+{
+auto
+match_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["match_phrase"] = match_phrase_;
+    if (analyzer_) {
+        built.query["analyzer"] = analyzer_.value();
+    }
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,59 @@
+/* -*- 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/match_query.hxx>
+
+namespace couchbase
+{
+auto
+match_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["match"] = match_;
+    if (prefix_length_) {
+        built.query["prefix_length"] = prefix_length_.value();
+    }
+    if (analyzer_) {
+        built.query["analyzer"] = analyzer_.value();
+    }
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+    if (fuzziness_) {
+        built.query["fuzziness"] = fuzziness_.value();
+    }
+    if (operator_) {
+        switch (operator_.value()) {
+            case match_operator::logical_or:
+                built.query["operator"] = "or";
+                break;
+            case match_operator::logical_and:
+                built.query["operator"] = "and";
+                break;
+        }
+    }
+
+    return built;
+}
+} // namespace couchbase

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

@@ -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.
+ */
+
+#include <couchbase/numeric_range.hxx>
+
+#include <fmt/chrono.h>
+
+namespace couchbase
+{
+numeric_range::numeric_range(std::string name, double min, double max)
+  : name_{ std::move(name) }
+  , min_{ min }
+  , max_{ max }
+{
+}
+
+numeric_range::numeric_range(std::string name, std::optional<double> min, std::optional<double> max)
+  : name_{ std::move(name) }
+  , min_{ min }
+  , max_{ max }
+{
+}
+
+numeric_range
+numeric_range::with_min(std::string name, double start)
+{
+    return { std::move(name), start, {} };
+}
+
+numeric_range
+numeric_range::with_max(std::string name, double end)
+{
+    return { std::move(name), {}, end };
+}
+} // namespace couchbase

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

@@ -0,0 +1,54 @@
+/* -*- 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_facet.hxx"
+
+#include <couchbase/error_codes.hxx>
+#include <couchbase/numeric_range_facet.hxx>
+
+namespace couchbase
+{
+auto
+numeric_range_facet::encode() const -> encoded_search_facet
+{
+    encoded_search_facet built;
+    built.facet = {
+        { "field", field_ },
+    };
+    if (size_) {
+        built.facet["size"] = size_.value();
+    }
+    if (ranges_.empty()) {
+        return { errc::common::invalid_argument };
+    }
+    tao::json::value ranges = tao::json::empty_array;
+    for (const auto& range : ranges_) {
+        tao::json::value entry = {
+            { "field", range.name() },
+        };
+        if (const auto& min = range.min(); min.has_value()) {
+            entry["min"] = min.value();
+        }
+        if (const auto& max = range.max(); max.has_value()) {
+            entry["max"] = max;
+        }
+        ranges.emplace_back(entry);
+    }
+    built.facet["numeric_ranges"] = ranges;
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/numeric_range_facet_result.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_numeric_range_facet_result.hxx"
+
+#include <couchbase/numeric_range_facet_result.hxx>
+
+namespace couchbase
+{
+numeric_range_facet_result::numeric_range_facet_result(internal_numeric_range_facet_result internal)
+  : internal_{ std::make_unique<internal_numeric_range_facet_result>(std::move(internal)) }
+{
+}
+
+auto
+numeric_range_facet_result::name() const -> const std::string&
+{
+    return internal_->name();
+}
+
+auto
+numeric_range_facet_result::field() const -> const std::string&
+{
+    return internal_->field();
+}
+
+auto
+numeric_range_facet_result::total() const -> std::uint64_t
+{
+    return internal_->total();
+}
+
+auto
+numeric_range_facet_result::missing() const -> std::uint64_t
+{
+    return internal_->missing();
+}
+
+auto
+numeric_range_facet_result::other() const -> std::uint64_t
+{
+    return internal_->other();
+}
+
+auto
+numeric_range_facet_result::numeric_ranges() const -> const std::vector<search_numeric_range>&
+{
+    return internal_->numeric_ranges();
+}
+} // namespace couchbase

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

@@ -161,6 +161,7 @@ build_query_request(std::string statement, query_options::built options)
         options.readonly,
         options.flex_index,
         options.preserve_expiry,
+        options.use_replica,
         options.max_parallelism,
         options.scan_cap,
         options.scan_wait,

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

@@ -0,0 +1,75 @@
+/* -*- 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/query_error_context.hxx>
+
+#include <couchbase/fmt/retry_reason.hxx>
+
+#include <tao/json/to_string.hpp>
+
+namespace couchbase
+{
+auto
+query_error_context::to_json() const -> std::string
+{
+    tao::json::value json = {
+        {
+          "ec",
+          tao::json::value{
+            { "value", ec().value() },
+            { "message", ec().message() },
+          },
+        },
+        { "operation_id", operation_id() },
+        { "retry_attempts", retry_attempts() },
+        { "client_context_id", client_context_id_ },
+        { "statement", statement_ },
+        { "method", statement_ },
+        { "path", statement_ },
+        { "http_status", http_status_ },
+        { "http_body", http_body_ },
+        { "hostname", hostname_ },
+        { "port", port_ },
+    };
+
+    if (const auto& val = parameters_; val.has_value()) {
+        json["parameters"] = val.value();
+    }
+    if (first_error_code_ > 0) {
+        json["first_error_code"] = first_error_code_;
+    }
+    if (!first_error_message_.empty()) {
+        json["first_error_message"] = first_error_message_;
+    }
+
+    if (const auto& reasons = retry_reasons(); !reasons.empty()) {
+        tao::json::value reasons_json = tao::json::empty_array;
+        for (const auto& reason : reasons) {
+            reasons_json.emplace_back(fmt::format("{}", reason));
+        }
+        json["retry_reasons"] = reasons_json;
+    }
+    if (const auto& val = last_dispatched_from(); val.has_value()) {
+        json["last_dispatched_from"] = val.value();
+    }
+    if (const auto& val = last_dispatched_to(); val.has_value()) {
+        json["last_dispatched_to"] = val.value();
+    }
+
+    return tao::json::to_string(json, 2);
+}
+} // namespace couchbase