Struct CsvItemWriter 

pub struct CsvItemWriter<O, W: Write> { /* private fields */ }

Available on crate feature csv only.

A CSV writer that implements the ItemWriter trait.

This writer serializes Rust structs to CSV format and writes them to the underlying destination (file, memory buffer, etc.)

Type Parameters

• T: The type of writer destination, must implement Write trait

Implementation Details

• Uses RefCell for interior mutability of the CSV writer
• Integrates with serde for serialization of custom types
• Handles serialization of batch items one by one
• Converts CSV errors to Spring Batch errors

Ownership Considerations

The writer borrows its destination mutably. When writing to a buffer:

• The buffer will be borrowed for the lifetime of the writer
• To read from the buffer after writing, ensure the writer is dropped first
• One approach is to use a separate scope for the writer operations

Examples

use spring_batch_rs::item::csv::csv_writer::CsvItemWriterBuilder;
use spring_batch_rs::core::item::ItemWriter;
use serde::Serialize;

#[derive(Serialize)]
struct Record {
    id: u32,
    name: String,
}

// Create records to write
let records = vec![
    Record { id: 1, name: "Alice".to_string() },
    Record { id: 2, name: "Bob".to_string() },
];

// Write records to a CSV string
let mut buffer = Vec::new();
{
    // Create a new scope for the writer to ensure it's dropped before we read the buffer
    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_writer(&mut buffer);

    writer.write(&records).unwrap();
    ItemWriter::<Record>::flush(&writer).unwrap();
} // writer is dropped here, releasing the borrow on buffer

// Now we can safely read from the buffer
let csv_content = String::from_utf8(buffer).unwrap();
assert!(csv_content.contains("id,name"));
assert!(csv_content.contains("1,Alice"));
assert!(csv_content.contains("2,Bob"));

Trait Implementations

impl<O: Serialize, W: Write> ItemWriter<O> for CsvItemWriter<O, W>

fn write(&self, items: &[O]) -> ItemWriterResult

Writes a batch of items to CSV.

This method serializes each item in the provided slice to CSV format and writes it to the underlying destination.

Serialization Process

1. For each item in the batch:
   • Serialize the item to CSV format using serde
   • Write the serialized row to the underlying destination
2. If any item fails to serialize, return an error immediately

Note: This method doesn’t flush the writer. You need to call flush() explicitly when you’re done writing.

Parameters

• items: A slice of items to be serialized and written

Returns

• Ok(()) if successful
• Err(BatchError) if writing fails

Examples

use spring_batch_rs::item::csv::csv_writer::CsvItemWriterBuilder;
use spring_batch_rs::core::item::ItemWriter;
use serde::Serialize;

#[derive(Serialize)]
struct Person {
    name: String,
    age: u8,
}

// Create people to write
let people = vec![
    Person { name: "Alice".to_string(), age: 28 },
    Person { name: "Bob".to_string(), age: 35 },
];

// Write to a buffer in a separate scope
let mut buffer = Vec::new();
{
    let writer = CsvItemWriterBuilder::new()
        .from_writer(&mut buffer);

    // Write the batch of people
    writer.write(&people).unwrap();
    ItemWriter::<Person>::flush(&writer).unwrap();
}

fn flush(&self) -> ItemWriterResult

Flush the contents of the internal buffer to the underlying writer.

If there was a problem writing to the underlying writer, then an error is returned.

Note that this also flushes the underlying writer.

Important

You must call this method when you’re done writing to ensure all data is written to the destination. The write method buffers data internally for efficiency, and flush ensures it’s all written out.

When to Call

• After writing all items in a batch
• Before dropping the writer if you need the data immediately
• When closing a file to ensure all data is written

Returns

• Ok(()) if successful
• Err(BatchError) if flushing fails

Examples

use spring_batch_rs::item::csv::csv_writer::CsvItemWriterBuilder;
use spring_batch_rs::core::item::ItemWriter;
use serde::Serialize;

#[derive(Serialize)]
struct Record {
    id: u32,
    value: String,
}

// Write to a buffer in a separate scope
let mut buffer = Vec::new();
{
    let writer = CsvItemWriterBuilder::new()
        .from_writer(&mut buffer);

    // Write some records
    let records = vec![Record { id: 1, value: "test".to_string() }];
    writer.write(&records).unwrap();

    // Ensure all data is written - specify type explicitly
    ItemWriter::<Record>::flush(&writer).unwrap();
}

fn open(&self) -> ItemWriterResult

Opens the writer.

fn close(&self) -> ItemWriterResult

Closes the writer.