Perguntas SQL em Entrevistas QA: O que Esperar e Como Responder

A maioria das perguntas de SQL em entrevistas para QA se resume a quatro padrões. SELECT com WHERE verifica que um registro foi salvo; LEFT JOIN encontra registros órfãos; COUNT com GROUP BY encontra duplicatas; DELETE limpa dados de teste. Os entrevistadores querem respostas práticas vinculadas a cenários de testes, não definições de livro didático.

Qual nível de SQL as entrevistas de QA testam?

Para a maioria dos cargos de QA automation:

• Júnior: SELECT, WHERE, filtragem básica, entender conceitualmente o que é um JOIN
• Mid-level: JOINs (INNER, LEFT), GROUP BY, funções de agregação (COUNT, SUM, AVG), subqueries
• Sênior: Window functions, conceitos de otimização de queries, explicar planos de execução

Se a descrição da vaga menciona "testes de banco de dados" ou "validação de dados", espere perguntas mais aprofundadas. Caso contrário, nível júnior a mid-level é o típico.

Perguntas principais e respostas

1. "Quais queries SQL você mais usa nos testes?"

2. "Como você verificaria que um usuário foi criado corretamente após um registro?"

-- Encontrar o usuário e verificar campos principais
SELECT id, email, role, is_active, created_at
FROM users
WHERE email = 'test_user@example.com';

Depois verificar:

• A linha existe (se 0 linhas, o registro não gravou no banco)
• email corresponde ao que foi submetido
• role é 'member' (não 'admin' por padrão)
• is_active é false (se confirmação por email é necessária antes da ativação)
• created_at é recente (não é uma linha pré-existente)

3. "Qual a diferença entre WHERE e HAVING?"

-- WHERE: filtrar linhas individuais
SELECT user_id, amount FROM orders WHERE status = 'completed';

-- HAVING: filtrar grupos (após GROUP BY)
SELECT user_id, COUNT(*) as order_count
FROM orders
GROUP BY user_id
HAVING COUNT(*) > 5;
-- Retorna usuários com mais de 5 pedidos

4. "Explique a diferença entre INNER JOIN e LEFT JOIN"

-- Quais usuários fizeram pelo menos um pedido?
SELECT u.email
FROM users u
INNER JOIN orders o ON u.id = o.user_id;
-- Apenas usuários que têm pedidos

-- Quais usuários NUNCA fizeram um pedido?
SELECT u.email
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE o.id IS NULL;
-- Usuários sem pedido correspondente (a verificação de NULL)

5. "Como você encontraria registros duplicados em uma tabela?"

SELECT email, COUNT(*) as count
FROM users
GROUP BY email
HAVING COUNT(*) > 1;

Isso encontra emails que aparecem mais de uma vez. Substitua email pelo campo que deveria ser único.

6. "Qual a diferença entre DELETE e TRUNCATE?"

| | DELETE | TRUNCATE |

|-|--------|---------|

| Remove | Linhas específicas (com WHERE) ou todas | Todas as linhas (sem cláusula WHERE) |

| Rollback | Pode ser revertido (em uma transação) | Geralmente não pode (operação DDL) |

| Triggers | Dispara triggers DELETE por linha | Não dispara triggers |

| Velocidade | Mais lento em tabelas grandes | Muito mais rápido |

| Uso em testes | Configurar/limpar dados específicos | Resetar tabelas inteiras entre execuções |

-- Remover apenas o usuário de teste
DELETE FROM users WHERE email LIKE 'test_%@example.com';

-- Limpar a tabela test_runs inteira entre suites
TRUNCATE TABLE test_runs;

7. "Como você usa SQL para configurar dados de teste?"

-- Setup: criar um usuário de teste
INSERT INTO users (email, password_hash, role, is_active)
VALUES ('playwright_test@example.com', '$2b$10$hashedpassword', 'member', true);

-- Verificar: confirmar que existe com os valores certos
SELECT id, email, role FROM users WHERE email = 'playwright_test@example.com';

-- Teardown: remover
DELETE FROM users WHERE email = 'playwright_test@example.com';

8. "Como você encontraria todos os pedidos feitos nos últimos 7 dias?"

SELECT id, user_id, total, status, created_at
FROM orders
WHERE created_at >= NOW() - INTERVAL '7 days'
ORDER BY created_at DESC;

(A sintaxe varia um pouco por banco de dados: PostgreSQL usa INTERVAL '7 days', MySQL usa INTERVAL 7 DAY, SQL Server usa DATEADD(day, -7, GETDATE()))

9. "O que é uma subquery e quando você usaria uma?"

Uma subquery é uma query dentro de outra query:

-- Encontrar usuários que fizeram pedidos acima de R$100
SELECT email FROM users
WHERE id IN (
    SELECT user_id FROM orders WHERE total > 100
);

10. "Como você verifica integridade referencial após uma exclusão?"

Se você deletar um usuário, pode querer verificar se os registros relacionados também foram deletados (cascade delete) ou se as constraints de chave estrangeira impediram registros órfãos.

-- Confirmar que o usuário foi deletado
SELECT COUNT(*) FROM users WHERE id = 123;
-- Esperado: 0

-- Confirmar que os pedidos relacionados também foram deletados (cascade)
SELECT COUNT(*) FROM orders WHERE user_id = 123;
-- Esperado: 0 (se cascade delete estiver configurado)

-- OU confirmar que os pedidos ainda existem (se soft-delete é usado)
SELECT id, user_id, deleted_at FROM orders WHERE user_id = 123;
-- Esperado: linhas com deleted_at preenchido

Dicas práticas para a entrevista

• Comece dizendo o que a query deve fazer antes de escrevê-la
• Escreva a estrutura básica primeiro (SELECT ... FROM ... WHERE ...), depois adicione complexidade
• Mencione que você gostaria de testar a query em dados reais antes de finalizar

• Diga "verificaria na documentação a sintaxe exata, mas a abordagem seria..." e explique a lógica
• Isso é muito melhor do que adivinhar uma sintaxe errada e defendê-la

• "Minha experiência é principalmente com PostgreSQL, mas o conceito é o mesmo no MySQL: a sintaxe para aritmética de datas é ligeiramente diferente"
• Demonstrar consciência das diferenças entre bancos de dados é um diferencial

Referência rápida: queries que QA engineers mais usam

-- Verificar que um registro foi criado
SELECT * FROM table WHERE id = 123;

-- Verificar contagem (registro criado ou deletado)
SELECT COUNT(*) FROM orders WHERE user_id = 456;

-- Encontrar duplicatas
SELECT email, COUNT(*) FROM users GROUP BY email HAVING COUNT(*) > 1;

-- Encontrar registros órfãos (não deveriam existir)
SELECT o.* FROM orders o
LEFT JOIN users u ON o.user_id = u.id
WHERE u.id IS NULL;

-- Registros recentes
SELECT * FROM logs WHERE created_at > NOW() - INTERVAL '1 hour';

-- Limpar dados de teste
DELETE FROM users WHERE email LIKE 'test_%';

SQL em entrevistas de QA é sobre demonstrar que você consegue verificar e manipular dados para suportar testes, não escrever schemas de banco de dados de produção. Foque nos padrões práticos acima e você estará bem preparado.