Questão de Banco de Dados — Geral — INSTITUTO AOCP 2026
Banco de Dados›Geral
Código
qa434189
Banca
INSTITUTO AOCP
Órgão
IF CE
Ano
2026
Cargo
Ana ( )
O IFCE necessita gerar um relatório contendo a quantidade de alunos matriculados por curso, considerando apenas aqueles com status “ATIVO”. O analista de tecnologia da informação identificou que a tabela alunos possui as colunas id_aluno, curso e status. Para atender ao requisito utilizando SQL (ANSI) no PostgreSQL, é necessário agrupar os registros por curso e contar apenas os alunos com status ativo. Assinale a alternativa que apresenta a instrução SQL adequada para esse cenário.
ASELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO' GROUP BY curso;
BSELECT curso FROM alunos WHERE status = 'ATIVO' GROUP BY COUNT(*);
CSELECT curso, COUNT(id_aluno) FROM alunos GROUP BY curso;
DSELECT COUNT(id_aluno), curso FROM alunos WHERE status = 'ATIVO';
ESELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO';
Revelar gabarito e comentário▾
GabaritoA — SELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO' GROUP BY curso;
Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.
SQL: agrupamento e contagem condicional
Gabarito: letra A. A consulta correta é SELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO' GROUP BY curso;, pois filtra os registros com status ativo antes de agrupar por curso e contar. A ordem lógica de execução do SQL é: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY, e é essa ordem que define a resposta.
O requisito do IFCE tem duas partes: (1) agrupar por curso e (2) contar apenas os alunos com status 'ATIVO'. A pegadinha está em onde aplicar o filtro: antes ou depois do agrupamento. A cláusula WHERE filtra linhas individuais antes do agrupamento — exatamente o que precisamos, pois queremos descartar os alunos inativos antes de contar. Já a cláusula HAVING filtra grupos inteiros depois da agregação, sendo usada para condições sobre o resultado da função agregada (ex.: HAVING COUNT(*) > 10).
Vamos ver o funcionamento na prática. Suponha a tabela alunos:
id_aluno
curso
status
1
CC
ATIVO
2
CC
INATIVO
3
SI
ATIVO
4
SI
ATIVO
A consulta da letra A executa assim: o WHERE status = 'ATIVO' elimina a linha 2; restam as linhas 1, 3 e 4; o GROUP BY curso forma dois grupos — CC (1 linha) e SI (2 linhas); o COUNT(*) conta 1 e 2, respectivamente. Resultado: CC → 1, SI → 2. Perfeito para o relatório.
A distinção crucial é entre WHERE e HAVING. O WHERE não pode usar funções agregadas (COUNT, SUM, AVG), pois roda antes da agregação; o HAVING só pode ser usado com GROUP BY e filtra os grupos já formados. Nesta questão, o filtro é sobre um atributo da linha (status), não sobre o resultado da contagem — logo, WHERE é o correto.
A banca explora três erros típicos: (1) colocar o filtro depois do agrupamento ou omiti-lo, contando todos os alunos; (2) usar GROUP BY com uma função agregada em vez de uma coluna; (3) esquecer o GROUP BY, gerando uma única linha com a contagem total. Guarde a ordem lógica de execução e a função de cada cláusula: é exatamente nesses pontos que as alternativas se dividem.
Alternativa A — ✅ Correta ⟵ GABARITO
A instrução SELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO' GROUP BY curso; está correta porque:
WHERE status = 'ATIVO' filtra as linhas antes do agrupamento, garantindo que apenas alunos ativos sejam considerados;
GROUP BY curso agrupa os registros por curso;
COUNT(*) conta as linhas de cada grupo.
A ordem lógica de execução confirma: FROM → WHERE (filtra linhas) → GROUP BY (agrupa) → SELECT (projeta e agrega). O resultado é exatamente a quantidade de alunos ativos por curso.
Alternativa B — ❌ Incorreta
SELECT curso FROM alunos WHERE status = 'ATIVO' GROUP BY COUNT(*); está errada porque GROUP BY deve receber colunas da tabela (ou expressões sobre elas), nunca uma função agregada como COUNT(*). O agrupamento é feito sobre valores de colunas; a contagem é o resultado do agrupamento, não o critério dele. Além disso, a consulta não retorna a contagem — apenas o curso —, o que não atende ao relatório.
Alternativa C — ❌ Incorreta
SELECT curso, COUNT(id_aluno) FROM alunos GROUP BY curso; conta todos os alunos por curso, sem filtrar pelo status 'ATIVO'. O requisito pede apenas os ativos; sem o WHERE status = 'ATIVO', o relatório incluiria alunos inativos, inflando os números. O COUNT(id_aluno) em si é válido (conta valores não nulos de id_aluno), mas a ausência do filtro torna a consulta incorreta para o cenário.
Alternativa D — ❌ Incorreta
SELECT COUNT(id_aluno), curso FROM alunos WHERE status = 'ATIVO'; filtra os ativos, mas não possui GROUP BY curso. Sem o agrupamento, a consulta retorna uma única linha com o total geral de alunos ativos e um valor arbitrário de curso (no PostgreSQL, qualquer curso, pois não há agrupamento). O resultado não é a quantidade por curso — é um total único, inútil para o relatório.
Alternativa E — ❌ Incorreta
SELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO'; também não possui GROUP BY curso. A consulta filtra os ativos, mas sem agrupar, o COUNT(*) conta todas as linhas do resultado (todos os ativos) e retorna uma única linha com um curso arbitrário. O requisito exige a contagem por curso, o que só é possível com o agrupamento.
PEGA ESSA DICA!
Para questões de GROUP BY, monte mentalmente a ordem de execução: FROM → WHERE → GROUP BY → HAVING → SELECT. Pergunte-se: o filtro é sobre uma coluna da linha (→ WHERE) ou sobre o resultado da agregação (→ HAVING)? E confira se toda coluna no SELECT que não é função agregada está no GROUP BY. Esse roteiro resolve a maioria das questões de agrupamento.