Method iter_to_array

datafusion/common/src/scalar/mod.rs:2693–3068

Converts an iterator of references [`ScalarValue`] into an [`ArrayRef`] corresponding to those values. For example, an iterator of [`ScalarValue::Int32`] would be converted to an [`Int32Array`]. Returns an error if the iterator is empty or if the [`ScalarValue`]s are not all the same type # Example ``` use arrow::array::{ArrayRef, BooleanArray}; use datafusion_common::ScalarValue; let scalars =

(
        scalars: impl IntoIterator<Item = ScalarValue>,
    )

    /// assert_eq!(&array, &expected);
    /// ```
    pub fn iter_to_array(
        scalars: impl IntoIterator<Item = ScalarValue>,
    ) -> Result<ArrayRef> {
        let mut scalars = scalars.into_iter().peekable();

        // figure out the type based on the first element
        let data_type = match scalars.peek() {
            None => {
                return _exec_err!("Empty iterator passed to ScalarValue::iter_to_array");
            }
            Some(sv) => sv.data_type(),
        };

        /// Creates an array of $ARRAY_TY by unpacking values of
        /// SCALAR_TY for primitive types
        macro_rules! build_array_primitive {
            ($ARRAY_TY:ident, $SCALAR_TY:ident) => {{
                {
                    let array = scalars
                        .map(|sv| {
                            if let ScalarValue::$SCALAR_TY(v) = sv {
                                Ok(v)
                            } else {
                                _exec_err!(
                                    "Inconsistent types in ScalarValue::iter_to_array. \
                                    Expected {:?}, got {:?}",
                                    data_type,
                                    sv
                                )
                            }
                        })
                        .collect::<Result<$ARRAY_TY>>()?;
                    Arc::new(array)
                }
            }};
        }

        macro_rules! build_array_primitive_tz {
            ($ARRAY_TY:ident, $SCALAR_TY:ident, $TZ:expr) => {{
                {
                    let array = scalars
                        .map(|sv| {
                            if let ScalarValue::$SCALAR_TY(v, _) = sv {
                                Ok(v)
                            } else {
                                _exec_err!(
                                    "Inconsistent types in ScalarValue::iter_to_array. \
                                    Expected {:?}, got {:?}",
                                    data_type,
                                    sv
                                )
                            }
                        })
                        .collect::<Result<$ARRAY_TY>>()?;
                    Arc::new(array.with_timezone_opt($TZ.clone()))
                }
            }};
        }