Struct ArrowRle 

pub struct ArrowRle { /* private fields */ }

A run-length encoded sequence whose values are an Arrow array of any type.

Like runlength::Rle, it stores cumulative run ends and one value per run, starts at position 0, and has no zero-length runs. Values may contain nulls; a null is a value like any other and merges with neighbouring nulls.

Implementations

impl ArrowRle

pub fn sum(&self) -> Result<ArrayRef>

The sum over all positions, as one value of the values’ type. Integer sums wrap on overflow.

pub fn mean(&self) -> Result<Option<f64>>

The mean over all positions, or None if the sequence is empty.

pub fn variance(&self, ddof: i64) -> Result<Option<f64>>

The variance over all positions with ddof delta degrees of freedom, or None if len() <= ddof.

pub fn std(&self, ddof: i64) -> Result<Option<f64>>

The standard deviation; see variance.

pub fn min(&self) -> Result<ArrayRef>

The smallest value ignoring NaN, as one value (null if there is none).

pub fn max(&self) -> Result<ArrayRef>

The largest value ignoring NaN, as one value (null if there is none).

impl ArrowRle

pub fn try_new(ends: Vec<i64>, values: ArrayRef) -> Result<Self>

Builds a sequence from cumulative run ends and one value per run.

pub fn from_runs(runs: &[i64], values: ArrayRef) -> Result<Self>

Builds a sequence from run lengths and one value per run. Zero-length runs are dropped; neighbouring identical values are kept as they are.

pub fn from_dense(values: ArrayRef) -> Result<Self>

Encodes a dense array, merging identical neighbours.

pub fn empty(data_type: &DataType) -> Self

An empty sequence of the given value type.

pub fn from_rle<T: ArrowPrimitiveType>(rle: &Rle<T::Native>) -> Self

Converts a core sequence of primitive values.

pub fn to_rle<T: ArrowPrimitiveType>(&self) -> Result<Rle<T::Native>>

Converts to a core sequence of primitive values. The values must be of type T and contain no nulls.

pub fn ends(&self) -> &[i64]

The cumulative end of each run.

pub fn values(&self) -> &ArrayRef

One value per run.

pub fn data_type(&self) -> &DataType

pub fn len(&self) -> i64

The number of positions the sequence covers.

pub fn is_empty(&self) -> bool

pub fn num_runs(&self) -> usize

pub fn runs(&self) -> Vec<i64>

The length of each run.

pub fn into_parts(self) -> (Vec<i64>, ArrayRef)

pub fn run_index(&self, pos: i64) -> Option<usize>

The index of the run containing pos, if pos is in range.

pub fn slice(&self, start: i64, end: i64) -> ArrowRle

The positions start..end as a new sequence starting at 0, clamped to the sequence. The values are a zero-copy slice.

pub fn getitems(&self, starts: &[i64], ends: &[i64]) -> Result<ArrowRleBatch>

Many slices at once, as a batch with one key column, slice, holding the slice number. Each interval needs 0 <= start <= end.

pub fn to_dense(&self) -> Result<ArrayRef>

Expands the sequence into one value per position.

pub fn plan_with(&self, other: &ArrowRle) -> Plan

The plan for combining this sequence with other. See Plan.

pub fn identical_neighbours(&self) -> Result<Vec<bool>>

For each pair of neighbouring runs, whether their values are identical.

pub fn is_merged(&self) -> Result<bool>

Whether no two neighbouring runs hold identical values.

pub fn merge(self) -> Result<Self>

Merges neighbouring runs with identical values.

pub fn merge_mask(self, mask: &[bool], keep: Keep) -> Result<Self>

Merges run i + 1 into run i wherever mask[i] is true, keeping the first or last value of each merged group.

pub fn zip_with<F>( &self, other: &ArrowRle, fill_a: Option<&dyn Array>, fill_b: Option<&dyn Array>, f: F, ) -> Result<ArrowRle>

where F: FnOnce(&dyn Array, &dyn Array) -> Result<ArrayRef, ArrowError>,

Combines two sequences position by position and merges the result.

f receives the values of both sides gathered onto the plan’s segments (two arrays of equal length) and must return one value per segment; any Arrow kernel fits. The shorter side is padded with its fill value, a single value of the same type; with no fill value, unequal lengths are an error.

pub fn zip_with_raw<F>( &self, other: &ArrowRle, fill_a: Option<&dyn Array>, fill_b: Option<&dyn Array>, f: F, ) -> Result<ArrowRle>

where F: FnOnce(&dyn Array, &dyn Array) -> Result<ArrayRef, ArrowError>,

Like zip_with but without merging the result.

pub fn map<F>(&self, f: F) -> Result<ArrowRle>

where F: FnOnce(&dyn Array) -> Result<ArrayRef, ArrowError>,

Applies an Arrow kernel to the run values and merges the result.

pub fn cast(&self, data_type: &DataType) -> Result<ArrowRle>

Casts the values to data_type and merges any neighbours that become identical (for example when floats are truncated to integers).

pub fn zip_with_default(&self, other: &ArrowRle, f: Kernel) -> Result<ArrowRle>

Combines with other using default_fill on each side, and merges.

impl ArrowRle

pub fn add(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise addition (integer overflow is an error). The shorter side is padded with default_fill.

pub fn sub(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise subtraction (integer overflow is an error). The shorter side is padded with default_fill.

pub fn mul(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise multiplication (integer overflow is an error). The shorter side is padded with default_fill.

pub fn div(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise division (integer division by zero is an error). The shorter side is padded with default_fill.

pub fn elem_eq(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise ==. The shorter side is padded with default_fill.

pub fn elem_ne(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise !=. The shorter side is padded with default_fill.

pub fn elem_lt(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise <. The shorter side is padded with default_fill.

pub fn elem_le(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise <=. The shorter side is padded with default_fill.

pub fn elem_gt(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise >. The shorter side is padded with default_fill.

pub fn elem_ge(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise >=. The shorter side is padded with default_fill.

pub fn and(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise logical and, with SQL semantics for nulls. The shorter side is padded with default_fill.

pub fn or(&self, other: &ArrowRle) -> Result<ArrowRle>

Element-wise logical or, with SQL semantics for nulls. The shorter side is padded with default_fill.

impl ArrowRle

pub fn slice_agg( &self, starts: &[i64], ends: &[i64], agg: SliceAgg, ) -> Result<ArrayRef>

Reduces many slices without copying them, in parallel: entry k of the result reduces positions starts[k]..ends[k] (clamped to the sequence) with agg. Values must be numeric or boolean.

use std::sync::Arc;
use arrow_array::{Array, Float64Array, Int64Array};
use runlength_arrow::{ArrowRle, SliceAgg};

let rle = ArrowRle::from_runs(&[3, 2], Arc::new(Int64Array::from(vec![1, 4]))).unwrap();
let means = rle.slice_agg(&[0, 2], &[2, 5], SliceAgg::Mean).unwrap();
let means = means.as_any().downcast_ref::<Float64Array>().unwrap();
assert_eq!(means.values().to_vec(), vec![1.0, 3.0]);

impl ArrowRle

pub fn shift(&self, distance: i64, fill: &dyn Array) -> Result<ArrowRle>

Shifts values distance positions right (left if negative), keeping the length; positions shifted in hold fill, a single value of the same type. The result is merged.

pub fn reversed(&self) -> Result<ArrowRle>

The sequence back to front.

pub fn true_ranges(&self) -> Result<(Vec<i64>, Vec<i64>)>

For a boolean sequence, the half-open ranges (starts, ends) where it is true (nulls count as false), with touching ranges joined.

pub fn fill_null(&self, fill: &dyn Array) -> Result<ArrowRle>

Replaces nulls with fill, a single value of the same type.

Trait Implementations

impl Clone for ArrowRle

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArrowRle

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

Formats the value using the given formatter.

impl PartialEq for ArrowRle

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

Whether both sequences represent the same values at every position (by identical_neighbours’s rule), however the runs are split.

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

Inequality operator !=.