Less verbose column checks

[SZenglein]

Inspired by the (pretty great) new helpers for writing migrations, I wrote an extension for ColumnDef that has the potential to also shorten writing common database checks.
The code is pretty simple, but I had to go a bit of a detour to get the column name as Iden from the ColumnDef using Alias.

use crate::{Alias, Expr};
use sea_orm_migration::prelude::{ColumnDef, SimpleExpr};

pub trait AddRangeCheck<N> {
    fn between(&mut self, a: N, b: N) -> &mut Self;

    // TODO: add functions for only lower or upper bound
}

impl<N: Into<SimpleExpr>> AddRangeCheck<N> for ColumnDef {
    fn between(&mut self, a: N, b: N) -> &mut Self {
        self.check(Expr::col(Alias::new(self.get_column_name())).between(a, b));
        self
    }
}

This results in the following change:
Before:

    .col(integer(Schedules::Day)
    .check(Expr::col(Schedules::Day).between(1, 32))

After:

    .col(integer(Schedules::Day).between(1, 32))

I'd say second snippet is easier to read and write by reducing the repetition of the column name.

The obvious downside is that it is only possible to apply checks that span one column, but I'd say that's still a pretty common use-case.

I plan to write a similar helper function for String enum value checks (on sqlite), but I'm not sure if there is any other common methods that are useful to abstract for a single column.

[tyt2y3]

That's a smart idea and really cool. I think there should be a better way to satisfy the type system than Expr::col(Alias::new(self.get_column_name())), but that's just an implementation detail. You are more than welcome to open a PR to add the above!

[SZenglein]

The Alias workaround is only because from outside the crate, it is not possible to access ColumnDef.name directly. If included in sea-orm, self.name can be used directly.

My main issue is that if this is included, a lot of other functions from Expr make sense: eq. like, gt, but I have not found a good way to expose the Expr directly to avoid repeating all the method definitions.

My latest attempt uses a closure, but using that directly is not that much shorter:

pub trait WithCheck {
    /// allows any check to be defined without repeating the column name
    fn with_check<F, E>(&mut self, check: F) -> &mut Self
    where
        F: FnOnce(Expr) -> E,
        E: Into<SimpleExpr>;

    /// shortcut functions can be implemented via the with_check function
    fn between<V: Into<SimpleExpr>>(&mut self, a: V, b: V) -> &mut Self {
        self.with_check(|e| e.between(a, b));
        self
    }
}

impl WithCheck for ColumnDef {
    fn with_check<F, E>(&mut self, check: F) -> &mut Self
    where
        F: FnOnce(Expr) -> E,
        E: Into<SimpleExpr>,
    {
        self.check(check(Expr::col(Alias::new(self.get_column_name()))));
        self
    }
}