Den Umgang mit der GROUP BY-Klausel lernen

GROUP BY ist ein wichtiger Bestandteil der SQL SELECT-Anweisung. Aber neue SQL-Programmierer können auf einige Probleme stoßen, wenn diese Klausel nicht korrekt verwendet wird. Hier erfahren Sie, wie Sie diese Probleme vermeiden können.

Sie lernen gerade SQL. Sie wissen, wie man Daten aus einer Tabelle auswählt (SELECT) und wie man die Daten mit einer WHERE-Klausel filtert. Sie können die Daten mit Aggregatfunktionen (MIN, MAX, SUM, AVG und andere) verarbeiten. Aber wenn Sie es mit vielen Daten zu tun haben, müssen Sie sie vielleicht noch weiter eingrenzen. Hier kommt die GROUP BY-Klausel ins Spiel, mit der Sie die Informationen anhand der von Ihnen festgelegten Parameter organisieren können.

In diesem Artikel wird erklärt, wie Sie GROUP BY verwenden können. Außerdem wird auf einige mögliche Probleme eingegangen, und es wird erläutert, wie man sie vermeiden oder beheben kann.

Verwendung von GROUP BY

Um zu verstehen, wie man GROUP BY verwendet, müssen wir zunächst eine Tabelle definieren, an der wir üben können. Wie wäre es mit einer, die Personen beschreibt?

| ID | Name     | Gender | Height | Weight | Eye_color |
--------------------------------------------------------
|  1 | Mark     | Male   |    180 |     78 | Blue      |
|  2 | Susan    | Female |    172 |     59 | Brown     |
|  3 | Thomas   | Male   |    179 |     92 | Brown     |
|  4 | Katarina | Female |    164 |     53 | Green     |
|  5 | Mindy    | Female |    170 |     58 | Blue      |
--------------------------------------------------------

Damit haben wir unsere Übungstabelle. Jetzt geht es an die Statistik. Wie hoch ist zum Beispiel die durchschnittliche Größe aller unserer Personen? Um das herauszufinden, tippen wir:

SELECT AVG(Height)
FROM People

+-------------+
| AVG(Height) |
+-------------+
|    173.0000 |
+-------------+

Nehmen wir nun an, wir wollen die Durchschnittsgröße nach Geschlecht wissen. Das scheint ganz einfach zu sein; wir fügen einfach eine WHERE-Klausel hinzu. Wir geben also ein:

SELECT AVG(Height)
FROM People
WHERE Gender = ‘Male’

Was aber, wenn wir andere Geschlechter in unsere Tabelle aufnehmen? In diesem Fall müssten wir zusätzliche Abfragen schreiben und die benötigten Daten manuell erfassen. Es ist einfacher, unsere Daten nach Gender zu gruppieren und dann die durchschnittliche Größe für jede Gruppe zu berechnen, wie unten gezeigt.

SELECT Gender, AVG(Height)
FROM People
GROUP BY Gender

+--------+-------------+
| Gender | AVG(Height) |
+--------+-------------+
| Female |    168.6667 |
| Male   |    179.5000 |
+--------+-------------+

Gruppieren scheint einfach zu sein, oder? Sie müssen lediglich die GROUP BY-Klausel zu Ihrer SQL-Anweisung hinzufügen. Nehmen wir jedoch an, dass wir zwei Parameter in unserer Suche benötigen. In diesem Fall müssen wir nach zwei Spalten gruppieren. Nehmen wir an, wir wollen wissen, wie viele Männer und Frauen blaue, braune oder grüne Augen haben. Wir würden eingeben:

SELECT Gender, Eye_color, COUNT(*)
FROM People
GROUP BY Gender, Eye_color

+--------+-----------+----------+
| Gender | Eye_color | COUNT(*) |
+--------+-----------+----------+
| Female | Blue      |        1 |
| Female | Brown     |        1 |
| Female | Green     |        1 |
| Male   | Blue      |        1 |
| Male   | Brown     |        1 |
+--------+-----------+----------+

Dies ist nur eine Einführung in GROUP BY. Sie können es auf viele Arten verwenden. Probieren Sie doch einmal verschiedene Aggregatfunktionen (wie AVG und COUNT) aus, um ein besseres Verständnis für GROUP BY zu bekommen.

Häufige GROUP BY-Fehler

Obwohl GROUP BY recht einfach zu verwenden ist, sehen sich SQL-Neulinge häufig mit verwirrenden Fehlermeldungen konfrontiert. Hier sind einige, auf die wir häufig stoßen:

1. Mehrere Werte auswählen

Das Wichtigste bei der Verwendung von GROUP BY ist, dass es sich bei dem , was Sie AUSWÄHLEN wollen, um einen einzigen Wert handeln muss. Aus diesem Grund müssen wir eine Aggregatfunktion verwenden: Sie nimmt mehrere Werte und gibt einen einzigen zurück.

Um das zu verdeutlichen, sehen wir uns unsere Gruppen an:

+--------+--------+
| Gender | Height |
+--------+--------+
| Male   |    180 |
|        |    179 |
| Female |    172 |
|        |    164 |
|        |    170 |
+--------+--------+

Wenn wir nach Höhe gruppiert nach Gender fragen, wollen wir einen einzigen Wert erhalten. Aber hier hat Male zwei Werte für Höhe und Female hat drei. Welchen sollen wir wählen?

SELECT Gender, Height
FROM People
GROUP BY Gender;

(MYSQL) ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP BY clause and contains 
nonaggregated column 'vertabelo.People.Height' which is not functionally dependent on columns 
in GROUP BY clause;

Deshalb müssen wir eine Aggregatfunktion (wie AVG, die wir bereits verwendet haben) verwenden, um einen einzigen Wert zu erhalten.

2. WHERE zum Filtern der Ergebnisse verwenden

Angenommen, wir möchten nur die Augenfarbenergebnisse von Personengruppen anzeigen, die größer als 170 cm sind. Wenn wir versuchen, dies in die WHERE-Klausel einzugeben, wie unten gezeigt:

SELECT Gender, Eye_color, COUNT(*)
FROM People
WHERE AVG(Height) > 170
GROUP BY Gender, Eye_color

Wir erhalten die unten gezeigte Fehlermeldung:

(MYSQL) ERROR 1111 (HY000): Invalid use of group function

Das liegt daran, dass die Datenbank unsere Datensätze nach der Filterung gruppiert. Wir möchten, dass sie das Ergebnis der GROUP BY-Anweisung filtern. Dazu verwenden wir eine weitere Klausel namens HAVING. Sie kommt nach GROUP BY und funktioniert wie WHERE. Der Unterschied ist, dass Sie darin Aggregatfunktionen verwenden können. Um die gewünschte Ergebnismenge zu erhalten, würden wir diesen Code schreiben:

SELECT Gender, Eye_color, COUNT(*)
FROM People
GROUP BY Gender, Eye_color
HAVING AVG(Height) > 170

Denken Sie daran, dass eine SQL SELECT-Anweisung in der Datenbank immer in dieser Reihenfolge ausgeführt wird:

1. FROM
2. WHERE
3. GROUP BY
4. HAVING
5. SELECT
6. ORDER BY

Wir nehmen eine Datenquelle, filtern die Datensätze, gruppieren sie, filtern die Gruppen, wählen die gewünschten Spalten aus und sortieren sie dann.

3. Multiple Entity-Fehler

Dies ist ein wenig fortgeschrittener. Wenn wir mehrere Tabellen miteinander verknüpft haben, ist es durchaus möglich, dass einige Entitäten denselben Namen haben. Daher möchten wir die Ergebnisse oft nach der Entitäts-ID und nicht nach dem Namen der Entität gruppieren.

Nehmen wir zum Beispiel an, dass Sie die Städtedaten für Warschau suchen. Es gibt ein Warschau, das die Hauptstadt Polens ist, und ein Warschau, das sich im Bundesstaat Indiana, USA, befindet.

Nehmen wir also an, wir haben eine Tabelle wie diese definiert:

Table City:
---------------------
| ID | Name | Award | 
---------------------

Diese Tabelle beschreibt Städte, die eine oder mehrere Auszeichnungen erhalten haben. Eine Stadt wird durch ihre ID identifiziert und kann viele Auszeichnungen haben.

Wenn wir die Anzahl der Auszeichnungen, die eine Stadt erhalten hat, sehen und diese Informationen nach Städtenamen gruppiert haben möchten, würden wir vielleicht diese Abfrage verwenden:

SELECT City.Name, COUNT(Award)
FROM City
GROUP BY City.Name

Das Problem ist, dass bei der Verwendung von City.Name die Auszeichnungen für Warschau, Polen, und Warschau, Indiana, addiert werden würden. Schließlich heißen beide Warschau! Es handelt sich jedoch um unterschiedliche Orte, und als solche haben sie unterschiedliche City.ID Werte. Wenn Sie sich eine Stadt als Datenbankentität vorstellen, wird sie durch ihre ID identifiziert und nicht durch ihre Attribute (wie Name). Wenn wir die Ergebnisse nach der ID gruppieren, erhalten wir die richtigen Informationen. Da wir trotzdem den Namen anzeigen wollen, verwenden wir etwas wie dieses:

SELECT City.Name, COUNT(Award)
FROM City
GROUP BY City.ID

Das Ergebnis wird separate Einträge für die verschiedenen Warschauer mit den gewünschten Werten enthalten. (Normalerweise gäbe es eine weitere Spalte, wie "Land" oder "Bundesland", um zwischen diesen beiden Städten zu unterscheiden. Aber um des Beispiels willen, nehmen wir an, es gibt keine).

4. Verwendung von Werten, die "nicht aggregiert" sind

Im obigen Beispiel haben wir das Attribut City.Name ausgewählt und die Ergebnisse nach dem Attribut City.ID gruppiert. In unserer Tabelle hat jeder Datensatz mit der gleichen ID auch den gleichen Städtenamen. Einige Datenbanken haben damit kein Problem und geben die erwarteten Ergebnisse zurück, aber andere geben eine Fehlermeldung aus, die besagt, dass City.Name nicht in der Klausel GROUP BY enthalten ist und nicht aggregiert wird. Ich habe die MySQL-Fehlermeldung unten wiedergegeben:

(MYSQL) ERROR 1055 (42000): Expression #1 of SELECT list is not in GROUP BY clause and contains 
nonaggregated column 'vertabelo.City.Name' which is not functionally dependent on columns 
in GROUP BY clause;

Aber es ist ein einzelner Wert! Wie können wir diesen Fehler beheben? Nun, da ein City.ID genau einem City.Name entspricht, können wir beide in die Klausel GROUP BY aufnehmen:

SELECT City.Name, COUNT(*)
FROM City
JOIN Person ON (Person.CityID = City.ID)
GROUP BY City.ID, City.Name

Damit sollte das Problem behoben sein.

Übung macht den Meister

Wenn Sie immer noch nicht wissen, wie oder wann Sie die GROUP BY-Klausel verwenden sollen, oder wenn Sie die Verwendung üben möchten, schauen Sie sich unseren SQL-Abfrage kurs an. Er deckt sowohl die Grundlagen als auch die fortgeschrittenen Dinge ab, so dass Sie viele Möglichkeiten haben, Ihre SQL-Kenntnisse zu perfektionieren.