use vortex_error::VortexResult;
use crate::ExecutionCtx;
use crate::array::ArrayView;
use crate::array::OperationsVTable;
use crate::array::ProbeState;
use crate::arrays::Decimal;
use crate::match_each_decimal_value_type;
use crate::scalar::DecimalValue;
use crate::scalar::Scalar;
impl OperationsVTable<Decimal> for Decimal {
type ProbeState = ();
fn probe_scalar(
state: &mut ProbeState<'_, Decimal>,
index: usize,
ctx: &mut ExecutionCtx,
) -> VortexResult<Scalar> {
let array = state.array();
if !state.is_valid(index, ctx)? {
return Ok(Scalar::null(array.dtype().clone()));
}
match_each_decimal_value_type!(array.values_type(), |D| {
Scalar::try_decimal(
DecimalValue::from(array.buffer::<D>()[index]),
array.decimal_dtype(),
array.dtype().nullability(),
)
})
}
fn scalar_at(
array: ArrayView<'_, Decimal>,
index: usize,
ctx: &mut ExecutionCtx,
) -> VortexResult<Scalar> {
Self::probe_scalar(&mut ProbeState::once(array), index, ctx)
}
}
#[cfg(test)]
mod tests {
use std::sync::LazyLock;
use rstest::rstest;
use vortex_buffer::buffer;
use vortex_error::VortexResult;
use vortex_session::VortexSession;
use crate::IntoArray;
use crate::VortexSessionExecute;
use crate::arrays::Decimal;
use crate::arrays::DecimalArray;
use crate::assert_arrays_eq;
use crate::dtype::DecimalDType;
use crate::dtype::Nullability;
use crate::scalar::DecimalValue;
use crate::scalar::Scalar;
use crate::validity::Validity;
static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
#[test]
fn test_slice() {
let array = DecimalArray::new(
buffer![100i128, 200i128, 300i128, 4000i128],
DecimalDType::new(3, 2),
Validity::NonNullable,
)
.into_array();
let sliced = array.slice(1..3).unwrap();
assert_eq!(sliced.len(), 2);
let decimal = sliced.as_::<Decimal>();
assert_eq!(decimal.buffer::<i128>(), buffer![200i128, 300i128]);
}
#[test]
fn test_slice_nullable() {
let array = DecimalArray::new(
buffer![100i128, 200i128, 300i128, 4000i128],
DecimalDType::new(3, 2),
Validity::from_iter([false, true, false, true]),
)
.into_array();
let sliced = array.slice(1..3).unwrap();
assert_eq!(sliced.len(), 2);
assert_arrays_eq!(
sliced,
DecimalArray::from_option_iter([Some(200i128), None], DecimalDType::new(3, 2)),
&mut SESSION.create_execution_ctx()
);
}
#[test]
fn test_scalar_at() {
let array = DecimalArray::new(
buffer![100i128],
DecimalDType::new(3, 2),
Validity::NonNullable,
);
assert_eq!(
array
.execute_scalar(0, &mut SESSION.create_execution_ctx())
.unwrap(),
Scalar::decimal(
DecimalValue::I128(100),
DecimalDType::new(3, 2),
Nullability::NonNullable
)
);
}
#[rstest]
#[case::positive(100i8)]
#[case::negative(-100i8)]
fn test_scalar_at_value_outside_precision_errors(#[case] value: i8) -> VortexResult<()> {
let array = DecimalArray::new(
buffer![value],
DecimalDType::new(2, 0),
Validity::NonNullable,
);
let err = array
.execute_scalar(0, &mut SESSION.create_execution_ctx())
.unwrap_err();
assert!(
err.to_string().contains("does not fit in precision"),
"unexpected error: {err}"
);
Ok(())
}
#[test]
fn test_scalar_at_ignores_value_outside_precision_in_null_slot() -> VortexResult<()> {
let array = DecimalArray::new(
buffer![5i8, 100i8],
DecimalDType::new(2, 0),
Validity::from_iter([true, false]),
);
let mut ctx = SESSION.create_execution_ctx();
assert_eq!(
array.execute_scalar(0, &mut ctx)?,
Scalar::decimal(
DecimalValue::I8(5),
DecimalDType::new(2, 0),
Nullability::Nullable
)
);
assert!(array.execute_scalar(1, &mut ctx)?.is_null());
Ok(())
}
}