Custom types: MariaDB UUID & INET6

[tgross35]

At long last, I think I have a working implementation for the MariaDB UUID and INET6 types, which aren't present in MySql.

What confused me for a bit was that you need two types: one that is the database's representation (derives SqlType and QueryId to actually select it), and one that is the user-facing representation (derives FromSqlRow, AsExpression). Because you can't implement these traits on foreign types like Uuid and Ipv6Addr, you need a wrapper which can deref to those types.

Still not 100% on this implementation so I'll take feedback if anyone has any suggestions.

use std::fmt::{Display, Formatter};
use std::io::Write;
use std::net::Ipv6Addr;
use std::ops::Deref;
use std::{fmt, str};

use diesel::backend::RawValue;
use diesel::deserialize::{self, FromSql, FromSqlRow};
use diesel::expression::AsExpression;
use diesel::mysql::Mysql;
use diesel::serialize::{self, IsNull, ToSql};
use diesel::sql_types::{SqlType, VarChar};
use uuid::Uuid;

#[derive(SqlType, QueryId)]
#[diesel(mysql_type(name = "String"))]
pub struct MariaUuidTy;

#[derive(Clone, Debug, PartialEq, Hash, Eq, FromSqlRow, AsExpression)]
#[diesel(sql_type = MariaUuidTy)]
pub struct MariaUuid(pub Uuid);

impl ToSql<MariaUuidTy, Mysql> for MariaUuid
where
    String: ToSql<VarChar, Mysql>,
{
    fn to_sql<'b>(&'b self, out: &mut serialize::Output<'b, '_, Mysql>) -> serialize::Result {
        let mut buf = [0u8; 32];
        let s = self.0.as_simple().encode_lower(&mut buf);
        out.write_all(s.as_bytes())?;
        Ok(IsNull::No)
    }
}

impl FromSql<MariaUuidTy, Mysql> for MariaUuid
where
    String: FromSql<VarChar, Mysql>,
{
    fn from_sql(bytes: RawValue<Mysql>) -> deserialize::Result<Self> {
        let s = str::from_utf8(bytes.as_bytes())?;
        Ok(Self(Uuid::parse_str(s)?))
    }
}

impl From<Uuid> for MariaUuid {
    fn from(value: Uuid) -> Self {
        Self(value)
    }
}

impl Deref for MariaUuid {
    type Target = Uuid;

    fn deref(&self) -> &Uuid {
        &self.0
    }
}

impl Display for MariaUuid {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

#[derive(SqlType, QueryId)]
#[diesel(mysql_type(name = "String"))]
pub struct MariaInet6Ty;

#[derive(Clone, Debug, PartialEq, Hash, Eq, FromSqlRow, AsExpression)]
#[diesel(sql_type = MariaInet6Ty)]
pub struct MariaInet6(pub Ipv6Addr);

impl ToSql<MariaInet6Ty, Mysql> for MariaInet6
where
    String: ToSql<VarChar, Mysql>,
{
    fn to_sql<'b>(&'b self, out: &mut serialize::Output<'b, '_, Mysql>) -> serialize::Result {
        write!(out, "{}", self.0)?;
        Ok(IsNull::No)
    }
}

impl FromSql<MariaInet6Ty, Mysql> for MariaInet6
where
    String: FromSql<VarChar, Mysql>,
{
    fn from_sql(bytes: RawValue<Mysql>) -> deserialize::Result<Self> {
        let buf = <String as deserialize::FromSql<VarChar, Mysql>>::from_sql(bytes)?;
        Ok(Self(buf.parse()?))
    }
}

impl From<Ipv6Addr> for MariaInet6 {
    fn from(value: Ipv6Addr) -> Self {
        Self(value)
    }
}

impl Deref for MariaInet6 {
    type Target = Ipv6Addr;

    fn deref(&self) -> &Ipv6Addr {
        &self.0
    }
}

impl Display for MariaInet6 {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

[weiznich]

This implementation looks correct.

What confused me for a bit was that you need two types: one that is the database's representation (derives SqlType and QueryId to actually select it), and one that is the user-facing representation (derives FromSqlRow, AsExpression).

That's by design. The sql type is used as compile time marker of the actual SQL type of expressions in the DSL, the rust type is used for loading/binding values. Strictly speaking there is no 1:1 mapping between these types, but a n:m mapping. One SQL type could be represented by several rust side types (see the timestamp types for example). One rust side type could be represented by several SQL side types (again see the timestamp types for examples.)

Because you can't implement these traits on foreign types like Uuid and Ipv6Addr, you need a wrapper which can deref to those types.

That's a language level restriction. It's called orphan rule and it's there to ensure that there exists exactly one possible trait impl. These rules are required to enforce that.

[tgross35]

I understand the restrictions, just pointing it out for anyone else who struggles at bit. Thank you for the review!