use enum in diesel

enum_serde_diesel.rs

/// Useage:
/// enum_serde_diesel!(Example {
///     a = 0,
///     b = 1,
///     c = 2,
/// });
macro_rules! enum_serde_diesel {
    ($name:ident { $($variant:ident = $value:expr, )* }) => {
        #[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, FromSqlRow, AsExpression)]
        #[sql_type = "::diesel::sql_types::SmallInt"]
        pub enum $name {
            $($variant = $value,)*
        }

        impl $name{
            fn new(value:i16)->Result<Self,String>{
                match value {
                            $( $value => Ok($name::$variant), )*
                            _ => Err(format!("unknown {} value: {}",
                                stringify!($name), value)),
                        }
            }
        }

        impl ::serde::Serialize for $name {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: ::serde::Serializer,
            {
                // Serialize the enum as a i16.
                serializer.serialize_i16(*self as i16)
            }
        }

        impl<'de> ::serde::Deserialize<'de> for $name {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: ::serde::Deserializer<'de>,
            {
                struct Visitor;

                impl<'de> ::serde::de::Visitor<'de> for Visitor {
                    type Value = $name;

                    fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                        formatter.write_str("overflow")
                    }

                    fn visit_i16<E>(self, value: i16) -> Result<$name, E>
                    where
                        E: ::serde::de::Error,
                    {
                        $name::new(value).map_err(E::custom)
                    }
                }

                // Deserialize the enum from a i16.
                deserializer.deserialize_i16(Visitor)
            }
        }
        
        impl<DB> ::diesel::serialize::ToSql<::diesel::sql_types::SmallInt,DB> for $name
        where 
            DB: ::diesel::backend::Backend
        {
            fn to_sql<W: ::std::io::Write>(&self,out:&mut ::diesel::serialize::Output<W,DB>)->::diesel::serialize::Result{
                <i16 as ::diesel::serialize::ToSql<::diesel::sql_types::SmallInt, DB>>::to_sql(&(*self as i16),out)
            }
        }
        impl<DB> ::diesel::deserialize::FromSql<::diesel::sql_types::SmallInt,DB> for $name
        where 
            DB: ::diesel::backend::Backend,
            i16: ::diesel::deserialize::FromSql<::diesel::sql_types::SmallInt,DB>
        {
            fn from_sql(bytes: Option<&DB::RawValue>) -> ::diesel::deserialize::Result<Self>{
                let value=<i16 as ::diesel::deserialize::FromSql<::diesel::sql_types::SmallInt, DB>>::from_sql(bytes)?;
                $name::new(value).map_err(Into::into)
            }
        }
    }
}