couchbase 3.4.0 → 3.4.2

data/ext/couchbase/core/utils/connection_string.cxx

@@ -51,18 +51,22 @@ using opt_bucket_name = opt_must<one<'/'>, bucket_name>;
 using opt_params = opt_must<one<'?'>, list_must<param, one<'&'>>>;
 using opt_nodes = seq<list_must<node, one<',', ';'>>, opt_bucket_name>;
 
-using grammar = must<seq<uri::scheme, one<':'>, uri::dslash, opt_nodes, opt_params, tao::pegtl::eof>>;
+struct scheme : seq<uri::scheme, one<':'>, uri::dslash> {
+};
+using opt_scheme = opt<scheme>;
+
+using grammar = must<seq<opt_scheme, opt_nodes, opt_params, tao::pegtl::eof>>;
 
 template<typename Rule>
 struct action {
 };
 
 template<>
-struct action<uri::scheme> {
+struct action<scheme> {
     template<typename ActionInput>
     static void apply(const ActionInput& in, connection_string& cs, connection_string::node& /* cur_node */)
     {
-        cs.scheme = in.string();
+        cs.scheme = in.string().substr(0, in.string().rfind(':'));
         if (cs.scheme == "couchbase") {
             cs.default_port = 11210;
             cs.default_mode = connection_string::bootstrap_mode::gcccp;
@@ -79,6 +83,9 @@ struct action<uri::scheme> {
             cs.default_port = 18091;
             cs.default_mode = connection_string::bootstrap_mode::http;
             cs.tls = true;
+        } else {
+            cs.default_mode = connection_string::bootstrap_mode::unspecified;
+            cs.default_port = 0;
         }
     }
 };

data/ext/couchbase/core/utils/connection_string.hxx

@@ -57,7 +57,7 @@ struct connection_string {
         }
     };
 
-    std::string scheme{};
+    std::string scheme{ "couchbase" };
     bool tls{ false };
     std::map<std::string, std::string> params{};
     cluster_options options{};
@@ -65,8 +65,8 @@ struct connection_string {
     std::vector<node> bootstrap_nodes{};
 
     std::optional<std::string> default_bucket_name{};
-    bootstrap_mode default_mode{ bootstrap_mode::unspecified };
-    std::uint16_t default_port{ 0 };
+    bootstrap_mode default_mode{ connection_string::bootstrap_mode::gcccp };
+    std::uint16_t default_port{ 11210 };
 
     std::optional<std::string> error{};
 };

data/ext/couchbase/couchbase/analytics_error_context.hxx

@@ -0,0 +1,143 @@
+/* -*- 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/error_context.hxx>
+
+#include <cstdint>
+#include <optional>
+
+namespace couchbase
+{
+/**
+ * The error context returned with Query operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class analytics_error_context : public error_context
+{
+  public:
+    /**
+     * Creates empty error context
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    analytics_error_context() = default;
+
+    analytics_error_context(std::error_code ec,
+                            std::optional<std::string> last_dispatched_to,
+                            std::optional<std::string> last_dispatched_from,
+                            std::size_t retry_attempts,
+                            std::set<retry_reason> retry_reasons,
+                            std::uint64_t first_error_code,
+                            std::string first_error_message,
+                            std::string client_context_id,
+                            std::string statement,
+                            std::optional<std::string> parameters,
+                            std::string method,
+                            std::string path,
+                            std::uint32_t http_status,
+                            std::string http_body,
+                            std::string hostname,
+                            std::uint16_t port)
+      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      , first_error_code_{ first_error_code }
+      , first_error_message_{ std::move(first_error_message) }
+      , client_context_id_{ std::move(client_context_id) }
+      , statement_{ std::move(statement) }
+      , parameters_{ std::move(parameters) }
+      , method_{ std::move(method) }
+      , path_{ std::move(path) }
+      , http_status_{ http_status }
+      , http_body_{ std::move(http_body) }
+      , hostname_{ std::move(hostname) }
+      , port_{ port }
+    {
+    }
+
+    [[nodiscard]] auto first_error_code() const -> std::uint64_t
+    {
+        return first_error_code_;
+    }
+
+    [[nodiscard]] auto first_error_message() const -> const std::string&
+    {
+        return first_error_message_;
+    }
+
+    [[nodiscard]] auto client_context_id() const -> const std::string&
+    {
+        return client_context_id_;
+    }
+
+    [[nodiscard]] auto statement() const -> const std::string&
+    {
+        return statement_;
+    }
+
+    [[nodiscard]] auto parameters() const -> const std::optional<std::string>&
+    {
+        return parameters_;
+    }
+
+    [[nodiscard]] auto method() const -> const std::string&
+    {
+        return method_;
+    }
+
+    [[nodiscard]] auto path() const -> const std::string&
+    {
+        return path_;
+    }
+
+    [[nodiscard]] auto http_status() const -> std::uint32_t
+    {
+        return http_status_;
+    }
+
+    [[nodiscard]] auto http_body() const -> const std::string&
+    {
+        return http_body_;
+    }
+
+    [[nodiscard]] auto hostname() const -> const std::string&
+    {
+        return hostname_;
+    }
+
+    [[nodiscard]] auto port() const -> std::uint16_t
+    {
+        return port_;
+    }
+
+  private:
+    std::uint64_t first_error_code_{};
+    std::string first_error_message_{};
+    std::string client_context_id_{};
+    std::string statement_{};
+    std::optional<std::string> parameters_{};
+    std::string method_{};
+    std::string path_{};
+    std::uint32_t http_status_{};
+    std::string http_body_{};
+    std::string hostname_{};
+    std::uint16_t port_{};
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/analytics_meta_data.hxx

@@ -0,0 +1,155 @@
+/* -*- 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_metrics.hxx>
+#include <couchbase/analytics_status.hxx>
+#include <couchbase/analytics_warning.hxx>
+#include <couchbase/codec/json_transcoder.hxx>
+
+#include <cinttypes>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+
+/**
+ * Stores any non-rows results related to the execution of a particular Analytics query.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class analytics_meta_data
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    analytics_meta_data() = default;
+
+    /**
+     * @since 1.0.0
+     * @volatile
+     */
+    analytics_meta_data(std::string request_id,
+                        std::string client_context_id,
+                        analytics_status status,
+                        std::vector<analytics_warning> warnings,
+                        analytics_metrics metrics,
+                        std::optional<codec::binary> signature)
+      : request_id_{ std::move(request_id) }
+      , client_context_id_{ std::move(client_context_id) }
+      , status_{ status }
+      , warnings_{ std::move(warnings) }
+      , metrics_{ std::move(metrics) }
+      , signature_{ std::move(signature) }
+    {
+    }
+
+    /**
+     * Returns the request identifier string of the query request
+     *
+     * @return The request identifier string
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto request_id() const -> const std::string&
+    {
+        return request_id_;
+    }
+
+    /**
+     * Returns the client context identifier string set on the query request.
+     *
+     * @return client context identifier
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto client_context_id() const -> const std::string&
+    {
+        return client_context_id_;
+    }
+
+    /**
+     * Returns the raw query execution status as returned by the query engine
+     *
+     * @return query execution status
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto status() const -> analytics_status
+    {
+        return status_;
+    }
+
+    /**
+     * Returns any warnings returned by the analytics engine.
+     *
+     * It returns an empty vector if no warnings were returned.
+     *
+     * @return vector of the reported warnings.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto warnings() const -> const std::vector<analytics_warning>&
+    {
+        return warnings_;
+    }
+
+    /**
+     * Returns the {@link analytics_metrics} as returned by the analytics engine if enabled.
+     *
+     * @return metrics
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto metrics() const -> const analytics_metrics&
+    {
+        return metrics_;
+    }
+
+    /**
+     * Returns the signature as returned by the analytics engine.
+     *
+     * @return optional byte string containing JSON encoded signature
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto signature() const -> const std::optional<codec::binary>&
+    {
+        return signature_;
+    }
+
+  private:
+    std::string request_id_{};
+    std::string client_context_id_{};
+    analytics_status status_{};
+    std::vector<analytics_warning> warnings_{};
+    analytics_metrics metrics_{};
+    std::optional<codec::binary> signature_{};
+};
+
+} // namespace couchbase

data/ext/couchbase/couchbase/analytics_metrics.hxx

@@ -0,0 +1,163 @@
+/* -*- 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 <chrono>
+#include <cinttypes>
+
+namespace couchbase
+{
+
+/**
+ * Analytics Metrics contains the query result metrics containing counts and timings
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class analytics_metrics
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    analytics_metrics() = default;
+
+    /**
+     * @since 1.0.0
+     * @volatile
+     */
+    analytics_metrics(std::chrono::nanoseconds elapsed_time,
+                      std::chrono::nanoseconds execution_time,
+                      std::uint64_t result_count,
+                      std::uint64_t result_size,
+                      std::uint64_t processed_objects,
+                      std::uint64_t error_count,
+                      std::uint64_t warning_count)
+      : elapsed_time_{ elapsed_time }
+      , execution_time_{ execution_time }
+      , result_count_{ result_count }
+      , result_size_{ result_size }
+      , processed_objects_{ processed_objects }
+      , error_count_{ error_count }
+      , warning_count_{ warning_count }
+    {
+    }
+
+    /**
+     * The total time taken for the request, that is the time from when the request was received until the results were returned.
+     *
+     * @return total time duration
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto elapsed_time() const -> std::chrono::nanoseconds
+    {
+        return elapsed_time_;
+    }
+
+    /**
+     * The time taken for the execution of the request, that is the time from when query execution started until the results were returned.
+     *
+     * @return the execution time duration
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto execution_time() const -> std::chrono::nanoseconds
+    {
+        return execution_time_;
+    }
+
+    /**
+     * The total number of objects in the results.
+     *
+     * @return number of results
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto result_count() const -> std::uint64_t
+    {
+        return result_count_;
+    }
+
+    /**
+     * The total number of bytes in the results
+     *
+     * @return number of bytes
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto result_size() const -> std::uint64_t
+    {
+        return result_size_;
+    }
+
+    /**
+     * The number of processed objects for the request.
+     *
+     * @return number of objects
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto processed_objects() const -> std::uint64_t
+    {
+        return processed_objects_;
+    }
+
+    /**
+     * The number of errors that occurred during the request
+     *
+     * @return number of errors
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto error_count() const -> std::uint64_t
+    {
+        return error_count_;
+    }
+
+    /**
+     * The number of warnings that occurred during the request.
+     *
+     * @return number of warnings
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto warning_count() const -> std::uint64_t
+    {
+        return warning_count_;
+    }
+
+  private:
+    std::chrono::nanoseconds elapsed_time_{};
+    std::chrono::nanoseconds execution_time_{};
+    std::uint64_t result_count_{};
+    std::uint64_t result_size_{};
+    std::uint64_t processed_objects_{};
+    std::uint64_t error_count_{};
+    std::uint64_t warning_count_{};
+};
+
+} // namespace couchbase