diff --git a/encodings/zigzag/src/compress.rs b/encodings/zigzag/src/compress.rs index 2f52bd89d24..260e2e375b5 100644 --- a/encodings/zigzag/src/compress.rs +++ b/encodings/zigzag/src/compress.rs @@ -77,6 +77,7 @@ where #[cfg(test)] mod test { + use rstest::rstest; use vortex_array::IntoArray; use vortex_array::LEGACY_SESSION; use vortex_array::VortexSessionExecute; @@ -85,44 +86,16 @@ mod test { use super::*; use crate::ZigZag; - #[test] - fn test_compress_i8() { + #[rstest] + #[case::i8(PrimitiveArray::from_iter(-100_i8..100))] + #[case::i16(PrimitiveArray::from_iter(-100_i16..100))] + #[case::i32(PrimitiveArray::from_iter(-100_i32..100))] + #[case::i64(PrimitiveArray::from_iter(-100_i64..100))] + fn test_compress(#[case] input: PrimitiveArray) { let mut ctx = LEGACY_SESSION.create_execution_ctx(); - let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i8..100).as_view()) - .unwrap() - .into_array(); + let compressed = zigzag_encode(input.as_view()).unwrap().into_array(); assert!(compressed.is::()); let decompressed = compressed.execute::(&mut ctx).unwrap(); - assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(-100_i8..100)); - } - #[test] - fn test_compress_i16() { - let mut ctx = LEGACY_SESSION.create_execution_ctx(); - let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i16..100).as_view()) - .unwrap() - .into_array(); - assert!(compressed.is::()); - let decompressed = compressed.execute::(&mut ctx).unwrap(); - assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(-100_i16..100)); - } - #[test] - fn test_compress_i32() { - let mut ctx = LEGACY_SESSION.create_execution_ctx(); - let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i32..100).as_view()) - .unwrap() - .into_array(); - assert!(compressed.is::()); - let decompressed = compressed.execute::(&mut ctx).unwrap(); - assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(-100_i32..100)); - } - #[test] - fn test_compress_i64() { - let mut ctx = LEGACY_SESSION.create_execution_ctx(); - let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i64..100).as_view()) - .unwrap() - .into_array(); - assert!(compressed.is::()); - let decompressed = compressed.execute::(&mut ctx).unwrap(); - assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(-100_i64..100)); + assert_arrays_eq!(decompressed, input); } } diff --git a/vortex-array/src/arrow/convert.rs b/vortex-array/src/arrow/convert.rs index 6eafa6033c5..ba95bdf0451 100644 --- a/vortex-array/src/arrow/convert.rs +++ b/vortex-array/src/arrow/convert.rs @@ -680,6 +680,7 @@ mod tests { use arrow_schema::Field; use arrow_schema::Fields; use arrow_schema::Schema; + use rstest::rstest; use crate::ArrayRef; use crate::IntoArray; @@ -689,171 +690,80 @@ mod tests { use crate::arrays::ListView; use crate::arrays::Primitive; use crate::arrays::Struct; - use crate::arrays::VarBin; use crate::arrays::VarBinView; use crate::arrays::fixed_size_list::FixedSizeListArrayExt; use crate::arrays::list::ListArrayExt; use crate::arrays::listview::ListViewArrayExt; use crate::arrays::struct_::StructArrayExt; use crate::arrow::FromArrowArray as _; - use crate::arrow::convert::TemporalArray; use crate::dtype::DType; use crate::dtype::Nullability; use crate::dtype::PType; use crate::extension::datetime::TimeUnit; use crate::extension::datetime::Timestamp; - // Test primitive array conversions - #[test] - fn test_int8_array_conversion() { - let arrow_array = Int8Array::from(vec![Some(1), None, Some(3), Some(4)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Int8Array::from(vec![1, 2, 3, 4]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with I8 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::I8); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::I8); - } - - #[test] - fn test_int16_array_conversion() { - let arrow_array = Int16Array::from(vec![Some(100), None, Some(300), Some(400)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Int16Array::from(vec![100, 200, 300, 400]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with I16 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::I16); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::I16); - } - - #[test] - fn test_int32_array_conversion() { - let arrow_array = Int32Array::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Int32Array::from(vec![1000, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with I32 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::I32); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::I32); - } - - #[test] - fn test_int64_array_conversion() { - let arrow_array = Int64Array::from(vec![Some(10000), None, Some(30000), Some(40000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Int64Array::from(vec![10000_i64, 20000, 30000, 40000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with I64 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::I64); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::I64); - } - - #[test] - fn test_uint8_array_conversion() { - let arrow_array = UInt8Array::from(vec![Some(1), None, Some(3), Some(4)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = UInt8Array::from(vec![1_u8, 2, 3, 4]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with U8 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::U8); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::U8); - } - - #[test] - fn test_uint16_array_conversion() { - let arrow_array = UInt16Array::from(vec![Some(100), None, Some(300), Some(400)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = UInt16Array::from(vec![100_u16, 200, 300, 400]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with U16 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::U16); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::U16); - } - - #[test] - fn test_uint32_array_conversion() { - let arrow_array = UInt32Array::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = UInt32Array::from(vec![1000_u32, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with U32 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::U32); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::U32); - } - - #[test] - fn test_uint64_array_conversion() { - let arrow_array = UInt64Array::from(vec![Some(10000), None, Some(30000), Some(40000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = UInt64Array::from(vec![10000_u64, 20000, 30000, 40000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with U64 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::U64); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::U64); + #[rstest] + #[case::i8( + Arc::new(Int8Array::from(vec![Some(1), None, Some(3), Some(4)])), + Arc::new(Int8Array::from(vec![1, 2, 3, 4])), + PType::I8, + )] + #[case::i16( + Arc::new(Int16Array::from(vec![Some(100), None, Some(300), Some(400)])), + Arc::new(Int16Array::from(vec![100, 200, 300, 400])), + PType::I16, + )] + #[case::i32( + Arc::new(Int32Array::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(Int32Array::from(vec![1000, 2000, 3000, 4000])), + PType::I32, + )] + #[case::i64( + Arc::new(Int64Array::from(vec![Some(10000), None, Some(30000), Some(40000)])), + Arc::new(Int64Array::from(vec![10000_i64, 20000, 30000, 40000])), + PType::I64, + )] + #[case::u8( + Arc::new(UInt8Array::from(vec![Some(1), None, Some(3), Some(4)])), + Arc::new(UInt8Array::from(vec![1_u8, 2, 3, 4])), + PType::U8, + )] + #[case::u16( + Arc::new(UInt16Array::from(vec![Some(100), None, Some(300), Some(400)])), + Arc::new(UInt16Array::from(vec![100_u16, 200, 300, 400])), + PType::U16, + )] + #[case::u32( + Arc::new(UInt32Array::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(UInt32Array::from(vec![1000_u32, 2000, 3000, 4000])), + PType::U32, + )] + #[case::u64( + Arc::new(UInt64Array::from(vec![Some(10000), None, Some(30000), Some(40000)])), + Arc::new(UInt64Array::from(vec![10000_u64, 20000, 30000, 40000])), + PType::U64, + )] + #[case::f32( + Arc::new(Float32Array::from(vec![Some(1.5), None, Some(3.5), Some(4.5)])), + Arc::new(Float32Array::from(vec![1.5_f32, 2.5, 3.5, 4.5])), + PType::F32, + )] + #[case::f64( + Arc::new(Float64Array::from(vec![Some(1.5), None, Some(3.5), Some(4.5)])), + Arc::new(Float64Array::from(vec![1.5_f64, 2.5, 3.5, 4.5])), + PType::F64, + )] + fn test_primitive_array_conversion( + #[case] nullable: Arc, + #[case] non_nullable: Arc, + #[case] expected_ptype: PType, + ) { + let v_null = ArrayRef::from_arrow(nullable.as_ref(), true).unwrap(); + let v_non_null = ArrayRef::from_arrow(non_nullable.as_ref(), false).unwrap(); + assert_eq!(v_null.len(), 4); + assert_eq!(v_non_null.len(), 4); + assert_eq!(v_null.as_::().ptype(), expected_ptype); + assert_eq!(v_non_null.as_::().ptype(), expected_ptype); } #[test] @@ -885,44 +795,6 @@ mod tests { assert_eq!(primitive_array_non_null.ptype(), PType::F16); } - #[test] - fn test_float32_array_conversion() { - let arrow_array = Float32Array::from(vec![Some(1.5), None, Some(3.5), Some(4.5)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Float32Array::from(vec![1.5_f32, 2.5, 3.5, 4.5]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with F32 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::F32); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::F32); - } - - #[test] - fn test_float64_array_conversion() { - let arrow_array = Float64Array::from(vec![Some(1.5), None, Some(3.5), Some(4.5)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Float64Array::from(vec![1.5_f64, 2.5, 3.5, 4.5]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be PrimitiveArray with F64 ptype - let primitive_array = vortex_array.as_::(); - assert_eq!(primitive_array.ptype(), PType::F64); - - let primitive_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(primitive_array_non_null.ptype(), PType::F64); - } - // Test decimal array conversions #[test] fn test_decimal128_array_conversion() { @@ -999,58 +871,55 @@ mod tests { } // Test temporal array conversions - #[test] - fn test_timestamp_second_array_conversion() { - let arrow_array = - TimestampSecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = TimestampSecondArray::from(vec![1000_i64, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be TemporalArray with Second time unit - let temporal_array = TemporalArray::try_from(vortex_array).unwrap(); - assert_eq!( - temporal_array.temporal_metadata().time_unit(), - TimeUnit::Seconds - ); - - let temporal_array_non_null = TemporalArray::try_from(vortex_array_non_null).unwrap(); - assert_eq!( - temporal_array_non_null.temporal_metadata().time_unit(), - TimeUnit::Seconds - ); - } - - #[test] - fn test_timestamp_millisecond_array_conversion() { - let arrow_array = - TimestampMillisecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = - TimestampMillisecondArray::from(vec![1000_i64, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_timestamp_microsecond_array_conversion() { - let arrow_array = - TimestampMicrosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = - TimestampMicrosecondArray::from(vec![1000_i64, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); + #[rstest] + #[case::timestamp_second( + Arc::new(TimestampSecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(TimestampSecondArray::from(vec![1000_i64, 2000, 3000, 4000])), + )] + #[case::timestamp_millisecond( + Arc::new(TimestampMillisecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(TimestampMillisecondArray::from(vec![1000_i64, 2000, 3000, 4000])), + )] + #[case::timestamp_microsecond( + Arc::new(TimestampMicrosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(TimestampMicrosecondArray::from(vec![1000_i64, 2000, 3000, 4000])), + )] + #[case::timestamp_nanosecond( + Arc::new(TimestampNanosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(TimestampNanosecondArray::from(vec![1000_i64, 2000, 3000, 4000])), + )] + #[case::time32_second( + Arc::new(Time32SecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(Time32SecondArray::from(vec![1000_i32, 2000, 3000, 4000])), + )] + #[case::time32_millisecond( + Arc::new(Time32MillisecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(Time32MillisecondArray::from(vec![1000_i32, 2000, 3000, 4000])), + )] + #[case::time64_microsecond( + Arc::new(Time64MicrosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(Time64MicrosecondArray::from(vec![1000_i64, 2000, 3000, 4000])), + )] + #[case::time64_nanosecond( + Arc::new(Time64NanosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)])), + Arc::new(Time64NanosecondArray::from(vec![1000_i64, 2000, 3000, 4000])), + )] + #[case::date32( + Arc::new(Date32Array::from(vec![Some(18000), None, Some(18002), Some(18003)])), + Arc::new(Date32Array::from(vec![18000_i32, 18001, 18002, 18003])), + )] + #[case::date64( + Arc::new(Date64Array::from(vec![Some(1555200000000), None, Some(1555286400000), Some(1555372800000)])), + Arc::new(Date64Array::from(vec![1555200000000_i64, 1555213600000, 1555286400000, 1555372800000])), + )] + fn test_temporal_array_conversion( + #[case] nullable: Arc, + #[case] non_nullable: Arc, + ) { + let v_null = ArrayRef::from_arrow(nullable.as_ref(), true).unwrap(); + let v_non_null = ArrayRef::from_arrow(non_nullable.as_ref(), false).unwrap(); + assert_eq!(v_null.len(), 4); + assert_eq!(v_non_null.len(), 4); } #[test] @@ -1090,192 +959,47 @@ mod tests { ); } - #[test] - fn test_timestamp_nanosecond_array_conversion() { - let arrow_array = - TimestampNanosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = TimestampNanosecondArray::from(vec![1000_i64, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_time32_second_array_conversion() { - let arrow_array = Time32SecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Time32SecondArray::from(vec![1000_i32, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be TemporalArray with Second time unit - let temporal_array = TemporalArray::try_from(vortex_array).unwrap(); - assert_eq!( - temporal_array.temporal_metadata().time_unit(), - TimeUnit::Seconds - ); - - let temporal_array_non_null = TemporalArray::try_from(vortex_array_non_null).unwrap(); - assert_eq!( - temporal_array_non_null.temporal_metadata().time_unit(), - TimeUnit::Seconds - ); - } - - #[test] - fn test_time32_millisecond_array_conversion() { - let arrow_array = - Time32MillisecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Time32MillisecondArray::from(vec![1000_i32, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_time64_microsecond_array_conversion() { - let arrow_array = - Time64MicrosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Time64MicrosecondArray::from(vec![1000_i64, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_time64_nanosecond_array_conversion() { - let arrow_array = - Time64NanosecondArray::from(vec![Some(1000), None, Some(3000), Some(4000)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Time64NanosecondArray::from(vec![1000_i64, 2000, 3000, 4000]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_date32_array_conversion() { - let arrow_array = Date32Array::from(vec![Some(18000), None, Some(18002), Some(18003)]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Date32Array::from(vec![18000_i32, 18001, 18002, 18003]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_date64_array_conversion() { - let arrow_array = Date64Array::from(vec![ - Some(1555200000000), - None, - Some(1555286400000), - Some(1555372800000), - ]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = Date64Array::from(vec![ - 1555200000000_i64, - 1555213600000, - 1555286400000, - 1555372800000, - ]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - // Test string/binary array conversions - #[test] - fn test_utf8_array_conversion() { - let arrow_array = StringArray::from(vec![Some("hello"), None, Some("world"), Some("test")]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = StringArray::from(vec!["hello", "world", "test", "vortex"]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - - // Verify metadata - should be VarBinArray with Utf8 dtype - let varbin_array = vortex_array.as_::(); - assert_eq!(varbin_array.dtype(), &DType::Utf8(true.into())); - - let varbin_array_non_null = vortex_array_non_null.as_::(); - assert_eq!(varbin_array_non_null.dtype(), &DType::Utf8(false.into())); - } - - #[test] - fn test_large_utf8_array_conversion() { - let arrow_array = - LargeStringArray::from(vec![Some("hello"), None, Some("world"), Some("test")]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = LargeStringArray::from(vec!["hello", "world", "test", "vortex"]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_binary_array_conversion() { - let arrow_array = BinaryArray::from(vec![ - Some("hello".as_bytes()), - None, - Some("world".as_bytes()), - Some("test".as_bytes()), - ]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = BinaryArray::from(vec![ - "hello".as_bytes(), - "world".as_bytes(), - "test".as_bytes(), - "vortex".as_bytes(), - ]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); - } - - #[test] - fn test_large_binary_array_conversion() { - let arrow_array = LargeBinaryArray::from(vec![ - Some("hello".as_bytes()), - None, - Some("world".as_bytes()), - Some("test".as_bytes()), - ]); - let vortex_array = ArrayRef::from_arrow(&arrow_array, true).unwrap(); - - let arrow_array_non_null = LargeBinaryArray::from(vec![ - "hello".as_bytes(), - "world".as_bytes(), - "test".as_bytes(), - "vortex".as_bytes(), - ]); - let vortex_array_non_null = ArrayRef::from_arrow(&arrow_array_non_null, false).unwrap(); - - assert_eq!(vortex_array.len(), 4); - assert_eq!(vortex_array_non_null.len(), 4); + #[rstest] + #[case::utf8( + Arc::new(StringArray::from(vec![Some("hello"), None, Some("world"), Some("test")])), + Arc::new(StringArray::from(vec!["hello", "world", "test", "vortex"])), + DType::Utf8(Nullability::NonNullable), + )] + #[case::large_utf8( + Arc::new(LargeStringArray::from(vec![Some("hello"), None, Some("world"), Some("test")])), + Arc::new(LargeStringArray::from(vec!["hello", "world", "test", "vortex"])), + DType::Utf8(Nullability::NonNullable), + )] + #[case::binary( + Arc::new(BinaryArray::from(vec![ + Some("hello".as_bytes()), None, Some("world".as_bytes()), Some("test".as_bytes()), + ])), + Arc::new(BinaryArray::from(vec![ + "hello".as_bytes(), "world".as_bytes(), "test".as_bytes(), "vortex".as_bytes(), + ])), + DType::Binary(Nullability::NonNullable), + )] + #[case::large_binary( + Arc::new(LargeBinaryArray::from(vec![ + Some("hello".as_bytes()), None, Some("world".as_bytes()), Some("test".as_bytes()), + ])), + Arc::new(LargeBinaryArray::from(vec![ + "hello".as_bytes(), "world".as_bytes(), "test".as_bytes(), "vortex".as_bytes(), + ])), + DType::Binary(Nullability::NonNullable), + )] + fn test_string_binary_array_conversion( + #[case] nullable: Arc, + #[case] non_nullable: Arc, + #[case] expected_non_nullable_dtype: DType, + ) { + let v_null = ArrayRef::from_arrow(nullable.as_ref(), true).unwrap(); + let v_non_null = ArrayRef::from_arrow(non_nullable.as_ref(), false).unwrap(); + assert_eq!(v_null.len(), 4); + assert_eq!(v_non_null.len(), 4); + assert_eq!(v_null.dtype(), &expected_non_nullable_dtype.as_nullable()); + assert_eq!(v_non_null.dtype(), &expected_non_nullable_dtype); } #[test]