couchbase 4.2.1 → 4.2.2

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

@@ -0,0 +1,218 @@
+/* -*- 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/build_query_index_options.hxx>
+#include <couchbase/create_primary_query_index_options.hxx>
+#include <couchbase/create_query_index_options.hxx>
+#include <couchbase/drop_primary_query_index_options.hxx>
+#include <couchbase/drop_query_index_options.hxx>
+#include <couchbase/get_all_query_indexes_options.hxx>
+#include <couchbase/watch_query_indexes_options.hxx>
+
+#include <future>
+#include <memory>
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace couchbase::core
+{
+class cluster;
+
+class query_context;
+
+} // namespace couchbase::core
+#endif
+
+namespace couchbase
+{
+class collection;
+
+/**
+ * The Query Index Manager interface contains the means for managing indexes used for queries.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class collection_query_index_manager
+{
+  public:
+    /**
+     * Get all indexes within a collection.
+     *
+     *
+     * @param options optional parameters
+     * @param handler the handler that implements @ref get_all_query_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void get_all_indexes(const get_all_query_indexes_options& options, get_all_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>>>
+    {
+        auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>>();
+        auto future = barrier->get_future();
+        get_all_indexes(options, [barrier](auto ctx, auto resp) { barrier->set_value({ ctx, resp }); });
+        return future;
+    }
+    /**
+     * Create an index on the collection.
+     *
+     * @param index_name name of the index
+     * @param fields the fields to create the index over
+     * @param options optional parameters
+     * @param handler the handler that implements @ref create_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void create_index(std::string index_name,
+                      std::vector<std::string> fields,
+                      const create_query_index_options& options,
+                      create_query_index_handler&& handler) const;
+
+    [[nodiscard]] auto create_index(std::string index_name,
+                                    std::vector<std::string> fields,
+                                    const create_query_index_options& options) const -> std::future<manager_error_context>
+    {
+        auto barrier = std::make_shared<std::promise<manager_error_context>>();
+        auto future = barrier->get_future();
+        create_index(std::move(index_name), std::move(fields), options, [barrier](auto ctx) { barrier->set_value(ctx); });
+        return future;
+    }
+
+    /**
+     * Create a primary index on a collection.
+     *
+     * @param options optional parameters
+     * @param handler the handler that implements @ref create_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    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>
+    {
+        auto barrier = std::make_shared<std::promise<manager_error_context>>();
+        auto future = barrier->get_future();
+        create_primary_index(options, [barrier](auto ctx) { barrier->set_value(ctx); });
+        return future;
+    }
+    /**
+     * Drop primary index on a collection.
+     *
+     * @param options optional parameters
+     * @param handler the handler that implements @ref drop_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void drop_primary_index(const drop_primary_query_index_options& options, drop_query_index_handler&& handler) const;
+
+    [[nodiscard]] auto drop_primary_index(const drop_primary_query_index_options& options) const -> std::future<manager_error_context>
+    {
+        auto barrier = std::make_shared<std::promise<manager_error_context>>();
+        auto future = barrier->get_future();
+        drop_primary_index(options, [barrier](auto ctx) { barrier->set_value(ctx); });
+        return future;
+    }
+
+    /**
+     * Drop index in collection.
+     *
+     * @param index_name name of the index to drop
+     * @param options optional parameters
+     * @param handler handler that implements @ref drop_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    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>
+    {
+        auto barrier = std::make_shared<std::promise<manager_error_context>>();
+        auto future = barrier->get_future();
+        drop_index(std::move(index_name), options, [barrier](auto ctx) { barrier->set_value(ctx); });
+        return future;
+    }
+    /**
+     * Builds all currently deferred indexes in this collection.
+     *
+     * By default, this method will build the indexes on the collection.
+     *
+     * @param options the custom options
+     * @param handler the handler that implements @ref build_deferred_query_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void build_deferred_indexes(const build_query_index_options& options, build_deferred_query_indexes_handler&& handler) const;
+
+    [[nodiscard]] auto build_deferred_indexes(const build_query_index_options& options) const -> std::future<manager_error_context>
+    {
+        auto barrier = std::make_shared<std::promise<manager_error_context>>();
+        auto future = barrier->get_future();
+        build_deferred_indexes(options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
+        return future;
+    }
+
+    /**
+     * Polls the state of a set of indexes, until they all are online.
+     *
+     * @param index_names names of the indexes to watch
+     * @param options optional parameters
+     * @param handler handler that implements @ref watch_query_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void watch_indexes(std::vector<std::string> index_names,
+                       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)
+    {
+        auto barrier = std::make_shared<std::promise<manager_error_context>>();
+        auto future = barrier->get_future();
+        watch_indexes(std::move(index_names), options, [barrier](auto ctx) { barrier->set_value(ctx); });
+        return future;
+    }
+
+  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_;
+};
+} // namespace couchbase

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

@@ -21,6 +21,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace couchbase
 {
@@ -54,5 +55,7 @@ class configuration_profiles_registry
      * @internal
      */
     static void apply_profile(const std::string& name, couchbase::cluster_options& options);
+
+    static auto available_profiles() -> std::vector<std::string>;
 };
 } // namespace couchbase

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

@@ -0,0 +1,166 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class create_primary_query_index_options : public common_options<create_primary_query_index_options>
+{
+  public:
+    /**
+     * Give the primary index a name
+     *
+     * defaults to #primary
+     *
+     * @param index_name
+     * @return reference to this object, for use in chaining.
+     */
+    auto index_name(std::string index_name) -> create_primary_query_index_options&
+    {
+        index_name_.emplace(index_name);
+        return self();
+    }
+    /**
+     * Set flag to ignore error if the index already exists
+     *
+     * The default is to not ignore the error.
+     *
+     * @param ignore_if_exists  if true, we don't return an error if the index already exists
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_exists(bool ignore_if_exists) -> create_primary_query_index_options&
+    {
+        ignore_if_exists_ = ignore_if_exists;
+        return self();
+    }
+    /**
+     * Set flag to defer building of the index
+     *
+     * The default is false, meaning start building the index immediately.
+     *
+     * @param deferred
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto build_deferred(bool deferred) -> create_primary_query_index_options&
+    {
+        deferred_ = deferred;
+        return self();
+    }
+
+    /**
+     * Set the number of replicas the index will have.
+     *
+     *
+     * @param num_replicas
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto num_replicas(uint8_t num_replicas) -> create_primary_query_index_options&
+    {
+        num_replicas_ = num_replicas;
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<create_primary_query_index_options>::built {
+        const std::optional<std::string> index_name{};
+        bool ignore_if_exists{};
+        bool deferred{};
+        std::optional<uint8_t> num_replicas{};
+    };
+
+    /**
+     * 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(), index_name_, ignore_if_exists_, deferred_, num_replicas_ };
+    }
+
+  private:
+    std::optional<std::string> index_name_{};
+    bool ignore_if_exists_{ false };
+    bool deferred_{ false };
+    std::optional<uint8_t> num_replicas_{};
+};
+
+/**
+ * The signature for the handler of the @ref query_index_manager#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using create_primary_query_index_handler = std::function<void(couchbase::manager_error_context)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+class query_context;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_create_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                                    std::string bucket_name,
+                                    couchbase::create_primary_query_index_options::built options,
+                                    query_context query_ctx,
+                                    std::string collection_name,
+                                    create_primary_query_index_handler&& handler);
+void
+initiate_create_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                                    std::string bucket_name,
+                                    couchbase::create_primary_query_index_options::built options,
+                                    create_primary_query_index_handler&& handler);
+
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

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

@@ -0,0 +1,172 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class create_query_index_options : public common_options<create_query_index_options>
+{
+  public:
+    /**
+     * Set flag to ignore error if the index already exists
+     *
+     * The default is to not ignore the error.
+     *
+     * @param ignore_if_exists  if true, we don't return an error if the index already exists
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_exists(bool ignore_if_exists) -> create_query_index_options&
+    {
+        ignore_if_exists_ = ignore_if_exists;
+        return self();
+    }
+    /**
+     * Set flag to defer building of the index
+     *
+     * The default is false, meaning start building the index immediately.
+     *
+     * @param deferred
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto build_deferred(bool deferred) -> create_query_index_options&
+    {
+        deferred_ = deferred;
+        return self();
+    }
+
+    /**
+     * Set the number of replicas the index will have.
+     *
+     *
+     * @param num_replicas
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto num_replicas(uint8_t num_replicas) -> create_query_index_options&
+    {
+        num_replicas_ = num_replicas;
+        return self();
+    }
+    /**
+     * Supply an extra condition on this index.
+     *
+     * This is the contents of the WHERE clause when creating the index.
+     *
+     * @param condition
+     * @return reference to this object, for use in chaining.
+     */
+    auto condition(std::string condition) -> create_query_index_options&
+    {
+        condition_.emplace(std::move(condition));
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<create_query_index_options>::built {
+        bool ignore_if_exists{};
+        bool deferred{};
+        std::optional<std::string> condition{};
+        std::optional<uint8_t> num_replicas{};
+    };
+
+    /**
+     * 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_, deferred_, condition_, num_replicas_ };
+    }
+
+  private:
+    std::optional<std::string> scope_name_{};
+    std::optional<std::string> collection_name_{};
+    bool ignore_if_exists_{ false };
+    bool deferred_{ false };
+    std::optional<uint8_t> num_replicas_{};
+    std::optional<std::string> condition_{};
+};
+
+/**
+ * The signature for the handler of the @ref query_index_manager#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using create_query_index_handler = std::function<void(couchbase::manager_error_context)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+class query_context;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_create_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                            std::string bucket_name,
+                            std::string index_name,
+                            std::vector<std::string> fields,
+                            couchbase::create_query_index_options::built options,
+                            create_query_index_handler&& handler);
+void
+initiate_create_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                            std::string bucket_name,
+                            std::string index_name,
+                            std::vector<std::string> fields,
+                            couchbase::create_query_index_options::built options,
+                            query_context query_ctx,
+                            std::string collection_name,
+                            create_query_index_handler&& handler);
+
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

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

@@ -0,0 +1,129 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class drop_primary_query_index_options : public common_options<drop_primary_query_index_options>
+{
+  public:
+    /**
+     * Name of the primary index
+     *
+     * If created with an optional name, specify that here as well.
+     * @param index_name
+     * @return reference to this object, for use in chaining.
+     */
+    auto index_name(std::string index_name) -> drop_primary_query_index_options&
+    {
+        index_name_.emplace(index_name);
+        return self();
+    }
+    /**
+     * Set flag to ignore error if the index already exists
+     *
+     * The default is to not ignore the error.
+     *
+     * @param ignore_if_exists  if true, we don't return an error if the index already exists
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_not_exists(bool ignore_if_not_exists) -> drop_primary_query_index_options&
+    {
+        ignore_if_not_exists_ = ignore_if_not_exists;
+        return self();
+    }
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<drop_primary_query_index_options>::built {
+        std::optional<std::string> index_name;
+        bool ignore_if_not_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(), index_name_, ignore_if_not_exists_ };
+    }
+
+  private:
+    std::optional<std::string> index_name_{};
+    bool ignore_if_not_exists_{ false };
+};
+
+/**
+ * The signature for the handler of the @ref query_index_manager#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using drop_primary_query_index_handler = std::function<void(couchbase::manager_error_context)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+class query_context;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                                  std::string bucket_name,
+                                  couchbase::drop_primary_query_index_options::built options,
+                                  query_context query_ctx,
+                                  std::string collection_name,
+                                  drop_primary_query_index_handler&& handler);
+
+void
+initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                                  std::string bucket_name,
+                                  couchbase::drop_primary_query_index_options::built options,
+                                  drop_primary_query_index_handler&& handler);
+
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase