couchbase 4.2.3 → 4.2.4

package/deps/couchbase-cxx-client/couchbase/conjunction_query.hxx

@@ -0,0 +1,88 @@
+/* -*- 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 <memory>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * The conjunction query is a compound query. The result documents must satisfy all of the child queries. It is possible to recursively nest
+ * compound queries.
+ *
+ * At execution, a conjunction query that has no child queries is not allowed and will fail fast.
+ *
+ * Match documents with `"location"` in the field `reviews.content` and `true` in the field `free_breakfast`.
+ * @snippet test_unit_search.cxx search-conjunction
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-conjuncts-disjuncts.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class conjunction_query : public search_query
+{
+  public:
+    /**
+     * Create a conjunction query.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries sequence of query arguments
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    explicit conjunction_query(SearchQuery&&... queries)
+    {
+        and_also(std::forward<SearchQuery>(queries)...);
+    }
+
+    /**
+     * Add one or more queries to add to the conjunction.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries sequence of query arguments
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    auto and_also(SearchQuery... queries) -> conjunction_query&
+    {
+        (conjuncts_.emplace_back(std::make_shared<SearchQuery>(std::move(queries))), ...);
+        return *this;
+    }
+
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+
+  private:
+    std::vector<std::shared_ptr<search_query>> conjuncts_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/date_range.hxx

@@ -0,0 +1,69 @@
+/* -*- 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 <cstdint>
+#include <ctime>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace couchbase
+{
+/**
+ * Date range for @ref date_range_facet.
+ */
+class date_range
+{
+  public:
+    date_range(std::string name, std::string start, std::string end);
+    date_range(std::string name, std::chrono::system_clock::time_point start, std::chrono::system_clock::time_point end);
+    date_range(std::string name, std::tm start, std::tm end);
+
+    static date_range with_start(std::string name, std::string start);
+    static date_range with_start(std::string name, std::chrono::system_clock::time_point start);
+    static date_range with_start(std::string name, std::tm start);
+
+    static date_range with_end(std::string name, std::string end);
+    static date_range with_end(std::string name, std::chrono::system_clock::time_point end);
+    static date_range with_end(std::string name, std::tm end);
+
+    [[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_;
+    }
+
+  private:
+    date_range(std::string name, std::optional<std::string> start, std::optional<std::string> end);
+
+    std::string name_;
+    std::optional<std::string> start_{};
+    std::optional<std::string> end_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/date_range_facet.hxx

@@ -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.
+ */
+
+#pragma once
+
+#include <couchbase/date_range.hxx>
+#include <couchbase/search_facet.hxx>
+
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * A facet that categorizes rows into dateal ranges (or buckets) provided by the user.
+ */
+class date_range_facet : public search_facet
+{
+  public:
+    date_range_facet(std::string field, std::vector<date_range> ranges)
+      : search_facet{ std::move(field) }
+      , ranges_{ std::move(ranges) }
+    {
+    }
+
+    date_range_facet(std::string field, std::uint32_t size, std::vector<date_range> ranges)
+      : search_facet{ std::move(field), size }
+      , ranges_{ std::move(ranges) }
+    {
+    }
+
+    /**
+     * @return encoded representation of the search facet.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_facet override;
+
+  private:
+    std::vector<date_range> ranges_;
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/date_range_facet_result.hxx

@@ -0,0 +1,55 @@
+/* -*- 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/search_date_range.hxx>
+#include <couchbase/search_facet_result.hxx>
+
+#include <string>
+#include <vector>
+
+namespace couchbase
+{
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class internal_date_range_facet_result;
+#endif
+
+/**
+ * @since 1.0.0
+ * @committed
+ */
+class date_range_facet_result : public search_facet_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    explicit date_range_facet_result(internal_date_range_facet_result internal);
+
+    [[nodiscard]] auto name() const -> const std::string& override;
+    [[nodiscard]] auto field() const -> const std::string& override;
+    [[nodiscard]] auto total() const -> std::uint64_t override;
+    [[nodiscard]] auto missing() const -> std::uint64_t override;
+    [[nodiscard]] auto other() const -> std::uint64_t override;
+    [[nodiscard]] auto date_ranges() const -> const std::vector<search_date_range>&;
+
+  private:
+    std::unique_ptr<internal_date_range_facet_result> internal_;
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/date_range_query.hxx

@@ -0,0 +1,265 @@
+/* -*- 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/match_operator.hxx>
+#include <couchbase/search_query.hxx>
+
+#include <chrono>
+#include <cstdint>
+#include <ctime>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * The date range query finds documents containing a date value in the specified field within the specified range. Either start or end can
+ * be omitted, but not both.
+ *
+ * Match documents where field `review_date` falls within the range ("2001-10-09T10:20:30-08:00", "2016-10-31")
+ * @snippet test_unit_search.cxx search-date-range
+ *
+ * It also works with `std::tm` and `std::chrono::system_clock::time_point`.
+ * @snippet test_unit_search.cxx search-date-range-tm
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-date-range.html server documentation.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class date_range_query : public search_query
+{
+  public:
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  start limit time point
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::chrono::system_clock::time_point value) -> date_range_query&;
+
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value start limit as a `tm` (broken down timestamp)
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::tm value) -> date_range_query&;
+
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  start limit time point
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::chrono::system_clock::time_point value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set lower limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value start limit as a `tm` (broken down timestamp)
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::tm value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set preformatted date as lower limit.
+     *
+     * @param value  start limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::string value) -> date_range_query&
+    {
+        start_ = std::move(value);
+        return *this;
+    }
+
+    /**
+     * Set preformatted date as lower limit.
+     *
+     * @param value  start limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto start(std::string value, bool inclusive) -> date_range_query&
+    {
+        start_ = std::move(value);
+        inclusive_start_ = inclusive;
+        return *this;
+    }
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  end limit time point
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::chrono::system_clock::time_point value) -> date_range_query&;
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value end limit as a `tm` (broken down timestamp)
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::tm value) -> date_range_query&;
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value  end limit time point
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::chrono::system_clock::time_point value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set upper limit and automatically format so that default date_time parser will be able to parse it on the server.
+     *
+     * @param value end limit as a `tm` (broken down timestamp)
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::tm value, bool inclusive) -> date_range_query&;
+
+    /**
+     * Set preformatted date as upper limit.
+     *
+     * @param value  end limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::string value)
+    {
+        end_ = std::move(value);
+        return *this;
+    }
+
+    /**
+     * Set preformatted date as upper limit.
+     *
+     * @param value  end limit formatted as a string, use @ref date_time_parser() for non-standard formats
+     * @param inclusive whether to include limit value into the interval.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto end(std::string value, bool inclusive) -> date_range_query&
+    {
+        end_ = std::move(value);
+        inclusive_end_ = inclusive;
+        return *this;
+    }
+
+    /**
+     * Enable custom date parser.
+     *
+     * @param parser_name name of the custom date parser
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto date_time_parser(std::string parser_name) -> date_range_query&
+    {
+        date_time_parser_ = std::move(parser_name);
+        return *this;
+    }
+
+    /**
+     * 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) -> date_range_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::optional<std::string> start_{};
+    std::optional<std::string> end_{};
+    std::optional<bool> inclusive_start_{};
+    std::optional<bool> inclusive_end_{};
+    std::optional<std::string> date_time_parser_{};
+    std::optional<std::string> field_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/disjunction_query.hxx

@@ -0,0 +1,109 @@
+/* -*- 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 <cstdint>
+#include <memory>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * The disjunction query is a compound query. The result documents must satisfy a configurable minimal (@ref min) number of child queries.
+ * By default this min is set to 1.
+ *
+ * At execution, a conjunction query that has no child queries is not allowed and will fail fast.
+ *
+ * Match documents with at least one (see @ref min) of the following conditions is satisfied:
+ * * `"location"` in the field `reviews.content`
+ * * `true` in the field `free_breakfast`.
+ *
+ * @snippet test_unit_search.cxx search-disjunction
+ *
+ * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-conjuncts-disjuncts.html server documentation
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class disjunction_query : public search_query
+{
+  public:
+    /**
+     * Create a disjunction query.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries sequence of query arguments
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    explicit disjunction_query(SearchQuery&&... queries)
+    {
+        or_else(std::forward<SearchQuery>(queries)...);
+    }
+
+    /**
+     * Add one or more queries to add to the disjunction.
+     *
+     * @tparam SearchQuery any subclass of @ref search_query
+     * @param queries sequence of query arguments
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename... SearchQuery>
+    auto or_else(SearchQuery... queries) -> disjunction_query&
+    {
+        (disjuncts_.emplace_back(std::make_shared<SearchQuery>(std::move(queries))), ...);
+        return *this;
+    }
+
+    /**
+     * Set the minimum number of child queries that must be satisfied for the disjunction query.
+     *
+     * @param number_of_queries minimum number of child queries.
+     *
+     * @return this query for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto min(std::uint32_t number_of_queries) -> disjunction_query&
+    {
+        min_ = number_of_queries;
+        return *this;
+    }
+
+    /**
+     * @return encoded representation of the query.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto encode() const -> encoded_search_query override;
+
+  private:
+    std::vector<std::shared_ptr<search_query>> disjuncts_{};
+    std::uint32_t min_{ 1 };
+};
+} // namespace couchbase