diesel-sqlite-enum-integer 0.1.0

This proc macro attribute will allow you to store the enum as integer.
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

use proc_macro::{TokenStream};
use syn::{parse_macro_input, Data, DeriveInput, Ident};
use quote::{quote, ToTokens};

#[proc_macro_attribute]
pub fn enum_to_diesel_integer(_args: TokenStream, input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let enum_names : Vec<Ident> = if let Data::Enum(data) = &input.data {
        data.variants.iter().map(|x| x.ident.clone()).collect()
    } else {
        panic!("Only enums are supported.");
    };


    let mut to_sql_tokens: proc_macro2::TokenStream = quote! {};
    let mut from_sql_tokens: proc_macro2::TokenStream = quote! {};

    enum_names.iter()
        .enumerate()
        .for_each(|(i, e)| {
            let i: i32 = i as i32;

            quote! {
                #name::#e=> diesel::serialize::ToSql::<diesel::sql_types::Integer, diesel::sqlite::Sqlite>::to_sql(&#i, out),
            }.to_tokens(&mut to_sql_tokens);

            quote! {
                #i => Ok(#name::#e),
            }.to_tokens(&mut from_sql_tokens);
        });
    

    return quote!{
        #[repr(i32)]
        #[derive(Debug, PartialEq, diesel::FromSqlRow, diesel::AsExpression, Eq, Clone)]
        #[diesel(sql_type = diesel::sql_types::Integer)]
        #input

        impl diesel::serialize::ToSql<diesel::sql_types::Integer, diesel::sqlite::Sqlite> for #name {
            fn to_sql<'b>(&'b self, out: &mut diesel::serialize::Output<'b, '_, diesel::sqlite::Sqlite>) -> diesel::serialize::Result {
                match self {
                    #to_sql_tokens
                    
                }
            }
        }

        impl diesel::deserialize::FromSql<diesel::sql_types::Integer, diesel::sqlite::Sqlite> for #name {
            fn from_sql(bytes: diesel::sqlite::SqliteValue<'_, '_, '_>) -> diesel::deserialize::Result<Self> {
                match <i32 as diesel::deserialize::FromSql<diesel::sql_types::Integer, diesel::sqlite::Sqlite>>::from_sql(bytes)? {
                    #from_sql_tokens
                    _ => Err("Unrecognized enum variant".into()),
                }
            }
        }
    }.into();
}