diff --git a/sqlx-core/src/decode.rs b/sqlx-core/src/decode.rs
index 3249c349cc..e980b3e189 100644
--- a/sqlx-core/src/decode.rs
+++ b/sqlx-core/src/decode.rs
@@ -1,5 +1,9 @@
 //! Provides [`Decode`] for decoding values from the database.
 
+use std::borrow::Cow;
+use std::rc::Rc;
+use std::sync::Arc;
+
 use crate::database::Database;
 use crate::error::BoxDynError;
 
@@ -77,3 +81,78 @@ where
         }
     }
 }
+
+macro_rules! impl_decode_for_smartpointer {
+    ($smart_pointer:tt) => {
+        impl<'r, DB, T> Decode<'r, DB> for $smart_pointer<T>
+        where
+            DB: Database,
+            T: Decode<'r, DB>,
+        {
+            fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+                Ok(Self::new(T::decode(value)?))
+            }
+        }
+
+        impl<'r, DB> Decode<'r, DB> for $smart_pointer<str>
+        where
+            DB: Database,
+            &'r str: Decode<'r, DB>,
+        {
+            fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+                let ref_str = <&str as Decode<DB>>::decode(value)?;
+                Ok(ref_str.into())
+            }
+        }
+
+        impl<'r, DB> Decode<'r, DB> for $smart_pointer<[u8]>
+        where
+            DB: Database,
+            Vec<u8>: Decode<'r, DB>,
+        {
+            fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+                // The `Postgres` implementation requires this to be decoded as an owned value because
+                // bytes can be sent in text format.
+                let bytes = <Vec<u8> as Decode<DB>>::decode(value)?;
+                Ok(bytes.into())
+            }
+        }
+    };
+}
+
+impl_decode_for_smartpointer!(Arc);
+impl_decode_for_smartpointer!(Box);
+impl_decode_for_smartpointer!(Rc);
+
+// implement `Decode` for Cow<T> for all SQL types
+impl<'r, 'a, DB, T> Decode<'r, DB> for Cow<'a, T>
+where
+    DB: Database,
+    // `ToOwned` is required here to satisfy `Cow`
+    T: ToOwned,
+    <T as ToOwned>::Owned: Decode<'r, DB>,
+{
+    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+        <<T as ToOwned>::Owned as Decode<DB>>::decode(value).map(Cow::Owned)
+    }
+}
+
+impl<'r, 'a, DB> Decode<'r, DB> for Cow<'a, str>
+where
+    DB: Database,
+    String: Decode<'r, DB>,
+{
+    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+        <String as Decode<DB>>::decode(value).map(Cow::Owned)
+    }
+}
+
+impl<'r, 'a, DB> Decode<'r, DB> for Cow<'a, [u8]>
+where
+    DB: Database,
+    Vec<u8>: Decode<'r, DB>,
+{
+    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+        <Vec<u8> as Decode<DB>>::decode(value).map(Cow::Owned)
+    }
+}
diff --git a/sqlx-core/src/encode.rs b/sqlx-core/src/encode.rs
index 2d28641f94..1a149b6e87 100644
--- a/sqlx-core/src/encode.rs
+++ b/sqlx-core/src/encode.rs
@@ -1,6 +1,9 @@
 //! Provides [`Encode`] for encoding values for the database.
 
+use std::borrow::Cow;
 use std::mem;
+use std::rc::Rc;
+use std::sync::Arc;
 
 use crate::database::Database;
 use crate::error::BoxDynError;
@@ -129,3 +132,71 @@ macro_rules! impl_encode_for_option {
         }
     };
 }
+
+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 produces(&self) -> Option<DB::TypeInfo> {
+                (**self).produces()
+            }
+
+            #[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<'q, T>
+where
+    T: Encode<'q, DB>,
+    T: ToOwned,
+{
+    #[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_by_ref(&self.as_ref(), buf)
+    }
+
+    #[inline]
+    fn produces(&self) -> Option<DB::TypeInfo> {
+        <&T as Encode<DB>>::produces(&self.as_ref())
+    }
+
+    #[inline]
+    fn size_hint(&self) -> usize {
+        <&T as Encode<DB>>::size_hint(&self.as_ref())
+    }
+}
diff --git a/sqlx-core/src/types/mod.rs b/sqlx-core/src/types/mod.rs
index b00427daae..f6ac3ac74d 100644
--- a/sqlx-core/src/types/mod.rs
+++ b/sqlx-core/src/types/mod.rs
@@ -17,6 +17,8 @@
 //! To represent nullable SQL types, `Option<T>` is supported where `T` implements `Type`.
 //! An `Option<T>` represents a potentially `NULL` value from SQL.
 
+use std::{borrow::Cow, rc::Rc, sync::Arc};
+
 use crate::database::Database;
 use crate::type_info::TypeInfo;
 
@@ -248,3 +250,38 @@ impl<T: Type<DB>, DB: Database> Type<DB> for Option<T> {
         ty.is_null() || <T as Type<DB>>::compatible(ty)
     }
 }
+
+macro_rules! impl_type_for_smartpointer {
+    ($smart_pointer:ty) => {
+        impl<T, DB: Database> Type<DB> for $smart_pointer
+        where
+            T: Type<DB> + ?Sized,
+        {
+            fn type_info() -> DB::TypeInfo {
+                <T as Type<DB>>::type_info()
+            }
+
+            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
+    // `ToOwned` is required here to satisfy `Cow`
+    T: Type<DB> + ToOwned + ?Sized,
+{
+    fn type_info() -> DB::TypeInfo {
+        <T as Type<DB>>::type_info()
+    }
+
+    fn compatible(ty: &DB::TypeInfo) -> bool {
+        <T as Type<DB>>::compatible(ty)
+    }
+}
diff --git a/sqlx-mysql/src/types/bytes.rs b/sqlx-mysql/src/types/bytes.rs
index ade079ad4e..023a8ee87a 100644
--- a/sqlx-mysql/src/types/bytes.rs
+++ b/sqlx-mysql/src/types/bytes.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -40,28 +42,12 @@ impl<'r> Decode<'r, MySql> for &'r [u8] {
     }
 }
 
-impl Type<MySql> for Box<[u8]> {
-    fn type_info() -> MySqlTypeInfo {
-        <&[u8] as Type<MySql>>::type_info()
-    }
-
-    fn compatible(ty: &MySqlTypeInfo) -> bool {
-        <&[u8] as Type<MySql>>::compatible(ty)
-    }
-}
-
 impl Encode<'_, MySql> for Box<[u8]> {
     fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
         <&[u8] as Encode<MySql>>::encode(self.as_ref(), buf)
     }
 }
 
-impl<'r> Decode<'r, MySql> for Box<[u8]> {
-    fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
-        <&[u8] as Decode<MySql>>::decode(value).map(Box::from)
-    }
-}
-
 impl Type<MySql> for Vec<u8> {
     fn type_info() -> MySqlTypeInfo {
         <[u8] as Type<MySql>>::type_info()
@@ -83,3 +69,9 @@ impl Decode<'_, MySql> for Vec<u8> {
         <&[u8] as Decode<MySql>>::decode(value).map(ToOwned::to_owned)
     }
 }
+
+impl Encode<'_, MySql> for Cow<'_, [u8]> {
+    fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
+        <&[u8] as Encode<MySql>>::encode(self.as_ref(), buf)
+    }
+}
diff --git a/sqlx-mysql/src/types/str.rs b/sqlx-mysql/src/types/str.rs
index 8233e90893..4e2730577a 100644
--- a/sqlx-mysql/src/types/str.rs
+++ b/sqlx-mysql/src/types/str.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -5,7 +7,6 @@ use crate::io::MySqlBufMutExt;
 use crate::protocol::text::{ColumnFlags, ColumnType};
 use crate::types::Type;
 use crate::{MySql, MySqlTypeInfo, MySqlValueRef};
-use std::borrow::Cow;
 
 impl Type<MySql> for str {
     fn type_info() -> MySqlTypeInfo {
@@ -46,28 +47,12 @@ impl<'r> Decode<'r, MySql> for &'r str {
     }
 }
 
-impl Type<MySql> for Box<str> {
-    fn type_info() -> MySqlTypeInfo {
-        <&str as Type<MySql>>::type_info()
-    }
-
-    fn compatible(ty: &MySqlTypeInfo) -> bool {
-        <&str as Type<MySql>>::compatible(ty)
-    }
-}
-
 impl Encode<'_, MySql> for Box<str> {
     fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
         <&str as Encode<MySql>>::encode(&**self, buf)
     }
 }
 
-impl<'r> Decode<'r, MySql> for Box<str> {
-    fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
-        <&str as Decode<MySql>>::decode(value).map(Box::from)
-    }
-}
-
 impl Type<MySql> for String {
     fn type_info() -> MySqlTypeInfo {
         <str as Type<MySql>>::type_info()
@@ -90,16 +75,6 @@ impl Decode<'_, MySql> for String {
     }
 }
 
-impl Type<MySql> for Cow<'_, str> {
-    fn type_info() -> MySqlTypeInfo {
-        <&str as Type<MySql>>::type_info()
-    }
-
-    fn compatible(ty: &MySqlTypeInfo) -> bool {
-        <&str as Type<MySql>>::compatible(ty)
-    }
-}
-
 impl Encode<'_, MySql> for Cow<'_, str> {
     fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
         match self {
@@ -108,9 +83,3 @@ impl Encode<'_, MySql> for Cow<'_, str> {
         }
     }
 }
-
-impl<'r> Decode<'r, MySql> for Cow<'r, str> {
-    fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
-        value.as_str().map(Cow::Borrowed)
-    }
-}
diff --git a/sqlx-postgres/src/types/bytes.rs b/sqlx-postgres/src/types/bytes.rs
index 45968837af..17b7ce9a3f 100644
--- a/sqlx-postgres/src/types/bytes.rs
+++ b/sqlx-postgres/src/types/bytes.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -80,15 +82,6 @@ fn text_hex_decode_input(value: PgValueRef<'_>) -> Result<&[u8], BoxDynError> {
         .map_err(Into::into)
 }
 
-impl Decode<'_, Postgres> for Box<[u8]> {
-    fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
-        Ok(match value.format() {
-            PgValueFormat::Binary => Box::from(value.as_bytes()?),
-            PgValueFormat::Text => Box::from(hex::decode(text_hex_decode_input(value)?)?),
-        })
-    }
-}
-
 impl Decode<'_, Postgres> for Vec<u8> {
     fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
         Ok(match value.format() {
@@ -110,3 +103,9 @@ impl<const N: usize> Decode<'_, Postgres> for [u8; N] {
         Ok(bytes)
     }
 }
+
+impl Encode<'_, Postgres> for Cow<'_, [u8]> {
+    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
+        <&[u8] as Encode<Postgres>>::encode(self.as_ref(), buf)
+    }
+}
diff --git a/sqlx-postgres/src/types/str.rs b/sqlx-postgres/src/types/str.rs
index ca7e20a558..8b9c33ef47 100644
--- a/sqlx-postgres/src/types/str.rs
+++ b/sqlx-postgres/src/types/str.rs
@@ -24,26 +24,6 @@ impl Type<Postgres> for str {
     }
 }
 
-impl Type<Postgres> for Cow<'_, 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 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()
@@ -129,18 +109,6 @@ impl<'r> Decode<'r, Postgres> for &'r str {
     }
 }
 
-impl<'r> Decode<'r, Postgres> for Cow<'r, str> {
-    fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
-        Ok(Cow::Borrowed(value.as_str()?))
-    }
-}
-
-impl<'r> Decode<'r, Postgres> for Box<str> {
-    fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
-        Ok(Box::from(value.as_str()?))
-    }
-}
-
 impl Decode<'_, Postgres> for String {
     fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
         Ok(value.as_str()?.to_owned())
diff --git a/sqlx-sqlite/src/types/bytes.rs b/sqlx-sqlite/src/types/bytes.rs
index f854b911c5..48dffe0ae5 100644
--- a/sqlx-sqlite/src/types/bytes.rs
+++ b/sqlx-sqlite/src/types/bytes.rs
@@ -34,16 +34,6 @@ impl<'r> Decode<'r, Sqlite> for &'r [u8] {
     }
 }
 
-impl Type<Sqlite> for Box<[u8]> {
-    fn type_info() -> SqliteTypeInfo {
-        <&[u8] as Type<Sqlite>>::type_info()
-    }
-
-    fn compatible(ty: &SqliteTypeInfo) -> bool {
-        <&[u8] as Type<Sqlite>>::compatible(ty)
-    }
-}
-
 impl Encode<'_, Sqlite> for Box<[u8]> {
     fn encode(self, args: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
         args.push(SqliteArgumentValue::Blob(Cow::Owned(self.into_vec())));
@@ -63,12 +53,6 @@ impl Encode<'_, Sqlite> for Box<[u8]> {
     }
 }
 
-impl Decode<'_, Sqlite> for Box<[u8]> {
-    fn decode(value: SqliteValueRef<'_>) -> Result<Self, BoxDynError> {
-        Ok(Box::from(value.blob()))
-    }
-}
-
 impl Type<Sqlite> for Vec<u8> {
     fn type_info() -> SqliteTypeInfo {
         <&[u8] as Type<Sqlite>>::type_info()
@@ -101,3 +85,20 @@ impl<'r> Decode<'r, Sqlite> for Vec<u8> {
         Ok(value.blob().to_owned())
     }
 }
+
+impl<'q> Encode<'q, Sqlite> for Cow<'q, [u8]> {
+    fn encode(self, args: &mut Vec<SqliteArgumentValue<'q>>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self));
+
+        Ok(IsNull::No)
+    }
+
+    fn encode_by_ref(
+        &self,
+        args: &mut Vec<SqliteArgumentValue<'q>>,
+    ) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(self.clone()));
+
+        Ok(IsNull::No)
+    }
+}
diff --git a/sqlx-sqlite/src/types/str.rs b/sqlx-sqlite/src/types/str.rs
index bfaffae78e..6c51fa1aff 100644
--- a/sqlx-sqlite/src/types/str.rs
+++ b/sqlx-sqlite/src/types/str.rs
@@ -30,12 +30,6 @@ impl<'r> Decode<'r, Sqlite> for &'r str {
     }
 }
 
-impl Type<Sqlite> for Box<str> {
-    fn type_info() -> SqliteTypeInfo {
-        <&str as Type<Sqlite>>::type_info()
-    }
-}
-
 impl Encode<'_, Sqlite> for Box<str> {
     fn encode(self, args: &mut Vec<SqliteArgumentValue<'_>>) -> Result<IsNull, BoxDynError> {
         args.push(SqliteArgumentValue::Text(Cow::Owned(self.into_string())));
@@ -55,12 +49,6 @@ impl Encode<'_, Sqlite> for Box<str> {
     }
 }
 
-impl Decode<'_, Sqlite> for Box<str> {
-    fn decode(value: SqliteValueRef<'_>) -> Result<Self, BoxDynError> {
-        value.text().map(Box::from)
-    }
-}
-
 impl Type<Sqlite> for String {
     fn type_info() -> SqliteTypeInfo {
         <&str as Type<Sqlite>>::type_info()
@@ -90,16 +78,6 @@ impl<'r> Decode<'r, Sqlite> for String {
     }
 }
 
-impl Type<Sqlite> for Cow<'_, str> {
-    fn type_info() -> SqliteTypeInfo {
-        <&str as Type<Sqlite>>::type_info()
-    }
-
-    fn compatible(ty: &SqliteTypeInfo) -> bool {
-        <&str as Type<Sqlite>>::compatible(ty)
-    }
-}
-
 impl<'q> Encode<'q, Sqlite> for Cow<'q, str> {
     fn encode(self, args: &mut Vec<SqliteArgumentValue<'q>>) -> Result<IsNull, BoxDynError> {
         args.push(SqliteArgumentValue::Text(self));
@@ -116,9 +94,3 @@ impl<'q> Encode<'q, Sqlite> for Cow<'q, str> {
         Ok(IsNull::No)
     }
 }
-
-impl<'r> Decode<'r, Sqlite> for Cow<'r, str> {
-    fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
-        value.text().map(Cow::Borrowed)
-    }
-}
diff --git a/tests/mysql/types.rs b/tests/mysql/types.rs
index e837a53f75..f323eb7cbc 100644
--- a/tests/mysql/types.rs
+++ b/tests/mysql/types.rs
@@ -1,18 +1,21 @@
 extern crate time_ as time;
 
+use std::borrow::Cow;
 use std::net::SocketAddr;
+use std::rc::Rc;
 #[cfg(feature = "rust_decimal")]
 use std::str::FromStr;
+use std::sync::Arc;
 
 use sqlx::mysql::MySql;
-use sqlx::{Executor, Row};
+use sqlx::{Executor, FromRow, Row};
 
 use sqlx::types::Text;
 
 use sqlx::mysql::types::MySqlTime;
 use sqlx_mysql::types::MySqlTimeSign;
 
-use sqlx_test::{new, test_type};
+use sqlx_test::{new, test_prepared_type, test_type};
 
 test_type!(bool(MySql, "false" == false, "true" == true));
 
@@ -300,6 +303,17 @@ mod json_tests {
     ));
 }
 
+test_type!(test_arc<Arc<i32>>(MySql, "1" == Arc::new(1i32)));
+test_type!(test_cow<Cow<'_, i32>>(MySql, "1" == Cow::<i32>::Owned(1i32)));
+test_type!(test_box<Box<i32>>(MySql, "1" == Box::new(1i32)));
+test_type!(test_rc<Rc<i32>>(MySql, "1" == Rc::new(1i32)));
+
+test_type!(test_box_str<Box<str>>(MySql, "'John'" == Box::<str>::from("John")));
+test_type!(test_cow_str<Cow<'_, str>>(MySql, "'Phil'" == Cow::<'static, str>::from("Phil")));
+
+test_prepared_type!(test_box_slice<Box<[u8]>>(MySql, "X'01020304'" == Box::<[u8]>::from([1,2,3,4])));
+test_prepared_type!(test_cow_slice<Cow<'_, [u8]>>(MySql, "X'01020304'" == Cow::<'static, [u8]>::from(&[1,2,3,4])));
+
 #[sqlx_macros::test]
 async fn test_bits() -> anyhow::Result<()> {
     let mut conn = new::<MySql>().await?;
diff --git a/tests/postgres/types.rs b/tests/postgres/types.rs
index d5d34bc1b3..569fe585e1 100644
--- a/tests/postgres/types.rs
+++ b/tests/postgres/types.rs
@@ -1,8 +1,11 @@
 extern crate time_ as time;
 
+use std::borrow::Cow;
 use std::net::SocketAddr;
 use std::ops::Bound;
+use std::rc::Rc;
 use std::str::FromStr;
+use std::sync::Arc;
 
 use sqlx::postgres::types::{Oid, PgCiText, PgInterval, PgMoney, PgRange};
 use sqlx::postgres::Postgres;
@@ -694,6 +697,17 @@ test_type!(ltree_vec<Vec<sqlx::postgres::types::PgLTree>>(Postgres,
         ]
 ));
 
+test_type!(test_arc<Arc<i32>>(Postgres, "1::INT4" == Arc::new(1i32)));
+test_type!(test_cow<Cow<'_, i32>>(Postgres, "1::INT4" == Cow::<i32>::Owned(1i32)));
+test_type!(test_box<Box<i32>>(Postgres, "1::INT4" == Box::new(1i32)));
+test_type!(test_rc<Rc<i32>>(Postgres, "1::INT4" == Rc::new(1i32)));
+
+test_type!(test_box_str<Box<str>>(Postgres, "'John'::TEXT" == Box::<str>::from("John")));
+test_type!(test_cow_str<Cow<'_, str>>(Postgres, "'Phil'::TEXT" == Cow::<'static, str>::from("Phil")));
+
+test_prepared_type!(test_box_slice<Box<[u8]>>(Postgres, "'\\x01020304'::BYTEA" == Box::<[u8]>::from([1,2,3,4])));
+test_prepared_type!(test_cow_slice<Cow<'_, [u8]>>(Postgres, "'\\x01020304'::BYTEA" == Cow::<'static, [u8]>::from(&[1,2,3,4])));
+
 #[sqlx_macros::test]
 async fn test_text_adapter() -> anyhow::Result<()> {
     #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
diff --git a/tests/sqlite/types.rs b/tests/sqlite/types.rs
index 2497e406cc..ddc2969705 100644
--- a/tests/sqlite/types.rs
+++ b/tests/sqlite/types.rs
@@ -1,12 +1,16 @@
 extern crate time_ as time;
 
 use sqlx::sqlite::{Sqlite, SqliteRow};
+use sqlx::{FromRow, Type};
 use sqlx_core::executor::Executor;
 use sqlx_core::row::Row;
 use sqlx_core::types::Text;
 use sqlx_test::new;
 use sqlx_test::test_type;
+use std::borrow::Cow;
 use std::net::SocketAddr;
+use std::rc::Rc;
+use std::sync::Arc;
 
 test_type!(null<Option<i32>>(Sqlite,
     "NULL" == None::<i32>
@@ -208,6 +212,17 @@ test_type!(uuid_simple<sqlx::types::uuid::fmt::Simple>(Sqlite,
         == sqlx::types::Uuid::parse_str("00000000000000000000000000000000").unwrap().simple()
 ));
 
+test_type!(test_arc<Arc<i32>>(Sqlite, "1" == Arc::new(1i32)));
+test_type!(test_cow<Cow<'_, i32>>(Sqlite, "1" == Cow::<i32>::Owned(1i32)));
+test_type!(test_box<Box<i32>>(Sqlite, "1" == Box::new(1i32)));
+test_type!(test_rc<Rc<i32>>(Sqlite, "1" == Rc::new(1i32)));
+
+test_type!(test_box_str<Box<str>>(Sqlite, "'John'" == Box::<str>::from("John")));
+test_type!(test_cow_str<Cow<'_, str>>(Sqlite, "'Phil'" == Cow::<'static, str>::from("Phil")));
+
+test_type!(test_box_slice<Box<[u8]>>(Sqlite, "X'01020304'" == Box::<[u8]>::from([1,2,3,4])));
+test_type!(test_cow_slice<Cow<'_, [u8]>>(Sqlite, "X'01020304'" == Cow::<'static, [u8]>::from(&[1,2,3,4])));
+
 #[sqlx_macros::test]
 async fn test_text_adapter() -> anyhow::Result<()> {
     #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
@@ -250,3 +265,23 @@ CREATE TEMPORARY TABLE user_login (
 
     Ok(())
 }
+
+#[sqlx_macros::test]
+async fn it_binds_with_borrowed_data() -> anyhow::Result<()> {
+    #[derive(Debug, Type, Clone)]
+    #[sqlx(rename_all = "lowercase")]
+    enum Status {
+        New,
+        Open,
+        Closed,
+    }
+
+    let owned = Status::New;
+
+    let mut conn = new::<Sqlite>().await?;
+    sqlx::query("select ?")
+        .bind(Cow::Borrowed(&owned))
+        .fetch_one(&mut conn)
+        .await?;
+    Ok(())
+}