Rust中如何为异构表动态构建ScyllaDB批量语句？

问题描述 #

在Rust中为异构表创建批量语句并通过循环提供对应值时，遇到核心瓶颈：Rust无法动态创建任意大小的元组，而数据库驱动的batch方法第二个参数要求实现BatchValues trait（该 trait 代表一组ValueList），但ValueList无法被对象化，导致自定义实现困难。

尝试的代码如下：

#[derive(Debug, FromRow, ValueList)]
struct Account {
    id: i32,
    name: String,
}

#[derive(Debug, FromRow, ValueList)]
struct User {
    id: i32,
    phone_number: String,
    name: String,
}

struct DBData {
    accounts: Account,
    users: User,
}

impl BatchValues for DBData {
    type BatchValuesIter<'r> = Box<dyn ValueList>
    where
        Self: 'r;

    fn batch_values_iter(&self) -> Self::BatchValuesIter<'_> {
        return BatchValuesFromIter::new(self.accounts.into_iter().chain(self.users.into_iter()));
    }
}

async fn foo() {
    let session: Session = SessionBuilder::new().known_node(uri).build().await.unwrap();
    let mut batch = Batch::default();
    let db_data = DBData { accounts: vec![], users: vec![] };

    for account in accounts {
        batch.append_statement("INSERT INTO accounts (id, name) VALUES (?, ?);");
    }
    for user in users {
        batch.append_statement("INSERT INTO users (id, phone_number, name) VALUES (?, ?, ?);");
    }

    session.batch(&batch, db_data).await.unwrap();
}

运行时报错：ValueList cannot be made into an object

此前的尝试均未解决问题：

• 序列化存储任意长度向量的结构体，但batch仅接受值元组或类型数组
• 使用itertools创建元组，但最多支持15元组，无法适配异构表的动态需求
• 尝试自定义BatchValues实现，但因ValueList无法对象化，无法完成迭代逻辑

解决思路 #

1. 拆分批量操作，分别处理异构表 #

既然异构表结构无法统一为单一ValueList集合，最直接的方式是拆分不同表的批量操作，分别调用batch方法：

async fn foo() {
    let session: Session = SessionBuilder::new().known_node(uri).build().await.unwrap();

    // 处理Account批量插入
    let mut account_batch = Batch::default();
    let accounts: Vec<Account> = vec![/* 填充你的Account数据 */];
    for _ in &accounts {
        account_batch.append_statement("INSERT INTO accounts (id, name) VALUES (?, ?);");
    }
    session.batch(&account_batch, accounts).await.unwrap();

    // 处理User批量插入
    let mut user_batch = Batch::default();
    let users: Vec<User> = vec![/* 填充你的User数据 */];
    for _ in &users {
        user_batch.append_statement("INSERT INTO users (id, phone_number, name) VALUES (?, ?, ?);");
    }
    session.batch(&user_batch, users).await.unwrap();
}

这种方式无需自定义trait实现，利用结构体自动派生的ValueList以及Vec<T>自动实现的BatchValues（当T: ValueList时），直接完成批量操作。

2. 封装统一枚举类型，实现ValueList和BatchValues #

如果必须在一个batch中处理异构操作，可以定义枚举包裹所有异构类型，手动为枚举实现ValueList，再基于枚举的Vec完成批量操作：

#[derive(Debug)]
enum DBRecord {
    Account(Account),
    User(User),
}

// 为DBRecord实现ValueList
impl ValueList for DBRecord {
    fn len(&self) -> usize {
        match self {
            DBRecord::Account(_) => 2, // Account包含2个字段
            DBRecord::User(_) => 3,    // User包含3个字段
        }
    }

    fn try_get(&self, index: usize) -> Result<Value, Error> {
        match self {
            DBRecord::Account(a) => match index {
                0 => Ok(a.id.into()),
                1 => Ok(a.name.clone().into()),
                _ => Err(Error::InvalidIndex(index)),
            },
            DBRecord::User(u) => match index {
                0 => Ok(u.id.into()),
                1 => Ok(u.phone_number.clone().into()),
                2 => Ok(u.name.clone().into()),
                _ => Err(Error::InvalidIndex(index)),
            },
        }
    }
}

async fn foo() {
    let session: Session = SessionBuilder::new().known_node(uri).build().await.unwrap();
    let mut batch = Batch::default();
    let mut records = Vec::new();

    // 添加Account语句和对应数据
    let accounts: Vec<Account> = vec![/* 填充数据 */];
    for account in accounts {
        batch.append_statement("INSERT INTO accounts (id, name) VALUES (?, ?);");
        records.push(DBRecord::Account(account));
    }

    // 添加User语句和对应数据
    let users: Vec<User> = vec![/* 填充数据 */];
    for user in users {
        batch.append_statement("INSERT INTO users (id, phone_number, name) VALUES (?, ?, ?);");
        records.push(DBRecord::User(user));
    }

    // Vec<DBRecord>会自动实现BatchValues
    session.batch(&batch, records).await.unwrap();
}

注意：语句的顺序必须和records中的枚举顺序严格对应，否则会出现参数不匹配的问题。

3. 手动构造动态值列表（Vec<Vec<Value>>） #

如果不想定义枚举，可直接将每条记录转换为Value的向量，再收集成二维向量作为批量值——多数数据库驱动会自动为Vec<Vec<Value>>实现BatchValues：

async fn foo() {
    let session: Session = SessionBuilder::new().known_node(uri).build().await.unwrap();
    let mut batch = Batch::default();
    let mut batch_values = Vec::new();

    // 处理Account数据
    let accounts: Vec<Account> = vec![/* 填充数据 */];
    for account in accounts {
        batch.append_statement("INSERT INTO accounts (id, name) VALUES (?, ?);");
        batch_values.push(vec![
            account.id.into(),
            account.name.into(),
        ]);
    }

    // 处理User数据
    let users: Vec<User> = vec![/* 填充数据 */];
    for user in users {
        batch.append_statement("INSERT INTO users (id, phone_number, name) VALUES (?, ?, ?);");
        batch_values.push(vec![
            user.id.into(),
            user.phone_number.into(),
            user.name.into(),
        ]);
    }

    session.batch(&batch, batch_values).await.unwrap();
}

这种方式灵活性最高，但需要手动处理字段到Value的类型转换，容易因字段顺序错误导致问题。

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