SQL-Einstieg: Da­ten­ban­ken verstehen & Beispiele nutzen

Die Syntax der Pro­gram­mier­spra­che SQL basiert auf der re­la­tio­na­len Algebra und hebt sich dadurch deutlich von anderen Sprachen ab. Um SQL effizient zu meistern, sind ein solides Ver­ständ­nis dieser Struktur sowie pra­xis­na­he Beispiele der beste Weg zum Erfolg.

Grund­la­gen der SQL-Syntax

Allgemein be­schreibt die Syntax die „Schreib­wei­se“ einer Sprache. Sie definiert die ver­füg­ba­ren Code-Bausteine und wie du diese korrekt kom­bi­nierst. Dieses Wissen ist die Basis, um Code feh­ler­frei zu lesen und zu erstellen.

Die zentralen Elemente sind SQL-An­wei­sun­gen mit op­tio­na­len Klauseln. Im Alltag werden beide oft ver­ein­facht als „SQL-Befehle“ be­zeich­net. Hier siehst du die wich­tigs­ten Kon­struk­te im Überblick:

Wie wird SQL-Code aus­ge­führt?

SQL-Code wird als reiner Text ge­spei­chert. Damit er aktiv wird, braucht er eine Aus­füh­rungs­um­ge­bung. Ein SQL-In­ter­pre­ter liest den Quelltext und setzt ihn in Aktionen innerhalb des RDBMS um. Dabei gibt es zwei Wege:

1. In­ter­ak­ti­ve Aus­füh­rung

Hier schreibst du den Code direkt in ein Textfeld. Er wird sofort ver­ar­bei­tet und das Ergebnis erscheint prompt. Da du den Code schnell anpassen und neu testen kannst, ist diese Methode ideal zum Lernen und für komplexe Abfragen.

2. Aus­füh­rung als Skript

Eine komplette Datei wird Zeile für Zeile ab­ge­ar­bei­tet. Feedback erhältst du oft erst am Ende. Das ist perfekt, um Prozesse zu au­to­ma­ti­sie­ren oder MySQL Datenbank-Backups via MySQL-Dump ein­zu­spie­len.

Beispiel: Eine Pro­dukt­ver­wal­tung mit SQL aufbauen

Am besten lernst du, wenn du selbst aktiv wirst. Wir bauen gemeinsam eine kleine Datenbank auf und führen Abfragen durch. Nutze dafür den Online SQL in­ter­pre­ter von sql.js. Ersetze dort einfach den vor­han­de­nen Code durch unsere Beispiele und führe ihn Schritt für Schritt aus.

Der Plan für deine SQL-Datenbank

Wir si­mu­lie­ren eine Pro­dukt­ver­wal­tung für ein Geschäft. Hier sind die Eckpunkte:

• Wir führen ver­schie­de­ne Produkte mit je­wei­li­gen La­ger­be­stän­den.
• Wir verwalten Daten unserer Kund­schaft.
• Be­stel­lun­gen können mehrere Produkte enthalten.
• Wir speichern Datum, Kund:innen und die genauen Be­stell­men­gen.

Diese Logik gießen wir nun in SQL-Code, wobei wir diesem festen Ablauf folgen:

1. Modell entwerfen
2. Schema festlegen
3. Daten ein­pfle­gen
4. Abfragen erstellen

Entitäten und Be­zie­hun­gen mo­del­lie­ren

Zuerst de­fi­nierst du das System auf theo­re­ti­scher Ebene (oft als Entity Re­la­ti­onship Diagram). Du suchst nach Entitäten (Klassen von Dingen) und deren Be­zie­hun­gen.

In unserem Fall sind das: Produkt, Kund­schaft und Be­stel­lung. Jede Entität bekommt eine Tabelle. Oft braucht es zu­sätz­li­che Tabellen, um Ver­knüp­fun­gen sauber ab­zu­bil­den – das erfordert etwas Übung.

Wichtig ist die Art der Beziehung, be­trach­tet in beide Rich­tun­gen (Einzahl/Mehrzahl). Beispiel Besitzer:in und Auto:

1. „Einer Person gehören oft mehrere Autos“
2. „Ein Auto gehört genau einer Person“

Daraus ergeben sich drei typische Muster:

Produkte anlegen

Wir starten mit der Tabelle für Produkte: Schema festlegen, Daten einfügen und erste Abfragen testen.

Schema de­fi­nie­ren

Mit CREATE TABLE erstellst du die Tabelle und de­fi­nierst die Spalten samt Da­ten­ty­pen und Regeln für die Werte:

DROP TABLE IF EXISTS Products;
CREATE TABLE Products ( product_id int, product_name text, stocked int, price int );

Da­ten­sät­ze ein­pfle­gen

Nun füllen wir die Tabelle mit Testdaten. Dafür nutzen wir INSERT INTO und die VALUES-Funktion:

INSERT INTO Products VALUES (10, 'ABC Product', 74, 1050);
INSERT INTO Products VALUES (20, 'KLM Product', 23, 750);
INSERT INTO Products VALUES (30, 'XYZ Product', 104, 350);

Abfragen de­fi­nie­ren

Um zu kon­trol­lie­ren, ob alles geklappt hat, lassen wir uns mit SELECT FROM die gesamte Tabelle anzeigen:

SELECT * FROM Products;

Hier eine fort­ge­schrit­te­ne Abfrage, die direkt den Ge­samt­wert des Lagers berechnet:

SELECT product_name AS 'Name', (stocked * price) AS 'Value' FROM Products;

Restliche Tabellen im­ple­men­tie­ren

Jetzt folgen die weiteren Tabellen nach demselben Prinzip. Zuerst die Kund­schaft:

DROP TABLE IF EXISTS Customers;
CREATE TABLE Customers ( customer_id int, customer_name text, contact text );

Wir fügen zwei Beispiel-Einträge hinzu:

INSERT INTO Customers VALUES (100, 'EDC Customer', 'ED@example.com');
INSERT INTO Customers VALUES (200, 'WVU Customer', 'WV@example.com');

Kurzer Check der Tabelle:

SELECT * FROM Customers;

Nun folgt die Tabelle für die Be­stel­lun­gen:

DROP TABLE IF EXISTS Orders;
CREATE TABLE Orders ( order_id int, customer_id int, order_date text );

Wir erfassen drei Be­stel­lun­gen. Wichtig: Die erste Zahl ist die ID (Pri­mär­schlüs­sel), die zweite die Kund:innen-ID (Fremd­schlüs­sel). Zudem speichern wir das Datum:

INSERT INTO Orders VALUES (1000, 100, '2022-05-03');
INSERT INTO Orders VALUES (1001, 100, '2022-05-04');
INSERT INTO Orders VALUES (1002, 200, '2022-05-08');

Kontrolle der Be­stel­lun­gen:

SELECT * FROM Orders;

Zuletzt brauchen wir eine Tabelle für die be­stell­ten Produkte pro Auftrag. Da eine Be­stel­lung viele Produkte haben kann und umgekehrt, ist dies eine m:n-Beziehung. Die Tabelle verknüpft die IDs von Be­stel­lung und Produkt:

DROP TABLE IF EXISTS OrderItems;
CREATE TABLE OrderItems ( orderitem_id int, order_id int, product_id int, count int );

Wir ordnen Produkte den Be­stel­lun­gen zu, sodass eine Be­stel­lung mehrere Posten enthält und eine andere nur einen:

INSERT INTO OrderItems VALUES (10001, 1000, 10, 3);
INSERT INTO OrderItems VALUES (10002, 1000, 20, 2);
INSERT INTO OrderItems VALUES (10003, 1002, 30, 12);

Ab­schlie­ßen­der Check der be­stell­ten Produkte:

SELECT * FROM OrderItems;

Komplexe Abfragen nutzen

Jetzt zeigt SQL seine wahre Stärke. Wir führen Daten aus ver­schie­de­nen Tabellen zusammen. Mit einem SQL JOIN ver­knüp­fen wir Kund:innen und Be­stel­lun­gen. Wir nutzen dabei qua­li­fi­zier­te Iden­ti­fi­ka­to­ren, um die Spalten sauber zu­zu­ord­nen:

SELECT customers.customer_name as 'Customer', customers.customer_id, orders.order_id, orders.order_date AS 'Date' FROM Customers JOIN Orders ON Orders.customer_id = Customers.customer_id ORDER BY Customers.customer_id;

Zum Abschluss berechnen wir mit einem weiteren JOIN die Ge­samt­kos­ten der Be­stel­lun­gen:

SELECT OrderItems.order_id, OrderItems.orderitem_id AS 'Order Item', Products.product_name AS 'Product', Products.price AS 'Unit Price', OrderItems.count AS 'Count', (OrderItems.count * Products.price) AS 'Total' FROM OrderItems JOIN Products ON OrderItems.product_id = Products.product_id;