Refactor PrimitiveBuilder Constructors

arrow/benches/builder.rs

@@ -43,7 +43,7 @@ fn bench_primitive(c: &mut Criterion) {
     ));
     group.bench_function("bench_primitive", |b| {
         b.iter(|| {
-            let mut builder = Int64Builder::new(64);
+            let mut builder = Int64Builder::with_capacity(64);
             for _ in 0..NUM_BATCHES {
                 builder.append_slice(&data[..]);
             }
@@ -57,7 +57,7 @@ fn bench_primitive_nulls(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench_primitive_nulls");
     group.bench_function("bench_primitive_nulls", |b| {
         b.iter(|| {
-            let mut builder = UInt8Builder::new(64);
+            let mut builder = UInt8Builder::with_capacity(64);
             for _ in 0..NUM_BATCHES * BATCH_SIZE {
                 builder.append_null();
             }

arrow/benches/string_dictionary_builder.rs

@@ -43,7 +43,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             |b| {
                 let strings = build_strings(dict_size, total_size, key_len);
                 b.iter(|| {
-                    let keys = Int32Builder::new(strings.len());
+                    let keys = Int32Builder::with_capacity(strings.len());
                     let values = StringBuilder::new((key_len + 1) * dict_size);
                     let mut builder = StringDictionaryBuilder::new(keys, values);
 

arrow/benches/take_kernels.rs

@@ -30,7 +30,7 @@ use arrow::{array::*, util::bench_util::*};
 
 fn create_random_index(size: usize, null_density: f32) -> UInt32Array {
     let mut rng = seedable_rng();
-    let mut builder = UInt32Builder::new(size);
+    let mut builder = UInt32Builder::with_capacity(size);
     for _ in 0..size {
         if rng.gen::<f32>() < null_density {
             builder.append_null();

arrow/examples/builders.rs

@@ -34,7 +34,7 @@ fn main() {
     // u64, i8, i16, i32, i64, f32, f64)
 
     // Create a new builder with a capacity of 100
-    let mut primitive_array_builder = Int32Builder::new(100);
+    let mut primitive_array_builder = Int32Builder::with_capacity(100);
 
     // Append an individual primitive value
     primitive_array_builder.append_value(55);

arrow/src/array/array_dictionary.rs

@@ -329,7 +329,7 @@ impl<'a, T: ArrowDictionaryKeyType> FromIterator<Option<&'a str>> for Dictionary
     fn from_iter<I: IntoIterator<Item = Option<&'a str>>>(iter: I) -> Self {
         let it = iter.into_iter();
         let (lower, _) = it.size_hint();
-        let key_builder = PrimitiveBuilder::<T>::new(lower);
+        let key_builder = PrimitiveBuilder::<T>::with_capacity(lower);
         let value_builder = StringBuilder::new(256);
         let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
         it.for_each(|i| {
@@ -367,7 +367,7 @@ impl<'a, T: ArrowDictionaryKeyType> FromIterator<&'a str> for DictionaryArray<T>
     fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self {
         let it = iter.into_iter();
         let (lower, _) = it.size_hint();
-        let key_builder = PrimitiveBuilder::<T>::new(lower);
+        let key_builder = PrimitiveBuilder::<T>::with_capacity(lower);
         let value_builder = StringBuilder::new(256);
         let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
         it.for_each(|i| {
@@ -581,8 +581,8 @@ mod tests {
 
     #[test]
     fn test_dictionary_array_fmt_debug() {
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
+        let key_builder = PrimitiveBuilder::<UInt8Type>::with_capacity(3);
+        let value_builder = PrimitiveBuilder::<UInt32Type>::with_capacity(2);
         let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
         builder.append(12345678).unwrap();
         builder.append_null();
@@ -593,8 +593,8 @@ mod tests {
             format!("{:?}", array)
         );
 
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(20);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
+        let key_builder = PrimitiveBuilder::<UInt8Type>::with_capacity(20);
+        let value_builder = PrimitiveBuilder::<UInt32Type>::with_capacity(2);
         let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
         for _ in 0..20 {
             builder.append(1).unwrap();

arrow/src/array/array_primitive.rs

@@ -91,7 +91,7 @@ impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
 
     // Returns a new primitive array builder
     pub fn builder(capacity: usize) -> PrimitiveBuilder<T> {
-        PrimitiveBuilder::<T>::new(capacity)
+        PrimitiveBuilder::<T>::with_capacity(capacity)
     }
 
     /// Returns the primitive value at index `i`.

arrow/src/array/builder/buffer_builder.rs

@@ -457,7 +457,7 @@ mod tests {
 
     #[test]
     fn test_append_values() {
-        let mut a = Int8Builder::new(0);
+        let mut a = Int8Builder::new();
         a.append_value(1);
         a.append_null();
         a.append_value(-2);

arrow/src/array/builder/fixed_size_list_builder.rs

@@ -156,7 +156,7 @@ mod tests {
 
     #[test]
     fn test_fixed_size_list_array_builder() {
-        let values_builder = Int32Builder::new(10);
+        let values_builder = Int32Builder::new();
         let mut builder = FixedSizeListBuilder::new(values_builder, 3);
 
         //  [[0, 1, 2], null, [3, null, 5], [6, 7, null]]

arrow/src/array/builder/generic_list_builder.rs

@@ -161,7 +161,7 @@ mod tests {
     use crate::datatypes::DataType;
 
     fn _test_generic_list_array_builder<O: OffsetSizeTrait>() {
-        let values_builder = Int32Builder::new(10);
+        let values_builder = Int32Builder::with_capacity(10);
         let mut builder = GenericListBuilder::<O, _>::new(values_builder);
 
         //  [[0, 1, 2], [3, 4, 5], [6, 7]]
@@ -206,7 +206,7 @@ mod tests {
     }
 
     fn _test_generic_list_array_builder_nulls<O: OffsetSizeTrait>() {
-        let values_builder = Int32Builder::new(10);
+        let values_builder = Int32Builder::with_capacity(10);
         let mut builder = GenericListBuilder::<O, _>::new(values_builder);
 
         //  [[0, 1, 2], null, [3, null, 5], [6, 7]]
@@ -265,7 +265,7 @@ mod tests {
 
     #[test]
     fn test_list_list_array_builder() {
-        let primitive_builder = Int32Builder::new(10);
+        let primitive_builder = Int32Builder::with_capacity(10);
         let values_builder = ListBuilder::new(primitive_builder);
         let mut builder = ListBuilder::new(values_builder);
 

arrow/src/array/builder/map_builder.rs

@@ -202,7 +202,7 @@ mod tests {
     #[test]
     fn test_map_array_builder() {
         let string_builder = StringBuilder::new(4);
-        let int_builder = Int32Builder::new(4);
+        let int_builder = Int32Builder::with_capacity(4);
 
         let mut builder = MapBuilder::new(None, string_builder, int_builder);
 

arrow/src/array/builder/mod.rs

@@ -73,8 +73,8 @@ pub use union_builder::UnionBuilder;
 /// # fn main() -> std::result::Result<(), ArrowError> {
 /// // Create
 /// let mut data_builders: Vec<Box<dyn ArrayBuilder>> = vec![
-///     Box::new(Float64Builder::new(1024)),
-///     Box::new(Int64Builder::new(1024)),
+///     Box::new(Float64Builder::new()),
+///     Box::new(Int64Builder::new()),
 ///     Box::new(StringBuilder::new(1024)),
 /// ];
 ///

arrow/src/array/builder/primitive_builder.rs

@@ -64,9 +64,20 @@ impl<T: ArrowPrimitiveType> ArrayBuilder for PrimitiveBuilder<T> {
     }
 }
 
+impl<T: ArrowPrimitiveType> Default for PrimitiveBuilder<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// Creates a new primitive array builder
-    pub fn new(capacity: usize) -> Self {
+    pub fn new() -> Self {
+        Self::with_capacity(1024)
+    }
+
+    /// Creates a new primitive array builder with capacity no of items
+    pub fn with_capacity(capacity: usize) -> Self {
         Self {
             values_builder: BufferBuilder::<T::Native>::new(capacity),
             null_buffer_builder: NullBufferBuilder::new(capacity),
@@ -355,7 +366,7 @@ mod tests {
 
     #[test]
     fn test_primitive_array_builder_finish() {
-        let mut builder = Int32Builder::new(5);
+        let mut builder = Int32Builder::new();
         builder.append_slice(&[2, 4, 6, 8]);
         let mut arr = builder.finish();
         assert_eq!(4, arr.len());

arrow/src/array/builder/primitive_dictionary_builder.rs

@@ -60,8 +60,8 @@ impl<T: ToByteSlice> Eq for Value<T> {}
 ///    };
 ///  use arrow::datatypes::{UInt8Type, UInt32Type};
 ///
-///  let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-///  let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
+///  let key_builder = PrimitiveBuilder::<UInt8Type>::with_capacity(3);
+///  let value_builder = PrimitiveBuilder::<UInt32Type>::with_capacity(2);
 ///  let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
 ///  builder.append(12345678).unwrap();
 ///  builder.append_null();
@@ -211,8 +211,8 @@ mod tests {
 
     #[test]
     fn test_primitive_dictionary_builder() {
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
+        let key_builder = PrimitiveBuilder::<UInt8Type>::with_capacity(3);
+        let value_builder = PrimitiveBuilder::<UInt32Type>::with_capacity(2);
         let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
         builder.append(12345678).unwrap();
         builder.append_null();
@@ -239,8 +239,8 @@ mod tests {
     #[test]
     #[should_panic(expected = "DictionaryKeyOverflowError")]
     fn test_primitive_dictionary_overflow() {
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(257);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(257);
+        let key_builder = PrimitiveBuilder::<UInt8Type>::with_capacity(257);
+        let value_builder = PrimitiveBuilder::<UInt32Type>::with_capacity(257);
         let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
         // 256 unique keys.
         for i in 0..256 {

arrow/src/array/builder/string_dictionary_builder.rs

@@ -42,7 +42,7 @@ use std::sync::Arc;
 /// // Create a dictionary array indexed by bytes whose values are Strings.
 /// // It can thus hold up to 256 distinct string values.
 ///
-/// let key_builder = PrimitiveBuilder::<Int8Type>::new(100);
+/// let key_builder = PrimitiveBuilder::<Int8Type>::with_capacity(100);
 /// let value_builder = StringBuilder::new(100);
 /// let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
 ///
@@ -111,7 +111,7 @@ where
     ///
     /// let dictionary_values = StringArray::from(vec![None, Some("abc"), Some("def")]);
     ///
-    /// let mut builder = StringDictionaryBuilder::new_with_dictionary(PrimitiveBuilder::<Int16Type>::new(3), &dictionary_values).unwrap();
+    /// let mut builder = StringDictionaryBuilder::new_with_dictionary(PrimitiveBuilder::<Int16Type>::with_capacity(3), &dictionary_values).unwrap();
     /// builder.append("def").unwrap();
     /// builder.append_null();
     /// builder.append("abc").unwrap();
@@ -290,7 +290,7 @@ mod tests {
 
     #[test]
     fn test_string_dictionary_builder() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(5);
+        let key_builder = PrimitiveBuilder::<Int8Type>::with_capacity(5);
         let value_builder = StringBuilder::new(2);
         let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
         builder.append("abc").unwrap();
@@ -317,7 +317,7 @@ mod tests {
     fn test_string_dictionary_builder_with_existing_dictionary() {
         let dictionary = StringArray::from(vec![None, Some("def"), Some("abc")]);
 
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(6);
+        let key_builder = PrimitiveBuilder::<Int8Type>::with_capacity(6);
         let mut builder =
             StringDictionaryBuilder::new_with_dictionary(key_builder, &dictionary)
                 .unwrap();
@@ -349,7 +349,7 @@ mod tests {
         let dictionary: Vec<Option<&str>> = vec![None];
         let dictionary = StringArray::from(dictionary);
 
-        let key_builder = PrimitiveBuilder::<Int16Type>::new(4);
+        let key_builder = PrimitiveBuilder::<Int16Type>::with_capacity(4);
         let mut builder =
             StringDictionaryBuilder::new_with_dictionary(key_builder, &dictionary)
                 .unwrap();