sea_orm::entity::prelude

Struct DateTime

source
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

source

pub const MIN: NaiveDateTime = _

The minimum possible NaiveDateTime.

source

pub const MAX: NaiveDateTime = _

The maximum possible NaiveDateTime.

source

pub const UNIX_EPOCH: NaiveDateTime = _

The Unix Epoch, 1970-01-01 00:00:00.

source

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);
source

pub const fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime

👎Deprecated since 0.4.23: use DateTime::from_timestamp instead

Makes 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).

source

pub const fn from_timestamp_millis(millis: i64) -> Option<NaiveDateTime>

👎Deprecated since 0.4.35: use DateTime::from_timestamp_millis instead

Creates 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)

source

pub const fn from_timestamp_micros(micros: i64) -> Option<NaiveDateTime>

👎Deprecated since 0.4.35: use DateTime::from_timestamp_micros instead

Creates 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)

source

pub const fn from_timestamp_nanos(nanos: i64) -> Option<NaiveDateTime>

👎Deprecated since 0.4.35: use DateTime::from_timestamp_nanos instead

Creates 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)

source

pub const fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime>

👎Deprecated since 0.4.35: use DateTime::from_timestamp instead

Makes 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).

source

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());
source

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");
source

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());
source

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());
source

pub const fn timestamp(&self) -> i64

👎Deprecated since 0.4.35: use .and_utc().timestamp() instead

Returns 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.

source

pub const fn timestamp_millis(&self) -> i64

👎Deprecated since 0.4.35: use .and_utc().timestamp_millis() instead

Returns 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.

source

pub const fn timestamp_micros(&self) -> i64

👎Deprecated since 0.4.35: use .and_utc().timestamp_micros() instead

Returns 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.

source

pub const fn timestamp_nanos(&self) -> i64

👎Deprecated since 0.4.31: use .and_utc().timestamp_nanos_opt() instead

Returns 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.

source

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

👎Deprecated since 0.4.35: use .and_utc().timestamp_nanos_opt() instead

Returns 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.

source

pub const fn timestamp_subsec_millis(&self) -> u32

👎Deprecated since 0.4.35: use .and_utc().timestamp_subsec_millis() instead

Returns 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.

source

pub const fn timestamp_subsec_micros(&self) -> u32

👎Deprecated since 0.4.35: use .and_utc().timestamp_subsec_micros() instead

Returns 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.

source

pub const fn timestamp_subsec_nanos(&self) -> u32

👎Deprecated since 0.4.36: use .and_utc().timestamp_subsec_nanos() instead

Returns 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.

source

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()));
source

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
);
source

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.

source

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.

source

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()));
source

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
);
source

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.

source

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.

source

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 NaiveDateTimes 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()
);
source

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. Otherwise it is the same as the ordinary format method.

The Iterator of items should be Cloneable, 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");
source

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");
source

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);
source

pub const fn and_utc(&self) -> DateTime<Utc>

Converts the NaiveDateTime into the timezone-aware DateTime<Utc>.

§Example
use chrono::{NaiveDate, Utc};
let dt =
    NaiveDate::from_ymd_opt(2023, 1, 30).unwrap().and_hms_opt(19, 32, 33).unwrap().and_utc();
assert_eq!(dt.timezone(), Utc);

Trait Implementations§

source§

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§

type Output = NaiveDateTime

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

The resulting type after applying the + operator.
source§

fn add(self, rhs: Duration) -> NaiveDateTime

Performs the + operation. Read more
source§

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

The resulting type after applying the + operator.
source§

fn add(self, rhs: FixedOffset) -> NaiveDateTime

Performs the + operation. Read more
source§

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§

type Output = NaiveDateTime

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

The resulting type after applying the + operator.
source§

fn add(self, rhs: TimeDelta) -> NaiveDateTime

Performs the + operation. Read more
source§

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)

Performs the += operation. Read more
source§

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)

Performs the += operation. Read more
source§

impl Clone for NaiveDateTime

source§

fn clone(&self) -> NaiveDateTime

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Datelike for NaiveDateTime

source§

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

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

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

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

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

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

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

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>

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>

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>

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>

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>

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>

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>

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 iso_week(&self) -> IsoWeek

Returns the ISO week.
source§

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).
source§

fn num_days_from_ce(&self) -> i32

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

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§

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

Formats the value using the given formatter. Read more
source§

impl<'r> Decode<'r, MySql> for NaiveDateTime

source§

fn decode( value: MySqlValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>

Decode a new value of this type using a raw value from the database.
source§

impl<'r> Decode<'r, Postgres> for NaiveDateTime

source§

fn decode( value: PgValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>

Decode a new value of this type using a raw value from the database.
source§

impl<'r> Decode<'r, Sqlite> for NaiveDateTime

source§

fn decode( value: SqliteValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Send + Sync>>

Decode a new value of this type using a raw value from the database.
source§

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

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for NaiveDateTime

source§

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

Deserialize this value from the given Serde deserializer. Read more
source§

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§

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

Formats the value using the given formatter. Read more
source§

impl DurationRound for NaiveDateTime

source§

type Err = RoundingError

Error that can occur in rounding or truncating
source§

fn duration_round( self, duration: TimeDelta, ) -> Result<NaiveDateTime, <NaiveDateTime as DurationRound>::Err>

Return a copy rounded by TimeDelta. Read more
source§

fn duration_trunc( self, duration: TimeDelta, ) -> Result<NaiveDateTime, <NaiveDateTime as DurationRound>::Err>

Return a copy truncated by TimeDelta. Read more
source§

impl Encode<'_, MySql> for NaiveDateTime

source§

fn encode_by_ref( &self, buf: &mut Vec<u8>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>

Writes the value of self into buf without moving self. Read more
source§

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,

Writes the value of self into buf in the expected format for the database.
source§

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

source§

impl Encode<'_, Postgres> for NaiveDateTime

source§

fn encode_by_ref( &self, buf: &mut PgArgumentBuffer, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>

Writes the value of self into buf without moving self. Read more
source§

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,

Writes the value of self into buf in the expected format for the database.
source§

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

source§

impl Encode<'_, Sqlite> for NaiveDateTime

source§

fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>

Writes the value of self into buf without moving self. Read more
source§

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>
where Self: Sized,

Writes the value of self into buf in the expected format for the database.
source§

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

source§

fn size_hint(&self) -> usize

source§

impl From<NaiveDate> for NaiveDateTime

source§

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

source§

fn from(naive_datetime: NaiveDateTime) -> NaiveDate

Converts to this type from the input type.
source§

impl From<NaiveDateTime> for Value

source§

fn from(x: NaiveDateTime) -> Value

Converts to this type from the input type.
source§

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

The associated error which can be returned from parsing.
source§

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

Parses a string s to return a value of this type. Read more
source§

impl Hash for NaiveDateTime

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl IntoActiveValue<NaiveDateTime> for DateTime

source§

fn into_active_value(self) -> ActiveValue<DateTime>

Method to perform the conversion
source§

impl Nullable for NaiveDateTime

source§

impl Ord for NaiveDateTime

source§

fn cmp(&self, other: &NaiveDateTime) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

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

Compares and returns the maximum of two values. Read more
1.21.0 · source§

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

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
source§

impl PartialEq for NaiveDateTime

source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd for NaiveDateTime

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl PgHasArrayType for NaiveDateTime

source§

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,

Serialize this value into the given Serde serializer. Read more
source§

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§

type Output = NaiveDateTime

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Duration) -> NaiveDateTime

Performs the - operation. Read more
source§

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

The resulting type after applying the - operator.
source§

fn sub(self, rhs: FixedOffset) -> NaiveDateTime

Performs the - operation. Read more
source§

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§

type Output = NaiveDateTime

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

The resulting type after applying the - operator.
source§

fn sub(self, rhs: TimeDelta) -> NaiveDateTime

Performs the - operation. Read more
source§

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 NaiveDateTimes 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§

type Output = TimeDelta

The resulting type after applying the - operator.
source§

fn sub(self, rhs: NaiveDateTime) -> TimeDelta

Performs the - operation. Read more
source§

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)

Performs the -= operation. Read more
source§

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)

Performs the -= operation. Read more
source§

impl Timelike for NaiveDateTime

source§

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

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

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

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>

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>

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>

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>

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)

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

fn num_seconds_from_midnight(&self) -> u32

Returns the number of non-leap seconds past the last midnight. Read more
source§

impl TryFromU64 for NaiveDateTime

source§

fn try_from_u64(_: u64) -> Result<Self, DbErr>

The method to convert the type to a u64
source§

impl TryGetable for NaiveDateTime

source§

fn try_get_by<I: ColIdx>(res: &QueryResult, idx: I) -> Result<Self, TryGetError>

Get a value from the query result with an ColIdx
source§

fn try_get(res: &QueryResult, pre: &str, col: &str) -> Result<Self, TryGetError>

Get a value from the query result with prefixed column name
source§

fn try_get_by_index( res: &QueryResult, index: usize, ) -> Result<Self, TryGetError>

Get a value from the query result based on the order in the select expressions
source§

impl Type<MySql> for NaiveDateTime

source§

fn type_info() -> MySqlTypeInfo

Returns the canonical SQL type for this Rust type. Read more
source§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
source§

impl Type<Postgres> for NaiveDateTime

source§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
source§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
source§

impl Type<Sqlite> for NaiveDateTime

source§

fn type_info() -> SqliteTypeInfo

Returns the canonical SQL type for this Rust type. Read more
source§

fn compatible(ty: &SqliteTypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
source§

impl ValueType for NaiveDateTime

source§

impl Copy for NaiveDateTime

source§

impl Eq for NaiveDateTime

source§

impl NotU8 for NaiveDateTime

source§

impl StructuralPartialEq for NaiveDateTime

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn compare(&self, key: &K) -> Ordering

Compare self to key and return their ordering.
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<T> ExprTrait for T
where T: Into<SimpleExpr>,

source§

fn as_enum<N>(self, type_name: N) -> SimpleExpr
where N: IntoIden,

Express a AS enum expression. Read more
source§

fn binary<O, R>(self, op: O, right: R) -> SimpleExpr
where O: Into<BinOper>, R: Into<SimpleExpr>,

Create any binary operation Read more
source§

fn cast_as<N>(self, type_name: N) -> SimpleExpr
where N: IntoIden,

Express a CAST AS expression. Read more
source§

fn unary(self, op: UnOper) -> SimpleExpr

Apply any unary operator to the expression. Read more
source§

fn add<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express an arithmetic addition operation. Read more
source§

fn and<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

source§

fn between<A, B>(self, a: A, b: B) -> SimpleExpr
where A: Into<SimpleExpr>, B: Into<SimpleExpr>,

Express a BETWEEN expression. Read more
source§

fn div<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express an arithmetic division operation. Read more
source§

fn eq<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express an equal (=) expression. Read more
source§

fn equals<C>(self, col: C) -> SimpleExpr
where C: IntoColumnRef,

Express a equal expression between two table columns, you will mainly use this to relate identical value between two table columns. Read more
source§

fn gt<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a greater than (>) expression. Read more
source§

fn gte<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a greater than or equal (>=) expression. Read more
source§

fn in_subquery(self, sel: SelectStatement) -> SimpleExpr

Express a IN sub-query expression. Read more
source§

fn in_tuples<V, I>(self, v: I) -> SimpleExpr
where V: IntoValueTuple, I: IntoIterator<Item = V>,

Express a IN sub expression. Read more
source§

fn is<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a IS expression. Read more
source§

fn is_in<V, I>(self, v: I) -> SimpleExpr
where V: Into<SimpleExpr>, I: IntoIterator<Item = V>,

Express a IN expression. Read more
source§

fn is_not<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a IS NOT expression. Read more
source§

fn is_not_in<V, I>(self, v: I) -> SimpleExpr
where V: Into<SimpleExpr>, I: IntoIterator<Item = V>,

Express a NOT IN expression. Read more
source§

fn is_not_null(self) -> SimpleExpr

Express a IS NOT NULL expression. Read more
source§

fn is_null(self) -> SimpleExpr

Express a IS NULL expression. Read more
source§

fn left_shift<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a bitwise left shift. Read more
source§

fn like<L>(self, like: L) -> SimpleExpr
where L: IntoLikeExpr,

Express a LIKE expression. Read more
source§

fn lt<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a less than (<) expression. Read more
source§

fn lte<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a less than or equal (<=) expression. Read more
source§

fn modulo<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express an arithmetic modulo operation. Read more
source§

fn mul<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express an arithmetic multiplication operation. Read more
source§

fn ne<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a not equal (<>) expression. Read more
source§

fn not(self) -> SimpleExpr

Negates an expression with NOT. Read more
source§

fn not_between<A, B>(self, a: A, b: B) -> SimpleExpr
where A: Into<SimpleExpr>, B: Into<SimpleExpr>,

Express a NOT BETWEEN expression. Read more
source§

fn not_equals<C>(self, col: C) -> SimpleExpr
where C: IntoColumnRef,

Express a not equal expression between two table columns, you will mainly use this to relate identical value between two table columns. Read more
source§

fn not_in_subquery(self, sel: SelectStatement) -> SimpleExpr

Express a NOT IN sub-query expression. Read more
source§

fn not_like<L>(self, like: L) -> SimpleExpr
where L: IntoLikeExpr,

Express a NOT LIKE expression. Read more
source§

fn or<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a logical OR operation. Read more
source§

fn right_shift<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express a bitwise right shift. Read more
source§

fn sub<R>(self, right: R) -> SimpleExpr
where R: Into<SimpleExpr>,

Express an arithmetic subtraction operation. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<V> FromValueTuple for V
where V: Into<Value> + ValueType,

source§

fn from_value_tuple<I>(i: I) -> V
where I: IntoValueTuple,

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts 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 more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts 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
source§

impl<V> IntoValueTuple for V
where V: Into<Value>,

source§

impl<V> PrimaryKeyArity for V
where V: TryGetable,

source§

const ARITY: usize = 1usize

Arity of the Primary Key
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
source§

impl<T> SubsecRound for T
where T: Add<TimeDelta, Output = T> + Sub<TimeDelta, Output = T> + Timelike,

source§

fn round_subsecs(self, digits: u16) -> T

Return a copy rounded to the specified number of subsecond digits. With 9 or more digits, self is returned unmodified. Halfway values are rounded up (away from zero). Read more
source§

fn trunc_subsecs(self, digits: u16) -> T

Return a copy truncated to the specified number of subsecond digits. With 9 or more digits, self is returned unmodified. Read more
source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T> TryGetableMany for T
where T: TryGetable,

source§

fn try_get_many( res: &QueryResult, pre: &str, cols: &[String], ) -> Result<T, TryGetError>

Get a tuple value from the query result with prefixed column name
source§

fn try_get_many_by_index(res: &QueryResult) -> Result<T, TryGetError>

Get a tuple value from the query result based on the order in the select expressions
source§

fn find_by_statement<C>( stmt: Statement, ) -> SelectorRaw<SelectGetableValue<Self, C>>

source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,