couchbase 4.2.8 → 4.2.10

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

@@ -29,10 +29,14 @@
 #include <memory>
 
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace couchbase::core
+namespace couchbase
+{
+namespace core
 {
 class cluster;
-} // namespace couchbase::core
+} // namespace core
+class collection_manager_impl;
+} // namespace couchbase
 #endif
 
 namespace couchbase
@@ -148,13 +152,8 @@ class collection_manager
   private:
     friend class bucket;
 
-    explicit collection_manager(std::shared_ptr<couchbase::core::cluster> core, std::string bucket_name)
-      : core_(std::move(core))
-      , bucket_name_(std::move(bucket_name))
-    {
-    }
+    collection_manager(core::cluster core, std::string_view bucket_name);
 
-    std::shared_ptr<couchbase::core::cluster> core_;
-    std::string bucket_name_;
+    std::shared_ptr<collection_manager_impl> impl_;
 };
 } // namespace couchbase

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

@@ -29,13 +29,14 @@
 #include <memory>
 
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace couchbase::core
+namespace couchbase
+{
+namespace core
 {
 class cluster;
-
-class query_context;
-
-} // namespace couchbase::core
+} // namespace core
+class query_index_manager_impl;
+} // namespace couchbase
 #endif
 
 namespace couchbase
@@ -64,7 +65,7 @@ class collection_query_index_manager
     void get_all_indexes(const get_all_query_indexes_options& options, get_all_query_indexes_handler&& handler) const;
 
     [[nodiscard]] auto get_all_indexes(const get_all_query_indexes_options& options) const
-      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>;
+      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query_index>>>;
     /**
      * Create an index on the collection.
      *
@@ -96,7 +97,8 @@ class collection_query_index_manager
      */
     void create_primary_index(const create_primary_query_index_options& options, create_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto create_primary_index(const create_primary_query_index_options& options) -> std::future<manager_error_context>;
+    [[nodiscard]] auto create_primary_index(const create_primary_query_index_options& options) const -> std::future<manager_error_context>;
+
     /**
      * Drop primary index on a collection.
      *
@@ -122,7 +124,8 @@ class collection_query_index_manager
      */
     void drop_index(std::string index_name, const drop_query_index_options& options, drop_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto drop_index(std::string index_name, const drop_query_index_options& options) -> std::future<manager_error_context>;
+    [[nodiscard]] auto drop_index(std::string index_name, const drop_query_index_options& options) const
+      -> std::future<manager_error_context>;
     /**
      * Builds all currently deferred indexes in this collection.
      *
@@ -152,26 +155,20 @@ class collection_query_index_manager
                        const watch_query_indexes_options& options,
                        watch_query_indexes_handler&& handler) const;
 
-    [[nodiscard]] auto watch_indexes(std::vector<std::string> index_names, const watch_query_indexes_options& options)
+    [[nodiscard]] auto watch_indexes(std::vector<std::string> index_names, const watch_query_indexes_options& options) const
       -> std::future<manager_error_context>;
 
   private:
     friend class collection;
 
-    explicit collection_query_index_manager(std::shared_ptr<couchbase::core::cluster> core,
-                                            std::string bucket_name,
-                                            std::string scope_name,
-                                            std::string collection_name)
-      : core_(core)
-      , bucket_name_(std::move(bucket_name))
-      , scope_name_(std::move(scope_name))
-      , collection_name_(std::move(collection_name))
-    {
-    }
-
-    std::shared_ptr<couchbase::core::cluster> core_;
-    std::string bucket_name_;
-    std::string scope_name_;
-    std::string collection_name_;
+    collection_query_index_manager(couchbase::core::cluster core,
+                                   std::string bucket_name,
+                                   std::string scope_name,
+                                   std::string collection_name);
+
+    std::shared_ptr<query_index_manager_impl> impl_;
+    std::string bucket_name_{};
+    std::string scope_name_{};
+    std::string collection_name_{};
 };
 } // namespace couchbase

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

@@ -0,0 +1,116 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class connect_link_analytics_options : public common_options<connect_link_analytics_options>
+{
+  public:
+    /**
+     * The name of the dataverse in which the link should be disconnected.
+     *
+     * defaults to `Default`
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> connect_link_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * The name of the link
+     *
+     * defaults to `Local`
+     *
+     * @param link_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto link_name(std::string link_name) -> connect_link_analytics_options&
+    {
+        link_name_ = std::move(link_name);
+        return self();
+    }
+
+    /**
+     * Whether to force link creation even if the bucket UUID changed, for example, due to the bucket being deleted and recreated.
+     */
+    auto force(bool force) -> connect_link_analytics_options&
+    {
+        force_ = force;
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<connect_link_analytics_options>::built {
+        std::optional<std::string> dataverse_name{};
+        std::optional<std::string> link_name{};
+        bool force{ false };
+    };
+
+    /**
+     * 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(), dataverse_name_, link_name_, force_ };
+    }
+
+  private:
+    bool force_{ false };
+    std::optional<std::string> dataverse_name_{};
+    std::optional<std::string> link_name_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#connect_link() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using connect_link_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -17,10 +17,10 @@
 
 #pragma once
 
+#include <couchbase/common_options.hxx>
+#include <couchbase/manager_error_context.hxx>
+
 #include <functional>
-#include <memory>
-#include <optional>
-#include <string>
 
 namespace couchbase
 {

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

@@ -17,26 +17,55 @@
 
 #pragma once
 
+#include <couchbase/common_options.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <cstdint>
 #include <functional>
-#include <memory>
 #include <optional>
-#include <string>
 
 namespace couchbase
 {
 struct create_collection_options : public common_options<create_collection_options> {
   public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
     struct built : public common_options<create_collection_options>::built {
     };
 
+    /**
+     * Validates the 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 settings to use when creating the collection
+ */
 struct create_collection_settings {
-    std::uint32_t max_expiry{ 0 };
+    /**
+     * The maximum expiry, in seconds, for documents in this collection. Values greater than or equal to -1 are valid.
+     * Value of 0 sets max_expiry to the bucket-level setting and value of -1 to set it as no-expiry.
+     */
+    std::int32_t max_expiry{ 0 };
+
+    /**
+     * Whether history retention should be enabled. If unset, the bucket-level setting is used.
+     */
     std::optional<bool> history{};
 };
 

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

@@ -0,0 +1,120 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class create_dataset_analytics_options : public common_options<create_dataset_analytics_options>
+{
+  public:
+    /**
+     * Ignore error if the dataset already exists.
+     *
+     * defaults to `false`
+     *
+     * @param ignore_if_exists
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_exists(bool ignore_if_exists) -> create_dataset_analytics_options&
+    {
+        ignore_if_exists_ = ignore_if_exists;
+        return self();
+    }
+
+    /**
+     * WHERE clause to use for creating the dataset
+     *
+     * @param condition
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto condition(std::string condition) -> create_dataset_analytics_options&
+    {
+        condition_ = std::move(condition);
+        return self();
+    }
+
+    /**
+     * The name of the dataverse the dataset should be created into
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> create_dataset_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<create_dataset_analytics_options>::built {
+        bool ignore_if_exists{};
+        std::optional<std::string> condition{};
+        std::optional<std::string> dataverse_name{};
+    };
+
+    /**
+     * 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(), ignore_if_exists_, condition_, dataverse_name_ };
+    }
+
+  private:
+    bool ignore_if_exists_{ false };
+    std::optional<std::string> condition_{};
+    std::optional<std::string> dataverse_name_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#create_dataset() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using create_dataset_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -0,0 +1,85 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+
+namespace couchbase
+{
+class create_dataverse_analytics_options : public common_options<create_dataverse_analytics_options>
+{
+  public:
+    /**
+     * Ignore error if the dataverse already exists.
+     *
+     * defaults to `false`
+     *
+     * @param ignore_if_exists
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_exists(bool ignore_if_exists) -> create_dataverse_analytics_options&
+    {
+        ignore_if_exists_ = ignore_if_exists;
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<create_dataverse_analytics_options>::built {
+        bool ignore_if_exists{};
+    };
+
+    /**
+     * 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(), ignore_if_exists_ };
+    }
+
+  private:
+    bool ignore_if_exists_{ false };
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#create_dataverse() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using create_dataverse_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -0,0 +1,103 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class create_index_analytics_options : public common_options<create_index_analytics_options>
+{
+  public:
+    /**
+     * Ignore error if the index already exists.
+     *
+     * defaults to `false`
+     *
+     * @param ignore_if_exists
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_exists(bool ignore_if_exists) -> create_index_analytics_options&
+    {
+        ignore_if_exists_ = ignore_if_exists;
+        return self();
+    }
+
+    /**
+     * The name of the dataverse the index should be created into
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> create_index_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<create_index_analytics_options>::built {
+        bool ignore_if_exists{};
+        std::optional<std::string> dataverse_name{};
+    };
+
+    /**
+     * 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(), ignore_if_exists_, dataverse_name_ };
+    }
+
+  private:
+    bool ignore_if_exists_{ false };
+    std::optional<std::string> dataverse_name_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#create_index() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using create_index_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -0,0 +1,63 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+
+namespace couchbase
+{
+class create_link_analytics_options : public common_options<create_link_analytics_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<create_link_analytics_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 analytics_index_manager#create_link() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using create_link_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase