SQL Cross Join

Den här artikeln ger en översikt över CROSS JOIN i SQL, samt några grundläggande exempel.

SQL CROSS JOIN (eller FULL OUTER JOIN ) returnerar rader som kombinerar varje rad från den första tabellen med varje rad från den andra tabellen.

Med andra ord returnerar den den kartesiska produkten av rader från tabeller i kopplingen.

Syntax

Du anger en korskoppling i FROM klausul.

Syntaxen ser ut så här:

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

Exempel 1

Här är ett exempel att visa.

Exempeldata

Först, här är tabellerna vi ska använda för exemplet.

t1 tabell:

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

t2 tabell:

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

The Cross Join Query

Här är ett exempel på hur man utför en korskoppling mot dessa två 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å vår fråga returnerar 9 rader, även om det bara finns 3 rader i varje tabell.

Detta beror på hur korsfogen fungerar. Antalet rader som returneras är antalet rader i den vänstra tabellen, multiplicerat med antalet rader i den högra tabellen.

Se hur den itererar genom den vänstra tabellen och matar ut varje rad i den högra tabellen för varje rad i den vänstra tabellen.

Detta har samma effekt som att göra följande:

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)

Exempel 2

Så här händer om vi lägger till en WHERE klausul till vår korskoppling.

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

Resultat:

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

Exempel 3

Anta att vi har följande tabeller.

PetTypes tabell:

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

Pets tabell:

+---------+-------------+-----------+-----------+------------+
| 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 det här fallet, Pets.PetTypeId kolumnen är en främmande nyckel för PetTypes.PetTypeId kolumn.

Nu, här är ett exempel på att köra en korskoppling på dessa två tabeller, men med 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)

Lägger till WHERE klausul till korsfogen förvandlade den till en inre sammanfogning.

Så här händer om vi tar bort 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 korskoppling som returnerar 32 rader.