Skip to main content

vortex_array/arrays/decimal/vtable/
operations.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use vortex_error::VortexResult;
5
6use crate::ExecutionCtx;
7use crate::array::ArrayView;
8use crate::array::OperationsVTable;
9use crate::arrays::Decimal;
10use crate::match_each_decimal_value_type;
11use crate::scalar::DecimalValue;
12use crate::scalar::Scalar;
13
14impl OperationsVTable<Decimal> for Decimal {
15    type ProbeState = ();
16
17    fn scalar_at(
18        array: ArrayView<'_, Decimal>,
19        index: usize,
20        _ctx: &mut ExecutionCtx,
21    ) -> VortexResult<Scalar> {
22        Ok(match_each_decimal_value_type!(array.values_type(), |D| {
23            Scalar::decimal(
24                DecimalValue::from(array.buffer::<D>()[index]),
25                array.decimal_dtype(),
26                array.dtype().nullability(),
27            )
28        }))
29    }
30}
31
32#[cfg(test)]
33mod tests {
34    use vortex_buffer::buffer;
35
36    use crate::IntoArray;
37    use crate::VortexSessionExecute;
38    use crate::array_session;
39    use crate::arrays::Decimal;
40    use crate::arrays::DecimalArray;
41    use crate::assert_arrays_eq;
42    use crate::dtype::DecimalDType;
43    use crate::dtype::Nullability;
44    use crate::scalar::DecimalValue;
45    use crate::scalar::Scalar;
46    use crate::validity::Validity;
47
48    #[test]
49    fn test_slice() {
50        let array = DecimalArray::new(
51            buffer![100i128, 200i128, 300i128, 4000i128],
52            DecimalDType::new(3, 2),
53            Validity::NonNullable,
54        )
55        .into_array();
56
57        let sliced = array.slice(1..3).unwrap();
58        assert_eq!(sliced.len(), 2);
59
60        let decimal = sliced.as_::<Decimal>();
61        assert_eq!(decimal.buffer::<i128>(), buffer![200i128, 300i128]);
62    }
63
64    #[test]
65    fn test_slice_nullable() {
66        let array = DecimalArray::new(
67            buffer![100i128, 200i128, 300i128, 4000i128],
68            DecimalDType::new(3, 2),
69            Validity::from_iter([false, true, false, true]),
70        )
71        .into_array();
72
73        let sliced = array.slice(1..3).unwrap();
74        assert_eq!(sliced.len(), 2);
75        assert_arrays_eq!(
76            sliced,
77            DecimalArray::from_option_iter([Some(200i128), None], DecimalDType::new(3, 2)),
78            &mut array_session().create_execution_ctx()
79        );
80    }
81
82    #[test]
83    fn test_scalar_at() {
84        let array = DecimalArray::new(
85            buffer![100i128],
86            DecimalDType::new(3, 2),
87            Validity::NonNullable,
88        );
89
90        assert_eq!(
91            array
92                .execute_scalar(0, &mut array_session().create_execution_ctx())
93                .unwrap(),
94            Scalar::decimal(
95                DecimalValue::I128(100),
96                DecimalDType::new(3, 2),
97                Nullability::NonNullable
98            )
99        );
100    }
101}