Tentatively moved uuid type and implemented blob-based variant for SQLite

diesel/src/pg/types/mod.rs

@@ -23,8 +23,6 @@ pub(in crate::pg) mod pg_lsn;
 mod primitives;
 mod ranges;
 mod record;
-#[cfg(feature = "uuid")]
-mod uuid;
 
 /// PostgreSQL specific SQL types
 ///
@@ -313,25 +311,6 @@ pub mod sql_types {
     #[cfg(feature = "postgres_backend")]
     pub type BigSerial = crate::sql_types::BigInt;
 
-    /// The [`UUID`] SQL type. This type can only be used with `feature = "uuid"`
-    ///
-    /// ### [`ToSql`] impls
-    ///
-    /// - [`uuid::Uuid`][Uuid]
-    ///
-    /// ### [`FromSql`] impls
-    ///
-    /// - [`uuid::Uuid`][Uuid]
-    ///
-    /// [`ToSql`]: crate::serialize::ToSql
-    /// [`FromSql`]: crate::deserialize::FromSql
-    /// [Uuid]: https://docs.rs/uuid/*/uuid/struct.Uuid.html
-    /// [`UUID`]: https://www.postgresql.org/docs/current/datatype-uuid.html
-    #[cfg(feature = "postgres_backend")]
-    #[derive(Debug, Clone, Copy, Default, QueryId, SqlType)]
-    #[diesel(postgres_type(oid = 2950, array_oid = 2951))]
-    pub struct Uuid;
-
     /// Alias for `Binary`, to ensure `diesel print-schema` works
     pub type Bytea = crate::sql_types::Binary;
 

diesel/src/sql_types/mod.rs

@@ -210,6 +210,27 @@ pub type Decimal = Numeric;
 #[diesel(mysql_type(name = "String"))]
 pub struct Text;
 
+#[cfg(feature = "uuid")]
+/// The [`UUID`] SQL type. This type can only be used with `feature = "uuid"`
+///
+/// ### [`ToSql`] impls
+///
+/// - [`uuid::Uuid`][Uuid]
+///
+/// ### [`FromSql`] impls
+///
+/// - [`uuid::Uuid`][Uuid]
+///
+/// [`ToSql`]: crate::serialize::ToSql
+/// [`FromSql`]: crate::deserialize::FromSql
+/// [Uuid]: https://docs.rs/uuid/*/uuid/struct.Uuid.html
+/// [`UUID`]: https://www.postgresql.org/docs/current/datatype-uuid.html
+#[derive(Debug, Clone, Copy, Default, QueryId, SqlType)]
+#[diesel(postgres_type(oid = 2950, array_oid = 2951))]
+#[diesel(sqlite_type(name = "Binary"))]
+#[diesel(mysql_type(name = "Blob"))]
+pub struct Uuid;
+
 /// The SQL `VARCHAR` type
 ///
 /// This type is generally interchangeable with `TEXT`, so Diesel has this as an

diesel/src/type_impls/mod.rs

@@ -12,3 +12,8 @@ mod json;
 mod option;
 mod primitives;
 pub(crate) mod tuples;
+#[cfg(all(
+    feature = "uuid",
+    any(feature = "postgres_backend", feature = "sqlite")
+))]
+mod uuid;

diesel/src/pg/types/uuid.rs → diesel/src/type_impls/uuid.rs

@@ -1,8 +1,7 @@
-use std::io::prelude::*;
+extern crate uuid;
 
 use crate::deserialize::{self, FromSql, FromSqlRow};
 use crate::expression::AsExpression;
-use crate::pg::{Pg, PgValue};
 use crate::serialize::{self, IsNull, Output, ToSql};
 use crate::sql_types::Uuid;
 
@@ -12,24 +11,41 @@ use crate::sql_types::Uuid;
 #[allow(dead_code)]
 struct UuidProxy(uuid::Uuid);
 
-#[cfg(all(feature = "postgres_backend", feature = "uuid"))]
-impl FromSql<Uuid, Pg> for uuid::Uuid {
-    fn from_sql(value: PgValue<'_>) -> deserialize::Result<Self> {
+#[cfg(feature = "postgres_backend")]
+impl FromSql<Uuid, crate::pg::Pg> for uuid::Uuid {
+    fn from_sql(value: crate::pg::PgValue<'_>) -> deserialize::Result<Self> {
         uuid::Uuid::from_slice(value.as_bytes()).map_err(Into::into)
     }
 }
 
-#[cfg(all(feature = "postgres_backend", feature = "uuid"))]
-impl ToSql<Uuid, Pg> for uuid::Uuid {
-    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
+#[cfg(feature = "postgres_backend")]
+impl ToSql<Uuid, crate::pg::Pg> for uuid::Uuid {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, crate::pg::Pg>) -> serialize::Result {
+        use std::io::Write;
         out.write_all(self.as_bytes())
             .map(|_| IsNull::No)
             .map_err(Into::into)
     }
 }
 
+#[cfg(feature = "sqlite")]
+impl ToSql<Uuid, crate::sqlite::Sqlite> for uuid::Uuid {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, crate::sqlite::Sqlite>) -> serialize::Result {
+        out.set_value(self.as_bytes().as_slice());
+        Ok(IsNull::No)
+    }
+}
+
+#[cfg(feature = "sqlite")]
+impl FromSql<Uuid, crate::sqlite::Sqlite> for uuid::Uuid {
+    fn from_sql(mut value: crate::sqlite::SqliteValue<'_, '_, '_>) -> deserialize::Result<Self> {
+        uuid::Uuid::from_slice(value.read_blob()).map_err(Into::into)
+    }
+}
+
 #[cfg(test)]
-mod tests {
+#[cfg(feature = "postgres_backend")]
+mod postgres_tests {
     use super::*;
 
     #[diesel_test_helper::test]
@@ -44,7 +60,7 @@ mod tests {
 
         let test_uuid = uuid::Uuid::from_slice(&bytes).unwrap();
         let mut bytes = Output::test(ByteWrapper(&mut buffer));
-        ToSql::<Uuid, Pg>::to_sql(&test_uuid, &mut bytes).unwrap();
+        ToSql::<Uuid, crate::pg::Pg>::to_sql(&test_uuid, &mut bytes).unwrap();
         assert_eq!(&buffer, test_uuid.as_bytes());
     }
 
@@ -55,15 +71,16 @@ mod tests {
             0x31, 0x32,
         ];
         let input_uuid = uuid::Uuid::from_slice(&bytes).unwrap();
-        let output_uuid =
-            <uuid::Uuid as FromSql<Uuid, Pg>>::from_sql(PgValue::for_test(input_uuid.as_bytes()))
-                .unwrap();
+        let output_uuid = <uuid::Uuid as FromSql<Uuid, crate::pg::Pg>>::from_sql(
+            crate::pg::PgValue::for_test(input_uuid.as_bytes()),
+        )
+        .unwrap();
         assert_eq!(input_uuid, output_uuid);
     }
 
     #[diesel_test_helper::test]
     fn bad_uuid_from_sql() {
-        let uuid = uuid::Uuid::from_sql(PgValue::for_test(b"boom"));
+        let uuid = uuid::Uuid::from_sql(crate::pg::PgValue::for_test(b"boom"));
         assert!(uuid.is_err());
         // The error message changes slightly between different
         // uuid versions, so we just check on the relevant parts