Function eval_binary_op

nodedb-query/src/expr/binary.rs:44–113

(left: &Value, op: BinaryOp, right: &Value)

}

pub(super) fn eval_binary_op(left: &Value, op: BinaryOp, right: &Value) -> Value {
    match op {
        // Arithmetic: prefer Decimal when either operand is Decimal to avoid f64 drift.
        BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
            let left_is_decimal = matches!(left, Value::Decimal(_));
            let right_is_decimal = matches!(right, Value::Decimal(_));
            if left_is_decimal || right_is_decimal {
                match (value_to_decimal(left), value_to_decimal(right)) {
                    (Some(a), Some(b)) => return decimal_arith(a, op, b),
                    _ => return Value::Null,
                }
            }
            // Both operands are non-Decimal: use f64 path.
            match op {
                BinaryOp::Add => match (value_to_f64(left, true), value_to_f64(right, true)) {
                    (Some(a), Some(b)) => to_value_number(a + b),
                    _ => Value::Null,
                },
                BinaryOp::Sub => match (value_to_f64(left, true), value_to_f64(right, true)) {
                    (Some(a), Some(b)) => to_value_number(a - b),
                    _ => Value::Null,
                },
                BinaryOp::Mul => match (value_to_f64(left, true), value_to_f64(right, true)) {
                    (Some(a), Some(b)) => to_value_number(a * b),
                    _ => Value::Null,
                },
                BinaryOp::Div => match (value_to_f64(left, true), value_to_f64(right, true)) {
                    (Some(a), Some(b)) => {
                        if b == 0.0 {
                            Value::Null
                        } else {
                            to_value_number(a / b)
                        }
                    }
                    _ => Value::Null,
                },
                BinaryOp::Mod => match (value_to_f64(left, true), value_to_f64(right, true)) {
                    (Some(a), Some(b)) => {
                        if b == 0.0 {
                            Value::Null
                        } else {
                            to_value_number(a % b)
                        }
                    }
                    _ => Value::Null,
                },
                _ => Value::Null,
            }
        }
        BinaryOp::Concat => {
            let ls = value_to_display_string(left);
            let rs = value_to_display_string(right);
            Value::String(format!("{ls}{rs}"))
        }
        BinaryOp::Eq => Value::Bool(coerced_eq(left, right)),
        BinaryOp::NotEq => Value::Bool(!coerced_eq(left, right)),
        BinaryOp::Gt => Value::Bool(compare_values(left, right) == std::cmp::Ordering::Greater),
        BinaryOp::GtEq => {