Add conversion from Option<PgUInt> to Option<uint>

Author: bitfl0wer

README.md

@@ -24,6 +24,10 @@ fn main() {
         "Interact with the underlying BigDecimal type directly: {}",
         pg_u_64.as_big_decimal()
     );
+    println!("You can also convert an Option<PgUInt> to a Option<uint> easily.")
+    let somepguint: Option<PgU32> = Some(PgU32::from(123u32));
+    let someuint: Option<u32> = somepguint.to_option_uint();
+    assert_eq!(someuint, Some(123u32));
     println!("PgUint types can be converted to and from BigDecimals, and are storable in an sqlx::Postgres database.");
     println!("If you load a PgUint from a database successfully, you can be sure that it's a valid fixed-size unsigned integer.");
 }

sqlx-pg-uint-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlx-pg-uint-macros"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2021"
 license = "MIT"
 authors = ["bitfl0wer"]
@@ -11,5 +11,5 @@ rust-version = "1.61.0"
 proc-macro = true
 
 [dependencies]
-quote = "1.0.38"
-syn = "2.0.98"
+quote = "1.0.40"
+syn = "2.0.101"

sqlx-pg-uint-macros/src/lib.rs

@@ -104,6 +104,11 @@ pub fn uint_wrapper_derive(input: TokenStream) -> TokenStream {
                 stringed_num.parse().unwrap()
             }
 
+            /// Converts `Option<PgUint>` to `Option<[underlying integer type]>`.
+            pub fn to_option_uint(&self) -> Option<<#name as UIntType>::Uint> {
+                <Option<#name> as OptionPgUint<#name>>::to_option_uint(&Some(self.clone()))
+            }
+
             /// Creates a new instance of this type from the associated unsigned integer type
             pub fn new(num: <#name as UIntType>::Uint) -> Self {
                 Self {
@@ -117,6 +122,12 @@ pub fn uint_wrapper_derive(input: TokenStream) -> TokenStream {
             }
         }
 
+        impl OptionPgUint<#name> for Option<#name> where #name: UIntType {
+            fn to_option_uint(&self) -> Option<<#name as UIntType>::Uint> {
+                self.clone().map(|v| v.to_uint())
+            }
+        }
+
         impl TryFrom<BigDecimal> for #name {
             type Error = crate::Error;
 

sqlx-pg-uint/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "sqlx-pg-uint"
-version = "0.9.0"
+version = "0.10.0"
 edition = "2021"
 license = "MIT"
 authors = ["bitfl0wer"]
 description = "SQLx compatible types to convert between Rust unsigned integers and the PostgreSQL `NUMERIC`/`DECIMAL` type seamlessly."
 repository = "https://github.com/bitfl0wer/sqlx-pg-uint"
 readme = "../README.md"
-rust-version = "1.74.1"
+rust-version = "1.81.0"
 
 [dependencies]
 sqlx = { version = "^0.8", default-features = false, features = [

sqlx-pg-uint/src/lib.rs

@@ -90,3 +90,8 @@ pub trait UIntType: private::Sealed + Display {
     /// The underlying integer type for the `PgUint` type.
     type Uint: private::Sealed + FromStr;
 }
+
+pub(crate) trait OptionPgUint<T: UIntType> {
+    /// Convert any `Option<PgUint>` to an `Option<[underlying integer type]>`
+    fn to_option_uint(&self) -> Option<T::Uint>;
+}

sqlx-pg-uint/src/u128.rs

@@ -96,4 +96,19 @@ mod pg_u128_tests {
         let pg_u128 = PgU128::try_from(big_decimal.clone());
         assert_eq!(pg_u128.unwrap_err(), Error::InvalidValue(big_decimal));
     }
+
+    #[test]
+    fn test_option_conversion() {
+        let somepguint = Some(PgU128::from(123u128));
+        let someuint = somepguint.to_option_uint();
+        assert_eq!(someuint, Some(123u128));
+
+        let pguint = PgU128::from(123);
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, Some(123u128));
+
+        let pguint: Option<PgU128> = None;
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, None::<u128>);
+    }
 }

sqlx-pg-uint/src/u16.rs

@@ -96,4 +96,19 @@ mod pg_u16_tests {
         let pg_u16 = PgU16::try_from(big_decimal.clone());
         assert_eq!(pg_u16.unwrap_err(), Error::InvalidValue(big_decimal));
     }
+
+    #[test]
+    fn test_option_conversion() {
+        let somepguint = Some(PgU16::from(123u16));
+        let someuint = somepguint.to_option_uint();
+        assert_eq!(someuint, Some(123u16));
+
+        let pguint = PgU16::from(123);
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, Some(123u16));
+
+        let pguint: Option<PgU16> = None;
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, None::<u16>);
+    }
 }

sqlx-pg-uint/src/u32.rs

@@ -95,4 +95,19 @@ mod pg_u32_tests {
         let pg_u32 = PgU32::try_from(big_decimal.clone());
         assert_eq!(pg_u32.unwrap_err(), Error::InvalidValue(big_decimal));
     }
+
+    #[test]
+    fn test_option_conversion() {
+        let somepguint = Some(PgU32::from(123u32));
+        let someuint = somepguint.to_option_uint();
+        assert_eq!(someuint, Some(123u32));
+
+        let pguint = PgU32::from(123);
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, Some(123u32));
+
+        let pguint: Option<PgU32> = None;
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, None::<u32>);
+    }
 }

sqlx-pg-uint/src/u64.rs

@@ -95,4 +95,19 @@ mod pg_u64_tests {
         let pg_u64 = PgU64::try_from(big_decimal.clone());
         assert_eq!(pg_u64.unwrap_err(), Error::InvalidValue(big_decimal));
     }
+
+    #[test]
+    fn test_option_conversion() {
+        let somepguint = Some(PgU64::from(123u64));
+        let someuint = somepguint.to_option_uint();
+        assert_eq!(someuint, Some(123u64));
+
+        let pguint = PgU64::from(123);
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, Some(123u64));
+
+        let pguint: Option<PgU64> = None;
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, None::<u64>);
+    }
 }

sqlx-pg-uint/src/u8.rs

@@ -96,4 +96,19 @@ mod pg_u8_tests {
         let pg_u8 = PgU8::try_from(big_decimal.clone());
         assert_eq!(pg_u8.unwrap_err(), Error::InvalidValue(big_decimal));
     }
+
+    #[test]
+    fn test_option_conversion() {
+        let somepguint = Some(PgU8::from(123u8));
+        let someuint = somepguint.to_option_uint();
+        assert_eq!(someuint, Some(123u8));
+
+        let pguint = PgU8::from(123);
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, Some(123u8));
+
+        let pguint: Option<PgU8> = None;
+        let someuint = pguint.to_option_uint();
+        assert_eq!(someuint, None::<u8>);
+    }
 }