Saltar al contenido
hg.Héctor GarridoCiencia de datos · Estadística · Ingeniería de datos
← Volver al blog
Data Warehouse SII

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.

data.table: El Motor Oculto Detrás de un Pipeline ETL Rápido

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:

  1. Sin copiar datos: Modifica en memoria, no crea copias intermedias
  2. Con índices automáticos: Detecta columnas usadas en by y las indexa
  3. Con paralelización: Aprovecha múltiples cores por defecto
  4. 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 (O(log⁡n)O(\log n)) en vez de recorridos lineales (O(n)O(n)).

::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?

  1. Detecta tipos automáticamente con un sample del archivo (no necesitas col_types)
  2. Paraleliza la lectura (usa múltiples cores para parsear chunks del archivo)
  3. Lee directamente a data.table (sin pasar por data.frame)
  4. Maneja archivos gigantes con select y drop para 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:

  1. Escala de datos: 2+ millones de filas en fact_empresas, 171 hojas Excel a procesar
  2. 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.
  3. Memoria limitada: Un pipeline ETL no debe necesitar 16 GB de RAM
  4. 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


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.