DuckDB: análise de dados direto no terminal sem infraestrutura

1. Por que DuckDB? O banco de dados OLAP que cabe no seu terminal

Vivemos uma explosão de dados locais: arquivos CSV de relatórios, logs de aplicações, datasets públicos baixados para análise exploratória. Tradicionalmente, analisar esses dados exigia montar um servidor de banco de dados, configurar conexões de rede e gerenciar daemons — infraestrutura pesada para consultas simples.

O DuckDB inverte essa lógica. É um banco de dados OLAP (Online Analytical Processing) embarcado, projetado para executar consultas analíticas complexas diretamente no seu terminal, sem necessidade de servidor. Diferente do SQLite (OLTP, focado em transações), o DuckDB é otimizado para agregações, window functions e scans de grandes volumes de dados.

Zero setup: você instala, digita duckdb no terminal e começa a consultar. Não há porta para configurar, nenhum serviço rodando em background.

2. Instalação e primeiros passos em segundos

A instalação é trivial em qualquer sistema:

# macOS (Homebrew)
brew install duckdb

# Linux (binário estático)
curl -fsSL https://install.duckdb.org | sh

# Python (biblioteca + CLI)
pip install duckdb

# Windows (binário único)
# Baixe de duckdb.org e execute duckdb.exe

Com o DuckDB instalado, inicie o shell interativo:

$ duckdb
D SELECT 'Olá, DuckDB' AS saudacao;
┌──────────────┐
│   saudacao   │
│   varchar    │
├──────────────┤
│ Olá, DuckDB  │
└──────────────┘

O verdadeiro poder aparece ao conectar diretamente a arquivos locais, sem importação:

D SELECT COUNT(*) FROM 'vendas.csv';
┌──────────────┐
│ count_star() │
│    int64     │
├──────────────┤
│      1048576 │
└──────────────┘

3. Consultas poderosas com sintaxe SQL familiar

O DuckDB implementa SQL completo com suporte a CTEs, window functions e agregações complexas. Veja um exemplo prático analisando logs de servidor:

D WITH logs_hora AS (
    SELECT 
        strftime(timestamp, '%Y-%m-%d %H:00:00') AS hora,
        status_code,
        COUNT(*) AS total
    FROM read_csv_auto('access.log')
    WHERE status_code >= 400
    GROUP BY ALL
)
SELECT 
    hora,
    status_code,
    total,
    SUM(total) OVER (PARTITION BY hora) AS total_hora,
    ROUND(total * 100.0 / SUM(total) OVER (PARTITION BY hora), 2) AS pct_hora
FROM logs_hora
ORDER BY hora, status_code;

A consulta processa milhões de linhas em milissegundos graças à arquitetura columnar e processamento vetorizado.

4. Trabalhando com múltiplos formatos de dados sem ETL

DuckDB lê diversos formatos nativamente. Você pode combinar fontes distintas em uma única consulta:

D SELECT 
    u.nome,
    u.email,
    p.produto,
    p.valor
FROM 'usuarios.csv' AS u
JOIN read_parquet('pedidos.parquet') AS p
    ON u.id = p.usuario_id
WHERE p.valor > 1000
ORDER BY p.valor DESC;

Exportar resultados é igualmente simples:

D COPY (
    SELECT categoria, SUM(valor) AS total
    FROM 'vendas.json'
    GROUP BY categoria
) TO 'relatorio.csv' (HEADER, DELIMITER ';');

5. DuckDB como motor de análise em scripts e pipelines

No terminal, você pode usar DuckDB em pipelines Unix:

$ duckdb -c "SELECT strftime(data, '%Y-%m') AS mes, SUM(valor) 
             FROM 'transacoes.parquet' 
             GROUP BY mes" --csv | head -20
mes,sum(valor)
2024-01,4589321.50
2024-02,5128347.25

Em Python, a biblioteca duckdb permite integração direta com DataFrames:

import duckdb
import pandas as pd

# Carrega dados de múltiplas fontes
con = duckdb.connect()
con.execute("CREATE VIEW logs AS SELECT * FROM 'server.log'")

# Consulta e retorna como DataFrame
df = con.execute("""
    SELECT 
        endpoint,
        COUNT(*) AS acessos,
        AVG(tempo_resposta) AS tempo_medio
    FROM logs
    WHERE status = 200
    GROUP BY endpoint
    ORDER BY acessos DESC
    LIMIT 10
""").df()

print(df.to_markdown())

6. Performance que surpreende: dados grandes, recursos mínimos

DuckDB processa bilhões de linhas em máquinas modestas. Sua arquitetura columnar armazena dados por coluna (não por linha), permitindo scans eficientes e compressão agressiva. O processamento vetorizado opera em batches de centenas de milhares de valores por vez.

Limitações práticas:
- Ideal para datasets de até centenas de GB (memória RAM disponível)
- Para terabytes, considere ClickHouse ou banco distribuído
- Sem suporte a concorrência multi-usuário (é embarcado)

Dicas de tuning:

-- Ajusta memória máxima
SET memory_limit = '4GB';

-- Ativa paralelismo
SET threads = 4;

-- Força uso de índices mínimos (DuckDB já otimiza automaticamente)

7. Casos de uso reais no dia a dia do desenvolvedor

Análise de logs sem ELK:

$ duckdb -c "
SELECT 
    ip,
    COUNT(*) AS requisicoes,
    COUNT(DISTINCT endpoint) AS endpoints_unicos,
    MAX(timestamp) AS ultimo_acesso
FROM read_csv_auto('/var/log/nginx/access.log')
WHERE status = 404
GROUP BY ip
HAVING requisicoes > 100
ORDER BY requisicoes DESC
"

Exploração de datasets públicos:

# Dados abertos do governo brasileiro (exemplo)
D SELECT 
    regiao,
    COUNT(*) AS municipios,
    AVG(populacao) AS pop_media
FROM 'municipios.csv'
GROUP BY regiao;

Substituindo planilhas pesadas:

D SELECT 
    departamento,
    SUM(salario) AS folha,
    AVG(salario) AS media,
    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY salario) AS mediana
FROM 'funcionarios.xlsx'
GROUP BY departamento;

8. DuckDB além do básico: extensões e integrações

As extensões oficiais expandem drasticamente as capacidades:

-- Acessa dados em S3 ou HTTP
INSTALL httpfs;
LOAD httpfs;

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

-- Conecta a PostgreSQL
INSTALL postgres_scanner;
LOAD postgres_scanner;

SELECT * FROM postgres_scan('host=localhost dbname=analytics', 'vendas');

DuckDB funciona como engine de consulta federada, unificando fontes heterogêneas:

D SELECT 
    p.nome,
    p.preco,
    e.estoque
FROM read_csv_auto('produtos.csv') AS p
JOIN postgres_scan('dbname=erp', 'estoque_atual') AS e
    ON p.sku = e.sku
WHERE e.estoque < 10;

O DuckDB democratizou a análise de dados: não é preciso mais montar infraestrutura complexa para consultas ad-hoc. Com instalação em segundos, suporte a múltiplos formatos e performance comparável a bancos dedicados, ele se tornou ferramenta essencial no terminal de qualquer profissional de dados.

Referências