couchbase 3.4.1 → 3.4.2

data/ext/couchbase/couchbase/analytics_result.hxx

@@ -0,0 +1,102 @@
+/* -*- 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/analytics_meta_data.hxx>
+#include <couchbase/codec/tao_json_serializer.hxx>
+
+#include <chrono>
+#include <cinttypes>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+
+/**
+ * Represents result of @ref cluster#analytics_query() and @ref scope#analytics_query() calls.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class analytics_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    analytics_result() = default;
+
+    /**
+     * @since 1.0.0
+     * @volatile
+     */
+    analytics_result(analytics_meta_data meta_data, std::vector<codec::binary> rows)
+      : meta_data_{ std::move(meta_data) }
+      , rows_{ std::move(rows) }
+    {
+    }
+
+    /**
+     * Returns the {@link analytics_meta_data} giving access to the additional metadata associated with this analytics query.
+     *
+     * @return response metadata
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto meta_data() const -> const analytics_meta_data&
+    {
+        return meta_data_;
+    }
+
+    /**
+     * @return list of analytics results as binary strings
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto rows_as_binary() const -> const std::vector<codec::binary>&
+    {
+        return rows_;
+    }
+
+    template<typename Serializer,
+             typename Document = typename Serializer::document_type,
+             std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
+    [[nodiscard]] auto rows_as() const -> std::vector<Document>
+    {
+        std::vector<Document> rows;
+        rows.reserve(rows_.size());
+        for (const auto& row : rows_) {
+            rows.emplace_back(Serializer::template deserialize<Document>(row));
+        }
+        return rows;
+    }
+
+    [[nodiscard]] auto rows_as_json() const -> std::vector<codec::tao_json_serializer::document_type>
+    {
+        return rows_as<codec::tao_json_serializer>();
+    }
+
+  private:
+    analytics_meta_data meta_data_{};
+    std::vector<codec::binary> rows_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/analytics_scan_consistency.hxx

@@ -0,0 +1,46 @@
+/* -*- 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
+
+namespace couchbase
+{
+enum class analytics_scan_consistency {
+    /**
+     * The indexer will return whatever state it has to the query engine at the time of query.
+     *
+     * This is the default (for single-statement requests). No timestamp vector is used in the index scan. This is also the fastest mode,
+     * because we avoid the cost of obtaining the vector, and we also avoid any wait for the index to catch up to the vector.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    not_bounded = 0,
+
+    /**
+     * The indexer will wait until all mutations have been processed at the time of request before returning to the query engine.
+     *
+     * This implements strong consistency per request. Before processing the request, a current vector is obtained. The vector is used as a
+     * lower bound for the statements in the request. If there are DML statements in the request, RYOW ("read your own write") is also
+     * applied within the request.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    request_plus,
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/analytics_status.hxx

@@ -0,0 +1,41 @@
+/* -*- 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
+
+namespace couchbase
+{
+/**
+ * Status of the Analytics Query
+ *
+ * @since 1.0.0
+ * @committed
+ */
+enum class analytics_status {
+    running,
+    success,
+    errors,
+    completed,
+    stopped,
+    timeout,
+    closed,
+    fatal,
+    aborted,
+    unknown,
+};
+
+} // namespace couchbase

data/ext/couchbase/couchbase/analytics_warning.hxx

@@ -0,0 +1,85 @@
+/* -*- 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 <cstdint>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+
+/**
+ * Represents a single warning returned from the analytics engine.
+ *
+ * @note warnings are not terminal errors but hints from the engine that something was not as expected.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class analytics_warning
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    analytics_warning() = default;
+
+    /**
+     * @since 1.0.0
+     * @volatile
+     */
+    analytics_warning(std::uint64_t code, std::string message)
+      : code_{ code }
+      , message_{ std::move(message) }
+    {
+    }
+
+    /**
+     * Error code.
+     *
+     * @return error code
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto code() const -> std::uint64_t
+    {
+        return code_;
+    }
+
+    /**
+     * Error message.
+     *
+     * @return human readable explanation
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto message() const -> const std::string&
+    {
+        return message_;
+    }
+
+  private:
+    std::uint64_t code_{};
+    std::string message_{};
+};
+
+} // namespace couchbase

data/ext/couchbase/couchbase/cluster.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <couchbase/analytics_options.hxx>
 #include <couchbase/bucket.hxx>
 #include <couchbase/cluster_options.hxx>
 #include <couchbase/query_index_manager.hxx>
@@ -165,6 +166,38 @@ class cluster
         return future;
     }
 
+    /**
+     * Performs a query against the analytics services.
+     *
+     * @param statement the query statement.
+     * @param options options to customize the query request.
+     * @param handler the handler that implements @ref query_handler
+     *
+     * @exception errc::common::ambiguous_timeout
+     * @exception errc::common::unambiguous_timeout
+     *
+     * @see https://docs.couchbase.com/server/current/analytics/introduction.html
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const;
+
+    /**
+     * Performs a query against the analytics services.
+     *
+     * @param statement the query statement.
+     * @param options options to customize the query request.
+     * @return future object that carries result of the operation
+     *
+     * @see https://docs.couchbase.com/server/current/analytics/introduction.html
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto analytics_query(std::string statement, const analytics_options& options = {}) const
+      -> std::future<std::pair<analytics_error_context, analytics_result>>;
+
     /**
      * Provides access to the N1QL index management services.
      *

data/ext/couchbase/couchbase/fmt/analytics_status.hxx

@@ -0,0 +1,76 @@
+/* -*- 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/analytics_status.hxx>
+
+#include <fmt/core.h>
+
+/**
+ * Helper for fmtlib to format @ref couchbase::analytics_status objects.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+template<>
+struct fmt::formatter<couchbase::analytics_status> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::analytics_status status, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (status) {
+            case couchbase::analytics_status::running:
+                name = "running";
+                break;
+            case couchbase::analytics_status::success:
+                name = "success";
+                break;
+            case couchbase::analytics_status::errors:
+                name = "errors";
+                break;
+            case couchbase::analytics_status::completed:
+                name = "completed";
+                break;
+            case couchbase::analytics_status::stopped:
+                name = "stopped";
+                break;
+            case couchbase::analytics_status::timeout:
+                name = "timeout";
+                break;
+            case couchbase::analytics_status::closed:
+                name = "closed";
+                break;
+            case couchbase::analytics_status::fatal:
+                name = "fatal";
+                break;
+            case couchbase::analytics_status::aborted:
+                name = "aborted";
+                break;
+            case couchbase::analytics_status::unknown:
+                name = "unknown";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

data/ext/couchbase/couchbase/query_options.hxx

@@ -19,7 +19,6 @@
 
 #include <couchbase/codec/tao_json_serializer.hxx>
 #include <couchbase/common_options.hxx>
-#include <couchbase/key_value_error_context.hxx>
 #include <couchbase/mutation_state.hxx>
 #include <couchbase/query_error_context.hxx>
 #include <couchbase/query_profile.hxx>

data/ext/couchbase/couchbase/scope.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <couchbase/analytics_options.hxx>
 #include <couchbase/query_options.hxx>
 
 #include <memory>
@@ -132,6 +133,38 @@ class scope
         return future;
     }
 
+    /**
+     * Performs a query against the analytics services.
+     *
+     * @param statement the query statement.
+     * @param options options to customize the query request.
+     * @param handler the handler that implements @ref query_handler
+     *
+     * @exception errc::common::ambiguous_timeout
+     * @exception errc::common::unambiguous_timeout
+     *
+     * @see https://docs.couchbase.com/server/current/analytics/introduction.html
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const;
+
+    /**
+     * Performs a query against the analytics services.
+     *
+     * @param statement the query statement.
+     * @param options options to customize the query request.
+     * @return future object that carries result of the operation
+     *
+     * @see https://docs.couchbase.com/server/current/analytics/introduction.html
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto analytics_query(std::string statement, const analytics_options& options = {}) const
+      -> std::future<std::pair<analytics_error_context, analytics_result>>;
+
   private:
     friend class bucket;
 

data/ext/couchbase/couchbase/transactions/attempt_context.hxx

@@ -33,7 +33,7 @@ class attempt_context
                                                                            const Content& content)
     {
         if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
-            return insert_raw(content, id, content);
+            return insert_raw(coll, id, content);
         } else {
             return insert_raw(coll, id, codec::tao_json_serializer::serialize(content));
         }

data/ext/couchbase/test/CMakeLists.txt

@@ -16,6 +16,7 @@ integration_test(tracer)
 integration_test(meter)
 integration_test(transcoders)
 integration_test(range_scan)
+integration_test(search)
 
 unit_test(connection_string)
 unit_test(utils)
@@ -28,8 +29,6 @@ target_link_libraries(test_unit_jsonsl jsonsl)
 
 integration_benchmark(get)
 
-add_subdirectory(tools)
-
 transaction_test(transaction_context)
 transaction_test(transaction_simple)
 transaction_test(transaction_simple_async)

data/ext/couchbase/test/test_helper.hxx

@@ -21,7 +21,7 @@
 
 #include "utils/binary.hxx"
 #include "utils/test_context.hxx"
-#include "utils/uniq_id.hxx"
+#include "utils/test_data.hxx"
 
 #include <catch2/catch.hpp>