Update references to use build

Author: alamb

arrow-arith/src/arity.rs

@@ -228,7 +228,7 @@ where
         .zip(b.values())
         .for_each(|(l, r)| *l = op(*l, *r));
 
-    let array = builder.finish();
+    let array = builder.build();
 
     // The builder has the null buffer from `a`, it is not changed.
     let nulls = NullBuffer::union(array.logical_nulls().as_ref(), b.logical_nulls().as_ref());
@@ -345,7 +345,7 @@ where
         if let Err(err) = r {
             return Ok(Err(err));
         }
-        let array_builder = builder.finish().into_data().into_builder();
+        let array_builder = builder.build().into_data().into_builder();
         let array_data = unsafe { array_builder.nulls(Some(nulls)).build_unchecked() };
         Ok(Ok(PrimitiveArray::<T>::from(array_data)))
     }
@@ -411,7 +411,7 @@ where
             };
         };
     }
-    Ok(Ok(builder.finish()))
+    Ok(Ok(builder.build()))
 }
 
 #[cfg(test)]

arrow-array/benches/decimal_overflow.rs

@@ -33,8 +33,8 @@ fn criterion_benchmark(c: &mut Criterion) {
             builder_256.append_value(i256::from_i128(i as i128));
         }
     }
-    let array_128 = builder_128.finish();
-    let array_256 = builder_256.finish();
+    let array_128 = builder_128.build();
+    let array_256 = builder_256.build();
 
     c.bench_function("validate_decimal_precision_128", |b| {
         b.iter(|| hint::black_box(array_128.validate_decimal_precision(8)));

arrow-array/src/array/dictionary_array.rs

@@ -507,11 +507,11 @@ impl<K: ArrowDictionaryKeyType> DictionaryArray<K> {
             (Ok(key_builder), Ok(value_builder)) => Ok(unsafe {
                 PrimitiveDictionaryBuilder::new_from_builders(key_builder, value_builder)
             }),
-            (Err(key_array), Ok(mut value_builder)) => {
-                Err(Self::try_new(key_array, Arc::new(value_builder.finish())).unwrap())
+            (Err(key_array), Ok(value_builder)) => {
+                Err(Self::try_new(key_array, Arc::new(value_builder.build())).unwrap())
             }
-            (Ok(mut key_builder), Err(value_array)) => {
-                Err(Self::try_new(key_builder.finish(), Arc::new(value_array)).unwrap())
+            (Ok(key_builder), Err(value_array)) => {
+                Err(Self::try_new(key_builder.build(), Arc::new(value_array)).unwrap())
             }
             (Err(key_array), Err(value_array)) => {
                 Err(Self::try_new(key_array, Arc::new(value_array)).unwrap())

arrow-array/src/array/primitive_array.rs

@@ -957,7 +957,7 @@ impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
             .values_slice_mut()
             .iter_mut()
             .for_each(|v| *v = op(*v));
-        Ok(builder.finish())
+        Ok(builder.build())
     }
 
     /// Applies a unary fallible function to all valid values in a primitive
@@ -1033,7 +1033,7 @@ impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
             return Ok(Err(err));
         }
 
-        Ok(Ok(builder.finish()))
+        Ok(Ok(builder.build()))
     }
 
     /// Applies a unary and nullable function to all valid values in a primitive array
@@ -2105,7 +2105,7 @@ mod tests {
         builder.append_slice(&[0, 1]);
         builder.append_null();
         builder.append_slice(&[3, 4]);
-        let arr = builder.finish();
+        let arr = builder.build();
         assert_eq!(
             "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  null,\n  3,\n  4,\n]",
             format!("{arr:?}")
@@ -2451,7 +2451,7 @@ mod tests {
         let mut decimal_builder = Decimal128Builder::with_capacity(10);
         decimal_builder.append_value(123456);
         decimal_builder.append_value(12345);
-        let result = decimal_builder.finish().with_precision_and_scale(5, 3);
+        let result = decimal_builder.build().with_precision_and_scale(5, 3);
         assert!(result.is_ok());
         let arr = result.unwrap();
         assert_eq!("12.345", arr.value_as_string(1));
@@ -2469,7 +2469,7 @@ mod tests {
         decimal_builder.append_value(99);
         decimal_builder.append_value(-100);
         decimal_builder.append_value(-99);
-        let result = decimal_builder.finish().with_precision_and_scale(2, 1);
+        let result = decimal_builder.build().with_precision_and_scale(2, 1);
         assert!(result.is_ok());
         let arr = result.unwrap();
         assert_eq!("9.9", arr.value_as_string(1));
@@ -2626,7 +2626,7 @@ mod tests {
         let decimal2 = i256::from_i128(56789);
         builder.append_value(decimal2);
 
-        let array: Decimal256Array = builder.finish().with_precision_and_scale(76, 6).unwrap();
+        let array: Decimal256Array = builder.build().with_precision_and_scale(76, 6).unwrap();
 
         let collected: Vec<_> = array.iter().collect();
         assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
@@ -2673,7 +2673,7 @@ mod tests {
         let decimal2 = 56789;
         builder.append_value(decimal2);
 
-        let array: Decimal64Array = builder.finish().with_precision_and_scale(18, 4).unwrap();
+        let array: Decimal64Array = builder.build().with_precision_and_scale(18, 4).unwrap();
 
         let collected: Vec<_> = array.iter().collect();
         assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
@@ -2707,7 +2707,7 @@ mod tests {
         let decimal2 = 56789;
         builder.append_value(decimal2);
 
-        let array: Decimal32Array = builder.finish().with_precision_and_scale(9, 2).unwrap();
+        let array: Decimal32Array = builder.build().with_precision_and_scale(9, 2).unwrap();
 
         let collected: Vec<_> = array.iter().collect();
         assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
@@ -2771,7 +2771,7 @@ mod tests {
 
         let expected: Int32Array = vec![Some(4), Some(2), Some(1)].into_iter().collect();
 
-        let new_array = builder.finish();
+        let new_array = builder.build();
         assert_eq!(expected, new_array);
     }
 

arrow-array/src/builder/buffer_builder.rs

@@ -219,7 +219,7 @@ mod tests {
         a.append_values(values, is_valid);
 
         assert_eq!(a.len(), 7);
-        let array = a.finish();
+        let array = a.build();
         assert_eq!(array.value(0), 1);
         assert!(array.is_null(1));
         assert_eq!(array.value(2), -2);

arrow-array/src/builder/fixed_size_binary_dictionary_builder.rs

@@ -128,7 +128,7 @@ where
     /// assert_eq!(keys, &UInt16Array::from_iter(0..256));
     /// ```
     pub fn try_new_from_builder<K2>(
-        mut source: FixedSizeBinaryDictionaryBuilder<K2>,
+        source: FixedSizeBinaryDictionaryBuilder<K2>,
     ) -> Result<Self, ArrowError>
     where
         K::Native: NumCast,
@@ -140,7 +140,7 @@ where
         let values_builder = source.values_builder;
         let byte_width = source.byte_width;
 
-        let source_keys = source.keys_builder.finish();
+        let source_keys = source.keys_builder.build();
         let new_keys: PrimitiveArray<K> = source_keys.try_unary(|value| {
             num_traits::cast::cast::<K2::Native, K::Native>(value).ok_or_else(|| {
                 ArrowError::CastError(format!(
@@ -561,7 +561,7 @@ mod tests {
             .append_value(<<K2 as ArrowPrimitiveType>::Native as From<u8>>::from(1u8));
         expected_keys_builder
             .append_value(<<K2 as ArrowPrimitiveType>::Native as From<u8>>::from(2u8));
-        let expected_keys = expected_keys_builder.finish();
+        let expected_keys = expected_keys_builder.build();
         assert_eq!(array.keys(), &expected_keys);
 
         let av = array.values();

arrow-array/src/builder/generic_bytes_dictionary_builder.rs

@@ -184,7 +184,7 @@ where
     /// assert_eq!(keys, &UInt16Array::from_iter(0..256));
     /// ```
     pub fn try_new_from_builder<K2>(
-        mut source: GenericByteDictionaryBuilder<K2, T>,
+        source: GenericByteDictionaryBuilder<K2, T>,
     ) -> Result<Self, ArrowError>
     where
         K::Native: NumCast,
@@ -195,7 +195,7 @@ where
         let dedup = source.dedup;
         let values_builder = source.values_builder;
 
-        let source_keys = source.keys_builder.finish();
+        let source_keys = source.keys_builder.build();
         let new_keys: PrimitiveArray<K> = source_keys.try_unary(|value| {
             num_traits::cast::cast::<K2::Native, K::Native>(value).ok_or_else(|| {
                 ArrowError::CastError(format!(
@@ -741,7 +741,7 @@ mod tests {
         expected_keys_builder.append_null();
         expected_keys_builder
             .append_value(<<K2 as ArrowPrimitiveType>::Native as From<u8>>::from(2u8));
-        let expected_keys = expected_keys_builder.finish();
+        let expected_keys = expected_keys_builder.build();
         assert_eq!(array.keys(), &expected_keys);
 
         let av = array.values();
@@ -975,7 +975,7 @@ mod tests {
             keys_builder.append_value(1);
 
             let values = values_builder.finish();
-            let keys = keys_builder.finish();
+            let keys = keys_builder.build();
 
             let data_type = DataType::Dictionary(
                 Box::new(Int32Type::DATA_TYPE),

arrow-array/src/builder/primitive_builder.rs

@@ -436,7 +436,7 @@ mod tests {
         for i in 0..5 {
             builder.append_value(i);
         }
-        let arr = builder.finish();
+        let arr = builder.build();
         assert_eq!(5, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(0, arr.null_count());
@@ -451,7 +451,7 @@ mod tests {
     fn test_primitive_array_builder_i32_append_iter() {
         let mut builder = Int32Array::builder(5);
         unsafe { builder.append_trusted_len_iter(0..5) };
-        let arr = builder.finish();
+        let arr = builder.build();
         assert_eq!(5, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(0, arr.null_count());
@@ -466,7 +466,7 @@ mod tests {
     fn test_primitive_array_builder_i32_append_nulls() {
         let mut builder = Int32Array::builder(5);
         builder.append_nulls(5);
-        let arr = builder.finish();
+        let arr = builder.build();
         assert_eq!(5, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(5, arr.null_count());
@@ -482,7 +482,7 @@ mod tests {
         for i in 0..5 {
             builder.append_value(i);
         }
-        let arr = builder.finish();
+        let arr = builder.build();
         assert_eq!(5, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(0, arr.null_count());
@@ -499,7 +499,7 @@ mod tests {
         for i in 0..5 {
             builder.append_value(i);
         }
-        let arr = builder.finish();
+        let arr = builder.build();
         assert_eq!(5, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(0, arr.null_count());
@@ -545,7 +545,7 @@ mod tests {
         builder.append_option(Some(2));
         builder.append_option(None);
         builder.append_option(Some(4));
-        let arr2 = builder.finish();
+        let arr2 = builder.build();
 
         assert_eq!(arr1.len(), arr2.len());
         assert_eq!(arr1.offset(), arr2.offset());
@@ -569,7 +569,7 @@ mod tests {
         builder.append_null();
         builder.append_null();
         builder.append_value(4);
-        let arr2 = builder.finish();
+        let arr2 = builder.build();
 
         assert_eq!(arr1.len(), arr2.len());
         assert_eq!(arr1.offset(), arr2.offset());
@@ -592,7 +592,7 @@ mod tests {
         builder.append_null();
         builder.append_null();
         builder.append_value(4);
-        let arr2 = builder.finish();
+        let arr2 = builder.build();
 
         assert_eq!(arr1.len(), arr2.len());
         assert_eq!(arr1.offset(), arr2.offset());
@@ -646,14 +646,14 @@ mod tests {
     fn test_primitive_array_builder_with_data_type() {
         let mut builder = Decimal128Builder::new().with_data_type(DataType::Decimal128(1, 2));
         builder.append_value(1);
-        let array = builder.finish();
+        let array = builder.build();
         assert_eq!(array.precision(), 1);
         assert_eq!(array.scale(), 2);
 
         let data_type = DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into()));
         let mut builder = TimestampNanosecondBuilder::new().with_data_type(data_type.clone());
         builder.append_value(1);
-        let array = builder.finish();
+        let array = builder.build();
         assert_eq!(array.data_type(), &data_type);
     }
 
@@ -682,7 +682,7 @@ mod tests {
         let mut builder = PrimitiveBuilder::<Int16Type>::new();
         builder.extend([1, 2, 3, 5, 2, 4, 4].into_iter().map(Some));
         builder.extend([2, 4, 6, 2].into_iter().map(Some));
-        let array = builder.finish();
+        let array = builder.build();
         assert_eq!(array.values(), &[1, 2, 3, 5, 2, 4, 4, 2, 4, 6, 2]);
     }
 
@@ -711,7 +711,7 @@ mod tests {
         builder.append_array(&arr1);
         builder.append_array(&arr2);
         builder.append_array(&arr3);
-        let actual = builder.finish();
+        let actual = builder.build();
         let expected = Int32Array::from(input);
 
         assert_eq!(actual, expected);
@@ -726,7 +726,7 @@ mod tests {
 
         let mut builder = Int32Array::builder(5);
         builder.append_array(&array);
-        let actual = builder.finish();
+        let actual = builder.build();
 
         assert_eq!(actual, array);
         assert_eq!(actual.values(), array.values())
@@ -738,7 +738,7 @@ mod tests {
         let array = {
             let mut builder = Decimal128Builder::new().with_data_type(DataType::Decimal128(1, 2));
             builder.append_value(1);
-            builder.finish()
+            builder.build()
         };
 
         let mut builder = Decimal128Builder::new().with_data_type(DataType::Decimal128(2, 3));

arrow-array/src/builder/primitive_dictionary_builder.rs

@@ -198,7 +198,7 @@ where
     ///
     /// assert_eq!(keys, &UInt16Array::from_iter(0..256));
     pub fn try_new_from_builder<K2>(
-        mut source: PrimitiveDictionaryBuilder<K2, V>,
+        source: PrimitiveDictionaryBuilder<K2, V>,
     ) -> Result<Self, ArrowError>
     where
         K::Native: NumCast,
@@ -208,7 +208,7 @@ where
         let map = source.map;
         let values_builder = source.values_builder;
 
-        let source_keys = source.keys_builder.finish();
+        let source_keys = source.keys_builder.build();
         let new_keys: PrimitiveArray<K> = source_keys.try_unary(|value| {
             num_traits::cast::cast::<K2::Native, K::Native>(value).ok_or_else(|| {
                 ArrowError::CastError(format!(
@@ -669,8 +669,8 @@ mod tests {
             values_builder.append_value(42);
             keys_builder.append_value(1);
 
-            let values = values_builder.finish();
-            let keys = keys_builder.finish();
+            let values = values_builder.build();
+            let keys = keys_builder.build();
 
             let data_type = DataType::Dictionary(
                 Box::new(Int32Type::DATA_TYPE),
@@ -774,7 +774,7 @@ mod tests {
             .append_value(<<K2 as ArrowPrimitiveType>::Native as From<u8>>::from(1u8));
         expected_keys_builder
             .append_value(<<K2 as ArrowPrimitiveType>::Native as From<u8>>::from(2u8));
-        let expected_keys = expected_keys_builder.finish();
+        let expected_keys = expected_keys_builder.build();
         assert_eq!(array.keys(), &expected_keys);
 
         let av = array.values();

arrow-array/src/builder/primitive_run_builder.rs

@@ -204,8 +204,8 @@ where
             let mut run_end_builder = run_ends_array.into_builder().unwrap();
             let mut values_builder = values_array.into_builder().unwrap();
             self.append_run_end_with_builders(&mut run_end_builder, &mut values_builder);
-            run_ends_array = run_end_builder.finish();
-            values_array = values_builder.finish();
+            run_ends_array = run_end_builder.build();
+            values_array = values_builder.build();
         }
 
         RunArray::try_new(&run_ends_array, &values_array).unwrap()