couchbase 3.4.0 → 3.4.2

data/ext/couchbase/third_party/snappy/snappy.h

@@ -39,7 +39,9 @@
 #ifndef THIRD_PARTY_SNAPPY_SNAPPY_H__
 #define THIRD_PARTY_SNAPPY_SNAPPY_H__
 
-#include <cstddef>
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "snappy-stubs-public.h"
@@ -63,20 +65,27 @@ namespace snappy {
   // Also note that this leaves "*source" in a state that is unsuitable for
   // further operations, such as RawUncompress(). You will need to rewind
   // or recreate the source yourself before attempting any further calls.
-  bool GetUncompressedLength(Source* source, uint32* result);
+  bool GetUncompressedLength(Source* source, uint32_t* result);
 
   // ------------------------------------------------------------------------
   // Higher-level string based routines (should be sufficient for most users)
   // ------------------------------------------------------------------------
 
-  // Sets "*compressed" to the compressed version of "input[0,input_length-1]".
+  // Sets "*compressed" to the compressed version of "input[0..input_length-1]".
   // Original contents of *compressed are lost.
   //
   // REQUIRES: "input[]" is not an alias of "*compressed".
   size_t Compress(const char* input, size_t input_length,
                   std::string* compressed);
 
-  // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed".
+  // Same as `Compress` above but taking an `iovec` array as input. Note that
+  // this function preprocesses the inputs to compute the sum of
+  // `iov[0..iov_cnt-1].iov_len` before reading. To avoid this, use
+  // `RawCompressFromIOVec` below.
+  size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
+                           std::string* compressed);
+
+  // Decompresses "compressed[0..compressed_length-1]" to "*uncompressed".
   // Original contents of "*uncompressed" are lost.
   //
   // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
@@ -122,6 +131,12 @@ namespace snappy {
                    char* compressed,
                    size_t* compressed_length);
 
+  // Same as `RawCompress` above but taking an `iovec` array as input. Note that
+  // `uncompressed_length` is the total number of bytes to be read from the
+  // elements of `iov` (_not_ the number of elements in `iov`).
+  void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
+                            char* compressed, size_t* compressed_length);
+
   // Given data in "compressed[0..compressed_length-1]" generated by
   // calling the Snappy::Compress routine, this routine
   // stores the uncompressed data to

data/ext/couchbase.cxx

@@ -1820,8 +1820,9 @@ cb_extract_option_bool(bool& field, VALUE options, const char* name)
     }
 }
 
+template<typename Integer>
 static void
-cb_extract_option_number(std::size_t& field, VALUE options, const char* name)
+cb_extract_option_number(Integer& field, VALUE options, const char* name)
 {
     if (!NIL_P(options) && TYPE(options) == T_HASH) {
         VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
@@ -1830,10 +1831,10 @@ cb_extract_option_number(std::size_t& field, VALUE options, const char* name)
         }
         switch (TYPE(val)) {
             case T_FIXNUM:
-                field = FIX2ULONG(val);
+                field = static_cast<Integer>(FIX2ULONG(val));
                 break;
             case T_BIGNUM:
-                field = NUM2ULL(val);
+                field = static_cast<Integer>(NUM2ULL(val));
                 break;
             default:
                 throw ruby_exception(rb_eArgError, rb_sprintf("%s must be a Integer, but given %+" PRIsVALUE, name, val));
@@ -1884,6 +1885,25 @@ cb_extract_option_string(std::string& target, VALUE options, const char* name);
 static void
 cb_extract_option_symbol(VALUE& val, VALUE options, const char* name);
 
+static void
+cb_extract_dns_config(couchbase::core::io::dns::dns_config& config, VALUE options)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        return;
+    }
+
+    auto timeout{ couchbase::core::timeout_defaults::dns_srv_timeout };
+    cb_extract_option_milliseconds(timeout, options, "dns_srv_timeout");
+
+    std::string nameserver{ couchbase::core::io::dns::dns_config::default_nameserver };
+    cb_extract_option_string(nameserver, options, "dns_srv_nameserver");
+
+    std::uint16_t port{ couchbase::core::io::dns::dns_config::default_port };
+    cb_extract_option_number(port, options, "dns_srv_port");
+
+    config = couchbase::core::io::dns::dns_config(nameserver, port, timeout);
+}
+
 static VALUE
 cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE options)
 {
@@ -1983,13 +2003,14 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
         cb_extract_option_milliseconds(origin.options().analytics_timeout, options, "analytics_timeout");
         cb_extract_option_milliseconds(origin.options().search_timeout, options, "search_timeout");
         cb_extract_option_milliseconds(origin.options().management_timeout, options, "management_timeout");
-        cb_extract_option_milliseconds(origin.options().dns_srv_timeout, options, "dns_srv_timeout");
         cb_extract_option_milliseconds(origin.options().tcp_keep_alive_interval, options, "tcp_keep_alive_interval");
         cb_extract_option_milliseconds(origin.options().config_poll_interval, options, "config_poll_interval");
         cb_extract_option_milliseconds(origin.options().config_poll_floor, options, "config_poll_floor");
         cb_extract_option_milliseconds(origin.options().config_idle_redial_timeout, options, "config_idle_redial_timeout");
         cb_extract_option_milliseconds(origin.options().idle_http_connection_timeout, options, "idle_http_connection_timeout");
 
+        cb_extract_dns_config(origin.options().dns_config, options);
+
         cb_extract_option_number(origin.options().max_http_connections, options, "max_http_connections");
 
         cb_extract_option_bool(origin.options().enable_tls, options, "enable_tls");
@@ -5084,9 +5105,9 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE options)
         VALUE indexes = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
         for (const auto& idx : resp.indexes) {
             VALUE index = rb_hash_new();
-            rb_hash_aset(index, rb_id2sym(rb_intern("state")), cb_str_new(idx.state));
+            rb_hash_aset(index, rb_id2sym(rb_intern("state")), rb_id2sym(rb_intern(idx.state.c_str())));
             rb_hash_aset(index, rb_id2sym(rb_intern("name")), cb_str_new(idx.name));
-            rb_hash_aset(index, rb_id2sym(rb_intern("type")), cb_str_new(idx.type));
+            rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern(idx.type.c_str())));
             rb_hash_aset(index, rb_id2sym(rb_intern("is_primary")), idx.is_primary ? Qtrue : Qfalse);
             VALUE index_key = rb_ary_new_capa(static_cast<long>(idx.index_key.size()));
             for (const auto& key : idx.index_key) {
@@ -5463,16 +5484,473 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE optio
 }
 
 static VALUE
-cb_Backend_query_index_watch(VALUE /* self */, VALUE bucket_name, VALUE index_names, VALUE timeout, VALUE options)
+cb_Backend_collection_query_index_get_all(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::operations::management::query_index_get_all_request req{};
+        req.bucket_name = cb_string_new(bucket_name);
+        req.scope_name = cb_string_new(scope_name);
+        req.collection_name = cb_string_new(collection_name);
+        cb_extract_timeout(req, options);
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_get_all_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_get_all_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            cb_throw_error_code(resp.ctx, fmt::format("unable to get list of the indexes of the collection \"{}\"", req.collection_name));
+        }
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        VALUE indexes = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
+        for (const auto& idx : resp.indexes) {
+            VALUE index = rb_hash_new();
+            rb_hash_aset(index, rb_id2sym(rb_intern("state")), rb_id2sym(rb_intern(idx.state.c_str())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("name")), cb_str_new(idx.name));
+            rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern(idx.type.c_str())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("is_primary")), idx.is_primary ? Qtrue : Qfalse);
+            VALUE index_key = rb_ary_new_capa(static_cast<long>(idx.index_key.size()));
+            for (const auto& key : idx.index_key) {
+                rb_ary_push(index_key, cb_str_new(key));
+            }
+            rb_hash_aset(index, rb_id2sym(rb_intern("index_key")), index_key);
+            if (idx.collection_name) {
+                rb_hash_aset(index, rb_id2sym(rb_intern("collection_name")), cb_str_new(idx.collection_name.value()));
+            }
+            if (idx.scope_name) {
+                rb_hash_aset(index, rb_id2sym(rb_intern("scope_name")), cb_str_new(idx.scope_name.value()));
+            }
+            rb_hash_aset(index, rb_id2sym(rb_intern("bucket_name")), cb_str_new(idx.bucket_name));
+            if (idx.condition) {
+                rb_hash_aset(index, rb_id2sym(rb_intern("condition")), cb_str_new(idx.condition.value()));
+            }
+            if (idx.partition) {
+                rb_hash_aset(index, rb_id2sym(rb_intern("partition")), cb_str_new(idx.partition.value()));
+            }
+            rb_ary_push(indexes, index);
+        }
+
+        rb_hash_aset(res, rb_id2sym(rb_intern("indexes")), indexes);
+
+        return res;
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_collection_query_index_create(VALUE self,
+                                         VALUE bucket_name,
+                                         VALUE scope_name,
+                                         VALUE collection_name,
+                                         VALUE index_name,
+                                         VALUE fields,
+                                         VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
+    Check_Type(index_name, T_STRING);
+    Check_Type(fields, T_ARRAY);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::operations::management::query_index_create_request req{};
+        cb_extract_timeout(req, options);
+        req.bucket_name = cb_string_new(bucket_name);
+        req.scope_name = cb_string_new(scope_name);
+        req.collection_name = cb_string_new(collection_name);
+        req.index_name = cb_string_new(index_name);
+        auto fields_num = static_cast<std::size_t>(RARRAY_LEN(fields));
+        req.fields.reserve(fields_num);
+        for (std::size_t i = 0; i < fields_num; ++i) {
+            VALUE entry = rb_ary_entry(fields, static_cast<long>(i));
+            cb_check_type(entry, T_STRING);
+            req.fields.emplace_back(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)));
+        }
+        if (!NIL_P(options)) {
+            if (VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists"))); ignore_if_exists == Qtrue) {
+                req.ignore_if_exists = true;
+            } else if (ignore_if_exists == Qfalse) {
+                req.ignore_if_exists = false;
+            } /* else use backend default */
+            if (VALUE deferred = rb_hash_aref(options, rb_id2sym(rb_intern("deferred"))); deferred == Qtrue) {
+                req.deferred = true;
+            } else if (deferred == Qfalse) {
+                req.deferred = false;
+            } /* else use backend default */
+            if (VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas"))); !NIL_P(num_replicas)) {
+                req.num_replicas = NUM2UINT(num_replicas);
+            } /* else use backend default */
+            if (VALUE condition = rb_hash_aref(options, rb_id2sym(rb_intern("condition"))); !NIL_P(condition)) {
+                req.condition.emplace(cb_string_new(condition));
+            } /* else use backend default */
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_create_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_create_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to create index "{}" on the collection "{}" ({}: {}))",
+                                                req.index_name,
+                                                req.collection_name,
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(
+                  resp.ctx, fmt::format(R"(unable to create index "{}" on the collection "{}")", req.index_name, req.collection_name));
+            }
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_collection_query_index_drop(VALUE self,
+                                       VALUE bucket_name,
+                                       VALUE scope_name,
+                                       VALUE collection_name,
+                                       VALUE index_name,
+                                       VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
+    Check_Type(index_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::operations::management::query_index_drop_request req{};
+        cb_extract_timeout(req, options);
+        req.bucket_name = cb_string_new(bucket_name);
+        req.scope_name = cb_string_new(scope_name);
+        req.collection_name = cb_string_new(collection_name);
+        req.index_name = cb_string_new(index_name);
+        if (!NIL_P(options)) {
+            if (VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
+                ignore_if_does_not_exist == Qtrue) {
+                req.ignore_if_does_not_exist = true;
+            } else if (ignore_if_does_not_exist == Qfalse) {
+                req.ignore_if_does_not_exist = false;
+            } /* else use backend default */
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_drop_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_drop_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to drop index "{}" on the collection "{}" ({}: {}))",
+                                                req.index_name,
+                                                req.collection_name,
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(
+                  resp.ctx, fmt::format(R"(unable to drop index "{}" on the collection "{}")", req.index_name, req.collection_name));
+            }
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_collection_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::operations::management::query_index_create_request req{};
+        cb_extract_timeout(req, options);
+        req.is_primary = true;
+        req.bucket_name = cb_string_new(bucket_name);
+        req.scope_name = cb_string_new(scope_name);
+        req.collection_name = cb_string_new(collection_name);
+        if (!NIL_P(options)) {
+            if (VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists"))); ignore_if_exists == Qtrue) {
+                req.ignore_if_exists = true;
+            } else if (ignore_if_exists == Qfalse) {
+                req.ignore_if_exists = false;
+            } /* else use backend default */
+            if (VALUE deferred = rb_hash_aref(options, rb_id2sym(rb_intern("deferred"))); deferred == Qtrue) {
+                req.deferred = true;
+            } else if (deferred == Qfalse) {
+                req.deferred = false;
+            } /* else use backend default */
+            if (VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas"))); !NIL_P(num_replicas)) {
+                req.num_replicas = NUM2UINT(num_replicas);
+            } /* else use backend default */
+            if (VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name"))); TYPE(index_name) == T_STRING) {
+                req.index_name = cb_string_new(index_name);
+            } /* else use backend default */
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_create_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_create_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to create primary index on the collection "{}" ({}: {}))",
+                                                req.collection_name,
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(resp.ctx, fmt::format(R"(unable to create primary index on the collection "{}")", req.collection_name));
+            }
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_collection_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::operations::management::query_index_drop_request req{};
+        cb_extract_timeout(req, options);
+        req.is_primary = true;
+        req.bucket_name = cb_string_new(bucket_name);
+        req.scope_name = cb_string_new(scope_name);
+        req.collection_name = cb_string_new(collection_name);
+        if (!NIL_P(options)) {
+            if (VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
+                ignore_if_does_not_exist == Qtrue) {
+                req.ignore_if_does_not_exist = true;
+            } else if (ignore_if_does_not_exist == Qfalse) {
+                req.ignore_if_does_not_exist = false;
+            } /* else use backend default */
+            if (VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name"))); !NIL_P(index_name)) {
+                cb_check_type(options, T_STRING);
+                req.is_primary = false;
+                req.bucket_name = cb_string_new(index_name);
+            }
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_drop_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_drop_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to drop primary index on the collection "{}" ({}: {}))",
+                                                req.collection_name,
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(resp.ctx, fmt::format(R"(unable to drop primary index on the collection "{}")", req.collection_name));
+            }
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_collection_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE options)
 {
+    const auto& cluster = cb_backend_to_cluster(self);
+
     Check_Type(bucket_name, T_STRING);
-    Check_Type(index_names, T_ARRAY);
-    Check_Type(timeout, T_FIXNUM);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
     if (!NIL_P(options)) {
         Check_Type(options, T_HASH);
     }
 
-    return Qtrue;
+    try {
+        couchbase::core::operations::management::query_index_build_deferred_request req{};
+        cb_extract_timeout(req, options);
+        req.bucket_name = cb_string_new(bucket_name);
+        req.scope_name = cb_string_new(scope_name);
+        req.collection_name = cb_string_new(collection_name);
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_build_deferred_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_build_deferred_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to build deferred indexes on the collection "{}" ({}: {}))",
+                                                req.collection_name.value(),
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to build deferred indexes on the collection "{}")", req.collection_name.value()));
+            }
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
 }
 
 static void
@@ -6150,19 +6628,15 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
             }
         }
 
-        if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
-            !NIL_P(scope_name) && TYPE(scope_name) == T_STRING) {
-            req.scope_name.emplace(cb_string_new(scope_name));
-            VALUE collections = rb_hash_aref(options, rb_id2sym(rb_intern("collections")));
-            if (!NIL_P(collections)) {
-                cb_check_type(collections, T_ARRAY);
-                auto collections_size = static_cast<std::size_t>(RARRAY_LEN(collections));
-                req.collections.reserve(collections_size);
-                for (std::size_t i = 0; i < collections_size; ++i) {
-                    VALUE collection = rb_ary_entry(collections, static_cast<long>(i));
-                    cb_check_type(collection, T_STRING);
-                    req.collections.emplace_back(cb_string_new(collection));
-                }
+        VALUE collections = rb_hash_aref(options, rb_id2sym(rb_intern("collections")));
+        if (!NIL_P(collections)) {
+            cb_check_type(collections, T_ARRAY);
+            auto collections_size = static_cast<std::size_t>(RARRAY_LEN(collections));
+            req.collections.reserve(collections_size);
+            for (std::size_t i = 0; i < collections_size; ++i) {
+                VALUE collection = rb_ary_entry(collections, static_cast<long>(i));
+                cb_check_type(collection, T_STRING);
+                req.collections.emplace_back(cb_string_new(collection));
             }
         }
 
@@ -6366,12 +6840,12 @@ cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
         if (tls) {
             service_name = "_couchbases";
         }
-        auto barrier = std::make_shared<std::promise<couchbase::core::io::dns::dns_client::dns_srv_response>>();
+        auto barrier = std::make_shared<std::promise<couchbase::core::io::dns::dns_srv_response>>();
         auto f = barrier->get_future();
         client.query_srv(host_name,
                          service_name,
                          couchbase::core::io::dns::dns_config::system_config(),
-                         [barrier](couchbase::core::io::dns::dns_client::dns_srv_response&& resp) { barrier->set_value(std::move(resp)); });
+                         [barrier](couchbase::core::io::dns::dns_srv_response&& resp) { barrier->set_value(std::move(resp)); });
         ctx.run();
         auto resp = cb_wait_for_future(f);
         if (resp.ec) {
@@ -8132,7 +8606,13 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "query_index_drop", VALUE_FUNC(cb_Backend_query_index_drop), 3);
     rb_define_method(cBackend, "query_index_drop_primary", VALUE_FUNC(cb_Backend_query_index_drop_primary), 2);
     rb_define_method(cBackend, "query_index_build_deferred", VALUE_FUNC(cb_Backend_query_index_build_deferred), 2);
-    rb_define_method(cBackend, "query_index_watch", VALUE_FUNC(cb_Backend_query_index_watch), 4);
+
+    rb_define_method(cBackend, "collection_query_index_get_all", VALUE_FUNC(cb_Backend_collection_query_index_get_all), 4);
+    rb_define_method(cBackend, "collection_query_index_create", VALUE_FUNC(cb_Backend_collection_query_index_create), 6);
+    rb_define_method(cBackend, "collection_query_index_create_primary", VALUE_FUNC(cb_Backend_collection_query_index_create_primary), 4);
+    rb_define_method(cBackend, "collection_query_index_drop", VALUE_FUNC(cb_Backend_collection_query_index_drop), 5);
+    rb_define_method(cBackend, "collection_query_index_drop_primary", VALUE_FUNC(cb_Backend_collection_query_index_drop_primary), 4);
+    rb_define_method(cBackend, "collection_query_index_build_deferred", VALUE_FUNC(cb_Backend_collection_query_index_build_deferred), 4);
 
     rb_define_method(cBackend, "search_get_stats", VALUE_FUNC(cb_Backend_search_get_stats), 1);
     rb_define_method(cBackend, "search_index_get_all", VALUE_FUNC(cb_Backend_search_index_get_all), 1);