Polars

A biblioteca DataFrame rápida para Rust - otimização de consulta lazy, execução vetorizada e layout de memória com base em Arrow.

Receita

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

use polars::prelude::*;
 
fn top_spenders(path: &str) -> PolarsResult<DataFrame> {
    LazyCsvReader::new(path.into())
        .with_has_header(true)
        .finish()?
        .group_by([col("customer_id")])
        .agg([col("amount").sum().alias("total")])
        .sort(["total"], SortMultipleOptions::default())
        .limit(10)
        .collect()
}

Quando usar isso:

• Substituindo scripts pandas que gargalam em loops Python single-threaded
• ETL onde você precisa de pushdown de predicado lazy em CSV ou Parquet
• Análises in-process sem configurar Spark ou DuckDB como um serviço
• Serviços Rust que já usam Arrow e precisam de uma API DataFrame

Exemplo de Trabalho

use polars::prelude::*;
 
fn main() -> PolarsResult<()> {
    let df = df! {
        "region" => ["west", "east", "west", "north"],
        "amount" => [120i64, 80, 200, 50],
    }?;
 
    let summary = df
        .lazy()
        .filter(col("amount").gt(lit(60)))
        .group_by([col("region")])
        .agg([
            col("amount").sum().alias("total"),
            col("amount").mean().alias("avg"),
        ])
        .sort(["total"], SortMultipleOptions::default())
        .collect()?;
 
    println!("{}", summary);
    Ok(())
}

O que isso demonstra:

• Construindo um pequeno frame em memória para testes e protótipos
• Mudando para o modo lazy com .lazy() para execução otimizada
• Agregações group-by com múltiplas expressões em um único plano

Mergulho Profundo

Como Funciona

• Polars armazena colunas em buffers compatíveis com Arrow para varreduras amigáveis ao cache.
• A API Lazy constrói um plano lógico; o otimizador reordena filtros e projeções.
• collect() executa o plano - esse é o limite do seu pico de memória e CPU.
• Métodos Eager DataFrame rodam imediatamente - modelo mental mais simples, menos otimizações.

Lazy vs Eager

Notas de Rust

// Prefira aliases explícitos em agg - expressões sem nome são difíceis de identificar em planos explain.
.col("amount").sum().alias("total")
 
// Use .explain() em planos lazy durante o desenvolvimento.
println!("{}", lf.explain(true)?);

Armadilhas

• Coletando muito cedo - chamar collect() após cada etapa anula a otimização lazy. Correção: encadeie transformações, colete uma vez no final.
• Colunas numéricas com tipo string - a inferência de CSV padrão é Utf8. Correção: passe with_dtypes ou faça o cast após o carregamento.
• Discrepância de dtype da chave de join - chaves i32 vs i64 silenciosamente descartam linhas. Correção: faça o cast de ambos os lados para o mesmo tipo antes do join.
• Assumindo semântica de índice pandas - Polars não tem índice oculto; joins usam chaves explícitas. Correção: adicione uma coluna id quando precisar de identidade de linha estável.
• OOM em Parquet largo - select * em 500 colunas carrega tudo. Correção: projete apenas as colunas necessárias na varredura lazy.

Alternativas

FAQs

Relacionados

• Noções Básicas de Dados - orientação da seção
• Apache Arrow - memória colunar sob Polars
• I/O de CSV/Parquet - ajuste de I/O
• Streaming e Dados Grandes - processamento em chunks

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+.