Como COUNT() funciona no SQL Server

No SQL Server, o COUNT() A função retorna o número de itens encontrados em um grupo. Você pode usá-lo para descobrir quantas linhas estão em uma tabela ou conjunto de resultados.

Sintaxe

A sintaxe fica assim:

-- Sintaxe da Função de Agregação COUNT ( { [ [ ALL | DISTINCT ] expression ] | * } ) -- Sintaxe da Função Analítica COUNT ( [ ALL ] { expression | * } ) OVER ( [  ] )

ALL aplica a função agregada a todos os valores. Este é o valor padrão.

DISTINCT especifica que a função retorna o número de valores não nulos exclusivos.

expression é uma expressão de qualquer tipo, exceto imagem , ntext , ou texto . Funções agregadas e subconsultas não são suportadas na expressão.

* especifica que todas as linhas devem ser contadas e retornadas, incluindo linhas duplicadas e linhas que contêm valores nulos. COUNT(*) não aceita parâmetros e não suporta o uso de DISTINCT . Também não requer uma expressão parâmetro (porque não usa informações sobre nenhuma coluna em particular).

OVER ( [ <partition_by_clause> ] divide o conjunto de resultados produzido pelo FROM cláusula em partições às quais a função é aplicada. Se não for especificado, a função trata todas as linhas do conjunto de resultados da consulta como um único grupo.

Exemplo 1 – Uso básico

Aqui está um exemplo básico mostrando como essa função funciona:

SELECT COUNT(*) AS 'Row Count'FROM artistas;

Resultado:

+-------------+| Contagem de linhas ||-------------|| 16 |+-------------+

Neste caso, há 16 linhas no campo Artistas tabela.

Só para ter certeza, aqui estão eles:

SELECIONAR *DE Artistas;

Resultado:

+------------+-------------+-------- --+-------------+| ArtistId | ArtistName | AtivoDe | CountryId ||------------+------------------------+--------- -----+-------------|| 1 | Donzela de Ferro | 1975-12-25 | NULO || 2 | CA/CC | 1973-01-11 | NULO || 3 | Allan Holdsworth | 1969-01-01 | NULO || 4 | Amigo Rico | 1919-01-01 | NULO || 5 | Devin Townsend | 01-01-1993 | NULO || 6 | Jim Reeves | 1948-01-01 | NULO || 7 | Tom Jones | 1963-01-01 | NULO || 8 | Marrom 5 | 01-01-1994 | NULO || 9 | O roteiro | 01-01-2001 | NULO || 10 | Aceso | 26-06-1988 | NULO || 11 | Sábado Negro | 1968-01-01 | NULO || 12 | Michael Aprende a Rock | 15-03-1988 | NULO || 13 | Carabão | 01-01-1981 | NULO || 14 | Karnivool | 01-01-1997 | NULO || 15 | Aves de Tóquio | 01-01-2004 | NULO || 16 | Bodyjar | 01-01-1990 | NULL |+------------+------------------------+----- -----+-------------+

Como esperado, 16 linhas são retornadas.

Observe que o CountryId coluna contém nada além de valores nulos. Isso será útil para o próximo exemplo.

Exemplo 2 – Especificar uma coluna

O exemplo anterior usou um asterisco (* ) para especificar todas as linhas. Isso resulta na contagem de todas as linhas, independentemente de haver duplicatas ou conter valores nulos.

Você também pode especificar uma coluna específica. Quando você faz isso, os valores nulos não são contados. Ou seja, todas as linhas que contêm um valor nulo para essa coluna não são contadas.

Aqui está um exemplo usando o CountryId coluna como mencionado no exemplo anterior:

SELECT COUNT(CountryId) AS 'Row Count'FROM artistas;

Resultado:

+-------------+| Contagem de linhas ||-------------|| 0 |+-------------+

Como vimos no exemplo anterior, todas as linhas desta coluna são NULL . Portanto, a contagem de linhas resultante é zero.

Vamos adicionar alguns valores nessa coluna:

UPDATE ArtistsSET CountryId =2WHERE ArtistName IN ( 'AC/DC', 'Karnivool', 'Birds of Tokyo', 'Bodyjar');

Agora vamos contar as linhas para essa coluna novamente:

SELECT COUNT(CountryId) AS 'Row Count'FROM artistas;

Resultado:

+-------------+| Contagem de linhas ||-------------|| 4 |+-------------+

Exemplo 3 – Com DISTINCT

Este exemplo usa o DISTINCT cláusula para retornar apenas linhas distintas (ou seja, não duplicadas).

No exemplo anterior, atualizei a tabela para que o mesmo CountryId foi aplicado a quatro artistas (usei SET CountryId = 2 para todos os quatro artistas). Isso resultou em quatro linhas com o mesmo CountryId .

Veja o que acontece se eu contar quantos CountryId distintos s estão nessa tabela:

SELECT COUNT(DISTINCT CountryId) 'Distinct CountryIds'FROM Artists;

Resultado:

+-----------------------+| IDs de país distintos ||----------------------------------|| 1 |+-----------------------+

Isso é esperado porque, embora haja quatro linhas com um CountryId , ainda é apenas um CountryId distinto .

Só para ter certeza, vamos executá-lo ao lado de sua versão “não distinta”:

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists;

Resultado:

+----------------+------------+| Não Distinto | Distinto ||----------------+------------|| 4 | 1 |+----------------+------------+

Portanto, a versão não distinta mostra quantas vezes o CountryId aparece na tabela, enquanto o DISTINCT versão conta várias ocorrências como 1.

Vamos adicionar outro CountryId para a mesa:

ATUALIZAR ArtistsSET CountryId =1WHERE ArtistName ='Carabao';

E agora execute a consulta novamente:

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists;

Resultado:

+----------------+------------+| Não Distinto | Distinto ||----------------+------------|| 5 | 2 |+----------------+------------+

Exemplo 4 – Use uma cláusula WHERE

Aqui está um exemplo rápido usando um WHERE cláusula.

SELECT COUNT(*) AS 'Row Count'FROM ArtistsWHERE ActiveFrom>='2000-01-01';

Resultado:

+-------------+| Contagem de linhas ||-------------|| 2 |+-------------+

Exemplo 5 – Com GROUP BY

Aqui está um exemplo de agrupar os artistas em uma coluna e, em seguida, contar todos os álbuns de cada artista na outra coluna.

Exemplo:

SELECT ArtistName, COUNT(al.AlbumId) 'Número de álbuns'FROM artistas arINNER JOIN Álbuns alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Número de álbuns' DESC;

Resultado:

+------------------------+--------------------+ | ArtistName | Número de álbuns ||------------------------+------------------------ || Donzela de Ferro | 5 || Michael Aprende a Rock | 3 || O roteiro | 3 || Tom Jones | 3 || Devin Townsend | 3 || Allan Holdsworth | 2 || Amigo Rico | 1 || CA/CC | 1 || Jim Reeves | 1 |+------------------------+--------------------+ Exemplo 6 – Com a Cláusula HAVING
 
 Podemos ajustar o exemplo anterior para incluir apenas os artistas que têm mais do que um certo número de álbuns. Podemos fazer isso usando o HAVING cláusula. 
 SELECT ArtistName, COUNT(al.AlbumId) 'Número de álbuns'FROM artistas arINNER JOIN Álbuns alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameHAVING COUNT(al.AlbumId)> 2ORDER BY 'Número de álbuns' DESC; 
 Resultado:
 +------------------------+--------------------+ | ArtistName | Número de álbuns ||------------------------+------------------------ || Donzela de Ferro | 5 || Michael Aprende a Rock | 3 || O roteiro | 3 || Tom Jones | 3 || Devin Townsend | 3 |+------------------------+--------------------+ Exemplo 7 – Particionamento com a cláusula OVER
 
 Você pode usar o OVER cláusula com PARTITION BY para dividir os resultados em partições. 
 
 Neste exemplo, eu uso OVER (PARTITION BY ArtistName) para listar cada álbum que o artista produziu, bem como o número total de álbuns desse artista. 
 SELECT ArtistName, AlbumName, COUNT(AlbumId) OVER (PARTITION BY ArtistName) 'Número de Álbuns deste Artista'FROM Artistas arINNER JOIN Álbuns alON al.ArtistId =ar.ArtistIdORDER BY 'Número de Álbuns deste Artista' DESC; 
 
 Resultado:
 +------------------------+--------------------- -----+-------------------------------------+| ArtistName | Nome do álbum | Número de álbuns deste artista ||------------------------+----------------- ---------+-------------------------------------|| Donzela de Ferro | Powerslave | 5 || Donzela de Ferro | Em algum lugar no tempo | 5 || Donzela de Ferro | Pedaço de Mente | 5 || Donzela de Ferro | Assassinos | 5 || Donzela de Ferro | Nenhuma oração para os moribundos | 5 || CA/CC | Potência | 3 || CA/CC | Voltar em Preto | 3 || CA/CC | Rocha ou busto | 3 || Michael Aprende a Rock | Noite Azul | 3 || Michael Aprende a Rock | Eternidade | 3 || Michael Aprende a Rock | Escandinávia | 3 || Devin Townsend | Ziltoid, o Onisciente | 3 || Devin Townsend | Vítimas de Cool | 3 || Devin Townsend | Epicloud | 3 || Tom Jones | Mala perdida há muito tempo | 3 || Tom Jones | Louvor e Culpa | 3 || Tom Jones | Junto veio Jones | 3 || Allan Holdsworth | Toda a noite errado | 2 || Allan Holdsworth | Os Dezesseis Homens de Tain | 2 || Amigo Rico | Big Swing Face | 1 || Jim Reeves | Cantando na pista | 1 || O roteiro | Sem som sem silêncio | 1 |+------------------------+---------------------- ----+-------------------------------------+
 
 Observe que isso faz com que a contagem de artistas e álbuns seja repetida em várias linhas, mas isso é esperado quando também queremos listar cada álbum em sua própria linha. 
 Exemplo 8 – Com STRING_AGG()
 
 Se você não quiser que a contagem de cada artista e álbum seja repetida em várias linhas, como no exemplo anterior, você sempre pode usar o STRING_AGG() função para produzir os álbuns como uma lista. Nesse caso, você não precisaria do OVER cláusula. 
 
 Exemplo:
 SELECT ArtistName, STRING_AGG(AlbumName, ', ') 'Albums', COUNT(AlbumId) 'Count'FROM Artists arINNER JOIN Álbuns alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Count' DESC;
 
 Resultado:
 +------------------------+--------------------- -------------------------------------------------- ---------+---------+| ArtistName | Álbuns | Contagem ||------------------------+---------------------- -------------------------------------------------- --------+---------|| Donzela de Ferro | Powerslave, Somewhere in Time, Piece of Mind, Killers, No Prayer for the Dying | 5 || CA/CC | Powerage, Back in Black, Rock or Bust | 3 || Michael Aprende a Rock | Noite Azul, Eternidade, Escandinávia | 3 || Devin Townsend | Ziltoid o Onisciente, Vítimas de Cool, Epicloud | 3 || Tom Jones | Mala perdida há muito tempo, louvor e culpa, veio Jones | 3 || Allan Holdsworth | All Night Wrong, Os Dezesseis Homens de Tain | 2 || Amigo Rico | Big Swing Face | 1 || Jim Reeves | Cantando na pista | 1 || O roteiro | Sem som sem silêncio | 1 |+------------------------+---------------------- -------------------------------------------------- --------+---------+
 MUITAS Linhas?
 
 O COUNT() função retorna seu resultado como um int tipo de dados. Se você tiver tantas linhas que o resultado seja maior do que int pode lidar, tente COUNT_BIG() em vez de. 
 
 COUNT_BIG() funciona da mesma forma que COUNT() , exceto que seus resultados são retornados como um bigint valor do tipo de dados. 
 
 Você também pode considerar usar APPROX_COUNT_DISTINCT() em alguns casos. 
 
 APPROX_COUNT_DISTINCT() retorna um valor aproximado, em vez de um valor preciso. No entanto, ele foi projetado para ser muito mais responsivo do que COUNT() e COUNT_BIG() , portanto, pode ser útil para momentos em que a capacidade de resposta é mais importante que a precisão. 
 
 Ele foi projetado para retornar valores únicos e não nulos, portanto, seria relevante apenas para momentos em que você normalmente usaria o DISTINCT cláusula com COUNT_BIG() . 
 
 Observe também que, no momento de escrever APPROX_COUNT_DISTINCT() está no status de visualização pública.