couchbase 3.8.2 → 3.9.0

data/ext/rcb_query.cxx

@@ -45,9 +45,9 @@ cb_Backend_query_index_get_all(VALUE self,
 {
   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 {
@@ -113,10 +113,8 @@ cb_Backend_query_index_get_all(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;
 }
@@ -131,11 +129,11 @@ cb_Backend_query_index_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(index_name, T_STRING);
-  Check_Type(keys, T_ARRAY);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
+  cb_check_type(keys, T_ARRAY);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -165,7 +163,7 @@ cb_Backend_query_index_create(VALUE self,
       } /* else use backend default */
       if (VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
           !NIL_P(num_replicas)) {
-        req.num_replicas = NUM2UINT(num_replicas);
+        req.num_replicas = cb_num2uint(num_replicas);
       } /* else use backend default */
       if (VALUE condition = rb_hash_aref(options, rb_id2sym(rb_intern("condition")));
           !NIL_P(condition)) {
@@ -219,10 +217,8 @@ cb_Backend_query_index_create(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;
 }
@@ -236,10 +232,10 @@ cb_Backend_query_index_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket_name, T_STRING);
-  Check_Type(index_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -304,10 +300,8 @@ cb_Backend_query_index_drop(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;
 }
@@ -320,9 +314,9 @@ cb_Backend_query_index_create_primary(VALUE self,
 {
   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 {
@@ -345,7 +339,7 @@ cb_Backend_query_index_create_primary(VALUE self,
       } /* else use backend default */
       if (VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
           !NIL_P(num_replicas)) {
-        req.num_replicas = NUM2UINT(num_replicas);
+        req.num_replicas = cb_num2uint(num_replicas);
       } /* else use backend default */
       if (VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name")));
           TYPE(index_name) == T_STRING) {
@@ -398,10 +392,8 @@ cb_Backend_query_index_create_primary(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;
 }
@@ -414,9 +406,9 @@ cb_Backend_query_index_drop_primary(VALUE self,
 {
   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 {
@@ -484,10 +476,8 @@ cb_Backend_query_index_drop_primary(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;
 }
@@ -500,9 +490,9 @@ cb_Backend_query_index_build_deferred(VALUE self,
 {
   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 {
@@ -559,51 +549,19 @@ cb_Backend_query_index_build_deferred(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;
 }
 
-int
-cb_for_each_named_param(VALUE key, VALUE value, VALUE arg)
-{
-  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-  auto* preq = reinterpret_cast<core::operations::query_request*>(arg);
-  try {
-    cb_check_type(key, T_STRING);
-    cb_check_type(value, T_STRING);
-  } catch (const ruby_exception&) {
-    return ST_STOP;
-  }
-  preq->named_parameters[cb_string_new(key)] = cb_string_new(value);
-  return ST_CONTINUE;
-}
-
-int
-cb_for_each_raw_param(VALUE key, VALUE value, VALUE arg)
-{
-  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-  auto* preq = reinterpret_cast<core::operations::query_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_query(VALUE self, VALUE statement, VALUE options, VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(statement, T_STRING);
-  Check_Type(options, T_HASH);
+  cb_check_type(statement, T_STRING);
+  cb_check_type(options, T_HASH);
 
   try {
     core::operations::query_request req;
@@ -655,8 +613,7 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options, VALUE obse
     if (VALUE named_params = rb_hash_aref(options, rb_id2sym(rb_intern("named_parameters")));
         !NIL_P(named_params)) {
       cb_check_type(named_params, T_HASH);
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-      rb_hash_foreach(named_params, cb_for_each_named_param, reinterpret_cast<VALUE>(&req));
+      cb_extract_string_hash(req.named_parameters, named_params, "named_parameters");
     }
     if (VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
         !NIL_P(scan_consistency)) {
@@ -686,7 +643,7 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options, VALUE obse
           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)) {
@@ -694,11 +651,11 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options, VALUE obse
           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");
         }
-        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));
       }
     }
@@ -706,8 +663,7 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options, VALUE obse
     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);
 
@@ -776,10 +732,8 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options, VALUE obse
 
     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;
 }
@@ -794,11 +748,11 @@ cb_Backend_collection_query_index_get_all(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 {
@@ -856,10 +810,8 @@ cb_Backend_collection_query_index_get_all(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;
 }
@@ -875,13 +827,13 @@ cb_Backend_collection_query_index_create(VALUE self,
                                          VALUE observability_handler)
 {
   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);
-  Check_Type(index_name, T_STRING);
-  Check_Type(keys, T_ARRAY);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
+  cb_check_type(collection_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
+  cb_check_type(keys, T_ARRAY);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -913,7 +865,7 @@ cb_Backend_collection_query_index_create(VALUE self,
       } /* else use backend default */
       if (VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
           !NIL_P(num_replicas)) {
-        req.num_replicas = NUM2UINT(num_replicas);
+        req.num_replicas = cb_num2uint(num_replicas);
       } /* else use backend default */
       if (VALUE condition = rb_hash_aref(options, rb_id2sym(rb_intern("condition")));
           !NIL_P(condition)) {
@@ -967,10 +919,8 @@ cb_Backend_collection_query_index_create(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;
 }
@@ -986,12 +936,12 @@ cb_Backend_collection_query_index_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);
-  Check_Type(index_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
+  cb_check_type(scope_name, T_STRING);
+  cb_check_type(collection_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1058,10 +1008,8 @@ cb_Backend_collection_query_index_drop(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;
 }
@@ -1076,11 +1024,11 @@ cb_Backend_collection_query_index_create_primary(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 {
@@ -1105,7 +1053,7 @@ cb_Backend_collection_query_index_create_primary(VALUE self,
       } /* else use backend default */
       if (VALUE num_replicas = rb_hash_aref(options, rb_id2sym(rb_intern("num_replicas")));
           !NIL_P(num_replicas)) {
-        req.num_replicas = NUM2UINT(num_replicas);
+        req.num_replicas = cb_num2uint(num_replicas);
       } /* else use backend default */
       if (VALUE index_name = rb_hash_aref(options, rb_id2sym(rb_intern("index_name")));
           TYPE(index_name) == T_STRING) {
@@ -1158,10 +1106,8 @@ cb_Backend_collection_query_index_create_primary(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;
 }
@@ -1176,11 +1122,11 @@ cb_Backend_collection_query_index_drop_primary(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 {
@@ -1251,10 +1197,8 @@ cb_Backend_collection_query_index_drop_primary(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;
 }
@@ -1269,11 +1213,11 @@ cb_Backend_collection_query_index_build_deferred(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 {
@@ -1320,10 +1264,8 @@ cb_Backend_collection_query_index_build_deferred(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;
 }
@@ -1333,34 +1275,49 @@ cb_Backend_collection_query_index_build_deferred(VALUE self,
 void
 init_query(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_query", cb_Backend_document_query, 3);
+  rb_define_method(cBackend, "document_query", cb_method<cb_Backend_document_query>::invoke, 3);
 
-  rb_define_method(cBackend, "query_index_get_all", cb_Backend_query_index_get_all, 3);
-  rb_define_method(cBackend, "query_index_create", cb_Backend_query_index_create, 5);
   rb_define_method(
-    cBackend, "query_index_create_primary", cb_Backend_query_index_create_primary, 3);
-  rb_define_method(cBackend, "query_index_drop", cb_Backend_query_index_drop, 4);
-  rb_define_method(cBackend, "query_index_drop_primary", cb_Backend_query_index_drop_primary, 3);
+    cBackend, "query_index_get_all", cb_method<cb_Backend_query_index_get_all>::invoke, 3);
   rb_define_method(
-    cBackend, "query_index_build_deferred", cb_Backend_query_index_build_deferred, 3);
+    cBackend, "query_index_create", cb_method<cb_Backend_query_index_create>::invoke, 5);
+  rb_define_method(cBackend,
+                   "query_index_create_primary",
+                   cb_method<cb_Backend_query_index_create_primary>::invoke,
+                   3);
+  rb_define_method(cBackend, "query_index_drop", cb_method<cb_Backend_query_index_drop>::invoke, 4);
+  rb_define_method(cBackend,
+                   "query_index_drop_primary",
+                   cb_method<cb_Backend_query_index_drop_primary>::invoke,
+                   3);
+  rb_define_method(cBackend,
+                   "query_index_build_deferred",
+                   cb_method<cb_Backend_query_index_build_deferred>::invoke,
+                   3);
 
-  rb_define_method(
-    cBackend, "collection_query_index_get_all", cb_Backend_collection_query_index_get_all, 5);
-  rb_define_method(
-    cBackend, "collection_query_index_create", cb_Backend_collection_query_index_create, 7);
+  rb_define_method(cBackend,
+                   "collection_query_index_get_all",
+                   cb_method<cb_Backend_collection_query_index_get_all>::invoke,
+                   5);
+  rb_define_method(cBackend,
+                   "collection_query_index_create",
+                   cb_method<cb_Backend_collection_query_index_create>::invoke,
+                   7);
   rb_define_method(cBackend,
                    "collection_query_index_create_primary",
-                   cb_Backend_collection_query_index_create_primary,
+                   cb_method<cb_Backend_collection_query_index_create_primary>::invoke,
                    5);
-  rb_define_method(
-    cBackend, "collection_query_index_drop", cb_Backend_collection_query_index_drop, 6);
+  rb_define_method(cBackend,
+                   "collection_query_index_drop",
+                   cb_method<cb_Backend_collection_query_index_drop>::invoke,
+                   6);
   rb_define_method(cBackend,
                    "collection_query_index_drop_primary",
-                   cb_Backend_collection_query_index_drop_primary,
+                   cb_method<cb_Backend_collection_query_index_drop_primary>::invoke,
                    5);
   rb_define_method(cBackend,
                    "collection_query_index_build_deferred",
-                   cb_Backend_collection_query_index_build_deferred,
+                   cb_method<cb_Backend_collection_query_index_build_deferred>::invoke,
                    5);
 }
 } // namespace couchbase::ruby