Pular para o conteúdo principal

Questão de Banco de Dados — Geral — INSTITUTO AOCP 2026

Banco de DadosGeral
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.
  1. ASELECT curso, COUNT(*) FROM alunos WHERE status = 'ATIVO' GROUP BY curso;
  2. BSELECT curso FROM alunos WHERE status = 'ATIVO' GROUP BY COUNT(*);
  3. CSELECT curso, COUNT(id_aluno) FROM alunos GROUP BY curso;
  4. DSELECT COUNT(id_aluno), curso FROM alunos WHERE status = 'ATIVO';
  5. 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.

Gabarito: letra A.

Link permanente: /questoes/qa434189