couchbase 3.8.2 → 3.9.1

data/ext/rcb_crud.cxx

@@ -26,6 +26,7 @@
 #include <core/operations/document_get_and_touch.hxx>
 #include <core/operations/document_get_any_replica.hxx>
 #include <core/operations/document_get_projected.hxx>
+#include <core/operations/document_get_replica.hxx>
 #include <core/operations/document_increment.hxx>
 #include <core/operations/document_insert.hxx>
 #include <core/operations/document_lookup_in.hxx>
@@ -92,10 +93,10 @@ cb_Backend_document_get(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
 
   try {
     core::document_id doc_id{
@@ -105,7 +106,8 @@ cb_Backend_document_get(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::get_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::get_request req{ doc_id, {}, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
 
     auto parent_span = cb_create_parent_span(req, self);
@@ -127,10 +129,8 @@ cb_Backend_document_get(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -146,10 +146,10 @@ cb_Backend_document_get_any_replica(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
 
   try {
     core::document_id doc_id{
@@ -180,13 +180,75 @@ cb_Backend_document_get_any_replica(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("content")), cb_str_new(resp.value));
     rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(resp.cas));
     rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
-    rb_hash_aset(res, rb_id2sym(rb_intern("replica")), resp.replica ? Qtrue : Qfalse);
+    rb_hash_aset(res, rb_id2sym(rb_intern("is_replica")), resp.replica ? Qtrue : Qfalse);
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
+      se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+  }
+  return Qnil;
+}
+
+VALUE
+cb_Backend_document_get_replica(VALUE self,
+                                VALUE bucket,
+                                VALUE scope,
+                                VALUE collection,
+                                VALUE id,
+                                VALUE strategy,
+                                VALUE options,
+                                VALUE observability_handler)
+{
+  auto cluster = cb_backend_to_core_api_cluster(self);
+
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(strategy, T_HASH);
+
+  try {
+    core::document_id doc_id{
+      cb_string_new(bucket),
+      cb_string_new(scope),
+      cb_string_new(collection),
+      cb_string_new(id),
+    };
+
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::get_replica_request req{ doc_id, {}, {}, {}, { retry_strategy } };
+    req.selection.emplace();
+    cb_extract_option_number(req.selection->replica_index, strategy, "replica_index");
+    cb_extract_option_bool(req.selection->wrap, strategy, "wrap");
+    cb_extract_timeout(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::get_replica_response> promise;
+    auto f = promise.get_future();
+    cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
+      promise.set_value(std::forward<decltype(resp)>(resp));
+    });
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts());
+    if (resp.ctx.ec()) {
+      // Overriding the code keeps the Hash error context of the other KV bindings.
+      // Error::DocumentNotFoundOnReplica subclasses Error::DocumentNotFound, which stands in for
+      // the document_not_found cause that core::impl::make_get_replica_error() attaches.
+      if (resp.ctx.ec() == errc::key_value::document_not_found) {
+        resp.ctx.override_ec(errc::key_value::document_not_found_on_replica);
+      }
+      cb_throw_error(resp.ctx, "unable to get replica of the document");
+    }
+
+    VALUE res = rb_hash_new();
+    rb_hash_aset(res, rb_id2sym(rb_intern("content")), cb_str_new(resp.value));
+    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(resp.cas));
+    rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+    return res;
+  } catch (const std::system_error& se) {
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -202,10 +264,10 @@ cb_Backend_document_get_all_replicas(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
 
   try {
     core::document_id doc_id{
@@ -239,15 +301,13 @@ cb_Backend_document_get_all_replicas(VALUE self,
       rb_hash_aset(response, rb_id2sym(rb_intern("content")), cb_str_new(entry.value));
       rb_hash_aset(response, rb_id2sym(rb_intern("cas")), cb_cas_to_num(entry.cas));
       rb_hash_aset(response, rb_id2sym(rb_intern("flags")), UINT2NUM(entry.flags));
-      rb_hash_aset(response, rb_id2sym(rb_intern("replica")), entry.replica ? Qtrue : Qfalse);
+      rb_hash_aset(response, rb_id2sym(rb_intern("is_replica")), entry.replica ? Qtrue : Qfalse);
       rb_ary_push(res, response);
     }
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -263,12 +323,12 @@ cb_Backend_document_get_projected(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -279,7 +339,10 @@ cb_Backend_document_get_projected(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::get_projected_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::get_projected_request req{
+      doc_id, {}, {}, {}, false, {}, false, {}, { retry_strategy },
+    };
     cb_extract_timeout(req, options);
     auto parent_span = cb_create_parent_span(req, self);
     cb_extract_option_bool(req.with_expiry, options, "with_expiry");
@@ -319,10 +382,8 @@ cb_Backend_document_get_projected(VALUE self,
     }
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -339,13 +400,13 @@ cb_Backend_document_get_and_lock(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(lock_time, T_FIXNUM);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(lock_time, T_FIXNUM);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -356,9 +417,10 @@ cb_Backend_document_get_and_lock(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::get_and_lock_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::get_and_lock_request req{ doc_id, {}, {}, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
-    req.lock_time = NUM2UINT(lock_time);
+    req.lock_time = cb_num2uint(lock_time);
 
     auto parent_span = cb_create_parent_span(req, self);
 
@@ -379,10 +441,8 @@ cb_Backend_document_get_and_lock(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -399,12 +459,12 @@ cb_Backend_document_get_and_touch(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -415,7 +475,8 @@ cb_Backend_document_get_and_touch(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::get_and_touch_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::get_and_touch_request req{ doc_id, {}, {}, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
     auto [type, duration] = unpack_expiry(expiry, false);
     req.expiry = static_cast<std::uint32_t>(duration.count());
@@ -439,10 +500,8 @@ cb_Backend_document_get_and_touch(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -459,12 +518,12 @@ cb_Backend_document_touch(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -475,7 +534,8 @@ cb_Backend_document_touch(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::touch_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::touch_request req{ doc_id, {}, {}, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
     auto [type, duration] = unpack_expiry(expiry, false);
     req.expiry = static_cast<std::uint32_t>(duration.count());
@@ -497,10 +557,8 @@ cb_Backend_document_touch(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(resp.cas));
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -516,12 +574,12 @@ cb_Backend_document_exists(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -532,7 +590,8 @@ cb_Backend_document_exists(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::exists_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::exists_request req{ doc_id, {}, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
 
     auto parent_span = cb_create_parent_span(req, self);
@@ -558,10 +617,8 @@ cb_Backend_document_exists(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("datatype")), UINT2NUM(resp.datatype));
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -578,12 +635,12 @@ cb_Backend_document_unlock(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -594,7 +651,8 @@ cb_Backend_document_unlock(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::unlock_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::unlock_request req{ doc_id, {}, {}, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
     cb_extract_cas(req.cas, cas);
 
@@ -615,10 +673,8 @@ cb_Backend_document_unlock(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(resp.cas));
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -636,14 +692,14 @@ cb_Backend_document_upsert(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(content, T_STRING);
-  Check_Type(flags, T_FIXNUM);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(content, T_STRING);
+  cb_check_type(flags, T_FIXNUM);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -654,6 +710,14 @@ cb_Backend_document_upsert(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      0,
+      0,
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_content(req, content);
     cb_extract_flags(req, flags);
@@ -693,10 +757,8 @@ cb_Backend_document_upsert(VALUE self,
     return cb_create_mutation_result(resp);
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -713,13 +775,13 @@ cb_Backend_document_append(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(content, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(content, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -730,6 +792,13 @@ cb_Backend_document_append(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_content(req, content);
     cb_extract_timeout(req, options);
@@ -767,10 +836,8 @@ cb_Backend_document_append(VALUE self,
     return cb_create_mutation_result(resp);
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -787,13 +854,13 @@ cb_Backend_document_prepend(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(content, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(content, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -804,6 +871,13 @@ cb_Backend_document_prepend(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_content(req, content);
     cb_extract_timeout(req, options);
@@ -840,10 +914,8 @@ cb_Backend_document_prepend(VALUE self,
 
     return cb_create_mutation_result(resp);
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -861,14 +933,14 @@ cb_Backend_document_replace(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(content, T_STRING);
-  Check_Type(flags, T_FIXNUM);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(content, T_STRING);
+  cb_check_type(flags, T_FIXNUM);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -879,6 +951,15 @@ cb_Backend_document_replace(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      0,
+      0,
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_content(req, content);
     cb_extract_flags(req, flags);
@@ -918,10 +999,8 @@ cb_Backend_document_replace(VALUE self,
     return cb_create_mutation_result(resp);
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -939,14 +1018,14 @@ cb_Backend_document_insert(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(content, T_STRING);
-  Check_Type(flags, T_FIXNUM);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(content, T_STRING);
+  cb_check_type(flags, T_FIXNUM);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -957,6 +1036,14 @@ cb_Backend_document_insert(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      0,
+      0,
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_content(req, content);
     cb_extract_flags(req, flags);
@@ -993,10 +1080,8 @@ cb_Backend_document_insert(VALUE self,
     return cb_create_mutation_result(resp);
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1012,12 +1097,12 @@ cb_Backend_document_remove(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1028,6 +1113,12 @@ cb_Backend_document_remove(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_timeout(req, options);
     cb_extract_durability_level(req, options);
@@ -1062,10 +1153,8 @@ cb_Backend_document_remove(VALUE self,
     }
     return cb_create_mutation_result(resp);
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1081,12 +1170,12 @@ cb_Backend_document_increment(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1097,6 +1186,14 @@ cb_Backend_document_increment(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      0,
+      1,
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
 
     cb_extract_timeout(req, options);
@@ -1138,10 +1235,8 @@ cb_Backend_document_increment(VALUE self,
     return res;
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1157,12 +1252,12 @@ cb_Backend_document_decrement(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1173,6 +1268,14 @@ cb_Backend_document_decrement(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      0,
+      1,
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
 
     cb_extract_timeout(req, options);
@@ -1214,10 +1317,8 @@ cb_Backend_document_decrement(VALUE self,
     return res;
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1234,17 +1335,16 @@ cb_Backend_document_lookup_in(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(specs, T_ARRAY);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(specs, T_ARRAY);
   if (RARRAY_LEN(specs) <= 0) {
-    rb_raise(rb_eArgError, "Array with specs cannot be empty");
-    return Qnil;
+    throw ruby_exception(rb_eArgError, "Array with specs cannot be empty");
   }
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1255,7 +1355,8 @@ cb_Backend_document_lookup_in(VALUE self,
       cb_string_new(id),
     };
 
-    core::operations::lookup_in_request req{ doc_id };
+    auto retry_strategy = cb_extract_retry_strategy(options);
+    core::operations::lookup_in_request req{ doc_id, {}, {}, false, {}, {}, { retry_strategy } };
     cb_extract_timeout(req, options);
     cb_extract_option_bool(req.access_deleted, options, "access_deleted");
 
@@ -1284,7 +1385,7 @@ cb_Backend_document_lookup_in(VALUE self,
       } else {
         throw ruby_exception(
           exc_invalid_argument(),
-          rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
+          cb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
       }
       cb_check_type(path, T_STRING);
 
@@ -1344,10 +1445,8 @@ cb_Backend_document_lookup_in(VALUE self,
     }
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1365,17 +1464,16 @@ cb_Backend_document_lookup_in_any_replica(VALUE self,
 
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(specs, T_ARRAY);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(specs, T_ARRAY);
   if (RARRAY_LEN(specs) <= 0) {
-    rb_raise(rb_eArgError, "Array with specs cannot be empty");
-    return Qnil;
+    throw ruby_exception(rb_eArgError, "Array with specs cannot be empty");
   }
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1415,7 +1513,7 @@ cb_Backend_document_lookup_in_any_replica(VALUE self,
       } else {
         throw ruby_exception(
           exc_invalid_argument(),
-          rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
+          cb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
       }
       cb_check_type(path, T_STRING);
       req.specs.emplace_back(core::impl::subdoc::command{
@@ -1477,10 +1575,8 @@ cb_Backend_document_lookup_in_any_replica(VALUE self,
 
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1497,17 +1593,16 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
-  Check_Type(specs, T_ARRAY);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
+  cb_check_type(specs, T_ARRAY);
   if (RARRAY_LEN(specs) <= 0) {
-    rb_raise(rb_eArgError, "Array with specs cannot be empty");
-    return Qnil;
+    throw ruby_exception(rb_eArgError, "Array with specs cannot be empty");
   }
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1548,7 +1643,7 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self,
       } else {
         throw ruby_exception(
           exc_invalid_argument(),
-          rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
+          cb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
       }
       cb_check_type(path, T_STRING);
 
@@ -1620,10 +1715,8 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self,
 
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1640,18 +1733,17 @@ cb_Backend_document_mutate_in(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(id, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(id, T_STRING);
 
-  Check_Type(specs, T_ARRAY);
+  cb_check_type(specs, T_ARRAY);
   if (RARRAY_LEN(specs) <= 0) {
-    rb_raise(rb_eArgError, "Array with specs cannot be empty");
-    return Qnil;
+    throw ruby_exception(rb_eArgError, "Array with specs cannot be empty");
   }
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1662,6 +1754,18 @@ cb_Backend_document_mutate_in(VALUE self,
         cb_string_new(collection),
         cb_string_new(id),
       },
+      {},
+      {},
+      {},
+      false,
+      false,
+      false,
+      {},
+      couchbase::store_semantics::replace,
+      {},
+      couchbase::durability_level::none,
+      {},
+      { cb_extract_retry_strategy(options) },
     };
     cb_extract_timeout(req, options);
     cb_extract_durability_level(req, options);
@@ -1739,7 +1843,7 @@ cb_Backend_document_mutate_in(VALUE self,
                                 .create_path(create_path));
         } else if (operation_id == rb_intern("counter")) {
           if (TYPE(param) == T_FIXNUM || TYPE(param) == T_BIGNUM) {
-            if (std::int64_t num = NUM2LL(param); num < 0) {
+            if (std::int64_t num = cb_num2ll(param); num < 0) {
               cxx_specs.push_back(
                 couchbase::mutate_in_specs::decrement(cb_string_new(path), -1 * num)
                   .xattr(xattr)
@@ -1752,7 +1856,7 @@ cb_Backend_document_mutate_in(VALUE self,
           } else {
             throw ruby_exception(
               exc_invalid_argument(),
-              rb_sprintf("subdocument counter operation expects number, but given: %+" PRIsVALUE,
+              cb_sprintf("subdocument counter operation expects number, but given: %+" PRIsVALUE,
                          param));
           }
         } else if (operation_id == rb_intern("set_doc")) {
@@ -1765,7 +1869,7 @@ cb_Backend_document_mutate_in(VALUE self,
         } else {
           throw ruby_exception(
             exc_invalid_argument(),
-            rb_sprintf("unsupported operation for subdocument mutation: %+" PRIsVALUE, operation));
+            cb_sprintf("unsupported operation for subdocument mutation: %+" PRIsVALUE, operation));
         }
       }
     }
@@ -1822,10 +1926,8 @@ cb_Backend_document_mutate_in(VALUE self,
     return res;
 
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -1835,28 +1937,47 @@ cb_Backend_document_mutate_in(VALUE self,
 void
 init_crud(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_get", cb_Backend_document_get, 6);
-  rb_define_method(cBackend, "document_get_any_replica", cb_Backend_document_get_any_replica, 6);
-  rb_define_method(cBackend, "document_get_all_replicas", cb_Backend_document_get_all_replicas, 6);
-  rb_define_method(cBackend, "document_get_projected", cb_Backend_document_get_projected, 6);
-  rb_define_method(cBackend, "document_get_and_lock", cb_Backend_document_get_and_lock, 7);
-  rb_define_method(cBackend, "document_get_and_touch", cb_Backend_document_get_and_touch, 7);
-  rb_define_method(cBackend, "document_insert", cb_Backend_document_insert, 8);
-  rb_define_method(cBackend, "document_replace", cb_Backend_document_replace, 8);
-  rb_define_method(cBackend, "document_upsert", cb_Backend_document_upsert, 8);
-  rb_define_method(cBackend, "document_append", cb_Backend_document_append, 7);
-  rb_define_method(cBackend, "document_prepend", cb_Backend_document_prepend, 7);
-  rb_define_method(cBackend, "document_remove", cb_Backend_document_remove, 6);
-  rb_define_method(cBackend, "document_lookup_in", cb_Backend_document_lookup_in, 7);
+  rb_define_method(cBackend, "document_get", cb_method<cb_Backend_document_get>::invoke, 6);
+  rb_define_method(cBackend,
+                   "document_get_any_replica",
+                   cb_method<cb_Backend_document_get_any_replica>::invoke,
+                   6);
+  rb_define_method(cBackend,
+                   "document_get_all_replicas",
+                   cb_method<cb_Backend_document_get_all_replicas>::invoke,
+                   6);
+  rb_define_method(
+    cBackend, "document_get_replica", cb_method<cb_Backend_document_get_replica>::invoke, 7);
+  rb_define_method(
+    cBackend, "document_get_projected", cb_method<cb_Backend_document_get_projected>::invoke, 6);
+  rb_define_method(
+    cBackend, "document_get_and_lock", cb_method<cb_Backend_document_get_and_lock>::invoke, 7);
+  rb_define_method(
+    cBackend, "document_get_and_touch", cb_method<cb_Backend_document_get_and_touch>::invoke, 7);
+  rb_define_method(cBackend, "document_insert", cb_method<cb_Backend_document_insert>::invoke, 8);
+  rb_define_method(cBackend, "document_replace", cb_method<cb_Backend_document_replace>::invoke, 8);
+  rb_define_method(cBackend, "document_upsert", cb_method<cb_Backend_document_upsert>::invoke, 8);
+  rb_define_method(cBackend, "document_append", cb_method<cb_Backend_document_append>::invoke, 7);
+  rb_define_method(cBackend, "document_prepend", cb_method<cb_Backend_document_prepend>::invoke, 7);
+  rb_define_method(cBackend, "document_remove", cb_method<cb_Backend_document_remove>::invoke, 6);
+  rb_define_method(
+    cBackend, "document_lookup_in", cb_method<cb_Backend_document_lookup_in>::invoke, 7);
+  rb_define_method(cBackend,
+                   "document_lookup_in_any_replica",
+                   cb_method<cb_Backend_document_lookup_in_any_replica>::invoke,
+                   7);
+  rb_define_method(cBackend,
+                   "document_lookup_in_all_replicas",
+                   cb_method<cb_Backend_document_lookup_in_all_replicas>::invoke,
+                   7);
+  rb_define_method(
+    cBackend, "document_mutate_in", cb_method<cb_Backend_document_mutate_in>::invoke, 7);
+  rb_define_method(cBackend, "document_touch", cb_method<cb_Backend_document_touch>::invoke, 7);
+  rb_define_method(cBackend, "document_exists", cb_method<cb_Backend_document_exists>::invoke, 6);
+  rb_define_method(cBackend, "document_unlock", cb_method<cb_Backend_document_unlock>::invoke, 7);
   rb_define_method(
-    cBackend, "document_lookup_in_any_replica", cb_Backend_document_lookup_in_any_replica, 7);
+    cBackend, "document_increment", cb_method<cb_Backend_document_increment>::invoke, 6);
   rb_define_method(
-    cBackend, "document_lookup_in_all_replicas", cb_Backend_document_lookup_in_all_replicas, 7);
-  rb_define_method(cBackend, "document_mutate_in", cb_Backend_document_mutate_in, 7);
-  rb_define_method(cBackend, "document_touch", cb_Backend_document_touch, 7);
-  rb_define_method(cBackend, "document_exists", cb_Backend_document_exists, 6);
-  rb_define_method(cBackend, "document_unlock", cb_Backend_document_unlock, 7);
-  rb_define_method(cBackend, "document_increment", cb_Backend_document_increment, 6);
-  rb_define_method(cBackend, "document_decrement", cb_Backend_document_decrement, 6);
+    cBackend, "document_decrement", cb_method<cb_Backend_document_decrement>::invoke, 6);
 }
 } // namespace couchbase::ruby