chore(query): cast variant to other type allow cast JSON null as SQL NULL (#17412)

* chore(query): cast variant to other type allow cast JSON null as SQL NULL

* fix

* fix

Author: b41sh

src/query/expression/src/evaluator.rs

@@ -349,6 +349,34 @@ impl<'a> Evaluator<'a> {
                 }
                 _ => unreachable!(),
             },
+            (
+                DataType::Nullable(box DataType::Variant) | DataType::Variant,
+                DataType::Nullable(box DataType::Boolean)
+                | DataType::Nullable(box DataType::Number(_))
+                | DataType::Nullable(box DataType::String)
+                | DataType::Nullable(box DataType::Date)
+                | DataType::Nullable(box DataType::Timestamp),
+            ) => {
+                // allow cast variant to nullable types.
+                let inner_dest_ty = dest_type.remove_nullable();
+                let cast_fn = format!("to_{}", inner_dest_ty.to_string().to_lowercase());
+                if let Some(new_value) = self.run_simple_cast(
+                    span,
+                    src_type,
+                    dest_type,
+                    value.clone(),
+                    &cast_fn,
+                    validity.clone(),
+                    options,
+                )? {
+                    Ok(new_value)
+                } else {
+                    Err(ErrorCode::BadArguments(format!(
+                        "unable to cast type `{src_type}` to type `{dest_type}`"
+                    ))
+                    .set_span(span))
+                }
+            }
             (DataType::Nullable(inner_src_ty), DataType::Nullable(inner_dest_ty)) => match value {
                 Value::Scalar(Scalar::Null) => Ok(Value::Scalar(Scalar::Null)),
                 Value::Scalar(_) => {

src/query/expression/src/types.rs

@@ -114,6 +114,31 @@ impl DataType {
         }
     }
 
+    pub fn nest_wrap_nullable(&self) -> Self {
+        match self {
+            DataType::Null => self.clone(),
+            DataType::Nullable(box inner_ty) => inner_ty.nest_wrap_nullable(),
+            DataType::Array(box inner_ty) => Self::Nullable(Box::new(Self::Array(Box::new(
+                inner_ty.nest_wrap_nullable(),
+            )))),
+            DataType::Map(box DataType::Tuple(inner_tys)) if inner_tys.len() == 2 => {
+                let key_ty = inner_tys[0].clone();
+                let val_ty = inner_tys[1].nest_wrap_nullable();
+                Self::Nullable(Box::new(Self::Map(Box::new(Self::Tuple(vec![
+                    key_ty, val_ty,
+                ])))))
+            }
+            DataType::Tuple(inner_tys) => {
+                let new_inner_tys = inner_tys
+                    .iter()
+                    .map(|inner_ty| inner_ty.nest_wrap_nullable())
+                    .collect();
+                Self::Nullable(Box::new(Self::Tuple(new_inner_tys)))
+            }
+            _ => Self::Nullable(Box::new(self.clone())),
+        }
+    }
+
     pub fn is_nullable_or_null(&self) -> bool {
         matches!(self, &DataType::Nullable(_) | &DataType::Null)
     }