couchbase 4.2.1 → 4.2.2

package/CMakeLists.txt

@@ -17,6 +17,7 @@ include_directories(${CMAKE_JS_INC})
 
 set(COUCHBASE_CXX_CLIENT_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(COUCHBASE_CXX_CLIENT_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(COUCHBASE_CXX_CLIENT_BUILD_TOOLS OFF CACHE BOOL "" FORCE)
 set(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL ON CACHE BOOL "" FORCE)
 set(COUCHBASE_CXX_CLIENT_STATIC_STDLIB ON CACHE BOOL "" FORCE)
 add_subdirectory(deps/couchbase-cxx-client)

package/deps/couchbase-cxx-client/.gitmodules

@@ -26,3 +26,6 @@
 [submodule "third_party/fmt"]
 	path = third_party/fmt
 	url = https://github.com/fmtlib/fmt.git
+[submodule "third_party/docopt"]
+	path = third_party/docopt
+	url = https://github.com/docopt/docopt.cpp.git

package/deps/couchbase-cxx-client/.idea/misc.xml

@@ -7,6 +7,7 @@
       <file path="$PROJECT_DIR$/couchbase" />
       <file path="$PROJECT_DIR$/examples" />
       <file path="$PROJECT_DIR$/private" />
+      <file path="$PROJECT_DIR$/tools" />
       <file path="$PROJECT_DIR$/transactions" />
     </sourceRoots>
     <libraryRoots>

package/deps/couchbase-cxx-client/.idea/vcs.xml

@@ -4,6 +4,7 @@
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/asio" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/catch2" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/third_party/docopt" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/fmt" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/gsl" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/hdr_histogram_c" vcs="Git" />

package/deps/couchbase-cxx-client/CMakeLists.txt

@@ -259,11 +259,14 @@ set(couchbase_cxx_client_FILES
         core/impl/append.cxx
         core/impl/best_effort_retry_strategy.cxx
         core/impl/build_deferred_query_indexes.cxx
+        core/impl/collection_query_index_manager.cxx
         core/impl/cluster.cxx
         core/impl/common_error_category.cxx
         core/impl/configuration_profiles_registry.cxx
+        core/impl/create_query_index.cxx
         core/impl/decrement.cxx
         core/impl/dns_srv_tracker.cxx
+        core/impl/drop_query_index.cxx
         core/impl/exists.cxx
         core/impl/expiry.cxx
         core/impl/fail_fast_retry_strategy.cxx
@@ -272,6 +275,7 @@ set(couchbase_cxx_client_FILES
         core/impl/get_all_replicas.cxx
         core/impl/get_and_lock.cxx
         core/impl/get_and_touch.cxx
+        core/impl/get_all_query_indexes.cxx
         core/impl/get_any_replica.cxx
         core/impl/get_replica.cxx
         core/impl/increment.cxx
@@ -293,6 +297,7 @@ set(couchbase_cxx_client_FILES
         core/impl/search_error_category.cxx
         core/impl/streaming_json_lexter_error_category.cxx
         core/impl/unlock.cxx
+        core/impl/watch_query_indexes.cxx
         core/impl/subdoc/array_add_unique.cxx
         core/impl/subdoc/array_append.cxx
         core/impl/subdoc/array_insert.cxx
@@ -325,7 +330,6 @@ set(couchbase_cxx_client_FILES
         core/transactions/attempt_context_impl.cxx
         core/transactions/binary.cxx
         core/transactions/exceptions.cxx
-        core/transactions/logging.cxx
         core/transactions/result.cxx
         core/transactions/staged_mutation.cxx
         core/transactions/utils.cxx
@@ -411,3 +415,9 @@ option(COUCHBASE_CXX_CLIENT_BUILD_EXAMPLES "Build example programs" TRUE)
 if (COUCHBASE_CXX_CLIENT_BUILD_EXAMPLES)
     add_subdirectory(examples)
 endif ()
+
+option(COUCHBASE_CXX_CLIENT_BUILD_TOOLS "Build tools" TRUE)
+if (COUCHBASE_CXX_CLIENT_BUILD_TOOLS)
+    add_subdirectory(third_party/docopt)
+    add_subdirectory(tools)
+endif ()

package/deps/couchbase-cxx-client/README.md

@@ -1,9 +1,9 @@
 # Couchbase C++ Client
 
 [![license](https://img.shields.io/github/license/couchbaselabs/couchbase-cxx-client?color=brightgreen)](https://opensource.org/licenses/Apache-2.0)
-[![linters](https://img.shields.io/github/actions/workflow/status/couchbaselabs/couchbase-cxx-client/linters.yml?branch=main&label=linters)](https://github.com/couchbaselabs/couchbase-cxx-client/actions?query=workflow%3Alinters)
-[![sanitizers](https://img.shields.io/github/actions/workflow/status/couchbaselabs/couchbase-cxx-client/sanitizers.yml?branch=main&label=sanitizers)](https://github.com/couchbaselabs/couchbase-cxx-client/actions?query=workflow%3Asanitizers)
-[![tests](https://img.shields.io/github/actions/workflow/status/couchbaselabs/couchbase-cxx-client/tests.yml?branch=main&label=tests)](https://github.com/couchbaselabs/couchbase-cxx-client/actions?query=workflow%3Atests)
+[![linters](https://img.shields.io/github/actions/workflow/status/couchbaselabs/couchbase-cxx-client/linters.yml?branch=main&label=linters)](https://github.com/couchbaselabs/couchbase-cxx-client/actions?query=workflow%3Alinters+branch%3Amain)
+[![sanitizers](https://img.shields.io/github/actions/workflow/status/couchbaselabs/couchbase-cxx-client/sanitizers.yml?branch=main&label=sanitizers)](https://github.com/couchbaselabs/couchbase-cxx-client/actions?query=workflow%3Asanitizers+branch%3Amain)
+[![tests](https://img.shields.io/github/actions/workflow/status/couchbaselabs/couchbase-cxx-client/tests.yml?branch=main&label=tests)](https://github.com/couchbaselabs/couchbase-cxx-client/actions?query=workflow%3Atests+branch%3Amain)
 
 This repo is under active development and is not yet ready for release as a public SDK.
 

package/deps/couchbase-cxx-client/cmake/CompilerWarnings.cmake

@@ -67,7 +67,6 @@ function(set_project_warnings project_name)
       -Wuseless-cast # warn if you perform a cast to the same type
       -Wdeprecated-declarations # warn if [[deprecated]] elements being used
   )
-
   set(CLANG_WARNINGS ${COMMON_WARNINGS}
       -Wshadow # warn the user if a variable declaration shadows one from a parent context
   )
@@ -77,6 +76,10 @@ function(set_project_warnings project_name)
   elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
     set(PROJECT_WARNINGS ${CLANG_WARNINGS})
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0.0" AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+      # One of the occurrences: https://github.com/chriskohlhoff/asio/pull/1176
+      set(GCC_WARNINGS ${GCC_WARNINGS} -Wno-error=null-dereference -Wno-error=array-bounds)
+    endif()
     set(PROJECT_WARNINGS ${GCC_WARNINGS})
   else()
     message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")

package/deps/couchbase-cxx-client/cmake/VersionInfo.cmake

@@ -9,7 +9,19 @@ if(NOT COUCHBASE_CXX_CLIENT_GIT_REVISION)
   else()
     set(COUCHBASE_CXX_CLIENT_GIT_REVISION "unknown")
   endif()
-  string(SUBSTRING "${COUCHBASE_CXX_CLIENT_GIT_REVISION}" 0 7 COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT)
+endif()
+string(SUBSTRING "${COUCHBASE_CXX_CLIENT_GIT_REVISION}" 0 7 COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT)
+
+if(NOT COUCHBASE_CXX_CLIENT_GIT_DESCRIBE)
+  if(GIT)
+    execute_process(
+            COMMAND git describe --always --long HEAD
+            WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            OUTPUT_VARIABLE COUCHBASE_CXX_CLIENT_GIT_DESCRIBE)
+  else()
+    set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "unknown")
+  endif()
 endif()
 
 string(TIMESTAMP COUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP "%Y-%m-%d %H:%M:%S" UTC)

package/deps/couchbase-cxx-client/cmake/build_version.hxx.in

@@ -30,5 +30,6 @@ constexpr auto COUCHBASE_CXX_CLIENT_VERSION_PATCH = @couchbase_cxx_client_VERSIO
 constexpr auto COUCHBASE_CXX_CLIENT_VERSION_BUILD = @couchbase_cxx_client_BUILD_NUMBER@;
 constexpr auto COUCHBASE_CXX_CLIENT_GIT_REVISION = "@COUCHBASE_CXX_CLIENT_GIT_REVISION@";
 constexpr auto COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT = "@COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT@";
+constexpr auto COUCHBASE_CXX_CLIENT_GIT_DESCRIBE = "@COUCHBASE_CXX_CLIENT_GIT_DESCRIBE@";
 #cmakedefine COUCHBASE_CXX_CLIENT_STATIC_STDLIB 1
 #cmakedefine COUCHBASE_CXX_CLIENT_STATIC_OPENSSL 1

package/deps/couchbase-cxx-client/core/cluster.hxx

@@ -88,17 +88,18 @@ class cluster : public std::enable_shared_from_this<cluster>
                 tracer_ = std::make_shared<tracing::noop_tracer>();
             }
         }
+        tracer_->start();
         // ignore the metrics options if a meter was passed in.
         if (nullptr != origin_.options().meter) {
             meter_ = origin_.options().meter;
         } else {
-
             if (origin_.options().enable_metrics) {
                 meter_ = std::make_shared<metrics::logging_meter>(ctx_, origin_.options().metrics_options);
             } else {
                 meter_ = std::make_shared<metrics::noop_meter>();
             }
         }
+        meter_->start();
         session_manager_->set_tracer(tracer_);
         if (origin_.options().enable_dns_srv) {
             auto [hostname, _] = origin_.next_address();
@@ -110,7 +111,7 @@ class cluster : public std::enable_shared_from_this<cluster>
                     [self, hostname = std::move(hostname), handler = std::forward<Handler>(handler)](origin::node_list nodes,
                                                                                                      std::error_code ec) mutable {
                         if (ec) {
-                            return handler(ec);
+                            return self->close([ec, handler = std::forward<Handler>(handler)]() mutable { handler(ec); });
                         }
                         if (!nodes.empty()) {
                             self->origin_.set_nodes(std::move(nodes));
@@ -141,7 +142,13 @@ class cluster : public std::enable_shared_from_this<cluster>
             self->session_manager_->close();
             handler();
             self->work_.reset();
+            if (self->tracer_) {
+                self->tracer_->stop();
+            }
             self->tracer_.reset();
+            if (self->meter_) {
+                self->meter_->stop();
+            }
             self->meter_.reset();
         }));
     }
@@ -395,7 +402,7 @@ class cluster : public std::enable_shared_from_this<cluster>
                 tls_.load_verify_file(origin_.options().trust_certificate, ec);
                 if (ec) {
                     CB_LOG_ERROR("[{}]: unable to load verify file \"{}\": {}", id_, origin_.options().trust_certificate, ec.message());
-                    return handler(ec);
+                    return close([ec, handler = std::forward<Handler>(handler)]() mutable { return handler(ec); });
                 }
             }
 #ifdef COUCHBASE_CXX_CLIENT_TLS_KEY_LOG_FILE
@@ -414,13 +421,13 @@ class cluster : public std::enable_shared_from_this<cluster>
                 tls_.use_certificate_chain_file(origin_.certificate_path(), ec);
                 if (ec) {
                     CB_LOG_ERROR("[{}]: unable to load certificate chain \"{}\": {}", id_, origin_.certificate_path(), ec.message());
-                    return handler(ec);
+                    return close([ec, handler = std::forward<Handler>(handler)]() mutable { return handler(ec); });
                 }
                 CB_LOG_DEBUG(R"([{}]: use TLS private key: "{}")", id_, origin_.key_path());
                 tls_.use_private_key_file(origin_.key_path(), asio::ssl::context::file_format::pem, ec);
                 if (ec) {
                     CB_LOG_ERROR("[{}]: unable to load private key \"{}\": {}", id_, origin_.key_path(), ec.message());
-                    return handler(ec);
+                    return close([ec, handler = std::forward<Handler>(handler)]() mutable { return handler(ec); });
                 }
             }
             session_ = io::mcbp_session(id_, ctx_, tls_, origin_, dns_srv_tracker_);
@@ -465,6 +472,9 @@ class cluster : public std::enable_shared_from_this<cluster>
                     }
                 });
             }
+            if (ec) {
+                return self->close([ec, handler = std::forward<Handler>(handler)]() mutable { handler(ec); });
+            }
             handler(ec);
         });
     }

package/deps/couchbase-cxx-client/core/impl/build_deferred_query_indexes.cxx

@@ -39,22 +39,24 @@ build_context(Response& resp)
              std::move(resp.ctx.http_body),
              std::move(resp.ctx.path) };
 }
-
 void
 initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                 std::string bucket_name,
                                 build_query_index_options::built options,
+                                query_context query_ctx,
+                                std::string collection_name,
                                 build_deferred_query_indexes_handler&& handler)
 {
     core->execute(
       operations::management::query_index_get_all_deferred_request{
         bucket_name,
-        options.scope_name.value_or(""),
-        options.collection_name.value_or(""),
+        "",
+        collection_name,
+        query_ctx,
         {},
         options.timeout,
       },
-      [core, bucket_name, options = std::move(options), handler = std::move(handler)](
+      [core, bucket_name, collection_name, options = std::move(options), query_ctx, handler = std::move(handler)](
         operations::management::query_index_get_all_deferred_response resp1) mutable {
           auto list_resp = std::move(resp1);
           if (list_resp.ctx.ec) {
@@ -66,8 +68,9 @@ initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
           core->execute(
             operations::management::query_index_build_request{
               std::move(bucket_name),
-              options.scope_name.value_or(""),
-              options.collection_name.value_or(""),
+              "",
+              collection_name,
+              query_ctx,
               std::move(list_resp.index_names),
               {},
               options.timeout,
@@ -78,4 +81,12 @@ initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
             });
       });
 }
+void
+initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                                std::string bucket_name,
+                                build_query_index_options::built options,
+                                build_deferred_query_indexes_handler&& handler)
+{
+    return initiate_build_deferred_indexes(core, std::move(bucket_name), options, {}, "", std::move(handler));
+}
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/cluster.cxx

@@ -169,7 +169,7 @@ initiate_cluster_connect(asio::io_service& io,
         auto c = couchbase::cluster(core);
         // create txns as we want to start cleanup immediately if configured with metadata_collection
         [[maybe_unused]] std::shared_ptr<couchbase::transactions::transactions> t = c.transactions();
-        handler(c, {});
+        handler(std::move(c), {});
     });
 }
 

package/deps/couchbase-cxx-client/core/impl/collection_query_index_manager.cxx

@@ -0,0 +1,93 @@
+/* -*- 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.
+ */
+
+#include <core/query_context.hxx>
+#include <couchbase/collection_query_index_manager.hxx>
+
+namespace couchbase
+{
+
+void
+collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_indexes_handler&& handler) const
+{
+    return core::impl::initiate_get_all_query_indexes(core_,
+                                                      "",
+                                                      options.build(),
+                                                      core::query_context(bucket_name_, scope_name_),
+                                                      collection_name_,
+                                                      std::forward<get_all_indexes_handler>(handler));
+}
+
+void
+collection_query_index_manager::create_index(std::string index_name,
+                                             std::vector<std::string> fields,
+                                             const create_query_index_options& options,
+                                             create_query_index_handler&& handler) const
+{
+    return core::impl::initiate_create_query_index(core_,
+                                                   "",
+                                                   std::move(index_name),
+                                                   std::move(fields),
+                                                   options.build(),
+                                                   { bucket_name_, scope_name_ },
+                                                   collection_name_,
+                                                   std::forward<create_query_index_handler>(handler));
+}
+
+void
+collection_query_index_manager::create_primary_index(const create_primary_query_index_options& options,
+                                                     create_query_index_handler&& handler) const
+{
+    return core::impl::initiate_create_primary_query_index(
+      core_, "", options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+
+void
+collection_query_index_manager::drop_primary_index(const drop_primary_query_index_options& options,
+                                                   drop_query_index_handler&& handler) const
+{
+    return core::impl::initiate_drop_primary_query_index(
+      core_, "", options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+void
+collection_query_index_manager::drop_index(std::string index_name,
+                                           const drop_query_index_options& options,
+                                           drop_query_index_handler&& handler) const
+{
+    return core::impl::initiate_drop_query_index(
+      core_, "", std::move(index_name), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+void
+collection_query_index_manager::build_deferred_indexes(const build_query_index_options& options,
+                                                       build_deferred_query_indexes_handler&& handler) const
+{
+    return core::impl::initiate_build_deferred_indexes(core_,
+                                                       "",
+                                                       options.build(),
+                                                       { bucket_name_, scope_name_ },
+                                                       collection_name_,
+                                                       std::forward<build_deferred_query_indexes_handler>(handler));
+}
+void
+collection_query_index_manager::watch_indexes(std::vector<std::string> index_names,
+                                              const watch_query_indexes_options& options,
+                                              watch_query_indexes_handler&& handler) const
+{
+    return core::impl::initiate_watch_query_indexes(
+      core_, "", std::move(index_names), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/configuration_profiles_registry.cxx

@@ -59,4 +59,15 @@ configuration_profiles_registry::apply_profile(const std::string& name, couchbas
 
     profile->apply(options);
 }
+
+auto
+configuration_profiles_registry::available_profiles() -> std::vector<std::string>
+{
+    std::vector<std::string> profile_names;
+    std::scoped_lock lock(registry::store_mutex);
+    for (const auto& [name, _] : registry::store) {
+        profile_names.push_back(name);
+    }
+    return profile_names;
+}
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/create_query_index.cxx

@@ -0,0 +1,119 @@
+/* -*- 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.
+ */
+
+#include <couchbase/error_codes.hxx>
+#include <couchbase/query_index_manager.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/management/query_index_create.hxx"
+
+namespace couchbase::core::impl
+{
+template<typename Response>
+static manager_error_context
+build_context(Response& resp)
+{
+    return { resp.ctx.ec,
+             resp.ctx.last_dispatched_to,
+             resp.ctx.last_dispatched_from,
+             resp.ctx.retry_attempts,
+             std::move(resp.ctx.retry_reasons),
+             std::move(resp.ctx.client_context_id),
+             resp.ctx.http_status,
+             std::move(resp.ctx.http_body),
+             std::move(resp.ctx.path) };
+}
+
+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)
+{
+    core->execute(
+      operations::management::query_index_create_request{
+        bucket_name,
+        "",
+        collection_name,
+        index_name,
+        fields,
+        query_ctx,
+        false,
+        options.ignore_if_exists,
+        options.condition,
+        options.deferred,
+        options.num_replicas,
+        {},
+        options.timeout,
+      },
+      [core, bucket_name, options = std::move(options), handler = std::move(handler)](
+        operations::management::query_index_create_response resp) { handler(build_context(resp)); });
+}
+
+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)
+{
+    initiate_create_query_index(
+      core, std::move(bucket_name), std::move(index_name), std::move(fields), options, {}, "", std::move(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,
+                                    query_context query_ctx,
+                                    std::string collection_name,
+                                    create_primary_query_index_handler&& handler)
+{
+    core->execute(
+      operations::management::query_index_create_request{
+        bucket_name,
+        "",
+        collection_name,
+        options.index_name.value_or(""),
+        {},
+        query_ctx,
+        true,
+        options.ignore_if_exists,
+        {},
+        options.deferred,
+        options.num_replicas,
+        {},
+        options.timeout,
+      },
+      [core, bucket_name, options = std::move(options), handler = std::move(handler)](
+        operations::management::query_index_create_response resp) { handler(build_context(resp)); });
+}
+
+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)
+{
+    initiate_create_primary_query_index(core, std::move(bucket_name), std::move(options), {}, "", std::move(handler));
+}
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/drop_query_index.cxx

@@ -0,0 +1,108 @@
+/* -*- 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.
+ */
+
+#include "couchbase/error_codes.hxx"
+#include "couchbase/query_index_manager.hxx"
+
+#include "core/cluster.hxx"
+#include "core/operations/management/query_index_drop.hxx"
+
+namespace couchbase::core::impl
+{
+template<typename Response>
+static manager_error_context
+build_context(Response& resp)
+{
+    return { resp.ctx.ec,
+             resp.ctx.last_dispatched_to,
+             resp.ctx.last_dispatched_from,
+             resp.ctx.retry_attempts,
+             std::move(resp.ctx.retry_reasons),
+             std::move(resp.ctx.client_context_id),
+             resp.ctx.http_status,
+             std::move(resp.ctx.http_body),
+             std::move(resp.ctx.path) };
+}
+
+void
+initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                          std::string bucket_name,
+                          std::string index_name,
+                          drop_query_index_options::built options,
+                          query_context query_context,
+                          std::string collection_name,
+                          drop_query_index_handler&& handler)
+{
+    core->execute(
+      operations::management::query_index_drop_request{
+        bucket_name,
+        "",
+        collection_name,
+        index_name,
+        query_context,
+        false,
+        options.ignore_if_not_exists,
+        {},
+        options.timeout,
+      },
+      [core, bucket_name, options = std::move(options), handler = std::move(handler)](
+        operations::management::query_index_drop_response resp) { handler(build_context(resp)); });
+}
+
+void
+initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                          std::string bucket_name,
+                          std::string index_name,
+                          couchbase::drop_query_index_options::built options,
+                          drop_query_index_handler&& handler)
+{
+    initiate_drop_query_index(core, std::move(bucket_name), std::move(index_name), options, {}, "", std::move(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,
+                                  query_context query_ctx,
+                                  std::string collection_name,
+                                  drop_primary_query_index_handler&& handler)
+{
+    core->execute(
+      operations::management::query_index_drop_request{
+        bucket_name,
+        "",
+        collection_name,
+        options.index_name.value_or(""),
+        query_ctx,
+        true,
+        options.ignore_if_not_exists,
+        {},
+        options.timeout,
+      },
+      [core, bucket_name, options = std::move(options), handler = std::move(handler)](
+        operations::management::query_index_drop_response resp) { handler(build_context(resp)); });
+}
+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)
+{
+    return initiate_drop_primary_query_index(core, std::move(bucket_name), options, {}, "", std::move(handler));
+}
+
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/get.cxx

@@ -59,7 +59,7 @@ initiate_get_operation(std::shared_ptr<couchbase::core::cluster> core,
       },
       [handler = std::move(handler)](operations::get_projected_response&& resp) mutable {
           std::optional<std::chrono::system_clock::time_point> expiry_time{};
-          if (resp.expiry) {
+          if (resp.expiry && resp.expiry.value() > 0) {
               expiry_time.emplace(std::chrono::seconds{ resp.expiry.value() });
           }
           return handler(std::move(resp.ctx), get_result{ resp.cas, { std::move(resp.value), resp.flags }, expiry_time });