SQL Cross Join

Denne artikel giver et overblik over CROSS JOIN i SQL, samt nogle grundlæggende eksempler.

SQL CROSS JOIN (eller FULL OUTER JOIN ) returnerer rækker, der kombinerer hver række fra den første tabel med hver række fra den anden tabel.

Med andre ord returnerer den det kartesiske produkt af rækker fra tabeller i joinforbindelsen.

Syntaks

Du angiver en krydsforbindelse i FROM klausul.

Syntaksen ser sådan ud:

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

Eksempel 1

Her er et eksempel til at demonstrere.

Eksempel på data

For det første er her de tabeller, vi skal bruge til eksemplet.

t1 tabel:

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

t2 tabel:

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

The Cross Join Query

Her er et eksempel på at udføre en krydssammenføjning mod disse to tabeller.

SELECT * FROM t1 
CROSS JOIN t2;

Resultat:

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

Så vores forespørgsel returnerer 9 rækker, selvom der kun er 3 rækker i hver tabel.

Dette er på grund af den måde, hvorpå krydsforbindelsen fungerer. Antallet af returnerede rækker er antallet af rækker i den venstre tabel, ganget med antallet af rækker i den højre tabel.

Se, hvordan den gentager den venstre tabel, og udskriver hver række i den højre tabel for hver række i den venstre tabel.

Dette har samme effekt som at gøre følgende:

SELECT * FROM t1, t2

Resultat:

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

Eksempel 2

Her er, hvad der sker, hvis vi tilføjer en WHERE klausul til vores krydsforbindelse.

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

Resultat:

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

Eksempel 3

Antag, at vi har følgende tabeller.

PetTypes tabel:

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

Pets tabel:

+---------+-------------+-----------+-----------+------------+
| 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)

I dette tilfælde er Pets.PetTypeId kolonnen er en fremmednøgle til PetTypes.PetTypeId kolonne.

Her er et eksempel på at køre en cross join på disse to tabeller, men ved at bruge en WHERE klausul.

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

Resultat:

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

Tilføjelse af WHERE klausul til krydssammenføjningen gjorde det til en indre sammenføjning.

Her er, hvad der sker, hvis vi fjerner WHERE klausul.

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

Resultat:

+-----------+-----------+
| 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)

Vi får en krydssammenføjning, der returnerer 32 rækker.