couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0.alpha.3-universal-darwin-19

data/ext/couchbase/couchbase.cxx

@@ -290,212 +290,213 @@ init_exceptions(VALUE mCouchbase)
     eXattrUnknownVirtualAttribute = rb_define_class_under(mError, "XattrUnknownVirtualAttribute", rb_eStandardError);
 }
 
-static NORETURN(void cb_raise_error_code(std::error_code ec, const std::string& message))
+static VALUE
+cb__map_error_code(std::error_code ec, const std::string& message)
 {
     if (ec.category() == couchbase::error::detail::get_common_category()) {
         switch (static_cast<couchbase::error::common_errc>(ec.value())) {
             case couchbase::error::common_errc::unambiguous_timeout:
-                rb_raise(eUnambiguousTimeout, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eUnambiguousTimeout, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::ambiguous_timeout:
-                rb_raise(eAmbiguousTimeout, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eAmbiguousTimeout, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::request_canceled:
-                rb_raise(eRequestCanceled, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eRequestCanceled, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::invalid_argument:
-                rb_raise(eInvalidArgument, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eInvalidArgument, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::service_not_available:
-                rb_raise(eServiceNotAvailable, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eServiceNotAvailable, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::internal_server_failure:
-                rb_raise(eInternalServerFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eInternalServerFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::authentication_failure:
-                rb_raise(eAuthenticationFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eAuthenticationFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::temporary_failure:
-                rb_raise(eTemporaryFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eTemporaryFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::parsing_failure:
-                rb_raise(eParsingFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eParsingFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::cas_mismatch:
-                rb_raise(eCasMismatch, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eCasMismatch, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::bucket_not_found:
-                rb_raise(eBucketNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eBucketNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::scope_not_found:
-                rb_raise(eScopeNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eScopeNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::collection_not_found:
-                rb_raise(eCollectionNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eCollectionNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::unsupported_operation:
-                rb_raise(eUnsupportedOperation, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eUnsupportedOperation, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::feature_not_available:
-                rb_raise(eFeatureNotAvailable, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eFeatureNotAvailable, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::encoding_failure:
-                rb_raise(eEncodingFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eEncodingFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::decoding_failure:
-                rb_raise(eDecodingFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDecodingFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::index_not_found:
-                rb_raise(eIndexNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eIndexNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::common_errc::index_exists:
-                rb_raise(eIndexExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eIndexExists, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_key_value_category()) {
         switch (static_cast<couchbase::error::key_value_errc>(ec.value())) {
             case couchbase::error::key_value_errc::document_not_found:
-                rb_raise(eDocumentNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDocumentNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::document_irretrievable:
-                rb_raise(eDocumentIrretrievable, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDocumentIrretrievable, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::document_locked:
-                rb_raise(eDocumentLocked, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDocumentLocked, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::value_too_large:
-                rb_raise(eValueTooLarge, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eValueTooLarge, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::document_exists:
-                rb_raise(eDocumentExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDocumentExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::durability_level_not_available:
-                rb_raise(eDurabilityLevelNotAvailable, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDurabilityLevelNotAvailable, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::durability_impossible:
-                rb_raise(eDurabilityImpossible, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDurabilityImpossible, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::durability_ambiguous:
-                rb_raise(eDurabilityAmbiguous, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDurabilityAmbiguous, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::durable_write_in_progress:
-                rb_raise(eDurableWriteInProgress, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDurableWriteInProgress, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::durable_write_re_commit_in_progress:
-                rb_raise(eDurableWriteReCommitInProgress, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDurableWriteReCommitInProgress, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::path_not_found:
-                rb_raise(ePathNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePathNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::path_mismatch:
-                rb_raise(ePathMismatch, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePathMismatch, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::path_invalid:
-                rb_raise(ePathInvalid, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePathInvalid, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::path_too_big:
-                rb_raise(ePathTooBig, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePathTooBig, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::path_too_deep:
-                rb_raise(ePathTooDeep, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePathTooDeep, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::value_too_deep:
-                rb_raise(eValueTooDeep, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eValueTooDeep, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::value_invalid:
-                rb_raise(eValueInvalid, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eValueInvalid, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::document_not_json:
-                rb_raise(eDocumentNotJson, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDocumentNotJson, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::number_too_big:
-                rb_raise(eNumberTooBig, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eNumberTooBig, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::delta_invalid:
-                rb_raise(eDeltaInvalid, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDeltaInvalid, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::path_exists:
-                rb_raise(ePathExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePathExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::xattr_unknown_macro:
-                rb_raise(eXattrUnknownMacro, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eXattrUnknownMacro, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::xattr_invalid_key_combo:
-                rb_raise(eXattrInvalidKeyCombo, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eXattrInvalidKeyCombo, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::xattr_unknown_virtual_attribute:
-                rb_raise(eXattrUnknownVirtualAttribute, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eXattrUnknownVirtualAttribute, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::key_value_errc::xattr_cannot_modify_virtual_attribute:
-                rb_raise(eXattrCannotModifyVirtualAttribute, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eXattrCannotModifyVirtualAttribute, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_query_category()) {
         switch (static_cast<couchbase::error::query_errc>(ec.value())) {
             case couchbase::error::query_errc::planning_failure:
-                rb_raise(ePlanningFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePlanningFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::query_errc::index_failure:
-                rb_raise(eIndexFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eIndexFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::query_errc::prepared_statement_failure:
-                rb_raise(ePreparedStatementFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(ePreparedStatementFailure, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_view_category()) {
         switch (static_cast<couchbase::error::view_errc>(ec.value())) {
             case couchbase::error::view_errc::view_not_found:
-                rb_raise(eViewNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eViewNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::view_errc::design_document_not_found:
-                rb_raise(eDesignDocumentNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDesignDocumentNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_analytics_category()) {
         switch (static_cast<couchbase::error::analytics_errc>(ec.value())) {
             case couchbase::error::analytics_errc::compilation_failure:
-                rb_raise(eCompilationFailure, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eCompilationFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::analytics_errc::job_queue_full:
-                rb_raise(eJobQueueFull, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eJobQueueFull, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::analytics_errc::dataset_not_found:
-                rb_raise(eDatasetNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDatasetNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::analytics_errc::dataverse_not_found:
-                rb_raise(eDataverseNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDataverseNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::analytics_errc::dataset_exists:
-                rb_raise(eDatasetExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDatasetExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::analytics_errc::dataverse_exists:
-                rb_raise(eDataverseExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eDataverseExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::analytics_errc::link_not_found:
-                rb_raise(eLinkNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eLinkNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_management_category()) {
         switch (static_cast<couchbase::error::management_errc>(ec.value())) {
             case couchbase::error::management_errc::collection_exists:
-                rb_raise(eCollectionExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eCollectionExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::management_errc::scope_exists:
-                rb_raise(eScopeExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eScopeExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::management_errc::user_not_found:
-                rb_raise(eUserNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eUserNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::management_errc::group_not_found:
-                rb_raise(eGroupNotFound, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eGroupNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::management_errc::user_exists:
-                rb_raise(eUserExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eUserExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::management_errc::bucket_exists:
-                rb_raise(eBucketExists, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eBucketExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
             case couchbase::error::management_errc::bucket_not_flushable:
-                rb_raise(eBucketNotFlushable, "%s: %s", message.c_str(), ec.message().c_str());
+                return rb_exc_new_cstr(eBucketNotFlushable, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     }
 
-    rb_raise(eBackendError, "%s: %s", message.c_str(), ec.message().c_str());
+    return rb_exc_new_cstr(eBackendError, fmt::format("{}: {}", message, ec.message()).c_str());
 }
 
 static VALUE
@@ -507,20 +508,26 @@ cb_Backend_open(VALUE self, VALUE hostname, VALUE username, VALUE password)
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
     }
+    VALUE exc = Qnil;
 
-    Check_Type(hostname, T_STRING);
-    Check_Type(username, T_STRING);
-    Check_Type(password, T_STRING);
-
-    couchbase::origin options;
-    options.hostname.assign(RSTRING_PTR(hostname), static_cast<size_t>(RSTRING_LEN(hostname)));
-    options.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
-    options.password.assign(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
-    auto barrier = std::make_shared<std::promise<std::error_code>>();
-    auto f = barrier->get_future();
-    backend->cluster->open(options, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
-    if (auto ec = f.get()) {
-        cb_raise_error_code(ec, fmt::format("unable open cluster at {}", options.hostname));
+    {
+        Check_Type(hostname, T_STRING);
+        Check_Type(username, T_STRING);
+        Check_Type(password, T_STRING);
+
+        couchbase::origin options;
+        options.hostname.assign(RSTRING_PTR(hostname), static_cast<size_t>(RSTRING_LEN(hostname)));
+        options.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
+        options.password.assign(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        backend->cluster->open(options, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        if (auto ec = f.get()) {
+            exc = cb__map_error_code(ec, fmt::format("unable open cluster at {}", options.hostname));
+        }
+    }
+    if (!NIL_P(exc)) {
+        rb_exc_raise(exc);
     }
 
     return Qnil;
@@ -546,20 +553,43 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket)
     }
 
     Check_Type(bucket, T_STRING);
-    std::string name(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
 
-    auto barrier = std::make_shared<std::promise<std::error_code>>();
-    auto f = barrier->get_future();
-    backend->cluster->open_bucket(name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
-    if (auto ec = f.get()) {
-        cb_raise_error_code(ec, fmt::format("unable open bucket \"{}\"", name));
+    VALUE exc = Qnil;
+    {
+        std::string name(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        backend->cluster->open_bucket(name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        if (auto ec = f.get()) {
+            exc = cb__map_error_code(ec, fmt::format("unable open bucket \"{}\"", name));
+        }
+    }
+    if (!NIL_P(exc)) {
+        rb_exc_raise(exc);
     }
 
     return Qtrue;
 }
 
+template<typename Request>
+void
+cb__extract_timeout(Request& req, VALUE timeout)
+{
+    if (!NIL_P(timeout)) {
+        switch (TYPE(timeout)) {
+            case T_FIXNUM:
+            case T_BIGNUM:
+                req.timeout = std::chrono::milliseconds(NUM2ULL(timeout));
+                break;
+            default:
+                rb_raise(rb_eArgError, "timeout must be an Integer");
+        }
+    }
+}
+
 static VALUE
-cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id)
+cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -572,29 +602,101 @@ cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id)
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::get_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {}", doc_id));
+            break;
+        }
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_get_projected(VALUE self,
+                                  VALUE bucket,
+                                  VALUE collection,
+                                  VALUE id,
+                                  VALUE timeout,
+                                  VALUE with_expiration,
+                                  VALUE projections,
+                                  VALUE preserve_array_indexes)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
 
-    couchbase::operations::get_request req{ doc_id };
-    auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::get_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable fetch {}", doc_id));
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
     }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
-    return res;
+    Check_Type(bucket, T_STRING);
+    Check_Type(collection, T_STRING);
+    Check_Type(id, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::get_projected_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        req.with_expiration = RTEST(with_expiration);
+        req.preserve_array_indexes = RTEST(preserve_array_indexes);
+        if (!NIL_P(projections)) {
+            Check_Type(projections, T_ARRAY);
+            auto entries_num = static_cast<size_t>(RARRAY_LEN(projections));
+            req.projections.reserve(entries_num);
+            for (size_t i = 0; i < entries_num; ++i) {
+                VALUE entry = rb_ary_entry(projections, static_cast<long>(i));
+                Check_Type(entry, T_STRING);
+                req.projections.emplace_back(std::string(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry))));
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_projected_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::get_projected_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch with projections {}", doc_id));
+            break;
+        }
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+        if (resp.expiration) {
+            rb_hash_aset(res, rb_id2sym(rb_intern("expiration")), UINT2NUM(resp.expiration.value()));
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE lock_time)
+cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE lock_time)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -608,31 +710,38 @@ cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VAL
     Check_Type(id, T_STRING);
     Check_Type(lock_time, T_FIXNUM);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
-    couchbase::operations::get_and_lock_request req{ doc_id };
-    req.lock_time = NUM2UINT(lock_time);
+        couchbase::operations::get_and_lock_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        req.lock_time = NUM2UINT(lock_time);
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_lock_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::get_and_lock_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable lock and fetch {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_lock_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::get_and_lock_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable lock and fetch {}", doc_id));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE expiration)
+cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiration)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -646,27 +755,34 @@ cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VA
     Check_Type(id, T_STRING);
     Check_Type(expiration, T_FIXNUM);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
-    couchbase::operations::get_and_touch_request req{ doc_id };
-    req.expiration = NUM2UINT(expiration);
+        couchbase::operations::get_and_touch_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        req.expiration = NUM2UINT(expiration);
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_touch_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::get_and_touch_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable fetch and touch {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_touch_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::get_and_touch_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch and touch {}", doc_id));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 template<typename Response>
@@ -687,7 +803,7 @@ cb__extract_mutation_result(Response resp)
 }
 
 static VALUE
-cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE expiration)
+cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiration)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -701,29 +817,36 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(id, T_STRING);
     Check_Type(expiration, T_FIXNUM);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
-    couchbase::operations::touch_request req{ doc_id };
-    req.expiration = NUM2UINT(expiration);
+        couchbase::operations::touch_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        req.expiration = NUM2UINT(expiration);
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::touch_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::touch_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to touch {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::touch_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::touch_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to touch {}", doc_id));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id)
+cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -736,46 +859,53 @@ cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id)
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
-    couchbase::operations::exists_request req{ doc_id };
-
-    auto barrier = std::make_shared<std::promise<couchbase::operations::exists_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::exists_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to exists {}", doc_id));
-    }
+        couchbase::operations::exists_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    rb_hash_aset(res, rb_id2sym(rb_intern("partition_id")), UINT2NUM(resp.partition_id));
-    switch (resp.status) {
-        case couchbase::operations::exists_response::observe_status::invalid:
-            rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("invalid")));
-            break;
-        case couchbase::operations::exists_response::observe_status::found:
-            rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("found")));
-            break;
-        case couchbase::operations::exists_response::observe_status::not_found:
-            rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("not_found")));
-            break;
-        case couchbase::operations::exists_response::observe_status::persisted:
-            rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("persisted")));
-            break;
-        case couchbase::operations::exists_response::observe_status::logically_deleted:
-            rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("logically_deleted")));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::exists_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::exists_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to exists {}", doc_id));
             break;
-    }
-    return res;
+        }
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        rb_hash_aset(res, rb_id2sym(rb_intern("partition_id")), UINT2NUM(resp.partition_id));
+        switch (resp.status) {
+            case couchbase::operations::exists_response::observe_status::invalid:
+                rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("invalid")));
+                break;
+            case couchbase::operations::exists_response::observe_status::found:
+                rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("found")));
+                break;
+            case couchbase::operations::exists_response::observe_status::not_found:
+                rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("not_found")));
+                break;
+            case couchbase::operations::exists_response::observe_status::persisted:
+                rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("persisted")));
+                break;
+            case couchbase::operations::exists_response::observe_status::logically_deleted:
+                rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("logically_deleted")));
+                break;
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE cas)
+cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE cas)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -788,36 +918,43 @@ cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
-    couchbase::operations::unlock_request req{ doc_id };
-    switch (TYPE(cas)) {
-        case T_FIXNUM:
-        case T_BIGNUM:
-            req.cas = NUM2ULL(cas);
-            break;
-        default:
-            rb_raise(rb_eArgError, "CAS must be an Integer");
-    }
+        couchbase::operations::unlock_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        switch (TYPE(cas)) {
+            case T_FIXNUM:
+            case T_BIGNUM:
+                req.cas = NUM2ULL(cas);
+                break;
+            default:
+                rb_raise(rb_eArgError, "CAS must be an Integer");
+        }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::unlock_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::unlock_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to unlock {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::unlock_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::unlock_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to unlock {}", doc_id));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, VALUE flags, VALUE options)
+cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE content, VALUE flags, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -832,56 +969,63 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(content, T_STRING);
     Check_Type(flags, T_FIXNUM);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-    std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
-
-    couchbase::operations::upsert_request req{ doc_id, value };
-    req.flags = FIX2UINT(flags);
-
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+        std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
+
+        couchbase::operations::upsert_request req{ doc_id, value };
+        cb__extract_timeout(req, timeout);
+        req.flags = FIX2UINT(flags);
+
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
             }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
+            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
+            if (!NIL_P(expiration)) {
+                Check_Type(expiration, T_FIXNUM);
+                req.expiration = FIX2UINT(expiration);
             }
         }
-        VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-        if (!NIL_P(expiration)) {
-            Check_Type(expiration, T_FIXNUM);
-            req.expiration = FIX2UINT(expiration);
-        }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to upsert {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert {}", doc_id));
+            break;
+        }
 
-    return cb__extract_mutation_result(resp);
+        return cb__extract_mutation_result(resp);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, VALUE flags, VALUE options)
+cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE content, VALUE flags, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -896,67 +1040,74 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
     Check_Type(content, T_STRING);
     Check_Type(flags, T_FIXNUM);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-    std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
-
-    couchbase::operations::replace_request req{ doc_id, value };
-    req.flags = FIX2UINT(flags);
-
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+        std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
+
+        couchbase::operations::replace_request req{ doc_id, value };
+        cb__extract_timeout(req, timeout);
+        req.flags = FIX2UINT(flags);
+
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
             }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
+            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
+            if (!NIL_P(expiration)) {
+                Check_Type(expiration, T_FIXNUM);
+                req.expiration = FIX2UINT(expiration);
             }
-        }
-        VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-        if (!NIL_P(expiration)) {
-            Check_Type(expiration, T_FIXNUM);
-            req.expiration = FIX2UINT(expiration);
-        }
-        VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
-        if (!NIL_P(cas)) {
-            switch (TYPE(cas)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    req.cas = NUM2ULL(cas);
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "CAS must be an Integer");
+            VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
+            if (!NIL_P(cas)) {
+                switch (TYPE(cas)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        req.cas = NUM2ULL(cas);
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "CAS must be an Integer");
+                }
             }
         }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::replace_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::replace_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to replace {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::replace_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::replace_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to replace {}", doc_id));
+            break;
+        }
 
-    return cb__extract_mutation_result(resp);
+        return cb__extract_mutation_result(resp);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, VALUE flags, VALUE options)
+cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE content, VALUE flags, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -971,56 +1122,63 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(content, T_STRING);
     Check_Type(flags, T_FIXNUM);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-    std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
-
-    couchbase::operations::insert_request req{ doc_id, value };
-    req.flags = FIX2UINT(flags);
-
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+        std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
+
+        couchbase::operations::insert_request req{ doc_id, value };
+        cb__extract_timeout(req, timeout);
+        req.flags = FIX2UINT(flags);
+
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
             }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
+            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
+            if (!NIL_P(expiration)) {
+                Check_Type(expiration, T_FIXNUM);
+                req.expiration = FIX2UINT(expiration);
             }
         }
-        VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-        if (!NIL_P(expiration)) {
-            Check_Type(expiration, T_FIXNUM);
-            req.expiration = FIX2UINT(expiration);
-        }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::insert_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::insert_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to insert {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::insert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::insert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to insert {}", doc_id));
+            break;
+        }
 
-    return cb__extract_mutation_result(resp);
+        return cb__extract_mutation_result(resp);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE options)
+cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1033,47 +1191,54 @@ cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-
-    couchbase::operations::remove_request req{ doc_id };
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
-            }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::remove_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
             }
         }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::remove_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::remove_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to remove {}", doc_id));
-    }
-    return cb__extract_mutation_result(resp);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::remove_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::remove_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to remove {}", doc_id));
+            break;
+        }
+        return cb__extract_mutation_result(resp);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE options)
+cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1086,76 +1251,83 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-
-    couchbase::operations::increment_request req{ doc_id };
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::increment_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
             }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
+            VALUE delta = rb_hash_aref(options, rb_id2sym(rb_intern("delta")));
+            if (!NIL_P(delta)) {
+                switch (TYPE(delta)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        req.delta = NUM2ULL(delta);
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "delta must be an Integer");
+                }
             }
-        }
-        VALUE delta = rb_hash_aref(options, rb_id2sym(rb_intern("delta")));
-        if (!NIL_P(delta)) {
-            switch (TYPE(delta)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    req.delta = NUM2ULL(delta);
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "delta must be an Integer");
+            VALUE initial_value = rb_hash_aref(options, rb_id2sym(rb_intern("initial_value")));
+            if (!NIL_P(initial_value)) {
+                switch (TYPE(initial_value)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        req.initial_value = NUM2ULL(initial_value);
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "initial_value must be an Integer");
+                }
             }
-        }
-        VALUE initial_value = rb_hash_aref(options, rb_id2sym(rb_intern("initial_value")));
-        if (!NIL_P(initial_value)) {
-            switch (TYPE(initial_value)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    req.initial_value = NUM2ULL(initial_value);
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "initial_value must be an Integer");
+            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
+            if (!NIL_P(expiration)) {
+                Check_Type(expiration, T_FIXNUM);
+                req.expiration = FIX2UINT(expiration);
             }
         }
-        VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-        if (!NIL_P(expiration)) {
-            Check_Type(expiration, T_FIXNUM);
-            req.expiration = FIX2UINT(expiration);
-        }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::increment_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::increment_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to increment {} by {}", doc_id, req.delta));
-    }
-    VALUE res = cb__extract_mutation_result(resp);
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content));
-    return res;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::increment_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::increment_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to increment {} by {}", doc_id, req.delta));
+            break;
+        }
+        VALUE res = cb__extract_mutation_result(resp);
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE options)
+cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1169,72 +1341,79 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
     Check_Type(id, T_STRING);
     Check_Type(options, T_HASH);
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-
-    couchbase::operations::decrement_request req{ doc_id };
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-            } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::decrement_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
             }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
+            VALUE delta = rb_hash_aref(options, rb_id2sym(rb_intern("delta")));
+            if (!NIL_P(delta)) {
+                switch (TYPE(delta)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        req.delta = NUM2ULL(delta);
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "delta must be an Integer");
+                }
             }
-        }
-        VALUE delta = rb_hash_aref(options, rb_id2sym(rb_intern("delta")));
-        if (!NIL_P(delta)) {
-            switch (TYPE(delta)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    req.delta = NUM2ULL(delta);
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "delta must be an Integer");
+            VALUE initial_value = rb_hash_aref(options, rb_id2sym(rb_intern("initial_value")));
+            if (!NIL_P(initial_value)) {
+                switch (TYPE(initial_value)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        req.initial_value = NUM2ULL(initial_value);
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "initial_value must be an Integer");
+                }
             }
-        }
-        VALUE initial_value = rb_hash_aref(options, rb_id2sym(rb_intern("initial_value")));
-        if (!NIL_P(initial_value)) {
-            switch (TYPE(initial_value)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    req.initial_value = NUM2ULL(initial_value);
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "initial_value must be an Integer");
+            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
+            if (!NIL_P(expiration)) {
+                Check_Type(expiration, T_FIXNUM);
+                req.expiration = FIX2UINT(expiration);
             }
         }
-        VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-        if (!NIL_P(expiration)) {
-            Check_Type(expiration, T_FIXNUM);
-            req.expiration = FIX2UINT(expiration);
-        }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::decrement_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::decrement_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to decrement {} by {}", doc_id, req.delta));
-    }
-    VALUE res = cb__extract_mutation_result(resp);
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content));
-    return res;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::decrement_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::decrement_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to decrement {} by {}", doc_id, req.delta));
+            break;
+        }
+        VALUE res = cb__extract_mutation_result(resp);
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
@@ -1276,6 +1455,9 @@ cb__map_subdoc_opcode(couchbase::protocol::subdoc_opcode opcode)
 
         case couchbase::protocol::subdoc_opcode::get_count:
             return rb_id2sym(rb_intern("count"));
+
+        case couchbase::protocol::subdoc_opcode::get_doc:
+            return rb_id2sym(rb_intern("get_doc"));
     }
     return rb_id2sym(rb_intern("unknown"));
 }
@@ -1338,7 +1520,7 @@ cb__map_subdoc_status(couchbase::protocol::status status)
 }
 
 static VALUE
-cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE access_deleted, VALUE specs)
+cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE access_deleted, VALUE specs)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1355,69 +1537,86 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         rb_raise(rb_eArgError, "Array with specs cannot be empty");
     }
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-
-    couchbase::operations::lookup_in_request req{ doc_id };
-    req.access_deleted = RTEST(access_deleted);
-    auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
-    req.specs.entries.reserve(entries_size);
-    for (size_t i = 0; i < entries_size; ++i) {
-        VALUE entry = rb_ary_entry(specs, static_cast<long>(i));
-        Check_Type(entry, T_HASH);
-        VALUE operation = rb_hash_aref(entry, rb_id2sym(rb_intern("opcode")));
-        Check_Type(operation, T_SYMBOL);
-        ID operation_id = rb_sym2id(operation);
-        couchbase::protocol::subdoc_opcode opcode;
-        if (operation_id == rb_intern("get") || operation_id == rb_intern("get_doc")) {
-            opcode = couchbase::protocol::subdoc_opcode::get;
-        } else if (operation_id == rb_intern("exists")) {
-            opcode = couchbase::protocol::subdoc_opcode::exists;
-        } else if (operation_id == rb_intern("count")) {
-            opcode = couchbase::protocol::subdoc_opcode::get_count;
-        } else {
-            rb_raise(rb_eArgError, "Unsupported operation for subdocument lookup");
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::lookup_in_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        req.access_deleted = RTEST(access_deleted);
+        auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
+        req.specs.entries.reserve(entries_size);
+        for (size_t i = 0; i < entries_size; ++i) {
+            VALUE entry = rb_ary_entry(specs, static_cast<long>(i));
+            Check_Type(entry, T_HASH);
+            VALUE operation = rb_hash_aref(entry, rb_id2sym(rb_intern("opcode")));
+            Check_Type(operation, T_SYMBOL);
+            ID operation_id = rb_sym2id(operation);
+            couchbase::protocol::subdoc_opcode opcode;
+            if (operation_id == rb_intern("get_doc")) {
+                opcode = couchbase::protocol::subdoc_opcode::get_doc;
+            } else if (operation_id == rb_intern("get")) {
+                opcode = couchbase::protocol::subdoc_opcode::get;
+            } else if (operation_id == rb_intern("exists")) {
+                opcode = couchbase::protocol::subdoc_opcode::exists;
+            } else if (operation_id == rb_intern("count")) {
+                opcode = couchbase::protocol::subdoc_opcode::get_count;
+            } else {
+                rb_raise(rb_eArgError, "Unsupported operation for subdocument lookup");
+            }
+            bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
+            VALUE path = rb_hash_aref(entry, rb_id2sym(rb_intern("path")));
+            Check_Type(path, T_STRING);
+            req.specs.add_spec(opcode, xattr, std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))));
         }
-        bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
-        VALUE path = rb_hash_aref(entry, rb_id2sym(rb_intern("path")));
-        Check_Type(path, T_STRING);
-        req.specs.add_spec(opcode, xattr, std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))));
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::lookup_in_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::lookup_in_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable fetch {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::lookup_in_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::lookup_in_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {}", doc_id));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
-    VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
-    rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
-    for (size_t i = 0; i < resp.fields.size(); ++i) {
-        VALUE entry = rb_hash_new();
-        rb_hash_aset(entry, rb_id2sym(rb_intern("exists")), resp.fields[i].exists ? Qtrue : Qfalse);
-        rb_hash_aset(
-          entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
-        rb_hash_aset(
-          entry, rb_id2sym(rb_intern("value")), rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
-        rb_hash_aset(entry, rb_id2sym(rb_intern("status")), cb__map_subdoc_status(resp.fields[i].status));
-        if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::get && resp.fields[i].path.empty()) {
-            rb_hash_aset(entry, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("get_doc")));
-        } else {
-            rb_hash_aset(entry, rb_id2sym(rb_intern("type")), cb__map_subdoc_opcode(resp.fields[i].opcode));
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+        VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
+        rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
+        for (size_t i = 0; i < resp.fields.size(); ++i) {
+            VALUE entry = rb_hash_new();
+            rb_hash_aset(entry, rb_id2sym(rb_intern("exists")), resp.fields[i].exists ? Qtrue : Qfalse);
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("value")),
+                         rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), cb__map_subdoc_status(resp.fields[i].status));
+            if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::get && resp.fields[i].path.empty()) {
+                rb_hash_aset(entry, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("get_doc")));
+            } else {
+                rb_hash_aset(entry, rb_id2sym(rb_intern("type")), cb__map_subdoc_opcode(resp.fields[i].opcode));
+            }
+            rb_ary_store(fields, static_cast<long>(i), entry);
         }
-        rb_ary_store(fields, static_cast<long>(i), entry);
-    }
-    return res;
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE access_deleted, VALUE specs, VALUE options)
+cb_Backend_document_mutate_in(VALUE self,
+                              VALUE bucket,
+                              VALUE collection,
+                              VALUE id,
+                              VALUE timeout,
+                              VALUE access_deleted,
+                              VALUE specs,
+                              VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1434,122 +1633,129 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         rb_raise(rb_eArgError, "Array with specs cannot be empty");
     }
 
-    couchbase::document_id doc_id;
-    doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
-    doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
-    doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
-
-    couchbase::operations::mutate_in_request req{ doc_id };
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-        if (!NIL_P(durability_level)) {
-            Check_Type(durability_level, T_SYMBOL);
-            ID level = rb_sym2id(durability_level);
-            if (level == rb_intern("none")) {
-                req.durability_level = couchbase::protocol::durability_level::none;
-            } else if (level == rb_intern("majority_and_persist_to_active")) {
-                req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-            } else if (level == rb_intern("persist_to_majority")) {
-                req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+
+        couchbase::operations::mutate_in_request req{ doc_id };
+        cb__extract_timeout(req, timeout);
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
+            if (!NIL_P(durability_level)) {
+                Check_Type(durability_level, T_SYMBOL);
+                ID level = rb_sym2id(durability_level);
+                if (level == rb_intern("none")) {
+                    req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority_and_persist_to_active")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (level == rb_intern("persist_to_majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    rb_raise(rb_eArgError, "Unknown durability level");
+                }
+                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
+                if (!NIL_P(durability_timeout)) {
+                    Check_Type(durability_timeout, T_FIXNUM);
+                    req.durability_timeout = FIX2UINT(durability_timeout);
+                }
+            }
+        }
+        req.access_deleted = RTEST(access_deleted);
+        auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
+        req.specs.entries.reserve(entries_size);
+        for (size_t i = 0; i < entries_size; ++i) {
+            VALUE entry = rb_ary_entry(specs, static_cast<long>(i));
+            Check_Type(entry, T_HASH);
+            VALUE operation = rb_hash_aref(entry, rb_id2sym(rb_intern("opcode")));
+            Check_Type(operation, T_SYMBOL);
+            ID operation_id = rb_sym2id(operation);
+            couchbase::protocol::subdoc_opcode opcode;
+            if (operation_id == rb_intern("dict_add")) {
+                opcode = couchbase::protocol::subdoc_opcode::dict_add;
+            } else if (operation_id == rb_intern("dict_upsert")) {
+                opcode = couchbase::protocol::subdoc_opcode::dict_upsert;
+            } else if (operation_id == rb_intern("remove")) {
+                opcode = couchbase::protocol::subdoc_opcode::remove;
+            } else if (operation_id == rb_intern("replace")) {
+                opcode = couchbase::protocol::subdoc_opcode::replace;
+            } else if (operation_id == rb_intern("array_push_last")) {
+                opcode = couchbase::protocol::subdoc_opcode::array_push_last;
+            } else if (operation_id == rb_intern("array_push_first")) {
+                opcode = couchbase::protocol::subdoc_opcode::array_push_first;
+            } else if (operation_id == rb_intern("array_insert")) {
+                opcode = couchbase::protocol::subdoc_opcode::array_insert;
+            } else if (operation_id == rb_intern("array_add_unique")) {
+                opcode = couchbase::protocol::subdoc_opcode::array_add_unique;
+            } else if (operation_id == rb_intern("counter")) {
+                opcode = couchbase::protocol::subdoc_opcode::counter;
             } else {
-                rb_raise(rb_eArgError, "Unknown durability level");
-            }
-            VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-            if (!NIL_P(durability_timeout)) {
-                Check_Type(durability_timeout, T_FIXNUM);
-                req.durability_timeout = FIX2UINT(durability_timeout);
-            }
-        }
-    }
-    req.access_deleted = RTEST(access_deleted);
-    auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
-    req.specs.entries.reserve(entries_size);
-    for (size_t i = 0; i < entries_size; ++i) {
-        VALUE entry = rb_ary_entry(specs, static_cast<long>(i));
-        Check_Type(entry, T_HASH);
-        VALUE operation = rb_hash_aref(entry, rb_id2sym(rb_intern("opcode")));
-        Check_Type(operation, T_SYMBOL);
-        ID operation_id = rb_sym2id(operation);
-        couchbase::protocol::subdoc_opcode opcode;
-        if (operation_id == rb_intern("dict_add")) {
-            opcode = couchbase::protocol::subdoc_opcode::dict_add;
-        } else if (operation_id == rb_intern("dict_upsert")) {
-            opcode = couchbase::protocol::subdoc_opcode::dict_upsert;
-        } else if (operation_id == rb_intern("remove")) {
-            opcode = couchbase::protocol::subdoc_opcode::remove;
-        } else if (operation_id == rb_intern("replace")) {
-            opcode = couchbase::protocol::subdoc_opcode::replace;
-        } else if (operation_id == rb_intern("array_push_last")) {
-            opcode = couchbase::protocol::subdoc_opcode::array_push_last;
-        } else if (operation_id == rb_intern("array_push_first")) {
-            opcode = couchbase::protocol::subdoc_opcode::array_push_first;
-        } else if (operation_id == rb_intern("array_insert")) {
-            opcode = couchbase::protocol::subdoc_opcode::array_insert;
-        } else if (operation_id == rb_intern("array_add_unique")) {
-            opcode = couchbase::protocol::subdoc_opcode::array_add_unique;
-        } else if (operation_id == rb_intern("counter")) {
-            opcode = couchbase::protocol::subdoc_opcode::counter;
-        } else {
-            rb_raise(rb_eArgError, "Unsupported operation for subdocument mutation: %+" PRIsVALUE, operation);
-        }
-        bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
-        bool create_parents = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("create_parents"))));
-        bool expand_macros = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("expand_macros"))));
-        VALUE path = rb_hash_aref(entry, rb_id2sym(rb_intern("path")));
-        Check_Type(path, T_STRING);
-        VALUE param = rb_hash_aref(entry, rb_id2sym(rb_intern("param")));
-        if (NIL_P(param)) {
-            req.specs.add_spec(opcode, xattr, std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))));
-        } else if (opcode == couchbase::protocol::subdoc_opcode::counter) {
-            Check_Type(param, T_FIXNUM);
-            req.specs.add_spec(opcode,
-                               xattr,
-                               create_parents,
-                               expand_macros,
-                               std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))),
-                               FIX2LONG(param));
-        } else {
-            Check_Type(param, T_STRING);
-            req.specs.add_spec(opcode,
-                               xattr,
-                               create_parents,
-                               expand_macros,
-                               std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))),
-                               std::string(RSTRING_PTR(param), static_cast<size_t>(RSTRING_LEN(param))));
+                rb_raise(rb_eArgError, "Unsupported operation for subdocument mutation: %+" PRIsVALUE, operation);
+            }
+            bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
+            bool create_parents = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("create_parents"))));
+            bool expand_macros = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("expand_macros"))));
+            VALUE path = rb_hash_aref(entry, rb_id2sym(rb_intern("path")));
+            Check_Type(path, T_STRING);
+            VALUE param = rb_hash_aref(entry, rb_id2sym(rb_intern("param")));
+            if (NIL_P(param)) {
+                req.specs.add_spec(opcode, xattr, std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))));
+            } else if (opcode == couchbase::protocol::subdoc_opcode::counter) {
+                Check_Type(param, T_FIXNUM);
+                req.specs.add_spec(opcode,
+                                   xattr,
+                                   create_parents,
+                                   expand_macros,
+                                   std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))),
+                                   FIX2LONG(param));
+            } else {
+                Check_Type(param, T_STRING);
+                req.specs.add_spec(opcode,
+                                   xattr,
+                                   create_parents,
+                                   expand_macros,
+                                   std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))),
+                                   std::string(RSTRING_PTR(param), static_cast<size_t>(RSTRING_LEN(param))));
+            }
         }
-    }
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::mutate_in_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute(req, [barrier](couchbase::operations::mutate_in_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to mutate {}", doc_id));
-    }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::mutate_in_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::mutate_in_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to mutate {}", doc_id));
+            break;
+        }
 
-    VALUE res = cb__extract_mutation_result(resp);
-    if (resp.first_error_index) {
-        rb_hash_aset(res, rb_id2sym(rb_intern("first_error_index")), ULONG2NUM(resp.first_error_index.value()));
-    }
-    VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
-    rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
-    for (size_t i = 0; i < resp.fields.size(); ++i) {
-        VALUE entry = rb_hash_new();
-        rb_hash_aset(
-          entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
-        if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::counter) {
-            rb_hash_aset(entry, rb_id2sym(rb_intern("value")), LONG2NUM(std::stoll(resp.fields[i].value)));
-        } else {
-            rb_hash_aset(entry,
-                         rb_id2sym(rb_intern("value")),
-                         rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+        VALUE res = cb__extract_mutation_result(resp);
+        if (resp.first_error_index) {
+            rb_hash_aset(res, rb_id2sym(rb_intern("first_error_index")), ULONG2NUM(resp.first_error_index.value()));
         }
-        rb_hash_aset(entry, rb_id2sym(rb_intern("status")), cb__map_subdoc_status(resp.fields[i].status));
-        rb_hash_aset(entry, rb_id2sym(rb_intern("type")), cb__map_subdoc_opcode(resp.fields[i].opcode));
-        rb_ary_store(fields, static_cast<long>(i), entry);
-    }
-    return res;
+        VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
+        rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
+        for (size_t i = 0; i < resp.fields.size(); ++i) {
+            VALUE entry = rb_hash_new();
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
+            if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::counter) {
+                rb_hash_aset(entry, rb_id2sym(rb_intern("value")), LONG2NUM(std::stoll(resp.fields[i].value)));
+            } else {
+                rb_hash_aset(entry,
+                             rb_id2sym(rb_intern("value")),
+                             rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+            }
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), cb__map_subdoc_status(resp.fields[i].status));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("type")), cb__map_subdoc_opcode(resp.fields[i].opcode));
+            rb_ary_store(fields, static_cast<long>(i), entry);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static int
@@ -1577,209 +1783,205 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
     Check_Type(statement, T_STRING);
     Check_Type(options, T_HASH);
 
-    couchbase::operations::query_request req;
-    req.statement.assign(RSTRING_PTR(statement), static_cast<size_t>(RSTRING_LEN(statement)));
-    VALUE client_context_id = rb_hash_aref(options, rb_id2sym(rb_intern("client_context_id")));
-    if (!NIL_P(client_context_id)) {
-        Check_Type(client_context_id, T_STRING);
-        req.client_context_id.assign(RSTRING_PTR(client_context_id), static_cast<size_t>(RSTRING_LEN(client_context_id)));
-    }
-    VALUE timeout = rb_hash_aref(options, rb_id2sym(rb_intern("timeout")));
-    if (!NIL_P(timeout)) {
-        switch (TYPE(timeout)) {
-            case T_FIXNUM:
-            case T_BIGNUM:
-                break;
-            default:
-                rb_raise(rb_eArgError, "timeout must be an Integer");
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_request req;
+        req.statement.assign(RSTRING_PTR(statement), static_cast<size_t>(RSTRING_LEN(statement)));
+        VALUE client_context_id = rb_hash_aref(options, rb_id2sym(rb_intern("client_context_id")));
+        if (!NIL_P(client_context_id)) {
+            Check_Type(client_context_id, T_STRING);
+            req.client_context_id.assign(RSTRING_PTR(client_context_id), static_cast<size_t>(RSTRING_LEN(client_context_id)));
         }
-        req.timeout = NUM2ULL(timeout);
-    }
-    VALUE adhoc = rb_hash_aref(options, rb_id2sym(rb_intern("adhoc")));
-    if (!NIL_P(adhoc)) {
-        req.adhoc = RTEST(adhoc);
-    }
-    VALUE metrics = rb_hash_aref(options, rb_id2sym(rb_intern("metrics")));
-    if (!NIL_P(metrics)) {
-        req.metrics = RTEST(metrics);
-    }
-    VALUE readonly = rb_hash_aref(options, rb_id2sym(rb_intern("readonly")));
-    if (!NIL_P(readonly)) {
-        req.readonly = RTEST(readonly);
-    }
-    VALUE scan_cap = rb_hash_aref(options, rb_id2sym(rb_intern("scan_cap")));
-    if (!NIL_P(scan_cap)) {
-        req.scan_cap = NUM2ULONG(scan_cap);
-    }
-    VALUE scan_wait = rb_hash_aref(options, rb_id2sym(rb_intern("scan_wait")));
-    if (!NIL_P(scan_wait)) {
-        req.scan_wait = NUM2ULONG(scan_wait);
-    }
-    VALUE max_parallelism = rb_hash_aref(options, rb_id2sym(rb_intern("max_parallelism")));
-    if (!NIL_P(max_parallelism)) {
-        req.max_parallelism = NUM2ULONG(max_parallelism);
-    }
-    VALUE pipeline_cap = rb_hash_aref(options, rb_id2sym(rb_intern("pipeline_cap")));
-    if (!NIL_P(pipeline_cap)) {
-        req.pipeline_cap = NUM2ULONG(pipeline_cap);
-    }
-    VALUE pipeline_batch = rb_hash_aref(options, rb_id2sym(rb_intern("pipeline_batch")));
-    if (!NIL_P(pipeline_batch)) {
-        req.pipeline_batch = NUM2ULONG(pipeline_batch);
-    }
-    VALUE profile = rb_hash_aref(options, rb_id2sym(rb_intern("profile")));
-    if (!NIL_P(profile)) {
-        Check_Type(profile, T_SYMBOL);
-        ID mode = rb_sym2id(profile);
-        if (mode == rb_intern("phases")) {
-            req.profile = couchbase::operations::query_request::profile_mode::phases;
-        } else if (mode == rb_intern("timings")) {
-            req.profile = couchbase::operations::query_request::profile_mode::timings;
-        } else if (mode == rb_intern("off")) {
-            req.profile = couchbase::operations::query_request::profile_mode::off;
-        }
-    }
-    VALUE positional_params = rb_hash_aref(options, rb_id2sym(rb_intern("positional_parameters")));
-    if (!NIL_P(positional_params)) {
-        Check_Type(positional_params, T_ARRAY);
-        auto entries_num = static_cast<size_t>(RARRAY_LEN(positional_params));
-        req.positional_parameters.reserve(entries_num);
-        for (size_t i = 0; i < entries_num; ++i) {
-            VALUE entry = rb_ary_entry(positional_params, static_cast<long>(i));
-            Check_Type(entry, T_STRING);
-            req.positional_parameters.emplace_back(
-              tao::json::from_string(std::string_view(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)))));
-        }
-    }
-    VALUE named_params = rb_hash_aref(options, rb_id2sym(rb_intern("named_parameters")));
-    if (!NIL_P(named_params)) {
-        Check_Type(named_params, T_HASH);
-        rb_hash_foreach(named_params, INT_FUNC(cb__for_each_named_param), reinterpret_cast<VALUE>(&req));
-    }
-    VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
-    if (!NIL_P(scan_consistency)) {
-        Check_Type(scan_consistency, T_SYMBOL);
-        ID type = rb_sym2id(scan_consistency);
-        if (type == rb_intern("not_bounded")) {
-            req.scan_consistency = couchbase::operations::query_request::scan_consistency_type::not_bounded;
-        } else if (type == rb_intern("request_plus")) {
-            req.scan_consistency = couchbase::operations::query_request::scan_consistency_type::request_plus;
-        }
-    }
-    VALUE mutation_state = rb_hash_aref(options, rb_id2sym(rb_intern("mutation_state")));
-    if (!NIL_P(mutation_state)) {
-        Check_Type(mutation_state, T_ARRAY);
-        auto state_size = static_cast<size_t>(RARRAY_LEN(mutation_state));
-        req.mutation_state.reserve(state_size);
-        for (size_t i = 0; i < state_size; ++i) {
-            VALUE token = rb_ary_entry(mutation_state, static_cast<long>(i));
-            Check_Type(token, T_HASH);
-            VALUE bucket_name = rb_hash_aref(token, rb_id2sym(rb_intern("bucket_name")));
-            Check_Type(bucket_name, T_STRING);
-            VALUE partition_id = rb_hash_aref(token, rb_id2sym(rb_intern("partition_id")));
-            Check_Type(partition_id, T_FIXNUM);
-            VALUE partition_uuid = rb_hash_aref(token, rb_id2sym(rb_intern("partition_uuid")));
-            switch (TYPE(partition_uuid)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "partition_uuid must be an Integer");
-            }
-            VALUE sequence_number = rb_hash_aref(token, rb_id2sym(rb_intern("sequence_number")));
-            switch (TYPE(sequence_number)) {
-                case T_FIXNUM:
-                case T_BIGNUM:
-                    break;
-                default:
-                    rb_raise(rb_eArgError, "sequence_number must be an Integer");
-            }
-            req.mutation_state.emplace_back(
-              couchbase::mutation_token{ NUM2ULL(partition_uuid),
-                                         NUM2ULL(sequence_number),
-                                         gsl::narrow_cast<std::uint16_t>(NUM2UINT(partition_id)),
-                                         std::string(RSTRING_PTR(bucket_name), static_cast<std::size_t>(RSTRING_LEN(bucket_name))) });
-        }
-    }
-
-    VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
-    if (!NIL_P(raw_params)) {
-        Check_Type(raw_params, T_HASH);
-        rb_hash_foreach(raw_params, INT_FUNC(cb__for_each_named_param), reinterpret_cast<VALUE>(&req));
-    }
-
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req, [barrier](couchbase::operations::query_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
-            const auto& first_error = resp.payload.meta_data.errors->front();
-            cb_raise_error_code(resp.ec,
-                                fmt::format("unable to query: \"{}{}\" ({}: {})",
-                                            req.statement.substr(0, 50),
-                                            req.statement.size() > 50 ? "..." : "",
-                                            first_error.code,
-                                            first_error.message));
-        } else {
-            cb_raise_error_code(
-              resp.ec, fmt::format("unable to query: \"{}{}\"", req.statement.substr(0, 50), req.statement.size() > 50 ? "..." : ""));
+        cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+        VALUE adhoc = rb_hash_aref(options, rb_id2sym(rb_intern("adhoc")));
+        if (!NIL_P(adhoc)) {
+            req.adhoc = RTEST(adhoc);
         }
-    }
-    VALUE res = rb_hash_new();
-    VALUE rows = rb_ary_new_capa(static_cast<long>(resp.payload.rows.size()));
-    rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
-    for (auto& row : resp.payload.rows) {
-        rb_ary_push(rows, rb_str_new(row.data(), static_cast<long>(row.size())));
-    }
-    VALUE meta = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
-    rb_hash_aset(meta,
-                 rb_id2sym(rb_intern("status")),
-                 rb_id2sym(rb_intern2(resp.payload.meta_data.status.data(), static_cast<long>(resp.payload.meta_data.status.size()))));
-    rb_hash_aset(meta,
-                 rb_id2sym(rb_intern("request_id")),
-                 rb_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
-    rb_hash_aset(
-      meta,
-      rb_id2sym(rb_intern("client_context_id")),
-      rb_str_new(resp.payload.meta_data.client_context_id.data(), static_cast<long>(resp.payload.meta_data.client_context_id.size())));
-    if (resp.payload.meta_data.signature) {
+        VALUE metrics = rb_hash_aref(options, rb_id2sym(rb_intern("metrics")));
+        if (!NIL_P(metrics)) {
+            req.metrics = RTEST(metrics);
+        }
+        VALUE readonly = rb_hash_aref(options, rb_id2sym(rb_intern("readonly")));
+        if (!NIL_P(readonly)) {
+            req.readonly = RTEST(readonly);
+        }
+        VALUE scan_cap = rb_hash_aref(options, rb_id2sym(rb_intern("scan_cap")));
+        if (!NIL_P(scan_cap)) {
+            req.scan_cap = NUM2ULONG(scan_cap);
+        }
+        VALUE scan_wait = rb_hash_aref(options, rb_id2sym(rb_intern("scan_wait")));
+        if (!NIL_P(scan_wait)) {
+            req.scan_wait = NUM2ULONG(scan_wait);
+        }
+        VALUE max_parallelism = rb_hash_aref(options, rb_id2sym(rb_intern("max_parallelism")));
+        if (!NIL_P(max_parallelism)) {
+            req.max_parallelism = NUM2ULONG(max_parallelism);
+        }
+        VALUE pipeline_cap = rb_hash_aref(options, rb_id2sym(rb_intern("pipeline_cap")));
+        if (!NIL_P(pipeline_cap)) {
+            req.pipeline_cap = NUM2ULONG(pipeline_cap);
+        }
+        VALUE pipeline_batch = rb_hash_aref(options, rb_id2sym(rb_intern("pipeline_batch")));
+        if (!NIL_P(pipeline_batch)) {
+            req.pipeline_batch = NUM2ULONG(pipeline_batch);
+        }
+        VALUE profile = rb_hash_aref(options, rb_id2sym(rb_intern("profile")));
+        if (!NIL_P(profile)) {
+            Check_Type(profile, T_SYMBOL);
+            ID mode = rb_sym2id(profile);
+            if (mode == rb_intern("phases")) {
+                req.profile = couchbase::operations::query_request::profile_mode::phases;
+            } else if (mode == rb_intern("timings")) {
+                req.profile = couchbase::operations::query_request::profile_mode::timings;
+            } else if (mode == rb_intern("off")) {
+                req.profile = couchbase::operations::query_request::profile_mode::off;
+            }
+        }
+        VALUE positional_params = rb_hash_aref(options, rb_id2sym(rb_intern("positional_parameters")));
+        if (!NIL_P(positional_params)) {
+            Check_Type(positional_params, T_ARRAY);
+            auto entries_num = static_cast<size_t>(RARRAY_LEN(positional_params));
+            req.positional_parameters.reserve(entries_num);
+            for (size_t i = 0; i < entries_num; ++i) {
+                VALUE entry = rb_ary_entry(positional_params, static_cast<long>(i));
+                Check_Type(entry, T_STRING);
+                req.positional_parameters.emplace_back(
+                  tao::json::from_string(std::string_view(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)))));
+            }
+        }
+        VALUE named_params = rb_hash_aref(options, rb_id2sym(rb_intern("named_parameters")));
+        if (!NIL_P(named_params)) {
+            Check_Type(named_params, T_HASH);
+            rb_hash_foreach(named_params, INT_FUNC(cb__for_each_named_param), reinterpret_cast<VALUE>(&req));
+        }
+        VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
+        if (!NIL_P(scan_consistency)) {
+            Check_Type(scan_consistency, T_SYMBOL);
+            ID type = rb_sym2id(scan_consistency);
+            if (type == rb_intern("not_bounded")) {
+                req.scan_consistency = couchbase::operations::query_request::scan_consistency_type::not_bounded;
+            } else if (type == rb_intern("request_plus")) {
+                req.scan_consistency = couchbase::operations::query_request::scan_consistency_type::request_plus;
+            }
+        }
+        VALUE mutation_state = rb_hash_aref(options, rb_id2sym(rb_intern("mutation_state")));
+        if (!NIL_P(mutation_state)) {
+            Check_Type(mutation_state, T_ARRAY);
+            auto state_size = static_cast<size_t>(RARRAY_LEN(mutation_state));
+            req.mutation_state.reserve(state_size);
+            for (size_t i = 0; i < state_size; ++i) {
+                VALUE token = rb_ary_entry(mutation_state, static_cast<long>(i));
+                Check_Type(token, T_HASH);
+                VALUE bucket_name = rb_hash_aref(token, rb_id2sym(rb_intern("bucket_name")));
+                Check_Type(bucket_name, T_STRING);
+                VALUE partition_id = rb_hash_aref(token, rb_id2sym(rb_intern("partition_id")));
+                Check_Type(partition_id, T_FIXNUM);
+                VALUE partition_uuid = rb_hash_aref(token, rb_id2sym(rb_intern("partition_uuid")));
+                switch (TYPE(partition_uuid)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "partition_uuid must be an Integer");
+                }
+                VALUE sequence_number = rb_hash_aref(token, rb_id2sym(rb_intern("sequence_number")));
+                switch (TYPE(sequence_number)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "sequence_number must be an Integer");
+                }
+                req.mutation_state.emplace_back(
+                  couchbase::mutation_token{ NUM2ULL(partition_uuid),
+                                             NUM2ULL(sequence_number),
+                                             gsl::narrow_cast<std::uint16_t>(NUM2UINT(partition_id)),
+                                             std::string(RSTRING_PTR(bucket_name), static_cast<std::size_t>(RSTRING_LEN(bucket_name))) });
+            }
+        }
+
+        VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
+        if (!NIL_P(raw_params)) {
+            Check_Type(raw_params, T_HASH);
+            rb_hash_foreach(raw_params, INT_FUNC(cb__for_each_named_param), reinterpret_cast<VALUE>(&req));
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req, [barrier](couchbase::operations::query_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
+                const auto& first_error = resp.payload.meta_data.errors->front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to query: \"{}{}\" ({}: {})",
+                                                     req.statement.substr(0, 50),
+                                                     req.statement.size() > 50 ? "..." : "",
+                                                     first_error.code,
+                                                     first_error.message));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to query: \"{}{}\"", req.statement.substr(0, 50), req.statement.size() > 50 ? "..." : ""));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        VALUE rows = rb_ary_new_capa(static_cast<long>(resp.payload.rows.size()));
+        rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
+        for (auto& row : resp.payload.rows) {
+            rb_ary_push(rows, rb_str_new(row.data(), static_cast<long>(row.size())));
+        }
+        VALUE meta = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
         rb_hash_aset(meta,
-                     rb_id2sym(rb_intern("signature")),
-                     rb_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
-    }
-    if (resp.payload.meta_data.profile) {
+                     rb_id2sym(rb_intern("status")),
+                     rb_id2sym(rb_intern2(resp.payload.meta_data.status.data(), static_cast<long>(resp.payload.meta_data.status.size()))));
         rb_hash_aset(meta,
-                     rb_id2sym(rb_intern("profile")),
-                     rb_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
-    }
-    metrics = rb_hash_new();
-    rb_hash_aset(meta, rb_id2sym(rb_intern("metrics")), metrics);
-    rb_hash_aset(metrics,
-                 rb_id2sym(rb_intern("elapsed_time")),
-                 rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
-                            static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
-    rb_hash_aset(metrics,
-                 rb_id2sym(rb_intern("execution_time")),
-                 rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
-                            static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
-    rb_hash_aset(metrics, rb_id2sym(rb_intern("result_count")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
-    rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
-    if (resp.payload.meta_data.metrics.sort_count) {
-        rb_hash_aset(metrics, rb_id2sym(rb_intern("sort_count")), ULL2NUM(*resp.payload.meta_data.metrics.sort_count));
-    }
-    if (resp.payload.meta_data.metrics.mutation_count) {
-        rb_hash_aset(metrics, rb_id2sym(rb_intern("mutation_count")), ULL2NUM(*resp.payload.meta_data.metrics.mutation_count));
-    }
-    if (resp.payload.meta_data.metrics.error_count) {
-        rb_hash_aset(metrics, rb_id2sym(rb_intern("error_count")), ULL2NUM(*resp.payload.meta_data.metrics.error_count));
-    }
-    if (resp.payload.meta_data.metrics.warning_count) {
-        rb_hash_aset(metrics, rb_id2sym(rb_intern("warning_count")), ULL2NUM(*resp.payload.meta_data.metrics.warning_count));
-    }
+                     rb_id2sym(rb_intern("request_id")),
+                     rb_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
+        rb_hash_aset(
+          meta,
+          rb_id2sym(rb_intern("client_context_id")),
+          rb_str_new(resp.payload.meta_data.client_context_id.data(), static_cast<long>(resp.payload.meta_data.client_context_id.size())));
+        if (resp.payload.meta_data.signature) {
+            rb_hash_aset(meta,
+                         rb_id2sym(rb_intern("signature")),
+                         rb_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
+        }
+        if (resp.payload.meta_data.profile) {
+            rb_hash_aset(meta,
+                         rb_id2sym(rb_intern("profile")),
+                         rb_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
+        }
+        metrics = rb_hash_new();
+        rb_hash_aset(meta, rb_id2sym(rb_intern("metrics")), metrics);
+        rb_hash_aset(metrics,
+                     rb_id2sym(rb_intern("elapsed_time")),
+                     rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
+                                static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
+        rb_hash_aset(metrics,
+                     rb_id2sym(rb_intern("execution_time")),
+                     rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
+                                static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("result_count")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
+        if (resp.payload.meta_data.metrics.sort_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("sort_count")), ULL2NUM(*resp.payload.meta_data.metrics.sort_count));
+        }
+        if (resp.payload.meta_data.metrics.mutation_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("mutation_count")), ULL2NUM(*resp.payload.meta_data.metrics.mutation_count));
+        }
+        if (resp.payload.meta_data.metrics.error_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("error_count")), ULL2NUM(*resp.payload.meta_data.metrics.error_count));
+        }
+        if (resp.payload.meta_data.metrics.warning_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("warning_count")), ULL2NUM(*resp.payload.meta_data.metrics.warning_count));
+        }
 
-    return res;
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static void
@@ -1878,7 +2080,7 @@ cb__generate_bucket_settings(VALUE bucket, couchbase::operations::bucket_setting
 }
 
 static VALUE
-cb_Backend_bucket_create(VALUE self, VALUE bucket_settings)
+cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1888,23 +2090,31 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings)
     }
 
     Check_Type(bucket_settings, T_HASH);
-    couchbase::operations::bucket_create_request req{};
-    cb__generate_bucket_settings(bucket_settings, req.bucket, true);
-    auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_create_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::bucket_create_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec,
-                            fmt::format("unable to create bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
-    }
 
-    return Qtrue;
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::bucket_create_request req{};
+        cb__extract_timeout(req, timeout);
+        cb__generate_bucket_settings(bucket_settings, req.bucket, true);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::bucket_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec, fmt::format("unable to create bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
+            break;
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_bucket_update(VALUE self, VALUE bucket_settings)
+cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1914,23 +2124,29 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings)
     }
 
     Check_Type(bucket_settings, T_HASH);
-    couchbase::operations::bucket_update_request req{};
-    cb__generate_bucket_settings(bucket_settings, req.bucket, false);
-    auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_update_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::bucket_update_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec,
-                            fmt::format("unable to update bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
-    }
-
-    return Qtrue;
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::bucket_update_request req{};
+        cb__extract_timeout(req, timeout);
+        cb__generate_bucket_settings(bucket_settings, req.bucket, false);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_update_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::bucket_update_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec, fmt::format("unable to update bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_bucket_drop(VALUE self, VALUE bucket_name)
+cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1941,21 +2157,28 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name)
 
     Check_Type(bucket_name, T_STRING);
 
-    couchbase::operations::bucket_drop_request req{};
-    req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_drop_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req, [barrier](couchbase::operations::bucket_drop_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
-    }
-
-    return Qtrue;
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::bucket_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::bucket_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_bucket_flush(VALUE self, VALUE bucket_name)
+cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1966,17 +2189,25 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name)
 
     Check_Type(bucket_name, T_STRING);
 
-    couchbase::operations::bucket_flush_request req{};
-    req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_flush_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req, [barrier](couchbase::operations::bucket_flush_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
-    }
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::bucket_flush_request req{};
+        cb__extract_timeout(req, timeout);
+        req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_flush_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::bucket_flush_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
+            break;
+        }
 
-    return Qtrue;
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static void
@@ -2056,7 +2287,7 @@ cb__extract_bucket_settings(const couchbase::operations::bucket_settings& entry,
 }
 
 static VALUE
-cb_Backend_bucket_get_all(VALUE self)
+cb_Backend_bucket_get_all(VALUE self, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2065,28 +2296,35 @@ cb_Backend_bucket_get_all(VALUE self)
         rb_raise(rb_eArgError, "Cluster has been closed already");
     }
 
-    couchbase::operations::bucket_get_all_request req{};
-    auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_get_all_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::bucket_get_all_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, "unable to get list of the buckets of the cluster");
-    }
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::bucket_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::bucket_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to get list of the buckets of the cluster");
+            break;
+        }
 
-    VALUE res = rb_ary_new_capa(static_cast<long>(resp.buckets.size()));
-    for (const auto& entry : resp.buckets) {
-        VALUE bucket = rb_hash_new();
-        cb__extract_bucket_settings(entry, bucket);
-        rb_ary_push(res, bucket);
-    }
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.buckets.size()));
+        for (const auto& entry : resp.buckets) {
+            VALUE bucket = rb_hash_new();
+            cb__extract_bucket_settings(entry, bucket);
+            rb_ary_push(res, bucket);
+        }
 
-    return res;
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_bucket_get(VALUE self, VALUE bucket_name)
+cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2097,20 +2335,28 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name)
 
     Check_Type(bucket_name, T_STRING);
 
-    couchbase::operations::bucket_get_request req{};
-    req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_get_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req, [barrier](couchbase::operations::bucket_get_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to locate bucket \"{}\" on the cluster", req.name));
-    }
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::bucket_get_request req{};
+        cb__extract_timeout(req, timeout);
+        req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::bucket_get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to locate bucket \"{}\" on the cluster", req.name));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    cb__extract_bucket_settings(resp.bucket, res);
+        VALUE res = rb_hash_new();
+        cb__extract_bucket_settings(resp.bucket, res);
 
-    return res;
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
@@ -2123,22 +2369,29 @@ cb_Backend_cluster_enable_developer_preview(VALUE self)
         rb_raise(rb_eArgError, "Cluster has been closed already");
     }
 
-    couchbase::operations::cluster_developer_preview_enable_request req{};
-    auto barrier = std::make_shared<std::promise<couchbase::operations::cluster_developer_preview_enable_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(
-      req, [barrier](couchbase::operations::cluster_developer_preview_enable_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to enable developer preview for this cluster"));
-    }
-    spdlog::critical("Developer preview cannot be disabled once it is enabled. If you enter developer preview mode you will not be able to "
-                     "upgrade. DO NOT USE IN PRODUCTION.");
-    return Qtrue;
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::cluster_developer_preview_enable_request req{};
+        auto barrier = std::make_shared<std::promise<couchbase::operations::cluster_developer_preview_enable_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::cluster_developer_preview_enable_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to enable developer preview for this cluster"));
+            break;
+        }
+        spdlog::critical(
+          "Developer preview cannot be disabled once it is enabled. If you enter developer preview mode you will not be able to "
+          "upgrade. DO NOT USE IN PRODUCTION.");
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_scope_get_all(VALUE self, VALUE bucket_name)
+cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2149,41 +2402,48 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name)
 
     Check_Type(bucket_name, T_STRING);
 
-    couchbase::operations::scope_get_all_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::scope_get_all_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::scope_get_all_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to get list of the scopes of the bucket \"{}\"", req.bucket_name));
-    }
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::scope_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::scope_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::scope_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to get list of the scopes of the bucket \"{}\"", req.bucket_name));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("uid")), ULL2NUM(resp.manifest.uid));
-    VALUE scopes = rb_ary_new_capa(static_cast<long>(resp.manifest.scopes.size()));
-    for (const auto& s : resp.manifest.scopes) {
-        VALUE scope = rb_hash_new();
-        rb_hash_aset(scope, rb_id2sym(rb_intern("uid")), ULL2NUM(s.uid));
-        rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_str_new(s.name.data(), static_cast<long>(s.name.size())));
-        VALUE collections = rb_ary_new_capa(static_cast<long>(s.collections.size()));
-        for (const auto& c : s.collections) {
-            VALUE collection = rb_hash_new();
-            rb_hash_aset(collection, rb_id2sym(rb_intern("uid")), ULL2NUM(c.uid));
-            rb_hash_aset(collection, rb_id2sym(rb_intern("name")), rb_str_new(c.name.data(), static_cast<long>(c.name.size())));
-            rb_ary_push(collections, collection);
-        }
-        rb_hash_aset(scope, rb_id2sym(rb_intern("collections")), collections);
-        rb_ary_push(scopes, scope);
-    }
-    rb_hash_aset(res, rb_id2sym(rb_intern("scopes")), scopes);
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("uid")), ULL2NUM(resp.manifest.uid));
+        VALUE scopes = rb_ary_new_capa(static_cast<long>(resp.manifest.scopes.size()));
+        for (const auto& s : resp.manifest.scopes) {
+            VALUE scope = rb_hash_new();
+            rb_hash_aset(scope, rb_id2sym(rb_intern("uid")), ULL2NUM(s.uid));
+            rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_str_new(s.name.data(), static_cast<long>(s.name.size())));
+            VALUE collections = rb_ary_new_capa(static_cast<long>(s.collections.size()));
+            for (const auto& c : s.collections) {
+                VALUE collection = rb_hash_new();
+                rb_hash_aset(collection, rb_id2sym(rb_intern("uid")), ULL2NUM(c.uid));
+                rb_hash_aset(collection, rb_id2sym(rb_intern("name")), rb_str_new(c.name.data(), static_cast<long>(c.name.size())));
+                rb_ary_push(collections, collection);
+            }
+            rb_hash_aset(scope, rb_id2sym(rb_intern("collections")), collections);
+            rb_ary_push(scopes, scope);
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("scopes")), scopes);
 
-    return res;
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name)
+cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2195,21 +2455,29 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name)
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
 
-    couchbase::operations::scope_create_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::scope_create_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req, [barrier](couchbase::operations::scope_create_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to create the scope on the bucket \"{}\"", req.bucket_name));
-    }
-    return ULL2NUM(resp.uid);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::scope_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::scope_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::scope_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to create the scope on the bucket \"{}\"", req.bucket_name));
+            break;
+        }
+        return ULL2NUM(resp.uid);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name)
+cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2221,21 +2489,30 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name)
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
 
-    couchbase::operations::scope_drop_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::scope_drop_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req, [barrier](couchbase::operations::scope_drop_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to drop the scope \"{}\" on the bucket \"{}\"", req.scope_name, req.bucket_name));
-    }
-    return ULL2NUM(resp.uid);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::scope_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::scope_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::scope_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec,
+                                     fmt::format("unable to drop the scope \"{}\" on the bucket \"{}\"", req.scope_name, req.bucket_name));
+            break;
+        }
+        return ULL2NUM(resp.uid);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE max_expiry)
+cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE max_expiry, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2248,28 +2525,38 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
     Check_Type(scope_name, T_STRING);
     Check_Type(collection_name, T_STRING);
 
-    couchbase::operations::collection_create_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
-    req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
-
-    if (!NIL_P(max_expiry)) {
-        Check_Type(max_expiry, T_FIXNUM);
-        req.max_expiry = FIX2UINT(max_expiry);
-    }
-    auto barrier = std::make_shared<std::promise<couchbase::operations::collection_create_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::collection_create_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to create the collection on the bucket \"{}\"", req.bucket_name));
-    }
-    return ULL2NUM(resp.uid);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::collection_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+        req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
+
+        if (!NIL_P(max_expiry)) {
+            Check_Type(max_expiry, T_FIXNUM);
+            req.max_expiry = FIX2UINT(max_expiry);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::collection_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::collection_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec,
+              fmt::format(
+                R"(unable create the collection "{}.{}" on the bucket "{}")", req.scope_name, req.collection_name, req.bucket_name));
+            break;
+        }
+        return ULL2NUM(resp.uid);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name)
+cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2282,27 +2569,34 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
     Check_Type(scope_name, T_STRING);
     Check_Type(collection_name, T_STRING);
 
-    couchbase::operations::collection_drop_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
-    req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::collection_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+        req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
 
-    auto barrier = std::make_shared<std::promise<couchbase::operations::collection_drop_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::collection_drop_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(
-          resp.ec,
-          fmt::format(
-            R"(unable to drop the collection  "{}.{}" on the bucket "{}")", req.scope_name, req.collection_name, req.bucket_name));
-    }
-    return ULL2NUM(resp.uid);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::collection_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::collection_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec,
+              fmt::format(
+                R"(unable to drop the collection  "{}.{}" on the bucket "{}")", req.scope_name, req.collection_name, req.bucket_name));
+            break;
+        }
+        return ULL2NUM(resp.uid);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name)
+cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2313,52 +2607,59 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name)
 
     Check_Type(bucket_name, T_STRING);
 
-    couchbase::operations::query_index_get_all_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_get_all_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(
-      req, [barrier](couchbase::operations::query_index_get_all_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        cb_raise_error_code(resp.ec, fmt::format("unable to get list of the indexes of the bucket \"{}\"", req.bucket_name));
-    }
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_index_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::query_index_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to get list of the indexes of the bucket \"{}\"", req.bucket_name));
+            break;
+        }
 
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-    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("id")), rb_str_new(idx.id.data(), static_cast<long>(idx.id.size())));
-        rb_hash_aset(index, rb_id2sym(rb_intern("state")), rb_str_new(idx.state.data(), static_cast<long>(idx.state.size())));
-        rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
-        rb_hash_aset(
-          index, rb_id2sym(rb_intern("datastore_id")), rb_str_new(idx.datastore_id.data(), static_cast<long>(idx.datastore_id.size())));
-        rb_hash_aset(
-          index, rb_id2sym(rb_intern("keyspace_id")), rb_str_new(idx.keyspace_id.data(), static_cast<long>(idx.keyspace_id.size())));
-        rb_hash_aset(
-          index, rb_id2sym(rb_intern("namespace_id")), rb_str_new(idx.namespace_id.data(), static_cast<long>(idx.namespace_id.size())));
-        rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
-        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, rb_str_new(key.data(), static_cast<long>(key.size())));
-        }
-        rb_hash_aset(index, rb_id2sym(rb_intern("index_key")), index_key);
-        if (idx.condition) {
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        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("id")), rb_str_new(idx.id.data(), static_cast<long>(idx.id.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("state")), rb_str_new(idx.state.data(), static_cast<long>(idx.state.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
+            rb_hash_aset(
+              index, rb_id2sym(rb_intern("datastore_id")), rb_str_new(idx.datastore_id.data(), static_cast<long>(idx.datastore_id.size())));
             rb_hash_aset(
-              index, rb_id2sym(rb_intern("condition")), rb_str_new(idx.condition->data(), static_cast<long>(idx.condition->size())));
+              index, rb_id2sym(rb_intern("keyspace_id")), rb_str_new(idx.keyspace_id.data(), static_cast<long>(idx.keyspace_id.size())));
+            rb_hash_aset(
+              index, rb_id2sym(rb_intern("namespace_id")), rb_str_new(idx.namespace_id.data(), static_cast<long>(idx.namespace_id.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
+            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, rb_str_new(key.data(), static_cast<long>(key.size())));
+            }
+            rb_hash_aset(index, rb_id2sym(rb_intern("index_key")), index_key);
+            if (idx.condition) {
+                rb_hash_aset(
+                  index, rb_id2sym(rb_intern("condition")), rb_str_new(idx.condition->data(), static_cast<long>(idx.condition->size())));
+            }
+            rb_ary_push(indexes, index);
         }
-        rb_ary_push(indexes, index);
-    }
 
-    rb_hash_aset(res, rb_id2sym(rb_intern("indexes")), indexes);
+        rb_hash_aset(res, rb_id2sym(rb_intern("indexes")), indexes);
 
-    return res;
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, VALUE fields, VALUE options)
+cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, VALUE fields, VALUE options, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2371,75 +2672,83 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
     Check_Type(index_name, T_STRING);
     Check_Type(fields, T_ARRAY);
 
-    couchbase::operations::query_index_create_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
-    auto fields_num = static_cast<size_t>(RARRAY_LEN(fields));
-    req.fields.reserve(fields_num);
-    for (size_t i = 0; i < fields_num; ++i) {
-        VALUE entry = rb_ary_entry(fields, static_cast<long>(i));
-        Check_Type(entry, T_STRING);
-        req.fields.emplace_back(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)));
-    }
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
-        if (ignore_if_exists == Qtrue) {
-            req.ignore_if_exists = true;
-        } else if (ignore_if_exists == Qfalse) {
-            req.ignore_if_exists = false;
-        } /* else use backend default */
-        VALUE deferred = rb_hash_aref(options, rb_id2sym(rb_intern("deferred")));
-        if (deferred == Qtrue) {
-            req.deferred = true;
-        } else if (deferred == Qfalse) {
-            req.deferred = false;
-        } /* else use backend default */
-        VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
-        if (!NIL_P(num_replicas)) {
-            req.num_replicas = NUM2UINT(num_replicas);
-        } /* else use backend default */
-        VALUE condition = rb_hash_aref(options, rb_id2sym(rb_intern("condition")));
-        if (!NIL_P(condition)) {
-            req.condition.emplace(std::string(RSTRING_PTR(condition), static_cast<std::size_t>(RSTRING_LEN(condition))));
-        } /* else use backend default */
-    }
-
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(
-      req, [barrier](couchbase::operations::query_index_create_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        if (!resp.errors.empty()) {
-            const auto& first_error = resp.errors.front();
-            cb_raise_error_code(resp.ec,
-                                fmt::format(R"(unable to create index "{}" on the bucket "{}" ({}: {}))",
-                                            req.index_name,
-                                            req.bucket_name,
-                                            first_error.code,
-                                            first_error.message));
-        } else {
-            cb_raise_error_code(resp.ec, fmt::format(R"(unable to create index "{}" on the bucket "{}")", req.index_name, req.bucket_name));
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_index_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        auto fields_num = static_cast<size_t>(RARRAY_LEN(fields));
+        req.fields.reserve(fields_num);
+        for (size_t i = 0; i < fields_num; ++i) {
+            VALUE entry = rb_ary_entry(fields, static_cast<long>(i));
+            Check_Type(entry, T_STRING);
+            req.fields.emplace_back(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)));
         }
-    }
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-    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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
-            rb_ary_push(errors, error);
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
+            if (ignore_if_exists == Qtrue) {
+                req.ignore_if_exists = true;
+            } else if (ignore_if_exists == Qfalse) {
+                req.ignore_if_exists = false;
+            } /* else use backend default */
+            VALUE deferred = rb_hash_aref(options, rb_id2sym(rb_intern("deferred")));
+            if (deferred == Qtrue) {
+                req.deferred = true;
+            } else if (deferred == Qfalse) {
+                req.deferred = false;
+            } /* else use backend default */
+            VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
+            if (!NIL_P(num_replicas)) {
+                req.num_replicas = NUM2UINT(num_replicas);
+            } /* else use backend default */
+            VALUE condition = rb_hash_aref(options, rb_id2sym(rb_intern("condition")));
+            if (!NIL_P(condition)) {
+                req.condition.emplace(std::string(RSTRING_PTR(condition), static_cast<std::size_t>(RSTRING_LEN(condition))));
+            } /* else use backend default */
         }
-        rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
-    }
-    return res;
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::query_index_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to create index "{}" on the bucket "{}" ({}: {}))",
+                                                     req.index_name,
+                                                     req.bucket_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to create index "{}" on the bucket "{}")", req.index_name, req.bucket_name));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VALUE options)
+cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VALUE options, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2451,54 +2760,62 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
     Check_Type(bucket_name, T_STRING);
     Check_Type(index_name, T_STRING);
 
-    couchbase::operations::query_index_drop_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
-        if (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 */
-    }
-
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::query_index_drop_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        if (!resp.errors.empty()) {
-            const auto& first_error = resp.errors.front();
-            cb_raise_error_code(resp.ec,
-                                fmt::format(R"(unable to drop index "{}" on the bucket "{}" ({}: {}))",
-                                            req.index_name,
-                                            req.bucket_name,
-                                            first_error.code,
-                                            first_error.message));
-        } else {
-            cb_raise_error_code(resp.ec, fmt::format(R"(unable to drop index "{}" on the bucket "{}")", req.index_name, req.bucket_name));
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_index_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
+            if (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 */
         }
-    }
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-    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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
-            rb_ary_push(errors, error);
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::query_index_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to drop index "{}" on the bucket "{}" ({}: {}))",
+                                                     req.index_name,
+                                                     req.bucket_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to drop index "{}" on the bucket "{}")", req.index_name, req.bucket_name));
+            }
+            break;
         }
-        rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
-    }
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE options, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2512,67 +2829,75 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
         Check_Type(options, T_HASH);
     }
 
-    couchbase::operations::query_index_create_request req{};
-    req.is_primary = true;
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
-        if (ignore_if_exists == Qtrue) {
-            req.ignore_if_exists = true;
-        } else if (ignore_if_exists == Qfalse) {
-            req.ignore_if_exists = false;
-        } /* else use backend default */
-        VALUE deferred = rb_hash_aref(options, rb_id2sym(rb_intern("deferred")));
-        if (deferred == Qtrue) {
-            req.deferred = true;
-        } else if (deferred == Qfalse) {
-            req.deferred = false;
-        } /* else use backend default */
-        VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
-        if (!NIL_P(num_replicas)) {
-            req.num_replicas = NUM2UINT(num_replicas);
-        } /* else use backend default */
-        VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name")));
-        if (!NIL_P(index_name)) {
-            req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
-        } /* else use backend default */
-    }
-
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(
-      req, [barrier](couchbase::operations::query_index_create_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        if (!resp.errors.empty()) {
-            const auto& first_error = resp.errors.front();
-            cb_raise_error_code(
-              resp.ec,
-              fmt::format(
-                R"(unable to create primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
-        } else {
-            cb_raise_error_code(resp.ec,
-                                fmt::format(R"(unable to create primary index on the bucket "{}")", req.index_name, req.bucket_name));
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_index_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.is_primary = true;
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
+            if (ignore_if_exists == Qtrue) {
+                req.ignore_if_exists = true;
+            } else if (ignore_if_exists == Qfalse) {
+                req.ignore_if_exists = false;
+            } /* else use backend default */
+            VALUE deferred = rb_hash_aref(options, rb_id2sym(rb_intern("deferred")));
+            if (deferred == Qtrue) {
+                req.deferred = true;
+            } else if (deferred == Qfalse) {
+                req.deferred = false;
+            } /* else use backend default */
+            VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
+            if (!NIL_P(num_replicas)) {
+                req.num_replicas = NUM2UINT(num_replicas);
+            } /* else use backend default */
+            VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name")));
+            if (!NIL_P(index_name)) {
+                req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+            } /* else use backend default */
         }
-    }
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-    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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
-            rb_ary_push(errors, error);
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::query_index_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to create primary index on the bucket "{}" ({}: {}))",
+                                                     req.bucket_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format(R"(unable to create primary index on the bucket "{}")", req.index_name, req.bucket_name));
+            }
+            break;
         }
-        rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
-    }
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2583,58 +2908,65 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
 
     Check_Type(bucket_name, T_STRING);
 
-    couchbase::operations::query_index_drop_request req{};
-    req.is_primary = true;
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-        VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
-        if (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 */
-        VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name")));
-        if (!NIL_P(index_name)) {
-            Check_Type(options, T_STRING);
-            req.is_primary = false;
-            req.bucket_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
-        }
-    }
-
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(req,
-                                   [barrier](couchbase::operations::query_index_drop_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        if (!resp.errors.empty()) {
-            const auto& first_error = resp.errors.front();
-            cb_raise_error_code(
-              resp.ec,
-              fmt::format(
-                R"(unable to drop primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
-        } else {
-            cb_raise_error_code(resp.ec, fmt::format(R"(unable to drop primary index on the bucket "{}")", req.bucket_name));
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_index_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.is_primary = true;
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        if (!NIL_P(options)) {
+            Check_Type(options, T_HASH);
+            VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
+            if (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 */
+            VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name")));
+            if (!NIL_P(index_name)) {
+                Check_Type(options, T_STRING);
+                req.is_primary = false;
+                req.bucket_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+            }
         }
-    }
-    VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-    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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
-            rb_ary_push(errors, error);
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::query_index_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format(
+                    R"(unable to drop primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
+            } else {
+                exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to drop primary index on the bucket "{}")", req.bucket_name));
+            }
+            break;
         }
-        rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
-    }
-    return res;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        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")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE timeout)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -2644,31 +2976,35 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE optio
     }
 
     Check_Type(bucket_name, T_STRING);
-    if (!NIL_P(options)) {
-        Check_Type(options, T_HASH);
-    }
 
-    couchbase::operations::query_index_build_deferred_request req{};
-    req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
-    auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_build_deferred_response>>();
-    auto f = barrier->get_future();
-    backend->cluster->execute_http(
-      req, [barrier](couchbase::operations::query_index_build_deferred_response resp) mutable { barrier->set_value(resp); });
-    auto resp = f.get();
-    if (resp.ec) {
-        if (!resp.errors.empty()) {
-            const auto& first_error = resp.errors.front();
-            cb_raise_error_code(
-              resp.ec,
-              fmt::format(
-                R"(unable to drop primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::query_index_build_deferred_request req{};
+        cb__extract_timeout(req, timeout);
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_build_deferred_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::query_index_build_deferred_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format(
+                    R"(unable to drop primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
 
-        } else {
-            cb_raise_error_code(resp.ec,
-                                fmt::format("unable to trigger build for deferred indexes for the bucket \"{}\"", req.bucket_name));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to trigger build for deferred indexes for the bucket \"{}\"", req.bucket_name));
+            }
+            break;
         }
-    }
-    return Qtrue;
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
@@ -2692,52 +3028,926 @@ cb_Backend_query_index_watch(VALUE self, VALUE bucket_name, VALUE index_names, V
 }
 
 static void
-init_backend(VALUE mCouchbase)
+cb__extract_search_index(VALUE index, const couchbase::operations::search_index& idx)
 {
-    VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
-    rb_define_alloc_func(cBackend, cb_Backend_allocate);
-    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
-    rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
-    rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 1);
+    rb_hash_aset(index, rb_id2sym(rb_intern("uuid")), rb_str_new(idx.uuid.data(), static_cast<long>(idx.uuid.size())));
+    rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
+    rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
+    if (!idx.params_json.empty()) {
+        rb_hash_aset(index, rb_id2sym(rb_intern("params")), rb_str_new(idx.params_json.data(), static_cast<long>(idx.params_json.size())));
+    }
 
-    rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 3);
-    rb_define_method(cBackend, "document_get_and_lock", VALUE_FUNC(cb_Backend_document_get_and_lock), 4);
-    rb_define_method(cBackend, "document_get_and_touch", VALUE_FUNC(cb_Backend_document_get_and_touch), 4);
-    rb_define_method(cBackend, "document_insert", VALUE_FUNC(cb_Backend_document_insert), 6);
-    rb_define_method(cBackend, "document_replace", VALUE_FUNC(cb_Backend_document_replace), 6);
-    rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 6);
-    rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 4);
-    rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 5);
-    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 6);
-    rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
-    rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 4);
-    rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 3);
-    rb_define_method(cBackend, "document_unlock", VALUE_FUNC(cb_Backend_document_unlock), 4);
-    rb_define_method(cBackend, "document_increment", VALUE_FUNC(cb_Backend_document_increment), 4);
-    rb_define_method(cBackend, "document_decrement", VALUE_FUNC(cb_Backend_document_decrement), 4);
-
-    rb_define_method(cBackend, "bucket_create", VALUE_FUNC(cb_Backend_bucket_create), 1);
-    rb_define_method(cBackend, "bucket_update", VALUE_FUNC(cb_Backend_bucket_update), 1);
-    rb_define_method(cBackend, "bucket_drop", VALUE_FUNC(cb_Backend_bucket_drop), 1);
-    rb_define_method(cBackend, "bucket_flush", VALUE_FUNC(cb_Backend_bucket_flush), 1);
-    rb_define_method(cBackend, "bucket_get_all", VALUE_FUNC(cb_Backend_bucket_get_all), 0);
-    rb_define_method(cBackend, "bucket_get", VALUE_FUNC(cb_Backend_bucket_get), 1);
+    if (!idx.source_uuid.empty()) {
+        rb_hash_aset(
+          index, rb_id2sym(rb_intern("source_uuid")), rb_str_new(idx.source_uuid.data(), static_cast<long>(idx.source_uuid.size())));
+    }
+    if (!idx.source_name.empty()) {
+        rb_hash_aset(
+          index, rb_id2sym(rb_intern("source_name")), rb_str_new(idx.source_name.data(), static_cast<long>(idx.source_name.size())));
+    }
+    rb_hash_aset(index, rb_id2sym(rb_intern("source_type")), rb_str_new(idx.source_type.data(), static_cast<long>(idx.source_type.size())));
+    if (!idx.source_params_json.empty()) {
+        rb_hash_aset(index,
+                     rb_id2sym(rb_intern("source_params")),
+                     rb_str_new(idx.source_params_json.data(), static_cast<long>(idx.source_params_json.size())));
+    }
+    if (!idx.plan_params_json.empty()) {
+        rb_hash_aset(index,
+                     rb_id2sym(rb_intern("plan_params")),
+                     rb_str_new(idx.plan_params_json.data(), static_cast<long>(idx.plan_params_json.size())));
+    }
+}
 
-    rb_define_method(cBackend, "cluster_enable_developer_preview!", VALUE_FUNC(cb_Backend_cluster_enable_developer_preview), 0);
+static VALUE
+cb_Backend_search_index_get_all(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
 
-    rb_define_method(cBackend, "scope_get_all", VALUE_FUNC(cb_Backend_scope_get_all), 1);
-    rb_define_method(cBackend, "scope_create", VALUE_FUNC(cb_Backend_scope_create), 2);
-    rb_define_method(cBackend, "scope_drop", VALUE_FUNC(cb_Backend_scope_drop), 2);
-    rb_define_method(cBackend, "collection_create", VALUE_FUNC(cb_Backend_collection_create), 4);
-    rb_define_method(cBackend, "collection_drop", VALUE_FUNC(cb_Backend_collection_drop), 3);
-
-    rb_define_method(cBackend, "query_index_get_all", VALUE_FUNC(cb_Backend_query_index_get_all), 1);
-    rb_define_method(cBackend, "query_index_create", VALUE_FUNC(cb_Backend_query_index_create), 4);
-    rb_define_method(cBackend, "query_index_create_primary", VALUE_FUNC(cb_Backend_query_index_create_primary), 2);
-    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);
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to get list of the search indexes");
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(
+          res, rb_id2sym(rb_intern("impl_version")), rb_str_new(resp.impl_version.data(), static_cast<long>(resp.impl_version.size())));
+        VALUE indexes = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
+        for (const auto& idx : resp.indexes) {
+            VALUE index = rb_hash_new();
+            cb__extract_search_index(index, idx);
+            rb_ary_push(indexes, index);
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("indexes")), indexes);
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_get(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_get_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to get search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to get search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        cb__extract_search_index(res, resp.index);
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_upsert(VALUE self, VALUE index_definition, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_definition, T_HASH);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_upsert_request req{};
+        cb__extract_timeout(req, timeout);
+
+        VALUE index_name = rb_hash_aref(index_definition, rb_id2sym(rb_intern("name")));
+        Check_Type(index_name, T_STRING);
+        req.index.name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+
+        VALUE index_type = rb_hash_aref(index_definition, rb_id2sym(rb_intern("type")));
+        Check_Type(index_type, T_STRING);
+        req.index.type.assign(RSTRING_PTR(index_type), static_cast<size_t>(RSTRING_LEN(index_type)));
+
+        VALUE index_uuid = rb_hash_aref(index_definition, rb_id2sym(rb_intern("uuid")));
+        if (!NIL_P(index_uuid)) {
+            Check_Type(index_uuid, T_STRING);
+            req.index.uuid.assign(RSTRING_PTR(index_uuid), static_cast<size_t>(RSTRING_LEN(index_uuid)));
+        }
+
+        VALUE index_params = rb_hash_aref(index_definition, rb_id2sym(rb_intern("params")));
+        if (!NIL_P(index_params)) {
+            Check_Type(index_params, T_STRING);
+            req.index.params_json.assign(std::string(RSTRING_PTR(index_params), static_cast<size_t>(RSTRING_LEN(index_params))));
+        }
+
+        VALUE source_name = rb_hash_aref(index_definition, rb_id2sym(rb_intern("source_name")));
+        if (!NIL_P(source_name)) {
+            Check_Type(source_name, T_STRING);
+            req.index.source_name.assign(RSTRING_PTR(source_name), static_cast<size_t>(RSTRING_LEN(source_name)));
+        }
+
+        VALUE source_type = rb_hash_aref(index_definition, rb_id2sym(rb_intern("source_type")));
+        Check_Type(source_type, T_STRING);
+        req.index.source_type.assign(RSTRING_PTR(source_type), static_cast<size_t>(RSTRING_LEN(source_type)));
+
+        VALUE source_uuid = rb_hash_aref(index_definition, rb_id2sym(rb_intern("source_uuid")));
+        if (!NIL_P(source_uuid)) {
+            Check_Type(source_uuid, T_STRING);
+            req.index.source_uuid.assign(RSTRING_PTR(source_uuid), static_cast<size_t>(RSTRING_LEN(source_uuid)));
+        }
+
+        VALUE source_params = rb_hash_aref(index_definition, rb_id2sym(rb_intern("source_params")));
+        if (!NIL_P(source_params)) {
+            Check_Type(source_params, T_STRING);
+            req.index.source_params_json.assign(std::string(RSTRING_PTR(source_params), static_cast<size_t>(RSTRING_LEN(source_params))));
+        }
+
+        VALUE plan_params = rb_hash_aref(index_definition, rb_id2sym(rb_intern("plan_params")));
+        if (!NIL_P(plan_params)) {
+            Check_Type(plan_params, T_STRING);
+            req.index.plan_params_json.assign(std::string(RSTRING_PTR(plan_params), static_cast<size_t>(RSTRING_LEN(plan_params))));
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_upsert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert the search index \"{}\"", req.index.name));
+            } else {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert the search index \"{}\": {}", req.index.name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_drop(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_get_documents_count(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_get_documents_count_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_documents_count_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_get_documents_count_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to get number of the indexed documents for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format("unable to get number of the indexed documents for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("count")), ULL2NUM(resp.count));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_pause_ingest(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_control_ingest_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.pause = true;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_ingest_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_control_ingest_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to pause ingest for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to pause ingest for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_resume_ingest(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_control_ingest_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.pause = false;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_ingest_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_control_ingest_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to resume ingest for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to resume ingest for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_allow_querying(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_control_query_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.allow = true;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_query_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_control_query_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to allow querying for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to allow querying for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_disallow_querying(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_control_query_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.allow = false;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_query_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_control_query_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to disallow querying for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to disallow querying for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_freeze_plan(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_control_plan_freeze_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.freeze = true;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_plan_freeze_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_control_plan_freeze_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to freeze for the search index \"{}\"", req.index_name));
+            } else {
+                exc =
+                  cb__map_error_code(resp.ec, fmt::format("unable to freeze for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_unfreeze_plan(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_control_plan_freeze_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.freeze = false;
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_plan_freeze_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_control_plan_freeze_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to unfreeze plan for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to unfreeze for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_index_analyze_document(VALUE self, VALUE index_name, VALUE encoded_document, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    Check_Type(encoded_document, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_analyze_document_request req{};
+        cb__extract_timeout(req, timeout);
+
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.encoded_document.assign(RSTRING_PTR(encoded_document), static_cast<size_t>(RSTRING_LEN(encoded_document)));
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_analyze_document_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_analyze_document_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to analyze document using the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to analyze document using the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("analysis")), rb_str_new(resp.analysis.data(), static_cast<long>(resp.analysis.size())));
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE options)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    Check_Type(query, T_STRING);
+    Check_Type(options, T_HASH);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_request req;
+        VALUE client_context_id = rb_hash_aref(options, rb_id2sym(rb_intern("client_context_id")));
+        if (!NIL_P(client_context_id)) {
+            Check_Type(client_context_id, T_STRING);
+            req.client_context_id.assign(RSTRING_PTR(client_context_id), static_cast<size_t>(RSTRING_LEN(client_context_id)));
+        }
+        cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.query = tao::json::from_string(std::string(RSTRING_PTR(query), static_cast<size_t>(RSTRING_LEN(query))));
+
+        VALUE explain = rb_hash_aref(options, rb_id2sym(rb_intern("explain")));
+        if (!NIL_P(explain)) {
+            req.explain = RTEST(explain);
+        }
+
+        VALUE skip = rb_hash_aref(options, rb_id2sym(rb_intern("skip")));
+        if (!NIL_P(skip)) {
+            Check_Type(skip, T_FIXNUM);
+            req.skip = FIX2ULONG(skip);
+        }
+
+        VALUE limit = rb_hash_aref(options, rb_id2sym(rb_intern("limit")));
+        if (!NIL_P(limit)) {
+            Check_Type(limit, T_FIXNUM);
+            req.limit = FIX2ULONG(limit);
+        }
+
+        VALUE highlight_style = rb_hash_aref(options, rb_id2sym(rb_intern("highlight_style")));
+        if (!NIL_P(highlight_style)) {
+            Check_Type(highlight_style, T_SYMBOL);
+            ID type = rb_sym2id(highlight_style);
+            if (type == rb_intern("html")) {
+                req.highlight_style = couchbase::operations::search_request::highlight_style_type::html;
+            } else if (type == rb_intern("ansi")) {
+                req.highlight_style = couchbase::operations::search_request::highlight_style_type::ansi;
+            }
+        }
+
+        VALUE highlight_fields = rb_hash_aref(options, rb_id2sym(rb_intern("highlight_fields")));
+        if (!NIL_P(highlight_fields)) {
+            Check_Type(highlight_fields, T_ARRAY);
+            auto highlight_fields_size = static_cast<size_t>(RARRAY_LEN(highlight_fields));
+            req.highlight_fields.reserve(highlight_fields_size);
+            for (size_t i = 0; i < highlight_fields_size; ++i) {
+                VALUE field = rb_ary_entry(highlight_fields, static_cast<long>(i));
+                Check_Type(field, T_STRING);
+                req.highlight_fields.emplace_back(std::string(RSTRING_PTR(field), static_cast<std::size_t>(RSTRING_LEN(field))));
+            }
+        }
+
+        VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
+        if (!NIL_P(scan_consistency)) {
+            Check_Type(scan_consistency, T_SYMBOL);
+            ID type = rb_sym2id(scan_consistency);
+            if (type == rb_intern("not_bounded")) {
+                req.scan_consistency = couchbase::operations::search_request::scan_consistency_type::not_bounded;
+            }
+        }
+
+        VALUE mutation_state = rb_hash_aref(options, rb_id2sym(rb_intern("mutation_state")));
+        if (!NIL_P(mutation_state)) {
+            Check_Type(mutation_state, T_ARRAY);
+            auto state_size = static_cast<size_t>(RARRAY_LEN(mutation_state));
+            req.mutation_state.reserve(state_size);
+            for (size_t i = 0; i < state_size; ++i) {
+                VALUE token = rb_ary_entry(mutation_state, static_cast<long>(i));
+                Check_Type(token, T_HASH);
+                VALUE bucket_name = rb_hash_aref(token, rb_id2sym(rb_intern("bucket_name")));
+                Check_Type(bucket_name, T_STRING);
+                VALUE partition_id = rb_hash_aref(token, rb_id2sym(rb_intern("partition_id")));
+                Check_Type(partition_id, T_FIXNUM);
+                VALUE partition_uuid = rb_hash_aref(token, rb_id2sym(rb_intern("partition_uuid")));
+                switch (TYPE(partition_uuid)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "partition_uuid must be an Integer");
+                }
+                VALUE sequence_number = rb_hash_aref(token, rb_id2sym(rb_intern("sequence_number")));
+                switch (TYPE(sequence_number)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "sequence_number must be an Integer");
+                }
+                req.mutation_state.emplace_back(
+                  couchbase::mutation_token{ NUM2ULL(partition_uuid),
+                                             NUM2ULL(sequence_number),
+                                             gsl::narrow_cast<std::uint16_t>(NUM2UINT(partition_id)),
+                                             std::string(RSTRING_PTR(bucket_name), static_cast<std::size_t>(RSTRING_LEN(bucket_name))) });
+            }
+        }
+
+        VALUE fields = rb_hash_aref(options, rb_id2sym(rb_intern("fields")));
+        if (!NIL_P(fields)) {
+            Check_Type(fields, T_ARRAY);
+            auto fields_size = static_cast<size_t>(RARRAY_LEN(fields));
+            req.fields.reserve(fields_size);
+            for (size_t i = 0; i < fields_size; ++i) {
+                VALUE field = rb_ary_entry(fields, static_cast<long>(i));
+                Check_Type(field, T_STRING);
+                req.fields.emplace_back(std::string(RSTRING_PTR(field), static_cast<std::size_t>(RSTRING_LEN(field))));
+            }
+        }
+
+        VALUE sort = rb_hash_aref(options, rb_id2sym(rb_intern("sort")));
+        if (!NIL_P(sort)) {
+            Check_Type(sort, T_ARRAY);
+            for (size_t i = 0; i < static_cast<std::size_t>(RARRAY_LEN(sort)); ++i) {
+                VALUE sort_spec = rb_ary_entry(sort, static_cast<long>(i));
+                req.sort_specs.emplace_back(std::string(RSTRING_PTR(sort_spec), static_cast<std::size_t>(RSTRING_LEN(sort_spec))));
+            }
+        }
+
+        VALUE facets = rb_hash_aref(options, rb_id2sym(rb_intern("facets")));
+        if (!NIL_P(facets)) {
+            Check_Type(facets, T_ARRAY);
+            for (size_t i = 0; i < static_cast<std::size_t>(RARRAY_LEN(facets)); ++i) {
+                VALUE facet_pair = rb_ary_entry(facets, static_cast<long>(i));
+                Check_Type(facet_pair, T_ARRAY);
+                if (RARRAY_LEN(facet_pair) == 2) {
+                    VALUE facet_name = rb_ary_entry(facet_pair, 0);
+                    Check_Type(facet_name, T_STRING);
+                    VALUE facet_definition = rb_ary_entry(facet_pair, 1);
+                    Check_Type(facet_definition, T_STRING);
+                    req.facets.emplace(std::string(RSTRING_PTR(facet_name), static_cast<std::size_t>(RSTRING_LEN(facet_name))),
+                                       std::string(RSTRING_PTR(facet_definition), static_cast<std::size_t>(RSTRING_LEN(facet_definition))));
+                }
+            }
+        }
+
+        VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
+        if (!NIL_P(raw_params)) {
+            Check_Type(raw_params, T_HASH);
+            rb_hash_foreach(raw_params, INT_FUNC(cb__for_each_named_param), reinterpret_cast<VALUE>(&req));
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req, [barrier](couchbase::operations::search_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to perform search query for index \"{}\"", req.index_name));
+            break;
+        }
+        VALUE res = rb_hash_new();
+
+        VALUE meta_data = rb_hash_new();
+        rb_hash_aset(meta_data,
+                     rb_id2sym(rb_intern("client_context_id")),
+                     rb_str_new(resp.meta_data.client_context_id.data(), static_cast<long>(resp.meta_data.client_context_id.size())));
+
+        VALUE metrics = rb_hash_new();
+        rb_hash_aset(metrics,
+                     rb_id2sym(rb_intern("took")),
+                     LONG2NUM(std::chrono::duration_cast<std::chrono::milliseconds>(resp.meta_data.metrics.took).count()));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("total_rows")), ULL2NUM(resp.meta_data.metrics.total_rows));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("max_score")), DBL2NUM(resp.meta_data.metrics.max_score));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("success_partition_count")), ULL2NUM(resp.meta_data.metrics.success_partition_count));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("error_partition_count")), ULL2NUM(resp.meta_data.metrics.error_partition_count));
+        rb_hash_aset(meta_data, rb_id2sym(rb_intern("metrics")), metrics);
+
+        if (!resp.meta_data.errors.empty()) {
+            VALUE errors = rb_hash_new();
+            for (auto err : resp.meta_data.errors) {
+                rb_hash_aset(errors,
+                             rb_str_new(err.first.data(), static_cast<long>(err.first.size())),
+                             rb_str_new(err.second.data(), static_cast<long>(err.second.size())));
+            }
+            rb_hash_aset(meta_data, rb_id2sym(rb_intern("errors")), errors);
+        }
+
+        rb_hash_aset(res, rb_id2sym(rb_intern("meta_data")), meta_data);
+
+        VALUE rows = rb_ary_new_capa(static_cast<long>(resp.rows.size()));
+        for (const auto& entry : resp.rows) {
+            VALUE row = rb_hash_new();
+            rb_hash_aset(row, rb_id2sym(rb_intern("index")), rb_str_new(entry.index.data(), static_cast<long>(entry.index.size())));
+            rb_hash_aset(row, rb_id2sym(rb_intern("id")), rb_str_new(entry.id.data(), static_cast<long>(entry.id.size())));
+            rb_hash_aset(row, rb_id2sym(rb_intern("score")), DBL2NUM(entry.score));
+            VALUE locations = rb_ary_new_capa(static_cast<long>(entry.locations.size()));
+            for (const auto& loc : entry.locations) {
+                VALUE location = rb_hash_new();
+                rb_hash_aset(row, rb_id2sym(rb_intern("field")), rb_str_new(loc.field.data(), static_cast<long>(loc.field.size())));
+                rb_hash_aset(row, rb_id2sym(rb_intern("term")), rb_str_new(loc.term.data(), static_cast<long>(loc.term.size())));
+                rb_hash_aset(row, rb_id2sym(rb_intern("pos")), ULL2NUM(loc.position));
+                rb_hash_aset(row, rb_id2sym(rb_intern("start_offset")), ULL2NUM(loc.start_offset));
+                rb_hash_aset(row, rb_id2sym(rb_intern("end_offset")), ULL2NUM(loc.end_offset));
+                if (loc.array_positions) {
+                    VALUE ap = rb_ary_new_capa(static_cast<long>(loc.array_positions->size()));
+                    for (const auto& pos : *loc.array_positions) {
+                        rb_ary_push(ap, ULL2NUM(pos));
+                    }
+                    rb_hash_aset(row, rb_id2sym(rb_intern("array_positions")), ap);
+                }
+                rb_ary_push(locations, location);
+            }
+            rb_hash_aset(row, rb_id2sym(rb_intern("locations")), locations);
+            if (!entry.fragments.empty()) {
+                VALUE fragments = rb_hash_new();
+                for (const auto& field_fragments : entry.fragments) {
+                    VALUE fragments_list = rb_ary_new_capa(static_cast<long>(field_fragments.second.size()));
+                    for (const auto& fragment : field_fragments.second) {
+                        rb_ary_push(fragments_list, rb_str_new(fragment.data(), static_cast<long>(fragment.size())));
+                    }
+                    rb_hash_aset(
+                      fragments, rb_str_new(field_fragments.first.data(), static_cast<long>(field_fragments.first.size())), fragments_list);
+                }
+                rb_hash_aset(row, rb_id2sym(rb_intern("fragments")), fragments);
+            }
+            if (!entry.fields.empty()) {
+                rb_hash_aset(row, rb_id2sym(rb_intern("fields")), rb_str_new(entry.fields.data(), static_cast<long>(entry.fields.size())));
+            }
+            if (!entry.explanation.empty()) {
+                rb_hash_aset(row,
+                             rb_id2sym(rb_intern("explanation")),
+                             rb_str_new(entry.explanation.data(), static_cast<long>(entry.explanation.size())));
+            }
+            rb_ary_push(rows, row);
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
+
+        if (!resp.facets.empty()) {
+            VALUE result_facets = rb_hash_new();
+            for (const auto& entry : resp.facets) {
+                VALUE facet = rb_hash_new();
+                VALUE facet_name = rb_str_new(entry.name.data(), static_cast<long>(entry.name.size()));
+                rb_hash_aset(facet, rb_id2sym(rb_intern("name")), facet_name);
+                rb_hash_aset(facet, rb_id2sym(rb_intern("field")), rb_str_new(entry.field.data(), static_cast<long>(entry.field.size())));
+                rb_hash_aset(facet, rb_id2sym(rb_intern("total")), ULL2NUM(entry.total));
+                rb_hash_aset(facet, rb_id2sym(rb_intern("missing")), ULL2NUM(entry.missing));
+                rb_hash_aset(facet, rb_id2sym(rb_intern("other")), ULL2NUM(entry.other));
+                if (!entry.terms.empty()) {
+                    VALUE terms = rb_ary_new_capa(static_cast<long>(entry.terms.size()));
+                    for (const auto& item : entry.terms) {
+                        VALUE term = rb_hash_new();
+                        rb_hash_aset(term, rb_id2sym(rb_intern("term")), rb_str_new(item.term.data(), static_cast<long>(item.term.size())));
+                        rb_hash_aset(term, rb_id2sym(rb_intern("count")), ULL2NUM(item.count));
+                        rb_ary_push(terms, term);
+                    }
+                    rb_hash_aset(facet, rb_id2sym(rb_intern("terms")), terms);
+                } else if (!entry.date_ranges.empty()) {
+                    VALUE date_ranges = rb_ary_new_capa(static_cast<long>(entry.date_ranges.size()));
+                    for (const auto& item : entry.date_ranges) {
+                        VALUE date_range = rb_hash_new();
+                        rb_hash_aset(
+                          date_range, rb_id2sym(rb_intern("name")), rb_str_new(item.name.data(), static_cast<long>(item.name.size())));
+                        rb_hash_aset(date_range, rb_id2sym(rb_intern("count")), ULL2NUM(item.count));
+                        if (item.start) {
+                            rb_hash_aset(date_range,
+                                         rb_id2sym(rb_intern("start_time")),
+                                         rb_str_new(item.start->data(), static_cast<long>(item.start->size())));
+                        }
+                        if (item.end) {
+                            rb_hash_aset(date_range,
+                                         rb_id2sym(rb_intern("end_time")),
+                                         rb_str_new(item.end->data(), static_cast<long>(item.end->size())));
+                        }
+                        rb_ary_push(date_ranges, date_range);
+                    }
+                    rb_hash_aset(facet, rb_id2sym(rb_intern("date_ranges")), date_ranges);
+                } else if (!entry.numeric_ranges.empty()) {
+                    VALUE numeric_ranges = rb_ary_new_capa(static_cast<long>(entry.numeric_ranges.size()));
+                    for (const auto& item : entry.numeric_ranges) {
+                        VALUE numeric_range = rb_hash_new();
+                        rb_hash_aset(
+                          numeric_range, rb_id2sym(rb_intern("name")), rb_str_new(item.name.data(), static_cast<long>(item.name.size())));
+                        rb_hash_aset(numeric_range, rb_id2sym(rb_intern("count")), ULL2NUM(item.count));
+                        if (std::holds_alternative<double>(item.min)) {
+                            rb_hash_aset(numeric_range, rb_id2sym(rb_intern("min")), DBL2NUM(std::get<double>(item.min)));
+                        } else if (std::holds_alternative<std::uint64_t>(item.min)) {
+                            rb_hash_aset(numeric_range, rb_id2sym(rb_intern("min")), ULL2NUM(std::get<std::uint64_t>(item.min)));
+                        }
+                        if (std::holds_alternative<double>(item.max)) {
+                            rb_hash_aset(numeric_range, rb_id2sym(rb_intern("max")), DBL2NUM(std::get<double>(item.max)));
+                        } else if (std::holds_alternative<std::uint64_t>(item.max)) {
+                            rb_hash_aset(numeric_range, rb_id2sym(rb_intern("max")), ULL2NUM(std::get<std::uint64_t>(item.max)));
+                        }
+                        rb_ary_push(numeric_ranges, numeric_range);
+                    }
+                    rb_hash_aset(facet, rb_id2sym(rb_intern("numeric_ranges")), numeric_ranges);
+                }
+                rb_hash_aset(result_facets, facet_name, facet);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("facets")), result_facets);
+        }
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static void
+init_backend(VALUE mCouchbase)
+{
+    VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
+    rb_define_alloc_func(cBackend, cb_Backend_allocate);
+    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
+    rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
+    rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 1);
+
+    rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 4);
+    rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 7);
+    rb_define_method(cBackend, "document_get_and_lock", VALUE_FUNC(cb_Backend_document_get_and_lock), 5);
+    rb_define_method(cBackend, "document_get_and_touch", VALUE_FUNC(cb_Backend_document_get_and_touch), 5);
+    rb_define_method(cBackend, "document_insert", VALUE_FUNC(cb_Backend_document_insert), 7);
+    rb_define_method(cBackend, "document_replace", VALUE_FUNC(cb_Backend_document_replace), 7);
+    rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 7);
+    rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 5);
+    rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 6);
+    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 7);
+    rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
+    rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 5);
+    rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 4);
+    rb_define_method(cBackend, "document_unlock", VALUE_FUNC(cb_Backend_document_unlock), 5);
+    rb_define_method(cBackend, "document_increment", VALUE_FUNC(cb_Backend_document_increment), 5);
+    rb_define_method(cBackend, "document_decrement", VALUE_FUNC(cb_Backend_document_decrement), 5);
+    rb_define_method(cBackend, "document_search", VALUE_FUNC(cb_Backend_document_search), 3);
+
+    rb_define_method(cBackend, "bucket_create", VALUE_FUNC(cb_Backend_bucket_create), 2);
+    rb_define_method(cBackend, "bucket_update", VALUE_FUNC(cb_Backend_bucket_update), 2);
+    rb_define_method(cBackend, "bucket_drop", VALUE_FUNC(cb_Backend_bucket_drop), 2);
+    rb_define_method(cBackend, "bucket_flush", VALUE_FUNC(cb_Backend_bucket_flush), 2);
+    rb_define_method(cBackend, "bucket_get_all", VALUE_FUNC(cb_Backend_bucket_get_all), 1);
+    rb_define_method(cBackend, "bucket_get", VALUE_FUNC(cb_Backend_bucket_get), 2);
+
+    rb_define_method(cBackend, "cluster_enable_developer_preview!", VALUE_FUNC(cb_Backend_cluster_enable_developer_preview), 0);
+
+    rb_define_method(cBackend, "scope_get_all", VALUE_FUNC(cb_Backend_scope_get_all), 2);
+    rb_define_method(cBackend, "scope_create", VALUE_FUNC(cb_Backend_scope_create), 3);
+    rb_define_method(cBackend, "scope_drop", VALUE_FUNC(cb_Backend_scope_drop), 3);
+    rb_define_method(cBackend, "collection_create", VALUE_FUNC(cb_Backend_collection_create), 5);
+    rb_define_method(cBackend, "collection_drop", VALUE_FUNC(cb_Backend_collection_drop), 4);
+
+    rb_define_method(cBackend, "query_index_get_all", VALUE_FUNC(cb_Backend_query_index_get_all), 2);
+    rb_define_method(cBackend, "query_index_create", VALUE_FUNC(cb_Backend_query_index_create), 5);
+    rb_define_method(cBackend, "query_index_create_primary", VALUE_FUNC(cb_Backend_query_index_create_primary), 3);
+    rb_define_method(cBackend, "query_index_drop", VALUE_FUNC(cb_Backend_query_index_drop), 4);
+    rb_define_method(cBackend, "query_index_drop_primary", VALUE_FUNC(cb_Backend_query_index_drop_primary), 3);
+    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, "search_index_get_all", VALUE_FUNC(cb_Backend_search_index_get_all), 1);
+    rb_define_method(cBackend, "search_index_get", VALUE_FUNC(cb_Backend_search_index_get), 2);
+    rb_define_method(cBackend, "search_index_upsert", VALUE_FUNC(cb_Backend_search_index_upsert), 2);
+    rb_define_method(cBackend, "search_index_drop", VALUE_FUNC(cb_Backend_search_index_drop), 2);
+    rb_define_method(cBackend, "search_index_get_documents_count", VALUE_FUNC(cb_Backend_search_index_get_documents_count), 2);
+    rb_define_method(cBackend, "search_index_pause_ingest", VALUE_FUNC(cb_Backend_search_index_pause_ingest), 2);
+    rb_define_method(cBackend, "search_index_resume_ingest", VALUE_FUNC(cb_Backend_search_index_resume_ingest), 2);
+    rb_define_method(cBackend, "search_index_allow_querying", VALUE_FUNC(cb_Backend_search_index_allow_querying), 2);
+    rb_define_method(cBackend, "search_index_disallow_querying", VALUE_FUNC(cb_Backend_search_index_disallow_querying), 2);
+    rb_define_method(cBackend, "search_index_freeze_plan", VALUE_FUNC(cb_Backend_search_index_freeze_plan), 2);
+    rb_define_method(cBackend, "search_index_unfreeze_plan", VALUE_FUNC(cb_Backend_search_index_unfreeze_plan), 2);
+    rb_define_method(cBackend, "search_index_analyze_document", VALUE_FUNC(cb_Backend_search_index_analyze_document), 3);
 }
 
 extern "C" {