Module arrow2::array[−][src]

Expand description

This module contains arrays: fixed-length and immutable 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, an array of values with a fixed length such as integers, floats, etc.
BooleanArray, an array of boolean values (stored as a bitmap)
Utf8Array, an array of utf8 values
BinaryArray, an array of binary values
ListArray, 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]})

This module contains constructors and accessors to operate on the arrays. All the arrays implement the trait Array and are often trait objects. Every array has a DataType, which you can access with Array::data_type. This can be used to downcast_ref a &dyn Array to a concrete struct. Arrays can share memory via crate::buffer::Buffer and thus cloning and slicing is O(1).

This module also contains the mutable counterparts of arrays, that are neither clonable nor slicable, but that can be operated in-place, such as MutablePrimitiveArray and MutableUtf8Array.

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

BooleanArray

A BooleanArray is arrow’s equivalent to Vec<Option<bool>>, i.e. an array designed for highly performant operations on optionally nullable booleans. The size of this struct is O(1) as all data is stored behind an Arc.

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.

The mutable version of BinaryArray.

MutableBooleanArray

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

MutableDictionaryArray

A mutable, strong-typed version of DictionaryArray.

MutableListArray

The mutable version of ListArray.

MutablePrimitiveArray

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

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 physical 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

Utf8Array

A Utf8Array is arrow’s equivalent of Vec<Option<String>>, i.e. an array designed for highly performant operations on optionally nullable strings. The size of this struct is O(1) as all data is stored behind an Arc.

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.

Index

Trait describing any type that can be used to index a slot of an array.

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.