In SQL der COUNT() Die Funktion ist eine Aggregatfunktion, die die Anzahl der in einer Gruppe gefundenen Elemente zurückgibt.
Sie können COUNT() verwenden in mehreren Teilen einer Abfrage. Sie können es zum Beispiel im SELECT verwenden Liste oder das HAVING -Klausel beim Filtern von Gruppen.
Beispieltabelle
Angenommen, wir haben die folgende Tabelle:
SELECT * FROM Pets;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
In den folgenden Beispielen wird COUNT() verwendet Funktion beim Abfragen dieser Tabelle.
Beispiel
Hier ist ein einfaches Beispiel für den Einstieg.
SELECT COUNT(*) AS Count
FROM Pets;Ergebnis:
+---------+ | Count | |---------| | 8 | +---------+
Dies sagt uns, dass es 8 Zeilen in der Tabelle gibt. Wir wissen das, weil wir den Sternchen-Platzhalter (* ), um alle Zeilen und alle Spalten anzugeben.
Zählen Sie eine bestimmte Spalte
Sie können auch eine bestimmte zu zählende Spalte angeben. Der COUNT() Funktion zählt nur Nicht-NULL Ergebnisse, also wenn Sie eine Spalte angeben, die NULL enthält Werte, diese Werte werden nicht gezählt.
Hier ist ein Beispiel, um zu demonstrieren, was ich meine.
SELECT COUNT(DOB) AS Count
FROM Pets;Ergebnis:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
In diesem Fall die Pets Tabelle enthält zwei NULL Werte im DOB Spalte (zwei Haustiere haben ihr Geburtsdatum nicht angegeben), also COUNT(DOB) gibt 6 statt 8 zurück, wenn wir COUNT(*) verwendet haben .
Der Grund COUNT(*) im vorherigen Beispiel alle Zeilen zurückgegeben hat, liegt daran, dass diese beiden Zeilen taten haben Daten in den anderen Spalten.
In meinem Beispiel hat mein DBMS auch eine Warnung dazu zurückgegeben. Abhängig von Ihrem DBMS und Ihrer spezifischen Konfiguration erhalten Sie möglicherweise eine Warnung oder auch nicht.
Gefilterte Ergebnisse
Der COUNT() Funktion zählt die von der Abfrage zurückgegebenen Zeilen. Wenn Sie also die Ergebnisse filtern, das Ergebnis von COUNT() wird das widerspiegeln.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Ergebnis:
+---------+ | Count | |---------| | 2 | +---------+
In diesem Fall gibt es zwei Haustiere mit dem Namen Fluffy. Daher wären zwei Zeilen von der Abfrage zurückgegeben worden, und das Ergebnis von COUNT() ist 2 .
Unterscheidbare Spalten zählen
Standardmäßig ist die COUNT() Funktion enthält ein implizites ALL Stichwort. Das bedeutet, dass Duplikate in den Ergebnissen enthalten sind.
Sie haben aber auch die Möglichkeit, den DISTINCT hinzuzufügen -Schlüsselwort, um anzugeben, dass nur eindeutige Werte zurückgegeben werden. Das heißt, Sie können festlegen, dass Duplikate ausgeschlossen werden.
Wählen wir den PetName Säule. Wenn Sie sich die obige Originaltabelle ansehen, können Sie sehen, dass der PetName Spalte enthält zwei Zeilen mit demselben Wert (Fluffy ).
Zuerst führen wir einen COUNT(ALL PetName) aus Abfrage, um alle doppelten Werte in die Zählung aufzunehmen:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Ergebnis:
+---------+ | Count | |---------| | 8 | +---------+
Es gibt also acht Zeilen. Denken Sie daran, dass dies das gleiche Ergebnis ist, das wir erhalten würden, wenn wir ALL nicht eingefügt hätten Schlüsselwort, weil ALL ist die Standardeinstellung.
Jetzt führen wir einen COUNT(DISTINCT PetName) aus um alle Duplikate aus der Zählung zu entfernen.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Ergebnis:
+---------+ | Count | |---------| | 7 | +---------+
Diesmal ist das Ergebnis 7 . Dies liegt daran, dass unser doppelter Wert eliminiert wurde. Das heißt, der doppelte Wert wurde so behandelt, als ob es nur einen Wert gäbe.
Mit COUNT() mit dem HAVING Klausel
Sie können COUNT() einschließen Funktion in mehreren Teilen einer Abfrage. Es ist nicht nur auf SELECT beschränkt Liste.
Hier ist ein Beispiel, das COUNT() verwendet sowohl im HAVING -Klausel und die SELECT Liste.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Ergebnis:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
In diesem Fall haben wir den HAVING verwendet -Klausel in Verbindung mit GROUP BY -Klausel, um nur die Zeilen zurückzugeben, die einen COUNT(PetTypeId) haben größer als 2 .
Sie sind nicht nur auf den )-Operator für Anfänger“>größer-als-Operator (>) beschränkt ) bei Verwendung des HAVING Klausel. Sie können dieselben Operatoren verwenden, die Sie mit WHERE verwenden können -Klausel (wie = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE usw.).
Eine Liste der in SQL verfügbaren Operatoren finden Sie unter SQL-Operatoren.
Fensterfunktionen
Abhängig von Ihrem DBMS können Sie möglicherweise einen OVER verwenden -Klausel mit Ihrem COUNT() Funktion zum Erstellen einer Fensterfunktion.
Eine Fensterfunktion führt eine aggregierte Operation für eine Reihe von Abfragezeilen aus. Es erzeugt ein Ergebnis für jede Abfragezeile. Dies steht im Gegensatz zu einer Aggregatoperation, die Abfragezeilen in einer einzigen Ergebniszeile gruppiert.
Hier ist ein Beispiel, um das Konzept zu demonstrieren.
Die Pets haben wir bereits gesehen Tisch. Unsere Datenbank hat auch einen Owners Tabelle, und sie enthält die folgenden Daten:
+-----------+-------------+------------+----------------+-------------------+ | 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] | +-----------+-------------+------------+----------------+-------------------+
Wir können Daten aus diesen Tabellen abrufen und sie mithilfe eines Joins als eine Ergebnismenge darstellen.
Wir können auch COUNT() verwenden Funktion mit dem OVER -Klausel, um eine Fensterfunktion auf die Daten anzuwenden.
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;Ergebnis:
+---------------+-----------+----------------------------------+ | 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 diesem Fall haben wir den OVER verwendet -Klausel mit unserem COUNT() -Klausel, um die Zählung nur auf den Namen des Eigentümers aufzuteilen.
Das Ergebnis ist, dass Besitzer mit mehreren Haustieren in mehreren Zeilen angezeigt werden (weil jedes Haustier auch angezeigt werden muss) und jede Zeile die Gesamtzahl der Haustiere dieses Besitzers enthält.
Dieses Konzept lässt sich auch auf andere Aggregatfunktionen in SQL anwenden, wie z. B. SUM() , MIN() , MAX() und AVG() .
COUNT_BIG()
Wenn Sie ernsthaft große Datensätze in SQL Server zählen, stellen Sie möglicherweise fest, dass die COUNT() Funktion erzeugt einen Fehler, da die Zahl zu hoch ist. Dies geschieht nur, wenn die Anzahl größer als 2.147.483.647 ist.
In solchen Fällen können Sie COUNT_BIG() verwenden , das für viel größere Zahlen geeignet ist.
Siehe Wie COUNT_BIG() Funktioniert in SQL Server und COUNT() vs COUNT_BIG() für eine ausführlichere Erklärung.
ANSI-SQL-Standard
Der COUNT() Die Funktion ist im SQL-Standard aufgeführt und in den meisten (wenn nicht allen) großen DBMSs verfügbar und funktioniert in allen ziemlich gleich.
Codebeispiele aus verschiedenen DBMS finden Sie unter SQLite COUNT() , SQL-Server COUNT() und MySQL COUNT() .
