在 Rust 中使用带有 serde 的嵌套枚举/结构序列化/反序列化 CSV

Question

I want to serialize/deserialize a CSV file with variable row length and content, like the following:

./test.csv

Message,20200202T102030,Some message content
Measurement,20200202T102031,10,30,40,2
AnotherMeasurement,20200202T102034,0,2

In my opinion, the easiest way to represent this is the following enum :

#[derive(Debug, Serialize, Deserialize)]
pub enum Record {
    Message { timestamp: String, content: String }, // timestamp is String because of simplicity
    Measurement { timestamp: String, a: u32, b: u32, c: u32, d: u32 },
    AnotherMeasurement { timestamp: String, a: u32, b: u32 },
}

Cargo.toml

[dependencies]¬
csv = "^1.1.6"¬
serde = { version = "^1", features = ["derive"] }

Running the following

main.rs

fn example() -> Result<(), Box<dyn Error>> {
    let mut rdr = csv::ReaderBuilder::new()
        .has_headers(false)
        .delimiter(b',')
        .flexible(true)
        .double_quote(false)
        .from_path("./test.csv")
        .unwrap();
    for result in rdr.deserialize() {
        let record: Record = result?;
        println!("{:?}", record);
    }
    Ok(())
}

fn write_msg() -> Result<(), Box<dyn Error>> {
    let msg = Record::Message {
        timestamp: String::from("time"),
        content: String::from("content"),
    };
    let mut wtr = csv::WriterBuilder::new()
        .has_headers(false)
        .flexible(true)
        .double_quote(false)
        .from_writer(std::io::stdout());
    wtr.serialize(msg)?;
    wtr.flush()?;
    Ok(())
}

fn main() {
    if let Err(err) = example() {
        println!("error running example: {}", err);
    }
    if let Err(err) = write_msg() {
        println!("error running example: {}", err);
    }
}

prints

error running example: CSV deserialize error: record 0 (line: 1, byte: 0): invalid type: unit variant, expected struct variant
error running example: CSV write error: serializing enum struct variants is not supported

Is there an easy solution to do this with serde and csv ? I feel like I missed one or two serde attributes, but I was not able to find the right one in the documentation yet.

EDITS

Netwave suggested adding the #[serde(tag = "type")] attribute. Serializing now works, Deserializing gives the following error:

error running example: CSV deserialize error: record 0 (line: 1, byte: 0): invalid type: string "Message", expected internally tagged enum Record

---

Research I did that did not lead to a solution yet

Is there a way to "flatten" enums for (de)serialization in Rust?

https://docs.rs/csv/1.1.6/csv/tutorial/index.html

Custom serde serialization for enum type

https://serde.rs/enum-representations.html

Answer 1

Make yourenum tagged (internally tagged specifically):

#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Record {
    Message { timestamp: String, content: String }, // timestamp is String because of simplicity
    Measurement { timestamp: String, a: u32, b: u32, c: u32, d: u32 },
    AnotherMeasurement { timestamp: String, a: u32, b: u32 },
}

Playground