[Variant] Bulk insert elements into List and Object Builders (#8629)

# Rationale for this change

This PR implements `Extend` for list and object builders. This way, we
can easily bulk insert items.

Author: friendlymatthew

parquet-variant/src/builder.rs

@@ -277,11 +277,7 @@ impl ValueBuilder {
 
     fn append_object<S: BuilderSpecificState>(state: ParentState<'_, S>, obj: VariantObject) {
         let mut object_builder = ObjectBuilder::new(state, false);
-
-        for (field_name, value) in obj.iter() {
-            object_builder.insert(field_name, value);
-        }
-
+        object_builder.extend(obj.iter());
         object_builder.finish();
     }
 
@@ -302,9 +298,7 @@ impl ValueBuilder {
 
     fn append_list<S: BuilderSpecificState>(state: ParentState<'_, S>, list: VariantList) {
         let mut list_builder = ListBuilder::new(state, false);
-        for value in list.iter() {
-            list_builder.append_value(value);
-        }
+        list_builder.extend(list.iter());
         list_builder.finish();
     }
 
@@ -1443,6 +1437,18 @@ impl<'a, S: BuilderSpecificState> ListBuilder<'a, S> {
     }
 }
 
+impl<'a, 'm, 'v, S, V> Extend<V> for ListBuilder<'a, S>
+where
+    S: BuilderSpecificState,
+    V: Into<Variant<'m, 'v>>,
+{
+    fn extend<T: IntoIterator<Item = V>>(&mut self, iter: T) {
+        for v in iter.into_iter() {
+            self.append_value(v);
+        }
+    }
+}
+
 /// A builder for creating [`Variant::Object`] values.
 ///
 /// See the examples on [`VariantBuilder`] for usage.
@@ -1693,6 +1699,19 @@ impl<'a, S: BuilderSpecificState> ObjectBuilder<'a, S> {
     }
 }
 
+impl<'a, 'm, 'v, S, K, V> Extend<(K, V)> for ObjectBuilder<'a, S>
+where
+    S: BuilderSpecificState,
+    K: AsRef<str>,
+    V: Into<Variant<'m, 'v>>,
+{
+    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
+        for (key, value) in iter.into_iter() {
+            self.insert(key.as_ref(), value);
+        }
+    }
+}
+
 /// Extends [`VariantBuilder`] to help building nested [`Variant`]s
 ///
 /// Allows users to append values to a [`VariantBuilder`], [`ListBuilder`] or

parquet-variant/src/variant/list.rs

@@ -727,9 +727,7 @@ mod tests {
     fn make_listi32(range: Range<i32>) -> (Vec<u8>, Vec<u8>) {
         let mut variant_builder = VariantBuilder::new();
         let mut list_builder = variant_builder.new_list();
-        for i in range {
-            list_builder.append_value(i);
-        }
+        list_builder.extend(range);
         list_builder.finish();
         variant_builder.finish()
     }
@@ -738,9 +736,7 @@ mod tests {
     fn make_listi64(range: Range<i64>) -> (Vec<u8>, Vec<u8>) {
         let mut variant_builder = VariantBuilder::new();
         let mut list_builder = variant_builder.new_list();
-        for i in range {
-            list_builder.append_value(i);
-        }
+        list_builder.extend(range);
         list_builder.finish();
         variant_builder.finish()
     }

parquet-variant/tests/variant_interop.rs

@@ -434,21 +434,17 @@ fn generate_random_value(rng: &mut StdRng, builder: &mut VariantBuilder, max_dep
             // Generate a list
             let mut list_builder = builder.new_list();
             let list_len = rng.random_range(0..10);
-
-            for _ in 0..list_len {
-                list_builder.append_value(rng.random::<i32>());
-            }
+            list_builder.extend(std::iter::repeat_with(|| rng.random::<i32>()).take(list_len));
             list_builder.finish();
         }
         14 => {
             // Generate an object
             let mut object_builder = builder.new_object();
             let obj_size = rng.random_range(0..10);
 
-            for i in 0..obj_size {
-                let key = format!("field_{i}");
-                object_builder.insert(&key, rng.random::<i32>());
-            }
+            object_builder
+                .extend((0..obj_size).map(|i| (format!("field_{i}"), rng.random::<i32>())));
+
             object_builder.finish();
         }
         15 => {