Enum datafusion::scalar::ScalarValue

source · [−]

pub enum ScalarValue {
Show 28 variants    Null,
    Boolean(Option<bool>),
    Float32(Option<f32>),
    Float64(Option<f64>),
    Decimal128(Option<i128>, usize, usize),
    Int8(Option<i8>),
    Int16(Option<i16>),
    Int32(Option<i32>),
    Int64(Option<i64>),
    UInt8(Option<u8>),
    UInt16(Option<u16>),
    UInt32(Option<u32>),
    UInt64(Option<u64>),
    Utf8(Option<String>),
    LargeUtf8(Option<String>),
    Binary(Option<Vec<u8, Global>>),
    LargeBinary(Option<Vec<u8, Global>>),
    List(Option<Vec<ScalarValue, Global>>, Box<DataType, Global>),
    Date32(Option<i32>),
    Date64(Option<i64>),
    TimestampSecond(Option<i64>, Option<String>),
    TimestampMillisecond(Option<i64>, Option<String>),
    TimestampMicrosecond(Option<i64>, Option<String>),
    TimestampNanosecond(Option<i64>, Option<String>),
    IntervalYearMonth(Option<i32>),
    IntervalDayTime(Option<i64>),
    IntervalMonthDayNano(Option<i128>),
    Struct(Option<Vec<ScalarValue, Global>>, Box<Vec<Field, Global>, Global>),
}

Expand description

Represents a dynamically typed, nullable single value. This is the single-valued counter-part of arrow’s Array.

Variants

`Null`

represents DataType::Null (castable to/from any other type)

`Boolean(Option<bool>)`

true or false value

`Float32(Option<f32>)`

32bit float

`Float64(Option<f64>)`

64bit float

`Decimal128(Option<i128>, usize, usize)`

128bit decimal, using the i128 to represent the decimal

`Int8(Option<i8>)`

signed 8bit int

`Int16(Option<i16>)`

signed 16bit int

`Int32(Option<i32>)`

signed 32bit int

`Int64(Option<i64>)`

signed 64bit int

`UInt8(Option<u8>)`

unsigned 8bit int

`UInt16(Option<u16>)`

unsigned 16bit int

`UInt32(Option<u32>)`

unsigned 32bit int

`UInt64(Option<u64>)`

unsigned 64bit int

`Utf8(Option<String>)`

utf-8 encoded string.

`LargeUtf8(Option<String>)`

utf-8 encoded string representing a LargeString’s arrow type.

`Binary(Option<Vec<u8, Global>>)`

binary

`LargeBinary(Option<Vec<u8, Global>>)`

large binary

`List(Option<Vec<ScalarValue, Global>>, Box<DataType, Global>)`

list of nested ScalarValue

`Date32(Option<i32>)`

Date stored as a signed 32bit int

`Date64(Option<i64>)`

Date stored as a signed 64bit int

`TimestampSecond(Option<i64>, Option<String>)`

Timestamp Second

`TimestampMillisecond(Option<i64>, Option<String>)`

Timestamp Milliseconds

`TimestampMicrosecond(Option<i64>, Option<String>)`

Timestamp Microseconds

`TimestampNanosecond(Option<i64>, Option<String>)`

Timestamp Nanoseconds

`IntervalYearMonth(Option<i32>)`

Interval with YearMonth unit

`IntervalDayTime(Option<i64>)`

Interval with DayTime unit

`IntervalMonthDayNano(Option<i128>)`

Interval with MonthDayNano unit

`Struct(Option<Vec<ScalarValue, Global>>, Box<Vec<Field, Global>, Global>)`

struct of nested ScalarValue

Implementations

source

impl ScalarValue

source

pub fn try_new_decimal128(
 value: i128,
 precision: usize,
 scale: usize
) -> Result<ScalarValue, DataFusionError>

Create a decimal Scalar from value/precision and scale.

source

pub fn get_datatype(&self) -> DataType

Getter for the DataType of the value

source

pub fn arithmetic_negate(&self) -> ScalarValue

Calculate arithmetic negation for a scalar value

source

pub fn is_null(&self) -> bool

whether this value is null or not.

source

pub fn to_array(&self) -> Arc<dyn Array + 'static>

Converts a scalar value into an 1-row array.

source

pub fn iter_to_array(
scalars: impl IntoIterator<Item = ScalarValue>
) -> Result<Arc<dyn Array + 'static>, DataFusionError>

Converts an iterator of references ScalarValue into an ArrayRef corresponding to those values. For example,

Returns an error if the iterator is empty or if the ScalarValues are not all the same type

Example

use datafusion_common::ScalarValue;
use arrow::array::{ArrayRef, BooleanArray};

let scalars = vec![
  ScalarValue::Boolean(Some(true)),
  ScalarValue::Boolean(None),
  ScalarValue::Boolean(Some(false)),
];

// Build an Array from the list of ScalarValues
let array = ScalarValue::iter_to_array(scalars.into_iter())
  .unwrap();

let expected: ArrayRef = std::sync::Arc::new(
  BooleanArray::from(vec![
    Some(true),
    None,
    Some(false)
  ]
));

assert_eq!(&array, &expected);

source

pub fn to_array_of_size(&self, size: usize) -> Arc<dyn Array + 'static>

Converts a scalar value into an array of size rows.

source

pub fn try_from_array(
array: &Arc<dyn Array + 'static>,
index: usize
) -> Result<ScalarValue, DataFusionError>

Converts a value in array at index into a ScalarValue

source

pub fn try_from_string(
value: String,
target_type: &DataType
) -> Result<ScalarValue, DataFusionError>

Try to parse value into a ScalarValue of type target_type

source

pub fn eq_array(&self, array: &Arc<dyn Array + 'static>, index: usize) -> bool

Compares a single row of array @ index for equality with self, in an optimized fashion.

This method implements an optimized version of:

    let arr_scalar = Self::try_from_array(array, index).unwrap();
    arr_scalar.eq(self)

Performance note: the arrow compute kernels should be preferred over this function if at all possible as they can be vectorized and are generally much faster.

This function has a few narrow usescases such as hash table key comparisons where comparing a single row at a time is necessary.