feat: function extract, date_part,date_diff support more date part (#17759)

* date_diff support more date part

* add typos wrong case

Author: TCeason

.typos.toml

@@ -14,6 +14,7 @@
 "flate" = "flate"
 "Tke" = "Tke"
 "typ" = "typ"
+"dows" = "dows"
 
 [files]
 extend-exclude = [

src/query/ast/src/ast/expr.rs

@@ -845,6 +845,9 @@ pub enum IntervalKind {
     Dow,
     Epoch,
     MicroSecond,
+    ISODow,
+    YearWeek,
+    Millennium,
 }
 
 impl Display for IntervalKind {
@@ -860,6 +863,9 @@ impl Display for IntervalKind {
             IntervalKind::Second => "SECOND",
             IntervalKind::Doy => "DOY",
             IntervalKind::Dow => "DOW",
+            IntervalKind::ISODow => "ISODOW",
+            IntervalKind::YearWeek => "YEARWEEK",
+            IntervalKind::Millennium => "MILLENNIUM",
             IntervalKind::Week => "WEEK",
             IntervalKind::Epoch => "EPOCH",
             IntervalKind::MicroSecond => "MICROSECOND",

src/query/ast/src/parser/expr.rs

@@ -1854,9 +1854,12 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
     let second = value(IntervalKind::Second, rule! { SECOND });
     let doy = value(IntervalKind::Doy, rule! { DOY });
     let dow = value(IntervalKind::Dow, rule! { DOW });
+    let isodow = value(IntervalKind::ISODow, rule! { ISODOW });
     let week = value(IntervalKind::Week, rule! { WEEK });
     let epoch = value(IntervalKind::Epoch, rule! { EPOCH });
     let microsecond = value(IntervalKind::MicroSecond, rule! { MICROSECOND });
+    let millennium = value(IntervalKind::Millennium, rule! { MILLENNIUM });
+    let yearweek = value(IntervalKind::YearWeek, rule! { YEARWEEK });
 
     let iso_year_str = value(
         IntervalKind::ISOYear,
@@ -1892,15 +1895,19 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
     );
     let doy_str = value(
         IntervalKind::Doy,
-        rule! { #literal_string_eq_ignore_case("DOY")  },
+        rule! { #literal_string_eq_ignore_case("DOY") | #literal_string_eq_ignore_case("DAYOFYEAR")  },
     );
     let dow_str = value(
         IntervalKind::Dow,
-        rule! { #literal_string_eq_ignore_case("DOW")  },
+        rule! { (#literal_string_eq_ignore_case("DOW") | #literal_string_eq_ignore_case("WEEKDAY") | #literal_string_eq_ignore_case("DAYOFWEEK") )  },
+    );
+    let isodow_str = value(
+        IntervalKind::ISODow,
+        rule! { #literal_string_eq_ignore_case("ISODOW")  },
     );
     let week_str = value(
         IntervalKind::Week,
-        rule! { #literal_string_eq_ignore_case("WEEK")  },
+        rule! { (#literal_string_eq_ignore_case("WEEK") | #literal_string_eq_ignore_case("WEEKS") | #literal_string_eq_ignore_case("W"))  },
     );
     let epoch_str = value(
         IntervalKind::Epoch,
@@ -1910,6 +1917,14 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
         IntervalKind::MicroSecond,
         rule! { #literal_string_eq_ignore_case("MICROSECOND")  },
     );
+    let yearweek_str = value(
+        IntervalKind::YearWeek,
+        rule! { #literal_string_eq_ignore_case("YEARWEEK")  },
+    );
+    let millennium_str = value(
+        IntervalKind::Millennium,
+        rule! { #literal_string_eq_ignore_case("MILLENNIUM")  },
+    );
     alt((
         rule!(
             #year
@@ -1925,6 +1940,9 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
             | #week
             | #epoch
             | #microsecond
+            | #isodow
+            | #millennium
+            | #yearweek
         ),
         rule!(
             #year_str
@@ -1940,6 +1958,9 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
             | #week_str
             | #epoch_str
             | #microsecond_str
+            | #isodow_str
+            | #yearweek_str
+            | #millennium_str
         ),
     ))(i)
 }

src/query/ast/src/parser/token.rs

@@ -591,6 +591,8 @@ pub enum TokenKind {
     ENGINES,
     #[token("EPOCH", ignore(ascii_case))]
     EPOCH,
+    #[token("YEARWEEK", ignore(ascii_case))]
+    YEARWEEK,
     #[token("MICROSECOND", ignore(ascii_case))]
     MICROSECOND,
     #[token("ERROR_ON_COLUMN_COUNT_MISMATCH", ignore(ascii_case))]

src/query/expression/src/utils/date_helper.rs

@@ -177,6 +177,52 @@ impl EvalYearsImpl {
     }
 }
 
+pub struct EvalISOYearsImpl;
+impl EvalISOYearsImpl {
+    pub fn eval_date_diff(date_start: i32, date_end: i32, tz: TimeZone) -> i32 {
+        let date_start = date_start.to_date(tz.clone());
+        let date_end = date_end.to_date(tz);
+        date_end.iso_week_date().year() as i32 - date_start.iso_week_date().year() as i32
+    }
+
+    pub fn eval_timestamp_diff(date_start: i64, date_end: i64, tz: TimeZone) -> i64 {
+        let date_start = date_start.to_timestamp(tz.clone());
+        let date_end = date_end.to_timestamp(tz);
+        date_end.date().iso_week_date().year() as i64 - date_start.iso_week_date().year() as i64
+    }
+}
+
+pub struct EvalYearWeeksImpl;
+impl EvalYearWeeksImpl {
+    pub fn eval_date_diff(date_start: i32, date_end: i32, tz: TimeZone) -> i32 {
+        let date_start = date_start.to_date(tz.clone());
+        let date_end = date_end.to_date(tz);
+        let week_date = date_end.iso_week_date();
+        let year = week_date.year() as i32 * 100;
+        let end = year + date_end.iso_week_date().week() as i32;
+
+        let week_date = date_start.iso_week_date();
+        let year = week_date.year() as i32 * 100;
+        let start = year + date_start.iso_week_date().week() as i32;
+
+        end - start
+    }
+
+    pub fn eval_timestamp_diff(date_start: i64, date_end: i64, tz: TimeZone) -> i64 {
+        let date_start = date_start.to_timestamp(tz.clone());
+        let date_end = date_end.to_timestamp(tz);
+        let week_date = date_end.date().iso_week_date();
+        let year = week_date.year() as i64 * 100;
+        let end = year + date_end.date().iso_week_date().week() as i64;
+
+        let week_date = date_start.date().iso_week_date();
+        let year = week_date.year() as i64 * 100;
+        let start = year + date_start.date().iso_week_date().week() as i64;
+
+        end - start
+    }
+}
+
 pub struct EvalQuartersImpl;
 
 impl EvalQuartersImpl {
@@ -351,16 +397,21 @@ impl ToNumberImpl {
 }
 
 pub struct ToYYYYMM;
+pub struct ToYYYYWW;
 pub struct ToYYYYMMDD;
 pub struct ToYYYYMMDDHH;
 pub struct ToYYYYMMDDHHMMSS;
 pub struct ToYear;
+pub struct ToTimezoneHour;
+pub struct ToTimezoneMinute;
+pub struct ToMillennium;
 pub struct ToISOYear;
 pub struct ToQuarter;
 pub struct ToMonth;
 pub struct ToDayOfYear;
 pub struct ToDayOfMonth;
 pub struct ToDayOfWeek;
+pub struct DayOfWeek;
 pub struct ToHour;
 pub struct ToMinute;
 pub struct ToSecond;
@@ -374,6 +425,12 @@ impl ToNumber<u32> for ToYYYYMM {
     }
 }
 
+impl ToNumber<u16> for ToMillennium {
+    fn to_number(dt: &Zoned) -> u16 {
+        dt.year() as u16 / 1000 + 1
+    }
+}
+
 impl ToNumber<u32> for ToWeekOfYear {
     fn to_number(dt: &Zoned) -> u32 {
         dt.date().iso_week_date().week() as u32
@@ -412,12 +469,32 @@ impl ToNumber<u16> for ToYear {
     }
 }
 
+impl ToNumber<i16> for ToTimezoneHour {
+    fn to_number(dt: &Zoned) -> i16 {
+        dt.offset().seconds().div_ceil(3600) as i16
+    }
+}
+
+impl ToNumber<i16> for ToTimezoneMinute {
+    fn to_number(dt: &Zoned) -> i16 {
+        (dt.offset().seconds() % 3600).div_ceil(60) as i16
+    }
+}
+
 impl ToNumber<u16> for ToISOYear {
     fn to_number(dt: &Zoned) -> u16 {
         dt.date().iso_week_date().year() as _
     }
 }
 
+impl ToNumber<u32> for ToYYYYWW {
+    fn to_number(dt: &Zoned) -> u32 {
+        let week_date = dt.date().iso_week_date();
+        let year = week_date.year() as u32 * 100;
+        year + dt.date().iso_week_date().week() as u32
+    }
+}
+
 impl ToNumber<u8> for ToQuarter {
     fn to_number(dt: &Zoned) -> u8 {
         // begin with 0
@@ -449,6 +526,12 @@ impl ToNumber<u8> for ToDayOfWeek {
     }
 }
 
+impl ToNumber<u8> for DayOfWeek {
+    fn to_number(dt: &Zoned) -> u8 {
+        dt.weekday().to_sunday_zero_offset() as u8
+    }
+}
+
 impl ToNumber<i64> for ToUnixTimestamp {
     fn to_number(dt: &Zoned) -> i64 {
         dt.with_time_zone(TimeZone::UTC).timestamp().as_second()