Um guia detalhado para a função SQL COUNT()

Você pode contar com este guia para lhe dar explicações detalhadas (apoiadas por exemplos) de todos os usos típicos da função COUNT(). COUNT() função.

Conhecer a agregação de dados é um trampolim necessário em sua jornada para se tornar um mestre SQL. Isto inclui a função COUNT() - uma das funções agregadas mais frequentemente utilizadas em SQL.

A agregação de dados ainda conta como conhecimento SQL de nível básico. Ter bases firmes garante que você não tenha buracos em seu conhecimento, o que torna mais fácil o aprendizado de conceitos SQL mais complexos. Você pode obter esta base e muito mais em nossa trilha de aprendizado SQL de A a Z. Seus sete cursos interativos lhe darão uma estrutura firme e tornarão seu aprendizado sistemático. Você começa com o básico de SQL, como recuperar dados e usar funções SQL padrão (que incluem COUNT() e outras funções agregadas). Uma vez que você tenha isso em mente, é muito mais fácil seguir os conceitos mais avançados que esta faixa ensina, tais como funções de janela, expressões comuns de tabela, e extensões GROUP BY.

Uma vez que você aprenda tudo isso, você precisará de alguma prática para realmente dominá-lo. Para isso, há o Curso de Práticas em SQL com seus 88 exercícios interativos.

Este artigo também será prático e mostrará diferentes exemplos de utilização do COUNT(). Para isso, precisamos de um conjunto de dados adequado.

Exemplo de conjunto de dados

Estaremos lidando com diretores e seus filmes. A primeira mesa é, sem surpresas, chamada directors. Aqui está a consulta que você mesmo pode usar para replicar esta tabela.

Os dados na tabela são parecidos com os seguintes:

É uma lista simples de diretores com algumas informações sobre eles.

A segunda tabela é films. Você pode criar esta tabela, também, usando esta consulta. Aqui estão os dados na tabela:

É uma lista de filmes conectados à tabela directors através da coluna director_id. Dois valores director_id são NULL. No contexto de nosso conjunto de dados, isso significa que há dados sobre esses filmes na tabela films. No entanto, não há um diretor correspondente na tabela directors. Em outras palavras, temos todas as informações sobre o "Dog Day Afternoon" e o "The Hater", exceto quem os dirigiu.

Agora que conhecemos os dados, podemos lidar com COUNT().

O que é COUNT()?

A resposta está no nome: a função COUNT() em SQL é utilizada para a contagem de filas. Ela conta as linhas no conjunto de resultados, não na tabela. Para ser mais preciso, ela contará linhas na tabela se sua tabela for um conjunto de resultados - ou seja, se você não tiver filtrado os dados de nenhuma forma. Se você filtrar os dados, COUNT() retorna o número de linhas nos dados filtrados.

Aqui está um exemplo:

SELECT 
  COUNT(*) AS number_of_directors
FROM directors;

O asterisco (*) na função COUNT() instrui-o a contar todas as filas. Como não são aplicados filtros, o conjunto directors tabela será o resultado definido. A função COUNT() irá, portanto, retornar o número de linhas na tabela:

O número de filas é dez, o que, neste caso, também representa o número de diretores.

Se o conjunto de resultados for limitado, COUNT(*) retornará um valor diferente. Por exemplo, suponha que quiséssemos mostrar o número de diretores mortos. Isto significa contar apenas os diretores que têm uma data na coluna date_of_death. Aqueles que têm valores NULL ainda estão vivos. Aqui está a pergunta:

SELECT 
  COUNT(*) AS number_of_dead_directors
FROM directors
WHERE date_of_death IS NOT NULL;

Conseguimos o que queríamos com a filtragem de dados usando a cláusula WHERE. Aqui está o resultado:

Quatro diretores não estão mais vivos.

COUNT() e GROUP BY

Normalmente, a função COUNT() é utilizada com a cláusula GROUP BY. Para refrescar sua memória, GROUP BY é uma cláusula que agrupa todas as filas com o mesmo valor. Normalmente, os grupos são colunas especificadas do conjunto de dados. Para mais informações, leia este artigo sobre como usar GROUP BY.

Aqui está um exemplo de utilização do GROUP BY com COUNT(*):

SELECT 
  country_of_birth,
  COUNT(*) AS number_of_directors
FROM directors
GROUP BY country_of_birth
ORDER BY country_of_birth;

Queremos mostrar todos os países e o número de diretores nascidos neles. Selecionamos o país e usamos COUNT(*) para mostrar o número de diretores. Depois especificamos a coluna country_of_birth em GROUP BY.

Cada coluna da tabela que aparece no SELECT deve aparecer também em GROUP BY. É lógico, porque você quer ver o número de diretores por país de nascimento e mostrar esses países simultaneamente.

Finalmente, a saída é ordenada alfabeticamente por país usando ORDER BY country_of_birth:

Há um diretor de cada país, exceto França e EUA.

Se você precisar de mais alguns exemplos, aqui está o artigo que mostra como usar GROUP BY com funções agregadas SQL.

Usando COUNT() Com uma Expressão ou Coluna

Você não está limitado a escrever um asterisco em COUNT(). Ele também pode ser usado com uma coluna ou uma expressão, tal como a declaração CASE WHEN.

A diferença é que COUNT(expression) conta apenas os valores nãoNULL da expressão. COUNT(*) contará também os valores NULL.

Como exemplo, vamos tentar listar todas as línguas do filme e o número de diretores que fizeram filmes nessas línguas. Parece que temos todos os dados na tabela films.

O que aconteceria se utilizássemos COUNT(*)?

SELECT 
  language,
  COUNT(*) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

No total, esta saída mostra todos os 12 filmes que aparecem na tabela. Alerta de spoiler: Isto está errado!

A razão? Lembre-se, COUNT(*) conta o número de linhas no conjunto de dados, incluindo NULLs. Portanto, esta saída não representa o número de diretores de forma alguma! Como contamos as linhas na tabela filmsagora é óbvio que contamos o número de filmes, não de diretores!

Em outras palavras, há oito filmes em inglês, um em polonês, e três em espanhol. Esta produção não tem nada a ver com o número de diretores!

Seria uma idéia melhor usar COUNT(director_id)? Deveríamos tentar:

SELECT 
  language,
  COUNT(director_id) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Selecionamos os idiomas e contamos os diretores através de seu identificador: director_id. A produção é agrupada e ordenada por idioma.

A saída é diferente da anterior, portanto, vamos analisá-la.

O que fizemos bem ao contar director_id é que nos livramos dos filmes com NULLs em director_id. Isto é especialmente óbvio para a língua polonesa - o número de diretores é zero. Por quê? Porque existe apenas um filme polonês e tem um NULL em director_id, portanto não é contado.

Menos obviamente, um desses filmes também está 'faltando' em inglês. É o Dog Day Afternoon, porque também tem um NULL em director_id.

No total, o resultado mostra dez diretores porque há dez registros na tabela films com valores não-NULL na coluna director_id.

Mas se você voltar para a tabela filmsVocê poderia ver algumas identificações de diretores aparecerem várias vezes. Portanto, sim, mostramos o número de diretores, mas também incluímos todos os diretores cada vez que eles aparecem na tabela. Em outras palavras, incluímos valores duplicados.

Portanto, este resultado está mais próximo do que queríamos alcançar, mas ainda não completamente correto. A contagem de identificações duplicadas de diretores inflaciona o resultado, ou seja, mostra um número irrealisticamente alto de diretores individuais.

O que resolveria este problema de duplicação é usar COUNT() com DISTINCT.

COUNT(expressão) com DISTINCT

Agora que você aprendeu a usar COUNT() com um nome de coluna, é hora de aprender a usá-lo com DISTINCT.

A cláusula DISTINCT elimina as duplicatas. Quando é usada com COUNT(expression), significa que a função contará apenas as instâncias únicas de uma coluna/expressão.

Vamos usar o mesmo exemplo acima, mas com DISTINCT:

SELECT 
  language,
  COUNT(DISTINCT director_id) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Note que DISTINCT está escrito na função COUNT(). Ela vem antes da coluna que você quer contar. E aqui estão os resultados:

O resultado mostra três diretores com filmes em inglês, zero em polonês, e dois em espanhol. Espere um segundo! Esse não é um resultado drasticamente diferente daquele que obtivemos quando usamos COUNT(director_id) sem DISTINCT?

Aqui está o resultado anterior:

Você percebe o que aconteceu aqui? Sem DISTINCT, contamos todos os valores director_id. Então a maneira correta de encontrar o número de diretores neste exemplo é usar COUNT() com DISTINCT.

Cuidado: Usando COUNT() Com JOGO ESQUERDO

Finalmente, vamos usar as duas mesas simultaneamente. Imagine que você quer produzir todos os diretores e a contagem de seus filmes.

Você pensaria (corretamente) que precisa LEFT JOIN. Isso é um bom começo! Pode haver diretores na mesa directors que não têm nenhum filme em nosso films mesa.

Como queremos mostrar a lista de todos os diretores, LEFT JOIN é a escolha certa. Para contar o número de filmes, você pode sentir a necessidade de usar COUNT(*). Aqui está a pergunta:

SELECT 
  d.id,
  d.first_name,
  d.last_name,
  COUNT(*) AS number_of_films
FROM directors d
LEFT JOIN films f
ON d.id = f.director_id
GROUP BY d.id, d.first_name, d.last_name
ORDER BY d.id;

Selecionamos as colunas necessárias e usamos COUNT(*). As duas tabelas estão unidas na coluna contendo as identificações dos diretores.

A saída é agrupada pelos IDs e nomes dos diretores e ordenada pelo ID. E os resultados:

Parece que cada diretor tem pelo menos um filme. No total, são 15 filmes. Espere aí! Isso não parece certo! Há apenas 12 filmes na mesa films.

Além disso, sabemos que não há filmes de Stanley Kubrick na mesa. Como é que a saída mostra que ele tem um? Os dados de todos os outros diretores também estão errados? Sim. Usar COUNT(*) não é a solução correta neste caso. LEFT JOIN retornará uma fila para todos os diretores, mesmo aquele que não pôde ser encontrado na tabela. films. E COUNT(*) conta todas essas filas, mesmo as que não têm filmes correspondentes.

Em vez de COUNT(*), use COUNT() com o nome da coluna. Qual coluna devemos contar? A maneira mais segura é contar os identificadores únicos, que é o id da coluna da tabela. films.

SELECT 
  d.id,
  d.first_name,
  d.last_name,
  COUNT(f.id) AS number_of_films
FROM directors d
LEFT JOIN films f
ON d.id = f.director_id
GROUP BY d.id, d.first_name, d.last_name;

A pergunta é praticamente a mesma de antes, exceto pelo uso diferente de COUNT(). E é isto que ela retorna:

É mais assim! Se você somar os valores, você verá que há dez filmes no total. Por que não 12? Porque dois filmes são de diretores que não existem em nosso conjunto de dados, ou seja, eles têm NULLs na coluna director_id na tabela films.

Para consolidar o que você aprendeu aqui, confira mais alguns exemplos de usos de COUNT().

COUNT() é tão fácil como um, dois, três!

Isso não foi difícil, foi? Estes exemplos fáceis lhe mostraram todas as variações de uso COUNT(). A função em si não é difícil de entender. Mas, como você viu, há várias maneiras de utilizá-la, e cada uma pode retornar um resultado diferente.

Escolher como usar COUNT() torna-se mais fácil com a prática. O Curso de Práticas em SQL é projetado exatamente para esse fim. Você também poderia tentar estes sete exemplos da função COUNT().

Além da prática, é importante que você conheça seus dados e o que você quer alcançar com eles. Quando tudo isso estiver claro para você, COUNT() se torna realmente uma função fácil. Você pode contar com isso! Punição intencional.