Struct Interval

pub struct Interval {
    months: i32,
    days: i32,
    usecs: i64,
}

Every interval can be represented by a Interval.

Note that the difference between Interval and Instant. For example, 5 yrs 1 month 25 days 23:22:57 is a interval (Can be interpreted by Interval Unit with months = 61, days = 25, usecs = (57 + 23 * 3600 + 22 * 60) * 1000000), 1970-01-01 04:05:06 is a Instant or Timestamp One month may contain 28/31 days. One day may contain 23/25 hours. This internals is learned from PG: https://www.postgresql.org/docs/9.1/datatype-datetime.html#:~:text=field%20is%20negative.-,Internally,-interval%20values%20are

Fields

months: i32

days: i32

usecs: i64

Implementations

impl Interval

pub const MIN: Self = _

Smallest interval value.

pub const USECS_PER_DAY: i64 = 86_400_000_000i64

pub const USECS_PER_MONTH: i64 = 2_592_000_000_000i64

pub const USECS_PER_SEC: i64 = 1_000_000i64

pub fn from_month_day_usec(months: i32, days: i32, usecs: i64) -> Self

Creates a new Interval from the given number of months, days, and microseconds.

pub fn months(&self) -> i32

Returns the total number of whole months.

Note the difference between months and months_field.

We have: months = years_field * 12 + months_field

Example

let interval: Interval = "5 yrs 1 month".parse().unwrap();
assert_eq!(interval.months(), 61);
assert_eq!(interval.months_field(), 1);

pub fn days(&self) -> i32

Returns the number of days.

pub fn usecs(&self) -> i64

Returns the number of microseconds.

Note the difference between usecs and seconds_in_micros.

We have: usecs = (hours_field * 3600 + minutes_field * 60) * 1_000_000 + seconds_in_micros.

pub fn usecs_of_day(&self) -> u64

Calculates the remaining number of microseconds. range: 0..86_400_000_000

Note the difference between usecs and usecs_of_day.

let interval: Interval = "-1:00:00".parse().unwrap();
assert_eq!(interval.usecs(), -1 * 60 * 60 * 1_000_000);
assert_eq!(interval.usecs_of_day(), 23 * 60 * 60 * 1_000_000);

pub fn years_field(&self) -> i32

Returns the years field. range: unlimited

Example

let interval: Interval = "2332 yrs 12 months".parse().unwrap();
assert_eq!(interval.years_field(), 2333);

pub fn months_field(&self) -> i32

Returns the months field. range: -11..=11

Example

let interval: Interval = "15 months".parse().unwrap();
assert_eq!(interval.months_field(), 3);

let interval: Interval = "-15 months".parse().unwrap();
assert_eq!(interval.months_field(), -3);

pub fn days_field(&self) -> i32

Returns the days field. range: unlimited

Example

let interval: Interval = "1 months 100 days 25:00:00".parse().unwrap();
assert_eq!(interval.days_field(), 100);

pub fn hours_field(&self) -> i64

Returns the hours field. range: unlimited

Example

let interval: Interval = "25:00:00".parse().unwrap();
assert_eq!(interval.hours_field(), 25);

let interval: Interval = "-25:00:00".parse().unwrap();
assert_eq!(interval.hours_field(), -25);

pub fn minutes_field(&self) -> i32

Returns the minutes field. range: -59..=-59

Example

let interval: Interval = "00:20:00".parse().unwrap();
assert_eq!(interval.minutes_field(), 20);

let interval: Interval = "-00:20:00".parse().unwrap();
assert_eq!(interval.minutes_field(), -20);

pub fn seconds_in_micros(&self) -> i32

Returns the seconds field, including fractional parts, in microseconds. range: -59_999_999..=59_999_999

Example

let interval: Interval = "01:02:03.45678".parse().unwrap();
assert_eq!(interval.seconds_in_micros(), 3_456_780);

let interval: Interval = "-01:02:03.45678".parse().unwrap();
assert_eq!(interval.seconds_in_micros(), -3_456_780);

pub fn epoch_in_micros(&self) -> i128

Returns the total number of microseconds, as defined by PostgreSQL extract.

Note this value is not used by interval ordering (IntervalCmpValue) and is not consistent with it.

pub fn from_protobuf(cursor: &mut Cursor<&[u8]>) -> ArrayResult<Interval>

pub fn to_protobuf<T: Write>(self, output: &mut T) -> ArrayResult<usize>

pub fn checked_mul_int<I>(&self, rhs: I) -> Option<Self>

where I: TryInto<i32>,

Multiple Interval by an integer with overflow check.

fn from_floats(months: f64, days: f64, usecs: f64) -> Option<Self>

Internal utility used by Self::mul_float and Self::div_float to adjust fractional units. Not intended as general constructor.

pub fn div_float<I>(&self, rhs: I) -> Option<Self>

where I: TryInto<F64>,

Divides Interval by an integer/float with zero check.

pub fn mul_float<I>(&self, rhs: I) -> Option<Self>

where I: TryInto<F64>,

times Interval with an integer/float.

pub fn exact_div(&self, rhs: &Self) -> Option<i64>

Performs an exact division, returns None if for any unit, lhs % rhs != 0.

pub fn is_positive(&self) -> bool

Checks if Interval is positive.

pub fn is_never_negative(&self) -> bool

Checks if all fields of Interval are all non-negative.

pub const fn truncate_millis(self) -> Self

Truncate the interval to the precision of milliseconds.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(
    interval.truncate_millis().to_string(),
    "5 years 1 mon 25 days 23:22:57.123"
);

pub const fn truncate_second(self) -> Self

Truncate the interval to the precision of seconds.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(
    interval.truncate_second().to_string(),
    "5 years 1 mon 25 days 23:22:57"
);

pub const fn truncate_minute(self) -> Self

Truncate the interval to the precision of minutes.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(
    interval.truncate_minute().to_string(),
    "5 years 1 mon 25 days 23:22:00"
);

pub const fn truncate_hour(self) -> Self

Truncate the interval to the precision of hours.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(
    interval.truncate_hour().to_string(),
    "5 years 1 mon 25 days 23:00:00"
);

pub const fn truncate_day(self) -> Self

Truncate the interval to the precision of days.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_day().to_string(), "5 years 1 mon 25 days");

pub const fn truncate_month(self) -> Self

Truncate the interval to the precision of months.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_month().to_string(), "5 years 1 mon");

pub const fn truncate_quarter(self) -> Self

Truncate the interval to the precision of quarters.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_quarter().to_string(), "5 years");

pub const fn truncate_year(self) -> Self

Truncate the interval to the precision of years.

Example

let interval: Interval = "5 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_year().to_string(), "5 years");

pub const fn truncate_decade(self) -> Self

Truncate the interval to the precision of decades.

Example

let interval: Interval = "15 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_decade().to_string(), "10 years");

pub const fn truncate_century(self) -> Self

Truncate the interval to the precision of centuries.

Example

let interval: Interval = "115 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_century().to_string(), "100 years");

pub const fn truncate_millennium(self) -> Self

Truncate the interval to the precision of millenniums.

Example

let interval: Interval = "1115 years 1 mon 25 days 23:22:57.123".parse().unwrap();
assert_eq!(interval.truncate_millennium().to_string(), "1000 years");

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

impl Interval

pub fn as_iso_8601(&self) -> String

pub fn from_iso_8601(s: &str) -> Result<Self, IntervalParseError>

Converts str to interval

The input str must have the following format: P<years>Y<months>M<days>DT<hours>H<minutes>M<seconds>S

Example

• P1Y2M3DT4H5M6.78S

impl Interval

fn parse_sql_standard( s: &str, leading_field: DateTimeField, ) -> Result<Self, IntervalParseError>

fn parse_postgres(s: &str) -> Result<Self, IntervalParseError>

pub fn parse_with_fields( s: &str, leading_field: Option<DateTimeField>, ) -> Result<Self, IntervalParseError>

Trait Implementations

impl Add for Interval

type Output = Interval

The resulting type after applying the + operator.

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

Performs the + operation.

impl CheckedAdd<Interval> for Timestamp

type Output = Timestamp

fn checked_add(self, rhs: Interval) -> Option<Timestamp>

impl CheckedAdd for Interval

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

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

impl CheckedNeg for Interval

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

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl CheckedSub for Interval

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

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

impl Clone for Interval

fn clone(&self) -> Interval

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interval

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

Formats the value using the given formatter.

impl Default for Interval

fn default() -> Interval

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Interval

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Interval

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

Formats the value using the given formatter.

impl From<&Interval> for Interval

fn from(p: &PbInterval) -> Self

Converts to this type from the input type.

impl From<Interval> for IntervalCmpValue

fn from(value: Interval) -> Self

Converts to this type from the input type.

impl From<Interval> for ScalarImpl

fn from(val: Interval) -> Self

Converts to this type from the input type.

impl<'scalar> From<Interval> for ScalarRefImpl<'scalar>

fn from(val: Interval) -> Self

Converts to this type from the input type.

impl From<Interval> for Time

In PostgreSQL, casting from interval to time discards the days part.

Example

use std::str::FromStr;

use risingwave_common::types::{Interval, Time};

let interval = Interval::from_month_day_usec(1, 2, 61000003);
let time = Time::from(interval);
assert_eq!(time, Time::from_str("00:01:01.000003").unwrap());

let interval = Interval::from_month_day_usec(0, 0, -61000003);
let time = Time::from(interval);
assert_eq!(time, Time::from_str("23:58:58.999997").unwrap());

fn from(interval: Interval) -> Self

Converts to this type from the input type.

impl From<Time> for Interval

fn from(time: Time) -> Self

Converts to this type from the input type.

impl FromIntoArrow for Interval

type ArrowType = IntervalMonthDayNano

The corresponding element type in the Arrow array.

fn from_arrow(value: Self::ArrowType) -> Self

fn into_arrow(self) -> Self::ArrowType

impl FromIntoArrow for Interval

type ArrowType = IntervalMonthDayNano

The corresponding element type in the Arrow array.

fn from_arrow(value: Self::ArrowType) -> Self

fn into_arrow(self) -> Self::ArrowType

impl<'a> FromSql<'a> for Interval

fn from_sql( _: &Type, raw: &'a [u8], ) -> Result<Interval, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(ty: &Type) -> Result<Self, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable( ty: &Type, raw: Option<&'a [u8]>, ) -> Result<Self, Box<dyn Error + Sync + Send>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

impl FromStr for Interval

type Err = IntervalParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, IntervalParseError>

Parses a string s to return a value of this type.

impl Hash for Interval

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 HashKeyDe for Interval

fn deserialize(_data_type: &DataType, buf: impl Buf) -> Self

impl HashKeySer<'_> for Interval

fn serialize_into(self, buf: impl BufMut)

Serialize the scalar into the given buffer.

fn exact_size() -> Option<usize>

Returns Some if the serialized size is known for this scalar type.

fn estimated_size(self) -> usize

Returns the estimated serialized size for this scalar.

impl IntervalTestExt for Interval

fn from_ymd(year: i32, month: i32, days: i32) -> Self

fn from_month(months: i32) -> Self

fn from_days(days: i32) -> Self

fn from_millis(ms: i64) -> Self

fn from_minutes(minutes: i64) -> Self

impl Into<Interval> for Interval

Duplicated logic only used by HopWindow. See #8452.

fn into(self) -> PbInterval

Converts this type into the (usually inferred) input type.

impl Neg for Interval

type Output = Interval

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Ord for Interval

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

Restrict a value to a certain interval.

impl PartialEq for Interval

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 Interval

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 PrimitiveArrayItemType for Interval

const DATA_TYPE: DataType = DataType::Interval

The data type.

fn erase_array_type(arr: PrimitiveArray<Self>) -> ArrayImpl

A helper to convert a primitive array to ArrayImpl.

fn try_into_array(arr: ArrayImpl) -> Option<PrimitiveArray<Self>>

A helper to convert ArrayImpl to self.

fn try_into_array_ref(arr: &ArrayImpl) -> Option<&PrimitiveArray<Self>>

A helper to convert ArrayImpl to self.

fn array_type() -> ArrayType

Returns array type of the primitive array

fn to_protobuf<T: Write>(self, output: &mut T) -> ArrayResult<usize>

fn from_protobuf(cur: &mut Cursor<&[u8]>) -> ArrayResult<Self>

impl RandValue for Interval

fn rand_value<R: Rng>(rand: &mut R) -> Self

impl Scalar for Interval

Implement Scalar for Interval.

type ScalarRefType<'a> = Interval

Type for reference of Scalar

fn as_scalar_ref(&self) -> Interval

Get a reference to current scalar.

fn to_scalar_value(self) -> ScalarImpl

impl ScalarRef<'_> for Interval

Implement ScalarRef for Interval.

type ScalarType = Interval

ScalarType is the owned type of current ScalarRef.

fn to_owned_scalar(&self) -> Interval

Convert ScalarRef to an owned scalar.

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

A wrapped hash function to get the hash value for this scaler.

impl Serialize for Interval

Loss of information during the process due to IntervalCmpValue. Only intended for memcomparable encoding.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Interval

type Output = Interval

The resulting type after applying the - operator.

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

Performs the - operation.

impl ToBinary for Interval

fn to_binary_with_type(&self, ty: &DataType) -> Result<Bytes, ToBinaryError>

impl ToSql for Interval

fn to_sql_checked( &self, ty: &Type, out: &mut BytesMut, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

fn to_sql( &self, _: &Type, out: &mut BytesMut, ) -> Result<IsNull, Box<dyn Error + Send + Sync + 'static>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn encode_format(&self, _ty: &Type) -> Format

Specify the encode format

impl ToText for Interval

fn write<W: Write>(&self, f: &mut W) -> Result

Write the text to the writer regardless of its data type

fn write_with_type<W: Write>(&self, ty: &DataType, f: &mut W) -> Result

Write the text to the writer according to its data type

fn to_text_with_type(&self, ty: &DataType) -> String

Convert to text according to its data type

fn to_text(&self) -> String

to_text is a special version of to_text_with_type, it convert the scalar to default type text. E.g. for Int64, it will convert to text as a Int64 type. We should prefer to use to_text_with_type because it’s more clear and readable.

impl TryFrom<ScalarImpl> for Interval

type Error = ArrayError

The type returned in the event of a conversion error.

fn try_from(val: ScalarImpl) -> ArrayResult<Self>

Performs the conversion.

impl<'scalar> TryFrom<ScalarRefImpl<'scalar>> for Interval

type Error = ArrayError

The type returned in the event of a conversion error.

fn try_from(val: ScalarRefImpl<'scalar>) -> ArrayResult<Self>

Performs the conversion.

impl<'a> WithDataType for &'a Interval

fn default_data_type() -> DataType

Returns the most obvious DataType for the rust type.

impl<'a> WithDataType for &'a mut Interval

fn default_data_type() -> DataType

Returns the most obvious DataType for the rust type.

impl WithDataType for Box<Interval>

fn default_data_type() -> DataType

Returns the most obvious DataType for the rust type.

impl WithDataType for Interval

fn default_data_type() -> DataType

Returns the most obvious DataType for the rust type.

impl Zero for Interval

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for Interval

impl Eq for Interval

impl ZeroHeapSize for Interval