pub struct DateTime { /* private fields */ }
Expand description
ISO 8601 combined date and time without timezone.
§Example
NaiveDateTime
is commonly created from NaiveDate
.
use chrono::{NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(9, 10, 11).unwrap();
You can use typical date-like and time-like methods, provided that relevant traits are in the scope.
use chrono::{Datelike, Timelike, Weekday};
assert_eq!(dt.weekday(), Weekday::Fri);
assert_eq!(dt.num_seconds_from_midnight(), 33011);
Implementations§
source§impl NaiveDateTime
impl NaiveDateTime
sourcepub const MIN: NaiveDateTime = _
pub const MIN: NaiveDateTime = _
The minimum possible NaiveDateTime
.
sourcepub const MAX: NaiveDateTime = _
pub const MAX: NaiveDateTime = _
The maximum possible NaiveDateTime
.
sourcepub const UNIX_EPOCH: NaiveDateTime = _
pub const UNIX_EPOCH: NaiveDateTime = _
The Unix Epoch, 1970-01-01 00:00:00.
sourcepub const fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime
pub const fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime
Makes a new NaiveDateTime
from date and time components.
Equivalent to date.and_time(time)
and many other helper constructors on NaiveDate
.
§Example
use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
let t = NaiveTime::from_hms_milli_opt(12, 34, 56, 789).unwrap();
let dt = NaiveDateTime::new(d, t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);
sourcepub const fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime
👎Deprecated since 0.4.23: use DateTime::from_timestamp
instead
pub const fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime
DateTime::from_timestamp
insteadMakes a new NaiveDateTime
corresponding to a UTC date and time,
from the number of non-leap seconds
since the midnight UTC on January 1, 1970 (aka “UNIX timestamp”)
and the number of nanoseconds since the last whole non-leap second.
For a non-naive version of this function see TimeZone::timestamp
.
The nanosecond part can exceed 1,000,000,000 in order to represent a
leap second, but only when secs % 60 == 59
.
(The true “UNIX timestamp” cannot represent a leap second unambiguously.)
§Panics
Panics if the number of seconds would be out of range for a NaiveDateTime
(more than
ca. 262,000 years away from common era), and panics on an invalid nanosecond (2 seconds or
more).
sourcepub const fn from_timestamp_millis(millis: i64) -> Option<NaiveDateTime>
👎Deprecated since 0.4.35: use DateTime::from_timestamp_millis
instead
pub const fn from_timestamp_millis(millis: i64) -> Option<NaiveDateTime>
DateTime::from_timestamp_millis
insteadCreates a new NaiveDateTime from milliseconds since the UNIX epoch.
The UNIX epoch starts on midnight, January 1, 1970, UTC.
§Errors
Returns None
if the number of milliseconds would be out of range for a NaiveDateTime
(more than ca. 262,000 years away from common era)
sourcepub const fn from_timestamp_micros(micros: i64) -> Option<NaiveDateTime>
👎Deprecated since 0.4.35: use DateTime::from_timestamp_micros
instead
pub const fn from_timestamp_micros(micros: i64) -> Option<NaiveDateTime>
DateTime::from_timestamp_micros
insteadCreates a new NaiveDateTime from microseconds since the UNIX epoch.
The UNIX epoch starts on midnight, January 1, 1970, UTC.
§Errors
Returns None
if the number of microseconds would be out of range for a NaiveDateTime
(more than ca. 262,000 years away from common era)
sourcepub const fn from_timestamp_nanos(nanos: i64) -> Option<NaiveDateTime>
👎Deprecated since 0.4.35: use DateTime::from_timestamp_nanos
instead
pub const fn from_timestamp_nanos(nanos: i64) -> Option<NaiveDateTime>
DateTime::from_timestamp_nanos
insteadCreates a new NaiveDateTime from nanoseconds since the UNIX epoch.
The UNIX epoch starts on midnight, January 1, 1970, UTC.
§Errors
Returns None
if the number of nanoseconds would be out of range for a NaiveDateTime
(more than ca. 262,000 years away from common era)
sourcepub const fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime>
👎Deprecated since 0.4.35: use DateTime::from_timestamp
instead
pub const fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime>
DateTime::from_timestamp
insteadMakes a new NaiveDateTime
corresponding to a UTC date and time,
from the number of non-leap seconds
since the midnight UTC on January 1, 1970 (aka “UNIX timestamp”)
and the number of nanoseconds since the last whole non-leap second.
The nanosecond part can exceed 1,000,000,000 in order to represent a
leap second, but only when secs % 60 == 59
.
(The true “UNIX timestamp” cannot represent a leap second unambiguously.)
§Errors
Returns None
if the number of seconds would be out of range for a NaiveDateTime
(more
than ca. 262,000 years away from common era), and panics on an invalid nanosecond
(2 seconds or more).
sourcepub fn parse_from_str(s: &str, fmt: &str) -> Result<NaiveDateTime, ParseError>
pub fn parse_from_str(s: &str, fmt: &str) -> Result<NaiveDateTime, ParseError>
Parses a string with the specified format string and returns a new NaiveDateTime
.
See the format::strftime
module
on the supported escape sequences.
§Example
use chrono::{NaiveDate, NaiveDateTime};
let parse_from_str = NaiveDateTime::parse_from_str;
assert_eq!(
parse_from_str("2015-09-05 23:56:04", "%Y-%m-%d %H:%M:%S"),
Ok(NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap())
);
assert_eq!(
parse_from_str("5sep2015pm012345.6789", "%d%b%Y%p%I%M%S%.f"),
Ok(NaiveDate::from_ymd_opt(2015, 9, 5)
.unwrap()
.and_hms_micro_opt(13, 23, 45, 678_900)
.unwrap())
);
Offset is ignored for the purpose of parsing.
assert_eq!(
parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
Ok(NaiveDate::from_ymd_opt(2014, 5, 17).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
Leap seconds are correctly handled by
treating any time of the form hh:mm:60
as a leap second.
(This equally applies to the formatting, so the round trip is possible.)
assert_eq!(
parse_from_str("2015-07-01 08:59:60.123", "%Y-%m-%d %H:%M:%S%.f"),
Ok(NaiveDate::from_ymd_opt(2015, 7, 1)
.unwrap()
.and_hms_milli_opt(8, 59, 59, 1_123)
.unwrap())
);
Missing seconds are assumed to be zero, but out-of-bound times or insufficient fields are errors otherwise.
assert_eq!(
parse_from_str("94/9/4 7:15", "%y/%m/%d %H:%M"),
Ok(NaiveDate::from_ymd_opt(1994, 9, 4).unwrap().and_hms_opt(7, 15, 0).unwrap())
);
assert!(parse_from_str("04m33s", "%Mm%Ss").is_err());
assert!(parse_from_str("94/9/4 12", "%y/%m/%d %H").is_err());
assert!(parse_from_str("94/9/4 17:60", "%y/%m/%d %H:%M").is_err());
assert!(parse_from_str("94/9/4 24:00:00", "%y/%m/%d %H:%M:%S").is_err());
All parsed fields should be consistent to each other, otherwise it’s an error.
let fmt = "%Y-%m-%d %H:%M:%S = UNIX timestamp %s";
assert!(parse_from_str("2001-09-09 01:46:39 = UNIX timestamp 999999999", fmt).is_ok());
assert!(parse_from_str("1970-01-01 00:00:00 = UNIX timestamp 1", fmt).is_err());
Years before 1 BCE or after 9999 CE, require an initial sign
let fmt = "%Y-%m-%d %H:%M:%S";
assert!(parse_from_str("10000-09-09 01:46:39", fmt).is_err());
assert!(parse_from_str("+10000-09-09 01:46:39", fmt).is_ok());
sourcepub fn parse_and_remainder<'a>(
s: &'a str,
fmt: &str,
) -> Result<(NaiveDateTime, &'a str), ParseError>
pub fn parse_and_remainder<'a>( s: &'a str, fmt: &str, ) -> Result<(NaiveDateTime, &'a str), ParseError>
Parses a string with the specified format string and returns a new NaiveDateTime
, and a
slice with the remaining portion of the string.
See the format::strftime
module
on the supported escape sequences.
Similar to parse_from_str
.
§Example
let (datetime, remainder) = NaiveDateTime::parse_and_remainder(
"2015-02-18 23:16:09 trailing text",
"%Y-%m-%d %H:%M:%S",
)
.unwrap();
assert_eq!(
datetime,
NaiveDate::from_ymd_opt(2015, 2, 18).unwrap().and_hms_opt(23, 16, 9).unwrap()
);
assert_eq!(remainder, " trailing text");
sourcepub const fn date(&self) -> NaiveDate
pub const fn date(&self) -> NaiveDate
Retrieves a date component.
§Example
use chrono::NaiveDate;
let dt = NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(9, 10, 11).unwrap();
assert_eq!(dt.date(), NaiveDate::from_ymd_opt(2016, 7, 8).unwrap());
sourcepub const fn time(&self) -> NaiveTime
pub const fn time(&self) -> NaiveTime
Retrieves a time component.
§Example
use chrono::{NaiveDate, NaiveTime};
let dt = NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(9, 10, 11).unwrap();
assert_eq!(dt.time(), NaiveTime::from_hms_opt(9, 10, 11).unwrap());
sourcepub const fn timestamp(&self) -> i64
👎Deprecated since 0.4.35: use .and_utc().timestamp()
instead
pub const fn timestamp(&self) -> i64
.and_utc().timestamp()
insteadReturns the number of non-leap seconds since the midnight on January 1, 1970.
Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.
sourcepub const fn timestamp_millis(&self) -> i64
👎Deprecated since 0.4.35: use .and_utc().timestamp_millis()
instead
pub const fn timestamp_millis(&self) -> i64
.and_utc().timestamp_millis()
insteadReturns the number of non-leap milliseconds since midnight on January 1, 1970.
Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.
sourcepub const fn timestamp_micros(&self) -> i64
👎Deprecated since 0.4.35: use .and_utc().timestamp_micros()
instead
pub const fn timestamp_micros(&self) -> i64
.and_utc().timestamp_micros()
insteadReturns the number of non-leap microseconds since midnight on January 1, 1970.
Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.
sourcepub const fn timestamp_nanos(&self) -> i64
👎Deprecated since 0.4.31: use .and_utc().timestamp_nanos_opt()
instead
pub const fn timestamp_nanos(&self) -> i64
.and_utc().timestamp_nanos_opt()
insteadReturns the number of non-leap nanoseconds since midnight on January 1, 1970.
Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.
§Panics
An i64
with nanosecond precision can span a range of ~584 years. This function panics on
an out of range NaiveDateTime
.
The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.
sourcepub const fn timestamp_nanos_opt(&self) -> Option<i64>
👎Deprecated since 0.4.35: use .and_utc().timestamp_nanos_opt()
instead
pub const fn timestamp_nanos_opt(&self) -> Option<i64>
.and_utc().timestamp_nanos_opt()
insteadReturns the number of non-leap nanoseconds since midnight on January 1, 1970.
Note that this does not account for the timezone! The true “UNIX timestamp” would count seconds since the midnight UTC on the epoch.
§Errors
An i64
with nanosecond precision can span a range of ~584 years. This function returns
None
on an out of range NaiveDateTime
.
The dates that can be represented as nanoseconds are between 1677-09-21T00:12:43.145224192 and 2262-04-11T23:47:16.854775807.
sourcepub const fn timestamp_subsec_millis(&self) -> u32
👎Deprecated since 0.4.35: use .and_utc().timestamp_subsec_millis()
instead
pub const fn timestamp_subsec_millis(&self) -> u32
.and_utc().timestamp_subsec_millis()
insteadReturns the number of milliseconds since the last whole non-leap second.
The return value ranges from 0 to 999, or for leap seconds, to 1,999.
sourcepub const fn timestamp_subsec_micros(&self) -> u32
👎Deprecated since 0.4.35: use .and_utc().timestamp_subsec_micros()
instead
pub const fn timestamp_subsec_micros(&self) -> u32
.and_utc().timestamp_subsec_micros()
insteadReturns the number of microseconds since the last whole non-leap second.
The return value ranges from 0 to 999,999, or for leap seconds, to 1,999,999.
sourcepub const fn timestamp_subsec_nanos(&self) -> u32
👎Deprecated since 0.4.36: use .and_utc().timestamp_subsec_nanos()
instead
pub const fn timestamp_subsec_nanos(&self) -> u32
.and_utc().timestamp_subsec_nanos()
insteadReturns the number of nanoseconds since the last whole non-leap second.
The return value ranges from 0 to 999,999,999, or for leap seconds, to 1,999,999,999.
sourcepub const fn checked_add_signed(self, rhs: TimeDelta) -> Option<NaiveDateTime>
pub const fn checked_add_signed(self, rhs: TimeDelta) -> Option<NaiveDateTime>
Adds given TimeDelta
to the current date and time.
As a part of Chrono’s leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
§Errors
Returns None
if the resulting date would be out of range.
§Example
use chrono::{NaiveDate, TimeDelta};
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::zero()), Some(hms(3, 5, 7)));
assert_eq!(
hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(1).unwrap()),
Some(hms(3, 5, 8))
);
assert_eq!(
hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(-1).unwrap()),
Some(hms(3, 5, 6))
);
assert_eq!(
hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(3600 + 60).unwrap()),
Some(hms(4, 6, 7))
);
assert_eq!(
hms(3, 5, 7).checked_add_signed(TimeDelta::try_seconds(86_400).unwrap()),
Some(from_ymd(2016, 7, 9).and_hms_opt(3, 5, 7).unwrap())
);
let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(
hmsm(3, 5, 7, 980).checked_add_signed(TimeDelta::try_milliseconds(450).unwrap()),
Some(hmsm(3, 5, 8, 430))
);
Overflow returns None
.
assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::try_days(1_000_000_000).unwrap()), None);
Leap seconds are handled, but the addition assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap.checked_add_signed(TimeDelta::zero()),
Some(hmsm(3, 5, 59, 1_300)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_milliseconds(-500).unwrap()),
Some(hmsm(3, 5, 59, 800)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_milliseconds(500).unwrap()),
Some(hmsm(3, 5, 59, 1_800)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_milliseconds(800).unwrap()),
Some(hmsm(3, 6, 0, 100)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_seconds(10).unwrap()),
Some(hmsm(3, 6, 9, 300)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_seconds(-10).unwrap()),
Some(hmsm(3, 5, 50, 300)));
assert_eq!(leap.checked_add_signed(TimeDelta::try_days(1).unwrap()),
Some(from_ymd(2016, 7, 9).and_hms_milli_opt(3, 5, 59, 300).unwrap()));
sourcepub const fn checked_add_months(self, rhs: Months) -> Option<NaiveDateTime>
pub const fn checked_add_months(self, rhs: Months) -> Option<NaiveDateTime>
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.
§Errors
Returns None
if the resulting date would be out of range.
§Example
use chrono::{Months, NaiveDate};
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1)
.unwrap()
.and_hms_opt(1, 0, 0)
.unwrap()
.checked_add_months(Months::new(1)),
Some(NaiveDate::from_ymd_opt(2014, 2, 1).unwrap().and_hms_opt(1, 0, 0).unwrap())
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1)
.unwrap()
.and_hms_opt(1, 0, 0)
.unwrap()
.checked_add_months(Months::new(core::i32::MAX as u32 + 1)),
None
);
sourcepub const fn checked_add_offset(self, rhs: FixedOffset) -> Option<NaiveDateTime>
pub const fn checked_add_offset(self, rhs: FixedOffset) -> Option<NaiveDateTime>
Adds given FixedOffset
to the current datetime.
Returns None
if the result would be outside the valid range for NaiveDateTime
.
This method is similar to checked_add_signed
, but preserves
leap seconds.
sourcepub const fn checked_sub_offset(self, rhs: FixedOffset) -> Option<NaiveDateTime>
pub const fn checked_sub_offset(self, rhs: FixedOffset) -> Option<NaiveDateTime>
Subtracts given FixedOffset
from the current datetime.
Returns None
if the result would be outside the valid range for NaiveDateTime
.
This method is similar to checked_sub_signed
, but preserves
leap seconds.
sourcepub const fn checked_sub_signed(self, rhs: TimeDelta) -> Option<NaiveDateTime>
pub const fn checked_sub_signed(self, rhs: TimeDelta) -> Option<NaiveDateTime>
Subtracts given TimeDelta
from the current date and time.
As a part of Chrono’s leap second handling,
the subtraction assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
§Errors
Returns None
if the resulting date would be out of range.
§Example
use chrono::{NaiveDate, TimeDelta};
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::zero()), Some(hms(3, 5, 7)));
assert_eq!(
hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(1).unwrap()),
Some(hms(3, 5, 6))
);
assert_eq!(
hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(-1).unwrap()),
Some(hms(3, 5, 8))
);
assert_eq!(
hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(3600 + 60).unwrap()),
Some(hms(2, 4, 7))
);
assert_eq!(
hms(3, 5, 7).checked_sub_signed(TimeDelta::try_seconds(86_400).unwrap()),
Some(from_ymd(2016, 7, 7).and_hms_opt(3, 5, 7).unwrap())
);
let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(
hmsm(3, 5, 7, 450).checked_sub_signed(TimeDelta::try_milliseconds(670).unwrap()),
Some(hmsm(3, 5, 6, 780))
);
Overflow returns None
.
assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::try_days(1_000_000_000).unwrap()), None);
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap.checked_sub_signed(TimeDelta::zero()),
Some(hmsm(3, 5, 59, 1_300)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_milliseconds(200).unwrap()),
Some(hmsm(3, 5, 59, 1_100)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_milliseconds(500).unwrap()),
Some(hmsm(3, 5, 59, 800)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_seconds(60).unwrap()),
Some(hmsm(3, 5, 0, 300)));
assert_eq!(leap.checked_sub_signed(TimeDelta::try_days(1).unwrap()),
Some(from_ymd(2016, 7, 7).and_hms_milli_opt(3, 6, 0, 300).unwrap()));
sourcepub const fn checked_sub_months(self, rhs: Months) -> Option<NaiveDateTime>
pub const fn checked_sub_months(self, rhs: Months) -> Option<NaiveDateTime>
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.
§Errors
Returns None
if the resulting date would be out of range.
§Example
use chrono::{Months, NaiveDate};
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1)
.unwrap()
.and_hms_opt(1, 0, 0)
.unwrap()
.checked_sub_months(Months::new(1)),
Some(NaiveDate::from_ymd_opt(2013, 12, 1).unwrap().and_hms_opt(1, 0, 0).unwrap())
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1)
.unwrap()
.and_hms_opt(1, 0, 0)
.unwrap()
.checked_sub_months(Months::new(core::i32::MAX as u32 + 1)),
None
);
sourcepub const fn checked_add_days(self, days: Days) -> Option<NaiveDateTime>
pub const fn checked_add_days(self, days: Days) -> Option<NaiveDateTime>
Add a duration in Days
to the date part of the NaiveDateTime
Returns None
if the resulting date would be out of range.
sourcepub const fn checked_sub_days(self, days: Days) -> Option<NaiveDateTime>
pub const fn checked_sub_days(self, days: Days) -> Option<NaiveDateTime>
Subtract a duration in Days
from the date part of the NaiveDateTime
Returns None
if the resulting date would be out of range.
sourcepub const fn signed_duration_since(self, rhs: NaiveDateTime) -> TimeDelta
pub const fn signed_duration_since(self, rhs: NaiveDateTime) -> TimeDelta
Subtracts another NaiveDateTime
from the current date and time.
This does not overflow or underflow at all.
As a part of Chrono’s leap second handling,
the subtraction assumes that there is no leap second ever,
except when any of the NaiveDateTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
§Example
use chrono::{NaiveDate, TimeDelta};
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let d = from_ymd(2016, 7, 8);
assert_eq!(
d.and_hms_opt(3, 5, 7).unwrap().signed_duration_since(d.and_hms_opt(2, 4, 6).unwrap()),
TimeDelta::try_seconds(3600 + 60 + 1).unwrap()
);
// July 8 is 190th day in the year 2016
let d0 = from_ymd(2016, 1, 1);
assert_eq!(
d.and_hms_milli_opt(0, 7, 6, 500)
.unwrap()
.signed_duration_since(d0.and_hms_opt(0, 0, 0).unwrap()),
TimeDelta::try_seconds(189 * 86_400 + 7 * 60 + 6).unwrap()
+ TimeDelta::try_milliseconds(500).unwrap()
);
Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.
let leap = from_ymd(2015, 6, 30).and_hms_milli_opt(23, 59, 59, 1_500).unwrap();
assert_eq!(
leap.signed_duration_since(from_ymd(2015, 6, 30).and_hms_opt(23, 0, 0).unwrap()),
TimeDelta::try_seconds(3600).unwrap() + TimeDelta::try_milliseconds(500).unwrap()
);
assert_eq!(
from_ymd(2015, 7, 1).and_hms_opt(1, 0, 0).unwrap().signed_duration_since(leap),
TimeDelta::try_seconds(3600).unwrap() - TimeDelta::try_milliseconds(500).unwrap()
);
sourcepub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
Formats the combined date and time with the specified formatting items.
Otherwise it is the same as the ordinary format
method.
The Iterator
of items should be Clone
able,
since the resulting DelayedFormat
value may be formatted multiple times.
§Example
use chrono::format::strftime::StrftimeItems;
use chrono::NaiveDate;
let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S");
let dt = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!(dt.format_with_items(fmt.clone()).to_string(), "2015-09-05 23:56:04");
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");
The resulting DelayedFormat
can be formatted directly via the Display
trait.
assert_eq!(format!("{}", dt.format_with_items(fmt)), "2015-09-05 23:56:04");
sourcepub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>
Formats the combined date and time with the specified format string.
See the format::strftime
module
on the supported escape sequences.
This returns a DelayedFormat
,
which gets converted to a string only when actual formatting happens.
You may use the to_string
method to get a String
,
or just feed it into print!
and other formatting macros.
(In this way it avoids the redundant memory allocation.)
A wrong format string does not issue an error immediately.
Rather, converting or formatting the DelayedFormat
fails.
You are recommended to immediately use DelayedFormat
for this reason.
§Example
use chrono::NaiveDate;
let dt = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");
assert_eq!(dt.format("around %l %p on %b %-d").to_string(), "around 11 PM on Sep 5");
The resulting DelayedFormat
can be formatted directly via the Display
trait.
assert_eq!(format!("{}", dt.format("%Y-%m-%d %H:%M:%S")), "2015-09-05 23:56:04");
assert_eq!(format!("{}", dt.format("around %l %p on %b %-d")), "around 11 PM on Sep 5");
sourcepub fn and_local_timezone<Tz>(&self, tz: Tz) -> LocalResult<DateTime<Tz>>where
Tz: TimeZone,
pub fn and_local_timezone<Tz>(&self, tz: Tz) -> LocalResult<DateTime<Tz>>where
Tz: TimeZone,
Converts the NaiveDateTime
into a timezone-aware DateTime<Tz>
with the provided
time zone.
§Example
use chrono::{FixedOffset, NaiveDate};
let hour = 3600;
let tz = FixedOffset::east_opt(5 * hour).unwrap();
let dt = NaiveDate::from_ymd_opt(2015, 9, 5)
.unwrap()
.and_hms_opt(23, 56, 4)
.unwrap()
.and_local_timezone(tz)
.unwrap();
assert_eq!(dt.timezone(), tz);
Trait Implementations§
source§impl Add<Days> for NaiveDateTime
impl Add<Days> for NaiveDateTime
Add Days
to NaiveDateTime
.
§Panics
Panics if the resulting date would be out of range.
Consider using checked_add_days
to get an Option
instead.
source§impl Add<Duration> for NaiveDateTime
impl Add<Duration> for NaiveDateTime
Add std::time::Duration
to NaiveDateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_add_signed
to get an Option
instead.
source§type Output = NaiveDateTime
type Output = NaiveDateTime
+
operator.source§impl Add<FixedOffset> for NaiveDateTime
impl Add<FixedOffset> for NaiveDateTime
Add FixedOffset
to NaiveDateTime
.
§Panics
Panics if the resulting date would be out of range.
Consider using checked_add_offset
to get an Option
instead.
source§type Output = NaiveDateTime
type Output = NaiveDateTime
+
operator.source§fn add(self, rhs: FixedOffset) -> NaiveDateTime
fn add(self, rhs: FixedOffset) -> NaiveDateTime
+
operation. Read moresource§impl Add<Months> for NaiveDateTime
impl Add<Months> for NaiveDateTime
Add Months
to NaiveDateTime
.
The result will be clamped to valid days in the resulting month, see checked_add_months
for
details.
§Panics
Panics if the resulting date would be out of range.
Consider using checked_add_months
to get an Option
instead.
§Example
use chrono::{Months, NaiveDate};
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1).unwrap().and_hms_opt(1, 0, 0).unwrap() + Months::new(1),
NaiveDate::from_ymd_opt(2014, 2, 1).unwrap().and_hms_opt(1, 0, 0).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1).unwrap().and_hms_opt(0, 2, 0).unwrap()
+ Months::new(11),
NaiveDate::from_ymd_opt(2014, 12, 1).unwrap().and_hms_opt(0, 2, 0).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1).unwrap().and_hms_opt(0, 0, 3).unwrap()
+ Months::new(12),
NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().and_hms_opt(0, 0, 3).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 1).unwrap().and_hms_opt(0, 0, 4).unwrap()
+ Months::new(13),
NaiveDate::from_ymd_opt(2015, 2, 1).unwrap().and_hms_opt(0, 0, 4).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 1, 31).unwrap().and_hms_opt(0, 5, 0).unwrap()
+ Months::new(1),
NaiveDate::from_ymd_opt(2014, 2, 28).unwrap().and_hms_opt(0, 5, 0).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2020, 1, 31).unwrap().and_hms_opt(6, 0, 0).unwrap()
+ Months::new(1),
NaiveDate::from_ymd_opt(2020, 2, 29).unwrap().and_hms_opt(6, 0, 0).unwrap()
);
source§impl Add<TimeDelta> for NaiveDateTime
impl Add<TimeDelta> for NaiveDateTime
Add TimeDelta
to NaiveDateTime
.
As a part of Chrono’s leap second handling, the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_add_signed
to get an Option
instead.
§Example
use chrono::{NaiveDate, TimeDelta};
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7) + TimeDelta::zero(), hms(3, 5, 7));
assert_eq!(hms(3, 5, 7) + TimeDelta::try_seconds(1).unwrap(), hms(3, 5, 8));
assert_eq!(hms(3, 5, 7) + TimeDelta::try_seconds(-1).unwrap(), hms(3, 5, 6));
assert_eq!(hms(3, 5, 7) + TimeDelta::try_seconds(3600 + 60).unwrap(), hms(4, 6, 7));
assert_eq!(
hms(3, 5, 7) + TimeDelta::try_seconds(86_400).unwrap(),
from_ymd(2016, 7, 9).and_hms_opt(3, 5, 7).unwrap()
);
assert_eq!(
hms(3, 5, 7) + TimeDelta::try_days(365).unwrap(),
from_ymd(2017, 7, 8).and_hms_opt(3, 5, 7).unwrap()
);
let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(hmsm(3, 5, 7, 980) + TimeDelta::try_milliseconds(450).unwrap(), hmsm(3, 5, 8, 430));
Leap seconds are handled, but the addition assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap + TimeDelta::zero(), hmsm(3, 5, 59, 1_300));
assert_eq!(leap + TimeDelta::try_milliseconds(-500).unwrap(), hmsm(3, 5, 59, 800));
assert_eq!(leap + TimeDelta::try_milliseconds(500).unwrap(), hmsm(3, 5, 59, 1_800));
assert_eq!(leap + TimeDelta::try_milliseconds(800).unwrap(), hmsm(3, 6, 0, 100));
assert_eq!(leap + TimeDelta::try_seconds(10).unwrap(), hmsm(3, 6, 9, 300));
assert_eq!(leap + TimeDelta::try_seconds(-10).unwrap(), hmsm(3, 5, 50, 300));
assert_eq!(leap + TimeDelta::try_days(1).unwrap(),
from_ymd(2016, 7, 9).and_hms_milli_opt(3, 5, 59, 300).unwrap());
source§type Output = NaiveDateTime
type Output = NaiveDateTime
+
operator.source§impl AddAssign<Duration> for NaiveDateTime
impl AddAssign<Duration> for NaiveDateTime
Add-assign std::time::Duration
to NaiveDateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_add_signed
to get an Option
instead.
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl AddAssign<TimeDelta> for NaiveDateTime
impl AddAssign<TimeDelta> for NaiveDateTime
Add-assign TimeDelta
to NaiveDateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_add_signed
to get an Option
instead.
source§fn add_assign(&mut self, rhs: TimeDelta)
fn add_assign(&mut self, rhs: TimeDelta)
+=
operation. Read moresource§impl Clone for NaiveDateTime
impl Clone for NaiveDateTime
source§fn clone(&self) -> NaiveDateTime
fn clone(&self) -> NaiveDateTime
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Datelike for NaiveDateTime
impl Datelike for NaiveDateTime
source§fn year(&self) -> i32
fn year(&self) -> i32
Returns the year number in the calendar date.
See also the NaiveDate::year
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.year(), 2015);
source§fn month(&self) -> u32
fn month(&self) -> u32
Returns the month number starting from 1.
The return value ranges from 1 to 12.
See also the NaiveDate::month
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month(), 9);
source§fn month0(&self) -> u32
fn month0(&self) -> u32
Returns the month number starting from 0.
The return value ranges from 0 to 11.
See also the NaiveDate::month0
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month0(), 8);
source§fn day(&self) -> u32
fn day(&self) -> u32
Returns the day of month starting from 1.
The return value ranges from 1 to 31. (The last day of month differs by months.)
See also the NaiveDate::day
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day(), 25);
source§fn day0(&self) -> u32
fn day0(&self) -> u32
Returns the day of month starting from 0.
The return value ranges from 0 to 30. (The last day of month differs by months.)
See also the NaiveDate::day0
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);
source§fn ordinal(&self) -> u32
fn ordinal(&self) -> u32
Returns the day of year starting from 1.
The return value ranges from 1 to 366. (The last day of year differs by years.)
See also the NaiveDate::ordinal
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
source§fn ordinal0(&self) -> u32
fn ordinal0(&self) -> u32
Returns the day of year starting from 0.
The return value ranges from 0 to 365. (The last day of year differs by years.)
See also the NaiveDate::ordinal0
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);
source§fn weekday(&self) -> Weekday
fn weekday(&self) -> Weekday
Returns the day of week.
See also the NaiveDate::weekday
method.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime, Weekday};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.weekday(), Weekday::Fri);
source§fn with_year(&self, year: i32) -> Option<NaiveDateTime>
fn with_year(&self, year: i32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the year number changed, while keeping the same month and
day.
See also the NaiveDate::with_year
method.
§Errors
Returns None
if:
- The resulting date does not exist (February 29 in a non-leap year).
- The year is out of range for a
NaiveDate
.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_year(2016),
Some(NaiveDate::from_ymd_opt(2016, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(
dt.with_year(-308),
Some(NaiveDate::from_ymd_opt(-308, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
source§fn with_month(&self, month: u32) -> Option<NaiveDateTime>
fn with_month(&self, month: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the month number (starting from 1) changed.
Don’t combine multiple Datelike::with_*
methods. The intermediate value may not exist.
See also the NaiveDate::with_month
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
month(4)
when day of the month is 31). - The value for
month
is invalid.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_month(10),
Some(NaiveDate::from_ymd_opt(2015, 10, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_month(13), None); // No month 13
assert_eq!(dt.with_month(2), None); // No February 30
source§fn with_month0(&self, month0: u32) -> Option<NaiveDateTime>
fn with_month0(&self, month0: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the month number (starting from 0) changed.
See also the NaiveDate::with_month0
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
month0(3)
when day of the month is 31). - The value for
month0
is invalid.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_month0(9),
Some(NaiveDate::from_ymd_opt(2015, 10, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_month0(12), None); // No month 13
assert_eq!(dt.with_month0(1), None); // No February 30
source§fn with_day(&self, day: u32) -> Option<NaiveDateTime>
fn with_day(&self, day: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the day of month (starting from 1) changed.
See also the NaiveDate::with_day
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
day(31)
in April). - The value for
day
is invalid.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_day(30),
Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_day(31), None); // no September 31
source§fn with_day0(&self, day0: u32) -> Option<NaiveDateTime>
fn with_day0(&self, day0: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the day of month (starting from 0) changed.
See also the NaiveDate::with_day0
method.
§Errors
Returns None
if:
- The resulting date does not exist (for example
day(30)
in April). - The value for
day0
is invalid.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_day0(29),
Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_day0(30), None); // no September 31
source§fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime>
fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the day of year (starting from 1) changed.
See also the NaiveDate::with_ordinal
method.
§Errors
Returns None
if:
- The resulting date does not exist (
with_ordinal(366)
in a non-leap year). - The value for
ordinal
is invalid.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_ordinal(60),
Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_ordinal(366), None); // 2015 had only 365 days
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2016, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_ordinal(60),
Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(
dt.with_ordinal(366),
Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
source§fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime>
fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the day of year (starting from 0) changed.
See also the NaiveDate::with_ordinal0
method.
§Errors
Returns None
if:
- The resulting date does not exist (
with_ordinal0(365)
in a non-leap year). - The value for
ordinal0
is invalid.
§Example
use chrono::{Datelike, NaiveDate, NaiveDateTime};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_ordinal0(59),
Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(dt.with_ordinal0(365), None); // 2015 had only 365 days
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2016, 9, 8).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(
dt.with_ordinal0(59),
Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
assert_eq!(
dt.with_ordinal0(365),
Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap().and_hms_opt(12, 34, 56).unwrap())
);
source§fn year_ce(&self) -> (bool, u32)
fn year_ce(&self) -> (bool, u32)
source§fn num_days_from_ce(&self) -> i32
fn num_days_from_ce(&self) -> i32
source§impl Debug for NaiveDateTime
impl Debug for NaiveDateTime
The Debug
output of the naive date and time dt
is the same as
dt.format("%Y-%m-%dT%H:%M:%S%.f")
.
The string printed can be readily parsed via the parse
method on str
.
It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)
§Example
use chrono::NaiveDate;
let dt = NaiveDate::from_ymd_opt(2016, 11, 15).unwrap().and_hms_opt(7, 39, 24).unwrap();
assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");
Leap seconds may also be used.
let dt =
NaiveDate::from_ymd_opt(2015, 6, 30).unwrap().and_hms_milli_opt(23, 59, 59, 1_500).unwrap();
assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");
source§impl<'r> Decode<'r, MySql> for NaiveDateTime
impl<'r> Decode<'r, MySql> for NaiveDateTime
source§fn decode(
value: MySqlValueRef<'r>,
) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>
fn decode( value: MySqlValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>
source§impl<'r> Decode<'r, Postgres> for NaiveDateTime
impl<'r> Decode<'r, Postgres> for NaiveDateTime
source§fn decode(
value: PgValueRef<'r>,
) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>
fn decode( value: PgValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>
source§impl<'r> Decode<'r, Sqlite> for NaiveDateTime
impl<'r> Decode<'r, Sqlite> for NaiveDateTime
source§fn decode(
value: SqliteValueRef<'r>,
) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>
fn decode( value: SqliteValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>
source§impl Default for NaiveDateTime
impl Default for NaiveDateTime
The default value for a NaiveDateTime is one with epoch 0 that is, 1st of January 1970 at 00:00:00.
§Example
use chrono::NaiveDateTime;
assert_eq!(NaiveDateTime::default(), NaiveDateTime::UNIX_EPOCH);
source§fn default() -> NaiveDateTime
fn default() -> NaiveDateTime
source§impl<'de> Deserialize<'de> for NaiveDateTime
impl<'de> Deserialize<'de> for NaiveDateTime
source§fn deserialize<D>(
deserializer: D,
) -> Result<NaiveDateTime, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<NaiveDateTime, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl Display for NaiveDateTime
impl Display for NaiveDateTime
The Display
output of the naive date and time dt
is the same as
dt.format("%Y-%m-%d %H:%M:%S%.f")
.
It should be noted that, for leap seconds not on the minute boundary, it may print a representation not distinguishable from non-leap seconds. This doesn’t matter in practice, since such leap seconds never happened. (By the time of the first leap second on 1972-06-30, every time zone offset around the world has standardized to the 5-minute alignment.)
§Example
use chrono::NaiveDate;
let dt = NaiveDate::from_ymd_opt(2016, 11, 15).unwrap().and_hms_opt(7, 39, 24).unwrap();
assert_eq!(format!("{}", dt), "2016-11-15 07:39:24");
Leap seconds may also be used.
let dt =
NaiveDate::from_ymd_opt(2015, 6, 30).unwrap().and_hms_milli_opt(23, 59, 59, 1_500).unwrap();
assert_eq!(format!("{}", dt), "2015-06-30 23:59:60.500");
source§impl DurationRound for NaiveDateTime
impl DurationRound for NaiveDateTime
source§type Err = RoundingError
type Err = RoundingError
source§fn duration_round(
self,
duration: TimeDelta,
) -> Result<NaiveDateTime, <NaiveDateTime as DurationRound>::Err>
fn duration_round( self, duration: TimeDelta, ) -> Result<NaiveDateTime, <NaiveDateTime as DurationRound>::Err>
source§fn duration_trunc(
self,
duration: TimeDelta,
) -> Result<NaiveDateTime, <NaiveDateTime as DurationRound>::Err>
fn duration_trunc( self, duration: TimeDelta, ) -> Result<NaiveDateTime, <NaiveDateTime as DurationRound>::Err>
source§impl Encode<'_, MySql> for NaiveDateTime
impl Encode<'_, MySql> for NaiveDateTime
source§fn encode_by_ref(
&self,
buf: &mut Vec<u8>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn encode_by_ref( &self, buf: &mut Vec<u8>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn size_hint(&self) -> usize
source§fn encode(
self,
buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>where
Self: Sized,
fn encode(
self,
buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>where
Self: Sized,
self
into buf
in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
source§impl Encode<'_, Postgres> for NaiveDateTime
impl Encode<'_, Postgres> for NaiveDateTime
source§fn encode_by_ref(
&self,
buf: &mut PgArgumentBuffer,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn encode_by_ref( &self, buf: &mut PgArgumentBuffer, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn size_hint(&self) -> usize
source§fn encode(
self,
buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>where
Self: Sized,
fn encode(
self,
buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>where
Self: Sized,
self
into buf
in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
source§impl Encode<'_, Sqlite> for NaiveDateTime
impl Encode<'_, Sqlite> for NaiveDateTime
source§fn encode_by_ref(
&self,
buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>
source§fn encode(
self,
buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>where
Self: Sized,
fn encode(
self,
buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Send + Sync>>where
Self: Sized,
self
into buf
in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
source§impl From<NaiveDate> for NaiveDateTime
impl From<NaiveDate> for NaiveDateTime
source§fn from(date: NaiveDate) -> NaiveDateTime
fn from(date: NaiveDate) -> NaiveDateTime
Converts a NaiveDate
to a NaiveDateTime
of the same date but at midnight.
§Example
use chrono::{NaiveDate, NaiveDateTime};
let nd = NaiveDate::from_ymd_opt(2016, 5, 28).unwrap();
let ndt = NaiveDate::from_ymd_opt(2016, 5, 28).unwrap().and_hms_opt(0, 0, 0).unwrap();
assert_eq!(ndt, NaiveDateTime::from(nd));
source§impl From<NaiveDateTime> for NaiveDate
impl From<NaiveDateTime> for NaiveDate
source§fn from(naive_datetime: NaiveDateTime) -> NaiveDate
fn from(naive_datetime: NaiveDateTime) -> NaiveDate
source§impl From<NaiveDateTime> for Value
impl From<NaiveDateTime> for Value
source§fn from(x: NaiveDateTime) -> Value
fn from(x: NaiveDateTime) -> Value
source§impl FromStr for NaiveDateTime
impl FromStr for NaiveDateTime
Parsing a str
into a NaiveDateTime
uses the same format,
%Y-%m-%dT%H:%M:%S%.f
, as in Debug
.
§Example
use chrono::{NaiveDateTime, NaiveDate};
let dt = NaiveDate::from_ymd_opt(2015, 9, 18).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt));
let dt = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap().and_hms_milli_opt(7, 59, 59, 1_500).unwrap(); // leap second
assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt));
assert!("foo".parse::<NaiveDateTime>().is_err());
source§type Err = ParseError
type Err = ParseError
source§fn from_str(s: &str) -> Result<NaiveDateTime, ParseError>
fn from_str(s: &str) -> Result<NaiveDateTime, ParseError>
s
to return a value of this type. Read moresource§impl Hash for NaiveDateTime
impl Hash for NaiveDateTime
source§impl IntoActiveValue<NaiveDateTime> for DateTime
impl IntoActiveValue<NaiveDateTime> for DateTime
source§fn into_active_value(self) -> ActiveValue<DateTime>
fn into_active_value(self) -> ActiveValue<DateTime>
source§impl Ord for NaiveDateTime
impl Ord for NaiveDateTime
source§fn cmp(&self, other: &NaiveDateTime) -> Ordering
fn cmp(&self, other: &NaiveDateTime) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl PartialEq for NaiveDateTime
impl PartialEq for NaiveDateTime
source§impl PartialOrd for NaiveDateTime
impl PartialOrd for NaiveDateTime
source§impl PgHasArrayType for NaiveDateTime
impl PgHasArrayType for NaiveDateTime
fn array_type_info() -> PgTypeInfo
fn array_compatible(ty: &PgTypeInfo) -> bool
source§impl Serialize for NaiveDateTime
impl Serialize for NaiveDateTime
Serialize a NaiveDateTime
as an ISO 8601 string
See the naive::serde
module for alternate serialization formats.
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
source§impl Sub<Days> for NaiveDateTime
impl Sub<Days> for NaiveDateTime
Subtract Days
from NaiveDateTime
.
§Panics
Panics if the resulting date would be out of range.
Consider using checked_sub_days
to get an Option
instead.
source§impl Sub<Duration> for NaiveDateTime
impl Sub<Duration> for NaiveDateTime
Subtract std::time::Duration
from NaiveDateTime
.
As a part of Chrono’s [leap second handling] the subtraction assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_sub_signed
to get an Option
instead.
source§type Output = NaiveDateTime
type Output = NaiveDateTime
-
operator.source§impl Sub<FixedOffset> for NaiveDateTime
impl Sub<FixedOffset> for NaiveDateTime
Subtract FixedOffset
from NaiveDateTime
.
§Panics
Panics if the resulting date would be out of range.
Consider using checked_sub_offset
to get an Option
instead.
source§type Output = NaiveDateTime
type Output = NaiveDateTime
-
operator.source§fn sub(self, rhs: FixedOffset) -> NaiveDateTime
fn sub(self, rhs: FixedOffset) -> NaiveDateTime
-
operation. Read moresource§impl Sub<Months> for NaiveDateTime
impl Sub<Months> for NaiveDateTime
Subtract Months
from NaiveDateTime
.
The result will be clamped to valid days in the resulting month, see
NaiveDateTime::checked_sub_months
for details.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_sub_months
to get an Option
instead.
§Example
use chrono::{Months, NaiveDate};
assert_eq!(
NaiveDate::from_ymd_opt(2014, 01, 01).unwrap().and_hms_opt(01, 00, 00).unwrap()
- Months::new(11),
NaiveDate::from_ymd_opt(2013, 02, 01).unwrap().and_hms_opt(01, 00, 00).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 01, 01).unwrap().and_hms_opt(00, 02, 00).unwrap()
- Months::new(12),
NaiveDate::from_ymd_opt(2013, 01, 01).unwrap().and_hms_opt(00, 02, 00).unwrap()
);
assert_eq!(
NaiveDate::from_ymd_opt(2014, 01, 01).unwrap().and_hms_opt(00, 00, 03).unwrap()
- Months::new(13),
NaiveDate::from_ymd_opt(2012, 12, 01).unwrap().and_hms_opt(00, 00, 03).unwrap()
);
source§impl Sub<TimeDelta> for NaiveDateTime
impl Sub<TimeDelta> for NaiveDateTime
Subtract TimeDelta
from NaiveDateTime
.
This is the same as the addition with a negated TimeDelta
.
As a part of Chrono’s leap second handling the subtraction assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_sub_signed
to get an Option
instead.
§Example
use chrono::{NaiveDate, TimeDelta};
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms_opt(h, m, s).unwrap();
assert_eq!(hms(3, 5, 7) - TimeDelta::zero(), hms(3, 5, 7));
assert_eq!(hms(3, 5, 7) - TimeDelta::try_seconds(1).unwrap(), hms(3, 5, 6));
assert_eq!(hms(3, 5, 7) - TimeDelta::try_seconds(-1).unwrap(), hms(3, 5, 8));
assert_eq!(hms(3, 5, 7) - TimeDelta::try_seconds(3600 + 60).unwrap(), hms(2, 4, 7));
assert_eq!(
hms(3, 5, 7) - TimeDelta::try_seconds(86_400).unwrap(),
from_ymd(2016, 7, 7).and_hms_opt(3, 5, 7).unwrap()
);
assert_eq!(
hms(3, 5, 7) - TimeDelta::try_days(365).unwrap(),
from_ymd(2015, 7, 9).and_hms_opt(3, 5, 7).unwrap()
);
let hmsm = |h, m, s, milli| d.and_hms_milli_opt(h, m, s, milli).unwrap();
assert_eq!(hmsm(3, 5, 7, 450) - TimeDelta::try_milliseconds(670).unwrap(), hmsm(3, 5, 6, 780));
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap - TimeDelta::zero(), hmsm(3, 5, 59, 1_300));
assert_eq!(leap - TimeDelta::try_milliseconds(200).unwrap(), hmsm(3, 5, 59, 1_100));
assert_eq!(leap - TimeDelta::try_milliseconds(500).unwrap(), hmsm(3, 5, 59, 800));
assert_eq!(leap - TimeDelta::try_seconds(60).unwrap(), hmsm(3, 5, 0, 300));
assert_eq!(leap - TimeDelta::try_days(1).unwrap(),
from_ymd(2016, 7, 7).and_hms_milli_opt(3, 6, 0, 300).unwrap());
source§type Output = NaiveDateTime
type Output = NaiveDateTime
-
operator.source§impl Sub for NaiveDateTime
impl Sub for NaiveDateTime
Subtracts another NaiveDateTime
from the current date and time.
This does not overflow or underflow at all.
As a part of Chrono’s leap second handling,
the subtraction assumes that there is no leap second ever,
except when any of the NaiveDateTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around NaiveDateTime::signed_duration_since
.
§Example
use chrono::{NaiveDate, TimeDelta};
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
let d = from_ymd(2016, 7, 8);
assert_eq!(
d.and_hms_opt(3, 5, 7).unwrap() - d.and_hms_opt(2, 4, 6).unwrap(),
TimeDelta::try_seconds(3600 + 60 + 1).unwrap()
);
// July 8 is 190th day in the year 2016
let d0 = from_ymd(2016, 1, 1);
assert_eq!(
d.and_hms_milli_opt(0, 7, 6, 500).unwrap() - d0.and_hms_opt(0, 0, 0).unwrap(),
TimeDelta::try_seconds(189 * 86_400 + 7 * 60 + 6).unwrap()
+ TimeDelta::try_milliseconds(500).unwrap()
);
Leap seconds are handled, but the subtraction assumes that no other leap seconds happened.
let leap = from_ymd(2015, 6, 30).and_hms_milli_opt(23, 59, 59, 1_500).unwrap();
assert_eq!(
leap - from_ymd(2015, 6, 30).and_hms_opt(23, 0, 0).unwrap(),
TimeDelta::try_seconds(3600).unwrap() + TimeDelta::try_milliseconds(500).unwrap()
);
assert_eq!(
from_ymd(2015, 7, 1).and_hms_opt(1, 0, 0).unwrap() - leap,
TimeDelta::try_seconds(3600).unwrap() - TimeDelta::try_milliseconds(500).unwrap()
);
source§impl SubAssign<Duration> for NaiveDateTime
impl SubAssign<Duration> for NaiveDateTime
Subtract-assign std::time::Duration
from NaiveDateTime
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_sub_signed
to get an Option
instead.
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl SubAssign<TimeDelta> for NaiveDateTime
impl SubAssign<TimeDelta> for NaiveDateTime
Subtract-assign TimeDelta
from NaiveDateTime
.
This is the same as the addition with a negated TimeDelta
.
As a part of Chrono’s [leap second handling], the addition assumes that there is no leap
second ever, except when the NaiveDateTime
itself represents a leap second in which case
the assumption becomes that there is exactly a single leap second ever.
§Panics
Panics if the resulting date would be out of range.
Consider using NaiveDateTime::checked_sub_signed
to get an Option
instead.
source§fn sub_assign(&mut self, rhs: TimeDelta)
fn sub_assign(&mut self, rhs: TimeDelta)
-=
operation. Read moresource§impl Timelike for NaiveDateTime
impl Timelike for NaiveDateTime
source§fn hour(&self) -> u32
fn hour(&self) -> u32
Returns the hour number from 0 to 23.
See also the NaiveTime::hour
method.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.hour(), 12);
source§fn minute(&self) -> u32
fn minute(&self) -> u32
Returns the minute number from 0 to 59.
See also the NaiveTime::minute
method.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.minute(), 34);
source§fn second(&self) -> u32
fn second(&self) -> u32
Returns the second number from 0 to 59.
See also the NaiveTime::second
method.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.second(), 56);
source§fn nanosecond(&self) -> u32
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.
See also the NaiveTime
method.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.nanosecond(), 789_000_000);
source§fn with_hour(&self, hour: u32) -> Option<NaiveDateTime>
fn with_hour(&self, hour: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the hour number changed.
See also the NaiveTime::with_hour
method.
§Errors
Returns None
if the value for hour
is invalid.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(
dt.with_hour(7),
Some(
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(7, 34, 56, 789).unwrap()
)
);
assert_eq!(dt.with_hour(24), None);
source§fn with_minute(&self, min: u32) -> Option<NaiveDateTime>
fn with_minute(&self, min: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the minute number changed.
See also the NaiveTime::with_minute
method.
§Errors
Returns None
if the value for minute
is invalid.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(
dt.with_minute(45),
Some(
NaiveDate::from_ymd_opt(2015, 9, 8)
.unwrap()
.and_hms_milli_opt(12, 45, 56, 789)
.unwrap()
)
);
assert_eq!(dt.with_minute(60), None);
source§fn with_second(&self, sec: u32) -> Option<NaiveDateTime>
fn with_second(&self, sec: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with the second number changed.
As with the second
method,
the input range is restricted to 0 through 59.
See also the NaiveTime::with_second
method.
§Errors
Returns None
if the value for second
is invalid.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(
dt.with_second(17),
Some(
NaiveDate::from_ymd_opt(2015, 9, 8)
.unwrap()
.and_hms_milli_opt(12, 34, 17, 789)
.unwrap()
)
);
assert_eq!(dt.with_second(60), None);
source§fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime>
fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime>
Makes a new NaiveDateTime
with nanoseconds since the whole non-leap second changed.
Returns None
when the resulting NaiveDateTime
would be invalid.
As with the NaiveDateTime::nanosecond
method,
the input range can exceed 1,000,000,000 for leap seconds.
See also the NaiveTime::with_nanosecond
method.
§Errors
Returns None
if nanosecond >= 2,000,000,000
.
§Example
use chrono::{NaiveDate, NaiveDateTime, Timelike};
let dt: NaiveDateTime =
NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 59, 789).unwrap();
assert_eq!(
dt.with_nanosecond(333_333_333),
Some(
NaiveDate::from_ymd_opt(2015, 9, 8)
.unwrap()
.and_hms_nano_opt(12, 34, 59, 333_333_333)
.unwrap()
)
);
assert_eq!(
dt.with_nanosecond(1_333_333_333), // leap second
Some(
NaiveDate::from_ymd_opt(2015, 9, 8)
.unwrap()
.and_hms_nano_opt(12, 34, 59, 1_333_333_333)
.unwrap()
)
);
assert_eq!(dt.with_nanosecond(2_000_000_000), None);
source§fn hour12(&self) -> (bool, u32)
fn hour12(&self) -> (bool, u32)
source§fn num_seconds_from_midnight(&self) -> u32
fn num_seconds_from_midnight(&self) -> u32
source§impl TryFromU64 for NaiveDateTime
impl TryFromU64 for NaiveDateTime
source§impl TryGetable for NaiveDateTime
impl TryGetable for NaiveDateTime
source§fn try_get_by<I: ColIdx>(res: &QueryResult, idx: I) -> Result<Self, TryGetError>
fn try_get_by<I: ColIdx>(res: &QueryResult, idx: I) -> Result<Self, TryGetError>
source§fn try_get(res: &QueryResult, pre: &str, col: &str) -> Result<Self, TryGetError>
fn try_get(res: &QueryResult, pre: &str, col: &str) -> Result<Self, TryGetError>
source§fn try_get_by_index(
res: &QueryResult,
index: usize,
) -> Result<Self, TryGetError>
fn try_get_by_index( res: &QueryResult, index: usize, ) -> Result<Self, TryGetError>
source§impl Type<MySql> for NaiveDateTime
impl Type<MySql> for NaiveDateTime
source§impl Type<Postgres> for NaiveDateTime
impl Type<Postgres> for NaiveDateTime
source§impl Type<Sqlite> for NaiveDateTime
impl Type<Sqlite> for NaiveDateTime
source§fn type_info() -> SqliteTypeInfo
fn type_info() -> SqliteTypeInfo
source§fn compatible(ty: &SqliteTypeInfo) -> bool
fn compatible(ty: &SqliteTypeInfo) -> bool
source§impl ValueType for NaiveDateTime
impl ValueType for NaiveDateTime
impl Copy for NaiveDateTime
impl Eq for NaiveDateTime
impl NotU8 for NaiveDateTime
impl StructuralPartialEq for NaiveDateTime
Auto Trait Implementations§
impl Freeze for NaiveDateTime
impl RefUnwindSafe for NaiveDateTime
impl Send for NaiveDateTime
impl Sync for NaiveDateTime
impl Unpin for NaiveDateTime
impl UnwindSafe for NaiveDateTime
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<T> ExprTrait for Twhere
T: Into<SimpleExpr>,
impl<T> ExprTrait for Twhere
T: Into<SimpleExpr>,
source§fn as_enum<N>(self, type_name: N) -> SimpleExprwhere
N: IntoIden,
fn as_enum<N>(self, type_name: N) -> SimpleExprwhere
N: IntoIden,
AS enum
expression. Read moresource§fn binary<O, R>(self, op: O, right: R) -> SimpleExpr
fn binary<O, R>(self, op: O, right: R) -> SimpleExpr
source§fn cast_as<N>(self, type_name: N) -> SimpleExprwhere
N: IntoIden,
fn cast_as<N>(self, type_name: N) -> SimpleExprwhere
N: IntoIden,
CAST AS
expression. Read moresource§fn unary(self, op: UnOper) -> SimpleExpr
fn unary(self, op: UnOper) -> SimpleExpr
source§fn add<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn add<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn and<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§fn between<A, B>(self, a: A, b: B) -> SimpleExpr
fn between<A, B>(self, a: A, b: B) -> SimpleExpr
BETWEEN
expression. Read moresource§fn div<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn div<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§fn eq<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn eq<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
=
) expression. Read moresource§fn equals<C>(self, col: C) -> SimpleExprwhere
C: IntoColumnRef,
fn equals<C>(self, col: C) -> SimpleExprwhere
C: IntoColumnRef,
source§fn gt<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn gt<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
>
) expression. Read moresource§fn gte<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn gte<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
>=
) expression. Read moresource§fn in_subquery(self, sel: SelectStatement) -> SimpleExpr
fn in_subquery(self, sel: SelectStatement) -> SimpleExpr
IN
sub-query expression. Read moresource§fn in_tuples<V, I>(self, v: I) -> SimpleExprwhere
V: IntoValueTuple,
I: IntoIterator<Item = V>,
fn in_tuples<V, I>(self, v: I) -> SimpleExprwhere
V: IntoValueTuple,
I: IntoIterator<Item = V>,
IN
sub expression. Read moresource§fn is<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn is<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
IS
expression. Read moresource§fn is_in<V, I>(self, v: I) -> SimpleExpr
fn is_in<V, I>(self, v: I) -> SimpleExpr
IN
expression. Read moresource§fn is_not<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn is_not<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
IS NOT
expression. Read moresource§fn is_not_in<V, I>(self, v: I) -> SimpleExpr
fn is_not_in<V, I>(self, v: I) -> SimpleExpr
NOT IN
expression. Read moresource§fn is_not_null(self) -> SimpleExpr
fn is_not_null(self) -> SimpleExpr
IS NOT NULL
expression. Read moresource§fn is_null(self) -> SimpleExpr
fn is_null(self) -> SimpleExpr
IS NULL
expression. Read moresource§fn left_shift<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn left_shift<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§fn like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
fn like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
LIKE
expression. Read moresource§fn lt<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn lt<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
<
) expression. Read moresource§fn lte<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn lte<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
<=
) expression. Read moresource§fn modulo<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn modulo<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§fn mul<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn mul<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§fn ne<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn ne<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
<>
) expression. Read moresource§fn not(self) -> SimpleExpr
fn not(self) -> SimpleExpr
NOT
. Read moresource§fn not_between<A, B>(self, a: A, b: B) -> SimpleExpr
fn not_between<A, B>(self, a: A, b: B) -> SimpleExpr
NOT BETWEEN
expression. Read moresource§fn not_equals<C>(self, col: C) -> SimpleExprwhere
C: IntoColumnRef,
fn not_equals<C>(self, col: C) -> SimpleExprwhere
C: IntoColumnRef,
source§fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr
fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr
NOT IN
sub-query expression. Read moresource§fn not_like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
fn not_like<L>(self, like: L) -> SimpleExprwhere
L: IntoLikeExpr,
NOT LIKE
expression. Read moresource§fn or<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn or<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
OR
operation. Read moresource§fn right_shift<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn right_shift<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§fn sub<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
fn sub<R>(self, right: R) -> SimpleExprwhere
R: Into<SimpleExpr>,
source§impl<V> FromValueTuple for V
impl<V> FromValueTuple for V
fn from_value_tuple<I>(i: I) -> Vwhere
I: IntoValueTuple,
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more