reifydb_function/duration/
subtract.rs1use reifydb_core::value::column::data::ColumnData;
5use reifydb_type::value::{container::temporal::TemporalContainer, r#type::Type};
6
7use crate::{
8 ScalarFunction, ScalarFunctionContext,
9 error::{ScalarFunctionError, ScalarFunctionResult},
10 propagate_options,
11};
12
13pub struct DurationSubtract;
14
15impl DurationSubtract {
16 pub fn new() -> Self {
17 Self
18 }
19}
20
21impl ScalarFunction for DurationSubtract {
22 fn scalar(&self, ctx: ScalarFunctionContext) -> ScalarFunctionResult<ColumnData> {
23 if let Some(result) = propagate_options(self, &ctx) {
24 return result;
25 }
26 let columns = ctx.columns;
27 let row_count = ctx.row_count;
28
29 if columns.len() != 2 {
30 return Err(ScalarFunctionError::ArityMismatch {
31 function: ctx.fragment.clone(),
32 expected: 2,
33 actual: columns.len(),
34 });
35 }
36
37 let lhs_col = columns.get(0).unwrap();
38 let rhs_col = columns.get(1).unwrap();
39
40 match (lhs_col.data(), rhs_col.data()) {
41 (ColumnData::Duration(lhs_container), ColumnData::Duration(rhs_container)) => {
42 let mut container = TemporalContainer::with_capacity(row_count);
43
44 for i in 0..row_count {
45 match (lhs_container.get(i), rhs_container.get(i)) {
46 (Some(lv), Some(rv)) => {
47 container.push(*lv - *rv);
48 }
49 _ => container.push_default(),
50 }
51 }
52
53 Ok(ColumnData::Duration(container))
54 }
55 (ColumnData::Duration(_), other) => Err(ScalarFunctionError::InvalidArgumentType {
56 function: ctx.fragment.clone(),
57 argument_index: 1,
58 expected: vec![Type::Duration],
59 actual: other.get_type(),
60 }),
61 (other, _) => Err(ScalarFunctionError::InvalidArgumentType {
62 function: ctx.fragment.clone(),
63 argument_index: 0,
64 expected: vec![Type::Duration],
65 actual: other.get_type(),
66 }),
67 }
68 }
69
70 fn return_type(&self, _input_types: &[Type]) -> Type {
71 Type::Duration
72 }
73}