0Pricing
SQL Academy · Lektion

Zeilen derselben Tabelle vergleichen

Paare und Beziehungen finden

Zeilen derselben Tabelle vergleichen ist eine kostenlose SQL Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des SQL Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der SQL Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Self-Join?

Ein Self-Join liegt vor, wenn Sie eine Tabelle mit sich selbst verknüpfen. Das klingt zunächst ungewöhnlich, ist aber eine leistungsfähige Technik zum Vergleichen von Zeilen innerhalb derselben Tabelle.

Stellen Sie sich eine Tabelle employees vor, in der jeder Mitarbeiter eine manager_id besitzt, die auf eine andere Zeile derselben Tabelle verweist. Mit einem Self-Join können Sie jeden Mitarbeiter in einer einzigen Abfrage seinem Manager zuordnen.

Die Beispieltabelle einrichten

Erstellen Sie eine einfache Tabelle employees, die Sie in der gesamten Lektion verwenden. Jede Zeile verfügt über eine id, einen name, ein salary und eine manager_id, die auf einen anderen Mitarbeiter in derselben Tabelle verweist.

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(50),
  salary     INT,
  manager_id INT
);

INSERT INTO employees VALUES
  (1, 'Alice',   90000, NULL),
  (2, 'Bob',     70000, 1),
  (3, 'Carol',   65000, 1),
  (4, 'Dave',    55000, 2),
  (5, 'Eve',     60000, 2),
  (6, 'Frank',   48000, 3);

Grundlegende Syntax eines Self-Joins

Um einen Self-Join auszuführen, referenzieren Sie dieselbe Tabelle zweimal mit zwei unterschiedlichen Aliasen. Die Aliase wirken so, als hätten Sie zwei separate Kopien der Tabelle. Anschließend geben Sie die Join-Bedingung an, die die beiden Kopien verknüpft.

Hier versehen wir employees mit dem Alias e (für den Mitarbeiter) und m (für den Manager) und führen dann den Abgleich über e.manager_id = m.id durch.

SELECT
  e.name   AS employee,
  m.name   AS manager
FROM employees e
JOIN employees m ON e.manager_id = m.id;

Oberste Zeilen mit LEFT JOIN einbeziehen

Ein regulärer INNER JOIN entfernt Zeilen, in denen manager_id den Wert NULL hat. Dadurch würde der Mitarbeiter an der Spitze der Hierarchie (Alice, die CEO) aus den Ergebnissen ausgeschlossen.

Verwenden Sie einen LEFT JOIN, damit jeder Mitarbeiter angezeigt wird, auch Mitarbeiter ohne Manager. Die Managerspalte enthält für diese Mitarbeiter einfach NULL.

SELECT
  e.name          AS employee,
  m.name          AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id
ORDER BY m.name NULLS LAST, e.name;

Paare mit einer gemeinsamen Eigenschaft finden

Self-Joins eignen sich auch, um Zeilenpaare zu finden, die denselben Wert besitzen. So können Sie beispielsweise alle Mitarbeiterpaare ermitteln, die demselben Manager unterstehen.

Die Bedingung a.id < b.id verhindert, dass doppelte Paare wie (Bob, Carol) und (Carol, Bob) beide in den Ergebnissen erscheinen.

SELECT
  a.name       AS employee_1,
  b.name       AS employee_2,
  a.manager_id AS shared_manager
FROM employees a
JOIN employees b
  ON a.manager_id = b.manager_id
 AND a.id < b.id;

Gehälter zwischen Zeilen vergleichen

Mit einem Self-Join können Sie numerische Werte über mehrere Zeilen hinweg vergleichen. Die folgende Abfrage findet jeden Mitarbeiter, dessen Gehalt höher als das Gehalt seines eigenen Managers ist – eine klassische analytische Prüfung.

SELECT
  e.name       AS employee,
  e.salary     AS emp_salary,
  m.name       AS manager,
  m.salary     AS mgr_salary
FROM employees e
JOIN employees m ON e.manager_id = m.id
WHERE e.salary > m.salary;

Zeilen ohne Übereinstimmung finden

Mit einem Self-Join, einem LEFT JOIN und einer Prüfung auf WHERE ... IS NULL können Sie Zeilen finden, die kein passendes Gegenstück haben. Hier ermitteln Sie Mitarbeiter, denen niemand untersteht – die Blattknoten der Hierarchie.

SELECT e.name AS employee
FROM employees e
LEFT JOIN employees sub ON sub.manager_id = e.id
WHERE sub.id IS NULL
ORDER BY e.name;

Direkt unterstellte Mitarbeiter zählen

Indem Sie die Tabelle mit sich selbst verknüpfen und nach der Managerseite gruppieren, können Sie zählen, wie viele direkt unterstellte Mitarbeiter jeder Manager hat. Mitarbeiter ohne direkt Unterstellte werden über LEFT JOIN ebenfalls einbezogen.

SELECT
  m.name           AS manager,
  COUNT(e.id)      AS direct_reports
FROM employees m
LEFT JOIN employees e ON e.manager_id = m.id
GROUP BY m.id, m.name
ORDER BY direct_reports DESC;

Self-Joins mit CTEs übersichtlicher gestalten

Wenn eine Self-Join-Abfrage komplexer wird, erleichtert das Einschließen in eine Common Table Expression (CTE) das Lesen der Logik. Definieren Sie eine CTE für die Hierarchie und fragen Sie diese anschließend übersichtlich ab.

WITH hierarchy AS (
  SELECT
    e.id         AS emp_id,
    e.name       AS employee,
    e.salary     AS emp_salary,
    m.name       AS manager,
    m.salary     AS mgr_salary
  FROM employees e
  LEFT JOIN employees m ON e.manager_id = m.id
)
SELECT *
FROM hierarchy
WHERE mgr_salary IS NOT NULL
  AND emp_salary > mgr_salary;

Self-Join bei einer nicht hierarchischen Tabelle

Self-Joins sind nicht auf Mitarbeiter-Manager-Hierarchien beschränkt. Das folgende Beispiel verwendet eine Tabelle products, um alle Produktpaare zu finden, die zur gleichen Kategorie gehören. Das ist für Empfehlungssysteme oder Ähnlichkeitsprüfungen nützlich.

CREATE TABLE products (
  id       INT PRIMARY KEY,
  name     VARCHAR(50),
  category VARCHAR(30)
);

INSERT INTO products VALUES
  (1, 'Laptop',  'Electronics'),
  (2, 'Phone',   'Electronics'),
  (3, 'Tablet',  'Electronics'),
  (4, 'Shirt',   'Clothing'),
  (5, 'Jeans',   'Clothing');

SELECT
  a.name AS product_1,
  b.name AS product_2,
  a.category
FROM products a
JOIN products b
  ON a.category = b.category
 AND a.id < b.id;

Fallstricke: kartesische Produkte und Duplikate

Zwei häufige Fehler bei Self-Joins sind kartesische Produkte (wenn die Join-Bedingung vollständig vergessen wird) und doppelte Paare (wenn a.id <> b.id statt a.id < b.id verwendet wird).

Überprüfen Sie immer, ob Ihre Join-Bedingung korrekt ist, und verwenden Sie < statt <>, wenn Sie nur ungeordnete und keine geordneten Paare benötigen.

-- Wrong: returns every ordered pair (A,B) AND (B,A)
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id <> b.id;

-- Correct: returns each unordered pair once
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id < b.id;

Kurztest

Testen Sie Ihr Verständnis von Self-Joins und dem Vergleich von Zeilen in derselben Tabelle.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt, wie Sie Self-Joins verwenden, um Zeilen innerhalb derselben Tabelle zu vergleichen.

Wichtige Punkte:

  • Vergeben Sie der Tabelle zweimal einen Alias (z. B. e und m), damit die Datenbank sie als separate Quellen behandelt.
  • Verwenden Sie INNER JOIN, wenn Sie nur Zeilen benötigen, für die es eine Übereinstimmung gibt, und LEFT JOIN, wenn Sie auch nicht übereinstimmende Zeilen einschließen möchten.
  • Verwenden Sie a.id < b.id, um doppelte ungeordnete Paare zu vermeiden.
  • Self-Joins eignen sich für Hierarchien (Manager/Mitarbeiter), Ähnlichkeitssuchen (gleiche Kategorie) und jeden Vergleich, bei dem zwei Zeilen derselben Tabelle miteinander in Beziehung gesetzt werden müssen.
  • CTEs können komplexe Self-Join-Abfragen deutlich leichter lesbar und wartbar machen.

Häufig gestellte Fragen

Ist die Lektion „Zeilen derselben Tabelle vergleichen“ kostenlos?

Ja — der vollständige Text von „Zeilen derselben Tabelle vergleichen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des SQL Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der SQL Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Zeilen derselben Tabelle vergleichen“?

Paare und Beziehungen finden Du übst SQL Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um SQL Academy zu starten?

Keine Vorkenntnisse erforderlich. SQL Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Zeilen derselben Tabelle vergleichen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser SQL Academy-Lektion Code schreiben und ausführen?

Ja. Jede SQL Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Was ist ein Self-Join?
  2. Mitarbeiter und Vorgesetzte
  3. Zeilen derselben Tabelle vergleichen
  4. Grenzen von Self-Joins
← Zurück zu SQL Academy