Module arrow2::compute::comparison

Contains comparison operators

The module contains functions that compare either an Array and a Scalar or two Arrays (of the same DataType). The scalar-oriented functions are suffixed with _scalar.

The functions are organized in two variants:

• statically typed
• dynamically typed The statically typed are available under each module of this module (e.g. primitive::eq, primitive::lt_scalar) The dynamically typed are available in this module (e.g. eq or lt_scalar).

Examples

Compare two PrimitiveArrays:

use arrow2::array::{BooleanArray, PrimitiveArray};
use arrow2::compute::comparison::primitive::gt;

let array1 = PrimitiveArray::<i32>::from([Some(1), None, Some(2)]);
let array2 = PrimitiveArray::<i32>::from([Some(1), Some(3), Some(1)]);
let result = gt(&array1, &array2);
assert_eq!(result, BooleanArray::from([Some(false), None, Some(true)]));

Compare two dynamically-typed Arrays (trait objects):

use arrow2::array::{Array, BooleanArray, PrimitiveArray};
use arrow2::compute::comparison::eq;

let array1: &dyn Array = &PrimitiveArray::<f64>::from(&[Some(10.0), None, Some(20.0)]);
let array2: &dyn Array = &PrimitiveArray::<f64>::from(&[Some(10.0), None, Some(10.0)]);
let result = eq(array1, array2);
assert_eq!(result, BooleanArray::from([Some(true), None, Some(false)]));

Compare (not equal) a Utf8Array to a word:

use arrow2::array::{BooleanArray, Utf8Array};
use arrow2::compute::comparison::utf8::neq_scalar;

let array = Utf8Array::<i32>::from([Some("compute"), None, Some("compare")]);
let result = neq_scalar(&array, "compare");
assert_eq!(result, BooleanArray::from([Some(true), None, Some(false)]));

Modules

binary

Comparison functions for BinaryArray

boolean

Comparison functions for BooleanArray

primitive

Comparison functions for PrimitiveArray

utf8

Comparison functions for Utf8Array

Traits

Simd8

NativeType that supports a representation of 8 lanes

Simd8Lanes

Trait declaring an 8-lane multi-data.

Simd8PartialEq

Trait implemented by implementors of Simd8Lanes whose Simd8 implements PartialEq.

Simd8PartialOrd

Trait implemented by implementors of Simd8Lanes whose Simd8 implements PartialOrd.

Functions

can_eq

Returns whether a DataType is comparable is supported by eq.

can_eq_scalar

Returns whether a DataType is supported by eq_scalar.

can_gt

Returns whether a DataType is comparable is supported by gt.

can_gt_eq

Returns whether a DataType is comparable is supported by gt_eq.

can_gt_eq_scalar

Returns whether a DataType is supported by gt_eq_scalar.

can_gt_scalar

Returns whether a DataType is supported by gt_scalar.

can_lt

Returns whether a DataType is comparable is supported by lt.

can_lt_eq

Returns whether a DataType is comparable is supported by lt.

can_lt_eq_scalar

Returns whether a DataType is supported by lt_eq_scalar.

can_lt_scalar

Returns whether a DataType is supported by lt_scalar.

can_neq

Returns whether a DataType is comparable is supported by neq.

can_neq_scalar

Returns whether a DataType is supported by neq_scalar.

eq

== between two Arrays. Use can_eq to check whether the operation is valid

eq_and_validity

== between two Arrays and includes validities in comparison. Use can_eq to check whether the operation is valid

eq_scalar

== between an Array and a Scalar. Use can_eq_scalar to check whether the operation is valid

eq_scalar_and_validity

== between an Array and a Scalar and includes validities in comparison. Use can_eq_scalar to check whether the operation is valid

gt

> between two Arrays. Use can_gt to check whether the operation is valid

gt_eq

>= between two Arrays. Use can_gt_eq to check whether the operation is valid

gt_eq_scalar

>= between an Array and a Scalar. Use can_gt_eq_scalar to check whether the operation is valid

gt_scalar

> between an Array and a Scalar. Use can_gt_scalar to check whether the operation is valid

lt

< between two Arrays. Use can_lt to check whether the operation is valid

lt_eq

<= between two Arrays. Use can_lt_eq to check whether the operation is valid

lt_eq_scalar

<= between an Array and a Scalar. Use can_lt_eq_scalar to check whether the operation is valid

lt_scalar

< between an Array and a Scalar. Use can_lt_scalar to check whether the operation is valid

neq

!= between two Arrays. Use can_neq to check whether the operation is valid

neq_and_validity

!= between two Arrays and includes validities in comparison. Use can_neq to check whether the operation is valid

neq_scalar

!= between an Array and a Scalar. Use can_neq_scalar to check whether the operation is valid

neq_scalar_and_validity

!= between an Array and a Scalar and includes validities in comparison. Use can_neq_scalar to check whether the operation is valid