refactor(query): refactor variant cast to types

Author: sundy-li

src/query/expression/src/evaluator.rs

@@ -377,14 +377,9 @@ impl<'a> Evaluator<'a> {
                     .set_span(span))
                 }
             }
-            (
-                DataType::Nullable(box DataType::Variant) | DataType::Variant,
-                DataType::Boolean
-                | DataType::Number(_)
-                | DataType::String
-                | DataType::Date
-                | DataType::Timestamp,
-            ) => {
+            (DataType::Nullable(box DataType::Variant) | DataType::Variant, other)
+                if !other.is_nullable() =>
+            {
                 // allow cast variant to not null types.
                 let cast_fn = format!("to_{}", dest_type.to_string().to_lowercase());
                 if let Some(new_value) = self.run_simple_cast(
@@ -396,20 +391,13 @@ impl<'a> Evaluator<'a> {
                     validity.clone(),
                     options,
                 )? {
-                    // remove wrapped null values.
-                    let new_value = match new_value {
-                        Value::Scalar(scalar) => {
-                            if scalar == Scalar::Null {
-                                Value::Scalar(Scalar::default_value(dest_type))
-                            } else {
-                                Value::Scalar(scalar)
-                            }
-                        }
-                        Value::Column(column) => {
-                            let nullable_column = column.as_nullable().unwrap();
-                            Value::Column(nullable_column.column.clone())
-                        }
-                    };
+                    let (new_value, has_null) = new_value.remove_nullable();
+                    if has_null {
+                        return Err(ErrorCode::BadArguments(format!(
+                            "unable to cast type `{src_type}` to type `{dest_type}`, result has null values"
+                        ))
+                        .set_span(span));
+                    }
                     Ok(new_value)
                 } else {
                     Err(ErrorCode::BadArguments(format!(

src/query/expression/src/values.rs

@@ -345,6 +345,24 @@ impl Value<AnyType> {
         }
     }
 
+    // returns result without nullable and has_null flag
+    pub fn remove_nullable(self) -> (Self, bool) {
+        let mut has_null = false;
+        match self {
+            Value::Scalar(scalar) => {
+                if scalar == Scalar::Null {
+                    has_null = true;
+                }
+                (Value::Scalar(scalar), has_null)
+            }
+            Value::Column(column) => {
+                let nullable_column = column.as_nullable().unwrap();
+                has_null = nullable_column.validity.null_count() > 0;
+                (Value::Column(nullable_column.column.clone()), has_null)
+            }
+        }
+    }
+
     pub fn domain(&self, data_type: &DataType) -> Domain {
         match self {
             Value::Scalar(scalar) => scalar.as_ref().domain(data_type),

tests/sqllogictests/suites/base/03_common/03_0014_insert_into_select.test

@@ -142,5 +142,11 @@ SELECT * FROM t5;
 {"user_id":1} 1
 {"user_id":2} 2
 
+statement ok
+INSERT INTO t4 values('{}');
+
+statement error
+INSERT INTO t5 SELECT data, data:user_id AS user_id FROM t4;
+
 statement ok
 DROP DATABASE db1