diff --git a/src/array/binary/mutable.rs b/src/array/binary/mutable.rs index df12e6d9d6c..78de6099767 100644 --- a/src/array/binary/mutable.rs +++ b/src/array/binary/mutable.rs @@ -163,6 +163,7 @@ impl MutableBinaryArray { let a: BinaryArray = self.into(); Arc::new(a) } + /// Shrinks the capacity of the [`MutableBinaryArray`] to fit its current length. pub fn shrink_to_fit(&mut self) { self.values.shrink_to_fit(); diff --git a/src/array/fixed_size_binary/mod.rs b/src/array/fixed_size_binary/mod.rs index 4209998ec1f..8ed5c5cec30 100644 --- a/src/array/fixed_size_binary/mod.rs +++ b/src/array/fixed_size_binary/mod.rs @@ -125,7 +125,7 @@ impl FixedSizeBinaryArray { let values = self .values .clone() - .slice_unchecked(offset * self.size as usize, length * self.size as usize); + .slice_unchecked(offset * self.size, length * self.size); Self { data_type: self.data_type.clone(), size: self.size, diff --git a/src/ffi/schema.rs b/src/ffi/schema.rs index 3ab3b9edcf8..e06ab4184cf 100644 --- a/src/ffi/schema.rs +++ b/src/ffi/schema.rs @@ -306,6 +306,7 @@ unsafe fn to_data_type(schema: &ArrowSchema) -> Result { let size = size_raw .parse::() .map_err(|_| Error::OutOfSpec("size is not a valid integer".to_string()))?; + println!("schema: {}", size); DataType::FixedSizeBinary(size) } ["+w", size_raw] => { diff --git a/src/trusted_len.rs b/src/trusted_len.rs index 98ff458e56a..a1c38bd51c7 100644 --- a/src/trusted_len.rs +++ b/src/trusted_len.rs @@ -21,6 +21,12 @@ where T: Copy, { } +unsafe impl<'a, I, T: 'a> TrustedLen for std::iter::Cloned +where + I: TrustedLen, + T: Clone, +{ +} unsafe impl TrustedLen for std::iter::Enumerate where I: TrustedLen {} diff --git a/tests/it/array/binary/mod.rs b/tests/it/array/binary/mod.rs index fb1bb9dcbe6..3e93a35c568 100644 --- a/tests/it/array/binary/mod.rs +++ b/tests/it/array/binary/mod.rs @@ -66,6 +66,16 @@ fn from_trusted_len_iter() { assert_eq!(a.len(), 2); } +#[test] +fn try_from_trusted_len_iter() { + let iter = std::iter::repeat(b"hello".as_ref()) + .take(2) + .map(Some) + .map(arrow2::error::Result::Ok); + let a = BinaryArray::::try_from_trusted_len_iter(iter).unwrap(); + assert_eq!(a.len(), 2); +} + #[test] fn from_iter() { let iter = std::iter::repeat(b"hello").take(2).map(Some); diff --git a/tests/it/array/binary/mutable.rs b/tests/it/array/binary/mutable.rs index d16ba14ad73..e363b47bcf8 100644 --- a/tests/it/array/binary/mutable.rs +++ b/tests/it/array/binary/mutable.rs @@ -35,30 +35,26 @@ fn from_iter() { #[test] fn from_trusted_len_iter() { - let iter = (0..3u8).map(|x| vec![x; x as usize]); - let a: MutableBinaryArray = iter.clone().map(Some).collect(); + let data = vec![vec![0; 0], vec![1; 1], vec![2; 2]]; + let a: MutableBinaryArray = data.iter().cloned().map(Some).collect(); assert_eq!(a.values().deref(), &[1u8, 2, 2]); assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]); assert_eq!(a.validity(), None); - let a = unsafe { - MutableBinaryArray::::from_trusted_len_iter_unchecked(iter.clone().map(Some)) - }; + let a = MutableBinaryArray::::from_trusted_len_iter(data.iter().cloned().map(Some)); assert_eq!(a.values().deref(), &[1u8, 2, 2]); assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]); assert_eq!(a.validity(), None); - let a = unsafe { - MutableBinaryArray::::try_from_trusted_len_iter_unchecked::( - iter.clone().map(Some).map(Ok), - ) - } + let a = MutableBinaryArray::::try_from_trusted_len_iter::( + data.iter().cloned().map(Some).map(Ok), + ) .unwrap(); assert_eq!(a.values().deref(), &[1u8, 2, 2]); assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]); assert_eq!(a.validity(), None); - let a = unsafe { MutableBinaryArray::::from_trusted_len_values_iter_unchecked(iter) }; + let a = MutableBinaryArray::::from_trusted_len_values_iter(data.iter().cloned()); assert_eq!(a.values().deref(), &[1u8, 2, 2]); assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]); assert_eq!(a.validity(), None); diff --git a/tests/it/array/boolean/mod.rs b/tests/it/array/boolean/mod.rs index 9b9ee57bd28..2dd47d480d9 100644 --- a/tests/it/array/boolean/mod.rs +++ b/tests/it/array/boolean/mod.rs @@ -39,6 +39,15 @@ fn basics() { assert!(!array.value(1)); } +#[test] +fn try_new_invalid() { + assert!(BooleanArray::try_new(DataType::Int32, [true].into(), None).is_err()); + assert!( + BooleanArray::try_new(DataType::Boolean, [true].into(), Some([false, true].into())) + .is_err() + ); +} + #[test] fn with_validity() { let bitmap = Bitmap::from([true, false, true]); @@ -58,14 +67,25 @@ fn into_mut_valid() { let bitmap = Bitmap::from([true, false, true]); let a = BooleanArray::from_data(DataType::Boolean, bitmap, None); let _ = a.into_mut().right().unwrap(); + + let bitmap = Bitmap::from([true, false, true]); + let validity = Bitmap::from([true, false, true]); + let a = BooleanArray::from_data(DataType::Boolean, bitmap, Some(validity)); + let _ = a.into_mut().right().unwrap(); } #[test] fn into_mut_invalid() { let bitmap = Bitmap::from([true, false, true]); - let _other = bitmap.clone(); // values are shared + let _other = bitmap.clone(); // values is shared let a = BooleanArray::from_data(DataType::Boolean, bitmap, None); let _ = a.into_mut().left().unwrap(); + + let bitmap = Bitmap::from([true, false, true]); + let validity = Bitmap::from([true, false, true]); + let _other = validity.clone(); // validity is shared + let a = BooleanArray::from_data(DataType::Boolean, bitmap, Some(validity)); + let _ = a.into_mut().left().unwrap(); } #[test] @@ -78,7 +98,30 @@ fn empty() { #[test] fn from_trusted_len_iter() { let iter = std::iter::repeat(true).take(2).map(Some); - let a = BooleanArray::from_trusted_len_iter(iter); + let a = BooleanArray::from_trusted_len_iter(iter.clone()); + assert_eq!(a.len(), 2); + let a = unsafe { BooleanArray::from_trusted_len_iter_unchecked(iter) }; + assert_eq!(a.len(), 2); +} + +#[test] +fn try_from_trusted_len_iter() { + let iter = std::iter::repeat(true) + .take(2) + .map(Some) + .map(arrow2::error::Result::Ok); + let a = BooleanArray::try_from_trusted_len_iter(iter.clone()).unwrap(); + assert_eq!(a.len(), 2); + let a = unsafe { BooleanArray::try_from_trusted_len_iter_unchecked(iter).unwrap() }; + assert_eq!(a.len(), 2); +} + +#[test] +fn from_trusted_len_values_iter() { + let iter = std::iter::repeat(true).take(2); + let a = BooleanArray::from_trusted_len_values_iter(iter.clone()); + assert_eq!(a.len(), 2); + let a = unsafe { BooleanArray::from_trusted_len_values_iter_unchecked(iter) }; assert_eq!(a.len(), 2); } diff --git a/tests/it/array/boolean/mutable.rs b/tests/it/array/boolean/mutable.rs index 1a7d926b643..173472106a0 100644 --- a/tests/it/array/boolean/mutable.rs +++ b/tests/it/array/boolean/mutable.rs @@ -142,3 +142,23 @@ fn extend_trusted_len_values() { ); assert_eq!(a.values(), &MutableBitmap::from([false, true, false])); } + +#[test] +fn into_iter() { + let ve = MutableBitmap::from([true, false]) + .into_iter() + .collect::>(); + assert_eq!(ve, vec![true, false]); + let ve = MutableBitmap::from([true, false]) + .iter() + .collect::>(); + assert_eq!(ve, vec![true, false]); +} + +#[test] +fn shrink_to_fit() { + let mut a = MutableBitmap::with_capacity(100); + a.push(true); + a.shrink_to_fit(); + assert_eq!(a.capacity(), 8); +} diff --git a/tests/it/bitmap/mutable.rs b/tests/it/bitmap/mutable.rs index d8bb85c0676..f228c323b73 100644 --- a/tests/it/bitmap/mutable.rs +++ b/tests/it/bitmap/mutable.rs @@ -7,6 +7,32 @@ fn from_slice() { assert_eq!(a.iter().collect::>(), slice); } +#[test] +fn from_len_zeroed() { + let a = MutableBitmap::from_len_zeroed(10); + assert_eq!(a.len(), 10); + assert_eq!(a.null_count(), 10); +} + +#[test] +fn from_len_set() { + let a = MutableBitmap::from_len_set(10); + assert_eq!(a.len(), 10); + assert_eq!(a.null_count(), 0); +} + +#[test] +fn try_new_invalid() { + assert!(MutableBitmap::try_new(vec![], 2).is_err()); +} + +#[test] +fn clear() { + let mut a = MutableBitmap::from_len_zeroed(10); + a.clear(); + assert_eq!(a.len(), 0); +} + #[test] fn trusted_len() { let data = vec![true; 65];