feat(query): add interval type (#16990)

* support Interval DataType

:) select to_interval('02:01'), to_interval('1 year 1 day 1 hour');

┌───────────────────────────────────────────────────────────┐
│ to_interval('02:01') │ to_interval('1 year 1 day 1 hour') │
│       Interval       │              Interval              │
├──────────────────────┼────────────────────────────────────┤
│ 2:01:00              │ 1year 1day 1:00:00                 │
└───────────────────────────────────────────────────────────┘

* refactor: months_days_ns(pub i32,pub i32,pub i64) -> months_days_micros(pub i128)

Author: TCeason

Cargo.lock

@@ -21,7 +21,7 @@ column-default = [
 ]
 
 [dependencies]
-
+borsh = { workspace = true, features = ["derive"] }
 databend-common-base = { workspace = true }
 databend-common-exception = { workspace = true }
 

src/common/column/Cargo.toml

@@ -114,6 +114,6 @@ mod private {
     impl Sealed for OrderedFloat<f32> {}
     impl Sealed for OrderedFloat<f64> {}
     impl Sealed for super::days_ms {}
-    impl Sealed for super::months_days_ns {}
+    impl Sealed for super::months_days_micros {}
     impl Sealed for View {}
 }

src/common/column/src/types/mod.rs

@@ -17,9 +17,13 @@ use std::convert::TryFrom;
 use std::ops::Neg;
 use std::panic::RefUnwindSafe;
 
+use borsh::BorshDeserialize;
+use borsh::BorshSerialize;
 use bytemuck::Pod;
 use bytemuck::Zeroable;
 use databend_common_base::base::OrderedFloat;
+use serde_derive::Deserialize;
+use serde_derive::Serialize;
 
 use super::PrimitiveType;
 
@@ -243,124 +247,71 @@ impl NativeType for days_ms {
 }
 
 /// The in-memory representation of the MonthDayNano variant of the "Interval" logical type.
-#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, Hash, Zeroable, Pod)]
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    Default,
+    PartialEq,
+    PartialOrd,
+    Ord,
+    Eq,
+    Hash,
+    Zeroable,
+    Pod,
+    Serialize,
+    Deserialize,
+    BorshSerialize,
+    BorshDeserialize,
+)]
 #[allow(non_camel_case_types)]
 #[repr(C)]
-pub struct months_days_ns(pub i32, pub i32, pub i64);
+pub struct months_days_micros(pub i128);
 
-impl months_days_ns {
-    /// A new [`months_days_ns`].
-    #[inline]
-    pub fn new(months: i32, days: i32, nanoseconds: i64) -> Self {
-        Self(months, days, nanoseconds)
+impl months_days_micros {
+    pub fn new(months: i32, days: i32, microseconds: i64) -> Self {
+        let months_bits = (months as i128) << 96;
+        let days_bits = (days as i128) << 64;
+        let micros_bits = microseconds as i128;
+
+        Self(months_bits | days_bits | micros_bits)
     }
 
-    /// The number of months
-    #[inline]
     pub fn months(&self) -> i32 {
-        self.0
+        // Decoding logic
+        ((self.0 >> 96) & 0xFFFFFFFF) as i32
     }
 
-    /// The number of days
-    #[inline]
     pub fn days(&self) -> i32 {
-        self.1
+        ((self.0 >> 64) & 0xFFFFFFFF) as i32
     }
 
-    /// The number of nanoseconds
-    #[inline]
-    pub fn ns(&self) -> i64 {
-        self.2
+    pub fn microseconds(&self) -> i64 {
+        (self.0 & 0xFFFFFFFFFFFFFFFF) as i64
     }
 }
 
-impl NativeType for months_days_ns {
+impl NativeType for months_days_micros {
     const PRIMITIVE: PrimitiveType = PrimitiveType::MonthDayNano;
     type Bytes = [u8; 16];
     #[inline]
     fn to_le_bytes(&self) -> Self::Bytes {
-        let months = self.months().to_le_bytes();
-        let days = self.days().to_le_bytes();
-        let ns = self.ns().to_le_bytes();
-        let mut result = [0; 16];
-        result[0] = months[0];
-        result[1] = months[1];
-        result[2] = months[2];
-        result[3] = months[3];
-        result[4] = days[0];
-        result[5] = days[1];
-        result[6] = days[2];
-        result[7] = days[3];
-        (0..8).for_each(|i| {
-            result[8 + i] = ns[i];
-        });
-        result
+        self.0.to_le_bytes()
     }
 
     #[inline]
     fn to_be_bytes(&self) -> Self::Bytes {
-        let months = self.months().to_be_bytes();
-        let days = self.days().to_be_bytes();
-        let ns = self.ns().to_be_bytes();
-        let mut result = [0; 16];
-        result[0] = months[0];
-        result[1] = months[1];
-        result[2] = months[2];
-        result[3] = months[3];
-        result[4] = days[0];
-        result[5] = days[1];
-        result[6] = days[2];
-        result[7] = days[3];
-        (0..8).for_each(|i| {
-            result[8 + i] = ns[i];
-        });
-        result
+        self.0.to_be_bytes()
     }
 
     #[inline]
     fn from_le_bytes(bytes: Self::Bytes) -> Self {
-        let mut months = [0; 4];
-        months[0] = bytes[0];
-        months[1] = bytes[1];
-        months[2] = bytes[2];
-        months[3] = bytes[3];
-        let mut days = [0; 4];
-        days[0] = bytes[4];
-        days[1] = bytes[5];
-        days[2] = bytes[6];
-        days[3] = bytes[7];
-        let mut ns = [0; 8];
-        (0..8).for_each(|i| {
-            ns[i] = bytes[8 + i];
-        });
-        Self(
-            i32::from_le_bytes(months),
-            i32::from_le_bytes(days),
-            i64::from_le_bytes(ns),
-        )
+        Self(i128::from_le_bytes(bytes))
     }
 
     #[inline]
     fn from_be_bytes(bytes: Self::Bytes) -> Self {
-        let mut months = [0; 4];
-        months[0] = bytes[0];
-        months[1] = bytes[1];
-        months[2] = bytes[2];
-        months[3] = bytes[3];
-        let mut days = [0; 4];
-        days[0] = bytes[4];
-        days[1] = bytes[5];
-        days[2] = bytes[6];
-        days[3] = bytes[7];
-        let mut ns = [0; 8];
-        (0..8).for_each(|i| {
-            ns[i] = bytes[8 + i];
-        });
-        Self(
-            i32::from_be_bytes(months),
-            i32::from_be_bytes(days),
-            i64::from_be_bytes(ns),
-        )
+        Self(i128::from_be_bytes(bytes))
     }
 }
 
@@ -370,9 +321,15 @@ impl std::fmt::Display for days_ms {
     }
 }
 
-impl std::fmt::Display for months_days_ns {
+impl std::fmt::Display for months_days_micros {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{}m {}d {}ns", self.months(), self.days(), self.ns())
+        write!(
+            f,
+            "{}m {}d {}micros",
+            self.months(),
+            self.days(),
+            self.microseconds()
+        )
     }
 }
 
@@ -385,12 +342,12 @@ impl Neg for days_ms {
     }
 }
 
-impl Neg for months_days_ns {
+impl Neg for months_days_micros {
     type Output = Self;
 
     #[inline(always)]
     fn neg(self) -> Self::Output {
-        Self::new(-self.months(), -self.days(), -self.ns())
+        Self::new(-self.months(), -self.days(), -self.microseconds())
     }
 }
 

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

@@ -19,7 +19,7 @@
 use super::days_ms;
 use super::f16;
 use super::i256;
-use super::months_days_ns;
+use super::months_days_micros;
 use super::BitChunk;
 use super::BitChunkIter;
 use super::NativeType;
@@ -151,7 +151,7 @@ pub(super) use native_simd;
 // of how they are represented in the different channels.
 native_simd!(f16x32, f16, 32, u32);
 native_simd!(days_msx8, days_ms, 8, u8);
-native_simd!(months_days_nsx8, months_days_ns, 8, u8);
+native_simd!(months_days_microsx8, months_days_micros, 8, u8);
 native_simd!(i128x8, i128, 8, u8);
 native_simd!(i256x8, i256, 8, u8);
 
@@ -185,4 +185,4 @@ native!(f64, f64x8);
 native!(i128, i128x8);
 native!(i256, i256x8);
 native!(days_ms, days_msx8);
-native!(months_days_ns, months_days_nsx8);
+native!(months_days_micros, months_days_microsx8);