ngli-me commented on code in PR #6758:
URL: https://github.com/apache/arrow-rs/pull/6758#discussion_r1903203143
##########
arrow-array/src/record_batch.rs:
##########
@@ -394,6 +396,104 @@ impl RecordBatch {
)
}
+ /// Normalize a semi-structured [`RecordBatch`] into a flat table.
+ ///
+ /// `separator`: Nested [`Field`]s will generate names separated by
`separator`, e.g. for
+ /// separator= "." and the schema:
+ /// ```text
+ /// "foo": StructArray<"bar": Utf8>
+ /// ```
+ /// will generate:
+ /// ```text
+ /// "foo.bar": Utf8
+ /// ```
+ /// `max_level`: The maximum number of levels (depth of the `Schema` and
`Columns`) to
+ /// normalize. If `0`, normalizes all levels.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use std::sync::Arc;
+ /// # use arrow_array::{ArrayRef, Int64Array, StringArray, StructArray,
RecordBatch};
+ /// # use arrow_schema::{DataType, Field, Fields, Schema};
+ ///
+ /// let animals: ArrayRef = Arc::new(StringArray::from(vec!["Parrot",
""]));
+ /// let n_legs: ArrayRef = Arc::new(Int64Array::from(vec![Some(2),
Some(4)]));
+ ///
+ /// let animals_field = Arc::new(Field::new("animals", DataType::Utf8,
true));
+ /// let n_legs_field = Arc::new(Field::new("n_legs", DataType::Int64,
true));
+ ///
+ /// let a = Arc::new(StructArray::from(vec![
+ /// (animals_field.clone(), Arc::new(animals.clone()) as ArrayRef),
+ /// (n_legs_field.clone(), Arc::new(n_legs.clone()) as ArrayRef),
+ /// ]));
+ ///
+ /// let schema = Schema::new(vec![
+ /// Field::new(
+ /// "a",
+ /// DataType::Struct(Fields::from(vec![animals_field,
n_legs_field])),
+ /// false,
+ /// )
+ /// ]);
+ ///
+ /// let normalized = RecordBatch::try_new(Arc::new(schema), vec![a])
+ /// .expect("valid conversion")
+ /// .normalize(".", 0)
+ /// .expect("valid normalization");
+ ///
+ /// let expected = RecordBatch::try_from_iter_with_nullable(vec![
+ /// ("a.animals", animals.clone(), true),
+ /// ("a.n_legs", n_legs.clone(), true),
+ /// ])
+ /// .expect("valid conversion");
+ ///
+ /// assert_eq!(expected, normalized);
+ /// ```
+ pub fn normalize(&self, separator: &str, mut max_level: usize) ->
Result<Self, ArrowError> {
+ if max_level == 0 {
+ max_level = usize::MAX;
+ }
+ let mut queue: VecDeque<(usize, &ArrayRef, Vec<&str>, &DataType,
bool)> = VecDeque::new();
Review Comment:
This makes some sense to me, I think with that approach we would need to
reverse the Vec after the initial instantiation, that way we can just use pop.
I'll do a bit of testing with this one.
Ah, that's a good point on the `&FieldRef`, changed it over, thanks!
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
