Struct arrow_array::types::IntervalMonthDayNano

#[repr(C)]
pub struct IntervalMonthDayNano {
    pub months: i32,
    pub days: i32,
    pub nanoseconds: i64,
}

Value of an IntervalMonthDayNano array

Representation

This type is stored as a single 128 bit integer, interpreted as three different signed integral fields:

1. The number of months (32 bits)
2. The number days (32 bits)
3. The number of nanoseconds (64 bits).

Nanoseconds does not allow for leap seconds.

Each field is independent (e.g. there is no constraint that the quantity of nanoseconds represents less than a day’s worth of time).

┌───────────────┬─────────────┬─────────────────────────────┐
│     Months    │     Days    │            Nanos            │
│   (32 bits)   │  (32 bits)  │          (64 bits)          │
└───────────────┴─────────────┴─────────────────────────────┘
0            32             64                           128 bit offset

Please see the Arrow Spec for more details

Note on Comparing and Ordering for Calendar Types

Values of IntervalMonthDayNano are compared using their binary representation, which can lead to surprising results.

Spans of time measured in calendar units are not fixed in absolute size (e.g. number of seconds) which makes defining comparisons and ordering non trivial. For example 1 month is 28 days for February but 1 month is 31 days in December.

This makes the seemingly simple operation of comparing two intervals complicated in practice. For example is 1 month more or less than 30 days? The answer depends on what month you are talking about.

This crate defines comparisons for calendar types using their binary representation which is fast and efficient, but leads to potentially surprising results.

For example a IntervalMonthDayNano of 1 month will compare as greater than a IntervalMonthDayNano of 100 days because the binary representation of 1 month is larger than the binary representation of 100 days.

Fields

months: i32

Number of months

days: i32

Number of days

nanoseconds: i64

Number of nanoseconds

Implementations

impl IntervalMonthDayNano

pub const ZERO: IntervalMonthDayNano = _

The additive identity i.e. 0.

pub const ONE: IntervalMonthDayNano = _

The multiplicative identity, i.e. 1.

pub const MINUS_ONE: IntervalMonthDayNano = _

The multiplicative inverse, i.e. -1.

pub const MAX: IntervalMonthDayNano = _

The maximum value that can be represented

pub const MIN: IntervalMonthDayNano = _

The minimum value that can be represented

pub const fn new( months: i32, days: i32, nanoseconds: i64, ) -> IntervalMonthDayNano

Create a new IntervalMonthDayNano

pub fn wrapping_abs(self) -> IntervalMonthDayNano

Computes the absolute value

pub fn checked_abs(self) -> Option<IntervalMonthDayNano>

Computes the absolute value

pub fn wrapping_neg(self) -> IntervalMonthDayNano

Negates the value

pub fn checked_neg(self) -> Option<IntervalMonthDayNano>

Negates the value

pub fn wrapping_add(self, other: IntervalMonthDayNano) -> IntervalMonthDayNano

Performs wrapping addition

pub fn checked_add( self, other: IntervalMonthDayNano, ) -> Option<IntervalMonthDayNano>

Performs checked addition

pub fn wrapping_sub(self, other: IntervalMonthDayNano) -> IntervalMonthDayNano

Performs wrapping subtraction

pub fn checked_sub( self, other: IntervalMonthDayNano, ) -> Option<IntervalMonthDayNano>

Performs checked subtraction

pub fn wrapping_mul(self, other: IntervalMonthDayNano) -> IntervalMonthDayNano

Performs wrapping multiplication

pub fn checked_mul( self, other: IntervalMonthDayNano, ) -> Option<IntervalMonthDayNano>

Performs checked multiplication

pub fn wrapping_div(self, other: IntervalMonthDayNano) -> IntervalMonthDayNano

Performs wrapping division

pub fn checked_div( self, other: IntervalMonthDayNano, ) -> Option<IntervalMonthDayNano>

Performs checked division

pub fn wrapping_rem(self, other: IntervalMonthDayNano) -> IntervalMonthDayNano

Performs wrapping remainder

pub fn checked_rem( self, other: IntervalMonthDayNano, ) -> Option<IntervalMonthDayNano>

Performs checked remainder

pub fn wrapping_pow(self, exp: u32) -> IntervalMonthDayNano

Performs wrapping exponentiation

pub fn checked_pow(self, exp: u32) -> Option<IntervalMonthDayNano>

Performs checked exponentiation

Trait Implementations

impl<'a, 'b> Add<&'b IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the + operator.

fn add( self, rhs: &'b IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Add<&'b IntervalMonthDayNano>>::Output

Performs the + operation.

impl<'a> Add<&'a IntervalMonthDayNano> for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the + operator.

fn add( self, rhs: &'a IntervalMonthDayNano, ) -> <IntervalMonthDayNano as Add<&'a IntervalMonthDayNano>>::Output

Performs the + operation.

impl<'a> Add<IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the + operator.

fn add( self, rhs: IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Add<IntervalMonthDayNano>>::Output

Performs the + operation.

impl Add for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the + operator.

fn add(self, rhs: IntervalMonthDayNano) -> <IntervalMonthDayNano as Add>::Output

Performs the + operation.

impl AddAssign for IntervalMonthDayNano

fn add_assign(&mut self, rhs: IntervalMonthDayNano)

Performs the += operation.

impl ArrowNativeType for IntervalMonthDayNano

fn from_usize(_: usize) -> Option<IntervalMonthDayNano>

Convert native integer type from usize

fn as_usize(self) -> usize

Convert to usize according to the as operator

fn usize_as(i: usize) -> IntervalMonthDayNano

Convert from usize according to the as operator

fn to_usize(self) -> Option<usize>

Convert native type to usize.

fn to_isize(self) -> Option<isize>

Convert native type to isize.

fn to_i64(self) -> Option<i64>

Convert native type to i64.

fn get_byte_width() -> usize

Returns the byte width of this native type.

fn from_i32(_: i32) -> Option<Self>

👎Deprecated: please use Option::Some instead

Convert native type from i32.

fn from_i64(_: i64) -> Option<Self>

👎Deprecated: please use Option::Some instead

Convert native type from i64.

fn from_i128(_: i128) -> Option<Self>

👎Deprecated: please use Option::Some instead

Convert native type from i128.

impl ArrowNativeTypeOp for IntervalMonthDayNano

const ZERO: Self = IntervalMonthDayNano::ZERO

The additive identity

const ONE: Self = IntervalMonthDayNano::ONE

The multiplicative identity

const MIN_TOTAL_ORDER: Self = IntervalMonthDayNano::MIN

The minimum value and identity for the max aggregation. Note that the aggregation uses the total order predicate for floating point values, which means that this value is a negative NaN.

const MAX_TOTAL_ORDER: Self = IntervalMonthDayNano::MAX

The maximum value and identity for the min aggregation. Note that the aggregation uses the total order predicate for floating point values, which means that this value is a positive NaN.

fn add_checked(self, rhs: Self) -> Result<Self, ArrowError>

Checked addition operation

fn add_wrapping(self, rhs: Self) -> Self

Wrapping addition operation

fn sub_checked(self, rhs: Self) -> Result<Self, ArrowError>

Checked subtraction operation

fn sub_wrapping(self, rhs: Self) -> Self

Wrapping subtraction operation

fn mul_checked(self, rhs: Self) -> Result<Self, ArrowError>

Checked multiplication operation

fn mul_wrapping(self, rhs: Self) -> Self

Wrapping multiplication operation

fn div_checked(self, rhs: Self) -> Result<Self, ArrowError>

Checked division operation

fn div_wrapping(self, rhs: Self) -> Self

Wrapping division operation

fn mod_checked(self, rhs: Self) -> Result<Self, ArrowError>

Checked remainder operation

fn mod_wrapping(self, rhs: Self) -> Self

Wrapping remainder operation

fn neg_checked(self) -> Result<Self, ArrowError>

Checked negation operation

fn pow_checked(self, exp: u32) -> Result<Self, ArrowError>

Checked exponentiation operation

fn pow_wrapping(self, exp: u32) -> Self

Wrapping exponentiation operation

fn neg_wrapping(self) -> Self

Wrapping negation operation

fn is_zero(self) -> bool

Returns true if zero else false

fn compare(self, rhs: Self) -> Ordering

Compare operation

fn is_eq(self, rhs: Self) -> bool

Equality operation

fn is_ne(self, rhs: Self) -> bool

Not equal operation

fn is_lt(self, rhs: Self) -> bool

Less than operation

fn is_le(self, rhs: Self) -> bool

Less than equals operation

fn is_gt(self, rhs: Self) -> bool

Greater than operation

fn is_ge(self, rhs: Self) -> bool

Greater than equals operation

impl Clone for IntervalMonthDayNano

fn clone(&self) -> IntervalMonthDayNano

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IntervalMonthDayNano

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

Formats the value using the given formatter.

impl Default for IntervalMonthDayNano

fn default() -> IntervalMonthDayNano

Returns the “default value” for a type.

impl<'a, 'b> Div<&'b IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the / operator.

fn div( self, rhs: &'b IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Div<&'b IntervalMonthDayNano>>::Output

Performs the / operation.

impl<'a> Div<&'a IntervalMonthDayNano> for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the / operator.

fn div( self, rhs: &'a IntervalMonthDayNano, ) -> <IntervalMonthDayNano as Div<&'a IntervalMonthDayNano>>::Output

Performs the / operation.

impl<'a> Div<IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the / operator.

fn div( self, rhs: IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Div<IntervalMonthDayNano>>::Output

Performs the / operation.

impl Div for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the / operator.

fn div(self, rhs: IntervalMonthDayNano) -> <IntervalMonthDayNano as Div>::Output

Performs the / operation.

impl DivAssign for IntervalMonthDayNano

fn div_assign(&mut self, rhs: IntervalMonthDayNano)

Performs the /= operation.

impl Hash for IntervalMonthDayNano

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

where __H: Hasher,

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<'a, 'b> Mul<&'b IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the * operator.

fn mul( self, rhs: &'b IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Mul<&'b IntervalMonthDayNano>>::Output

Performs the * operation.

impl<'a> Mul<&'a IntervalMonthDayNano> for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the * operator.

fn mul( self, rhs: &'a IntervalMonthDayNano, ) -> <IntervalMonthDayNano as Mul<&'a IntervalMonthDayNano>>::Output

Performs the * operation.

impl<'a> Mul<IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the * operator.

fn mul( self, rhs: IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Mul<IntervalMonthDayNano>>::Output

Performs the * operation.

impl Mul for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the * operator.

fn mul(self, rhs: IntervalMonthDayNano) -> <IntervalMonthDayNano as Mul>::Output

Performs the * operation.

impl MulAssign for IntervalMonthDayNano

fn mul_assign(&mut self, rhs: IntervalMonthDayNano)

Performs the *= operation.

impl Neg for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the - operator.

fn neg(self) -> <IntervalMonthDayNano as Neg>::Output

Performs the unary - operation.

impl Ord for IntervalMonthDayNano

fn cmp(&self, other: &IntervalMonthDayNano) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for IntervalMonthDayNano

fn eq(&self, other: &IntervalMonthDayNano) -> 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 IntervalMonthDayNano

fn partial_cmp(&self, other: &IntervalMonthDayNano) -> 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<'a, 'b> Rem<&'b IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the % operator.

fn rem( self, rhs: &'b IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Rem<&'b IntervalMonthDayNano>>::Output

Performs the % operation.

impl<'a> Rem<&'a IntervalMonthDayNano> for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the % operator.

fn rem( self, rhs: &'a IntervalMonthDayNano, ) -> <IntervalMonthDayNano as Rem<&'a IntervalMonthDayNano>>::Output

Performs the % operation.

impl<'a> Rem<IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the % operator.

fn rem( self, rhs: IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Rem<IntervalMonthDayNano>>::Output

Performs the % operation.

impl Rem for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the % operator.

fn rem(self, rhs: IntervalMonthDayNano) -> <IntervalMonthDayNano as Rem>::Output

Performs the % operation.

impl RemAssign for IntervalMonthDayNano

fn rem_assign(&mut self, rhs: IntervalMonthDayNano)

Performs the %= operation.

impl<'a, 'b> Sub<&'b IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the - operator.

fn sub( self, rhs: &'b IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Sub<&'b IntervalMonthDayNano>>::Output

Performs the - operation.

impl<'a> Sub<&'a IntervalMonthDayNano> for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the - operator.

fn sub( self, rhs: &'a IntervalMonthDayNano, ) -> <IntervalMonthDayNano as Sub<&'a IntervalMonthDayNano>>::Output

Performs the - operation.

impl<'a> Sub<IntervalMonthDayNano> for &'a IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the - operator.

fn sub( self, rhs: IntervalMonthDayNano, ) -> <&'a IntervalMonthDayNano as Sub<IntervalMonthDayNano>>::Output

Performs the - operation.

impl Sub for IntervalMonthDayNano

type Output = IntervalMonthDayNano

The resulting type after applying the - operator.

fn sub(self, rhs: IntervalMonthDayNano) -> <IntervalMonthDayNano as Sub>::Output

Performs the - operation.

impl SubAssign for IntervalMonthDayNano

fn sub_assign(&mut self, rhs: IntervalMonthDayNano)

Performs the -= operation.

impl Copy for IntervalMonthDayNano

impl Eq for IntervalMonthDayNano

impl StructuralPartialEq for IntervalMonthDayNano