Struct TimestampUTC 

pub struct TimestampUTC(/* private fields */);

A wrapper around the chrono crate’s DateTime<Utc> type.

Implementations

impl TimestampUTC

pub fn now() -> Self

Returns the current time in UTC.

Examples

use rosetta_utc::TimestampUTC;

let now = TimestampUTC::now();

Methods from Deref<Target = DateTime<Utc>>

pub const MIN_UTC: DateTime<Utc>

pub const MAX_UTC: DateTime<Utc>

pub fn date(&self) -> Date<Tz>

👎Deprecated since 0.4.23: Use date_naive() instead

Retrieves the date component with an associated timezone.

Unless you are immediately planning on turning this into a DateTime with the same timezone you should use the date_naive method.

NaiveDate is a more well-defined type, and has more traits implemented on it, so should be preferred to Date any time you truly want to operate on dates.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local date outside of the representable range of a Date.

pub fn date_naive(&self) -> NaiveDate

Retrieves the date component.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local date outside of the representable range of a NaiveDate.

Example

use chrono::prelude::*;

let date: DateTime<Utc> = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
let other: DateTime<FixedOffset> =
    FixedOffset::east_opt(23).unwrap().with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
assert_eq!(date.date_naive(), other.date_naive());

pub fn time(&self) -> NaiveTime

Retrieves the time component.

pub fn timestamp(&self) -> i64

Returns the number of non-leap seconds since January 1, 1970 0:00:00 UTC (aka “UNIX timestamp”).

The reverse operation of creating a DateTime from a timestamp can be performed using from_timestamp or TimeZone::timestamp_opt.

use chrono::{DateTime, TimeZone, Utc};

let dt: DateTime<Utc> = Utc.with_ymd_and_hms(2015, 5, 15, 0, 0, 0).unwrap();
assert_eq!(dt.timestamp(), 1431648000);

assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);

pub fn timestamp_millis(&self) -> i64

Returns the number of non-leap-milliseconds since January 1, 1970 UTC.

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_milli_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_milli_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);

pub fn timestamp_micros(&self) -> i64

Returns the number of non-leap-microseconds since January 1, 1970 UTC.

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_micro_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_micro_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);

pub fn timestamp_nanos(&self) -> i64

👎Deprecated since 0.4.31: use timestamp_nanos_opt() instead

Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.

Panics

An i64 with nanosecond precision can span a range of ~584 years. This function panics on an out of range DateTime.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

pub fn timestamp_nanos_opt(&self) -> Option<i64>

Returns the number of non-leap-nanoseconds since January 1, 1970 UTC.

Errors

An i64 with nanosecond precision can span a range of ~584 years. This function returns None on an out of range DateTime.

The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.

Example

use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_nano_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_444));

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_nano_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(1_000_000_000_000_000_555));

let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
    .unwrap()
    .and_hms_nano_opt(0, 12, 43, 145_224_192)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(-9_223_372_036_854_775_808));

let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
    .unwrap()
    .and_hms_nano_opt(23, 47, 16, 854_775_807)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), Some(9_223_372_036_854_775_807));

let dt = NaiveDate::from_ymd_opt(1677, 9, 21)
    .unwrap()
    .and_hms_nano_opt(0, 12, 43, 145_224_191)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);

let dt = NaiveDate::from_ymd_opt(2262, 4, 11)
    .unwrap()
    .and_hms_nano_opt(23, 47, 16, 854_775_808)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_nanos_opt(), None);

pub fn timestamp_subsec_millis(&self) -> u32

Returns the number of milliseconds since the last second boundary.

In event of a leap second this may exceed 999.

pub fn timestamp_subsec_micros(&self) -> u32

Returns the number of microseconds since the last second boundary.

In event of a leap second this may exceed 999,999.

pub fn timestamp_subsec_nanos(&self) -> u32

Returns the number of nanoseconds since the last second boundary

In event of a leap second this may exceed 999,999,999.

pub fn offset(&self) -> &<Tz as TimeZone>::Offset

Retrieves an associated offset from UTC.

pub fn timezone(&self) -> Tz

Retrieves an associated time zone.

pub fn with_timezone<Tz2>(&self, tz: &Tz2) -> DateTime<Tz2>

where Tz2: TimeZone,

Changes the associated time zone. The returned DateTime references the same instant of time from the perspective of the provided time zone.

pub fn fixed_offset(&self) -> DateTime<FixedOffset>

Fix the offset from UTC to its current value, dropping the associated timezone information. This is useful for converting a generic DateTime<Tz: Timezone> to DateTime<FixedOffset>.

pub fn to_utc(&self) -> DateTime<Utc>

Turn this DateTime into a DateTime<Utc>, dropping the offset and associated timezone information.

pub fn naive_utc(&self) -> NaiveDateTime

Returns a view to the naive UTC datetime.

pub fn naive_local(&self) -> NaiveDateTime

Returns a view to the naive local datetime.

Panics

DateTime internally stores the date and time in UTC with a NaiveDateTime. This method will panic if the offset from UTC would push the local datetime outside of the representable range of a NaiveDateTime.

pub fn years_since(&self, base: DateTime<Tz>) -> Option<u32>

Retrieve the elapsed years from now to the given DateTime.

Errors

Returns None if base > self.

pub fn to_rfc2822(&self) -> String

Returns an RFC 2822 date and time string such as Tue, 1 Jul 2003 10:52:37 +0200.

Panics

Panics if the date can not be represented in this format: the year may not be negative and can not have more than 4 digits.

pub fn to_rfc3339(&self) -> String

Returns an RFC 3339 and ISO 8601 date and time string such as 1996-12-19T16:39:57-08:00.

pub fn to_rfc3339_opts(&self, secform: SecondsFormat, use_z: bool) -> String

Return an RFC 3339 and ISO 8601 date and time string with subseconds formatted as per SecondsFormat.

If use_z is true and the timezone is UTC (offset 0), uses Z as per Fixed::TimezoneOffsetColonZ. If use_z is false, uses Fixed::TimezoneOffsetColon

Examples

let dt = NaiveDate::from_ymd_opt(2018, 1, 26)
    .unwrap()
    .and_hms_micro_opt(18, 30, 9, 453_829)
    .unwrap()
    .and_utc();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, false), "2018-01-26T18:30:09.453+00:00");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Millis, true), "2018-01-26T18:30:09.453Z");
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T18:30:09Z");

let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
let dt = pst
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2018, 1, 26)
            .unwrap()
            .and_hms_micro_opt(10, 30, 9, 453_829)
            .unwrap(),
    )
    .unwrap();
assert_eq!(dt.to_rfc3339_opts(SecondsFormat::Secs, true), "2018-01-26T10:30:09+08:00");

pub fn with_time(&self, time: NaiveTime) -> LocalResult<DateTime<Tz>>

Set the time to a new fixed time on the existing date.

Errors

Returns LocalResult::None if the datetime is at the edge of the representable range for a DateTime, and with_time would push the value in UTC out of range.

Example

use chrono::{Local, NaiveTime};

let noon = NaiveTime::from_hms_opt(12, 0, 0).unwrap();
let today_noon = Local::now().with_time(noon);
let today_midnight = Local::now().with_time(NaiveTime::MIN);

assert_eq!(today_noon.single().unwrap().time(), noon);
assert_eq!(today_midnight.single().unwrap().time(), NaiveTime::MIN);

pub const UNIX_EPOCH: DateTime<Utc>

pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>

where I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>,

Formats the combined date and time with the specified formatting items.

pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

Formats the combined date and time per the specified format string.

See the crate::format::strftime module for the supported escape sequences.

Example

use chrono::prelude::*;

let date_time: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 04, 02, 12, 50, 32).unwrap();
let formatted = format!("{}", date_time.format("%d/%m/%Y %H:%M"));
assert_eq!(formatted, "02/04/2017 12:50");

Trait Implementations

impl<'__expr> AsExpression<Nullable<TimestampUTC>> for &'__expr TimestampUTC

type Expression = Bound<Nullable<TimestampUTC>, &'__expr TimestampUTC>

The expression being returned

fn as_expression( self, ) -> <Self as AsExpression<Nullable<TimestampUTC>>>::Expression

Perform the conversion

impl AsExpression<Nullable<TimestampUTC>> for TimestampUTC

type Expression = Bound<Nullable<TimestampUTC>, TimestampUTC>

The expression being returned

fn as_expression( self, ) -> <Self as AsExpression<Nullable<TimestampUTC>>>::Expression

Perform the conversion

impl<'__expr> AsExpression<TimestampUTC> for &'__expr TimestampUTC

type Expression = Bound<TimestampUTC, &'__expr TimestampUTC>

The expression being returned

fn as_expression(self) -> <Self as AsExpression<TimestampUTC>>::Expression

Perform the conversion

impl AsExpression<TimestampUTC> for TimestampUTC

type Expression = Bound<TimestampUTC, TimestampUTC>

The expression being returned

fn as_expression(self) -> <Self as AsExpression<TimestampUTC>>::Expression

Perform the conversion

impl AsMut<DateTime<Utc>> for TimestampUTC

fn as_mut(&mut self) -> &mut DateTime<Utc>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<DateTime<Utc>> for TimestampUTC

fn as_ref(&self) -> &DateTime<Utc>

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TimestampUTC

fn clone(&self) -> TimestampUTC

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimestampUTC

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

Formats the value using the given formatter.

impl Default for TimestampUTC

fn default() -> Self

Returns the “default value” for a type.

impl Deref for TimestampUTC

type Target = DateTime<Utc>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for TimestampUTC

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for TimestampUTC

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TimestampUTC

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

Formats the value using the given formatter.

impl From<DateTime<Utc>> for TimestampUTC

fn from(value: DateTime<Utc>) -> Self

Converts to this type from the input type.

impl From<NaiveDateTime> for TimestampUTC

fn from(value: NaiveDateTime) -> Self

Converts to this type from the input type.

impl From<TimestampUTC> for DateTime<Utc>

fn from(value: TimestampUTC) -> Self

Converts to this type from the input type.

impl FromSql<TimestampUTC, Pg> for TimestampUTC

fn from_sql(value: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql( bytes: Option<<DB as Backend>::RawValue<'_>>, ) -> Result<Self, Box<dyn Error + Sync + Send>>

A specialized variant of from_sql for handling null values.

impl FromSql<TimestampUTC, Sqlite> for TimestampUTC

fn from_sql(value: SqliteValue<'_, '_, '_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql( bytes: Option<<DB as Backend>::RawValue<'_>>, ) -> Result<Self, Box<dyn Error + Sync + Send>>

A specialized variant of from_sql for handling null values.

impl FromStr for TimestampUTC

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Hash for TimestampUTC

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 Ord for TimestampUTC

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

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

fn partial_cmp(&self, other: &TimestampUTC) -> 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<__DB, __ST> Queryable<__ST, __DB> for TimestampUTC

where __DB: Backend, __ST: SingleValue, Self: FromSql<__ST, __DB>,

type Row = TimestampUTC

The Rust type you’d like to map from.

fn build(row: Self) -> Result<Self>

Construct an instance of this type

impl Serialize for TimestampUTC

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__DB> ToSql<Nullable<TimestampUTC>, __DB> for TimestampUTC

where __DB: Backend, Self: ToSql<TimestampUTC, __DB>,

fn to_sql<'__b>(&'__b self, out: &mut Output<'__b, '_, __DB>) -> Result

See the trait documentation.

impl ToSql<TimestampUTC, Pg> for TimestampUTC

fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> Result

See the trait documentation.

impl ToSql<TimestampUTC, Sqlite> for TimestampUTC

fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Sqlite>) -> Result

See the trait documentation.

impl Copy for TimestampUTC

impl Eq for TimestampUTC

impl StructuralPartialEq for TimestampUTC