feat: add U16 to binary operator

gluesql · panarch · Oct 29, 2022 · Sep 14, 2022 · Sep 14, 2022 · Sep 14, 2022
commit 8de937a9b46092a5696f9f67064ef1d532a6fb59
diff --git a/core/src/data/value/binary_op/f64.rs b/core/src/data/value/binary_op/f64.rs
@@ -21,6 +21,7 @@ impl PartialEq<Value> for f64 {
             I64(rhs) => (lhs - (rhs as f64)).abs() < f64::EPSILON,
             I128(rhs) => (lhs - (rhs as f64)).abs() < f64::EPSILON,
             U8(rhs) => (lhs - (rhs as f64)).abs() < f64::EPSILON,
+            U16(rhs) => (lhs - (rhs as f64)).abs() < f64::EPSILON,
             F64(rhs) => (lhs - rhs).abs() < f64::EPSILON,
             Decimal(rhs) => Decimal::from_f64_retain(lhs)
                 .map(|x| rhs == x)
@@ -39,6 +40,7 @@ impl PartialOrd<Value> for f64 {
             I64(rhs) => self.partial_cmp(&(rhs as f64)),
             I128(rhs) => self.partial_cmp(&(rhs as f64)),
             U8(rhs) => self.partial_cmp(&(rhs as f64)),
+            U16(rhs) => self.partial_cmp(&(rhs as f64)),
             F64(rhs) => self.partial_cmp(&rhs),
             Decimal(rhs) => Decimal::from_f64_retain(*self)
                 .map(|x| x.partial_cmp(&rhs))
@@ -61,6 +63,7 @@ impl TryBinaryOperator for f64 {
             I64(rhs) => Ok(F64(lhs + rhs as f64)),
             I128(rhs) => Ok(F64(lhs + rhs as f64)),
             U8(rhs) => Ok(F64(lhs + rhs as f64)),
+            U16(rhs) => Ok(F64(lhs + rhs as f64)),
             F64(rhs) => Ok(F64(lhs + rhs)),
             Decimal(rhs) => Decimal::from_f64_retain(lhs)
                 .map(|x| Ok(Decimal(x + rhs)))
@@ -85,6 +88,7 @@ impl TryBinaryOperator for f64 {
             I64(rhs) => Ok(F64(lhs - rhs as f64)),
             I128(rhs) => Ok(F64(lhs - rhs as f64)),
             U8(rhs) => Ok(F64(lhs - rhs as f64)),
+            U16(rhs) => Ok(F64(lhs - rhs as f64)),
             F64(rhs) => Ok(F64(lhs - rhs)),
             Decimal(rhs) => Decimal::from_f64_retain(lhs)
                 .map(|x| Ok(Decimal(x - rhs)))
@@ -109,6 +113,7 @@ impl TryBinaryOperator for f64 {
             I64(rhs) => Ok(F64(lhs * rhs as f64)),
             I128(rhs) => Ok(F64(lhs * rhs as f64)),
             U8(rhs) => Ok(F64(lhs * rhs as f64)),
+            U16(rhs) => Ok(F64(lhs * rhs as f64)),
             F64(rhs) => Ok(F64(lhs * rhs)),
             Interval(rhs) => Ok(Interval(lhs * rhs)),
             Decimal(rhs) => Decimal::from_f64_retain(lhs)
@@ -134,6 +139,7 @@ impl TryBinaryOperator for f64 {
             I64(rhs) => Ok(F64(lhs / rhs as f64)),
             I128(rhs) => Ok(F64(lhs / rhs as f64)),
             U8(rhs) => Ok(F64(lhs / rhs as f64)),
+            U16(rhs) => Ok(F64(lhs / rhs as f64)),
             F64(rhs) => Ok(F64(lhs / rhs)),
             Decimal(rhs) => Decimal::from_f64_retain(lhs)
                 .map(|x| Ok(Decimal(x * rhs)))
@@ -158,6 +164,7 @@ impl TryBinaryOperator for f64 {
             I64(rhs) => Ok(F64(lhs % rhs as f64)),
             I128(rhs) => Ok(F64(lhs % rhs as f64)),
             U8(rhs) => Ok(F64(lhs % rhs as f64)),
+            U16(rhs) => Ok(F64(lhs % rhs as f64)),
             F64(rhs) => Ok(F64(lhs % rhs)),
             Decimal(rhs) => match Decimal::from_f64_retain(lhs) {
                 Some(x) => x
@@ -203,6 +210,7 @@ mod tests {
         assert_eq!(base, I64(1));
         assert_eq!(base, I128(1));
         assert_eq!(base, U8(1));
+        assert_eq!(base, U16(1));
         assert_eq!(base, F64(1.0));
         assert_eq!(base, Decimal(Decimal::from(1)));
 
@@ -219,6 +227,7 @@ mod tests {
         assert_eq!(base.partial_cmp(&I64(1)), Some(Ordering::Equal));
         assert_eq!(base.partial_cmp(&I128(1)), Some(Ordering::Equal));
         assert_eq!(base.partial_cmp(&U8(1)), Some(Ordering::Equal));
+        assert_eq!(base.partial_cmp(&U16(1)), Some(Ordering::Equal));
         assert_eq!(base.partial_cmp(&F64(1.0)), Some(Ordering::Equal));
         assert_eq!(
             base.partial_cmp(&Decimal(Decimal::ONE)),
@@ -238,6 +247,7 @@ mod tests {
         assert!(matches!(base.try_add(&I64(1)), Ok(F64(x)) if (x - 2.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_add(&I128(1)), Ok(F64(x)) if (x - 2.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_add(&U8(1)), Ok(F64(x)) if (x - 2.0).abs() < f64::EPSILON ));
+        assert!(matches!(base.try_add(&U16(1)), Ok(F64(x)) if (x - 2.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_add(&F64(1.0)), Ok(F64(x)) if (x - 2.0).abs() < f64::EPSILON ));
         assert!(
             matches!(base.try_add(&Decimal(Decimal::ONE)), Ok(Decimal(x)) if x == Decimal::TWO)
@@ -272,6 +282,9 @@ mod tests {
             matches!(base.try_subtract(&I128(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON )
         );
         assert!(matches!(base.try_subtract(&U8(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON ));
+        assert!(
+            matches!(base.try_subtract(&U16(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON )
+        );
         assert!(
             matches!(base.try_subtract(&F64(1.0)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON )
         );
@@ -308,6 +321,9 @@ mod tests {
             matches!(base.try_multiply(&I128(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON )
         );
         assert!(matches!(base.try_multiply(&U8(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON ));
+        assert!(
+            matches!(base.try_multiply(&U16(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON )
+        );
         assert!(
             matches!(base.try_multiply(&F64(1.0)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON )
         );
@@ -336,6 +352,7 @@ mod tests {
         assert!(matches!(base.try_divide(&I64(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_divide(&I128(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_divide(&U8(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON ));
+        assert!(matches!(base.try_divide(&U16(1)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON ));
         assert!(
             matches!(base.try_divide(&F64(1.0)), Ok(F64(x)) if (x - 1.0).abs() < f64::EPSILON )
         );
@@ -364,6 +381,7 @@ mod tests {
         assert!(matches!(base.try_modulo(&I64(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_modulo(&I128(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON ));
         assert!(matches!(base.try_modulo(&U8(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON ));
+        assert!(matches!(base.try_modulo(&U16(1)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON ));
         assert!(
             matches!(base.try_modulo(&F64(1.0)), Ok(F64(x)) if (x - 0.0).abs() < f64::EPSILON )
         );

diff --git a/core/src/data/value/binary_op/i128.rs b/core/src/data/value/binary_op/i128.rs
@@ -19,6 +19,7 @@ impl PartialEq<Value> for i128 {
             I64(other) => self == &(*other as i128),
             I128(other) => self == other,
             U8(other) => self == &(*other as i128),
+            U16(other) => self == &(*other as i128),
             F64(other) => ((*self as f64) - other).abs() < f64::EPSILON,
             Decimal(other) => Decimal::from(*self) == *other,
             _ => false,
@@ -35,6 +36,7 @@ impl PartialOrd<Value> for i128 {
             I64(other) => PartialOrd::partial_cmp(self, &(*other as i128)),
             I128(other) => PartialOrd::partial_cmp(self, other),
             U8(other) => PartialOrd::partial_cmp(self, &(*other as i128)),
+            U16(other) => PartialOrd::partial_cmp(self, &(*other as i128)),
             F64(other) => PartialOrd::partial_cmp(&(*self as f64), other),
             Decimal(other) => Decimal::from(*self).partial_cmp(other),
             _ => None,
@@ -116,6 +118,17 @@ impl TryBinaryOperator for i128 {
                     .into()
                 })
                 .map(I128),
+            U16(rhs) => lhs
+                .checked_add(rhs as i128)
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: I128(lhs),
+                        rhs: U16(rhs),
+                        operator: NumericBinaryOperator::Add,
+                    }
+                    .into()
+                })
+                .map(I128),
             F64(rhs) => Ok(F64(lhs as f64 + rhs)),
             Decimal(rhs) => Ok(Decimal(Decimal::from(lhs) + rhs)),
             Null => Ok(Null),

diff --git a/core/src/data/value/binary_op/i16.rs b/core/src/data/value/binary_op/i16.rs
@@ -21,6 +21,7 @@ impl PartialEq<Value> for i16 {
             I64(rhs) => (lhs as i64) == *rhs,
             I128(rhs) => (lhs as i128) == *rhs,
             U8(rhs) => lhs == (*rhs as i16),
+            U16(rhs) => lhs == (*rhs as i16),
             F64(rhs) => ((lhs as f64) - rhs).abs() < f64::EPSILON,
             Decimal(rhs) => Decimal::from(lhs) == *rhs,
             _ => false,
@@ -37,6 +38,7 @@ impl PartialOrd<Value> for i16 {
             I64(rhs) => (*self as i64).partial_cmp(rhs),
             I128(rhs) => (*self as i128).partial_cmp(rhs),
             U8(rhs) => self.partial_cmp(&(*rhs as i16)),
+            U16(rhs) => self.partial_cmp(&(*rhs as i16)),
             F64(rhs) => (*self as f64).partial_cmp(rhs),
             Decimal(rhs) => Decimal::from(*self).partial_cmp(rhs),
             _ => None,
@@ -117,6 +119,17 @@ impl TryBinaryOperator for i16 {
                     .into()
                 })
                 .map(I16),
+            U16(rhs) => lhs
+                .checked_add(rhs as i16)
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: I16(lhs),
+                        rhs: U16(rhs),
+                        operator: NumericBinaryOperator::Add,
+                    }
+                    .into()
+                })
+                .map(I16),
             F64(rhs) => Ok(F64(lhs as f64 + rhs)),
             Decimal(rhs) => Ok(Decimal(Decimal::from(lhs) + rhs)),
             Null => Ok(Null),
@@ -199,6 +212,17 @@ impl TryBinaryOperator for i16 {
                     .into()
                 })
                 .map(I16),
+            U16(rhs) => lhs
+                .checked_sub(rhs as i16)
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: I16(lhs),
+                        rhs: U16(rhs),
+                        operator: NumericBinaryOperator::Subtract,
+                    }
+                    .into()
+                })
+                .map(I16),
             F64(rhs) => Ok(F64(lhs as f64 - rhs)),
             Decimal(rhs) => Decimal::from(lhs)
                 .checked_sub(rhs)
@@ -291,6 +315,17 @@ impl TryBinaryOperator for i16 {
                     .into()
                 })
                 .map(I16),
+            U16(rhs) => lhs
+                .checked_mul(rhs as i16)
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: I16(lhs),
+                        rhs: U16(rhs),
+                        operator: NumericBinaryOperator::Multiply,
+                    }
+                    .into()
+                })
+                .map(I16),
             F64(rhs) => Ok(F64(lhs as f64 * rhs)),
             Decimal(rhs) => Decimal::from(lhs)
                 .checked_mul(rhs)
@@ -384,6 +419,17 @@ impl TryBinaryOperator for i16 {
                     .into()
                 })
                 .map(I16),
+            U16(rhs) => lhs
+                .checked_div(rhs as i16)
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: I16(lhs),
+                        rhs: U16(rhs),
+                        operator: NumericBinaryOperator::Divide,
+                    }
+                    .into()
+                })
+                .map(I16),
             F64(rhs) => Ok(F64(lhs as f64 / rhs)),
             Decimal(rhs) => Decimal::from(lhs)
                 .checked_div(rhs)
@@ -476,6 +522,17 @@ impl TryBinaryOperator for i16 {
                     .into()
                 })
                 .map(I16),
+            U16(rhs) => lhs
+                .checked_rem(rhs as i16)
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: I16(lhs),
+                        rhs: U16(rhs),
+                        operator: NumericBinaryOperator::Modulo,
+                    }
+                    .into()
+                })
+                .map(I16),
             F64(rhs) => Ok(F64(lhs as f64 % rhs)),
             Decimal(rhs) => Decimal::from(lhs)
                 .checked_rem(rhs)

diff --git a/core/src/data/value/binary_op/mod.rs b/core/src/data/value/binary_op/mod.rs
@@ -7,6 +7,7 @@ mod i16;
 mod i32;
 mod i64;
 mod i8;
+mod u16;
 mod u8;
 
 pub trait TryBinaryOperator {