Struct arrow2::array::Utf8Array

pub struct Utf8Array<O: Offset> { /* private fields */ }

A Utf8Array is arrow’s equivalent of an immutable Vec<Option<String>>. Cloning and slicing this struct is O(1).

Example

use arrow2::array::Utf8Array;
let array = Utf8Array::<i32>::from([Some("hi"), None, Some("there")]);
assert_eq!(array.value(0), "hi");
assert_eq!(array.values().as_slice(), b"hithere".as_ref());
assert_eq!(array.offsets().as_slice(), &[0, 2, 2, 2 + 5]);

Safety

The following invariants hold:

• Two consecutives offsets casted (as) to usize are valid slices of values.
• A slice of values taken from two consecutives offsets is valid utf8.
• len is equal to validity.len(), when defined.

Implementations

impl<O: Offset> Utf8Array<O>

pub fn from_slice<T: AsRef<str>, P: AsRef<[T]>>(slice: P) -> Self

Creates a new Utf8Array from a slice of &str. This is a convenience method that just calls Self::from_trusted_len_values_iter.

pub fn from<T: AsRef<str>, P: AsRef<[Option<T>]>>(slice: P) -> Self

Creates a new Utf8Array from a slice of &str.

pub fn from_trusted_len_values_iter<T: AsRef<str>, I: TrustedLen<Item = T>>(
    iterator: I
) -> Self

Creates a new Utf8Array from a TrustedLen of &str.

pub fn from_iter_values<T: AsRef<str>, I: Iterator<Item = T>>(
    iterator: I
) -> Self

Creates a new Utf8Array from a Iterator of &str.

impl<O: Offset> Utf8Array<O>

pub unsafe fn from_trusted_len_iter_unchecked<I, P>(iterator: I) -> Self where
    P: AsRef<str>,
    I: Iterator<Item = Option<P>>, 

Creates a Utf8Array from an iterator of trusted length.

Safety

The iterator must be TrustedLen. I.e. that size_hint().1 correctly reports its length.

pub fn from_trusted_len_iter<I, P>(iterator: I) -> Self where
    P: AsRef<str>,
    I: TrustedLen<Item = Option<P>>, 

Creates a Utf8Array from an iterator of trusted length.

pub unsafe fn try_from_trusted_len_iter_unchecked<E, I, P>(
    iterator: I
) -> Result<Self, E> where
    P: AsRef<str>,
    I: IntoIterator<Item = Result<Option<P>, E>>, 

Creates a Utf8Array from an falible iterator of trusted length.

Safety

The iterator must be TrustedLen. I.e. that size_hint().1 correctly reports its length.

pub fn try_from_trusted_len_iter<E, I, P>(iter: I) -> Result<Self, E> where
    P: AsRef<str>,
    I: TrustedLen<Item = Result<Option<P>, E>>, 

Creates a Utf8Array from an fallible iterator of trusted length.

impl<'a, O: Offset> Utf8Array<O>

pub fn iter(&'a self) -> ZipValidity<'a, &'a str, Utf8ValuesIter<'a, O>>

Returns an iterator of Option<&str>

pub fn values_iter(&'a self) -> Utf8ValuesIter<'a, O>

Returns an iterator of &str

impl<O: Offset> Utf8Array<O>

pub fn try_new(
    data_type: DataType,
    offsets: Buffer<O>,
    values: Buffer<u8>,
    validity: Option<Bitmap>
) -> Result<Self>

Returns a new Utf8Array.

Errors

This function returns an error iff:

• the offsets are not monotonically increasing
• The last offset is not equal to the values’ length.
• the validity’s length is not equal to offsets.len() - 1.
• The data_type’s crate::datatypes::PhysicalType is not equal to either Utf8 or LargeUtf8.
• The values between two consecutive offsets are not valid utf8

Implementation

This function is O(N) - checking monotinicity and utf8 is O(N)

pub fn new(
    data_type: DataType,
    offsets: Buffer<O>,
    values: Buffer<u8>,
    validity: Option<Bitmap>
) -> Self

Creates a new Utf8Array.

Panics

This function panics iff:

• the offsets are not monotonically increasing
• The last offset is not equal to the values’ length.
• the validity’s length is not equal to offsets.len() - 1.
• The data_type’s crate::datatypes::PhysicalType is not equal to either Utf8 or LargeUtf8.
• The values between two consecutive offsets are not valid utf8

Implementation

This function is O(N) - checking monotinicity and utf8 is O(N)

pub fn from_data(
    data_type: DataType,
    offsets: Buffer<O>,
    values: Buffer<u8>,
    validity: Option<Bitmap>
) -> Self

Alias for new

pub fn new_empty(data_type: DataType) -> Self

Returns a new empty Utf8Array.

pub fn new_null(data_type: DataType, length: usize) -> Self

Returns a new Utf8Array whose all slots are null / None.

pub fn default_data_type() -> DataType

Returns the default DataType, DataType::Utf8 or DataType::LargeUtf8

impl<O: Offset> Utf8Array<O>

pub unsafe fn try_new_unchecked(
    data_type: DataType,
    offsets: Buffer<O>,
    values: Buffer<u8>,
    validity: Option<Bitmap>
) -> Result<Self>

Creates a new Utf8Array without checking for offsets monotinicity nor utf8-validity

Errors

This function returns an error iff:

• The last offset is not equal to the values’ length.
• the validity’s length is not equal to offsets.len() - 1.
• The data_type’s crate::datatypes::PhysicalType is not equal to either Utf8 or LargeUtf8.

Safety

This function is unsound iff:

• the offsets are not monotonically increasing
• The values between two consecutive offsets are not valid utf8

Implementation

This function is O(1)

pub unsafe fn new_unchecked(
    data_type: DataType,
    offsets: Buffer<O>,
    values: Buffer<u8>,
    validity: Option<Bitmap>
) -> Self

Creates a new Utf8Array without checking for offsets monotinicity.

Errors

This function returns an error iff:

• The last offset is not equal to the values’ length.
• the validity’s length is not equal to offsets.len() - 1.
• The data_type’s crate::datatypes::PhysicalType is not equal to either Utf8 or LargeUtf8.

Safety

This function is unsound iff:

• the offsets are not monotonically increasing
• The values between two consecutive offsets are not valid utf8

Implementation

This function is O(1)

pub unsafe fn from_data_unchecked(
    data_type: DataType,
    offsets: Buffer<O>,
    values: Buffer<u8>,
    validity: Option<Bitmap>
) -> Self

Alias for [new_unchecked]

Safety

This function is unsafe iff:

• the offsets are not monotonically increasing
• The values between two consecutive offsets are not valid utf8

impl<O: Offset> Utf8Array<O>

pub fn slice(&self, offset: usize, length: usize) -> Self

Returns a slice of this Utf8Array.

Implementation

This operation is O(1) as it amounts to essentially increase two ref counts.

Panic

This function panics iff offset + length >= self.len().

pub unsafe fn slice_unchecked(&self, offset: usize, length: usize) -> Self

Returns a slice of this Utf8Array.

Implementation

This operation is O(1) as it amounts to essentially increase two ref counts.

Safety

The caller must ensure that offset + length <= self.len().

pub fn with_validity(&self, validity: Option<Bitmap>) -> Self

Sets the validity bitmap on this Utf8Array.

Panic

This function panics iff validity.len() != self.len().

pub fn into_mut(self) -> Either<Self, MutableUtf8Array<O>>

Try to convert this Utf8Array to a MutableUtf8Array

impl<O: Offset> Utf8Array<O>

pub fn len(&self) -> usize

Returns the length of this array

pub unsafe fn value_unchecked(&self, i: usize) -> &str

Returns the element at index i as &str

Safety

This function is safe iff i < self.len.

pub fn value(&self, i: usize) -> &str

Returns the element at index i

pub fn validity(&self) -> Option<&Bitmap>

The optional validity.

pub fn offsets(&self) -> &Buffer<O>

Returns the offsets of this Utf8Array.

pub fn values(&self) -> &Buffer<u8>

Returns the values of this Utf8Array.

Trait Implementations

impl<O: Offset> Array for Utf8Array<O>

fn as_any(&self) -> &dyn Any

Convert to trait object.

fn len(&self) -> usize

The length of the Array. Every array has a length corresponding to the number of elements (slots).

fn data_type(&self) -> &DataType

The DataType of the Array. In combination with Array::as_any, this can be used to downcast trait objects (dyn Array) to concrete arrays.

fn validity(&self) -> Option<&Bitmap>

The validity of the Array: every array has an optional Bitmap that, when available specifies whether the array slot is valid or not (null). When the validity is None, all slots are valid.

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

Slices the Array, returning a new Box<dyn Array>.

unsafe fn slice_unchecked(&self, offset: usize, length: usize) -> Box<dyn Array>

Slices the Array, returning a new Box<dyn Array>.

fn with_validity(&self, validity: Option<Bitmap>) -> Box<dyn Array>

Sets the validity bitmap on this Array.

fn is_empty(&self) -> bool

whether the array is empty

fn null_count(&self) -> usize

The number of null slots on this Array.

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

Returns whether slot i is null.

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

Returns whether slot i is valid.

impl<O: Clone + Offset> Clone for Utf8Array<O>

fn clone(&self) -> Utf8Array<O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O: Offset> Debug for Utf8Array<O>

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

Formats the value using the given formatter.

impl<'a, O: Offset> From<GrowableUtf8<'a, O>> for Utf8Array<O>

fn from(val: GrowableUtf8<'a, O>) -> Self

Performs the conversion.

impl<O: Offset> From<MutableUtf8Array<O>> for Utf8Array<O>

fn from(other: MutableUtf8Array<O>) -> Self

Performs the conversion.

impl<O: Offset, P: AsRef<str>> FromIterator<Option<P>> for Utf8Array<O>

fn from_iter<I: IntoIterator<Item = Option<P>>>(iter: I) -> Self

Creates a value from an iterator.

impl<O: Offset> GenericBinaryArray<O> for Utf8Array<O>

fn values(&self) -> &[u8]

The values of the array

fn offsets(&self) -> &[O]

The offsets of the array

impl<'a, O: Offset> IntoIterator for &'a Utf8Array<O>

type Item = Option<&'a str>

The type of the elements being iterated over.

type IntoIter = ZipValidity<'a, &'a str, Utf8ValuesIter<'a, O>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<O: Offset> PartialEq<&'_ (dyn Array + '_)> for Utf8Array<O>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<O: Offset> PartialEq<Utf8Array<O>> for Utf8Array<O>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.