Generic connection types and SaveChangesDsl

[Justice4Joffrey]

I want to write my db operations like so:

fn do_thing(conn: impl Connection<Backend=SomeBackend>) {
   // database things
}

The result is that this is available the caller uses a PooledConnection or a Connection.

This works fine for the most part, but SaveChangesDsl is awkward - it's implemented on concrete connections (e.g. PgConnection, PooledConnection<M> where M::Connection impls UpdateAndFetchResults). Therefore, there isn't a single trait impl I can use which will allow this. Also, requiring UpdateAndFetchResults<Changes, Output> at the call site will leak all specific implementations which will awkwardly have to be propagated up the call stack.

It's obviously fairly simple for me to not use SaveChangesDsl with this workflow, but would imagine this could simplify a lot of diesel use where both pooled and single connections are sharing the same functionality.

Interested to hear whether this could be supported and what an implementation might look like.

[weiznich]

This could likely be solved at application level by using the following function signature:

fn do_thing<C>(conn: C)
where C: Connection<Backend = SomeBackend>,
           YourType: SaveChangesDsl<C>,
{
     // database things
}

Possibly it's even possible to write some sort of "super" trait that just implies SaveChangesDsl for a number of types by just listing them as part of the where clause of the corresponding wild card impl. Something like

pub trait MySuperConnection: Connection {}

impl<T> MySuperConnection for T
where T: Connection<Backend = SomeBackend>, 
           SomeUpdateType: SaveChangesDsl<T>,
           SomeOtherUpdateType: SaveChangesDsl<T>,
           // … more types here
{}