Struct FFI_ArrowArray 

#[repr(C)]
pub struct FFI_ArrowArray {
    length: i64,
    null_count: i64,
    offset: i64,
    n_buffers: i64,
    n_children: i64,
    buffers: *mut *const c_void,
    children: *mut *mut FFI_ArrowArray,
    dictionary: *mut FFI_ArrowArray,
    release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
    private_data: *mut c_void,
}

ABI-compatible struct for ArrowArray from C Data Interface See https://arrow.apache.org/docs/format/CDataInterface.html#the-arrowarray-structure

fn export_array(array: &ArrayData) -> FFI_ArrowArray {
    FFI_ArrowArray::new(array)
}

Fields

length: i64

Logical length of the array

null_count: i64

Number of null items in the array

offset: i64

logical offset inside the array

n_buffers: i64

Number of physical buffers backing this array

n_children: i64

Number of children this array has

buffers: *mut *const c_void

C array of pointers to the start of each physical buffer backing this array

children: *mut *mut FFI_ArrowArray

C array of pointers to each child array of this array

dictionary: *mut FFI_ArrowArray

Pointer to the underlying array of dictionary values

release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>

Producer-provided release callback.

private_data: *mut c_void

Opaque pointer to producer-provided private data When exported, this MUST contain everything that is owned by this array. For example, any buffer pointed to in buffers must be here, as well as the buffers pointer itself. In other words, everything in FFI_ArrowArray must be owned by private_data and can assume that they do not outlive private_data.

Implementations

impl FFI_ArrowArray

pub fn new(data: &ArrayData) -> Self

creates a new FFI_ArrowArray from existing data.

pub unsafe fn from_raw(array: *mut FFI_ArrowArray) -> Self

Takes ownership of the pointed to FFI_ArrowArray

This acts to move the data out of array, setting the release callback to NULL

Safety

• array must be valid for reads and writes
• array must be properly aligned
• array must point to a properly initialized value of FFI_ArrowArray

pub fn empty() -> Self

create an empty FFI_ArrowArray, which can be used to import data into

pub fn release(&self) -> Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>

Returns the producer-provided release callback, if any.

pub fn private_data(&self) -> *mut c_void

Returns the opaque producer-provided private data pointer.

pub unsafe fn set_release( &mut self, release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>, ) -> Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>

Replaces the release callback, returning the previous one.

Lets a consumer wrap release: save the old callback, install its own, and chain back on drop. See https://github.com/apache/arrow-rs/issues/9771.

Safety

Drop calls this callback with a pointer to self. The new callback must correctly release this array (usually by chaining to the returned one) and must match the FFI_ArrowArray::private_data it reads. A wrong callback is undefined behavior on drop.

pub unsafe fn set_private_data( &mut self, private_data: *mut c_void, ) -> *mut c_void

Replaces the private data pointer, returning the previous one.

Safety

The old pointer is returned without being freed; the caller owns it from here. The new pointer must match what the current FFI_ArrowArray::release callback expects.

pub fn len(&self) -> usize

the length of the array

pub fn is_empty(&self) -> bool

whether the array is empty

pub fn is_released(&self) -> bool

Whether the array has been released

pub fn offset(&self) -> usize

the offset of the array

pub fn null_count(&self) -> usize

the null count of the array

pub fn null_count_opt(&self) -> Option<usize>

Returns the null count, checking for validity

pub unsafe fn set_null_count(&mut self, null_count: i64)

Set the null count of the array

Safety

Null count must match that of null buffer

pub fn buffer(&self, index: usize) -> *const u8

Returns the buffer at the provided index

Panics

Panics if index >= self.num_buffers() or the buffer is not correctly aligned

pub fn num_buffers(&self) -> usize

Returns the number of buffers

pub fn child(&self, index: usize) -> &FFI_ArrowArray

Returns the child at the provided index

pub fn num_children(&self) -> usize

Returns the number of children

pub fn dictionary(&self) -> Option<&Self>

Returns the dictionary if any

Trait Implementations

impl Debug for FFI_ArrowArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for FFI_ArrowArray

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for FFI_ArrowArray

impl Sync for FFI_ArrowArray