Struct Datetime 

pub struct Datetime(pub DateTime<Utc>);

Tuple Fields

0: DateTime<Utc>

Implementations

impl Datetime

pub fn walk_revisioned_field_names( wire_revision: u16, ) -> &'static [&'static str]

Field names at the given wire revision in declaration order. Returns an empty slice if the revision is unknown. Generated by the revisioned derive.

impl Datetime

pub const REVISION: u16 = 1u16

The revision number of this type, as declared via #[revisioned(revision = N)].

impl Datetime

pub fn now() -> Datetime

impl Datetime

pub const MIN_UTC: Self

pub const MAX_UTC: Self

impl Datetime

pub fn to_version_stamp(self, ts_impl: &dyn TimeStampImpl) -> Result<u64>

Convert the datetime to a version stamp using the datastore’s timestamp implementation.

pub fn to_i64(self) -> Option<i64>

Convert to nanosecond timestamp.

pub fn to_secs(self) -> i64

Convert to second timestamp.

Methods from Deref<Target = 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 checked_add_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>>

Adds given TimeDelta to the current date and time.

Errors

Returns None if the resulting date would be out of range.

pub fn checked_add_months(self, months: Months) -> Option<DateTime<Tz>>

Adds given Months to the current date and time.

Uses the last day of the month if the day does not exist in the resulting month.

See NaiveDate::checked_add_months for more details on behavior.

Errors

Returns None if:

• The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
• The resulting UTC datetime would be out of range.
• The resulting local datetime would be out of range (unless months is zero).

pub fn checked_sub_signed(self, rhs: TimeDelta) -> Option<DateTime<Tz>>

Subtracts given TimeDelta from the current date and time.

Errors

Returns None if the resulting date would be out of range.

pub fn checked_sub_months(self, months: Months) -> Option<DateTime<Tz>>

Subtracts given Months from the current date and time.

Uses the last day of the month if the day does not exist in the resulting month.

See NaiveDate::checked_sub_months for more details on behavior.

Errors

Returns None if:

• The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
• The resulting UTC datetime would be out of range.
• The resulting local datetime would be out of range (unless months is zero).

pub fn checked_add_days(self, days: Days) -> Option<DateTime<Tz>>

Add a duration in Days to the date part of the DateTime.

Errors

Returns None if:

• The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
• The resulting UTC datetime would be out of range.
• The resulting local datetime would be out of range (unless days is zero).

pub fn checked_sub_days(self, days: Days) -> Option<DateTime<Tz>>

Subtract a duration in Days from the date part of the DateTime.

Errors

Returns None if:

• The local time at the resulting date does not exist or is ambiguous, for example during a daylight saving time transition.
• The resulting UTC datetime would be out of range.
• The resulting local datetime would be out of range (unless days is zero).

pub fn signed_duration_since<Tz2>( self, rhs: impl Borrow<DateTime<Tz2>>, ) -> TimeDelta

where Tz2: TimeZone,

Subtracts another DateTime from the current date and time. This does not overflow or underflow at all.

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 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 Add<Datetime> for Duration

type Output = Datetime

The resulting type after applying the + operator.

fn add(self, other: Datetime) -> Datetime

Performs the + operation.

impl<'de, F> BorrowDecode<'de, F> for Datetime

fn borrow_decode(r: &mut BorrowReader<'de>) -> Result<Self, DecodeError>

impl Cast for Datetime

fn can_cast(v: &Value) -> bool

Returns true if calling cast on the value will succeed.

fn cast(v: Value) -> Result<Self, CastError>

Cast a value to the self type.

impl Clone for Datetime

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Coerce for Datetime

fn can_coerce(v: &Value) -> bool

Returns if calling coerce on the value will succeed or not.

fn coerce(v: Value) -> Result<Self, CoerceError>

Coerce a value.

impl Copy for Datetime

impl Debug for Datetime

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

Formats the value using the given formatter.

impl Deref for Datetime

type Target = DateTime<Utc>

The resulting type after dereferencing.

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

Dereferences the value.

impl DeserializeRevisioned for Datetime

fn deserialize_revisioned<R: Read>(reader: &mut R) -> Result<Self, Error>

Deserializes a new instance of the struct from the specified reader.

impl Display for Datetime

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

Formats the value using the given formatter.

impl<F> Encode<F> for Datetime

fn encode<W: Write>(&self, w: &mut Writer<W>) -> Result<(), EncodeError>

impl Eq for Datetime

impl From<DateTime<Utc>> for Datetime

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

Converts to this type from the input type.

impl From<Datetime> for DateTime<Utc>

fn from(x: Datetime) -> Self

Converts to this type from the input type.

impl From<Datetime> for Datetime

fn from(v: Datetime) -> Self

Converts to this type from the input type.

impl From<Datetime> for Datetime

fn from(x: Datetime) -> Self

Converts to this type from the input type.

impl From<Datetime> for Value

fn from(v: Datetime) -> Self

Converts to this type from the input type.

impl FromStr for Datetime

type Err = ()

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 HasKind for Datetime

fn kind() -> Kind

impl Hash for Datetime

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 Datetime

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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Datetime

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Datetime

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 Revisioned for Datetime

fn revision() -> u16

Returns the current revision of this type.

fn type_id() -> TypeId

where Self: 'static,

Returns the type id of this type.

impl SerializeRevisioned for Datetime

fn serialize_revisioned<W: Write>(&self, writer: &mut W) -> Result<(), Error>

Serializes the struct using the specified writer.

impl SkipCheckRevisioned for Datetime

fn skip_check_revisioned<R: Read>(reader: &mut R) -> Result<(), Error>

impl SkipRevisioned for Datetime

fn skip_revisioned<R: Read>(reader: &mut R) -> Result<(), Error>

fn skip_revisioned_slice(reader: &mut SliceReader<'_>) -> Result<(), Error>

Consume through bytes backed by SliceReader without allocating a buffer for bulk segments.

impl StructuralPartialEq for Datetime

impl Sub for Datetime

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Duration

Performs the - operation.

impl Sub<Datetime> for Duration

type Output = Datetime

The resulting type after applying the - operator.

fn sub(self, other: Datetime) -> Datetime

Performs the - operation.

impl ToSql for Datetime

fn fmt_sql(&self, f: &mut String, sql_fmt: SqlFormat)

Format the type to a SQL string.

fn to_sql(&self) -> String

Convert the type to a SQL string.

fn to_sql_pretty(&self) -> String

Convert the type to a pretty-printed SQL string with indentation.

impl TryAdd<Datetime> for Duration

type Output = Datetime

fn try_add(self, other: Datetime) -> Result<Datetime>

impl TryFrom<(i64, u32)> for Datetime

type Error = ()

The type returned in the event of a conversion error.

fn try_from(v: (i64, u32)) -> Result<Self, Self::Error>

Performs the conversion.

impl TrySub for Datetime

type Output = Duration

fn try_sub(self, other: Self) -> Result<Duration>

impl TrySub<Datetime> for Duration

type Output = Datetime

fn try_sub(self, other: Datetime) -> Result<Datetime>

impl WalkRevisioned for Datetime

type Walker<'r, R: BorrowedReader + 'r> = DatetimeWalker<'r, R>

Walker produced by walk_revisioned.

fn walk_revisioned<'r, R: BorrowedReader>( reader: &'r mut R, ) -> Result<Self::Walker<'r, R>, Error>

Read the type’s revision-level prefix and return a walker positioned at the start of the body.