couchbase 3.8.2 → 3.9.1

data/ext/rcb_range_scan.cxx

@@ -15,6 +15,8 @@
  *   limitations under the License.
  */
 
+#include <couchbase/cluster.hxx>
+
 #include <core/agent_group.hxx>
 #include <core/agent_group_config.hxx>
 #include <core/cluster.hxx>
@@ -40,6 +42,10 @@ namespace couchbase::ruby
 namespace
 {
 struct cb_core_scan_result_data {
+  // The orchestrator behind scan_result holds the cluster's io_context by reference. This copy
+  // keeps the io_context alive until scan_result is destroyed, even after Cluster#disconnect or
+  // when the GC frees the backend first.
+  std::unique_ptr<couchbase::cluster> cluster;
   std::unique_ptr<couchbase::core::scan_result> scan_result;
 };
 
@@ -57,6 +63,7 @@ cb_CoreScanResult_free(void* ptr)
     data->scan_result->cancel();
   }
   data->scan_result.reset();
+  data->cluster.reset();
   ruby_xfree(data);
 }
 
@@ -143,10 +150,8 @@ cb_CoreScanResult_next_item(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;
 }
@@ -161,14 +166,15 @@ cb_Backend_document_scan_create(VALUE self,
                                 VALUE scan_type,
                                 VALUE options)
 {
-  auto cluster = cb_backend_to_core_api_cluster(self);
+  auto public_cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = couchbase::core::get_core_cluster(public_cluster);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
-  Check_Type(scan_type, T_HASH);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
+  cb_check_type(scan_type, T_HASH);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -201,7 +207,7 @@ cb_Backend_document_scan_create(VALUE self,
             case T_BIGNUM:
               break;
             default:
-              rb_raise(rb_eArgError, "partition_uuid must be an Integer");
+              throw ruby_exception(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)) {
@@ -209,12 +215,12 @@ cb_Backend_document_scan_create(VALUE self,
             case T_BIGNUM:
               break;
             default:
-              rb_raise(rb_eArgError, "sequence_number must be an Integer");
+              throw ruby_exception(rb_eArgError, "sequence_number must be an Integer");
           }
           core_mut_state.tokens.emplace_back(
-            NUM2ULL(partition_uuid),
-            NUM2ULL(sequence_number),
-            gsl::narrow_cast<std::uint16_t>(NUM2UINT(partition_id)),
+            cb_num2ull(partition_uuid),
+            cb_num2ull(sequence_number),
+            gsl::narrow_cast<std::uint16_t>(cb_num2uint(partition_id)),
             cb_string_new(bucket_name));
         }
 
@@ -232,13 +238,11 @@ cb_Backend_document_scan_create(VALUE self,
     auto err = agent_group.open_bucket(bucket_name);
     if (err) {
       cb_throw_error_code(err, "unable to open bucket for range scan");
-      return Qnil;
     }
     auto agent = agent_group.get_agent(bucket_name);
     if (!agent.has_value()) {
-      rb_raise(exc_couchbase_error(),
-               "Cannot perform scan operation. Unable to get operation agent");
-      return Qnil;
+      throw ruby_exception(exc_couchbase_error(),
+                           "Cannot perform scan operation. Unable to get operation agent");
     }
 
     // Getting the vbucket map
@@ -253,18 +257,17 @@ cb_Backend_document_scan_create(VALUE self,
       });
     auto config = cb_wait_for_future(f);
     if (!config.has_value()) {
-      rb_raise(exc_couchbase_error(),
-               "Cannot perform scan operation. Unable to get bucket configuration");
-      return Qnil;
+      throw ruby_exception(exc_couchbase_error(),
+                           "Cannot perform scan operation. Unable to get bucket configuration");
     }
     if (!config->capabilities.supports_range_scan()) {
-      rb_raise(exc_feature_not_available(), "Server does not support key-value scan operations");
-      return Qnil;
+      throw ruby_exception(exc_feature_not_available(),
+                           "Server does not support key-value scan operations");
     }
     auto vbucket_map = config->vbmap;
     if (!vbucket_map || vbucket_map->empty()) {
-      rb_raise(exc_couchbase_error(), "Cannot perform scan operation. Unable to get vbucket map");
-      return Qnil;
+      throw ruby_exception(exc_couchbase_error(),
+                           "Cannot perform scan operation. Unable to get vbucket map");
     }
 
     // Constructing the scan type
@@ -273,7 +276,7 @@ cb_Backend_document_scan_create(VALUE self,
                  couchbase::core::prefix_scan,
                  couchbase::core::sampling_scan>
       core_scan_type{};
-    ID scan_type_id = rb_sym2id(rb_hash_aref(scan_type, rb_id2sym(rb_intern("scan_type"))));
+    ID scan_type_id = cb_sym2id(rb_hash_aref(scan_type, rb_id2sym(rb_intern("scan_type"))));
     if (scan_type_id == rb_intern("range")) {
       auto range_scan = couchbase::core::range_scan{};
 
@@ -281,13 +284,13 @@ cb_Backend_document_scan_create(VALUE self,
       VALUE to_hash = rb_hash_aref(scan_type, rb_id2sym(rb_intern("to")));
 
       if (!NIL_P(from_hash)) {
-        Check_Type(from_hash, T_HASH);
+        cb_check_type(from_hash, T_HASH);
         range_scan.from = couchbase::core::scan_term{};
         cb_extract_option_string(range_scan.from->term, from_hash, "term");
         cb_extract_option_bool(range_scan.from->exclusive, from_hash, "exclusive");
       }
       if (!NIL_P(to_hash)) {
-        Check_Type(to_hash, T_HASH);
+        cb_check_type(to_hash, T_HASH);
         range_scan.to = couchbase::core::scan_term{};
         cb_extract_option_string(range_scan.to->term, to_hash, "term");
         cb_extract_option_bool(range_scan.to->exclusive, to_hash, "exclusive");
@@ -303,7 +306,7 @@ cb_Backend_document_scan_create(VALUE self,
       cb_extract_option_number(sampling_scan.seed, scan_type, "seed");
       core_scan_type = sampling_scan;
     } else {
-      rb_raise(exc_invalid_argument(), "Invalid scan operation type");
+      throw ruby_exception(exc_invalid_argument(), "Invalid scan operation type");
     }
 
     auto orchestrator = couchbase::core::range_scan_orchestrator(cluster.io_context(),
@@ -323,19 +326,21 @@ cb_Backend_document_scan_create(VALUE self,
     // Wrap core scan_result inside Ruby ScanResult
     // Creating a Ruby CoreScanResult object *after* checking that no error occurred during
     // orchestrator.scan()
-    VALUE core_scan_result_obj = rb_class_new_instance(0, nullptr, cCoreScanResult);
+    VALUE core_scan_result_obj = Qnil;
+    cb_protect([&core_scan_result_obj] {
+      core_scan_result_obj = rb_class_new_instance(0, nullptr, cCoreScanResult);
+    });
     rb_ivar_set(core_scan_result_obj, rb_intern("@backend"), self);
     cb_core_scan_result_data* data = nullptr;
     TypedData_Get_Struct(
       core_scan_result_obj, cb_core_scan_result_data, &cb_core_scan_result_type, data);
+    data->cluster = std::make_unique<couchbase::cluster>(std::move(public_cluster));
     data->scan_result = std::make_unique<couchbase::core::scan_result>(resp.value());
     return core_scan_result_obj;
 
   } 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;
 }
@@ -345,11 +350,12 @@ cb_Backend_document_scan_create(VALUE self,
 void
 init_range_scan(VALUE mCouchbase, VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_scan_create", cb_Backend_document_scan_create, 5);
+  rb_define_method(
+    cBackend, "document_scan_create", cb_method<cb_Backend_document_scan_create>::invoke, 5);
 
   cCoreScanResult = rb_define_class_under(mCouchbase, "CoreScanResult", rb_cObject);
   rb_define_alloc_func(cCoreScanResult, cb_CoreScanResult_allocate);
-  rb_define_method(cCoreScanResult, "next_item", cb_CoreScanResult_next_item, 0);
+  rb_define_method(cCoreScanResult, "next_item", cb_method<cb_CoreScanResult_next_item>::invoke, 0);
   rb_define_method(cCoreScanResult, "cancelled?", cb_CoreScanResult_is_cancelled, 0);
   rb_define_method(cCoreScanResult, "cancel", cb_CoreScanResult_cancel, 0);
 }

data/ext/rcb_search.cxx

@@ -29,6 +29,7 @@
 #include <core/operations/management/search_index_get_documents_count.hxx>
 #include <core/operations/management/search_index_get_stats.hxx>
 #include <core/operations/management/search_index_upsert.hxx>
+#include <core/search_scoring.hxx>
 
 #include <gsl/narrow>
 #include <spdlog/fmt/bundled/core.h>
@@ -115,10 +116,8 @@ cb_Backend_search_index_get_all(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("indexes")), indexes);
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    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;
 }
@@ -133,7 +132,7 @@ cb_Backend_search_index_get(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_get_request req{};
@@ -168,10 +167,8 @@ cb_Backend_search_index_get(VALUE self,
     cb_extract_search_index(res, resp.index);
     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;
 }
@@ -186,7 +183,7 @@ cb_Backend_search_index_upsert(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_definition, T_HASH);
+  cb_check_type(index_definition, T_HASH);
 
   try {
     core::operations::management::search_index_upsert_request req{};
@@ -271,10 +268,8 @@ cb_Backend_search_index_upsert(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -289,7 +284,7 @@ cb_Backend_search_index_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_drop_request req{};
@@ -325,10 +320,8 @@ cb_Backend_search_index_drop(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -343,7 +336,7 @@ cb_Backend_search_index_get_documents_count(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_get_documents_count_request req{};
@@ -385,10 +378,8 @@ cb_Backend_search_index_get_documents_count(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("count")), ULL2NUM(resp.count));
     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;
 }
@@ -401,7 +392,7 @@ cb_Backend_search_index_get_stats(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_get_stats_request req{};
@@ -428,10 +419,8 @@ cb_Backend_search_index_get_stats(VALUE self,
     }
     return cb_str_new(resp.stats);
   } 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;
 }
@@ -457,10 +446,8 @@ cb_Backend_search_get_stats(VALUE self, VALUE timeout, VALUE observability_handl
     }
     return cb_str_new(resp.stats);
   } 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;
 }
@@ -475,7 +462,7 @@ cb_Backend_search_index_pause_ingest(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_control_ingest_request req{};
@@ -514,10 +501,8 @@ cb_Backend_search_index_pause_ingest(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -532,7 +517,7 @@ cb_Backend_search_index_resume_ingest(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_control_ingest_request req{};
@@ -571,10 +556,8 @@ cb_Backend_search_index_resume_ingest(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -589,7 +572,7 @@ cb_Backend_search_index_allow_querying(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_control_query_request req{};
@@ -628,10 +611,8 @@ cb_Backend_search_index_allow_querying(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -646,7 +627,7 @@ cb_Backend_search_index_disallow_querying(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_control_query_request req{};
@@ -685,10 +666,8 @@ cb_Backend_search_index_disallow_querying(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -703,7 +682,7 @@ cb_Backend_search_index_freeze_plan(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_control_plan_freeze_request req{};
@@ -741,10 +720,8 @@ cb_Backend_search_index_freeze_plan(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -759,7 +736,7 @@ cb_Backend_search_index_unfreeze_plan(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
 
   try {
     core::operations::management::search_index_control_plan_freeze_request req{};
@@ -798,10 +775,8 @@ cb_Backend_search_index_unfreeze_plan(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
     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;
 }
@@ -817,8 +792,8 @@ cb_Backend_search_index_analyze_document(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
-  Check_Type(encoded_document, T_STRING);
+  cb_check_type(index_name, T_STRING);
+  cb_check_type(encoded_document, T_STRING);
 
   try {
     core::operations::management::search_index_analyze_document_request req{};
@@ -861,29 +836,12 @@ cb_Backend_search_index_analyze_document(VALUE self,
     rb_hash_aset(res, rb_id2sym(rb_intern("analysis")), cb_str_new(resp.analysis));
     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;
 }
 
-int
-cb_for_each_raw_param(VALUE key, VALUE value, VALUE arg)
-{
-  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-  auto* preq = reinterpret_cast<core::operations::search_request*>(arg);
-  try {
-    cb_check_type(key, T_STRING);
-    cb_check_type(value, T_STRING);
-  } catch (const ruby_exception&) {
-    return ST_STOP;
-  }
-  preq->raw[cb_string_new(key)] = cb_string_new(value);
-  return ST_CONTINUE;
-}
-
 VALUE
 cb_Backend_document_search(VALUE self,
                            VALUE bucket,
@@ -896,10 +854,10 @@ cb_Backend_document_search(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
-  Check_Type(query, T_STRING);
+  cb_check_type(index_name, T_STRING);
+  cb_check_type(query, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -926,6 +884,28 @@ cb_Backend_document_search(VALUE self,
     cb_extract_option_bool(req.include_locations, options, "include_locations");
     cb_extract_option_bool(req.show_request, options, "show_request");
 
+    if (VALUE scoring = rb_hash_aref(options, rb_id2sym(rb_intern("scoring"))); !NIL_P(scoring)) {
+      cb_check_type(scoring, T_HASH);
+      VALUE mode = rb_hash_aref(scoring, rb_id2sym(rb_intern("mode")));
+      cb_check_type(mode, T_SYMBOL);
+      VALUE params = rb_hash_aref(scoring, rb_id2sym(rb_intern("params")));
+      if (ID mode_type = rb_sym2id(mode); mode_type == rb_intern("none")) {
+        req.scoring = core::search_scoring_none{};
+      } else if (mode_type == rb_intern("reciprocal_rank_fusion")) {
+        core::search_scoring_reciprocal_rank_fusion rrf{};
+        cb_extract_option_number(rrf.rank_constant, params, "rank_constant");
+        cb_extract_option_number(rrf.window_size, params, "window_size");
+        req.scoring = rrf;
+      } else if (mode_type == rb_intern("relative_score_fusion")) {
+        core::search_scoring_relative_score_fusion rsf{};
+        cb_extract_option_number(rsf.window_size, params, "window_size");
+        req.scoring = rsf;
+      } else {
+        throw ruby_exception(rb_eArgError,
+                             cb_sprintf("unknown search scoring mode: %+" PRIsVALUE, mode));
+      }
+    }
+
     if (VALUE vector_options = rb_hash_aref(search_request, rb_id2sym(rb_intern("vector_search")));
         !NIL_P(vector_options)) {
       cb_check_type(vector_options, T_HASH);
@@ -1015,9 +995,9 @@ cb_Backend_document_search(VALUE self,
           default:
             throw ruby_exception(rb_eArgError, "sequence_number must be an Integer");
         }
-        req.mutation_state.emplace_back(NUM2ULL(partition_uuid),
-                                        NUM2ULL(sequence_number),
-                                        gsl::narrow_cast<std::uint16_t>(NUM2UINT(partition_id)),
+        req.mutation_state.emplace_back(cb_num2ull(partition_uuid),
+                                        cb_num2ull(sequence_number),
+                                        gsl::narrow_cast<std::uint16_t>(cb_num2uint(partition_id)),
                                         cb_string_new(bucket_name));
       }
     }
@@ -1071,8 +1051,7 @@ cb_Backend_document_search(VALUE self,
     if (VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
         !NIL_P(raw_params)) {
       cb_check_type(raw_params, T_HASH);
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-      rb_hash_foreach(raw_params, cb_for_each_raw_param, reinterpret_cast<VALUE>(&req));
+      cb_extract_string_hash(req.raw, raw_params, "raw_parameters");
     }
 
     auto parent_span = cb_create_parent_span(req, self);
@@ -1238,10 +1217,8 @@ cb_Backend_document_search(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;
 }
@@ -1251,27 +1228,49 @@ cb_Backend_document_search(VALUE self,
 void
 init_search(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_search", cb_Backend_document_search, 7);
-
-  rb_define_method(cBackend, "search_get_stats", cb_Backend_search_get_stats, 2);
-  rb_define_method(cBackend, "search_index_get_all", cb_Backend_search_index_get_all, 4);
-  rb_define_method(cBackend, "search_index_get", cb_Backend_search_index_get, 5);
-  rb_define_method(cBackend, "search_index_upsert", cb_Backend_search_index_upsert, 5);
-  rb_define_method(cBackend, "search_index_drop", cb_Backend_search_index_drop, 5);
-  rb_define_method(cBackend, "search_index_get_stats", cb_Backend_search_index_get_stats, 3);
-  rb_define_method(
-    cBackend, "search_index_get_documents_count", cb_Backend_search_index_get_documents_count, 5);
-  rb_define_method(cBackend, "search_index_pause_ingest", cb_Backend_search_index_pause_ingest, 5);
-  rb_define_method(
-    cBackend, "search_index_resume_ingest", cb_Backend_search_index_resume_ingest, 5);
+  rb_define_method(cBackend, "document_search", cb_method<cb_Backend_document_search>::invoke, 7);
+
+  rb_define_method(cBackend, "search_get_stats", cb_method<cb_Backend_search_get_stats>::invoke, 2);
   rb_define_method(
-    cBackend, "search_index_allow_querying", cb_Backend_search_index_allow_querying, 5);
+    cBackend, "search_index_get_all", cb_method<cb_Backend_search_index_get_all>::invoke, 4);
+  rb_define_method(cBackend, "search_index_get", cb_method<cb_Backend_search_index_get>::invoke, 5);
   rb_define_method(
-    cBackend, "search_index_disallow_querying", cb_Backend_search_index_disallow_querying, 5);
-  rb_define_method(cBackend, "search_index_freeze_plan", cb_Backend_search_index_freeze_plan, 5);
+    cBackend, "search_index_upsert", cb_method<cb_Backend_search_index_upsert>::invoke, 5);
   rb_define_method(
-    cBackend, "search_index_unfreeze_plan", cb_Backend_search_index_unfreeze_plan, 5);
+    cBackend, "search_index_drop", cb_method<cb_Backend_search_index_drop>::invoke, 5);
   rb_define_method(
-    cBackend, "search_index_analyze_document", cb_Backend_search_index_analyze_document, 6);
+    cBackend, "search_index_get_stats", cb_method<cb_Backend_search_index_get_stats>::invoke, 3);
+  rb_define_method(cBackend,
+                   "search_index_get_documents_count",
+                   cb_method<cb_Backend_search_index_get_documents_count>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_pause_ingest",
+                   cb_method<cb_Backend_search_index_pause_ingest>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_resume_ingest",
+                   cb_method<cb_Backend_search_index_resume_ingest>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_allow_querying",
+                   cb_method<cb_Backend_search_index_allow_querying>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_disallow_querying",
+                   cb_method<cb_Backend_search_index_disallow_querying>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_freeze_plan",
+                   cb_method<cb_Backend_search_index_freeze_plan>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_unfreeze_plan",
+                   cb_method<cb_Backend_search_index_unfreeze_plan>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "search_index_analyze_document",
+                   cb_method<cb_Backend_search_index_analyze_document>::invoke,
+                   6);
 }
 } // namespace couchbase::ruby