Wie man GROUP BY und ORDER BY in SQL verwendet

Einführung

Strukturierte Abfragesprache (SQL) Datenbanken können eine große Menge an Daten über zahlreiche Tabellen speichern und verwalten. Bei großen Datensätzen ist es wichtig zu verstehen, wie Daten sortiert werden können, insbesondere zur Analyse von Ergebnismengen oder zur Organisation von Daten für Berichte oder externe Kommunikationen.

Zwei gängige Anweisungen in SQL, die beim Sortieren Ihrer Daten helfen, sind GROUP BY und ORDER BY. Eine GROUP BY-Anweisung sortiert Daten, indem sie diese basierend auf den von Ihnen in der Abfrage angegebenen Spalten gruppieren und wird mit Aggregatfunktionen verwendet. Ein ORDER BY ermöglicht es Ihnen, Ergebnismengen alphabetisch oder numerisch und in aufsteigender oder absteigender Reihenfolge zu organisieren.

In diesem Tutorial werden Sie Abfrageergebnisse in SQL mithilfe der Anweisungen GROUP BY und ORDER BY sortieren. Sie werden auch üben, Aggregatfunktionen und die WHERE-Klausel in Ihren Abfragen zu implementieren, um die Ergebnisse noch weiter zu sortieren.

Voraussetzungen

Um dieser Anleitung zu folgen, benötigen Sie einen Computer, der ein relationales Datenbankmanagementsystem (RDBMS) verwendet, das SQL verwendet. Die Anweisungen und Beispiele in diesem Tutorial wurden in der folgenden Umgebung validiert:

• A server running Ubuntu 20.04, with a non-root user with sudo administrative privileges and firewall enabled. Follow our Initial Server Setup with Ubuntu 20.04 to get started.
• MySQL installiert und auf dem Server gesichert. Befolgen Sie unsere Anleitung So installieren Sie MySQL auf Ubuntu 20.04, um dies einzurichten. Diese Anleitung setzt voraus, dass Sie auch einen nicht-root MySQL-Benutzer eingerichtet haben, wie in Schritt 3 dieser Anleitung beschrieben.

Um das Sortieren von Daten in diesem Tutorial zu üben, benötigen Sie eine Datenbank und eine Tabelle mit Beispieldaten. Wenn Sie keine bereit haben, können Sie den folgenden Abschnitt Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten lesen, um zu erfahren, wie Sie eine Datenbank und Tabelle erstellen können. In diesem Tutorial wird auf diese Beispieldatenbank und Tabelle verwiesen.

Verbindung zu MySQL herstellen und eine Beispieldatenbank einrichten

Wenn Ihre SQL-Datenbank auf einem Remote-Server läuft, melden Sie sich von Ihrem lokalen Rechner aus über SSH auf Ihrem Server an:

ssh sammy@your_server_ip

Als Nächstes öffnen Sie die MySQL-Eingabeaufforderung und ersetzen Sie sammy durch Ihre MySQL-Benutzerkontoinformationen:

mysql -u sammy -p

Erstellen Sie eine Datenbank mit dem Namen movieDB:

CREATE DATABASE movieDB;

Wenn die Datenbank erfolgreich erstellt wurde, erhalten Sie die folgende Ausgabe:

Output
Query OK, 1 row affected (0.01 sec)

Um die Datenbank movieDB auszuwählen, führen Sie das folgende USE-Statement aus:

USE movieDB;

Output
Database changed

Nach Auswahl der Datenbank erstellen Sie eine Tabelle darin. Für das Beispiel dieses Tutorials erstellen wir eine Tabelle, die Informationen über die Vorführungen eines lokalen Kinos speichert. Diese Tabelle enthält die folgenden sieben Spalten:

• theater_id: speichert Werte vom Datentyp int für die Vorführungsräume jedes Kinos und dient als Primärschlüssel, was bedeutet, dass jeder Wert in dieser Spalte als eindeutiger Bezeichner für die jeweilige Zeile fungiert.
• date: verwendet den Datentyp DATE, um das spezifische Datum des Jahres, Monats und Tages zu speichern, an dem ein Film gezeigt wurde. Dieser Datentyp entspricht den folgenden Parametern: vier Stellen für das Jahr und maximal zwei Stellen für den Monat und Tag (YYYY-MM-DD).
• time: repräsentiert die geplante Vorführzeit des Films mit dem Datentyp TIME nach Stunden, Minuten und Sekunden (HH:MM:SS).
• movie_name: speichert den Namen des Films unter Verwendung des Datentyps varchar mit maximal 40 Zeichen.
• movie_genre: verwendet den Datentyp varchar mit maximal 30 Zeichen, um Informationen über das jeweilige Genre jedes Films zu speichern.
• guest_total: zeigt die Gesamtanzahl der Gäste an, die eine Filmvorführung besucht haben, mit dem Datentyp int.
• ticket_cost: verwendet den Datentyp decimal mit einer Präzision von vier und einer Skala von eins, was bedeutet, dass Werte in dieser Spalte vier Ziffern haben können und zwei Ziffern rechts vom Dezimalpunkt. Diese Spalte repräsentiert die Ticketkosten für die spezifische Filmvorführung.

Erstellen Sie eine Tabelle mit dem Namen movie_theater, die jede dieser Spalten enthält, indem Sie den folgenden CREATE TABLE-Befehl ausführen:

CREATE TABLE movie_theater (
theater_id int, 
date DATE,
time TIME, 
movie_name varchar(40),
movie_genre varchar(30),
guest_total int,
ticket_cost decimal(4,2),
PRIMARY KEY (theater_id)
); 

Als nächstes fügen Sie einige Beispieldaten in die leere Tabelle ein:

INSERT INTO movie_theater
(theater_id, date, time, movie_name, movie_genre, guest_total, ticket_cost)
VALUES
(1, '2022-05-27', '10:00:00', 'Top Gun Maverick', 'Action', 131, 18.00),
(2, '2022-05-27', '10:00:00', 'Downton Abbey A New Era', 'Drama', 90, 18.00),
(3, '2022-05-27', '10:00:00', 'Men', 'Horror', 100, 18.00),
(4, '2022-05-27', '10:00:00', 'The Bad Guys', 'Animation', 83, 18.00),
(5, '2022-05-28', '09:00:00', 'Top Gun Maverick', 'Action', 112, 8.00),
(6, '2022-05-28', '09:00:00', 'Downton Abbey A New Era', 'Drama', 137, 8.00),
(7, '2022-05-28', '09:00:00', 'Men', 'Horror', 25, 8.00),
(8, '2022-05-28', '09:00:00', 'The Bad Guys', 'Animation', 142, 8.00),
(9, '2022-05-28', '05:00:00', 'Top Gun Maverick', 'Action', 150, 13.00),
(10, '2022-05-28', '05:00:00', 'Downton Abbey A New Era', 'Drama', 118, 13.00),
(11, '2022-05-28', '05:00:00', 'Men', 'Horror', 88, 13.00),
(12, '2022-05-28', '05:00:00', 'The Bad Guys', 'Animation', 130, 13.00);

Output
Query OK, 12 rows affected (0.00 sec)
Records: 12  Duplicates: 0  Warnings: 0

Nachdem Sie die Daten eingefügt haben, können Sie damit beginnen, Abfrageergebnisse in SQL zu sortieren.

Verwendung von GROUP BY

Die Funktion einer GROUP BY-Anweisung besteht darin, Datensätze mit gemeinsamen Werten zu gruppieren. Eine GROUP BY-Anweisung wird immer mit einer Aggregatfunktion in einer Abfrage verwendet. Wie Sie sich vielleicht erinnern, fasst eine Aggregatfunktion Informationen zusammen und gibt ein einzelnes Ergebnis zurück. Zum Beispiel können Sie nach der Gesamtanzahl oder Summe einer Spalte abfragen, und dies wird einen einzelnen Wert in Ihrem Ergebnis produzieren. Mit einer GROUP BY-Klausel können Sie die Aggregatfunktion implementieren, um einen Ergebniswert für jede gewünschte Gruppe zu erhalten.

GROUP BY ist nützlich, um mehrere gewünschte Ergebnisse nach Ihren angegebenen Gruppen sortiert zurückzugeben, anstatt nur einer Spalte. Darüber hinaus muss GROUP BY immer nach der FROM-Anweisung und der WHERE-Klausel stehen, wenn Sie eine verwenden möchten. Hier ist ein Beispiel dafür, wie eine Abfrage mit GROUP BY und einer Aggregatfunktion strukturiert ist:

SELECT column_1, AGGREGATE_FUNCTION(column_2) FROM table GROUP BY column_1;

Um zu veranschaulichen, wie Sie GROUP BY-Anweisungen verwenden können, sagen wir, Sie führen die Kampagne für mehrere Filmveröffentlichungen an und möchten den Erfolg Ihrer Marketingbemühungen bewerten. Sie bitten ein örtliches Kino, die von den Gästen am Freitag und Samstag gesammelten Daten zu teilen. Beginnen Sie mit der Überprüfung der Daten, indem Sie SELECT und das *-Symbol ausführen, um „jede Spalte“ aus der Tabelle movie_theater auszuwählen:

SELECT * FROM movie_theater;

Output
+------------+------------+----------+-------------------------+-------------+-------------+-------------+
| theater_id | date       | time     | movie_name              | movie_genre | guest_total | ticket_cost |
+------------+------------+----------+-------------------------+-------------+-------------+-------------+
|          1 | 2022-05-27 | 10:00:00 | Top Gun Maverick        | Action      |         131 |       18.00 |
|          2 | 2022-05-27 | 10:00:00 | Downton Abbey A New Era | Drama       |          90 |       18.00 |
|          3 | 2022-05-27 | 10:00:00 | Men                     | Horror      |         100 |       18.00 |
|          4 | 2022-05-27 | 10:00:00 | The Bad Guys            | Animation   |          83 |       18.00 |
|          5 | 2022-05-28 | 09:00:00 | Top Gun Maverick        | Action      |         112 |        8.00 |
|          6 | 2022-05-28 | 09:00:00 | Downton Abbey A New Era | Drama       |         137 |        8.00 |
|          7 | 2022-05-28 | 09:00:00 | Men                     | Horror      |          25 |        8.00 |
|          8 | 2022-05-28 | 09:00:00 | The Bad Guys            | Animation   |         142 |        8.00 |
|          9 | 2022-05-28 | 05:00:00 | Top Gun Maverick        | Action      |         150 |       13.00 |
|         10 | 2022-05-28 | 05:00:00 | Downton Abbey A New Era | Drama       |         118 |       13.00 |
|         11 | 2022-05-28 | 05:00:00 | Men                     | Horror      |          88 |       13.00 |
|         12 | 2022-05-28 | 05:00:00 | The Bad Guys            | Animation   |         130 |       13.00 |
+------------+------------+----------+-------------------------+-------------+-------------+-------------+
12 rows in set (0.00 sec)

Obwohl diese Daten hilfreich sind, möchten Sie eine tiefere Bewertung durchführen und die Ergebnisse für einige spezifische Spalten sortieren.

Da Sie an Filmen verschiedener Genres gearbeitet haben, interessieren Sie sich dafür, wie gut sie von Kinobesuchern aufgenommen wurden. Sie möchten speziell den durchschnittlichen Betrag der Personen wissen, die sich jeden Filmgenre angesehen haben. Verwenden Sie SELECT, um die verschiedenen Arten von Filmen aus der Spalte movie_genre abzurufen. Wenden Sie dann die Aggregatfunktion AVG auf die Spalte guest_total an, verwenden Sie AS, um einen Alias für eine Spalte namens average zu erstellen, und fügen Sie die GROUP BY-Anweisung hinzu, um die Ergebnisse nach movie_genre zu gruppieren. Durch diese Gruppierung erhalten Sie die durchschnittlichen Ergebnisse für jedes Filmgenre:

SELECT movie_genre, AVG(guest_total) AS average
FROM movie_theater 
GROUP BY movie_genre;

Output
+-------------+----------+
| movie_genre | average  |
+-------------+----------+
| Action      | 131.0000 |
| Drama       | 115.0000 |
| Horror      |  71.0000 |
| Animation   | 118.3333 |
+-------------+----------+
4 rows in set (0.00 sec)

Diese Ausgabe liefert die vier Durchschnittswerte für jedes Genre innerhalb der movie_genre-Gruppe. Basierend auf diesen Informationen zogen Action-Filme im Durchschnitt die höchste Anzahl von Gästen pro Vorstellung an.

Als nächstes nehmen wir an, Sie möchten die Einnahmen des Theaters an zwei separaten Tagen messen. Die folgende Abfrage gibt Werte aus der date-Spalte sowie Werte zurück, die von der SUM-Aggregatfunktion zurückgegeben werden. Speziell wird die Aggregatfunktion SUM eine mathematische Gleichung in Klammern einschließen, um (mit dem *-Operator) die Anzahl der Gesamtgäste mit dem Ticketpreis zu multiplizieren, dargestellt als: SUM(guest_total * ticket_cost). Diese Abfrage enthält die AS-Klausel, um dem Rückgabewert der Aggregatfunktion die Aliasbezeichnung total_revenue zu geben. Vervollständigen Sie dann die Abfrage mit der GROUP BY-Anweisung, um die Abfrageergebnisse nach der date-Spalte zu gruppieren:

SELECT date, SUM(guest_total * ticket_cost) 
AS total_revenue 
FROM movie_theater 
GROUP BY date;

Output
+------------+---------------+
| date       | total_revenue |
+------------+---------------+
| 2022-05-27 |       7272.00 |
| 2022-05-28 |       9646.00 |
+------------+---------------+
2 rows in set (0.00 sec)

Da Sie GROUP BY verwendet haben, um die date-Spalte zu gruppieren, liefert Ihre Ausgabe die Ergebnisse für die Gesamteinnahmen aus dem Ticketverkauf für jeden Tag, in diesem Fall 7.272 $ für Freitag, 27. Mai, und 9.646 $ für Samstag, 28. Mai.

Nun stellen Sie sich vor, Sie möchten sich auf einen Film konzentrieren und analysieren: The Bad Guys. In diesem Szenario möchten Sie herausfinden, wie Timing und Preisgestaltung die Entscheidung einer Familie beeinflussen, einen Animationsfilm anzusehen. Verwenden Sie für diese Abfrage die Aggregatfunktion MAX, um den maximalen ticket_cost abzurufen, und verwenden Sie AS, um den Alias für die price_data-Spalte zu erstellen. Verwenden Sie dann die WHERE-Klausel, um die Ergebnisse nach movie_name auf ausschließlich „The Bad Guys“ einzugrenzen, und verwenden Sie AND, um auch die beliebtesten Filmzeiten basierend auf guest_total-Zahlen zu bestimmen, die mehr als 100 mit dem Vergleichsoperator > waren. Vervollständigen Sie die Abfrage dann mit der GROUP BY-Anweisung und gruppieren Sie sie nach time:

SELECT time, MAX(ticket_cost) AS price_data 
FROM movie_theater
WHERE movie_name = "The Bad Guys" 
AND guest_total > 100
GROUP BY time;

Output
+----------+------------+
| time     | price_data |
+----------+------------+
| 09:00:00 |       8.00 |
| 05:00:00 |      13.00 |
+----------+------------+
2 rows in set (0.00 sec)

Gemäß dieser Ausgabe nahmen mehr Gäste an der Vorführung von The Bad Guys um 9:00 Uhr morgens teil, die den erschwinglicheren Preis von $8.00 pro Ticket hatte. Diese Ergebnisse zeigen jedoch auch, dass die Kinobesucher den höheren Ticketpreis von $13.00 um 17:00 Uhr zahlten, was darauf hindeutet, dass Familien Vorführungen bevorzugen, die nicht zu spät am Tag stattfinden, und bereit sind, etwas mehr für ein Ticket zu bezahlen. Dies scheint eine faire Einschätzung im Vergleich zur Vorführzeit um 22:00 Uhr zu sein, als der Film The Bad Guys nur 83 Gäste hatte und der Ticketpreis $18.00 betrug. Diese Informationen können dem Kinomanager dabei helfen, Beweise dafür vorzulegen, dass die Eröffnung von mehr Matinee- und Frühabendvorstellungen die Teilnahme von Familien erhöhen kann, die eine Wahl auf der Grundlage einer bevorzugten Zeit und eines Preisniveaus treffen.

Bitte beachten Sie, dass obwohl GROUP BY fast immer mit einer Aggregatfunktion verwendet wird, es Ausnahmen geben kann, wenn auch unwahrscheinlich. Wenn Sie jedoch Ihre Ergebnisse gruppieren möchten, ohne eine Aggregatfunktion zu verwenden, können Sie die DISTINCT-Anweisung verwenden, um dasselbe Ergebnis zu erzielen. Eine DISTINCT-Klausel entfernt alle Duplikate in einem Ergebnisdatensatz, indem sie die eindeutigen Werte in der Spalte zurückgibt, und sie kann nur mit einer SELECT-Anweisung verwendet werden. Wenn Sie beispielsweise alle Filme nach Namen gruppieren möchten, könnten Sie dies mit der folgenden Abfrage tun:

SELECT DISTINCT movie_name FROM movie_theater;

Output
+-------------------------+
| movie_name              |
+-------------------------+
| Top Gun Maverick        |
| Downton Abbey A New Era |
| Men                     |
| The Bad Guys            |
+-------------------------+
4 rows in set (0.00 sec)

Wie Sie sich beim Anzeigen aller Daten in der Tabelle erinnern, gab es Duplikate der Filmtitel, da es mehrere Vorführungen gab. Daher entfernte DISTINCT diese Duplikate und gruppierte effektiv die eindeutigen Werte unter der einzelnen Spalte movie_name. Dies ist effektiv identisch mit der folgenden Abfrage, die eine GROUP BY-Anweisung enthält:

SELECT movie_name FROM movie_theater GROUP BY movie_name;

Jetzt, da Sie geübt haben, GROUP BY mit Aggregatfunktionen zu verwenden, werden Sie als nächstes lernen, wie Sie Ihre Abfrageergebnisse mit der ORDER BY-Anweisung sortieren.

MIT VERWENDUNG VON ORDER BY

Die Funktion des ORDER BY-Statements besteht darin, die Ergebnisse basierend auf der von Ihnen in der Abfrage angegebenen Spalte in aufsteigender oder absteigender Reihenfolge zu sortieren. Abhängig vom Datentyp, der von der Spalte gespeichert wird, die Sie danach angeben, organisiert ORDER BY sie in alphabetischer oder numerischer Reihenfolge. Standardmäßig sortiert ORDER BY die Ergebnisse in aufsteigender Reihenfolge; wenn Sie jedoch eine absteigende Reihenfolge bevorzugen, müssen Sie das Schlüsselwort DESC in Ihrer Abfrage einschließen. Sie können das ORDER BY-Statement auch mit GROUP BY verwenden, es muss jedoch danach kommen, um ordnungsgemäß zu funktionieren. Ähnlich wie GROUP BY muss auch ORDER BY nach dem FROM-Statement und der WHERE-Klausel stehen. Die allgemeine Syntax für die Verwendung von ORDER BY lautet wie folgt:

SELECT column_1, column_2 FROM table ORDER BY column_1;

Lassen Sie uns mit den Beispieldaten für das Kino fortfahren und das Sortieren von Ergebnissen mit ORDER BY üben. Beginnen Sie mit der folgenden Abfrage, die Werte aus der Spalte guest_total abruft und diese numerischen Werte mit einem ORDER BY-Statement organisiert:

SELECT guest_total FROM movie_theater 
ORDER BY guest_total;

Output
+-------------+
| guest_total |
+-------------+
|          25 |
|          83 |
|          88 |
|          90 |
|         100 |
|         112 |
|         118 |
|         130 |
|         131 |
|         137 |
|         142 |
|         150 |
+-------------+
12 rows in set (0.00 sec)

Da Ihre Abfrage eine Spalte mit numerischen Werten angegeben hat, hat das ORDER BY-Statement die Ergebnisse nach numerischer und aufsteigender Reihenfolge organisiert, beginnend mit 25 unter der Spalte guest_total.

Wenn Sie die Spalte in absteigender Reihenfolge bestellen möchten, fügen Sie das Schlüsselwort DESC am Ende der Abfrage hinzu. Darüber hinaus, wenn Sie die Daten nach den Zeichenwerten unter movie_name ordnen möchten, geben Sie dies in Ihrer Abfrage an. Führen wir eine solche Abfrage mit ORDER BY aus, um die Spalte movie_name mit den Zeichenwerten in absteigender Reihenfolge zu ordnen. Sortieren Sie die Ergebnisse noch weiter, indem Sie eine WHERE-Klausel einschließen, um die Daten zu Filmen abzurufen, die um 22:00 Uhr in der Spalte time gezeigt werden:

SELECT movie_name FROM movie_theater
WHERE time = '10:00:00' 
ORDER BY movie_name DESC;

Output
+-------------------------+
| movie_name              |
+-------------------------+
| Top Gun Maverick        |
| The Bad Guys            |
| Men                     |
| Downton Abbey A New Era |
+-------------------------+
4 rows in set (0.01 sec)

Dieses Ergebnisset listet die vier verschiedenen Filmvorführungen um 22:00 Uhr in absteigender alphabetischer Reihenfolge auf, beginnend von Top Gun Maverick bis Downtown Abbey A New Era.

Für diese nächste Abfrage kombinieren Sie die Anweisungen ORDER BY und GROUP BY mit der Aggregatfunktion SUM, um Ergebnisse über die insgesamt erzielten Einnahmen für jeden Film zu generieren. Angenommen, das Kino hat die Gesamtzahl der Gäste falsch gezählt und vergessen, spezielle Partys einzubeziehen, die im Voraus Tickets für eine Gruppe von 12 Personen für jede Vorstellung gekauft und reserviert hatten.

In dieser Abfrage verwenden Sie SUM und schließen Sie die zusätzlichen 12 Gäste bei jeder Filmvorführung ein, indem Sie den Additionoperator + implementieren und dann 12 zur guest_total hinzufügen. Stellen Sie sicher, dass Sie dies in Klammern einschließen. Multiplizieren Sie dann dieses Ergebnis mit dem ticket_cost unter Verwendung des Operators * und schließen Sie die mathematische Gleichung am Ende der Klammer ab. Fügen Sie die AS Klausel hinzu, um einen Alias für die neue Spalte mit dem Titel total_revenue zu erstellen. Verwenden Sie dann GROUP BY, um die total_revenue-Ergebnisse für jeden Film basierend auf den Daten aus der movie_name-Spalte zu gruppieren. Verwenden Sie schließlich ORDER BY, um die Ergebnisse unter der neuen Spalte total_revenue in aufsteigender Reihenfolge zu organisieren:

SELECT movie_name, SUM((guest_total + 12) * ticket_cost) 
AS total_revenue
FROM movie_theater 
GROUP BY movie_name 
ORDER BY total_revenue;

Output
+-------------------------+---------------+
| movie_name              | total_revenue |
+-------------------------+---------------+
| Men                     |       3612.00 |
| Downton Abbey A New Era |       4718.00 |
| The Bad Guys            |       4788.00 |
| Top Gun Maverick        |       5672.00 |
+-------------------------+---------------+
4 rows in set (0.00 sec)

Dieses Ergebnisset gibt uns den Gesamterlös für jeden Film mit den zusätzlichen 12 Ticketverkäufen an und organisiert die Gesamtticketverkäufe in aufsteigender Reihenfolge von niedrigsten zu höchsten. Daraus erfahren wir, dass Top Gun Maverick die meisten Ticketverkäufe erhalten hat, während Men die wenigsten erhielt. In der Zwischenzeit waren die Filme The Bad Guys und Downton Abbey A New Era in den Gesamtticketverkäufen sehr nahe beieinander.

In diesem Abschnitt haben Sie verschiedene Möglichkeiten zur Implementierung der ORDER BY-Anweisung geübt und gelernt, wie Sie die gewünschte Reihenfolge angeben können, z. B. aufsteigende und absteigende Reihenfolgen für sowohl Zeichen- als auch numerische Datenwerte. Sie haben auch gelernt, wie Sie die WHERE-Klausel verwenden, um Ihre Ergebnisse einzugrenzen, und eine Abfrage unter Verwendung der GROUP BY– und ORDER BY-Anweisungen mit einer Aggregatfunktion und einer mathematischen Gleichung durchgeführt.

Abschluss

Das Verständnis dafür, wie man die GROUP BY– und ORDER BY-Anweisungen verwendet, ist wichtig, um Ihre Ergebnisse und Daten zu sortieren. Ob Sie mehrere Ergebnisse unter einer Gruppe organisieren möchten, eine Ihrer Spalten alphabetisch und absteigend ordnen möchten oder beides gleichzeitig tun möchten; es liegt bei Ihnen und Ihren gewünschten Ergebnissen. Sie haben auch andere Möglichkeiten kennengelernt, Ihre Ergebnisse mit der WHERE-Klausel noch weiter zu sortieren. Wenn Sie mehr erfahren möchten, schauen Sie sich unser Tutorial zum Thema Verwendung von Platzhaltern in SQL an, um das Filtern von Ergebnissen mit der LIKE-Klausel zu üben.