• Embebido, en el sentido de que no corre como proceso separado sino dentro del programa que lo invoca.
• Analítico, construido para consultas que recorren millones de filas y agregan columnas completas.
• Sin dependencias externas, se compila en cualquier sistema operativo y hasta en el navegador.
• Transaccional, con garantías ACID mediante control de concurrencia multiversión.
• Portable, con interfaces para Python, R, Java, C, C++, Go, Rust y Node.js.
• Libre, bajo licencia MIT y con la propiedad intelectual en la DuckDB Foundation.

Un motor tradicional procesa una fila a la vez. DuckDB procesa vectores de unos dos mil valores de la misma columna.

• El costo de interpretar la operación se reparte entre miles de valores en lugar de pagarse por fila.
• Los valores de una columna comparten tipo y quedan contiguos en memoria, lo que aprovecha la caché del procesador.
• El trabajo se reparte por porciones del archivo, así que todos los núcleos atienden la misma consulta.

brew install duckdb

pip install duckdb

import duckdb

con = duckdb.connect()

con = duckdb.connect("ventas.duckdb")

SELECT * FROM 'ventas.csv';

SELECT * FROM 'ventas.parquet';

SELECT * FROM read_csv('ventas.csv', header = true);

CREATE VIEW ventas AS
SELECT * FROM read_parquet('datos/ventas.parquet');

SELECT region, SUM(monto)
FROM 'ventas.parquet'
WHERE anio = 2025
GROUP BY region;

SELECT COUNT(*) FROM 'datos/ventas/*.parquet';

SELECT * FROM read_parquet(['enero.parquet', 'febrero.parquet']);

SELECT filename, COUNT(*)
FROM 'datos/ventas/*.parquet'
GROUP BY filename;

Los valores de una columna se codifican en los nombres de los directorios, con el formato clave igual valor.

ventas/
├── anio=2024/
│   ├── mes=1/datos.parquet
│   └── mes=2/datos.parquet
└── anio=2025/
    ├── mes=1/datos.parquet
    └── mes=2/datos.parquet

SELECT SUM(monto)
FROM read_parquet(
    'ventas/**/*.parquet',
    hive_partitioning = true
)
WHERE anio = 2025 AND mes = 1;

COPY ventas TO 'salida'
    (FORMAT parquet, PARTITION_BY (anio, mes));

• El administrador de búferes trabaja por bloques y decide qué fragmentos del estado intermedio van a disco.
• Usa particionamiento por radix, de modo que cada fragmento se puede procesar por separado al volver a memoria.
• El rendimiento cae de forma progresiva en lugar de colapsar cuando la memoria se agota.

SET memory_limit = '8GB';
SET temp_directory = '/ruta/disco/rapido/tmp';
SET threads = 8;
SET preserve_insertion_order = false;

• memory_limit: tope de memoria, por omisión el ochenta por ciento de la memoria física.
• temp_directory: dónde se escribe el volcado, idealmente un disco de estado sólido local.
• threads: límite de hilos, útil cuando demasiada concurrencia degrada el rendimiento.
• preserve_insertion_order: permite reordenar el resultado y reduce el consumo al importar y exportar.

• Las agregaciones que acumulan colecciones, como list y string_agg, mantienen todo su estado en memoria.
• Las agregaciones que requieren orden necesitan el conjunto completo antes de empezar.
• Una consulta con varios operadores bloqueantes simultáneos todavía puede agotar la memoria.

INSTALL httpfs;
LOAD httpfs;

SELECT COUNT(*) FROM read_parquet('s3://bucket/ventas/*.parquet');

import duckdb
import pandas as pd

ventas = pd.read_csv("ventas.csv")

resultado = duckdb.sql("""
    SELECT region, SUM(monto) AS total
    FROM ventas GROUP BY region ORDER BY total DESC
""").df()

• Entre cinco y diez veces más rápido que pandas en agrupaciones sobre más de cien millones de filas.
• Resuelve uniones de cien millones de filas en memoria o en disco, donde pandas suele agotar la memoria.
• Spark en modo local pierde frente a DuckDB, porque paga la coordinación de un clúster sin tener uno.

• Cargar todo a una tabla antes de consultar, cuando la vista sobre Parquet basta y evita duplicar el almacenamiento.
• Filtrar después de leer, que obliga a abrir las trescientas sesenta y cinco particiones para conservar una.
• Particionar en exceso, porque miles de archivos diminutos degradan la lectura más de lo que ayuda la poda.

• Dejar el directorio temporal en un disco lento, lo que convierte el volcado en el cuello de botella.
• Usar CSV para datos grandes, ya que sin mapas de zonas ni compresión por columna desaparecen las optimizaciones.
• Esperar que list y string_agg vuelquen a disco, cuando su estado permanece completo en memoria.

• DuckDB es una base de datos analítica embebida que corre dentro del proceso que la usa, sin servidor ni administración.
• Su almacenamiento por columnas y su ejecución vectorizada recorren millones de filas y agregan columnas completas.
• Consulta archivos Parquet y CSV en su lugar, mediante vistas y patrones glob.
• La proyección y el filtro empujados reducen la lectura a las columnas y los grupos de filas necesarios.

• El particionado tipo Hive traslada el filtro al sistema de archivos, así que las particiones irrelevantes nunca se abren.
• La agrupación, la unión, el orden y las funciones de ventana vuelcan a disco cuando el estado intermedio excede la memoria.
• memory_limit, temp_directory y threads gobiernan ese comportamiento, con un tope por omisión del ochenta por ciento de la memoria física.
• En la franja de un gigabyte a un terabyte supera a pandas y evita el costo de un clúster de Spark.