feat(query): interval support agg func sum (#17379)

* feat(query): interval support agg func sum

* impl Add/AddAssign for months_days_micros

Author: TCeason

src/common/column/src/types/native.rs

@@ -17,6 +17,8 @@ use std::cmp::Ordering;
 use std::convert::TryFrom;
 use std::hash::Hash;
 use std::hash::Hasher;
+use std::ops::Add;
+use std::ops::AddAssign;
 use std::ops::Neg;
 use std::panic::RefUnwindSafe;
 
@@ -268,6 +270,26 @@ impl NativeType for days_ms {
 #[repr(C)]
 pub struct months_days_micros(pub i128);
 
+impl Add for months_days_micros {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        let add_months = self.months() + rhs.months();
+        let add_days = self.days() + rhs.days();
+        let add_micros = self.microseconds() + rhs.microseconds();
+        Self::new(add_months, add_days, add_micros)
+    }
+}
+
+impl AddAssign for months_days_micros {
+    fn add_assign(&mut self, rhs: Self) {
+        let add_months = self.months() + rhs.months();
+        let add_days = self.days() + rhs.days();
+        let add_micros = self.microseconds() + rhs.microseconds();
+        self.0 = months_days_micros::new(add_months, add_days, add_micros).0
+    }
+}
+
 impl Hash for months_days_micros {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.total_micros().hash(state)

src/query/functions/src/aggregates/aggregate_sum.rs

@@ -15,6 +15,7 @@
 use boolean::TrueIdxIter;
 use borsh::BorshDeserialize;
 use borsh::BorshSerialize;
+use databend_common_column::types::months_days_micros;
 use databend_common_exception::ErrorCode;
 use databend_common_exception::Result;
 use databend_common_expression::types::decimal::*;
@@ -271,6 +272,63 @@ where
     }
 }
 
+#[derive(BorshSerialize, BorshDeserialize, Default)]
+pub struct IntervalSumState {
+    pub value: months_days_micros,
+}
+
+impl UnaryState<IntervalType, IntervalType> for IntervalSumState {
+    fn add(
+        &mut self,
+        other: months_days_micros,
+        _function_data: Option<&dyn FunctionData>,
+    ) -> Result<()> {
+        self.value += other;
+        Ok(())
+    }
+
+    fn add_batch(
+        &mut self,
+        other: Buffer<months_days_micros>,
+        validity: Option<&Bitmap>,
+        _function_data: Option<&dyn FunctionData>,
+    ) -> Result<()> {
+        let col = IntervalType::upcast_column(other);
+        let buffer = IntervalType::try_downcast_column(&col).unwrap();
+        match validity {
+            Some(validity) if validity.null_count() > 0 => {
+                buffer.iter().zip(validity.iter()).for_each(|(t, b)| {
+                    if b {
+                        self.value += *t;
+                    }
+                });
+            }
+            _ => {
+                buffer.iter().for_each(|t| {
+                    self.value += *t;
+                });
+            }
+        }
+
+        Ok(())
+    }
+
+    fn merge(&mut self, rhs: &Self) -> Result<()> {
+        let res = self.value.total_micros() + rhs.value.total_micros();
+        self.value = months_days_micros(res as i128);
+        Ok(())
+    }
+
+    fn merge_result(
+        &mut self,
+        builder: &mut Vec<months_days_micros>,
+        _function_data: Option<&dyn FunctionData>,
+    ) -> Result<()> {
+        IntervalType::push_item(builder, IntervalType::to_scalar_ref(&self.value));
+        Ok(())
+    }
+}
+
 pub fn try_create_aggregate_sum_function(
     display_name: &str,
     params: Vec<Scalar>,
@@ -323,6 +381,15 @@ pub fn try_create_aggregate_sum_function(
                 )
             }
         }
+        DataType::Interval => {
+            let return_type = DataType::Interval;
+            AggregateUnaryFunction::<IntervalSumState, IntervalType, IntervalType>::try_create_unary(
+                display_name,
+                return_type,
+                params,
+                arguments[0].clone(),
+            )
+        }
         DataType::Decimal(DecimalDataType::Decimal256(s)) => {
             let p = MAX_DECIMAL256_PRECISION;
             let decimal_size = DecimalSize {

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

@@ -8,3 +8,36 @@ with t as ( select to_weeks(weeks) + to_hours(hours) as i, weeks*168+hours as h
 
 statement ok
 drop table test_r;
+
+statement ok
+create or replace table t (c interval);
+
+statement ok
+insert into t values('1 year'),('1 months'),('1 day'),('1 hour'),('1 minute'),('1 second'),('1 microsecond');
+
+onlyif http
+query T
+select * from t order by c;
+----
+0:00:00.000001
+0:00:01
+0:01:00
+1:00:00
+1 day
+1 month
+1 year
+
+onlyif http
+query T
+select sum(c) from t;
+----
+9385:01:01.000001
+
+onlyif http
+query T
+select sum(c) from t where c <= interval '1 day';
+----
+25:01:01.000001
+
+statement ok
+drop table t;