couchbase 3.8.1 → 3.9.0

data/ext/rcb_buckets.cxx

@@ -56,11 +56,11 @@ cb_generate_bucket_settings(VALUE bucket,
         entry.bucket_type = core::management::cluster::bucket_type::ephemeral;
       } else {
         throw ruby_exception(rb_eArgError,
-                             rb_sprintf("unknown bucket type, given %+" PRIsVALUE, bucket_type));
+                             cb_sprintf("unknown bucket type, given %+" PRIsVALUE, bucket_type));
       }
     } else {
       throw ruby_exception(
-        rb_eArgError, rb_sprintf("bucket type must be a Symbol, given %+" PRIsVALUE, bucket_type));
+        rb_eArgError, cb_sprintf("bucket type must be a Symbol, given %+" PRIsVALUE, bucket_type));
     }
   }
 
@@ -68,7 +68,7 @@ cb_generate_bucket_settings(VALUE bucket,
     entry.name = cb_string_new(name);
   } else {
     throw ruby_exception(rb_eArgError,
-                         rb_sprintf("bucket name must be a String, given %+" PRIsVALUE, name));
+                         cb_sprintf("bucket name must be a String, given %+" PRIsVALUE, name));
   }
 
   if (VALUE quota = rb_hash_aref(bucket, rb_id2sym(rb_intern("ram_quota_mb"))); !NIL_P(quota)) {
@@ -76,28 +76,28 @@ cb_generate_bucket_settings(VALUE bucket,
       entry.ram_quota_mb = FIX2ULONG(quota);
     } else {
       throw ruby_exception(
-        rb_eArgError, rb_sprintf("bucket RAM quota must be an Integer, given %+" PRIsVALUE, quota));
+        rb_eArgError, cb_sprintf("bucket RAM quota must be an Integer, given %+" PRIsVALUE, quota));
     }
   }
 
   if (VALUE expiry = rb_hash_aref(bucket, rb_id2sym(rb_intern("max_expiry"))); !NIL_P(expiry)) {
     if (TYPE(expiry) == T_FIXNUM) {
-      entry.max_expiry = FIX2UINT(expiry);
+      entry.max_expiry = cb_num2uint(expiry);
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("bucket max expiry must be an Integer, given %+" PRIsVALUE, expiry));
+        cb_sprintf("bucket max expiry must be an Integer, given %+" PRIsVALUE, expiry));
     }
   }
 
   if (VALUE num_replicas = rb_hash_aref(bucket, rb_id2sym(rb_intern("num_replicas")));
       !NIL_P(num_replicas)) {
     if (TYPE(num_replicas) == T_FIXNUM) {
-      entry.num_replicas = FIX2UINT(num_replicas);
+      entry.num_replicas = cb_num2uint(num_replicas);
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("bucket number of replicas must be an Integer, given %+" PRIsVALUE,
+        cb_sprintf("bucket number of replicas must be an Integer, given %+" PRIsVALUE,
                    num_replicas));
     }
   }
@@ -124,12 +124,12 @@ cb_generate_bucket_settings(VALUE bucket,
       } else {
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("unknown compression mode, given %+" PRIsVALUE, compression_mode));
+          cb_sprintf("unknown compression mode, given %+" PRIsVALUE, compression_mode));
       }
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("bucket compression mode must be a Symbol, given %+" PRIsVALUE,
+        cb_sprintf("bucket compression mode must be a Symbol, given %+" PRIsVALUE,
                    compression_mode));
     }
   }
@@ -148,12 +148,12 @@ cb_generate_bucket_settings(VALUE bucket,
           core::management::cluster::bucket_eviction_policy::not_recently_used;
       } else {
         throw ruby_exception(
-          rb_eArgError, rb_sprintf("unknown eviction policy, given %+" PRIsVALUE, eviction_policy));
+          rb_eArgError, cb_sprintf("unknown eviction policy, given %+" PRIsVALUE, eviction_policy));
       }
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("bucket eviction policy must be a Symbol, given %+" PRIsVALUE, eviction_policy));
+        cb_sprintf("bucket eviction policy must be a Symbol, given %+" PRIsVALUE, eviction_policy));
     }
   }
 
@@ -167,12 +167,12 @@ cb_generate_bucket_settings(VALUE bucket,
       } else {
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("unknown storage backend type, given %+" PRIsVALUE, storage_backend));
+          cb_sprintf("unknown storage backend type, given %+" PRIsVALUE, storage_backend));
       }
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("bucket storage backend type must be a Symbol, given %+" PRIsVALUE,
+        cb_sprintf("bucket storage backend type must be a Symbol, given %+" PRIsVALUE,
                    storage_backend));
     }
   }
@@ -191,12 +191,12 @@ cb_generate_bucket_settings(VALUE bucket,
         entry.minimum_durability_level = couchbase::durability_level::persist_to_majority;
       } else {
         throw ruby_exception(
-          rb_eArgError, rb_sprintf("unknown durability level, given %+" PRIsVALUE, minimum_level));
+          rb_eArgError, cb_sprintf("unknown durability level, given %+" PRIsVALUE, minimum_level));
       }
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("bucket minimum durability level must be a Symbol, given %+" PRIsVALUE,
+        cb_sprintf("bucket minimum durability level must be a Symbol, given %+" PRIsVALUE,
                    minimum_level));
     }
   }
@@ -211,11 +211,11 @@ cb_generate_bucket_settings(VALUE bucket,
         rb_hash_aref(bucket, rb_id2sym(rb_intern("history_retention_bytes")));
       !NIL_P(history_retention_bytes)) {
     if (TYPE(history_retention_bytes) == T_FIXNUM) {
-      entry.history_retention_bytes = FIX2UINT(history_retention_bytes);
+      entry.history_retention_bytes = cb_num2uint(history_retention_bytes);
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("history retention bytes must be an Integer, given %+" PRIsVALUE,
+        cb_sprintf("history retention bytes must be an Integer, given %+" PRIsVALUE,
                    history_retention_bytes));
     }
   }
@@ -224,11 +224,11 @@ cb_generate_bucket_settings(VALUE bucket,
         rb_hash_aref(bucket, rb_id2sym(rb_intern("history_retention_duration")));
       !NIL_P(history_retention_duration)) {
     if (TYPE(history_retention_duration) == T_FIXNUM) {
-      entry.history_retention_duration = FIX2UINT(history_retention_duration);
+      entry.history_retention_duration = cb_num2uint(history_retention_duration);
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("history retention duration must be an Integer, given %+" PRIsVALUE,
+        cb_sprintf("history retention duration must be an Integer, given %+" PRIsVALUE,
                    history_retention_duration));
     }
   }
@@ -236,11 +236,11 @@ cb_generate_bucket_settings(VALUE bucket,
   if (VALUE num_vbuckets = rb_hash_aref(bucket, rb_id2sym(rb_intern("num_vbuckets")));
       !NIL_P(num_vbuckets)) {
     if (TYPE(num_vbuckets) == T_FIXNUM) {
-      entry.num_vbuckets = FIX2UINT(num_vbuckets);
+      entry.num_vbuckets = cb_num2uint(num_vbuckets);
     } else {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("num vbuckets must be an Integer, given %+" PRIsVALUE, num_vbuckets));
+        cb_sprintf("num vbuckets must be an Integer, given %+" PRIsVALUE, num_vbuckets));
     }
   }
 
@@ -260,13 +260,13 @@ cb_generate_bucket_settings(VALUE bucket,
             core::management::cluster::bucket_conflict_resolution::custom;
         } else {
           throw ruby_exception(rb_eArgError,
-                               rb_sprintf("unknown conflict resolution type, given %+" PRIsVALUE,
+                               cb_sprintf("unknown conflict resolution type, given %+" PRIsVALUE,
                                           conflict_resolution_type));
         }
       } else {
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("bucket conflict resolution type must be a Symbol, given %+" PRIsVALUE,
+          cb_sprintf("bucket conflict resolution type must be a Symbol, given %+" PRIsVALUE,
                      conflict_resolution_type));
       }
     }
@@ -281,9 +281,9 @@ cb_Backend_bucket_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_settings, T_HASH);
+  cb_check_type(bucket_settings, T_HASH);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -307,10 +307,8 @@ cb_Backend_bucket_create(VALUE self,
 
     return Qtrue;
   } 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;
 }
@@ -323,9 +321,9 @@ cb_Backend_bucket_update(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_settings, T_HASH);
+  cb_check_type(bucket_settings, T_HASH);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
   try {
     core::operations::management::bucket_update_request req{};
@@ -347,10 +345,8 @@ cb_Backend_bucket_update(VALUE self,
     }
     return Qtrue;
   } 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;
 }
@@ -360,9 +356,9 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options, VALUE obser
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -382,10 +378,8 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options, VALUE obser
     }
     return Qtrue;
   } 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;
 }
@@ -395,9 +389,9 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE options, VALUE obse
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -418,10 +412,8 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE options, VALUE obse
 
     return Qtrue;
   } 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;
 }
@@ -586,7 +578,7 @@ cb_Backend_bucket_get_all(VALUE self, VALUE options, VALUE observability_handler
   auto cluster = cb_backend_to_core_api_cluster(self);
 
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -613,10 +605,8 @@ cb_Backend_bucket_get_all(VALUE self, VALUE options, VALUE observability_handler
 
     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;
 }
@@ -626,9 +616,9 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options, VALUE observ
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -651,10 +641,8 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options, VALUE observ
     cb_extract_bucket_settings(resp.bucket, res);
     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;
 }
@@ -663,11 +651,11 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options, VALUE observ
 void
 init_buckets(VALUE cBackend)
 {
-  rb_define_method(cBackend, "bucket_create", cb_Backend_bucket_create, 3);
-  rb_define_method(cBackend, "bucket_update", cb_Backend_bucket_update, 3);
-  rb_define_method(cBackend, "bucket_drop", cb_Backend_bucket_drop, 3);
-  rb_define_method(cBackend, "bucket_flush", cb_Backend_bucket_flush, 3);
-  rb_define_method(cBackend, "bucket_get_all", cb_Backend_bucket_get_all, 2);
-  rb_define_method(cBackend, "bucket_get", cb_Backend_bucket_get, 3);
+  rb_define_method(cBackend, "bucket_create", cb_method<cb_Backend_bucket_create>::invoke, 3);
+  rb_define_method(cBackend, "bucket_update", cb_method<cb_Backend_bucket_update>::invoke, 3);
+  rb_define_method(cBackend, "bucket_drop", cb_method<cb_Backend_bucket_drop>::invoke, 3);
+  rb_define_method(cBackend, "bucket_flush", cb_method<cb_Backend_bucket_flush>::invoke, 3);
+  rb_define_method(cBackend, "bucket_get_all", cb_method<cb_Backend_bucket_get_all>::invoke, 2);
+  rb_define_method(cBackend, "bucket_get", cb_method<cb_Backend_bucket_get>::invoke, 3);
 }
 } // namespace couchbase::ruby

data/ext/rcb_collections.cxx

@@ -43,9 +43,9 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options, VALUE obs
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -91,10 +91,8 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options, VALUE obs
 
     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;
 }
@@ -108,10 +106,10 @@ cb_Backend_scope_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(scope_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -135,10 +133,8 @@ cb_Backend_scope_create(VALUE self,
     }
     return ULL2NUM(resp.uid);
   } 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;
 }
@@ -152,10 +148,10 @@ cb_Backend_scope_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(scope_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -178,10 +174,8 @@ cb_Backend_scope_drop(VALUE self,
     }
     return ULL2NUM(resp.uid);
   } 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;
 }
@@ -197,14 +191,14 @@ cb_Backend_collection_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(scope_name, T_STRING);
-  Check_Type(collection_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
+  cb_check_type(collection_name, T_STRING);
   if (!NIL_P(settings)) {
-    Check_Type(settings, T_HASH);
+    cb_check_type(settings, T_HASH);
   }
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -217,18 +211,18 @@ cb_Backend_collection_create(VALUE self,
       if (VALUE max_expiry = rb_hash_aref(settings, rb_id2sym(rb_intern("max_expiry")));
           !NIL_P(max_expiry)) {
         if (TYPE(max_expiry) == T_FIXNUM) {
-          req.max_expiry = FIX2INT(max_expiry);
+          req.max_expiry = cb_num2int(max_expiry);
           if (req.max_expiry < -1) {
             throw ruby_exception(
               exc_invalid_argument(),
-              rb_sprintf(
+              cb_sprintf(
                 "collection max expiry must be greater than or equal to -1, given %+" PRIsVALUE,
                 max_expiry));
           }
         } else {
           throw ruby_exception(
             rb_eArgError,
-            rb_sprintf("collection max expiry must be an Integer, given %+" PRIsVALUE, max_expiry));
+            cb_sprintf("collection max expiry must be an Integer, given %+" PRIsVALUE, max_expiry));
         }
       }
       if (VALUE history = rb_hash_aref(settings, rb_id2sym(rb_intern("history")));
@@ -254,10 +248,8 @@ cb_Backend_collection_create(VALUE self,
     }
     return ULL2NUM(resp.uid);
   } 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;
 }
@@ -273,14 +265,14 @@ cb_Backend_collection_update(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(scope_name, T_STRING);
-  Check_Type(collection_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
+  cb_check_type(collection_name, T_STRING);
   if (!NIL_P(settings)) {
-    Check_Type(settings, T_HASH);
+    cb_check_type(settings, T_HASH);
   }
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -293,18 +285,18 @@ cb_Backend_collection_update(VALUE self,
       if (VALUE max_expiry = rb_hash_aref(settings, rb_id2sym(rb_intern("max_expiry")));
           !NIL_P(max_expiry)) {
         if (TYPE(max_expiry) == T_FIXNUM) {
-          req.max_expiry = FIX2INT(max_expiry);
+          req.max_expiry = cb_num2int(max_expiry);
           if (req.max_expiry < -1) {
             throw ruby_exception(
               exc_invalid_argument(),
-              rb_sprintf(
+              cb_sprintf(
                 "collection max expiry must be greater than or equal to -1, given %+" PRIsVALUE,
                 max_expiry));
           }
         } else {
           throw ruby_exception(
             rb_eArgError,
-            rb_sprintf("collection max expiry must be an Integer, given %+" PRIsVALUE, max_expiry));
+            cb_sprintf("collection max expiry must be an Integer, given %+" PRIsVALUE, max_expiry));
         }
       }
       if (VALUE history = rb_hash_aref(settings, rb_id2sym(rb_intern("history")));
@@ -330,10 +322,8 @@ cb_Backend_collection_update(VALUE self,
     }
     return ULL2NUM(resp.uid);
   } 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;
 }
@@ -348,11 +338,11 @@ cb_Backend_collection_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(scope_name, T_STRING);
-  Check_Type(collection_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
+  cb_check_type(collection_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -379,10 +369,8 @@ cb_Backend_collection_drop(VALUE self,
 
     return ULL2NUM(resp.uid);
   } 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;
 }
@@ -391,11 +379,13 @@ cb_Backend_collection_drop(VALUE self,
 void
 init_collections(VALUE cBackend)
 {
-  rb_define_method(cBackend, "scope_get_all", cb_Backend_scope_get_all, 3);
-  rb_define_method(cBackend, "scope_create", cb_Backend_scope_create, 4);
-  rb_define_method(cBackend, "scope_drop", cb_Backend_scope_drop, 4);
-  rb_define_method(cBackend, "collection_create", cb_Backend_collection_create, 6);
-  rb_define_method(cBackend, "collection_update", cb_Backend_collection_update, 6);
-  rb_define_method(cBackend, "collection_drop", cb_Backend_collection_drop, 5);
+  rb_define_method(cBackend, "scope_get_all", cb_method<cb_Backend_scope_get_all>::invoke, 3);
+  rb_define_method(cBackend, "scope_create", cb_method<cb_Backend_scope_create>::invoke, 4);
+  rb_define_method(cBackend, "scope_drop", cb_method<cb_Backend_scope_drop>::invoke, 4);
+  rb_define_method(
+    cBackend, "collection_create", cb_method<cb_Backend_collection_create>::invoke, 6);
+  rb_define_method(
+    cBackend, "collection_update", cb_method<cb_Backend_collection_update>::invoke, 6);
+  rb_define_method(cBackend, "collection_drop", cb_method<cb_Backend_collection_drop>::invoke, 5);
 }
 } // namespace couchbase::ruby