1use crate::array::print_long_array;
19use crate::builder::{BooleanBufferBuilder, BufferBuilder, PrimitiveBuilder};
20use crate::iterator::PrimitiveIter;
21use crate::temporal_conversions::{
22    as_date, as_datetime, as_datetime_with_timezone, as_duration, as_time,
23};
24use crate::timezone::Tz;
25use crate::trusted_len::trusted_len_unzip;
26use crate::types::*;
27use crate::{Array, ArrayAccessor, ArrayRef, Scalar};
28use arrow_buffer::{ArrowNativeType, Buffer, NullBuffer, ScalarBuffer, i256};
29use arrow_data::bit_iterator::try_for_each_valid_idx;
30use arrow_data::{ArrayData, ArrayDataBuilder};
31use arrow_schema::{ArrowError, DataType};
32use chrono::{DateTime, Duration, NaiveDate, NaiveDateTime, NaiveTime};
33use half::f16;
34use std::any::Any;
35use std::sync::Arc;
36
37pub type Int8Array = PrimitiveArray<Int8Type>;
55
56pub type Int16Array = PrimitiveArray<Int16Type>;
74
75pub type Int32Array = PrimitiveArray<Int32Type>;
93
94pub type Int64Array = PrimitiveArray<Int64Type>;
112
113pub type UInt8Array = PrimitiveArray<UInt8Type>;
131
132pub type UInt16Array = PrimitiveArray<UInt16Type>;
150
151pub type UInt32Array = PrimitiveArray<UInt32Type>;
169
170pub type UInt64Array = PrimitiveArray<UInt64Type>;
188
189pub type Float16Array = PrimitiveArray<Float16Type>;
215
216pub type Float32Array = PrimitiveArray<Float32Type>;
234
235pub type Float64Array = PrimitiveArray<Float64Type>;
253
254pub type TimestampSecondArray = PrimitiveArray<TimestampSecondType>;
302
303pub type TimestampMillisecondArray = PrimitiveArray<TimestampMillisecondType>;
307
308pub type TimestampMicrosecondArray = PrimitiveArray<TimestampMicrosecondType>;
312
313pub type TimestampNanosecondArray = PrimitiveArray<TimestampNanosecondType>;
317
318pub type Date32Array = PrimitiveArray<Date32Type>;
323
324pub type Date64Array = PrimitiveArray<Date64Type>;
329
330pub type Time32SecondArray = PrimitiveArray<Time32SecondType>;
335
336pub type Time32MillisecondArray = PrimitiveArray<Time32MillisecondType>;
341
342pub type Time64MicrosecondArray = PrimitiveArray<Time64MicrosecondType>;
347
348pub type Time64NanosecondArray = PrimitiveArray<Time64NanosecondType>;
353
354pub type IntervalYearMonthArray = PrimitiveArray<IntervalYearMonthType>;
368
369pub type IntervalDayTimeArray = PrimitiveArray<IntervalDayTimeType>;
384
385pub type IntervalMonthDayNanoArray = PrimitiveArray<IntervalMonthDayNanoType>;
400
401pub type DurationSecondArray = PrimitiveArray<DurationSecondType>;
403
404pub type DurationMillisecondArray = PrimitiveArray<DurationMillisecondType>;
406
407pub type DurationMicrosecondArray = PrimitiveArray<DurationMicrosecondType>;
409
410pub type DurationNanosecondArray = PrimitiveArray<DurationNanosecondType>;
412
413pub type Decimal32Array = PrimitiveArray<Decimal32Type>;
431
432pub type Decimal64Array = PrimitiveArray<Decimal64Type>;
450
451pub type Decimal128Array = PrimitiveArray<Decimal128Type>;
469
470pub type Decimal256Array = PrimitiveArray<Decimal256Type>;
489
490pub use crate::types::ArrowPrimitiveType;
491
492pub struct PrimitiveArray<T: ArrowPrimitiveType> {
567    data_type: DataType,
568    values: ScalarBuffer<T::Native>,
570    nulls: Option<NullBuffer>,
571}
572
573impl<T: ArrowPrimitiveType> Clone for PrimitiveArray<T> {
574    fn clone(&self) -> Self {
575        Self {
576            data_type: self.data_type.clone(),
577            values: self.values.clone(),
578            nulls: self.nulls.clone(),
579        }
580    }
581}
582
583impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
584    pub fn new(values: ScalarBuffer<T::Native>, nulls: Option<NullBuffer>) -> Self {
606        Self::try_new(values, nulls).unwrap()
607    }
608
609    pub fn new_null(length: usize) -> Self {
611        Self {
612            data_type: T::DATA_TYPE,
613            values: vec![T::Native::usize_as(0); length].into(),
614            nulls: Some(NullBuffer::new_null(length)),
615        }
616    }
617
618    pub fn try_new(
625        values: ScalarBuffer<T::Native>,
626        nulls: Option<NullBuffer>,
627    ) -> Result<Self, ArrowError> {
628        if let Some(n) = nulls.as_ref() {
629            if n.len() != values.len() {
630                return Err(ArrowError::InvalidArgumentError(format!(
631                    "Incorrect length of null buffer for PrimitiveArray, expected {} got {}",
632                    values.len(),
633                    n.len(),
634                )));
635            }
636        }
637
638        Ok(Self {
639            data_type: T::DATA_TYPE,
640            values,
641            nulls,
642        })
643    }
644
645    pub fn new_scalar(value: T::Native) -> Scalar<Self> {
647        Scalar::new(Self {
648            data_type: T::DATA_TYPE,
649            values: vec![value].into(),
650            nulls: None,
651        })
652    }
653
654    pub fn into_parts(self) -> (DataType, ScalarBuffer<T::Native>, Option<NullBuffer>) {
656        (self.data_type, self.values, self.nulls)
657    }
658
659    pub fn with_data_type(self, data_type: DataType) -> Self {
668        Self::assert_compatible(&data_type);
669        Self { data_type, ..self }
670    }
671
672    fn assert_compatible(data_type: &DataType) {
674        assert!(
675            Self::is_compatible(data_type),
676            "PrimitiveArray expected data type {} got {}",
677            T::DATA_TYPE,
678            data_type
679        );
680    }
681
682    #[inline]
684    pub fn len(&self) -> usize {
685        self.values.len()
686    }
687
688    pub fn is_empty(&self) -> bool {
690        self.values.is_empty()
691    }
692
693    #[inline]
695    pub fn values(&self) -> &ScalarBuffer<T::Native> {
696        &self.values
697    }
698
699    pub fn builder(capacity: usize) -> PrimitiveBuilder<T> {
701        PrimitiveBuilder::<T>::with_capacity(capacity)
702    }
703
704    pub fn is_compatible(data_type: &DataType) -> bool {
709        match T::DATA_TYPE {
710            DataType::Timestamp(t1, _) => {
711                matches!(data_type, DataType::Timestamp(t2, _) if &t1 == t2)
712            }
713            DataType::Decimal32(_, _) => matches!(data_type, DataType::Decimal32(_, _)),
714            DataType::Decimal64(_, _) => matches!(data_type, DataType::Decimal64(_, _)),
715            DataType::Decimal128(_, _) => matches!(data_type, DataType::Decimal128(_, _)),
716            DataType::Decimal256(_, _) => matches!(data_type, DataType::Decimal256(_, _)),
717            _ => T::DATA_TYPE.eq(data_type),
718        }
719    }
720
721    #[inline]
730    pub unsafe fn value_unchecked(&self, i: usize) -> T::Native {
731        unsafe { *self.values.get_unchecked(i) }
732    }
733
734    #[inline]
742    pub fn value(&self, i: usize) -> T::Native {
743        assert!(
744            i < self.len(),
745            "Trying to access an element at index {} from a PrimitiveArray of length {}",
746            i,
747            self.len()
748        );
749        unsafe { self.value_unchecked(i) }
750    }
751
752    pub fn from_iter_values<I: IntoIterator<Item = T::Native>>(iter: I) -> Self {
754        let val_buf: Buffer = iter.into_iter().collect();
755        let len = val_buf.len() / std::mem::size_of::<T::Native>();
756        Self {
757            data_type: T::DATA_TYPE,
758            values: ScalarBuffer::new(val_buf, 0, len),
759            nulls: None,
760        }
761    }
762
763    pub fn from_iter_values_with_nulls<I: IntoIterator<Item = T::Native>>(
765        iter: I,
766        nulls: Option<NullBuffer>,
767    ) -> Self {
768        let val_buf: Buffer = iter.into_iter().collect();
769        let len = val_buf.len() / std::mem::size_of::<T::Native>();
770        Self {
771            data_type: T::DATA_TYPE,
772            values: ScalarBuffer::new(val_buf, 0, len),
773            nulls,
774        }
775    }
776
777    pub fn from_value(value: T::Native, count: usize) -> Self {
779        let val_buf: Vec<_> = vec![value; count];
780        Self::new(val_buf.into(), None)
781    }
782
783    pub fn take_iter<'a>(
785        &'a self,
786        indexes: impl Iterator<Item = Option<usize>> + 'a,
787    ) -> impl Iterator<Item = Option<T::Native>> + 'a {
788        indexes.map(|opt_index| opt_index.map(|index| self.value(index)))
789    }
790
791    pub unsafe fn take_iter_unchecked<'a>(
796        &'a self,
797        indexes: impl Iterator<Item = Option<usize>> + 'a,
798    ) -> impl Iterator<Item = Option<T::Native>> + 'a {
799        indexes.map(|opt_index| opt_index.map(|index| unsafe { self.value_unchecked(index) }))
800    }
801
802    pub fn slice(&self, offset: usize, length: usize) -> Self {
804        Self {
805            data_type: self.data_type.clone(),
806            values: self.values.slice(offset, length),
807            nulls: self.nulls.as_ref().map(|n| n.slice(offset, length)),
808        }
809    }
810
811    pub fn reinterpret_cast<K>(&self) -> PrimitiveArray<K>
829    where
830        K: ArrowPrimitiveType<Native = T::Native>,
831    {
832        let d = self.to_data().into_builder().data_type(K::DATA_TYPE);
833
834        PrimitiveArray::from(unsafe { d.build_unchecked() })
837    }
838
839    pub fn unary<F, O>(&self, op: F) -> PrimitiveArray<O>
870    where
871        O: ArrowPrimitiveType,
872        F: Fn(T::Native) -> O::Native,
873    {
874        let nulls = self.nulls().cloned();
875        let values = self.values().into_iter().map(|v| op(*v));
876        let buffer: Vec<_> = values.collect();
877        PrimitiveArray::new(buffer.into(), nulls)
878    }
879
880    pub fn unary_mut<F>(self, op: F) -> Result<PrimitiveArray<T>, PrimitiveArray<T>>
924    where
925        F: Fn(T::Native) -> T::Native,
926    {
927        let mut builder = self.into_builder()?;
928        builder
929            .values_slice_mut()
930            .iter_mut()
931            .for_each(|v| *v = op(*v));
932        Ok(builder.finish())
933    }
934
935    pub fn try_unary<F, O, E>(&self, op: F) -> Result<PrimitiveArray<O>, E>
944    where
945        O: ArrowPrimitiveType,
946        F: Fn(T::Native) -> Result<O::Native, E>,
947    {
948        let len = self.len();
949
950        let nulls = self.nulls().cloned();
951        let mut buffer = BufferBuilder::<O::Native>::new(len);
952        buffer.append_n_zeroed(len);
953        let slice = buffer.as_slice_mut();
954
955        let f = |idx| {
956            unsafe { *slice.get_unchecked_mut(idx) = op(self.value_unchecked(idx))? };
957            Ok::<_, E>(())
958        };
959
960        match &nulls {
961            Some(nulls) => nulls.try_for_each_valid_idx(f)?,
962            None => (0..len).try_for_each(f)?,
963        }
964
965        let values = buffer.finish().into();
966        Ok(PrimitiveArray::new(values, nulls))
967    }
968
969    pub fn try_unary_mut<F, E>(
987        self,
988        op: F,
989    ) -> Result<Result<PrimitiveArray<T>, E>, PrimitiveArray<T>>
990    where
991        F: Fn(T::Native) -> Result<T::Native, E>,
992    {
993        let len = self.len();
994        let null_count = self.null_count();
995        let mut builder = self.into_builder()?;
996
997        let (slice, null_buffer) = builder.slices_mut();
998
999        let r = try_for_each_valid_idx(len, 0, null_count, null_buffer.as_deref(), |idx| {
1000            unsafe { *slice.get_unchecked_mut(idx) = op(*slice.get_unchecked(idx))? };
1001            Ok::<_, E>(())
1002        });
1003
1004        if let Err(err) = r {
1005            return Ok(Err(err));
1006        }
1007
1008        Ok(Ok(builder.finish()))
1009    }
1010
1011    pub fn unary_opt<F, O>(&self, op: F) -> PrimitiveArray<O>
1019    where
1020        O: ArrowPrimitiveType,
1021        F: Fn(T::Native) -> Option<O::Native>,
1022    {
1023        let len = self.len();
1024        let (nulls, null_count, offset) = match self.nulls() {
1025            Some(n) => (Some(n.validity()), n.null_count(), n.offset()),
1026            None => (None, 0, 0),
1027        };
1028
1029        let mut null_builder = BooleanBufferBuilder::new(len);
1030        match nulls {
1031            Some(b) => null_builder.append_packed_range(offset..offset + len, b),
1032            None => null_builder.append_n(len, true),
1033        }
1034
1035        let mut buffer = BufferBuilder::<O::Native>::new(len);
1036        buffer.append_n_zeroed(len);
1037        let slice = buffer.as_slice_mut();
1038
1039        let mut out_null_count = null_count;
1040
1041        let _ = try_for_each_valid_idx(len, offset, null_count, nulls, |idx| {
1042            match op(unsafe { self.value_unchecked(idx) }) {
1043                Some(v) => unsafe { *slice.get_unchecked_mut(idx) = v },
1044                None => {
1045                    out_null_count += 1;
1046                    null_builder.set_bit(idx, false);
1047                }
1048            }
1049            Ok::<_, ()>(())
1050        });
1051
1052        let nulls = null_builder.finish();
1053        let values = buffer.finish().into();
1054        let nulls = unsafe { NullBuffer::new_unchecked(nulls, out_null_count) };
1055        PrimitiveArray::new(values, Some(nulls))
1056    }
1057
1058    pub fn from_unary<U: ArrayAccessor, F>(left: U, mut op: F) -> Self
1074    where
1075        F: FnMut(U::Item) -> T::Native,
1076    {
1077        let nulls = left.logical_nulls();
1078        let buffer: Vec<_> = (0..left.len())
1079            .map(|i| op(unsafe { left.value_unchecked(i) }))
1081            .collect();
1082        PrimitiveArray::new(buffer.into(), nulls)
1083    }
1084
1085    pub fn into_builder(self) -> Result<PrimitiveBuilder<T>, Self> {
1096        let len = self.len();
1097        let data = self.into_data();
1098        let null_bit_buffer = data.nulls().map(|b| b.inner().sliced());
1099
1100        let element_len = std::mem::size_of::<T::Native>();
1101        let buffer =
1102            data.buffers()[0].slice_with_length(data.offset() * element_len, len * element_len);
1103
1104        drop(data);
1105
1106        let try_mutable_null_buffer = match null_bit_buffer {
1107            None => Ok(None),
1108            Some(null_buffer) => {
1109                null_buffer.into_mutable().map(Some)
1111            }
1112        };
1113
1114        let try_mutable_buffers = match try_mutable_null_buffer {
1115            Ok(mutable_null_buffer) => {
1116                let try_mutable_buffer = buffer.into_mutable();
1118
1119                match try_mutable_buffer {
1122                    Ok(mutable_buffer) => Ok(PrimitiveBuilder::<T>::new_from_buffer(
1123                        mutable_buffer,
1124                        mutable_null_buffer,
1125                    )),
1126                    Err(buffer) => Err((buffer, mutable_null_buffer.map(|b| b.into()))),
1127                }
1128            }
1129            Err(mutable_null_buffer) => {
1130                Err((buffer, Some(mutable_null_buffer)))
1132            }
1133        };
1134
1135        match try_mutable_buffers {
1136            Ok(builder) => Ok(builder),
1137            Err((buffer, null_bit_buffer)) => {
1138                let builder = ArrayData::builder(T::DATA_TYPE)
1139                    .len(len)
1140                    .add_buffer(buffer)
1141                    .null_bit_buffer(null_bit_buffer);
1142
1143                let array_data = unsafe { builder.build_unchecked() };
1144                let array = PrimitiveArray::<T>::from(array_data);
1145
1146                Err(array)
1147            }
1148        }
1149    }
1150}
1151
1152impl<T: ArrowPrimitiveType> From<PrimitiveArray<T>> for ArrayData {
1153    fn from(array: PrimitiveArray<T>) -> Self {
1154        let builder = ArrayDataBuilder::new(array.data_type)
1155            .len(array.values.len())
1156            .nulls(array.nulls)
1157            .buffers(vec![array.values.into_inner()]);
1158
1159        unsafe { builder.build_unchecked() }
1160    }
1161}
1162
1163impl<T: ArrowPrimitiveType> Array for PrimitiveArray<T> {
1164    fn as_any(&self) -> &dyn Any {
1165        self
1166    }
1167
1168    fn to_data(&self) -> ArrayData {
1169        self.clone().into()
1170    }
1171
1172    fn into_data(self) -> ArrayData {
1173        self.into()
1174    }
1175
1176    fn data_type(&self) -> &DataType {
1177        &self.data_type
1178    }
1179
1180    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
1181        Arc::new(self.slice(offset, length))
1182    }
1183
1184    fn len(&self) -> usize {
1185        self.values.len()
1186    }
1187
1188    fn is_empty(&self) -> bool {
1189        self.values.is_empty()
1190    }
1191
1192    fn shrink_to_fit(&mut self) {
1193        self.values.shrink_to_fit();
1194        if let Some(nulls) = &mut self.nulls {
1195            nulls.shrink_to_fit();
1196        }
1197    }
1198
1199    fn offset(&self) -> usize {
1200        0
1201    }
1202
1203    fn nulls(&self) -> Option<&NullBuffer> {
1204        self.nulls.as_ref()
1205    }
1206
1207    fn logical_null_count(&self) -> usize {
1208        self.null_count()
1209    }
1210
1211    fn get_buffer_memory_size(&self) -> usize {
1212        let mut size = self.values.inner().capacity();
1213        if let Some(n) = self.nulls.as_ref() {
1214            size += n.buffer().capacity();
1215        }
1216        size
1217    }
1218
1219    fn get_array_memory_size(&self) -> usize {
1220        std::mem::size_of::<Self>() + self.get_buffer_memory_size()
1221    }
1222}
1223
1224impl<T: ArrowPrimitiveType> ArrayAccessor for &PrimitiveArray<T> {
1225    type Item = T::Native;
1226
1227    fn value(&self, index: usize) -> Self::Item {
1228        PrimitiveArray::value(self, index)
1229    }
1230
1231    #[inline]
1232    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
1233        unsafe { PrimitiveArray::value_unchecked(self, index) }
1234    }
1235}
1236
1237impl<T: ArrowTemporalType> PrimitiveArray<T>
1238where
1239    i64: From<T::Native>,
1240{
1241    pub fn value_as_datetime(&self, i: usize) -> Option<NaiveDateTime> {
1248        as_datetime::<T>(i64::from(self.value(i)))
1249    }
1250
1251    pub fn value_as_datetime_with_tz(&self, i: usize, tz: Tz) -> Option<DateTime<Tz>> {
1258        as_datetime_with_timezone::<T>(i64::from(self.value(i)), tz)
1259    }
1260
1261    pub fn value_as_date(&self, i: usize) -> Option<NaiveDate> {
1267        self.value_as_datetime(i).map(|datetime| datetime.date())
1268    }
1269
1270    pub fn value_as_time(&self, i: usize) -> Option<NaiveTime> {
1276        as_time::<T>(i64::from(self.value(i)))
1277    }
1278
1279    pub fn value_as_duration(&self, i: usize) -> Option<Duration> {
1285        as_duration::<T>(i64::from(self.value(i)))
1286    }
1287}
1288
1289impl<T: ArrowPrimitiveType> std::fmt::Debug for PrimitiveArray<T> {
1290    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1291        let data_type = self.data_type();
1292
1293        write!(f, "PrimitiveArray<{data_type}>\n[\n")?;
1294        print_long_array(self, f, |array, index, f| match data_type {
1295            DataType::Date32 | DataType::Date64 => {
1296                let v = self.value(index).to_i64().unwrap();
1297                match as_date::<T>(v) {
1298                    Some(date) => write!(f, "{date:?}"),
1299                    None => {
1300                        write!(
1301                            f,
1302                            "Cast error: Failed to convert {v} to temporal for {data_type}"
1303                        )
1304                    }
1305                }
1306            }
1307            DataType::Time32(_) | DataType::Time64(_) => {
1308                let v = self.value(index).to_i64().unwrap();
1309                match as_time::<T>(v) {
1310                    Some(time) => write!(f, "{time:?}"),
1311                    None => {
1312                        write!(
1313                            f,
1314                            "Cast error: Failed to convert {v} to temporal for {data_type}"
1315                        )
1316                    }
1317                }
1318            }
1319            DataType::Timestamp(_, tz_string_opt) => {
1320                let v = self.value(index).to_i64().unwrap();
1321                match tz_string_opt {
1322                    Some(tz_string) => {
1324                        match tz_string.parse::<Tz>() {
1325                            Ok(tz) => match as_datetime_with_timezone::<T>(v, tz) {
1327                                Some(datetime) => write!(f, "{}", datetime.to_rfc3339()),
1328                                None => write!(f, "null"),
1329                            },
1330                            Err(_) => match as_datetime::<T>(v) {
1332                                Some(datetime) => {
1333                                    write!(f, "{datetime:?} (Unknown Time Zone '{tz_string}')")
1334                                }
1335                                None => write!(f, "null"),
1336                            },
1337                        }
1338                    }
1339                    None => match as_datetime::<T>(v) {
1341                        Some(datetime) => write!(f, "{datetime:?}"),
1342                        None => write!(f, "null"),
1343                    },
1344                }
1345            }
1346            _ => std::fmt::Debug::fmt(&array.value(index), f),
1347        })?;
1348        write!(f, "]")
1349    }
1350}
1351
1352impl<'a, T: ArrowPrimitiveType> IntoIterator for &'a PrimitiveArray<T> {
1353    type Item = Option<<T as ArrowPrimitiveType>::Native>;
1354    type IntoIter = PrimitiveIter<'a, T>;
1355
1356    fn into_iter(self) -> Self::IntoIter {
1357        PrimitiveIter::<'a, T>::new(self)
1358    }
1359}
1360
1361impl<'a, T: ArrowPrimitiveType> PrimitiveArray<T> {
1362    pub fn iter(&'a self) -> PrimitiveIter<'a, T> {
1364        PrimitiveIter::<'a, T>::new(self)
1365    }
1366}
1367
1368#[derive(Debug)]
1375pub struct NativeAdapter<T: ArrowPrimitiveType> {
1376    pub native: Option<T::Native>,
1378}
1379
1380macro_rules! def_from_for_primitive {
1381    ( $ty:ident, $tt:tt) => {
1382        impl From<$tt> for NativeAdapter<$ty> {
1383            fn from(value: $tt) -> Self {
1384                NativeAdapter {
1385                    native: Some(value),
1386                }
1387            }
1388        }
1389    };
1390}
1391
1392def_from_for_primitive!(Int8Type, i8);
1393def_from_for_primitive!(Int16Type, i16);
1394def_from_for_primitive!(Int32Type, i32);
1395def_from_for_primitive!(Int64Type, i64);
1396def_from_for_primitive!(UInt8Type, u8);
1397def_from_for_primitive!(UInt16Type, u16);
1398def_from_for_primitive!(UInt32Type, u32);
1399def_from_for_primitive!(UInt64Type, u64);
1400def_from_for_primitive!(Float16Type, f16);
1401def_from_for_primitive!(Float32Type, f32);
1402def_from_for_primitive!(Float64Type, f64);
1403def_from_for_primitive!(Decimal32Type, i32);
1404def_from_for_primitive!(Decimal64Type, i64);
1405def_from_for_primitive!(Decimal128Type, i128);
1406def_from_for_primitive!(Decimal256Type, i256);
1407
1408impl<T: ArrowPrimitiveType> From<Option<<T as ArrowPrimitiveType>::Native>> for NativeAdapter<T> {
1409    fn from(value: Option<<T as ArrowPrimitiveType>::Native>) -> Self {
1410        NativeAdapter { native: value }
1411    }
1412}
1413
1414impl<T: ArrowPrimitiveType> From<&Option<<T as ArrowPrimitiveType>::Native>> for NativeAdapter<T> {
1415    fn from(value: &Option<<T as ArrowPrimitiveType>::Native>) -> Self {
1416        NativeAdapter { native: *value }
1417    }
1418}
1419
1420impl<T: ArrowPrimitiveType, Ptr: Into<NativeAdapter<T>>> FromIterator<Ptr> for PrimitiveArray<T> {
1421    fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
1422        let iter = iter.into_iter();
1423        let (lower, _) = iter.size_hint();
1424
1425        let mut null_builder = BooleanBufferBuilder::new(lower);
1426
1427        let buffer: Buffer = iter
1428            .map(|item| {
1429                if let Some(a) = item.into().native {
1430                    null_builder.append(true);
1431                    a
1432                } else {
1433                    null_builder.append(false);
1434                    T::Native::default()
1438                }
1439            })
1440            .collect();
1441
1442        let len = null_builder.len();
1443
1444        let data = unsafe {
1445            ArrayData::new_unchecked(
1446                T::DATA_TYPE,
1447                len,
1448                None,
1449                Some(null_builder.into()),
1450                0,
1451                vec![buffer],
1452                vec![],
1453            )
1454        };
1455        PrimitiveArray::from(data)
1456    }
1457}
1458
1459impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
1460    #[inline]
1465    pub unsafe fn from_trusted_len_iter<I, P>(iter: I) -> Self
1466    where
1467        P: std::borrow::Borrow<Option<<T as ArrowPrimitiveType>::Native>>,
1468        I: IntoIterator<Item = P>,
1469    {
1470        let iterator = iter.into_iter();
1471        let (_, upper) = iterator.size_hint();
1472        let len = upper.expect("trusted_len_unzip requires an upper limit");
1473
1474        let (null, buffer) = unsafe { trusted_len_unzip(iterator) };
1475
1476        let data = unsafe {
1477            ArrayData::new_unchecked(T::DATA_TYPE, len, None, Some(null), 0, vec![buffer], vec![])
1478        };
1479        PrimitiveArray::from(data)
1480    }
1481}
1482
1483macro_rules! def_numeric_from_vec {
1487    ( $ty:ident ) => {
1488        impl From<Vec<<$ty as ArrowPrimitiveType>::Native>> for PrimitiveArray<$ty> {
1489            fn from(data: Vec<<$ty as ArrowPrimitiveType>::Native>) -> Self {
1490                let array_data = ArrayData::builder($ty::DATA_TYPE)
1491                    .len(data.len())
1492                    .add_buffer(Buffer::from_vec(data));
1493                let array_data = unsafe { array_data.build_unchecked() };
1494                PrimitiveArray::from(array_data)
1495            }
1496        }
1497
1498        impl From<Vec<Option<<$ty as ArrowPrimitiveType>::Native>>> for PrimitiveArray<$ty> {
1500            fn from(data: Vec<Option<<$ty as ArrowPrimitiveType>::Native>>) -> Self {
1501                PrimitiveArray::from_iter(data.iter())
1502            }
1503        }
1504    };
1505}
1506
1507def_numeric_from_vec!(Int8Type);
1508def_numeric_from_vec!(Int16Type);
1509def_numeric_from_vec!(Int32Type);
1510def_numeric_from_vec!(Int64Type);
1511def_numeric_from_vec!(UInt8Type);
1512def_numeric_from_vec!(UInt16Type);
1513def_numeric_from_vec!(UInt32Type);
1514def_numeric_from_vec!(UInt64Type);
1515def_numeric_from_vec!(Float16Type);
1516def_numeric_from_vec!(Float32Type);
1517def_numeric_from_vec!(Float64Type);
1518def_numeric_from_vec!(Decimal32Type);
1519def_numeric_from_vec!(Decimal64Type);
1520def_numeric_from_vec!(Decimal128Type);
1521def_numeric_from_vec!(Decimal256Type);
1522
1523def_numeric_from_vec!(Date32Type);
1524def_numeric_from_vec!(Date64Type);
1525def_numeric_from_vec!(Time32SecondType);
1526def_numeric_from_vec!(Time32MillisecondType);
1527def_numeric_from_vec!(Time64MicrosecondType);
1528def_numeric_from_vec!(Time64NanosecondType);
1529def_numeric_from_vec!(IntervalYearMonthType);
1530def_numeric_from_vec!(IntervalDayTimeType);
1531def_numeric_from_vec!(IntervalMonthDayNanoType);
1532def_numeric_from_vec!(DurationSecondType);
1533def_numeric_from_vec!(DurationMillisecondType);
1534def_numeric_from_vec!(DurationMicrosecondType);
1535def_numeric_from_vec!(DurationNanosecondType);
1536def_numeric_from_vec!(TimestampSecondType);
1537def_numeric_from_vec!(TimestampMillisecondType);
1538def_numeric_from_vec!(TimestampMicrosecondType);
1539def_numeric_from_vec!(TimestampNanosecondType);
1540
1541impl<T: ArrowTimestampType> PrimitiveArray<T> {
1542    pub fn timezone(&self) -> Option<&str> {
1544        match self.data_type() {
1545            DataType::Timestamp(_, tz) => tz.as_deref(),
1546            _ => unreachable!(),
1547        }
1548    }
1549
1550    pub fn with_timezone(self, timezone: impl Into<Arc<str>>) -> Self {
1552        self.with_timezone_opt(Some(timezone.into()))
1553    }
1554
1555    pub fn with_timezone_utc(self) -> Self {
1557        self.with_timezone("+00:00")
1558    }
1559
1560    pub fn with_timezone_opt<S: Into<Arc<str>>>(self, timezone: Option<S>) -> Self {
1562        Self {
1563            data_type: DataType::Timestamp(T::UNIT, timezone.map(Into::into)),
1564            ..self
1565        }
1566    }
1567}
1568
1569impl<T: ArrowPrimitiveType> From<ArrayData> for PrimitiveArray<T> {
1571    fn from(data: ArrayData) -> Self {
1572        Self::assert_compatible(data.data_type());
1573        assert_eq!(
1574            data.buffers().len(),
1575            1,
1576            "PrimitiveArray data should contain a single buffer only (values buffer)"
1577        );
1578
1579        let values = ScalarBuffer::new(data.buffers()[0].clone(), data.offset(), data.len());
1580        Self {
1581            data_type: data.data_type().clone(),
1582            values,
1583            nulls: data.nulls().cloned(),
1584        }
1585    }
1586}
1587
1588impl<T: DecimalType + ArrowPrimitiveType> PrimitiveArray<T> {
1589    pub fn with_precision_and_scale(self, precision: u8, scale: i8) -> Result<Self, ArrowError> {
1594        validate_decimal_precision_and_scale::<T>(precision, scale)?;
1595        Ok(Self {
1596            data_type: T::TYPE_CONSTRUCTOR(precision, scale),
1597            ..self
1598        })
1599    }
1600
1601    pub fn validate_decimal_precision(&self, precision: u8) -> Result<(), ArrowError> {
1604        if precision < self.scale() as u8 {
1605            return Err(ArrowError::InvalidArgumentError(format!(
1606                "Decimal precision {precision} is less than scale {}",
1607                self.scale()
1608            )));
1609        }
1610        (0..self.len()).try_for_each(|idx| {
1611            if self.is_valid(idx) {
1612                let decimal = unsafe { self.value_unchecked(idx) };
1613                T::validate_decimal_precision(decimal, precision, self.scale())
1614            } else {
1615                Ok(())
1616            }
1617        })
1618    }
1619
1620    pub fn null_if_overflow_precision(&self, precision: u8) -> Self {
1623        self.unary_opt::<_, T>(|v| T::is_valid_decimal_precision(v, precision).then_some(v))
1624    }
1625
1626    pub fn value_as_string(&self, row: usize) -> String {
1628        T::format_decimal(self.value(row), self.precision(), self.scale())
1629    }
1630
1631    pub fn precision(&self) -> u8 {
1633        match T::BYTE_LENGTH {
1634            4 => {
1635                if let DataType::Decimal32(p, _) = self.data_type() {
1636                    *p
1637                } else {
1638                    unreachable!(
1639                        "Decimal32Array datatype is not DataType::Decimal32 but {}",
1640                        self.data_type()
1641                    )
1642                }
1643            }
1644            8 => {
1645                if let DataType::Decimal64(p, _) = self.data_type() {
1646                    *p
1647                } else {
1648                    unreachable!(
1649                        "Decimal64Array datatype is not DataType::Decimal64 but {}",
1650                        self.data_type()
1651                    )
1652                }
1653            }
1654            16 => {
1655                if let DataType::Decimal128(p, _) = self.data_type() {
1656                    *p
1657                } else {
1658                    unreachable!(
1659                        "Decimal128Array datatype is not DataType::Decimal128 but {}",
1660                        self.data_type()
1661                    )
1662                }
1663            }
1664            32 => {
1665                if let DataType::Decimal256(p, _) = self.data_type() {
1666                    *p
1667                } else {
1668                    unreachable!(
1669                        "Decimal256Array datatype is not DataType::Decimal256 but {}",
1670                        self.data_type()
1671                    )
1672                }
1673            }
1674            other => unreachable!("Unsupported byte length for decimal array {}", other),
1675        }
1676    }
1677
1678    pub fn scale(&self) -> i8 {
1680        match T::BYTE_LENGTH {
1681            4 => {
1682                if let DataType::Decimal32(_, s) = self.data_type() {
1683                    *s
1684                } else {
1685                    unreachable!(
1686                        "Decimal32Array datatype is not DataType::Decimal32 but {}",
1687                        self.data_type()
1688                    )
1689                }
1690            }
1691            8 => {
1692                if let DataType::Decimal64(_, s) = self.data_type() {
1693                    *s
1694                } else {
1695                    unreachable!(
1696                        "Decimal64Array datatype is not DataType::Decimal64 but {}",
1697                        self.data_type()
1698                    )
1699                }
1700            }
1701            16 => {
1702                if let DataType::Decimal128(_, s) = self.data_type() {
1703                    *s
1704                } else {
1705                    unreachable!(
1706                        "Decimal128Array datatype is not DataType::Decimal128 but {}",
1707                        self.data_type()
1708                    )
1709                }
1710            }
1711            32 => {
1712                if let DataType::Decimal256(_, s) = self.data_type() {
1713                    *s
1714                } else {
1715                    unreachable!(
1716                        "Decimal256Array datatype is not DataType::Decimal256 but {}",
1717                        self.data_type()
1718                    )
1719                }
1720            }
1721            other => unreachable!("Unsupported byte length for decimal array {}", other),
1722        }
1723    }
1724}
1725
1726#[cfg(test)]
1727mod tests {
1728    use super::*;
1729    use crate::BooleanArray;
1730    use crate::builder::{
1731        Decimal32Builder, Decimal64Builder, Decimal128Builder, Decimal256Builder,
1732    };
1733    use crate::cast::downcast_array;
1734    use arrow_buffer::{IntervalDayTime, IntervalMonthDayNano};
1735    use arrow_schema::TimeUnit;
1736
1737    #[test]
1738    fn test_primitive_array_from_vec() {
1739        let buf = Buffer::from_slice_ref([0, 1, 2, 3, 4]);
1740        let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
1741        assert_eq!(&buf, arr.values.inner());
1742        assert_eq!(5, arr.len());
1743        assert_eq!(0, arr.offset());
1744        assert_eq!(0, arr.null_count());
1745        for i in 0..5 {
1746            assert!(!arr.is_null(i));
1747            assert!(arr.is_valid(i));
1748            assert_eq!(i as i32, arr.value(i));
1749        }
1750    }
1751
1752    #[test]
1753    fn test_primitive_array_from_vec_option() {
1754        let arr = Int32Array::from(vec![Some(0), None, Some(2), None, Some(4)]);
1756        assert_eq!(5, arr.len());
1757        assert_eq!(0, arr.offset());
1758        assert_eq!(2, arr.null_count());
1759        for i in 0..5 {
1760            if i % 2 == 0 {
1761                assert!(!arr.is_null(i));
1762                assert!(arr.is_valid(i));
1763                assert_eq!(i as i32, arr.value(i));
1764            } else {
1765                assert!(arr.is_null(i));
1766                assert!(!arr.is_valid(i));
1767            }
1768        }
1769    }
1770
1771    #[test]
1772    fn test_date64_array_from_vec_option() {
1773        let arr: PrimitiveArray<Date64Type> =
1777            vec![Some(1550902545147), None, Some(1550902545147)].into();
1778        assert_eq!(3, arr.len());
1779        assert_eq!(0, arr.offset());
1780        assert_eq!(1, arr.null_count());
1781        for i in 0..3 {
1782            if i % 2 == 0 {
1783                assert!(!arr.is_null(i));
1784                assert!(arr.is_valid(i));
1785                assert_eq!(1550902545147, arr.value(i));
1786                assert_eq!(
1788                    1550902545147,
1789                    arr.value_as_datetime(i)
1790                        .unwrap()
1791                        .and_utc()
1792                        .timestamp_millis()
1793                );
1794            } else {
1795                assert!(arr.is_null(i));
1796                assert!(!arr.is_valid(i));
1797            }
1798        }
1799    }
1800
1801    #[test]
1802    fn test_time32_millisecond_array_from_vec() {
1803        let arr: PrimitiveArray<Time32MillisecondType> = vec![1, 37_800_005, 86_399_210].into();
1807        assert_eq!(3, arr.len());
1808        assert_eq!(0, arr.offset());
1809        assert_eq!(0, arr.null_count());
1810        let formatted = ["00:00:00.001", "10:30:00.005", "23:59:59.210"];
1811        for (i, formatted) in formatted.iter().enumerate().take(3) {
1812            assert_eq!(None, arr.value_as_datetime(i));
1814            assert_eq!(None, arr.value_as_date(i));
1815            let time = arr.value_as_time(i).unwrap();
1816            assert_eq!(*formatted, time.format("%H:%M:%S%.3f").to_string());
1817        }
1818    }
1819
1820    #[test]
1821    fn test_time64_nanosecond_array_from_vec() {
1822        let arr: PrimitiveArray<Time64NanosecondType> =
1830            vec![1_000_000, 37_800_005_000_000, 86_399_210_000_000].into();
1831        assert_eq!(3, arr.len());
1832        assert_eq!(0, arr.offset());
1833        assert_eq!(0, arr.null_count());
1834        let formatted = ["00:00:00.001", "10:30:00.005", "23:59:59.210"];
1835        for (i, item) in formatted.iter().enumerate().take(3) {
1836            assert_eq!(None, arr.value_as_datetime(i));
1838            assert_eq!(None, arr.value_as_date(i));
1839            let time = arr.value_as_time(i).unwrap();
1840            assert_eq!(*item, time.format("%H:%M:%S%.3f").to_string());
1841        }
1842    }
1843
1844    #[test]
1845    fn test_interval_array_from_vec() {
1846        let arr = IntervalYearMonthArray::from(vec![Some(1), None, Some(-5)]);
1848        assert_eq!(3, arr.len());
1849        assert_eq!(0, arr.offset());
1850        assert_eq!(1, arr.null_count());
1851        assert_eq!(1, arr.value(0));
1852        assert_eq!(1, arr.values()[0]);
1853        assert!(arr.is_null(1));
1854        assert_eq!(-5, arr.value(2));
1855        assert_eq!(-5, arr.values()[2]);
1856
1857        let v0 = IntervalDayTime {
1858            days: 34,
1859            milliseconds: 1,
1860        };
1861        let v2 = IntervalDayTime {
1862            days: -2,
1863            milliseconds: -5,
1864        };
1865
1866        let arr = IntervalDayTimeArray::from(vec![Some(v0), None, Some(v2)]);
1867
1868        assert_eq!(3, arr.len());
1869        assert_eq!(0, arr.offset());
1870        assert_eq!(1, arr.null_count());
1871        assert_eq!(v0, arr.value(0));
1872        assert_eq!(v0, arr.values()[0]);
1873        assert!(arr.is_null(1));
1874        assert_eq!(v2, arr.value(2));
1875        assert_eq!(v2, arr.values()[2]);
1876
1877        let v0 = IntervalMonthDayNano {
1878            months: 2,
1879            days: 34,
1880            nanoseconds: -1,
1881        };
1882        let v2 = IntervalMonthDayNano {
1883            months: -3,
1884            days: -2,
1885            nanoseconds: 4,
1886        };
1887
1888        let arr = IntervalMonthDayNanoArray::from(vec![Some(v0), None, Some(v2)]);
1889        assert_eq!(3, arr.len());
1890        assert_eq!(0, arr.offset());
1891        assert_eq!(1, arr.null_count());
1892        assert_eq!(v0, arr.value(0));
1893        assert_eq!(v0, arr.values()[0]);
1894        assert!(arr.is_null(1));
1895        assert_eq!(v2, arr.value(2));
1896        assert_eq!(v2, arr.values()[2]);
1897    }
1898
1899    #[test]
1900    fn test_duration_array_from_vec() {
1901        let arr = DurationSecondArray::from(vec![Some(1), None, Some(-5)]);
1902        assert_eq!(3, arr.len());
1903        assert_eq!(0, arr.offset());
1904        assert_eq!(1, arr.null_count());
1905        assert_eq!(1, arr.value(0));
1906        assert_eq!(1, arr.values()[0]);
1907        assert!(arr.is_null(1));
1908        assert_eq!(-5, arr.value(2));
1909        assert_eq!(-5, arr.values()[2]);
1910
1911        let arr = DurationMillisecondArray::from(vec![Some(1), None, Some(-5)]);
1912        assert_eq!(3, arr.len());
1913        assert_eq!(0, arr.offset());
1914        assert_eq!(1, arr.null_count());
1915        assert_eq!(1, arr.value(0));
1916        assert_eq!(1, arr.values()[0]);
1917        assert!(arr.is_null(1));
1918        assert_eq!(-5, arr.value(2));
1919        assert_eq!(-5, arr.values()[2]);
1920
1921        let arr = DurationMicrosecondArray::from(vec![Some(1), None, Some(-5)]);
1922        assert_eq!(3, arr.len());
1923        assert_eq!(0, arr.offset());
1924        assert_eq!(1, arr.null_count());
1925        assert_eq!(1, arr.value(0));
1926        assert_eq!(1, arr.values()[0]);
1927        assert!(arr.is_null(1));
1928        assert_eq!(-5, arr.value(2));
1929        assert_eq!(-5, arr.values()[2]);
1930
1931        let arr = DurationNanosecondArray::from(vec![Some(1), None, Some(-5)]);
1932        assert_eq!(3, arr.len());
1933        assert_eq!(0, arr.offset());
1934        assert_eq!(1, arr.null_count());
1935        assert_eq!(1, arr.value(0));
1936        assert_eq!(1, arr.values()[0]);
1937        assert!(arr.is_null(1));
1938        assert_eq!(-5, arr.value(2));
1939        assert_eq!(-5, arr.values()[2]);
1940    }
1941
1942    #[test]
1943    fn test_timestamp_array_from_vec() {
1944        let arr = TimestampSecondArray::from(vec![1, -5]);
1945        assert_eq!(2, arr.len());
1946        assert_eq!(0, arr.offset());
1947        assert_eq!(0, arr.null_count());
1948        assert_eq!(1, arr.value(0));
1949        assert_eq!(-5, arr.value(1));
1950        assert_eq!(&[1, -5], arr.values());
1951
1952        let arr = TimestampMillisecondArray::from(vec![1, -5]);
1953        assert_eq!(2, arr.len());
1954        assert_eq!(0, arr.offset());
1955        assert_eq!(0, arr.null_count());
1956        assert_eq!(1, arr.value(0));
1957        assert_eq!(-5, arr.value(1));
1958        assert_eq!(&[1, -5], arr.values());
1959
1960        let arr = TimestampMicrosecondArray::from(vec![1, -5]);
1961        assert_eq!(2, arr.len());
1962        assert_eq!(0, arr.offset());
1963        assert_eq!(0, arr.null_count());
1964        assert_eq!(1, arr.value(0));
1965        assert_eq!(-5, arr.value(1));
1966        assert_eq!(&[1, -5], arr.values());
1967
1968        let arr = TimestampNanosecondArray::from(vec![1, -5]);
1969        assert_eq!(2, arr.len());
1970        assert_eq!(0, arr.offset());
1971        assert_eq!(0, arr.null_count());
1972        assert_eq!(1, arr.value(0));
1973        assert_eq!(-5, arr.value(1));
1974        assert_eq!(&[1, -5], arr.values());
1975    }
1976
1977    #[test]
1978    fn test_primitive_array_slice() {
1979        let arr = Int32Array::from(vec![
1980            Some(0),
1981            None,
1982            Some(2),
1983            None,
1984            Some(4),
1985            Some(5),
1986            Some(6),
1987            None,
1988            None,
1989        ]);
1990        assert_eq!(9, arr.len());
1991        assert_eq!(0, arr.offset());
1992        assert_eq!(4, arr.null_count());
1993
1994        let arr2 = arr.slice(2, 5);
1995        assert_eq!(5, arr2.len());
1996        assert_eq!(1, arr2.null_count());
1997
1998        for i in 0..arr2.len() {
1999            assert_eq!(i == 1, arr2.is_null(i));
2000            assert_eq!(i != 1, arr2.is_valid(i));
2001        }
2002        let int_arr2 = arr2.as_any().downcast_ref::<Int32Array>().unwrap();
2003        assert_eq!(2, int_arr2.values()[0]);
2004        assert_eq!(&[4, 5, 6], &int_arr2.values()[2..5]);
2005
2006        let arr3 = arr2.slice(2, 3);
2007        assert_eq!(3, arr3.len());
2008        assert_eq!(0, arr3.null_count());
2009
2010        let int_arr3 = arr3.as_any().downcast_ref::<Int32Array>().unwrap();
2011        assert_eq!(&[4, 5, 6], int_arr3.values());
2012        assert_eq!(4, int_arr3.value(0));
2013        assert_eq!(5, int_arr3.value(1));
2014        assert_eq!(6, int_arr3.value(2));
2015    }
2016
2017    #[test]
2018    fn test_boolean_array_slice() {
2019        let arr = BooleanArray::from(vec![
2020            Some(true),
2021            None,
2022            Some(false),
2023            None,
2024            Some(true),
2025            Some(false),
2026            Some(true),
2027            Some(false),
2028            None,
2029            Some(true),
2030        ]);
2031
2032        assert_eq!(10, arr.len());
2033        assert_eq!(0, arr.offset());
2034        assert_eq!(3, arr.null_count());
2035
2036        let arr2 = arr.slice(3, 5);
2037        assert_eq!(5, arr2.len());
2038        assert_eq!(3, arr2.offset());
2039        assert_eq!(1, arr2.null_count());
2040
2041        let bool_arr = arr2.as_any().downcast_ref::<BooleanArray>().unwrap();
2042
2043        assert!(!bool_arr.is_valid(0));
2044
2045        assert!(bool_arr.is_valid(1));
2046        assert!(bool_arr.value(1));
2047
2048        assert!(bool_arr.is_valid(2));
2049        assert!(!bool_arr.value(2));
2050
2051        assert!(bool_arr.is_valid(3));
2052        assert!(bool_arr.value(3));
2053
2054        assert!(bool_arr.is_valid(4));
2055        assert!(!bool_arr.value(4));
2056    }
2057
2058    #[test]
2059    fn test_int32_fmt_debug() {
2060        let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
2061        assert_eq!(
2062            "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  2,\n  3,\n  4,\n]",
2063            format!("{arr:?}")
2064        );
2065    }
2066
2067    #[test]
2068    fn test_fmt_debug_up_to_20_elements() {
2069        (1..=20).for_each(|i| {
2070            let values = (0..i).collect::<Vec<i16>>();
2071            let array_expected = format!(
2072                "PrimitiveArray<Int16>\n[\n{}\n]",
2073                values
2074                    .iter()
2075                    .map(|v| { format!("  {v},") })
2076                    .collect::<Vec<String>>()
2077                    .join("\n")
2078            );
2079            let array = Int16Array::from(values);
2080
2081            assert_eq!(array_expected, format!("{array:?}"));
2082        })
2083    }
2084
2085    #[test]
2086    fn test_int32_with_null_fmt_debug() {
2087        let mut builder = Int32Array::builder(3);
2088        builder.append_slice(&[0, 1]);
2089        builder.append_null();
2090        builder.append_slice(&[3, 4]);
2091        let arr = builder.finish();
2092        assert_eq!(
2093            "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  null,\n  3,\n  4,\n]",
2094            format!("{arr:?}")
2095        );
2096    }
2097
2098    #[test]
2099    fn test_timestamp_fmt_debug() {
2100        let arr: PrimitiveArray<TimestampMillisecondType> =
2101            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000]);
2102        assert_eq!(
2103            "PrimitiveArray<Timestamp(ms)>\n[\n  2018-12-31T00:00:00,\n  2018-12-31T00:00:00,\n  1921-01-02T00:00:00,\n]",
2104            format!("{arr:?}")
2105        );
2106    }
2107
2108    #[test]
2109    fn test_timestamp_utc_fmt_debug() {
2110        let arr: PrimitiveArray<TimestampMillisecondType> =
2111            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
2112                .with_timezone_utc();
2113        assert_eq!(
2114            "PrimitiveArray<Timestamp(ms, \"+00:00\")>\n[\n  2018-12-31T00:00:00+00:00,\n  2018-12-31T00:00:00+00:00,\n  1921-01-02T00:00:00+00:00,\n]",
2115            format!("{arr:?}")
2116        );
2117    }
2118
2119    #[test]
2120    #[cfg(feature = "chrono-tz")]
2121    fn test_timestamp_with_named_tz_fmt_debug() {
2122        let arr: PrimitiveArray<TimestampMillisecondType> =
2123            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
2124                .with_timezone("Asia/Taipei".to_string());
2125        assert_eq!(
2126            "PrimitiveArray<Timestamp(ms, \"Asia/Taipei\")>\n[\n  2018-12-31T08:00:00+08:00,\n  2018-12-31T08:00:00+08:00,\n  1921-01-02T08:00:00+08:00,\n]",
2127            format!("{arr:?}")
2128        );
2129    }
2130
2131    #[test]
2132    #[cfg(not(feature = "chrono-tz"))]
2133    fn test_timestamp_with_named_tz_fmt_debug() {
2134        let arr: PrimitiveArray<TimestampMillisecondType> =
2135            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
2136                .with_timezone("Asia/Taipei".to_string());
2137
2138        println!("{arr:?}");
2139
2140        assert_eq!(
2141            "PrimitiveArray<Timestamp(ms, \"Asia/Taipei\")>\n[\n  2018-12-31T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n  2018-12-31T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n  1921-01-02T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n]",
2142            format!("{arr:?}")
2143        );
2144    }
2145
2146    #[test]
2147    fn test_timestamp_with_fixed_offset_tz_fmt_debug() {
2148        let arr: PrimitiveArray<TimestampMillisecondType> =
2149            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
2150                .with_timezone("+08:00".to_string());
2151        assert_eq!(
2152            "PrimitiveArray<Timestamp(ms, \"+08:00\")>\n[\n  2018-12-31T08:00:00+08:00,\n  2018-12-31T08:00:00+08:00,\n  1921-01-02T08:00:00+08:00,\n]",
2153            format!("{arr:?}")
2154        );
2155    }
2156
2157    #[test]
2158    fn test_timestamp_with_incorrect_tz_fmt_debug() {
2159        let arr: PrimitiveArray<TimestampMillisecondType> =
2160            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
2161                .with_timezone("xxx".to_string());
2162        assert_eq!(
2163            "PrimitiveArray<Timestamp(ms, \"xxx\")>\n[\n  2018-12-31T00:00:00 (Unknown Time Zone 'xxx'),\n  2018-12-31T00:00:00 (Unknown Time Zone 'xxx'),\n  1921-01-02T00:00:00 (Unknown Time Zone 'xxx'),\n]",
2164            format!("{arr:?}")
2165        );
2166    }
2167
2168    #[test]
2169    #[cfg(feature = "chrono-tz")]
2170    fn test_timestamp_with_tz_with_daylight_saving_fmt_debug() {
2171        let arr: PrimitiveArray<TimestampMillisecondType> = TimestampMillisecondArray::from(vec![
2172            1647161999000,
2173            1647162000000,
2174            1667717999000,
2175            1667718000000,
2176        ])
2177        .with_timezone("America/Denver".to_string());
2178        assert_eq!(
2179            "PrimitiveArray<Timestamp(ms, \"America/Denver\")>\n[\n  2022-03-13T01:59:59-07:00,\n  2022-03-13T03:00:00-06:00,\n  2022-11-06T00:59:59-06:00,\n  2022-11-06T01:00:00-06:00,\n]",
2180            format!("{arr:?}")
2181        );
2182    }
2183
2184    #[test]
2185    fn test_date32_fmt_debug() {
2186        let arr: PrimitiveArray<Date32Type> = vec![12356, 13548, -365].into();
2187        assert_eq!(
2188            "PrimitiveArray<Date32>\n[\n  2003-10-31,\n  2007-02-04,\n  1969-01-01,\n]",
2189            format!("{arr:?}")
2190        );
2191    }
2192
2193    #[test]
2194    fn test_time32second_fmt_debug() {
2195        let arr: PrimitiveArray<Time32SecondType> = vec![7201, 60054].into();
2196        assert_eq!(
2197            "PrimitiveArray<Time32(s)>\n[\n  02:00:01,\n  16:40:54,\n]",
2198            format!("{arr:?}")
2199        );
2200    }
2201
2202    #[test]
2203    fn test_time32second_invalid_neg() {
2204        let arr: PrimitiveArray<Time32SecondType> = vec![-7201, -60054].into();
2206        assert_eq!(
2207            "PrimitiveArray<Time32(s)>\n[\n  Cast error: Failed to convert -7201 to temporal for Time32(s),\n  Cast error: Failed to convert -60054 to temporal for Time32(s),\n]",
2208            format!("{arr:?}")
2210        )
2211    }
2212
2213    #[test]
2214    fn test_timestamp_micros_out_of_range() {
2215        let arr: PrimitiveArray<TimestampMicrosecondType> = vec![9065525203050843594].into();
2217        assert_eq!(
2218            "PrimitiveArray<Timestamp(µs)>\n[\n  null,\n]",
2219            format!("{arr:?}")
2220        )
2221    }
2222
2223    #[test]
2224    fn test_primitive_array_builder() {
2225        let buf = Buffer::from_slice_ref([0i32, 1, 2, 3, 4, 5, 6]);
2227        let buf2 = buf.slice_with_length(8, 20);
2228        let data = ArrayData::builder(DataType::Int32)
2229            .len(5)
2230            .offset(2)
2231            .add_buffer(buf)
2232            .build()
2233            .unwrap();
2234        let arr = Int32Array::from(data);
2235        assert_eq!(&buf2, arr.values.inner());
2236        assert_eq!(5, arr.len());
2237        assert_eq!(0, arr.null_count());
2238        for i in 0..3 {
2239            assert_eq!((i + 2) as i32, arr.value(i));
2240        }
2241    }
2242
2243    #[test]
2244    fn test_primitive_from_iter_values() {
2245        let arr: PrimitiveArray<Int32Type> = PrimitiveArray::from_iter_values(0..10);
2247        assert_eq!(10, arr.len());
2248        assert_eq!(0, arr.null_count());
2249        for i in 0..10i32 {
2250            assert_eq!(i, arr.value(i as usize));
2251        }
2252    }
2253
2254    #[test]
2255    fn test_primitive_array_from_unbound_iter() {
2256        let value_iter = (0..)
2258            .scan(0usize, |pos, i| {
2259                if *pos < 10 {
2260                    *pos += 1;
2261                    Some(Some(i))
2262                } else {
2263                    None
2265                }
2266            })
2267            .take(100);
2269
2270        let (_, upper_size_bound) = value_iter.size_hint();
2271        assert_eq!(upper_size_bound, Some(100));
2273        let primitive_array: PrimitiveArray<Int32Type> = value_iter.collect();
2274        assert_eq!(primitive_array.len(), 10);
2276    }
2277
2278    #[test]
2279    fn test_primitive_array_from_non_null_iter() {
2280        let iter = (0..10_i32).map(Some);
2281        let primitive_array = PrimitiveArray::<Int32Type>::from_iter(iter);
2282        assert_eq!(primitive_array.len(), 10);
2283        assert_eq!(primitive_array.null_count(), 0);
2284        assert!(primitive_array.nulls().is_none());
2285        assert_eq!(primitive_array.values(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
2286    }
2287
2288    #[test]
2289    #[should_panic(expected = "PrimitiveArray data should contain a single buffer only \
2290                               (values buffer)")]
2291    #[cfg(not(feature = "force_validate"))]
2294    fn test_primitive_array_invalid_buffer_len() {
2295        let buffer = Buffer::from_slice_ref([0i32, 1, 2, 3, 4]);
2296        let data = unsafe {
2297            ArrayData::builder(DataType::Int32)
2298                .add_buffer(buffer.clone())
2299                .add_buffer(buffer)
2300                .len(5)
2301                .build_unchecked()
2302        };
2303
2304        drop(Int32Array::from(data));
2305    }
2306
2307    #[test]
2308    fn test_access_array_concurrently() {
2309        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
2310        let ret = std::thread::spawn(move || a.value(3)).join();
2311
2312        assert!(ret.is_ok());
2313        assert_eq!(8, ret.ok().unwrap());
2314    }
2315
2316    #[test]
2317    fn test_primitive_array_creation() {
2318        let array1: Int8Array = [10_i8, 11, 12, 13, 14].into_iter().collect();
2319        let array2: Int8Array = [10_i8, 11, 12, 13, 14].into_iter().map(Some).collect();
2320
2321        assert_eq!(array1, array2);
2322    }
2323
2324    #[test]
2325    #[should_panic(
2326        expected = "Trying to access an element at index 4 from a PrimitiveArray of length 3"
2327    )]
2328    fn test_string_array_get_value_index_out_of_bound() {
2329        let array: Int8Array = [10_i8, 11, 12].into_iter().collect();
2330
2331        array.value(4);
2332    }
2333
2334    #[test]
2335    #[should_panic(expected = "PrimitiveArray expected data type Int64 got Int32")]
2336    fn test_from_array_data_validation() {
2337        let foo = PrimitiveArray::<Int32Type>::from_iter([1, 2, 3]);
2338        let _ = PrimitiveArray::<Int64Type>::from(foo.into_data());
2339    }
2340
2341    #[test]
2342    fn test_decimal32() {
2343        let values: Vec<_> = vec![0, 1, -1, i32::MIN, i32::MAX];
2344        let array: PrimitiveArray<Decimal32Type> =
2345            PrimitiveArray::from_iter(values.iter().copied());
2346        assert_eq!(array.values(), &values);
2347
2348        let array: PrimitiveArray<Decimal32Type> =
2349            PrimitiveArray::from_iter_values(values.iter().copied());
2350        assert_eq!(array.values(), &values);
2351
2352        let array = PrimitiveArray::<Decimal32Type>::from(values.clone());
2353        assert_eq!(array.values(), &values);
2354
2355        let array = PrimitiveArray::<Decimal32Type>::from(array.to_data());
2356        assert_eq!(array.values(), &values);
2357    }
2358
2359    #[test]
2360    fn test_decimal64() {
2361        let values: Vec<_> = vec![0, 1, -1, i64::MIN, i64::MAX];
2362        let array: PrimitiveArray<Decimal64Type> =
2363            PrimitiveArray::from_iter(values.iter().copied());
2364        assert_eq!(array.values(), &values);
2365
2366        let array: PrimitiveArray<Decimal64Type> =
2367            PrimitiveArray::from_iter_values(values.iter().copied());
2368        assert_eq!(array.values(), &values);
2369
2370        let array = PrimitiveArray::<Decimal64Type>::from(values.clone());
2371        assert_eq!(array.values(), &values);
2372
2373        let array = PrimitiveArray::<Decimal64Type>::from(array.to_data());
2374        assert_eq!(array.values(), &values);
2375    }
2376
2377    #[test]
2378    fn test_decimal128() {
2379        let values: Vec<_> = vec![0, 1, -1, i128::MIN, i128::MAX];
2380        let array: PrimitiveArray<Decimal128Type> =
2381            PrimitiveArray::from_iter(values.iter().copied());
2382        assert_eq!(array.values(), &values);
2383
2384        let array: PrimitiveArray<Decimal128Type> =
2385            PrimitiveArray::from_iter_values(values.iter().copied());
2386        assert_eq!(array.values(), &values);
2387
2388        let array = PrimitiveArray::<Decimal128Type>::from(values.clone());
2389        assert_eq!(array.values(), &values);
2390
2391        let array = PrimitiveArray::<Decimal128Type>::from(array.to_data());
2392        assert_eq!(array.values(), &values);
2393    }
2394
2395    #[test]
2396    fn test_decimal256() {
2397        let values: Vec<_> = vec![i256::ZERO, i256::ONE, i256::MINUS_ONE, i256::MIN, i256::MAX];
2398
2399        let array: PrimitiveArray<Decimal256Type> =
2400            PrimitiveArray::from_iter(values.iter().copied());
2401        assert_eq!(array.values(), &values);
2402
2403        let array: PrimitiveArray<Decimal256Type> =
2404            PrimitiveArray::from_iter_values(values.iter().copied());
2405        assert_eq!(array.values(), &values);
2406
2407        let array = PrimitiveArray::<Decimal256Type>::from(values.clone());
2408        assert_eq!(array.values(), &values);
2409
2410        let array = PrimitiveArray::<Decimal256Type>::from(array.to_data());
2411        assert_eq!(array.values(), &values);
2412    }
2413
2414    #[test]
2415    fn test_decimal_array() {
2416        let values: [u8; 32] = [
2419            192, 219, 180, 17, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 36, 75, 238, 253, 255, 255,
2420            255, 255, 255, 255, 255, 255, 255, 255, 255,
2421        ];
2422        let array_data = ArrayData::builder(DataType::Decimal128(38, 6))
2423            .len(2)
2424            .add_buffer(Buffer::from(&values))
2425            .build()
2426            .unwrap();
2427        let decimal_array = Decimal128Array::from(array_data);
2428        assert_eq!(8_887_000_000_i128, decimal_array.value(0));
2429        assert_eq!(-8_887_000_000_i128, decimal_array.value(1));
2430    }
2431
2432    #[test]
2433    fn test_decimal_append_error_value() {
2434        let mut decimal_builder = Decimal128Builder::with_capacity(10);
2435        decimal_builder.append_value(123456);
2436        decimal_builder.append_value(12345);
2437        let result = decimal_builder.finish().with_precision_and_scale(5, 3);
2438        assert!(result.is_ok());
2439        let arr = result.unwrap();
2440        assert_eq!("12.345", arr.value_as_string(1));
2441
2442        let result = arr.validate_decimal_precision(5);
2444        let error = result.unwrap_err();
2445        assert_eq!(
2446            "Invalid argument error: 123.456 is too large to store in a Decimal128 of precision 5. Max is 99.999",
2447            error.to_string()
2448        );
2449
2450        decimal_builder = Decimal128Builder::new();
2451        decimal_builder.append_value(100);
2452        decimal_builder.append_value(99);
2453        decimal_builder.append_value(-100);
2454        decimal_builder.append_value(-99);
2455        let result = decimal_builder.finish().with_precision_and_scale(2, 1);
2456        assert!(result.is_ok());
2457        let arr = result.unwrap();
2458        assert_eq!("9.9", arr.value_as_string(1));
2459        assert_eq!("-9.9", arr.value_as_string(3));
2460
2461        let result = arr.validate_decimal_precision(2);
2463        let error = result.unwrap_err();
2464        assert_eq!(
2465            "Invalid argument error: 10.0 is too large to store in a Decimal128 of precision 2. Max is 9.9",
2466            error.to_string()
2467        );
2468    }
2469
2470    #[test]
2471    fn test_decimal_from_iter_values() {
2472        let array = Decimal128Array::from_iter_values(vec![-100, 0, 101]);
2473        assert_eq!(array.len(), 3);
2474        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
2475        assert_eq!(-100_i128, array.value(0));
2476        assert!(!array.is_null(0));
2477        assert_eq!(0_i128, array.value(1));
2478        assert!(!array.is_null(1));
2479        assert_eq!(101_i128, array.value(2));
2480        assert!(!array.is_null(2));
2481    }
2482
2483    #[test]
2484    fn test_decimal_from_iter() {
2485        let array: Decimal128Array = vec![Some(-100), None, Some(101)].into_iter().collect();
2486        assert_eq!(array.len(), 3);
2487        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
2488        assert_eq!(-100_i128, array.value(0));
2489        assert!(!array.is_null(0));
2490        assert!(array.is_null(1));
2491        assert_eq!(101_i128, array.value(2));
2492        assert!(!array.is_null(2));
2493    }
2494
2495    #[test]
2496    fn test_decimal_iter_sized() {
2497        let data = vec![Some(-100), None, Some(101)];
2498        let array: Decimal128Array = data.into_iter().collect();
2499        let mut iter = array.into_iter();
2500
2501        assert_eq!(array.len(), 3);
2503
2504        assert_eq!(iter.size_hint(), (3, Some(3)));
2506        iter.next().unwrap();
2507        assert_eq!(iter.size_hint(), (2, Some(2)));
2508        iter.next().unwrap();
2509        iter.next().unwrap();
2510        assert_eq!(iter.size_hint(), (0, Some(0)));
2511        assert!(iter.next().is_none());
2512        assert_eq!(iter.size_hint(), (0, Some(0)));
2513    }
2514
2515    #[test]
2516    fn test_decimal_array_value_as_string() {
2517        let arr = [123450, -123450, 100, -100, 10, -10, 0]
2518            .into_iter()
2519            .map(Some)
2520            .collect::<Decimal128Array>()
2521            .with_precision_and_scale(6, 3)
2522            .unwrap();
2523
2524        assert_eq!("123.450", arr.value_as_string(0));
2525        assert_eq!("-123.450", arr.value_as_string(1));
2526        assert_eq!("0.100", arr.value_as_string(2));
2527        assert_eq!("-0.100", arr.value_as_string(3));
2528        assert_eq!("0.010", arr.value_as_string(4));
2529        assert_eq!("-0.010", arr.value_as_string(5));
2530        assert_eq!("0.000", arr.value_as_string(6));
2531    }
2532
2533    #[test]
2534    fn test_decimal_array_with_precision_and_scale() {
2535        let arr = Decimal128Array::from_iter_values([12345, 456, 7890, -123223423432432])
2536            .with_precision_and_scale(20, 2)
2537            .unwrap();
2538
2539        assert_eq!(arr.data_type(), &DataType::Decimal128(20, 2));
2540        assert_eq!(arr.precision(), 20);
2541        assert_eq!(arr.scale(), 2);
2542
2543        let actual: Vec<_> = (0..arr.len()).map(|i| arr.value_as_string(i)).collect();
2544        let expected = vec!["123.45", "4.56", "78.90", "-1232234234324.32"];
2545
2546        assert_eq!(actual, expected);
2547    }
2548
2549    #[test]
2550    #[should_panic(
2551        expected = "-1232234234324.32 is too small to store in a Decimal128 of precision 5. Min is -999.99"
2552    )]
2553    fn test_decimal_array_with_precision_and_scale_out_of_range() {
2554        let arr = Decimal128Array::from_iter_values([12345, 456, 7890, -123223423432432])
2555            .with_precision_and_scale(5, 2)
2557            .unwrap();
2558        arr.validate_decimal_precision(5).unwrap();
2559    }
2560
2561    #[test]
2562    #[should_panic(expected = "precision cannot be 0, has to be between [1, 38]")]
2563    fn test_decimal_array_with_precision_zero() {
2564        Decimal128Array::from_iter_values([12345, 456])
2565            .with_precision_and_scale(0, 2)
2566            .unwrap();
2567    }
2568
2569    #[test]
2570    #[should_panic(expected = "precision 40 is greater than max 38")]
2571    fn test_decimal_array_with_precision_and_scale_invalid_precision() {
2572        Decimal128Array::from_iter_values([12345, 456])
2573            .with_precision_and_scale(40, 2)
2574            .unwrap();
2575    }
2576
2577    #[test]
2578    #[should_panic(expected = "scale 40 is greater than max 38")]
2579    fn test_decimal_array_with_precision_and_scale_invalid_scale() {
2580        Decimal128Array::from_iter_values([12345, 456])
2581            .with_precision_and_scale(20, 40)
2582            .unwrap();
2583    }
2584
2585    #[test]
2586    #[should_panic(expected = "scale 10 is greater than precision 4")]
2587    fn test_decimal_array_with_precision_and_scale_invalid_precision_and_scale() {
2588        Decimal128Array::from_iter_values([12345, 456])
2589            .with_precision_and_scale(4, 10)
2590            .unwrap();
2591    }
2592
2593    #[test]
2594    fn test_decimal_array_set_null_if_overflow_with_precision() {
2595        let array = Decimal128Array::from(vec![Some(123456), Some(123), None, Some(123456)]);
2596        let result = array.null_if_overflow_precision(5);
2597        let expected = Decimal128Array::from(vec![None, Some(123), None, None]);
2598        assert_eq!(result, expected);
2599    }
2600
2601    #[test]
2602    fn test_decimal256_iter() {
2603        let mut builder = Decimal256Builder::with_capacity(30);
2604        let decimal1 = i256::from_i128(12345);
2605        builder.append_value(decimal1);
2606
2607        builder.append_null();
2608
2609        let decimal2 = i256::from_i128(56789);
2610        builder.append_value(decimal2);
2611
2612        let array: Decimal256Array = builder.finish().with_precision_and_scale(76, 6).unwrap();
2613
2614        let collected: Vec<_> = array.iter().collect();
2615        assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
2616    }
2617
2618    #[test]
2619    fn test_from_iter_decimal256array() {
2620        let value1 = i256::from_i128(12345);
2621        let value2 = i256::from_i128(56789);
2622
2623        let mut array: Decimal256Array =
2624            vec![Some(value1), None, Some(value2)].into_iter().collect();
2625        array = array.with_precision_and_scale(76, 10).unwrap();
2626        assert_eq!(array.len(), 3);
2627        assert_eq!(array.data_type(), &DataType::Decimal256(76, 10));
2628        assert_eq!(value1, array.value(0));
2629        assert!(!array.is_null(0));
2630        assert!(array.is_null(1));
2631        assert_eq!(value2, array.value(2));
2632        assert!(!array.is_null(2));
2633    }
2634
2635    #[test]
2636    fn test_from_iter_decimal128array() {
2637        let mut array: Decimal128Array = vec![Some(-100), None, Some(101)].into_iter().collect();
2638        array = array.with_precision_and_scale(38, 10).unwrap();
2639        assert_eq!(array.len(), 3);
2640        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
2641        assert_eq!(-100_i128, array.value(0));
2642        assert!(!array.is_null(0));
2643        assert!(array.is_null(1));
2644        assert_eq!(101_i128, array.value(2));
2645        assert!(!array.is_null(2));
2646    }
2647
2648    #[test]
2649    fn test_decimal64_iter() {
2650        let mut builder = Decimal64Builder::with_capacity(30);
2651        let decimal1 = 12345;
2652        builder.append_value(decimal1);
2653
2654        builder.append_null();
2655
2656        let decimal2 = 56789;
2657        builder.append_value(decimal2);
2658
2659        let array: Decimal64Array = builder.finish().with_precision_and_scale(18, 4).unwrap();
2660
2661        let collected: Vec<_> = array.iter().collect();
2662        assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
2663    }
2664
2665    #[test]
2666    fn test_from_iter_decimal64array() {
2667        let value1 = 12345;
2668        let value2 = 56789;
2669
2670        let mut array: Decimal64Array =
2671            vec![Some(value1), None, Some(value2)].into_iter().collect();
2672        array = array.with_precision_and_scale(18, 4).unwrap();
2673        assert_eq!(array.len(), 3);
2674        assert_eq!(array.data_type(), &DataType::Decimal64(18, 4));
2675        assert_eq!(value1, array.value(0));
2676        assert!(!array.is_null(0));
2677        assert!(array.is_null(1));
2678        assert_eq!(value2, array.value(2));
2679        assert!(!array.is_null(2));
2680    }
2681
2682    #[test]
2683    fn test_decimal32_iter() {
2684        let mut builder = Decimal32Builder::with_capacity(30);
2685        let decimal1 = 12345;
2686        builder.append_value(decimal1);
2687
2688        builder.append_null();
2689
2690        let decimal2 = 56789;
2691        builder.append_value(decimal2);
2692
2693        let array: Decimal32Array = builder.finish().with_precision_and_scale(9, 2).unwrap();
2694
2695        let collected: Vec<_> = array.iter().collect();
2696        assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
2697    }
2698
2699    #[test]
2700    fn test_from_iter_decimal32array() {
2701        let value1 = 12345;
2702        let value2 = 56789;
2703
2704        let mut array: Decimal32Array =
2705            vec![Some(value1), None, Some(value2)].into_iter().collect();
2706        array = array.with_precision_and_scale(9, 2).unwrap();
2707        assert_eq!(array.len(), 3);
2708        assert_eq!(array.data_type(), &DataType::Decimal32(9, 2));
2709        assert_eq!(value1, array.value(0));
2710        assert!(!array.is_null(0));
2711        assert!(array.is_null(1));
2712        assert_eq!(value2, array.value(2));
2713        assert!(!array.is_null(2));
2714    }
2715
2716    #[test]
2717    fn test_unary_opt() {
2718        let array = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7]);
2719        let r = array.unary_opt::<_, Int32Type>(|x| (x % 2 != 0).then_some(x));
2720
2721        let expected = Int32Array::from(vec![Some(1), None, Some(3), None, Some(5), None, Some(7)]);
2722        assert_eq!(r, expected);
2723
2724        let r = expected.unary_opt::<_, Int32Type>(|x| (x % 3 != 0).then_some(x));
2725        let expected = Int32Array::from(vec![Some(1), None, None, None, Some(5), None, Some(7)]);
2726        assert_eq!(r, expected);
2727    }
2728
2729    #[test]
2730    #[should_panic(
2731        expected = "Trying to access an element at index 4 from a PrimitiveArray of length 3"
2732    )]
2733    fn test_fixed_size_binary_array_get_value_index_out_of_bound() {
2734        let array = Decimal128Array::from(vec![-100, 0, 101]);
2735        array.value(4);
2736    }
2737
2738    #[test]
2739    fn test_into_builder() {
2740        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
2741
2742        let boxed: ArrayRef = Arc::new(array);
2743        let col: Int32Array = downcast_array(&boxed);
2744        drop(boxed);
2745
2746        let mut builder = col.into_builder().unwrap();
2747
2748        let slice = builder.values_slice_mut();
2749        assert_eq!(slice, &[1, 2, 3]);
2750
2751        slice[0] = 4;
2752        slice[1] = 2;
2753        slice[2] = 1;
2754
2755        let expected: Int32Array = vec![Some(4), Some(2), Some(1)].into_iter().collect();
2756
2757        let new_array = builder.finish();
2758        assert_eq!(expected, new_array);
2759    }
2760
2761    #[test]
2762    fn test_into_builder_cloned_array() {
2763        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
2764
2765        let boxed: ArrayRef = Arc::new(array);
2766
2767        let col: Int32Array = PrimitiveArray::<Int32Type>::from(boxed.to_data());
2768        let err = col.into_builder();
2769
2770        match err {
2771            Ok(_) => panic!("Should not get builder from cloned array"),
2772            Err(returned) => {
2773                let expected: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
2774                assert_eq!(expected, returned)
2775            }
2776        }
2777    }
2778
2779    #[test]
2780    fn test_into_builder_on_sliced_array() {
2781        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
2782        let slice = array.slice(1, 2);
2783        let col: Int32Array = downcast_array(&slice);
2784
2785        drop(slice);
2786
2787        col.into_builder()
2788            .expect_err("Should not build builder from sliced array");
2789    }
2790
2791    #[test]
2792    fn test_unary_mut() {
2793        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
2794
2795        let c = array.unary_mut(|x| x * 2 + 1).unwrap();
2796        let expected: Int32Array = vec![3, 5, 7].into_iter().map(Some).collect();
2797
2798        assert_eq!(expected, c);
2799
2800        let array: Int32Array = Int32Array::from(vec![Some(5), Some(7), None]);
2801        let c = array.unary_mut(|x| x * 2 + 1).unwrap();
2802        assert_eq!(c, Int32Array::from(vec![Some(11), Some(15), None]));
2803    }
2804
2805    #[test]
2806    #[should_panic(
2807        expected = "PrimitiveArray expected data type Interval(MonthDayNano) got Interval(DayTime)"
2808    )]
2809    fn test_invalid_interval_type() {
2810        let array = IntervalDayTimeArray::from(vec![IntervalDayTime::ZERO]);
2811        let _ = IntervalMonthDayNanoArray::from(array.into_data());
2812    }
2813
2814    #[test]
2815    fn test_timezone() {
2816        let array = TimestampNanosecondArray::from_iter_values([1, 2]);
2817        assert_eq!(array.timezone(), None);
2818
2819        let array = array.with_timezone("+02:00");
2820        assert_eq!(array.timezone(), Some("+02:00"));
2821    }
2822
2823    #[test]
2824    fn test_try_new() {
2825        Int32Array::new(vec![1, 2, 3, 4].into(), None);
2826        Int32Array::new(vec![1, 2, 3, 4].into(), Some(NullBuffer::new_null(4)));
2827
2828        let err = Int32Array::try_new(vec![1, 2, 3, 4].into(), Some(NullBuffer::new_null(3)))
2829            .unwrap_err();
2830
2831        assert_eq!(
2832            err.to_string(),
2833            "Invalid argument error: Incorrect length of null buffer for PrimitiveArray, expected 4 got 3"
2834        );
2835
2836        TimestampNanosecondArray::new(vec![1, 2, 3, 4].into(), None).with_data_type(
2837            DataType::Timestamp(TimeUnit::Nanosecond, Some("03:00".into())),
2838        );
2839    }
2840
2841    #[test]
2842    #[should_panic(expected = "PrimitiveArray expected data type Int32 got Date32")]
2843    fn test_with_data_type() {
2844        Int32Array::new(vec![1, 2, 3, 4].into(), None).with_data_type(DataType::Date32);
2845    }
2846
2847    #[test]
2848    fn test_time_32second_output() {
2849        let array: Time32SecondArray = vec![
2850            Some(-1),
2851            Some(0),
2852            Some(86_399),
2853            Some(86_400),
2854            Some(86_401),
2855            None,
2856        ]
2857        .into();
2858        let debug_str = format!("{array:?}");
2859        assert_eq!(
2860            "PrimitiveArray<Time32(s)>\n[\n  Cast error: Failed to convert -1 to temporal for Time32(s),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400 to temporal for Time32(s),\n  Cast error: Failed to convert 86401 to temporal for Time32(s),\n  null,\n]",
2861            debug_str
2862        );
2863    }
2864
2865    #[test]
2866    fn test_time_32millisecond_debug_output() {
2867        let array: Time32MillisecondArray = vec![
2868            Some(-1),
2869            Some(0),
2870            Some(86_399_000),
2871            Some(86_400_000),
2872            Some(86_401_000),
2873            None,
2874        ]
2875        .into();
2876        let debug_str = format!("{array:?}");
2877        assert_eq!(
2878            "PrimitiveArray<Time32(ms)>\n[\n  Cast error: Failed to convert -1 to temporal for Time32(ms),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400000 to temporal for Time32(ms),\n  Cast error: Failed to convert 86401000 to temporal for Time32(ms),\n  null,\n]",
2879            debug_str
2880        );
2881    }
2882
2883    #[test]
2884    fn test_time_64nanosecond_debug_output() {
2885        let array: Time64NanosecondArray = vec![
2886            Some(-1),
2887            Some(0),
2888            Some(86_399 * 1_000_000_000),
2889            Some(86_400 * 1_000_000_000),
2890            Some(86_401 * 1_000_000_000),
2891            None,
2892        ]
2893        .into();
2894        let debug_str = format!("{array:?}");
2895        assert_eq!(
2896            "PrimitiveArray<Time64(ns)>\n[\n  Cast error: Failed to convert -1 to temporal for Time64(ns),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400000000000 to temporal for Time64(ns),\n  Cast error: Failed to convert 86401000000000 to temporal for Time64(ns),\n  null,\n]",
2897            debug_str
2898        );
2899    }
2900
2901    #[test]
2902    fn test_time_64microsecond_debug_output() {
2903        let array: Time64MicrosecondArray = vec![
2904            Some(-1),
2905            Some(0),
2906            Some(86_399 * 1_000_000),
2907            Some(86_400 * 1_000_000),
2908            Some(86_401 * 1_000_000),
2909            None,
2910        ]
2911        .into();
2912        let debug_str = format!("{array:?}");
2913        assert_eq!(
2914            "PrimitiveArray<Time64(µs)>\n[\n  Cast error: Failed to convert -1 to temporal for Time64(µs),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400000000 to temporal for Time64(µs),\n  Cast error: Failed to convert 86401000000 to temporal for Time64(µs),\n  null,\n]",
2915            debug_str
2916        );
2917    }
2918
2919    #[test]
2920    fn test_primitive_with_nulls_into_builder() {
2921        let array: Int32Array = vec![
2922            Some(1),
2923            None,
2924            Some(3),
2925            Some(4),
2926            None,
2927            Some(7),
2928            None,
2929            Some(8),
2930        ]
2931        .into_iter()
2932        .collect();
2933        let _ = array.into_builder();
2934    }
2935}