feat: better ways to use deletion vectors

ffi/src/lib.rs

@@ -4,12 +4,14 @@
 #[cfg(any(feature = "default-engine", feature = "sync-engine"))]
 use std::collections::HashMap;
 use std::default::Default;
+use std::ffi::{c_long, c_longlong, c_ulonglong};
 use std::os::raw::{c_char, c_void};
 use std::ptr::NonNull;
 use std::sync::Arc;
 use tracing::debug;
 use url::Url;
 
+use delta_kernel::actions::deletion_vector::DeletionVector;
 use delta_kernel::expressions::{BinaryOperator, Expression, Scalar};
 use delta_kernel::schema::{ArrayType, DataType, MapType, PrimitiveType, StructType};
 use delta_kernel::snapshot::Snapshot;
@@ -113,6 +115,8 @@ pub type AllocateStringFn = extern "C" fn(kernel_str: KernelStringSlice) -> Null
 // Put KernelBoolSlice in a sub-module, with non-public members, so rust code cannot instantiate it
 // directly. It can only be created by converting `From<Vec<bool>>`.
 mod private {
+    use delta_kernel::actions::deletion_vector::DeletionVector;
+
     /// Represents an owned slice of boolean values allocated by the kernel. Any time the engine
     /// receives a `KernelBoolSlice` as a return value from a kernel method, engine is responsible
     /// to free that slice, by calling [super::drop_bool_slice] exactly once.
@@ -122,6 +126,12 @@ mod private {
         len: usize,
     }
 
+    #[repr(C)]
+    pub struct KernelRowIndexArray {
+        ptr: *mut u64,
+        len: usize,
+    }
+
     impl KernelBoolSlice {
         /// Creates an empty slice.
         pub fn empty() -> KernelBoolSlice {
@@ -175,13 +185,43 @@ mod private {
     /// memory, but must only free it by calling [super::drop_bool_slice]. Since the global
     /// allocator is threadsafe, it doesn't matter which engine thread invokes that method.
     unsafe impl Send for KernelBoolSlice {}
+    unsafe impl Send for KernelRowIndexArray {}
 
     /// # Safety
     ///
     /// If engine chooses to leverage concurrency, engine is responsible to prevent data races.
     unsafe impl Sync for KernelBoolSlice {}
+    unsafe impl Sync for KernelRowIndexArray {}
+
+    impl KernelRowIndexArray {
+        /// Converts this slice back into a `Vec<u64>`.
+        ///
+        /// # Safety
+        ///
+        /// The slice must have been originally created `From<Vec<u64>>`, and must not have been
+        /// already been consumed by a previous call to this method.
+        pub unsafe fn into_vec(self) -> Vec<u64> {
+            if self.ptr.is_null() {
+                Default::default()
+            } else {
+                Vec::from_raw_parts(self.ptr, self.len, self.len)
+            }
+        }
+    }
+
+    impl From<DeletionVector> for KernelRowIndexArray {
+        fn from(value: DeletionVector) -> Self {
+            let mut vec = value.row_indexes();
+            vec.shrink_to_fit();
+            let len = vec.len();
+            let boxed = vec.into_boxed_slice();
+            let ptr = Box::into_raw(boxed).cast();
+            KernelRowIndexArray { ptr, len }
+        }
+    }
 }
 pub use private::KernelBoolSlice;
+pub use private::KernelRowIndexArray;
 
 /// # Safety
 ///
@@ -192,6 +232,11 @@ pub unsafe extern "C" fn drop_bool_slice(slice: KernelBoolSlice) {
     debug!("Dropping bool slice. It is {vec:#?}");
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn drop_row_indexes(slice: KernelRowIndexArray) {
+    let _ = slice.into_vec();
+}
+
 #[repr(C)]
 #[derive(Debug)]
 pub enum KernelError {

kernel/src/actions/deletion_vector.rs

@@ -4,10 +4,11 @@ use std::io::{Cursor, Read};
 use std::sync::Arc;
 
 use bytes::Bytes;
-use delta_kernel_derive::Schema;
 use roaring::RoaringTreemap;
 use url::Url;
 
+use delta_kernel_derive::Schema;
+
 use crate::utils::require;
 use crate::{DeltaResult, Error, FileSystemClient};
 
@@ -165,6 +166,14 @@ impl DeletionVectorDescriptor {
             }
         }
     }
+
+    pub fn into_deletion_vector(
+        self,
+        fs_client: Arc<dyn FileSystemClient>,
+        parent: &Url,
+    ) -> DeltaResult<DeletionVector> {
+        DeletionVector::new(fs_client, parent, self)
+    }
 }
 
 enum Endian {
@@ -223,15 +232,37 @@ pub(crate) fn treemap_to_bools(treemap: RoaringTreemap) -> Vec<bool> {
     }
 }
 
+#[derive(Debug, Clone)]
+#[repr(C)]
+pub struct DeletionVector {
+    inner: RoaringTreemap,
+}
+
+impl DeletionVector {
+    pub fn new(
+        fs_client: Arc<dyn FileSystemClient>,
+        parent: &Url,
+        descriptor: DeletionVectorDescriptor,
+    ) -> DeltaResult<Self> {
+        let inner = descriptor.read(fs_client, parent)?;
+        Ok(Self { inner })
+    }
+
+    pub fn row_indexes(self) -> Vec<u64> {
+        self.inner.into_iter().collect::<Vec<u64>>()
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use roaring::RoaringTreemap;
     use std::path::PathBuf;
 
-    use super::*;
+    use roaring::RoaringTreemap;
+
     use crate::{engine::sync::SyncEngine, Engine};
 
     use super::DeletionVectorDescriptor;
+    use super::*;
 
     fn dv_relative() -> DeletionVectorDescriptor {
         DeletionVectorDescriptor {
@@ -358,4 +389,16 @@ mod tests {
         expected[4294967300] = false;
         assert_eq!(bools, expected);
     }
+
+    #[tokio::test]
+    async fn test_dv_wrapper() -> Result<(), Box<dyn std::error::Error>> {
+        let example = dv_inline();
+        let sync_engine = SyncEngine::new();
+        let fs_client = sync_engine.get_file_system_client();
+        let parent = Url::parse("http://not.used")?;
+        let dv = example.into_deletion_vector(fs_client, &parent)?;
+        let row_idx = dv.row_indexes();
+        dbg!(row_idx);
+        Ok(())
+    }
 }