Rust代码重构优化：解决借用错误与冗余Vector克隆问题

1. 避免分组时克隆Vector的优化方案 #

方案1：转移所有权（优先推荐） #

如果不需要保留原始数据集合，直接将查询得到的Vec<Data>的元素所有权转移到分组的HashMap中，完全无需克隆：

use std::collections::HashMap;
use diesel::prelude::*;
use crate::schema::data;

#[derive(Queryable, Debug)]
struct Data {
    id: i32,
    group_id: i32,
    value: String,
}

fn group_data_without_clone(data: Vec<Data>) -> HashMap<i32, Vec<Data>> {
    let mut groups = HashMap::new();
    for item in data {
        groups.entry(item.group_id).or_default().push(item);
    }
    groups
}

// 调用示例
let conn = establish_connection();
let data = data::table.load(&conn)?;
let groups = group_data_without_clone(data);

方案2：使用引用分组（需保留原始数据） #

若必须保留原始数据，通过引用而非克隆来构建分组，仅需确保引用生命周期合法：

fn group_data_with_refs<'a>(data: &'a [Data]) -> HashMap<i32, Vec<&'a Data>> {
    let mut groups = HashMap::new();
    for item in data {
        groups.entry(item.group_id).or_default().push(item);
    }
    groups
}

// 调用示例
let mut data = fetch_data(&conn)?;
let groups = group_data_with_refs(&data);
// 后续仍可使用原始data（只要groups的生命周期不超过data）

方案3：数据库层面分组（极致优化） #

如果分组逻辑仅需统计或聚合，直接通过Diesel在数据库层面完成分组，减少内存开销：

let group_stats = data::table
    .select((data::group_id, diesel::dsl::count(data::id)))
    .group_by(data::group_id)
    .load::<(i32, i64)>(&conn)?;

2. 拆分复杂函数解决借用冲突 #

原函数的借用错误（不可变借用后无法可变借用）本质是同一作用域内同时存在同一数据的可变与不可变引用，通过拆分函数明确职责与作用域即可解决：

拆分步骤 #

将原函数拆分为3个单一职责的函数：

1. 从数据库查询数据
2. 处理/修改数据（可变借用）
3. 对数据进行分组（不可变借用）

// 1. 单独负责数据查询
fn fetch_data(conn: &PgConnection) -> Result<Vec<Data>, diesel::result::Error> {
    data::table.load(conn)
}

// 2. 单独负责数据修改（可变借用）
fn process_data_items(data: &mut [Data]) {
    data.iter_mut().for_each(|item| {
        item.value.push_str("_processed");
    });
}

// 3. 单独负责数据分组（不可变借用）
fn group_data<'a>(data: &'a [Data]) -> HashMap<i32, Vec<&'a Data>> {
    let mut groups = HashMap::new();
    for item in data {
        groups.entry(item.group_id).or_default().push(item);
    }
    groups
}

// 调用时按顺序执行，避免同时借用
fn main() -> Result<(), diesel::result::Error> {
    let conn = establish_connection();
    let mut data = fetch_data(&conn)?;
    
    // 先完成可变借用操作
    process_data_items(&mut data);
    
    // 再进行不可变借用操作
    let groups = group_data(&data);
    
    // 后续逻辑...
    Ok(())
}

若需分组后修改数据 #

如果必须在分组后修改元素，可通过可变引用分组实现，确保同一时间仅有一个可变引用：

fn group_data_mut<'a>(data: &'a mut [Data]) -> HashMap<i32, Vec<&'a mut Data>> {
    let mut groups = HashMap::new();
    for item in data.iter_mut() {
        groups.entry(item.group_id).or_default().push(item);
    }
    groups
}

// 调用示例
let mut data = fetch_data(&conn)?;
let mut groups = group_data_mut(&mut data);
for (_, items) in groups.iter_mut() {
    for item in items {
        item.value.push_str("_group_processed");
    }
}

内容的提问来源于stack exchange，提问作者RfDzDeveloper