具有自定义包装类型的Diesel

use diesel::backend::Backend;
use diesel::deserialize::{self, FromSql};
use diesel::serialize::{self, IsNull, Output, ToSql};
use diesel::sql_types::Text;
use std::io::Write;
use std::str::FromStr;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Email(String);

impl FromStr for Email {
    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if s.contains('@') {
            Ok(Email(s.to_string()))
        } else {
            Err("Invalid email format")
        }
    }
}

impl ToString for Email {
    fn to_string(&self) -> String {
        self.0.clone()
    }
}

// Implementing ToSql for Email
impl<DB: Backend> ToSql<Text, DB> for Email {
    fn to_sql<W: Write>(&self, out: &mut Output<W, DB>) -> serialize::Result {
        out.write_all(self.0.as_bytes())?;
        Ok(IsNull::No)
    }
}

// Implementing FromSql for Email
impl<DB: Backend> FromSql<Text, DB> for Email {
    fn from_sql(bytes: Option<&DB::RawValue>) -> deserialize::Result<Self> {
        let bytes = not_none!(bytes);
        let s = std::str::from_utf8(bytes)?;
        Email::from_str(s).map_err(|_| "Invalid email format".into())
    }
}

use diesel::prelude::*;
use diesel::sql_types::Text;

table! {
    users (id) {
        id -> Integer,
        email -> Text,
    }
}

#[derive(Queryable, Insertable)]
#[table_name = "users"]
pub struct User {
    pub id: i32,
    pub email: Email,
}

#[macro_use]
extern crate diesel;
extern crate dotenv;

use diesel::prelude::*;
use diesel::sqlite::SqliteConnection;
use dotenv::dotenv;
use std::env;

mod schema {
    table! {
        users (id) {
            id -> Integer,
            email -> Text,
        }
    }
}

use self::schema::users;
use self::schema::users::dsl::*;

#[derive(Debug, Queryable, Insertable)]
#[table_name = "users"]
pub struct User {
    pub id: i32,
    pub email: Email,
}

fn establish_connection() -> SqliteConnection {
    dotenv().ok();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    SqliteConnection::establish(&database_url).expect(&format!("Error connecting to {}", database_url))
}

fn main() {
    let connection = establish_connection();

    // Create a new user
    let new_user = User {
        id: 1,
        email: "user@example.com".parse().expect("Invalid email format"),
    };

    // Insert the new user into the database
    diesel::insert_into(users)
        .values(&new_user)
        .execute(&connection)
        .expect("Error inserting new user");

    // Query the user from the database
    let results = users
        .filter(id.eq(1))
        .load::<User>(&connection)
        .expect("Error loading user");

    for user in results {
        println!("Found user: {:?}", user);
    }
}