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, Int16Type, Int32Type, Int64Type, Int8Type, LogicalPrimitiveType,
29    UInt16Type, UInt32Type, UInt64Type, UInt8Type, 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
369pub(crate) fn replicate_primitive<T: LogicalPrimitiveType>(
370    vector: &PrimitiveVector<T>,
371    offsets: &[usize],
372) -> PrimitiveVector<T> {
373    assert_eq!(offsets.len(), vector.len());
374
375    if offsets.is_empty() {
376        return vector.get_slice(0, 0);
377    }
378
379    let mut builder = PrimitiveVectorBuilder::<T>::with_capacity(*offsets.last().unwrap());
380
381    let mut previous_offset = 0;
382
383    for (offset, value) in offsets.iter().zip(vector.array.iter()) {
384        let repeat_times = *offset - previous_offset;
385        match value {
386            Some(data) => {
387                unsafe {
388                    // Safety: std::iter::Repeat and std::iter::Take implement TrustedLen.
389                    builder
390                        .mutable_array
391                        .append_trusted_len_iter(std::iter::repeat_n(data, repeat_times));
392                }
393            }
394            None => {
395                builder.mutable_array.append_nulls(repeat_times);
396            }
397        }
398        previous_offset = *offset;
399    }
400    builder.finish()
401}
402
403#[cfg(test)]
404mod tests {
405    use std::vec;
406
407    use arrow::array::{
408        Int32Array, Time32MillisecondArray, Time32SecondArray, Time64MicrosecondArray,
409        Time64NanosecondArray,
410    };
411    use arrow::datatypes::{DataType as ArrowDataType, IntervalDayTime};
412    use arrow_array::{
413        DurationMicrosecondArray, DurationMillisecondArray, DurationNanosecondArray,
414        DurationSecondArray, IntervalDayTimeArray, IntervalYearMonthArray,
415        TimestampMicrosecondArray, TimestampMillisecondArray, TimestampNanosecondArray,
416        TimestampSecondArray,
417    };
418    use serde_json;
419
420    use super::*;
421    use crate::data_type::DataType;
422    use crate::serialize::Serializable;
423    use crate::timestamp::TimestampMillisecond;
424    use crate::types::Int64Type;
425    use crate::vectors::{
426        DurationMicrosecondVector, DurationMillisecondVector, DurationNanosecondVector,
427        DurationSecondVector, IntervalDayTimeVector, IntervalYearMonthVector,
428        TimeMicrosecondVector, TimeMillisecondVector, TimeNanosecondVector, TimeSecondVector,
429        TimestampMicrosecondVector, TimestampMillisecondVector, TimestampMillisecondVectorBuilder,
430        TimestampNanosecondVector, TimestampSecondVector,
431    };
432
433    fn check_vec(v: Int32Vector) {
434        assert_eq!(4, v.len());
435        assert_eq!("Int32Vector", v.vector_type_name());
436        assert!(!v.is_const());
437        assert!(v.validity().is_all_valid());
438        assert!(!v.only_null());
439
440        for i in 0..4 {
441            assert!(!v.is_null(i));
442            assert_eq!(Value::Int32(i as i32 + 1), v.get(i));
443            assert_eq!(ValueRef::Int32(i as i32 + 1), v.get_ref(i));
444        }
445
446        let json_value = v.serialize_to_json().unwrap();
447        assert_eq!("[1,2,3,4]", serde_json::to_string(&json_value).unwrap(),);
448
449        let arrow_arr = v.to_arrow_array();
450        assert_eq!(4, arrow_arr.len());
451        assert_eq!(&ArrowDataType::Int32, arrow_arr.data_type());
452    }
453
454    #[test]
455    fn test_from_values() {
456        let v = Int32Vector::from_values(vec![1, 2, 3, 4]);
457        check_vec(v);
458    }
459
460    #[test]
461    fn test_from_vec() {
462        let v = Int32Vector::from_vec(vec![1, 2, 3, 4]);
463        check_vec(v);
464    }
465
466    #[test]
467    fn test_from_slice() {
468        let v = Int32Vector::from_slice(vec![1, 2, 3, 4]);
469        check_vec(v);
470    }
471
472    #[test]
473    fn test_serialize_primitive_vector_with_null_to_json() {
474        let input = [Some(1i32), Some(2i32), None, Some(4i32), None];
475        let mut builder = Int32VectorBuilder::with_capacity(input.len());
476        for v in input {
477            builder.push(v);
478        }
479        let vector = builder.finish();
480
481        let json_value = vector.serialize_to_json().unwrap();
482        assert_eq!(
483            "[1,2,null,4,null]",
484            serde_json::to_string(&json_value).unwrap(),
485        );
486    }
487
488    #[test]
489    fn test_from_arrow_array() {
490        let arrow_array = Int32Array::from(vec![1, 2, 3, 4]);
491        let v = Int32Vector::from(arrow_array);
492        check_vec(v);
493    }
494
495    #[test]
496    fn test_primitive_vector_build_get() {
497        let input = [Some(1i32), Some(2i32), None, Some(4i32), None];
498        let mut builder = Int32VectorBuilder::with_capacity(input.len());
499        for v in input {
500            builder.push(v);
501        }
502        let vector = builder.finish();
503        assert_eq!(input.len(), vector.len());
504
505        for (i, v) in input.into_iter().enumerate() {
506            assert_eq!(v, vector.get_data(i));
507            assert_eq!(Value::from(v), vector.get(i));
508        }
509
510        let res: Vec<_> = vector.iter_data().collect();
511        assert_eq!(input, &res[..]);
512    }
513
514    #[test]
515    fn test_primitive_vector_validity() {
516        let input = [Some(1i32), Some(2i32), None, None];
517        let mut builder = Int32VectorBuilder::with_capacity(input.len());
518        for v in input {
519            builder.push(v);
520        }
521        let vector = builder.finish();
522        assert_eq!(2, vector.null_count());
523        let validity = vector.validity();
524        assert_eq!(2, validity.null_count());
525        assert!(!validity.is_set(2));
526        assert!(!validity.is_set(3));
527
528        let vector = Int32Vector::from_slice(vec![1, 2, 3, 4]);
529        assert_eq!(0, vector.null_count());
530        assert!(vector.validity().is_all_valid());
531    }
532
533    #[test]
534    fn test_memory_size() {
535        let v = Int32Vector::from_slice((0..5).collect::<Vec<i32>>());
536        assert_eq!(20, v.memory_size());
537        let v = Int64Vector::from(vec![Some(0i64), Some(1i64), Some(2i64), None, None]);
538        assert_eq!(144, v.memory_size());
539    }
540
541    #[test]
542    fn test_get_slice() {
543        let v = Int32Vector::from_slice(vec![1, 2, 3, 4, 5]);
544        let slice = v.get_slice(1, 3);
545        assert_eq!(v, Int32Vector::from_slice(vec![1, 2, 3, 4, 5]));
546        assert_eq!(slice, Int32Vector::from_slice(vec![2, 3, 4]));
547    }
548
549    #[test]
550    fn test_primitive_vector_builder() {
551        let mut builder = Int64Type::default().create_mutable_vector(3);
552        builder.push_value_ref(ValueRef::Int64(123));
553        assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
554
555        let input = Int64Vector::from_slice([7, 8, 9]);
556        builder.extend_slice_of(&input, 1, 2).unwrap();
557        assert!(builder
558            .extend_slice_of(&Int32Vector::from_slice([13]), 0, 1)
559            .is_err());
560        let vector = builder.to_vector();
561
562        let expect: VectorRef = Arc::new(Int64Vector::from_slice([123, 8, 9]));
563        assert_eq!(expect, vector);
564    }
565
566    #[test]
567    fn test_from_wrapper_slice() {
568        macro_rules! test_from_wrapper_slice {
569            ($vec: ident, $ty: ident) => {
570                let from_wrapper_slice = $vec::from_wrapper_slice(&[
571                    $ty::from_native($ty::MAX),
572                    $ty::from_native($ty::MIN),
573                ]);
574                let from_slice = $vec::from_slice([$ty::MAX, $ty::MIN]);
575                assert_eq!(from_wrapper_slice, from_slice);
576            };
577        }
578
579        test_from_wrapper_slice!(UInt8Vector, u8);
580        test_from_wrapper_slice!(Int8Vector, i8);
581        test_from_wrapper_slice!(UInt16Vector, u16);
582        test_from_wrapper_slice!(Int16Vector, i16);
583        test_from_wrapper_slice!(UInt32Vector, u32);
584        test_from_wrapper_slice!(Int32Vector, i32);
585        test_from_wrapper_slice!(UInt64Vector, u64);
586        test_from_wrapper_slice!(Int64Vector, i64);
587        test_from_wrapper_slice!(Float32Vector, f32);
588        test_from_wrapper_slice!(Float64Vector, f64);
589    }
590
591    #[test]
592    fn test_try_from_arrow_time_array() {
593        let array: ArrayRef = Arc::new(Time32SecondArray::from(vec![1i32, 2, 3]));
594        let vector = TimeSecondVector::try_from_arrow_array(array).unwrap();
595        assert_eq!(TimeSecondVector::from_values(vec![1, 2, 3]), vector);
596
597        let array: ArrayRef = Arc::new(Time32MillisecondArray::from(vec![1i32, 2, 3]));
598        let vector = TimeMillisecondVector::try_from_arrow_array(array).unwrap();
599        assert_eq!(TimeMillisecondVector::from_values(vec![1, 2, 3]), vector);
600
601        let array: ArrayRef = Arc::new(Time64MicrosecondArray::from(vec![1i64, 2, 3]));
602        let vector = TimeMicrosecondVector::try_from_arrow_array(array).unwrap();
603        assert_eq!(TimeMicrosecondVector::from_values(vec![1, 2, 3]), vector);
604
605        let array: ArrayRef = Arc::new(Time64NanosecondArray::from(vec![1i64, 2, 3]));
606        let vector = TimeNanosecondVector::try_from_arrow_array(array).unwrap();
607        assert_eq!(TimeNanosecondVector::from_values(vec![1, 2, 3]), vector);
608
609        // Test convert error
610        let array: ArrayRef = Arc::new(Int32Array::from(vec![1i32, 2, 3]));
611        assert!(TimeSecondVector::try_from_arrow_array(array).is_err());
612    }
613
614    #[test]
615    fn test_try_from_arrow_timestamp_array() {
616        let array: ArrayRef = Arc::new(TimestampSecondArray::from(vec![1i64, 2, 3]));
617        let vector = TimestampSecondVector::try_from_arrow_array(array).unwrap();
618        assert_eq!(TimestampSecondVector::from_values(vec![1, 2, 3]), vector);
619
620        let array: ArrayRef = Arc::new(TimestampMillisecondArray::from(vec![1i64, 2, 3]));
621        let vector = TimestampMillisecondVector::try_from_arrow_array(array).unwrap();
622        assert_eq!(
623            TimestampMillisecondVector::from_values(vec![1, 2, 3]),
624            vector
625        );
626
627        let array: ArrayRef = Arc::new(TimestampMicrosecondArray::from(vec![1i64, 2, 3]));
628        let vector = TimestampMicrosecondVector::try_from_arrow_array(array).unwrap();
629        assert_eq!(
630            TimestampMicrosecondVector::from_values(vec![1, 2, 3]),
631            vector
632        );
633
634        let array: ArrayRef = Arc::new(TimestampNanosecondArray::from(vec![1i64, 2, 3]));
635        let vector = TimestampNanosecondVector::try_from_arrow_array(array).unwrap();
636        assert_eq!(
637            TimestampNanosecondVector::from_values(vec![1, 2, 3]),
638            vector
639        );
640
641        // Test convert error
642        let array: ArrayRef = Arc::new(Int32Array::from(vec![1i32, 2, 3]));
643        assert!(TimestampSecondVector::try_from_arrow_array(array).is_err());
644    }
645
646    #[test]
647    fn test_try_from_arrow_interval_array() {
648        let array: ArrayRef = Arc::new(IntervalYearMonthArray::from(vec![1000, 2000, 3000]));
649        let vector = IntervalYearMonthVector::try_from_arrow_array(array).unwrap();
650        assert_eq!(
651            IntervalYearMonthVector::from_values(vec![1000, 2000, 3000]),
652            vector
653        );
654
655        let array: ArrayRef = Arc::new(IntervalDayTimeArray::from(vec![
656            IntervalDayTime::new(1, 1000),
657            IntervalDayTime::new(1, 2000),
658            IntervalDayTime::new(1, 3000),
659        ]));
660        let vector = IntervalDayTimeVector::try_from_arrow_array(array).unwrap();
661        assert_eq!(
662            IntervalDayTimeVector::from_values(vec![
663                IntervalDayTime::new(1, 1000),
664                IntervalDayTime::new(1, 2000),
665                IntervalDayTime::new(1, 3000),
666            ]),
667            vector
668        );
669
670        let array: ArrayRef = Arc::new(IntervalYearMonthArray::from(vec![1000, 2000, 3000]));
671        let vector = IntervalYearMonthVector::try_from_arrow_array(array).unwrap();
672        assert_eq!(
673            IntervalYearMonthVector::from_values(vec![1000, 2000, 3000]),
674            vector
675        );
676    }
677
678    #[test]
679    fn test_try_from_arrow_duration_array() {
680        let array: ArrayRef = Arc::new(DurationSecondArray::from(vec![1000, 2000, 3000]));
681        let vector = DurationSecondVector::try_from_arrow_array(array).unwrap();
682        assert_eq!(
683            DurationSecondVector::from_values(vec![1000, 2000, 3000]),
684            vector
685        );
686
687        let array: ArrayRef = Arc::new(DurationMillisecondArray::from(vec![1000, 2000, 3000]));
688        let vector = DurationMillisecondVector::try_from_arrow_array(array).unwrap();
689        assert_eq!(
690            DurationMillisecondVector::from_values(vec![1000, 2000, 3000]),
691            vector
692        );
693
694        let array: ArrayRef = Arc::new(DurationMicrosecondArray::from(vec![1000, 2000, 3000]));
695        let vector = DurationMicrosecondVector::try_from_arrow_array(array).unwrap();
696        assert_eq!(
697            DurationMicrosecondVector::from_values(vec![1000, 2000, 3000]),
698            vector
699        );
700
701        let array: ArrayRef = Arc::new(DurationNanosecondArray::from(vec![1000, 2000, 3000]));
702        let vector = DurationNanosecondVector::try_from_arrow_array(array).unwrap();
703        assert_eq!(
704            DurationNanosecondVector::from_values(vec![1000, 2000, 3000]),
705            vector
706        );
707    }
708
709    #[test]
710    fn test_primitive_vector_builder_finish_cloned() {
711        let mut builder = Int64Type::default().create_mutable_vector(3);
712        builder.push_value_ref(ValueRef::Int64(123));
713        builder.push_value_ref(ValueRef::Int64(456));
714        let vector = builder.to_vector_cloned();
715        assert_eq!(vector.len(), 2);
716        assert_eq!(vector.null_count(), 0);
717        assert_eq!(builder.len(), 2);
718
719        let mut builder = TimestampMillisecondVectorBuilder::with_capacity(1024);
720        builder.push(Some(TimestampMillisecond::new(1)));
721        builder.push(Some(TimestampMillisecond::new(2)));
722        builder.push(Some(TimestampMillisecond::new(3)));
723        let vector = builder.finish_cloned();
724        assert_eq!(vector.len(), 3);
725        assert_eq!(builder.len(), 3);
726    }
727}
datatypes/vectors/primitive.rs

datatypes/vectors/
primitive.rs
