Hide type information from from_iter

Author: tobixdev

arrow-array/src/array/boolean_array.rs

@@ -480,11 +480,14 @@ impl From<&Option<bool>> for BooleanAdapter {
 
 impl<Ptr: Into<BooleanAdapter>> FromIterator<Ptr> for BooleanArray {
     fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
-        let vec = iter.into_iter().collect::<Vec<_>>();
-        unsafe {
-            // SAFETY: Vec iterator is trusted len
-            BooleanArray::from_trusted_len_iter(vec)
-        }
+        let iter = iter.into_iter();
+        let capacity = match iter.size_hint() {
+            (lower, Some(upper)) if lower == upper => lower,
+            _ => 0,
+        };
+        let mut builder = BooleanBuilder::with_capacity(capacity);
+        builder.extend(iter.map(|item| item.into().native));
+        builder.finish()
     }
 }
 

arrow/benches/array_from.rs

@@ -15,13 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+extern crate arrow;
 #[macro_use]
 extern crate criterion;
 
 use criterion::Criterion;
 
-extern crate arrow;
-
 use arrow::array::*;
 use arrow_buffer::i256;
 use rand::Rng;
@@ -207,40 +206,47 @@ fn array_from_vec_benchmark(c: &mut Criterion) {
     });
 }
 
-fn gen_option_vector<TItem: Copy>(item: TItem, len: usize) -> Vec<Option<TItem>> {
-    hint::black_box(
-        repeat_n(item, len)
-            .enumerate()
-            .map(|(idx, item)| if idx % 3 == 0 { None } else { Some(item) })
-            .collect(),
-    )
+fn gen_option_iter<TItem: Clone + 'static>(
+    item: TItem,
+    len: usize,
+) -> Box<dyn Iterator<Item = Option<TItem>>> {
+    hint::black_box(Box::new(repeat_n(item, len).enumerate().map(
+        |(idx, item)| {
+            if idx % 3 == 0 {
+                None
+            } else {
+                Some(item)
+            }
+        },
+    )))
 }
 
 fn from_iter_benchmark(c: &mut Criterion) {
     const ITER_LEN: usize = 16_384;
 
     // All ArrowPrimitiveType use the same implementation
     c.bench_function("Int64Array::from_iter", |b| {
-        let values = gen_option_vector(1, ITER_LEN);
-        b.iter(|| hint::black_box(Int64Array::from_iter(values.iter())));
+        b.iter(|| hint::black_box(Int64Array::from_iter(gen_option_iter(1, ITER_LEN))));
     });
     c.bench_function("Int64Array::from_trusted_len_iter", |b| {
-        let values = gen_option_vector(1, ITER_LEN);
+        let values = gen_option_iter(1, ITER_LEN);
         b.iter(|| unsafe {
-            // SAFETY: values.iter() is a TrustedLenIterator
-            hint::black_box(Int64Array::from_trusted_len_iter(values.iter()))
+            // SAFETY: gen_option_iter is a TrustedLenIterator
+            hint::black_box(Int64Array::from_trusted_len_iter(gen_option_iter(
+                1, ITER_LEN,
+            )))
         });
     });
 
     c.bench_function("BooleanArray::from_iter", |b| {
-        let values = gen_option_vector(true, ITER_LEN);
-        b.iter(|| hint::black_box(BooleanArray::from_iter(values.iter())));
+        b.iter(|| hint::black_box(BooleanArray::from_iter(gen_option_iter(true, ITER_LEN))));
     });
     c.bench_function("BooleanArray::from_trusted_len_iter", |b| {
-        let values = gen_option_vector(true, ITER_LEN);
         b.iter(|| unsafe {
-            // SAFETY: values.iter() is a TrustedLenIterator
-            hint::black_box(BooleanArray::from_trusted_len_iter(values.iter()))
+            // SAFETY: gen_option_iter is a TrustedLenIterator
+            hint::black_box(BooleanArray::from_trusted_len_iter(gen_option_iter(
+                true, ITER_LEN,
+            )))
         });
     });
 }