chore: use macro's

Author: joeydewaal

sqlx-core/src/encode.rs

@@ -133,34 +133,45 @@ macro_rules! impl_encode_for_option {
     };
 }
 
-impl<'q, T, DB: Database> Encode<'q, DB> for Arc<T>
-where
-    T: Encode<'q, DB>,
-{
-    #[inline]
-    fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer<'q>) -> Result<IsNull, BoxDynError> {
-        <T as Encode<DB>>::encode_by_ref(self.as_ref(), buf)
-    }
+macro_rules! impl_encode_for_smartpointer {
+    ($smart_pointer:ty) => {
+        impl<'q, T, DB: Database> Encode<'q, DB> for $smart_pointer
+        where
+            T: Encode<'q, DB>,
+        {
+            #[inline]
+            fn encode(
+                self,
+                buf: &mut <DB as Database>::ArgumentBuffer<'q>,
+            ) -> Result<IsNull, BoxDynError> {
+                <T as Encode<DB>>::encode_by_ref(self.as_ref(), buf)
+            }
 
-    #[inline]
-    fn encode_by_ref(
-        &self,
-        buf: &mut <DB as Database>::ArgumentBuffer<'q>,
-    ) -> Result<IsNull, BoxDynError> {
-        <&T as Encode<DB>>::encode(self, buf)
-    }
+            #[inline]
+            fn encode_by_ref(
+                &self,
+                buf: &mut <DB as Database>::ArgumentBuffer<'q>,
+            ) -> Result<IsNull, BoxDynError> {
+                <&T as Encode<DB>>::encode(self, buf)
+            }
 
-    #[inline]
-    fn produces(&self) -> Option<DB::TypeInfo> {
-        (**self).produces()
-    }
+            #[inline]
+            fn produces(&self) -> Option<DB::TypeInfo> {
+                (**self).produces()
+            }
 
-    #[inline]
-    fn size_hint(&self) -> usize {
-        (**self).size_hint()
-    }
+            #[inline]
+            fn size_hint(&self) -> usize {
+                (**self).size_hint()
+            }
+        }
+    };
 }
 
+impl_encode_for_smartpointer!(Arc<T>);
+impl_encode_for_smartpointer!(Box<T>);
+impl_encode_for_smartpointer!(Rc<T>);
+
 impl<'q, T, DB: Database> Encode<'q, DB> for Cow<'_, T>
 where
     T: Encode<'q, DB>,
@@ -189,59 +200,3 @@ where
         (**self).size_hint()
     }
 }
-
-impl<'q, T, DB: Database> Encode<'q, DB> for Box<T>
-where
-    T: Encode<'q, DB>,
-{
-    #[inline]
-    fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer<'q>) -> Result<IsNull, BoxDynError> {
-        <T as Encode<DB>>::encode_by_ref(self.as_ref(), buf)
-    }
-
-    #[inline]
-    fn encode_by_ref(
-        &self,
-        buf: &mut <DB as Database>::ArgumentBuffer<'q>,
-    ) -> Result<IsNull, BoxDynError> {
-        <&T as Encode<DB>>::encode(self, buf)
-    }
-
-    #[inline]
-    fn produces(&self) -> Option<DB::TypeInfo> {
-        (**self).produces()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> usize {
-        (**self).size_hint()
-    }
-}
-
-impl<'q, T, DB: Database> Encode<'q, DB> for Rc<T>
-where
-    T: Encode<'q, DB>,
-{
-    #[inline]
-    fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer<'q>) -> Result<IsNull, BoxDynError> {
-        <T as Encode<DB>>::encode_by_ref(self.as_ref(), buf)
-    }
-
-    #[inline]
-    fn encode_by_ref(
-        &self,
-        buf: &mut <DB as Database>::ArgumentBuffer<'q>,
-    ) -> Result<IsNull, BoxDynError> {
-        <&T as Encode<DB>>::encode(self, buf)
-    }
-
-    #[inline]
-    fn produces(&self) -> Option<DB::TypeInfo> {
-        (**self).produces()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> usize {
-        (**self).size_hint()
-    }
-}

sqlx-core/src/types/mod.rs

@@ -244,20 +244,28 @@ impl<T: Type<DB>, DB: Database> Type<DB> for Option<T> {
     }
 }
 
-impl<T, DB: Database> Type<DB> for Arc<T>
-where
-    T: Type<DB>,
-    T: ?Sized,
-{
-    fn type_info() -> DB::TypeInfo {
-        <T as Type<DB>>::type_info()
-    }
+macro_rules! impl_type_for_smartpointer {
+    ($smart_pointer:ty) => {
+        impl<T, DB: Database> Type<DB> for $smart_pointer
+        where
+            T: Type<DB>,
+            T: ?Sized,
+        {
+            fn type_info() -> DB::TypeInfo {
+                <T as Type<DB>>::type_info()
+            }
 
-    fn compatible(ty: &DB::TypeInfo) -> bool {
-        ty.is_null() || <T as Type<DB>>::compatible(ty)
-    }
+            fn compatible(ty: &DB::TypeInfo) -> bool {
+                <T as Type<DB>>::compatible(ty)
+            }
+        }
+    };
 }
 
+impl_type_for_smartpointer!(Arc<T>);
+impl_type_for_smartpointer!(Box<T>);
+impl_type_for_smartpointer!(Rc<T>);
+
 impl<T, DB: Database> Type<DB> for Cow<'_, T>
 where
     T: Type<DB>,
@@ -268,26 +276,6 @@ where
     }
 
     fn compatible(ty: &DB::TypeInfo) -> bool {
-        ty.is_null() || <T as Type<DB>>::compatible(ty)
-    }
-}
-
-impl<T: Type<DB>, DB: Database> Type<DB> for Box<T> {
-    fn type_info() -> DB::TypeInfo {
-        <T as Type<DB>>::type_info()
-    }
-
-    fn compatible(ty: &DB::TypeInfo) -> bool {
-        ty.is_null() || <T as Type<DB>>::compatible(ty)
-    }
-}
-
-impl<T: Type<DB>, DB: Database> Type<DB> for Rc<T> {
-    fn type_info() -> DB::TypeInfo {
-        <T as Type<DB>>::type_info()
-    }
-
-    fn compatible(ty: &DB::TypeInfo) -> bool {
-        ty.is_null() || <T as Type<DB>>::compatible(ty)
+        <T as Type<DB>>::compatible(ty)
     }
 }

sqlx-postgres/src/types/str.rs

@@ -34,16 +34,6 @@ impl Type<Postgres> for Cow<'_, str> {
     }
 }
 
-impl Type<Postgres> for Box<str> {
-    fn type_info() -> PgTypeInfo {
-        <&str as Type<Postgres>>::type_info()
-    }
-
-    fn compatible(ty: &PgTypeInfo) -> bool {
-        <&str as Type<Postgres>>::compatible(ty)
-    }
-}
-
 impl Type<Postgres> for String {
     fn type_info() -> PgTypeInfo {
         <&str as Type<Postgres>>::type_info()

tests/postgres/types.rs

@@ -683,11 +683,12 @@ async fn test_arc() -> anyhow::Result<()> {
     let user_age: (Arc<i32>, Cow<'static, i32>, Box<i32>, i32) =
         sqlx::query_as("SELECT $1, $2, $3, $4")
             .bind(Arc::new(1i32))
-            .bind(Cow::<'_, i32>::Owned(2i32))
+            .bind(Cow::<'_, i32>::Borrowed(&2i32))
             .bind(Box::new(3i32))
             .bind(Rc::new(4i32))
             .fetch_one(&mut conn)
             .await?;
+
     assert!(user_age.0.as_ref() == &1);
     assert!(user_age.1.as_ref() == &2);
     assert!(user_age.2.as_ref() == &3);