feat: support type TimeStamp

docs/features.md

@@ -133,6 +133,7 @@ let kite_sql = DataBaseBuilder::path("./data")
   - Right
   - Full
   - Cross (Natural\Using)
+- [x] Exists
 - [x] Group By
 - [x] Having
 - [x] Order By
@@ -170,4 +171,5 @@ let kite_sql = DataBaseBuilder::path("./data")
 - Date
 - DateTime
 - Time
+- TimeStamp
 - Tuple

src/db.rs

@@ -6,6 +6,7 @@ use crate::expression::function::table::TableFunctionImpl;
 use crate::expression::function::FunctionSummary;
 use crate::function::char_length::CharLength;
 use crate::function::current_date::CurrentDate;
+use crate::function::current_timestamp::CurrentTimeStamp;
 use crate::function::lower::Lower;
 use crate::function::numbers::Numbers;
 use crate::function::octet_length::OctetLength;
@@ -61,6 +62,7 @@ impl DataBaseBuilder {
         builder =
             builder.register_scala_function(CharLength::new("character_length".to_lowercase()));
         builder = builder.register_scala_function(CurrentDate::new());
+        builder = builder.register_scala_function(CurrentTimeStamp::new());
         builder = builder.register_scala_function(Lower::new());
         builder = builder.register_scala_function(OctetLength::new());
         builder = builder.register_scala_function(Upper::new());

src/function/current_timestamp.rs

@@ -0,0 +1,56 @@
+use crate::catalog::ColumnRef;
+use crate::errors::DatabaseError;
+use crate::expression::function::scala::FuncMonotonicity;
+use crate::expression::function::scala::ScalarFunctionImpl;
+use crate::expression::function::FunctionSummary;
+use crate::expression::ScalarExpression;
+use crate::types::tuple::Tuple;
+use crate::types::value::DataValue;
+use crate::types::LogicalType;
+use chrono::Utc;
+use serde::Deserialize;
+use serde::Serialize;
+use std::sync::Arc;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) struct CurrentTimeStamp {
+    summary: FunctionSummary,
+}
+
+impl CurrentTimeStamp {
+    #[allow(unused_mut)]
+    pub(crate) fn new() -> Arc<Self> {
+        let function_name = "current_timestamp".to_lowercase();
+
+        Arc::new(Self {
+            summary: FunctionSummary {
+                name: function_name,
+                arg_types: Vec::new(),
+            },
+        })
+    }
+}
+
+#[typetag::serde]
+impl ScalarFunctionImpl for CurrentTimeStamp {
+    #[allow(unused_variables, clippy::redundant_closure_call)]
+    fn eval(
+        &self,
+        _: &[ScalarExpression],
+        _: Option<(&Tuple, &[ColumnRef])>,
+    ) -> Result<DataValue, DatabaseError> {
+        Ok(DataValue::Time64(Utc::now().timestamp(), 0, false))
+    }
+
+    fn monotonicity(&self) -> Option<FuncMonotonicity> {
+        todo!()
+    }
+
+    fn return_type(&self) -> &LogicalType {
+        &LogicalType::TimeStamp(None, false)
+    }
+
+    fn summary(&self) -> &FunctionSummary {
+        &self.summary
+    }
+}

src/function/mod.rs

@@ -1,5 +1,6 @@
 pub(crate) mod char_length;
 pub(crate) mod current_date;
+pub(crate) mod current_timestamp;
 pub(crate) mod lower;
 pub(crate) mod numbers;
 pub(crate) mod octet_length;

src/optimizer/core/histogram.rs

@@ -329,14 +329,20 @@ impl Histogram {
                     }
                     _ => unreachable!(),
                 },
-                LogicalType::Date | LogicalType::DateTime | LogicalType::Time => match value {
+                LogicalType::Date
+                | LogicalType::DateTime
+                | LogicalType::Time(_, _)
+                | LogicalType::TimeStamp(_, _) => match value {
                     DataValue::Date32(value) => DataValue::Int32(*value)
                         .cast(&LogicalType::Double)?
                         .double(),
                     DataValue::Date64(value) => DataValue::Int64(*value)
                         .cast(&LogicalType::Double)?
                         .double(),
-                    DataValue::Time(value) => DataValue::UInt32(*value)
+                    DataValue::Time32(value, ..) => DataValue::UInt32(*value)
+                        .cast(&LogicalType::Double)?
+                        .double(),
+                    DataValue::Time64(value, ..) => DataValue::Int64(*value)
                         .cast(&LogicalType::Double)?
                         .double(),
                     _ => unreachable!(),

src/types/evaluator/mod.rs

@@ -9,7 +9,8 @@ pub mod int32;
 pub mod int64;
 pub mod int8;
 pub mod null;
-pub mod time;
+pub mod time32;
+pub mod time64;
 pub mod tuple;
 pub mod uint16;
 pub mod uint32;
@@ -30,7 +31,8 @@ use crate::types::evaluator::int32::*;
 use crate::types::evaluator::int64::*;
 use crate::types::evaluator::int8::*;
 use crate::types::evaluator::null::NullBinaryEvaluator;
-use crate::types::evaluator::time::*;
+use crate::types::evaluator::time32::*;
+use crate::types::evaluator::time64::*;
 use crate::types::evaluator::tuple::{
     TupleEqBinaryEvaluator, TupleGtBinaryEvaluator, TupleGtEqBinaryEvaluator,
     TupleLtBinaryEvaluator, TupleLtEqBinaryEvaluator, TupleNotEqBinaryEvaluator,
@@ -191,7 +193,28 @@ impl EvaluatorFactory {
             LogicalType::Double => numeric_binary_evaluator!(Float64, op, LogicalType::Double),
             LogicalType::Date => numeric_binary_evaluator!(Date, op, LogicalType::Date),
             LogicalType::DateTime => numeric_binary_evaluator!(DateTime, op, LogicalType::DateTime),
-            LogicalType::Time => numeric_binary_evaluator!(Time, op, LogicalType::Time),
+            LogicalType::Time(_, _) => match op {
+                BinaryOperator::Plus => Ok(BinaryEvaluatorBox(Arc::new(TimePlusBinaryEvaluator))),
+                BinaryOperator::Minus => Ok(BinaryEvaluatorBox(Arc::new(TimeMinusBinaryEvaluator))),
+                BinaryOperator::Gt => Ok(BinaryEvaluatorBox(Arc::new(TimeGtBinaryEvaluator))),
+                BinaryOperator::GtEq => Ok(BinaryEvaluatorBox(Arc::new(TimeGtEqBinaryEvaluator))),
+                BinaryOperator::Lt => Ok(BinaryEvaluatorBox(Arc::new(TimeLtBinaryEvaluator))),
+                BinaryOperator::LtEq => Ok(BinaryEvaluatorBox(Arc::new(TimeLtEqBinaryEvaluator))),
+                BinaryOperator::Eq => Ok(BinaryEvaluatorBox(Arc::new(TimeEqBinaryEvaluator))),
+                BinaryOperator::NotEq => Ok(BinaryEvaluatorBox(Arc::new(TimeNotEqBinaryEvaluator))),
+                _ => Err(DatabaseError::UnsupportedBinaryOperator(ty, op)),
+            },
+            LogicalType::TimeStamp(_, _) => match op {
+                BinaryOperator::Gt => Ok(BinaryEvaluatorBox(Arc::new(Time64GtBinaryEvaluator))),
+                BinaryOperator::GtEq => Ok(BinaryEvaluatorBox(Arc::new(Time64GtEqBinaryEvaluator))),
+                BinaryOperator::Lt => Ok(BinaryEvaluatorBox(Arc::new(Time64LtBinaryEvaluator))),
+                BinaryOperator::LtEq => Ok(BinaryEvaluatorBox(Arc::new(Time64LtEqBinaryEvaluator))),
+                BinaryOperator::Eq => Ok(BinaryEvaluatorBox(Arc::new(Time64EqBinaryEvaluator))),
+                BinaryOperator::NotEq => {
+                    Ok(BinaryEvaluatorBox(Arc::new(Time64NotEqBinaryEvaluator)))
+                }
+                _ => Err(DatabaseError::UnsupportedBinaryOperator(ty, op)),
+            },
             LogicalType::Decimal(_, _) => numeric_binary_evaluator!(Decimal, op, ty),
             LogicalType::Boolean => match op {
                 BinaryOperator::And => Ok(BinaryEvaluatorBox(Arc::new(BooleanAndBinaryEvaluator))),
@@ -1032,6 +1055,164 @@ mod test {
         Ok(())
     }
 
+    #[test]
+    fn test_binary_op_time32_and_time64() -> Result<(), DatabaseError> {
+        let evaluator_time32 =
+            EvaluatorFactory::binary_create(LogicalType::Time(None, false), BinaryOperator::Plus)?;
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2621204256, 4, false),
+            ),
+            DataValue::Time32(2618593017, 4, false)
+        );
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190175696, 3, false),
+                &DataValue::Time32(2621224256, 4, false),
+            ),
+            DataValue::Null
+        );
+
+        let evaluator_time32 =
+            EvaluatorFactory::binary_create(LogicalType::Time(None, false), BinaryOperator::Minus)?;
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2621204256, 4, false),
+            ),
+            DataValue::Null
+        );
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(2621204256, 4, false),
+                &DataValue::Time32(4190119896, 3, false),
+            ),
+            DataValue::Time32(2375496, 4, false)
+        );
+
+        let evaluator_time32 =
+            EvaluatorFactory::binary_create(LogicalType::Time(None, false), BinaryOperator::Gt)?;
+        let evaluator_time64 = EvaluatorFactory::binary_create(
+            LogicalType::TimeStamp(None, false),
+            BinaryOperator::Gt,
+        )?;
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(2621204256, 4, false),
+                &DataValue::Time32(4190119896, 3, false),
+            ),
+            DataValue::Boolean(true)
+        );
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2621204256, 4, false),
+            ),
+            DataValue::Boolean(false)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1736055775154814, 6, false),
+                &DataValue::Time64(1738734177256, 3, false),
+            ),
+            DataValue::Boolean(false)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1738734177256, 3, false),
+                &DataValue::Time64(1736055775154814, 6, false),
+            ),
+            DataValue::Boolean(true)
+        );
+
+        let evaluator_time32 =
+            EvaluatorFactory::binary_create(LogicalType::Time(None, false), BinaryOperator::GtEq)?;
+        let evaluator_time64 = EvaluatorFactory::binary_create(
+            LogicalType::TimeStamp(None, false),
+            BinaryOperator::GtEq,
+        )?;
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(2621204256, 4, false),
+                &DataValue::Time32(4190119896, 3, false),
+            ),
+            DataValue::Boolean(true)
+        );
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2621204256, 4, false),
+            ),
+            DataValue::Boolean(false)
+        );
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2618828760, 4, false),
+            ),
+            DataValue::Boolean(true)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1736055775154814, 6, false),
+                &DataValue::Time64(1738734177256, 3, false),
+            ),
+            DataValue::Boolean(false)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1738734177256, 3, false),
+                &DataValue::Time64(1736055775154814, 6, false),
+            ),
+            DataValue::Boolean(true)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1738734177256, 3, false),
+                &DataValue::Time64(1738734177256000, 6, false),
+            ),
+            DataValue::Boolean(true)
+        );
+
+        let evaluator_time32 =
+            EvaluatorFactory::binary_create(LogicalType::Time(None, false), BinaryOperator::Eq)?;
+        let evaluator_time64 = EvaluatorFactory::binary_create(
+            LogicalType::TimeStamp(None, false),
+            BinaryOperator::Eq,
+        )?;
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2621204256, 4, false),
+            ),
+            DataValue::Boolean(false)
+        );
+        assert_eq!(
+            evaluator_time32.0.binary_eval(
+                &DataValue::Time32(4190119896, 3, false),
+                &DataValue::Time32(2618828760, 4, false),
+            ),
+            DataValue::Boolean(true)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1738734177256, 3, false),
+                &DataValue::Time64(1736055775154814, 6, false),
+            ),
+            DataValue::Boolean(false)
+        );
+        assert_eq!(
+            evaluator_time64.0.binary_eval(
+                &DataValue::Time64(1738734177256, 3, false),
+                &DataValue::Time64(1738734177256000, 6, false),
+            ),
+            DataValue::Boolean(true)
+        );
+
+        Ok(())
+    }
+
     #[test]
     fn test_reference_serialization() -> Result<(), DatabaseError> {
         let mut cursor = Cursor::new(Vec::new());