feat(query): Interval kin support iw and hh24 (#18114)

`iw` is ISOWeek.
`hh24` is hour.

In main will return parse err:

```sql
SELECT TRUNC(DATE '2024-01-01', 'IW');

select TRUNC('2025-06-09 10:11:12'::Datetime, 'HH24');

```

In pr:

```sql
query T
SELECT TRUNC('2024-01-01'::Date, 'IW');
----
2024-01-01

query T
select TRUNC('2025-06-09 10:11:12'::Datetime, 'HH24');
----
2025-06-09 10:00:00.000000

```

Author: TCeason

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

@@ -896,6 +896,7 @@ pub enum IntervalKind {
     Second,
     Doy,
     Week,
+    ISOWeek,
     Dow,
     Epoch,
     MicroSecond,
@@ -921,6 +922,7 @@ impl Display for IntervalKind {
             IntervalKind::YearWeek => "YEARWEEK",
             IntervalKind::Millennium => "MILLENNIUM",
             IntervalKind::Week => "WEEK",
+            IntervalKind::ISOWeek => "ISOWEEK",
             IntervalKind::Epoch => "EPOCH",
             IntervalKind::MicroSecond => "MICROSECOND",
         })

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

@@ -1866,6 +1866,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
     let doy = value(IntervalKind::Doy, rule! { DOY });
     let dow = value(IntervalKind::Dow, rule! { DOW });
     let isodow = value(IntervalKind::ISODow, rule! { ISODOW });
+    let isoweek = value(IntervalKind::ISOWeek, rule! { ISOWEEK });
     let week = value(IntervalKind::Week, rule! { WEEK });
     let epoch = value(IntervalKind::Epoch, rule! { EPOCH });
     let microsecond = value(IntervalKind::MicroSecond, rule! { MICROSECOND });
@@ -1925,6 +1926,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
         rule! { #literal_string_eq_ignore_case("HOUR")
             | #literal_string_eq_ignore_case("H")
             | #literal_string_eq_ignore_case("HH")
+            | #literal_string_eq_ignore_case("HH24")
             | #literal_string_eq_ignore_case("HR")
             | #literal_string_eq_ignore_case("HOURS")
             | #literal_string_eq_ignore_case("HRS")
@@ -1991,6 +1993,11 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
         },
     );
 
+    let isoweek_str = value(
+        IntervalKind::ISOWeek,
+        rule! { #literal_string_eq_ignore_case("IW") },
+    );
+
     let epoch_str = value(
         IntervalKind::Epoch,
         rule! { #literal_string_eq_ignore_case("EPOCH")
@@ -2037,6 +2044,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
             | #epoch
             | #microsecond
             | #isodow
+            | #isoweek
             | #millennium
             | #yearweek
         ),
@@ -2055,6 +2063,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
             | #epoch_str
             | #microsecond_str
             | #isodow_str
+            | #isoweek_str
             | #yearweek_str
             | #millennium_str
         ),

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

@@ -763,6 +763,8 @@ pub enum TokenKind {
     IS,
     #[token("ISODOW", ignore(ascii_case))]
     ISODOW,
+    #[token("ISOWEEK", ignore(ascii_case))]
+    ISOWEEK,
     #[token("ISOYEAR", ignore(ascii_case))]
     ISOYEAR,
     #[token("JOIN", ignore(ascii_case))]

src/query/functions/src/scalars/timestamp/src/datetime.rs

@@ -2324,6 +2324,7 @@ fn register_rounder_functions(registry: &mut FunctionRegistry) {
     );
 
     // date | timestamp -> date
+    registry.register_aliases("to_monday", &["to_start_of_iso_week"]);
     rounder_functions_helper::<ToLastMonday>(registry, "to_monday");
     rounder_functions_helper::<ToLastSunday>(registry, "to_start_of_week");
     rounder_functions_helper::<ToStartOfMonth>(registry, "to_start_of_month");

src/query/functions/tests/it/scalars/testdata/function_list.txt

@@ -75,6 +75,7 @@ substring_utf8 -> substr
 subtract -> minus
 to_char -> to_string
 to_datetime -> to_timestamp
+to_start_of_iso_week -> to_monday
 to_text -> to_string
 to_varchar -> to_string
 trunc -> truncate

src/query/sql/src/planner/semantic/type_check.rs

@@ -3226,6 +3226,10 @@ impl<'a> TypeChecker<'a> {
             ASTIntervalKind::Millennium => {
                 self.resolve_function(span, "millennium", vec![], &[arg])
             }
+            ASTIntervalKind::ISOWeek => Err(ErrorCode::SemanticError(
+                "Not support interval type ISOWeek".to_string(),
+            )
+            .set_span(span)),
         }
     }
 
@@ -3312,6 +3316,13 @@ impl<'a> TypeChecker<'a> {
                     }],
                 )
             }
+            ASTIntervalKind::ISOWeek => {
+                self.resolve_function(
+                    span,
+                    "to_start_of_iso_week", vec![],
+                    &[date],
+                )
+            }
             ASTIntervalKind::Day => {
                 self.resolve_function(
                     span,

tests/sqllogictests/suites/query/functions/02_0012_function_datetimes.test

@@ -292,6 +292,32 @@ select trunc('2025-02-05 00:01:00', week);
 ----
 2025-02-03
 
+
+query T
+SELECT TRUNC('2025-06-11'::Date, 'IW');
+----
+2025-06-09
+
+query T
+SELECT TRUNC('2025-06-09'::Date, 'IW');
+----
+2025-06-09
+
+query T
+SELECT TRUNC('2023-12-31'::Date, 'IW');
+----
+2023-12-25
+
+query T
+SELECT TRUNC('2024-01-01'::Date, 'IW');
+----
+2024-01-01
+
+query T
+select TRUNC('2025-06-09 10:11:12'::Datetime, 'HH24');
+----
+2025-06-09 10:00:00.000000
+
 query FF
 SELECT
     MONTHS_BETWEEN('2019-03-15'::DATE,