introduce from for struct

Signed-off-by: jayzhan211 <jayzhan211@gmail.com>

Author: jayzhan211

datafusion/common/src/scalar.rs

@@ -48,7 +48,7 @@ use arrow::{
 };
 use arrow_array::types::ArrowTimestampType;
 use arrow_array::{ArrowNativeTypeOp, Scalar};
-use arrow_buffer::Buffer;
+use arrow_buffer::{Buffer, NullBuffer};
 
 /// A dynamically typed, nullable single value, (the single-valued counter-part
 /// to arrow's [`Array`])
@@ -1793,11 +1793,6 @@ impl ScalarValue {
         Arc::new(array_into_large_list_array(values))
     }
 
-    pub fn new_struct(fields: Fields, arrays: Vec<ArrayRef>) -> Self {
-        // TODO: ensure single element per column
-        ScalarValue::Struct(Arc::new(StructArray::new(fields, arrays, None)))
-    }
-
     /// Converts a scalar value into an array of `size` rows.
     ///
     /// # Errors
@@ -2718,6 +2713,23 @@ impl From<String> for ScalarValue {
     }
 }
 
+// Wrapper for ScalarValue::Struct that checks the length of the arrays, without nulls
+impl From<(Fields, Vec<ArrayRef>)> for ScalarValue {
+    fn from((fields, arrays): (Fields, Vec<ArrayRef>)) -> Self {
+        Self::from((fields, arrays, None))
+    }
+}
+
+// Wrapper for ScalarValue::Struct that checks the length of the arrays
+impl From<(Fields, Vec<ArrayRef>, Option<NullBuffer>)> for ScalarValue {
+    fn from((fields, arrays, nulls): (Fields, Vec<ArrayRef>, Option<NullBuffer>)) -> Self {
+        for arr in arrays.iter() {
+            assert_eq!(arr.len(), 1);
+        }
+        Self::Struct(Arc::new(StructArray::new(fields, arrays, nulls)))
+    }
+}
+
 macro_rules! impl_try_from {
     ($SCALAR:ident, $NATIVE:ident) => {
         impl TryFrom<ScalarValue> for $NATIVE {
@@ -3204,9 +3216,9 @@ mod tests {
     use crate::cast::{as_string_array, as_uint32_array, as_uint64_array};
 
     #[test]
-    fn new_struct() {
-        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
-        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+    fn test_scalar_value_from_for_struct() {
+        let boolean = Arc::new(BooleanArray::from(vec![false]));
+        let int = Arc::new(Int32Array::from(vec![42]));
 
         let expected = StructArray::from(vec![
             (
@@ -3224,12 +3236,27 @@ mod tests {
             Field::new("b", DataType::Boolean, false),
             Field::new("c", DataType::Int32, false),
         ]);
-        let sv = ScalarValue::new_struct(fields, arrays);
+        let sv = ScalarValue::from((fields, arrays));
         let struct_arr = sv.to_array().unwrap();
         let actual = as_struct_array(&struct_arr).unwrap();
         assert_eq!(actual, &expected);
     }
 
+    #[test]
+    #[should_panic(expected = "assertion `left == right` failed")]
+    fn test_scalar_value_from_for_struct_should_panic() {
+        let fields = Fields::from(vec![
+            Field::new("bool", DataType::Boolean, false),
+            Field::new("i32", DataType::Int32, false),
+        ]);
+
+        let arrays = vec![
+            Arc::new(BooleanArray::from(vec![false, true, false, false])) as ArrayRef, 
+            Arc::new(Int32Array::from(vec![42, 28, 19, 31]))];
+
+        let _ = ScalarValue::from((fields, arrays));   
+    }
+
     #[test]
     fn test_to_array_of_size_for_nested() {
         // Struct

datafusion/proto/tests/cases/roundtrip_logical_plan.rs

@@ -62,8 +62,8 @@ use datafusion_proto::bytes::{
     logical_plan_from_bytes, logical_plan_from_bytes_with_extension_codec,
     logical_plan_to_bytes, logical_plan_to_bytes_with_extension_codec,
 };
+use datafusion_proto::logical_plan::from_proto;
 use datafusion_proto::logical_plan::LogicalExtensionCodec;
-use datafusion_proto::logical_plan::{from_proto, to_proto};
 use datafusion_proto::protobuf;
 
 #[cfg(feature = "json")]
@@ -877,19 +877,19 @@ fn round_trip_scalar_values() {
         ScalarValue::Binary(None),
         ScalarValue::LargeBinary(Some(b"bar".to_vec())),
         ScalarValue::LargeBinary(None),
-        ScalarValue::new_struct(
-            Fields::from(vec![
+        ScalarValue::from((
+            vec![
                 Field::new("a", DataType::Int32, true),
                 Field::new("b", DataType::Boolean, false),
-            ]),
+            ].into(),
             vec![
                 Arc::new(Int32Array::from(vec![Some(23)])) as ArrayRef,
                 Arc::new(BooleanArray::from(vec![Some(false)])) as ArrayRef,
             ],
-        ),
+        )),
         ScalarValue::try_from(&DataType::Struct(Fields::from(vec![
             Field::new("a", DataType::Int32, true),
-            Field::new("a", DataType::Boolean, false),
+            Field::new("b", DataType::Boolean, false),
         ])))
         .unwrap(),
         ScalarValue::FixedSizeBinary(b"bar".to_vec().len() as i32, Some(b"bar".to_vec())),
@@ -1824,4 +1824,4 @@ fn roundtrip_window() {
     roundtrip_expr_test(test_expr4, ctx.clone());
     roundtrip_expr_test(test_expr5, ctx.clone());
     roundtrip_expr_test(test_expr6, ctx);
-}
+}