MySQL bevat een COUNT() functie, waarmee u kunt achterhalen hoeveel rijen zouden worden geretourneerd door een query. Deze functie maakt deel uit van de SQL-standaard en kan worden gebruikt met de meeste relationele databasebeheersystemen.
De COUNT() De functie kan indien nodig ook worden gebruikt om de resultaten van een zoekopdracht te beïnvloeden, bijvoorbeeld door alleen die resultaten te retourneren waarvan het aantal rijen groter is dan een bepaald aantal.
Dit artikel bevat voorbeelden van COUNT() gebruik in MySQL.
De gegevens
Ten eerste, hier zijn de gegevens die we zullen gebruiken voor de voorbeelden op deze pagina:
SELECT * FROM Tasks;
Resultaat:
+--------+-------------------+-----------------+ | TaskId | TaskName | TaskDescription | +--------+-------------------+-----------------+ | 1 | Do garden | NULL | | 2 | Feed cats | NULL | | 3 | Paint roof | NULL | | 4 | Take dog for walk | NULL | | 5 | Relax | NULL | | 6 | Feed cats | NULL | +--------+-------------------+-----------------+
Tel alle rijen in een tabel
U kunt COUNT() . gebruiken om het totale aantal rijen in een tabel te retourneren:
SELECT COUNT(*) FROM Tasks;
Resultaat:
+----------+ | COUNT(*) | +----------+ | 6 | +----------+
Dit retourneert het aantal rijen in de tabel omdat we geen criteria hebben opgegeven om de resultaten te verfijnen.
Beperk de resultaten
Wanneer we een WHERE . toevoegen clausule die de resultatenset verkleint, krijgen we een kleiner aantal:
SELECT COUNT(*) FROM Tasks WHERE TaskName LIKE '%cat%';
Resultaat:
+----------+ | COUNT(*) | +----------+ | 2 | +----------+
Enkele kolom versus sterretje (*)
De vorige voorbeelden gebruiken allemaal een asterisk om de telling op alle kolommen toe te passen. Zoals bij elke zoekopdracht is het sterretje optioneel en wordt het gebruikt als jokerteken om alle kolommen te retourneren. Dus bij gebruik van de COUNT() functie, hebt u ook de mogelijkheid om specifieke kolommen (in tegenstelling tot alle kolommen) als argument op te geven.
Voorbeeld:
SELECT COUNT(TaskName) FROM Tasks;
Resultaat:
+-----------------+ | COUNT(TaskName) | +-----------------+ | 6 | +-----------------+
Hoewel dit voorbeeld hetzelfde resultaat oplevert dat we kregen toen we de asterisk gebruikten, is dat niet altijd het geval. Dit is bijvoorbeeld wat er gebeurt als we een andere kolom specificeren:
SELECT COUNT(TaskDescription) FROM Tasks;
Resultaat:
+------------------------+ | COUNT(TaskDescription) | +------------------------+ | 0 | +------------------------+
In dit geval krijgen we nul, omdat die bepaalde kolom null-waarden bevat in elke rij.
Voorbeeld – Duidelijk
U kunt de DISTINCT . toevoegen argument om alleen het aantal rijen met verschillende niet-NULL . te retourneren waarden.
Het is je misschien opgevallen dat de TaskName kolom een dubbele waarde heeft (“Katten voeren” verschijnt twee keer). Dit kan problemen veroorzaken als u niet wilt dat duplicaten worden geteld.
Zo ziet het eruit als we de DISTINCT . toepassen argument aan de TaskName kolom:
SELECT COUNT(DISTINCT TaskName) FROM Tasks;
Resultaat:
+--------------------------+ | COUNT(DISTINCT TaskName) | +--------------------------+ | 5 | +--------------------------+
Dus hoewel de tabel zes rijen bevat, zijn er twee duplicaten. Daarom worden die twee geteld als één, we krijgen een resultaat van vijf.
Voorbeeld – De HAVING-clausule
U kunt ook COUNT() . gebruiken met de HAVING clausule om een resultaatset te beperken op basis van het aantal rijen dat zou worden geretourneerd.
Hier is een voorbeeld met een andere dataset dan de vorige voorbeelden:
USE Music;
SELECT ar.ArtistName,
COUNT(al.AlbumName) 'Album Count'
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
GROUP BY ar.ArtistName
HAVING COUNT(al.AlbumName) > 1;
Resultaat:
+------------------------+-------------+ | ArtistName | Album Count | +------------------------+-------------+ | Iron Maiden | 5 | | Devin Townsend | 3 | | Michael Learns to Rock | 3 | | Tom Jones | 3 | | Allan Holdsworth | 2 | +------------------------+-------------+
Deze zoekopdracht retourneert alleen de artiesten die meer dan 1 album hebben uitgebracht. Dit is wat er gebeurt als we de waarde verhogen in de HAVING clausule:
USE Music;
SELECT ar.ArtistName,
COUNT(al.AlbumName) 'Album Count'
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
GROUP BY ar.ArtistName
HAVING COUNT(al.AlbumName) > 4;
Resultaat:
+-------------+-------------+ | ArtistName | Album Count | +-------------+-------------+ | Iron Maiden | 5 | +-------------+-------------+