Einführung in SQL-Joins

Traditionell ziehen Sie Daten aus zwei oder mehr Tabellen mit einem WHERE Klausel in einer Abfrage. Aber in einem relationalen Datenbanksystem (RDBMS) kann dies mit einem einzigen SELECT erreicht werden Anfrage. Das ist die wahre Stärke relationaler Datenbanksysteme. In diesem Handbuch lernen Sie SQL-Joins kennen, eine leistungsstarke Methode zum Vergleichen und Auswählen von Zeilen und Tabellen.

Was ist ein SQL-Join?

In SQL ein join -Klausel erweitert die Möglichkeit, Zeilen aus Tabellen zu vergleichen und auszuwählen. Es verwendet einen algebraischen Prozess zum Kombinieren von Zeilen aus zwei oder mehr Tabellen basierend auf einer verwandten Spalte in diesen Tabellen. Gemäß der ANSI-Standard-SQL-Definition gibt es fünf Arten von Joins – Cross Joins , Inner Joins , linke (äußere) Joins , Right(Outer) Joins , und Full (Outer) Joins . Diese Joins sind in allen relationalen Datenbanksystemen implementiert und werden in den folgenden Abschnitten behandelt.

Hinweis Joins können für eine beliebige Anzahl von Tabellen in einer bestimmten Abfrage durchgeführt werden. Der Kürze und Klarheit halber behandelt dieser Leitfaden Joins, die auf zwei Tabellen angewendet werden.

Dieser Leitfaden verwendet zwei Tabellen, Employees und Address , um SQL-Joins zu demonstrieren. Jede dieser Tabellen enthält die folgenden Spaltendefinitionen und Daten:

• Mitarbeitertabelle

  Mitarbeiter-ID	Mitarbeitername
  1	Johannes
  2	Maria
  3	Robert

• Adresstabelle

  ID	Staat
  1	New York
  2	New Jersey
  3	Idaho
  4	Hawaii

Hinweis Sofern nicht anders erwähnt, funktionieren alle Befehle in diesem Handbuch sowohl auf MySQL als auch gut und PostgreSQL Datenbanken.

SQL-Cross-Joins

Auch bekannt als kartesischer Join , Cross Joins treten auf, wenn Sie mehrere Tabellen als Quelle für Ihr SELECT angeben Spaltenliste. In diesem Fall lassen Sie das WHERE weg Klausel-Join-Ausdruck, um Zeilen abzugleichen. Die Ergebnismenge enthält eine Zeile für jede Kombination von Zeilen zwischen den Tabellen. In einem Zwei-Tabellen-Szenario wird jede Zeile in einer Tabelle mit jeder Zeile der anderen Tabelle gepaart. Das resultierende Produkt wird als Kartesisches Produkt bezeichnet der beiden Tische. Die Syntax für einen Cross Join lautet wie folgt:

(# Rows in Table A) TIMES (# of Rows in Table B)

Hinweis

In der Mengenlehre ist das kartesische Produkt eine Multiplikationsoperation, die alle geordneten Paare der gegebenen Mengen erzeugt. Betrachten Sie zum Beispiel die Menge A mit den Elementen {a,b} und setzen Sie B mit Elementen {1,2,3} . Das kartesische Produkt von A und B wird durch AxB bezeichnet und das Ergebnis ist das folgende:

AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}

Die SQL-Syntax für einen Cross Join lautet wie folgt:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM [Table_1]
     CROSS JOIN [Table_2]

Aus der obigen Syntax, Column_1 , Column_2 , Column_N stellen die Spalten in einer Tabelle dar, und den CROSS JOIN -Klausel dient zum Kombinieren der beiden Tabellen, Table_1 und Table_2 . Aus den Beispieltabellen oben, wenn Sie einen Cross Join für Employees durchführen müssen und Address Tabellen verwenden Sie den folgenden SQL-Code:

SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address

Die Ausgabe des obigen SQL-Codes sieht wie folgt aus:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| John         |   New Jersey |
| John         |   Idaho      |
| John         |   Hawaii     |
| John         |   New York   |
| Mary         |   New York   |
| Mary         |   New Jersey |
| Mary         |   Idaho      |
| Mary         |   Hawaii     |
| Robert       |   New York   |
| Robert       |   New Jersey |
| Robert       |   Idaho      |
| Robert       |   Hawaii     |
+------------+----------------+

SQL Inner Join

Ein Inner Join gibt Zeilen mit übereinstimmenden Werten in beiden Tabellen zurück. Wenn es keine übereinstimmenden Datensätze gibt, werden in den Ergebnissen keine Zeilen zurückgegeben.

Die SQL-Syntax für Inner Join lautet wie folgt:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;

Im obigen Beispiel key ist der jeweilige Schlüssel der Tabellen. Wenn Sie einen inneren Join für Employees durchführen müssen und Address Tabellen verwenden Sie den folgenden SQL-Code:

SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id

Die Ausgabe des obigen SQL-Codes sieht wie folgt aus:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
+------------+----------------+

Linker (äußerer) SQL-Join

Ein Left Join gibt einen vollständigen Satz von Zeilen aus der linken Tabelle zusammen mit den übereinstimmenden Zeilen aus der rechten Tabelle zurück. Wenn es keine übereinstimmenden Datensätze gibt, dann NULL Werte werden aus der rechten Tabelle zurückgegeben.

Hinweis Einige Implementierungen relationaler Datenbanken verwenden die Schlüsselwörter „Left Outer Join“ im Gegensatz zu „Left Join“, aber sie sind funktional gleichwertig.

Die SQL-Syntax für Left Join lautet wie folgt:

SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key

Im obigen Beispiel key ist der jeweilige Schlüssel der Tabellen. Wenn Sie eine Linksverknüpfung für Employees durchführen müssen und Address Tabellen verwenden Sie den folgenden SQL-Code:

SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id

Die Ausgabe des obigen SQL-Codes lautet wie folgt:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| Robert       |   NULL       |
+------------+----------------+

SQL Right (Outer) Join

Ein Right Join gibt einen vollständigen Satz von Zeilen aus der rechten Tabelle und die übereinstimmenden Zeilen aus der linken Tabelle zurück. Dies wird auch als Right Outer Join bezeichnet. Wenn es keine übereinstimmenden Datensätze gibt, dann NULL Werte werden aus der rechten Tabelle für die betroffenen Zeilen in der linken Tabelle zurückgegeben.

Hinweis Einige Implementierungen relationaler Datenbanken verwenden die Schlüsselwörter „Right Outer Join“ im Gegensatz zu „Right Join“, aber sie sind funktional gleichwertig.

Die SQL-Syntax für einen Right Join lautet wie folgt:

SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key

Aus dem obigen Code key ist der jeweilige Schlüssel der Tabellen. Wenn Sie eine Rechtsverknüpfung für Employees durchführen müssen und Address Tabellen verwenden Sie den folgenden SQL-Code:

SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id

Die Ausgabe des obigen SQL-Codes ist die folgende:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| NULL         |   Idaho      |
| NULL         |   Hawaii     |
+------------+----------------+

Vollständiger (äußerer) SQL-Join

Ein vollständiger Join gibt alle Zeilen aus der linken Tabelle und alle Zeilen aus der rechten Tabelle zurück. Dies wird auch als Full Outer Join bezeichnet. Ein vollständiger Join gibt auch alle übereinstimmenden Datensätze aus beiden Tabellen zurück, sofern verfügbar. Wenn es keine übereinstimmenden Datensätze gibt, dann NULL Werte werden aus der linken Tabelle zurückgegeben. Es gibt auch NULL zurück Werte aus der rechten Tabelle.

Hinweis Einige Implementierungen relationaler Datenbanken verwenden die Schlüsselwörter „Full Outer Join“ im Gegensatz zu „Full Join“, aber sie sind funktional gleichwertig.

Die SQL-Syntax für Full Join lautet wie folgt:

SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key

Im obigen Code key ist der jeweilige Schlüssel der Tabellen. Wenn Sie einen vollständigen Join für Employees durchführen müssen und Address Tabellen verwenden Sie den folgenden SQL-Code:

SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id

Die Ausgabe des obigen SQL-Codes ist die folgende:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| Robert       |   NULL       |
| NULL         |   Idaho      |
| NULL         |   Hawaii     |
+------------+----------------+

Hinweis Während Join-Berechnungen, wenn Sie Tabellendaten mit NULL vergleichen Werte, sie stimmen nicht überein. Daher NULL -Werte werden nur als Teil der Join-Ergebnisse zurückgegeben und bei Join-Berechnungen ignoriert.

Leistungsvergleich von SQL-Joins

In Anbetracht der obigen Beispieltabellen ist der Inner Join in Bezug auf die Datenbankleistung normalerweise die schnellste der fünf Join-Klauseln. Je nach Größe der beiden Tabellen sind der Left Join und der Right Join die zweitschnellsten. Der Full Join ist normalerweise langsamer als der Left Join oder der Right Join. Der Cross Join, der auf dem kartesischen Produkt der beiden Tabellen basiert, ist in Bezug auf die Datenbankleistung normalerweise am langsamsten. Die angegebene Leistungshierarchie kann je nach Tabellenspaltenlänge, Spaltendatentyp und Schlüsseldefinitionen abweichen.

Schlussfolgerung

Die Verwendung von SQL-Joins erweitert die Funktionalität, Tabellenzeilen vergleichen zu können, gegenüber herkömmlichem WHERE Klauselabfragen. Joins sind ein wertvoller Mechanismus, um algebraische Logik auf zwei oder mehr Tabellen anzuwenden.