feat: implememnt convert for unsigned int

ChobobDev · Nov 26, 2022 · f22f06c · f22f06c
1 parent 784cdcc
commit f22f06c
Show file tree

Hide file tree

Showing 6 changed files with 336 additions and 12 deletions.
diff --git a/core/src/ast/data_type.rs b/core/src/ast/data_type.rs
@@ -14,6 +14,9 @@ pub enum DataType {
     Int128,
     Uint8,
     Uint16,
+    Uint32,
+    Uint64,
+    Uint128,
     Float,
     Text,
     Bytea,

diff --git a/core/src/data/bigdecimal_ext.rs b/core/src/data/bigdecimal_ext.rs
@@ -8,6 +8,9 @@ pub trait BigDecimalExt {
     fn to_i128(&self) -> Option<i128>;
     fn to_u8(&self) -> Option<u8>;
     fn to_u16(&self) -> Option<u16>;
+    fn to_u32(&self) -> Option<u32>;
+    fn to_u64(&self) -> Option<u64>;
+    fn to_u128(&self) -> Option<u128>;
     fn to_f64(&self) -> Option<f64>;
 }
 
@@ -44,6 +47,18 @@ impl BigDecimalExt for BigDecimal {
         self.is_integer()
             .then(|| bigdecimal::ToPrimitive::to_u16(self))?
     }
+    fn to_u32(&self) -> Option<u32> {
+        self.is_integer()
+            .then(|| bigdecimal::ToPrimitive::to_u32(self))?
+    }
+    fn to_u64(&self) -> Option<u64> {
+        self.is_integer()
+            .then(|| bigdecimal::ToPrimitive::to_u64(self))?
+    }
+    fn to_u128(&self) -> Option<u128> {
+        self.is_integer()
+            .then(|| bigdecimal::ToPrimitive::to_u128(self))?
+    }
     fn to_f64(&self) -> Option<f64> {
         bigdecimal::ToPrimitive::to_f64(self)
     }

diff --git a/core/src/data/value/binary_op/decimal.rs b/core/src/data/value/binary_op/decimal.rs
@@ -19,6 +19,7 @@ impl PartialEq<Value> for Decimal {
             I128(other) => *self == Decimal::from(*other),
             U8(other) => *self == Decimal::from(*other),
             U16(other) => *self == Decimal::from(*other),
+            U32(other) => *self == Decimal::from(*other),
             F64(other) => Decimal::from_f64_retain(*other)
                 .map(|x| *self == x)
                 .unwrap_or(false),
@@ -37,6 +38,7 @@ impl PartialOrd<Value> for Decimal {
             I128(rhs) => self.partial_cmp(&(Decimal::from(rhs))),
             U8(rhs) => self.partial_cmp(&(Decimal::from(rhs))),
             U16(rhs) => self.partial_cmp(&(Decimal::from(rhs))),
+            U32(rhs) => self.partial_cmp(&(Decimal::from(rhs))),
             F64(rhs) => Decimal::from_f64_retain(rhs)
                 .map(|x| self.partial_cmp(&x))
                 .unwrap_or(None),
@@ -119,6 +121,17 @@ impl TryBinaryOperator for Decimal {
                     .into()
                 })
                 .map(Decimal),
+            U32(rhs) => lhs
+                .checked_add(Decimal::from(rhs))
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: Decimal(lhs),
+                        rhs: U32(rhs),
+                        operator: NumericBinaryOperator::Add,
+                    }
+                    .into()
+                })
+                .map(Decimal),
             F64(rhs) => Decimal::from_f64_retain(rhs)
                 .map(|x| Ok(Decimal(lhs + x)))
                 .unwrap_or_else(|| Err(ValueError::FloatToDecimalConversionFailure(rhs).into())),
@@ -213,6 +226,17 @@ impl TryBinaryOperator for Decimal {
                     .into()
                 })
                 .map(Decimal),
+            U32(rhs) => lhs
+                .checked_sub(Decimal::from(rhs))
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: Decimal(lhs),
+                        rhs: U32(rhs),
+                        operator: NumericBinaryOperator::Subtract,
+                    }
+                    .into()
+                })
+                .map(Decimal),
             F64(rhs) => Decimal::from_f64_retain(rhs)
                 .map(|x| Ok(Decimal(lhs - x)))
                 .unwrap_or_else(|| Err(ValueError::FloatToDecimalConversionFailure(rhs).into())),
@@ -307,6 +331,17 @@ impl TryBinaryOperator for Decimal {
                     .into()
                 })
                 .map(Decimal),
+            U32(rhs) => lhs
+                .checked_mul(Decimal::from(rhs))
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: Decimal(lhs),
+                        rhs: U32(rhs),
+                        operator: NumericBinaryOperator::Multiply,
+                    }
+                    .into()
+                })
+                .map(Decimal),
             F64(rhs) => Decimal::from_f64_retain(rhs)
                 .map(|x| Ok(Decimal(lhs * x)))
                 .unwrap_or_else(|| Err(ValueError::FloatToDecimalConversionFailure(rhs).into())),
@@ -401,6 +436,17 @@ impl TryBinaryOperator for Decimal {
                     .into()
                 })
                 .map(Decimal),
+            U32(rhs) => lhs
+                .checked_div(Decimal::from(rhs))
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: Decimal(lhs),
+                        rhs: U32(rhs),
+                        operator: NumericBinaryOperator::Divide,
+                    }
+                    .into()
+                })
+                .map(Decimal),
             F64(rhs) => Decimal::from_f64_retain(rhs)
                 .map(|x| Ok(Decimal(lhs / x)))
                 .unwrap_or_else(|| Err(ValueError::FloatToDecimalConversionFailure(rhs).into())),
@@ -495,6 +541,17 @@ impl TryBinaryOperator for Decimal {
                     .into()
                 })
                 .map(Decimal),
+            U32(rhs) => lhs
+                .checked_rem(Decimal::from(rhs))
+                .ok_or_else(|| {
+                    ValueError::BinaryOperationOverflow {
+                        lhs: Decimal(lhs),
+                        rhs: U32(rhs),
+                        operator: NumericBinaryOperator::Modulo,
+                    }
+                    .into()
+                })
+                .map(Decimal),
             F64(rhs) => match Decimal::from_f64_retain(rhs) {
                 Some(x) => lhs
                     .checked_rem(x)