data.table: El Motor Oculto Detrás de un Pipeline ETL Rápido
¿Cómo pasar de 8 minutos a menos de 2 en un pipeline de datos con 171 hojas de Excel? En este post, analizo la migración crítica del proyecto manageDW desde dplyr hacia data.table. Exploro por qué la manipulación in-place y la gestión eficiente de memoria permitieron procesar 2 millones de filas reduciendo el consumo de RAM de 4 GB a solo 800 MB. Una comparativa técnica sobre cuándo priorizar la legibilidad de la "gramática de datos" frente al rendimiento bruto en entornos de producción.

El Problema: 171 Hojas Excel No Se Procesan Solas
El 26 de septiembre de 2025, en el mismo día de los ocho commits sobre el ETL, tuve que hacer una decisión de arquitectura: ¿qué librería de manipulación de datos usar para el pipeline? Había empezado con dplyr porque es lo que uso normalmente. Pronto descubrí que no escala bien a este caso.
El problema eran 9 archivos Excel del SII, cada uno con 19 hojas (una por año, de 2005 a 2023). Cada hoja con entre 300 y 5.000 filas según el nivel geográfico (región/provincia/comuna) y la agregación (actividad/subrubro/rubro).
Total: 171 data.tables a leer, validar, limpiar, transformar y cargar a PostgreSQL.
Con dplyr, el pipeline tardó ~8 minutos. No era inaceptable, pero tampoco era bueno. Más importante: al apilar las 171 hojas con bind_rows(), la memoria de R alcanzó ~4 GB y el proceso se volvió lento incluso para operaciones simples. En el refactor R6 del 24 de enero de 2026 (385aa04), todo el pipeline se reescribió con data.table. El resultado: 1 minuto 47 segundos con memoria máxima de ~800 MB.
¿Qué pasó?
data.table vs dplyr: Dos Filosofías
Ambos paquetes resuelven el mismo problema: manipulación de datos tabulares en R. Pero sus filosofías son radicalmente distintas.
dplyr: Legibilidad Primero
library(dplyr)
result <- empresas %>%
filter(region == "Metropolitana") %>%
group_by(actividad, anio) %>%
summarise(
total_ventas = sum(ventas_uf, na.rm = TRUE),
n_empresas = n()
) %>%
arrange(desc(total_ventas))
Es código que cualquiera puede leer sin saber R. Los verbos (filter, group_by, summarise) son autoexplicativos. El pipe %>% te lleva paso por paso. Es declarativo: describes qué quieres, no cómo hacerlo.
data.table: Performance Primero
library(data.table)
result <- empresas[
region == "Metropolitana",
.(total_ventas = sum(ventas_uf, na.rm = TRUE),
n_empresas = .N),
by = .(actividad, anio)
][order(-total_ventas)]
La sintaxis es más compacta. Usa una sola estructura DT[i, j, by] que combina filtrado, agregación y agrupación. No hay pipes. No hay verbos en inglés. Es más críptico al principio, pero una vez que entiendes la gramática, es poderosamente conciso.
Lo importante no es la sintaxis. Lo importante es que data.table hace esto:
- Sin copiar datos: Modifica en memoria, no crea copias intermedias
- Con índices automáticos: Detecta columnas usadas en
byy las indexa - Con paralelización: Aprovecha múltiples cores por defecto
- Con código C optimizado: Las operaciones críticas están en C, no en R interpretado
::note dplyr también está optimizado (usa C++ vía Rcpp), pero su filosofía funcional hace más copias. Cuando el pipeline procesa 2+ millones de filas o itera cientos de veces (como en IPF), esas copias son decisivas. ::
La Gramática: DT[i, j, by]
Todo en data.table gira alrededor de tres argumentos:
DT[i, j, by]
| Argumento | Qué hace | Ejemplo |
|---|---|---|
i |
Filtrar filas (WHERE en SQL) | anio > 2020 |
j |
Seleccionar o calcular columnas (SELECT en SQL) | .(ventas, renta_neta) |
by |
Agrupar (GROUP BY en SQL) | by = .(region, actividad) |
Tres posiciones, tres acciones. Se pueden combinar en una sola expresión.
::tip
La notación DT[i, j, by] es una sobrecarga del operador [. Toda la magia ocurre dentro de los corchetes: R evalúa i, j y by en el contexto del data.table, lo que permite usar nombres de columnas directamente sin $.
::
Ejemplos Concretos del Proyecto
1. Filtrar filas
# En ETLStarSchemaSII: separar por nivel geográfico
dt_region <- dt_all[nivel == "REGION"]
dt_provincia <- dt_all[nivel == "PROVINCIA"]
dt_comuna <- dt_all[nivel == "COMUNA"]
Esto es equivalente a filter(dt_all, nivel == "REGION") en dplyr, pero sin crear copias.
2. Calcular columnas
# En ImputadorVentasSII: marcar valores faltantes
dt_comuna[, fue_imputado := is.na(ventas_uf)]
El operador := es crítico. Modifica dt_comuna in-place sin crear una copia. En dplyr, mutate() siempre crea un nuevo data.frame. Con 2 millones de filas, evitar copias ahorra gigabytes de memoria.
3. Agrupar y agregar
# Sumar ventas por provincia
comunas_sum <- dt_comuna[,
.(total = sum(ventas_uf, na.rm = TRUE)),
by = .(anio, actividad_cod, provincia_cod)
]
Esto es group_by + summarise en dplyr, pero en una sola expresión. La notación .(...) es azúcar sintáctica para list(...) y se usa tanto para crear columnas como para especificar grupos.
4. Modificar columnas agrupadas
# En ImputadorVentasSII: inicializar NAs con media del grupo
dt[, valor_estimado := {
var_col <- get(variable)
if (all(is.na(var_col))) {
rep(100.0, .N)
} else {
media <- mean(var_col, na.rm = TRUE)
ifelse(is.na(var_col), media, var_col)
}
}, by = .(actividad_cod, region_cod)]
Aquí .N es una variable especial de data.table que contiene el número de filas en cada grupo. El bloque { ... } puede tener lógica compleja. Esto calcula la media por grupo (actividad × región) y la usa solo para rellenar NAs de ese grupo.
En dplyr esto requeriría group_by(), mutate() con ifelse(), y probablemente un ungroup() después. data.table lo hace en una expresión.
El Truco: Operaciones In-Place con :=
La diferencia de performance entre data.table y dplyr se debe fundamentalmente a esto: modificar vs copiar.
::important
El operador := no devuelve un valor. Modifica el data.table en el lugar e invisiblemente. Si asignas su resultado (dt2 <- dt[, x := x*2]), dt2 es solo otro puntero al mismo objeto. No hay copia.
::
En R base y dplyr (copias)
# R base
df$nueva_columna <- df$ventas * 1.19 # Copia implícita
# dplyr
df <- df %>% mutate(nueva_columna = ventas * 1.19) # Copia explícita
Cada operación crea un nuevo data.frame. Si df tiene 2 millones de filas y 10 columnas, y haces 5 operaciones, creaste 5 copias de ~150 MB cada una. El garbage collector de R tendrá que limpiar todo eso.
En data.table (in-place)
dt[, nueva_columna := ventas * 1.19]
No hay copia. La columna se agrega directamente a la estructura existente en memoria. Si tienes 2 millones de filas, solo se aloca memoria para la nueva columna (~16 MB para un vector numérico), no para todo el data.table.
Múltiples Columnas
# Agregar tres columnas a la vez
dt[, `:=`(
ventas_pesos = ventas_uf * 36000,
utilidad = ventas_uf - costos_uf,
margen = (ventas_uf - costos_uf) / ventas_uf
)]
La notación := con paréntesis se usa para operaciones múltiples. Sigue siendo in-place.
Eliminar Columnas
# Eliminar columnas
dt[, c("temp1", "temp2") := NULL]
Las columnas desaparecen sin copiar el resto del data.table.
Joins: El Benchmark Que Importa
Los joins son donde data.table brilla más. En el ETL de manageDW, necesitamos hacer joins constantemente: hechos con dimensiones, validaciones contra catálogos, etc.
dplyr
result <- inner_join(fact, dim_actividad, by = "actividad_cod")
dplyr usa hash joins (via merge() de R base). Funciona bien hasta ~1 millón de filas. Después, el costo de construir el hash se vuelve notable.
data.table con setkey() (indexado)
# Opción 1: merge tradicional (sin índice)
result <- merge(fact, dim_actividad, by = "actividad_cod")
# Opción 2: con keys (indexado, recomendado para joins repetidos)
setkey(fact, actividad_cod)
setkey(dim_actividad, actividad_cod)
result <- fact[dim_actividad]
setkey() ordena el data.table por esa columna y mantiene un índice, convirtiendo los joins en búsquedas binarias () en vez de recorridos lineales ().
::tip
Usa setkey() cuando el mismo join se ejecuta más de una vez (como en el pipeline IPF, que itera hasta convergencia). El costo de construir el índice se amortiza rápidamente.
::
Benchmark Real
Probé en mi máquina (Ryzen 7, 32GB RAM) con el mismo dataset:
- fact_empresas: 2.1 millones de filas
- dim_actividad: 538 filas
| Método | Tiempo | Memoria pico |
|---|---|---|
dplyr::inner_join() |
1.4 seg | 450 MB |
data.table::merge() |
0.7 seg | 280 MB |
data.table con setkey() |
0.08 seg | 200 MB |
17× más rápido con keys. Y si haces el join 10 veces (como en un pipeline con múltiples dimensiones), la diferencia se multiplica.
rbindlist(): Apilar 171 Hojas en Segundos
En el ETL, necesitábamos leer 9 archivos Excel con 19 hojas cada uno y apilarlos:
# Lectura
dt_list <- list()
for (i in seq_along(rutas)) {
sheets <- readxl::excel_sheets(rutas[i])
for (sheet in sheets) {
dt <- readxl::read_excel(rutas[i], sheet = sheet)
# ... procesamiento ...
dt_list[[length(dt_list) + 1]] <- dt
}
}
# Apilar
dt_all <- rbindlist(dt_list, fill = TRUE)
rbindlist() es la versión de data.table de bind_rows() de dplyr. La diferencia:
- dplyr verifica tipos columna por columna, hace coerciones si es necesario, y construye el resultado incrementalmente
- data.table prealoca el data.table final con el tamaño correcto, luego copia cada lista directamente sin verificaciones redundantes
El parámetro fill = TRUE rellena con NA las columnas que no existen en alguna hoja (como cuando el SII cambia los nombres de columnas entre años).
Tiempo para 171 hojas:
- dplyr bind_rows(): ~12 segundos
- data.table rbindlist(): 1.8 segundos
fread(): Leer CSV a la Velocidad de la Luz
Aunque en manageDW usamos Excel (porque así publica el SII), fread() merece mención. Es la función de lectura de archivos de texto de data.table.
dt <- fread("data.csv")
¿Qué hace diferente?
- Detecta tipos automáticamente con un sample del archivo (no necesitas
col_types) - Paraleliza la lectura (usa múltiples cores para parsear chunks del archivo)
- Lee directamente a data.table (sin pasar por data.frame)
- Maneja archivos gigantes con
selectydroppara leer solo columnas específicas
Benchmark informal (archivo CSV de 500 MB):
- read.csv(): ~45 segundos
- readr::read_csv(): ~18 segundos
- data.table::fread(): ~3 segundos
Si tu pipeline empieza con archivos CSV de centenares de megabytes, fread() es una inversión de tiempo inmediata.
Patrones del Proyecto manageDW
1. Copy Cuando Necesitas Inmutabilidad
# En ImputadorVentasSII
ejecutar_ipf_variable = function(dt_comuna, dt_provincia, dt_region, variable) {
dt <- data.table::copy(dt_comuna) # Copia explícita
while (!convergencia && iteracion < max_iter) {
dt_anterior <- data.table::copy(dt) # Otra copia
dt <- ajustar_variable_comuna_provincia(dt, dt_provincia, variable)
cambio_max <- max(abs(dt[[variable]] - dt_anterior[[variable]]))
# ...
}
}
data.table se pasa por referencia. Si modificas dt con :=, modificas el objeto original. Cuando necesitas comparar estados (como en IPF), haces copy() explícito. Es más verboso que la inmutabilidad default de dplyr, pero te da control total.
2. get() para Columnas Dinámicas
# Cuando el nombre de la columna está en una variable
dt[, suma := sum(get(variable_nombre), na.rm = TRUE)]
get() evalúa el string como nombre de columna. Útil para funciones genéricas (como cuando ImputadorVentasSII itera sobre variables_imputar = c("ventas_uf", "renta_neta_uf")).
3. .N, .SD, .SDcols: Variables Especiales
# .N = número de filas en el grupo
dt[, n := .N, by = region]
# .SD = Subset of Data (el data.table del grupo actual)
# .SDcols = columnas a incluir en .SD
dt[, lapply(.SD, mean),
by = region,
.SDcols = c("ventas_uf", "renta_neta_uf")]
.SD es poderoso para operaciones que afectan múltiples columnas. En el ejemplo, calcula la media de dos variables por región en una expresión.
4. setDT() para Convertir In-Place
# Si recibes un data.frame de readxl
df <- readxl::read_excel("file.xlsx")
setDT(df) # Ahora df es data.table, sin copiar
setDT() convierte un data.frame existente a data.table modificándolo directamente. as.data.table() haría una copia. Cuando procesas 171 hojas, esto importa.
Cuándo NO Usar data.table
No todo es data.table. Hay casos donde dplyr (o incluso R base) es mejor:
1. Código que Otros Leerán
Si estás escribiendo un tutorial para principiantes en R, o un análisis que verá tu jefe que sabe Excel pero no programación, dplyr es más legible. filter() %>% group_by() %>% summarise() se explica solo. DT[i, j, by] requiere una curva de aprendizaje.
2. Datos Pequeños (<100k filas)
Si tu dataset cabe cómodamente en RAM y las operaciones toman milisegundos, la diferencia entre dplyr y data.table es irrelevante. Optimiza para legibilidad, no para velocidad.
3. Tidyverse Workflow
Si ya estás usando ggplot2, tidyr, purrr, etc., mantener todo en dplyr tiene sentido para consistencia. Cambiar entre sintaxis pierde tiempo. data.table se integra bien con algunos paquetes tidyverse (especialmente ggplot2, que acepta data.tables sin conversión), pero no con todos.
4. Cuando Necesitas Inmutabilidad Estricta
El paso por referencia de data.table puede causar bugs sutiles:
dt2 <- dt1
dt2[, x := x * 2]
# dt1 también cambió. dt2 es solo un puntero al mismo objeto.
::warning
Este es el error más común al migrar de dplyr a data.table. Cuando necesitas conservar el estado original, usa data.table::copy(dt) explícitamente. En el imputador IPF, cada iteración usa data.table::copy(dt_comuna) antes de modificar los valores.
::
La Decisión para manageDW
data.table resuelve tres problemas concretos del proyecto:
- Escala de datos: 2+ millones de filas en
fact_empresas, 171 hojas Excel a procesar - Operaciones repetitivas: IPF itera hasta convergencia, ejecutando el mismo cálculo cientos de veces sobre ~500.000 celdas multidimensionales. Desde v0.3.2, el Random Forest (
ranger) también lee sus datos de entrenamiento directamente desde data.tables para evitar copias. - Memoria limitada: Un pipeline ETL no debe necesitar 16 GB de RAM
- Performance importa: De 8 minutos a <2 minutos es la diferencia entre iterar rápido en desarrollo y esperar con café
Pero documenté cada operación no obvia con comentarios. Y en el dashboard Shiny, donde hay menos datos y más interactividad, usé dplyr para los cálculos reactivos porque la legibilidad importaba más.
No es una religión. Es una herramienta. Usa la que resuelva tu problema.
Para Seguir Aprendiendo
- Documentación oficial: rdatatable.gitlab.io — La mejor referencia
- Cheat sheet: rstudio.com/resources/cheatsheets
- Benchmarks: h2oai.github.io/db-benchmark — Comparación data.table vs dplyr vs pandas vs polars en datasets grandes
- Libro: Advanced R de Hadley Wickham (capítulo sobre Performance) — Explica por qué las copias cuestan en R
Reflexión
Llevo años usando R. Empecé con dplyr porque es lo que enseñan los tutoriales y lo que aparece en Stack Overflow. data.table me parecía críptico e innecesariamente compacto.
Fue el ETL de manageDW — 171 hojas Excel, 2+ millones de filas en fact_empresas, e IPF que itera hasta convergencia — el que me obligó a hacer el cambio. El commit 385aa04 del 24 de enero de 2026 refactoriza todo el ETL a R6 y data.table simultáneamente. No fue solo refactor de arquitectura; fue también refactor de performance.
Lo que aprendí: la elección no es una cuestión de ideología. dplyr es excelente para análisis exploratorio interactivo donde la legibilidad importa y los datos caben cómodamente en RAM. data.table es indispensable cuando el pipeline corre en producción, procesa millones de registros, o itera cientos de veces como en el IPF. En manageDW, el dashboard Shiny usa dplyr en los cálculos reactivos porque son datos filtrados (pequeños). El ETL y el imputador usan data.table porque trabajan con el dataset completo.
Hoy, mi regla es simple: para análisis exploratorio con datos <100k filas, dplyr porque el código se lee como prosa. Para pipelines de producción o datos grandes, data.table porque cada segundo cuenta. El mejor código no es el más rápido ni el más legible. Es el que resuelve el problema con el menor costo total.