In SQL, il COUNT() function è una funzione aggregata che restituisce il numero di elementi trovati in un gruppo.
Puoi usare COUNT() in più parti di una query. Ad esempio, puoi usarlo in SELECT elenco, o il HAVING clausola durante il filtraggio dei gruppi.
Tabella di esempio
Supponiamo di avere la seguente tabella:
SELECT * FROM Pets;Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Gli esempi seguenti utilizzeranno COUNT() funzione quando si interroga questa tabella.
Esempio
Ecco un semplice esempio per iniziare.
SELECT COUNT(*) AS Count
FROM Pets;Risultato:
+---------+ | Count | |---------| | 8 | +---------+
Questo ci dice che ci sono 8 righe nella tabella. Lo sappiamo perché abbiamo utilizzato il carattere jolly asterisco (* ) per specificare tutte le righe e tutte le colonne.
Conta una colonna specifica
Puoi anche specificare una particolare colonna da contare. Il COUNT() la funzione conta solo non NULL risultati, quindi se specifichi una colonna che contiene NULL valori, quei valori non verranno conteggiati.
Ecco un esempio per dimostrare cosa intendo.
SELECT COUNT(DOB) AS Count
FROM Pets;Risultato:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
In questo caso, il Pets la tabella contiene due NULL valori nel DOB colonna (due animali domestici non hanno fornito la loro data di nascita), e quindi COUNT(DOB) restituisce 6, invece di 8 quando abbiamo usato COUNT(*) .
Il motivo COUNT(*) nell'esempio precedente hanno restituito tutte le righe, perché quelle due righe hanno fatto avere dati nelle altre colonne.
Nel mio esempio, anche il mio DBMS ha restituito un avviso al riguardo. Potresti ricevere o meno un avviso, a seconda del tuo DBMS e della tua configurazione specifica.
Risultati filtrati
Il COUNT() la funzione conta le righe restituite dalla query. Quindi, se filtri i risultati, il risultato di COUNT() lo rifletterà.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Risultato:
+---------+ | Count | |---------| | 2 | +---------+
In questo caso, ci sono due animali domestici con il nome di Fluffy. Pertanto, la query avrebbe restituito due righe e il risultato di COUNT() è 2 .
Conta colonne distinte
Per impostazione predefinita, il COUNT() la funzione include un implicito ALL parola chiave. Ciò significa che include duplicati nei suoi risultati.
Ma hai anche la possibilità di aggiungere il DISTINCT parola chiave per specificare che vengono restituiti solo valori distinti. Cioè, puoi specificare che esclude i duplicati.
Scegliamo il PetName colonna. Se guardi la tabella originale sopra, puoi vedere che il PetName colonna include due righe con lo stesso valore (Fluffy ).
Per prima cosa eseguiremo un COUNT(ALL PetName) query per includere tutti i valori duplicati nel conteggio:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Risultato:
+---------+ | Count | |---------| | 8 | +---------+
Quindi, ci sono otto righe. Ricorda che questo è lo stesso risultato che otterremmo se non avessimo incluso ALL parola chiave, perché ALL è l'impostazione predefinita.
Ora eseguiremo un COUNT(DISTINCT PetName) per eliminare eventuali duplicati dal conteggio.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Risultato:
+---------+ | Count | |---------| | 7 | +---------+
Questa volta il risultato è 7 . Questo perché il nostro valore duplicato è stato eliminato. Cioè, il valore duplicato è stato trattato come se fosse presente un solo valore.
Utilizzo di COUNT() con il HAVING Clausola
Puoi includere COUNT() funzione in più parti di una query. Non è solo limitato a SELECT elenco.
Ecco un esempio che utilizza COUNT() in entrambi i HAVING clausola e il SELECT elenco.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Risultato:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
In questo caso, abbiamo usato il HAVING clausola unitamente al GROUP BY clausola per restituire solo quelle righe che hanno un COUNT(PetTypeId) maggiore di 2 .
Non sei limitato al solo ) Operatore per principianti">maggiore di operatore (> ) quando si utilizza il HAVING clausola. Puoi usare gli stessi operatori che puoi usare con WHERE clausola (come = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , ecc).
Vedere Operatori SQL per un elenco di operatori disponibili in SQL.
Funzioni della finestra
A seconda del tuo DBMS, potresti essere in grado di utilizzare un OVER clausola con il tuo COUNT() funzione per creare una funzione finestra.
Una funzione finestra esegue un'operazione di tipo aggregato su un insieme di righe di query. Produce un risultato per ogni riga di query. Ciò è in contrasto con un'operazione di aggregazione, che raggruppa le righe di query in un'unica riga di risultati.
Ecco un esempio per dimostrare il concetto.
Abbiamo già visto i Pets tavolo. Il nostro database ha anche un Owners tabella e contiene i seguenti dati:
+-----------+-------------+------------+----------------+-------------------+ | 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] | +-----------+-------------+------------+----------------+-------------------+
Possiamo recuperare i dati da queste tabelle e presentarli come un set di risultati utilizzando un join.
Possiamo anche usare COUNT() funzione con il OVER clausola per applicare una funzione finestra ai dati.
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;Risultato:
+---------------+-----------+----------------------------------+ | 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 | +---------------+-----------+----------------------------------+
In questo caso abbiamo usato il OVER clausola con il nostro COUNT() clausola per partizionare il conteggio solo per il nome del proprietario.
Il risultato è che i proprietari con più animali domestici vengono visualizzati su più righe (perché anche ogni animale domestico deve essere visualizzato) e ogni riga contiene il conteggio aggregato degli animali domestici di quel proprietario.
Questo concetto può essere applicato anche ad altre funzioni aggregate in SQL, come SUM() , MIN() , MAX() e AVG() .
COUNT_BIG()
Se stai contando set di dati di grandi dimensioni in SQL Server, potresti scoprire che COUNT() la funzione produce un errore, a causa del numero troppo alto. Ciò accadrà solo che il tuo conteggio è maggiore di 2.147.483.647.
In questi casi, puoi utilizzare COUNT_BIG() , che può soddisfare numeri molto più grandi.
Guarda come COUNT_BIG() Funziona in SQL Server e COUNT() rispetto a COUNT_BIG() per una spiegazione più dettagliata.
Standard ANSI SQL
Il COUNT() La funzione è elencata nello standard SQL ed è disponibile nella maggior parte (se non in tutti) dei principali DBMS e funziona praticamente allo stesso modo su di essi.
Per esempi di codice eseguiti in vari DBMS, vedere SQLite COUNT() , SQL Server COUNT() e MySQL COUNT() .
