Remove Clone and copy source structs internally

arrow/src/ffi.rs

@@ -107,7 +107,7 @@ bitflags! {
 /// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
 /// This was created by bindgen
 #[repr(C)]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FFI_ArrowSchema {
     format: *const c_char,
     name: *const c_char,
@@ -336,7 +336,7 @@ fn bit_width(data_type: &DataType, i: usize) -> Result<usize> {
 /// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
 /// This was created by bindgen
 #[repr(C)]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FFI_ArrowArray {
     pub(crate) length: i64,
     pub(crate) null_count: i64,
@@ -769,6 +769,9 @@ impl ArrowArray {
     /// creates a new [ArrowArray] from two pointers. Used to import from the C Data Interface.
     /// # Safety
     /// See safety of [ArrowArray]
+    /// Note that this function will copy the content pointed by the raw pointers. Considering
+    /// the raw pointers can be from `Arc::into_raw` or other raw pointers, users must be responsible
+    /// on managing the allocation of the structs by themselves.
     /// # Error
     /// Errors if any of the pointers is null
     pub unsafe fn try_from_raw(
@@ -781,11 +784,16 @@ impl ArrowArray {
                     .to_string(),
             ));
         };
-        let ffi_array = (*array).clone();
-        let ffi_schema = (*schema).clone();
+
+        let array_mut = array as *mut FFI_ArrowArray;
+        let schema_mut = schema as *mut FFI_ArrowSchema;
+
+        let array_data = std::ptr::replace(array_mut, FFI_ArrowArray::empty());
+        let schema_data = std::ptr::replace(schema_mut, FFI_ArrowSchema::empty());
+
         Ok(Self {
-            array: Arc::new(ffi_array),
-            schema: Arc::new(ffi_schema),
+            array: Arc::new(array_data),
+            schema: Arc::new(schema_data),
         })
     }
 
@@ -802,6 +810,41 @@ impl ArrowArray {
     pub fn into_raw(this: ArrowArray) -> (*const FFI_ArrowArray, *const FFI_ArrowSchema) {
         (Arc::into_raw(this.array), Arc::into_raw(this.schema))
     }
+
+    /// exports [ArrowArray] to raw pointers of the C Data Interface provided by the consumer.
+    /// # Safety
+    /// See safety of [ArrowArray]
+    /// This function copies the content of two FFI structs [FFI_ArrowArray] and [FFI_ArrowSchema] in
+    /// this [ArrowArray] to the location pointed by the raw pointers. Usually the raw pointers are
+    /// provided by the array data consumer.
+    pub fn export_into_raw(
+        this: ArrowArray,
+        out_array: *mut FFI_ArrowArray,
+        out_schema: *mut FFI_ArrowSchema,
+    ) {
+        let array = Arc::into_raw(this.array);
+        let schema = Arc::into_raw(this.schema);
+        unsafe {
+            std::ptr::copy_nonoverlapping(array, out_array, 1);
+            std::ptr::copy_nonoverlapping(schema, out_schema, 1);
+
+            // Clean up the structs to avoid double-dropping
+            let empty_array = Box::into_raw(Box::new(FFI_ArrowArray::empty()));
+            let empty_schema = Box::into_raw(Box::new(FFI_ArrowSchema::empty()));
+            std::ptr::copy_nonoverlapping(empty_array, array as *mut FFI_ArrowArray, 1);
+            std::ptr::copy_nonoverlapping(
+                empty_schema,
+                schema as *mut FFI_ArrowSchema,
+                1,
+            );
+
+            // Drop Box and Arc pointers
+            Box::from_raw(empty_array);
+            Box::from_raw(empty_schema);
+            Arc::from_raw(array);
+            Arc::from_raw(schema);
+        }
+    }
 }
 
 impl<'a> ArrowArrayChild<'a> {
@@ -1164,4 +1207,36 @@ mod tests {
         // (drop/release)
         Ok(())
     }
+
+    #[test]
+    fn test_export_into_raw() -> Result<()> {
+        let array = Int32Array::from(vec![1, 2, 3]);
+        let arrow_array = ArrowArray::try_from(array.data().clone())?;
+
+        // Assume two raw pointers provided by the consumer
+        let out_array = Box::new(FFI_ArrowArray::empty());
+        let out_schema = Box::new(FFI_ArrowSchema::empty());
+        let out_array_ptr = Box::into_raw(out_array);
+        let out_schema_ptr = Box::into_raw(out_schema);
+
+        ArrowArray::export_into_raw(arrow_array, out_array_ptr, out_schema_ptr);
+
+        // (simulate consumer) import it
+        unsafe {
+            let array = ArrowArray::try_from_raw(out_array_ptr, out_schema_ptr).unwrap();
+            let data = ArrayData::try_from(array)?;
+            let array = make_array(data);
+
+            // perform some operation
+            let array = array.as_any().downcast_ref::<Int32Array>().unwrap();
+            let array = kernels::arithmetic::add(array, array).unwrap();
+
+            // verify
+            assert_eq!(array, Int32Array::from(vec![2, 4, 6]));
+
+            Box::from_raw(out_array_ptr);
+            Box::from_raw(out_schema_ptr);
+        }
+        Ok(())
+    }
 }