Skip to main content

Enum

diesel::types

Derive Macro Enum 

Source 
#[derive(Enum)]
{
    // Attributes available to this derive:
    #[diesel]
}
Expand description

Implements FromSql and ToSql for enum types

This derive enables an enum (with unit-variants only) to be serialized to the database as a byte-string and deserialized from the same representation from the database.

This derive generates FromSql and ToSql implementations for all backends based on the provided SQL type. It currently supports the following SQL types:

  • diesel::sql_types::Integer, diesel::sql_types::SmallInt, diesel::sql_types::BigInt, diesel::sql_types::TinyInt and their unsigned variants for all backends to (de)serialize a Rust enum as integer values. This requires annotating every variant with an explicit discriminant value
  • diesel::sql_types::Text for all backend to (de)serialize a Rust enum as text values.
  • Any custom SQL type marked with #[diesel(enum_type)]

Additional it internally generates the same implementations as #[derive(FromSqlRow)] and #[derive(AsExpression)]

§Attributes

§Required container attributes

  • #[diesel(sql_type = path::to::MyEnumType)], specifies the database type this enum represents, can appear several times

§Optional container attributes

  • #[diesel(rename_all = "case")] to rename all enum variants according the provided scheme. The following schemes are supported:
    • "lowercase" to rename all variants to lower-case
    • "UPPERCASE" to rename all variants to upper-case
    • "PascalCase" to keep the provided Rust variant name
    • "camelCase" to rename all variants to camel-case
    • "snake_case" to rename all variants to snake-case
    • "SCREAMING_SNAKE_CASE" to rename all variants to screaming snake case
    • "kebab-case" to rename all variants to kebab-case
    • "SCREAMING-KEBAB-CASE" to rename all variants to screaming kebab case

§Optional variant attributes

  • #[diesel(rename = "newSqlName")] to provide an explicit name for the SQL side variant

§Examples

§Usage with database side Enums

#[derive(Debug, diesel::types::Enum, PartialEq)]
#[diesel(sql_type = schema::sql_types::Color)]
enum Color {
    Red,
    Green,
    Blue
}
let r = diesel::select(Color::Red.into_sql::<schema::sql_types::Color>())
    .get_result::<Color>(connection)?;
assert_eq!(r, Color::Red);
Ok(())

§Usage with a database side integer column

#[derive(Debug, diesel::types::Enum, PartialEq)]
#[diesel(sql_type = diesel::sql_types::Integer)]
enum Color {
    // Explicit discriminants are required here
    Red = 1,
    Green = 2,
    Blue = 3
}
let r = diesel::select(1.into_sql::<diesel::sql_types::Integer>())
    .get_result::<Color>(connection)?;
assert_eq!(r, Color::Red);
Ok(())

§Usage with a database side text column

#[derive(Debug, diesel::types::Enum, PartialEq)]
#[diesel(sql_type = diesel::sql_types::Text)]
#[diesel(rename_all = "SCREAMING_SNAKE_CASE")]
enum Color {
    Red,
    Green,
    Blue,
}
let r = diesel::select("RED".into_sql::<diesel::sql_types::Text>())
    .get_result::<Color>(connection)?;
assert_eq!(r, Color::Red);
Ok(())

§Expanded Code

Expanded Code

§Database side Enum

§Input
ⓘ
#[derive(Enum)]
#[derive(Debug, diesel::Enum)]
#[diesel(sql_type = schema::sql_types::Color)]
enum Color {
    Red,
    Green,
    Blue,
}
§Expanded Code
Expanded code might use diesel internal API's and is only shown for educational purpose

The macro expands the input to the following Rust code:

ⓘ
const _: () = {
    use diesel;
    impl<__DB> diesel::deserialize::FromSql<schema::sql_types::Color, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        schema::sql_types::Color: diesel::sql_types::EnumSqlType<false, __DB>,
        <schema::sql_types::Color as diesel::sql_types::EnumSqlType<
            false,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn from_sql(
            value: <__DB as diesel::backend::Backend>::RawValue<'_>,
        ) -> diesel::deserialize::Result<Self> {
            const VARIANTS: &[diesel::internal::derives::enum_::EnumVariant] = &[
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 0i128,
                    rust_name: stringify!(Red),
                    sql_name: "Red",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 1i128,
                    rust_name: stringify!(Green),
                    sql_name: "Green",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 2i128,
                    rust_name: stringify!(Blue),
                    sql_name: "Blue",
                },
            ];
            let idx = <<schema::sql_types::Color as diesel::sql_types::EnumSqlType<
                false,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_from_database_value(value, stringify!(Color), VARIANTS)?;
            match idx {
                0usize => Ok(Self::Red),
                1usize => Ok(Self::Green),
                2usize => Ok(Self::Blue),
                _ => unreachable!("We construct all relevant variants"),
            }
        }
    }
    impl<__DB> diesel::serialize::ToSql<schema::sql_types::Color, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        schema::sql_types::Color: diesel::sql_types::EnumSqlType<false, __DB>,
        <schema::sql_types::Color as diesel::sql_types::EnumSqlType<
            false,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn to_sql<'b>(
            &'b self,
            output: &mut diesel::serialize::Output<'b, '_, __DB>,
        ) -> diesel::serialize::Result {
            let variant = match self {
                Self::Red => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 0i128,
                        rust_name: stringify!(Red),
                        sql_name: "Red",
                    }
                }
                Self::Green => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 1i128,
                        rust_name: stringify!(Green),
                        sql_name: "Green",
                    }
                }
                Self::Blue => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 2i128,
                        rust_name: stringify!(Blue),
                        sql_name: "Blue",
                    }
                }
            };
            <<schema::sql_types::Color as diesel::sql_types::EnumSqlType<
                false,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_to_database_value(output, variant)
        }
    }
    impl<'__expr> diesel::expression::AsExpression<schema::sql_types::Color>
    for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            schema::sql_types::Color,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            schema::sql_types::Color,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<schema::sql_types::Color>,
    > for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<schema::sql_types::Color>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<schema::sql_types::Color>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<'__expr, '__expr2> diesel::expression::AsExpression<schema::sql_types::Color>
    for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            schema::sql_types::Color,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            schema::sql_types::Color,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
        '__expr2,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<schema::sql_types::Color>,
    > for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<schema::sql_types::Color>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<schema::sql_types::Color>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<
        __DB,
    > diesel::serialize::ToSql<
        diesel::sql_types::Nullable<schema::sql_types::Color>,
        __DB,
    > for Color
    where
        __DB: diesel::backend::Backend,
        Self: diesel::serialize::ToSql<schema::sql_types::Color, __DB>,
    {
        fn to_sql<'__b>(
            &'__b self,
            out: &mut diesel::serialize::Output<'__b, '_, __DB>,
        ) -> diesel::serialize::Result {
            diesel::serialize::ToSql::<schema::sql_types::Color, __DB>::to_sql(self, out)
        }
    }
    impl diesel::expression::AsExpression<schema::sql_types::Color> for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            schema::sql_types::Color,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            schema::sql_types::Color,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl diesel::expression::AsExpression<
        diesel::sql_types::Nullable<schema::sql_types::Color>,
    > for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<schema::sql_types::Color>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<schema::sql_types::Color>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<__DB, __ST> diesel::deserialize::Queryable<__ST, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        __ST: diesel::sql_types::SingleValue,
        Self: diesel::deserialize::FromSql<__ST, __DB>,
    {
        type Row = Self;
        fn build(row: Self) -> diesel::deserialize::Result<Self> {
            diesel::deserialize::Result::Ok(row)
        }
    }
};

§Mapping to Integer

§Input
ⓘ
#[derive(Enum)]
#[derive(Debug, diesel::Enum)]
#[diesel(sql_type = diesel::sql_types::Integer)]
enum Color {
    Red = 1,
    Green = 2,
    Blue = 3,
}
§Expanded Code
Expanded code might use diesel internal API's and is only shown for educational purpose

The macro expands the input to the following Rust code:

ⓘ
const _: () = {
    use diesel;
    impl<__DB> diesel::deserialize::FromSql<diesel::sql_types::Integer, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        diesel::sql_types::Integer: diesel::sql_types::EnumSqlType<true, __DB>,
        <diesel::sql_types::Integer as diesel::sql_types::EnumSqlType<
            true,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn from_sql(
            value: <__DB as diesel::backend::Backend>::RawValue<'_>,
        ) -> diesel::deserialize::Result<Self> {
            const VARIANTS: &[diesel::internal::derives::enum_::EnumVariant] = &[
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 1i128,
                    rust_name: stringify!(Red),
                    sql_name: "Red",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 2i128,
                    rust_name: stringify!(Green),
                    sql_name: "Green",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 3i128,
                    rust_name: stringify!(Blue),
                    sql_name: "Blue",
                },
            ];
            let idx = <<diesel::sql_types::Integer as diesel::sql_types::EnumSqlType<
                true,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_from_database_value(value, stringify!(Color), VARIANTS)?;
            match idx {
                0usize => Ok(Self::Red),
                1usize => Ok(Self::Green),
                2usize => Ok(Self::Blue),
                _ => unreachable!("We construct all relevant variants"),
            }
        }
    }
    impl<__DB> diesel::serialize::ToSql<diesel::sql_types::Integer, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        diesel::sql_types::Integer: diesel::sql_types::EnumSqlType<true, __DB>,
        <diesel::sql_types::Integer as diesel::sql_types::EnumSqlType<
            true,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn to_sql<'b>(
            &'b self,
            output: &mut diesel::serialize::Output<'b, '_, __DB>,
        ) -> diesel::serialize::Result {
            let variant = match self {
                Self::Red => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 1i128,
                        rust_name: stringify!(Red),
                        sql_name: "Red",
                    }
                }
                Self::Green => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 2i128,
                        rust_name: stringify!(Green),
                        sql_name: "Green",
                    }
                }
                Self::Blue => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 3i128,
                        rust_name: stringify!(Blue),
                        sql_name: "Blue",
                    }
                }
            };
            <<diesel::sql_types::Integer as diesel::sql_types::EnumSqlType<
                true,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_to_database_value(output, variant)
        }
    }
    impl<'__expr> diesel::expression::AsExpression<diesel::sql_types::Integer>
    for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Integer,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Integer,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Integer>,
    > for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Integer>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Integer>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<'__expr, '__expr2> diesel::expression::AsExpression<diesel::sql_types::Integer>
    for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Integer,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Integer,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
        '__expr2,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Integer>,
    > for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Integer>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Integer>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<
        __DB,
    > diesel::serialize::ToSql<
        diesel::sql_types::Nullable<diesel::sql_types::Integer>,
        __DB,
    > for Color
    where
        __DB: diesel::backend::Backend,
        Self: diesel::serialize::ToSql<diesel::sql_types::Integer, __DB>,
    {
        fn to_sql<'__b>(
            &'__b self,
            out: &mut diesel::serialize::Output<'__b, '_, __DB>,
        ) -> diesel::serialize::Result {
            diesel::serialize::ToSql::<
                diesel::sql_types::Integer,
                __DB,
            >::to_sql(self, out)
        }
    }
    impl diesel::expression::AsExpression<diesel::sql_types::Integer> for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Integer,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Integer,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Integer>,
    > for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Integer>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Integer>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<__DB, __ST> diesel::deserialize::Queryable<__ST, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        __ST: diesel::sql_types::SingleValue,
        Self: diesel::deserialize::FromSql<__ST, __DB>,
    {
        type Row = Self;
        fn build(row: Self) -> diesel::deserialize::Result<Self> {
            diesel::deserialize::Result::Ok(row)
        }
    }
};

§Rename all variants

§Input
ⓘ
#[derive(Enum)]
#[derive(Debug, diesel::Enum)]
#[diesel(sql_type = diesel::sql_types::Text)]
#[diesel(rename_all = "snake_case")]
enum Color {
    RedColor,
    GreenColor,
    BlueColor,
}
§Expanded Code
Expanded code might use diesel internal API's and is only shown for educational purpose

The macro expands the input to the following Rust code:

ⓘ
const _: () = {
    use diesel;
    impl<__DB> diesel::deserialize::FromSql<diesel::sql_types::Text, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        diesel::sql_types::Text: diesel::sql_types::EnumSqlType<false, __DB>,
        <diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
            false,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn from_sql(
            value: <__DB as diesel::backend::Backend>::RawValue<'_>,
        ) -> diesel::deserialize::Result<Self> {
            const VARIANTS: &[diesel::internal::derives::enum_::EnumVariant] = &[
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 0i128,
                    rust_name: stringify!(RedColor),
                    sql_name: "red_color",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 1i128,
                    rust_name: stringify!(GreenColor),
                    sql_name: "green_color",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 2i128,
                    rust_name: stringify!(BlueColor),
                    sql_name: "blue_color",
                },
            ];
            let idx = <<diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
                false,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_from_database_value(value, stringify!(Color), VARIANTS)?;
            match idx {
                0usize => Ok(Self::RedColor),
                1usize => Ok(Self::GreenColor),
                2usize => Ok(Self::BlueColor),
                _ => unreachable!("We construct all relevant variants"),
            }
        }
    }
    impl<__DB> diesel::serialize::ToSql<diesel::sql_types::Text, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        diesel::sql_types::Text: diesel::sql_types::EnumSqlType<false, __DB>,
        <diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
            false,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn to_sql<'b>(
            &'b self,
            output: &mut diesel::serialize::Output<'b, '_, __DB>,
        ) -> diesel::serialize::Result {
            let variant = match self {
                Self::RedColor => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 0i128,
                        rust_name: stringify!(RedColor),
                        sql_name: "red_color",
                    }
                }
                Self::GreenColor => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 1i128,
                        rust_name: stringify!(GreenColor),
                        sql_name: "green_color",
                    }
                }
                Self::BlueColor => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 2i128,
                        rust_name: stringify!(BlueColor),
                        sql_name: "blue_color",
                    }
                }
            };
            <<diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
                false,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_to_database_value(output, variant)
        }
    }
    impl<'__expr> diesel::expression::AsExpression<diesel::sql_types::Text>
    for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Text,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Text,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
    > for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<'__expr, '__expr2> diesel::expression::AsExpression<diesel::sql_types::Text>
    for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Text,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Text,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
        '__expr2,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
    > for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<
        __DB,
    > diesel::serialize::ToSql<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
        __DB,
    > for Color
    where
        __DB: diesel::backend::Backend,
        Self: diesel::serialize::ToSql<diesel::sql_types::Text, __DB>,
    {
        fn to_sql<'__b>(
            &'__b self,
            out: &mut diesel::serialize::Output<'__b, '_, __DB>,
        ) -> diesel::serialize::Result {
            diesel::serialize::ToSql::<diesel::sql_types::Text, __DB>::to_sql(self, out)
        }
    }
    impl diesel::expression::AsExpression<diesel::sql_types::Text> for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Text,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Text,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
    > for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<__DB, __ST> diesel::deserialize::Queryable<__ST, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        __ST: diesel::sql_types::SingleValue,
        Self: diesel::deserialize::FromSql<__ST, __DB>,
    {
        type Row = Self;
        fn build(row: Self) -> diesel::deserialize::Result<Self> {
            diesel::deserialize::Result::Ok(row)
        }
    }
};

§Rename single variant

§Input
ⓘ
#[derive(Enum)]
#[derive(Debug, diesel::Enum)]
#[diesel(sql_type = diesel::sql_types::Text)]
enum Color {
    #[diesel(rename = "ReD")]
    Red,
    #[diesel(rename = "GreeN")]
    Green,
    #[diesel(rename = "BluE")]
    Blue,
}
§Expanded Code
Expanded code might use diesel internal API's and is only shown for educational purpose

The macro expands the input to the following Rust code:

ⓘ
const _: () = {
    use diesel;
    impl<__DB> diesel::deserialize::FromSql<diesel::sql_types::Text, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        diesel::sql_types::Text: diesel::sql_types::EnumSqlType<false, __DB>,
        <diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
            false,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn from_sql(
            value: <__DB as diesel::backend::Backend>::RawValue<'_>,
        ) -> diesel::deserialize::Result<Self> {
            const VARIANTS: &[diesel::internal::derives::enum_::EnumVariant] = &[
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 0i128,
                    rust_name: stringify!(Red),
                    sql_name: "ReD",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 1i128,
                    rust_name: stringify!(Green),
                    sql_name: "GreeN",
                },
                diesel::internal::derives::enum_::EnumVariant {
                    discriminant: 2i128,
                    rust_name: stringify!(Blue),
                    sql_name: "BluE",
                },
            ];
            let idx = <<diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
                false,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_from_database_value(value, stringify!(Color), VARIANTS)?;
            match idx {
                0usize => Ok(Self::Red),
                1usize => Ok(Self::Green),
                2usize => Ok(Self::Blue),
                _ => unreachable!("We construct all relevant variants"),
            }
        }
    }
    impl<__DB> diesel::serialize::ToSql<diesel::sql_types::Text, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        diesel::sql_types::Text: diesel::sql_types::EnumSqlType<false, __DB>,
        <diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
            false,
            __DB,
        >>::Strategy: diesel::internal::derives::enum_::EnumMapping<__DB>,
    {
        fn to_sql<'b>(
            &'b self,
            output: &mut diesel::serialize::Output<'b, '_, __DB>,
        ) -> diesel::serialize::Result {
            let variant = match self {
                Self::Red => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 0i128,
                        rust_name: stringify!(Red),
                        sql_name: "ReD",
                    }
                }
                Self::Green => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 1i128,
                        rust_name: stringify!(Green),
                        sql_name: "GreeN",
                    }
                }
                Self::Blue => {
                    &diesel::internal::derives::enum_::EnumVariant {
                        discriminant: 2i128,
                        rust_name: stringify!(Blue),
                        sql_name: "BluE",
                    }
                }
            };
            <<diesel::sql_types::Text as diesel::sql_types::EnumSqlType<
                false,
                __DB,
            >>::Strategy as diesel::internal::derives::enum_::EnumMapping<
                __DB,
            >>::map_to_database_value(output, variant)
        }
    }
    impl<'__expr> diesel::expression::AsExpression<diesel::sql_types::Text>
    for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Text,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Text,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
    > for &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<'__expr, '__expr2> diesel::expression::AsExpression<diesel::sql_types::Text>
    for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Text,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Text,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    #[diagnostic::do_not_recommend]
    impl<
        '__expr,
        '__expr2,
    > diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
    > for &'__expr2 &'__expr Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<
        __DB,
    > diesel::serialize::ToSql<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
        __DB,
    > for Color
    where
        __DB: diesel::backend::Backend,
        Self: diesel::serialize::ToSql<diesel::sql_types::Text, __DB>,
    {
        fn to_sql<'__b>(
            &'__b self,
            out: &mut diesel::serialize::Output<'__b, '_, __DB>,
        ) -> diesel::serialize::Result {
            diesel::serialize::ToSql::<diesel::sql_types::Text, __DB>::to_sql(self, out)
        }
    }
    impl diesel::expression::AsExpression<diesel::sql_types::Text> for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Text,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Text,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl diesel::expression::AsExpression<
        diesel::sql_types::Nullable<diesel::sql_types::Text>,
    > for Color {
        type Expression = diesel::internal::derives::as_expression::Bound<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
            Self,
        >;
        fn as_expression(
            self,
        ) -> <Self as diesel::expression::AsExpression<
            diesel::sql_types::Nullable<diesel::sql_types::Text>,
        >>::Expression {
            diesel::internal::derives::as_expression::Bound::new(self)
        }
    }
    impl<__DB, __ST> diesel::deserialize::Queryable<__ST, __DB> for Color
    where
        __DB: diesel::backend::Backend,
        __ST: diesel::sql_types::SingleValue,
        Self: diesel::deserialize::FromSql<__ST, __DB>,
    {
        type Row = Self;
        fn build(row: Self) -> diesel::deserialize::Result<Self> {
            diesel::deserialize::Result::Ok(row)
        }
    }
};