# Struct arrow::array::types::IntervalMonthDayNanoType

source · `pub struct IntervalMonthDayNanoType {}`

## Expand description

A “calendar” interval type in months, days, and nanoseconds.

### §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).

```
┌──────────────────────────────┬─────────────┬──────────────┐
│ Nanos │ Days │ Months │
│ (64 bits) │ (32 bits) │ (32 bits) │
└──────────────────────────────┴─────────────┴──────────────┘
0 63 95 127 bit offset
```

Please see the Arrow Spec for more details

### §Note on Comparing and Ordering for Calendar Types

Values of `IntervalMonthDayNanoType`

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.

## Implementations§

source§### impl IntervalMonthDayNanoType

### impl IntervalMonthDayNanoType

source#### pub fn make_value(
months: i32,
days: i32,
nanos: i64,
) -> <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native

#### pub fn make_value( months: i32, days: i32, nanos: i64, ) -> <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native

Creates a IntervalMonthDayNanoType::Native

##### §Arguments

`months`

- The number of months (+/-) represented in this interval`days`

- The number of days (+/-) represented in this interval`nanos`

- The number of nanoseconds (+/-) represented in this interval

source#### pub fn to_parts(
i: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
) -> (i32, i32, i64)

#### pub fn to_parts( i: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native, ) -> (i32, i32, i64)

Turns a IntervalMonthDayNanoType into a tuple of (months, days, nanos)

##### §Arguments

`i`

- The IntervalMonthDayNanoType to convert