SQL Inner Join

Dieser Artikel gibt einen Überblick über den INNER JOIN in SQL sowie einige grundlegende Beispiele.

Der SQL-INNER JOIN gibt Zeilen zurück, wenn in beiden Tabellen mindestens eine Zeile vorhanden ist, die der Join-Bedingung entspricht. Nicht übereinstimmende Zeilen aus beiden Tabellen werden verworfen. Dies ist der standardmäßige Join-Typ.

Syntax

Es gibt zwei Möglichkeiten, einen Inner Join anzugeben:im FROM -Klausel (unter Verwendung des INNER JOIN Syntax) oder mit WHERE Klausel.

Um einen inneren Join im FROM anzugeben Klausel:

SELECT *
FROM Table1 INNER JOIN Table2 
ON Table1.Column = Table2.Column;

Um einen inneren Join im WHERE anzugeben Klausel:

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

Nachfolgend finden Sie jeweils Beispiele.

Beispiele

Hier haben wir Beispiele für jede Methode zur Angabe eines inneren Joins.

Beispieldaten

Hier sind zunächst die Tabellen, die wir für die Beispiele verwenden werden.

Die PetTypes Tabelle:

+-------------+-----------+| PetTypeId | Haustiertyp ||-------------+-----------|| 1 | Vogel || 2 | Katze || 3 | Hund || 4 | Hase |+-------------+-----------+(4 Zeilen betroffen)

Die Pets Tabelle:

+---------+------------+-----------+---------- -+------------+| Haustier-ID | PetTypeId | Eigentümer-ID | Haustiername | Geburtsdatum ||---------+------------+-----------+----------- +------------|| 1 | 2 | 3 | Flauschig | 2020-11-20 || 2 | 3 | 3 | Holen | 2019-08-16 || 3 | 2 | 2 | Kratzer | 01.10.2018 || 4 | 3 | 3 | Wackeln | 2020-03-15 || 5 | 1 | 1 | Twittern | 2020-11-28 || 6 | 3 | 4 | Flauschig | 2020-09-17 || 7 | 3 | 2 | Rinde | NULL || 8 | 2 | 4 | Miau | NULL |+---------+------------+-----------+----------- +------------+(8 Zeilen betroffen)

Die Owners Tabelle:

+-----------+------------+-----------+------- ---------+-------------------+| Inhaber-ID   | Vorname   | Nachname   | Telefon          | E-Mail             ||-----------+-------------+------------+-------- --------+-------------------|| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] || 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  || 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              || 4         | Boris       | Trumpf      | (349) 611-8908 | NULL              |+-----------+-------------+------------+-------- --------+-------------------+

Beachten Sie Folgendes:

Die PetTypeId Spalte der Pets table ist ein Fremdschlüssel der PetTypeId der PetTypes Tabelle (das ist der Primärschlüssel dieser Tabelle).
Die OwnerId Spalte der Pets table ist ein Fremdschlüssel der OwnerId Spalte der Owners Tabelle.

Beispiel für die INNER JOIN-Syntax

Hier ist ein einfaches Beispiel für die Angabe eines inneren Joins mit dem INNER JOIN Syntax.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Ergebnis:

-----------+-----------+| Haustiername | Haustiertyp ||-----------+-----------|| Flauschig | Katze || Holen | Hund || Kratzer | Katze || Wackeln | Hund || Twittern | Vogel || Flauschig | Hund || Rinde | Hund || Miau | Katze |+-----------+-----------+(8 Zeilen betroffen)

Um einen inneren Join im FROM anzugeben -Klausel verwenden wir INNER JOIN . Wir verwenden auch den ON -Schlüsselwort, um das Prädikat zu definieren, das für jedes Paar verbundener Zeilen ausgewertet werden soll.

Unabhängig vom Join-Typ qualifizieren wir unsere Spaltennamen mit den Tabellennamen. Wir tun dies, um Mehrdeutigkeiten bezüglich der Spaltennamen zwischen den Tabellen zu vermeiden. Beide Tabellen könnten Spalten mit demselben Namen haben (wie in unserem Beispiel), und in solchen Fällen weiß das DBMS nicht, auf welche Spalte Sie sich beziehen. Das Präfixieren der Spaltennamen mit ihren Tabellennamen stellt sicher, dass Sie auf die richtige Spalte verweisen, und verhindert Fehler, die aus einer Mehrdeutigkeit darüber resultieren könnten, auf welche Spalte Sie sich beziehen.

In diesem Beispiel haben beide Tabellen eine PetTypeId Säule. Die Pets.PetTypeId Spalte ist ein Fremdschlüssel zu PetTypes.PetTypeId Spalte, die der Primärschlüssel für diese Tabelle ist.

In diesem Beispiel sehen wir, dass alle Haustiere zurückgegeben werden, aber nicht alle Arten von Haustieren. Es gibt keine Kaninchen in den Pets Tabelle, und so die Rabbits Haustiertyp wird nicht zurückgegeben.

Der Grund sind die Rabbits type nicht zurückgegeben wird, weil der INNER JOIN gibt nur Zeilen zurück, wenn in beiden Tabellen mindestens eine Zeile vorhanden ist, die der Join-Bedingung entspricht. In diesem Fall Rabbits befindet sich nur in einer Tabelle (die PetTypes Tabelle).

Join-Typ ist optional

Beachten Sie, dass der Join-Typ optional ist. Daher erlauben Ihnen die meisten (wenn nicht alle) DBMSs, den INNER wegzulassen Stichwort. Wenn Sie dies weglassen (d. h. nur JOIN angeben ), wird angenommen, dass es sich um eine innere Verknüpfung handelt.

Daher könnten wir das obige Beispiel folgendermaßen umschreiben:

SELECT
    Pets.PetName,
    PetTypes.PetType
FROM Pets
JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;

Formatierung

Wie bei jeder SQL-Anweisung können Sie Leerzeichen und Einzüge usw. verwenden, um Ihre Abfragen zu formatieren.

Zum Beispiel FROM Klausel kann auf einer ganzen Zeile stehen, wenn Sie es vorziehen:

SELECT
    Pets.PetName,
    PetTypes.PetType
FROM Pets JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId;

Wenn Sie größere Tabellen schreiben, die mehrere Tabellen verbinden, kann das Einrücken sehr hilfreich sein.

Beispiel für die Verwendung der WHERE-Klausel

Der obige Join kann auch als Equi-Join bezeichnet werden . Ein Equi-Join ist ein Join, der nur Gleichheitsvergleiche im Join-Prädikat enthält.

Hier ist ein Beispiel für die Angabe eines inneren Joins mit WHERE Klausel:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;

Ergebnis:

+-----------+-----------+| Haustiername   | PetType   ||-----------+-----------|| Flauschig    | Katze       || Holen Sie     | Hund       || Kratzer   | Katze       || Wag       | Hund       || Tweete     | Vogel      || Flauschig    | Hund       || Rinde      | Hund       || Miau      | Katze       |+-----------+-----------+(8 Zeilen betroffen)

Dies hat das gleiche Ergebnis wie das vorherige Beispiel zurückgegeben.

Hier haben wir einfach eine durch Kommas getrennte Liste der Tabellen bereitgestellt und dann ein WHERE Zustand. Wenn wir WHERE weggelassen hätten Bedingung, hätten wir am Ende einen CROSS JOIN erhalten .

Viele Anfänger finden die obige Syntax viel einfacher zu verstehen als den INNER JOIN Syntax. Fühlen Sie sich frei, diese Syntax zu verwenden, wenn Sie dies vorziehen, beachten Sie jedoch, dass die meisten SQL-Profis den INNER JOIN bevorzugen Syntax aus dem vorherigen Beispiel..

Innerer Join an 3 Tischen

Hier ist ein Beispiel für die Durchführung eines Inner Join an 3 Tabellen.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
INNER JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

Ergebnis:

+-----------+-----------+---------------+| Haustiername   | Haustiertyp   | Haustierbesitzer      ||-----------+-----------+---------------|| Flauschig    | Katze       | Nancy Simpson || Holen Sie     | Hund       | Nancy Simpson || Kratzer   | Katze       | Bart Pitt     || Wag       | Hund       | Nancy Simpson || Tweete     | Vogel      | Homer Connery || Flauschig    | Hund       | Boris Trump   || Rinde      | Hund       | Bart Pitt     || Miau      | Katze       | Boris Trump   |+-----------+-----------+---------------+(8 Zeilen betroffen)

In diesem Beispiel haben wir die Owners mitgebracht Tabelle in die Mischung, weil wir diese Abfrage brauchten, um Informationen über den Eigentümer zurückzugeben.

Um eine dritte Tabelle zu verwenden, haben wir lediglich einen weiteren INNER JOIN... ON hinzugefügt Argument zusammen mit den relevanten Tabellen-/Spaltendetails.

In diesem Fall habe ich CONCAT() von T-SQL verwendet Funktion, um zwei Spalten zu verketten, aber das ist für den Join irrelevant.