SQL Academy · Aula

Populando o banco de dados com dados de teste

Gere dados de teste realistas com INSERT ... SELECT e generate_series e verifique-os com consultas analíticas simples.

Populando o banco de dados com dados de teste é uma aula grátis de SQL Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de SQL Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de SQL Academy inclui 4 aulas no total.

Por que criar dados iniciais?

Bancos de dados vazios ocultam erros. Você precisa de dados realistas:

Para executar testes de interface e de ponta a ponta
Para verificar características de desempenho (índices, planos de consulta)
Para demonstrar a aplicação

Dados iniciais escritos manualmente

Para algumas linhas de dados de teste, escreva-as manualmente em SQL ou em uma migração:

INSERT INTO users (id, email, full_name) VALUES
  (1, 'alice@example.com', 'Alice Adams'),
  (2, 'bob@example.com',   'Bob Brown');

SELECT setval('users_id_seq', (SELECT MAX(id) FROM users));

Série gerada para cargas em massa

generate_series é seu aliado. Crie 1000 publicações:

INSERT INTO posts (author_id, title, body, published_at)
SELECT
  ((random() * 9 + 1)::int),                              -- random user 1-10
  'Post number ' || g,
  'Lorem ipsum body ' || g,
  NOW() - (random() * INTERVAL '90 days')
FROM generate_series(1, 1000) AS g;

Chaves estrangeiras aleatórias

Escolha um registro pai aleatório:

INSERT INTO comments (post_id, author_id, body)
SELECT
  (SELECT id FROM posts ORDER BY random() LIMIT 1),
  (SELECT id FROM users ORDER BY random() LIMIT 1),
  'Sample comment ' || g
FROM generate_series(1, 5000) AS g;
-- Slow at scale — see next slide for a faster pattern.

Mais rápido: armazene os registros pai em cache

Materialize os identificadores candidatos uma única vez:

WITH u AS (SELECT id FROM users),
     p AS (SELECT id FROM posts)
INSERT INTO comments (post_id, author_id, body)
SELECT
  (SELECT id FROM p OFFSET floor(random()*1000)::int LIMIT 1),
  (SELECT id FROM u OFFSET floor(random()*10)::int   LIMIT 1),
  'Sample comment ' || g
FROM generate_series(1, 5000) AS g;

faker_fdw e ferramentas

Para obter dados fictícios mais elaborados (nomes, endereços, parágrafos), use:

faker_fdw — extensão do Postgres que expõe o Python Faker
@faker-js/faker do Node
Geradores de dados iniciais do Django/Rails na forma de scripts

COPY para grandes importações em massa

Para carregar um milhão de linhas, COPY é de 5 a 10 vezes mais rápido que INSERT:

COPY users (email, full_name)
  FROM '/tmp/seed_users.csv' WITH (FORMAT csv, HEADER true);

Redefinindo sequências

Se você inseriu manualmente linhas com identificadores explícitos, avance rapidamente a sequência para que os futuros identificadores automáticos não colidam:

SELECT setval('users_id_seq', (SELECT COALESCE(MAX(id), 0) FROM users));

Dados iniciais idempotentes

Faça com que as cargas iniciais possam ser executadas muitas vezes com segurança. Use UPSERT ou TRUNCATE e depois INSERT:

INSERT INTO products (sku, name, price) VALUES
  ('A-001', 'Widget', 9.99)
ON CONFLICT (sku) DO UPDATE
  SET name = EXCLUDED.name, price = EXCLUDED.price;

Distribuição realista

Os testes devem refletir a estrutura da produção. Se 80% das publicações tiverem 0 comentários e 1% tiverem 1000, os dados de teste deverão se parecer com isso; caso contrário, seus planos de índice serão enganosos.

Carga inicial na integração contínua

Para testes de ponta a ponta, execute o script de carga inicial depois das migrações e antes do conjunto de testes. Mantenha as cargas iniciais no controle de versão.

Resumo

Boas cargas iniciais = dados realistas + script idempotente + carregamento rápido (COPY para grandes volumes de dados).

generate_series para cargas em massa
UPSERT para execuções repetidas
setval após inserções manuais
Distribuições compatíveis com a produção

Verificação rápida

Você quer inserir 10.000 linhas de dados de teste rapidamente. Qual função do PostgreSQL gera os números das linhas?

Perguntas Frequentes

A aula “Populando o banco de dados com dados de teste” é grátis?

Sim — o texto completo de “Populando o banco de dados com dados de teste” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de SQL Academy, atualize para CoddyKit PRO. O curso de SQL Academy inclui 4 aulas no total.

O que vou aprender em “Populando o banco de dados com dados de teste”?

Gere dados de teste realistas com INSERT ... SELECT e generate_series e verifique-os com consultas analíticas simples. Você pratica SQL Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar SQL Academy?

Nenhuma experiência prévia é necessária. SQL Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Populando o banco de dados com dados de teste”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de SQL Academy?

Sim. Cada aula de SQL Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Modelando um blog: usuários, publicações e comentários
Escolhendo chaves e tipos
Índices para consultas comuns
Populando o banco de dados com dados de teste

← Voltar para SQL Academy