Alle anderen Antworten auf diese Frage trafen nicht den entscheidenden Punkt.
Angenommen, wir haben eine Tabelle:
CREATE TABLE `table` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`value` int(10) unsigned NOT NULL,
PRIMARY KEY (`id`),
KEY `value` (`value`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
Und haben 10 Zeilen mit ID und Wert von 1 bis 10:
INSERT INTO `table`(`id`, `value`) VALUES (1, 1),(2, 2),(3, 3),(4, 4),(5, 5),(6, 6),(7, 7),(8, 8),(9, 9),(10, 10);
Versuchen Sie die folgenden 2 Abfragen:
SELECT `value` v FROM `table` WHERE `value`>5; -- Get 5 rows
SELECT `value` v FROM `table` HAVING `value`>5; -- Get 5 rows
Sie erhalten genau die gleichen Ergebnisse. Sie können sehen, dass die HAVING-Klausel ohne die GROUP BY-Klausel funktionieren kann.
Hier ist der Unterschied:
SELECT `value` v FROM `table` WHERE `v`>5;
Fehler # 1054 - Unbekannte Spalte 'v' in 'where-Klausel'
SELECT `value` v FROM `table` HAVING `v`>5; -- Get 5 rows
Mit der WHERE-Klausel kann eine Bedingung eine beliebige Tabellenspalte verwenden, jedoch keine Aliase oder Aggregatfunktionen. Mit der HAVING-Klausel kann eine Bedingung eine ausgewählte (!) Spalte, einen Alias oder eine Aggregatfunktion verwenden.
Dies liegt daran, dass die WHERE-Klausel Daten vor der Auswahl filtert, die HAVING-Klausel jedoch die resultierenden Daten nach der Auswahl filtert.
Wenn Sie also die Bedingungen in die WHERE-Klausel einfügen, ist dies effizienter, wenn Sie viele, viele Zeilen in einer Tabelle haben.
Versuchen Sie EXPLAIN, um den Hauptunterschied zu sehen:
EXPLAIN SELECT `value` v FROM `table` WHERE `value`>5;
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
| 1 | SIMPLE | table | range | value | value | 4 | NULL | 5 | Using where; Using index |
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
EXPLAIN SELECT `value` v FROM `table` having `value`>5;
+----+-------------+-------+-------+---------------+-------+---------+------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+-------+---------------+-------+---------+------+------+-------------+
| 1 | SIMPLE | table | index | NULL | value | 4 | NULL | 10 | Using index |
+----+-------------+-------+-------+---------------+-------+---------+------+------+-------------+
Sie können sehen, ob WHERE oder HAVING den Index verwendet, aber die Zeilen sind unterschiedlich.
SELECT value, COUNT(*) frequency FROM table GROUP BY value HAVING frequency > 10
...HAVING clause can use both column and alias.
zu...HAVING clause can use either column or alias.
und Wechsel...WHERE clause will be more effective
zu...WHERE clause will be more efficient
Der Hauptunterschied besteht darin, dass
WHERE
nicht für gruppierte Elemente (wie z. B.SUM(number)
) verwendet werden kannHAVING
kann, ist.Der Grund dafür ist das
WHERE
geschehen ist , bevor die Gruppierung undHAVING
erfolgt nach der Gruppierung erfolgt.quelle
HAVING
wird verwendet, um nach Aggregationen in Ihrem zu filternGROUP BY
.So suchen Sie beispielsweise nach doppelten Namen:
quelle
Diese 2 fühlen sich wie die ersten an, da beide verwendet werden, um über eine Bedingung zum Filtern von Daten zu sprechen. Obwohl wir in jedem Fall "Haben" anstelle von "Wo" verwenden können, gibt es Fälle, in denen wir "Wo" nicht anstelle von "Haben" verwenden können. Dies liegt daran, dass in einer Auswahlabfrage 'wobei' Daten vor 'Auswahl' filtert, während 'Daten nach' Auswahl 'gefiltert werden. Wenn wir also Aliasnamen verwenden, die sich nicht in der Datenbank befinden, kann 'wo' sie nicht identifizieren, aber 'haben' kann.
Beispiel: Lassen Sie die Tabelle Student student_id, Name, Geburtstag, Adresse enthalten. Angenommen, der Geburtstag ist vom Typ Datum.
quelle
WHERE
und vollständigHAVING
.Und weiter,
Auszug aus: Forta, Ben. "Sams bringt sich SQL in 10 Minuten bei (5. Ausgabe) (Sams bringt sich selbst bei ...)."
quelle
Haben wird nur mit Aggregation verwendet, aber wo mit Nicht-Aggregationsanweisungen.
quelle