SQL Befehle: Liste gängiger SQL-Anweisungen mit Beispielen

Die SQL Befehle im Überblick

SQL Befehle lassen sich nach ihrer Aufgabe in einige Gruppen einteilen. Die Tabelle zeigt die, die du am häufigsten brauchst, und jeder Abschnitt unten führt einen davon aus.

DDL steht für Data Definition Language, DML für Data Manipulation Language, DQL für Data Query Language und TCL für Transaction Control Language. Die Namen sind weniger wichtig als die Aufteilung: DDL ändert die Form der Datenbank, DML ändert, was in ihr steht.

CREATE TABLE: Eine Tabelle anlegen

CREATE TABLE gibt der Tabelle einen Namen und führt ihre Spalten mit Typen und Regeln auf. Jeder andere Befehl auf dieser Seite braucht eine Tabelle, mit der er arbeiten kann.

CREATE TABLE students (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    grade INTEGER
);

SELECT name, sql FROM sqlite_master WHERE type = 'table';

Die Seite zu CREATE TABLE behandelt Regeln wie NOT NULL, UNIQUE und DEFAULT.

INSERT: Zeilen hinzufügen

INSERT INTO fügt eine oder mehrere Zeilen hinzu. Nenne die Spalten und dann die Werte in derselben Reihenfolge.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);

INSERT INTO students (name, grade) VALUES ('Ada', 91);
INSERT INTO students (name, grade) VALUES
    ('Boris', 78),
    ('Rosa', 85);

SELECT * FROM students;

Die Spalte id hat sich selbst gefüllt: Ein INTEGER PRIMARY KEY bekommt die nächste Nummer, wenn du ihn weglässt. Mehr dazu unter INSERT.

SELECT: Zeilen lesen

SELECT ist der Befehl, den du am häufigsten schreibst. Wähle die Spalten, filtere Zeilen mit WHERE und sortiere sie mit ORDER BY.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);
INSERT INTO students (name, grade) VALUES ('Ada', 91), ('Boris', 78), ('Rosa', 85), ('Chen', 62);

SELECT name, grade
FROM students
WHERE grade >= 80
ORDER BY grade DESC;

Nur Zeilen, die die WHERE-Bedingung erfüllen, kommen zurück, die höchste Note zuerst. Die Details stehen unter SELECT-Grundlagen und WHERE.

UPDATE: Zeilen ändern

UPDATE setzt neue Werte in Zeilen, die schon existieren. Die WHERE-Klausel bestimmt, welche Zeilen das sind; lässt du sie weg, ändert sich jede Zeile.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);
INSERT INTO students (name, grade) VALUES ('Ada', 91), ('Boris', 78), ('Rosa', 85);

UPDATE students
SET grade = 82
WHERE name = 'Boris';

SELECT * FROM students;

Wenn du nicht sicher bist, welche Zeilen eine WHERE-Klausel trifft, führe sie zuerst als SELECT aus. Die Seite UPDATE zeigt weitere Muster.

DELETE: Zeilen entfernen

DELETE FROM entfernt die Zeilen, auf die seine WHERE-Klausel passt. Wie bei UPDATE betrifft es jede Zeile, wenn die Klausel fehlt.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL, grade INTEGER);
INSERT INTO students (name, grade) VALUES ('Ada', 91), ('Boris', 78), ('Rosa', 85), ('Chen', 62);

DELETE FROM students
WHERE grade < 70;

SELECT * FROM students;

Chens Zeile ist weg, die anderen bleiben unverändert. Siehe DELETE.

ALTER TABLE und DROP TABLE: Eine Tabelle ändern oder entfernen

ALTER TABLE ändert eine bestehende Tabelle, ohne ihre Zeilen zu verlieren. DROP TABLE entfernt die Tabelle vollständig.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
INSERT INTO students (name) VALUES ('Ada'), ('Boris');

ALTER TABLE students ADD COLUMN email TEXT;
UPDATE students SET email = lower(name) || '@school.test';
SELECT * FROM students;

CREATE TABLE old_notes (id INTEGER PRIMARY KEY, body TEXT);
DROP TABLE old_notes;
SELECT name FROM sqlite_master WHERE type = 'table';

Eine neue Spalte ist in bestehenden Zeilen NULL, bis du sie füllst. ALTER und DROP TABLE listet auf, was SQLite erlaubt.

JOIN: Tabellen verbinden

Ein JOIN liest Zeilen aus zwei Tabellen gleichzeitig und ordnet sie über eine gemeinsame Spalte einander zu.

CREATE TABLE students (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
CREATE TABLE enrollments (student_id INTEGER, course TEXT);

INSERT INTO students (name) VALUES ('Ada'), ('Boris'), ('Rosa');
INSERT INTO enrollments VALUES (1, 'Math'), (1, 'Physics'), (3, 'Art');

SELECT students.name, enrollments.course
FROM students
INNER JOIN enrollments ON enrollments.student_id = students.id
ORDER BY students.name;

Boris hat keine Einschreibungen, deshalb lässt ein INNER JOIN ihn weg. Ein LEFT JOIN würde ihn behalten, mit leerem Kurs.

GROUP BY: Zeilen zusammenfassen

GROUP BY fasst Zeilen mit demselben Wert zu einer Zeile zusammen, und eine Aggregatfunktion wie COUNT oder AVG fasst jede Gruppe zusammen.

CREATE TABLE enrollments (student TEXT, course TEXT, score INTEGER);
INSERT INTO enrollments VALUES
    ('Ada', 'Math', 91), ('Boris', 'Math', 78),
    ('Ada', 'Art', 88), ('Rosa', 'Art', 95), ('Chen', 'Art', 70);

SELECT course, COUNT(*) AS students, AVG(score) AS average
FROM enrollments
GROUP BY course
ORDER BY course;

Aggregatfunktionen und GROUP BY und HAVING gehen weiter.

BEGIN, COMMIT und ROLLBACK: Änderungen bündeln

Eine Transaktion lässt mehrere Änderungen als eine zählen. COMMIT behält sie alle; ROLLBACK macht sie alle rückgängig.

CREATE TABLE accounts (name TEXT, balance INTEGER);
INSERT INTO accounts VALUES ('Ada', 100), ('Boris', 50);

BEGIN;
UPDATE accounts SET balance = balance - 30 WHERE name = 'Ada';
UPDATE accounts SET balance = balance + 30 WHERE name = 'Boris';
COMMIT;

BEGIN;
UPDATE accounts SET balance = 0;
ROLLBACK;

SELECT * FROM accounts;

Die Überweisung wurde mit COMMIT bestätigt und die zweite Änderung zurückgerollt, deshalb hat Ada am Ende 70 und Boris 80. Transaktionen erklärt, wann du sie einsetzen solltest.

Wo SQLite sich unterscheidet

Die Befehle auf dieser Seite sind Standard-SQL, und was du hier lernst, gilt auch in MySQL und PostgreSQL. Die ausführbaren Beispiele sind aber für SQLite geschrieben, und in den größeren Datenbanken ändern sich drei Details:

• Tabellen auflisten. Die Beispiele lesen sqlite_master, die eigene Schematabelle von SQLite. MySQL verwendet SHOW TABLES, PostgreSQL die View information_schema.tables (oder \dt in psql).
• Automatische IDs. In SQLite nummeriert eine als INTEGER PRIMARY KEY deklarierte Spalte neue Zeilen selbst; deshalb lassen die INSERT-Beispiele id weg. MySQL braucht AUTO_INCREMENT an der Spalte, PostgreSQL eine Identity-Spalte (GENERATED BY DEFAULT AS IDENTITY) oder SERIAL.
• Rechte und Schemaänderungen. SQLite kennt weder GRANT noch REVOKE, weil eine SQLite-Datenbank eine einzelne Datei ohne Benutzerkonten ist, und sein ALTER TABLE kann den Typ einer Spalte nicht ändern.