datatypes/vectors/
primitive.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::any::Any;
16use std::fmt;
17use std::sync::Arc;
18
19use arrow::array::{Array, ArrayBuilder, ArrayIter, ArrayRef, PrimitiveArray, PrimitiveBuilder};
20use serde_json::Value as JsonValue;
21use snafu::OptionExt;
22
23use crate::data_type::ConcreteDataType;
24use crate::error::{self, Result};
25use crate::scalars::{Scalar, ScalarRef, ScalarVector, ScalarVectorBuilder};
26use crate::serialize::Serializable;
27use crate::types::{
28    Float32Type, Float64Type, Int8Type, Int16Type, Int32Type, Int64Type, LogicalPrimitiveType,
29    UInt8Type, UInt16Type, UInt32Type, UInt64Type, WrapperType,
30};
31use crate::value::{Value, ValueRef};
32use crate::vectors::{self, MutableVector, Validity, Vector, VectorRef};
33
34pub type UInt8Vector = PrimitiveVector<UInt8Type>;
35pub type UInt16Vector = PrimitiveVector<UInt16Type>;
36pub type UInt32Vector = PrimitiveVector<UInt32Type>;
37pub type UInt64Vector = PrimitiveVector<UInt64Type>;
38
39pub type Int8Vector = PrimitiveVector<Int8Type>;
40pub type Int16Vector = PrimitiveVector<Int16Type>;
41pub type Int32Vector = PrimitiveVector<Int32Type>;
42pub type Int64Vector = PrimitiveVector<Int64Type>;
43
44pub type Float32Vector = PrimitiveVector<Float32Type>;
45pub type Float64Vector = PrimitiveVector<Float64Type>;
46
47/// Vector for primitive data types.
48pub struct PrimitiveVector<T: LogicalPrimitiveType> {
49    array: PrimitiveArray<T::ArrowPrimitive>,
50}
51
52impl<T: LogicalPrimitiveType> PrimitiveVector<T> {
53    pub fn new(array: PrimitiveArray<T::ArrowPrimitive>) -> Self {
54        Self { array }
55    }
56
57    pub fn try_from_arrow_array(array: impl AsRef<dyn Array>) -> Result<Self> {
58        let arrow_array = array
59            .as_ref()
60            .as_any()
61            .downcast_ref::<PrimitiveArray<T::ArrowPrimitive>>()
62            .with_context(|| error::ConversionSnafu {
63                from: format!("{:?}", array.as_ref().data_type()),
64            })?;
65
66        Ok(Self::new(arrow_array.clone()))
67    }
68
69    pub fn from_slice<P: AsRef<[T::Native]>>(slice: P) -> Self {
70        let iter = slice.as_ref().iter().copied();
71        Self {
72            array: PrimitiveArray::from_iter_values(iter),
73        }
74    }
75
76    pub fn from_wrapper_slice<P: AsRef<[T::Wrapper]>>(slice: P) -> Self {
77        let iter = slice.as_ref().iter().copied().map(WrapperType::into_native);
78        Self {
79            array: PrimitiveArray::from_iter_values(iter),
80        }
81    }
82
83    pub fn from_vec(vector: Vec<T::Native>) -> Self {
84        let mutable_buffer = arrow::buffer::MutableBuffer::from(vector);
85        let mut primitive_builder =
86            PrimitiveBuilder::<T::ArrowPrimitive>::new_from_buffer(mutable_buffer, None);
87        let array = primitive_builder.finish();
88        Self { array }
89    }
90
91    pub fn from_iter_values<I: IntoIterator<Item = T::Native>>(iter: I) -> Self {
92        Self {
93            array: PrimitiveArray::from_iter_values(iter),
94        }
95    }
96
97    pub fn from_values<I: IntoIterator<Item = T::Native>>(iter: I) -> Self {
98        Self {
99            array: PrimitiveArray::from_iter_values(iter),
100        }
101    }
102
103    /// Get the inner arrow array.
104    pub fn as_arrow(&self) -> &PrimitiveArray<T::ArrowPrimitive> {
105        &self.array
106    }
107
108    // To distinguish with `Vector::slice()`.
109    /// Slice the vector, returning a new vector.
110    ///
111    /// # Panics
112    /// This function panics if `offset + length > self.len()`.
113    pub fn get_slice(&self, offset: usize, length: usize) -> Self {
114        Self {
115            array: self.array.slice(offset, length),
116        }
117    }
118}
119
120impl<T: LogicalPrimitiveType> Vector for PrimitiveVector<T> {
121    fn data_type(&self) -> ConcreteDataType {
122        T::build_data_type()
123    }
124
125    fn vector_type_name(&self) -> String {
126        format!("{}Vector", T::type_name())
127    }
128
129    fn as_any(&self) -> &dyn Any {
130        self
131    }
132
133    fn len(&self) -> usize {
134        self.array.len()
135    }
136
137    fn to_arrow_array(&self) -> ArrayRef {
138        Arc::new(self.array.clone())
139    }
140
141    fn to_boxed_arrow_array(&self) -> Box<dyn Array> {
142        Box::new(self.array.clone())
143    }
144
145    fn validity(&self) -> Validity {
146        vectors::impl_validity_for_vector!(self.array)
147    }
148
149    fn memory_size(&self) -> usize {
150        self.array.get_buffer_memory_size()
151    }
152
153    fn null_count(&self) -> usize {
154        self.array.null_count()
155    }
156
157    fn is_null(&self, row: usize) -> bool {
158        self.array.is_null(row)
159    }
160
161    fn slice(&self, offset: usize, length: usize) -> VectorRef {
162        Arc::new(self.get_slice(offset, length))
163    }
164
165    fn get(&self, index: usize) -> Value {
166        if self.array.is_valid(index) {
167            // Safety: The index have been checked by `is_valid()`.
168            let wrapper = unsafe { T::Wrapper::from_native(self.array.value_unchecked(index)) };
169            wrapper.into()
170        } else {
171            Value::Null
172        }
173    }
174
175    fn get_ref(&self, index: usize) -> ValueRef<'_> {
176        if self.array.is_valid(index) {
177            // Safety: The index have been checked by `is_valid()`.
178            let wrapper = unsafe { T::Wrapper::from_native(self.array.value_unchecked(index)) };
179            wrapper.into()
180        } else {
181            ValueRef::Null
182        }
183    }
184}
185
186impl<T: LogicalPrimitiveType> fmt::Debug for PrimitiveVector<T> {
187    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
188        f.debug_struct("PrimitiveVector")
189            .field("array", &self.array)
190            .finish()
191    }
192}
193
194impl<T: LogicalPrimitiveType> From<PrimitiveArray<T::ArrowPrimitive>> for PrimitiveVector<T> {
195    fn from(array: PrimitiveArray<T::ArrowPrimitive>) -> Self {
196        Self { array }
197    }
198}
199
200impl<T: LogicalPrimitiveType> From<Vec<Option<T::Native>>> for PrimitiveVector<T> {
201    fn from(v: Vec<Option<T::Native>>) -> Self {
202        Self {
203            array: PrimitiveArray::from_iter(v),
204        }
205    }
206}
207
208pub struct PrimitiveIter<'a, T: LogicalPrimitiveType> {
209    iter: ArrayIter<&'a PrimitiveArray<T::ArrowPrimitive>>,
210}
211
212impl<T: LogicalPrimitiveType> Iterator for PrimitiveIter<'_, T> {
213    type Item = Option<T::Wrapper>;
214
215    fn next(&mut self) -> Option<Option<T::Wrapper>> {
216        self.iter
217            .next()
218            .map(|item| item.map(T::Wrapper::from_native))
219    }
220
221    fn size_hint(&self) -> (usize, Option<usize>) {
222        self.iter.size_hint()
223    }
224}
225
226impl<T: LogicalPrimitiveType> ScalarVector for PrimitiveVector<T> {
227    type OwnedItem = T::Wrapper;
228    type RefItem<'a> = T::Wrapper;
229    type Iter<'a> = PrimitiveIter<'a, T>;
230    type Builder = PrimitiveVectorBuilder<T>;
231
232    fn get_data(&self, idx: usize) -> Option<Self::RefItem<'_>> {
233        if self.array.is_valid(idx) {
234            Some(T::Wrapper::from_native(self.array.value(idx)))
235        } else {
236            None
237        }
238    }
239
240    fn iter_data(&self) -> Self::Iter<'_> {
241        PrimitiveIter {
242            iter: self.array.iter(),
243        }
244    }
245}
246
247impl<T: LogicalPrimitiveType> Serializable for PrimitiveVector<T> {
248    fn serialize_to_json(&self) -> Result<Vec<JsonValue>> {
249        let res = self
250            .iter_data()
251            .map(|v| match v {
252                None => serde_json::Value::Null,
253                // use WrapperType's Into<serde_json::Value> bound instead of
254                // serde_json::to_value to facilitate customized serialization
255                // for WrapperType
256                Some(v) => v.into(),
257            })
258            .collect::<Vec<_>>();
259        Ok(res)
260    }
261}
262
263impl<T: LogicalPrimitiveType> PartialEq for PrimitiveVector<T> {
264    fn eq(&self, other: &PrimitiveVector<T>) -> bool {
265        self.array == other.array
266    }
267}
268
269pub type UInt8VectorBuilder = PrimitiveVectorBuilder<UInt8Type>;
270pub type UInt16VectorBuilder = PrimitiveVectorBuilder<UInt16Type>;
271pub type UInt32VectorBuilder = PrimitiveVectorBuilder<UInt32Type>;
272pub type UInt64VectorBuilder = PrimitiveVectorBuilder<UInt64Type>;
273
274pub type Int8VectorBuilder = PrimitiveVectorBuilder<Int8Type>;
275pub type Int16VectorBuilder = PrimitiveVectorBuilder<Int16Type>;
276pub type Int32VectorBuilder = PrimitiveVectorBuilder<Int32Type>;
277pub type Int64VectorBuilder = PrimitiveVectorBuilder<Int64Type>;
278
279pub type Float32VectorBuilder = PrimitiveVectorBuilder<Float32Type>;
280pub type Float64VectorBuilder = PrimitiveVectorBuilder<Float64Type>;
281
282/// Builder to build a primitive vector.
283pub struct PrimitiveVectorBuilder<T: LogicalPrimitiveType> {
284    mutable_array: PrimitiveBuilder<T::ArrowPrimitive>,
285}
286
287impl<T: LogicalPrimitiveType> MutableVector for PrimitiveVectorBuilder<T> {
288    fn data_type(&self) -> ConcreteDataType {
289        T::build_data_type()
290    }
291
292    fn len(&self) -> usize {
293        self.mutable_array.len()
294    }
295
296    fn as_any(&self) -> &dyn Any {
297        self
298    }
299
300    fn as_mut_any(&mut self) -> &mut dyn Any {
301        self
302    }
303
304    fn to_vector(&mut self) -> VectorRef {
305        Arc::new(self.finish())
306    }
307
308    fn to_vector_cloned(&self) -> VectorRef {
309        Arc::new(self.finish_cloned())
310    }
311
312    fn try_push_value_ref(&mut self, value: &ValueRef) -> Result<()> {
313        let primitive = T::cast_value_ref(value)?;
314        match primitive {
315            Some(v) => self.mutable_array.append_value(v.into_native()),
316            None => self.mutable_array.append_null(),
317        }
318        Ok(())
319    }
320
321    fn extend_slice_of(&mut self, vector: &dyn Vector, offset: usize, length: usize) -> Result<()> {
322        let primitive = T::cast_vector(vector)?;
323        // Slice the underlying array to avoid creating a new Arc.
324        let slice = primitive.get_slice(offset, length);
325        for v in slice.iter_data() {
326            self.push(v);
327        }
328        Ok(())
329    }
330
331    fn push_null(&mut self) {
332        self.mutable_array.append_null()
333    }
334}
335
336impl<T> ScalarVectorBuilder for PrimitiveVectorBuilder<T>
337where
338    T: LogicalPrimitiveType,
339    T::Wrapper: Scalar<VectorType = PrimitiveVector<T>>,
340    for<'a> T::Wrapper: ScalarRef<'a, ScalarType = T::Wrapper>,
341    for<'a> T::Wrapper: Scalar<RefType<'a> = T::Wrapper>,
342{
343    type VectorType = PrimitiveVector<T>;
344
345    fn with_capacity(capacity: usize) -> Self {
346        Self {
347            mutable_array: PrimitiveBuilder::with_capacity(capacity),
348        }
349    }
350
351    fn push(&mut self, value: Option<<Self::VectorType as ScalarVector>::RefItem<'_>>) {
352        self.mutable_array
353            .append_option(value.map(|v| v.into_native()));
354    }
355
356    fn finish(&mut self) -> Self::VectorType {
357        PrimitiveVector {
358            array: self.mutable_array.finish(),
359        }
360    }
361
362    fn finish_cloned(&self) -> Self::VectorType {
363        PrimitiveVector {
364            array: self.mutable_array.finish_cloned(),
365        }
366    }
367}
368
369#[cfg(test)]
370mod tests {
371    use std::vec;
372
373    use arrow::array::{
374        Int32Array, Time32MillisecondArray, Time32SecondArray, Time64MicrosecondArray,
375        Time64NanosecondArray,
376    };
377    use arrow::datatypes::{DataType as ArrowDataType, IntervalDayTime};
378    use arrow_array::{
379        DurationMicrosecondArray, DurationMillisecondArray, DurationNanosecondArray,
380        DurationSecondArray, IntervalDayTimeArray, IntervalYearMonthArray,
381        TimestampMicrosecondArray, TimestampMillisecondArray, TimestampNanosecondArray,
382        TimestampSecondArray,
383    };
384    use serde_json;
385
386    use super::*;
387    use crate::data_type::DataType;
388    use crate::serialize::Serializable;
389    use crate::timestamp::TimestampMillisecond;
390    use crate::types::Int64Type;
391    use crate::vectors::{
392        DurationMicrosecondVector, DurationMillisecondVector, DurationNanosecondVector,
393        DurationSecondVector, IntervalDayTimeVector, IntervalYearMonthVector,
394        TimeMicrosecondVector, TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector,
395        TimestampMicrosecondVector, TimestampMillisecondVector, TimestampMillisecondVectorBuilder,
396        TimestampNanosecondVector, TimestampSecondVector,
397    };
398
399    fn check_vec(v: Int32Vector) {
400        assert_eq!(4, v.len());
401        assert_eq!("Int32Vector", v.vector_type_name());
402        assert!(v.validity().is_all_valid());
403        assert!(!v.only_null());
404
405        for i in 0..4 {
406            assert!(!v.is_null(i));
407            assert_eq!(Value::Int32(i as i32 + 1), v.get(i));
408            assert_eq!(ValueRef::Int32(i as i32 + 1), v.get_ref(i));
409        }
410
411        let json_value = v.serialize_to_json().unwrap();
412        assert_eq!("[1,2,3,4]", serde_json::to_string(&json_value).unwrap(),);
413
414        let arrow_arr = v.to_arrow_array();
415        assert_eq!(4, arrow_arr.len());
416        assert_eq!(&ArrowDataType::Int32, arrow_arr.data_type());
417    }
418
419    #[test]
420    fn test_from_values() {
421        let v = Int32Vector::from_values(vec![1, 2, 3, 4]);
422        check_vec(v);
423    }
424
425    #[test]
426    fn test_from_vec() {
427        let v = Int32Vector::from_vec(vec![1, 2, 3, 4]);
428        check_vec(v);
429    }
430
431    #[test]
432    fn test_from_slice() {
433        let v = Int32Vector::from_slice(vec![1, 2, 3, 4]);
434        check_vec(v);
435    }
436
437    #[test]
438    fn test_serialize_primitive_vector_with_null_to_json() {
439        let input = [Some(1i32), Some(2i32), None, Some(4i32), None];
440        let mut builder = Int32VectorBuilder::with_capacity(input.len());
441        for v in input {
442            builder.push(v);
443        }
444        let vector = builder.finish();
445
446        let json_value = vector.serialize_to_json().unwrap();
447        assert_eq!(
448            "[1,2,null,4,null]",
449            serde_json::to_string(&json_value).unwrap(),
450        );
451    }
452
453    #[test]
454    fn test_from_arrow_array() {
455        let arrow_array = Int32Array::from(vec![1, 2, 3, 4]);
456        let v = Int32Vector::from(arrow_array);
457        check_vec(v);
458    }
459
460    #[test]
461    fn test_primitive_vector_build_get() {
462        let input = [Some(1i32), Some(2i32), None, Some(4i32), None];
463        let mut builder = Int32VectorBuilder::with_capacity(input.len());
464        for v in input {
465            builder.push(v);
466        }
467        let vector = builder.finish();
468        assert_eq!(input.len(), vector.len());
469
470        for (i, v) in input.into_iter().enumerate() {
471            assert_eq!(v, vector.get_data(i));
472            assert_eq!(Value::from(v), vector.get(i));
473        }
474
475        let res: Vec<_> = vector.iter_data().collect();
476        assert_eq!(input, &res[..]);
477    }
478
479    #[test]
480    fn test_primitive_vector_validity() {
481        let input = [Some(1i32), Some(2i32), None, None];
482        let mut builder = Int32VectorBuilder::with_capacity(input.len());
483        for v in input {
484            builder.push(v);
485        }
486        let vector = builder.finish();
487        assert_eq!(2, vector.null_count());
488        let validity = vector.validity();
489        assert_eq!(2, validity.null_count());
490        assert!(!validity.is_set(2));
491        assert!(!validity.is_set(3));
492
493        let vector = Int32Vector::from_slice(vec![1, 2, 3, 4]);
494        assert_eq!(0, vector.null_count());
495        assert!(vector.validity().is_all_valid());
496    }
497
498    #[test]
499    fn test_memory_size() {
500        let v = Int32Vector::from_slice((0..5).collect::<Vec<i32>>());
501        assert_eq!(20, v.memory_size());
502        let v = Int64Vector::from(vec![Some(0i64), Some(1i64), Some(2i64), None, None]);
503        assert_eq!(144, v.memory_size());
504    }
505
506    #[test]
507    fn test_get_slice() {
508        let v = Int32Vector::from_slice(vec![1, 2, 3, 4, 5]);
509        let slice = v.get_slice(1, 3);
510        assert_eq!(v, Int32Vector::from_slice(vec![1, 2, 3, 4, 5]));
511        assert_eq!(slice, Int32Vector::from_slice(vec![2, 3, 4]));
512    }
513
514    #[test]
515    fn test_primitive_vector_builder() {
516        let mut builder = Int64Type::default().create_mutable_vector(3);
517        builder.push_value_ref(&ValueRef::Int64(123));
518        assert!(builder.try_push_value_ref(&ValueRef::Int32(123)).is_err());
519
520        let input = Int64Vector::from_slice([7, 8, 9]);
521        builder.extend_slice_of(&input, 1, 2).unwrap();
522        assert!(
523            builder
524                .extend_slice_of(&Int32Vector::from_slice([13]), 0, 1)
525                .is_err()
526        );
527        let vector = builder.to_vector();
528
529        let expect: VectorRef = Arc::new(Int64Vector::from_slice([123, 8, 9]));
530        assert_eq!(expect, vector);
531    }
532
533    #[test]
534    fn test_from_wrapper_slice() {
535        macro_rules! test_from_wrapper_slice {
536            ($vec: ident, $ty: ident) => {
537                let from_wrapper_slice = $vec::from_wrapper_slice(&[
538                    $ty::from_native($ty::MAX),
539                    $ty::from_native($ty::MIN),
540                ]);
541                let from_slice = $vec::from_slice([$ty::MAX, $ty::MIN]);
542                assert_eq!(from_wrapper_slice, from_slice);
543            };
544        }
545
546        test_from_wrapper_slice!(UInt8Vector, u8);
547        test_from_wrapper_slice!(Int8Vector, i8);
548        test_from_wrapper_slice!(UInt16Vector, u16);
549        test_from_wrapper_slice!(Int16Vector, i16);
550        test_from_wrapper_slice!(UInt32Vector, u32);
551        test_from_wrapper_slice!(Int32Vector, i32);
552        test_from_wrapper_slice!(UInt64Vector, u64);
553        test_from_wrapper_slice!(Int64Vector, i64);
554        test_from_wrapper_slice!(Float32Vector, f32);
555        test_from_wrapper_slice!(Float64Vector, f64);
556    }
557
558    #[test]
559    fn test_try_from_arrow_time_array() {
560        let array: ArrayRef = Arc::new(Time32SecondArray::from(vec![1i32, 2, 3]));
561        let vector = TimeSecondVector::try_from_arrow_array(array).unwrap();
562        assert_eq!(TimeSecondVector::from_values(vec![1, 2, 3]), vector);
563
564        let array: ArrayRef = Arc::new(Time32MillisecondArray::from(vec![1i32, 2, 3]));
565        let vector = TimeMillisecondVector::try_from_arrow_array(array).unwrap();
566        assert_eq!(TimeMillisecondVector::from_values(vec![1, 2, 3]), vector);
567
568        let array: ArrayRef = Arc::new(Time64MicrosecondArray::from(vec![1i64, 2, 3]));
569        let vector = TimeMicrosecondVector::try_from_arrow_array(array).unwrap();
570        assert_eq!(TimeMicrosecondVector::from_values(vec![1, 2, 3]), vector);
571
572        let array: ArrayRef = Arc::new(Time64NanosecondArray::from(vec![1i64, 2, 3]));
573        let vector = TimeNanosecondVector::try_from_arrow_array(array).unwrap();
574        assert_eq!(TimeNanosecondVector::from_values(vec![1, 2, 3]), vector);
575
576        // Test convert error
577        let array: ArrayRef = Arc::new(Int32Array::from(vec![1i32, 2, 3]));
578        assert!(TimeSecondVector::try_from_arrow_array(array).is_err());
579    }
580
581    #[test]
582    fn test_try_from_arrow_timestamp_array() {
583        let array: ArrayRef = Arc::new(TimestampSecondArray::from(vec![1i64, 2, 3]));
584        let vector = TimestampSecondVector::try_from_arrow_array(array).unwrap();
585        assert_eq!(TimestampSecondVector::from_values(vec![1, 2, 3]), vector);
586
587        let array: ArrayRef = Arc::new(TimestampMillisecondArray::from(vec![1i64, 2, 3]));
588        let vector = TimestampMillisecondVector::try_from_arrow_array(array).unwrap();
589        assert_eq!(
590            TimestampMillisecondVector::from_values(vec![1, 2, 3]),
591            vector
592        );
593
594        let array: ArrayRef = Arc::new(TimestampMicrosecondArray::from(vec![1i64, 2, 3]));
595        let vector = TimestampMicrosecondVector::try_from_arrow_array(array).unwrap();
596        assert_eq!(
597            TimestampMicrosecondVector::from_values(vec![1, 2, 3]),
598            vector
599        );
600
601        let array: ArrayRef = Arc::new(TimestampNanosecondArray::from(vec![1i64, 2, 3]));
602        let vector = TimestampNanosecondVector::try_from_arrow_array(array).unwrap();
603        assert_eq!(
604            TimestampNanosecondVector::from_values(vec![1, 2, 3]),
605            vector
606        );
607
608        // Test convert error
609        let array: ArrayRef = Arc::new(Int32Array::from(vec![1i32, 2, 3]));
610        assert!(TimestampSecondVector::try_from_arrow_array(array).is_err());
611    }
612
613    #[test]
614    fn test_try_from_arrow_interval_array() {
615        let array: ArrayRef = Arc::new(IntervalYearMonthArray::from(vec![1000, 2000, 3000]));
616        let vector = IntervalYearMonthVector::try_from_arrow_array(array).unwrap();
617        assert_eq!(
618            IntervalYearMonthVector::from_values(vec![1000, 2000, 3000]),
619            vector
620        );
621
622        let array: ArrayRef = Arc::new(IntervalDayTimeArray::from(vec![
623            IntervalDayTime::new(1, 1000),
624            IntervalDayTime::new(1, 2000),
625            IntervalDayTime::new(1, 3000),
626        ]));
627        let vector = IntervalDayTimeVector::try_from_arrow_array(array).unwrap();
628        assert_eq!(
629            IntervalDayTimeVector::from_values(vec![
630                IntervalDayTime::new(1, 1000),
631                IntervalDayTime::new(1, 2000),
632                IntervalDayTime::new(1, 3000),
633            ]),
634            vector
635        );
636
637        let array: ArrayRef = Arc::new(IntervalYearMonthArray::from(vec![1000, 2000, 3000]));
638        let vector = IntervalYearMonthVector::try_from_arrow_array(array).unwrap();
639        assert_eq!(
640            IntervalYearMonthVector::from_values(vec![1000, 2000, 3000]),
641            vector
642        );
643    }
644
645    #[test]
646    fn test_try_from_arrow_duration_array() {
647        let array: ArrayRef = Arc::new(DurationSecondArray::from(vec![1000, 2000, 3000]));
648        let vector = DurationSecondVector::try_from_arrow_array(array).unwrap();
649        assert_eq!(
650            DurationSecondVector::from_values(vec![1000, 2000, 3000]),
651            vector
652        );
653
654        let array: ArrayRef = Arc::new(DurationMillisecondArray::from(vec![1000, 2000, 3000]));
655        let vector = DurationMillisecondVector::try_from_arrow_array(array).unwrap();
656        assert_eq!(
657            DurationMillisecondVector::from_values(vec![1000, 2000, 3000]),
658            vector
659        );
660
661        let array: ArrayRef = Arc::new(DurationMicrosecondArray::from(vec![1000, 2000, 3000]));
662        let vector = DurationMicrosecondVector::try_from_arrow_array(array).unwrap();
663        assert_eq!(
664            DurationMicrosecondVector::from_values(vec![1000, 2000, 3000]),
665            vector
666        );
667
668        let array: ArrayRef = Arc::new(DurationNanosecondArray::from(vec![1000, 2000, 3000]));
669        let vector = DurationNanosecondVector::try_from_arrow_array(array).unwrap();
670        assert_eq!(
671            DurationNanosecondVector::from_values(vec![1000, 2000, 3000]),
672            vector
673        );
674    }
675
676    #[test]
677    fn test_primitive_vector_builder_finish_cloned() {
678        let mut builder = Int64Type::default().create_mutable_vector(3);
679        builder.push_value_ref(&ValueRef::Int64(123));
680        builder.push_value_ref(&ValueRef::Int64(456));
681        let vector = builder.to_vector_cloned();
682        assert_eq!(vector.len(), 2);
683        assert_eq!(vector.null_count(), 0);
684        assert_eq!(builder.len(), 2);
685
686        let mut builder = TimestampMillisecondVectorBuilder::with_capacity(1024);
687        builder.push(Some(TimestampMillisecond::new(1)));
688        builder.push(Some(TimestampMillisecond::new(2)));
689        builder.push(Some(TimestampMillisecond::new(3)));
690        let vector = builder.finish_cloned();
691        assert_eq!(vector.len(), 3);
692        assert_eq!(builder.len(), 3);
693    }
694}
datatypes/vectors/primitive.rs

datatypes/vectors/
primitive.rs
