Sqlserver
 sql >> Datenbank >  >> RDS >> Sqlserver

Funktionsweise von COUNT() in SQL Server

In SQL Server der COUNT() Die Funktion gibt die Anzahl der in einer Gruppe gefundenen Elemente zurück. Sie können damit herausfinden, wie viele Zeilen sich in einer Tabelle oder Ergebnismenge befinden.

Syntax

Die Syntax lautet wie folgt:

-- Aggregationsfunktionssyntax COUNT ( { [ [ ALL | DISTINCT ] expression ] | * } ) -- Analytische Funktionssyntax COUNT ( [ ALL ] { expression | * } ) OVER ( [  ] )

ALL wendet die Aggregatfunktion auf alle Werte an. Dies ist der Standardwert.

DISTINCT gibt an, dass die Funktion die Anzahl der eindeutigen Nicht-Null-Werte zurückgibt.

expression ist ein Ausdruck beliebigen Typs, außer image , ntext , oder Text . Aggregatfunktionen und Unterabfragen werden im Ausdruck nicht unterstützt.

* gibt an, dass alle Zeilen gezählt und zurückgegeben werden sollen, einschließlich doppelter Zeilen und Zeilen, die Nullwerte enthalten. COUNT(*) akzeptiert keine Parameter und unterstützt nicht die Verwendung von DISTINCT . Es erfordert auch keinen Ausdruck -Parameter (weil er keine Informationen über eine bestimmte Spalte verwendet).

OVER ( [ <partition_by_clause> ] teilt die von FROM erzeugte Ergebnismenge -Klausel in Partitionen, auf die die Funktion angewendet wird. Wenn nicht angegeben, behandelt die Funktion alle Zeilen der Ergebnismenge der Abfrage als eine einzige Gruppe.

Beispiel 1 – Grundlegende Verwendung

Hier ist ein einfaches Beispiel, das zeigt, wie diese Funktion funktioniert:

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

Ergebnis:

+-------------+| Zeilenanzahl ||-------------|| 16 |+-------------+

In diesem Fall gibt es 16 Zeilen in den Artists Tabelle.

Nur um sicherzugehen, hier sind sie:

SELECT *FROM Artists;

Ergebnis:

+------------+-----------------------+-------- ------+-------------+| ArtistID | Künstlername | AktivVon | CountryId ||------------+--------------------------------+--------- -----+-------------|| 1 | Eiserne Jungfrau | 1975-12-25 | NULL || 2 | Wechselstrom/Gleichstrom | 11.01.1973 | NULL || 3 | Allan Holdsworth | 1969-01-01 | NULL || 4 | Kumpel Reich | 01.01.1919 | NULL || 5 | Devin Townsend | 1993-01-01 | NULL || 6 | Jim Reeve | 01.01.1948 | NULL || 7 | Tom Jones | 1963-01-01 | NULL || 8 | Kastanienbraun 5 | 1994-01-01 | NULL || 9 | Das Skript | 01.01.2001 | NULL || 10 | beleuchtet | 1988-06-26 | NULL || 11 | Schwarzer Sabbath | 1968-01-01 | NULL || 12 | Michael lernt zu rocken | 1988-03-15 | NULL || 13 | Karabao | 01.01.1981 | NULL || 14 | Karniwool | 01.01.1997 | NULL || 15 | Vögel von Tokio | 01.01.2004 | NULL || 16 | Bodyjar | 1990-01-01 | NULL |+------------+-----------------------+--------- -----+-------------+

Wie erwartet werden 16 Zeilen zurückgegeben.

Beachten Sie, dass die CountryId Spalte enthält nichts als Nullwerte. Dies wird für das nächste Beispiel nützlich sein.

Beispiel 2 – Spalte angeben

Im vorherigen Beispiel wurde ein Sternchen (* ), um alle Zeilen anzugeben. Dies führt dazu, dass alle Zeilen gezählt werden, unabhängig davon, ob es Duplikate gibt oder ob irgendwelche Nullwerte enthalten.

Sie können auch eine bestimmte Spalte angeben. Dabei werden Nullwerte nicht gezählt. Das heißt, alle Zeilen, die einen Nullwert für diese Spalte enthalten, werden nicht gezählt.

Hier ist ein Beispiel mit der CountryId Spalte wie im vorherigen Beispiel erwähnt:

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

Ergebnis:

+-------------+| Zeilenanzahl ||-------------|| 0 |+------------+

Wie wir im vorherigen Beispiel gesehen haben, sind alle Zeilen für diese Spalte NULL . Daher ist die resultierende Zeilenanzahl Null.

Fügen wir dieser Spalte einige Werte hinzu:

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

Lassen Sie uns nun die Zeilen für diese Spalte erneut zählen:

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

Ergebnis:

+-------------+| Zeilenanzahl ||-------------|| 4 |+-------------+

Beispiel 3 – Mit DISTINCT

Dieses Beispiel verwendet den DISTINCT -Klausel, um nur unterschiedliche Zeilen zurückzugeben (d. h. keine Duplikate).

Im vorherigen Beispiel habe ich die Tabelle so aktualisiert, dass dieselbe CountryId wurde auf vier Künstler angewendet (ich habe SET CountryId = 2 verwendet für alle vier Künstler). Dies führte zu vier Zeilen mit derselben CountryId .

Folgendes passiert, wenn ich zähle, wie viele verschiedene CountryId s befinden sich in dieser Tabelle:

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

Ergebnis:

+-----------------------+| Eindeutige CountryIds ||---------------------|| 1 |+-----------------------+

Das ist zu erwarten, denn obwohl es vier Zeilen mit einer CountryId gibt , ist es immer noch nur eine eindeutige CountryId .

Um sicherzugehen, lassen Sie es uns zusammen mit seiner „nicht eindeutigen“ Version ausführen:

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

Ergebnis:

+----------------+------------+| Nicht unterscheidbar | Eindeutig ||----------------+------------|| 4 | 1 |+----------------+------------+

Die nicht eindeutige Version zeigt also wie oft die CountryId erscheint in der Tabelle, während der DISTINCT Version zählt mehrere Vorkommen als 1.

Lassen Sie uns eine weitere CountryId hinzufügen zur Tabelle:

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

Führen Sie nun die Abfrage erneut aus:

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

Ergebnis:

+----------------+------------+| Nicht unterscheidbar | Eindeutig ||----------------+------------|| 5 | 2 |+-----------+------------+

Beispiel 4 – Verwenden Sie eine WHERE-Klausel

Hier ist ein kurzes Beispiel mit einem WHERE Klausel.

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

Ergebnis:

+-------------+| Zeilenanzahl ||-------------|| 2 |+-------------+

Beispiel 5 – Mit GROUP BY

Hier ist ein Beispiel für das Gruppieren der Künstler in einer Spalte und das Zählen aller Alben für jeden Künstler in der anderen Spalte.

Beispiel:

SELECT ArtistName, COUNT(al.AlbumId) 'Anzahl der Alben'FROM Artists arINNER JOIN Alben alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Anzahl der Alben' DESC;

Ergebnis:

+------------------------+--------------------+ | Künstlername | Anzahl der Alben ||--------------------------------+-------------------- || Eiserne Jungfrau | 5 || Michael lernt zu rocken | 3 || Das Skript | 3 || Tom Jones | 3 || Devin Townsend | 3 || Allan Holdsworth | 2 || Kumpel Reich | 1 || Wechselstrom/Gleichstrom | 1 || Jim Reeve | 1 |+--------------------------------+--------------------+

Beispiel 6 – Mit der HAVING-Klausel

Wir können das vorherige Beispiel optimieren, um nur die Künstler einzubeziehen, die mehr als eine bestimmte Anzahl von Alben haben. Wir können dies mit dem HAVING tun Klausel.

SELECT ArtistName, COUNT(al.AlbumId) 'Anzahl der Alben'FROM Artists arINNER JOIN Alben alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameHAVING COUNT(al.AlbumId)> 2ORDER BY 'Anzahl der Alben' DESC; 

 Ergebnis:
 
+------------------------+--------------------+ | Künstlername | Anzahl der Alben ||--------------------------------+-------------------- || Eiserne Jungfrau | 5 || Michael lernt zu rocken | 3 || Das Skript | 3 || Tom Jones | 3 || Devin Townsend | 3 |+------------------------+--------------------+
 
Beispiel 7 – Partitionierung mit der OVER-Klausel
 

 Sie können den OVER verwenden -Klausel mit PARTITION BY um die Ergebnisse in Partitionen aufzuteilen. 
 

 In diesem Beispiel verwende ich OVER (PARTITION BY ArtistName) um jedes Album aufzulisten, das der Künstler produziert hat, sowie die Gesamtzahl der Alben für diesen Künstler. 
 
SELECT ArtistName, AlbumName, COUNT(AlbumId) OVER (PARTITION BY ArtistName) 'Anzahl der Alben dieses Künstlers'FROM Artists arINNER JOIN Alben alON al.ArtistId =ar.ArtistIdORDER BY 'Anzahl der Alben dieses Künstlers' DESC; 
 

 Ergebnis:
 
+------------------------+--------------------- -----+-------------------------------------+| Künstlername | Albumname | Anzahl der Alben dieses Künstlers ||------------------------+---------------- ---------+------------------------------------|| Eiserne Jungfrau | Machtsklave | 5 || Eiserne Jungfrau | Irgendwo in der Zeit | 5 || Eiserne Jungfrau | Seelenfrieden | 5 || Eiserne Jungfrau | Mörder | 5 || Eiserne Jungfrau | Kein Gebet für die Sterbenden | 5 || Wechselstrom/Gleichstrom | Powerage | 3 || Wechselstrom/Gleichstrom | Zurück in Schwarz | 3 || Wechselstrom/Gleichstrom | Rock oder Büste | 3 || Michael lernt zu rocken | Blaue Nacht | 3 || Michael lernt zu rocken | Ewigkeit | 3 || Michael lernt zu rocken | Skandinavien | 3 || Devin Townsend | Ziltoid der Allwissende | 3 || Devin Townsend | Opfer von Cool | 3 || Devin Townsend | Epiwolke | 3 || Tom Jones | Lange verlorener Koffer | 3 || Tom Jones | Lob und Tadel | 3 || Tom Jones | Da kam Jones | 3 || Allan Holdsworth | Die ganze Nacht falsch | 2 || Allan Holdsworth | Die sechzehn Männer von Tain | 2 || Kumpel Reich | Großes Schwunggesicht | 1 || Jim Reeve | Singen auf der Gasse | 1 || Das Skript | Kein Ton ohne Stille | 1 |+------------------------+--------------------- ----+-------------------------------------+
 

 Beachten Sie, dass dies dazu führt, dass die Anzahl der Künstler und Alben über mehrere Zeilen hinweg wiederholt wird, aber dies ist zu erwarten, wenn wir auch jedes Album in einer eigenen Zeile auflisten möchten.
 
Beispiel 8 – Mit STRING_AGG()
 

 Wenn Sie nicht möchten, dass die Anzahl der Künstler und Alben wie im vorherigen Beispiel über mehrere Zeilen wiederholt wird, können Sie immer STRING_AGG() verwenden Funktion zur Ausgabe der Alben als Liste. In diesem Fall benötigen Sie den OVER nicht Klausel.
 

 Beispiel:
 
SELECT ArtistName, STRING_AGG(AlbumName, ', ') 'Alben', COUNT(AlbumId) 'Count'FROM Artists arINNER JOIN Alben alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Count' DESC;
 

 Ergebnis:
 
+------------------------+--------------------- -------------------------------------------------- ---------+---------+| Künstlername | Alben | Anzahl ||------------------------+--------------------- -------------------------------------------------- --------+---------|| Eiserne Jungfrau | Powerslave, Irgendwo in der Zeit, Seelenfrieden, Mörder, Kein Gebet für die Sterbenden | 5 || Wechselstrom/Gleichstrom | Powerage, zurück in Schwarz, Rock oder Büste | 3 || Michael lernt zu rocken | Blaue Nacht, Ewigkeit, Skandinavien | 3 || Devin Townsend | Ziltoid der Allwissende, Opfer von Cool, Epicloud | 3 || Tom Jones | Lang verlorener Koffer, Lob und Tadel, Jones kam mit | 3 || Allan Holdsworth | Die ganze Nacht falsch, Die sechzehn Männer von Tain | 2 || Kumpel Reich | Großes Schwunggesicht | 1 || Jim Reeve | Singen auf der Gasse | 1 || Das Skript | Kein Ton ohne Stille | 1 |+------------------------+--------------------- -------------------------------------------------- --------+---------+
 
VIELE Zeilen?
 

 Der COUNT() Die Funktion gibt ihr Ergebnis als int zurück Datentyp. Wenn Sie so viele Zeilen haben, dass das Ergebnis größer als int ist verarbeiten können, versuchen Sie es mit COUNT_BIG() stattdessen.
 

 COUNT_BIG() funktioniert genauso wie COUNT() , außer dass die Ergebnisse als bigint zurückgegeben werden Datentypwert.
 

 Sie können auch die Verwendung von APPROX_COUNT_DISTINCT() in Betracht ziehen in manchen Fällen. 
 

 APPROX_COUNT_DISTINCT() gibt eher einen ungefähren als einen genauen Wert zurück. Es ist jedoch so konzipiert, dass es viel reaktionsschneller ist als COUNT() und COUNT_BIG() , daher könnte es in Zeiten nützlich sein, in denen Reaktionsfähigkeit wichtiger ist als Präzision.
 

 Es wurde entwickelt, um eindeutige Nicht-Null-Werte zurückzugeben, sodass es nur für Zeiten relevant wäre, in denen Sie normalerweise DISTINCT verwenden würden -Klausel mit COUNT_BIG() .
 

 Beachten Sie auch, dass zum Zeitpunkt des Schreibens von APPROX_COUNT_DISTINCT() befindet sich im öffentlichen Vorschaustatus.