DuckDB: O Novo Favorito para Análise de Dados

DuckDB é um mecanismo de análise SQL que está ganhando notoriedade rapidamente, evidenciado por suas estatísticas impressionantes:

DuckDB x Postgres — Classificação por estrelas do GitHub

Em um período comparável de dois anos, o DuckDB experimentou o mesmo crescimento em popularidade que o Snowflake, conforme relatado pelas tendências do DB-Engines. Parece bem posicionado para se tornar popular nos próximos anos e substituir pelo menos algumas das cargas atualmente processadas em data warehouses tradicionais.

Principais Benefícios do DuckDB

• Facilidade de instalação: executar o DuckDB é tão simples quanto brew install duckdb (que instala o DuckDB CLI).
• Baixa complexidade: a ausência de um servidor (DuckDB é apenas um binário) significa que não há necessidade de lidar com credenciais, listas de controle de acesso, configurações de firewall, etc.
• Compatibilidade universal: com pouquíssimas dependências, o DuckDB é o epítome da portabilidade — ele pode até ser executado no seu navegador!
• Integração com DataFrame: a biblioteca Python do DuckDB tem a capacidade de consultar DataFrames do Pandas — isso é uma virada de jogo! Ele atua como uma camada unificadora ou "cola" entre ele e quaisquer sistemas que não possa consultar diretamente, facilitando a etapa de transformação no processamento de dados.
• Extensões: DuckDB possui um mecanismo de extensão flexível, que permite maior flexibilidade, principalmente quando se trata de leitura de dados diretamente do JSON e Parquet ou diretamente do S3. Esse recurso melhora muito a experiência dos desenvolvedores.
• Estabilidade e eficiência: DuckDB foi projetado para lidar com cargas de trabalho além dos limites de memória (embora com algumas limitações). Isto é particularmente relevante em cenários onde os conjuntos de dados analisados são significativamente maiores do que a RAM disponível, mas pequenos o suficiente para caber no disco — permitindo que as análises sejam concluídas usando hardware "barato" e prontamente disponível (como o seu laptop).

DuckDB em Pipelines de Dados do Mundo Real

Comparado aos sistemas baseados em nuvem, o DuckDB se destaca por seus requisitos mínimos e custo-benefício. Elimina a necessidade de contas na nuvem, cotas ou despesas adicionais. A consistência do DuckDB em todos os ambientes, desde o laptop de um desenvolvedor até as configurações de produção, contrasta fortemente com as soluções baseadas em nuvem que muitas vezes sofrem desvios à medida que o tempo passa e os dados ficam obsoletos ou inválidos.

A simplicidade de executar o DuckDB em qualquer lugar contorna desafios comuns vistos em sistemas distribuídos, como movimentação de dados para nós de computação, orquestração de VM/trabalho e tratamento de falhas. A capacidade das máquinas modernas, baseadas em nuvem ou como aquelas alimentadas pelos SoCs M1 da Apple, aprimora ainda mais a utilidade do DuckDB, permitindo cenários de processamento de máquina única para conjuntos de dados significativamente grandes. A realidade é que muito poucos clientes precisarão processar TB de dados diariamente, necessitando genuinamente de mais capacidade de CPU do que a disponível em todas as nuvens públicas.

Integração com DataFrames Pandas

Uma vantagem significativa do DuckDB, especialmente no ecossistema Python, é sua integração perfeita com DataFrames do Pandas. Esse recurso simplifica o processo de mesclagem de diversos conjuntos de dados de diversas fontes, agilizando a análise de dados e as tarefas de transformação.

Para ilustrar a facilidade, criei um repositório onde faço um leve tratamento de um dataset qualquer relacionado a algo de plano econômico (https://data.world/mkalish/great-streets) e dele crio um DataFrame Pandas, faço atribuição ao DuckDB e faço queries junto com um PostgreSQL (você pode ver os outros bancos compatíveis aqui).

Segue repositório: GitHub - duckdb_postgresql

Exemplo de Código em Python

# Instalando dependências 
%pip install --quiet wget
%pip install --quiet duckdb
%pip install --quiet jupysql
%pip install --quiet duckdb-engine
%pip install --quiet pandas
%pip install --quiet matplotlib
%pip install --quiet psycopg2-binary
%pip install --quiet dash
%pip install --quiet plotly

# Importações
import wget
import duckdb
import pandas as pd

# DC Mayor's office of Planning and Economic Development - Dataset
df = pd.read_csv('dataset.csv', delimiter=";", encoding='ISO-8859-1')

# Substituindo espaços por underlines nos nomes das colunas
df.columns = df.columns.str.replace(' ', '_').str.lower()

# Removendo o '$' e ';' e convertendo para float
df['official_amount'] = df['official_amount'].str.replace('[$;]', '', regex=True).astype(float)
df.tail()

# Carregando e configurando o Jupyter Notebook para trabalhar com o DuckDB 
%load_ext sql
%config SqlMagic.autopandas = True
%config SqlMagic.feedback = False
%config SqlMagic.displaycon = False
%config SqlMagic.named_parameters=True

# Conectando ao DuckDB local
%sql duckdb:///

# Conectando ao DuckDB
con = duckdb.connect(database=':memory:', read_only=False)

# Registrando o DataFrame do Pandas como uma tabela no DuckDB
con.register('my_table', df)

# Agora você pode executar consultas SQL na tabela registrada
result = con.execute("SELECT * FROM my_table").fetchdf()
print(result)

import random
import psycopg2

# Conexão com o banco de dados PostgreSQL
conn = psycopg2.connect(
    dbname='postgres', 
    user='admin', 
    password='admin', 
    host='localhost', 
    port='5432'
)

from psycopg2 import sql
cur = conn.cursor()

# Criando a tabela dataset
cur.execute("""
CREATE TABLE IF NOT EXISTS dataset (
    id SERIAL PRIMARY KEY,
    city VARCHAR(255),
    official_amount FLOAT
)
""")

# Lista de cidades americanas para inserir na tabela
cities = ["New York", "Los Angeles", "Chicago", "Houston", "Phoenix",
          "Philadelphia", "San Antonio", "San Diego", "Dallas", "San Jose",
          "Austin", "Jacksonville", "Fort Worth", "Columbus", "Charlotte",
          "San Francisco", "Indianapolis", "Seattle", "Denver", "Washington"]

# Inserindo 50 registros na tabela
for _ in range(50):
    city = random.choice(cities)
    official_amount = round(random.uniform(1000, 5000), 2)
    cur.execute(
        sql.SQL("INSERT INTO dataset (city, official_amount) VALUES (%s, %s)"),
        [city, official_amount]
    )

# Commitando a transação
conn.commit()

# Fechando a conexão
cur.close()
conn.close()

%%sql
select * from postgres.public.dataset
limit 5;

%%sql
# Caso já exista conexão com postgresql
DETACH DATABASE pg;

# Conectando com postgresql
ATTACH 'dbname=postgres user=admin host=localhost password=admin connect_timeout=10' AS pg (TYPE postgres, READ_ONLY);

# Executando a consulta de junção no DuckDB
SELECT 
    A.city, 
    SUM(A.official_amount) AS total_official_amount
FROM postgres.public.dataset AS A
INNER JOIN my_table AS B USING (city)
GROUP BY A.city

Conclusão

O DuckDB é um sistema de gerenciamento de banco de dados embutido e orientado a colunas, projetado para análise de dados e processamento de consultas OLAP (Online Analytical Processing). Sua arquitetura é otimizada para cenários de análise de dados, onde a capacidade de executar consultas complexas e agregações em grandes conjuntos de dados é crucial. Um dos aspectos notáveis do DuckDB é sua facilidade de integração em aplicações existentes, pois não requer configuração de servidor ou gerenciamento separado, podendo ser executado diretamente dentro do processo de uma aplicação.

A principal vantagem do DuckDB reside em sua eficiência e velocidade no processamento de consultas em grandes volumes de dados, graças à sua arquitetura orientada a colunas e técnicas de execução de consultas avançadas, como a vectorização. Isso o torna uma escolha atraente para cientistas de dados, analistas e desenvolvedores que precisam realizar análises rápidas e interativas em seus conjuntos de dados.

Repositório: GitHub - duckdb_postgresql

LinkedIn - Airton Lira Junior

database #duckdb #bigdata #python #dataengineer #dataanalytics