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

Author: joeydewaal

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;
@@ -73,3 +75,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 {
@@ -94,3 +95,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(),
+        })
+    }
+}

sqlx-postgres/src/types/str.rs

@@ -5,6 +5,7 @@ use crate::types::array_compatible;
 use crate::types::Type;
 use crate::{PgArgumentBuffer, PgHasArrayType, PgTypeInfo, PgValueRef, Postgres};
 use std::borrow::Cow;
+use std::sync::Arc;
 
 impl Type<Postgres> for str {
     fn type_info() -> PgTypeInfo {
@@ -74,6 +75,16 @@ impl PgHasArrayType for String {
     }
 }
 
+impl PgHasArrayType for Arc<str> {
+    fn array_type_info() -> PgTypeInfo {
+        <&str as PgHasArrayType>::array_type_info()
+    }
+
+    fn array_compatible(ty: &PgTypeInfo) -> bool {
+        <&str as PgHasArrayType>::array_compatible(ty)
+    }
+}
+
 impl Encode<'_, Postgres> for &'_ str {
     fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
         buf.extend(self.as_bytes());
@@ -103,6 +114,12 @@ impl Encode<'_, Postgres> for String {
     }
 }
 
+impl Encode<'_, Postgres> for Arc<str> {
+    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
+        <&str as Encode<Postgres>>::encode(&**self, buf)
+    }
+}
+
 impl<'r> Decode<'r, Postgres> for &'r str {
     fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
         value.as_str()
@@ -126,3 +143,9 @@ impl Decode<'_, Postgres> for String {
         Ok(value.as_str()?.to_owned())
     }
 }
+
+impl Decode<'_, Postgres> for Arc<str> {
+    fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
+        Ok(value.as_str()?.into())
+    }
+}

sqlx-sqlite/src/types/bytes.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::sync::Arc;
 
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
@@ -91,3 +92,26 @@ impl<'r> Decode<'r, Sqlite> for Vec<u8> {
         Ok(value.blob().to_owned())
     }
 }
+
+impl<'q> Encode<'q, Sqlite> for Arc<[u8]> {
+    fn encode(self, args: &mut Vec<SqliteArgumentValue<'q>>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(Cow::Owned(self.to_vec())));
+
+        Ok(IsNull::No)
+    }
+
+    fn encode_by_ref(
+        &self,
+        args: &mut Vec<SqliteArgumentValue<'q>>,
+    ) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Blob(Cow::Owned(self.to_vec())));
+
+        Ok(IsNull::No)
+    }
+}
+
+impl<'r> Decode<'r, Sqlite> for Arc<[u8]> {
+    fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
+        Ok(value.blob().into())
+    }
+}

sqlx-sqlite/src/types/str.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::sync::Arc;
 
 use crate::decode::Decode;
 use crate::encode::{Encode, IsNull};
@@ -106,3 +107,26 @@ impl<'r> Decode<'r, Sqlite> for Cow<'r, str> {
         value.text().map(Cow::Borrowed)
     }
 }
+
+impl<'q> Encode<'q, Sqlite> for Arc<str> {
+    fn encode(self, args: &mut Vec<SqliteArgumentValue<'q>>) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Text(Cow::Owned(self.to_string())));
+
+        Ok(IsNull::No)
+    }
+
+    fn encode_by_ref(
+        &self,
+        args: &mut Vec<SqliteArgumentValue<'q>>,
+    ) -> Result<IsNull, BoxDynError> {
+        args.push(SqliteArgumentValue::Text(Cow::Owned(self.to_string())));
+
+        Ok(IsNull::No)
+    }
+}
+
+impl<'r> Decode<'r, Sqlite> for Arc<str> {
+    fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
+        value.text().map(Into::into)
+    }
+}

tests/mysql/types.rs

@@ -3,6 +3,7 @@ extern crate time_ as time;
 use std::net::SocketAddr;
 #[cfg(feature = "rust_decimal")]
 use std::str::FromStr;
+use std::sync::Arc;
 
 use sqlx::mysql::MySql;
 use sqlx::{Executor, Row};
@@ -384,3 +385,33 @@ CREATE TEMPORARY TABLE user_login (
 
     Ok(())
 }
+
+#[sqlx_macros::test]
+async fn test_arc_str() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let name: Arc<str> = "Harold".into();
+
+    let username: Arc<str> = sqlx::query_scalar("SELECT ? AS username")
+        .bind(&name)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(username == name);
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_arc_slice() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let name: Arc<[u8]> = [5, 0].into();
+
+    let username: Arc<[u8]> = sqlx::query_scalar("SELECT ?")
+        .bind(&name)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(username == name);
+    Ok(())
+}

tests/postgres/types.rs

@@ -8,6 +8,7 @@ use std::sync::Arc;
 
 use sqlx::postgres::types::{Oid, PgCiText, PgInterval, PgMoney, PgRange};
 use sqlx::postgres::Postgres;
+use sqlx_macros::FromRow;
 use sqlx_test::{new, test_decode_type, test_prepared_type, test_type};
 
 use sqlx_core::executor::Executor;
@@ -701,3 +702,20 @@ async fn test_arc() -> anyhow::Result<()> {
     assert!(user_age.3 == 4);
     Ok(())
 }
+
+#[sqlx_macros::test]
+async fn test_arc_slice_2() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    #[derive(FromRow)]
+    struct Nested {
+        inner: Arc<[i32]>,
+    }
+
+    let username: Nested = sqlx::query_as("SELECT ARRAY[1, 2, 3]::INT4[] as inner")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(username.inner.as_ref() == &[1, 2, 3]);
+    Ok(())
+}

tests/sqlite/types.rs

@@ -7,6 +7,7 @@ use sqlx_core::types::Text;
 use sqlx_test::new;
 use sqlx_test::test_type;
 use std::net::SocketAddr;
+use std::sync::Arc;
 
 test_type!(null<Option<i32>>(Sqlite,
     "NULL" == None::<i32>
@@ -250,3 +251,33 @@ CREATE TEMPORARY TABLE user_login (
 
     Ok(())
 }
+
+#[sqlx_macros::test]
+async fn test_arc_str() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+
+    let name: Arc<str> = "Harold".into();
+
+    let username: Arc<str> = sqlx::query_scalar("SELECT $1 AS username")
+        .bind(&name)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(username == name);
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_arc_slice() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+
+    let name: Arc<[u8]> = [5, 0].into();
+
+    let username: Arc<[u8]> = sqlx::query_scalar("SELECT $1")
+        .bind(&name)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(username == name);
+    Ok(())
+}