diff --git a/zino-core/src/datetime/date.rs b/zino-core/src/datetime/date.rs
new file mode 100644
index 00000000..5bb9a533
--- /dev/null
+++ b/zino-core/src/datetime/date.rs
@@ -0,0 +1,306 @@
+use crate::{AvroValue, JsonValue};
+use chrono::{format::ParseError, Datelike, Local, NaiveDate};
+use serde::{Deserialize, Serialize, Serializer};
+use std::{
+    fmt,
+    ops::{Add, AddAssign, Sub, SubAssign},
+    str::FromStr,
+    time::Duration,
+};
+
+/// A wrapper type for [`chrono::NaiveDate`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deserialize)]
+pub struct Date(NaiveDate);
+
+impl Date {
+    /// Returns a new instance which corresponds to the current date.
+    #[inline]
+    pub fn today() -> Self {
+        Self(Local::now().date_naive())
+    }
+
+    /// Returns a new instance which corresponds to the tomorrow date.
+    #[inline]
+    pub fn tomorrow() -> Self {
+        let date = Local::now()
+            .date_naive()
+            .succ_opt()
+            .unwrap_or(NaiveDate::MAX);
+        Self(date)
+    }
+
+    /// Returns a new instance which corresponds to the yesterday date.
+    #[inline]
+    pub fn yesterday() -> Self {
+        let date = Local::now()
+            .date_naive()
+            .pred_opt()
+            .unwrap_or(NaiveDate::MIN);
+        Self(date)
+    }
+
+    /// Returns a new instance which corresponds to 1st of January 1970.
+    #[inline]
+    pub fn epoch() -> Self {
+        Self(NaiveDate::default())
+    }
+
+    /// Counts the days from the 1st of January 1970.
+    #[inline]
+    pub fn num_days_from_epoch(&self) -> i32 {
+        let unix_epoch = NaiveDate::default();
+        self.0
+            .signed_duration_since(unix_epoch)
+            .num_days()
+            .try_into()
+            .unwrap_or_default()
+    }
+
+    /// Formats the date with the specified format string.
+    /// See [`format::strftime`](chrono::format::strftime) for the supported escape sequences.
+    #[inline]
+    pub fn format(&self, fmt: &str) -> String {
+        format!("{}", self.0.format(fmt))
+    }
+
+    /// Returns the amount of time elapsed from another date to this one,
+    /// or zero duration if that date is later than this one.
+    #[inline]
+    pub fn duration_since(&self, earlier: Date) -> Duration {
+        (self.0 - earlier.0).to_std().unwrap_or_default()
+    }
+
+    /// Returns the duration of time between `self` and `other`.
+    #[inline]
+    pub fn span_between(&self, other: Date) -> Duration {
+        let duration = if self > &other {
+            self.0 - other.0
+        } else {
+            other.0 - self.0
+        };
+        duration.to_std().unwrap_or_default()
+    }
+
+    /// Returns the year number in the calendar date.
+    #[inline]
+    pub fn year(&self) -> i32 {
+        self.0.year()
+    }
+
+    /// Returns the month number starting from 1.
+    ///
+    /// The return value ranges from 1 to 12.
+    #[inline]
+    pub fn month(&self) -> u32 {
+        self.0.month()
+    }
+
+    /// Returns the day of month starting from 1.
+    ///
+    /// The return value ranges from 1 to 31. (The last day of month differs by months.)
+    #[inline]
+    pub fn day(&self) -> u32 {
+        self.0.day()
+    }
+
+    /// Returns the ISO week number starting from 1.
+    ///
+    /// The return value ranges from 1 to 53. (The last week of year differs by years.)
+    #[inline]
+    pub fn week(&self) -> u32 {
+        self.0.iso_week().week()
+    }
+
+    /// Returns the day of year starting from 1.
+    ///
+    /// The return value ranges from 1 to 366. (The last day of year differs by years.)
+    #[inline]
+    pub fn day_of_year(&self) -> u32 {
+        self.0.ordinal()
+    }
+
+    /// Returns the day of week starting from 0 (Sunday) to 6 (Saturday).
+    #[inline]
+    pub fn day_of_week(&self) -> u8 {
+        self.0.weekday() as u8
+    }
+
+    /// Returns `true` if the current year is a leap year.
+    #[inline]
+    pub fn is_leap_year(&self) -> bool {
+        self.0.leap_year()
+    }
+
+    /// Returns the number of days in the current year.
+    #[inline]
+    pub fn days_in_current_year(&self) -> u32 {
+        if self.is_leap_year() {
+            366
+        } else {
+            365
+        }
+    }
+
+    /// Returns the number of days in the current month.
+    pub fn days_in_current_month(&self) -> u32 {
+        let month = self.month();
+        match month {
+            1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+            4 | 6 | 9 | 11 => 30,
+            2 => {
+                if self.is_leap_year() {
+                    29
+                } else {
+                    28
+                }
+            }
+            _ => panic!("invalid month: {month}"),
+        }
+    }
+
+    /// Returns the start of the current year.
+    pub fn start_of_current_year(&self) -> Self {
+        let year = self.year();
+        Self(NaiveDate::from_ymd_opt(year, 1, 1).unwrap_or_default())
+    }
+
+    /// Returns the end of the current year.
+    pub fn end_of_current_year(&self) -> Self {
+        let year = self.year();
+        Self(NaiveDate::from_ymd_opt(year, 12, 31).unwrap_or_default())
+    }
+
+    /// Returns the start of the next year.
+    pub fn start_of_next_year(&self) -> Self {
+        let year = self.year() + 1;
+        Self(NaiveDate::from_ymd_opt(year, 1, 1).unwrap_or_default())
+    }
+
+    /// Returns the start of the current month.
+    pub fn start_of_current_month(&self) -> Self {
+        let year = self.year();
+        let month = self.month();
+        Self(NaiveDate::from_ymd_opt(year, month, 1).unwrap_or_default())
+    }
+
+    /// Returns the end of the current month.
+    pub fn end_of_current_month(&self) -> Self {
+        let year = self.year();
+        let month = self.month();
+        let day = self.days_in_current_month();
+        Self(NaiveDate::from_ymd_opt(year, month, day).unwrap_or_default())
+    }
+
+    /// Returns the start of the next month.
+    pub fn start_of_next_month(&self) -> Self {
+        let year = self.year();
+        let month = self.month();
+        let date_opt = if month == 12 {
+            NaiveDate::from_ymd_opt(year + 1, 1, 1)
+        } else {
+            NaiveDate::from_ymd_opt(year, month, 1)
+        };
+        Self(date_opt.unwrap_or_default())
+    }
+}
+
+impl Default for Date {
+    /// Returns an instance which corresponds to **the current date**.
+    #[inline]
+    fn default() -> Self {
+        Self::today()
+    }
+}
+
+impl fmt::Display for Date {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0.format("%Y-%m-%d"))
+    }
+}
+
+impl Serialize for Date {
+    #[inline]
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl From<NaiveDate> for Date {
+    #[inline]
+    fn from(d: NaiveDate) -> Self {
+        Self(d)
+    }
+}
+
+impl From<Date> for NaiveDate {
+    #[inline]
+    fn from(d: Date) -> Self {
+        d.0
+    }
+}
+
+impl From<Date> for AvroValue {
+    #[inline]
+    fn from(d: Date) -> Self {
+        AvroValue::Date(d.num_days_from_epoch())
+    }
+}
+
+impl From<Date> for JsonValue {
+    #[inline]
+    fn from(d: Date) -> Self {
+        JsonValue::String(d.to_string())
+    }
+}
+
+impl FromStr for Date {
+    type Err = ParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.parse::<NaiveDate>().map(Self)
+    }
+}
+
+impl Add<Duration> for Date {
+    type Output = Self;
+
+    #[inline]
+    fn add(self, rhs: Duration) -> Self {
+        let duration = chrono::Duration::from_std(rhs).expect("Duration value is out of range");
+        let date = self
+            .0
+            .checked_add_signed(duration)
+            .expect("`Date + Duration` overflowed");
+        Self(date)
+    }
+}
+
+impl AddAssign<Duration> for Date {
+    #[inline]
+    fn add_assign(&mut self, rhs: Duration) {
+        *self = *self + rhs;
+    }
+}
+
+impl Sub<Duration> for Date {
+    type Output = Self;
+
+    #[inline]
+    fn sub(self, rhs: Duration) -> Self {
+        let duration = chrono::Duration::from_std(rhs).expect("Duration value is out of range");
+        let date = self
+            .0
+            .checked_sub_signed(duration)
+            .expect("`Date - Duration` overflowed");
+        Self(date)
+    }
+}
+
+impl SubAssign<Duration> for Date {
+    #[inline]
+    fn sub_assign(&mut self, rhs: Duration) {
+        *self = *self - rhs;
+    }
+}
diff --git a/zino-core/src/datetime/mod.rs b/zino-core/src/datetime/mod.rs
index 4f6ca15e..bc31f109 100644
--- a/zino-core/src/datetime/mod.rs
+++ b/zino-core/src/datetime/mod.rs
@@ -3,7 +3,7 @@
 use crate::{AvroValue, JsonValue};
 use chrono::{
     format::ParseError, Datelike, Days, Local, Months, NaiveDate, NaiveDateTime, NaiveTime,
-    SecondsFormat, TimeZone, Utc,
+    SecondsFormat, TimeZone, Timelike, Utc,
 };
 use serde::{Deserialize, Serialize, Serializer};
 use std::{
@@ -13,9 +13,13 @@ use std::{
     time::Duration,
 };
 
+mod date;
 mod duration;
+mod time;
 
+pub use date::Date;
 pub use duration::{parse_duration, ParseDurationError};
+pub use time::Time;
 
 /// Alias for [`chrono::DateTime<Local>`](chrono::DateTime).
 type LocalDateTime = chrono::DateTime<Local>;
@@ -25,7 +29,7 @@ type LocalDateTime = chrono::DateTime<Local>;
 pub struct DateTime(LocalDateTime);
 
 impl DateTime {
-    /// Returns a new instance which corresponds to the current date.
+    /// Returns a new instance which corresponds to the current date and time.
     #[inline]
     pub fn now() -> Self {
         Self(Local::now())
@@ -183,45 +187,54 @@ impl DateTime {
     /// Returns the duration of time between `self` and `other`.
     #[inline]
     pub fn span_between(&self, other: DateTime) -> Duration {
-        let timestamp = self.timestamp_micros();
-        let current_timestamp = other.timestamp_micros();
-        Duration::from_micros(current_timestamp.abs_diff(timestamp))
+        let duration = if self > &other {
+            self.0 - other.0
+        } else {
+            other.0 - self.0
+        };
+        duration.to_std().unwrap_or_default()
     }
 
     /// Returns the duration of time between `self` and `DateTime::now()`.
     #[inline]
     pub fn span_between_now(&self) -> Duration {
-        let timestamp = self.timestamp_micros();
-        let current_timestamp = Local::now().timestamp_micros();
-        Duration::from_micros(current_timestamp.abs_diff(timestamp))
+        self.span_between(Self::now())
     }
 
     /// Returns the duration of time from `self` to `DateTime::now()`.
+    #[inline]
     pub fn span_before_now(&self) -> Option<Duration> {
-        let timestamp = self.timestamp_micros();
-        let current_timestamp = Local::now().timestamp_micros();
-        if current_timestamp >= timestamp {
-            u64::try_from(current_timestamp - timestamp)
-                .ok()
-                .map(Duration::from_micros)
+        let current = Self::now();
+        if self <= &current {
+            (current.0 - self.0).to_std().ok()
         } else {
             None
         }
     }
 
     /// Returns the duration of time from `DateTime::now()` to `self`.
+    #[inline]
     pub fn span_after_now(&self) -> Option<Duration> {
-        let timestamp = self.timestamp_micros();
-        let current_timestamp = Local::now().timestamp_micros();
-        if current_timestamp <= timestamp {
-            u64::try_from(timestamp - current_timestamp)
-                .ok()
-                .map(Duration::from_micros)
+        let current = Self::now();
+        if self >= &current {
+            (self.0 - current.0).to_std().ok()
         } else {
             None
         }
     }
 
+    /// Retrieves the date component.
+    #[inline]
+    pub fn date(&self) -> Date {
+        self.0.date_naive().into()
+    }
+
+    /// Retrieves the time component.
+    #[inline]
+    pub fn time(&self) -> Time {
+        self.0.time().into()
+    }
+
     /// Returns the year number in the calendar date.
     #[inline]
     pub fn year(&self) -> i32 {
@@ -244,6 +257,46 @@ impl DateTime {
         self.0.day()
     }
 
+    /// Returns the hour number from 0 to 23.
+    #[inline]
+    pub fn hour(&self) -> u32 {
+        self.0.hour()
+    }
+
+    /// Returns the minute number from 0 to 59.
+    #[inline]
+    pub fn minute(&self) -> u32 {
+        self.0.minute()
+    }
+
+    /// Returns the second number from 0 to 59.
+    #[inline]
+    pub fn second(&self) -> u32 {
+        self.0.second()
+    }
+
+    /// Returns the ISO week number starting from 1.
+    ///
+    /// The return value ranges from 1 to 53. (The last week of year differs by years.)
+    #[inline]
+    pub fn week(&self) -> u32 {
+        self.0.iso_week().week()
+    }
+
+    /// Returns the day of year starting from 1.
+    ///
+    /// The return value ranges from 1 to 366. (The last day of year differs by years.)
+    #[inline]
+    pub fn day_of_year(&self) -> u32 {
+        self.0.ordinal()
+    }
+
+    /// Returns the day of week starting from 0 (Sunday) to 6 (Saturday).
+    #[inline]
+    pub fn day_of_week(&self) -> u8 {
+        self.0.weekday() as u8
+    }
+
     /// Returns `true` if the current year is a leap year.
     #[inline]
     pub fn is_leap_year(&self) -> bool {
@@ -283,7 +336,10 @@ impl DateTime {
         let date = NaiveDate::from_ymd_opt(year, 1, 1).unwrap_or_default();
         let dt = NaiveDateTime::new(date, NaiveTime::default());
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the end of the current year.
@@ -293,7 +349,10 @@ impl DateTime {
             .and_then(|date| date.and_hms_milli_opt(23, 59, 59, 1_000))
             .unwrap_or_default();
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the start of the current month.
@@ -303,7 +362,10 @@ impl DateTime {
         let date = NaiveDate::from_ymd_opt(year, month, 1).unwrap_or_default();
         let dt = NaiveDateTime::new(date, NaiveTime::default());
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the end of the current month.
@@ -315,7 +377,10 @@ impl DateTime {
             .and_then(|date| date.and_hms_milli_opt(23, 59, 59, 1_000))
             .unwrap_or_default();
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the start of the current day.
@@ -323,7 +388,10 @@ impl DateTime {
         let date = self.0.date_naive();
         let dt = NaiveDateTime::new(date, NaiveTime::default());
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the end of the current day.
@@ -333,7 +401,10 @@ impl DateTime {
             .and_hms_milli_opt(23, 59, 59, 1_000)
             .unwrap_or_default();
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the start of the year.
@@ -341,7 +412,10 @@ impl DateTime {
         let date = NaiveDate::from_ymd_opt(year, 1, 1).unwrap_or_default();
         let dt = NaiveDateTime::new(date, NaiveTime::default());
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the end of the year.
@@ -351,7 +425,10 @@ impl DateTime {
             .and_then(|date| date.and_hms_milli_opt(23, 59, 59, 1_000))
             .unwrap_or_default();
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the start of the month.
@@ -359,7 +436,10 @@ impl DateTime {
         let date = NaiveDate::from_ymd_opt(year, month, 1).unwrap_or_default();
         let dt = NaiveDateTime::new(date, NaiveTime::default());
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the end of the month.
@@ -369,7 +449,10 @@ impl DateTime {
             .and_then(|date| date.and_hms_milli_opt(23, 59, 59, 1_000))
             .unwrap_or_default();
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the start of the day.
@@ -377,7 +460,10 @@ impl DateTime {
         let date = NaiveDate::from_ymd_opt(year, month, day).unwrap_or_default();
         let dt = NaiveDateTime::new(date, NaiveTime::default());
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Returns the end of the month.
@@ -387,7 +473,10 @@ impl DateTime {
             .and_hms_milli_opt(23, 59, 59, 1_000)
             .unwrap_or_default();
         let offset = Local.offset_from_utc_datetime(&dt);
-        Self(LocalDateTime::from_naive_utc_and_offset(dt, offset))
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
     }
 
     /// Adds a duration in months to the date part of the `DateTime`.
@@ -445,6 +534,17 @@ impl Serialize for DateTime {
     }
 }
 
+impl From<Date> for DateTime {
+    fn from(d: Date) -> Self {
+        let dt = NaiveDateTime::new(d.into(), NaiveTime::default());
+        let offset = Local.offset_from_utc_datetime(&dt);
+        Self(LocalDateTime::from_naive_utc_and_offset(
+            dt - offset,
+            offset,
+        ))
+    }
+}
+
 impl From<LocalDateTime> for DateTime {
     #[inline]
     fn from(dt: LocalDateTime) -> Self {
@@ -543,7 +643,7 @@ impl SubAssign<Duration> for DateTime {
 
 #[cfg(test)]
 mod tests {
-    use super::DateTime;
+    use super::{Date, DateTime};
 
     #[test]
     fn it_parses_datetime() {
@@ -553,5 +653,20 @@ mod tests {
         assert!("2023-06-10 05:17:23.713071 +0800"
             .parse::<DateTime>()
             .is_ok());
+
+        let datetime = "2023-11-30 16:24:30.654321 +0800"
+            .parse::<DateTime>()
+            .unwrap();
+        let start_day = datetime.start_of_current_day();
+        let end_day = datetime.end_of_current_day();
+        assert_eq!("2023-11-30", start_day.format_date());
+        assert_eq!("00:00:00", start_day.format_time());
+        assert_eq!("2023-11-30", end_day.format_date());
+        assert_eq!("23:59:60", end_day.format_time());
+
+        let date = "2023-11-30".parse::<Date>().unwrap();
+        let datetime = DateTime::from(date);
+        assert_eq!("2023-11-30", datetime.format_date());
+        assert_eq!("00:00:00", datetime.format_time());
     }
 }
diff --git a/zino-core/src/datetime/time.rs b/zino-core/src/datetime/time.rs
new file mode 100644
index 00000000..b2b3cc58
--- /dev/null
+++ b/zino-core/src/datetime/time.rs
@@ -0,0 +1,210 @@
+use crate::{AvroValue, JsonValue};
+use chrono::{format::ParseError, Local, NaiveTime, Timelike};
+use serde::{Deserialize, Serialize, Serializer};
+use std::{
+    fmt,
+    ops::{Add, AddAssign, Sub, SubAssign},
+    str::FromStr,
+    time::Duration,
+};
+
+/// A wrapper type for [`chrono::NaiveTime`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deserialize)]
+pub struct Time(NaiveTime);
+
+impl Time {
+    /// Returns a new instance which corresponds to the current time.
+    #[inline]
+    pub fn now() -> Self {
+        Self(Local::now().time())
+    }
+
+    /// Returns a new instance which corresponds to the midnight.
+    #[inline]
+    pub fn midnight() -> Self {
+        Self(NaiveTime::default())
+    }
+
+    /// Returns the number of non-leap seconds past the last midnight.
+    #[inline]
+    pub fn num_secs_from_midnight(&self) -> u32 {
+        self.0.num_seconds_from_midnight()
+    }
+
+    /// Returns the number of non-leap milliseconds past the last midnight.
+    #[inline]
+    pub fn num_millis_from_midnight(&self) -> u32 {
+        self.0.num_seconds_from_midnight() * 1000 + self.0.nanosecond() / 1_000_000
+    }
+
+    /// Returns the number of non-leap microseconds past the last midnight.
+    #[inline]
+    pub fn num_micros_from_midnight(&self) -> u32 {
+        self.0.num_seconds_from_midnight() * 1_000_000 + self.0.nanosecond() / 1000
+    }
+
+    /// Formats the time with the specified format string.
+    /// See [`format::strftime`](chrono::format::strftime) for the supported escape sequences.
+    #[inline]
+    pub fn format(&self, fmt: &str) -> String {
+        format!("{}", self.0.format(fmt))
+    }
+
+    /// Returns the amount of time elapsed from another time to this one,
+    /// or zero duration if that time is later than this one.
+    #[inline]
+    pub fn duration_since(&self, earlier: Time) -> Duration {
+        (self.0 - earlier.0).to_std().unwrap_or_default()
+    }
+
+    /// Returns the duration of time between `self` and `other`.
+    #[inline]
+    pub fn span_between(&self, other: Time) -> Duration {
+        let duration = if self > &other {
+            self.0 - other.0
+        } else {
+            other.0 - self.0
+        };
+        duration.to_std().unwrap_or_default()
+    }
+
+    /// Returns the duration of time between `self` and `Time::now()`.
+    #[inline]
+    pub fn span_between_now(&self) -> Duration {
+        self.span_between(Self::now())
+    }
+
+    /// Returns the duration of time from `self` to `Time::now()`.
+    #[inline]
+    pub fn span_before_now(&self) -> Option<Duration> {
+        let current = Self::now();
+        if self <= &current {
+            (current.0 - self.0).to_std().ok()
+        } else {
+            None
+        }
+    }
+
+    /// Returns the duration of time from `Time::now()` to `self`.
+    #[inline]
+    pub fn span_after_now(&self) -> Option<Duration> {
+        let current = Self::now();
+        if self >= &current {
+            (self.0 - current.0).to_std().ok()
+        } else {
+            None
+        }
+    }
+
+    /// Returns the hour number from 0 to 23.
+    #[inline]
+    pub fn hour(&self) -> u32 {
+        self.0.hour()
+    }
+
+    /// Returns the minute number from 0 to 59.
+    #[inline]
+    pub fn minute(&self) -> u32 {
+        self.0.minute()
+    }
+
+    /// Returns the second number from 0 to 59.
+    #[inline]
+    pub fn second(&self) -> u32 {
+        self.0.second()
+    }
+}
+
+impl Default for Time {
+    /// Returns an instance which corresponds to **the current time**.
+    #[inline]
+    fn default() -> Self {
+        Self::now()
+    }
+}
+
+impl fmt::Display for Time {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0.format("%H:%M:%S%.f"))
+    }
+}
+
+impl Serialize for Time {
+    #[inline]
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl From<NaiveTime> for Time {
+    #[inline]
+    fn from(t: NaiveTime) -> Self {
+        Self(t)
+    }
+}
+
+impl From<Time> for NaiveTime {
+    #[inline]
+    fn from(t: Time) -> Self {
+        t.0
+    }
+}
+
+impl From<Time> for AvroValue {
+    #[inline]
+    fn from(t: Time) -> Self {
+        let micros = t.num_micros_from_midnight();
+        AvroValue::TimeMicros(micros.into())
+    }
+}
+
+impl From<Time> for JsonValue {
+    #[inline]
+    fn from(t: Time) -> Self {
+        JsonValue::String(t.to_string())
+    }
+}
+
+impl FromStr for Time {
+    type Err = ParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.parse::<NaiveTime>().map(Self)
+    }
+}
+
+impl Add<Duration> for Time {
+    type Output = Self;
+
+    #[inline]
+    fn add(self, rhs: Duration) -> Self {
+        let duration = chrono::Duration::from_std(rhs).expect("Duration value is out of range");
+        Self(self.0 + duration)
+    }
+}
+
+impl AddAssign<Duration> for Time {
+    #[inline]
+    fn add_assign(&mut self, rhs: Duration) {
+        *self = *self + rhs;
+    }
+}
+
+impl Sub<Duration> for Time {
+    type Output = Self;
+
+    #[inline]
+    fn sub(self, rhs: Duration) -> Self {
+        let duration = chrono::Duration::from_std(rhs).expect("Duration value is out of range");
+        Self(self.0 - duration)
+    }
+}
+
+impl SubAssign<Duration> for Time {
+    #[inline]
+    fn sub_assign(&mut self, rhs: Duration) {
+        *self = *self - rhs;
+    }
+}
diff --git a/zino-core/src/extension/json_object.rs b/zino-core/src/extension/json_object.rs
index 934d2168..97dfb827 100644
--- a/zino-core/src/extension/json_object.rs
+++ b/zino-core/src/extension/json_object.rs
@@ -1,6 +1,6 @@
 use super::JsonValueExt;
 use crate::{
-    datetime::{self, DateTime},
+    datetime::{self, Date, DateTime, Time},
     helper, openapi, JsonValue, Map, Record, Uuid,
 };
 use std::{
@@ -37,6 +37,14 @@ pub trait JsonObjectExt {
     /// and represents it as `usize` if possible.
     fn get_usize(&self, key: &str) -> Option<usize>;
 
+    /// Extracts the integer value corresponding to the key
+    /// and represents it as `i8` if possible.
+    fn get_i8(&self, key: &str) -> Option<i8>;
+
+    /// Extracts the integer value corresponding to the key
+    /// and represents it as `i16` if possible.
+    fn get_i16(&self, key: &str) -> Option<i16>;
+
     /// Extracts the integer value corresponding to the key
     /// and represents it as `i32` if possible.
     fn get_i32(&self, key: &str) -> Option<i32>;
@@ -62,6 +70,14 @@ pub trait JsonObjectExt {
     /// and represents it as `Uuid` if possible.
     fn get_uuid(&self, key: &str) -> Option<Uuid>;
 
+    /// Extracts the string corresponding to the key
+    /// and represents it as `Date` if possible.
+    fn get_date(&self, key: &str) -> Option<Date>;
+
+    /// Extracts the string corresponding to the key
+    /// and represents it as `Time` if possible.
+    fn get_time(&self, key: &str) -> Option<Time>;
+
     /// Extracts the string corresponding to the key
     /// and represents it as `DateTime` if possible.
     fn get_datetime(&self, key: &str) -> Option<DateTime>;
@@ -109,6 +125,12 @@ pub trait JsonObjectExt {
     /// Extracts the value corresponding to the key and parses it as `usize`.
     fn parse_usize(&self, key: &str) -> Option<Result<usize, ParseIntError>>;
 
+    /// Extracts the value corresponding to the key and parses it as `i8`.
+    fn parse_i8(&self, key: &str) -> Option<Result<i8, ParseIntError>>;
+
+    /// Extracts the value corresponding to the key and parses it as `i16`.
+    fn parse_i16(&self, key: &str) -> Option<Result<i16, ParseIntError>>;
+
     /// Extracts the value corresponding to the key and parses it as `i32`.
     fn parse_i32(&self, key: &str) -> Option<Result<i32, ParseIntError>>;
 
@@ -149,6 +171,12 @@ pub trait JsonObjectExt {
     /// If the `Uuid` is `nil`, it also returns `None`.
     fn parse_uuid(&self, key: &str) -> Option<Result<Uuid, uuid::Error>>;
 
+    /// Extracts the string corresponding to the key and parses it as `Date`.
+    fn parse_date(&self, key: &str) -> Option<Result<Date, chrono::format::ParseError>>;
+
+    /// Extracts the string corresponding to the key and parses it as `Time`.
+    fn parse_time(&self, key: &str) -> Option<Result<Time, chrono::format::ParseError>>;
+
     /// Extracts the string corresponding to the key and parses it as `DateTime`.
     fn parse_datetime(&self, key: &str) -> Option<Result<DateTime, chrono::format::ParseError>>;
 
@@ -237,6 +265,20 @@ impl JsonObjectExt for Map {
             .and_then(|i| usize::try_from(i).ok())
     }
 
+    #[inline]
+    fn get_i8(&self, key: &str) -> Option<i8> {
+        self.get(key)
+            .and_then(|v| v.as_i64())
+            .and_then(|i| i8::try_from(i).ok())
+    }
+
+    #[inline]
+    fn get_i16(&self, key: &str) -> Option<i16> {
+        self.get(key)
+            .and_then(|v| v.as_i64())
+            .and_then(|i| i16::try_from(i).ok())
+    }
+
     #[inline]
     fn get_i32(&self, key: &str) -> Option<i32> {
         self.get(key)
@@ -276,6 +318,16 @@ impl JsonObjectExt for Map {
         self.get_str(key).and_then(|s| s.parse().ok())
     }
 
+    #[inline]
+    fn get_date(&self, key: &str) -> Option<Date> {
+        self.get_str(key).and_then(|s| s.parse().ok())
+    }
+
+    #[inline]
+    fn get_time(&self, key: &str) -> Option<Time> {
+        self.get_str(key).and_then(|s| s.parse().ok())
+    }
+
     #[inline]
     fn get_datetime(&self, key: &str) -> Option<DateTime> {
         self.get_str(key).and_then(|s| s.parse().ok())
@@ -383,6 +435,24 @@ impl JsonObjectExt for Map {
             .or_else(|| value.and_then(|v| v.as_str()).map(|s| s.parse()))
     }
 
+    fn parse_i8(&self, key: &str) -> Option<Result<i8, ParseIntError>> {
+        let value = self.get(key);
+        value
+            .and_then(|v| v.as_i64())
+            .and_then(|i| i8::try_from(i).ok())
+            .map(Ok)
+            .or_else(|| value.and_then(|v| v.as_str()).map(|s| s.parse()))
+    }
+
+    fn parse_i16(&self, key: &str) -> Option<Result<i16, ParseIntError>> {
+        let value = self.get(key);
+        value
+            .and_then(|v| v.as_i64())
+            .and_then(|i| i16::try_from(i).ok())
+            .map(Ok)
+            .or_else(|| value.and_then(|v| v.as_str()).map(|s| s.parse()))
+    }
+
     fn parse_i32(&self, key: &str) -> Option<Result<i32, ParseIntError>> {
         let value = self.get(key);
         value
@@ -506,6 +576,16 @@ impl JsonObjectExt for Map {
             .map(|s| s.parse())
     }
 
+    #[inline]
+    fn parse_date(&self, key: &str) -> Option<Result<Date, chrono::format::ParseError>> {
+        self.get_str(key).map(|s| s.parse())
+    }
+
+    #[inline]
+    fn parse_time(&self, key: &str) -> Option<Result<Time, chrono::format::ParseError>> {
+        self.get_str(key).map(|s| s.parse())
+    }
+
     #[inline]
     fn parse_datetime(&self, key: &str) -> Option<Result<DateTime, chrono::format::ParseError>> {
         self.get_str(key).map(|s| s.parse())
diff --git a/zino-core/src/extension/json_value.rs b/zino-core/src/extension/json_value.rs
index 6ea2e417..d38a3000 100644
--- a/zino-core/src/extension/json_value.rs
+++ b/zino-core/src/extension/json_value.rs
@@ -1,5 +1,5 @@
 use crate::{
-    datetime::{self, DateTime},
+    datetime::{self, Date, DateTime, Time},
     extension::JsonObjectExt,
     helper, JsonValue, Map, Uuid,
 };
@@ -33,6 +33,14 @@ pub trait JsonValueExt {
     /// Returns `None` otherwise.
     fn as_usize(&self) -> Option<usize>;
 
+    /// If the `Value` is an integer, represent it as `i8` if possible.
+    /// Returns `None` otherwise.
+    fn as_i8(&self) -> Option<i8>;
+
+    /// If the `Value` is an integer, represent it as `i16` if possible.
+    /// Returns `None` otherwise.
+    fn as_i16(&self) -> Option<i16>;
+
     /// If the `Value` is an integer, represent it as `i32` if possible.
     /// Returns `None` otherwise.
     fn as_i32(&self) -> Option<i32>;
@@ -57,6 +65,14 @@ pub trait JsonValueExt {
     /// Returns `None` otherwise.
     fn as_uuid(&self) -> Option<Uuid>;
 
+    /// If the `Value` is a String, represent it as `Date` if possible.
+    /// Returns `None` otherwise.
+    fn as_date(&self) -> Option<Date>;
+
+    /// If the `Value` is a String, represent it as `Time` if possible.
+    /// Returns `None` otherwise.
+    fn as_time(&self) -> Option<Time>;
+
     /// If the `Value` is a String, represent it as `DateTime` if possible.
     /// Returns `None` otherwise.
     fn as_datetime(&self) -> Option<DateTime>;
@@ -83,6 +99,12 @@ pub trait JsonValueExt {
     /// Parses the JSON value as `usize`.
     fn parse_usize(&self) -> Option<Result<usize, ParseIntError>>;
 
+    /// Parses the JSON value as `i8`.
+    fn parse_i8(&self) -> Option<Result<i8, ParseIntError>>;
+
+    /// Parses the JSON value as `i16`.
+    fn parse_i16(&self) -> Option<Result<i16, ParseIntError>>;
+
     /// Parses the JSON value as `i32`.
     fn parse_i32(&self) -> Option<Result<i32, ParseIntError>>;
 
@@ -114,6 +136,12 @@ pub trait JsonValueExt {
     /// If the `Uuid` is `nil`, it also returns `None`.
     fn parse_uuid(&self) -> Option<Result<Uuid, uuid::Error>>;
 
+    /// Parses the JSON value as `Date`.
+    fn parse_date(&self) -> Option<Result<Date, chrono::format::ParseError>>;
+
+    /// Parses the JSON value as `Time`.
+    fn parse_time(&self) -> Option<Result<Time, chrono::format::ParseError>>;
+
     /// Parses the JSON value as `DateTime`.
     fn parse_datetime(&self) -> Option<Result<DateTime, chrono::format::ParseError>>;
 
@@ -174,6 +202,16 @@ impl JsonValueExt for JsonValue {
         self.as_u64().and_then(|i| usize::try_from(i).ok())
     }
 
+    #[inline]
+    fn as_i8(&self) -> Option<i8> {
+        self.as_i64().and_then(|i| i8::try_from(i).ok())
+    }
+
+    #[inline]
+    fn as_i16(&self) -> Option<i16> {
+        self.as_i64().and_then(|i| i16::try_from(i).ok())
+    }
+
     #[inline]
     fn as_i32(&self) -> Option<i32> {
         self.as_i64().and_then(|i| i32::try_from(i).ok())
@@ -210,6 +248,16 @@ impl JsonValueExt for JsonValue {
         self.as_str().and_then(|s| s.parse().ok())
     }
 
+    #[inline]
+    fn as_date(&self) -> Option<Date> {
+        self.as_str().and_then(|s| s.parse().ok())
+    }
+
+    #[inline]
+    fn as_time(&self) -> Option<Time> {
+        self.as_str().and_then(|s| s.parse().ok())
+    }
+
     #[inline]
     fn as_datetime(&self) -> Option<DateTime> {
         self.as_str().and_then(|s| s.parse().ok())
@@ -260,6 +308,20 @@ impl JsonValueExt for JsonValue {
             .or_else(|| self.as_str().map(|s| s.parse()))
     }
 
+    fn parse_i8(&self) -> Option<Result<i8, ParseIntError>> {
+        self.as_i64()
+            .and_then(|i| i8::try_from(i).ok())
+            .map(Ok)
+            .or_else(|| self.as_str().map(|s| s.parse()))
+    }
+
+    fn parse_i16(&self) -> Option<Result<i16, ParseIntError>> {
+        self.as_i64()
+            .and_then(|i| i16::try_from(i).ok())
+            .map(Ok)
+            .or_else(|| self.as_str().map(|s| s.parse()))
+    }
+
     fn parse_i32(&self) -> Option<Result<i32, ParseIntError>> {
         self.as_i64()
             .and_then(|i| i32::try_from(i).ok())
@@ -333,6 +395,16 @@ impl JsonValueExt for JsonValue {
             .map(|s| s.parse())
     }
 
+    #[inline]
+    fn parse_date(&self) -> Option<Result<Date, chrono::format::ParseError>> {
+        self.as_str().map(|s| s.parse())
+    }
+
+    #[inline]
+    fn parse_time(&self) -> Option<Result<Time, chrono::format::ParseError>> {
+        self.as_str().map(|s| s.parse())
+    }
+
     #[inline]
     fn parse_datetime(&self) -> Option<Result<DateTime, chrono::format::ParseError>> {
         self.as_str().map(|s| s.parse())
diff --git a/zino-core/src/extension/toml_table.rs b/zino-core/src/extension/toml_table.rs
index 4e4075fe..030b3fde 100644
--- a/zino-core/src/extension/toml_table.rs
+++ b/zino-core/src/extension/toml_table.rs
@@ -27,6 +27,14 @@ pub trait TomlTableExt {
     /// represents it as `usize` if possible.
     fn get_usize(&self, key: &str) -> Option<usize>;
 
+    /// Extracts the integer value corresponding to the key and
+    /// represents it as `i8` if possible.
+    fn get_i8(&self, key: &str) -> Option<i8>;
+
+    /// Extracts the integer value corresponding to the key and
+    /// represents it as `i16` if possible.
+    fn get_i16(&self, key: &str) -> Option<i16>;
+
     /// Extracts the integer value corresponding to the key and
     /// represents it as `i32` if possible.
     fn get_i32(&self, key: &str) -> Option<i32>;
@@ -34,6 +42,10 @@ pub trait TomlTableExt {
     /// Extracts the integer value corresponding to the key.
     fn get_i64(&self, key: &str) -> Option<i64>;
 
+    /// Extracts the integer value corresponding to the key and
+    /// represents it as `isize` if possible.
+    fn get_isize(&self, key: &str) -> Option<isize>;
+
     /// Extracts the float value corresponding to the key and
     /// represents it as `f32` if possible.
     fn get_f32(&self, key: &str) -> Option<f32>;
@@ -108,6 +120,20 @@ impl TomlTableExt for Table {
             .and_then(|i| usize::try_from(i).ok())
     }
 
+    #[inline]
+    fn get_i8(&self, key: &str) -> Option<i8> {
+        self.get(key)
+            .and_then(|v| v.as_integer())
+            .and_then(|i| i8::try_from(i).ok())
+    }
+
+    #[inline]
+    fn get_i16(&self, key: &str) -> Option<i16> {
+        self.get(key)
+            .and_then(|v| v.as_integer())
+            .and_then(|i| i16::try_from(i).ok())
+    }
+
     #[inline]
     fn get_i32(&self, key: &str) -> Option<i32> {
         self.get(key)
@@ -120,6 +146,13 @@ impl TomlTableExt for Table {
         self.get(key).and_then(|v| v.as_integer())
     }
 
+    #[inline]
+    fn get_isize(&self, key: &str) -> Option<isize> {
+        self.get(key)
+            .and_then(|v| v.as_integer())
+            .and_then(|i| isize::try_from(i).ok())
+    }
+
     #[inline]
     fn get_f32(&self, key: &str) -> Option<f32> {
         self.get(key).and_then(|v| v.as_float()).map(|f| f as f32)
diff --git a/zino-core/src/extension/toml_value.rs b/zino-core/src/extension/toml_value.rs
index d0ba33d3..a50f5e49 100644
--- a/zino-core/src/extension/toml_value.rs
+++ b/zino-core/src/extension/toml_value.rs
@@ -19,10 +19,22 @@ pub trait TomlValueExt {
     /// Returns `None` otherwise.
     fn as_usize(&self) -> Option<usize>;
 
+    /// If the `Value` is an integer, represent it as `i8` if possible.
+    /// Returns `None` otherwise.
+    fn as_i8(&self) -> Option<i8>;
+
+    /// If the `Value` is an integer, represent it as `i16` if possible.
+    /// Returns `None` otherwise.
+    fn as_i16(&self) -> Option<i16>;
+
     /// If the `Value` is an integer, represent it as `i32` if possible.
     /// Returns `None` otherwise.
     fn as_i32(&self) -> Option<i32>;
 
+    /// If the `Value` is an integer, represent it as `isize` if possible.
+    /// Returns `None` otherwise.
+    fn as_isize(&self) -> Option<isize>;
+
     /// If the `Value` is a float, represent it as `f32` if possible.
     /// Returns `None` otherwise.
     fn as_f32(&self) -> Option<f32>;
@@ -52,11 +64,26 @@ impl TomlValueExt for TomlValue {
         self.as_integer().and_then(|i| usize::try_from(i).ok())
     }
 
+    #[inline]
+    fn as_i8(&self) -> Option<i8> {
+        self.as_integer().and_then(|i| i8::try_from(i).ok())
+    }
+
+    #[inline]
+    fn as_i16(&self) -> Option<i16> {
+        self.as_integer().and_then(|i| i16::try_from(i).ok())
+    }
+
     #[inline]
     fn as_i32(&self) -> Option<i32> {
         self.as_integer().and_then(|i| i32::try_from(i).ok())
     }
 
+    #[inline]
+    fn as_isize(&self) -> Option<isize> {
+        self.as_integer().and_then(|i| isize::try_from(i).ok())
+    }
+
     #[inline]
     fn as_f32(&self) -> Option<f32> {
         self.as_float().map(|f| f as f32)
diff --git a/zino-core/src/orm/decode.rs b/zino-core/src/orm/decode.rs
index ccbc3be6..6140a9b6 100644
--- a/zino-core/src/orm/decode.rs
+++ b/zino-core/src/orm/decode.rs
@@ -1,8 +1,30 @@
 use super::{DatabaseDriver, DatabaseRow};
 use crate::{error::Error, BoxError};
-use chrono::{DateTime, Local};
+use chrono::{DateTime, Local, NaiveDate, NaiveTime};
 use sqlx::{database::HasValueRef, Database, Decode, Row, Type};
 
+impl<DB> Type<DB> for crate::datetime::Date
+where
+    DB: Database,
+    NaiveDate: Type<DB>,
+{
+    #[inline]
+    fn type_info() -> <DB as Database>::TypeInfo {
+        <NaiveDate as Type<DB>>::type_info()
+    }
+}
+
+impl<DB> Type<DB> for crate::datetime::Time
+where
+    DB: Database,
+    NaiveTime: Type<DB>,
+{
+    #[inline]
+    fn type_info() -> <DB as Database>::TypeInfo {
+        <NaiveTime as Type<DB>>::type_info()
+    }
+}
+
 impl<DB> Type<DB> for crate::datetime::DateTime
 where
     DB: Database,
@@ -14,6 +36,28 @@ where
     }
 }
 
+impl<'r, DB> Decode<'r, DB> for crate::datetime::Date
+where
+    DB: Database,
+    NaiveDate: Decode<'r, DB>,
+{
+    #[inline]
+    fn decode(value: <DB as HasValueRef<'r>>::ValueRef) -> Result<Self, BoxError> {
+        <NaiveDate as Decode<'r, DB>>::decode(value).map(|dt| dt.into())
+    }
+}
+
+impl<'r, DB> Decode<'r, DB> for crate::datetime::Time
+where
+    DB: Database,
+    NaiveTime: Decode<'r, DB>,
+{
+    #[inline]
+    fn decode(value: <DB as HasValueRef<'r>>::ValueRef) -> Result<Self, BoxError> {
+        <NaiveTime as Decode<'r, DB>>::decode(value).map(|dt| dt.into())
+    }
+}
+
 impl<'r, DB> Decode<'r, DB> for crate::datetime::DateTime
 where
     DB: Database,
diff --git a/zino-core/src/orm/mod.rs b/zino-core/src/orm/mod.rs
index fbc5f325..a17c4ad3 100644
--- a/zino-core/src/orm/mod.rs
+++ b/zino-core/src/orm/mod.rs
@@ -67,6 +67,7 @@
 //! | `$not`     | `NOT`               | `NOT`            | `NOT`                 |
 //! | `$rand`    | `rand()`            | `random()`       | `abs(random())`       |
 //! | `$text`    | `match() against()` | `to_tsvector()`  | `MATCH`               |
+//! | `$ovlp`    | `overlaps()`        | `OVERLAPS`       | N/A                   |
 //! | `$eq`      | `=`                 | `=`              | `=`                   |
 //! | `$ne`      | `<>`                | `<>`             | `<>`                  |
 //! | `$lt`      | `<`                 | `<`              | `<`                   |
@@ -81,7 +82,6 @@
 //! | `$rlike`   | `RLIKE`             | `~*`             | `REGEXP`              |
 //! | `$glob`    | N/A                 | N/A              | `GLOB`                |
 //! | `$is`      | `IS`                | `IS`             | `IS`                  |
-//! | `$all`     | N/A                 | `@>`             | N/A                   |
 //! | `$size`    | `json_length()`     | `array_length()` | `json_array_length()` |
 //!
 //! [`Mongoose`]: https://mongoosejs.com/
diff --git a/zino-core/src/orm/mysql.rs b/zino-core/src/orm/mysql.rs
index e3ac314a..3183a205 100644
--- a/zino-core/src/orm/mysql.rs
+++ b/zino-core/src/orm/mysql.rs
@@ -1,12 +1,12 @@
 use super::{query::QueryExt, DatabaseDriver, DatabaseRow, Schema};
 use crate::{
-    datetime::DateTime,
+    datetime::{Date, DateTime, Time},
     error::Error,
     extension::{JsonObjectExt, JsonValueExt},
     model::{Column, DecodeRow, EncodeColumn, Query},
     AvroValue, JsonValue, Map, Record, SharedString, Uuid,
 };
-use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
+use chrono::NaiveDateTime;
 use std::borrow::Cow;
 
 #[cfg(feature = "orm-sqlx")]
@@ -37,10 +37,10 @@ impl<'c> EncodeColumn<DatabaseDriver> for Column<'c> {
                     "TEXT"
                 }
             }
+            "Date" | "NaiveDate" => "DATE",
+            "Time" | "NaiveTime" => "TIME",
             "DateTime" => "TIMESTAMP(6)",
             "NaiveDateTime" => "DATETIME(6)",
-            "NaiveDate" | "Date" => "DATE",
-            "NaiveTime" | "Time" => "TIME",
             "Uuid" | "Option<Uuid>" => "CHAR(36)",
             "Vec<u8>" => "BLOB",
             "Vec<String>" | "Vec<Uuid>" | "Vec<u64>" | "Vec<i64>" | "Vec<u32>" | "Vec<i32>"
@@ -308,7 +308,48 @@ impl<'c> EncodeColumn<DatabaseDriver> for Column<'c> {
                     format!(r#"{field} = {value}"#)
                 }
             }
-            "DateTime" | "Date" | "Time" | "NaiveDateTime" | "NaiveDate" | "NaiveTime" => {
+            "DateTime" | "NaiveDateTime" => {
+                if let Some(value) = value.as_str() {
+                    if let Some((min_value, max_value)) = value.split_once(',') {
+                        let min_value = self.format_value(min_value);
+                        let max_value = self.format_value(max_value);
+                        format!(r#"{field} >= {min_value} AND {field} < {max_value}"#)
+                    } else {
+                        let length = value.len();
+                        let value = self.format_value(value);
+                        match length {
+                            4 => format!(r#"date_format({field}, '%Y') = {value}"#),
+                            7 => format!(r#"date_format({field}, '%Y-%m') = {value}"#),
+                            10 => format!(r#"date_format({field}, '%Y-%m-%d') = {value}"#),
+                            _ => format!(r#"{field} = {value}"#),
+                        }
+                    }
+                } else {
+                    let value = self.encode_value(Some(value));
+                    format!(r#"{field} = {value}"#)
+                }
+            }
+            "Date" | "NaiveDate" => {
+                if let Some(value) = value.as_str() {
+                    if let Some((min_value, max_value)) = value.split_once(',') {
+                        let min_value = self.format_value(min_value);
+                        let max_value = self.format_value(max_value);
+                        format!(r#"{field} >= {min_value} AND {field} < {max_value}"#)
+                    } else {
+                        let length = value.len();
+                        let value = self.format_value(value);
+                        match length {
+                            4 => format!(r#"date_format({field}, '%Y') = {value}"#),
+                            7 => format!(r#"date_format({field}, '%Y-%m') = {value}"#),
+                            _ => format!(r#"{field} = {value}"#),
+                        }
+                    }
+                } else {
+                    let value = self.encode_value(Some(value));
+                    format!(r#"{field} = {value}"#)
+                }
+            }
+            "Time" | "NaiveTime" => {
                 if let Some(value) = value.as_str() {
                     if let Some((min_value, max_value)) = value.split_once(',') {
                         let min_value = self.format_value(min_value);
@@ -415,12 +456,8 @@ impl DecodeRow<DatabaseRow> for Map {
                     "DATETIME" => decode_raw::<NaiveDateTime>(field, raw_value)?
                         .to_string()
                         .into(),
-                    "DATE" => decode_raw::<NaiveDate>(field, raw_value)?
-                        .to_string()
-                        .into(),
-                    "TIME" => decode_raw::<NaiveTime>(field, raw_value)?
-                        .to_string()
-                        .into(),
+                    "DATE" => decode_raw::<Date>(field, raw_value)?.into(),
+                    "TIME" => decode_raw::<Time>(field, raw_value)?.into(),
                     "BYTE" | "BINARY" | "VARBINARY" | "BLOB" => {
                         let bytes = decode_raw::<Vec<u8>>(field, raw_value)?;
                         if bytes.len() == 16 {
@@ -491,12 +528,8 @@ impl DecodeRow<DatabaseRow> for Record {
                     "DATETIME" => decode_raw::<NaiveDateTime>(field, raw_value)?
                         .to_string()
                         .into(),
-                    "DATE" => decode_raw::<NaiveDate>(field, raw_value)?
-                        .to_string()
-                        .into(),
-                    "TIME" => decode_raw::<NaiveTime>(field, raw_value)?
-                        .to_string()
-                        .into(),
+                    "DATE" => decode_raw::<Date>(field, raw_value)?.into(),
+                    "TIME" => decode_raw::<Time>(field, raw_value)?.into(),
                     "BYTE" | "BINARY" | "VARBINARY" | "BLOB" => {
                         let bytes = decode_raw::<Vec<u8>>(field, raw_value)?;
                         if bytes.len() == 16 {
diff --git a/zino-core/src/orm/postgres.rs b/zino-core/src/orm/postgres.rs
index 2d600e92..5d72353d 100644
--- a/zino-core/src/orm/postgres.rs
+++ b/zino-core/src/orm/postgres.rs
@@ -1,12 +1,12 @@
 use super::{query::QueryExt, DatabaseDriver, DatabaseRow, Schema};
 use crate::{
-    datetime::DateTime,
+    datetime::{Date, DateTime, Time},
     error::Error,
     extension::{JsonObjectExt, JsonValueExt},
     model::{Column, DecodeRow, EncodeColumn, Query},
     AvroValue, JsonValue, Map, Record, SharedString, Uuid,
 };
-use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
+use chrono::NaiveDateTime;
 use std::borrow::Cow;
 
 #[cfg(feature = "orm-sqlx")]
@@ -43,10 +43,10 @@ impl<'c> EncodeColumn<DatabaseDriver> for Column<'c> {
             "f64" => "DOUBLE PRECISION",
             "f32" => "REAL",
             "Decimal" => "NUMERIC",
+            "Date" | "NaiveDate" => "DATE",
+            "Time" | "NaiveTime" => "TIME",
             "DateTime" => "TIMESTAMPTZ",
             "NaiveDateTime" => "TIMESTAMP",
-            "NaiveDate" | "Date" => "DATE",
-            "NaiveTime" | "Time" => "TIME",
             "Uuid" | "Option<Uuid>" => "UUID",
             "Vec<u8>" => "BYTEA",
             "Vec<String>" => "TEXT[]",
@@ -198,7 +198,6 @@ impl<'c> EncodeColumn<DatabaseDriver> for Column<'c> {
                         "$ilike" => "ILIKE",
                         "$rlike" => "~*",
                         "$is" => "IS",
-                        "$all" => "@>",
                         "$size" => "array_length",
                         _ => {
                             if cfg!(debug_assertions) && name.starts_with('$') {
@@ -333,7 +332,48 @@ impl<'c> EncodeColumn<DatabaseDriver> for Column<'c> {
                     format!(r#"{field} = {value}"#)
                 }
             }
-            "DateTime" | "Date" | "Time" | "NaiveDateTime" | "NaiveDate" | "NaiveTime" => {
+            "DateTime" | "NaiveDateTime" => {
+                if let Some(value) = value.as_str() {
+                    if let Some((min_value, max_value)) = value.split_once(',') {
+                        let min_value = self.format_value(min_value);
+                        let max_value = self.format_value(max_value);
+                        format!(r#"{field} >= {min_value} AND {field} < {max_value}"#)
+                    } else {
+                        let length = value.len();
+                        let value = self.format_value(value);
+                        match length {
+                            4 => format!(r#"to_char({field}, 'YYYY') = {value}"#),
+                            7 => format!(r#"to_char({field}, 'YYYY-MM') = {value}"#),
+                            10 => format!(r#"to_char({field}, 'YYYY-MM-DD') = {value}"#),
+                            _ => format!(r#"{field} = {value}"#),
+                        }
+                    }
+                } else {
+                    let value = self.encode_value(Some(value));
+                    format!(r#"{field} = {value}"#)
+                }
+            }
+            "Date" | "NaiveDate" => {
+                if let Some(value) = value.as_str() {
+                    if let Some((min_value, max_value)) = value.split_once(',') {
+                        let min_value = self.format_value(min_value);
+                        let max_value = self.format_value(max_value);
+                        format!(r#"{field} >= {min_value} AND {field} < {max_value}"#)
+                    } else {
+                        let length = value.len();
+                        let value = self.format_value(value);
+                        match length {
+                            4 => format!(r#"to_char({field}, 'YYYY') = {value}"#),
+                            7 => format!(r#"to_char({field}, 'YYYY-MM') = {value}"#),
+                            _ => format!(r#"{field} = {value}"#),
+                        }
+                    }
+                } else {
+                    let value = self.encode_value(Some(value));
+                    format!(r#"{field} = {value}"#)
+                }
+            }
+            "Time" | "NaiveTime" => {
                 if let Some(value) = value.as_str() {
                     if let Some((min_value, max_value)) = value.split_once(',') {
                         let min_value = self.format_value(min_value);
@@ -441,12 +481,8 @@ impl DecodeRow<DatabaseRow> for Map {
                     "TIMESTAMP" => decode_raw::<NaiveDateTime>(field, raw_value)?
                         .to_string()
                         .into(),
-                    "DATE" => decode_raw::<NaiveDate>(field, raw_value)?
-                        .to_string()
-                        .into(),
-                    "TIME" => decode_raw::<NaiveTime>(field, raw_value)?
-                        .to_string()
-                        .into(),
+                    "DATE" => decode_raw::<Date>(field, raw_value)?.into(),
+                    "TIME" => decode_raw::<Time>(field, raw_value)?.into(),
                     "UUID" => decode_raw::<Uuid>(field, raw_value)?.to_string().into(),
                     "BYTEA" => decode_raw::<Vec<u8>>(field, raw_value)?.into(),
                     "INT4[]" => decode_raw::<Vec<i32>>(field, raw_value)?.into(),
@@ -498,12 +534,8 @@ impl DecodeRow<DatabaseRow> for Record {
                     "TIMESTAMP" => decode_raw::<NaiveDateTime>(field, raw_value)?
                         .to_string()
                         .into(),
-                    "DATE" => decode_raw::<NaiveDate>(field, raw_value)?
-                        .to_string()
-                        .into(),
-                    "TIME" => decode_raw::<NaiveTime>(field, raw_value)?
-                        .to_string()
-                        .into(),
+                    "DATE" => decode_raw::<Date>(field, raw_value)?.into(),
+                    "TIME" => decode_raw::<Time>(field, raw_value)?.into(),
                     "UUID" => decode_raw::<Uuid>(field, raw_value)?.into(),
                     "BYTEA" => decode_raw::<Vec<u8>>(field, raw_value)?.into(),
                     "INT4[]" => {
diff --git a/zino-core/src/orm/query.rs b/zino-core/src/orm/query.rs
index a0a751dd..e5944345 100644
--- a/zino-core/src/orm/query.rs
+++ b/zino-core/src/orm/query.rs
@@ -131,6 +131,34 @@ pub(super) trait QueryExt<DB> {
                         }
                     }
                 }
+                "$ovlp" => {
+                    if let Some(value) = value.parse_str_array()
+                        && let &[start_field, end_field, start_value, end_value] = value.as_slice()
+                    {
+                        let start_field = Self::format_field(start_field);
+                        let end_field = Self::format_field(end_field);
+                        let start_value = Self::escape_string(start_value);
+                        let end_value = Self::escape_string(end_value);
+                        let condition = if cfg!(any(
+                            feature = "orm-mariadb",
+                            feature = "orm-mysql",
+                            feature = "orm-tidb"
+                        )) {
+                            format!(
+                                r#"overlaps({start_field}, {end_field}, {start_value}, {end_value})"#
+                            )
+                        } else if cfg!(feature = "orm-postgres") {
+                            format!(
+                                r#"({start_field}, {end_field}) OVERLAPS ({start_value}, {end_value})"#
+                            )
+                        } else {
+                            format!(
+                                r#"({start_field} <= {end_value} AND {end_field} >= {start_value})"#
+                            )
+                        };
+                        conditions.push(condition);
+                    }
+                }
                 _ => {
                     if let Some(col) = M::get_column(key) {
                         let condition = col.format_filter(key, value);
@@ -195,6 +223,35 @@ pub(super) trait QueryExt<DB> {
                                 conditions.push(condition);
                             }
                         }
+                        "$ovlp" => {
+                            if let Some(value) = value.parse_str_array()
+                                && let &[start_field, end_field, start_value, end_value] =
+                                    value.as_slice()
+                            {
+                                let start_field = Self::format_field(start_field);
+                                let end_field = Self::format_field(end_field);
+                                let start_value = Self::escape_string(start_value);
+                                let end_value = Self::escape_string(end_value);
+                                let condition = if cfg!(any(
+                                    feature = "orm-mariadb",
+                                    feature = "orm-mysql",
+                                    feature = "orm-tidb"
+                                )) {
+                                    format!(
+                                        r#"overlaps({start_field}, {end_field}, {start_value}, {end_value})"#
+                                    )
+                                } else if cfg!(feature = "orm-postgres") {
+                                    format!(
+                                        r#"({start_field}, {end_field}) OVERLAPS ({start_value}, {end_value})"#
+                                    )
+                                } else {
+                                    format!(
+                                        r#"({start_field} <= {end_value} AND {end_field} >= {start_value})"#
+                                    )
+                                };
+                                conditions.push(condition);
+                            }
+                        }
                         _ => {
                             if let Some(col) = M::get_column(key) {
                                 let condition = col.format_filter(key, value);
diff --git a/zino-core/src/orm/sqlite.rs b/zino-core/src/orm/sqlite.rs
index 86bf0486..35c40116 100644
--- a/zino-core/src/orm/sqlite.rs
+++ b/zino-core/src/orm/sqlite.rs
@@ -1,12 +1,11 @@
 use super::{query::QueryExt, DatabaseDriver, DatabaseRow, Schema};
 use crate::{
-    datetime::DateTime,
+    datetime::{Date, DateTime, Time},
     error::Error,
     extension::{JsonObjectExt, JsonValueExt},
     model::{Column, DecodeRow, EncodeColumn, Query},
     AvroValue, JsonValue, Map, Record, SharedString, Uuid,
 };
-use chrono::{NaiveDate, NaiveTime};
 use std::borrow::Cow;
 
 #[cfg(feature = "orm-sqlx")]
@@ -290,7 +289,48 @@ impl<'c> EncodeColumn<DatabaseDriver> for Column<'c> {
                     format!(r#"{field} = {value}"#)
                 }
             }
-            "DateTime" | "Date" | "Time" | "NaiveDateTime" | "NaiveDate" | "NaiveTime" => {
+            "DateTime" | "NaiveDateTime" => {
+                if let Some(value) = value.as_str() {
+                    if let Some((min_value, max_value)) = value.split_once(',') {
+                        let min_value = self.format_value(min_value);
+                        let max_value = self.format_value(max_value);
+                        format!(r#"{field} >= {min_value} AND {field} < {max_value}"#)
+                    } else {
+                        let length = value.len();
+                        let value = self.format_value(value);
+                        match length {
+                            4 => format!(r#"strftime('%Y', {field}) = {value}"#),
+                            7 => format!(r#"strftime('%Y-%m', {field}) = {value}"#),
+                            10 => format!(r#"strftime('%Y-%m-%d', {field}) = {value}"#),
+                            _ => format!(r#"{field} = {value}"#),
+                        }
+                    }
+                } else {
+                    let value = self.encode_value(Some(value));
+                    format!(r#"{field} = {value}"#)
+                }
+            }
+            "Date" | "NaiveDate" => {
+                if let Some(value) = value.as_str() {
+                    if let Some((min_value, max_value)) = value.split_once(',') {
+                        let min_value = self.format_value(min_value);
+                        let max_value = self.format_value(max_value);
+                        format!(r#"{field} >= {min_value} AND {field} < {max_value}"#)
+                    } else {
+                        let length = value.len();
+                        let value = self.format_value(value);
+                        match length {
+                            4 => format!(r#"strftime('%Y', {field}) = {value}"#),
+                            7 => format!(r#"strftime('%Y-%m', {field}) = {value}"#),
+                            _ => format!(r#"{field} = {value}"#),
+                        }
+                    }
+                } else {
+                    let value = self.encode_value(Some(value));
+                    format!(r#"{field} = {value}"#)
+                }
+            }
+            "Time" | "NaiveTime" => {
                 if let Some(value) = value.as_str() {
                     if let Some((min_value, max_value)) = value.split_once(',') {
                         let min_value = self.format_value(min_value);
@@ -393,12 +433,8 @@ impl DecodeRow<DatabaseRow> for Map {
                         }
                     }
                     "DATETIME" => decode_raw::<DateTime>(field, raw_value)?.into(),
-                    "DATE" => decode_raw::<NaiveDate>(field, raw_value)?
-                        .to_string()
-                        .into(),
-                    "TIME" => decode_raw::<NaiveTime>(field, raw_value)?
-                        .to_string()
-                        .into(),
+                    "DATE" => decode_raw::<Date>(field, raw_value)?.into(),
+                    "TIME" => decode_raw::<Time>(field, raw_value)?.into(),
                     "BLOB" => {
                         let bytes = decode_raw::<Vec<u8>>(field, raw_value)?;
                         if bytes.len() == 16 {
@@ -452,12 +488,8 @@ impl DecodeRow<DatabaseRow> for Record {
                         }
                     }
                     "DATETIME" => decode_raw::<DateTime>(field, raw_value)?.to_string().into(),
-                    "DATE" => decode_raw::<NaiveDate>(field, raw_value)?
-                        .to_string()
-                        .into(),
-                    "TIME" => decode_raw::<NaiveTime>(field, raw_value)?
-                        .to_string()
-                        .into(),
+                    "DATE" => decode_raw::<Date>(field, raw_value)?.into(),
+                    "TIME" => decode_raw::<Time>(field, raw_value)?.into(),
                     "BLOB" => {
                         let bytes = decode_raw::<Vec<u8>>(field, raw_value)?;
                         if bytes.len() == 16 {
diff --git a/zino-core/src/validation/validator/date.rs b/zino-core/src/validation/validator/date.rs
index bed8dc4d..2109aeb1 100644
--- a/zino-core/src/validation/validator/date.rs
+++ b/zino-core/src/validation/validator/date.rs
@@ -1,8 +1,9 @@
 use super::Validator;
-use chrono::{format::ParseError, NaiveDate};
+use crate::datetime::Date;
+use chrono::format::ParseError;
 use std::str::FromStr;
 
-/// A validator for date.
+/// A validator for [`Date`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct DateValidator;
 
@@ -11,7 +12,7 @@ impl Validator<str> for DateValidator {
 
     #[inline]
     fn validate(&self, data: &str) -> Result<(), Self::Error> {
-        NaiveDate::from_str(data)?;
+        Date::from_str(data)?;
         Ok(())
     }
 }
diff --git a/zino-core/src/validation/validator/time.rs b/zino-core/src/validation/validator/time.rs
index d182ce59..ced87c1e 100644
--- a/zino-core/src/validation/validator/time.rs
+++ b/zino-core/src/validation/validator/time.rs
@@ -1,8 +1,9 @@
 use super::Validator;
-use chrono::{format::ParseError, NaiveTime};
+use crate::datetime::Time;
+use chrono::format::ParseError;
 use std::str::FromStr;
 
-/// A validator for time.
+/// A validator for [`Time`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct TimeValidator;
 
@@ -11,7 +12,7 @@ impl Validator<str> for TimeValidator {
 
     #[inline]
     fn validate(&self, data: &str) -> Result<(), Self::Error> {
-        NaiveTime::from_str(data)?;
+        Time::from_str(data)?;
         Ok(())
     }
 }
diff --git a/zino-derive/docs/model_hooks.md b/zino-derive/docs/model_hooks.md
index 31dcc4c4..c840a517 100644
--- a/zino-derive/docs/model_hooks.md
+++ b/zino-derive/docs/model_hooks.md
@@ -1 +1,9 @@
 Derives the [`ModelHooks`](zino_core::model::ModelHooks) trait.
+
+# Attributes on struct fields
+
+- **`#[schema(corelates_with = "field")]`**: The `corelates_with` attribute specifies
+  a field from whose referenced model the column value is copied.
+
+- **`#[schema(referenced_field = "field")]`**: The `referenced_field` attribute specifies
+  the original field name in the corresponding referenced model.
diff --git a/zino-derive/src/model_accessor.rs b/zino-derive/src/model_accessor.rs
index dc90e64e..d6655067 100644
--- a/zino-derive/src/model_accessor.rs
+++ b/zino-derive/src/model_accessor.rs
@@ -1,6 +1,7 @@
 use super::parser;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
+use std::collections::HashMap;
 use syn::{Data, DeriveInput, Fields};
 
 /// Parses the token stream for the `ModelAccessor` trait derivation.
@@ -56,7 +57,7 @@ pub(super) fn parse_token_stream(input: DeriveInput) -> TokenStream {
     if let Data::Struct(data) = input.data
         && let Fields::Named(fields) = data.fields
     {
-        let mut model_references: Vec<(String, Vec<String>)> = Vec::new();
+        let mut model_references: HashMap<String, Vec<String>> = HashMap::new();
         for field in fields.named.into_iter() {
             let type_name = parser::get_type_name(&field.ty);
             if let Some(ident) = field.ident
@@ -170,9 +171,10 @@ pub(super) fn parse_token_stream(input: DeriveInput) -> TokenStream {
                                             }
                                         });
                                     }
-                                    match model_references.iter_mut().find(|r| r.0 == value) {
-                                        Some(r) => r.1.push(name.clone()),
-                                        None => model_references.push((value, vec![name.clone()])),
+                                    if let Some(vec) = model_references.get_mut(&value) {
+                                        vec.push(name.clone());
+                                    } else {
+                                        model_references.insert(value, vec![name.clone()]);
                                     }
                                 }
                             }
@@ -702,36 +704,21 @@ pub(super) fn parse_token_stream(input: DeriveInput) -> TokenStream {
                 }
             }
         }
-        if model_references.is_empty() {
-            populated_queries.push(quote! {
-                let mut models = Self::find::<Map>(query).await?;
-                for model in models.iter_mut() {
-                    Self::after_decode(model).await?;
-                    translate_enabled.then(|| Self::translate_model(model));
-                }
-            });
-            populated_one_queries.push(quote! {
-                let mut model = Self::find_by_id::<Map>(id)
-                    .await?
-                    .ok_or_else(|| zino_core::warn!("404 Not Found: cannot find the model `{}`", id))?;
-                Self::after_decode(&mut model).await?;
-                Self::translate_model(&mut model);
-            });
-        } else {
-            populated_queries.push(quote! {
-                let mut models = Self::find::<Map>(query).await?;
-                for model in models.iter_mut() {
-                    Self::after_decode(model).await?;
-                    translate_enabled.then(|| Self::translate_model(model));
-                }
-            });
-            populated_one_queries.push(quote! {
-                let mut model = Self::find_by_id::<Map>(id)
-                    .await?
-                    .ok_or_else(|| zino_core::warn!("404 Not Found: cannot find the model `{}`", id))?;
-                Self::after_decode(&mut model).await?;
-                Self::translate_model(&mut model);
-            });
+        populated_queries.push(quote! {
+            let mut models = Self::find::<Map>(query).await?;
+            for model in models.iter_mut() {
+                Self::after_decode(model).await?;
+                translate_enabled.then(|| Self::translate_model(model));
+            }
+        });
+        populated_one_queries.push(quote! {
+            let mut model = Self::find_by_id::<Map>(id)
+                .await?
+                .ok_or_else(|| zino_core::warn!("404 Not Found: cannot find the model `{}`", id))?;
+            Self::after_decode(&mut model).await?;
+            Self::translate_model(&mut model);
+        });
+        if !model_references.is_empty() {
             for (model, ref_fields) in model_references.into_iter() {
                 let model_ident = format_ident!("{}", model);
                 let populated_query = quote! {
diff --git a/zino-derive/src/model_hooks.rs b/zino-derive/src/model_hooks.rs
index 257fc4d0..4a34cc73 100644
--- a/zino-derive/src/model_hooks.rs
+++ b/zino-derive/src/model_hooks.rs
@@ -1,15 +1,98 @@
+use super::parser;
 use proc_macro2::TokenStream;
-use quote::quote;
-use syn::DeriveInput;
+use quote::{format_ident, quote};
+use std::collections::HashMap;
+use syn::{Data, DeriveInput, Fields};
 
 /// Parses the token stream for the `ModelHooks` trait derivation.
 pub(super) fn parse_token_stream(input: DeriveInput) -> TokenStream {
-    // Parsing field attributes
+    // Model name
     let name = input.ident;
-    quote! {
-        impl zino_core::model::ModelHooks for #name {
-            type Data = ();
-            type Extension = ();
+
+    // Parsing field attributes
+    let mut embedding_queries = Vec::new();
+    if let Data::Struct(data) = input.data
+        && let Fields::Named(fields) = data.fields
+    {
+        let mut model_mappings: HashMap<String, String> = HashMap::new();
+        let mut field_embeddings: HashMap<String, Vec<(String, String)>> = HashMap::new();
+        for field in fields.named.into_iter() {
+            let type_name = parser::get_type_name(&field.ty);
+            if let Some(ident) = field.ident
+                && !type_name.is_empty()
+            {
+                let name = ident.to_string();
+                let mut correlatation_field = None;
+                let mut field_mapping = None;
+                for attr in field.attrs.iter() {
+                    let arguments = parser::parse_schema_attr(attr);
+                    for (key, value) in arguments.into_iter() {
+                        match key.as_str() {
+                            "reference" => {
+                                if let Some(value) = value {
+                                    model_mappings.insert(name.clone(), value);
+                                }
+                            }
+                            "correlates_with" => {
+                                correlatation_field = value;
+                            }
+                            "referenced_field" => {
+                                if let Some(value) = value {
+                                    field_mapping = Some((name.clone(), value));
+                                }
+                            }
+                            _ => (),
+                        }
+                    }
+                }
+                if let Some(correlatation_field) = correlatation_field
+                    && let Some(field_mapping) = field_mapping
+                {
+                    if let Some(vec) = field_embeddings.get_mut(&correlatation_field) {
+                        vec.push(field_mapping);
+                    } else {
+                        field_embeddings.insert(correlatation_field, vec![field_mapping]);
+                    }
+                }
+            }
+        }
+        for (correlatation_field, model) in model_mappings.into_iter() {
+            if let Some(field_mappings) = field_embeddings.get(&correlatation_field) {
+                let model_ident = format_ident!("{}", model);
+                for (field, referenced_field) in field_mappings {
+                    embedding_queries.push(quote! {
+                        if data.contains_key(#correlatation_field) {
+                            let id = &self.#correlatation_field;
+                            let value = <#model_ident>::find_scalar_by_id(&id, #referenced_field).await?;
+                            self.#field = value;
+                            data.upsert(#field, value.to_string());
+                        }
+                    });
+                }
+            }
+        }
+    }
+    if embedding_queries.is_empty() {
+        quote! {
+            use zino_core::model::ModelHooks;
+
+            impl ModelHooks for #name {
+                type Data = ();
+                type Extension = ();
+            }
+        }
+    } else {
+        quote! {
+            use zino_core::{model::{ModelHooks, QueryContext}, schema::ScalarQuery};
+
+            impl ModelHooks for #name {
+                type Data = ();
+                type Extension = ();
+
+                async fn after_validation(&mut self, data: &mut Map) -> Result<(), Error> {
+                    #(#embedding_queries)*
+                }
+            }
         }
     }
 }
diff --git a/zino/src/prelude/mod.rs b/zino/src/prelude/mod.rs
index 5b5c60c7..5c63f8f3 100644
--- a/zino/src/prelude/mod.rs
+++ b/zino/src/prelude/mod.rs
@@ -9,7 +9,7 @@ pub use zino_core::{
         AccessKeyId, AuthorizationProvider, JwtClaims, SecretAccessKey, SecurityToken, UserSession,
     },
     bail,
-    datetime::DateTime,
+    datetime::{Date, DateTime, Time},
     error::Error,
     extension::{JsonObjectExt, JsonValueExt, TomlTableExt},
     file::NamedFile,