在Rust与SQLx中正确处理层级数据的实现方案咨询

问题1：让SQLx正确映射array_agg结果到customers字段 #

SQLx目前确实不支持直接将PostgreSQL的RECORD[]类型映射到Rust的Vec<CustomerData>，但可以通过改用json_agg聚合为JSON数组的方式解决，这是最简洁高效的方案：

实现代码 #

#[derive(Serialize, Deserialize)]
struct CustomerData {
    pub id: Uuid,
    pub name: String
}

#[derive(Serialize, Deserialize)]
struct UserData {
    pub id: Uuid,
    pub email: String,
    pub customers: Vec<CustomerData>
}

// 查询逻辑
let result = sqlx::query_as!(
    UserData,
    r#"
    SELECT 
        U.id, 
        U.email, 
        -- 用json_agg构造JSON数组，COALESCE确保无客户时返回空数组
        COALESCE(json_agg(json_build_object('id', C.id, 'name', C.name)), '[]'::json) as "customers!: Vec<CustomerData>"
    FROM users U 
    LEFT JOIN customers C ON C.user_id = U.id
    GROUP BY U.id
    "#
)
.fetch_all(pool.as_ref())
.await?;

关键说明 #

• json_agg会将聚合结果转为PostgreSQL的JSON数组类型，SQLx可直接将其反序列化为Vec<CustomerData>（需给结构体派生Deserialize）。
• json_build_object精准控制返回字段，避免包含数据库中多余字段。
• COALESCE配合LEFT JOIN确保无关联客户的用户返回[]空数组，而非null，符合JSON响应的预期格式。

如果坚持使用array_agg，需要自定义SQLx类型映射，但步骤繁琐且无必要，优先推荐json_agg方案。

问题2：多层级结构时的方案选择 #

两层关联（如用户->客户）：单查询聚合更优 #

对于简单的两层嵌套，json_agg单查询方案性能更好，仅需一次数据库往返，避免多次查询的网络开销，代码也相对简洁。

多层级关联（如用户->客户->订单->商品）：拆分多查询更合适 #

若嵌套层级超过2层，单查询会带来两个核心问题：

1. 数据冗余严重：上层数据（用户、客户）会在每个下层数据（订单、商品）行重复，导致返回数据量暴增。
2. SQL复杂度爆炸：多层嵌套的聚合与JOIN会让SQL语句难以维护，调试成本极高。

此时拆分多查询是更优选择，步骤如下：

1. 先查询所有用户列表：

   let users: Vec<UserData> = sqlx::query_as!(UserData, "SELECT id, email FROM users")
       .fetch_all(pool.as_ref())
       .await?;
   

2. 提取所有用户ID，批量查询关联客户（按user_id分组）：

   let user_ids: Vec<Uuid> = users.iter().map(|u| u.id).collect();
   let customers: Vec<(Uuid, CustomerData)> = sqlx::query_as!(
       (Uuid, CustomerData),
       "SELECT user_id, id, name FROM customers WHERE user_id = ANY($1)",
       &user_ids
   )
   .fetch_all(pool.as_ref())
   .await?;
   

3. 在Rust代码中将客户关联到对应用户：

   let mut user_map: HashMap<Uuid, UserData> = users.into_iter().map(|u| (u.id, u)).collect();
   for (user_id, customer) in customers {
       user_map.get_mut(&user_id).unwrap().customers.push(customer);
   }
   let result: Vec<UserData> = user_map.into_values().collect();
   

这种方式代码结构清晰，易扩展到更多层级，虽多了几次查询，但批量查询的开销远小于单查询数据冗余带来的性能损耗。

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