Die einfachste Form von SELECT ruft alle in der Tabelle vorhandenen Daten ab:

mysql> SELECT * FROM haustier;
+----------+----------+----------+------------+------------+------------+
| name     | besitzer | gattung  | geschlecht | geburtstag | todestag   |
+----------+----------+----------+------------+------------+------------+
| Fluffy   | Harold   | Katze    | w          | 1993-02-04 | NULL       |
| Claws    | Gwen     | Katze    | m          | 1994-03-17 | NULL       |
| Buffy    | Harold   | Hund     | w          | 1989-05-13 | NULL       |
| Fang     | Benny    | Hund     | m          | 1990-08-27 | NULL       |
| Bowser   | Diane    | Hund     | m          | 1979-08-31 | 1995-07-29 |
| Chirpy   | Gwen     | Vogel    | w          | 1998-09-11 | NULL       |
| Whistler | Gwen     | Vogel    | NULL       | 1997-12-09 | NULL       |
| Slim     | Benny    | Schlange | m          | 1996-04-29 | NULL       |
| Puffball | Diane    | Hamster  | w          | 1999-03-30 | NULL       |
+----------+----------+----------+------------+------------+------------+

Diese Verwendung von SELECT ist nützlich, wenn Sie beispielsweise Ihre Tabelle überprüfen wollen, nachdem Sie gerade die ersten Daten eingeladen haben. Nehmen wir etwa an, dass Sie nicht ganz sicher sind, ob Sie für Bowser das richtige Geburtsdatum eingegeben haben. Dem Stammbaum entnehmen Sie, dass das korrekte Geburtsjahr nicht 1979, sondern 1989 lautet.

Nun gibt es zwei Möglichkeiten, den Fehler zu beheben:

Wie im vorherigen Abschnitt gezeigt, ist das Abrufen der Daten einer ganzen Tabelle recht einfach. Sie lassen einfach die WHERE-Klausel in der SELECT-Anweisung weg. In der Regel wollen Sie aber nicht die gesamte Tabelle anzeigen – insbesondere dann nicht, wenn diese sehr groß ist. Stattdessen werden Sie meist an der Beantwortung einer bestimmten Frage interessiert sein. In diesem Fall müssen Sie Beschränkungen für die gewünschten Daten definieren. Betrachten wir einmal einige Auswahlabfragen dahingehend, welche Fragen diese zu Ihren Haustieren beantworten.

Sie können die Auswahl in Ihrer Tabelle auch auf bestimmte Datensätze beschränken. Wollen Sie z. B. die Änderungen am Geburtsdatum von Bowser überprüfen, dann wählen Sie den entsprechenden Datensatz wie folgt aus:

mysql> SELECT * FROM haustier WHERE name = 'Bowser';
+--------+----------+----------+------------+------------+------------+
| name   | besitzer | gattung  | geschlecht | geburtstag | todestag   |
+--------+----------+----------+------------+------------+------------+
| Bowser | Diane    | Hund     | m          | 1989-08-31 | 1995-07-29 |
+--------+----------+----------+------------+------------+------------+

Die Ausgabe bestätigt die korrekte Änderung der Jahresangabe von 1979 auf 1989.

Bei String-Vergleichen wird die Groß-/Kleinschreibung normalerweise ignoriert, weswegen Sie den Namen als 'bowser', 'BOWSER' usw. angeben können. Das Abfrageergebnis ist stets gleich.

Sie können Bedingungen aber nicht nur für name, sondern für jede beliebige Spalte angeben. Wenn Sie beispielsweise wissen wollen, welche Tiere im Jahre 1998 oder danach geboren wurden, testen Sie die Spalte geburtstag:

mysql> SELECT * FROM haustier WHERE geburtstag >= '1998-1-1';
+----------+----------+---------+-------------+------------+----------+
| name     | besitzer | gattung | geschlecht  | geburtstag | todestag |
+----------+----------+---------+-------------+------------+----------+
| Chirpy   | Gwen     | Vogel   | w           | 1998-09-11 | NULL     |
| Puffball | Diane    | Hamster | w           | 1999-03-30 | NULL     |
+----------+----------+---------+-------------+------------+----------+

Sie können auch Bedingungen kombinieren, um etwa nach weiblichen Hunden zu suchen:

mysql> SELECT * FROM haustier WHERE gattung = 'Hund' AND geschlecht = 'w';
+-------+-----------+---------+-------------+------------+----------+
| name  | besitzer  | gattung | geschlecht  | geburtstag | todestag |
+-------+-----------+---------+-------------+------------+----------+
| Buffy | Harold    | Hund    | w           | 1989-05-13 | NULL     |
+-------+-----------+---------+-------------+------------+----------+

Obige Abfrage verwendet den Operator AND (logisches Und). Es gibt analog auch einen Operator OR (logisches Oder):

mysql> SELECT * FROM haustier WHERE gattung = 'Schlange' OR gattung = 'Vogel';
+----------+----------+----------+-------------+------------+----------+
| name     | besitzer | gattung  | geschlecht  | geburtstag | todestag |
+----------+----------+----------+-------------+------------+----------+
| Chirpy   | Gwen     | Vogel    | w           | 1998-09-11 | NULL     |
| Whistler | Gwen     | Vogel    | NULL        | 1997-12-09 | NULL     |
| Slim     | Benny    | Schlange | m           | 1996-04-29 | NULL     |
+----------+----------+----------+-------------+------------+----------+

AND und OR können auch gemischt verwendet werden, wobei AND jedoch Vorrang vor OR hat. Wenn Sie beide Operatoren verwenden, bietet sich die Verwendung von Klammern an, um exakt anzugeben, wie die Bedingungen gruppiert werden sollen:

mysql> SELECT * FROM haustier WHERE (gattung = 'Katze' AND geschlecht = 'm')
    -> OR (gattung = 'Hund' AND geschlecht = 'w');
+-------+-----------+---------+-------------+------------+----------+
| name  | besitzer  | gattung | geschlecht  | geburtstag | todestag |
+-------+-----------+---------+-------------+------------+----------+
| Claws | Gwen      | Katze   | m           | 1994-03-17 | NULL     |
| Buffy | Harold    | Hund    | w           | 1989-05-13 | NULL     |
+-------+-----------+---------+-------------+------------+----------+

Wenn Sie nicht die gesamten Datensätze aus Ihrer Tabelle sehen wollen, dann führen Sie in der jeweiligen Abfrage die gewünschten Spalten durch Kommata getrennt auf. Wollen Sie also etwa wissen, wann Ihre Tiere geboren wurden, dann wählen Sie die Spalten name und geburtstag:

mysql> SELECT name, geburtstag FROM haustier;
+----------+------------+
| name     | geburtstag |
+----------+------------+
| Fluffy   | 1993-02-04 |
| Claws    | 1994-03-17 |
| Buffy    | 1989-05-13 |
| Fang     | 1990-08-27 |
| Bowser   | 1989-08-31 |
| Chirpy   | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim     | 1996-04-29 |
| Puffball | 1999-03-30 |
+----------+------------+

Um herauszufinden, wem welches Tier gehört, setzen Sie folgende Abfrage ab:

mysql> SELECT besitzer FROM haustier;
+----------+
| besitzer |
+----------+
| Harold   |
| Gwen     |
| Harold   |
| Benny    |
| Diane    |
| Gwen     |
| Gwen     |
| Benny    |
| Diane    |
+----------+

Beachten Sie, dass diese einfache Abfrage die Spalte besitzer jedes Datensatzes abruft; einige davon tauchen mehrfach auf. Um die Ausgabe zu optimieren, können Sie jeden eindeutigen Ergebnisdatensatz genau einmal ausgeben, indem Sie einfach das Schlüsselwort DISTINCT hinzufügen:

mysql> SELECT DISTINCT besitzer FROM haustier;
+----------+
| besitzer |
+----------+
| Benny    |
| Diane    |
| Gwen     |
| Harold   |
+----------+

Mithilfe einer WHERE-Klausel können Sie Datensatz- und Spaltenauswahl kombinieren. Um z. B. die Geburtsdaten von Hunden und Katzen anzuzeigen, verwenden Sie folgende Abfrage:

mysql> SELECT name, gattung, geburtstag FROM haustier
    -> WHERE gattung = 'Hund' OR gattung = 'Katze';
+--------+---------+------------+
| name   | gattung | geburtstag |
+--------+---------+------------+
| Fluffy | Katze   | 1993-02-04 |
| Claws  | Katze   | 1994-03-17 |
| Buffy  | Hund    | 1989-05-13 |
| Fang   | Hund    | 1990-08-27 |
| Bowser | Hund    | 1989-08-31 |
+--------+---------+------------+

Sie haben in den vorangegangenen Beispielen vielleicht bereits festgestellt, dass die Ergebnisdatensätze nicht in einer bestimmten Reihenfolge angezeigt werden. Häufig ist es jedoch einfacher, das Abfrageergebnis zu durchsuchen, wenn die Datensätze sinnvoll sortiert werden. Um ein Ergebnis zu sortieren, verwenden Sie die ORDER BY-Klausel.

Nachfolgend sind die Geburtstage der Tiere nach Datum sortiert aufgelistet:

mysql> SELECT name, geburtstag FROM haustier ORDER BY geburtstag;
+----------+------------+
| name     | geburtstag |
+----------+------------+
| Buffy    | 1989-05-13 |
| Bowser   | 1989-08-31 |
| Fang     | 1990-08-27 |
| Fluffy   | 1993-02-04 |
| Claws    | 1994-03-17 |
| Slim     | 1996-04-29 |
| Whistler | 1997-12-09 |
| Chirpy   | 1998-09-11 |
| Puffball | 1999-03-30 |
+----------+------------+

Bei zeichenbasierten Spalten erfolgt die Sortierung – wie bei allen anderen Vergleichsoperationen auch – normalerweise ohne Berücksichtigung der Groß-/Kleinschreibung. Das bedeutet, dass die Reihenfolge bei Spalten, die bis auf die Groß-/Kleinschreibung identisch sind, nicht definiert ist. Sie können die Sortierung einer Spalte unter Berücksichtigung der Groß-/Kleinschreibung durch Verwendung von BINARY wie folgt erzwingen: ORDER BY BINARY col_name.

Die Standardreihenfolge bei der Sortierung ist aufsteigend, d. h., die kleinsten Werte werden zuerst aufgeführt. Um in umgekehrter (absteigender) Reihenfolge zu sortieren, fügen Sie das Schlüsselwort DESC zum Namen der Spalte zu, nach der die Sortierung erfolgt:

mysql> SELECT name, geburtstag FROM haustier ORDER BY geburtstag DESC;
+----------+------------+
| name     | geburtstag |
+----------+------------+
| Puffball | 1999-03-30 |
| Chirpy   | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim     | 1996-04-29 |
| Claws    | 1994-03-17 |
| Fluffy   | 1993-02-04 |
| Fang     | 1990-08-27 |
| Bowser   | 1989-08-31 |
| Buffy    | 1989-05-13 |
+----------+------------+

Sie können auch nach mehreren Spalten und diese jeweils mit eigener Reihenfolge sortieren. Um beispielsweise nach der Tierart in aufsteigender, dann dem Geburtsdatum innerhalb der Tierart in absteigender Reihenfolge (d. h. das jüngste Tier zuerst nennend) zu sortieren, verwenden Sie die folgende Abfrage:

mysql> SELECT name, gattung, geburtstag FROM haustier
    -> ORDER BY gattung, geburtstag DESC;
+----------+----------+------------+
| name     | gattung  | geburtstag |
+----------+----------+------------+
| Chirpy   | Vogel    | 1998-09-11 |
| Whistler | Vogel    | 1997-12-09 |
| Claws    | Katze    | 1994-03-17 |
| Fluffy   | Katze    | 1993-02-04 |
| Fang     | Hund     | 1990-08-27 |
| Bowser   | Hund     | 1989-08-31 |
| Buffy    | Hund     | 1989-05-13 |
| Puffball | Hamster  | 1999-03-30 |
| Slim     | Schlange | 1996-04-29 |
+----------+----------+------------+

Beachten Sie, dass das Schlüsselwort DESC nur für den Spaltennamen gilt, dem es direkt vorangestellt ist (geburtstag); die Sortierreihenfolge der Spalte gattung wird hiervon nicht berührt.

MySQL bietet eine Anzahl von Funktionen, mit denen Sie datumsbezogene Berechnungen durchführen können, um etwa Altersangaben zu ermitteln oder Teile aus Datumsangaben zu extrahieren.

Um zu bestimmen, wie alt Ihre Haustiere jeweils sind, berechnen Sie die Differenz im Jahresbestandteil des aktuellen und des Geburtsdatums und ziehen den Wert 1 ab, sofern das aktuelle Datum im Kalenderjahr vor dem Geburtsdatum liegt. Die folgende Abfrage zeigt für jedes Haustier das Geburtsdatum, das aktuelle Datum und das Alter in Jahren an.

mysql> SELECT name, geburtstag, CURDATE(),
    -> (YEAR(CURDATE())-YEAR(geburtstag))
    -> - (RIGHT(CURDATE(),5)<RIGHT(geburtstag,5))
    -> AS tieralter
    -> FROM haustier;
+----------+------------+------------+-----------+
| name     | geburtstag | CURDATE()  | tieralter |
+----------+------------+------------+-----------+
| Fluffy   | 1993-02-04 | 2003-08-19 |        10 |
| Claws    | 1994-03-17 | 2003-08-19 |         9 |
| Buffy    | 1989-05-13 | 2003-08-19 |        14 |
| Fang     | 1990-08-27 | 2003-08-19 |        12 |
| Bowser   | 1989-08-31 | 2003-08-19 |        13 |
| Chirpy   | 1998-09-11 | 2003-08-19 |         4 |
| Whistler | 1997-12-09 | 2003-08-19 |         5 |
| Slim     | 1996-04-29 | 2003-08-19 |         7 |
| Puffball | 1999-03-30 | 2003-08-19 |         4 |
+----------+------------+------------+-----------+

Hierbei extrahiert YEAR() die Jahreszahl aus dem Datum, während mit RIGHT() die fünf Zeichen ganz rechts im Datum (MM-DD, also der Monat und der Tag) ermittelt werden. Der Teil des Ausdrucks, der die Werte MM-DD vergleicht, ist entweder 1 oder 0. Hiermit wird von der Jahresdifferenz ggf. ein Jahr abgezogen, sofern CURDATE() (das aktuelle Datum) im Kalenderjahr vor geburtstag liegt. Der gesamte Ausdruck wirkt ein wenig unübersichtlich, weswegen ein Alias (tieralter) verwendet wird, um die Beschriftung der Ausgabespalte sinnvoller zu gestalten.

Die Abfrage funktioniert zwar, aber das Ergebnis ließe sich einfacher erfassen, wenn die Datensätze in einer bestimmten Reihenfolge angezeigt würden. Dies ist durch Ergänzen der Klausel ORDER BY name möglich, die die Ausgaben dem Namen nach sortiert:

mysql> SELECT name, geburtstag, CURDATE(),
    -> (YEAR(CURDATE())-YEAR(geburtstag))
    -> - (RIGHT(CURDATE(),5)<RIGHT(geburtstag,5))
    -> AS tieralter
    -> FROM haustier ORDER BY name;
+----------+------------+------------+-----------+
| name     | geburtstag | CURDATE()  | tieralter |
+----------+------------+------------+-----------+
| Bowser   | 1989-08-31 | 2003-08-19 |        13 |
| Buffy    | 1989-05-13 | 2003-08-19 |        14 |
| Chirpy   | 1998-09-11 | 2003-08-19 |         4 |
| Claws    | 1994-03-17 | 2003-08-19 |         9 |
| Fang     | 1990-08-27 | 2003-08-19 |        12 |
| Fluffy   | 1993-02-04 | 2003-08-19 |        10 |
| Puffball | 1999-03-30 | 2003-08-19 |         4 |
| Slim     | 1996-04-29 | 2003-08-19 |         7 |
| Whistler | 1997-12-09 | 2003-08-19 |         5 |
+----------+------------+------------+-----------+

Um die Ausgabe nach dem Alter statt dem Namen zu sortieren, verwenden Sie einfach eine andere ORDER BY-Klausel:

mysql> SELECT name, geburtstag, CURDATE(),
    -> (YEAR(CURDATE())-YEAR(geburtstag))
    -> - (RIGHT(CURDATE(),5)<RIGHT(geburtstag,5))
    -> AS tieralter
    -> FROM haustier ORDER BY alter;
+----------+------------+------------+-----------+
| name     | geburtstag | CURDATE()  | tieralter |
+----------+------------+------------+-----------+
| Chirpy   | 1998-09-11 | 2003-08-19 |         4 |
| Puffball | 1999-03-30 | 2003-08-19 |         4 |
| Whistler | 1997-12-09 | 2003-08-19 |         5 |
| Slim     | 1996-04-29 | 2003-08-19 |         7 |
| Claws    | 1994-03-17 | 2003-08-19 |         9 |
| Fluffy   | 1993-02-04 | 2003-08-19 |        10 |
| Fang     | 1990-08-27 | 2003-08-19 |        12 |
| Bowser   | 1989-08-31 | 2003-08-19 |        13 |
| Buffy    | 1989-05-13 | 2003-08-19 |        14 |
+----------+------------+------------+-----------+

Eine ähnliche Abfrage kann verwendet werden, um das erreichte Alter bereits verstorbener Tiere zu bestimmen. Welche Tiere dies sind, ermitteln Sie durch die Überprüfung, ob für todestag der Wert NULL lautet. Bei denjenigen Datensätzen, bei denen der Wert nicht NULL ist, berechnen Sie die Differenz zwischen den Werten todestag und geburtstag:

mysql> SELECT name, geburtstag, todestag,
    -> (YEAR(todestag)-YEAR(geburtstag)) - (RIGHT(todestag,5)<RIGHT(geburtstag,5))
    -> AS tieralter
    -> FROM haustier WHERE todestag IS NOT NULL ORDER BY alter;
+--------+------------+------------+-----------+
| name   | geburtstag | todestag   | tieralter |
+--------+------------+------------+-----------+
| Bowser | 1989-08-31 | 1995-07-29 |         5 |
+--------+------------+------------+-----------+

Die Abfrage verwendet todestag IS NOT NULL statt todestag <> NULL, da NULL ein Sonderwert ist, der nicht mithilfe der üblichen Vergleichsoperatoren verglichen werden kann. Wir werden später noch darauf eingehen. Siehe auch Abschnitt 3.3.4.6, „Mit NULL-Werten arbeiten“.

Was aber, wenn Sie nun wissen wollen, welche Tiere im nächsten Monat Geburtstag haben? Für diese Art der Berechnung sind Jahr und Tag irrelevant: Sie müssen lediglich den Monat aus der Spalte geburtstag extrahieren. MySQL bietet mehrere Funktionen zur Extraktion von Datumsbestandteilen, z. B. YEAR(), MONTH() und DAYOFMONTH(). MONTH() ist für unsere Belange die passende Funktion. Um zu sehen, wie sie funktioniert, führen Sie eine einfache Abfrage aus, die den Wert von geburtstag und MONTH(geburtstag) anzeigt:

mysql> SELECT name, geburtstag, MONTH(geburtstag) FROM haustier;
+----------+------------+-------------------+
| name     | geburtstag | MONTH(geburtstag) |
+----------+------------+-------------------+
| Fluffy   | 1993-02-04 |                 2 |
| Claws    | 1994-03-17 |                 3 |
| Buffy    | 1989-05-13 |                 5 |
| Fang     | 1990-08-27 |                 8 |
| Bowser   | 1989-08-31 |                 8 |
| Chirpy   | 1998-09-11 |                 9 |
| Whistler | 1997-12-09 |                12 |
| Slim     | 1996-04-29 |                 4 |
| Puffball | 1999-03-30 |                 3 |
+----------+------------+-------------------+

Das Suchen von Tieren, die nächsten Monat Geburtstag haben, ist ebenfalls ganz einfach. Nehmen wir einmal an, es wäre April. In diesem Fall ist der Monatswert 4 – Sie suchen also nach Tieren, die im Mai (d. h. im Monat 5) geboren sind. Das geht wie folgt:

mysql> SELECT name, geburtstag FROM haustier WHERE MONTH(geburtstag) = 5;
+-------+------------+
| name  | geburtstag |
+-------+------------+
| Buffy | 1989-05-13 |
+-------+------------+

Wenn der aktuelle Monat Dezember ist, gibt es eine kleine Komplikation. Sie können nämlich nicht einfach die Monatsnummer (12) um den Wert 1 erhöhen – die Suche nach im Monat 13 geborenen Tieren brächte kein Ergebnis, weil es diesen Monat nicht gibt. Schließlich suchen Sie nach Tieren, die im Januar (Monat 1) geboren sind.

Sie können die Abfrage so verfassen, dass sie unabhängig vom aktuellen Monat funktioniert, sodass Sie die Nummer eines bestimmten Monats gar nicht verwenden müssen. DATE_ADD() erlaubt Ihnen das Addieren eines bestimmten Zeitintervalls für ein gegebenes Datum. Wenn Sie einen Monat zum aktuellen Wert von CURDATE() hinzuaddieren wollen, extrahieren Sie den Monatsbestandteil mit MONTH(). Das Ergebnis ist der Monat, in dem Sie nach Geburtstagen suchen müssen:

mysql> SELECT name, geburtstag FROM haustier
    -> WHERE MONTH(geburtstag) = MONTH(DATE_ADD(CURDATE(),INTERVAL 1 MONTH));

Eine andere Möglichkeit, diese Aufgabe zu lösen, besteht darin, 1 hinzuzuaddieren und dann den auf den aktuellen Monat folgenden Monat zu ermitteln, wobei mithilfe der Modulofunktion (MOD) der Monatswert auf 0 gesetzt wird, wenn er derzeit 12 beträgt:

mysql> SELECT name, geburtstag FROM haustier
    -> WHERE MONTH(geburtstag) = MOD(MONTH(CURDATE()), 12) + 1;

Beachten Sie, dass MONTH eine Zahl zwischen 1 und 12 zurückgibt. Ferner gibt MOD(something,12) eine Zahl zwischen 0 und 11 zurück. Insofern muss die Addition nach MOD() erfolgen, andernfalls würden wir von November (11) direkt zu Januar (1) springen.

Wenn Sie mit dem Wert NULL noch keine Erfahrung haben, kann Ihnen manche Überraschung bevorstehen. Vom Konzept her bezeichnet NULL einen „fehlenden unbekannten Wert“ und wird etwas anders behandelt als andere Werte. Um auf NULL zu prüfen, können Sie arithmetische Vergleichsoperatoren wie =, < oder <> nicht verwenden. Um dies zu demonstrieren, geben Sie einmal Folgendes ein:

mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
| 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
|     NULL |      NULL |     NULL |     NULL |
+----------+-----------+----------+----------+

Offensichtlich lassen sich aus diesen Vergleichen keine sinngebenden Ergebnisse ziehen. Verwenden Sie stattdessen die Operatoren IS NULL und IS NOT NULL:

mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
|         0 |             1 |
+-----------+---------------+

Beachten Sie, dass 0 oder NULL in MySQL „falsch“ entspricht, während alles andere wahr ist. Der standardmäßig „wahr“ entsprechende Wert aus einer booleschen Operation ist 1.

Die Sonderbehandlung für NULL ist der Grund dafür, warum im vorherigen Abschnitt die Frage, welche Tiere nicht mehr leben, mit todestag IS NOT NULL statt mit todestag <> NULL ermittelt werden musste.

Zwei NULL in einer GROUP BY-Klausel werden als gleichberechtigt betrachtet.

Wenn Sie eine ORDER BY-Klausel verwenden, werden NULL-Werte zuerst angezeigt, sofern Sie ORDER BY ... ASC angeben; im umgekehrten Fall ORDER BY ... DESC erscheinen sie hingegen am Ende der Ergebnislisten.

Ein häufiger Fehler beim Umgang mit NULL besteht in der Annahme, dass es nicht möglich ist, eine Null oder einen Leer-String in eine Spalte einzufügen, die als NOT NULL definiert ist. Das stimmt nicht. Es handelt sich dabei vielmehr um echte Werte, während NULL die Bedeutung „kein Wert“ hat. Sie können dies ganz einfach wie folgt durch Verwendung von IS [NOT] NULL testen:

mysql> SELECT 0 IS NULL, 0 IS NOT NULL, '' IS NULL, '' IS NOT NULL;
+-----------+---------------+------------+----------------+
| 0 IS NULL | 0 IS NOT NULL | '' IS NULL | '' IS NOT NULL |
+-----------+---------------+------------+----------------+
|         0 |             1 |          0 |              1 |
+-----------+---------------+------------+----------------+

Es ist also durchaus möglich, eine Null oder einen Leer-String in eine NOT NULL-Spalte einzusetzen, denn diese Werte sind in der Tat NOT NULL. Siehe auch Abschnitt A.5.3, „Probleme mit NULL-Werten“.

MySQL ermöglicht einen Mustervergleich sowohl nach SQL-Standard als auch basierend auf erweiterten regulären Ausdrücken, wie man es von Unix-Hilfsprogrammen wie vi, grep und sed her kennt.

Beim SQL-Mustervergleich können Sie ‘_’ für eine Übereinstimmung mit einzelnen Zeichen sowie ‘%’ für eine Übereinstimmung mit einer beliebigen Anzahl von Zeichen (einschließlich 0 Zeichen) verwenden. In MySQL wird bei SQL-Mustern standardmäßig keine Unterscheidung der Groß-/Kleinschreibung vorgenommen. Einige Beispiele sind hier aufgeführt. Achten Sie darauf, in Verbindung mit SQL-Mustern nicht = oder <> zu verwenden, sondern die Vergleichsoperatoren LIKE bzw. NOT LIKE.

Namen, die mit ‘b’ beginnen, finden Sie so:

mysql> SELECT * FROM haustier WHERE name LIKE 'b%';
+--------+----------+---------+------------+------------+------------+
| name   | besitzer | gattung | geschlecht | geburtstag | todestag   |
+--------+----------+---------+------------+------------+------------+
| Buffy  | Harold   | Hund    | w          | 1989-05-13 | NULL       |
| Bowser | Diane    | Hund    | m          | 1989-08-31 | 1995-07-29 |
+--------+----------+---------+------------+------------+------------+

Namen, die auf ‘fy’ enden, finden Sie so:

mysql> SELECT * FROM haustier WHERE name LIKE '%fy';
+--------+----------+---------+------------+------------+----------+
| name   | besitzer | gattung | geschlecht | geburtstag | todestag |
+--------+----------+---------+------------+------------+----------+
| Fluffy | Harold   | Katze   | w          | 1993-02-04 | NULL     |
| Buffy  | Harold   | Hund    | w          | 1989-05-13 | NULL     |
+--------+----------+---------+------------+------------+----------+

Und Namen, die ‘w’ enthalten, finden Sie so:

mysql> SELECT * FROM haustier WHERE name LIKE '%w%';
+----------+----------+---------+------------+------------+------------+
| name     | besitzer | gattung | geschlecht | geburtstag | todestag   |
+----------+----------+---------+------------+------------+------------+
| Claws    | Gwen     | Katze   | m          | 1994-03-17 | NULL       |
| Bowser   | Diane    | Hund    | m          | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen     | Vogel   | NULL       | 1997-12-09 | NULL       |
+----------+----------+---------+------------+------------+------------+

Um Namen zu ermitteln, die aus genau fünf Zeichen bestehen, verwenden Sie fünf Instanzen des Musterzeichens ‘_’:

mysql> SELECT * FROM haustier WHERE name LIKE '_____';
+-------+----------+---------+------------+------------+----------+
| name  | besitzer | gattung | geschlecht | geburtstag | todestag |
+-------+----------+---------+------------+------------+----------+
| Claws | Gwen     | Katze   | m          | 1994-03-17 | NULL     |
| Buffy | Harold   | Hund    | w          | 1989-05-13 | NULL     |
+-------+----------+---------+------------+------------+----------+

Der andere von MySQL unterstützte Mustervergleichstyp nutzt erweiterte reguläre Ausdrücke. Wenn Sie bei diesem Mustertyp auf Übereinstimmung testen, verwenden Sie die Operatoren REGEXP und NOT REGEXP (bzw. deren Synonyme RLIKE und NOT RLIKE).

Erweiterte reguläre Ausdrücke weisen u. a. die folgenden Merkmale auf:

Um zu demonstrieren, wie erweiterte reguläre Ausdrücke funktionieren, haben wir die oben gezeigten LIKE-Abfragen so umgeschrieben, dass sie REGEXP verwenden.

Um Namen zu finden, die mit ‘b’ beginnen, verwenden Sie ‘^’ für eine Übereinstimmung mit dem Namensanfang:

mysql> SELECT * FROM haustier WHERE name REGEXP '^b';
+--------+----------+---------+------------+------------+------------+
| name   | besitzer | gattung | geschlecht | geburtstag | todestag   |
+--------+----------+---------+------------+------------+------------+
| Buffy  | Harold   | Hund    | w          | 1989-05-13 | NULL       |
| Bowser | Diane    | Hund    | m          | 1989-08-31 | 1995-07-29 |
+--------+----------+---------+------------+------------+------------+

Wenn Sie einen REGEXP-Vergleich mit Unterscheidung der Groß-/Kleinschreibung wirklich erzwingen wollen, verwenden Sie das Schlüsselwort BINARY, um aus einem der Strings einen Binär-String zu machen. Bei folgender Abfrage liegt eine Übereinstimmung nur bei einem kleinen ‘b’ am Anfang des Namens vor:

mysql> SELECT * FROM haustier WHERE name REGEXP BINARY '^b';

Um Namen zu finden, die auf ‘fy’ enden, verwenden Sie ‘$’ für eine Übereinstimmung mit dem Namensende:

mysql> SELECT * FROM haustier WHERE name REGEXP 'fy$';
+--------+----------+---------+------------+------------+----------+
| name   | besitzer | gattung | geschlecht | geburtstag | todestag |
+--------+----------+---------+------------+------------+----------+
| Fluffy | Harold   | Katze   | w          | 1993-02-04 | NULL     |
| Buffy  | Harold   | Hund    | w          | 1989-05-13 | NULL     |
+--------+----------+---------+------------+------------+----------+

Namen schließlich, die ‘w’ enthalten, finden Sie mit folgender Abfrage:

mysql> SELECT * FROM haustier WHERE name REGEXP 'w';
+----------+----------+---------+------------+------------+------------+
| name     | besitzer | gattung | geschlecht | geburtstag | todestag   |
+----------+----------+---------+------------+------------+------------+
| Claws    | Gwen     | Katze   | m          | 1994-03-17 | NULL       |
| Bowser   | Diane    | Hund    | m          | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen     | Vogel   | NULL       | 1997-12-09 | NULL       |
+----------+----------+---------+------------+------------+------------+

Da ein auf einem regulären Ausdruck basierendes Muster eine Übereinstimmung liefert, wenn es an beliebiger Stelle im Wert auftaucht, ist es in dieser Abfrage nicht notwendig, ein Jokerzeichen an den beiden Seiten des Musters zu setzen (bei einem SQL-Muster wäre dies hingegen erforderlich, um eine Übereinstimmung zu erzielen).

Um Namen zu ermitteln, die aus genau fünf Zeichen bestehen, verwenden Sie ‘^’ und ‘$’ für Übereinstimmungen für Anfang und Ende des Namens und fünf Instanzen von ‘.’ dazwischen:

mysql> SELECT * FROM haustier WHERE name REGEXP '^.....$';
+-------+----------+---------+------------+------------+----------+
| name  | besitzer | gattung | geschlecht | geburtstag | todestag |
+-------+----------+---------+------------+------------+----------+
| Claws | Gwen     | Katze   | m          | 1994-03-17 | NULL     |
| Buffy | Harold   | Hund    | w          | 1989-05-13 | NULL     |
+-------+----------+---------+------------+------------+----------+

Sie könnten diese Abfrage auch mithilfe des Operators {n} („n-mal wiederholen“) schreiben:

mysql> SELECT * FROM haustier WHERE name REGEXP '^.{5}$';
+-------+----------+---------+------------+------------+----------+
| name  | besitzer | gattung | geschlecht | geburtstag | todestag |
+-------+----------+---------+------------+------------+----------+
| Claws | Gwen     | Katze   | m          | 1994-03-17 | NULL     |
| Buffy | Harold   | Hund    | w          | 1989-05-13 | NULL     |
+-------+----------+---------+------------+------------+----------+

In Anhang G, Beschreibung der MySQL-Syntax für reguläre Ausdrücke, finden Sie weitere Informationen zur Syntax regulärer Ausdrücke.

Datenbanken werden häufig zur Beantwortung der Frage „Wie häufig taucht ein bestimmter Datentyp in einer Tabelle auf?“ verwendet. So möchten Sie vielleicht wissen, wie viele Tiere Sie oder ein anderer Besitzer haben, oder verschiedene statistische Erhebungen zu Ihren Tieren machen.

Das Zählen aller vorhandenen Tiere entspricht der Frage „Wie viele Datensätze sind in der Tabelle haustier vorhanden?“, denn es gibt genau einen Datensatz pro Tier. COUNT(*) zählt die Anzahl der Datensätze, d. h., die Abfrage zur Zählung Ihrer Tiere sieht wie folgt aus:

mysql> SELECT COUNT(*) FROM haustier;
+----------+
| COUNT(*) |
+----------+
|        9 |
+----------+

Weiter oben haben Sie die Namen der Leute abgerufen, die Tiere besitzen. Mit COUNT() können Sie etwa ermitteln, wie viele Tiere jeder Besitzer hat:

mysql> SELECT besitzer, COUNT(*) FROM haustier GROUP BY besitzer;
+----------+----------+
| besitzer | COUNT(*) |
+----------+----------+
| Benny    |        2 |
| Diane    |        2 |
| Gwen     |        3 |
| Harold   |        2 |
+----------+----------+

Beachten Sie, dass GROUP BY zur Gruppierung aller Datensätze für jeden Besitzer besitzer verwendet wird. Ohne diese Klausel erhalten Sie lediglich eine Fehlermeldung:

mysql> SELECT besitzer, COUNT(*) FROM haustier;
ERROR 1140 (42000): Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) 
with no GROUP columns is illegal if there is no GROUP BY clause

COUNT() und GROUP BY sind praktisch, wenn Sie Ihre Daten auf verschiedene Arten charakterisieren wollen. Die folgenden Beispiele zeigen verschiedene Wege, statistische Daten zu den Tieren zu erheben.

Anzahl der Exemplare je Tierart:

mysql> SELECT gattung, COUNT(*) FROM haustier GROUP BY gattung;
+----------+----------+
| gattung  | COUNT(*) |
+----------+----------+
| Vogel    |        2 |
| Katze    |        2 |
| Hund     |        3 |
| Hamster  |        1 |
| Schlange |        1 |
+----------+----------+

Anzahl der Tiere je Geschlecht:

mysql> SELECT geschlecht, COUNT(*) FROM haustier GROUP BY geschlecht;
+------------+----------+
| geschlecht | COUNT(*) |
+------------+----------+
| NULL       |        1 |
| w          |        4 |
| m          |        4 |
+------------+----------+

(In dieser Ausgabe gibt NULL an, dass das Geschlecht unbekannt ist.)

Anzahl der Tiere je Kombination von Tierart und Geschlecht:

mysql> SELECT gattung, geschlecht, COUNT(*) FROM haustier GROUP BY gattung, geschlecht;
+----------+------------+----------+
| gattung  | geschlecht | COUNT(*) |
+----------+------------+----------+
| Vogel    | NULL       |        1 |
| Vogel    | w          |        1 |
| Katze    | w          |        1 |
| Katze    | m          |        1 |
| Hund     | w          |        1 |
| Hund     | m          |        2 |
| Hamster  | w          |        1 |
| Schlange | m          |        1 |
+----------+------------+----------+

Wenn Sie COUNT() verwenden, müssen Sie nicht die gesamte Tabelle abrufen. Die obige Abfrage beispielsweise sieht wie folgt aus, wenn Sie nur für Hunde und Katzen durchgeführt wird:

mysql> SELECT gattung, geschlecht, COUNT(*) FROM haustier
    -> WHERE gattung = 'Hund' OR gattung = 'Katze'
    -> GROUP BY gattung, geschlecht;
+---------+------------+----------+
| gattung | geschlecht | COUNT(*) |
+---------+------------+----------+
| Katze   | w          |        1 |
| Katze   | m          |        1 |
| Hund    | w          |        1 |
| Hund    | m          |        2 |
+---------+------------+----------+

Oder, wenn Sie die Anzahl der Tiere je Geschlecht nur für diejenigen Tiere anzeigen wollen, deren Geschlecht auch bekannt ist:

mysql> SELECT gattung, geschlecht, COUNT(*) FROM haustier
    -> WHERE geschlecht IS NOT NULL
    -> GROUP BY gattung, geschlecht;
+----------+------------+----------+
| gattung  | geschlecht | COUNT(*) |
+----------+------------+----------+
| Vogel    | w          |        1 |
| Katze    | w          |        1 |
| Katze    | m          |        1 |
| Hund     | w          |        1 |
| Hund     | m          |        2 |
| Hamster  | w          |        1 |
| Schlange | m          |        1 |
+----------+------------+----------+

Die Tabelle haustier enthält Daten zu den Tieren, die Sie besitzen. Wollen Sie andere Informationen zu diesen aufzeichnen – z. B. Ereignisse wie Tierarztbesuche oder die Ankunft von Nachwuchs –, dann benötigen Sie eine zweite Tabelle. Wie sollte diese Tabelle aussehen? Folgende Angaben müssen enthalten sein:

Unter Berücksichtigung dieser Aspekte könnte die CREATE TABLE-Anweisung für die Tabelle ereignis wie folgt aussehen:

mysql> CREATE TABLE ereignis (name VARCHAR(20), datum DATE,
    -> typ VARCHAR(15), bemerkung VARCHAR(255));

Wie bei der Tabelle haustier ist es auch hier am einfachsten, die bereits bekannten Daten über eine tabulatorgetrennte Textdatei in die Tabelle einzuladen. Diese Datei soll die folgenden Informationen enthalten:

Laden Sie die Datensätze wie folgt:

mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE ereignis;

Mit dem, was Sie bereits aus den Abfragen erlernt haben, die Sie zur Tabelle haustier abgesetzt haben, sollten Sie auch Daten aus der Tabelle ereignis abrufen können; die Prinzipien sind dieselben. Was aber, wenn Sie die Fragen, die Sie stellen, mit der Tabelle ereignis allein nicht beantworten können?

Nehmen wir an, Sie wollen herausfinden, in welchem Alter die jeweiligen Tiere Nachwuchs bekommen haben. Wir haben bereits weiter oben gesehen, wie Sie das Alter auf der Grundlage zweiter Datumsangaben berechnen. Das Datum, an dem die Mutter ihren Nachwuchs auf die Welt gebracht hat, ist in der Tabelle ereignis gespeichert, aber um das Alter der Mutter am Tag der Niederkunft zu ermitteln, benötigen Sie das Geburtsdatum, welches wiederum in der Tabelle haustier abgelegt ist. Das bedeutet, dass wir zwei Tabellen benötigen:

mysql> SELECT pet.name,
    -> (YEAR(datum)-YEAR(geburtstag)) - (RIGHT(datum,5)<RIGHT(geburtstag,5)) AS tieralter,
    -> bemerkung
    -> FROM haustier, ereignis
    -> WHERE pet.name = event.name AND event.typ = 'Nachwuchs';
+--------+-----------+-------------------------------------+
| name   | tieralter | bemerkung                           |
+--------+-----------+-------------------------------------+
| Fluffy |         2 | 4 Kätzchen, 3 weiblich, 1 männlich  |
| Buffy  |         4 | 5 Welpen, 2 weiblich, 3 männlich    |
| Buffy  |         5 | 3 Welpen, 3 weiblich                |
+--------+-----------+-------------------------------------+

Bei dieser Abfrage fällt Verschiedenes auf:

Um eine solche Verknüpfung – einen Join – durchzuführen, brauchen Sie keine zwei Tabellen. Manchmal ist es nützlich, eine Tabelle mit sich selbst zu verknüpfen, wenn man etwa Datensätze in einer Tabelle mit anderen Datensätzen in derselben Tabelle vergleichen will. Um beispielsweise Zuchtmöglichkeiten unter Ihren Tieren auszuloten, kann eine Verknüpfung der Tabelle haustier mit sich selbst praktisch sein, um passende Männchen und Weibchen einer Tierart zu ermitteln:

mysql> SELECT p1.name, p1.geschlecht, p2.name, p2.geschlecht, p1.gattung
    -> FROM haustier AS p1, haustier AS p2
    -> WHERE p1.gattung = p2.gattung AND p1.geschlecht = 'w' AND p2.geschlecht = 'm';
+--------+------------+--------+------------+---------+
| name   | geschlecht | name   | geschlecht | gattung |
+--------+------------+--------+------------+---------+
| Fluffy | w          | Claws  | m          | Katze   |
| Buffy  | w          | Fang   | m          | Hund    |
| Buffy  | w          | Bowser | m          | Hund    |
+--------+------------+--------+------------+---------+

In dieser Abfrage geben Sie Aliase für den Tabellennamen an, um auf die Spalten Bezug zu nehmen und klar zu machen, welcher Tabelleninstanz die Bezugnahme auf eine Spalte zuzuordnen ist.