feat(query): Allow extract parts from interval type

Author: TCeason

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

@@ -829,6 +829,7 @@ pub enum IntervalKind {
     Week,
     Dow,
     Epoch,
+    MicroSecond,
 }
 
 impl Display for IntervalKind {
@@ -845,6 +846,7 @@ impl Display for IntervalKind {
             IntervalKind::Dow => "DOW",
             IntervalKind::Week => "WEEK",
             IntervalKind::Epoch => "EPOCH",
+            IntervalKind::MicroSecond => "MICROSECOND",
         })
     }
 }

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

@@ -1843,6 +1843,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
     let dow = value(IntervalKind::Dow, rule! { DOW });
     let week = value(IntervalKind::Week, rule! { WEEK });
     let epoch = value(IntervalKind::Epoch, rule! { EPOCH });
+    let microsecond = value(IntervalKind::MicroSecond, rule! { MICROSECOND });
     let year_str = value(
         IntervalKind::Year,
         rule! { #literal_string_eq_ignore_case("YEAR")  },
@@ -1887,6 +1888,10 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
         IntervalKind::Epoch,
         rule! { #literal_string_eq_ignore_case("EPOCH")  },
     );
+    let microsecond_str = value(
+        IntervalKind::MicroSecond,
+        rule! { #literal_string_eq_ignore_case("MICROSECOND")  },
+    );
     alt((
         rule!(
             #year
@@ -1900,6 +1905,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
             | #dow
             | #week
             | #epoch
+            | #microsecond
         ),
         rule!(
             #year_str
@@ -1913,6 +1919,7 @@ pub fn interval_kind(i: Input) -> IResult<IntervalKind> {
             | #dow_str
             | #week_str
             | #epoch_str
+            | #microsecond_str
         ),
     ))(i)
 }

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

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

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

@@ -19,6 +19,7 @@ use databend_common_expression::date_helper::EvalMonthsImpl;
 use databend_common_expression::error_to_null;
 use databend_common_expression::types::interval::interval_to_string;
 use databend_common_expression::types::interval::string_to_interval;
+use databend_common_expression::types::Float64Type;
 use databend_common_expression::types::Int64Type;
 use databend_common_expression::types::IntervalType;
 use databend_common_expression::types::StringType;
@@ -296,4 +297,72 @@ fn register_number_to_interval(registry: &mut FunctionRegistry) {
             output.push(res);
         }),
     );
+
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Int64Type, _, _>(
+        "to_year",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Int64Type>(|val, output, _| {
+            output.push(val.months() as i64 / 12);
+        }),
+    );
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Int64Type, _, _>(
+        "to_month",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Int64Type>(|val, output, _| {
+            output.push(val.months() as i64);
+        }),
+    );
+    // Directly return interval days. Extract need named to_day_of_month
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Int64Type, _, _>(
+        "to_day_of_month",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Int64Type>(|val, output, _| {
+            output.push(val.days() as i64);
+        }),
+    );
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Int64Type, _, _>(
+        "to_hour",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Int64Type>(|val, output, _| {
+            let total_seconds = (val.microseconds() as f64) / 1_000_000.0;
+            let hours = (total_seconds / 3600.0) as i64;
+            output.push(hours);
+        }),
+    );
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Int64Type, _, _>(
+        "to_minute",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Int64Type>(|val, output, _| {
+            let total_seconds = (val.microseconds() as f64) / 1_000_000.0;
+            let minutes = ((total_seconds % 3600.0) / 60.0) as i64;
+            output.push(minutes);
+        }),
+    );
+
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Float64Type, _, _>(
+        "to_second",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Float64Type>(|val, output, _| {
+            let microseconds = val.microseconds() % 60_000_000;
+            let seconds = microseconds as f64 / 1_000_000.0;
+            output.push(seconds.into());
+        }),
+    );
+
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Int64Type, _, _>(
+        "to_microsecond",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Int64Type>(|val, output, _| {
+            let microseconds = val.microseconds() % 60_000_000;
+            output.push(microseconds);
+        }),
+    );
+    registry.register_passthrough_nullable_1_arg::<IntervalType, Float64Type, _, _>(
+        "epoch",
+        |_, _| FunctionDomain::MayThrow,
+        vectorize_with_builder_1_arg::<IntervalType, Float64Type>(|val, output, _| {
+            let total_seconds = (val.total_micros() as f64) / 1_000_000.0;
+            output.push(total_seconds.into());
+        }),
+    );
 }

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

@@ -2950,6 +2950,9 @@ impl<'a> TypeChecker<'a> {
             ASTIntervalKind::Dow => self.resolve_function(span, "to_day_of_week", vec![], &[arg]),
             ASTIntervalKind::Week => self.resolve_function(span, "to_week_of_year", vec![], &[arg]),
             ASTIntervalKind::Epoch => self.resolve_function(span, "epoch", vec![], &[arg]),
+            ASTIntervalKind::MicroSecond => {
+                self.resolve_function(span, "to_microsecond", vec![], &[arg])
+            }
         }
     }
 

tests/sqllogictests/suites/base/11_data_type/11_0007_data_type_interval.test

@@ -41,3 +41,51 @@ select sum(c) from t where c <= interval '1 day';
 
 statement ok
 drop table t;
+
+onlyif http
+query T
+select EXTRACT(epoch from '1 day 2 hours 3 minutes'::INTERVAL);
+----
+93780.0
+
+onlyif http
+query T
+select EXTRACT(minute from '1 day 2 hours 3 minutes'::INTERVAL);
+----
+3
+
+onlyif http
+query T
+select EXTRACT(hour from '1 day 48 hours 3600 minutes'::INTERVAL);
+----
+108
+
+onlyif http
+query T
+select EXTRACT(day from '1 day 48 hours 3600 minutes'::INTERVAL);
+----
+1
+
+onlyif http
+query T
+select EXTRACT(second from '1 day 2 hours 3 minutes 200 seconds 100 microsecond'::INTERVAL);
+----
+20.0001
+
+onlyif http
+query T
+select EXTRACT(microsecond from '1 day 2 hours 3 minutes 200 seconds 100 microsecond'::INTERVAL);
+----
+20000100
+
+onlyif http
+query T
+select EXTRACT(month from '3 months 60 day 2 hours 3 minutes 200 seconds 100 microsecond'::INTERVAL);
+----
+3
+
+onlyif http
+query T
+select EXTRACT(year from '1 years 13 months 60 day 2 hours 3 minutes 200 seconds 100 microsecond'::INTERVAL);
+----
+2