couchbase 3.4.2 → 3.4.3

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

@@ -0,0 +1,80 @@
+/* -*- 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_term_facet_result.hxx"
+
+namespace couchbase
+{
+
+static std::vector<search_term_range>
+map_ranges(const core::operations::search_response::search_facet& facet)
+{
+    std::vector<search_term_range> ranges;
+    ranges.reserve(facet.terms.size());
+
+    for (const auto& range : facet.terms) {
+        ranges.emplace_back(range.term, range.count);
+    }
+
+    return ranges;
+}
+
+internal_term_facet_result::internal_term_facet_result(const core::operations::search_response::search_facet& facet)
+  : name_{ facet.name }
+  , field_{ facet.field }
+  , total_{ facet.total }
+  , missing_{ facet.missing }
+  , other_{ facet.other }
+  , ranges_{ map_ranges(facet) }
+{
+}
+
+auto
+internal_term_facet_result::name() const -> const std::string&
+{
+    return name_;
+}
+auto
+internal_term_facet_result::field() const -> const std::string&
+{
+    return field_;
+}
+
+auto
+internal_term_facet_result::total() const -> std::uint64_t
+{
+    return total_;
+}
+
+auto
+internal_term_facet_result::missing() const -> std::uint64_t
+{
+    return missing_;
+}
+
+auto
+internal_term_facet_result::other() const -> std::uint64_t
+{
+    return other_;
+}
+
+auto
+internal_term_facet_result::terms() const -> const std::vector<search_term_range>&
+{
+    return ranges_;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/internal_term_facet_result.hxx

@@ -0,0 +1,48 @@
+/* -*- 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 "core/operations/document_search.hxx"
+
+#include <couchbase/search_meta_data.hxx>
+#include <couchbase/search_term_range.hxx>
+
+namespace couchbase
+{
+class internal_term_facet_result
+{
+  public:
+    explicit internal_term_facet_result(const core::operations::search_response::search_facet& facet);
+
+    [[nodiscard]] auto name() const -> const std::string&;
+    [[nodiscard]] auto field() const -> const std::string&;
+    [[nodiscard]] auto total() const -> std::uint64_t;
+    [[nodiscard]] auto missing() const -> std::uint64_t;
+    [[nodiscard]] auto other() const -> std::uint64_t;
+    [[nodiscard]] auto terms() const -> const std::vector<search_term_range>&;
+
+  private:
+    std::string name_;
+    std::string field_;
+    std::uint64_t total_{};
+    std::uint64_t missing_{};
+    std::uint64_t other_{};
+    std::vector<search_term_range> ranges_;
+};
+
+} // 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_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