0Pricing
SQL Interview Prep · Aula

COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT)

A pergunta clássica sobre como cada forma de COUNT trata NULLs e duplicatas.

COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT) é uma aula grátis de SQL Interview Prep no CoddyKit. Esta é a aula 1 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 Interview Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de SQL Interview Prep inclui 4 aulas no total.

A pergunta que lhe farão

Se participar de uma entrevista de SQL, espere ouvir isto nos primeiros dez minutos: qual é a diferença entre COUNT(*), COUNT(column) e COUNT(DISTINCT column)?

Parece algo trivial, mas os entrevistadores usam essa pergunta para verificar se você realmente entende como as funções de agregação lidam com valores NULL e duplicados. Uma resposta precisa e dada com confiança mostra que você já escreveu consultas reais, em vez de apenas memorizar sintaxe.

Nesta lição, construiremos um modelo mental sólido para que você possa responder imediatamente e explicar o motivo.

COUNT(*) conta linhas

COUNT(*) conta linhas. Ele não analisa os valores de nenhuma coluna, portanto os NULLs são irrelevantes. Se a tabela tiver 100 linhas, COUNT(*) retornará 100, ponto final.

O asterisco não está multiplicando nem expandindo colunas aqui. Ele é um token especial que significa "contar todas as linhas que atendem aos critérios". Esta é a forma que você deve usar quando a pergunta for simplesmente "quantos registros existem?"

SELECT COUNT(*) AS total_rows
FROM employees;

Dados de exemplo para analisar

Vamos basear tudo em uma tabela pequena. Imagine uma tabela employees com uma coluna department que aceita NULL:

  • Alice, Vendas
  • Bob, Vendas
  • Carol, NULL
  • Dan, Engenharia
  • Eve, NULL

Ao todo, são 5 linhas. Três linhas têm um valor de departamento (Vendas, Vendas, Engenharia) e duas têm NULL. Tenha esses números em mente; contaremos essa tabela de três maneiras diferentes.

COUNT(column) ignora NULLs

COUNT(column) conta apenas as linhas em que essa coluna não é NULL. Ele ignora completamente os valores NULL.

Nos nossos dados de exemplo, COUNT(department) retorna 3, não 5, porque dois valores de departamento são NULL. Este é o fato mais importante de toda a lição: COUNT de uma coluna nunca conta NULLs.

SELECT COUNT(department) AS depts_present
FROM employees;
-- returns 3 on our sample data

Comparando os dois até agora

Na mesma tabela de 5 linhas, lado a lado:

  • COUNT(*) = 5 (todas as linhas)
  • COUNT(department) = 3 (departamentos não NULL)

A diferença entre eles, 5 menos 3, é igual ao número de departamentos NULL. Um truque útil para entrevistas: COUNT(*) - COUNT(col) fornece a quantidade de NULLs nessa coluna sem que você precise escrever uma cláusula WHERE separada.

SELECT COUNT(*) - COUNT(department) AS null_departments
FROM employees;
-- returns 2

COUNT(DISTINCT column)

COUNT(DISTINCT column) conta o número de valores exclusivos que não são NULL. Primeiro ele elimina as duplicatas, depois ignora os NULLs e, por fim, conta o que restou.

Nos nossos dados, os valores distintos de departamento são Vendas e Engenharia, portanto COUNT(DISTINCT department) retorna 2. Os dois NULLs não entram na contagem, e a duplicata de Vendas é reduzida a uma única ocorrência.

SELECT COUNT(DISTINCT department) AS unique_depts
FROM employees;
-- returns 2

Os três juntos

O quadro completo da nossa tabela de 5 linhas:

  • COUNT(*) = 5 — linhas
  • COUNT(department) = 3 — valores não NULL
  • COUNT(DISTINCT department) = 2 — valores exclusivos que não são NULL

Se você conseguir recitar essa ordem, primeiro considerando NULL e depois as duplicatas, terá entendido todo o conceito. Observe que cada forma retorna um valor menor ou igual ao da forma acima.

SELECT
  COUNT(*)                       AS rows_total,
  COUNT(department)              AS depts_present,
  COUNT(DISTINCT department)     AS unique_depts
FROM employees;

Uma variação de entrevista resolvida

Os entrevistadores costumam apresentar a questão de outra forma: "Quantos funcionários estão atribuídos a um departamento e quantos departamentos distintos existem?"

A primeira parte é COUNT(department) (estar atribuído significa não ser NULL). A segunda parte é COUNT(DISTINCT department). Reconhecer a qual COUNT cada frase corresponde é exatamente a habilidade que está sendo avaliada.

SELECT
  COUNT(department)          AS assigned_employees,
  COUNT(DISTINCT department) AS distinct_departments
FROM employees;

COUNT com uma condição

Uma pergunta complementar frequente: conte apenas as linhas que atendem a uma condição. Uma técnica limpa e portável é aplicar COUNT a uma expressão CASE. Como COUNT(column) ignora NULLs, faça o CASE retornar NULL para as linhas que você deseja excluir.

Aqui contamos os funcionários de Vendas. O CASE produz um valor apenas para as linhas de Vendas e NULL nas demais, então COUNT contabiliza somente essas linhas.

SELECT
  COUNT(CASE WHEN department = 'Sales' THEN 1 END) AS sales_count
FROM employees;
-- returns 2

Erros comuns a evitar

Fique atento a estas armadilhas preparadas pelos entrevistadores:

  • Presumir que COUNT(column) é igual a COUNT(*) — isso só acontece quando a coluna não contém nenhum NULL.
  • Achar que COUNT(DISTINCT col) inclui NULL como um valor distinto — não inclui.
  • Escrever COUNT(1) esperando que ele ignore NULLs — ele se comporta como COUNT(*) e conta todas as linhas.

Mencione esses pontos espontaneamente em uma entrevista para demonstrar conhecimento aprofundado.

COUNT(1) e COUNT(constant)

Os candidatos costumam perguntar o que é mais rápido: COUNT(*) ou COUNT(1). A resposta é: eles são semanticamente idênticos — ambos contam todas as linhas, independentemente de NULLs — e os otimizadores modernos os tratam da mesma forma, portanto não há diferença real de desempenho.

A constante dentro de COUNT(1) nunca é NULL, então nenhuma linha é ignorada. Prefira COUNT(*) por clareza; essa é a forma idiomática.

SELECT COUNT(*) AS a, COUNT(1) AS b
FROM employees;
-- a and b are always equal

Verificação rápida

Teste seu modelo mental com a tabela de exemplo.

Revisão

Agora você domina a pergunta mais frequente sobre agregações:

  • COUNT(*) conta cada linha, incluindo os NULLs.
  • COUNT(column) conta apenas valores não NULL.
  • COUNT(DISTINCT column) conta valores exclusivos que não são NULL.
  • COUNT(*) - COUNT(col) fornece a quantidade de NULLs sem precisar de outra operação.
  • COUNT(1) é igual a COUNT(*) — não ignora NULLs e não oferece diferença de velocidade.

Diga isso de forma clara e explique o motivo. A seguir: como SUM e AVG lidam com NULLs.

Perguntas Frequentes

A aula “COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT)” é grátis?

Sim — o texto completo de “COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT)” é 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 Interview Prep, atualize para CoddyKit PRO. O curso de SQL Interview Prep inclui 4 aulas no total.

O que vou aprender em “COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT)”?

A pergunta clássica sobre como cada forma de COUNT trata NULLs e duplicatas. Você pratica SQL Interview Prep 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 Interview Prep?

Nenhuma experiência prévia é necessária. SQL Interview Prep 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 1 de 4.

Quanto tempo leva a aula “COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT)”?

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 Interview Prep?

Sim. Cada aula de SQL Interview Prep 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

  1. COUNT(*) versus COUNT(coluna) versus COUNT(DISTINCT)
  2. SUM e AVG com NULLs
  3. MIN, MAX e agregação não numérica
  4. Agregações sem GROUP BY
← Voltar para SQL Interview Prep