22 Übungen zum Üben von SQL-Befehlen

Möchten Sie Ihre SQL-Kenntnisse verbessern? Üben Sie die SQL-Befehle in diesen 22 realistischen Übungen!

Es gibt ein altes Sprichwort, das besagt, dass es keinen Ersatz für Erfahrung gibt. Aber wie kann man diese Erfahrung erlangen, wenn man gerade erst anfängt, etwas Neues zu lernen? Der beste Weg ist Übung, Übung und nochmals Übung! In diesem Artikel bieten wir Ihnen einige praktische Übungen für SQL-Befehle.

Alle unsere Übungsaufgaben stammen aus den Kursen auf LearnSQL.de. Wir bieten interaktive SQL-Kurse mit verschiedenen Schwerpunkten an. Einige Kurse richten sich an Anfänger; unser SQL für Anfänger Kurs enthält mehr als 120 Übungen zu den grundlegenden SQL-Befehlen. Fortgeschrittene Benutzer können von Kursen profitieren wie SQL-Praxisder zehn interaktive Kurse und mehr als 100 Übungsstunden umfasst! Und für erfahrene Profis sind die drei Kurse des Fortgeschrittenes SQL (mit fast 400 praktischen Übungen) dabei helfen, die tiefgreifendsten Funktionen von SQL zu beherrschen.

Beginnen wir damit, unsere Kenntnisse über SQL-Befehle zu verbessern!

Arbeiten mit einer Tabelle: SELECT, WHERE, ORDER BY, GROUP BY

In den nächsten Übungen werden wir Daten aus einer einzigen Tabelle abfragen, die Informationen über Katzen enthält. Die Tabelle heißt Cat und hat die folgenden Spalten:

• id - Die ID einer bestimmten Katze. Dies ist der Primärschlüssel der Tabelle.
• name - Der Name der Katze
• breed - Die der Katze
• coloration - Die der Katze
• age - Die Katze
• sex - Die Katze ist
• fav_toy - Das Lieblingsspielzeug der Katze.

Übung Nr. 1: Auswählen von Spalten und Filtern von numerischen Daten

Übung: Wählen Sie den Namen, die Rasse und die Färbung für jede Katze aus, die jünger als fünf Jahre alt ist.

Lösung:

SELECT 
  name, 
  breed, 
  coloration
FROM cat
WHERE age < 5;

Erläuterung: Führen Sie die erforderlichen Spalten (name, breed und coloration) in der Klausel SELECT auf; trennen Sie sie durch Kommata. Verweisen Sie auf die Cat Tabelle in der FROM -Klausel und verwenden Sie die erforderliche Bedingung age < 5 in der WHERE-Klausel.

Übung Nr. 2: Alle Spalten auswählen und Textdaten filtern

Übung: Wählen Sie alle Daten für Katzen aus, deren:

• Rasse beginnt mit einem 'R'.
• Lieblingsspielzeug mit dem Wort 'Ball' beginnt.
• Färbung endet mit einem 'm'.

Lösung:

SELECT *
FROM cat
WHERE breed LIKE 'R%'
  AND fav_toy LIKE 'ball%'
  AND coloration LIKE '%m';

Erläuterung: Da wir alle Tabellenspalten im Ergebnis erhalten wollen, verwenden wir das Symbol *, um alle verfügbaren Spalten in der Tabelle darzustellen. Wir referenzieren die Cat Tabelle in der Klausel FROM und fügen die drei erforderlichen Filterbedingungen mit dem LIKE-Operator und dem Platzhalter % ein. Die Verwendung des AND -Operators bedeutet, dass jede Bedingung mit der vorherigen verknüpft ist; alle drei Bedingungen müssen erfüllt sein, damit die Zeile in das Ergebnis aufgenommen wird.

Denken Sie daran, dass Textwerte in einfache Anführungszeichen gesetzt werden müssen.

Übung Nr. 3: Spalten auswählen und NULL-Daten filtern

Übung: Wählen Sie die Namen aller männlichen Katzen aus, die kein Lieblingsspielzeug haben - d. h. der Wert des Feldes fav_toy ist NULL für diese Katzen.

Lösung:

SELECT name
FROM cat
WHERE sex = 'M'
  AND fav_toy IS NULL;

Erläuterung: Nehmen Sie nur die Spalte name in die SELECT Klausel auf. Verwenden Sie zwei Filterbedingungen mit dem Operator AND in der Klausel WHERE. Die erste Bedingung ist die Übereinstimmung der Spalte sex mit dem Literal 'M'. Die zweite Bedingung filtert nach Zeilen, in denen die Spalte fav_toy einen NULL-Wert hat.

Wichtig: Sie können NULLs nicht mit anderen Werten vergleichen, indem Sie Vergleichsoperatoren wie equal verwenden; Sie müssen fragen, ob ein Wert IS NULL oder IS NOT NULL ist.

Übung Nr. 4: Ordnen von Daten, die von einem SELECT zurückgegeben werden

Übung: Wählen Sie den Namen, das Alter, die Rasse und das Geschlecht für alle Katzen aus, wobei die älteren Katzen zuerst angezeigt werden sollen.

Lösung:

SELECT 
  name, 
  age, 
  breed, 
  sex
FROM cat
ORDER BY age DESC;

Erläuterung: Führen Sie die erforderlichen Spalten (name, age, breed und sex) in der Klausel SELECT auf. Verweisen Sie auf die Cat in der Klausel FROM und ordnen Sie die Zeilen mit der Klausel ORDER BY<, gefolgt von der Spalte age.

Da die Standardreihenfolge aufsteigend ist, müssen wir das optionale Schlüsselwort DESC hinzufügen, um die Daten in absteigender Reihenfolge zu sortieren, d. h. ältere Katzen zuerst abzurufen.

Übung Nr. 5: Daten gruppieren und durch Aggregation ordnen

Übung: Zeigen Sie die Anzahl der Katzen für jeden Färbungstyp an, indem Sie number_of_cats als Alias für die Aggregatfunktion verwenden, die diese Informationen berechnet. Zeigen Sie die Färbungen mit weniger Katzen zuerst an.

Lösung:

SELECT 
  coloration, 
  COUNT(*) AS number_of_cats
FROM cat
GROUP BY coloration
ORDER BY number_of_cats DESC;

Erläuterung: Fügen Sie die Färbungsspalte und die Aggregatfunktion COUNT(*) in die Klausel SELECT ein. Verwenden Sie den Alias AS number_of_cats, um einen benutzerfreundlichen Namen für die Spalte COUNT(*) zu erhalten.

Verwenden Sie die Klausel GROUP BY gefolgt von der Spalte coloration, um die Daten nach der Färbung zu gruppieren. Ordnen Sie die Ergebnisse mit der Klausel ORDER BY gefolgt von einem Spaltennamen oder Alias - in diesem Fall number_of_cats.

Übung Nr. 6: Daten gruppieren und durch Aggregation filtern

Übung: Zeigen Sie das Durchschnittsalter der Katzen jeder Rasse an; verwenden Sie Average_Age als Alias für die Aggregatfunktion. Zeigen Sie nur Rassen an, bei denen das Durchschnittsalter größer als fünf Jahre ist.

Lösung:

SELECT 
  breed, 
  AVG(age) AS Average_Age
FROM cat
GROUP BY breed
HAVING AVG(age) > 5;

Erläuterung: Fügen Sie die Rassen-Spalte und die Aggregatfunktion AVG(age) in die Klausel SELECT ein. Verwenden Sie einen Alias, um einen benutzerfreundlichen Spaltennamen für die Aggregatfunktion zu erhalten. Verwenden Sie die GROUP BY-Klausel, gefolgt von der Spalte "Rasse", um die Daten auf der Grundlage der einzelnen Katzenrassen zu gruppieren.

Da wir auf der Grundlage der Ergebnisse der Aggregation filtern müssen, können wir die WHERE Klausel nicht verwenden; sie filtert Zeilen BEFORE sie gruppiert sind. Stattdessen müssen wir die HAVING Klausel verwenden; sie wird angewendet, nachdem die Zeilen gruppiert wurden.

Erfahren Sie mehr: Weitere Übungsbeispiele GROUP BY finden Sie in dem Artikel 10 GROUP BY SQL-Praxis Übungen mit Lösungen.

Arbeiten mit mehreren Tabellen: JOIN

In den nächsten Übungen werden wir Daten aus mehr als einer Tabelle abfragen. Wir werden ein sehr einfaches Modell verwenden, das Mitarbeiter, Gehälter und Leistungen enthält.

Schauen wir uns die employee Struktur der Tabelle:

• id - die ID eines bestimmten Mitarbeiters.
• first_name - den Vornamen des Mitarbeiters.
• last_name - Der Nachname des Mitarbeiters.
• salary - Der Name des Mitarbeiters
• manager_id - Die ID des Vorgesetzten des Mitarbeiters.

Als nächstes enthält die salgrade Tabelle Informationen zur Gehaltsklasse:

• Besoldungsgruppe - Die Besoldungsgruppe eines Gehalts.
• lower_limit - Die Untergrenze der Gehaltsgruppe.
• upper_limit - Die Obergrenze der Gehaltsgruppe.

Und die letzte Tabelle, benefitshat nur zwei Spalten:

• benefit_name - Die Bezeichnung einer bestimmten Leistung.
• salary_req - Das Mindestgehalt, das erforderlich ist, um diese Leistung zu erhalten.

Übung Nr. 7: Implizite Verknüpfung von Daten aus mehreren Tabellen

Übung: Wählen Sie den Vornamen, den Nachnamen, das Gehalt und die Gehaltsklasse der Mitarbeiter aus, deren Gehalt zwischen lower_limit und upper_limit in der Tabelle salgrade Tabelle passt.

Lösung:

SELECT 
  first_name, 
  last_name, 
  salary, 
  grade
FROM employee, salgrade
WHERE salary BETWEEN lower_limit AND upper_limit;

Erläuterung: Führen Sie die benötigten Spalten (first_name, last_name, salary, grade) in der Klausel SELECT auf. Verweisen Sie sowohl auf die employee und salgrade Tabellen in der FROM Klausel. Wir verwenden die WHERE Klausel, um die Join-Kriterien zwischen den beiden Tabellen zu definieren, indem wir angeben, dass das Mitarbeitergehalt zwischen der unteren und oberen Grenze der salgrade Tabelle liegen muss.

Übung Nr. 8: Explizites Joinen von Daten aus mehreren Tabellen

Übung: Zeigen Sie alle Leistungen an, die der Mitarbeiter mit id = 5 erhalten würde. Wählen Sie den Vor- und Nachnamen dieses Mitarbeiters zusammen mit den Namen der Leistungen aus.

Lösung:

SELECT 
  first_name, 
  last_name, 
  benefits.benefit_name
FROM employee
JOIN benefits 
ON employee.salary > benefits.salary_req
WHERE employee.id = 5;

Erläuterung: Führen Sie die erforderlichen Spalten (first_name, last_name, benefits.benefit_name) in der Klausel SELECT auf. Verweisen Sie auf die employee in der Klausel FROM und verknüpfen Sie dann die Zeilen explizit mit der Tabelle benefit mit dem Schlüsselwort JOIN.

Die Bedingung, die die Beziehung zwischen den beiden Tabellen definiert, wird nach dem Schlüsselwort ON angegeben. Dadurch werden die Bedingungen für die Tabellenbeziehung von den Filterbedingungen getrennt, was die Übersichtlichkeit der Abfrage verbessert. Filterbedingungen werden immer noch in der Klausel WHERE definiert; in diesem Fall verwenden wir die Bedingung employee.id = 5.

Übung Nr. 9: Verbinden und Gruppieren von Daten aus mehreren Tabellen

Übung: Ermitteln Sie für jede Leistung die Anzahl der Mitarbeiter, die diese Leistung erhalten. Zeigen Sie zwei Spalten an: die benefit_name und die Anzahl der Mitarbeiter, die diese Leistung erhalten (nennen Sie diese Spalte employee_count). Vergessen Sie nicht die Leistungen, die von niemandem in Anspruch genommen werden.

Lösung:

SELECT 
  benefits.benefit_name, 
  COUNT(employee.id) AS employee_count
FROM benefits
LEFT JOIN employee 
ON salary_req <= employee.salary
GROUP BY benefits.benefit_name;

Erläuterung: Fügen Sie die Spalte benefit_name und die Aggregationsfunktion COUNT() (angewandt auf die Spalte employee.id ) in die SELECT-Klausel ein. Verwenden Sie einen Alias für die Ergebnisse der Aggregationsfunktion: AS employee_count. Verweisen Sie auf die benefits Tabelle in der Klausel FROM und verbinden Sie dann die employee Tabelle mit einem LEFT JOIN.

Denken Sie daran, dass LEFT (und RIGHT) JOIN Operationen alle Daten von der linken (oder rechten) Seite der JOIN Kriterien abrufen - auch wenn keine übereinstimmenden Zeilen in der anderen Tabelle existieren. Weitere Informationen finden Sie in dem Artikel SQL JOIN Types Explained.

Das Verknüpfungskriterium wird nach dem Schlüsselwort ON angegeben. Verwenden Sie schließlich die Klausel GROUP BY, um die Daten auf der Ebene benefit_name zu aggregieren.

Übung Nr. 10: Eine Tabelle mit sich selbst verknüpfen (Self-Joins)

Übung: Zeigen Sie den Vornamen, den Nachnamen und das Gehalt jedes Mitarbeiters sowie den Vor- und Nachnamen seines direkten Vorgesetzten in derselben Zeile an. Für Mitarbeiter, die keinen Vorgesetzten haben (z.B. der CEO), zeigen Sie NULL als Vor- und Nachnamen des Vorgesetzten.

Verwenden Sie einen Alias, um den Spalten des Mitarbeiters employee_ und denen des Managers manager_ voranzustellen (z. B. employee_first_name).

Lösung:

SELECT 
  e.first_name AS employee_first_name, 
  e.last_name AS employee_last_name, 
  e.salary AS employee_salary,
  m.first_name AS manager_first_name,
  m.last_name AS manager_last_name
FROM employee e
LEFT JOIN employee m 
ON e.manager_id = m.id;

Erläuterung: Fügen Sie den Vornamen, den Nachnamen und das Gehalt des Mitarbeiters mit e als employee Tabellenalias. Fügen Sie den Vornamen und Nachnamen des Managers mit m als Tabellenalias ein. Verwenden Sie in der FROM -Klausel die employee Tabelle mit dem Alias e, um auf die Mitarbeiterdaten zu verweisen; in der LEFT JOIN Klausel verwenden Sie die employee Tabelle mit dem Alias m, um auf Managerdaten zu verweisen. Die Verknüpfungsbedingung ist, dass der Wert manager_id des Mitarbeiters mit dem Wert id des Managers übereinstimmen muss.

Erfahren Sie mehr: Die Verknüpfung einer Tabelle mit sich selbst ist ein gängiger Vorgang. Sie mag kompliziert erscheinen, ist aber einfacher zu verstehen, wenn Sie die richtigen Aliasnamen für die betreffende Tabelle verwenden! Weitere Hilfe zu JOINs finden Sie in unserem SQL-Kurs JOINS. Er enthält mehr als 90 interaktive Übungen, einschließlich zehn kostenloser Beispiele, mit denen Sie sofort anfangen können zu üben.

Verwendung von Unterabfragen

In diesem Abschnitt werden wir Unterabfragen verwenden, um Daten auf der Grundlage von Bedingungen abzufragen, die von anderen in der Datenbank gespeicherten Daten abhängen. Wir werden die folgenden Tabellen verwenden, beginnend mit der orchestras Tabelle:

• id - Die ID des Orchesters.
• name - Der Name des Orchesters.
• rating - Die Bewertung des Orchesters in den letzten zehn Jahren.
• city_origin - Die Heimatstadt des Orchesters (z.B. "Berlin" für die Berliner Philharmoniker).
• country_origin - Das Herkunftsland des Orchesters (z. B. "Deutschland" für die Berliner Philharmoniker).
• Jahr - Das Jahr, in dem das Orchester gegründet wurde.

Die Tabelle concert Tabelle enthält Informationen über die von Orchestern gespielten Konzerte:

• id - Die ID des Konzerts.
• city - Der Name der Stadt, in der das Konzert stattgefunden hat. Diese kann sich von der Heimatstadt des Orchesters unterscheiden.
• country - Der Name des Landes, in dem das Konzert stattgefunden hat.
• year - Das Jahr, in dem das Konzert stattgefunden hat.
• rating - Die Bewertung, die Kritiker dem Konzert gegeben haben.
• orchestra_id - Die ID des Orchesters, das das Konzert gespielt hat.

Die Tabelle members Tabelle enthält Informationen über jedes Orchestermitglied:

• id - Die ID eines bestimmten Mitglieds.
• name - Der Name des Mitglieds.
• position - Die Position des Mitglieds im Orchester (z. B. zweite Flöte, erste Viola).
• wage - Ein fester monatlicher Betrag, den das Orchestermitglied erhält.
• experience - Die Anzahl der Jahre an Erfahrung, die das Orchestermitglied hat.
• orchestra_id - Die ID des Orchesters.

Übung Nr. 11: Verwenden von Unterabfragen zum Filtern von Daten

Übung: Zeigen Sie die Namen von Orchestern an, die nach dem "Kammerorchester" gegründet wurden und eine Bewertung von mehr als 7,5 haben.

Lösung:

SELECT name
FROM orchestras 
WHERE year > 
(SELECT year 
FROM orchestras 
WHERE name = 'Chamber Orchestra') 
  AND rating > 7.5;

Erläuterung: Die Klauseln SELECT und FROM sind in dieser Übung sehr einfach, aber der knifflige Teil ist die Klausel WHERE. Wir müssen zwei Bedingungen auswerten, von denen wir genau eine kennen (rating > 7.5). Die zweite ist uns nicht bekannt, da es sich nicht um einen definierten Wert wie 7,5 handelt, sondern um etwas, das aus den Daten gewonnen werden muss - z. B. das Gründungsjahr des Kammerorchesters.

In diesen Szenarien verwenden wir eine Unterabfrage, d. h. eine Abfrage, die "innerhalb" einer größeren Abfrage ausgeführt wird. Für diese Übung ist eine Unterabfrage erforderlich, die das Gründungsjahr des Orchesters ermittelt, wenn der Name gleich "Kammerorchester" ist. Wir verwenden das Ergebnis dieser Unterabfrage, um das Gründungsjahr für jedes Orchester zu filtern.

Profi-Tipp: Bei der Arbeit mit Unterabfragen empfiehlt es sich, zuerst die Unterabfrage zu erstellen. Sobald sie das gewünschte Ergebnis liefert, betten Sie sie in die Hauptabfrage ein!

Übung Nr. 12: Unterabfragen in FROM verwenden

Übung: Finden Sie die durchschnittliche Anzahl der Mitglieder pro Orchester.

Lösung:

SELECT AVG(d.count) 
FROM (SELECT 
        orchestra_id, 
        COUNT(id) 
FROM members 
GROUP BY orchestra_id) d;

Erläuterung: Beginnen Sie mit der Unterabfrage, die die Anzahl der Mitglieder für jedes Orchester und die Kennung des Orchesters ermittelt. Fügen Sie die Unterabfrage in die FROM Klausel der Hauptabfrage ein und geben Sie ihr einen Alias. Die SELECT Klausel muss nur die durchschnittliche Anzahl der Mitglieder berechnen, indem sie die AVG() Aggregatfunktion auf die Zählergebnisse der Unterabfrage anwendet.

Übung Nr. 13: Korrelierte Unterabfragen

Übung: Wählen Sie den Namen, das Gehalt und die Erfahrung der bestbezahlten Mitglieder jedes Orchesters aus.

Lösung:

SELECT 
  name, 
  wage, 
  experience
FROM members m1
WHERE wage = (SELECT MAX(wage) 
             FROM members m2 
		WHERE m1.orchestra_id = m2.orchestra_id);

Erläuterung: Schließen Sie die Spalten name, wage und experience in die Hauptklausel SELECT ein. Legen Sie die members in die FROM -Klausel und geben ihr den Alias m1. Vergleichen Sie in der Klausel WHERE den Lohnwert (aus der Hauptabfrage) mit den Ergebnissen der korrelierten Unterabfrage.

Die korrelierte Unterabfrage ermittelt den Höchstlohn mithilfe der Aggregatfunktion MAX() für alle Zeilen in der Tabelle members (alias m2), deren orchestra_id mit der Hauptabfrage übereinstimmt.

Im Gegensatz zu regulären Unterabfragen, die einmal vor der Hauptabfrage ausgeführt werden, werden korrelierte Unterabfragen einmal für jede Zeile in der Hauptabfrage ausgeführt. Das liegt daran, dass sie sich auf Werte aus der Hauptabfrage beziehen.

Übung Nr. 14: Filter, Joins, GROUP BY und Unterabfragen verwenden

Übung: Zeigen Sie für jedes Orchester dessen Namen, den Namen der Stadt, in der das Orchester die höchste Bewertung für seine Aufführung erhalten hat, und diese Bewertung an.

Lösung:

SELECT 
  o.name, 
  c.city, 
  c.rating
FROM orchestras o
JOIN concerts c 
ON o.id = c.orchestra_id
WHERE c.rating IN ( SELECT MAX(con.rating)
			FROM concerts con
			WHERE con.orchestra_id = o.id) ;

Erläuterung: Fügen Sie den Namen des Orchesters, das Konzert city und die Spalten rating in die SELECT Klausel der Hauptabfrage ein. In der FROM Klausel schließen Sie die orchestras Tabelle und JOIN die concerts Tabelle unter Verwendung der Orchester-IDs.

Verwenden Sie die WHERE Klausel, um den Wert der concert rating mit der maximalen Konzertbewertung des Orchesters gleichzusetzen. Um dies zu erhalten, verwenden Sie eine korrelierte Unterabfrage, die die Funktion MAX() auf die Bewertungsspalte anwendet. In der WHERE -Klausel der Unterabfrage müssen Sie die Orchester-ID mit der Orchester-ID aus der Hauptabfrage abgleichen.

SQL-Befehle zur Datenmodifikation: EINFÜGEN, AKTUALISIEREN, LÖSCHEN

In den vorherigen Abschnitten haben wir den Befehl SELECT verwendet. In diesem Abschnitt werden wir die Verwendung anderer SQL-Befehle wie INSERT, UPDATE und DELETE üben. Wir verwenden die dish Tabelle, die Informationen über die Mahlzeiten in einem Restaurant enthält. Sie hat die folgenden Spalten:

• id - Die ID der einzelnen Gerichte und der Primärschlüssel dieser Tabelle.
• type - Die Art des Gerichts (z. B. Vorspeise, Hauptgericht, Nachspeise).
• name - Das Gericht
• price - Die des Gerichts

Übung Nr. 15: Einfügen einer einzelnen Zeile ohne Angabe von Spalten

Übung: Fügen Sie ein Gericht namens Cevapcici mit einer ID von 9 und einem Preis von 27 ein. Es ist ein Hauptgericht.

Lösung:

INSERT INTO dish 
VALUES (9, 'main course', 'Cevapcici', 27);

Erläuterung: Die INSERT INTO Klausel, gefolgt vom Tabellennamen, gibt die Tabelle an, in die wir Daten einfügen wollen. Da wir keine Liste der Spalten angegeben haben, müssen die Werte für alle Spalten in der VALUES Klausel angegeben werden. Führen Sie sie in der Reihenfolge auf, in der sie in der Tabelle definiert sind, und schließen Sie die Liste in Klammern ein. In diesem Fall fügen wir die ID, den Typ, den Namen und den Preis des Gerichts in die Tabelle ein.

Übung Nr. 16: Einfügen einer einzelnen Zeile und Angeben von Spalten

Übung: Die Balkanküche wird immer beliebter, also brauchen wir einen weiteren Balkanartikel auf der Speisekarte. Fügen Sie Kosovo-Brot mit einer ID von 10 hinzu; es ist eine Vorspeise. Über den Preis müssen wir noch entscheiden, also lassen wir ihn vorerst weg.

Lösung:

INSERT INTO dish (id, type, name) 
VALUES (10, 'starter', 'Kosovo Bread');

Erläuterung: Nach der INSERT INTO -Klausel und dem Tabellennamen geben Sie die Liste der einzufügenden Spalten an. (Denken Sie an die Klammern!) Spalten, die nicht in der Liste enthalten sind, erhalten den Wert NULL.

In der Klausel VALUES werden für jede der in der Liste angegebenen Spalten Werte angegeben.

Übung Nr. 17: Bestimmte Zeilen aktualisieren

Übung: Es ist Happy Hour in unserem Restaurant! Ändern Sie den Preis für alle Hauptgerichte auf 20.

Lösung:

UPDATE dish 
SET price = 20 
WHERE type = 'main course';

Erläuterung: Verwenden Sie den Satz UPDATE gefolgt von dem Namen der Tabelle, die Sie aktualisieren möchten. In der Klausel SET geben Sie die Spalte an, die Sie aktualisieren möchten (in diesem Fall einfach price), gefolgt von dem neuen Wert, der ihr zugewiesen werden soll.

Die WHERE -Klausel funktioniert genauso wie der SELECT -Satz, aber hier identifiziert sie die zu aktualisierenden Zeilen anstelle der zurückzugebenden Zeilen.

Übung Nr. 18: Mehrere Spalten aktualisieren

Übung: Frühlingsrollen verkaufen sich wie verrückt, aber niemand interessiert sich mehr für den Krabbensalat (ID 1). Wir müssen den Namen in etwas Exotischeres ändern - versuchen wir es mit Green Sea Dragon. Setzen Sie den Preis auf 10, um die Kunden zu ermutigen, dieses Gericht zu probieren.

Lösung:

UPDATE dish 
SET name = 'Green Sea Dragon', price = 10 
WHERE id = 1;

Erläuterung: Verwenden Sie den Satz UPDATE, gefolgt von dem Namen der Tabelle, die Sie aktualisieren möchten. In der SET -Klausel geben Sie die zu aktualisierenden Spalten an (name und price), gefolgt von dem/den neuen Wert(en), den/die wir zuweisen wollen; trennen Sie jedes Paar von Namen und Werten mit einem Komma. Die Klausel WHERE funktioniert genauso wie der SELECT-Satz.

Übung Nr. 19: Löschen einer einzelnen Zeile

Übung: Austern Bienville (ID 7) sind nicht sehr beliebt. Wir wollen sie aus der Speisekarte entfernen.

Lösung:

DELETE FROM dish 
WHERE id = 7;

Erläuterung: Verwenden Sie die Klausel DELETE FROM gefolgt vom Tabellennamen, um die Tabelle anzugeben, in der die Daten gelöscht werden sollen.

Die Klausel WHERE funktioniert mit DELETE genauso wie mit SELECT. In diesem Fall vergleicht sie die Spalte id mit einem einzigen Wert. Es werden also nur eine oder null Zeilen gelöscht (je nachdem, ob die Zeile mit id = 7 existiert oder nicht).

Übung Nr. 20: Mehrere Zeilen löschen

Übung: Ups, wir haben keinen Zucker mehr! Löschen Sie alle Desserts aus unserem Menü.

Lösung:

DELETE FROM dish 
WHERE type = 'dessert';

Erläuterung: Verwenden Sie die Klausel DELETE FROM gefolgt vom Tabellennamen, um die Tabelle anzugeben, in der die Daten gelöscht werden sollen. Die Klausel WHERE funktioniert genauso wie der Befehl SELECT; in diesem Fall löscht der SQL-Befehl alle Zeilen mit dem Wert "dessert" in der Spalte type.

Erfahren Sie mehr: Werfen Sie einen Blick auf den Kurs Wie man Daten in einer Datenbank in SQL ändert für 50+ Übungen zum Einfügen, Aktualisieren und Löschen von Daten.

CREATE TABLE- und ALTER TABLE-Befehle

Jetzt können wir die Verwendung von zwei weiteren SQL-Befehlen üben, mit denen wir Tabellen erstellen und ändern können.

Übung Nr. 21: Erstellen einer einfachen Tabelle

Übung: Erstellen Sie eine Tabelle mit dem Namen result mit zwei INTEGER Spalten (id und score) und einer DATE Spalte (score_date).

Lösung:

CREATE TABLE result (
  id integer,
  score integer,
  score_date date
);

Erläuterung: Verwenden Sie den Satz CREATE TABLE gefolgt von dem Namen der Tabelle, die Sie erstellen wollen. Geben Sie eine Liste von Spaltennamen mit dem entsprechenden Datentyp an, getrennt durch Kommata. Achten Sie darauf, dass die gesamte Spaltenliste in Klammern eingeschlossen ist.

Übung Nr. 22: Fügen Sie eine NOT NULL-Spalte hinzu

Übung: Ändern Sie die result Tabelle, indem Sie die Spalte id NOT NULL und eine neue VARCHAR Spalte namens name mit einer Begrenzung von 32 Zeichen hinzufügen.

Lösung:

ALTER TABLE result ALTER COLUMN id SET NOT NULL;
ALTER TABLE result ADD COLUMN name varchar(32);

Erläuterung: Verwenden Sie den Befehl ALTER TABLE gefolgt von dem Tabellennamen. Verwenden Sie die Klausel ALTER COLUMN, gefolgt von dem Namen der Spalte, die Sie ändern wollen. In diesem Fall setzen Sie die Spalte auf NOT NULL.

Verwenden Sie erneut den Befehl ALTER TABLE. Diesmal setzen Sie die Klausel ADD COLUMN ein, gefolgt vom Namen der neuen Spalte, ihrem Datentyp und der Zeichenbegrenzung (varchar(32)).

Erfahren Sie mehr: Der Kurs The Basics of Creating Tables in SQL enthält mehr als 80 Übungen und 10 Stunden Praxis zum Erstellen und Ändern von Datenbanktabellen.

Bereit für mehr SQL-Befehlsübungen?

Wir haben SQL-Befehle behandelt, mit denen Sie eine oder mehrere Tabellen abfragen, Daten filtern, Daten gruppieren und ordnen, Daten einfügen und aktualisieren sowie Daten löschen können. Wir haben Ihnen auch die grundlegenden Optionen zum Erstellen und Ändern von Datenbanktabellen gezeigt.

Es gibt jedoch noch eine Fülle von Wissen über SQL-Befehle zu erwerben. Unter Your Guide to SQL-Praxis auf LearnSQL.com finden Sie Dutzende von Artikeln, in denen Sie weitere SQL-Befehle üben können.

Wenn Sie sich umfassend informieren möchten, sollten Sie unser Alle für immer SQL-Paket erwerben. Dieses Paket gewährt Ihnen Zugang zu allen aktuellen und zukünftigen Kursen und stellt sicher, dass Sie die Ressourcen haben, um Ihre SQL-Kenntnisse kontinuierlich zu verbessern. Verpassen Sie nicht die Gelegenheit, Ihren Vorsprung zu sichern!