wip

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

vortex-array/src/scalar_fns/binary/mod.rs

@@ -143,118 +143,6 @@ fn execute_arithmetic_primitive(
     .ok_or_else(|| vortex_err!("Arithmetic overflow/underflow or type mismatch"))
 }
 
-// fn execute_scalar_scalar(
-//     lhs: &vortex_vector::Scalar,
-//     rhs: &vortex_vector::Scalar,
-//     op: Operator,
-// ) -> VortexResult<Datum> {
-//     use vortex_vector::Scalar;
-//     use vortex_vector::ScalarOps;
-//
-//     // Handle null propagation for non-kleene operators
-//     if !matches!(op, Operator::And | Operator::Or) && (!lhs.is_valid() || !rhs.is_valid()) {
-//         return match op {
-//             Operator::Add | Operator::Sub | Operator::Mul | Operator::Div => {
-//                 // Return null primitive - we'd need to know the type
-//                 // For now, bail
-//                 vortex_bail!("Null scalar arithmetic not yet supported")
-//             }
-//             _ => Ok(Datum::Scalar(BoolScalar::new(None).into())),
-//         };
-//     }
-//
-//     match (lhs, rhs) {
-//         (Scalar::Bool(l), Scalar::Bool(r)) => {
-//             let result: BoolScalar = match op {
-//                 op if op.maybe_cmp_operator().is_some() => compare_op!(
-//                     op,
-//                     l,
-//                     r,
-//                     Operator::Eq,
-//                     Operator::NotEq,
-//                     Operator::Lt,
-//                     Operator::Lte,
-//                     Operator::Gt,
-//                     Operator::Gte
-//                 ),
-//                 _ => vortex_bail!("Arithmetic not supported for bool scalars"),
-//             };
-//             Ok(Datum::Scalar(result.into()))
-//         }
-//         (Scalar::Primitive(l), Scalar::Primitive(r)) => execute_scalar_scalar_primitive(l, r, op),
-//         _ => vortex_bail!(
-//             "Binary operation not supported for scalar types {:?} and {:?}",
-//             lhs,
-//             rhs
-//         ),
-//     }
-// }
-
-// fn execute_scalar_scalar_primitive(
-//     lhs: &PrimitiveScalar,
-//     rhs: &PrimitiveScalar,
-//     op: Operator,
-// ) -> VortexResult<Datum> {
-//     if op.maybe_cmp_operator().is_some() {
-//         let result = compare_op!(
-//             op,
-//             lhs,
-//             rhs,
-//             Operator::Eq,
-//             Operator::NotEq,
-//             Operator::Lt,
-//             Operator::Lte,
-//             Operator::Gt,
-//             Operator::Gte
-//         );
-//         return Ok(Datum::Scalar(result.into()));
-//     }
-//
-//     if op.is_arithmetic() {
-//         return execute_scalar_arithmetic_primitive(lhs, rhs, op);
-//     }
-//
-//     vortex_bail!("Operation {:?} not supported for primitive scalars", op)
-// }
-
-// fn execute_scalar_arithmetic_primitive(
-//     lhs: &PrimitiveScalar,
-//     rhs: &PrimitiveScalar,
-//     op: Operator,
-// ) -> VortexResult<Datum> {
-//     // Float arithmetic - no overflow checking needed
-//     if lhs.ptype().is_float() && lhs.ptype() == rhs.ptype() {
-//         let result = arithmetic_op!(
-//             op,
-//             lhs,
-//             rhs,
-//             Operator::Add,
-//             Operator::Sub,
-//             Operator::Mul,
-//             Operator::Div
-//         );
-//         return Ok(Datum::Scalar(result.into()));
-//     }
-//
-//     // Integer arithmetic - use checked operations
-//     let result: Option<PrimitiveScalar> = checked_arithmetic_op!(
-//         op,
-//         lhs,
-//         rhs,
-//         Operator::Add,
-//         Operator::Sub,
-//         Operator::Mul,
-//         Operator::Div
-//     );
-//
-//     match result {
-//         Some(v) => Ok(Datum::Scalar(v.into())),
-//         None => Err(vortex_err!(
-//             "Arithmetic overflow/underflow or type mismatch"
-//         )),
-//     }
-// }
-
 #[cfg(test)]
 mod tests {
     use vortex_buffer::buffer;