Grundlegende SQL-Befehle - Die Liste der Datenbankabfragen und -anweisungen, die Sie kennen sollten

Entdecken Sie die essenziellen SQL-Befehle in unserer umfassenden Liste! Lernen Sie Datenbankabfragen und -anweisungen kennen, die Ihnen dabei helfen, effizient mit Daten umzugehen. Alles, was Sie über SQL-Befehle wissen müssen, kompakt und verständlich erklärt. Starten Sie Ihre Reise in die Welt der Datenverwaltung noch heute!

Von @RebeccaZuletzt aktualisiert 22.02.2024

SQL steht für Structured Query Language (strukturierte Abfragesprache). SQL-Befehle sind die Anweisungen, die zur Kommunikation mit einer Datenbank verwendet werden, um Aufgaben, Funktionen und Abfragen mit Daten durchzuführen.

Mit SQL-Befehlen können Sie die Datenbank durchsuchen und andere Funktionen wie das Erstellen von Tabellen, das Hinzufügen von Daten zu Tabellen, das Ändern von Daten und das Löschen von Tabellen ausführen.

Im Folgenden finden Sie eine Liste der grundlegenden SQL-Befehle (manchmal auch Klauseln genannt), die Sie kennen sollten, wenn Sie mit SQL arbeiten.

SELECT und FROM

Der SELECT-Teil einer Abfrage bestimmt, welche Spalten der Daten in den Ergebnissen angezeigt werden sollen. Es gibt auch Optionen, die Sie anwenden können, um Daten anzuzeigen, die keine Tabellenspalten sind.

Das folgende Beispiel zeigt drei Spalten, die aus der Tabelle "student" SELECTed wurden, und eine berechnete Spalte. Die Datenbank speichert die Schüler-ID, den Vornamen und den Nachnamen des Schülers. Wir können die Spalten Vorname und Nachname kombinieren, um die berechnete Spalte FullName zu erstellen.

SELECT studentID, FirstName, LastName, FirstName + ' ' + LastName AS FullName FROM student;

CREATE TABLE

CREATE TABLE tut genau das, wonach es klingt: Es erstellt eine Tabelle in der Datenbank. Sie können den Namen der Tabelle und die Spalten angeben, die in der Tabelle enthalten sein sollen.

CREATE TABLE table_name ( column_1 datatype, column_2 datatype, column_3 datatype );

ALTER TABLE

ALTER TABLE ändert die Struktur einer Tabelle. So fügen Sie eine Spalte zu einer Datenbank hinzu:

ALTER TABLE table_name ADD column_name datatype;

CHECK

Die CHECK-Beschränkung wird verwendet, um den Wertebereich zu begrenzen, der in einer Spalte platziert werden kann.

Wenn Sie eine CHECK-Beschränkung für eine einzelne Spalte definieren, sind nur bestimmte Werte für diese Spalte zulässig. Wenn Sie eine CHECK-Beschränkung für eine Tabelle definieren, kann sie die Werte in bestimmten Spalten auf der Grundlage von Werten in anderen Spalten in der Zeile einschränken.

Das folgende SQL erstellt eine CHECK-Beschränkung für die Spalte "Alter", wenn die Tabelle "Personen" erstellt wird. Die CHECK-Beschränkung stellt sicher, dass keine Person unter 18 Jahren vorhanden sein darf.

CREATE TABLE Persons ( ID int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Age int, CHECK (Age>=18) );

Um die Benennung einer CHECK-Beschränkung zu ermöglichen und um eine CHECK-Beschränkung für mehrere Spalten zu definieren, verwenden Sie die folgende SQL-Syntax:

CREATE TABLE Persons ( ID int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Age int, City varchar(255), CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes') );

WHERE

(AND, OR, IN, BETWEEN, und LIKE)

Die WHERE-Klausel wird verwendet, um die Anzahl der zurückgegebenen Zeilen zu begrenzen.

Als Beispiel zeigen wir Ihnen zunächst eine SELECT-Anweisung und die Ergebnisse ohne WHERE-Anweisung. Dann fügen wir eine WHERE-Anweisung hinzu, die alle fünf oben genannten Qualifier verwendet.

SELECT studentID, FullName, sat_score, rcd_updated FROM student;

+-----------+---------------------------+-----------+-------------------------+ | studentID | FullName | sat_score | rcd_updated | +-----------+---------------------------+-----------+-------------------------+ | 1 | Monique Davis | 400 | 2017-08-16 15:34:50 | | 2 | Teri Gutierrez | 800 | 2017-08-16 15:34:50 | | 3 | Spencer Pautier | 1000 | 2017-08-16 15:34:50 | | 4 | Louis Ramsey | 1200 | 2017-08-16 15:34:50 | | 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 | | 6 | Sophie Freeman | 1200 | 2017-08-16 15:34:50 | | 7 | Edgar Frank "Ted" Codd | 2400 | 2017-08-16 15:35:33 | | 8 | Donald D. Chamberlin | 2400 | 2017-08-16 15:35:33 | | 9 | Raymond F. Boyce | 2400 | 2017-08-16 15:35:33 | +-----------+---------------------------+-----------+-------------------------+ 9 rows in set (0.00 sec)

Jetzt wiederholen wir die SELECT-Abfrage, schränken aber die zurückgegebenen Zeilen mit einer WHERE-Anweisung ein.

STUDENT studentID, FullName, sat_score, recordUpdated FROM student WHERE (studentID BETWEEN 1 AND 5 OR studentID = 8) AND sat_score NOT IN (1000, 1400);

+------------+--------------------------+-----------+-------------------------+ | studentID | FullName | sat_score | rcd_updated | +------------+--------------------------+-----------+-------------------------+ | 1 | Monique Davis | 400 | 2017-08-16 15:34:50 | | 2 | Teri Gutierrez | 800 | 2017-08-16 15:34:50 | | 4 | Louis Ramsey | 1200 | 2017-08-16 15:34:50 | | 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 | | 8 | Donald D. Chamberlin | 2400 | 2017-08-16 15:35:33 | +------------+--------------------------+-----------+-------------------------+ 5 rows in set (0.00 sec)

UPDATE

Um einen Datensatz in einer Tabelle zu aktualisieren, verwenden Sie die UPDATE-Anweisung.

Verwenden Sie die WHERE-Bedingung, um anzugeben, welche Datensätze Sie aktualisieren möchten. Es ist möglich, eine oder mehrere Spalten auf einmal zu aktualisieren. Die Syntax lautet:

UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE condition;

Hier ein Beispiel für die Aktualisierung des Namens des Datensatzes mit der Id 4:

UPDATE Person SET Name = “Elton John” WHERE Id = 4;

Sie können auch Spalten in einer Tabelle aktualisieren, indem Sie Werte aus anderen Tabellen verwenden. Verwenden Sie die JOIN-Klausel, um Daten aus mehreren Tabellen zu erhalten. Die Syntax lautet:

UPDATE table_name1 SET table_name1.column1 = table_name2.columnA table_name1.column2 = table_name2.columnB FROM table_name1 JOIN table_name2 ON table_name1.ForeignKey = table_name2.Key

Hier ist ein Beispiel für die Aktualisierung des Managers aller Datensätze:

UPDATE Person SET Person.Manager = Department.Manager FROM Person JOIN Department ON Person.DepartmentID = Department.ID

GRUPPE BY

GROUP BY ermöglicht es Ihnen, Zeilen zu kombinieren und Daten zu aggregieren.

Hier ist die Syntax von GROUP BY:

SELECT column_name, COUNT(*) FROM table_name GROUP BY column_name;

HAVING

Mit HAVING können Sie die durch die GROUP BY-Klausel aggregierten Daten filtern, so dass der Benutzer eine begrenzte Anzahl von Datensätzen zur Ansicht erhält.

Hier ist die Syntax von HAVING:

SELECT column_name, COUNT(*) FROM table_name GROUP BY column_name HAVING COUNT(*) > value;

AVG()

"Average" wird verwendet, um den Durchschnitt einer numerischen Spalte aus der Menge der von einer SQL-Anweisung zurückgegebenen Zeilen zu berechnen.

Hier ist die Syntax für die Verwendung der Funktion:

SELECT groupingField, AVG(num_field) FROM table1 GROUP BY groupingField

Hier ist ein Beispiel mit der Tabelle Schüler:

SELECT studentID, FullName, AVG(sat_score) FROM student GROUP BY studentID, FullName;

AS

Mit AS können Sie eine Spalte oder Tabelle unter Verwendung eines Alias umbenennen.

SELECT user_only_num1 AS AgeOfServer, (user_only_num1 - warranty_period) AS NonWarrantyPeriod FROM server_table

Das Ergebnis ist die unten stehende Ausgabe.

+---------------+--------------------------+ | AgeOfServer | NonWarrantyPeriod | +---------------+--------------------------+ | 36 | 24 | | 24 | 12 | | 61 | 49 | | 12 | 0 | | 6 | -6 | | 0 | -12 | | 36 | 24 | | 36 | 24 | | 24 | 12 | +---------------+--------------------------+

Sie können AS auch verwenden, um einer Tabelle einen Namen zuzuweisen, damit sie in Joins leichter referenziert werden kann.

SELECT ord.product, ord.ord_number, ord.price, cust.cust_name, cust.cust_number FROM customer_table AS cust JOIN order_table AS ord ON cust.cust_number = ord.cust_number

Das Ergebnis ist die folgende Ausgabe.

+--------------+--------------+-----------+-----------------+----------------+ | product | ord_number | price | cust_name | cust_number | +--------------+--------------+-----------+-----------------+----------------+ | RAM | 12345 | 124 | John Smith | 20 | | CPU | 12346 | 212 | Mia X | 22 | | USB | 12347 | 49 | Elise Beth | 21 | | Cable | 12348 | 0 | Paul Fort | 19 | | Mouse | 12349 | 66 | Nats Back | 15 | | Laptop | 12350 | 612 | Mel S | 36 | | Keyboard | 12351 | 24 | George Z | 95 | | Keyboard | 12352 | 24 | Ally B | 55 | | Air | 12353 | 12 | Maria Trust | 11 | +--------------+--------------+-----------+-----------------+----------------+

ORDER BY

ORDER BY gibt uns die Möglichkeit, die Ergebnismenge nach einem oder mehreren der Elemente im SELECT-Abschnitt zu sortieren. Hier ist ein SQL, das die Schüler nach FullName in absteigender Reihenfolge sortiert. Die Standardsortierreihenfolge ist aufsteigend (ASC), aber um in der umgekehrten Reihenfolge (absteigend) zu sortieren, verwenden Sie DESC.

SELECT studentID, FullName, sat_score FROM student ORDER BY FullName DESC;

COUNT

COUNT zählt die Anzahl der Zeilen und gibt diese Anzahl als Spalte in der Ergebnismenge zurück.

Hier einige Beispiele für die Verwendung von COUNT:

Zählen aller Zeilen in einer Tabelle (keine Gruppierung nach erforderlich)
Zählen der Summen von Teilmengen von Daten (erfordert einen Abschnitt "Gruppieren nach" in der Anweisung)

Diese SQL-Anweisung liefert eine Zählung aller Zeilen. Beachten Sie, dass Sie der resultierenden COUNT-Spalte mit "AS" einen Namen geben können.

SELECT count(*) AS studentCount FROM student;

DELETE

DELETE wird verwendet, um einen Datensatz in einer Tabelle zu löschen.

Seien Sie vorsichtig. Sie können alle Datensätze der Tabelle oder nur einige wenige löschen. Verwenden Sie die WHERE-Bedingung, um anzugeben, welche Datensätze Sie löschen wollen. Die Syntax lautet:

DELETE FROM table_name WHERE condition;

Hier ein Beispiel für das Löschen des Datensatzes mit der Id 3 aus der Tabelle Person:

DELETE FROM Person WHERE Id = 3;

INNER JOIN

JOIN, auch Inner Join genannt, wählt Datensätze aus, deren Werte in zwei Tabellen übereinstimmen.

SELECT * FROM A x JOIN B y ON y.aId = x.Id

LEFT JOIN

Ein LEFT JOIN gibt alle Zeilen aus der linken Tabelle und die übereinstimmenden Zeilen aus der rechten Tabelle zurück. Zeilen in der linken Tabelle werden auch dann zurückgegeben, wenn es in der rechten Tabelle keine Übereinstimmung gab. Die Zeilen aus der linken Tabelle, die in der rechten Tabelle nicht übereinstimmen, haben für die Werte der rechten Tabelle den Wert Null.

SELECT * FROM A x LEFT JOIN B y ON y.aId = x.Id

RIGHT JOIN

Ein RIGHT JOIN gibt alle Zeilen aus der rechten Tabelle und die übereinstimmenden Zeilen aus der linken Tabelle zurück. Im Gegensatz zu einer linken Verknüpfung werden hier alle Zeilen aus der rechten Tabelle zurückgegeben, auch wenn es keine Übereinstimmung in der linken Tabelle gibt. Zeilen in der rechten Tabelle, die keine Übereinstimmung in der linken Tabelle haben, haben Nullwerte für Spalten der linken Tabelle.

SELECT * FROM A x RIGHT JOIN B y ON y.aId = x.Id

FULL OUTER JOIN

Ein FULL OUTER JOIN gibt alle Zeilen zurück, für die es in einer der Tabellen eine Übereinstimmung gibt. Wenn es also Zeilen in der linken Tabelle gibt, die keine Übereinstimmung in der rechten Tabelle haben, werden diese einbezogen. Wenn es Zeilen in der rechten Tabelle gibt, die keine Übereinstimmungen in der linken Tabelle haben, werden diese ebenfalls einbezogen.

SELECT Customers.CustomerName, Orders.OrderID FROM Customers FULL OUTER JOIN Orders ON Customers.CustomerID=Orders.CustomerID ORDER BY Customers.CustomerName

INSERT

INSERT ist eine Methode, um Daten in eine Tabelle einzufügen.

INSERT INTO table_name (column_1, column_2, column_3) VALUES (value_1, 'value_2', value_3);

LIKE

LIKE wird in einem WHERE oder HAVING (als Teil des GROUP BY) verwendet, um die ausgewählten Zeilen auf die Elemente zu beschränken, wenn eine Spalte ein bestimmtes Zeichenmuster enthält.

Mit dieser SQL werden Schüler ausgewählt, deren FullName mit "Monique" beginnt oder mit "Greene" endet.

SELECT studentID, FullName, sat_score, rcd_updated FROM student WHERE FullName LIKE 'Monique%' OR FullName LIKE '%Greene';

+-----------+------------------+-------------+-------------------------+ | studentID | FullName | sat_score | rcd_updated | +-----------+------------------+-------------+-------------------------+ | 1 | Monique Davis | 400 | 2017-08-16 15:34:50 | | 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 | +-----------+------------------+-------------+-------------------------+ 2 rows in set (0.00 sec)

Sie können NOT vor LIKE setzen, um die Zeilen mit dem Zeichenfolgenmuster auszuschließen, anstatt sie auszuwählen. Diese SQL schließt Datensätze aus, die "cer Pau" und "Ted" in der Spalte FullName enthalten.

SELECT studentID, FullName, sat_score, rcd_updated FROM student WHERE FullName NOT LIKE '%cer Pau%' AND FullName NOT LIKE '%"Ted"%';

+-----------+-------------------------+------------+--------------------------+ | studentID | FullName | sat_score | rcd_updated | +-----------+-------------------------+------------+--------------------------+ | 1 | Monique Davis | 400 | 2017-08-16 15:34:50 | | 2 | Teri Gutierrez | 800 | 2017-08-16 15:34:50 | | 4 | Louis Ramsey | 1200 | 2017-08-16 15:34:50 | | 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 | | 6 | Sophie Freeman | 1200 | 2017-08-16 15:34:50 | | 8 | Donald D. Chamberlin | 2400 | 2017-08-16 15:35:33 | | 9 | Raymond F. Boyce | 2400 | 2017-08-16 15:35:33 | +-----------+-------------------------+-----------+----------------------------+ 7 rows in set (0.00 sec)