test: added tests for statements methods (#622)

* test: added tests for parse_column_default_constraint

* test: added test for sql_column_def_to_grpc_column_def

* refactor: remove hardcode in test

src/datanode/src/server/grpc/ddl.rs

@@ -122,7 +122,7 @@ impl Instance {
 mod tests {
     use std::sync::Arc;
 
-    use api::v1::ColumnDef;
+    use api::v1::{ColumnDataType, ColumnDef};
     use common_catalog::consts::MIN_USER_TABLE_ID;
     use common_grpc_expr::create_table_schema;
     use datatypes::prelude::ConcreteDataType;
@@ -173,6 +173,7 @@ mod tests {
     }
 
     #[test]
+
     fn test_create_column_schema() {
         let column_def = ColumnDef {
             name: "a".to_string(),
@@ -188,7 +189,7 @@ mod tests {
 
         let column_def = ColumnDef {
             name: "a".to_string(),
-            datatype: 12, // string
+            datatype: ColumnDataType::String as i32,
             is_nullable: true,
             default_constraint: None,
         };
@@ -200,7 +201,7 @@ mod tests {
         let default_constraint = ColumnDefaultConstraint::Value(Value::from("default value"));
         let column_def = ColumnDef {
             name: "a".to_string(),
-            datatype: 12, // string
+            datatype: ColumnDataType::String as i32,
             is_nullable: true,
             default_constraint: Some(default_constraint.clone().try_into().unwrap()),
         };
@@ -218,25 +219,25 @@ mod tests {
         let column_defs = vec![
             ColumnDef {
                 name: "host".to_string(),
-                datatype: 12, // string
+                datatype: ColumnDataType::String as i32,
                 is_nullable: false,
                 default_constraint: None,
             },
             ColumnDef {
                 name: "ts".to_string(),
-                datatype: 15, // timestamp
+                datatype: ColumnDataType::Timestamp as i32,
                 is_nullable: false,
                 default_constraint: None,
             },
             ColumnDef {
                 name: "cpu".to_string(),
-                datatype: 9, // float32
+                datatype: ColumnDataType::Float32 as i32,
                 is_nullable: true,
                 default_constraint: None,
             },
             ColumnDef {
                 name: "memory".to_string(),
-                datatype: 10, // float64
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: None,
             },

src/sql/src/statements.rs

@@ -322,11 +322,16 @@ pub fn sql_data_type_to_concrete_data_type(data_type: &SqlDataType) -> Result<Co
 
 #[cfg(test)]
 mod tests {
+    use std::assert_matches::assert_matches;
+
+    use api::v1::ColumnDataType;
     use common_time::timestamp::TimeUnit;
+    use datatypes::types::BooleanType;
     use datatypes::value::OrderedFloat;
 
     use super::*;
-    use crate::ast::Ident;
+    use crate::ast::{DataType, Ident};
+    use crate::statements::ColumnOption;
 
     fn check_type(sql_type: SqlDataType, data_type: ConcreteDataType) {
         assert_eq!(
@@ -531,4 +536,61 @@ mod tests {
         )
         .is_err());
     }
+
+    #[test]
+    pub fn test_parse_column_default_constraint() {
+        let bool_value = sqlparser::ast::Value::Boolean(true);
+
+        let opts = vec![
+            ColumnOptionDef {
+                name: None,
+                option: ColumnOption::Default(Expr::Value(bool_value)),
+            },
+            ColumnOptionDef {
+                name: None,
+                option: ColumnOption::NotNull,
+            },
+        ];
+
+        let constraint =
+            parse_column_default_constraint("coll", &ConcreteDataType::Boolean(BooleanType), &opts)
+                .unwrap();
+
+        assert_matches!(
+            constraint,
+            Some(ColumnDefaultConstraint::Value(Value::Boolean(true)))
+        );
+    }
+
+    #[test]
+    pub fn test_sql_column_def_to_grpc_column_def() {
+        // test basic
+        let column_def = ColumnDef {
+            name: "col".into(),
+            data_type: DataType::Double,
+            collation: None,
+            options: vec![],
+        };
+
+        let grpc_column_def = sql_column_def_to_grpc_column_def(column_def).unwrap();
+
+        assert_eq!("col", grpc_column_def.name);
+        assert!(grpc_column_def.is_nullable); // nullable when options are empty
+        assert_eq!(ColumnDataType::Float64 as i32, grpc_column_def.datatype);
+        assert_eq!(None, grpc_column_def.default_constraint);
+
+        // test not null
+        let column_def = ColumnDef {
+            name: "col".into(),
+            data_type: DataType::Double,
+            collation: None,
+            options: vec![ColumnOptionDef {
+                name: None,
+                option: ColumnOption::NotNull,
+            }],
+        };
+
+        let grpc_column_def = sql_column_def_to_grpc_column_def(column_def).unwrap();
+        assert!(!grpc_column_def.is_nullable);
+    }
 }