feat: implement Encode, Decode, Type for Arc<str> and Arc<[u8]>

sqlx-core/src/decode.rs

@@ -1,5 +1,8 @@
 //! Provides [`Decode`] for decoding values from the database.
 
+use std::borrow::Cow;
+use std::sync::Arc;
+
 use crate::database::Database;
 use crate::error::BoxDynError;
 
@@ -77,3 +80,37 @@ where
         }
     }
 }
+
+// implement `Decode` for Arc<T> for all SQL types
+impl<'r, DB, T> Decode<'r, DB> for Arc<T>
+where
+    DB: Database,
+    T: Decode<'r, DB>,
+{
+    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+        Ok(Arc::new(T::decode(value)?))
+    }
+}
+
+// implement `Decode` for Cow<T> for all SQL types
+impl<'r, DB, T> Decode<'r, DB> for Cow<'_, T>
+where
+    DB: Database,
+    T: Decode<'r, DB>,
+    T: ToOwned<Owned = T>,
+{
+    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+        Ok(Cow::Owned(T::decode(value)?))
+    }
+}
+
+// implement `Decode` for Box<T> for all SQL types
+impl<'r, DB, T> Decode<'r, DB> for Box<T>
+where
+    DB: Database,
+    T: Decode<'r, DB>,
+{
+    fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError> {
+        Ok(Box::new(T::decode(value)?))
+    }
+}

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,116 @@ 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)
+    }
+
+    #[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 Cow<'_, T>
+where
+    T: Encode<'q, DB>,
+    T: ToOwned<Owned = T>,
+{
+    #[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 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

@@ -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;
 
@@ -238,3 +240,51 @@ impl<T: Type<DB>, DB: Database> Type<DB> for Option<T> {
         ty.is_null() || <T as Type<DB>>::compatible(ty)
     }
 }
+
+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()
+    }
+
+    fn compatible(ty: &DB::TypeInfo) -> bool {
+        ty.is_null() || <T as Type<DB>>::compatible(ty)
+    }
+}
+
+impl<T, DB: Database> Type<DB> for Cow<'_, T>
+where
+    T: Type<DB>,
+    T: ToOwned<Owned = 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 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)
+    }
+}

sqlx-mysql/src/types/bytes.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -83,3 +85,15 @@ impl Decode<'_, MySql> for Vec<u8> {
         <&[u8] as Decode<MySql>>::decode(value).map(ToOwned::to_owned)
     }
 }
+
+impl Encode<'_, MySql> for Arc<[u8]> {
+    fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
+        <&[u8] as Encode<MySql>>::encode(&**self, buf)
+    }
+}
+
+impl Decode<'_, MySql> for Arc<[u8]> {
+    fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
+        <&[u8] as Decode<MySql>>::decode(value).map(Into::into)
+    }
+}

sqlx-mysql/src/types/str.rs

@@ -6,6 +6,7 @@ use crate::protocol::text::{ColumnFlags, ColumnType};
 use crate::types::Type;
 use crate::{MySql, MySqlTypeInfo, MySqlValueRef};
 use std::borrow::Cow;
+use std::sync::Arc;
 
 impl Type<MySql> for str {
     fn type_info() -> MySqlTypeInfo {
@@ -114,3 +115,15 @@ impl<'r> Decode<'r, MySql> for Cow<'r, str> {
         value.as_str().map(Cow::Borrowed)
     }
 }
+
+impl Encode<'_, MySql> for Arc<str> {
+    fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
+        <&str as Encode<MySql>>::encode(&**self, buf)
+    }
+}
+
+impl Decode<'_, MySql> for Arc<str> {
+    fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
+        <&str as Decode<MySql>>::decode(value).map(Into::into)
+    }
+}

sqlx-postgres/src/types/array.rs

@@ -1,6 +1,7 @@
 use sqlx_core::bytes::Buf;
 use sqlx_core::types::Text;
 use std::borrow::Cow;
+use std::sync::Arc;
 
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
@@ -192,6 +193,17 @@ where
     }
 }
 
+impl<'q, T> Encode<'q, Postgres> for Arc<[T]>
+where
+    for<'a> &'a [T]: Encode<'q, Postgres>,
+    T: Encode<'q, Postgres>,
+{
+    #[inline]
+    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
+        <&[T] as Encode<Postgres>>::encode_by_ref(&self.as_ref(), buf)
+    }
+}
+
 impl<'r, T, const N: usize> Decode<'r, Postgres> for [T; N]
 where
     T: for<'a> Decode<'a, Postgres> + Type<Postgres>,
@@ -354,3 +366,12 @@ where
         }
     }
 }
+
+impl<'r, T> Decode<'r, Postgres> for Arc<[T]>
+where
+    T: for<'a> Decode<'a, Postgres> + Type<Postgres>,
+{
+    fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
+        <Vec<T> as Decode<Postgres>>::decode(value).map(Into::into)
+    }
+}

sqlx-postgres/src/types/bytes.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
 use crate::error::BoxDynError;
@@ -28,6 +30,12 @@ impl PgHasArrayType for Vec<u8> {
     }
 }
 
+impl PgHasArrayType for Arc<[u8]> {
+    fn array_type_info() -> PgTypeInfo {
+        <[&[u8]] as Type<Postgres>>::type_info()
+    }
+}
+
 impl<const N: usize> PgHasArrayType for [u8; N] {
     fn array_type_info() -> PgTypeInfo {
         <[&[u8]] as Type<Postgres>>::type_info()
@@ -60,6 +68,12 @@ impl<const N: usize> Encode<'_, Postgres> for [u8; N] {
     }
 }
 
+impl Encode<'_, Postgres> for Arc<[u8]> {
+    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
+        <&[u8] as Encode<Postgres>>::encode(self, buf)
+    }
+}
+
 impl<'r> Decode<'r, Postgres> for &'r [u8] {
     fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
         match value.format() {
@@ -110,3 +124,12 @@ impl<const N: usize> Decode<'_, Postgres> for [u8; N] {
         Ok(bytes)
     }
 }
+
+impl Decode<'_, Postgres> for Arc<[u8]> {
+    fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
+        Ok(match value.format() {
+            PgValueFormat::Binary => value.as_bytes()?.into(),
+            PgValueFormat::Text => hex::decode(text_hex_decode_input(value)?)?.into(),
+        })
+    }
+}