Nachhaltigkeit im Unternehmen ist ohne ordnungsgemäßes Datenmanagement schwierig. Der Aufbau eines klar definierten Systems ist für die Verwaltung interner und externer Abläufe unerlässlich. Ein detaillierter Einblick in die Geschäftsdaten hilft, den gesamten Arbeitsablauf zu verstehen und die Leistung zu messen. Darüber hinaus spart die Nutzung von Datenbanken Zeit und ermöglicht den mühelosen Zugriff auf Informationen.
Was ist eine Datenbank?
Eine Datenbank ist ein organisiertes System, das zur sicheren Speicherung von Informationen dient. Es bietet Kategorisierung und ermöglicht die Erstellung von Tabellen, um ähnliche Arten von Elementen in einer Gruppe zu sortieren. Tabellen bieten Optionen zur Auflistung von Informationen in mehreren Zeilen und Spalten. Dadurch verbessern sich die Qualität und Konsistenz der Daten. Neben Speicher- und einfachen Zugriffsmöglichkeiten spielen Datenbanken eine wichtige Rolle beim Schutz der Privatsphäre und der Sicherung von Systemen. Ob ad-hoc oder als Teil eines in einer Anwendung codierten Prozesses, das Abrufen von Daten ist einer der kritischsten Aspekte des Datenbankmanagements.
Eine Abfrage in relationalen DMS ist jeder Befehl, der zum Abrufen von Daten aus einer Tabelle verwendet wird. SELECT-Anweisungen werden fast immer in Structured Query Language-Abfragen (SQL) verwendet. Es gibt verschiedene Methoden, um Informationen aus einer Datenbank abzurufen. Im Allgemeinen bevorzugen Entwickler die Befehlszeilenoption, da sie schnell und effektiv ist. Sie ermöglicht das nahtlose Senden von Abfragen.
In dieser Anleitung werden wir Sie in MySQL einführen und besprechen, wie man mit Abfragen in MySQL arbeitet. Starten wir!
Voraussetzungen
Um diesem Tutorial zu folgen, benötigen Sie Folgendes:
-
Die neueste Version von Ubuntu ist installiert auf Ihrem System.
-
Systembenutzer müssen über sudo-Rechte verfügen.
-
Wenn Sie Schwierigkeiten beim Zugriff auf Ihr sudo-Konto haben, ziehen Sie in Erwägung, das MySQL-Root-Passwort zu ändern.
-
-
MySQL ist eingerichtet auf Ihrem Server.
Schritt 1 — Erstellen und Einrichten einer Datenbank
Bevor wir beginnen und unsere erste SQL-Abfrage schreiben, müssen wir eine Datenbank erstellen und Tabellen hinzufügen. Danach werden wir die Tabellen mit Beispieldaten füllen. Die Arbeit mit Datenbanken wird Ihnen helfen, die grundlegende Einrichtung zu verstehen und Vertrauen im Umgang mit Abfragen zu gewinnen.
Praktische Erfahrung ist der effektivste Weg, um Konzepte aufzubauen und die Bedeutung von Datenbanken zu verstehen. In dieser Anleitung führen wir Sie durch die Verwendung von Datenbanken und deren Bedeutung zur Lösung realer Probleme. Schauen wir uns ein Szenario an, um zu verstehen, wie Datenbanken helfen können, Datensätze strukturiert zu organisieren.
Szenario: Wir werden eine Datenbank erstellen, in der eine Gruppe von College-Studenten in den Urlaub fährt, um ihre Geburtstage zu feiern. Bevor sie in den Urlaub fahren, planen sie, an einem freundschaftlichen Schwimmwettkampf teilzunehmen. Außerdem plant jeder Freund in der Gruppe eine To-Do-Liste mit Aktivitäten, um ihre Reise aufregend und angenehm zu gestalten.
Öffnen Sie zuerst MySQL als Root-Benutzer:
|
1 |
$ sudo mysql |
Erstellen Sie dann eine Datenbank, indem Sie den folgenden Befehl ausführen:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Als Nächstes verwenden wir unsere Datenbank mit dem folgenden Befehl:
|
1 |
mysql> USE vacation; |
Danach werden wir Tabellen in unserer Datenbank erstellen. Benennen Sie die erste Tabelle als celebration. Unsere Tabelle wird Spalten für die Namen unserer Freunde haben (name), die Turniere, die sie gewonnen haben (wins) und auch eine Spalte für ihre beste Zeit (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Query OK, 0 rows affected (2.03 sec) |
Wir werden dann unsere Tabelle mit Daten füllen:
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Query OK, 4 rows affected (0.29 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Erstellen Sie dann eine weitere Tabelle in unserer Datenbank, um Informationen über ihre liebsten Geburtstagsaktivitäten zu speichern. Wir werden eine Tabelle namens vacation erstellen und ihr die folgenden Spalten zuweisen:
|
Liste |
Detail |
|
name: |
Speichert den Namen jedes Freundes. |
|
birthdate: |
Verfolgt das Geburtsdatum jeder Person. |
|
activity: |
Hält die Lieblingsaktivität fest. |
|
Destination: |
Speichert die Information über das bevorzugte Reiseziel jeder Person. |
|
meal: |
Verfolgt das Lieblingsgericht einer Person. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Befüllen Sie die Tabelle mit Daten:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Sie haben die Einrichtung Ihrer Datenbank nun abgeschlossen.
Schritt 2 — Erste Schritte mit SELECT-Anweisungen
Abfragen in SQL beginnen normalerweise mit SELECT. Dies wird in Abfragen verwendet, um anzugeben, welche Spalten in einer Tabelle mit den Ergebnissen zurückgegeben werden sollen. Eine Abfrage muss außerdem immer enthaltenFROM, was verwendet wird, um die Tabelle anzugeben, die von der Anweisung abgefragt wird.
Abfragen folgen der unten stehenden Syntax:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
Wir werden die Abfragesyntax verwenden, um die Spalte meal aus der Tabelle vacation zurückzugeben:
|
1 |
mysql> SELECT meal FROM vacation; |
Unsere Ausgabe sieht wie folgt aus:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Sie können auch mehrere Spalten auswählen, indem Sie sie durch ein Komma trennen:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Ausgabe:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
Sie können auch ein asterisk (*) verwenden, wenn Sie alle Spalten in der Tabelle darstellen möchten:
|
1 |
mysql> SELECT * FROM celebration; |
Ausgabe:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Wenn Sie Datensätze filtern möchten, die eine bestimmte Bedingung erfüllen, verwenden Sie WHERE. Die Zeilen, die die angegebene Bedingung nicht erfüllen, werden aus den Ergebnissen entfernt. Die WHERE-Klausel verwendet die folgende Syntax:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Es ist ein Vergleichsoperator, der definiert, wie die angegebene Spalte mit dem Wert verglichen werden soll. Zu den gängigen SQL-Vergleichsoperatoren gehören:
|
Operator |
Verwendung |
|
= |
Gleichheit |
|
!= |
Ungleichheit |
|
< |
Kleiner als |
|
> |
Größer als |
|
<= |
Kleiner oder gleich |
|
>= |
Größer oder gleich |
|
BETWEEN |
Prüft, ob der Wert innerhalb des angegebenen Bereichs liegt. |
|
IN |
Prüft, ob der Wert einer Zeile in einer Menge bestimmter Werte enthalten ist. |
|
EXISTS |
Prüft, ob eine Zeile existiert |
|
LIKE |
Prüft, ob ein Wert mit der angegebenen Zeichenkette übereinstimmt |
|
IS NULL |
Prüft auf NULL-Werte |
|
IS NOT NULL |
Prüft auf alle Werte außer NULL |
Wenn Sie Aishas bevorzugtes Reiseziel finden möchten, können Sie die folgende Abfrage verwenden:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
Die Abfrage gibt dann Folgendes zurück:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 Zeile im Satz (0.03 Sek.) |
SQL unterstützt die Verwendung von Platzhaltern, die besonders nützlich in WHERE-Klauseln sind. Prozentzeichen ( %) stehen für null oder mehr unbekannte Zeichen, während Unterstriche ( _) für ein einzelnes unbekanntes Zeichen stehen. Diese sind hilfreich, wenn Sie einen bestimmten Eintrag in einer Tabelle finden möchten, sich aber über den Eintrag nicht sicher sind.
Wenn Sie beispielsweise das Lieblingsreiseziel eines Freundes vergessen haben und nur den Anfangsbuchstaben kennen, z. B. “m”, können Sie den Namen des Reiseziels mithilfe der folgenden Abfrage finden:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
Die Abfrage gibt Folgendes zurück:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Malediven | | Mauritius | +-------------+ 2 Zeilen im Satz (0.04 Sek.) |
Beim Arbeiten mit Datenbanken stoßen Sie möglicherweise auf Spalten oder Tabellen mit relativ langen oder schwer lesbaren Namen. In diesen Fällen können Sie die Namen lesbarer machen, indem Sie das Schlüsselwort AS verwenden, um einen Alias zu erstellen. Aliase, die mit AS erstellt wurden, sind nur für die Dauer der Abfrage gültig, für die sie erstellt wurden:
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Malediven | Skifahren | | Ivan | Mauritius | Paragliding | | Aisha | Colorado | Bergsteigen | | Zane | Bora Bora | Angeln | +--------+-----------+-------------------+ 4 Zeilen im Satz (0.00 Sek.) |
Schritt 3 — Einführung in Aggregatfunktionen
Beim Arbeiten mit Daten möchten Sie nicht immer die Daten selbst sehen. Sie möchten lieber Informationen über die Daten haben. Durch das Absetzen einer SELECT-Abfrage können Sie Ihre Daten mithilfe der SQL-Syntax interpretieren oder Berechnungen daran durchführen. Diese werden als Aggregatfunktionen bezeichnet.
Die COUNT-Funktion zählt und gibt die Anzahl der Zeilen zurück, die bestimmte Kriterien erfüllen. Wenn Sie beispielsweise wissen möchten, wie viele Freunde lieber auf die Malediven reisen, können Sie die folgende Abfrage verwenden:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
Die folgenden Ergebnisse werden zurückgegeben:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 Zeile im Satz (0.06 Sek.) |
MIN wird verwendet, um den kleinsten Wert in einer bestimmten Spalte zu finden:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
Die Abfrage gibt Folgendes aus:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 Zeile im Satz (0.02 Sek.) |
MAX wird verwendet, um den größten numerischen Wert in einer bestimmten Spalte zu finden:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
Die erwartete Ausgabe ist:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 Zeile im Satz (0.03 Sek.) |
Sowohl die MIN als auch die MAX-Funktionen können auf numerische und alphabetische Daten angewendet werden. Wenn sie auf eine Spalte mit Zeichenfolgenwerten angewendet wird, gibt die MIN-Funktion den alphabetisch ersten Wert zurück.
Die MIN-Funktion gibt den alphabetisch ersten Wert zurück:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
So sieht die Ausgabe aus:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 Zeile im Satz (0.00 Sek.) |
Die MAX-Funktion gibt den alphabetisch letzten Wert zurück:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
So wird die Ausgabe aussehen:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 Zeile in Set (0.00 Sek.) |
Schritt 4 — Abfrageergebnisse manipulieren
Eine weitere beliebte Klausel, die verwendet wird, ist die GROUP BY-Klausel. Sie wird verwendet, wenn eine Aggregatfunktion auf eine Spalte, aber in Bezug auf übereinstimmende Werte in einer anderen Spalte angewendet wird:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
Die Ausgabe lautet:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | Skifahren | | 1 | Paragliding | | 1 | Berg-steigen | | 1 | Angeln | +-------------+-------------------+ 4 Zeilen in Set (0.04 Sek.) |
Um Abfrageergebnisse zu sortieren, verwenden Sie die ORDER BY-Klausel. Numerische Werte werden standardmäßig aufsteigend sortiert, während Textwerte alphabetisch sortiert werden. Die folgende Abfrage listet die Spalten name und birthdate auf, sortiert die Ergebnisse jedoch nach birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
Die Ausgabe sieht wie folgt aus:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 Zeilen in Set (0.04 Sek.) |
Die Ausgabe erfolgt in aufsteigender Reihenfolge. Um in absteigender Reihenfolge zu sortieren, schließen Sie die Abfrage mit dem Wort DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Werfen Sie einen Blick auf die Ausgabe:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 Zeilen in Set (0.00 Sek.) |
Die HAVING-Klausel wurde zu SQL hinzugefügt, um eine ähnliche Funktionalität wie die WHERE-Klausel zu bieten, während sie gleichzeitig mit Aggregatfunktionen kompatibel ist. Der Unterschied zwischen diesen beiden Klauseln besteht darin, dass sich WHERE auf einzelne Datensätze bezieht und HAVING sich auf Gruppendatensätze bezieht. Zu diesem Zweck muss die GROUP BY-Klausel immer vorhanden sein, wenn eine HAVING-Klausel verwendet wird:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
Die Abfrage gibt Folgendes aus:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | Skifahren | | 1 | Paragliding | | 1 | Berg-steigen | | 1 | Angeln | +-------------+-------------------+ |
Der COUNT ist bei allen 1, da keine zwei Freunde dieselbe Aktivität mögen.
Schritt 5 — Abfragen mehrerer Tabellen
Die JOIN-Klausel kann in einem Abfrageergebnis verwendet werden, um Zeilen aus zwei oder mehr Tabellen zu kombinieren. Dies wird erreicht, indem eine verknüpfte Spalte zwischen den Tabellen ausfindig gemacht und die Ausgabe entsprechend sortiert wird.
SELECT-Anweisungen, die eine JOIN-Klausel enthalten, folgen der unten stehenden Syntax:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Wenn Sie jedem Ihrer Freunde eine Trophäe für seine wins beim swimming an ihren birthdays schenken möchten, können Sie eine Abfrage erstellen, die beide Tabellen verbindet, um alle gewünschten Informationen mit einer einzigen Abfrage zu finden:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
Die Ausgabe lautet:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 Zeilen in Set (0.00 Sek.) |
Dies ist eine innere JOIN-Klausel. Das liegt daran, dass sie alle Datensätze auswählt, die übereinstimmende Werte in beiden Tabellen haben, und diese in einer Ergebnismenge ausgibt. Datensätze, die nicht mit der Abfrage übereinstimmen, werden nicht einbezogen. Wir können eine neue Zeile in unsere Tabellen einfügen, die keinem Eintrag entspricht:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Abfrage OK, 1 Zeile betroffen (0.01 Sek.) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Abfrage OK, 1 Zeile betroffen (0.01 Sek.) |
Führen Sie dann die SELECT-Anweisung mit der JOIN-Klausel erneut aus:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 Zeilen in Set (0.00 Sek.) |
Da die Tabelle „celebration“ keinen Eintrag für Peter und die Tabelle „vacation“ keinen Eintrag für Ella hat, fehlen diese Datensätze.
Wir können alle Datensätze aus einer der Tabellen zurückgeben, indem wir eine äußere JOIN-Klausel verwenden. Dies kann entweder ein LEFT JOIN oder ein RIGHT JOIN sein. Ein LEFT JOIN gibt alle Datensätze aus der linken Tabelle und nur übereinstimmende Datensätze aus der rechten Tabelle zurück. Die linke Tabelle im Kontext von Outer Joins ist diejenige, auf die in der FROM-Klausel verwiesen wird, und die rechte Tabelle ist jede Tabelle, auf die nach der JOIN-Anweisung verwiesen wird.
Führen Sie die Abfrage erneut aus, verwenden Sie jedoch eine LEFT JOIN-Klausel:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
Der Befehl gibt alle Datensätze aus der linken Tabelle ( celebration) zurück, selbst wenn diese keinen entsprechenden Datensatz in der rechten Tabelle hat. Wenn es keinen übereinstimmenden Datensatz in der rechten Tabelle gibt, wird er als NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 Zeilen in Set (0.00 Sek.) |
Dies ist nun die RIGHT JOIN-Klausel:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Alle Werte aus der rechten Tabelle werden zurückgegeben (vacation). Da Peters birthdate in der rechten Tabelle erfasst ist und nicht in der linken Tabelle, werden die Spalten name und wins in diesen Zeilen NULL-Werte zurückgeben:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | Name | Siege | Geburtsdatum | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 Zeilen in Satz (0.01 Sek.) |
Sie können die UNION-Klausel anstelle von JOIN verwenden, um Datensätze aus mehreren Tabellen abzufragen. Der UNION-Operator unterscheidet sich von der JOIN-Klausel dadurch, dass er die Ergebnisse von zwei SELECT-Anweisungen in einer einzigen Spalte kombiniert, anstatt die Ergebnisse aus mehreren Tabellen als eindeutige Spalten mit einer einzigen SELECT-Anweisung auszugeben.
Sie können diese Abfrage ausführen, um dies zu veranschaulichen:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
Die Abfrage entfernt doppelte Einträge. Dies ist das Standardverhalten des UNION-Operators:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | Name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 Zeilen in Satz (0.00 Sek.) |
Um alle Einträge (einschließlich Duplikate) zurückzugeben, verwenden Sie den UNION ALL-Operator:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Ausgabe:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | Name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 Zeilen in Satz (0.00 Sek.) |
Unterabfragen sind eine weitere Methode zur Abfrage mehrerer Tabellen. Unterabfragen sind Abfragen, die in eine andere Abfrage eingeschlossen sind (auch als innere oder verschachtelte Abfragen bezeichnet). Diese sind nützlich, wenn Sie die Ergebnisse einer Abfrage mit den Ergebnissen einer separaten Aggregatfunktion vergleichen möchten.
Wir verwenden das Beispiel, herauszufinden, welcher Freund mehr Schwimmturniere als Ella gewonnen hat. Anstatt abzufragen, wie viele Spiele Ella gewonnen hat, und dann eine weitere Abfrage auszuführen, um zu sehen, wer mehr Spiele als sie gewonnen hat, können Sie beides mit einer einzigen Abfrage berechnen:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
Die Abfrage gibt Folgendes zurück:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | Name | Siege | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 Zeilen in Satz (0.06 Sek.) |
Wenn Sie Ihre Freunde in einen Überraschungsurlaub entführen möchten, können Sie mithilfe einer Abfrage ermitteln, wer die meisten Siege hat, und deren Reiseziel zurückgeben:
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
Die Abfrage gibt Folgendes zurück:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | Name | Reiseziel | Aktivität | Mahlzeit | +------+-------------+----------+------+ | Zane | Bora Bora | Angeln | Tofu | +------+-------------+----------+------+ 1 Zeile in Satz (0.00 Sek.) |
Diese Anweisung enthält eine Unterabfrage innerhalb einer Unterabfrage.
Fazit
Die Generierung von Abfragen ist eine der häufigsten Aufgaben in der Datenbankverwaltung. Es gibt verschiedene Tools zur Datenbankverwaltung wie phpMyAdmin und pgAdmin, mit denen Sie mit Abfragen arbeiten und deren Ergebnisse visualisieren können. Die SELECT-Anweisung über die Befehlszeile ist jedoch aufgrund ihrer einfachen Handhabung und hervorragenden Kontrolle die bevorzugte Wahl.
Darüber hinaus gibt es viele Tutorials zu Datenbanken, die Sie in unserem Blog entdecken können:
- SQLite vs. MySQL vs. PostgreSQL: Relationale Datenbankmanagementsysteme im Vergleich
- Schnelle Lösungen zur Reparatur beschädigter Tabellen in MySQL: Ein Tutorial
- So installieren Sie MySQL auf Centos 7
- MySQL-Benutzer — Berechtigungen erstellen und erteilen
- Einrichten der Replikation in MySQL auf Ubuntu
Viel Spaß beim Computing!
Kommentare
Noch keine Kommentare. Schreiben Sie den ersten.