I/O CSV/Parquet

Leia e escreva CSV e Parquet em Rust com esquemas previsíveis, compressão e desempenho de varredura.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

use polars::prelude::*;
 
fn csv_to_parquet(csv_path: &str, parquet_path: &str) -> PolarsResult<()> {
    let mut df = CsvReadOptions::default()
        .with_has_header(true)
        .try_into_reader_with_file_path(Some(csv_path.into()))?
        .finish()?;
    ParquetWriter::new(std::fs::File::create(parquet_path)?)
        .with_compression(ParquetCompression::Zstd(None))
        .finish(&mut df)?;
    Ok(())
}

Quando usar isso:

• ETL de zona de pouso a partir de exportações CSV de fornecedores
• Publicação de conjuntos de dados analíticos para consumidores DuckDB, Spark ou Polars
• Redução de armazenamento e egress com compressão colunar
• Validação de esquemas na ingestão antes do SQL downstream

Exemplo de Trabalho

use polars::prelude::*;
 
fn main() -> PolarsResult<()> {
    let schema = Schema::from_iter([
        Field::new("order_id".into(), DataType::Int64),
        Field::new("region".into(), DataType::String),
        Field::new("amount".into(), DataType::Float64),
    ]);
 
    let df = CsvReadOptions::default()
        .with_has_header(true)
        .with_schema(Some(Arc::new(schema)))
        .try_into_reader_with_file_path(Some("orders.csv".into()))?
        .finish()?;
 
    let filtered = df
        .lazy()
        .filter(col("amount").gt(lit(0.0)))
        .collect()?;
 
    let mut out = filtered.clone();
    ParquetWriter::new(std::fs::File::create("orders_clean.parquet")?)
        .with_row_group_size(Some(128_000))
        .finish(&mut out)?;
 
    Ok(())
}

O que isso demonstra:

• Fornecimento de um esquema CSV explícito em vez de inferir tipos
• Filtragem de linhas inválidas antes de gravar Parquet
• Definição do tamanho do grupo de linhas para predicate pushdown posterior

Mergulho Profundo

Como Funciona

• CSV é texto de linha - os parsers devem inferir ou aceitar dtypes por coluna.
• Parquet armazena blocos de colunas tipados com estatísticas por grupo de linhas (mín/máx).
• Leitores pulam grupos de linhas quando predicados contradizem estatísticas.
• Gravadores escolhem compressão (Snappy, ZSTD, Gzip) por codificação de coluna.

Comparação de Formatos

Notas de Rust

// Varredura Lazy evita carregar CSV completo:
LazyCsvReader::new("big.csv".into()).with_has_header(true).finish()?;
 
// Ler subconjunto de colunas Parquet:
LazyFrame::scan_parquet("big.parquet", ScanArgsParquet::default())?
    .select([col("user_id"), col("event_time")]);

Armadilhas

• Decimais CSV específicos de localidade - 1,5 vs 1.5 quebram a inferência. Correção: normalize arquivos ou defina o separador decimal nas opções.
• BOM UTF-8 em cabeçalhos - o primeiro nome de coluna inclui BOM invisível. Correção: remova o BOM ou use pré-processamento utf8-lossy.
• Grupos de linhas enormes - pushdown ruim e picos de memória na leitura. Correção: mire 128K-1M de linhas por grupo, dependendo da largura.
• Gravação de Utf8 para tudo - Parquet ainda armazena strings, mas perde estatísticas numéricas. Correção: converta antes de gravar.
• Anexar Parquet concatenando arquivos - grupos de linhas duplicados e conflitos de esquema. Correção: grave diretórios de conjuntos de dados particionados com esquema consistente.

Alternativas

FAQs

Relacionados

• Polars - API de I/O principal nos exemplos
• Streaming & Large Data - CSV em chunks
• Apache Arrow - formato de destino em memória
• Building Data CLIs & Services - wrappers CLI

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.