Struct tiberius::time::chrono::DateTime

pub struct DateTime<Tz>where
    Tz: TimeZone,{ /* private fields */ }

ISO 8601 combined date and time with time zone.

There are some constructors implemented here (the from_* methods), but the general-purpose constructors are all via the methods on the TimeZone implementations.

Implementations

impl<Tz> DateTime<Tz>where Tz: TimeZone,

pub fn from_utc( datetime: NaiveDateTime, offset: <Tz as TimeZone>::Offset ) -> DateTime<Tz>

Makes a new DateTime with given UTC datetime and offset. The local datetime should be constructed via the TimeZone trait.

Example

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

let dt = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp_opt(61, 0).unwrap(), Utc);
assert_eq!(Utc.timestamp_opt(61, 0).unwrap(), dt);

pub fn from_local( datetime: NaiveDateTime, offset: <Tz as TimeZone>::Offset ) -> DateTime<Tz>

Makes a new DateTime with given local datetime and offset that presents local timezone.

Example

use chrono::DateTime;
use chrono::naive::NaiveDate;
use chrono::offset::{Utc, FixedOffset};

let naivedatetime_utc = NaiveDate::from_ymd_opt(2000, 1, 12).unwrap().and_hms_opt(2, 0, 0).unwrap();
let datetime_utc = DateTime::<Utc>::from_utc(naivedatetime_utc, Utc);

let timezone_east = FixedOffset::east_opt(8 * 60 * 60).unwrap();
let naivedatetime_east = NaiveDate::from_ymd_opt(2000, 1, 12).unwrap().and_hms_opt(10, 0, 0).unwrap();
let datetime_east = DateTime::<FixedOffset>::from_local(naivedatetime_east, timezone_east);

let timezone_west = FixedOffset::west_opt(7 * 60 * 60).unwrap();
let naivedatetime_west = NaiveDate::from_ymd_opt(2000, 1, 11).unwrap().and_hms_opt(19, 0, 0).unwrap();
let datetime_west = DateTime::<FixedOffset>::from_local(naivedatetime_west, timezone_west);
assert_eq!(datetime_east, datetime_utc.with_timezone(&timezone_east));
assert_eq!(datetime_west, datetime_utc.with_timezone(&timezone_west));

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

👎Deprecated since 0.4.23: Use date_naive() instead

Retrieves a date component

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

pub fn date_naive(&self) -> NaiveDate

Retrieves the Date without an associated timezone

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.

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 a time component. Unlike date, this is not associated to the time zone.

pub fn timestamp(&self) -> i64

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

pub fn timestamp_millis(&self) -> i64

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

Note that this does reduce the number of years that can be represented from ~584 Billion to ~584 Million. (If this is a problem, please file an issue to let me know what domain needs millisecond precision over billions of years, I’m curious.)

Example

use chrono::{Utc, NaiveDate};

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

Note that this does reduce the number of years that can be represented from ~584 Billion to ~584 Thousand. (If this is a problem, please file an issue to let me know what domain needs microsecond precision over millennia, I’m curious.)

Example

use chrono::{Utc, NaiveDate};

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

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

Note that this does reduce the number of years that can be represented from ~584 Billion to ~584. (If this is a problem, please file an issue to let me know what domain needs nanosecond precision over millennia, I’m curious.)

Example

use chrono::{Utc, NaiveDate};

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(), 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(), 1_000_000_000_000_000_555);

pub fn timestamp_subsec_millis(&self) -> u32

Returns the number of milliseconds since the last second boundary

warning: in event of a leap second, this may exceed 999

note: this is not the number of milliseconds since January 1, 1970 0:00:00 UTC

pub fn timestamp_subsec_micros(&self) -> u32

Returns the number of microseconds since the last second boundary

warning: in event of a leap second, this may exceed 999_999

note: this is not the number of microseconds since January 1, 1970 0:00:00 UTC

pub fn timestamp_subsec_nanos(&self) -> u32

Returns the number of nanoseconds since the last second boundary

warning: in event of a leap second, this may exceed 999_999_999

note: this is not the number of nanoseconds since January 1, 1970 0:00:00 UTC

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 it useful for converting a generic DateTime<Tz: Timezone> to DateTime<FixedOffset>.

pub fn checked_add_signed(self, rhs: Duration) -> Option<DateTime<Tz>>

Adds given Duration to the current date and time.

Returns None when it will result in overflow.

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

Adds given Months to the current date and time.

Returns None when it will result in overflow, or if the local time is not valid on the newly calculated date.

See NaiveDate::checked_add_months for more details on behavior

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

Subtracts given Duration from the current date and time.

Returns None when it will result in overflow.

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

Subtracts given Months from the current date and time.

Returns None when it will result in overflow, or if the local time is not valid on the newly calculated date.

See NaiveDate::checked_sub_months for more details on behavior

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

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

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

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

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

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

pub fn signed_duration_since<Tz2>(self, rhs: DateTime<Tz2>) -> Durationwhere 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.

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

Retrieve the elapsed years from now to the given DateTime.

pub const MIN_UTC: DateTime<Utc> = _

The minimum possible DateTime<Utc>.

pub const MAX_UTC: DateTime<Utc> = _

The maximum possible DateTime<Utc>.

impl DateTime<FixedOffset>

pub fn parse_from_rfc2822(s: &str) -> Result<DateTime<FixedOffset>, ParseError>

Parses an RFC 2822 date-and-time string into a DateTime<FixedOffset> value.

This parses valid RFC 2822 datetime strings (such as Tue, 1 Jul 2003 10:52:37 +0200) and returns a new DateTime instance with the parsed timezone as the FixedOffset.

RFC 2822 is the internet message standard that specifies the representation of times in HTTP and email headers.

assert_eq!(
    DateTime::parse_from_rfc2822("Wed, 18 Feb 2015 23:16:09 GMT").unwrap(),
    FixedOffset::east_opt(0).unwrap().with_ymd_and_hms(2015, 2, 18, 23, 16, 9).unwrap()
);

pub fn parse_from_rfc3339(s: &str) -> Result<DateTime<FixedOffset>, ParseError>

Parses an RFC 3339 date-and-time string into a DateTime<FixedOffset> value.

Parses all valid RFC 3339 values (as well as the subset of valid ISO 8601 values that are also valid RFC 3339 date-and-time values) and returns a new DateTime with a FixedOffset corresponding to the parsed timezone. While RFC 3339 values come in a wide variety of shapes and sizes, 1996-12-19T16:39:57-08:00 is an example of the most commonly encountered variety of RFC 3339 formats.

Why isn’t this named parse_from_iso8601? That’s because ISO 8601 allows representing values in a wide range of formats, only some of which represent actual date-and-time instances (rather than periods, ranges, dates, or times). Some valid ISO 8601 values are also simultaneously valid RFC 3339 values, but not all RFC 3339 values are valid ISO 8601 values (or the other way around).

pub fn parse_from_str( s: &str, fmt: &str ) -> Result<DateTime<FixedOffset>, ParseError>

Parses a string from a user-specified format into a DateTime<FixedOffset> value.

Note that this method requires a timezone in the input string. See NaiveDateTime::parse_from_str for a version that does not require a timezone in the to-be-parsed str. The returned DateTime value will have a FixedOffset reflecting the parsed timezone.

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

Example

use chrono::{DateTime, FixedOffset, TimeZone, NaiveDate};

let dt = DateTime::parse_from_str(
    "1983 Apr 13 12:09:14.274 +0000", "%Y %b %d %H:%M:%S%.3f %z");
assert_eq!(dt, Ok(FixedOffset::east_opt(0).unwrap().from_local_datetime(&NaiveDate::from_ymd_opt(1983, 4, 13).unwrap().and_hms_milli_opt(12, 9, 14, 274).unwrap()).unwrap()));

pub fn parse_and_remainder<'a>( s: &'a str, fmt: &str ) -> Result<(DateTime<FixedOffset>, &'a str), ParseError>

Parses a string from a user-specified format into a DateTime<FixedOffset> value, and a slice with the remaining portion of the string.

Note that this method requires a timezone in the input string. See NaiveDateTime::parse_and_remainder for a version that does not require a timezone in s. The returned DateTime value will have a FixedOffset reflecting the parsed timezone.

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

Similar to parse_from_str.

Example

let (datetime, remainder) = DateTime::parse_and_remainder(
    "2015-02-18 23:16:09 +0200 trailing text", "%Y-%m-%d %H:%M:%S %z").unwrap();
assert_eq!(
    datetime,
    FixedOffset::east_opt(2*3600).unwrap().with_ymd_and_hms(2015, 2, 18, 23, 16, 9).unwrap()
);
assert_eq!(remainder, " trailing text");

impl<Tz> DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Display,

pub fn to_rfc2822(&self) -> String

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

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_local_timezone(Utc).unwrap();
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 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<Tz> Add<Days> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, days: Days) -> <DateTime<Tz> as Add<Days>>::Output

Performs the + operation.

impl<Tz> Add<Duration> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> DateTime<Tz>

Performs the + operation.

impl<Tz> Add<FixedOffset> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: FixedOffset) -> DateTime<Tz>

Performs the + operation.

impl<Tz> Add<Months> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the + operator.

fn add(self, rhs: Months) -> <DateTime<Tz> as Add<Months>>::Output

Performs the + operation.

impl<Tz> AddAssign<Duration> for DateTime<Tz>where Tz: TimeZone,

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl<Tz> Clone for DateTime<Tz>where Tz: Clone + TimeZone, <Tz as TimeZone>::Offset: Clone,

fn clone(&self) -> DateTime<Tz>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tz> Datelike for DateTime<Tz>where Tz: TimeZone,

fn year(&self) -> i32

Returns the year number in the calendar date.

fn month(&self) -> u32

Returns the month number starting from 1.

fn month0(&self) -> u32

Returns the month number starting from 0.

fn day(&self) -> u32

Returns the day of month starting from 1.

fn day0(&self) -> u32

Returns the day of month starting from 0.

fn ordinal(&self) -> u32

Returns the day of year starting from 1.

fn ordinal0(&self) -> u32

Returns the day of year starting from 0.

fn weekday(&self) -> Weekday

Returns the day of week.

fn iso_week(&self) -> IsoWeek

Returns the ISO week.

fn with_year(&self, year: i32) -> Option<DateTime<Tz>>

Makes a new value with the year number changed.

fn with_month(&self, month: u32) -> Option<DateTime<Tz>>

Makes a new value with the month number (starting from 1) changed.

fn with_month0(&self, month0: u32) -> Option<DateTime<Tz>>

Makes a new value with the month number (starting from 0) changed.

fn with_day(&self, day: u32) -> Option<DateTime<Tz>>

Makes a new value with the day of month (starting from 1) changed.

fn with_day0(&self, day0: u32) -> Option<DateTime<Tz>>

Makes a new value with the day of month (starting from 0) changed.

fn with_ordinal(&self, ordinal: u32) -> Option<DateTime<Tz>>

Makes a new value with the day of year (starting from 1) changed.

fn with_ordinal0(&self, ordinal0: u32) -> Option<DateTime<Tz>>

Makes a new value with the day of year (starting from 0) changed.

fn year_ce(&self) -> (bool, u32)

Returns the absolute year number starting from 1 with a boolean flag, which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).

fn num_days_from_ce(&self) -> i32

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.

impl<Tz> Debug for DateTime<Tz>where Tz: TimeZone,

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

Formats the value using the given formatter.

impl Default for DateTime<FixedOffset>

fn default() -> DateTime<FixedOffset>

Returns the “default value” for a type.

impl Default for DateTime<Local>

fn default() -> DateTime<Local>

Returns the “default value” for a type.

impl Default for DateTime<Utc>

fn default() -> DateTime<Utc>

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DateTime<FixedOffset>

Deserialize a value that optionally includes a timezone offset in its string representation

The value to be deserialized must be an rfc3339 string.

See the serde module for alternate deserialization formats.

fn deserialize<D>( deserializer: D ) -> Result<DateTime<FixedOffset>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> Deserialize<'de> for DateTime<Local>

Deserialize a value that includes no timezone in its string representation

The value to be deserialized must be an rfc3339 string.

See the serde module for alternate serialization formats.

fn deserialize<D>( deserializer: D ) -> Result<DateTime<Local>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> Deserialize<'de> for DateTime<Utc>

Deserialize into a UTC value

The value to be deserialized must be an rfc3339 string.

See the serde module for alternate deserialization formats.

fn deserialize<D>( deserializer: D ) -> Result<DateTime<Utc>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Tz> Display for DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Display,

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

Formats the value using the given formatter.

impl<Tz> DurationRound for DateTime<Tz>where Tz: TimeZone,

type Err = RoundingError

Error that can occur in rounding or truncating

fn duration_round( self, duration: Duration ) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>

Return a copy rounded by Duration.

fn duration_trunc( self, duration: Duration ) -> Result<DateTime<Tz>, <DateTime<Tz> as DurationRound>::Err>

Return a copy truncated by Duration.

impl From<DateTime<FixedOffset>> for DateTime<Local>

Convert a DateTime<FixedOffset> instance into a DateTime<Local> instance.

fn from(src: DateTime<FixedOffset>) -> DateTime<Local>

Convert this DateTime<FixedOffset> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone. Returns the equivalent value in local time.

impl From<DateTime<FixedOffset>> for DateTime<Utc>

Convert a DateTime<FixedOffset> instance into a DateTime<Utc> instance.

fn from(src: DateTime<FixedOffset>) -> DateTime<Utc>

Convert this DateTime<FixedOffset> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the timezone difference.

impl From<DateTime<Local>> for DateTime<FixedOffset>

Convert a DateTime<Local> instance into a DateTime<FixedOffset> instance.

fn from(src: DateTime<Local>) -> DateTime<FixedOffset>

Convert this DateTime<Local> instance into a DateTime<FixedOffset> instance.

Conversion is performed via DateTime::with_timezone.

impl From<DateTime<Local>> for DateTime<Utc>

Convert a DateTime<Local> instance into a DateTime<Utc> instance.

fn from(src: DateTime<Local>) -> DateTime<Utc>

Convert this DateTime<Local> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

impl From<DateTime<Utc>> for DateTime<FixedOffset>

Convert a DateTime<Utc> instance into a DateTime<FixedOffset> instance.

fn from(src: DateTime<Utc>) -> DateTime<FixedOffset>

Convert this DateTime<Utc> instance into a DateTime<FixedOffset> instance.

Conversion is done via DateTime::with_timezone. Note that the converted value returned by this will be created with a fixed timezone offset of 0.

impl From<DateTime<Utc>> for DateTime<Local>

Convert a DateTime<Utc> instance into a DateTime<Local> instance.

fn from(src: DateTime<Utc>) -> DateTime<Local>

Convert this DateTime<Utc> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

impl From<SystemTime> for DateTime<Local>

fn from(t: SystemTime) -> DateTime<Local>

Converts to this type from the input type.

impl From<SystemTime> for DateTime<Utc>

fn from(t: SystemTime) -> DateTime<Utc>

Converts to this type from the input type.

impl<'a> FromSql<'a> for DateTime<FixedOffset>

fn from_sql(data: &'a ColumnData<'static>) -> Result<Option<Self>>

Returns the value, None being a null value, copying the value.

impl<'a> FromSql<'a> for DateTime<Utc>

fn from_sql(data: &'a ColumnData<'static>) -> Result<Option<Self>>

Returns the value, None being a null value, copying the value.

impl FromSqlOwned for DateTime<FixedOffset>

fn from_sql_owned(data: ColumnData<'static>) -> Result<Option<Self>>

Returns the value, None being a null value, taking the ownership.

impl FromSqlOwned for DateTime<Utc>

fn from_sql_owned(data: ColumnData<'static>) -> Result<Option<Self>>

Returns the value, None being a null value, taking the ownership.

impl FromStr for DateTime<FixedOffset>

Accepts a relaxed form of RFC3339. A space or a ‘T’ are acepted as the separator between the date and time parts. Additional spaces are allowed between each component.

All of these examples are equivalent:

"2012-12-12T12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012-  12-12T12:  12:12Z".parse::<DateTime<FixedOffset>>()?;

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<DateTime<FixedOffset>, ParseError>

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

impl FromStr for DateTime<Local>

Accepts a relaxed form of RFC3339. A space or a ‘T’ are acepted as the separator between the date and time parts.

All of these examples are equivalent:

"2012-12-12T12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Local>>()?;

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<DateTime<Local>, ParseError>

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

impl FromStr for DateTime<Utc>

Accepts a relaxed form of RFC3339. A space or a ‘T’ are acepted as the separator between the date and time parts.

All of these examples are equivalent:

"2012-12-12T12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Utc>>()?;

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<DateTime<Utc>, ParseError>

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

impl<Tz> Hash for DateTime<Tz>where Tz: TimeZone,

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

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<'a> IntoSql<'a> for DateTime<FixedOffset>

fn into_sql(self) -> ColumnData<'a>

Convert to a value understood by the SQL Server. Conversion by-value.

impl<'a> IntoSql<'a> for DateTime<Utc>

fn into_sql(self) -> ColumnData<'a>

Convert to a value understood by the SQL Server. Conversion by-value.

impl<Tz> Ord for DateTime<Tz>where Tz: TimeZone,

fn cmp(&self, other: &DateTime<Tz>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<Tz, Tz2> PartialEq<DateTime<Tz2>> for DateTime<Tz>where Tz: TimeZone, Tz2: TimeZone,

fn eq(&self, other: &DateTime<Tz2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Tz, Tz2> PartialOrd<DateTime<Tz2>> for DateTime<Tz>where Tz: TimeZone, Tz2: TimeZone,

fn partial_cmp(&self, other: &DateTime<Tz2>) -> Option<Ordering>

Compare two DateTimes based on their true time, ignoring time zones

Example

use chrono::prelude::*;

let earlier = Utc.with_ymd_and_hms(2015, 5, 15, 2, 0, 0).unwrap().with_timezone(&FixedOffset::west_opt(1 * 3600).unwrap());
let later   = Utc.with_ymd_and_hms(2015, 5, 15, 3, 0, 0).unwrap().with_timezone(&FixedOffset::west_opt(5 * 3600).unwrap());

assert_eq!(earlier.to_string(), "2015-05-15 01:00:00 -01:00");
assert_eq!(later.to_string(), "2015-05-14 22:00:00 -05:00");

assert!(later > earlier);

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Tz> Serialize for DateTime<Tz>where Tz: TimeZone,

Serialize into a rfc3339 time string

See the serde module for alternate serializations.

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

Serialize this value into the given Serde serializer.

impl<Tz> Sub<Days> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, days: Days) -> <DateTime<Tz> as Sub<Days>>::Output

Performs the - operation.

impl<Tz> Sub<Duration> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> DateTime<Tz>

Performs the - operation.

impl<Tz> Sub<FixedOffset> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, rhs: FixedOffset) -> DateTime<Tz>

Performs the - operation.

impl<Tz> Sub<Months> for DateTime<Tz>where Tz: TimeZone,

type Output = DateTime<Tz>

The resulting type after applying the - operator.

fn sub(self, rhs: Months) -> <DateTime<Tz> as Sub<Months>>::Output

Performs the - operation.

impl<Tz> Sub for DateTime<Tz>where Tz: TimeZone,

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: DateTime<Tz>) -> Duration

Performs the - operation.

impl<Tz> SubAssign<Duration> for DateTime<Tz>where Tz: TimeZone,

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl<Tz> Timelike for DateTime<Tz>where Tz: TimeZone,

fn hour(&self) -> u32

Returns the hour number from 0 to 23.

fn minute(&self) -> u32

Returns the minute number from 0 to 59.

fn second(&self) -> u32

Returns the second number from 0 to 59.

fn nanosecond(&self) -> u32

Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

fn with_hour(&self, hour: u32) -> Option<DateTime<Tz>>

Makes a new value with the hour number changed.

fn with_minute(&self, min: u32) -> Option<DateTime<Tz>>

Makes a new value with the minute number changed.

fn with_second(&self, sec: u32) -> Option<DateTime<Tz>>

Makes a new value with the second number changed.

fn with_nanosecond(&self, nano: u32) -> Option<DateTime<Tz>>

Makes a new value with nanoseconds since the whole non-leap second changed.

fn hour12(&self) -> (bool, u32)

Returns the hour number from 1 to 12 with a boolean flag, which is false for AM and true for PM.

fn num_seconds_from_midnight(&self) -> u32

Returns the number of non-leap seconds past the last midnight.

impl ToSql for DateTime<FixedOffset>

fn to_sql(&self) -> ColumnData<'_>

Convert to a value understood by the SQL Server. Conversion by-reference.

impl ToSql for DateTime<Utc>

fn to_sql(&self) -> ColumnData<'_>

Convert to a value understood by the SQL Server. Conversion by-reference.

impl<Tz> Copy for DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Copy,

impl<Tz> Eq for DateTime<Tz>where Tz: TimeZone,

impl<Tz> Send for DateTime<Tz>where Tz: TimeZone, <Tz as TimeZone>::Offset: Send,