diff --git a/src/array/fixed_size_binary/iterator.rs b/src/array/fixed_size_binary/iterator.rs index 445e584be4a..cc88967667c 100644 --- a/src/array/fixed_size_binary/iterator.rs +++ b/src/array/fixed_size_binary/iterator.rs @@ -60,10 +60,7 @@ impl<'a> FixedSizeBinaryArray { pub fn iter( &'a self, ) -> ZipValidity<'a, &'a [u8], FixedSizeBinaryValuesIter<'a, FixedSizeBinaryArray>> { - zip_validity( - FixedSizeBinaryValuesIter::new(self), - self.validity.as_ref().map(|x| x.iter()), - ) + zip_validity(self.iter_values(), self.validity.as_ref().map(|x| x.iter())) } /// Returns iterator over the values of [`FixedSizeBinaryArray`] @@ -88,7 +85,7 @@ impl<'a> MutableFixedSizeBinaryArray { &'a self, ) -> ZipValidity<'a, &'a [u8], FixedSizeBinaryValuesIter<'a, MutableFixedSizeBinaryArray>> { zip_validity( - FixedSizeBinaryValuesIter::new(self), + self.iter_values(), self.validity().as_ref().map(|x| x.iter()), ) } diff --git a/src/array/fixed_size_binary/mod.rs b/src/array/fixed_size_binary/mod.rs index 98dc365ff33..82695c437e7 100644 --- a/src/array/fixed_size_binary/mod.rs +++ b/src/array/fixed_size_binary/mod.rs @@ -81,9 +81,10 @@ impl FixedSizeBinaryArray { /// Returns a new null [`FixedSizeBinaryArray`]. pub fn new_null(data_type: DataType, length: usize) -> Self { + let size = Self::maybe_get_size(&data_type).unwrap(); Self::new( data_type, - Buffer::new_zeroed(length), + Buffer::new_zeroed(length * size), Some(Bitmap::new_zeroed(length)), ) } diff --git a/src/array/fixed_size_binary/mutable.rs b/src/array/fixed_size_binary/mutable.rs index a5da541cc86..787996267bc 100644 --- a/src/array/fixed_size_binary/mutable.rs +++ b/src/array/fixed_size_binary/mutable.rs @@ -134,6 +134,11 @@ impl MutableFixedSizeBinaryArray { self.size } + /// Returns the capacity of this array + pub fn capacity(&self) -> usize { + self.values.capacity() / self.size + } + fn init_validity(&mut self) { let mut validity = MutableBitmap::new(); validity.extend_constant(self.len(), true); diff --git a/src/array/primitive/mutable.rs b/src/array/primitive/mutable.rs index 1b52c4eadee..92b0c647d96 100644 --- a/src/array/primitive/mutable.rs +++ b/src/array/primitive/mutable.rs @@ -262,6 +262,11 @@ impl MutablePrimitiveArray { validity.shrink_to_fit() } } + + /// Returns the capacity of this [`MutablePrimitiveArray`]. + pub fn capacity(&self) -> usize { + self.values.capacity() + } } /// Accessors @@ -477,6 +482,12 @@ impl MutablePrimitiveArray { } } + /// Creates a (non-null) [`MutablePrimitiveArray`] from a vector of values. + /// This does not have memcopy and is the fastest way to create a [`PrimitiveArray`]. + pub fn from_vec(values: Vec) -> Self { + Self::from_data(T::PRIMITIVE.into(), values, None) + } + /// Creates a new [`MutablePrimitiveArray`] from an iterator over values /// # Safety /// The iterator must be [`TrustedLen`](https://doc.rust-lang.org/std/iter/trait.TrustedLen.html). diff --git a/src/array/utf8/mod.rs b/src/array/utf8/mod.rs index 81cf97d2243..e473d5a10d2 100644 --- a/src/array/utf8/mod.rs +++ b/src/array/utf8/mod.rs @@ -341,24 +341,30 @@ impl Utf8Array { } } else { match (self.values.into_mut(), self.offsets.into_mut()) { - (Left(immutable_values), Left(immutable_offsets)) => Left(Utf8Array::from_data( - self.data_type, - immutable_offsets, - immutable_values, - None, - )), - (Left(immutable_values), Right(mutable_offsets)) => Left(Utf8Array::from_data( - self.data_type, - mutable_offsets.into(), - immutable_values, - None, - )), - (Right(mutable_values), Left(immutable_offsets)) => Left(Utf8Array::from_data( - self.data_type, - immutable_offsets, - mutable_values.into(), - None, - )), + (Left(immutable_values), Left(immutable_offsets)) => Left(unsafe { + Utf8Array::new_unchecked( + self.data_type, + immutable_offsets, + immutable_values, + None, + ) + }), + (Left(immutable_values), Right(mutable_offsets)) => Left(unsafe { + Utf8Array::new_unchecked( + self.data_type, + mutable_offsets.into(), + immutable_values, + None, + ) + }), + (Right(mutable_values), Left(immutable_offsets)) => Left(unsafe { + Utf8Array::from_data( + self.data_type, + immutable_offsets, + mutable_values.into(), + None, + ) + }), (Right(mutable_values), Right(mutable_offsets)) => { Right(MutableUtf8Array::from_data( self.data_type, diff --git a/tests/it/array/fixed_size_binary/mod.rs b/tests/it/array/fixed_size_binary/mod.rs index 9d8c2cd728a..f1edb8bf76d 100644 --- a/tests/it/array/fixed_size_binary/mod.rs +++ b/tests/it/array/fixed_size_binary/mod.rs @@ -24,7 +24,7 @@ fn basics() { #[test] fn with_validity() { let values = Buffer::from_slice([1, 2, 3, 4, 5, 6]); - let a = FixedSizeBinaryArray::from_data(DataType::FixedSizeBinary(2), values, None); + let a = FixedSizeBinaryArray::new(DataType::FixedSizeBinary(2), values, None); let a = a.with_validity(Some(Bitmap::from([true, false, true]))); assert!(a.validity().is_some()); } @@ -50,9 +50,48 @@ fn empty() { assert_eq!(array.validity(), None); } +#[test] +fn null() { + let array = FixedSizeBinaryArray::new_null(DataType::FixedSizeBinary(2), 2); + assert_eq!(array.values().len(), 4); + assert_eq!(array.validity().cloned(), Some([false, false].into())); +} + #[test] fn from_iter() { let iter = std::iter::repeat(vec![1u8, 2]).take(2).map(Some); let a = FixedSizeBinaryArray::from_iter(iter, 2); assert_eq!(a.len(), 2); } + +#[test] +fn wrong_size() { + let values = Buffer::from_slice(b"abb"); + assert!(FixedSizeBinaryArray::try_new(DataType::FixedSizeBinary(2), values, None).is_err()); +} + +#[test] +fn wrong_len() { + let values = Buffer::from_slice(b"abba"); + let validity = Some([true, false, false].into()); // it should be 2 + assert!(FixedSizeBinaryArray::try_new(DataType::FixedSizeBinary(2), values, validity).is_err()); +} + +#[test] +fn wrong_data_type() { + let values = Buffer::from_slice(b"abba"); + assert!(FixedSizeBinaryArray::try_new(DataType::Binary, values, None).is_err()); +} + +#[test] +fn to() { + let values = Buffer::from_slice(b"abba"); + let a = FixedSizeBinaryArray::new(DataType::FixedSizeBinary(2), values, None); + + let extension = DataType::Extension( + "a".to_string(), + Box::new(DataType::FixedSizeBinary(2)), + None, + ); + let _ = a.to(extension); +} diff --git a/tests/it/array/fixed_size_binary/mutable.rs b/tests/it/array/fixed_size_binary/mutable.rs index 4739baeb239..b5f5babae00 100644 --- a/tests/it/array/fixed_size_binary/mutable.rs +++ b/tests/it/array/fixed_size_binary/mutable.rs @@ -66,3 +66,35 @@ fn push_null() { let array: FixedSizeBinaryArray = array.into(); assert_eq!(array.validity(), Some(&Bitmap::from([false]))); } + +#[test] +fn as_arc() { + let mut array = MutableFixedSizeBinaryArray::try_from_iter( + vec![Some(b"ab"), Some(b"bc"), None, Some(b"fh")], + 2, + ) + .unwrap(); + + let array = array.as_arc(); + assert_eq!(array.len(), 4); +} + +#[test] +fn as_box() { + let mut array = MutableFixedSizeBinaryArray::try_from_iter( + vec![Some(b"ab"), Some(b"bc"), None, Some(b"fh")], + 2, + ) + .unwrap(); + + let array = array.as_box(); + assert_eq!(array.len(), 4); +} + +#[test] +fn shrink_to_fit_and_capacity() { + let mut array = MutableFixedSizeBinaryArray::with_capacity(2, 100); + array.push(Some([1, 2])); + array.shrink_to_fit(); + assert_eq!(array.capacity(), 1); +} diff --git a/tests/it/array/growable/fixed_binary.rs b/tests/it/array/growable/fixed_binary.rs index e5936a1f096..6c213432176 100644 --- a/tests/it/array/growable/fixed_binary.rs +++ b/tests/it/array/growable/fixed_binary.rs @@ -87,3 +87,39 @@ fn sized_offsets() { let expected = FixedSizeBinaryArray::from_iter(vec![Some(&[0, 2]), Some(&[0, 1])], 2); assert_eq!(result, expected); } + +/// to, as_box, as_arc +#[test] +fn as_box() { + let array = + FixedSizeBinaryArray::from_iter(vec![Some(b"ab"), Some(b"bc"), None, Some(b"de")], 2); + let mut a = GrowableFixedSizeBinary::new(vec![&array], false, 0); + a.extend(0, 1, 2); + + let result = a.as_box(); + let result = result + .as_any() + .downcast_ref::() + .unwrap(); + + let expected = FixedSizeBinaryArray::from_iter(vec![Some("bc"), None], 2); + assert_eq!(&expected, result); +} + +/// as_arc +#[test] +fn as_arc() { + let array = + FixedSizeBinaryArray::from_iter(vec![Some(b"ab"), Some(b"bc"), None, Some(b"de")], 2); + let mut a = GrowableFixedSizeBinary::new(vec![&array], false, 0); + a.extend(0, 1, 2); + + let result = a.as_arc(); + let result = result + .as_any() + .downcast_ref::() + .unwrap(); + + let expected = FixedSizeBinaryArray::from_iter(vec![Some("bc"), None], 2); + assert_eq!(&expected, result); +} diff --git a/tests/it/array/growable/mod.rs b/tests/it/array/growable/mod.rs index 578f34485cf..e3de20a424e 100644 --- a/tests/it/array/growable/mod.rs +++ b/tests/it/array/growable/mod.rs @@ -10,131 +10,37 @@ mod struct_; mod union; mod utf8; -/* -#[cfg(test)] -mod tests { - use std::convert::TryFrom; +use arrow2::array::growable::make_growable; +use arrow2::array::*; +use arrow2::datatypes::DataType; - use super::*; +#[test] +fn test_make_growable() { + let array = Int32Array::from_slice([1, 2]); + make_growable(&[&array], false, 2); - use crate::{ - array::{ - Array, ArrayDataRef, ArrayRef, BooleanArray, DictionaryArray, - FixedSizeBinaryArray, Int16Array, Int16Type, Int32Array, Int64Array, - Int64Builder, ListBuilder, NullArray, PrimitiveBuilder, StringArray, - StringDictionaryBuilder, StructArray, UInt8Array, - }, - buffer::Buffer, - datatypes::Field, - }; - use crate::{ - array::{ListArray, StringBuilder}, - error::Result, - }; + let array = Utf8Array::::from_slice(["a", "aa"]); + make_growable(&[&array], false, 2); - fn create_dictionary_array(values: &[&str], keys: &[Option<&str>]) -> ArrayDataRef { - let values = StringArray::from(values.to_vec()); - let mut builder = StringDictionaryBuilder::new_with_dictionary( - PrimitiveBuilder::::new(3), - &values, - ) - .unwrap(); - for key in keys { - if let Some(v) = key { - builder.append(v).unwrap(); - } else { - builder.append_null().unwrap() - } - } - builder.finish().data() - } + let array = Utf8Array::::from_slice(["a", "aa"]); + make_growable(&[&array], false, 2); - /* - // this is an old test used on a meanwhile removed dead code - // that is still useful when `MutableArrayData` supports fixed-size lists. - #[test] - fn test_fixed_size_list_append() -> Result<()> { - let int_builder = UInt16Builder::new(64); - let mut builder = FixedSizeListBuilder::::new(int_builder, 2); - builder.values().append_slice(&[1, 2])?; - builder.append(true)?; - builder.values().append_slice(&[3, 4])?; - builder.append(false)?; - builder.values().append_slice(&[5, 6])?; - builder.append(true)?; + let array = BinaryArray::::from_slice([b"a".as_ref(), b"aa".as_ref()]); + make_growable(&[&array], false, 2); - let a_builder = UInt16Builder::new(64); - let mut a_builder = FixedSizeListBuilder::::new(a_builder, 2); - a_builder.values().append_slice(&[7, 8])?; - a_builder.append(true)?; - a_builder.values().append_slice(&[9, 10])?; - a_builder.append(true)?; - a_builder.values().append_slice(&[11, 12])?; - a_builder.append(false)?; - a_builder.values().append_slice(&[13, 14])?; - a_builder.append(true)?; - a_builder.values().append_null()?; - a_builder.values().append_null()?; - a_builder.append(true)?; - let a = a_builder.finish(); + let array = BinaryArray::::from_slice([b"a".as_ref(), b"aa".as_ref()]); + make_growable(&[&array], false, 2); - // append array - builder.append_data(&[ - a.data(), - a.slice(1, 3).data(), - a.slice(2, 1).data(), - a.slice(5, 0).data(), - ])?; - let finished = builder.finish(); + let array = BinaryArray::::from_slice([b"a".as_ref(), b"aa".as_ref()]); + make_growable(&[&array], false, 2); - let expected_int_array = UInt16Array::from(vec![ - Some(1), - Some(2), - Some(3), - Some(4), - Some(5), - Some(6), - // append first array - Some(7), - Some(8), - Some(9), - Some(10), - Some(11), - Some(12), - Some(13), - Some(14), - None, - None, - // append slice(1, 3) - Some(9), - Some(10), - Some(11), - Some(12), - Some(13), - Some(14), - // append slice(2, 1) - Some(11), - Some(12), - ]); - let expected_list_data = ArrayData::new( - DataType::FixedSizeList( - Box::new(Field::new("item", DataType::UInt16, true)), - 2, - ), - 12, - None, - None, - 0, - vec![], - vec![expected_int_array.data()], - ); - let expected_list = - FixedSizeListArray::from(Arc::new(expected_list_data) as ArrayDataRef); - assert_eq!(&expected_list.values(), &finished.values()); - assert_eq!(expected_list.len(), finished.len()); + let array = + FixedSizeBinaryArray::new(DataType::FixedSizeBinary(2), b"abcd".to_vec().into(), None); + make_growable(&[&array], false, 2); - Ok(()) - } - */ + let array = DictionaryArray::::from_data( + Int32Array::from_slice([1, 2]), + std::sync::Arc::new(Int32Array::from_slice([1, 2])), + ); + make_growable(&[&array], false, 2); } -*/ diff --git a/tests/it/array/primitive/fmt.rs b/tests/it/array/primitive/fmt.rs new file mode 100644 index 00000000000..e8870b14412 --- /dev/null +++ b/tests/it/array/primitive/fmt.rs @@ -0,0 +1,226 @@ +use arrow2::{ + array::*, + datatypes::*, + types::{days_ms, months_days_ns}, +}; + +#[test] +fn debug_int32() { + let array = Int32Array::from(&[Some(1), None, Some(2)]); + assert_eq!(format!("{:?}", array), "Int32[1, None, 2]"); +} + +#[test] +fn debug_date32() { + let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Date32); + assert_eq!( + format!("{:?}", array), + "Date32[1970-01-02, None, 1970-01-03]" + ); +} + +#[test] +fn debug_time32s() { + let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Second)); + assert_eq!( + format!("{:?}", array), + "Time32(Second)[00:00:01, None, 00:00:02]" + ); +} + +#[test] +fn debug_time32ms() { + let array = + Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Millisecond)); + assert_eq!( + format!("{:?}", array), + "Time32(Millisecond)[00:00:00.001, None, 00:00:00.002]" + ); +} + +#[test] +fn debug_interval_d() { + let array = + Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Interval(IntervalUnit::YearMonth)); + assert_eq!(format!("{:?}", array), "Interval(YearMonth)[1m, None, 2m]"); +} + +#[test] +fn debug_int64() { + let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Int64); + assert_eq!(format!("{:?}", array), "Int64[1, None, 2]"); +} + +#[test] +fn debug_date64() { + let array = Int64Array::from(&[Some(1), None, Some(86400000)]).to(DataType::Date64); + assert_eq!( + format!("{:?}", array), + "Date64[1970-01-01, None, 1970-01-02]" + ); +} + +#[test] +fn debug_time64us() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Microsecond)); + assert_eq!( + format!("{:?}", array), + "Time64(Microsecond)[00:00:00.000001, None, 00:00:00.000002]" + ); +} + +#[test] +fn debug_time64ns() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Nanosecond)); + assert_eq!( + format!("{:?}", array), + "Time64(Nanosecond)[00:00:00.000000001, None, 00:00:00.000000002]" + ); +} + +#[test] +fn debug_timestamp_s() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(TimeUnit::Second, None)); + assert_eq!( + format!("{:?}", array), + "Timestamp(Second, None)[1970-01-01 00:00:01, None, 1970-01-01 00:00:02]" + ); +} + +#[test] +fn debug_timestamp_ms() { + let array = Int64Array::from(&[Some(1), None, Some(2)]) + .to(DataType::Timestamp(TimeUnit::Millisecond, None)); + assert_eq!( + format!("{:?}", array), + "Timestamp(Millisecond, None)[1970-01-01 00:00:00.001, None, 1970-01-01 00:00:00.002]" + ); +} + +#[test] +fn debug_timestamp_us() { + let array = Int64Array::from(&[Some(1), None, Some(2)]) + .to(DataType::Timestamp(TimeUnit::Microsecond, None)); + assert_eq!( + format!("{:?}", array), + "Timestamp(Microsecond, None)[1970-01-01 00:00:00.000001, None, 1970-01-01 00:00:00.000002]" + ); +} + +#[test] +fn debug_timestamp_ns() { + let array = Int64Array::from(&[Some(1), None, Some(2)]) + .to(DataType::Timestamp(TimeUnit::Nanosecond, None)); + assert_eq!( + format!("{:?}", array), + "Timestamp(Nanosecond, None)[1970-01-01 00:00:00.000000001, None, 1970-01-01 00:00:00.000000002]" + ); +} + +#[test] +fn debug_timestamp_tz_ns() { + let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp( + TimeUnit::Nanosecond, + Some("+02:00".to_string()), + )); + assert_eq!( + format!("{:?}", array), + "Timestamp(Nanosecond, Some(\"+02:00\"))[1970-01-01 02:00:00.000000001 +02:00, None, 1970-01-01 02:00:00.000000002 +02:00]" + ); +} + +#[cfg(feature = "chrono-tz")] +#[test] +fn debug_timestamp_tz1_ns() { + let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp( + TimeUnit::Nanosecond, + Some("Europe/Lisbon".to_string()), + )); + assert_eq!( + format!("{:?}", array), + "Timestamp(Nanosecond, Some(\"Europe/Lisbon\"))[1970-01-01 01:00:00.000000001 CET, None, 1970-01-01 01:00:00.000000002 CET]" + ); +} + +#[test] +fn debug_duration_ms() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Millisecond)); + assert_eq!( + format!("{:?}", array), + "Duration(Millisecond)[1ms, None, 2ms]" + ); +} + +#[test] +fn debug_duration_s() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Second)); + assert_eq!(format!("{:?}", array), "Duration(Second)[1s, None, 2s]"); +} + +#[test] +fn debug_duration_us() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Microsecond)); + assert_eq!( + format!("{:?}", array), + "Duration(Microsecond)[1us, None, 2us]" + ); +} + +#[test] +fn debug_duration_ns() { + let array = + Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Nanosecond)); + assert_eq!( + format!("{:?}", array), + "Duration(Nanosecond)[1ns, None, 2ns]" + ); +} + +#[test] +fn debug_decimal() { + let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 2)); + assert_eq!( + format!("{:?}", array), + "Decimal(5, 2)[123.45, None, 234.56]" + ); +} + +#[test] +fn debug_decimal1() { + let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 1)); + assert_eq!( + format!("{:?}", array), + "Decimal(5, 1)[1234.5, None, 2345.6]" + ); +} + +#[test] +fn debug_interval_days_ms() { + let array = DaysMsArray::from(&[Some(days_ms::new(1, 1)), None, Some(days_ms::new(2, 2))]); + assert_eq!( + format!("{:?}", array), + "Interval(DayTime)[1d1ms, None, 2d2ms]" + ); +} + +#[test] +fn debug_months_days_ns() { + let data = &[ + Some(months_days_ns::new(1, 1, 2)), + None, + Some(months_days_ns::new(2, 3, 3)), + ]; + + let array = MonthsDaysNsArray::from(&data); + + assert_eq!( + format!("{:?}", array), + "Interval(MonthDayNano)[1m1d2ns, None, 2m3d3ns]" + ); +} diff --git a/tests/it/array/primitive/mod.rs b/tests/it/array/primitive/mod.rs index b2080577eae..7599d8ef2cb 100644 --- a/tests/it/array/primitive/mod.rs +++ b/tests/it/array/primitive/mod.rs @@ -1,13 +1,8 @@ use std::iter::FromIterator; -use arrow2::{ - array::*, - bitmap::Bitmap, - buffer::Buffer, - datatypes::*, - types::{days_ms, months_days_ns}, -}; +use arrow2::{array::*, bitmap::Bitmap, buffer::Buffer, datatypes::*, types::months_days_ns}; +mod fmt; mod mutable; mod to_mutable; @@ -77,230 +72,55 @@ fn from() { } #[test] -fn debug_int32() { - let array = Int32Array::from(&[Some(1), None, Some(2)]); - assert_eq!(format!("{:?}", array), "Int32[1, None, 2]"); -} - -#[test] -fn debug_date32() { - let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Date32); - assert_eq!( - format!("{:?}", array), - "Date32[1970-01-02, None, 1970-01-03]" - ); -} - -#[test] -fn debug_time32s() { - let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Second)); - assert_eq!( - format!("{:?}", array), - "Time32(Second)[00:00:01, None, 00:00:02]" - ); -} - -#[test] -fn debug_time32ms() { - let array = - Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Millisecond)); - assert_eq!( - format!("{:?}", array), - "Time32(Millisecond)[00:00:00.001, None, 00:00:00.002]" - ); -} - -#[test] -fn debug_interval_d() { - let array = - Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Interval(IntervalUnit::YearMonth)); - assert_eq!(format!("{:?}", array), "Interval(YearMonth)[1m, None, 2m]"); -} - -#[test] -fn debug_int64() { - let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Int64); - assert_eq!(format!("{:?}", array), "Int64[1, None, 2]"); -} - -#[test] -fn debug_date64() { - let array = Int64Array::from(&[Some(1), None, Some(86400000)]).to(DataType::Date64); - assert_eq!( - format!("{:?}", array), - "Date64[1970-01-01, None, 1970-01-02]" - ); -} - -#[test] -fn debug_time64us() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Microsecond)); - assert_eq!( - format!("{:?}", array), - "Time64(Microsecond)[00:00:00.000001, None, 00:00:00.000002]" - ); -} - -#[test] -fn debug_time64ns() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Nanosecond)); - assert_eq!( - format!("{:?}", array), - "Time64(Nanosecond)[00:00:00.000000001, None, 00:00:00.000000002]" - ); -} - -#[test] -fn debug_timestamp_s() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(TimeUnit::Second, None)); - assert_eq!( - format!("{:?}", array), - "Timestamp(Second, None)[1970-01-01 00:00:01, None, 1970-01-01 00:00:02]" - ); -} - -#[test] -fn debug_timestamp_ms() { - let array = Int64Array::from(&[Some(1), None, Some(2)]) - .to(DataType::Timestamp(TimeUnit::Millisecond, None)); - assert_eq!( - format!("{:?}", array), - "Timestamp(Millisecond, None)[1970-01-01 00:00:00.001, None, 1970-01-01 00:00:00.002]" - ); -} - -#[test] -fn debug_timestamp_us() { - let array = Int64Array::from(&[Some(1), None, Some(2)]) - .to(DataType::Timestamp(TimeUnit::Microsecond, None)); - assert_eq!( - format!("{:?}", array), - "Timestamp(Microsecond, None)[1970-01-01 00:00:00.000001, None, 1970-01-01 00:00:00.000002]" - ); -} - -#[test] -fn debug_timestamp_ns() { - let array = Int64Array::from(&[Some(1), None, Some(2)]) - .to(DataType::Timestamp(TimeUnit::Nanosecond, None)); - assert_eq!( - format!("{:?}", array), - "Timestamp(Nanosecond, None)[1970-01-01 00:00:00.000000001, None, 1970-01-01 00:00:00.000000002]" - ); -} - -#[test] -fn debug_timestamp_tz_ns() { - let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp( - TimeUnit::Nanosecond, - Some("+02:00".to_string()), - )); - assert_eq!( - format!("{:?}", array), - "Timestamp(Nanosecond, Some(\"+02:00\"))[1970-01-01 02:00:00.000000001 +02:00, None, 1970-01-01 02:00:00.000000002 +02:00]" - ); -} - -#[test] -fn debug_duration_ms() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Millisecond)); - assert_eq!( - format!("{:?}", array), - "Duration(Millisecond)[1ms, None, 2ms]" - ); -} - -#[test] -fn debug_duration_s() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Second)); - assert_eq!(format!("{:?}", array), "Duration(Second)[1s, None, 2s]"); -} - -#[test] -fn debug_duration_us() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Microsecond)); - assert_eq!( - format!("{:?}", array), - "Duration(Microsecond)[1us, None, 2us]" - ); -} +fn months_days_ns() { + let data = &[ + months_days_ns::new(1, 1, 2), + months_days_ns::new(1, 1, 3), + months_days_ns::new(2, 3, 3), + ]; -#[test] -fn debug_duration_ns() { - let array = - Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Nanosecond)); - assert_eq!( - format!("{:?}", array), - "Duration(Nanosecond)[1ns, None, 2ns]" - ); -} + let array = MonthsDaysNsArray::from_slice(&data); -#[test] -fn debug_decimal() { - let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 2)); - assert_eq!( - format!("{:?}", array), - "Decimal(5, 2)[123.45, None, 234.56]" - ); + let a = array.values().as_slice(); + assert_eq!(a, data.as_ref()); } #[test] -fn debug_decimal1() { - let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 1)); - assert_eq!( - format!("{:?}", array), - "Decimal(5, 1)[1234.5, None, 2345.6]" - ); +fn wrong_data_type() { + let values = Buffer::from_slice(b"abbb"); + assert!(PrimitiveArray::try_new(DataType::Utf8, values, None).is_err()); } #[test] -fn debug_interval_days_ms() { - let array = DaysMsArray::from(&[Some(days_ms::new(1, 1)), None, Some(days_ms::new(2, 2))]); - assert_eq!( - format!("{:?}", array), - "Interval(DayTime)[1d1ms, None, 2d2ms]" - ); +fn wrong_len() { + let values = Buffer::from_slice(b"abbb"); + let validity = Some([true, false].into()); + assert!(PrimitiveArray::try_new(DataType::Utf8, values, validity).is_err()); } #[test] -fn debug_months_days_ns() { - let data = &[ - Some(months_days_ns::new(1, 1, 2)), - None, - Some(months_days_ns::new(2, 3, 3)), - ]; - - let array = MonthsDaysNsArray::from(&data); - - assert_eq!( - format!("{:?}", array), - "Interval(MonthDayNano)[1m1d2ns, None, 2m3d3ns]" - ); +fn into_mut_1() { + let values = Buffer::::from_slice([0, 1]); + let a = values.clone(); // cloned values + assert_eq!(a, values); + let array = PrimitiveArray::new(DataType::Int32, values, None); + assert!(array.into_mut().is_left()); } #[test] -fn months_days_ns() { - let data = &[ - months_days_ns::new(1, 1, 2), - months_days_ns::new(1, 1, 3), - months_days_ns::new(2, 3, 3), - ]; - - let array = MonthsDaysNsArray::from_slice(&data); - - let a = array.values().as_slice(); - assert_eq!(a, data.as_ref()); +fn into_mut_2() { + let values = Buffer::::from_slice([0, 1]); + let validity = Some([true, false].into()); + let a = validity.clone(); // cloned values + assert_eq!(a, validity); + let array = PrimitiveArray::new(DataType::Int32, values, validity); + assert!(array.into_mut().is_left()); } #[test] -#[should_panic] -fn wrong_data_type() { - let values = Buffer::from_slice(b"abbb"); - PrimitiveArray::from_data(DataType::Utf8, values, None); +fn into_mut_3() { + let values = Buffer::::from_slice([0, 1]); + let validity = Some([true, false].into()); + let array = PrimitiveArray::new(DataType::Int32, values, validity); + assert!(array.into_mut().is_right()); } diff --git a/tests/it/array/primitive/mutable.rs b/tests/it/array/primitive/mutable.rs index 33d73241ddf..d2014cbf136 100644 --- a/tests/it/array/primitive/mutable.rs +++ b/tests/it/array/primitive/mutable.rs @@ -96,6 +96,27 @@ fn natural_arc() { assert_eq!(a.len(), 2); } +#[test] +fn as_arc() { + let a = MutablePrimitiveArray::::from_slice(&[0, 1]).as_arc(); + assert_eq!(a.len(), 2); +} + +#[test] +fn as_box() { + let a = MutablePrimitiveArray::::from_slice(&[0, 1]).as_box(); + assert_eq!(a.len(), 2); +} + +#[test] +fn shrink_to_fit_and_capacity() { + let mut a = MutablePrimitiveArray::::with_capacity(100); + a.push(Some(1)); + assert!(a.capacity() >= 100); + a.shrink_to_fit(); + assert_eq!(a.capacity(), 1); +} + #[test] fn only_nulls() { let mut a = MutablePrimitiveArray::::new(); diff --git a/tests/it/array/utf8/mod.rs b/tests/it/array/utf8/mod.rs index 91c3428c7df..90e71440b55 100644 --- a/tests/it/array/utf8/mod.rs +++ b/tests/it/array/utf8/mod.rs @@ -110,60 +110,53 @@ fn try_from_trusted_len_iter() { } #[test] -#[should_panic] fn not_utf8() { let offsets = Buffer::from_slice([0, 4]); let values = Buffer::from_slice([0, 159, 146, 150]); // invalid utf8 - Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Utf8, offsets, values, None).is_err()); } #[test] -#[should_panic] fn not_utf8_individually() { let offsets = Buffer::from_slice([0, 1, 2]); let values = Buffer::from_slice([207, 128]); // each is invalid utf8, but together is valid - Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Utf8, offsets, values, None).is_err()); } #[test] -#[should_panic] fn wrong_offsets() { let offsets = Buffer::from_slice([0, 5, 4]); // invalid offsets let values = Buffer::from_slice(b"abbbbb"); - Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Utf8, offsets, values, None).is_err()); } #[test] -#[should_panic] fn wrong_data_type() { let offsets = Buffer::from_slice([0, 4]); let values = Buffer::from_slice(b"abbb"); - Utf8Array::::from_data(DataType::Int8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Int32, offsets, values, None).is_err()); } #[test] -#[should_panic] fn out_of_bounds_offsets_panics() { // the 10 is out of bounds let offsets = Buffer::from_slice([0, 10, 11]); let values = Buffer::from_slice(b"abbb"); - let _ = Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Utf8, offsets, values, None).is_err()); } #[test] -#[should_panic] fn decreasing_offset_and_ascii_panics() { let offsets = Buffer::from_slice([0, 2, 1]); let values = Buffer::from_slice(b"abbb"); - let _ = Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Utf8, offsets, values, None).is_err()); } #[test] -#[should_panic] fn decreasing_offset_and_utf8_panics() { let offsets = Buffer::from_slice([0, 2, 4, 2]); // not increasing let values = Buffer::from_slice([207, 128, 207, 128, 207, 128]); // valid utf8 - let _ = Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(Utf8Array::::try_new(DataType::Utf8, offsets, values, None).is_err()); } #[test] @@ -182,3 +175,43 @@ fn debug() { assert_eq!(format!("{:?}", array), "Utf8Array[aa, , None]"); } + +#[test] +fn into_mut_1() { + let offsets = Buffer::from_slice([0, 1]); + let values = Buffer::from_slice(b"a"); + let a = values.clone(); // cloned values + assert_eq!(a, values); + let array = Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(array.into_mut().is_left()); +} + +#[test] +fn into_mut_2() { + let offsets = Buffer::from_slice([0, 1]); + let values = Buffer::from_slice(b"a"); + let a = offsets.clone(); // cloned offsets + assert_eq!(a, offsets); + let array = Utf8Array::::from_data(DataType::Utf8, offsets, values, None); + assert!(array.into_mut().is_left()); +} + +#[test] +fn into_mut_3() { + let offsets = Buffer::from_slice([0, 1]); + let values = Buffer::from_slice(b"a"); + let validity = Some([true].into()); + let a = validity.clone(); // cloned validity + assert_eq!(a, validity); + let array = Utf8Array::::new(DataType::Utf8, offsets, values, validity); + assert!(array.into_mut().is_left()); +} + +#[test] +fn into_mut_4() { + let offsets = Buffer::from_slice([0, 1]); + let values = Buffer::from_slice(b"a"); + let validity = Some([true].into()); + let array = Utf8Array::::new(DataType::Utf8, offsets, values, validity); + assert!(array.into_mut().is_right()); +} diff --git a/tests/it/ffi/data.rs b/tests/it/ffi/data.rs index 45c2f66cc1a..63a4489a0df 100644 --- a/tests/it/ffi/data.rs +++ b/tests/it/ffi/data.rs @@ -58,26 +58,47 @@ fn test_round_trip_schema(field: Field) -> Result<()> { } #[test] -fn u32() -> Result<()> { +fn bool_nullable() -> Result<()> { + let data = BooleanArray::from(&[Some(true), None, Some(false), None]); + test_round_trip(data) +} + +#[test] +fn bool() -> Result<()> { + let data = BooleanArray::from_slice(&[true, true, false]); + test_round_trip(data) +} + +#[test] +fn u32_nullable() -> Result<()> { let data = Int32Array::from(&[Some(2), None, Some(1), None]); test_round_trip(data) } #[test] -fn u64() -> Result<()> { - let data = UInt64Array::from(&[Some(2), None, Some(1), None]); +fn u32() -> Result<()> { + let data = Int32Array::from_slice(&[2, 0, 1, 0]); + test_round_trip(data) +} + +#[test] +fn timestamp_tz() -> Result<()> { + let data = Int64Array::from(&vec![Some(2), None, None]).to(DataType::Timestamp( + TimeUnit::Second, + Some("UTC".to_string()), + )); test_round_trip(data) } #[test] -fn i64() -> Result<()> { - let data = Int64Array::from(&[Some(2), None, Some(1), None]); +fn utf8_nullable() -> Result<()> { + let data = Utf8Array::::from(&vec![Some("a"), None, Some("bb"), None]); test_round_trip(data) } #[test] fn utf8() -> Result<()> { - let data = Utf8Array::::from(&vec![Some("a"), None, Some("bb"), None]); + let data = Utf8Array::::from_slice(&["a", "", "bb", ""]); test_round_trip(data) } @@ -88,18 +109,15 @@ fn large_utf8() -> Result<()> { } #[test] -fn binary() -> Result<()> { +fn binary_nullable() -> Result<()> { let data = BinaryArray::::from(&vec![Some(b"a".as_ref()), None, Some(b"bb".as_ref()), None]); test_round_trip(data) } #[test] -fn timestamp_tz() -> Result<()> { - let data = Int64Array::from(&vec![Some(2), None, None]).to(DataType::Timestamp( - TimeUnit::Second, - Some("UTC".to_string()), - )); +fn binary() -> Result<()> { + let data = BinaryArray::::from_slice(&[b"a".as_ref(), b"", b"bb", b""]); test_round_trip(data) }