Struct IntervalMonthDayNano

Source

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

Expand description

Value of an IntervalMonthDayNano array

§Representation

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

The number of months (32 bits)
The number days (32 bits)
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

Struct IntervalMonthDayNanoCopy item path

§Representation

§Note on Comparing and Ordering for Calendar Types

Fields§

Implementations§

impl IntervalMonthDayNano

pub const ZERO: Self = _

pub const ONE: Self = _

pub const MINUS_ONE: Self = _

pub const MAX: Self = _

pub const MIN: Self = _

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

pub fn wrapping_abs(self) -> Self

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

pub fn wrapping_neg(self) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

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

Trait Implementations§

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

type Output = IntervalMonthDayNano

fn add(self, rhs: &'b IntervalMonthDayNano) -> Self::Output

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

type Output = IntervalMonthDayNano

fn add(self, rhs: &'a IntervalMonthDayNano) -> Self::Output

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

type Output = IntervalMonthDayNano

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

impl Add for IntervalMonthDayNano

type Output = IntervalMonthDayNano

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

impl AddAssign for IntervalMonthDayNano

fn add_assign(&mut self, rhs: Self)

impl ArrowNativeType for IntervalMonthDayNano

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

fn as_usize(self) -> usize

fn usize_as(i: usize) -> Self

fn to_usize(self) -> Option<usize>

fn to_isize(self) -> Option<isize>

fn to_i64(self) -> Option<i64>

fn get_byte_width() -> usize

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

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

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

impl Clone for IntervalMonthDayNano

fn clone(&self) -> IntervalMonthDayNano

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

impl Debug for IntervalMonthDayNano

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

impl Default for IntervalMonthDayNano

fn default() -> IntervalMonthDayNano

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

type Output = IntervalMonthDayNano

fn div(self, rhs: &'b IntervalMonthDayNano) -> Self::Output

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

type Output = IntervalMonthDayNano

fn div(self, rhs: &'a IntervalMonthDayNano) -> Self::Output

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

type Output = IntervalMonthDayNano

fn div(self, rhs: IntervalMonthDayNano) -> Self::Output

impl Div for IntervalMonthDayNano

type Output = IntervalMonthDayNano

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

impl DivAssign for IntervalMonthDayNano

fn div_assign(&mut self, rhs: Self)

impl Hash for IntervalMonthDayNano

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

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

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

type Output = IntervalMonthDayNano

Struct IntervalMonthDayNano

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

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

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

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

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