Struct PrimitiveScalar 

pub struct PrimitiveScalar<'a> { /* private fields */ }

A scalar value representing a primitive type.

This type provides a view into a primitive scalar value of any primitive type (integers, floats) with various bit widths.

Implementations

impl<'a> PrimitiveScalar<'a>

pub fn try_new(dtype: &'a DType, value: &ScalarValue) -> VortexResult<Self>

Creates a new primitive scalar from a data type and scalar value.

Errors

Returns an error if the data type is not a primitive type or if the value cannot be converted to the expected primitive type.

pub fn dtype(&self) -> &'a DType

Returns the data type of this primitive scalar.

pub fn ptype(&self) -> PType

Returns the primitive type of this scalar.

pub fn pvalue(&self) -> Option<PValue>

Returns the primitive value, or None if null.

pub fn typed_value<T: NativePType>(&self) -> Option<T>

Returns the value as a specific native primitive type.

Returns None if the scalar is null, otherwise returns Some(value) where value is the underlying primitive value cast to the requested type T.

Panics

Panics if the primitive type of this scalar does not match the requested type.

pub fn is_nan(&self) -> bool

Returns true if the scalar is nan.

pub fn as_<T: FromPrimitiveOrF16>(&self) -> Option<T>

Attempts to extract the primitive value as the given type.

Errors

Panics if the cast fails due to overflow or type incompatibility. See also as_opt for the checked version that does not panic.

Examples

let wide = Scalar::primitive(1000i32, false.into());

// This succeeds
let narrow = wide.as_primitive().as_::<i16>();
assert_eq!(narrow, Some(1000i16));

// This also succeeds
let null = Scalar::null(DType::Primitive(PType::I16, true.into()));
assert_eq!(null.as_primitive().as_::<i8>(), None);

// This will panic, because 1000 does not fit in i8
wide.as_primitive().as_::<i8>();

pub fn as_opt<T: FromPrimitiveOrF16>(&self) -> Option<Option<T>>

Returns the inner value cast to the desired type.

If the cast fails, None is returned. If the scalar represents a null, Some(None) is returned. Otherwise, Some(Some(T)) is returned for a successful non-null conversion.

Examples

// Non-null values
let scalar = Scalar::primitive(100i32, false.into());
let primitive = scalar.as_primitive();
assert_eq!(primitive.as_opt::<i8>(), Some(Some(100i8)));

// Null value
let scalar = Scalar::null(DType::Primitive(PType::I32, true.into()));
let primitive = scalar.as_primitive();
assert_eq!(primitive.as_opt::<i8>(), Some(None));

// Failed conversion: 1000 cannot fit in an i8
let scalar = Scalar::primitive(1000i32, false.into());
let primitive = scalar.as_primitive();
assert_eq!(primitive.as_opt::<i8>(), None);

impl<'a> PrimitiveScalar<'a>

pub fn checked_binary_numeric( &self, other: &PrimitiveScalar<'a>, op: NumericOperator, ) -> Option<PrimitiveScalar<'a>>

Apply the (checked) operator to self and other using SQL-style null semantics.

If the operation overflows, Ok(None) is returned.

If the types are incompatible (ignoring nullability), an error is returned.

If either value is null, the result is null.

Trait Implementations

impl Add for PrimitiveScalar<'_>

type Output = PrimitiveScalar<'_>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl CheckedAdd for PrimitiveScalar<'_>

fn checked_add(&self, rhs: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedSub for PrimitiveScalar<'_>

fn checked_sub(&self, rhs: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<'a> Clone for PrimitiveScalar<'a>

fn clone(&self) -> PrimitiveScalar<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for PrimitiveScalar<'a>

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

Formats the value using the given formatter.

impl Display for PrimitiveScalar<'_>

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

Formats the value using the given formatter.

impl From<PrimitiveScalar<'_>> for Scalar

fn from(pscalar: PrimitiveScalar<'_>) -> Self

Converts to this type from the input type.

impl<'a> Hash for PrimitiveScalar<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PrimitiveScalar<'_>

fn eq(&self, other: &Self) -> 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 PartialOrd for PrimitiveScalar<'_>

Ord is not implemented since it’s undefined for different PTypes

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for PrimitiveScalar<'_>

type Output = PrimitiveScalar<'_>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<'a> TryFrom<&'a Scalar> for PrimitiveScalar<'a>

type Error = VortexError

The type returned in the event of a conversion error.

fn try_from(value: &'a Scalar) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Copy for PrimitiveScalar<'a>

impl Eq for PrimitiveScalar<'_>