couchbase 4.2.1 → 4.2.2

package/deps/couchbase-cxx-client/core/transactions/transactions_cleanup.cxx

@@ -64,9 +64,8 @@ transactions_cleanup::transactions_cleanup(std::shared_ptr<core::cluster> cluste
 static uint64_t
 byteswap64(uint64_t val)
 {
-    std::size_t ii;
     uint64_t ret = 0;
-    for (ii = 0; ii < sizeof(uint64_t); ii++) {
+    for (std::size_t ii = 0; ii < sizeof(uint64_t); ii++) {
         ret <<= 8ull;
         ret |= val & 0xffull;
         val >>= 8ull;
@@ -130,12 +129,11 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
         {
             std::lock_guard<std::mutex> lock(mutex_);
             if (collections_.end() == std::find(collections_.begin(), collections_.end(), keyspace)) {
-                lost_attempts_cleanup_log->info(
-                  "{} cleanup for {} ending, no longer in collection cleanup list", static_cast<void*>(this), keyspace);
+                CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup for {} ending, no longer in collection cleanup list", keyspace);
                 return;
             }
         }
-        lost_attempts_cleanup_log->info("{} cleanup for {} starting", static_cast<void*>(this), keyspace);
+        CB_LOST_ATTEMPT_CLEANUP_LOG_INFO("cleanup for {} starting", keyspace);
         // we are running, and collection is in the list, so lets clean it.
         try {
             auto details = get_active_clients(keyspace, client_uuid_);
@@ -145,11 +143,10 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
             std::chrono::microseconds cleanup_window =
               std::chrono::duration_cast<std::chrono::microseconds>(config_.cleanup_config.cleanup_window);
             auto start = std::chrono::steady_clock::now();
-            lost_attempts_cleanup_log->info("{} {} active clients (including this one), {} ATRs to check in {}ms",
-                                            static_cast<void*>(this),
-                                            details.num_active_clients,
-                                            all_atrs.size(),
-                                            config_.cleanup_config.cleanup_window.count());
+            CB_LOST_ATTEMPT_CLEANUP_LOG_INFO("{} active clients (including this one), {} ATRs to check in {}ms",
+                                             details.num_active_clients,
+                                             all_atrs.size(),
+                                             config_.cleanup_config.cleanup_window.count());
 
             for (auto it = all_atrs.begin() + details.index_of_this_client; it < all_atrs.end(); it += details.num_active_clients) {
                 auto atrs_left_for_this_client =
@@ -162,15 +159,14 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
                 // clean the ATR entry
                 std::string atr_id = *it;
                 if (!running_.load()) {
-                    lost_attempts_cleanup_log->debug("{} cleanup of {} complete", static_cast<void*>(this), keyspace);
+                    CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup of {} complete", keyspace);
                     return;
                 }
 
                 try {
                     handle_atr_cleanup({ keyspace.bucket, keyspace.scope, keyspace.collection, atr_id });
                 } catch (const std::exception& e) {
-                    lost_attempts_cleanup_log->error(
-                      "{} cleanup of atr {} failed with {}, moving on", static_cast<void*>(this), atr_id, e.what());
+                    CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup of atr {} failed with {}, moving on", atr_id, e.what());
                 }
 
                 auto atr_end = std::chrono::steady_clock::now();
@@ -178,7 +174,7 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
                 std::chrono::microseconds atr_left = budget_for_this_atr - atr_used;
 
                 // Too verbose to log, but leaving here commented as it may be useful later for internal debugging
-                /*lost_attempts_cleanup_log->info("{} {} atrs_left_for_this_client={} elapsed_in_cleanup_window={}us "
+                /*CB_LOST_ATTEMPT_CLEANUP_LOG_INFO("{} {} atrs_left_for_this_client={} elapsed_in_cleanup_window={}us "
                                             "remaining_in_cleanup_window={}us budget_for_this_atr={}us atr_used={}us atr_left={}us",
                                             bucket_name,
                                             atr_id,
@@ -194,7 +190,7 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
                 }
             }
         } catch (const std::exception& ex) {
-            lost_attempts_cleanup_log->error("{} cleanup failed with {}, trying again in 3 sec...", static_cast<void*>(this), ex.what());
+            CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup failed with {}, trying again in 3 sec...", ex.what());
             // we must have gotten an exception trying to get the client records.   Let's wait 3 sec and try again
             std::this_thread::sleep_for(std::chrono::seconds(3));
         }
@@ -219,13 +215,12 @@ transactions_cleanup::handle_atr_cleanup(const core::document_id& atr_id, std::v
                 if (results) {
                     results->emplace_back(cleanup_entry);
                 }
-                cleanup_entry.clean(lost_attempts_cleanup_log, results ? &results->back() : nullptr);
+                cleanup_entry.clean(results ? &results->back() : nullptr);
                 if (results) {
                     results->back().success(true);
                 }
             } catch (const std::exception& e) {
-                lost_attempts_cleanup_log->error(
-                  "{} cleanup of {} failed: {}, moving on", static_cast<void*>(this), cleanup_entry, e.what());
+                CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup of {} failed: {}, moving on", cleanup_entry, e.what());
                 if (results) {
                     results->back().success(false);
                 }
@@ -263,11 +258,11 @@ transactions_cleanup::create_client_record(const couchbase::transactions::transa
         wrap_operation_future(f);
 
     } catch (const client_error& e) {
-        lost_attempts_cleanup_log->trace("{} create_client_record got error {}", static_cast<void*>(this), e.what());
+        CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("create_client_record got error {}", e.what());
         auto ec = e.ec();
         switch (ec) {
             case FAIL_DOC_ALREADY_EXISTS:
-                lost_attempts_cleanup_log->trace("{} client record already exists, moving on", static_cast<void*>(this));
+                CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("client record already exists, moving on");
                 return;
             default:
                 throw;
@@ -313,7 +308,7 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
               details.override_expires = 0;
               if (res.values[0].status == subdoc_result::status_type::success) {
                   auto records = res.values[0].content_as();
-                  lost_attempts_cleanup_log->trace("client records: {}", core::utils::json::generate(records));
+                  CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("client records: {}", core::utils::json::generate(records));
                   for (const auto& [key, value] : records.get_object()) {
                       if (key == FIELD_OVERRIDE) {
                           for (const auto& [override, param] : value.get_object()) {
@@ -352,9 +347,9 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
               details.client_uuid = uuid;
               details.cas_now_nanos = now_ms * 1000000;
               details.override_active = (details.override_enabled && details.override_expires > details.cas_now_nanos);
-              lost_attempts_cleanup_log->trace("{} client details {}", static_cast<void*>(this), details);
+              CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("client details {}", details);
               if (details.override_active) {
-                  lost_attempts_cleanup_log->trace("{} override enabled, will not update record", static_cast<void*>(this));
+                  CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("override enabled, will not update record");
                   return details;
               }
 
@@ -373,8 +368,8 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
                     .create_path(),
               };
               for (std::size_t idx = 0; idx < std::min(details.expired_client_ids.size(), static_cast<std::size_t>(12)); idx++) {
-                  lost_attempts_cleanup_log->trace("adding {} to list of clients to be removed when updating this client",
-                                                   details.expired_client_ids[idx]);
+                  CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("adding {} to list of clients to be removed when updating this client",
+                                                    details.expired_client_ids[idx]);
                   mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
               }
               mutate_req.specs = mut_specs.specs();
@@ -385,7 +380,7 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
               wrap_durable_request(mutate_req, config_);
               auto mutate_barrier = std::make_shared<std::promise<result>>();
               auto mutate_f = mutate_barrier->get_future();
-              lost_attempts_cleanup_log->trace("updating record");
+              CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("updating record");
               cluster_->execute(mutate_req, [mutate_barrier](core::operations::mutate_in_response resp) {
                   mutate_barrier->set_value(result::create_from_subdoc_response(resp));
               });
@@ -393,17 +388,17 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
 
               // just update the cas, and return the details
               details.cas_now_nanos = res.cas;
-              lost_attempts_cleanup_log->debug("{} get_active_clients found {}", static_cast<void*>(this), details);
+              CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("get_active_clients found {}", details);
               return details;
           } catch (const client_error& e) {
               auto ec = e.ec();
               switch (ec) {
                   case FAIL_DOC_NOT_FOUND:
-                      lost_attempts_cleanup_log->debug("{} client record not found, creating new one", static_cast<void*>(this));
+                      CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("client record not found, creating new one");
                       create_client_record(keyspace);
                       throw retry_operation("Client record didn't exist. Creating and retrying");
                   default:
-                      throw; // retry_operation(fmt::format("got error '' while processing client record, retrying...", e.what()));
+                      throw;
               }
           }
       });
@@ -438,17 +433,16 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
                           barrier->set_value(result::create_from_subdoc_response(resp));
                       });
                       wrap_operation_future(f);
-                      lost_attempts_cleanup_log->debug("{} removed {} from {}", static_cast<void*>(this), uuid, keyspace);
+                      CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("removed {} from {}", uuid, keyspace);
                   } catch (const client_error& e) {
-                      lost_attempts_cleanup_log->debug("{} error removing client records {}", static_cast<void*>(this), e.what());
+                      CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("error removing client records {}", e.what());
                       auto ec = e.ec();
                       switch (ec) {
                           case FAIL_DOC_NOT_FOUND:
-                              lost_attempts_cleanup_log->debug("{} no client record in {}, ignoring", static_cast<void*>(this), keyspace);
+                              CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("no client record in {}, ignoring", keyspace);
                               return;
                           case FAIL_PATH_NOT_FOUND:
-                              lost_attempts_cleanup_log->debug(
-                                "{} client {} not in client record for {}, ignoring", static_cast<void*>(this), uuid, keyspace);
+                              CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("client {} not in client record for {}, ignoring", uuid, keyspace);
                               return;
                           default:
                               throw retry_operation("retry remove until timeout");
@@ -456,8 +450,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
                   }
               });
         } catch (const std::exception& e) {
-            lost_attempts_cleanup_log->error(
-              "{} Error removing client record {} from {}: {}", static_cast<void*>(this), uuid, keyspace, e.what());
+            CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("Error removing client record {} from {}: {}", uuid, keyspace, e.what());
         }
     }
 }
@@ -465,7 +458,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
 const atr_cleanup_stats
 transactions_cleanup::force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
 {
-    lost_attempts_cleanup_log->trace("{} starting force_cleanup_atr: atr_id {}", static_cast<void*>(this), atr_id);
+    CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("starting force_cleanup_atr: atr_id {}", atr_id);
     return handle_atr_cleanup(atr_id, &results);
 }
 
@@ -473,11 +466,11 @@ void
 transactions_cleanup::force_cleanup_entry(atr_cleanup_entry& entry, transactions_cleanup_attempt& attempt)
 {
     try {
-        entry.clean(attempt_cleanup_log, &attempt);
+        entry.clean(&attempt);
         attempt.success(true);
 
     } catch (const std::runtime_error& e) {
-        attempt_cleanup_log->error("error attempting to clean {}: {}", entry, e.what());
+        CB_ATTEMPT_CLEANUP_LOG_ERROR("error attempting to clean {}: {}", entry, e.what());
         attempt.success(false);
     }
 }
@@ -485,16 +478,16 @@ transactions_cleanup::force_cleanup_entry(atr_cleanup_entry& entry, transactions
 void
 transactions_cleanup::force_cleanup_attempts(std::vector<transactions_cleanup_attempt>& results)
 {
-    attempt_cleanup_log->trace("starting force_cleanup_attempts");
+    CB_ATTEMPT_CLEANUP_LOG_TRACE("starting force_cleanup_attempts");
     while (atr_queue_.size() > 0) {
         auto entry = atr_queue_.pop(false);
         if (!entry) {
-            attempt_cleanup_log->error("pop failed to return entry, but queue size {}", atr_queue_.size());
+            CB_ATTEMPT_CLEANUP_LOG_ERROR("pop failed to return entry, but queue size {}", atr_queue_.size());
             return;
         }
         results.emplace_back(*entry);
         try {
-            entry->clean(attempt_cleanup_log, &results.back());
+            entry->clean(&results.back());
             results.back().success(true);
         } catch (std::runtime_error&) {
             results.back().success(false);
@@ -506,27 +499,27 @@ void
 transactions_cleanup::attempts_loop()
 {
     try {
-        attempt_cleanup_log->debug("cleanup attempts loop starting...");
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup attempts loop starting...");
         while (interruptable_wait(cleanup_loop_delay_)) {
             while (auto entry = atr_queue_.pop()) {
                 if (!running_.load()) {
-                    attempt_cleanup_log->debug("loop stopping - {} entries on queue", atr_queue_.size());
+                    CB_ATTEMPT_CLEANUP_LOG_DEBUG("loop stopping - {} entries on queue", atr_queue_.size());
                     return;
                 }
                 if (entry) {
-                    attempt_cleanup_log->trace("beginning cleanup on {}", *entry);
+                    CB_ATTEMPT_CLEANUP_LOG_TRACE("beginning cleanup on {}", *entry);
                     try {
-                        entry->clean(attempt_cleanup_log);
+                        entry->clean();
                     } catch (...) {
                         // catch everything as we don't want to raise out of this thread
-                        attempt_cleanup_log->info("got error cleaning {}, leaving for lost txn cleanup", entry.value());
+                        CB_ATTEMPT_CLEANUP_LOG_DEBUG("got error cleaning {}, leaving for lost txn cleanup", entry.value());
                     }
                 }
             }
         }
-        attempt_cleanup_log->info("stopping - {} entries on queue", atr_queue_.size());
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("stopping - {} entries on queue", atr_queue_.size());
     } catch (const std::runtime_error& e) {
-        attempt_cleanup_log->error("got error \"{}\" in attempts_loop", e.what());
+        CB_ATTEMPT_CLEANUP_LOG_ERROR("got error \"{}\" in attempts_loop", e.what());
     }
 }
 
@@ -538,14 +531,14 @@ transactions_cleanup::add_attempt(attempt_context& ctx)
         case attempt_state::NOT_STARTED:
         case attempt_state::COMPLETED:
         case attempt_state::ROLLED_BACK:
-            attempt_cleanup_log->trace("attempt in state {}, not adding to cleanup", attempt_state_name(ctx_impl.state()));
+            CB_ATTEMPT_CLEANUP_LOG_TRACE("attempt in state {}, not adding to cleanup", attempt_state_name(ctx_impl.state()));
             return;
         default:
             if (config_.cleanup_config.cleanup_client_attempts) {
-                attempt_cleanup_log->debug("adding attempt {} to cleanup queue", ctx_impl.id());
+                CB_ATTEMPT_CLEANUP_LOG_DEBUG("adding attempt {} to cleanup queue", ctx_impl.id());
                 atr_queue_.push(ctx);
             } else {
-                attempt_cleanup_log->trace("not cleaning client attempts, ignoring {}", ctx_impl.id());
+                CB_ATTEMPT_CLEANUP_LOG_TRACE("not cleaning client attempts, ignoring {}", ctx_impl.id());
             }
     }
 }
@@ -564,7 +557,7 @@ transactions_cleanup::add_collection(couchbase::transactions::transaction_keyspa
             lost_attempt_cleanup_workers_.emplace_back([this, keyspace = collections_.back()]() { this->clean_collection(keyspace); });
         }
         lock.unlock();
-        lost_attempts_cleanup_log->info("added {} to lost transaction cleanup", keyspace);
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("added {} to lost transaction cleanup", keyspace);
     }
 }
 
@@ -578,15 +571,15 @@ transactions_cleanup::close()
     }
     if (cleanup_thr_.joinable()) {
         cleanup_thr_.join();
-        attempt_cleanup_log->info("cleanup attempt thread closed");
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup attempt thread closed");
     }
     for (auto& t : lost_attempt_cleanup_workers_) {
-        lost_attempts_cleanup_log->info("shutting down all lost attempt threads...");
+        CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("shutting down all lost attempt threads...");
         if (t.joinable()) {
             t.join();
         }
     }
-    lost_attempts_cleanup_log->info("all lost attempt cleanup threads closed");
+    CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("all lost attempt cleanup threads closed");
     if (true) {
         remove_client_record_from_all_buckets(client_uuid_);
     }

package/deps/couchbase-cxx-client/core/transactions/waitable_op_list.hxx

@@ -98,11 +98,11 @@ class waitable_op_list
         in_flight_--;
         if (mode_.mode == attempt_mode::modes::KV) {
             // wait until all in_flight ops are done
-            txn_log->trace("set_query_mode: waiting for in_flight ops to go to 0...");
+            CB_TXN_LOG_TRACE("set_query_mode: waiting for in_flight ops to go to 0...");
             cv_in_flight_.wait(lock, [this]() { return (0 == in_flight_); });
             // ok, now no outstanding ops(apart from the query that called this), and I have the lock, so...
             if (mode_.mode == attempt_mode::modes::KV) {
-                txn_log->trace("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
+                CB_TXN_LOG_TRACE("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
                 // still kv, so now (while blocking) set the mode
                 mode_.mode = attempt_mode::modes::QUERY;
                 // ok to unlock now, as any racing set_query_mode will wait for
@@ -117,10 +117,10 @@ class waitable_op_list
         }
         // you make it here, and someone else is currently setting the node (a byproduct of
         // calling the callback).  So wait for that.
-        txn_log->trace("set_query_mode: mode already query, waiting for node to be set...");
+        CB_TXN_LOG_TRACE("set_query_mode: mode already query, waiting for node to be set...");
         cv_query_.wait(lock, [this]() { return !mode_.query_node.empty(); });
         in_flight_++;
-        txn_log->trace("set_query_mode: node set, continuing...");
+        CB_TXN_LOG_TRACE("set_query_mode: node set, continuing...");
         lock.unlock();
         cb();
     }
@@ -145,7 +145,7 @@ class waitable_op_list
     {
         std::lock_guard<std::mutex> lock(mutex_);
         in_flight_--;
-        txn_log->trace("in_flight decremented to {}", in_flight_);
+        CB_TXN_LOG_TRACE("in_flight decremented to {}", in_flight_);
         assert(in_flight_ >= 0);
         if (0 == in_flight_) {
             cv_in_flight_.notify_all();
@@ -161,7 +161,7 @@ class waitable_op_list
             if (val > 0) {
                 in_flight_ += val;
             }
-            txn_log->trace("op count changed by {} to {}, {} in_flight", val, count_, in_flight_);
+            CB_TXN_LOG_TRACE("op count changed by {} to {}, {} in_flight", val, count_, in_flight_);
             assert(count_ >= 0);
             assert(in_flight_ >= 0);
             if (0 == count_) {
@@ -171,7 +171,7 @@ class waitable_op_list
                 cv_in_flight_.notify_all();
             }
         } else {
-            txn_log->error("operation attempted after commit/rollback");
+            CB_TXN_LOG_ERROR("operation attempted after commit/rollback");
             throw async_operation_conflict("Operation attempted after commit or rollback");
         }
     }

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

@@ -61,18 +61,6 @@ using async_logic = std::function<void(async_attempt_context&)>;
 using txn_complete_callback =
   std::function<void(std::optional<transaction_exception>, std::optional<::couchbase::transactions::transaction_result>)>;
 
-/**
- * @brief set log level for transactions
- */
-void
-set_transactions_log_level(core::logger::level level);
-
-/**
- * @brief create the loggers, using a custom spdlog::sink, if desired.
- */
-void
-create_loggers(core::logger::level level = core::logger::level::off, spdlog::sink_ptr = nullptr);
-
 /**
  * @mainpage
  * A transaction consists of a lambda containing all the operations you wish to perform within a transaction.

package/deps/couchbase-cxx-client/core/utils/binary.hxx

@@ -34,7 +34,7 @@ to_binary(const T* data, const std::size_t size) noexcept
     static_assert(sizeof(T) == 1);
     binary copy;
     copy.reserve(size);
-    std::transform(data, data + size, std::back_insert_iterator(copy), [](auto e) { return static_cast<std::byte>(e); });
+    copy.insert(copy.end(), reinterpret_cast<const std::byte*>(data), reinterpret_cast<const std::byte*>(data + size));
     return copy;
 }
 

package/deps/couchbase-cxx-client/core/utils/keyspace.hxx

@@ -0,0 +1,55 @@
+/* -*- 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 <fmt/format.h>
+#include <string>
+
+namespace couchbase::core::utils
+{
+template<typename Request>
+static bool
+check_query_management_request(const Request& req)
+{
+    // if there is a query_context, then bucket, scope should not be specified, but collection should be.
+    // collection should be.
+    if (req.query_ctx.has_value()) {
+        return !req.collection_name.empty() && req.bucket_name.empty() && req.scope_name.empty();
+    }
+    // otherwise, both scope and collection must be specified, if one is
+    // and bucket _must_ be there as well.
+    return !req.bucket_name.empty() &&
+           ((req.scope_name.empty() && req.collection_name.empty()) || (!req.scope_name.empty() && !req.collection_name.empty()));
+}
+
+template<typename Request>
+static std::string
+build_keyspace(const Request& req)
+{
+    // keyspace is just the collection if we have a query_context.
+    if (req.query_ctx.has_value()) {
+        return fmt::format("{}.`{}`", req.query_ctx.value(), req.collection_name);
+    }
+    // otherwise, build from the bucket, scope and collection names in request...
+    if (req.scope_name.empty() && req.collection_name.empty()) {
+        return fmt::format("{}:`{}`", req.namespace_id, req.bucket_name);
+    }
+    return fmt::format("{}:`{}`.`{}`.`{}`", req.namespace_id, req.bucket_name, req.scope_name, req.collection_name);
+}
+
+} // namespace couchbase::core::utils

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

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/common_options.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/manager_error_context.hxx>
 
 #include <functional>
@@ -36,40 +37,6 @@ namespace couchbase
 class build_query_index_options : public common_options<build_query_index_options>
 {
   public:
-    /**
-     * Sets the scope name for this query management operation.
-     *
-     * Please note that if the scope name is set, the {@link #collection_name} must also be set.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto scope_name(std::string scope_name) -> build_query_index_options&
-    {
-        scope_name_.emplace(std::move(scope_name));
-        return self();
-    }
-
-    /**
-     * Sets the collection name for this query management operation.
-     *
-     * Please note that if the collection name is set, the {@link #scope_name} must also be set.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto collection_name(std::string collection_name) -> build_query_index_options&
-    {
-        collection_name_.emplace(std::move(collection_name));
-        return self();
-    }
-
-    /**
-     * Immutable value object representing consistent options.
-     *
-     * @since 1.0.0
-     * @internal
-     */
     struct built : public common_options<build_query_index_options>::built {
         const std::optional<std::string> scope_name{};
         const std::optional<std::string> collection_name{};
@@ -87,18 +54,9 @@ class build_query_index_options : public common_options<build_query_index_option
      */
     [[nodiscard]] auto build() const -> built
     {
-        if (scope_name_.has_value() && !collection_name_.has_value()) {
-            throw std::system_error(errc::common::invalid_argument, "if a scope_name is provided, a collection_name must also be provided");
-        }
-        if (!scope_name_.has_value() && collection_name_.has_value()) {
-            throw std::system_error(errc::common::invalid_argument, "if a collection_name is provided, a scope_name must also be provided");
-        }
-        return { build_common_options(), scope_name_, collection_name_ };
-    }
 
-  private:
-    std::optional<std::string> scope_name_{};
-    std::optional<std::string> collection_name_{};
+        return { build_common_options() };
+    }
 };
 
 /**
@@ -113,6 +71,7 @@ using build_deferred_query_indexes_handler = std::function<void(couchbase::manag
 namespace core
 {
 class cluster;
+class query_context;
 namespace impl
 {
 
@@ -121,6 +80,14 @@ namespace impl
  * @internal
  */
 void
+initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> resp1,
+                                std::string bucket_name,
+                                build_query_index_options::built options,
+                                query_context query_ctx,
+                                std::string collection_name,
+                                build_deferred_query_indexes_handler&& handler);
+
+void
 initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> resp1,
                                 std::string bucket_name,
                                 build_query_index_options::built options,

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

@@ -141,7 +141,7 @@ class cluster
     template<typename Handler>
     void query(std::string statement, const query_options& options, Handler&& handler) const
     {
-        return core::impl::initiate_query_operation(core_, std::move(statement), {}, {}, options.build(), std::forward<Handler>(handler));
+        return core::impl::initiate_query_operation(core_, std::move(statement), {}, options.build(), std::forward<Handler>(handler));
     }
 
     /**

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

@@ -72,8 +72,10 @@ class cluster_options
     explicit cluster_options(password_authenticator authenticator)
       : username_{ std::move(authenticator.username_) }
       , password_{ std::move(authenticator.password_) }
-      , ldap_compatible_{ authenticator.ldap_compatible_ }
     {
+        if (authenticator.ldap_compatible_) {
+            sasl_mechanisms_ = { { "PLAIN" } };
+        }
     }
 
     /**
@@ -246,7 +248,7 @@ class cluster_options
         std::string password;
         std::string certificate_path;
         std::string key_path;
-        std::vector<std::string> allowed_sasl_mechanisms;
+        std::optional<std::vector<std::string>> allowed_sasl_mechanisms;
         compression_options::built compression;
         timeout_options::built timeouts;
         dns_options::built dns;
@@ -261,15 +263,12 @@ class cluster_options
 
     [[nodiscard]] auto build() const -> built
     {
-        static const std::vector<std::string> default_sasl_mechanisms{ "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
-        static const std::vector<std::string> ldap_sasl_mechanisms{ "PLAIN" };
-
         return {
             username_,
             password_,
             certificate_path_,
             key_path_,
-            ldap_compatible_ ? ldap_sasl_mechanisms : default_sasl_mechanisms,
+            sasl_mechanisms_,
             compression_.build(),
             timeouts_.build(),
             dns_.build(),
@@ -288,7 +287,7 @@ class cluster_options
     std::string password_{};
     std::string certificate_path_{};
     std::string key_path_{};
-    bool ldap_compatible_{ false };
+    std::optional<std::vector<std::string>> sasl_mechanisms_{};
 
     compression_options compression_{};
     timeout_options timeouts_{};

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/binary_collection.hxx>
 #include <couchbase/codec/default_json_transcoder.hxx>
+#include <couchbase/collection_query_index_manager.hxx>
 #include <couchbase/exists_options.hxx>
 #include <couchbase/expiry.hxx>
 #include <couchbase/get_all_replicas_options.hxx>
@@ -31,12 +32,14 @@
 #include <couchbase/lookup_in_specs.hxx>
 #include <couchbase/mutate_in_options.hxx>
 #include <couchbase/mutate_in_specs.hxx>
+#include <couchbase/query_options.hxx>
 #include <couchbase/remove_options.hxx>
 #include <couchbase/replace_options.hxx>
 #include <couchbase/touch_options.hxx>
 #include <couchbase/unlock_options.hxx>
 #include <couchbase/upsert_options.hxx>
 
+#include <fmt/format.h>
 #include <future>
 #include <memory>
 
@@ -991,6 +994,11 @@ class collection
         return future;
     }
 
+    [[nodiscard]] auto query_indexes() const -> collection_query_index_manager
+    {
+        return collection_query_index_manager(core_, bucket_name_, scope_name_, name_);
+    }
+
   private:
     friend class bucket;
     friend class scope;