Diesel generic implementation of insert, update and delete won't work with tables

I've been trying to assemble a generic implementation of our database layer written using diesel in preparation for a migration from our current db.

However despite getting a working trait, it refuses to work with tables created using the table! macro.

Trait

use diesel::{
    query_builder::{InsertStatement, UpdateStatement, IntoUpdateTarget, DeleteStatement, AsQuery, QueryFragment},
    query_dsl::{
        methods::ExecuteDsl,
    },
    r2d2::R2D2Connection,
    Table, 
    RunQueryDsl, associations::HasTable, AsChangeset, Connection, 
};

pub trait DataStore {

    type Conn: R2D2Connection + 'static;

    fn insert<T, M>(conn: &mut Self::Conn, records: M)
    where
        T: Table +  HasTable<Table = T> ,
        M: diesel::Insertable<T>,
        T::FromClause: QueryFragment<<Self::Conn as Connection>::Backend>,
        InsertStatement<T, M::Values>: ExecuteDsl<Self::Conn>,
    {
        diesel::insert_into(T::table()).values(records).execute(conn);
    }

    fn update<T, U, V>(conn: &mut Self::Conn, table: T, values: V)
    where
        T: IntoUpdateTarget +  HasTable<Table = T> + Table,
        V: diesel::query_builder::AsChangeset<Target = T>,
        UpdateStatement<T, <T as IntoUpdateTarget>::WhereClause, <V as AsChangeset>::Changeset>: AsQuery +  ExecuteDsl<Self::Conn>,
    {
        diesel::update(T::table()).set(values).execute(conn);
    }

    fn delete<T, U, V>(conn: &mut Self::Conn, table: T, values: V)
    where
        T: IntoUpdateTarget + HasTable<Table = T> + Table,
        V: diesel::query_builder::AsChangeset<Target = T>,
        DeleteStatement<T, <T as IntoUpdateTarget>::WhereClause>: AsQuery + ExecuteDsl<Self::Conn> {
            diesel::delete(T::table()).execute(conn);
    }

}

Table

diesel::table! {
    testing (code) {
        code -> Text,
        user_id -> Integer,
    }
}

Usage

//! Module for database related stuff.
pub use diesel::Connection;

use super::DataStore;

/// Connection to the DB.
pub struct PgConn(diesel::pg::PgConnection);

impl DataStore for diesel::pg::Pg {
    type Conn = diesel::pg::PgConnection;
}

impl std::fmt::Debug for PgConn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "PgConn(..)")
    }
}

#[derive(Clone, Debug, Default, Eq, Insertable, PartialEq, Queryable, Selectable)]
#[diesel(table_name = testing)]
pub struct TestingRow {
    /// Code used to sign up
    pub code: String,
    /// user_id 
    pub user_id: i32,
}

pub struct DbWrapper<Db: R2D2Connection + 'static,  T: DataStore<Conn = Db> > {
    db: Db,
    phantom: PhantomData<T>
}

impl<Db: R2D2Connection + 'static, T: DataStore<Conn = Db>> DbWrapper<Db, T> {
  pub fn insert_row(&self, row: &TestingRow) -> Result<()> {
        // Error occurs here
        T::insert::<testing, _>(*self.db.get(), row.clone());
        Ok(())
  }

}

Reference

My implementation was based off the answer available here: https://stackoverflow.com/questions/58589018/writing-diesel-crud-operations-for-generic-types

To call a method with generic arguments the compiler must verify that all generic bounds are valid. In your case you are calling that method inside of another generic context, which means that there are a few bounds that cannot be verified without placing restrictions on the generic bounds in the outer context. That affects all the bounds that depend on your Db or T generic type.
You can fix that by duplicating the relevant bounds from DataStore::insert on the DbWrapper impl and replacing some parts with the correct specific types there:

impl<Db: R2D2Connection + 'static, T: DataStore<Conn = Db>> DbWrapper<Db, T>
where
    <testing::table as QuerySource>::FromClause: QueryFragment<<Db as Connection>::Backend>,
    InsertStatement<testing::table, <TestingRow as diesel::Insertable<testing::table>>::Values>: ExecuteDsl<Db>,
{
    fn get(&self) -> &mut Db {
        todo!()
    }

    pub fn insert_row(&self, row: &TestingRow) -> QueryResult<()> {
        T::insert::<testing::table, _>(&mut *self.get(), row.clone());
        Ok(())
    }
}

That written: It's generally not advised to write generic diesel code in that way as it leads to complex trait bounds really soon.