
calamine
Biblioteca de Rust puro para hojas de cálculo
Lee XLS, XLSX, XLSM, XLSB, ODS y más con deserialización sin copias en Rust.
¿Qué es calamine?
calamine es una biblioteca de alto rendimiento y puro Rust para leer y deserializar archivos de hojas de cálculo Excel y OpenDocument. Soporta formatos como XLS, XLSX, XLSM, XLSB, ODS y más, enfocándose en una extracción de datos rápida, segura y sin copias. Diseñada para la fiabilidad y con dependencias mínimas, calamine evita bibliotecas del sistema externas y se basa únicamente en implementaciones puras de Rust. Su API permite a los desarrolladores extraer valores de celdas de manera eficiente, manejar proyectos VBA y analizar fórmulas sin una configuración compleja ni sobrecarga en tiempo de ejecución.
La biblioteca sobresale en aplicaciones críticas de rendimiento, ofreciendo un procesamiento significativamente más rápido que las alternativas en Python, C# y Go. Con integración incorporada de Serde, calamine permite mapear de forma fluida los datos de la hoja de cálculo a estructuras Rust. Soporta carga perezosa para archivos grandes, configuración de fila de encabezado y características opcionales como soporte de fechas/horas con chrono y extracción de datos de imágenes. Ya sea que estés construyendo herramientas CLI, backends web o sistemas embebidos, calamine brinda un rendimiento robusto y predecible en todas las plataformas.
Primeros pasos con calamine
Para comenzar a usar calamine, agrégalo a tu proyecto Rust mediante Cargo. Puedes instalarlo directamente usando cargo add calamine o añadir manualmente la dependencia a tu Cargo.toml. La biblioteca está disponible en crates.io y su código fuente se aloja en calamine GitHub. Para usos avanzados, habilita características opcionales como chrono para soporte de fecha/hora o picture para la extracción de datos de imágenes. La biblioteca se compila limpiamente con Rust estable y no requiere binarios externos ni bibliotecas del sistema.
Instalar calamine mediante Cargo
cargo add calamineDeserialización de hojas de cálculo basada en Serde
calamine ofrece una potente integración con Serde para mapear datos de hojas de cálculo directamente a structs de Rust. Usando RangeDeserializerBuilder, los desarrolladores pueden definir modelos de datos fuertemente tipados y deserializar automáticamente filas en registros estructurados. La biblioteca incluye funciones auxiliares como deserialize_as_f64_or_none y deserialize_as_f64_or_string para manejar columnas de tipo mixto de forma elegante. Este enfoque garantiza la seguridad de tipos, reduce el código repetitivo y permite la validación en tiempo de compilación de las estructuras de datos. Es especialmente útil para pipelines de datos, herramientas de informes y aplicaciones ETL donde la fiabilidad y el rendimiento son críticos.
Deserializar filas de hoja de cálculo en structs de Rust
use calamine::{deserialize_as_f64_or_none, open_workbook, RangeDeserializerBuilder, Reader, Xlsx};
use serde::Deserialize;
#[derive(Deserialize)]
struct Record {
metric: String,
#[serde(deserialize_with = "deserialize_as_f64_or_none")]
value: Option,
}
let mut excel: Xlsx<_> = open_workbook("file.xlsx")?;
let range = excel.worksheet_range("Sheet1")?;
let iter = RangeDeserializerBuilder::with_headers(&["metric", "value"]).from_range(&range)?;
for result in iter {
let record: Record = result?;
println!("{:?}", record);
} Extracción de proyectos VBA y fórmulas
calamine permite la extracción de módulos de proyecto VBA y definiciones de fórmulas de archivos Excel. Los desarrolladores pueden recuperar el código VBA de los módulos, detectar referencias rotas y examinar los nombres definidos y sus fórmulas. Esta capacidad es esencial para herramientas de migración, utilidades de auditoría y análisis de sistemas heredados. La API proporciona acceso estructurado a los metadatos VBA y admite tanto escenarios simples como complejos de introspección de libros de trabajo. Ya sea que estés analizando macros por seguridad o convirtiendo lógica de Excel heredada, calamine ofrece acceso preciso y de bajo nivel al contenido oculto del libro de trabajo.
Extraer código VBA y nombres definidos
use calamine::{open_workbook_auto, Reader};
let mut workbook = open_workbook_auto("file.xlsx")?;
if let Ok(Some(vba)) = workbook.vba_project() {
let module = vba.get_module("Module1").unwrap();
println!("{}", module);
for ref in vba.get_references() {
if ref.is_missing() { println!("Broken: {}", ref.name); }
}
}
for (name, formula) in workbook.defined_names() {
println!("{}: {}", name, formula);
}Carga diferida y manejo de archivos grandes
calamine admite la carga diferida para archivos XLSX y XLSB, lo que permite procesar eficientemente hojas de cálculo grandes sin cargar todas las hojas en memoria de una sola vez. Configurando filas de encabezado y utilizando iteración basada en rangos, los desarrolladores pueden minimizar la huella de memoria y maximizar el rendimiento. Esta característica es particularmente valiosa para funciones sin servidor, herramientas CLI y despliegues integrados donde los recursos son limitados. Las pruebas de referencia muestran que calamine lee más de 1 millón de filas con un consumo de memoria mínimo en comparación con alternativas como openpyxl y ClosedXML, lo que lo hace ideal para pipelines de ingestión de datos a gran escala.
Procesar hojas de cálculo grandes de manera eficiente
use calamine::{open_workbook, Reader, Xlsx};
let mut excel: Xlsx<_> = open_workbook("large.xlsx")?;
let range = excel
.worksheet_range("Sheet1")?
.expect("Sheet not found");
for row in range.rows() {
// Process row without loading entire file
process_row(row);
}Optimización del rendimiento y pruebas de referencia
calamine ofrece un rendimiento excepcional, procesando 41 millones de celdas en menos de 25 segundos—superando a las bibliotecas de Python, C# y Go hasta 9,4 veces. Su diseño sin copias y sus mínimas asignaciones en el heap reducen significativamente el uso de CPU y memoria. Las pruebas con un archivo XLSX de 186 MB muestran que calamine utiliza solo 186 MB de lecturas de disco frente a 1,5 GB para excelize. El comportamiento determinista de la memoria de la biblioteca y la baja presión del GC la hacen adecuada para aplicaciones en tiempo real y sensibles a la latencia. Los desarrolladores se benefician de un uso predecible de recursos y de un rendimiento constante en diversas cargas de trabajo.
