Sql inner join примеры: Команда INNER JOIN — связывание таблиц

Команда INNER JOIN — связывание таблиц

Команда INNER JOIN используются для связывания таблиц по определенным полям связи.

Синтаксис

SELECT поля FROM имя_таблицы
INNER JOIN имя_связанной_таблицы ON условие_связи 
WHERE условие_выборки

Примеры

Все примеры будут по таблицам countries и cities, если не сказано иное.

Таблица countries:

Таблица cities:

Пример

В данном примере … Лондон и Украина не выберется

SELECT
	cities.id as city_id, cities.name as city_name, cities.country_id as city_country_id,
	countries.id as country_id, countries.name as country_name
FROM cities
INNER JOIN countries ON countries.id=cities.country_id

SQL запрос выберет следующие строки:

Команда UNION — слияние таблиц

При объединении количество столбцов во всех таблицах должно совпадать, иначе будет ошибка

Имена столбцов будут такие же, как в основной таблице, в которую добавляются данные из других таблиц.

Внимание: если не используется ключевое слово ALL для UNION, все возвращенные строки будут уникальными, так как по умолчанию подразумевается DISTINCT, который удаляет неуникальные значения.

Чтобы отменить такое поведение — нужно указать ключевое слово ALL, вот так: UNION ALL.

См. также команду JOIN, которая объединяет связанные таблицы.

Синтаксис

С удалением дублей:

SELECT * FROM имя_таблицы1 WHERE условие
	UNION SELECT * FROM имя_таблицы2 WHERE условие

Без удаления дублей:

SELECT * FROM имя_таблицы1 WHERE условие
	UNION ALL SELECT * FROM имя_таблицы2 WHERE условие 

Можно объединять не две таблицы, а три или более:

SELECT * FROM имя_таблицы1 WHERE условие
	UNION SELECT * FROM имя_таблицы2 WHERE условие
	UNION SELECT * FROM имя_таблицы3 WHERE условие
	UNION SELECT * FROM имя_таблицы4 WHERE условие

Примеры

Все примеры будут по таблицам countries и cities, если не сказано иное.

Таблица countries:

Таблица cities:

Пример

В данном примере объединяются записи из двух таблиц:

SELECT id, name FROM countries UNION ALL SELECT id, name FROM cities

SQL запрос выберет следующие строки:

Пример

В данном примере отсутствует ключевое слово ALL, однако дубли не будут удалены, так как дублями считается полное совпадение строк:

SELECT id, name FROM countries UNION SELECT id, name FROM cities

SQL запрос выберет следующие строки:

Пример

А вот теперь дубли будут удалены (из двух Минсков останется один), так как будет иметь место полное совпадение строк (потому что поле осталось одно, но это не обязательно):

SELECT name FROM countries UNION SELECT name FROM cities

SQL запрос выберет следующие строки:

Пример

А теперь добавим слово ALL — и дубли не будут удалятся:

SELECT name FROM countries UNION ALL SELECT name FROM cities

SQL запрос выберет следующие строки:

Пример

В данном примере демонстрируется работа условий WHERE в комбинации с UNION:

SELECT id, name FROM countries WHERE id>=2
	UNION SELECT id, name FROM cities WHERE id

SQL запрос выберет следующие строки:

Пример

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

SELECT id as country_id, name as country_name FROM countries
 	UNION SELECT id, name FROM cities
 
 

SQL запрос выберет следующие строки:

Пример

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

SELECT id, name FROM countries UNION SELECT id, name, country_id FROM cities

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

SELECT * FROM countries UNION SELECT * FROM cities

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

К примеру, мы хотим забрать 3 поля из второй таблицы, а в первой таблице полей только 2. Решим эту проблему создав поле с именем country_id и содержимым 0 для первой таблицы (вот так: 0 as country_id):

SELECT id, name, 0 as country_id FROM countries
	UNION SELECT id, name, country_id FROM cities

SQL запрос выберет следующие строки:

Соединение таблиц или действие оператора SQL JOIN на примерах : WEBCodius

Синтаксис соединения таблиц оператором JOIN имеет вид:

FROM <таблица 1>
 [INNER]
 {{LEFT | RIGHT | FULL } [OUTER]} JOIN <таблица 2>
[ON <предикат>]

Предикат в этой конструкции определяет условие соединения строк из разных таблиц.

Допустим есть две таблицы (Auto слева и Selling справа), в каждой по четыре записи. Одна таблица содержит названия марок автомобилей (Auto), вторая количество проданных автомобилей (Selling):

id   name          id   sum
--   ----          --   ----
1    bmw           1    250
2    opel          5    450
3    kia           3    300
4    audi          6    400

Далее соединим эти таблицы по полю id несколькими различными способами. Совпадающие значения выделены красным для лучшего восприятия.

1. Внутреннее соединение (INNER JOIN) означает, что в результирующий набор попадут только те соединения строк двух таблиц, для которых значение предиката равно TRUE. Обычно используется для объединения записей, которые есть и в первой и во второй таблице, т. е. получения пересечения таблиц:

Красным выделена область, которую мы должны получить.

Итак, сам запрос:

SELECT * FROM 'Auto'
INNER JOIN 'Selling' ON 'Auto'.id = 'Selling'.id

И результат:

id   name          id   sum
--   ----          --   ----
1    bmw           1    250
3    kia           3    300

Ключевое слово INNER в запросе можно опустить.

В итоге запрос отбирает и соединяет те записи, у которых значение поля id в обоих таблицах совпадает.

2. Внешнее соединение

Переходим к запросу:

SELECT * FROM 'Auto'
FULL OUTER JOIN 'Selling' ON 'Auto'.id = 'Selling'.id

Результат:

id   name          id   sum
--   ----          --   ----
1    bmw           1    250
2    opel        NULL   NULL
3    kia           3    300
4    audi        NULL   NULL
NULL NULL          5    450
NULL NULL          6    400

То есть мы получили все записи, которые есть в обоих таблицах. Записи у которых значение поля id совпадает соединяются, а у записей для которых совпадений не найдено недостающие поля заполняются значением NULL.

Ключевое слово OUTER можно опустить.

3. Левое внешнее объединение (LEFT OUTER JOIN). В этом случае получаем все записи удовлетворяющие условию объединения, плюс все оставшиеся записи из внешней таблицы, которые не удовлетворяют условию объединения. Граф выборки:

Запрос:

SELECT * FROM 'Auto'
LEFT OUTER JOIN 'Selling' ON 'Auto'.id = 'Selling'.id

Результат:

id   name          id   sum
--   ----          --   ----
1    bmw           1    250
2    opel        NULL   NULL
3    kia           3    300
4    audi        NULL   NULL

Запрос также можно писать без ключевого слова OUTER.

В итоге здесь мы получили все записи таблицы Auto. Записи для которых были найдены совпадения по полю id в таблице Selling соединяются, для остальных недостающие поля заполняются значением NULL.

Еще существует правое внешнее объединение (RIGHT OUTER JOIN). Оно работает точно также как и левое объединение, только  в качестве внешней таблицы будет использоваться правая (в нашем случае таблица Selling или таблица Б на графе).

Далее рассмотрим остальные возможные выборки с использованием объединения двух таблиц.

4. Получить все записи из таблицы А, которые не имеют объединения из таблицы Б. Граф:

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

Запрос:

SELECT * FROM 'Auto'
LEFT OUTER JOIN 'Selling' ON 'Auto'.id = 'Selling'.id
WHERE 'Selling'.id IS null

Результат:

id   name          id   sum
--   ----          --   ----
2    opel        NULL   NULL
4    audi        NULL   NULL

5. И последний вариант, получить все записи из таблицы А и Таблицы Б, которые не имеют объединений. Граф:

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

Запрос:

SELECT * FROM 'Auto'
FULL OUTER JOIN 'Selling'
ON 'Auto'.id = 'Selling'.id
WHERE 'Auto'.id IS null
OR 'Selling'.id IS null

Результат:

id   name          id   sum
--   ----          --   ----
2    opel        NULL   NULL
4    audi        NULL   NULL
NULL NULL          5    450
NULL NULL          6    400

На этом все, до новых встреч на страницах блога.

Операция INNER JOIN

Синтаксис

FROM таблица1 INNER JOIN таблица2 ON таблица1.поле1оператор_сравнения таблица2.поле2

Операция INNER JOIN состоит из следующих элементов:

Замечания

Операцию INNER JOIN можно использовать в любом предложении FROM. Это самый распространенный тип объединения. С его помощью происходит объединение записей из двух таблиц по связующему полю, если оно содержит одинаковые значения в обеих таблицах.

При работе с таблицами «Отделы» и «Сотрудники» операцией INNER JOIN можно воспользоваться для выбора всех сотрудников в каждом отделе. Если же требуется выбрать все отделы (включая те из них, в которых нет сотрудников) или всех сотрудников (в том числе и не закрепленных за отделом), можно при помощи операции LEFT JOIN или RIGHT JOIN создать внешнее соединение.

При попытке связи полей, содержащих данные типа Memo или объекты OLE, возникнет ошибка.

Вы можете объединить любые два числовых поля похожих типов. Например, можно объединить поля с типом данных «Автонобере» и «Длинный». Однако нельзя соединить поля Single и Double.

В следующем примере показано, как можно объединить таблицы Categories и Products по полю CategoryID.

SELECT CategoryName, ProductName
FROM Categories INNER JOIN Products
ON Categories.CategoryID = Products.CategoryID;

В предыдущем примере CategoryID — это соединенное поле, но оно не включается в результаты запроса, так как оно не включено в утверждение SELECT. Чтобы включить в него соединенное поле, включив его имя в утверждение SELECT— в данном случае это Categories.CategoryID.

В инструкции JOIN можно также связать несколько предложений ON, используя следующий синтаксис:

SELECT поля
FROM таблица1 INNER JOIN таблица2
ON таблица1.таблица1оператор_сравнениятаблица2.поле1 AND
ON таблица1.поле2оператор_сравнениятаблица2.поле2) OR
ON таблица1.поле3оператор_сравнениятаблица2.поле3)];

Ниже приведен пример синтаксиса, с помощью которого можно составлять вложенные инструкции JOIN.

SELECT поля
FROM таблица1 INNER JOIN
(таблица2 INNER JOIN [( ]таблица3
[INNER JOIN [( ]таблицаx [INNER JOIN …)]
ON таблица3.поле3оператор_сравнениятаблицаx.полеx)]
ON таблица2.поле2оператор_сравнениятаблица3.поле3)
ON таблица1.поле1оператор_сравнениятаблица2.поле2;

Операции LEFT JOIN и RIGHT JOIN могут быть вложены в операцию INNER JOIN, но операция INNER JOIN не может быть вложена в операцию LEFT JOIN или RIGHT JOIN.

INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL JOIN

Содержание:

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

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

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

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

• id – идентификатор сотрудника
• Имя
• Отдел – идентификатор отдела, в котором работает сотрудник

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

• id – идентификатор отдела
• Наименование

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

INNER JOIN

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

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

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

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

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

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

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

Если для одной или нескольких срок из левой таблицы (в рассмотренном примере левой таблицей является «Сотрудники», а правой «Отделы») истинным условием соединения будут являться одна или несколько срок из правой таблицы, то строки умножат друг друга (повторятся). В нашем примере так произошло для отдела с 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

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

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

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

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

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

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

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

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

FULL JOIN

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

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

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

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

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

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

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

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

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

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

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

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

Хочу обратить внимание на то, что любое сравнение с неизвестным значением никогда не будет истинным (даже 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 Вам помогли, то поддержите, пожалуйста, проект, чтобы я мог развивать его дальше.

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

SQL оператор JOINS — Oracle PL/SQL •MySQL •MariaDB •SQL Server •SQLite

В этом учебном материале вы узнаете, как использовать SQL JOINS с синтаксисом и примерами.

Описание

SQL JOINS используются для извлечения данных из нескольких таблиц. SQL JOIN выполняется всякий раз, когда две или более таблицы перечислены в операторе SQL.

Существует 4 различных типа соединений SQL:

Итак, давайте обсудим синтаксис SQL JOIN, рассмотрим наглядные иллюстрации SQL JOINS и рассмотрим несколько примеров.

SQL INNER JOIN (простое соединение)

Скорее всего, вы уже писали SQL запрос, который использует SQL INNER JOIN. Это наиболее распространенный тип соединения SQL. INNER JOIN возвращает все строки из нескольких таблиц, где выполняется условие соединения.

Синтаксис

Синтаксис INNER JOIN в SQL:

SELECT columns
FROM table1
INNER JOIN table2
ON table1.column = table2.column;

Рисунок.

На этом рисунке SQL INNER JOIN возвращает затененную область:

SQL INNER JOIN будет возвращать записи, где пересекаются table1 и table2.

Пример

Давайте рассмотрим пример использования INNER JOIN в запросе.

В этом примере у нас есть таблица customer и следующими данными:

И таблица orders со следующими данными:

Выполним следующий SQL оператор:

SELECT customers.customer_id, orders.order_id, orders.order_date FROM customers INNER JOIN orders ON customers.customer_id = orders.customer_id ORDER BY customers.customer_id;

Будет выбрано 4 записи. Вот результаты, которые вы должны получить:

В этом примере будут возвращены все строки из таблиц customers и orders, в которых совпадают значения поля customer_id в обоих таблицах.

Строки, где значение customer_id равен 6000 и 9000 в таблице customers, будут опущены, поскольку они не существуют в обеих таблицах. Строка, в которой значение order_id равно 5 из таблицы orders, будет опущена, поскольку customer_id со значением NULL не существует в таблице customers.

SQL LEFT OUTER JOIN

Другой тип соединения называется LEFT OUTER JOIN. Этот тип соединения возвращает все строки из таблиц с левосторонним соединением, указанным в условии ON, и только те строки из другой таблицы, где объединяемые поля равны (выполняется условие соединения).

Синтаксис

Синтаксис для LEFT OUTER JOIN в SQL:

SELECT columns
FROM table1
LEFT [OUTER] JOIN table2
ON table1.column = table2.column;

В некоторых базах данных ключевое слово OUTER опущено и записывается просто как LEFT JOIN.

Рисунок

На этом рисунке SQL LEFT OUTER JOIN возвращает затененную область:

SQL LEFT OUTER JOIN возвращает все записи из table1 и только те записи из table2, которые пересекаются с table1.

Пример

Теперь давайте рассмотрим пример, который показывает, как использовать LEFT OUTER JOIN в операторе SELECT.

Используя ту же таблицу customers, что и в предыдущем примере:

И таблицу orders со следующими данными:

Введите следующий SQL оператор:

SELECT customers.customer_id, orders.order_id, orders.order_date FROM customers LEFT OUTER JOIN orders ON customers.customer_id = orders.customer_id ORDER BY customers.customer_id;

Будет выбрано 6 записей. Вот результаты, которые вы получите:

Этот пример LEFT OUTER JOIN вернул бы все строки из таблицы customers и только те строки из таблицы orders, в которых объединенные поля равны.

Если значение customer_id в таблице customers не существует в таблице orders, все поля таблицы orders будут отображаться как NULL в наборе результатов. Как вы можете видеть, строки, где customer_id равен 6000 и 9000, будут включены в LEFT OUTER JOIN, но поля order_id и order_date отображают NULL.

SQL RIGHT OUTER JOIN JOIN

Другой тип соединения называется SQL RIGHT OUTER JOIN. Этот тип соединения возвращает все строки из таблиц с правосторонним соединением, указанным в условии ON, и только те строки из другой таблицы, где объединяемые поля равны (выполняется условие соединения).

Синтаксис

Синтаксис для RIGHT OUTER JOIN в SQL:

SELECT columns
FROM table1
RIGHT [OUTER] JOIN table2
ON table1.column = table2.column;

В некоторых базах данных ключевое слово OUTER опущено и записывается просто как RIGHT JOIN.

Рисунок

На этом рисунке SQL RIGHT OUTER JOIN возвращает затененную область:

SQL RIGHT OUTER JOIN возвращает все записи из table2 и только те записи из table1, которые пересекаются с table2.

Пример

Теперь давайте рассмотрим пример, который показывает, как использовать RIGHT OUTER JOIN в операторе SELECT.

И таблицу orders со следующими данными:

Введите следующий SQL оператор:

SELECT customers.customer_id, orders.order_id, orders.order_date FROM customers RIGHT OUTER JOIN orders ON customers.customer_id = orders.customer_id ORDER BY customers.customer_id;

Будет выбрано 5 записей. Вот результаты, которые вы должны получить:

Этот пример RIGHT OUTER JOIN вернул бы все строки из таблицы orders и только те строки из таблицы customers, где объединенные поля равны.

Если значение customer_id в таблице orders не существует в таблице customers, то все поля в таблице customers будут отображаться как NULL в наборе результатов. Как видите, строка, где order_id равен 5, будет включена в RIGHT OUTER JOIN, но в поле customer_id отображается NULL.

SQL FULL OUTER JOIN

Другой тип объединения называется SQL FULL OUTER JOIN. Этот тип объединения возвращает все строки из LEFT таблицы и RIGHT таблицы со значениями NULL в месте, где условие соединения не выполняется.

Синтаксис

Синтаксис для SQL FULL OUTER JOIN:

SELECT columns
FROM table1
FULL [OUTER] JOIN table2
ON table1.column = table2.column;

В некоторых базах данных ключевое слово OUTER опускается и записывается просто как FULL JOIN.

Рисунок

На этом рисунке SQL FULL OUTER JOIN возвращает затененную область:

SQL FULL OUTER JOIN возвращает все записи из таблиц table1 и table2.

Пример

Давайте рассмотрим пример, который показывает, как использовать FULL OUTER JOIN в операторе SELECT.

Используя ту же таблицу customers, что и в предыдущем примере:

И таблицу orders со следующими данными:

Введите следующий SQL оператор:
SELECT customers.customer_id,
orders.order_id,
orders.order_date
FROM customers
FULL OUTER JOIN orders
ON customers.customer_id = orders.customer_id
ORDER BY customers.customer_id;

Будет выбрано 7 записей. Вот результаты, которые вы получите:

Это пример FULL OUTER JOIN будет возвращать все строки из таблицы orders и все строки из таблицы customers. Всякий раз, когда условие соединения не выполняется, значение NULL будет распространяться на эти поля в наборе результатов. Это означает, что если значение customer_id в таблице customers не существует в таблице orders, то все поля в таблице orders будут отображаться в наборе результатов как NULL Кроме того, если значение customer_id в таблице orders не существует в таблице customers, то все поля в таблице customers будут отображаться в наборе результатов как NULL.

Как видите, строки, где customer_id равен 6000 и 9000, будут включены, но поля order_id и order_date для этих записей содержат значение NULL. Строка, где order_id равен 5, также будет включена, но поле customer_id для этой записи имеет значение NULL.

Запросы sql inner join на объединение данных из разных таблиц

На уроке будут рассмотрены запросы SQL INNER JOIN на объединение таблиц. Будут разобраны конкретные примеры запросов

Выборка из нескольких таблиц (неявная операция соединения)

В sql выборка из нескольких таблиц или неявная операция соединения допускается в предложении FROM, но при этом перечисление таблиц, как правило, сопровождается условием соединения записей из разных таблиц.

Рассмотрим пример неявной операции соединения:

✍ Решение: 

1
2
3
4
5

SELECT DISTINCT группы.`Преподаватель` , 
   список.`Учебная группа` , список.`курс` 
FROM группы, список
WHERE группы.`Учебная группа` = список.`Учебная группа` 
AND курс <3

SELECT DISTINCT группы.`Преподаватель` , список.`Учебная группа` , список.`курс` FROM группы, список WHERE группы.`Учебная группа` = список.`Учебная группа` AND курс <3

✍ Решение: 

1
2
3
4

SELECT DISTINCT pc.Номер, Производитель
FROM  pc, product
WHERE pc.Номер = product.Номер
AND  Цена <30000

SELECT DISTINCT pc.Номер, Производитель FROM pc, product WHERE pc.Номер = product.Номер AND Цена <30000

Иногда в предложении FROM требуется указать одну и ту же таблицу несколько раз. В таком случае для таблицы потребуется псевдоним. Рассмотрим пример:

✍ Решение: 

1
2
3
4
5

SELECT DISTINCT A.`Курс` AS номер_курса1, B.`Курс` AS номер_курса2
FROM список AS A, список AS B
WHERE A.`Год рождения` = B.`Год рождения` 
AND A.Курс < B.Курс
LIMIT 0 , 30

SELECT DISTINCT A.`Курс` AS номер_курса1, B.`Курс` AS номер_курса2 FROM список AS A, список AS B WHERE A.`Год рождения` = B.`Год рождения` AND A.Курс < B.Курс LIMIT 0 , 30

Результат:

Здесь условие A.Курс используется для того, чтобы не выводились одинаковые пары, отличающиеся только перестановкой курса.
В общем случае можно использовать условие A.Курс B.Курс!

✍ Решение: 

1
2
3
4

SELECT DISTINCT A.Номер AS модель1, B.Номер AS модель2
FROM pc AS A, pc AS B
WHERE A.Цена = B.Цена
  AND A.Номер < B.Номер

SELECT DISTINCT A.Номер AS модель1, B.Номер AS модель2 FROM pc AS A, pc AS B WHERE A.Цена = B.Цена AND A.Номер < B.Номер

Здесь условие A.Номер используется для того, чтобы не выводились одинаковые пары, отличающиеся только перестановкой номера:


Sql tables 2. Вывести номера учителей (tid), которые ведут уроки по одинаковым курсам (таблица lessons)

Результат:

Запросы sql INNER JOIN

В предложении FROM может использоваться явная операция соединения двух и более таблиц.

Разберем пример. Имеем две таблицы: teachers (учителя) и lessons (уроки):

Пример: Выбрать имена учителей и проведенные уроки по курсам, которые они ведут

✍ Решение: 

SELECT t.name,t.code,l.course 
FROM teachers t 
INNER JOIN lessons l ON t.id=l.tid

SELECT t.name,t.code,l.course FROM teachers t INNER JOIN lessons l ON t.id=l.tid

Результат:

В запросе буквы l и t являются псевдонимами таблиц lessons (l) и teachers (t).

Inner Join — это внутреннее объединение (JOIN — с англ. «объединение», ключевое слово INNER можно опустить).

При внутреннем объединении выбираются только совпадающие данные из объединяемых таблиц.

Важно: Inner Join — выбираются значения только в случае присутствия в обеих таблицах

Важно: Соединение таблиц может быть либо внутренним (INNER), либо одним из внешних (OUTER). Служебное слово INNER можно опускать, тогда при использовании просто слова JOIN имеется в виду внутреннее соединение (INNER)

Запросы sql OUTER JOIN

При использовании внутреннего объединения inner join выбираются только совпадающие данные из объединяемых таблиц. Для того чтобы получить данные, которые подходят по условию частично, необходимо использовать внешнее объединение.

OUTER JOIN — внешнее объединение, которое возвращает данные из обеих таблиц (совпадающие по условию объединения), ПЛЮС выборка дополнится оставшимися данными из внешней таблицы, которые по условию не подходят, заполнив недостающие данные значением NULL.

Существует два типа внешнего объединения — LEFT OUTER JOIN («внешней» таблицей будет находящаяся слева) и RIGHT OUTER JOIN («внешней» таблицей будет находящаяся справа).

Рисунок относится к объединению типа Left Outer Join:

Важно: Ключевое слово OUTER можно опустить. Запись LEFT JOIN эквивалентна записи LEFT OUTER JOIN.

Пример БД Институт: Выбрать имена всех учителей и курсы, которые они ведут. Если учитель не прикреплен к курсу, его фамилию все равно необходимо вывести

✍ Решение: 

SELECT t.name, t.code, l.course
FROM teachers t
LEFT OUTER JOIN lessons l ON t.id = l.tid

SELECT t.name, t.code, l.course FROM teachers t LEFT OUTER JOIN lessons l ON t.id = l.tid

Результат:

Важно: Таким образом, соединение LEFT JOIN означает, что помимо строк, для которых выполняется условие, в результирующий набор попадут все остальные строки из левой таблицы. При этом отсутствующие значения из правой таблицы будут заполнены NULL-значениями.

С тем же примером (выбрать имена учителей и курсы, которые они ведут) фильтрация по RIGHT OUTER JOIN вернет полный список уроков по курсам (правая таблица) и сопоставленных учителей. Но так как нет таких уроков, которые бы не соответствовали определенным учителям, то выборка будет состоять только из двух строк:

SELECT t.name, t.code, l.course
FROM teachers t
RIGHT OUTER JOIN lessons l ON t.id = l.tid

SELECT t.name, t.code, l.course FROM teachers t RIGHT OUTER JOIN lessons l ON t.id = l.tid

Важно: Left Outer Join — после основной выборки, удовлетворяющей условиям, выбираются оставшиеся данные левой таблицы (внешней), которые по условию не подходят

Выбрать фамилии студентов и их оценки по Word. В случае отсутствия оценки, все равно выводить фамилию.

Sql left outer join 1. Вывести фамилии всех преподавателей, названия и длительность курсов, которые они ведут (name, title, length) из таблиц teachers и courses. Использовать внешнее объединение

В приведенных примерах можно вводить фильтры для более точной фильтрации:

Пример БД Институт: выводить только тех учителей, которые не проводили/не будут проводить уроков

✍ Решение: 

SELECT t.name, t.code, l.course
FROM teachers t
LEFT OUTER JOIN lessons l ON t.id = l.tid
WHERE l.tid IS NULL

SELECT t.name, t.code, l.course FROM teachers t LEFT OUTER JOIN lessons l ON t.id = l.tid WHERE l.tid IS NULL

Объединение с подзапросом

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

Синтаксис:

SELECT t1.*, t2.* FROM left_table t1 LEFT JOIN (SELECT * FROM right_table WHERE some_column = 1 LIMIT 1) t2 ON t1.id = t2.join_id

SELECT t1.*, t2.* from left_table t1 left join (select * from right_table where some_column = 1 limit 1) t2 ON t1.id = t2.join_id

или

SELECT t1.*, t2.* FROM left_table t1 INNER JOIN (SELECT * FROM right_table WHERE some_column = 1 LIMIT 1) t2 ON t1.id = t2.join_id

SELECT t1.*, t2.* from left_table t1 inner join (select * from right_table where some_column = 1 limit 1) t2 ON t1.id = t2.join_id

Пример БД Институт: Выбрать данные по учителям и проведенным ими урокам, только для уроков по курсу «php»

✍ Решение: 

SELECT t1.*, t2.* FROM teachers t1 
INNER JOIN (SELECT * FROM lessons WHERE course = "php" LIMIT 1) 
t2 ON t1.id = t2.tid

SELECT t1.*, t2.* from teachers t1 inner join (select * from lessons where course = «php» limit 1) t2 ON t1.id = t2.tid

Результат:

Разберем еще один пример:

✍ Решение: 

1
2
3
4
5
6
7

SELECT t1.производитель, t1.Тип, t2 . * 
FROM pc t2
INNER JOIN (
SELECT * 
FROM product
WHERE Тип =  "Компьютер"
) t1 ON t2.Номер = t1.Номер

SELECT t1.производитель, t1.Тип, t2 . * FROM pc t2 INNER JOIN ( SELECT * FROM product WHERE Тип = «Компьютер» ) t1 ON t2.Номер = t1.Номер

Так как в таблице product находятся данные не только по компьютерам, то мы использовали подзапрос, при этом сохранив внутреннее соединение таблиц.
Результат:

Пошаговое руководство по SQL Inner Join

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

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

Прежде чем мы начнем с SQL Inner Join, я хотел бы вызвать здесь SQL Join. Присоединение — это широко используемое предложение в SQL Server, по сути, для объединения и извлечения данных из двух или более таблиц. В реальной реляционной базе данных данные структурированы в виде большого количества таблиц, и поэтому существует постоянная потребность в объединении этих нескольких таблиц на основе логических отношений между ними. В SQL Server существует четыре основных типа объединений — внутреннее, внешнее (левое, правое, полное), самостоятельное и перекрестное соединение. Чтобы получить краткий обзор всех этих объединений, я бы порекомендовал пройти по этой ссылке, обзору типов соединений SQL и руководству.

Эта статья посвящена внутреннему соединению в SQL Server, так что давайте перейдем к ней.

Определение внутреннего соединения SQL

Предложение Inner Join в SQL Server создает новую таблицу (не физическую) путем объединения строк, имеющих совпадающие значения в двух или более таблицах. Это соединение основано на логической связи (или общем поле) между таблицами и используется для извлечения данных, которые появляются в обеих таблицах.

Предположим, у нас есть две таблицы, Таблица A и Таблица B, которые мы хотели бы объединить с помощью SQL Inner Join.Результатом этого соединения будет новый набор результатов, который возвращает совпадающие строки в обеих этих таблицах. В части пересечения, выделенной черным цветом ниже, показаны данные, полученные с помощью внутреннего соединения в SQL Server.

Синтаксис внутреннего соединения SQL Server

Ниже приведен базовый синтаксис Inner Join.

SELECT Column_list
FROM TABLE1
INNER JOIN TABLE2
ON Table1.ColName = Table2.ColName

Синтаксис внутреннего соединения в основном сравнивает строки таблицы 1 с таблицей 2, чтобы проверить, совпадает ли что-либо, на основе условия, указанного в предложении ON.Когда условие соединения выполнено, оно возвращает совпадающие строки в обеих таблицах с выбранными столбцами в предложении SELECT.

Предложение SQL Inner Join аналогично предложению Join и работает таким же образом, если мы не указываем тип (INNER) при использовании предложения Join. Короче говоря, Inner Join — это ключевое слово по умолчанию для Join, и оба могут использоваться взаимозаменяемо.

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

SQL Inner Join в действии

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

Вот так выглядят данные в таблице PizzaCompany:

Давайте сейчас создадим и заполним таблицу Foods. CompanyID в этой таблице — это внешний ключ, который ссылается на первичный ключ таблицы PizzaCompany, созданной выше.

В следующей таблице показаны данные из таблицы «Продукты питания». В этой таблице хранится такая информация, как количество проданных единиц продукта питания, а также точка доставки пиццы (CompanyId), которая ее доставляет.

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

Ниже приведен набор результатов указанного выше запроса SQL Inner Join. Для каждой строки в таблице PizzaCompany функция Inner Join сравнивает и находит совпадающие строки в таблице Foods и возвращает все совпадающие строки, как показано ниже. И если вы заметили, CompanyId = 5 исключается из результата запроса, так как он не соответствует в таблице Foods.

С помощью приведенного выше набора результатов мы можем различить товары, а также количество товаров, доставленных пиццериями в разных городах. Например, Dominos доставил в Лос-Анджелес 7 хлебных палочек и 11 средних пицц.

Внутреннее соединение SQL трех таблиц

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

Я собираюсь быстро создать таблицу WaterPark и загрузить в нее произвольные данные, как показано ниже.

И ниже вывод этой таблицы.

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

Теперь мы собираемся включить эту третью таблицу в предложение SQL Inner Join, чтобы увидеть, как это повлияет на набор результатов. Согласно данным в таблице «Аквапарк», три аквапарка передают еду на аутсорсинг всем пиццериям, кроме пиццерии (Id = 6) и Chuck e Cheese (Id = 7).Выполните приведенный ниже код, чтобы увидеть, как распределяется еда в аквапарках у точек Pizza.

На основе CompanyId SQL Inner Join сопоставляет строки в обеих таблицах, PizzaCompany (Таблица 1) и Foods (Таблица 2), а затем ищет совпадение в WaterPark (Таблица 3), чтобы вернуть строки.Как показано ниже, с добавлением внутреннего соединения в WaterPark, CompanyId (6,7 (кроме 5)) также исключается из окончательного набора результатов, поскольку условие w.CompanyId = pz.CompanyId не выполняется для идентификаторов (6, 7). Вот как внутреннее соединение SQL помогает возвращать определенные строки данных из нескольких таблиц.

Давайте углубимся в SQL Inner Join, добавив еще несколько предложений T-SQL.

Использование WHERE с внутренним соединением

Мы можем фильтровать записи на основе указанного условия, когда внутреннее соединение SQL используется с предложением WHERE.Предположим, мы хотели бы получить строки, в которых проданных единиц было больше 6.

В следующем запросе предложение WHERE добавляется для извлечения результатов со значением более 6 для проданных единиц.

Выполните приведенный выше код в SSMS, чтобы увидеть результат ниже. Этот запрос возвращает четыре таких записи.

Использование Group By с внутренним соединением

SQL Inner Join позволяет нам использовать предложение Group by вместе с агрегатными функциями для группировки набора результатов по одному или нескольким столбцам. Группировка по обычно работает с внутренним объединением по окончательному результату, возвращаемому после объединения двух или более таблиц. Если вы не знакомы с предложением Group by в SQL, я бы посоветовал пройти через это, чтобы быстро понять эту концепцию.Ниже приведен код, в котором используется предложение Group By с внутренним соединением.

Здесь мы собираемся получить общее количество товаров, проданных каждой пиццерией, присутствующей в городе.Как видно ниже, агрегированный результат в столбце «totalquantitysold» равен 18 (7 + 11) и 9 (6 + 3) для Лос-Анджелеса и Сан-Диего соответственно.

Краткое описание Equi и Theta Join

Прежде чем мы закончим эту статью, давайте быстро рассмотрим термины, которые разработчик SQL может время от времени слышать — Equi и Theta Join.

Equi Join

Как следует из названия, equi join содержит оператор равенства ‘=’ либо в предложении Join, либо в условии WHERE.SQL Inner, Left, Right — все равнозначные соединения, когда оператор «=» используется в качестве оператора сравнения. Обычно, когда упоминается внутреннее соединение SQL, оно рассматривается как внутреннее равное соединение, только в необычной ситуации оператор равенства не используется.

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

Theta Join (Неравномерное соединение)

Неравномерное соединение в основном противоположно равнозначному соединению и используется, когда мы соединяемся с условием, отличным от оператора «=». Этот тип редко используется на практике. Ниже приведен пример, в котором используется тета-соединение с оператором неравенства (<) для оценки прибыли путем оценки себестоимости и продажных цен в двух таблицах.

Заключение

Я надеюсь, что эта статья о «Внутреннем соединении SQL» обеспечивает понятный подход к одному из важных и часто используемых предложений — «Внутреннее соединение» в SQL Server для объединения нескольких таблиц. Если у вас есть какие-либо вопросы, не стесняйтесь задавать их в разделе комментариев ниже.

Чтобы продолжить изучение SQL-соединений, вы можете обратиться к сообщениям ниже:

Она имеет большой опыт в разработке решений для данных и аналитики, а также в обеспечении их стабильности, надежности и производительности. Она также сертифицирована по SQL Server и прошла такие сертификаты, как 70-463: Внедрение хранилищ данных с Microsoft SQL Server.

Посмотреть все сообщения от Gauri Mahajan

Внутреннее объединение SQL Server на практических примерах

Резюме : в этом руководстве вы узнаете, как использовать предложение SQL Server INNER JOIN для запроса данных из нескольких таблиц.

Введение в SQL Server

Внутреннее соединение — одно из наиболее часто используемых соединений в SQL Server. Предложение внутреннего соединения позволяет запрашивать данные из двух или более связанных таблиц.

См. Следующие продукты Категории и Таблицы :

Следующий оператор извлекает информацию о продукте из таблицы production.products :

 
  SELECT
    наименование товара,
    список цен,
    category_id
ИЗ
    производство.продукты
СОРТИРОВАТЬ ПО
    product_name DESC;
  
  Язык кода: SQL (язык структурированных запросов) (sql)  

Запрос вернул только список идентификационных номеров категорий, но не имена категорий. Чтобы включить имена категорий в набор результатов, используйте предложение INNER JOIN следующим образом:

 
  SELECT
    наименование товара,
    category_name,
    список цен
ИЗ
    production.products p
ВНУТРЕННЕЕ СОЕДИНЕНИЕ production.categories c
    ВКЛ c.category_id = p.category_id
СОРТИРОВАТЬ ПО
    product_name DESC;
  
  Язык кода: SQL (язык структурированных запросов) (sql)  

В этом запросе:

c и p являются псевдонимами таблиц production.categories и production.products таблиц . Таким образом, когда вы ссылаетесь на столбец в этой таблице, вы можете использовать псевдоним . имя_столбца вместо использования имя_таблицы.имя_столбца . Например, в запросе используется c.category_id вместо production.categories.category_id . Следовательно, это избавляет вас от набора текста.

Для каждой строки в таблице production.products предложение внутреннего соединения сопоставляет его с каждой строкой в ​​таблице product.categories на основе значений столбца category_id :

• Если в обеих строках есть то же значение в столбце category_id , внутреннее соединение образует новую строку, столбцы которой взяты из строк продукции .категории и production.products таблиц в соответствии со столбцами в списке выбора и включают эту новую строку в набор результатов.
• Если строка в таблице production.products не соответствует строке из таблицы production.categories , предложение внутреннего соединения просто вставляет эти строки и не включает их в набор результатов.

SQL Server

Ниже показан синтаксис предложения SQL Server INNER JOIN :

 
  SELECT
    select_list
ИЗ
    Т1
ВНУТРЕННЕЕ СОЕДИНЕНИЕ T2 ON join_predicate;
  
  Язык кода: SQL (язык структурированных запросов) (sql)  

В этом синтаксисе запрос извлекает данные из таблиц T1 и T2:

• Сначала укажите основную таблицу (T1) в FROM предложение
• Во-вторых, укажите вторую таблицу в предложении INNER JOIN (T2) и предикат соединения.В набор результатов включаются только строки, которые приводят к тому, что предикат соединения оценивается как ИСТИНА .

Предложение INNER JOIN сравнивает каждую строку таблицы T1 со строками таблицы T2, чтобы найти все пары строк, которые удовлетворяют предикату соединения. Если предикат соединения оценивается как ИСТИНА , значения столбцов совпадающих строк T1 и T2 объединяются в новую строку и включаются в набор результатов.

В следующей таблице показано внутреннее соединение двух таблиц T1 (1,2,3) и T2 (A, B, C).Результат включает строки: (2, A) и (3, B), поскольку они имеют одинаковые шаблоны.

Обратите внимание, что ключевое слово INNER является необязательным, вы можете пропустить его, как показано в следующем запросе:

 
  SELECT
    select_list
ИЗ
    Т1
ПРИСОЕДИНЯЙТЕСЬ к T2 ON join_predicate;
  
  Язык кода: SQL (язык структурированных запросов) (sql)  

Дополнительные примеры внутреннего соединения SQL Server

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

В следующем операторе используются два INNER JOIN предложений для запроса данных из трех таблиц:

 
  SELECT
    наименование товара,
    category_name,
    название бренда,
    список цен
ИЗ
    производство.продукты p
ВНУТРЕННЕЕ СОЕДИНЕНИЕ production.categories c ON c.category_id = p.category_id
ВНУТРЕННЕЕ СОЕДИНЕНИЕ production.brands b ON b.brand_id = p.brand_id
СОРТИРОВАТЬ ПО
    product_name DESC;
  
  Язык кода: SQL (язык структурированных запросов) (sql)  

В этом руководстве вы узнали, как использовать предложение SQL Server INNER JOIN для запроса данных из нескольких таблиц.

ВНУТРЕННЕЕ СОЕДИНЕНИЕ SQL - w3resource

 ВЫБРАТЬ *
ИЗ table1 ВНУТРЕННЕЕ СОЕДИНЕНИЕ table2
ON table1.column_name = table2.column_name;
 

 ВЫБРАТЬ *
ИЗ table1
ПРИСОЕДИНЯЙТЕСЬ к таблице2
ON table1.column_name = table2.column_name;
 

  ВЫБЕРИТЕ продукты.item_name, foods.item_unit,
company.com название_компании, company.company_city
Из продуктов
Компания INNER JOIN
НА food.company_id = company.company_id;
  

 ITEM_NAME ITEM_ COMPANY_NAME COMPANY_CITY
------------------------- ----- -------------------- ----- --------------
Chex Mix Pcs Akas Foods Дели
Cheez-It Pcs Jack Hill Ltd Лондон
BN Biscuit Pcs Jack Hill Ltd Лондон
Mighty Munch Pcs Foodies.Лондон
Pot Rice Pcs Jack Hill Ltd Лондон
Jaffa Cakes Pcs Заказать Весь Бостон
 

  ВЫБЕРИТЕ продукты.item_name, foods.item_unit,
company.com название_компании, company.company_city
Из продуктов
ПРИСОЕДИНЯЙТЕСЬ к компании
НА food.company_id = company.company_id;
  

 ITEM_NAME ITEM_ COMPANY_NAME COMPANY_CITY
------------------------- ----- -------------------- ----- -------------
Chex Mix Pcs Akas Foods Дели
Cheez-It Pcs Jack Hill Ltd Лондон
BN Biscuit Pcs Jack Hill Ltd Лондон
Mighty Munch Pcs Foodies.Лондон
Pot Rice Pcs Jack Hill Ltd Лондон
Jaffa Cakes Pcs Заказать Весь Бостон
 

  ВЫБРАТЬ *
Из продуктов
ПРИСОЕДИНЯЙТЕСЬ к компании
НА продукты.company_id = company.company_id;
  

 ITEM_ID ITEM_NAME ITEM_ COMPAN COMPAN COMPANY_NAME COMPANY_CITY
-------- ------------------------- ----- ------ ------ ------------------------- -------------
1 Chex Mix шт 16 16 Akas Foods Delhi
6 шт. Cheez-It 15 15 Jack Hill Ltd Лондон
2 BN Biscuit Pcs 15 15 Jack Hill Ltd Лондон
3 Mighty Munch Pcs 17 17 Foodies.Лондон
Рис 4 шт. 15 15 Jack Hill Ltd Лондон
5 Jaffa Cakes шт 18 18 Заказать весь Бостон
 

  ВЫБРАТЬ * ИЗ
Таблица1 JOIN Table2
ВКЛ Таблица1.имя_столбца = Таблица2.имя_столбца;
  

  ВЫБРАТЬ *
ИЗ Table1 ВНУТРЕННЕЕ СОЕДИНЕНИЕ Table2
ON Table1.column_name = Table2.column_name;  

  ВЫБРАТЬ *
ИЗ tableX
ВНУТРЕННЕЕ СОЕДИНЕНИЕ tableY на tableX.X = tableY.Y;  

  ВЫБРАТЬ tableX. *, TableY. *
ОТ tableX, tableY
ГДЕ tableX.X = tableY.Y;  

  ВЫБРАТЬ tableX.*, таблицаY. *
ОТ tableX, tableY
ГДЕ tableX.X = tableY.Y (+)  

  ВЫБРАТЬ *
ИЗ tableX
ЛЕВОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ tableY ON tableX.X = tableY.Y  

  ВЫБРАТЬ * ИЗ tableX
ПРАВО ВНЕШНЕЕ СОЕДИНЕНИЕ tableY ON tableX.X = таблицаY.Y  

  ВЫБРАТЬ *
ИЗ tableX
ПОЛНОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ tableY ON tableX.X = tableY.Y  

 
  SELECT
    столбец1, столбец2
ИЗ
    Таблица 1
ВНУТРЕННЕЕ СОЕДИНЕНИЕ table_2 ON условие_соединения;  
 

 
  SELECT
    productID, productName, categoryName
ИЗ
    продукты
ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    категории ПО категории.categoryID = products.categoryID;  
 

 
  category.categoryID = products.categoryID  
 

 
  SELECT
    идантификационный номер продукта,
    наименование товара,
    categoryName,
    companyName AS поставщик
ИЗ
    продукты
ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    категории ПО категории.categoryID = products.categoryID
ВНУТРЕННЕЕ СОЕДИНЕНИЕ
    Поставщики ON suppliers.supplierID = products.supplierID  
  Язык кода: PHP (php)  

 
  ВЫБРАТЬ
    столбец1, столбец2
ИЗ
    Таблица 1,
    Таблица 2
КУДА
    join_condition;  
 

 
  SELECT
    productID, productName, categoryName
ИЗ
    продукты,
    категории
КУДА
    products.categoryID = category.categoryID;  
 

  ВЫБРАТЬ игроков. *,
       команды. *
  ОТ игроков benn.college_football_players
  ПРИСОЕДИНЯЙТЕСЬ к командам benn.college_football_teams
    ON team.school_name = player.school_name
  

  ВЫБРАТЬ player.school_name AS player_school_name,
       team.school_name AS team_school_name
  ОТ игроков benn.college_football_players
  ПРИСОЕДИНЯЙТЕСЬ к командам benn.college_football_teams
    ON team.school_name = player.school_name
  

 ИСПОЛЬЗОВАНИЕ [AdventureWorks2019]
ИДТИ
ВЫБРАТЬ
     д. [BusinessEntityID]
     ,п.[Имя]
     , стр. [MiddleName]
     , стр. [Фамилия]
     , д. [JobTitle]
     , д. [Название] AS [Отдел]
     , d. [GroupName]
     , edh. [Дата начала]
ОТ [HumanResources]. [Сотрудник] e
     INNER JOIN [Человек]. [Человек] p
     НА стр. [BusinessEntityID] = e. [BusinessEntityID]
     ВНУТРЕННЕЕ СОЕДИНЕНИЕ [HumanResources]. [EmployeeDepartmentHistory] edh
     НА e. [BusinessEntityID] = edh. [BusinessEntityID]
     INNER JOIN [HumanResources]. [Department] d
     НА edh.[DepartmentID] = d. [DepartmentID]
ГДЕ edh.EndDate ЕСТЬ NULL
ИДТИ
 

 ВЫБРАТЬ столбцы
ИЗ table1
INNER JOIN table2
НА table1.column = table2.column; 

 ВЫБРАТЬ клиентов.customer_id, orders.order_id, orders.order_date
ОТ клиентов
INNER JOIN заказы
ВКЛ. Customers.customer_id = orders.customer_id
ЗАКАЗАТЬ ПО customers.customer_id; 

 ВЫБРАТЬ клиентов.customer_id, orders.order_id, orders.order_date
ОТ клиентов, заказы
ГДЕ customers.customer_id = orders.customer_id
ЗАКАЗАТЬ ПО customers.customer_id; 

 ВЫБРАТЬ столбцы
ИЗ table1
LEFT [OUTER] JOIN table2
НА table1.столбец = table2.column; 

 ВЫБРАТЬ клиентов.customer_id, orders.order_id, orders.order_date
ОТ клиентов
LEFT OUTER JOIN заказы
ВКЛ. Customers.customer_id = orders.customer_id
ЗАКАЗАТЬ ПО customers.customer_id; 

 ВЫБРАТЬ столбцы
ИЗ table1
RIGHT [OUTER] JOIN table2
НА table1.column = table2.column; 

 ВЫБРАТЬ клиентов.customer_id, orders.order_id, orders.order_date
ОТ клиентов
RIGHT OUTER JOIN заказы
ВКЛ. Customers.customer_id = orders.customer_id
ЗАКАЗАТЬ ПО customers.customer_id; 

 ВЫБРАТЬ столбцы
ИЗ table1
FULL [OUTER] JOIN table2
НА table1.column = table2.column; 

 ВЫБРАТЬ клиентов.customer_id, orders.order_id, orders.order_date
ОТ клиентов
ЗАКАЗЫ FULL OUTER JOIN
ВКЛ. Customers.customer_id = orders.customer_id
ЗАКАЗАТЬ ПО customers.customer_id;