Module arrow2::array[−][src]

Expand description

Contains the Array and MutableArray trait objects declaring arrays, as well as concrete arrays (such as Utf8Array and MutableUtf8Array).

Fixed-length containers with optional values that are layed in memory according to the Arrow specification. Each array type has its own struct. The following are the main array types:

PrimitiveArray and MutablePrimitiveArray, an array of values with a fixed length such as integers, floats, etc.
BooleanArray and MutableBooleanArray, an array of boolean values (stored as a bitmap)
Utf8Array and MutableUtf8Array, an array of variable length utf8 values
BinaryArray and MutableBinaryArray, an array of opaque variable length values
ListArray and MutableListArray, an array of arrays (e.g. [[1, 2], None, [], [None]])
StructArray, an array of arrays identified by a string (e.g. {"a": [1, 2], "b": [true, false]}) All immutable arrays implement the trait object Array and that can be downcasted to a concrete struct based on PhysicalType available from Array::data_type. All immutable arrays are backed by Buffer and thus cloning and slicing them is O(1).

Most arrays contain a MutableArray counterpart that is neither clonable nor slicable, but can be operated in-place.

Modules

growable

Contains the trait Growable and corresponding concreate implementations, one per concrete array, that offer the ability to create a new Array out of slices of existing Arrays.

ord

Contains functions and function factories to order values within arrays.

Structs

BinaryArray

A BinaryArray is a nullable array of bytes - the Arrow equivalent of Vec<Option<Vec<u8>>>.

BooleanArray

The Arrow’s equivalent to an immutable Vec<Option<bool>>, but with 1/16 of its size. Cloning and slicing this struct is O(1).

DictionaryArray

An Array whose values are encoded by keys. This Array is useful when the cardinality of values is low compared to the length of the Array.

FixedSizeBinaryArray

The Arrow’s equivalent to an immutable Vec<Option<[u8; size]>>. Cloning and slicing this struct is O(1).

FixedSizeListArray

The Arrow’s equivalent to an immutable Vec<Option<[T; size]>> where T is an Arrow type. Cloning and slicing this struct is O(1).

ListArray

An Array semantically equivalent to Vec<Option<Vec<Option<T>>>> with Arrow’s in-memory.

MapArray

An array representing a (key, value), both of arbitrary logical types.

MutableBinaryArray

The Arrow’s equivalent to Vec<Option<Vec<u8>>>. Converting a MutableBinaryArray into a BinaryArray is O(1).

MutableBooleanArray

The Arrow’s equivalent to Vec<Option<bool>>, but with 1/16 of its size. Converting a MutableBooleanArray into a BooleanArray is O(1).

MutableDictionaryArray

A mutable, strong-typed version of DictionaryArray.

MutableFixedSizeBinaryArray

The Arrow’s equivalent to a mutable Vec<Option<[u8; size]>>. Converting a MutableFixedSizeBinaryArray into a FixedSizeBinaryArray is O(1).

MutableFixedSizeListArray

The mutable version of FixedSizeListArray.

MutableListArray

The mutable version of ListArray.

MutablePrimitiveArray

The Arrow’s equivalent to Vec<Option<T>> where T is byte-size (e.g. i32). Converting a MutablePrimitiveArray into a PrimitiveArray is O(1).

MutableUtf8Array

The mutable version of Utf8Array. See MutableArray for more details.

NullArray

The concrete Array of DataType::Null.

PrimitiveArray

A PrimitiveArray is arrow’s equivalent to Vec<Option<T: NativeType>>, i.e. an array designed for highly performant operations on optionally nullable slots, backed by a physical type of a fixed byte-width, such as i32 or f64. The size of this struct is O(1) as all data is stored behind an std::sync::Arc.

StructArray

A StructArray is a nested Array with an optional validity representing multiple Array with the same number of rows.

UnionArray

UnionArray represents an array whose each slot can contain different values.

Utf8Array

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

Utf8ValuesIter

Iterator of values of an Utf8Array.

Traits

Array

A trait representing an immutable Arrow array. Arrow arrays are trait objects that are infalibly downcasted to concrete types according to the Array::data_type.

DictionaryKey

Trait denoting NativeTypes that can be used as keys of a dictionary.

FromFfi

Trait describing how a struct imports into itself from the C data interface (FFI).

GenericBinaryArray

Trait that BinaryArray and Utf8Array implement for the purposes of DRY.

IterableListArray

Trait that list arrays implement for the purposes of DRY.

MutableArray

A trait describing a mutable array; i.e. an array whose values can be changed. Mutable arrays are not Send + Sync and cannot be cloned but can be mutated in place, thereby making them useful to perform numeric operations without allocations. As in Array, concrete arrays (such as MutablePrimitiveArray) implement how they are mutated.

Offset

Trait describing types that can be used as offsets as per Arrow specification. This trait is only implemented for i32 and i64, the two sizes part of the specification.

ToFfi

Trait describing how a struct presents itself to the C data interface (FFI).

TryExtend

A trait describing the ability of a struct to create itself from a iterator. This is similar to Extend, but accepted the creation to error.

TryPush

A trait describing the ability of a struct to receive new items.

Functions

clone

Clones a dynamic Array.

equal

Logically compares two Arrays. Two arrays are logically equal if and only if:

get_display

Returns a function of index returning the string representation of the item of array. This outputs an empty string on nulls.

new_empty_array

Creates a new Array with a Array::len of 0.

new_null_array

Creates a new Array of DataType data_type and length. The array is guaranteed to have Array::null_count equal to Array::len for all types except Union, which does not have a validity.