Соединение таблиц – операция JOIN и ее виды

Содержание:

Говоря про соединение таблиц в SQL, обычно подразумевают один из видов операции JOIN. Не стоит путать с объединением таблиц через операцию UNION. В этой статье я постараюсь простыми словами рассказать именно про соединение, чтобы после ее прочтения Вы могли использовать джойны в работе и не допускать грубых ошибок.

Соединение – это операция, когда таблицы сравниваются между собой построчно и появляется возможность вывода столбцов из всех таблиц, участвующих в соединении.

Придумаем 2 таблицы, на которых будем тренироваться.

Таблица «Сотрудники», содержит поля:

  • id – идентификатор сотрудника
  • Имя
  • Отдел – идентификатор отдела, в котором работает сотрудник
idИмяОтдел
1Юлия1
2Федор2
3АлексейNULL
4Светлана2

Таблица «Отделы», содержит поля:

  • id – идентификатор отдела
  • Наименование
idНаименование
1Кухня
2Бар
3Администрация

Давайте уже быстрее что-нибудь покодим.

INNER JOIN

Самый простой вид соединения INNER JOIN – внутреннее соединение. Этот вид джойна выведет только те строки, если условие соединения выполняется (является истинным, т.е. TRUE). В запросах необязательно прописывать INNER – если написать только JOIN, то СУБД по умолчанию выполнить именно внутреннее соединение.

Давайте соединим таблицы из нашего примера, чтобы ответить на вопрос, в каких отделах работают сотрудники (читайте комментарии в запросе для понимания синтаксиса).

SELECT
  -- Перечисляем столбцы, которые хотим вывести
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел -- выводим наименование отдела и переименовываем столбец через as
FROM
  -- таблицы для соединения перечисляем в предложении from 
  Сотрудники
  -- обратите внимание, что мы не указали вид соединения, поэтому выполнится внутренний (inner) джойн
  JOIN Отделы
    -- условия соединения прописываются после ON
    -- условий может быть несколько, записанных через and, or и т.п.
    ON Сотрудники.Отдел = Отделы.id

Получим следующий результат:

idИмяОтдел
1ЮлияКухня
2ФедорБар
4СветланаБар

Из результатов пропал сотрудник Алексей (id = 3), потому что условие «Сотрудники.Отдел = Отделы.id» не будет истинно для этой сроки из таблицы «Сотрудники» с каждой строкой из таблицы «Отделы». По той же логике в результате нет отдела «Администрация». Попробую это визуализировать (зеленные линии – условие TRUE, иначе линия красная):

Визуализация inner join

Если не углубляться в то, как внутреннее соединение работает под капотом СУБД, то происходит примерно следующее:

  • Каждая строка из одной таблицы сравнивается с каждой строкой из другой таблицы
  • Строка возвращается, если условие сравнения является истинным

Если для одной или нескольких срок из левой таблицы (в рассмотренном примере левой таблицей является «Сотрудники», а правой «Отделы») истинным условием соединения будут являться одна или несколько срок из правой таблицы, то строки умножат друг друга (повторятся). В нашем примере так произошло для отдела с id = 2, поэтому строка из таблицы «Отделы» повторилась дважды для Федора и Светланы.
Перемножение таблиц проще ощутить на таком примере, где условие соединения будет всегда возвращать TRUE, например 1=1:

SELECT *
FROM
  Сотрудники
  JOIN Отделы
    ON 1=1

В результате получится 12 строк (4 сотрудника * 3 отдела), где для каждого сотрудника подтянется каждый отдел.

Также хочу сразу отметить, что в соединении может участвовать сколько угодно таблиц, можно таблицу соединить даже саму с собой (в аналитических задачах это не редкость). Какая из таблиц будет правой или левой не имеется значения для INNER JOIN (для внешних соединений типа LEFT JOIN или RIGHT JOIN это важно. Читайте далее). Пример соединения 4-х таблиц:

SELECT *
FROM
  Table_1

  JOIN Table_2
    ON Table_1.Column_1 = Table_2.Column_1

  JOIN Table_3
    ON
      Table_1.Column_1 = Table_3.Column_1
      AND Table_2.Column_1 = Table_3.Column_1

  JOIN Table_1 AS Tbl_1 -- Задаем алиас для таблицы, чтобы избежать неоднозначности
    -- Если в Table_1.Column_1 хранится порядковый номер какого-то объекта, 
    -- то так можно присоединить следующий по порядку объект
    ON Table_1.Column_1 = Tbl_1.Column_1 + 1

Как видите, все просто, прописываем новый джойн после завершения условий предыдущего соединения. Обратите внимание, что для Table_3 указано несколько условий соединения с двумя разными таблицами, а также Table_1 соединяется сама с собой по условию с использованием сложения.
Строки, которые выведутся запросом, должны совпасть по всем условиям. Например:

  • Строка из Table_1 соединилась со строкой из Table_2 по условию первого JOIN. Давайте назовем ее «объединенной строкой» из двух таблиц;
  • Объединенная строка успешно соединилась с Table_3 по условию второго JOIN и теперь состоит из трех таблиц;
  • Для объединенной строки не нашлось строки из Table_1 по условию третьего JOIN, поэтому она не выводится вообще.

На этом про внутреннее соединение и логику соединения таблиц в SQL – всё. Если остались неясности, то спрашивайте в комментариях.
Далее рассмотрим отличия остальных видов джойнов.

LEFT JOIN и RIGHT JOIN

Левое и правое соединения еще называют внешними. Главное их отличие от внутреннего соединения в том, что строка из левой (для LEFT JOIN) или из правой таблицы (для RIGHT JOIN) попадет в результаты в любом случае. Давайте до конца определимся с тем, какая таблица левая, а какая правая.
Левая таблица та, которая идет перед написанием ключевых слов [LEFT | RIGHT| INNER] JOIN, правая таблица – после них:

SELECT *
FROM
  Левая_таблица AS lt
  LEFT JOIN Правая_таблица AS rt
    ON lt.c = rt.c

Теперь изменим наш SQL-запрос из самого первого примера так, чтобы ответить на вопрос «В каких отделах работают сотрудники, а также показать тех, кто не распределен ни в один отдел?»:

SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Сотрудники
  LEFT JOIN Отделы -- добавляем только left
    ON Сотрудники.Отдел = Отделы.id

Результат запроса будет следующим:

idИмяОтдел
1ЮлияКухня
2ФедорБар
3АлексейNULL
4СветланаБар

Как видите, запрос вернул все строки из левой таблицы «Сотрудники», дополнив их значениями из правой таблицы «Отделы». А вот строка для отдела «Администрация» не показана, т.к. для нее не нашлось совпадений слева.

Это мы рассмотрели пример для левого внешнего соединения. Для RIGHT JOIN будет все тоже самое, только вернутся все строки из таблицы «Отделы»:

idИмяОтдел
1ЮлияКухня
2ФедорБар
4СветланаБар
NULLNULLАдминистрация

Алексей «потерялся», Администрация «нашлась».

Вопрос для Вас. Что надо изменить в последнем приведенном SQL-запросе, чтобы результат остался тем же, но вместо LEFT JOIN, использовался RIGHT JOIN?

Ответ. Нужно поменять таблицы местами:

SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Отделы
  RIGHT JOIN Сотрудники
    ON Сотрудники.Отдел = Отделы.id

В одном запросе можно применять и внутренние соединения, и внешние одновременно, главное соблюдать порядок таблиц, чтобы не потерять часть записей (строк).

FULL JOIN

Еще один вид соединения, который осталось рассмотреть – полное внешнее соединение.
Этот вид джойна вернет все строки из всех таблиц, участвующих в соединении, соединив между собой те, которые подошли под условие ON.

Давайте посмотрим всех сотрудников и все отделы из наших тестовых таблиц:

SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Сотрудники
  FULL JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id
idИмяОтдел
1ЮлияКухня
2ФедорБар
3АлексейNULL
4СветланаБар
NULLNULLАдминистрация

Теперь мы видим все, даже Алексея без отдела и Администрацию без сотрудников.

Вместо заключения

Помните о порядке выполнения соединений и порядке таблиц, если используете несколько соединений и используете внешние соединения. Можно выполнять LEFT JOIN для сохранения всех строк из самой первой таблицы, а последним внутренним соединением потерять часть данных. На маленьких таблицах косяк заметить легко, на огромных очень тяжело, поэтому будьте внимательны.
Рассмотрим последний пример и введем еще одну таблицу «Банки», в которой обслуживаются наши придуманные сотрудники:

idНаименование
1Банк №1
2Лучший банк
3Банк Лидер

В таблицу «Сотрудники» добавим столбец «Банк»:

idИмяОтделБанк
1Юлия12
2Федор22
3АлексейNULL3
4Светлана24

Теперь выполним такой запрос:

SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел,
  Банки.Наименование AS Банк
FROM
  Сотрудники

  LEFT JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id

  INNER JOIN Банки
    ON Сотрудники.Банк = Банки.id

В результате потеряли информацию о Светлане, т.к. для нее не нашлось банка с id = 4 (такое происходит из-за неправильной проектировки БД):

idИмяОтделБанк
1ЮлияКухняЛучший банк
2ФедорБарЛучший банк
3АлексейNULLБанк Лидер

Хочу обратить внимание на то, что любое сравнение с неизвестным значением никогда не будет истинным (даже NULL = NULL). Эту грубую ошибку часто допускают начинающие специалисты. Подробнее читайте в статье про значение NULL в SQL.

Пройдите мой тест на знание основ SQL. В нем есть задания на соединения таблиц, которые помогут закрепить материал.

Дополнить Ваше понимание соединений в SQL могут схемы, изображенные с помощью кругов Эйлера. В интернете много примеров в виде картинок.

Если какие нюансы джойнов остались не раскрытыми, или что-то описано не совсем понятно, что-то надо дополнить, то пишите в комментариях. Буду только рад вопросам и предложениям.

Привожу простыню запросов, чтобы Вы могли попрактиковаться на легких примерах, рассмотренных в статье:

-- Создаем CTE для таблиц из примеров
WITH Сотрудники AS(
  SELECT 1 AS id, 'Юлия' AS Имя, 1 AS Отдел, 2 AS Банк
  UNION ALL
  SELECT 2, 'Федор', 2, 2
  UNION ALL
  SELECT 3, 'Алексей', NULL, 3
  UNION ALL
  SELECT 4, 'Светлана', 2, 4
),
Отделы AS(
  SELECT 1 AS id, 'Кухня' AS Наименование
  UNION ALL
  SELECT 2, 'Бар'
  UNION ALL
  SELECT 3, 'Администрация'
),
Банки AS(
  SELECT 1 AS id, 'Банк №1' AS Наименование
  UNION ALL
  SELECT 2, 'Лучший банк'
  UNION ALL
  SELECT 3, 'Банк Лидер'
)

-- Если надо выполнить другие запросы, то сначала закоментируй это запрос с помощью /**/,
-- а нужный запрос расскоментируй или напиши свой.
-- Это пример внутреннего соединения
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Сотрудники
  JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id

/*
-- Пример левого джойна
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Сотрудники
  LEFT JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id
*/

/*
-- Результат этого запроса будет аналогичен результату запроса выше, хотя соединение отличается
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Отделы
  RIGHT JOIN Сотрудники
    ON Сотрудники.Отдел = Отделы.id
*/

/*
-- Правое соединение
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Сотрудники
  RIGHT JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id
*/

/*
-- Пример с использованием разных видов JOIN
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Отделы
  RIGHT JOIN Сотрудники
    ON Сотрудники.Отдел = Отделы.id
  LEFT JOIN Банки
    ON Банки.id = Сотрудники.Банк
*/

/*
-- Полное внешние соединение
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел
FROM
  Сотрудники
  FULL JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id
*/

/*
-- Пример с потерей строки из-за последнего внутреннего соединения
SELECT
  Сотрудники.id,
  Сотрудники.Имя,
  Отделы.Наименование AS Отдел,
  Банки.Наименование AS Банк
FROM
  Сотрудники

  LEFT JOIN Отделы
    ON Сотрудники.Отдел = Отделы.id

  INNER JOIN Банки
    ON Сотрудники.Банк = Банки.id
*/

/*
-- Запрос с условием, которое всегда будет True
SELECT *
FROM
  Сотрудники
  JOIN Отделы
    ON 1=1
*/

Если материалы office-menu.ru Вам помогли, то поддержите, пожалуйста, проект, чтобы я мог развивать его дальше.

Добавить комментарий


Защитный код
Обновить