Otimização de carga em massa de dados

Imagina que você precisa carregar um milhão de linhas de dados. Se fizer isso devagar, seu servidor vai ficar ocupado por um tempão, os usuários podem sentir lentidão no banco, e pior ainda — seu café pode esfriar antes do processo acabar. Otimizar evita sobrecarregar o servidor, reduz o tempo de espera e minimiza a chance de erro na hora de carregar os dados.

Vamos começar com passos simples e depois partir pra umas dicas mais avançadas e espertas.

Desativando índices e triggers

Índices e triggers são coisas muito legais que deixam nossos bancos de dados inteligentes e rápidos. Mas durante a carga em massa, eles podem deixar tudo bem mais lento, porque o servidor tenta atualizar índices e rodar triggers pra cada linha que você carrega.

Pra aliviar o sistema temporariamente, dá pra desativar eles.

Exemplo de como desativar índices e triggers:

-- Desativando triggers pra tabela
ALTER TABLE students DISABLE TRIGGER ALL;

-- Carregando os dados
COPY students FROM '/path/to/students.csv' DELIMITER ',' CSV HEADER;

-- Ativando triggers de novo
ALTER TABLE students ENABLE TRIGGER ALL;

Como isso funciona?

1. A gente desativa todos os triggers temporariamente usando o comando DISABLE TRIGGER ALL.
2. Depois de carregar os dados, ativa os triggers de novo com ENABLE TRIGGER ALL.

Erro comum: se você esquecer de ativar os triggers de novo, alguns processos automáticos (tipo atualizar campos padrão) podem não funcionar direito. Então não esquece de voltar tudo ao normal — tipo sair do modo avião no seu celular.

Usando transações

Transações deixam você carregar todos os dados de uma vez, como se fosse uma operação só. Se der ruim, dá pra desfazer tudo e seu banco não vira uma bagunça de dados quebrados.

Exemplo de uso de transação:

-- Começando a transação
BEGIN;

-- Carregando os dados
COPY courses FROM '/path/to/courses.csv' DELIMITER ',' CSV HEADER;

-- Confirmando as mudanças
COMMIT;

Por que isso é mais rápido?

Quando você carrega dados sem transação, o servidor confirma cada linha. Com transação, ele faz isso só uma vez no final, economizando muito tempo.

Desativando checagem de integridade

Se você não precisa checar chave estrangeira ou restrição de unicidade durante a carga, desativa elas. Senão o banco vai checar cada linha, deixando tudo mais lento.

Exemplo de como desativar checagem de integridade:

SET session_replication_role = 'replica';

-- Carregando os dados
COPY enrollments FROM '/path/to/enrollments.csv' DELIMITER ',' CSV HEADER;

SET session_replication_role = 'origin';

session_replication_role = 'replica' desativa checagem de integridade dos dados (tipo unicidade e restrições FOREIGN KEY).

Aumentando a memória de execução

Ajustar a memória do PostgreSQL pode melhorar a performance da carga. Os parâmetros chave são work_mem e maintenance_work_mem.

Exemplo de aumento de memória:

-- Aumentando a memória
SET work_mem = '64MB';
SET maintenance_work_mem = '256MB';

-- Carregando os dados
COPY teachers FROM '/path/to/teachers.csv' DELIMITER ',' CSV HEADER;

O que isso faz?

• work_mem é usado pra operações intermediárias, tipo sort ou hash.
• maintenance_work_mem afeta operações com índices, tipo rebuild deles.

Dica: Vai com calma no aumento de memória, principalmente em servidores com pouca RAM.

Preparando os dados antes da carga

Preparar os dados pode reduzir bastante o tempo de carga. Por exemplo, se tiver linhas duplicadas, filtra antes pra não fazer o PostgreSQL perder tempo com dados inúteis.

Exemplo de limpeza de dados:

Se você tem um arquivo com linhas duplicadas, pode usar Python pra remover elas.

import pandas as pd

# Carregando o arquivo CSV
data = pd.read_csv('students.csv')

# Removendo duplicatas
data = data.drop_duplicates()

# Salvando o CSV limpo
data.to_csv('students_clean.csv', index=False)

Particionando os dados

Se o arquivo for gigante, divide ele em vários menores. Assim o PostgreSQL processa tudo de forma mais eficiente.

Exemplo:

Divide o arquivo large_data.csv em pedaços de 1000 linhas usando Linux:

split -l 1000 large_data.csv chunk_

Depois carrega eles separadamente:

COPY students FROM 'chunk_aa' DELIMITER ',' CSV HEADER;
COPY students FROM 'chunk_ab' DELIMITER ',' CSV HEADER;
-- E assim por diante

Carregando em background

Se der, usa processos em background pra carregar os dados, assim não sobrecarrega o banco principal.

Ferramentas como pg_cron ajudam a agendar tarefas.

Exemplo: agendando carga em background com pg_cron:

CREATE EXTENSION pg_cron;

SELECT cron.schedule('*/5 * * * *', $$COPY students FROM '/path/to/data.csv' DELIMITER ',' CSV HEADER$$);

A cada 5 minutos os dados do arquivo vão ser carregados na tabela.

Isso é só um exemplo, não faz assim na vida real! Só queria mostrar que o PostgreSQL é bem flexível e você pode controlar a carga de dados direto dos scripts SQL.

Pegadinhas

Algumas coisas pra ficar ligado:

• Se desativar índices e triggers, lembra de ativar de novo! Se esquecer, vai ter que consertar erro depois da carga.
• Ao aumentar memória, fica de olho nos recursos do servidor: uma query faminta pode acabar com toda a RAM.
• Usando transações, garante que o arquivo de dados não tem erro crítico. Um erro já faz a carga toda ser desfeita.

Dicas pro futuro

Agora você já sabe como otimizar carga em massa de dados — desde desativar índices até usar transações. Essas skills vão te ajudar a carregar dados mais rápido, economizar recursos do servidor, nervos, café e deixar os usuários felizes.

Da próxima vez que precisar lidar com arquivos de gigabytes, você já vai estar preparado!