SQL кръстосано присъединяване

Тази статия предоставя общ преглед на CROSS JOIN в SQL, както и някои основни примери.

SQL CROSS JOIN (или FULL OUTER JOIN ) връща редове, които комбинират всеки ред от първата таблица с всеки ред от втората таблица.

С други думи, той връща декартовото произведение на редовете от таблици в обединението.

Синтаксис

Посочвате кръстосано присъединяване в FROM клауза.

Синтаксисът е така:

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

Пример 1

Ето пример за демонстрация.

Примерни данни

Първо, ето таблиците, които ще използваме за примера.

t1 таблица:

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

t2 таблица:

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

Заявката за кръстосано присъединяване

Ето пример за извършване на кръстосано свързване срещу тези две таблици.

SELECT * FROM t1 
CROSS JOIN t2;

Резултат:

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

Така че нашата заявка връща 9 реда, въпреки че има само 3 реда във всяка таблица.

Това се дължи на начина, по който работи кръстосаното съединение. Броят на върнатите редове е броят на редовете в лявата таблица, умножен по броя на редовете в дясната таблица.

Вижте как преминава през лявата таблица, като извежда всеки ред в дясната таблица за всеки ред в лявата таблица.

Това има същия ефект като извършването на следното:

SELECT * FROM t1, t2

Резултат:

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

Пример 2

Ето какво се случва, ако добавим WHERE клауза към нашето кръстосано присъединяване.

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

Резултат:

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

Пример 3

Да предположим, че имаме следните таблици.

PetTypes таблица:

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

Pets таблица:

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

В този случай Pets.PetTypeId колоната е външен ключ на PetTypes.PetTypeId колона.

Сега, ето пример за изпълнение на кръстосано присъединяване на тези две таблици, но с помощта на WHERE клауза.

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

Резултат:

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

Добавяне на WHERE клаузата за кръстосано съединение го превърна във вътрешно съединение.

Ето какво се случва, ако премахнем WHERE клауза.

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

Резултат:

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

Получаваме кръстосано съединение, което връща 32 реда.