csv

To use this crate in your Rust project, add csv to your Cargo.toml file or use the cargo add command.

cargo add csv

To use csv-index in your Rust project, add it to your Cargo.toml dependencies file.

[dependencies]
csv-index = "0.1.6"

Add csv-core to your Cargo.toml dependencies to use this fast CSV reader and writer in no_std contexts. This crate does not use the Rust standard library.

[dependencies]
csv-core = "0.1.6"

The csv-core crate provides high-performance CSV reader and writer APIs specifically designed for no_std environments. It does not use the Rust standard library.

Note: If you require more ergonomic or high-level CSV parsing routines, use the csv crate instead. csv-core is intended for low-level, performance-critical, or resource-constrained applications.

A ByteRecord stores a single CSV record as raw bytes. This is useful when you need to handle CSV rows that are not valid UTF-8. While StringRecord is generally more ergonomic, ByteRecord is necessary for:

1. Deserializing fields that contain invalid UTF-8.
2. Using Serde to read into borrowed data like &'a str or &'a [u8].

Two ByteRecords are compared based on their field data; position information is ignored during equality checks.

use csv::ByteRecord;

let record = ByteRecord::new();

A StringRecord is a single CSV record stored as valid UTF-8 bytes. It is used when you need to work with text data and want to ensure all fields are valid UTF-8.

Important Considerations:

• Invalid UTF-8: If you attempt to read CSV data that contains invalid UTF-8 into a StringRecord, the reader will return a FromUtf8Error. If your data contains invalid UTF-8, use ByteRecord instead, as it makes no assumptions about UTF-8 encoding.
• Serde Integration: While StringRecord can be used with Serde, if you need to deserialize fields that might contain invalid UTF-8, you should first read the row into a ByteRecord and then use ByteRecord::deserialize.

use csv::StringRecord;

let record = StringRecord::new();

The csv crate prioritizes finding a parse over rejecting data. Because CSV data is highly variable, the parser attempts to find a way to interpret the data even if it seems malformed.

Common error scenarios include:

• Unequal Lengths: Occurs when a record has a different number of fields than previous records (unless .flexible(true) is used).
• IO Errors: Occurs when reading from the underlying resource (e.g., a file) fails. Subsequent read attempts after an IO error will behave as if EOF was reached to prevent infinite loops.
• UTF-8 Errors: Occurs when reading StringRecords if the data contains invalid UTF-8. To handle invalid UTF-8, use the byte-oriented ByteRecord API instead.
• Serde Errors: Occurs when deserializing CSV data into specific Rust types (e.g., trying to parse a non-numeric string into an i32).

By default, the csv reader expects every record to have the same number of fields as the first record (or the header). If a record has a different length, an ErrorKind::UnequalLengths error is returned.

To allow records with varying numbers of fields, enable the flexible option in the ReaderBuilder.

Error Details: When an UnequalLengths error occurs, it contains:

• pos: The Position of the error.
• expected_len: The number of fields expected.
• len: The actual number of fields found.

By default, the csv crate enforces that all records have the same number of fields. If a record is encountered with a different number of fields than a previous record, an error of type ErrorKind::UnequalLengths is returned.

To allow records to have varying numbers of fields, enable flexible parsing using .flexible(true) on the ReaderBuilder.