Struct CustomDateTime 

pub struct CustomDateTime(NaiveDateTime);

CustomDateTime is a wrapper around NaiveDateTime that provides additional functionality.

Tuple Fields

0: NaiveDateTime

Implementations

impl CustomDateTime

CustomDateTime implementing certain useful methods.

pub fn inner(&self) -> NaiveDateTime

Returns the inner NaiveDateTime.

pub fn now() -> Self

Returns the current date and time.

Methods from Deref<Target = NaiveDateTime>

pub const MIN: NaiveDateTime

pub const MAX: NaiveDateTime

pub const UNIX_EPOCH: NaiveDateTime

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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

impl Add<TimeDelta> for CustomDateTime

Add implementation for CustomDateTime.

type Output = CustomDateTime

Outputs a new CustomDateTime by adding a Duration to the current one.

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

Adds a Duration to the CustomDateTime.

impl AddAssign<TimeDelta> for CustomDateTime

AddAssign implementation for CustomDateTime.

fn add_assign(&mut self, other: TimeDelta)

Adds a TimeDelta to the CustomDateTime.

impl<'__expr> AsExpression<Datetime> for &'__expr CustomDateTime

type Expression = Bound<Datetime, &'__expr CustomDateTime>

The expression being returned

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

Perform the conversion

impl AsExpression<Datetime> for CustomDateTime

type Expression = Bound<Datetime, CustomDateTime>

The expression being returned

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

Perform the conversion

impl<'__expr> AsExpression<Nullable<Datetime>> for &'__expr CustomDateTime

type Expression = Bound<Nullable<Datetime>, &'__expr CustomDateTime>

The expression being returned

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

Perform the conversion

impl AsExpression<Nullable<Datetime>> for CustomDateTime

type Expression = Bound<Nullable<Datetime>, CustomDateTime>

The expression being returned

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

Perform the conversion

impl Clone for CustomDateTime

fn clone(&self) -> CustomDateTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CustomDateTime

impl Debug for CustomDateTime

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

Formats the value using the given formatter.

impl Deref for CustomDateTime

Deref implementation for CustomDateTime.

type Target = NaiveDateTime

Target type for dereferencing.

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

Dereferences the CustomDateTime to its underlying NaiveDateTime.

impl<'de> Deserialize<'de> for CustomDateTime

Deserialize implementation for CustomDateTime.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserializes a JSON string into a CustomDateTime.

impl Eq for CustomDateTime

impl From<NaiveDateTime> for CustomDateTime

From<NaiveDateTime> implementation for CustomDateTime.

fn from(dt: NaiveDateTime) -> Self

Converts a NaiveDateTime to a CustomDateTime.

impl FromSql<Datetime, Mysql> for CustomDateTime

FromSql implementation for CustomDateTime.

fn from_sql<'a>(bytes: <Mysql as Backend>::RawValue<'a>) -> Result<Self>

Converts a MySQL datetime to a CustomDateTime.

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

A specialized variant of from_sql for handling null values.

impl Ord for CustomDateTime

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for CustomDateTime

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for CustomDateTime

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<__DB, __ST> Queryable<__ST, __DB> for CustomDateTime

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

type Row = CustomDateTime

The Rust type you’d like to map from.

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

Construct an instance of this type

impl Serialize for CustomDateTime

Serialize implementation for CustomDateTime.

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

where S: Serializer,

Serializes the CustomDateTime into a JSON string.

impl StructuralPartialEq for CustomDateTime

impl<DB> ToSql<Datetime, DB> for CustomDateTime

where DB: Backend, NaiveDateTime: ToSql<Datetime, DB>,

ToSql implementation for CustomDateTime.

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

Converts a CustomDateTime to a MySQL datetime.

impl<__DB> ToSql<Nullable<Datetime>, __DB> for CustomDateTime

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

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

See the trait documentation.