migratio 0.4.2

Write expressive database migrations in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/// Error type for the migratio crate.
#[derive(thiserror::Error, Debug)]
pub enum Error {
    #[cfg(feature = "sqlite")]
    #[error("{0}")]
    Rusqlite(rusqlite::Error),
    #[cfg(feature = "mysql")]
    #[error("{0}")]
    Mysql(String),
    #[cfg(feature = "postgres")]
    #[error("{0}")]
    Postgres(#[from] postgres::Error),
    #[error("{0}")]
    Generic(String),
}

#[cfg(feature = "sqlite")]
impl From<rusqlite::Error> for Error {
    fn from(value: rusqlite::Error) -> Self {
        Self::Rusqlite(value)
    }
}

#[cfg(feature = "mysql")]
impl From<mysql::Error> for Error {
    fn from(value: mysql::Error) -> Self {
        Self::Mysql(value.to_string())
    }
}

impl From<String> for Error {
    fn from(value: String) -> Self {
        Self::Generic(value)
    }
}

// Manual PartialEq implementation because postgres::Error doesn't implement PartialEq
impl PartialEq for Error {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            #[cfg(feature = "sqlite")]
            (Self::Rusqlite(a), Self::Rusqlite(b)) => a == b,
            #[cfg(feature = "mysql")]
            (Self::Mysql(a), Self::Mysql(b)) => a == b,
            #[cfg(feature = "postgres")]
            (Self::Postgres(a), Self::Postgres(b)) => a.to_string() == b.to_string(),
            (Self::Generic(a), Self::Generic(b)) => a == b,
            #[allow(unreachable_patterns)]
            _ => false,
        }
    }
}