vortex-array 0.54.0

Vortex in memory columnar data format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use vortex_error::VortexResult;
use vortex_scalar::Scalar;

use crate::arrays::{ConstantArray, ConstantVTable};
use crate::compute::{FillNullKernel, FillNullKernelAdapter, cast};
use crate::{ArrayRef, IntoArray, register_kernel};

impl FillNullKernel for ConstantVTable {
    fn fill_null(&self, array: &ConstantArray, fill_value: &Scalar) -> VortexResult<ArrayRef> {
        if array.scalar().is_null() {
            Ok(ConstantArray::new(fill_value.clone(), array.len()).into_array())
        } else {
            cast(array.as_ref(), fill_value.dtype())
        }
    }
}

register_kernel!(FillNullKernelAdapter(ConstantVTable).lift());

#[cfg(test)]
mod test {
    use vortex_scalar::Scalar;

    use crate::IntoArray as _;
    use crate::arrays::ConstantArray;
    use crate::arrow::IntoArrowArray as _;
    use crate::compute::fill_null;

    #[test]
    fn test_null() {
        let actual = fill_null(
            &ConstantArray::new(Scalar::from(None::<i32>), 3).into_array(),
            &Scalar::from(1),
        )
        .unwrap();
        let expected = ConstantArray::new(Scalar::from(1), 3).into_array();

        assert!(!actual.dtype().is_nullable());

        let actual_arrow = actual.clone().into_arrow_preferred().unwrap();
        let expected_arrow = expected.clone().into_arrow_preferred().unwrap();
        assert_eq!(
            &actual_arrow,
            &expected_arrow,
            "{}, {}",
            actual.display_values(),
            expected.display_values()
        );
    }

    #[test]
    fn test_non_null() {
        let actual = fill_null(
            &ConstantArray::new(Scalar::from(Some(1)), 3).into_array(),
            &Scalar::from(1),
        )
        .unwrap();
        let expected = ConstantArray::new(Scalar::from(1), 3).into_array();

        assert!(!actual.dtype().is_nullable());

        let actual_arrow = actual.clone().into_arrow_preferred().unwrap();
        let expected_arrow = expected.clone().into_arrow_preferred().unwrap();
        assert_eq!(
            &actual_arrow,
            &expected_arrow,
            "{}, {}",
            actual.display_values(),
            expected.display_values()
        );
    }

    #[test]
    fn test_non_nullable_with_nullable() {
        let actual = fill_null(
            &ConstantArray::new(Scalar::from(1), 3).into_array(),
            &Scalar::from(Some(1)),
        )
        .unwrap();
        let expected = ConstantArray::new(Scalar::from(1), 3).into_array();

        assert!(!Scalar::from(1).dtype().is_nullable());

        assert!(actual.dtype().is_nullable());

        let actual_arrow = actual.clone().into_arrow_preferred().unwrap();
        let expected_arrow = expected.clone().into_arrow_preferred().unwrap();
        assert_eq!(
            &actual_arrow,
            &expected_arrow,
            "{}, {}",
            actual.display_values(),
            expected.display_values()
        );
    }
}