invalid: fix name Date -> DateTime

Author: KKould

src/expression/value_compute.rs

@@ -726,7 +726,7 @@ pub fn binary_op(
         LogicalType::SqlNull => {
             DataValue::Boolean(None)
         }
-        LogicalType::Date => {
+        LogicalType::DateTime => {
             let left_value = unpack_date(left.clone().cast(&unified_type));
             let right_value = unpack_date(right.clone().cast(&unified_type));
 

src/types/mod.rs

@@ -55,7 +55,7 @@ pub enum LogicalType {
     Float,
     Double,
     Varchar,
-    Date,
+    DateTime,
 }
 
 impl LogicalType {
@@ -75,7 +75,7 @@ impl LogicalType {
             LogicalType::Float => Some(4),
             LogicalType::Double => Some(8),
             LogicalType::Varchar => None,
-            LogicalType::Date => Some(8),
+            LogicalType::DateTime => Some(8),
         }
     }
 
@@ -146,8 +146,8 @@ impl LogicalType {
         if left.is_numeric() && right.is_numeric() {
             return LogicalType::combine_numeric_types(left, right);
         }
-        if matches!((left, right), (LogicalType::Date, LogicalType::Varchar) | (LogicalType::Varchar, LogicalType::Date)) {
-            return Ok(LogicalType::Date);
+        if matches!((left, right), (LogicalType::DateTime, LogicalType::Varchar) | (LogicalType::Varchar, LogicalType::DateTime)) {
+            return Ok(LogicalType::DateTime);
         }
         Err(TypeError::InternalError(format!(
             "can not compare two types: {:?} and {:?}",
@@ -250,7 +250,7 @@ impl LogicalType {
             LogicalType::Float => matches!(to, LogicalType::Double),
             LogicalType::Double => false,
             LogicalType::Varchar => false,
-            LogicalType::Date => false,
+            LogicalType::DateTime => false,
         }
     }
 }
@@ -280,7 +280,7 @@ impl TryFrom<sqlparser::ast::DataType> for LogicalType {
             sqlparser::ast::DataType::BigInt(_) => Ok(LogicalType::Bigint),
             sqlparser::ast::DataType::UnsignedBigInt(_) => Ok(LogicalType::UBigint),
             sqlparser::ast::DataType::Boolean => Ok(LogicalType::Boolean),
-            sqlparser::ast::DataType::Datetime(_) => Ok(LogicalType::Date),
+            sqlparser::ast::DataType::Datetime(_) => Ok(LogicalType::DateTime),
             other => Err(TypeError::NotImplementedSqlparserDataType(
                 other.to_string(),
             )),

src/types/tuple.rs

@@ -168,7 +168,7 @@ mod tests {
             Arc::new(ColumnCatalog::new(
                 "c11".to_string(),
                 false,
-                ColumnDesc::new(LogicalType::Date, false)
+                ColumnDesc::new(LogicalType::DateTime, false)
             )),
         ];
 

src/types/value.rs

@@ -200,7 +200,7 @@ impl DataValue {
             LogicalType::Float => DataValue::Float32(None),
             LogicalType::Double => DataValue::Float64(None),
             LogicalType::Varchar => DataValue::Utf8(None),
-            LogicalType::Date => DataValue::Date64(None)
+            LogicalType::DateTime => DataValue::Date64(None)
         }
     }
 
@@ -220,7 +220,7 @@ impl DataValue {
             LogicalType::Float => DataValue::Float32(Some(0.0)),
             LogicalType::Double => DataValue::Float64(Some(0.0)),
             LogicalType::Varchar => DataValue::Utf8(Some("".to_string())),
-            LogicalType::Date => DataValue::Date64(Some(UNIX_DATETIME.timestamp()))
+            LogicalType::DateTime => DataValue::Date64(Some(UNIX_DATETIME.timestamp()))
         }
     }
 
@@ -267,7 +267,7 @@ impl DataValue {
                 f64::from_ne_bytes(buf)
             })),
             LogicalType::Varchar => DataValue::Utf8((!bytes.is_empty()).then(|| String::from_utf8(bytes.to_owned()).unwrap())),
-            LogicalType::Date => DataValue::Date64((!bytes.is_empty()).then(|| i64::decode_fixed(bytes))),
+            LogicalType::DateTime => DataValue::Date64((!bytes.is_empty()).then(|| i64::decode_fixed(bytes))),
         }
     }
 
@@ -286,7 +286,7 @@ impl DataValue {
             DataValue::UInt32(_) => LogicalType::UInteger,
             DataValue::UInt64(_) => LogicalType::UBigint,
             DataValue::Utf8(_) => LogicalType::Varchar,
-            DataValue::Date64(_) => LogicalType::Date,
+            DataValue::Date64(_) => LogicalType::DateTime,
         }
     }
 
@@ -308,7 +308,7 @@ impl DataValue {
                     LogicalType::Float => DataValue::Float32(None),
                     LogicalType::Double => DataValue::Float64(None),
                     LogicalType::Varchar => DataValue::Utf8(None),
-                    LogicalType::Date => DataValue::Date64(None),
+                    LogicalType::DateTime => DataValue::Date64(None),
                 }
             }
             DataValue::Boolean(value) => {
@@ -327,7 +327,7 @@ impl DataValue {
                     LogicalType::Float => DataValue::Float32(value.map(|v| v.into())),
                     LogicalType::Double => DataValue::Float64(value.map(|v| v.into())),
                     LogicalType::Varchar => DataValue::Utf8(value.map(|v| format!("{}", v))),
-                    LogicalType::Date => panic!("not support"),
+                    LogicalType::DateTime => panic!("not support"),
                 }
             }
             DataValue::Float32(value) => {
@@ -481,7 +481,7 @@ impl DataValue {
                     LogicalType::Float => DataValue::Float32(value.map(|v| f32::from_str(&v).unwrap())),
                     LogicalType::Double => DataValue::Float64(value.map(|v| f64::from_str(&v).unwrap())),
                     LogicalType::Varchar => DataValue::Utf8(value),
-                    LogicalType::Date => {
+                    LogicalType::DateTime => {
                         let option = value.map(|v| {
                             NaiveDateTime::parse_from_str(&v, "%Y-%m-%d %H:%M:%S")
                                 .unwrap()
@@ -497,7 +497,7 @@ impl DataValue {
                     LogicalType::Invalid => panic!("invalid logical type"),
                     LogicalType::SqlNull => DataValue::Null,
                     LogicalType::Varchar => DataValue::Utf8(value.map(|v| format!("{}", v))),
-                    LogicalType::Date => DataValue::Date64(value),
+                    LogicalType::DateTime => DataValue::Date64(value),
                     _ => panic!("not support"),
                 }
             }