Method normalize

arrow-array/src/record_batch.rs:541–574

Normalize a semi-structured [`RecordBatch`] into a flat table. Nested [`Field`]s will generate names separated by `separator`, up to a depth of `max_level` (unlimited if `None`). e.g. given a [`RecordBatch`] with schema: ```text "foo": StructArray<"bar": Utf8> ``` A separator of `"."` would generate a batch with the schema: ```text "foo.bar": Utf8 ``` Note that giving a depth of `Some(0)` to

(&self, separator: &str, max_level: Option<usize>)

    /// assert_eq!(expected, normalized);
    /// ```
    pub fn normalize(&self, separator: &str, max_level: Option<usize>) -> Result<Self, ArrowError> {
        let max_level = match max_level.unwrap_or(usize::MAX) {
            0 => usize::MAX,
            val => val,
        };
        let mut stack: Vec<(usize, ArrayRef, String, FieldRef)> = self
            .columns
            .iter()
            .zip(self.schema.fields())
            .rev()
            .map(|(c, f)| (0, c.clone(), f.name().clone(), Arc::clone(f)))
            .collect();
        let mut columns: Vec<ArrayRef> = Vec::new();
        let mut fields: Vec<FieldRef> = Vec::new();

        while let Some((depth, c, name, field_ref)) = stack.pop() {
            match field_ref.data_type() {
                DataType::Struct(_) if depth < max_level => {
                    let (flat_fields, flat_cols) = c.as_struct().flatten();
                    for (cff, fff) in flat_cols.into_iter().zip(flat_fields.iter()).rev() {
                        let child_name = format!("{name}{separator}{}", fff.name());
                        stack.push((depth + 1, cff, child_name, Arc::clone(fff)))
                    }
                }
                _ => {
                    let updated_field =
                        Field::new(name, field_ref.data_type().clone(), field_ref.is_nullable());
                    columns.push(c);
                    fields.push(Arc::new(updated_field));
                }
            }
        }
        RecordBatch::try_new(Arc::new(Schema::new(fields)), columns)
    }

    /// Returns the number of columns in the record batch.
    ///