Struct FixedSizeBinaryArray 

pub struct FixedSizeBinaryArray {
    data_type: DataType,
    value_data: Buffer,
    nulls: Option<NullBuffer>,
    len: usize,
    value_length: i32,
}

An array of fixed-size binary values

Each element in a FixedSizeBinaryArray has value_length bytes, where value_length is defined by the schema.

This array type is useful for storing fixed-length values such as 16-byte UUIDs (value_length = 16).

Layout

Values in a FixedSizeBinaryArray are stored contiguously in a single buffer. The byte offset for the i-th element can be calculated as i * value_length.

Nulls are stored in a standard optional Arrow NullBuffer.

For example, a 100-value FixedSizeBinaryArray with value_length = 12 is shown below.

┌──────────────────────────────────────────┐
│ Computed byte offsets                    │
│          ┌──────────────────────┐ ┌────┐ │
│          │┌────────────────────┐│ │    │ │
│       0  ││value 0  (12 bytes) ││ │ 1  │ │
│          │├────────────────────┤│ │    │ │
│       12 ││value 1  (12 bytes) ││ │ 0  │ │
│          │├────────────────────┤│ │    │ │
│       24 ││value 2  (12 bytes) ││ │ 1  │ │
│          │└────────────────────┘│ │    │ │
│          │         ...          │ │... │ │
│          │┌───────────────────┐ │ │    │ │
│     1188 ││value 99 (12 bytes)│ │ │ 1  │ │
│          │└───────────────────┘ │ │    │ │
│          └──────────────────────┘ └────┘ │
│           value_data              nulls  │
└──────────────────────────────────────────┘

Examples

Create an array from an iterable argument of byte slices.

   use arrow_array::{Array, FixedSizeBinaryArray};
   let input_arg = vec![ vec![1, 2], vec![3, 4], vec![5, 6] ];
   let arr = FixedSizeBinaryArray::try_from_iter(input_arg.into_iter()).unwrap();

   assert_eq!(3, arr.len());

Create an array from an iterable argument of sparse byte slices. Sparsity means that the input argument can contain None items.

   use arrow_array::{Array, FixedSizeBinaryArray};
   let input_arg = vec![ None, Some(vec![7, 8]), Some(vec![9, 10]), None, Some(vec![13, 14]) ];
   let arr = FixedSizeBinaryArray::try_from_sparse_iter_with_size(input_arg.into_iter(), 2).unwrap();
   assert_eq!(5, arr.len())

Fields

data_type: DataType

value_data: Buffer

nulls: Option<NullBuffer>

len: usize

value_length: i32

Implementations

impl FixedSizeBinaryArray

pub fn new( value_length: i32, values: Buffer, nulls: Option<NullBuffer>, ) -> FixedSizeBinaryArray

Create a new FixedSizeBinaryArray with value_length bytes per element, panicking on failure

Panics

Panics if Self::try_new returns an error

pub fn new_scalar(value: impl AsRef<[u8]>) -> Scalar<FixedSizeBinaryArray>

Create a new Scalar from value

pub fn try_new( value_length: i32, values: Buffer, nulls: Option<NullBuffer>, ) -> Result<FixedSizeBinaryArray, ArrowError>

Create a new FixedSizeBinaryArray from the provided parts, returning an error on failure

Creating an array with value_length == 0 will try to get the length from the null buffer. If no null buffer is provided, the resulting array will have length zero.

Errors

• value_length < 0
• values.len() / value_length != nulls.len()
• value_length == 0 && values.len() != 0
• len * value_length > i32::MAX

pub fn new_null(value_length: i32, len: usize) -> FixedSizeBinaryArray

Create a new FixedSizeBinaryArray of length len where all values are null

Panics

Panics if

• value_length < 0
• value_length * len would overflow usize
• value_length * len > i32::MAX
• value_length * len * 8 would overflow usize

pub fn into_parts(self) -> (i32, Buffer, Option<NullBuffer>)

Deconstruct this array into its constituent parts

pub fn value(&self, i: usize) -> &[u8]

Returns the element at index i as a byte slice.

Note: This method does not check for nulls and the value is arbitrary (but still well-defined) if is_null returns true for the index.

Panics

Panics if index i is out of bounds.

pub unsafe fn value_unchecked(&self, i: usize) -> &[u8]

Returns the element at index i as a byte slice.

Note: This method does not check for nulls and the value is arbitrary if is_null returns true for the index.

Safety

Caller is responsible for ensuring that the index is within the bounds of the array

pub fn value_offset(&self, i: usize) -> i32

Returns the offset for the element at index i.

Note this doesn’t do any bound checking, for performance reason.

pub fn value_length(&self) -> i32

Returns the length for an element.

All elements have the same length as the array is a fixed size.

pub fn values(&self) -> &Buffer

Returns the values of this array.

Unlike Self::value_data this returns the Buffer allowing for zero-copy cloning.

pub fn value_data(&self) -> &[u8]

Returns the raw value data.

pub fn slice(&self, offset: usize, len: usize) -> FixedSizeBinaryArray

Returns a zero-copy slice of this array with the indicated offset and length.

pub fn try_from_sparse_iter<T, U>( iter: T, ) -> Result<FixedSizeBinaryArray, ArrowError>

where T: Iterator<Item = Option<U>>, U: AsRef<[u8]>,

👎Deprecated since 28.0.0:

This function will fail if the iterator produces only None values; prefer try_from_sparse_iter_with_size

Create an array from an iterable argument of sparse byte slices. Sparsity means that items returned by the iterator are optional, i.e input argument can contain None items.

Examples

use arrow_array::FixedSizeBinaryArray;
let input_arg = vec![
    None,
    Some(vec![7, 8]),
    Some(vec![9, 10]),
    None,
    Some(vec![13, 14]),
    None,
];
let array = FixedSizeBinaryArray::try_from_sparse_iter(input_arg.into_iter()).unwrap();

Errors

Returns error if argument has length zero, or sizes of nested slices don’t match.

pub fn try_from_sparse_iter_with_size<T, U>( iter: T, value_length: i32, ) -> Result<FixedSizeBinaryArray, ArrowError>

where T: Iterator<Item = Option<U>>, U: AsRef<[u8]>,

Create an array from an iterable argument of sparse byte slices. Sparsity means that items returned by the iterator are optional, i.e input argument can contain None items. In cases where the iterator returns only None values, this also takes a value_length parameter to ensure that a valid FixedSizeBinaryArray is still created.

Examples

use arrow_array::FixedSizeBinaryArray;
let input_arg = vec![
    None,
    Some(vec![7, 8]),
    Some(vec![9, 10]),
    None,
    Some(vec![13, 14]),
    None,
];
let array = FixedSizeBinaryArray::try_from_sparse_iter_with_size(input_arg.into_iter(), 2).unwrap();

Errors

Returns error if argument has length zero, or sizes of nested slices don’t match.

pub fn try_from_iter<T, U>(iter: T) -> Result<FixedSizeBinaryArray, ArrowError>

where T: Iterator<Item = U>, U: AsRef<[u8]>,

Create an array from an iterable argument of byte slices.

Examples

use arrow_array::FixedSizeBinaryArray;
let input_arg = vec![
    vec![1, 2],
    vec![3, 4],
    vec![5, 6],
];
let array = FixedSizeBinaryArray::try_from_iter(input_arg.into_iter()).unwrap();

Errors

Returns error if argument has length zero, or sizes of nested slices don’t match.

pub fn iter(&self) -> ArrayIter<&FixedSizeBinaryArray>

constructs a new iterator

Trait Implementations

impl Array for FixedSizeBinaryArray

SAFETY: Correctly implements the contract of Arrow Arrays

fn as_any(&self) -> &(dyn Any + 'static)

Returns the array as Any so that it can be downcasted to a specific implementation.

fn to_data(&self) -> ArrayData

Returns the underlying data of this array

fn into_data(self) -> ArrayData

Returns the underlying data of this array

fn data_type(&self) -> &DataType

Returns a reference to the DataType of this array.

fn slice(&self, offset: usize, length: usize) -> Arc<dyn Array>

Returns a zero-copy slice of this array with the indicated offset and length.

fn len(&self) -> usize

Returns the length (i.e., number of elements) of this array.

fn is_empty(&self) -> bool

Returns whether this array is empty.

fn shrink_to_fit(&mut self)

Shrinks the capacity of any exclusively owned buffer as much as possible

fn offset(&self) -> usize

Returns the offset into the underlying data used by this array(-slice). Note that the underlying data can be shared by many arrays. This defaults to 0.

fn nulls(&self) -> Option<&NullBuffer>

Returns the null buffer of this array if any.

fn logical_null_count(&self) -> usize

Returns the total number of logical null values in this array.

fn get_buffer_memory_size(&self) -> usize

Returns the total number of bytes of memory pointed to by this array. The buffers store bytes in the Arrow memory format, and include the data as well as the validity map. Note that this does not always correspond to the exact memory usage of an array, since multiple arrays can share the same buffers or slices thereof.

fn get_array_memory_size(&self) -> usize

Returns the total number of bytes of memory occupied physically by this array. This value will always be greater than returned by get_buffer_memory_size() and includes the overhead of the data structures that contain the pointers to the various buffers.

fn claim(&self, pool: &dyn MemoryPool)

Claim memory used by this array in the provided memory pool.

fn logical_nulls(&self) -> Option<NullBuffer>

Returns a potentially computed NullBuffer that represents the logical null values of this array, if any.

fn is_null(&self, index: usize) -> bool

Returns whether the element at index is null according to Array::nulls

fn is_valid(&self, index: usize) -> bool

Returns whether the element at index is not null, the opposite of Self::is_null.

fn null_count(&self) -> usize

Returns the total number of physical null values in this array.

fn is_nullable(&self) -> bool

Returns false if the array is guaranteed to not contain any logical nulls

impl<'a> ArrayAccessor for &'a FixedSizeBinaryArray

type Item = &'a [u8]

The Arrow type of the element being accessed.

fn value( &self, index: usize, ) -> <&'a FixedSizeBinaryArray as ArrayAccessor>::Item

Returns the element at index i

unsafe fn value_unchecked( &self, index: usize, ) -> <&'a FixedSizeBinaryArray as ArrayAccessor>::Item

Returns the element at index i

impl<'a> BinaryArrayType<'a> for &'a FixedSizeBinaryArray

fn iter(&self) -> ArrayIter<&'a FixedSizeBinaryArray>

Constructs a new iterator

impl Clone for FixedSizeBinaryArray

fn clone(&self) -> FixedSizeBinaryArray

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FixedSizeBinaryArray

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

Formats the value using the given formatter.

impl DisplayIndex for &FixedSizeBinaryArray

fn write(&self, idx: usize, f: &mut dyn Write) -> Result<(), FormatError>

Write the value of the underlying array at idx to f.

impl From<ArrayData> for FixedSizeBinaryArray

fn from(data: ArrayData) -> FixedSizeBinaryArray

Converts to this type from the input type.

impl From<FixedSizeBinaryArray> for ArrayData

fn from(array: FixedSizeBinaryArray) -> ArrayData

Converts to this type from the input type.

impl From<FixedSizeListArray> for FixedSizeBinaryArray

Creates a FixedSizeBinaryArray from FixedSizeList<u8> array

fn from(v: FixedSizeListArray) -> FixedSizeBinaryArray

Converts to this type from the input type.

impl From<Vec<&[u8]>> for FixedSizeBinaryArray

fn from(v: Vec<&[u8]>) -> FixedSizeBinaryArray

Converts to this type from the input type.

impl<const N: usize> From<Vec<&[u8; N]>> for FixedSizeBinaryArray

fn from(v: Vec<&[u8; N]>) -> FixedSizeBinaryArray

Converts to this type from the input type.

impl From<Vec<Option<&[u8]>>> for FixedSizeBinaryArray

fn from(v: Vec<Option<&[u8]>>) -> FixedSizeBinaryArray

Converts to this type from the input type.

impl<'a> IntoIterator for &'a FixedSizeBinaryArray

type Item = Option<&'a [u8]>

The type of the elements being iterated over.

type IntoIter = ArrayIter<&'a FixedSizeBinaryArray>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a FixedSizeBinaryArray as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for FixedSizeBinaryArray

fn eq(&self, other: &FixedSizeBinaryArray) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.