Struct clickhouse_data_value::date::NaiveDate

pub struct NaiveDate(pub ChronoNaiveDate);

Methods from Deref<Target = ChronoNaiveDate>

pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime

Makes a new NaiveDateTime from the current date and given NaiveTime.

Example

use chrono::{NaiveDate, NaiveTime, NaiveDateTime};

let d = NaiveDate::from_ymd(2015, 6, 3);
let t = NaiveTime::from_hms_milli(12, 34, 56, 789);

let dt: NaiveDateTime = d.and_time(t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);

pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_* methods with a subsecond parameter instead.

Panics on invalid hour, minute and/or second.

Example

use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms(12, 34, 56);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);

pub fn and_hms_opt(
    &self,
    hour: u32,
    min: u32,
    sec: u32
) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_*_opt methods with a subsecond parameter instead.

Returns None on invalid hour, minute and/or second.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_opt(12, 34, 56).is_some());
assert!(d.and_hms_opt(12, 34, 60).is_none()); // use `and_hms_milli_opt` instead
assert!(d.and_hms_opt(12, 60, 56).is_none());
assert!(d.and_hms_opt(24, 34, 56).is_none());

pub fn and_hms_milli(
    &self,
    hour: u32,
    min: u32,
    sec: u32,
    milli: u32
) -> NaiveDateTime

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part can exceed 1,000 in order to represent the leap second.

Panics on invalid hour, minute, second and/or millisecond.

Example

use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms_milli(12, 34, 56, 789);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_000_000);

pub fn and_hms_milli_opt(
    &self,
    hour: u32,
    min: u32,
    sec: u32,
    milli: u32
) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part can exceed 1,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or millisecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_milli_opt(12, 34, 56,   789).is_some());
assert!(d.and_hms_milli_opt(12, 34, 59, 1_789).is_some()); // leap second
assert!(d.and_hms_milli_opt(12, 34, 59, 2_789).is_none());
assert!(d.and_hms_milli_opt(12, 34, 60,   789).is_none());
assert!(d.and_hms_milli_opt(12, 60, 56,   789).is_none());
assert!(d.and_hms_milli_opt(24, 34, 56,   789).is_none());

pub fn and_hms_micro(
    &self,
    hour: u32,
    min: u32,
    sec: u32,
    micro: u32
) -> NaiveDateTime

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part can exceed 1,000,000 in order to represent the leap second.

Panics on invalid hour, minute, second and/or microsecond.

Example

use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms_micro(12, 34, 56, 789_012);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);

pub fn and_hms_micro_opt(
    &self,
    hour: u32,
    min: u32,
    sec: u32,
    micro: u32
) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part can exceed 1,000,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or microsecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_micro_opt(12, 34, 56,   789_012).is_some());
assert!(d.and_hms_micro_opt(12, 34, 59, 1_789_012).is_some()); // leap second
assert!(d.and_hms_micro_opt(12, 34, 59, 2_789_012).is_none());
assert!(d.and_hms_micro_opt(12, 34, 60,   789_012).is_none());
assert!(d.and_hms_micro_opt(12, 60, 56,   789_012).is_none());
assert!(d.and_hms_micro_opt(24, 34, 56,   789_012).is_none());

pub fn and_hms_nano(
    &self,
    hour: u32,
    min: u32,
    sec: u32,
    nano: u32
) -> NaiveDateTime

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.

Panics on invalid hour, minute, second and/or nanosecond.

Example

use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};

let d = NaiveDate::from_ymd(2015, 6, 3);

let dt: NaiveDateTime = d.and_hms_nano(12, 34, 56, 789_012_345);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_345);

pub fn and_hms_nano_opt(
    &self,
    hour: u32,
    min: u32,
    sec: u32,
    nano: u32
) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or nanosecond.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 6, 3);
assert!(d.and_hms_nano_opt(12, 34, 56,   789_012_345).is_some());
assert!(d.and_hms_nano_opt(12, 34, 59, 1_789_012_345).is_some()); // leap second
assert!(d.and_hms_nano_opt(12, 34, 59, 2_789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 34, 60,   789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 60, 56,   789_012_345).is_none());
assert!(d.and_hms_nano_opt(24, 34, 56,   789_012_345).is_none());

pub fn succ(&self) -> NaiveDate

Makes a new NaiveDate for the next calendar date.

Panics when self is the last representable date.

Example

use chrono::NaiveDate;

assert_eq!(NaiveDate::from_ymd(2015,  6,  3).succ(), NaiveDate::from_ymd(2015, 6, 4));
assert_eq!(NaiveDate::from_ymd(2015,  6, 30).succ(), NaiveDate::from_ymd(2015, 7, 1));
assert_eq!(NaiveDate::from_ymd(2015, 12, 31).succ(), NaiveDate::from_ymd(2016, 1, 1));

pub fn succ_opt(&self) -> Option<NaiveDate>

Makes a new NaiveDate for the next calendar date.

Returns None when self is the last representable date.

Example

use chrono::NaiveDate;
use chrono::naive::MAX_DATE;

assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ_opt(),
           Some(NaiveDate::from_ymd(2015, 6, 4)));
assert_eq!(MAX_DATE.succ_opt(), None);

pub fn pred(&self) -> NaiveDate

Makes a new NaiveDate for the previous calendar date.

Panics when self is the first representable date.

Example

use chrono::NaiveDate;

assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred(), NaiveDate::from_ymd(2015,  6,  2));
assert_eq!(NaiveDate::from_ymd(2015, 6, 1).pred(), NaiveDate::from_ymd(2015,  5, 31));
assert_eq!(NaiveDate::from_ymd(2015, 1, 1).pred(), NaiveDate::from_ymd(2014, 12, 31));

pub fn pred_opt(&self) -> Option<NaiveDate>

Makes a new NaiveDate for the previous calendar date.

Returns None when self is the first representable date.

Example

use chrono::NaiveDate;
use chrono::naive::MIN_DATE;

assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred_opt(),
           Some(NaiveDate::from_ymd(2015, 6, 2)));
assert_eq!(MIN_DATE.pred_opt(), None);

pub fn iter_days(&self) -> NaiveDateDaysIterator

Returns an iterator that steps by days until the last representable date.

Example

let expected = [
    NaiveDate::from_ymd(2016, 2, 27),
    NaiveDate::from_ymd(2016, 2, 28),
    NaiveDate::from_ymd(2016, 2, 29),
    NaiveDate::from_ymd(2016, 3, 1),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_days().take(4).enumerate() {
   assert_eq!(d, expected[idx]);
   count += 1;
}
assert_eq!(count, 4);

pub fn iter_weeks(&self) -> NaiveDateWeeksIterator

Returns an iterator that steps by weeks until the last representable date.

Example

let expected = [
    NaiveDate::from_ymd(2016, 2, 27),
    NaiveDate::from_ymd(2016, 3, 5),
    NaiveDate::from_ymd(2016, 3, 12),
    NaiveDate::from_ymd(2016, 3, 19),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_weeks().take(4).enumerate() {
   assert_eq!(d, expected[idx]);
   count += 1;
}
assert_eq!(count, 4);

Trait Implementations

impl Clone for NaiveDate

fn clone(&self) -> NaiveDate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NaiveDate

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

Formats the value using the given formatter.

impl Deref for NaiveDate

type Target = ChronoNaiveDate

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for NaiveDate

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for NaiveDate

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

Deserialize this value from the given Serde deserializer.

impl From<NaiveDate> for NaiveDate

fn from(inner: ChronoNaiveDate) -> Self

Performs the conversion.

impl FromStr for NaiveDate

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl PartialEq<NaiveDate> for NaiveDate

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

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

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

This method tests for !=.

impl StructuralPartialEq for NaiveDate