Generic Repository Trait

[leobelen]

I am new to Diesel, and I have a project with nearly 100 tables. As a consequence, I would like to have a trait with common queries to implement on each of them, such as find_all, count, insert, delete, and update. Now, I was able to create a trait that at least compile with all but update which is showing below:

pub trait BaseRepositoryTrait<TABLE, MODEL>
where
    TABLE: diesel::Table + diesel::associations::HasTable<Table = TABLE>,
{
    /// Gets the role by ID or none if none found
    /// # Arguments
    /// * `connection` the db connection object.
    /// * `obj_id` the id of the object to find.
    /// # Returns
    /// An optional object if found
    fn find_by_id(
        connection: &DbConnection,
        id: TABLE::PrimaryKey,
    ) -> Result<MODEL, diesel::result::Error>
    where
        TABLE: diesel::query_dsl::methods::FindDsl<<TABLE as diesel::Table>::PrimaryKey>,
        dsl::Find<TABLE, TABLE::PrimaryKey>: RunQueryDsl<DbConnection> + LimitDsl,
        dsl::Limit<dsl::Find<TABLE, TABLE::PrimaryKey>>: LoadQuery<DbConnection, MODEL>,
    {
        TABLE::table().find(id).first(connection)
    }

    /// Returns all objects in the table.
    /// # Arguments
    /// * `connection` the db connection object.
    /// # Returns
    /// The list of all objects
    fn find_all(connection: &DbConnection) -> Result<Vec<MODEL>, diesel::result::Error>
    where
        TABLE: diesel::query_dsl::methods::FindDsl<<TABLE as diesel::Table>::PrimaryKey>,
        dsl::Find<TABLE, TABLE::PrimaryKey>: RunQueryDsl<DbConnection> + LimitDsl,
        dsl::Limit<dsl::Find<TABLE, TABLE::PrimaryKey>>: LoadQuery<DbConnection, MODEL>,
        diesel::pg::Pg: HasSqlType<<TABLE as AsQuery>::SqlType>,
        <TABLE as AsQuery>::Query: QueryFragment<<DbConnection as Connection>::Backend>,
        <TABLE as AsQuery>::Query: QueryId,
        MODEL: Queryable<<TABLE as AsQuery>::SqlType, <DbConnection as Connection>::Backend>,
    {
        TABLE::table().load::<MODEL>(connection)
    }

    /// Inserts an object into the database table.
    /// # Arguments
    /// * `connection` the db connection object.
    /// * `object` the object to insert or update.
    /// # Returns
    /// Ok() or error
    fn insert<'a>(connection: &DbConnection, data: &'a MODEL) -> Result<(), diesel::result::Error>
    where
        &'a MODEL: Insertable<TABLE> + UndecoratedInsertRecord<TABLE>,
        <&'a MODEL as Insertable<TABLE>>::Values: QueryFragment<<DbConnection as Connection>::Backend>
            + CanInsertInSingleQuery<<DbConnection as Connection>::Backend>,
        TABLE::FromClause: QueryFragment<<DbConnection as Connection>::Backend>,
        InsertStatement<TABLE, <&'a MODEL as Insertable<TABLE>>::Values>: RunQueryDsl<DbConnection>,
    {
        diesel::insert_into(TABLE::table())
            .values(data)
            .execute(connection)?;
        Ok(())
    }

    
    /// Deletes an object into the database table.
    /// # Arguments
    /// * `connection` the db connection object.
    /// * `obj_id` the object id delete.
    /// # Returns
    /// The count of objects deleted.
    fn delete_by_id<'a>(
        connection: &DbConnection,
        id: &'a TABLE::PrimaryKey,
    ) -> Result<(), diesel::result::Error>
    where
        TABLE: diesel::query_dsl::methods::FindDsl<&'a <TABLE as diesel::Table>::PrimaryKey>,
        dsl::Find<TABLE, &'a TABLE::PrimaryKey>: IntoUpdateTarget<Table = TABLE>,
        TABLE::FromClause: QueryFragment<<DbConnection as Connection>::Backend>,
        <dsl::Find<TABLE, &'a TABLE::PrimaryKey> as IntoUpdateTarget>::WhereClause:
            QueryFragment<<DbConnection as Connection>::Backend> + QueryId,
        TABLE: QueryId,
    {
        diesel::delete(TABLE::PrimaryKey).execute(connection)?;
        Ok(())
    }
}

However, I am failing to create a simple generic update function for the trait. Isolated, so far it looks like

pub trait BaseUpdateRepositoryTrait<TABLE, MODEL>
where
    TABLE:
        diesel::Table + diesel::associations::HasTable<Table = TABLE> + IntoUpdateTarget + QueryId,
{
    /// Inserts or updates an object into the database table.
    /// # Arguments
    /// * `connection` the db connection object.
    /// * `object` the object to insert or update.
    /// # Returns
    /// The count of objects inserted.
    fn update<'a>(connection: &DbConnection, object: &'a MODEL) -> Result<(), diesel::result::Error>
    where
        <TABLE as QuerySource>::FromClause: QueryFragment<<DbConnection as Connection>::Backend>,
        <TABLE as diesel::Table>::PrimaryKey: Column,
        <TABLE::Table as diesel::QuerySource>::FromClause:
            diesel::query_builder::QueryFragment<<DbConnection as Connection>::Backend>,
        &'a MODEL: diesel::Insertable<TABLE::Table> + AsChangeset,
        <&'a MODEL as diesel::Insertable<TABLE>>::Values: UndecoratedInsertRecord<TABLE>,
        &'a MODEL: diesel::Insertable<TABLE>,
    {
        diesel::insert_into(TABLE::table())
            .values(object)
            .on_conflict(TABLE::table().primary_key())
            .do_update()
            .set(object)
            .execute(connection)
    }
}

But it keeps returning weird unmet dependencies... how should I do a generics update function the proper diesel way? For some reason it is not really that common to adopt an strategy to create traits as you would do with a repository since I have search on google, this repo, the official docs and many other sources without any clear answer. Although I admit I may not have look where I should.

Best regards, and thank you for your help.

[weiznich]

I fear its near to impossible to help you here. Please consider adding the following information to support other people understanding your problem:

• Rust, diesel and database version you are using
• Definition of all used types (as long as they are not part of diesel or std)
• Any use statement in scope
• An exemplary call to your generic function including all type used for that call.
• The corresponding error message for that call above with the current code version.

[leobelen]

Answering your questions:
rust: 1.54.0 (a178d0322 2021-07-26) - on a mac catalina.
Diesel: 1.4.7
There is a minimal example on https://github.com/leobelen/antares_test

Thanks for your help and time.

[weiznich]

I'm on mobile for the next time, so I cannot try to code on my own. As you didn't include any concrete indications on what went wrong I fear I cannot help you here any further.

[Katsutoshii]

+1 to this question, I have a similar need to define shared behavior over multiple tables but have found it difficult to abstract over different table types.

[weiznich]

@Katsutoshii As already stated above: It's not possible to generally answer such questions in detail, without having details about your setup. So if you are interested in a more detailed answer add any nessesary details.
Generally speaking it's possible to abstract over multiple tables, but you need to full full a trait bounds requested by any methods you want to use. This normally involves writing large where clauses. My general advice here is to just not do that if you don't plan to write a library crate that is reusable by a lot of people.