diesel-enum 0.2.0

Interop between your enums and your database with diesel
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

This crate allows the user to represent state in the database using Rust enums. This is achieved
through a proc macro. First the macro looks at your chosen `sql_type`, and then it devises a
corresponding Rust type. The mapping is as follows:

| SQL | Rust |
|--|--|
| `SmallInt` | `i16` |
| `Integer` | `i32` |
| `Int` | `i32` |
| `BigInt` | `i64` |
| `VarChar` | `String` |
| `Text` | `String` |

 The macro then generates three impls: a `FromSql` impl, an `ToSql` impl and a
`TryFrom` impl, which allow conversion between the Sql type and the enum (`FromSql` and `ToSql`),
and from the Rust type into the enum (`TryInto`).

### Usage
```rust
use diesel_enum::DbEnum;
use diesel::{sql_types::SmallInt, expression::AsExpression, deserialize::FromSqlRow};

#[derive(Debug)]
pub struct CustomError {
    msg: String,
    status: u16,
}

impl CustomError {
    fn not_found(msg: String) -> Self {
        Self {
            msg,
            status: 404,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, AsExpression, FromSqlRow, DbEnum)]
#[diesel(sql_type = SmallInt)]
#[diesel_enum(error_fn = CustomError::not_found)]
#[diesel_enum(error_type = CustomError)
pub enum Status {
    /// Will be represented as 0.
    Ready,
    /// Will be represented as 1.
    Pending,
}
```
Alternatively you can use strings, with will be cast to lowercase. (e.g. `Status::Ready` will be
stored as `"ready"` in the database):
```rust
#[derive(Debug, Clone, Copy, PartialEq, Eq, AsExpression, FromSqlRow, DbEnum)]
#[diesel(sql_type = VarChar)]
#[diesel_enum(error_fn = CustomError::not_found)]
#[diesel_enum(error_type = CustomError)]
pub enum Status {
    /// Will be represented as `"ready"`.
    Ready,
    /// Will be represented as `"pending"`.
    Pending,
}
```
Another option is to manually override the values set for each or some of the variants. This is done
using the `val` attribute:
```rust
#[derive(Debug, Clone, Copy, PartialEq, Eq, AsExpression, FromSqlRow, DbEnum)]
#[diesel(sql_type = VarChar)]
#[diesel_enum(error_fn = CustomError::not_found)]
#[diesel_enum(error_type = CustomError)]
pub enum Status {
    /// Will be represented as `"reddy"`.
    #[val = "reddy"]
    Ready,
    /// Will be represented as `"pending"`.
    Pending,
}
```