couchbase 3.4.2 → 3.4.4

data/ext/couchbase/couchbase/get_bucket_options.hxx

@@ -0,0 +1,43 @@
+/* -*- 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/management/bucket_settings.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct get_bucket_options : public common_options<get_bucket_options> {
+  public:
+    struct built : public common_options<get_bucket_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using get_bucket_handler = std::function<void(couchbase::manager_error_context, couchbase::management::cluster::bucket_settings)>;
+} // namespace couchbase

data/ext/couchbase/couchbase/get_options.hxx

@@ -129,8 +129,8 @@ initiate_get_operation(std::shared_ptr<couchbase::core::cluster> core,
                        std::string scope_name,
                        std::string collection_name,
                        std::string document_key,
-                       get_options::built options,
-                       get_handler&& handler);
+                       couchbase::get_options::built options,
+                       couchbase::get_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/highlight_style.hxx

@@ -0,0 +1,45 @@
+/* -*- 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
+{
+/**
+ * Enumeration of the highlighting styles recognized by the FTS engine.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+enum class highlight_style {
+    /**
+     * Use HTML tags `<mark>` and `</mark>` to indicate matches in the fields.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    html,
+
+    /**
+     * Use ANSI code sequences `\\x1b[43m>` and `\\x1b[0m` to indicate matches in the fields.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    ansi,
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/insert_options.hxx

@@ -127,9 +127,9 @@ initiate_insert_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string scope_name,
                           std::string collection_name,
                           std::string document_key,
-                          codec::encoded_value encoded,
-                          insert_options::built options,
-                          insert_handler&& handler);
+                          couchbase::codec::encoded_value encoded,
+                          couchbase::insert_options::built options,
+                          couchbase::insert_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/key_value_error_context.hxx

@@ -48,6 +48,7 @@ class key_value_error_context : public error_context
     /**
      * Creates and initializes error context with given parameters.
      *
+     * @param operation_id
      * @param ec
      * @param last_dispatched_to
      * @param last_dispatched_from
@@ -66,7 +67,8 @@ class key_value_error_context : public error_context
      * @since 1.0.0
      * @internal
      */
-    key_value_error_context(std::error_code ec,
+    key_value_error_context(std::string operation_id,
+                            std::error_code ec,
                             std::optional<std::string> last_dispatched_to,
                             std::optional<std::string> last_dispatched_from,
                             std::size_t retry_attempts,
@@ -80,7 +82,8 @@ class key_value_error_context : public error_context
                             couchbase::cas cas,
                             std::optional<key_value_error_map_info> error_map_info,
                             std::optional<key_value_extended_error_info> extended_error_info)
-      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      : error_context{ std::move(operation_id), ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts,
+                       std::move(retry_reasons) }
       , id_{ std::move(id) }
       , bucket_{ std::move(bucket) }
       , scope_{ std::move(scope) }
@@ -210,6 +213,8 @@ class key_value_error_context : public error_context
         return extended_error_info_;
     }
 
+    [[nodiscard]] auto to_json() const -> std::string;
+
   private:
     std::string id_{};
     std::string bucket_{};

data/ext/couchbase/couchbase/lookup_in_all_replicas_options.hxx

@@ -0,0 +1,109 @@
+/* -*- 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/subdoc/fwd/command_bundle.hxx>
+
+#include <core/impl/subdoc/command.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/common_options.hxx>
+#include <couchbase/expiry.hxx>
+#include <couchbase/lookup_in_replica_result.hxx>
+#include <couchbase/store_semantics.hxx>
+#include <couchbase/subdocument_error_context.hxx>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * Options for @ref collection#lookup_in_all_replicas().
+ *
+ * @since 1.0.0
+ * @committed
+ */
+struct lookup_in_all_replicas_options : common_options<lookup_in_all_replicas_options> {
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<lookup_in_all_replicas_options>::built {
+    };
+
+    /**
+     * Validates options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+};
+
+/**
+ * The result for the @ref collection#lookup_in_all_replicas() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using lookup_in_all_replicas_result = std::vector<lookup_in_replica_result>;
+
+/**
+ * The signature for the handler of the @ref collection#lookup_in_all_replicas() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using lookup_in_all_replicas_handler = std::function<void(couchbase::subdocument_error_context, lookup_in_all_replicas_result)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_lookup_in_all_replicas_operation(std::shared_ptr<couchbase::core::cluster> core,
+                                          const std::string& bucket_name,
+                                          const std::string& scope_name,
+                                          const std::string& collection_name,
+                                          std::string document_key,
+                                          const std::vector<couchbase::core::impl::subdoc::command>& specs,
+                                          lookup_in_all_replicas_options::built options,
+                                          lookup_in_all_replicas_handler&& handler);
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

data/ext/couchbase/couchbase/lookup_in_any_replica_options.hxx

@@ -0,0 +1,101 @@
+/* -*- 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/subdoc/fwd/command_bundle.hxx>
+
+#include <core/impl/subdoc/command.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/common_options.hxx>
+#include <couchbase/expiry.hxx>
+#include <couchbase/lookup_in_replica_result.hxx>
+#include <couchbase/store_semantics.hxx>
+#include <couchbase/subdocument_error_context.hxx>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace couchbase
+{
+/**
+ * Options for @ref collection#lookup_in_any_replica().
+ *
+ * @since 1.0.0
+ * @committed
+ */
+struct lookup_in_any_replica_options : common_options<lookup_in_any_replica_options> {
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<lookup_in_any_replica_options>::built {
+    };
+
+    /**
+     * Validates options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+};
+
+/**
+ * The signature for the handler of the @ref collection#lookup_in_any_replica() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using lookup_in_any_replica_handler = std::function<void(couchbase::subdocument_error_context, lookup_in_replica_result)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_lookup_in_any_replica_operation(std::shared_ptr<couchbase::core::cluster> core,
+                                         const std::string& bucket_name,
+                                         const std::string& scope_name,
+                                         const std::string& collection_name,
+                                         std::string document_key,
+                                         const std::vector<couchbase::core::impl::subdoc::command>& specs,
+                                         lookup_in_any_replica_options::built options,
+                                         lookup_in_any_replica_handler&& handler);
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

data/ext/couchbase/couchbase/lookup_in_options.hxx

@@ -111,8 +111,8 @@ initiate_lookup_in_operation(std::shared_ptr<couchbase::core::cluster> core,
                              std::string collection_name,
                              std::string document_key,
                              const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                             lookup_in_options::built options,
-                             lookup_in_handler&& handler);
+                             couchbase::lookup_in_options::built options,
+                             couchbase::lookup_in_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/lookup_in_replica_result.hxx

@@ -0,0 +1,74 @@
+/* -*- 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/lookup_in_result.hxx>
+
+#include <vector>
+
+namespace couchbase
+{
+
+/**
+ * Represents result of lookup_in_replica operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class lookup_in_replica_result : public lookup_in_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    lookup_in_replica_result() = default;
+
+    /**
+     * Constructs result for lookup_in_replica operation
+     *
+     * @param cas
+     * @param entries list of the fields returned by the server
+     * @param is_deleted
+     * @param is_replica true if document originates from replica node
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    lookup_in_replica_result(couchbase::cas cas, std::vector<entry> entries, bool is_deleted, bool is_replica)
+      : lookup_in_result{ cas, std::move(entries), is_deleted }
+      , is_replica_{ is_replica }
+    {
+    }
+
+    /**
+     * Returns whether this document originates from a replica node
+     *
+     * @return whether document originates from a replica node
+     *
+     * @since 1.0.0
+     */
+    [[nodiscard]] auto is_replica() const -> bool
+    {
+        return is_replica_;
+    }
+
+  private:
+    bool is_replica_{ false };
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/lookup_in_result.hxx

@@ -44,6 +44,7 @@ class lookup_in_result : public result
         codec::binary value;
         std::size_t original_index;
         bool exists;
+        std::error_code ec;
     };
 
     /**
@@ -84,6 +85,11 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.original_index == index) {
+                if (e.ec) {
+                    throw std::system_error(
+                      e.ec, "error getting result for spec at index " + std::to_string(index) + ", path \"" + e.path + "\"");
+                }
+
                 return codec::tao_json_serializer::deserialize<Document>(e.value);
             }
         }
@@ -105,6 +111,10 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.path == path) {
+                if (e.ec) {
+                    throw std::system_error(e.ec, "error getting result for path \"" + e.path + "\"");
+                }
+
                 return codec::tao_json_serializer::deserialize<Document>(e.value);
             }
         }
@@ -127,6 +137,10 @@ class lookup_in_result : public result
         const auto& macro_string = subdoc::to_string(macro);
         for (const entry& e : entries_) {
             if (e.path == macro_string) {
+                if (e.ec) {
+                    throw std::system_error(e.ec, "error getting result for macro \"" + macro_string + "\"");
+                }
+
                 return codec::tao_json_serializer::deserialize<Document>(e.value);
             }
         }
@@ -147,6 +161,10 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.original_index == index) {
+                if (e.ec && e.ec != couchbase::errc::key_value::path_not_found) {
+                    throw std::system_error(e.ec, "error getting result for path \"" + e.path + "\"");
+                }
+
                 return e.exists;
             }
         }
@@ -167,6 +185,10 @@ class lookup_in_result : public result
         const auto& macro_string = subdoc::to_string(macro);
         for (const entry& e : entries_) {
             if (e.path == macro_string) {
+                if (e.ec && e.ec != couchbase::errc::key_value::path_not_found) {
+                    throw std::system_error(e.ec, "error getting result for macro \"" + macro_string + "\"");
+                }
+
                 return e.exists;
             }
         }
@@ -186,6 +208,10 @@ class lookup_in_result : public result
     {
         for (const entry& e : entries_) {
             if (e.path == path) {
+                if (e.ec && e.ec != couchbase::errc::key_value::path_not_found) {
+                    throw std::system_error(e.ec, "error getting result for path \"" + e.path + "\"");
+                }
+
                 return e.exists;
             }
         }

data/ext/couchbase/couchbase/management/bucket_settings.hxx

@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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/durability_level.hxx>
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::management::cluster
+{
+enum class bucket_type { unknown, couchbase, memcached, ephemeral };
+enum class bucket_compression { unknown, off, active, passive };
+enum class bucket_eviction_policy {
+    unknown,
+
+    /**
+     * During ejection, everything (including key, metadata, and value) will be ejected.
+     *
+     * Full Ejection reduces the memory overhead requirement, at the cost of performance.
+     *
+     * This value is only valid for buckets of type COUCHBASE.
+     */
+    full,
+
+    /**
+     * During ejection, only the value will be ejected (key and metadata will remain in memory).
+     *
+     * Value Ejection needs more system memory, but provides better performance than Full Ejection.
+     *
+     * This value is only valid for buckets of type COUCHBASE.
+     */
+    value_only,
+
+    /**
+     * Couchbase Server keeps all data until explicitly deleted, but will reject
+     * any new data if you reach the quota (dedicated memory) you set for your bucket.
+     *
+     * This value is only valid for buckets of type EPHEMERAL.
+     */
+    no_eviction,
+
+    /**
+     * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
+     *
+     * This value is only valid for buckets of type EPHEMERAL.
+     */
+    not_recently_used,
+};
+enum class bucket_conflict_resolution {
+    unknown,
+    /**
+     * Use timestamp conflict resolution.
+     *
+     * Timestamp-based conflict resolution (often referred to as Last Write Wins, or LWW) uses the document
+     * timestamp (stored in the CAS) to resolve conflicts. The timestamps associated with the most recent
+     * updates of source and target documents are compared. The document whose update has the more recent
+     * timestamp prevails.
+     */
+    timestamp,
+
+    /**
+     * Use sequence number conflict resolution
+     *
+     * Conflicts can be resolved by referring to documents' sequence numbers. Sequence numbers are maintained
+     * per document, and are incremented on every document-update. The sequence numbers of source and
+     * target documents are compared; and the document with the higher sequence number prevails.
+     */
+    sequence_number,
+
+    /**
+     * VOLATILE: This API is subject to change at any time.
+     *
+     * In Couchbase Server 7.1, this feature is only available in "developer-preview" mode. See the UI XDCR settings.
+     */
+    custom,
+};
+enum class bucket_storage_backend { unknown, couchstore, magma };
+
+struct bucket_settings {
+
+    std::string name;
+    cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
+    std::uint64_t ram_quota_mb{ 100 };
+    std::uint32_t max_expiry{ 0 };
+    bucket_compression compression_mode{ bucket_compression::unknown };
+    std::optional<couchbase::durability_level> minimum_durability_level{};
+    std::uint32_t num_replicas{ 1 };
+    bool replica_indexes{ false };
+    bool flush_enabled{ false };
+    bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
+    bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
+
+    /**
+     * UNCOMMITTED: This API may change in the future
+     */
+    bucket_storage_backend storage_backend{ bucket_storage_backend::unknown };
+};
+} // namespace couchbase::management::cluster