Em SQL, o
COUNT() function é uma função agregada que retorna o número de itens encontrados em um grupo. Você pode usar
COUNT() em várias partes de uma consulta. Por exemplo, você pode usá-lo no SELECT lista, ou o HAVING cláusula ao filtrar grupos. Tabela de amostra
Suponha que temos a seguinte tabela:
SELECT * FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Os exemplos a seguir usarão o
COUNT() função ao consultar esta tabela. Exemplo
Aqui está um exemplo simples para começar.
SELECT COUNT(*) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 8 | +---------+
Isso nos diz que há 8 linhas na tabela. Sabemos disso porque usamos o curinga asterisco (
* ) para especificar todas as linhas e todas as colunas. Contar uma coluna específica
Você também pode especificar uma coluna específica para contar. O
COUNT() função conta apenas não-NULL resultados, portanto, se você especificar uma coluna que contém NULL valores, esses valores não serão contados. Aqui está um exemplo para demonstrar o que quero dizer.
SELECT COUNT(DOB) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
Neste caso, os
Pets tabela contém dois NULL valores no DOB coluna (dois animais de estimação não forneceram a data de nascimento) e, portanto, COUNT(DOB) retorna 6, em vez de 8 quando usamos COUNT(*) . O motivo
COUNT(*) no exemplo anterior retornou todas as linhas, porque essas duas linhas retornou tem dados nas outras colunas. No meu exemplo, meu DBMS também retornou um aviso sobre isso. Você pode ou não receber um aviso, dependendo do seu DBMS e da sua configuração específica.
Resultados filtrados
O
COUNT() função conta as linhas retornadas pela consulta. Portanto, se você filtrar os resultados, o resultado de COUNT() vai refletir isso. SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Resultado:
+---------+ | Count | |---------| | 2 | +---------+
Neste caso, existem dois animais de estimação com o nome de Fluffy. Portanto, duas linhas teriam sido retornadas pela consulta e o resultado de
COUNT() é 2 . Contar Colunas Distintas
Por padrão, o
COUNT() A função inclui um ALL implícito palavra-chave. Isso significa que inclui duplicatas em seus resultados. Mas você também tem a opção de adicionar o
DISTINCT palavra-chave para especificar que apenas valores distintos são retornados. Ou seja, você pode especificar que exclua duplicatas. Vamos escolher o
PetName coluna. Se você observar a tabela original acima, poderá ver que o PetName coluna inclui duas linhas com o mesmo valor (Fluffy ). Primeiro vamos executar um
COUNT(ALL PetName) query para incluir todos os valores duplicados na contagem:SELECT COUNT(ALL PetName) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 8 | +---------+
Portanto, há oito linhas. Lembre-se que este é o mesmo resultado que obteríamos se não tivéssemos incluído o
ALL palavra-chave, porque ALL é o padrão. Agora vamos executar um
COUNT(DISTINCT PetName) para eliminar quaisquer duplicatas da contagem. SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 7 | +---------+
Desta vez, o resultado é
7 . Isso ocorre porque nosso valor duplicado foi eliminado. Ou seja, o valor duplicado foi tratado como se houvesse apenas um valor. Usando COUNT() com o HAVING Cláusula
Você pode incluir o
COUNT() função em várias partes de uma consulta. Não se limita apenas ao SELECT Lista. Aqui está um exemplo que usa
COUNT() tanto no HAVING cláusula e o SELECT Lista. SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Resultado:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
Neste caso, usamos o
HAVING cláusula em conjunto com o GROUP BY cláusula para retornar apenas as linhas que têm um COUNT(PetTypeId) maior que 2 . Você não está limitado apenas ao operador ) para iniciantes”>maior que o operador (
> ) ao usar o HAVING cláusula. Você pode usar os mesmos operadores que você pode usar com o WHERE cláusula (como = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , etc). Consulte Operadores SQL para obter uma lista de operadores disponíveis em SQL.
Funções da janela
Dependendo do seu DBMS, você pode usar um
OVER cláusula com seu COUNT() função para criar uma função de janela. Uma função de janela executa uma operação semelhante à agregação em um conjunto de linhas de consulta. Ele produz um resultado para cada linha da consulta. Isso contrasta com uma operação agregada, que agrupa linhas de consulta em uma única linha de resultado.
Aqui está um exemplo para demonstrar o conceito.
Já vimos os
Pets tabela. Nosso banco de dados também possui um Owners tabela e contém os seguintes dados:+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
Podemos recuperar dados dessas tabelas e apresentá-los como um conjunto de resultados usando uma junção.
Também podemos usar o
COUNT() função com o OVER cláusula para aplicar uma função de janela aos dados. SELECT
CONCAT(o.FirstName, ' ', o.LastName) AS Owner,
p.PetName,
COUNT(PetId) OVER (PARTITION BY CONCAT(o.FirstName, ' ', o.LastName)) AS "Number of pets from this owner"
FROM Owners o
INNER JOIN Pets p
ON p.OwnerId = o.OwnerId
ORDER BY "Number of pets from this owner" DESC;Resultado:
+---------------+-----------+----------------------------------+ | Owner | PetName | Number of pets from this owner | |---------------+-----------+----------------------------------| | Nancy Simpson | Wag | 3 | | Nancy Simpson | Fluffy | 3 | | Nancy Simpson | Fetch | 3 | | Bart Pitt | Scratch | 2 | | Bart Pitt | Bark | 2 | | Boris Trump | Meow | 2 | | Boris Trump | Fluffy | 2 | | Homer Connery | Tweet | 1 | +---------------+-----------+----------------------------------+
Neste caso usamos o
OVER cláusula com nosso COUNT() cláusula para particionar a contagem apenas para o nome do proprietário. O resultado é que os proprietários com vários animais de estimação são exibidos em várias linhas (porque cada animal também precisa ser exibido), e cada linha contém a contagem agregada dos animais de estimação desse proprietário.
Este conceito também pode ser aplicado a outras funções agregadas em SQL, como
SUM() , MIN() , MAX() e AVG() . COUNT_BIG()
Se você estiver contando conjuntos de dados muito grandes no SQL Server, poderá descobrir que o
COUNT() A função produz um erro, devido ao número ser muito alto. Isso só acontecerá se sua contagem for maior que 2.147.483.647. Nesses casos, você pode usar
COUNT_BIG() , que pode atender a números muito maiores. Veja como
COUNT_BIG() Funciona no SQL Server e COUNT() vs COUNT_BIG() para uma explicação mais detalhada. Padrão ANSI SQL
O
COUNT() A função está listada no padrão SQL e está disponível na maioria (se não em todos) os principais SGBDs e funciona praticamente da mesma forma em todos eles. Para exemplos de código feitos em vários DBMSs, veja SQLite
COUNT() , SQL Server COUNT() e MySQL COUNT() . 
