SQL-Cross-Join

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

Der SQL-CROSS JOIN (oder FULL OUTER JOIN ) gibt Zeilen zurück, die jede Zeile aus der ersten Tabelle mit jeder Zeile aus der zweiten Tabelle kombinieren.

Mit anderen Worten, es gibt das kartesische Produkt von Zeilen aus Tabellen im Join zurück.

Syntax

Sie geben einen Cross Join im FROM an Klausel.

Die Syntax lautet wie folgt:

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

Beispiel 1

Hier ist ein Beispiel zur Veranschaulichung.

Beispieldaten

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

Der t1 Tabelle:

+--------+
| col1   |
|--------|
| a      |
| b      |
| c      |
+--------+

Der t2 Tabelle:

+--------+
| col1   |
|--------|
| 1      |
| 2      |
| 3      |
+--------+

Die Cross-Join-Abfrage

Hier ist ein Beispiel für die Durchführung eines Cross Joins für diese beiden Tabellen.

SELECT * FROM t1 
CROSS JOIN t2;

Ergebnis:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| b      | 1      |
| c      | 1      |
| a      | 2      |
| b      | 2      |
| c      | 2      |
| a      | 3      |
| b      | 3      |
| c      | 3      |
+--------+--------+
(9 rows affected)

Unsere Abfrage gibt also 9 Zeilen zurück, obwohl jede Tabelle nur 3 Zeilen enthält.

Das liegt an der Funktionsweise des Cross Joins. Die Anzahl der zurückgegebenen Zeilen ist die Anzahl der Zeilen in der linken Tabelle, multipliziert mit der Anzahl der Zeilen in der rechten Tabelle.

Sehen Sie, wie es die linke Tabelle durchläuft und jede Zeile in der rechten Tabelle für jede Zeile in der linken Tabelle ausgibt.

Dies hat denselben Effekt wie Folgendes:

SELECT * FROM t1, t2

Ergebnis:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| b      | 1      |
| c      | 1      |
| a      | 2      |
| b      | 2      |
| c      | 2      |
| a      | 3      |
| b      | 3      |
| c      | 3      |
+--------+--------+
(9 rows affected)

Beispiel 2

Folgendes passiert, wenn wir ein WHERE hinzufügen -Klausel zu unserem Cross Join.

SELECT * FROM t1 
CROSS JOIN t2
WHERE t1.col1 = 'a';

Ergebnis:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| a      | 2      |
| a      | 3      |
+--------+--------+
(3 rows affected)

Beispiel 3

Angenommen, wir haben die folgenden Tabellen.

Die PetTypes Tabelle:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Die Pets Tabelle:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

In diesem Fall die Pets.PetTypeId Spalte ist ein Fremdschlüssel von PetTypes.PetTypeId Spalte.

Hier ist nun ein Beispiel für die Ausführung eines Cross Joins für diese beiden Tabellen, aber unter Verwendung eines WHERE Klausel.

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

Ergebnis:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Hinzufügen des WHERE -Klausel zum Cross Join machte daraus einen Inner Join.

Folgendes passiert, wenn wir WHERE entfernen Klausel.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p 
CROSS JOIN PetTypes pt;

Ergebnis:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Bird      |
| Fetch     | Bird      |
| Scratch   | Bird      |
| Wag       | Bird      |
| Tweet     | Bird      |
| Fluffy    | Bird      |
| Bark      | Bird      |
| Meow      | Bird      |
| Fluffy    | Cat       |
| Fetch     | Cat       |
| Scratch   | Cat       |
| Wag       | Cat       |
| Tweet     | Cat       |
| Fluffy    | Cat       |
| Bark      | Cat       |
| Meow      | Cat       |
| Fluffy    | Dog       |
| Fetch     | Dog       |
| Scratch   | Dog       |
| Wag       | Dog       |
| Tweet     | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Dog       |
| Fluffy    | Rabbit    |
| Fetch     | Rabbit    |
| Scratch   | Rabbit    |
| Wag       | Rabbit    |
| Tweet     | Rabbit    |
| Fluffy    | Rabbit    |
| Bark      | Rabbit    |
| Meow      | Rabbit    |
+-----------+-----------+
(32 rows affected)

Wir erhalten einen Cross Join, der 32 Zeilen zurückgibt.