Refactor ColumnFamilyDescriptor to be RocksObject

java/CMakeLists.txt

@@ -21,6 +21,7 @@ set(JNI_NATIVE_SOURCES
         rocksjni/cassandra_value_operator.cc
         rocksjni/checkpoint.cc
         rocksjni/clock_cache.cc
+        rocksjni/columnfamilydescriptor.cc
         rocksjni/columnfamilyhandle.cc
         rocksjni/compact_range_options.cc
         rocksjni/compaction_filter.cc
@@ -321,6 +322,7 @@ set(JAVA_TEST_CLASSES
   src/test/java/org/rocksdb/BytewiseComparatorRegressionTest.java
   src/test/java/org/rocksdb/CheckPointTest.java
   src/test/java/org/rocksdb/ClockCacheTest.java
+  src/test/java/org/rocksdb/ColumnFamilyDescriptorTest.java
   src/test/java/org/rocksdb/ColumnFamilyOptionsTest.java
   src/test/java/org/rocksdb/ColumnFamilyTest.java
   src/test/java/org/rocksdb/CompactRangeOptionsTest.java
@@ -439,6 +441,7 @@ set(JAVA_TEST_RUNNING_CLASSES
   org.rocksdb.BytewiseComparatorRegressionTest
   org.rocksdb.CheckPointTest
   org.rocksdb.ClockCacheTest
+  org.rocksdb.ColumnFamilyDescriptorTest
   org.rocksdb.ColumnFamilyOptionsTest
   org.rocksdb.ColumnFamilyTest
   org.rocksdb.CompactRangeOptionsTest

java/rocksjni/columnfamilydescriptor.cc

@@ -0,0 +1,64 @@
+
+#include <jni.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "include/org_rocksdb_ColumnFamilyDescriptor.h"
+#include "rocksjni/portal.h"
+
+/*
+ * Class:     org_rocksdb_ColumnFamilyDescriptor
+ * Method:    createNativeInstance
+ * Signature: ([BJ)J
+ */
+jlong Java_org_rocksdb_ColumnFamilyDescriptor_createNativeDescriptor(
+    JNIEnv* env, jclass, jbyteArray jname, jlong jcf_options_handle) {
+  jboolean has_exception = JNI_FALSE;
+
+  auto cf_name = ROCKSDB_NAMESPACE::JniUtil::byteString<std::string>(
+      env, jname,
+      [](const char* str_data, const size_t str_len) {
+        return std::string(str_data, str_len);
+      },
+      &has_exception);
+
+  if (has_exception) {
+    return 0;
+  }
+
+  auto cf_options = reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(
+      jcf_options_handle);
+
+  ROCKSDB_NAMESPACE::ColumnFamilyDescriptor* cf_descriptor =
+      new ROCKSDB_NAMESPACE::ColumnFamilyDescriptor(cf_name, *cf_options);
+
+  return GET_CPLUSPLUS_POINTER(cf_descriptor);
+}
+
+/*
+ * Class:     org_rocksdb_ColumnFamilyDescriptor
+ * Method:    getName
+ * Signature: (J)[B
+ */
+jbyteArray Java_org_rocksdb_ColumnFamilyDescriptor_getName(
+    JNIEnv* env, jclass, jlong jcf_descriptor_handle) {
+  auto cf_descriptor =
+      reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor*>(
+          jcf_descriptor_handle);
+
+  return ROCKSDB_NAMESPACE::JniUtil::copyBytes(env, cf_descriptor->name);
+}
+
+/*
+ * Class:     org_rocksdb_ColumnFamilyDescriptor
+ * Method:    disposeJni
+ * Signature: (J)V
+ */
+void Java_org_rocksdb_ColumnFamilyDescriptor_disposeJni(
+    JNIEnv*, jclass, jlong jcf_descriptor_handle) {
+  auto cf_options =
+      reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor*>(
+          jcf_descriptor_handle);
+
+  delete (cf_options);
+}

java/rocksjni/optimistic_transaction_db.cc

@@ -51,56 +51,22 @@ jlong Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2(
  * Signature: (JLjava/lang/String;[[B[J)[J
  */
 jlongArray
-Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3_3B_3J(
+Java_org_rocksdb_OptimisticTransactionDB_open__JLjava_lang_String_2_3J(
     JNIEnv* env, jclass, jlong jdb_options_handle, jstring jdb_path,
-    jobjectArray jcolumn_names, jlongArray jcolumn_options_handles) {
+    jlongArray jcf_descriptors) {
   const char* db_path = env->GetStringUTFChars(jdb_path, nullptr);
   if (db_path == nullptr) {
     // exception thrown: OutOfMemoryError
     return nullptr;
   }
 
-  std::vector<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor> column_families;
-  const jsize len_cols = env->GetArrayLength(jcolumn_names);
-  if (len_cols > 0) {
-    jlong* jco = env->GetLongArrayElements(jcolumn_options_handles, nullptr);
-    if (jco == nullptr) {
-      // exception thrown: OutOfMemoryError
-      env->ReleaseStringUTFChars(jdb_path, db_path);
-      return nullptr;
-    }
-
-    for (int i = 0; i < len_cols; i++) {
-      const jobject jcn = env->GetObjectArrayElement(jcolumn_names, i);
-      if (env->ExceptionCheck()) {
-        // exception thrown: ArrayIndexOutOfBoundsException
-        env->ReleaseLongArrayElements(jcolumn_options_handles, jco, JNI_ABORT);
-        env->ReleaseStringUTFChars(jdb_path, db_path);
-        return nullptr;
-      }
+  const jsize len_cols = env->GetArrayLength(jcf_descriptors);
 
-      const jbyteArray jcn_ba = reinterpret_cast<jbyteArray>(jcn);
-      const jsize jcf_name_len = env->GetArrayLength(jcn_ba);
-      jbyte* jcf_name = env->GetByteArrayElements(jcn_ba, nullptr);
-      if (jcf_name == nullptr) {
-        // exception thrown: OutOfMemoryError
-        env->DeleteLocalRef(jcn);
-        env->ReleaseLongArrayElements(jcolumn_options_handles, jco, JNI_ABORT);
-        env->ReleaseStringUTFChars(jdb_path, db_path);
-        return nullptr;
-      }
-
-      const std::string cf_name(reinterpret_cast<char*>(jcf_name),
-                                jcf_name_len);
-      const ROCKSDB_NAMESPACE::ColumnFamilyOptions* cf_options =
-          reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jco[i]);
-      column_families.push_back(
-          ROCKSDB_NAMESPACE::ColumnFamilyDescriptor(cf_name, *cf_options));
-
-      env->ReleaseByteArrayElements(jcn_ba, jcf_name, JNI_ABORT);
-      env->DeleteLocalRef(jcn);
-    }
-    env->ReleaseLongArrayElements(jcolumn_options_handles, jco, JNI_ABORT);
+  auto column_families =
+      ROCKSDB_NAMESPACE::ColumnFamilyDescriptorJni::jcf_descriptorsToVec(
+          env, jcf_descriptors);
+  if (env->ExceptionCheck()) {
+    return nullptr;
   }
 
   auto* db_options =

java/rocksjni/portal.h

@@ -6788,14 +6788,14 @@ class ColumnFamilyDescriptorJni : public JavaClass {
     }
 
     jmethodID mid = env->GetMethodID(jclazz, "<init>",
-                                     "([BLorg/rocksdb/ColumnFamilyOptions;)V");
+                                     "([BLorg/rocksdb/ColumnFamilyOptions;Z)V");
     if (mid == nullptr) {
       // exception thrown: NoSuchMethodException or OutOfMemoryError
       env->DeleteLocalRef(jcf_name);
       return nullptr;
     }
 
-    jobject jcfd = env->NewObject(jclazz, mid, jcf_name, cfopts);
+    jobject jcfd = env->NewObject(jclazz, mid, jcf_name, cfopts, JNI_TRUE);
     if (env->ExceptionCheck()) {
       env->DeleteLocalRef(jcf_name);
       return nullptr;
@@ -6844,6 +6844,35 @@ class ColumnFamilyDescriptorJni : public JavaClass {
     assert(mid != nullptr);
     return mid;
   }
+
+  /**
+   * @brief Converts a Java long array to a vector of ColumnFamilyDescriptor.
+   *
+   * @param env The JNI environment pointer.
+   * @param jcf_descriptors The JNI long array containing column family
+   * descriptors.
+   * @return A `std::vector` of `ROCKSDB_NAMESPACE::ColumnFamilyDescriptor`.
+   *         Returns an empty vector if an exception occurs.
+   */
+  static std::vector<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor>
+  jcf_descriptorsToVec(JNIEnv* env, jlongArray jcf_descriptors) {
+    const jsize len_cols = env->GetArrayLength(jcf_descriptors);
+
+    auto cf_descriptors = std::make_unique<jlong[]>(len_cols);
+    env->GetLongArrayRegion(jcf_descriptors, 0, len_cols, cf_descriptors.get());
+    if (env->ExceptionCheck()) {
+      return std::vector<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor>();
+    }
+
+    std::vector<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor> column_families;
+    column_families.reserve(len_cols);
+    for (int i = 0; i < len_cols; i++) {
+      column_families.push_back(
+          *reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyDescriptor*>(
+              cf_descriptors[i]));
+    }
+    return column_families;
+  }
 };
 
 // The portal class for org.rocksdb.IndexType