SQL-Joins Tutorial

SQL Server ist ein relationales Datenbankmanagementsystem. Ein zentrales Prinzip relationaler Datenbanken ist, dass Daten über mehrere Tabellen verteilt gespeichert werden.

Um die benötigten Daten zu extrahieren, müssen wir Tabellen miteinander verknüpfen. Dafür nutzen wir Primary- und Foreign-Keys.

Primary Key

Ein Primärschlüssel ist eine Spalte, die jede Zeile in einer Tabelle eindeutig identifiziert. Diese Eindeutigkeit lässt sich zum Beispiel mit einer fortlaufenden Ganzzahl als Identity-Spalte erreichen. Manchmal enthalten bestehende Spalten von Natur aus eindeutige Werte und können dafür genutzt werden.

Im folgenden Beispiel sehen wir die ersten Zeilen der Tabelle artist. Sie hat zwei Spalten: artist_id und name. Die Spalte artist_id fungiert als Primärschlüssel dieser Tabelle, sie ist vom Typ Integer und jeder Wert kommt nur einmal vor.

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
Bereitgestellt von

Schauen wir uns nun die Tabelle album an. Erkennst du den Primärschlüssel? Genau, es ist die Spalte album_id. Häufig folgt der Primärschlüssel dem Muster „Tabellenname_Unterstrich_id“. Dir ist sicher auch die Spalte artist_id aufgefallen. Sie besteht ebenfalls aus Ganzzahlen und trägt denselben Namen wie die artist_id in der Tabelle artist. Was bedeutet das?

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
Bereitgestellt von

Foreign Keys

Am vorherigen Output wird deutlich: Die artist_id in der Tabelle album verweist als Foreign_key auf die Tabelle artist. Die FOREIGN KEY-Constraint verhindert Aktionen, die die Verknüpfungen zwischen Tabellen zerstören würden.

• Tabelle artist

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
Bereitgestellt von

• Tabelle album

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
Bereitgestellt von

Das bedeutet: Wenn die artist_id in der Tabelle album mit der artist_id in der Tabelle artist übereinstimmt, können diese Zeilen per JOIN verknüpft werden.

Album und Artist verknüpfen

Die Zeilen 1 und 4 der Tabelle album haben eine artist_id von 1. Die artist_id 1 in der Tabelle artist steht für AC/DC. Wenn wir also beide Tabellen verknüpfen, erhalten wir die Albumdetails aus der Tabelle album und die zugehörigen Artist-Informationen aus der Tabelle artist – verbunden über das Feld artist_id, das in beiden Tabellen vorhanden ist.

Das ist ein inner Join.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;
Bereitgestellt von

+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------|
Bereitgestellt von

Wir haben die Tabellen album und artist verknüpft, indem wir die artist_id aus der Tabelle artist mit der artist_id in der Tabelle album abgeglichen haben.

Wenn du Spalten mit demselben Namen aus unterschiedlichen Tabellen auswählst, musst du den Spaltennamen vollständig qualifizieren. Andernfalls weiß SQL Server nicht, aus welcher Tabelle die Spalte per SELECT abgerufen werden soll.

Um eine Spalte vollständig zu qualifizieren, setzt du den Tabellennamen gefolgt von einem Punkt davor.

Inner-Join-Syntax

Hier ist ein generisches Beispiel zur Erinnerung an die Syntax. Wir wählen die relevanten Spalten aus der Haupttabelle, hier table_A, und anschließend beliebige zusätzliche Spalten aus der zu verknüpfenden Tabelle, hier table_B. Dann geben wir die Verknüpfung mit den Schlüsselwörtern INNER JOIN und ON an und nennen die passenden Schlüsselspalten beider Tabellen.

SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;
Bereitgestellt von

Ohne WHERE-Klausel

In diesem Beispiel geben wir keine WHERE-Klausel an. Daher erhalten wir ALLE Kombinationen aller Treffer zwischen den Tabellen artist und album – erneut basierend auf der Spalte artist_id, die beiden gemeinsam ist.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;
Bereitgestellt von

+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+
Bereitgestellt von

Mehrere Inner Joins

Du kannst auch mehr als zwei Tabellen mit INNER JOINS verknüpfen. Du fügst einfach für jede Tabellenkombination einen weiteren INNER JOIN hinzu. Im folgenden Code verknüpfen wir die Tabellen A und B sowie B und C.

SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;
Bereitgestellt von

Wenn du mehr über das Verknüpfen von Tabellen erfahren möchtest, schau dir dieses Video aus unserem Kurs Introduction to SQL Server an.

Dieser Inhalt stammt aus DataCamps Kurs Introduction to SQL Server von John MacKintosh.