Как реализовать возможность запроса и вставку для настраиваемых типов полей в Diesel?

Мне удобнее создавать оболочки нового типа, которые реализуют ToSql и FromSql. Затем вы можете использовать эти базовые блоки для создания более крупных типов, которые могут быть производными Queryable / Insertable.

В этом примере показано только, как выполнить сопоставление перечисления с SmallInt, но регистр десятичных чисел будет таким же. Единственная разница будет в том, как вы выполняете преобразования:

#[macro_use]
extern crate diesel;

mod types {
    use diesel::sql_types::*;
    use diesel::backend::Backend;
    use diesel::deserialize::{self, FromSql};
    use diesel::serialize::{self, ToSql, Output};
    use std::io;

    table! {
        records (id) {
            id -> BigInt,
            record_type -> SmallInt,
        }
    }

    #[derive(Debug, Copy, Clone, AsExpression, FromSqlRow)]
    #[sql_type = "SmallInt"]
    pub enum RecordType {
        A,
        B,
    }

    impl<DB: Backend> ToSql<SmallInt, DB> for RecordType
    where
        i16: ToSql<SmallInt, DB>,
    {
        fn to_sql<W>(&self, out: &mut Output<W, DB>) -> serialize::Result
        where
            W: io::Write,
        {
            let v = match *self {
                RecordType::A => 1,
                RecordType::B => 2,
            };
            v.to_sql(out)
        }
    }

    impl<DB: Backend> FromSql<SmallInt, DB> for RecordType
    where
        i16: FromSql<SmallInt, DB>,
    {
        fn from_sql(bytes: Option<&DB::RawValue>) -> deserialize::Result<Self> {
            let v = i16::from_sql(bytes)?;
            Ok(match v {
                1 => RecordType::A,
                2 => RecordType::B,
                _ => return Err("replace me with a real error".into()),
            })
        }
    }

    #[derive(Insertable, Queryable, Debug)]
    #[table_name = "records"]
    pub struct Record {
        pub id: i64,
        pub record_type: RecordType,
    }
}

Существует черновик руководства, описывающий все производные и их аннотации, но еще не упоминается #[sql_type] для всего типа. Это позволяет Diesel узнать, какое основное хранилище необходимо внутри базы данных.

См. Также тесты Diesel для пользовательских типов.

Иногда самый простой способ понять, что делает макрос (производные - это просто другая форма макросов), - это запросить у компилятора расширенный код. С ночным компилятором вы можете сделать это с помощью этой команды:

cargo rustc -- -Z unstable-options --pretty expanded > expanded.rs

Это выведет расширенный код в expanded.rs.

Теперь мы можем взглянуть на этот файл, чтобы увидеть, до чего #[derive(Insertable)] расширяется. Естественно, я сначала изменил определение Record, чтобы оно соответствовало типам Diesel. После некоторой очистки это сгенерированный код:

impl<'insert> diesel::insertable::Insertable<records::table> for &'insert Record {
    type Values = <(
        Option<diesel::dsl::Eq<records::id, &'insert i64>>,
        Option<diesel::dsl::Eq<records::record_type, &'insert i16>>,
        Option<diesel::dsl::Eq<records::value, &'insert BigDecimal>>
    ) as diesel::insertable::Insertable<records::table>>::Values;

    #[allow(non_shorthand_field_patterns)]
    fn values(self) -> Self::Values {
        let Record {
            id: ref id,
            record_type: ref record_type,
            value: ref value,
        } = *self;
        diesel::insertable::Insertable::values((
            Some(::ExpressionMethods::eq(records::id, id)),
            Some(::ExpressionMethods::eq(records::record_type, record_type)),
            Some(::ExpressionMethods::eq(records::value, value))))
    }
}

impl diesel::query_builder::UndecoratedInsertRecord<records::table> for Record {
}

Теперь мы можем адаптировать реализацию Insertable для наших пользовательских типов. Обратите внимание, что я изменил связанный тип Values, чтобы возвращать значения напрямую, а не ссылки на значения, потому что для двух из них значение создается в методе values, поэтому мы не можем вернуть ссылку, а для другого , возврат ссылки не сильно выигрывает с точки зрения производительности.

impl<'insert> diesel::insertable::Insertable<records::table> for &'insert Record {
    type Values = <(
        Option<diesel::dsl::Eq<records::id, i64>>,
        Option<diesel::dsl::Eq<records::record_type, i16>>,
        Option<diesel::dsl::Eq<records::value, BigDecimal>>
    ) as diesel::insertable::Insertable<records::table>>::Values;

    #[allow(non_shorthand_field_patterns)]
    fn values(self) -> Self::Values {
        let Record {
            id: ref id,
            record_type: ref record_type,
            value: ref value,
        } = *self;
        let record_type = match *record_type {
            RecordType::A => 1,
            RecordType::B => 2,
        };
        let value: BigDecimal = value.to_string().parse().unwrap();
        diesel::insertable::Insertable::values((
            Some(::ExpressionMethods::eq(records::id, *id)),
            Some(::ExpressionMethods::eq(records::record_type, record_type)),
            Some(::ExpressionMethods::eq(records::value, value))))
    }
}