Business Intelligence & Ingeniería de Datos

Analítica OLAP de Baja Latencia sin Costos de Nube Excesivos: DuckDB, Apache Parquet y Consultas Vectorizadas en Producción

Criterio arquitectónico para dimensionar plataformas analíticas modernas. Cómo procesar decenas de millones de registros comerciales y financieros en milisegundos combinando almacenamiento columnar Apache Parquet y ejecución vectorizada con DuckDB sin recurrir a clústeres distribuidos sobredimensionados.

Christian Mollo(Principal Data & BI Architect en FORBUS S.R.L.)
Publicado: · Actualizado:
5 min de lectura

El Mito del "Big Data" y el Sobredimensionamiento en la Mediana Empresa

Durante la última década, gran parte de la industria tecnológica adoptó por inercia arquitecturas diseñadas para gigantes de internet en organizaciones cuyos volúmenes de datos reales son radicalmente distintos. Es frecuente encontrar empresas medianas y corporativos regionales pagando miles de dólares mensuales por clústeres distribuidos permanentemente encendidos para analizar conjuntos de datos que, una vez comprimidos, apenas ocupan entre 20 GB y 300 GB.

Por otro lado, el extremo opuesto resulta igual de perjudicial: ejecutar reportes gerenciales pesados directamente sobre la base de datos PostgreSQL o MySQL transaccional en pleno horario de atención al público, degradando el rendimiento de las ventas y bloqueando la caché de páginas operativas.

En este artículo expongo cómo diseñamos en FORBUS S.R.L. arquitecturas analíticas de altísimo rendimiento, bajo costo operativo y latencia sub-segundo combinando almacenamiento columnar Apache Parquet con el motor analítico vectorizado DuckDB.


1. Por Qué los Motores Orientados a Filas Sufren en Consultas Analíticas (OLAP)

Una base de datos relacional transaccional (OLTP) como PostgreSQL almacena los registros de forma contigua fila por fila (row-oriented storage). Si una tabla facturas_detalle tiene 35 columnas y cada fila ocupa 450 bytes, esta disposición es óptima cuando necesitamos insertar una venta completa o recuperar todos los atributos de una factura específica por su clave primaria.

Sin embargo, cuando la gerencia financiera solicita un reporte agregado:

sql
SELECT
    date_trunc('month', fecha_emision) AS mes,
    sucursal_region,
    categoria_producto,
    SUM(subtotal_neto) AS ingresos_totales,
    AVG(margen_operativo) AS margen_promedio
FROM comercial.facturas_detalle
WHERE fecha_emision >= '2024-01-01'
GROUP BY 1, 2, 3;

La consulta solo necesita leer 5 de las 35 columnas. En un motor orientado a filas sin índices cubrientes específicos para esa combinación, el sistema de almacenamiento se ve obligado a leer del disco las 35 columnas completas de millones de registros, saturando el ancho de banda de entrada/salida (I/O) y expulsando de la memoria RAM las páginas calientes que necesitan los usuarios operativos.


2. Almacenamiento Columnar Apache Parquet y Empuje de Predicados (Predicate Pushdown)

Al desacoplar la carga analítica mediante una extracción incremental hacia archivos Apache Parquet particionados, transformamos por completo la física del problema:

  1. Lectura Selectiva de Columnas (Projection Pushdown): Parquet organiza los datos por columnas dentro de bloques llamados Row Groups. Si la consulta requiere 5 columnas, el motor lee del disco exclusivamente los bytes correspondientes a esas 5 columnas, ignorando el 85% restante del archivo.
  2. Compresión de Alta Densidad (Dictionary & Run-Length Encoding): En una columna como sucursal_region donde los valores LA_PAZ, EL_ALTO, SANTA_CRUZ y COCHABAMBA se repiten millones de veces, Parquet reemplaza las cadenas de texto por enteros de pocos bits y los comprime con Zstandard (ZSTD), reduciendo el tamaño en disco entre 6 y 10 veces respecto a una tabla relacional o un archivo CSV.
  3. Salto de Bloques por Metadatos (Min/Max Zone Maps): Cada bloque dentro de un archivo Parquet almacena en su encabezado el valor mínimo y máximo de cada columna. Si filtramos por fecha_emision >= '2026-01-01', el motor inspecciona el encabezado en microsegundos y omite la lectura de todos los bloques cuyos valores máximos sean anteriores a esa fecha.

3. Ejecución Vectorizada en Memoria con DuckDB

DuckDB es un motor de base de datos analítico (OLAP) en proceso (in-process), escrito en C++ sin dependencias externas. A diferencia de los motores tradicionales que procesan una tupla a la vez mediante un árbol de iteradores (Volcano Iterator Model, con millones de llamadas a funciones virtuales por segundo), DuckDB opera sobre vectores de datos en lotes de 2,048 valores contiguos que caben íntegramente dentro de las cachés L1 y L2 del procesador, aprovechando instrucciones SIMD (Single Instruction, Multiple Data) de las CPUs modernas.

Renderizando Diagrama de Arquitectura...

Ejemplo de Pipeline de Exportación y Consulta Analítica en Producción

En lugar de construir complejos pipelines de transformación intermedios, podemos consultar y agregar decenas de millones de filas almacenadas en Parquet con control estricto de memoria e hilos de ejecución:

python
import duckdb
from pathlib import Path

def ejecutar_cierre_analitico_regional(ruta_datalake: Path, anio_fiscal: int) -> list[dict]:
    # Instancia aislada con límite estricto de memoria para convivir en servidores de aplicación
    con = duckdb.connect(database=":memory:")
    con.execute("SET memory_limit = '2GB';")
    con.execute("SET threads = 4;")

    patron_parquet = str(ruta_datalake / f"ventas_historicas/anio={anio_fiscal}/**/*.parquet")

    consulta_olap = """
        SELECT
            sucursal_ciudad,
            linea_negocio,
            COUNT(DISTINCT id_factura) AS volumen_transacciones,
            ROUND(SUM(monto_facturado_bob), 2) AS total_facturado_bob,
            ROUND(QUANTILE_CONT(monto_facturado_bob, 0.50), 2) AS ticket_mediano_bob,
            ROUND(QUANTILE_CONT(monto_facturado_bob, 0.95), 2) AS percentil_95_bob
        FROM read_parquet($1, hive_partitioning = true)
        WHERE estado_fiscal = 'VALIDA'
        GROUP BY sucursal_ciudad, linea_negocio
        ORDER BY total_facturado_bob DESC;
    """

    tabla_arrow = con.execute(consulta_olap, [patron_parquet]).fetch_arrow_table()
    return tabla_arrow.to_pylist()

En pruebas de rendimiento sobre un servidor Linux estándar de 4 núcleos vCPU y almacenamiento NVMe, esta consulta escanea y calcula percentiles exactos sobre 25 millones de registros comerciales en menos de 140 milisegundos, sin tocar en absoluto la base de datos PostgreSQL transaccional que sigue atendiendo las ventas en vivo.


Conclusión

La verdadera madurez en arquitectura de datos consiste en elegir la herramienta adecuada para la escala real del negocio. Antes de comprometer el presupuesto anual de tecnología en infraestructuras distribuidas complejas, la combinación de PostgreSQL bien afinado para las transacciones y DuckDB sobre Apache Parquet para la analítica proporciona un rendimiento extraordinario, soberanía total sobre los datos y una reducción drástica en los costos recurrentes de nube.

¿Encontraste un error o un dato que necesita una fuente? Envíanos una corrección. Consulta nuestra política editorial.

Documentación para contrastar los ejemplos

Etiquetas Técnicas:

#DuckDB#Apache Parquet#Analítica OLAP#Business Intelligence#Ingeniería de Datos#Optimización de Costos Cloud#Consultas Vectorizadas
C

Christian Mollo

Principal Data & BI Architect en FORBUS S.R.L.

Especialista en arquitectura de sistemas críticos, ingeniería de datos de alta disponibilidad e inteligencia artificial aplicada en FORBUS S.R.L. Los análisis publicados provienen de implementaciones reales en entornos corporativos.

Lecturas Técnicas Recomendadas