PostgreSQL JOIN

Как Join работает с таблицами в PostgreSQL?

Основная концепция, которая фокусируется на объединении, состоит в том, что два или более набора данных при объединении объединяют свои столбцы в новый набор строк, включая каждый из столбцов, запрашиваемых из каждого из наборов данных. Все соединения стоят на фундаменте декартового произведения. Декартово произведение - это набор всех возможных комбинаций между двумя наборами данных. Объединение создает набор строк во временной таблице и работает с двумя или более таблицами, и каждая таблица должна содержать хотя бы одно общее поле и должна поддерживать связь между общими полями. Объединение сохраняет структуру базовых таблиц неизменной.

Типы PostgreSQL JOIN

• Перекрестное соединение
• Внутреннее соединение
• Левое внешнее соединение
• Правое внешнее соединение
• Полное внешнее соединение

Иллюстрированная презентация соединений PostgreSQL

Предположим, у нас есть две таблицы:

 postgres = # выберите * от поставщика;
 id | название
---- + ------------
  0 | Jems
  1 | похлопывание
  2 | Kane
(3 ряда)
postgres = # выбор * из заказов;
 id | ord_value
---- + -----------
  1 | 5000
  2 | 8000
  3 | 10000
(3 ряда)

CROSS JOIN

Самый простой тип объединения - это перекрестное соединение. Cross Join создает декартово произведение между двумя наборами данных.

 postgres = # выбор * от поставщика, заказов;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
  0 | Джемс | 1 | 5000
  1 | Пэт | 1 | 5000
  2 | Кейн | 1 | 5000
  0 | Джемс | 2 | 8000
  1 | Пэт | 2 | 8000
  2 | Кейн | 2 | 8000
  0 | Джемс | 3 | 10000
  1 | Пэт | 3 | 10000
  2 | Кейн | 3 | 10000
(9 рядов)

Приведенный выше результат показывает, что первые два столбца представляют собой все поля таблицы первых поставщиков, за которыми следуют все поля второй таблицы заказов. Здесь из приведенного выше результата кажется, что он берет таблицу поставщиков и объединяет все ее строки с первой строкой заказов, затем снова берет таблицу поставщиков и объединяет ее со второй строкой заказов и, наконец, выполняет ту же работу для третий ряд заказов для производства 3 * 3 ряда.

Здесь в приведенном ниже утверждении показано, что тот же набор результатов может быть получен с использованием терминологии CROSS JOIN. Вот код ниже.

 postgres = # select * из заказов на взаимное соединение поставщиков;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
  0 | Джемс | 1 | 5000
  1 | Пэт | 1 | 5000
  2 | Кейн | 1 | 5000
  0 | Джемс | 2 | 8000
  1 | Пэт | 2 | 8000
  2 | Кейн | 2 | 8000
  0 | Джемс | 3 | 10000
  1 | Пэт | 3 | 10000
  2 | Кейн | 3 | 10000
(9 рядов)

ВНУТРЕННЕЕ СОЕДИНЕНИЕ

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

 postgres = # select * из заказов на присоединение поставщиков на supplier.id = orders.id;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
  1 | Пэт | 1 | 5000
  2 | Кейн | 2 | 8000
(2 ряда)
или запрос может быть написан как ниже.
postgres = # select * из заказов на внутреннее объединение поставщиков на supplier.id = orders.id;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
  1 | Пэт | 1 | 5000
  2 | Кейн | 2 | 8000
(2 ряда)

Приведенный выше вывод показывает, что в выводе есть только те строки, которые соответствуют критериям обеих связанных таблиц, поэтому мы получаем только 2 строки (1, 'Pat') и (2, 'Kane'). Критерии являются логическими критериями и должны возвращать true или false для каждой комбинации строк.

ЕСТЕСТВЕННОЕ СОЕДИНЕНИЕ

Иногда мы используем одно и то же имя поля для одних и тех же типов сущностей в разных таблицах. НАТУРАЛЬНОЕ объединение - это особый тип ВНУТРЕННЕГО объединения, когда мы просим PostgreSQL сопоставить все столбцы с одинаковыми именами. Вот запрос ниже.

 postgres = # select * из заказов естественного объединения поставщиков;
 id | имя | ord_value
---- + ------------ + -----------
  1 | Пэт | 5000
  2 | Кейн | 8000
(2 ряда)

В приведенном выше примере столбец «id» появляется только один раз, потому что этот столбец является общим в обеих таблицах. Здесь PostgreSQL неявно выполняет INNER JOIN для этого столбца.

СЛЕДУЮЩИЙ РЕЙТИНГ

В LEFT JOIN при соединении таблицы с поставщиками таблиц PostgreSQL сначала выполняет «нормальное» внутреннее соединение. Затем начинается сканирование, если в таблице поставщиков есть строки, которых нет в наборе результатов. Если это так, он добавляет в эти строки размещение пустых значений для всех полей заказов. Таким образом, убедитесь, что каждая строка поставщика появится хотя бы один раз в наборе результатов. Вот пример ниже.

 postgres = # select * из списка поставщиков, оставленных заказами на соединение на supplier.id = orders.id;
или запрос может быть написан как ниже.
postgres = # select * из левого внешнего заказа на поставку поставщика на supplier.id = orders.id;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
 0 | Джемс | |
  1 | Пэт | 1 | 5000
  2 | Кейн | 2 | 8000
(3 ряда)

Приведенный выше пример показывает, что строка выделена синим цветом, идентификатор 0 в таблице поставщиков не совпадает с таблицей заказов. поэтому для всех полей ордеров он заменяет NULL, здесь в приведенном выше выводе пустые поля имеют значение NULL.

ПРАВИЛЬНОЕ СОЕДИНЕНИЕ

В RIGHT JOIN при соединении таблицы с поставщиками таблиц PostgreSQL сначала выполняет «нормальное» внутреннее соединение. Затем он начинает сканирование, если в таблице заказов есть строки, которых нет в наборе результатов. Если это так, он добавляет в эти строки размещение пустых значений для всех полей поставщика. Таким образом, убедитесь, что каждая строка заказов появится хотя бы один раз в наборе результатов. Вот пример ниже.

 postgres = # select * из заказов на право присоединения поставщиков на supplier.id = orders.id;
или запрос может быть написан как ниже.
postgres = # select * из заказа на поставку правого внешнего соединения на supplier.id = orders.id;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
  1 | Пэт | 1 | 5000
  2 | Кейн | 2 | 8000
| | 3 | 10000
(3 ряда)

Приведенный выше пример показывает, что выделение строки синим цветом, идентификатор 3 в таблице заказов не совпадает с таблицей поставщика, поэтому для всех полей поставщика он заменяет NULL, здесь в приведенном выше выводе пустые поля имеют значение NULL. ,

ПОЛНОЕ СОЕДИНЕНИЕ или ПОЛНОЕ НАРУЖНОЕ СОЕДИНЕНИЕ

FULL OUTER JOIN - это сочетание левого и правого внешнего соединения. Во-первых, он выполняет внутреннее соединение и добавляет все пропущенные строки из таблицы, связанной с этим оператором, здесь - поставщик и заказы.

 postgres = # select * из заказов на полное присоединение поставщика на supplier.id = orders.id;
или запрос может быть написан как ниже.
postgres = # select * из заказов на полное внешнее объединение поставщиков на supplier.id = orders.id;
 id | имя | id | ord_value
---- + ---- + ------------ + -----------
0 | Джемс | |
  1 | Пэт | 1 | 5000
  2 | Кейн | 2 | 8000
| | 3 | 10000
(4 ряда)

Приведенный выше пример показывает, что выделение строки синим цветом, идентификаторы 0 и 3 в таблице поставщиков и заказов не соответствуют таблице заказов или поставщика соответственно, поэтому для всех полей заказов и поставщика она заменяет NULL, здесь в выше вывода пустые поля имеют значение NULL.

Предыдущая: функция UNNEST
Далее: CROSS JOIN