在Rust中通过trait兼容可变与不可变泛型类型的实现方案

你的问题核心在于Pool<Postgres>的共享引用即可实现Executor，但Transaction<Postgres>必须用可变引用才能实现该Trait。要让CRUD逻辑兼容两者，最优雅的方式是通过自定义Trait封装不同连接类型的Executor获取逻辑，避免重复代码。

1. 定义统一的数据库连接Trait #

创建一个DbConnTrait，为不同连接类型提供一致的Executor获取方法：

use sqlx::{Executor, Postgres};

/// 统一数据库连接的Executor获取接口
pub trait DbConn {
    /// 返回可用于执行SQL的Executor实例
    fn as_executor(&mut self) -> impl Executor<'_, Database = Postgres>;
}

2. 为连接池和事务实现Trait #

分别为PgPool和PgTransaction实现DbConnTrait，适配各自的Executor要求：

use sqlx::postgres::{PgPool, PgTransaction};

// 为连接池实现：&mut PgPool会自动Deref为&PgPool，满足Executor约束
impl DbConn for PgPool {
    fn as_executor(&mut self) -> impl Executor<'_, Database = Postgres> {
        self
    }
}

// 为事务实现：直接返回&mut Transaction，满足Executor约束
impl DbConn for PgTransaction<'_> {
    fn as_executor(&mut self) -> impl Executor<'_, Database = Postgres> {
        self
    }
}

3. 修改Database结构体与CRUD方法 #

调整Database的泛型约束为自定义的DbConn，并在CRUD方法中通过as_executor()统一获取Executor：

// 假设你有一个User模型
#[derive(Debug, sqlx::FromRow)]
pub struct User {
    pub id: i32,
    pub name: String,
    pub email: String,
}

pub struct Database<T>
where
    T: DbConn + Send + Sync,
{
    conn: T,
}

impl<T> Database<T>
where
    T: DbConn + Send + Sync,
{
    pub fn new(conn: T) -> Self {
        Self { conn }
    }

    // 示例：根据ID查询用户
    pub async fn get_user(&mut self, user_id: i32) -> Result<User, sqlx::Error> {
        let user = sqlx::query_as!(
            User,
            "SELECT id, name, email FROM users WHERE id = $1",
            user_id
        )
        .fetch_one(self.conn.as_executor())
        .await?;
        Ok(user)
    }

    // 示例：创建用户
    pub async fn create_user(&mut self, name: &str, email: &str) -> Result<User, sqlx::Error> {
        let user = sqlx::query_as!(
            User,
            "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email",
            name,
            email
        )
        .fetch_one(self.conn.as_executor())
        .await?;
        Ok(user)
    }
}

4. 使用示例 #

无论是连接池还是事务，都可以复用同一套CRUD逻辑：

// 使用连接池
async fn use_pool() -> Result<(), sqlx::Error> {
    let pool = PgPool::connect("postgres://user:pass@localhost/db").await?;
    let mut db = Database::new(pool);
    let user = db.get_user(1).await?;
    println!("{:?}", user);
    Ok(())
}

// 使用事务
async fn use_transaction() -> Result<(), sqlx::Error> {
    let pool = PgPool::connect("postgres://user:pass@localhost/db").await?;
    let mut tx = pool.begin().await?;
    let mut db = Database::new(tx);
    
    let new_user = db.create_user("Alice", "alice@example.com").await?;
    println!("Created user: {:?}", new_user);
    
    // 提交事务
    db.conn.commit().await?;
    Ok(())
}

优势说明 #

• 静态分发：自定义Trait采用静态分发，不会带来动态类型的性能开销
• 保留底层控制权：可以直接操作Database.conn（比如事务的提交/回滚）
• 完全复用：CRUD逻辑无需针对连接池或事务做任何修改

内容的提问来源于stack exchange，提问作者Ahmet Yazıcı