Enum NullableInterval

pub enum NullableInterval {
    Null {
        datatype: DataType,
    },
    MaybeNull {
        values: Interval,
    },
    NotNull {
        values: Interval,
    },
}

An Interval that also tracks null status using a boolean interval.

This represents values that may be in a particular range or be null.

Examples

use arrow::datatypes::DataType;
use datafusion_common::ScalarValue;
use datafusion_expr_common::interval_arithmetic::Interval;
use datafusion_expr_common::interval_arithmetic::NullableInterval;

// [1, 2) U {NULL}
let maybe_null = NullableInterval::MaybeNull {
   values: Interval::try_new(
           ScalarValue::Int32(Some(1)),
           ScalarValue::Int32(Some(2)),
       ).unwrap(),
};

// (0, ∞)
let not_null = NullableInterval::NotNull {
  values: Interval::try_new(
           ScalarValue::Int32(Some(0)),
           ScalarValue::Int32(None),
       ).unwrap(),
};

// {NULL}
let null_interval = NullableInterval::Null { datatype: DataType::Int32 };

// {4}
let single_value = NullableInterval::from(ScalarValue::Int32(Some(4)));

Variants

Null

The value is always null. This is typed so it can be used in physical expressions, which don’t do type coercion.

Fields

datatype: DataType

MaybeNull

The value may or may not be null. If it is non-null, its is within the specified range.

Fields

values: Interval

NotNull

The value is definitely not null, and is within the specified range.

Fields

values: Interval

Implementations

impl NullableInterval

pub fn values(&self) -> Option<&Interval>

Get the values interval, or None if this interval is definitely null.

pub fn data_type(&self) -> DataType

Get the data type

pub fn is_certainly_true(&self) -> bool

Return true if the value is definitely true (and not null).

pub fn is_certainly_false(&self) -> bool

Return true if the value is definitely false (and not null).

pub fn apply_operator(&self, op: &Operator, rhs: &Self) -> Result<Self>

Apply the given operator to this interval and the given interval.

Examples

use datafusion_common::ScalarValue;
use datafusion_expr_common::operator::Operator;
use datafusion_expr_common::interval_arithmetic::Interval;
use datafusion_expr_common::interval_arithmetic::NullableInterval;

// 4 > 3 -> true
let lhs = NullableInterval::from(ScalarValue::Int32(Some(4)));
let rhs = NullableInterval::from(ScalarValue::Int32(Some(3)));
let result = lhs.apply_operator(&Operator::Gt, &rhs).unwrap();
assert_eq!(result, NullableInterval::from(ScalarValue::Boolean(Some(true))));

// [1, 3) > NULL -> NULL
let lhs = NullableInterval::NotNull {
    values: Interval::try_new(
           ScalarValue::Int32(Some(1)),
           ScalarValue::Int32(Some(3)),
       ).unwrap(),
};
let rhs = NullableInterval::from(ScalarValue::Int32(None));
let result = lhs.apply_operator(&Operator::Gt, &rhs).unwrap();
assert_eq!(result.single_value(), Some(ScalarValue::Boolean(None)));

// [1, 3] > [2, 4] -> [false, true]
let lhs = NullableInterval::NotNull {
    values: Interval::try_new(
           ScalarValue::Int32(Some(1)),
           ScalarValue::Int32(Some(3)),
       ).unwrap(),
};
let rhs = NullableInterval::NotNull {
   values: Interval::try_new(
           ScalarValue::Int32(Some(2)),
           ScalarValue::Int32(Some(4)),
       ).unwrap(),
};
let result = lhs.apply_operator(&Operator::Gt, &rhs).unwrap();
// Both inputs are valid (non-null), so result must be non-null
assert_eq!(result, NullableInterval::NotNull {
// Uncertain whether inequality is true or false
   values: Interval::UNCERTAIN,
});

pub fn contains<T: Borrow<Self>>(&self, other: T) -> Result<Self>

Decide if this interval is a superset of, overlaps with, or disjoint with other by returning [true, true], [false, true] or [false, false] respectively.

NOTE: This function only works with intervals of the same data type. Attempting to compare intervals of different data types will lead to an error.

pub fn single_value(&self) -> Option<ScalarValue>

If the interval has collapsed to a single value, return that value. Otherwise, returns None.

Examples

use datafusion_common::ScalarValue;
use datafusion_expr_common::interval_arithmetic::Interval;
use datafusion_expr_common::interval_arithmetic::NullableInterval;

let interval = NullableInterval::from(ScalarValue::Int32(Some(4)));
assert_eq!(interval.single_value(), Some(ScalarValue::Int32(Some(4))));

let interval = NullableInterval::from(ScalarValue::Int32(None));
assert_eq!(interval.single_value(), Some(ScalarValue::Int32(None)));

let interval = NullableInterval::MaybeNull {
    values: Interval::try_new(
        ScalarValue::Int32(Some(1)),
        ScalarValue::Int32(Some(4)),
    ).unwrap(),
};
assert_eq!(interval.single_value(), None);

Trait Implementations

impl Clone for NullableInterval

fn clone(&self) -> NullableInterval

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NullableInterval

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

Formats the value using the given formatter.

impl Display for NullableInterval

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

Formats the value using the given formatter.

impl From<ScalarValue> for NullableInterval

fn from(value: ScalarValue) -> Self

Create an interval that represents a single value.

impl PartialEq for NullableInterval

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for NullableInterval

impl StructuralPartialEq for NullableInterval