Sql join примеры: Команда UNION — слияние таблиц
Содержание
Команда UNION — слияние таблиц
Команда 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:
id айди | name название |
---|---|
1 | Беларусь |
2 | Россия |
3 | Украина |
Таблица cities:
id айди | name название | country_id айди страны |
---|---|---|
1 | Минск | 1 |
2 | Минск | 1 |
3 | Москва | 2 |
4 | Киев | 3 |
Пример
В данном примере объединяются записи из двух таблиц:
SELECT id, name FROM countries UNION ALL SELECT id, name FROM cities
SQL запрос выберет следующие строки:
id айди | name название |
---|---|
1 | Беларусь |
2 | Россия |
3 | Украина |
1 | Минск |
2 | Минск |
3 | Москва |
4 | Киев |
Пример
В данном примере отсутствует ключевое слово ALL, однако дубли не будут удалены,
так как дублями считается полное совпадение строк:
SELECT id, name FROM countries UNION SELECT id, name FROM cities
SQL запрос выберет следующие строки:
id айди | name название |
---|---|
1 | Беларусь |
2 | Россия |
3 | Украина |
1 | Минск |
2 | Минск |
3 | Москва |
4 | Киев |
Пример
А вот теперь дубли будут удалены (из двух Минсков останется один),
так как будет иметь место полное совпадение строк (потому что поле осталось одно,
но это не обязательно):
SELECT name FROM countries UNION SELECT name FROM cities
SQL запрос выберет следующие строки:
name название |
---|
Беларусь |
Россия |
Украина |
Минск |
Москва |
Киев |
Пример
А теперь добавим слово ALL — и дубли не будут удалятся:
SELECT name FROM countries UNION ALL SELECT name FROM cities
SQL запрос выберет следующие строки:
name название |
---|
Беларусь |
Россия |
Украина |
Минск |
Минск |
Москва |
Киев |
Пример
В данном примере демонстрируется работа условий
WHERE в комбинации с UNION:
SELECT id, name FROM countries WHERE id>=2
UNION SELECT id, name FROM cities WHERE id
SQL запрос выберет следующие строки:
id айди | name имя |
---|---|
2 | Россия |
3 | Украина |
1 | Минск |
2 | Минск |
Пример
Имена колонок берутся из первой таблицы (то есть имена колонок таблиц,
подключенных через UNION нигде себя не проявят):
SELECT id as country_id, name as country_name FROM countries
UNION SELECT id, name FROM cities
SQL запрос выберет следующие строки:
country_id айди | country_name имя | |
---|---|---|
1 | Беларусь | |
2 | Россия | |
3 | Украина | |
1 | Минск | 1 |
2 | Минск | 1 |
3 | Москва | 2 |
4 | Киев | 3 |
Пример
Такой запрос выдаст ошибку, так как в таблицах не совпадает количество колонок:
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 запрос выберет следующие строки:
id айди | name имя | country_id айди страны |
---|---|---|
1 | Беларусь | 0 |
2 | Россия | 0 |
3 | Украина | 0 |
1 | Минск | 1 |
2 | Минск | 1 |
3 | Москва | 2 |
4 | Киев | 3 |
Sql inner join 3 таблицы примеры
Главное меню » Базы данных » Учебное пособие по SQL » Как присоединить три таблицы в SQL запросе – Пример в MySQL
В случае присоединения трех таблиц, первая относится к таблице 2, а затем таблица 2 относится к таблице 3. Если вы посмотрите внимательно, то вы обнаружите , что таблица 2 представляет собой присоединенную таблицу, которая содержит первичный ключ из обеих таблиц 1 и 2. Как мы сказали, это может быть очень запутанным, чтобы понять объединение трех или более таблиц.
Мы обнаружили, что понимание отношение таблиц в качестве первичного ключа и внешнего ключа помогает облегчить задачу.
SQL Join также является очень популярной темой в SQL и там всегда были некоторые вопросы из соединений, как разница между INNER и OUTER JOIN, например SQL – запрос с JOIN Employee Department и разница между LEFT и RIGHT OUTER JOIN и т.д. Короче говоря это одна из самых важных тем в SQL как из опыта так и из точки зрения цели.
Единственный способ освоить SQL JOIN, это сделать как можно больше упражнений, насколько это возможно. Если бы вы могли решить большинство головоломок SQL из классической книги Джо Селко, SQL Puzzles and Answers, 2nd edition, вы были бы более уверены в работе с SQL JOIN, хоть это быть две, три или четыре таблицы.
Объединение трех таблиц, синтаксис в SQL
Вот общий синтаксис запроса SQL, чтобы присоединить три или более таблиц. Этот SQL-запрос должен работать во всех основных баз данных, например в базе данных MySQL, Oracle, Microsoft SQLServer, Sybase и PostgreSQL:
Мы сначала присоединим таблице 2 к таблице 1, которые создадут временную таблицу с комбинированными данными из table1 и table2, а затем присоединим к Table3. Эта формула может быть распространена на более чем 3 -х таблиц в N таблиц, Вам просто нужно убедиться, что SQL – запрос должен иметь N-1 join, чтобы присоединить N таблиц. Как для объединения двух таблиц мы требуем 1 join а для присоединения 3 таблиц нам нужно 2 join.
Вот хорошая схема, которая хорошо показывает, как применять различные типы присоединений, например как работают в SQL inner, left outer, right outer и cross joins:
SQL запрос по присоединению трех таблиц в MySQL
Для того, чтобы лучше понять присоединение 3 таблицы в SQL запросе, давайте рассмотрим пример. Рассмотрим популярный пример Employee и Department. В нашем случае мы использовали таблицу ссылок под названием Register, который связывает или имеет отношение Employee для Department. Первичный ключ таблицы Employee (emp_id) является внешним ключом в Register и аналогичным образом, первичный ключ таблицы Department (dept_id) является внешним ключом в таблице Register.
Для того , чтобы написать запрос SQL для печати имя сотрудника и название отдела мы должны присоединиться к трем таблицам. Первое присоединение Employee и Register и создают временную таблицу, с колонкой dept_id. Теперь второе присоединение таблицы Department к этой временной таблицы по колонке dept_id, чтобы получить желаемый результат. Вот полный SELECT, пример SQL – запроса, чтобы присоединиться к 3 таблицам, и она может быть расширена, чтобы присоединиться к более чем 3 или N таблицам.
Если вы хотите понять это лучше, попытайтесь объединить таблицы шаг за шагом. Таким образом, вместо того, чтобы присоединиться 3 таблицы за один раз, сначала соединить 2 таблицы и посмотреть, как будет выглядеть таблица результатов. Это все о том, как присоединить три таблицы в одном запросе SQL в реляционной базе данных. Кстати, в этом примере SQL JOIN, мы использовали ANSI SQL, и он будет работать в другой реляционной базы данных, а также, Oracle, SQL Server, Sybase, PostgreSQL и т.д. Дайте нам знать, если вы сталкивались с какой – либо проблемой во время объединения 3 таблицы запросом JOIN в любой другой базе данных.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
лабораторные работы и задачи по программированию и информатике, егэ по информатике
Выборка из нескольких таблиц (неявная операция соединения)
В sql выборка из нескольких таблиц или неявная операция соединения допускается в предложении FROM, но при этом перечисление таблиц, как правило, сопровождается условием соединения записей из разных таблиц.
Рассмотрим пример неявной операции соединения:
SELECT DISTINCT группы.`Преподаватель` , список.`Учебная группа` , список.`курс` FROM группы, список WHERE группы.`Учебная группа` = список.`Учебная группа` AND курс
SELECT DISTINCT pc.Номер, Производитель FROM pc, product WHERE pc.Номер = product.Номер AND Цена
SELECT DISTINCT A.`Курс` AS номер_курса1, B.`Курс` AS номер_курса2 FROM список AS A, список AS B WHERE A.`Год рождения` = B.`Год рождения` AND A.Курс A.Курс используется для того, чтобы не выводились одинаковые пары, отличающиеся только перестановкой курса.
В общем случае можно использовать условие A.Курс <> B.Курс !
SELECT DISTINCT A.Номер AS модель1, B.Номер AS модель2 FROM pc AS A, pc AS B WHERE A.Цена = B.Цена AND A.Номер A.Номер используется для того, чтобы не выводились одинаковые пары, отличающиеся только перестановкой номера:
Результат:
Запросы sql INNER JOIN
В предложении FROM может использоваться явная операция соединения двух и более таблиц.
Разберем пример. Имеем две таблицы: teachers (учителя) и lessons (уроки):
teachers | lessons |
SELECT t.name,t.code,l.course FROM teachers t INNER JOIN lessons l ON t. >
Результат:
В запросе буквы l и t являются псевдонимами таблиц lessons (l) и teachers (t).
Inner Join — это внутреннее объединение ( JOIN — с англ. «объединение», ключевое слово INNER можно опустить).
При внутреннем объединении выбираются только совпадающие данные из объединяемых таблиц.
Запросы sql OUTER JOIN
При использовании внутреннего объединения inner join выбираются только совпадающие данные из объединяемых таблиц. Для того чтобы получить данные, которые подходят по условию частично, необходимо использовать внешнее объединение.
OUTER JOIN — внешнее объединение, которое возвращает данные из обеих таблиц (совпадающие по условию объединения), ПЛЮС выборка дополнится оставшимися данными из внешней таблицы, которые по условию не подходят, заполнив недостающие данные значением NULL .
Существует два типа внешнего объединения — LEFT OUTER JOIN («внешней» таблицей будет находящаяся слева) и RIGHT OUTER JOIN («внешней» таблицей будет находящаяся справа).
Рисунок относится к объединению типа Left Outer Join:
SELECT t.name, t.code, l.course FROM teachers t LEFT OUTER JOIN lessons l ON t. >
Результат:
С тем же примером (выбрать имена учителей и курсы, которые они ведут) фильтрация по RIGHT OUTER JOIN вернет полный список уроков по курсам (правая таблица) и сопоставленных учителей. Но так как нет таких уроков, которые бы не соответствовали определенным учителям, то выборка будет состоять только из двух строк:
SELECT t.name, t.code, l.course FROM teachers t RIGHT OUTER JOIN lessons l ON t. >
Выбрать фамилии студентов и их оценки по Word. В случае отсутствия оценки, все равно выводить фамилию.
В приведенных примерах можно вводить фильтры для более точной фильтрации:
SELECT t.name, t.code, l.course FROM teachers t LEFT OUTER JOIN lessons l ON t. >
Объединение с подзапросом
При использовании объединения часто бывает необходимо, чтобы результирующая выборка содержала данные только по одной конкретной строке
SELECT t1.*, t2.* from left_table t1 left join (select * from right_table where some_column = 1 limit 1) t2 ON t1. >
SELECT t1.*, t2.* from left_table t1 inner join (select * from right_table where some_column = 1 limit 1) t2 ON t1. >
SELECT t1.*, t2.* from teachers t1 inner join (select * from lessons where course = «php» limit 1) t2 ON t1. >
Результат:
Разберем еще один пример:
SELECT t1.производитель, t1.Тип, t2 . * FROM pc t2 INNER JOIN ( SELECT * FROM product WHERE Тип = «Компьютер» ) t1 ON t2.Номер = t1.Номер
Так как в таблице product находятся данные не только по компьютерам, то мы использовали подзапрос, при этом сохранив внутреннее соединение таблиц.
Результат:
Здравствуйте.
SQL подробно я начал только недавно учить.
И тут запнулся, как вытянуть информацию из таблиц (более 2) ?
Например есть таблица:
1. Рецепт :
id | name | description | .
2. Компоненты рецепта:
id | recept_id | parent_id | .
recept_id -> id рецепта из 1 таблицы, parent_id -> id компонента из 3 таблицы
3. Компоненты
id | name | percent | .
4. Вкусы:
id | taste | recept_id
recept_id -> id рецепта из 1 таблицы
Нужно достать:
1. Всю информацию из рецепта,
2. Информацию о компоненте( который используется в данном рецепте )
2. Вкусы используемые в данном рецепте
Подскажите пожалуйста, как это будет выглядеть, с JOIN я пока не сильно дружу, знаю лишь как вытащить из 2 таблиц и не более, буду очень благодарен.
Всем спасибо 🙂
- Вопрос задан более трёх лет назад
- 1581 просмотр
я из мира MS SQL, поэтому возможны некоторые несоответствия:
вместо звездочек указываете конкретные поля которые вас интересуют
т.о. будут выбраны ТОЛьКО рецепты длы которых существуют и вкусы и компоненты
Не знаю можно ли тут постить ссылки, но погуглите «tsql join» по картинкам и найдете все варианты join’ов с наглядным объяснением
MS SQL Server и T-SQL
OUTER JOIN
Последнее обновление: 20.07.2017
В предыдущей теме было рассмотрено внутреннее соединение таблиц. Но MS SQL Server также поддерживает внешнее соединение или outer join.
В отличие от inner join внешнее соединение возвращает все строки одной или двух таблиц, которые участвуют в соединении.
Outer Join имеет следующий формальный синтаксис:
SELECT столбцы FROM таблица1 {LEFT|RIGHT|FULL} [OUTER] JOIN таблица2 ON условие1 [{LEFT|RIGHT|FULL} [OUTER] JOIN таблица3 ON условие2]...
Перед оператором JOIN указывается одно из ключевых слов LEFT,
RIGHT или FULL, которые определяют тип соединения:
LEFT: выборка будет содержать все строки из первой или левой таблицы
RIGHT: выборка будет содержать все строки из второй или правой таблицы
FULL: выборка будет содержать все строки из обоих таблиц
Также перед оператором JOIN может указываться ключевое слово OUTER, но его применение необязательно.
Далее после JOIN указывается присоединяемая таблица, а затем идет условие соединения.
Например, соединим таблицы Orders и Customers:
SELECT FirstName, CreatedAt, ProductCount, Price, ProductId FROM Orders LEFT JOIN Customers ON Orders.CustomerId = Customers.Id
Таблица Orders является первой или левой таблицей, а таблица Customers — правой таблицей. Поэтому, так как здесь используется
выборка по левой таблице, то вначале будут выбираться все строки из Orders, а затем к ним по условию Orders.CustomerId = Customers.Id
будут
добавляться связанные строки из Customers.
По вышеприведенному результату может показаться, что левостороннее соединение аналогично INNER Join, но это не так.
Inner Join объединяет строки из дух таблиц при соответствии условию. Если одна из таблиц содержит строки, которые не соответствуют этому условию, то данные строки
не включаются в выходную выборку. Left Join выбирает все строки первой таблицы и затем присоединяет к ним строки правой таблицы. К примеру, возьмем таблицу Customers и добавим к покупателям информацию об их заказах:
-- INNER JOIN SELECT FirstName, CreatedAt, ProductCount, Price FROM Customers JOIN Orders ON Orders.CustomerId = Customers.Id --LEFT JOIN SELECT FirstName, CreatedAt, ProductCount, Price FROM Customers LEFT JOIN Orders ON Orders.CustomerId = Customers.Id
Изменим в примере выше тип соединения на правостороннее:
SELECT FirstName, CreatedAt, ProductCount, Price, ProductId FROM Orders RIGHT JOIN Customers ON Orders.CustomerId = Customers.Id
Теперь будут выбираться все строки из Customers, а к ним уже будет присоединяться связанные по условию строки из таблицы Orders:
Поскольку один из покупателей из таблицы Customers не имеет связанных заказов из Orders, то соответствующие столбцы, которые берутся из Orders,
будут иметь значение NULL.
Используем левостороннее соединение для добавления к заказам информации о пользователях и товарах:
SELECT Customers.FirstName, Orders.CreatedAt, Products.ProductName, Products.Manufacturer FROM Orders LEFT JOIN Customers ON Orders.CustomerId = Customers.Id LEFT JOIN Products ON Orders.ProductId = Products.Id
И также можно применять более комплексные условия с фильтрацией и сортировкой. Например, выберем все заказы с информацией о клиентах и товарах по тем товарам,
у которых цена меньше 45000, и отсортируем по дате заказа:
SELECT Customers.FirstName, Orders.CreatedAt, Products.ProductName, Products.Manufacturer FROM Orders LEFT JOIN Customers ON Orders.CustomerId = Customers.Id LEFT JOIN Products ON Orders.ProductId = Products.Id WHERE Products.Price < 45000 ORDER BY Orders.CreatedAt
Или выберем всех пользователей из Customers, у которых нет заказов в таблице Orders:
SELECT FirstName FROM Customers LEFT JOIN Orders ON Customers.Id = Orders.CustomerId WHERE Orders.CustomerId IS NULL
Также можно комбинировать Inner Join и Outer Join:
SELECT Customers.FirstName, Orders.CreatedAt, Products.ProductName, Products.Manufacturer FROM Orders JOIN Products ON Orders.ProductId = Products.Id AND Products.Price < 45000 LEFT JOIN Customers ON Orders.CustomerId = Customers.Id ORDER BY Orders.CreatedAt
Вначале по условию к таблице Orders через Inner Join присоединяется связанная информация из Products, затем через Outer Join
добавляется информация из таблицы Customers.
Cross Join
Cross Join или перекрестное соединение создает набор строк, где каждая строка из одной таблицы соединяется с каждой строкой из второй таблицы.
Например, соединим таблицу заказов Orders и таблицу покупателей Customers:
SELECT * FROM Orders CROSS JOIN Customers
Если в таблице Orders 3 строки, а в таблице Customers то же три строки, то в результате перекрестного соединения создается 3 * 3 = 9 строк вне зависимости,
связаны ли данные строки или нет.
При неявном перекрестном соединении можно опустить оператор CROSS JOIN и просто перечислить все получаемые таблицы:
SELECT * FROM Orders, Customers
База Данных MySQL LEFT JOIN
Ключевое слово соединения SQL Left
Ключевое слово LEFT JOIN возвращает все записи из левой таблицы (Table1) и совпадающие записи из правой таблицы (Table2). Результат равен NULL с правой стороны, если совпадений нет.
LEFT JOIN Синтаксис
SELECT column_name(s)
FROM table1
LEFT JOIN table2 ON table1.column_name = table2.column_name;
Note: In some databases LEFT JOIN is called LEFT OUTER JOIN.
Демонстрационная база данных
В этом учебнике мы будем использовать хорошо известную базу данных Northwind Sample.
Ниже представлен выбор из таблицы «Customers»:
CustomerID | CustomerName | ContactName | Address | City | PostalCode | Country |
---|---|---|---|---|---|---|
1 | Alfreds Futterkiste | Maria Anders | Obere Str. 57 | Berlin | 12209 | Germany |
2 | Ana Trujillo Emparedados y helados | Ana Trujillo | Avda. de la Constitución 2222 | México D.F. | 05021 | Mexico |
3 | Antonio Moreno Taquería | Antonio Moreno | Mataderos 2312 | México D.F. | 05023 | Mexico |
And a selection from the «Orders» table:
OrderID | CustomerID | EmployeeID | OrderDate | ShipperID |
---|---|---|---|---|
10308 | 2 | 7 | 1996-09-18 | 3 |
10309 | 37 | 3 | 1996-09-19 | 1 |
10310 | 77 | 8 | 1996-09-20 | 2 |
Пример левого соединения SQL
Следующая инструкция SQL выберет всех клиентов и любые заказы, которые они могут иметь:
Пример
SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;
Примечание: Ключевое слово LEFT JOIN возвращает все записи из левой таблицы (Customers), даже если в правой таблице нет совпадений (Orders).
как объединить две таблицы с возвратом строк из левой при отсутствии нужного предиката
От автора: LEFT JOIN SQL возвращает все строки из левой таблицы, даже если в правой таблице нет совпадений. Это означает, что, если условие ON соответствует 0 (нолю) записей в правой таблице; объединение все равно вернет строку в результат, но с NULL в каждом столбце из правой таблицы.
Это означает, что LEFT JOIN возвращает все значения из левой таблицы, а также соответствующие значения из правой таблицы или NULL в случае отсутствия соответствующего предиката объединения.
Синтаксис
Основной синтаксис LEFT JOIN следующий.
SELECT таблица1.столбец1, таблица2.стобец2…
FROM таблица1
LEFT JOIN таблица2
ON таблица1.общее_поле = таблица2.общее_поле;
SELECT таблица1.столбец1, таблица2.стобец2… FROM таблица1 LEFT JOIN таблица2 ON таблица1.общее_поле = таблица2.общее_поле; |
Бесплатный курс по PHP программированию
Освойте курс и узнайте, как создать динамичный сайт на PHP и MySQL с полного нуля, используя модель MVC
В курсе 39 уроков | 15 часов видео | исходники для каждого урока
Получить курс сейчас!
Данное условие может быть любым заданным выражением, исходя из ваших потребностей.
Пример
Рассмотрим следующие две таблицы. Таблица 1 — Таблица CUSTOMERS выглядит следующим образом.
Таблица 2 — Таблица ORDERS выглядит следующим образом.
Теперь давайте объединим две таблицы, используя LEFT JOIN следующим образом.
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS LEFT JOIN ORDERS ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID; |
Мы получим следующий результат.
Источник: //www.tutorialspoint.com/
Редакция: Команда webformyself.
Бесплатный курс по PHP программированию
Освойте курс и узнайте, как создать динамичный сайт на PHP и MySQL с полного нуля, используя модель MVC
В курсе 39 уроков | 15 часов видео | исходники для каждого урока
Получить курс сейчас!
Хотите изучить MySQL?
Посмотрите курс по базе данных MySQL!
Смотреть
Объединение таблиц при запросе (JOIN) в SQL
С помощью команды SELECT можно выбрать данные не только из одной таблицы, но и нескольких. Такая задача появляется довольно часто, потому что принято разносить данные по разным таблицам в зависимости от хранимой в них информации. К примеру, в одной таблице хранится информация о пользователях, во второй таблице о должностях компании, а в третьей и четвёртой о поставщиках и клиентах. Данные разбивают на таблицы так, чтобы с одной стороны получить самую высокую скорость выполнения запроса, а с другой стороны избежать ненужных объединений, которые снижают производительность.
Чем больше столбцов в таблице — тем сильнее падает скорость выборки из неё. Поэтому стараются делать в каждой таблице не больше 5-10 столбцов. Но чем сильнее данные разбиваются на разные таблицы, тем больше придётся делать объединений внутри запросов, что тоже снизит скорость получения выборки и увеличит нагрузку на базу.
Приведём пример запроса с объединением данных из двух таблиц. Для этого предположим, что существует две таблицы. Первая таблица будет иметь название USERS и будет иметь два столбца: ID и именами пользователей:
+-----------+ | USERS | +-----------+ | ID | NAME | +----+------+ | 1 | Мышь | +----+------+ | 2 | Кот | +----+------+
Вторая таблица будет называться FOOD и будет содержать два столбца: USER_ID и NAME. В этой таблице будет содержаться список любимых блюд пользователей из первой таблицы. В столбце USER_ID содержится ID пользователя, а в столбце PRODUCT находится название любимого блюда.
+-------------------+ | FOOD | +-------------------+ | USER_ID | PRODUCT | +---------+---------+ | 1 | Сыр | +---------+---------+ | 2 | Молоко | +---------+---------+
Условимся что поле ID в таблице USERS и поле USER_ID в таблице FOOD являются первичными ключами (то есть имеют уникальные значения, которые не повторяются). Теперь попробуем использовать логику и найти любимое блюдо пользователя «Мышь», используя обе таблицы. Для этого мы сначала посмотрим в первую таблицу и найдём ID пользователя под именем «Мышь», а затем найдём название продукта под таким же ID во второй таблице. Объединяющие SQL запросы работают по такой же логике: нужен столбец, в по которому таблицы могут быть объединены.
Продемонстрируем запрос, объединяющий таблицы по столбцам ID и USER_ID:
SELECT * FROM `USERS` INNER JOIN `FOOD` ON `USERS`.`ID`=`FOOD`.`USER_ID`;
Разберём команду по словам. Начинается она как обычная выборка из одной таблицы со слов «SELECT * FROM USERS». Но затем идёт слово INNER, которое означает тип объединения. Существует три типа объединения таблиц: INNER, LEFT, RIGHT. Все они связаны с тем, что некоторым строкам в одной таблице может не найтись соответствующей строки во второй таблице. В таком случае при использовании «INNER» из результатов запроса будет удалены все строки, которым не нашлась соответствующая пара в другой таблице. Если же использовать вместо «INNER» слово «LEFT» или «RIGHT», то будут удалены строки, которые не нашли совпадение из первой (левой) или второй (правой) таблицы.
После слова «INNER» стоит слово «JOIN» (которое переводится с английского как «ПРИСОЕДИНИТЬ»). После слова «JOIN» стоит название таблицы, которая будет присоединена. В нашем случае это таблица FOOD. После названия таблицы стоит слово «ON» и равенство USERS.ID=FOOD.USER_ID, которое задаёт правило присоединения. При выполнении выборки будут объединены две таблицы так, чтобы значения в столбце ID таблицы USERS равнялось значению USER_ID таблицы FOOD.
В результате выполнения этого SQL запроса мы получим таблицу с четырьмя столбцами:
+----+------+---------+---------+ | ID | NAME | USER_ID | PRODUCT | +----+------+---------+---------+ | 1 | Мышь | 1 | Сыр | +----+------+---------+---------+ | 2 | Кот | 2 | Молоко | +----+------+---------+---------+
Предлагаем модифицировать запрос, потому что нам не нужны все четыре столбца. Уберём столбцы ID и USER_ID. Для этого вместо * в команде SELECT поставим название столбцов. Но необходимо сделать это, ставя сначала название таблицы и через точку название столбца. Чтобы получилось так:
SELECT `USERS`.`NAME`, `FOOD`.`PRODUCT`
FROM `USERS` INNER JOIN `FOOD` ON `USERS`.`ID`=`FOOD`.`USER_ID`;
Теперь результат будет компактнее. И благодаря уменьшенному количеству запрашиваемых данных, результат будет получаться из базы быстрее:
+------+---------+ | NAME | PRODUCT | +------+---------+ | Мышь | Сыр | +------+---------+ | Кот | Молоко | +------+---------+
Если в двух таблицах имеются столбцы с одинаковыми названиями, то будет показан только последний столбце с таким названием. Чтобы этого не происходило, выбирайте определённый столбцы и используйте команду «AS» с помощью которой можно переименовать столбец в результатах выборки.
Давайте теперь решим логическую задачу, которую поставили в начале статьи. Попробуем выбрать в этой объединённой таблице только одну строку, которая соответствует пользователю «Мышь». Для этого используем условие WHERE в SQL запросе:
SELECT `USERS`.`NAME`, `FOOD`.`PRODUCT`
FROM `USERS` INNER JOIN `FOOD` ON `USERS`.`ID`=`FOOD`.`USER_ID`
WHERE `USERS`.`NAME` LIKE 'Мышь';
Обратите внимание, что в условии WHERE название полей так же необходимо ставить вместе с названием таблицы через точку: USERS.NAME. В результате выполнения этого запроса появится такой результат:
+------+---------+ | NAME | PRODUCT | +------+---------+ | Мышь | Сыр | +------+---------+
Отлично! Теперь мы знаем, как делать объединение таблиц.
SQL-запросы. В чем разница между INNER JOIN, RIGHT JOIN, LEFT JOIN?
-
-
– Автор:
Игорь (Администратор)
В рамках сегодняшней статьи я расскажу вам в чем разница между INNER JOIN, RIGHT JOIN и LEFT JOIN, приведу подробные примеры, а так же предоставлю некоторые пояснения.
Без баз данных сегодня не обходится практически ни одно приложение. И в этом нет ничего странного, так как наличие пользовательской информации требует специальных хранилищ. Кто-то пытается реализовывать их собственными силами, используя, например, файлы. А кто-то использует уже готовые решения, по типу MySQL. Если в первом случае все задачи ложатся на плечи их создателей, то во втором авторам программных продуктов предоставляется универсальный язык для построения запросов под названием SQL
Однако, специфика использования SQL запросов может оказаться простой не для всех. Поэтому попробуем поэтапно посмотреть их на практике.
Допустим, что у вас существует две таблицы — авторы и программы. Сразу оговоримся, что не всегда известно какие программы кем написаны (обычно мелкие утилиты и инструменты можно встретить без указания авторства, к примеру, небольшие скрипты), а так же не все авторы еще что-либо написали (т.е. допустим, автор оставил заявку, но еще не приложил свое творение). Для простоты, таблицы назовем author и util.
Таблица авторов (author) будет выглядеть следующим образом:
id | name |
---|---|
1 | Вася |
2 | Коля |
3 | Петя |
Где id — это идентификатор автора, а name — это, собственно, имя автора
Таблица программ (util) будет выглядеть следующим образом:
id | author_id | name |
---|---|---|
1 | 1 | Вася Мега продукт |
2 | 0 | Крутая, но неизвестная утилита |
Где id — это идентификатор программы, author_id — это идентификатор автора (0 — если неизвестен), name — название программы
Итак, исходные данные у нас есть, теперь, давайте рассмотрим каждый из join по отдельности.
INNER JOIN
Данный тип объединения таблиц позволяет находить все те вариации соединения строк двух таблиц, где точно выполняется условие. В нашем примере, мы ищем всех авторов и их произведения. При этом нужно вывести только тех авторов, у которых есть хотя бы одно произведение.
Примечание: Кстати, в большинстве баз данных не обязательно писать перед join слово inner. Однако, в рамках примера я все же его укажу.
SQL запрос будет выглядеть следующим образом
-- Выводим все поля select * -- Указываем таблицу авторов from author -- Соединяем с таблицей программ inner join util -- Указываем условие on author.id = util.author_id
Результат выполнения такого SQL запроса будет следующим:
id | name | id | author_id | name |
---|---|---|---|---|
1 | Вася | 1 | 1 | Вася Мега продукт |
Как видите, в нашей базе данных известно, что только автор Вася написал хотя бы одну программу. Коля и Петя ничего не написали, поэтому их в результатах нет. Так же не вывелась безызвестная программа.
Теперь, перейдем к следующему типу
LEFT JOIN
Данные тип позволяет находить как все вариации обычного JOIN-а (inner), так и выводить строки из первой таблицы, для которых не нашлись строки из второй таблицы, удовлетворяющие условиям. В нашем случае, мы выведем всех авторов и, если есть, их программы тоже.
SQL запрос будет выглядеть следующим образом. Он точно такой же, как и в предыдущем случае, только вместо inner join стоит left join.
-- Выводим все поля select * -- Указываем таблицу авторов from author -- Соединяем с таблицей программ left join util -- Указываем условие on author.id = util.author_id
Результат выполнения такого SQL запроса будет следующим:
id | name | id | author_id | name |
---|---|---|---|---|
1 | Вася | 1 | 1 | Вася Мега продукт |
2 | Коля | NULL | NULL | NULL |
3 | Петя | NULL | NULL | NULL |
Как видите, были выведены все авторы. В случае с Васей, строка осталась аналогичной, так как он написал хотя бы одну программу. В случае с Колей и Петей возвращаемые результаты были NULL, так как они еще не написали ни одной программы. Так же стоит отметить, что и программа без автора не попала в результат, так как автор неизвестен.
Теперь, последний тип.
RIGHT JOIN
В целом, действие этого оператора точно такое же как и у LEFT JOIN, за одним исключением — таблицы «как бы» меняются местами (т.е. ищутся соответствия по второй таблице, а не первой). Вы могли бы сказать, что в таком случае можно было бы просто ограничится одним LEFT, но как показывает практика, RIGHT JOIN позволяет использовать понятные и удобные запросы, а так же быстро менять логику самих SQL запросов. В нашем случае, попытаемся найти все программы и их авторов, если таковые были указаны.
Воспользуемся тем же SQL запросом, но с правым объединением строк таблиц:
-- Выводим все поля select * -- Указываем таблицу авторов from author -- Соединяем с таблицей программ right join util -- Указываем условие on author.id = util.author_id
Результат выполнения такого SQL запроса будет следующим:
id | name | id | author_id | name |
---|---|---|---|---|
1 | Вася | 1 | 1 | Вася Мега продукт |
NULL | NULL | 2 | 0 | Крутая, но неизвестная утилита |
Как видите, вывелся весь список программ. В случае с Мега продуктом, автор нашелся, так что в левой части результата отображаются данные Васи. В случае же с безызвестной утилитой, автор не нашелся, поэтому в полях автора стоит значение NULL.
Если вы внимательно следили, то могли отметить насколько удобно устроен оператор JOIN, всего одной простой правкой можно легко поменять логику основного запроса.
Теперь, надеюсь, у вас не будет проблем с INNER JOIN, RIGHT JOIN, LEFT JOIN, и вы сможете с легкостью реализовывать свои творения.
☕ Хотите выразить благодарность автору? Поделитесь с друзьями!
- PrestaShop 1.6 — создаем свой модуль — уникальные имена классов
- SQL-запросы. Группировка данных Group By и Having
Добавить комментарий / отзыв
SQL множественные соединения для новичков с примерами
ТАБЛИЦА УДАЛЕНИЯ, ЕСЛИ СУЩЕСТВУЕТ продажи
GO
ТАБЛИЦА УДАЛЕНИЯ, ЕСЛИ СУЩЕСТВУЕТ заказы
GO
ТАБЛИЦА УДАЛЕНИЯ, ЕСЛИ СУЩЕСТВУЕТ онлайн-клиенты
GO
СОЗДАНИЕ КЛИЕНТОВ (ТАБЛИЦА СОЗДАНИЯ ИНТ. 1,1), CustomerName VARCHAR (100)
, CustomerCity VARCHAR (100), Customermail VARCHAR (100))
GO
CREATE TABLE orders (orderId INT PRIMARY KEY IDENTITY (1,1), Customerid INT,
ordertotal float, Discountrate float, orderdate DATETIME)
GO
CREATE TABLE sales (salesId INT PRIMARY KEY IDENTITY (1,1),
orderId INT,
salestotal FLOAT)
GO
IN [dbo].[onlinecustomers] ([CustomerName], [CustomerCity], [Customermail]) ЗНАЧЕНИЯ (N’Salvador ‘, N’Philadelphia’, N’tyiptqo.wethls @ chttw.org ‘)
INSERT INTO [dbo]. [onlinecustomers] ([CustomerName], [CustomerCity], [Customermail]) ЗНАЧЕНИЯ (N’Gilbert ‘, N’San Diego’, N’rrvyy.wdumos @ lklkj.org ‘)
INSERT INTO [dbo]. [Onlinecustomers] ([ CustomerName], [CustomerCity], [Customermail]) ЗНАЧЕНИЯ (N’Ernest ‘, N’New York’, N’ymuea.pnxkukf @ dwv.org ‘)
INSERT INTO [dbo]. [Onlinecustomers] ([CustomerName] , [CustomerCity], [Customermail]) ЗНАЧЕНИЯ (N’Stella ‘, N’Phoenix’, N’[email protected] ‘)
INSERT INTO [dbo]. [onlinecustomers] ([CustomerName], [CustomerCity], [Customermail]) ЦЕННОСТИ (N’Jorge’, N’Los Angeles ‘, N’oykbo.vlxopp @ nmwhv.org ‘)
INSERT INTO [dbo]. [onlinecustomers] ([CustomerName], [CustomerCity], [Customermail]) ЗНАЧЕНИЯ (N’Jerome’, N’San Antonio ‘, N’wkabc.ofmhetq @ gtmh. co ‘)
INSERT INTO [dbo]. [onlinecustomers] ([CustomerName], [CustomerCity], [Customermail]) ЗНАЧЕНИЯ (N’Edward’, N’Chicago ‘, N’wguexiymy.nnbdgpc @ juc.co’)
GO
INSERT INTO [dbo].[заказы] ([Customerid], [ordertotal], [Discountrate], [orderdate]) VALUES (3,1910,64,5,49, CAST (’03 -Dec-2019 ‘AS DATETIME))
INSERT INTO [dbo]. [ заказы] ([Customerid], [ordertotal], [Discountrate], [orderdate]) VALUES (4 150,89,15,33, CAST (’11 -Jun-2019 ‘AS DATETIME))
INSERT INTO [dbo]. [orders] ( [Customerid], [ordertotal], [Discountrate], [orderdate]) VALUES (5,912,55,13,74, CAST (’15 -Sep-2019 ‘AS DATETIME))
INSERT INTO [dbo]. [orders] ([customerid] , [итого заказа], [ставка скидки], [дата заказа]) ЗНАЧЕНИЯ (7,418.24,14.53, CAST (’28 -May-2019 ‘AS DATETIME))
INSERT INTO [dbo]. [Orders] ([Customerid], [ordertotal], [Discountrate], [orderdate]) VALUES (55 512,55,13,74 , CAST (’15 -Jun-2019 ‘AS DATETIME))
INSERT INTO [dbo]. [Orders] ([Customerid], [ordertotal], [Discountrate], [orderdate]) VALUES (57,118,24,14,53, CAST ( ’28 -Dec-2019 ‘AS DATETIME))
GO
INSERT INTO [dbo]. [Sales] ([orderId], [salestotal]) VALUES (3,370.95)
INSERT INTO [dbo]. [Sales] ] ([orderId], [salestotal]) ЗНАЧЕНИЯ (4,882.13)
ВСТАВИТЬ В [dbo]. [Sales] ([orderId], [salestotal]) ЗНАЧЕНИЯ (12,370,95)
INSERT INTO [dbo]. [Sales] ([orderId], [salestotal]) VALUES (13,882,13)
ВСТАВИТЬ В [dbo]. [Sales] ([orderId], [salestotal]) ЗНАЧЕНИЯ (55,170.95)
INSERT INTO [dbo]. [Sales] ([orderId], [salestotal]) VALUES (57,382,13)
7 примеров SQL JOIN с подробными пояснениями
Вам нужно объединить несколько таблиц, чтобы получить необходимый набор результатов? SQL JOIN — это базовый, но важный инструмент, используемый аналитиками данных, работающими с реляционными базами данных.И я понимаю, что бывает сложно выбрать из огромного количества вводных руководств, чтобы присоединиться. В этой статье я сосредоточусь на реальных примерах с подробными объяснениями.
Введение в JOIN
В реляционных базах данных нужная информация часто хранится в нескольких таблицах. В таких случаях вам нужно будет присоединиться к этим столам. Здесь в игру вступает SQL JOIN.
Предложение JOIN в SQL используется для объединения строк из нескольких таблиц на основе связанного столбца между этими таблицами. .Вы можете получить обзор инструмента SQL JOIN в этой вводной статье.
В этом руководстве я хочу охватить основные типы SQL JOIN на нескольких примерах. Я подробно расскажу о синтаксисе каждого запроса, о том, как он работает, как создать условие и как интерпретировать результаты.
В качестве примеров мы будем использовать информацию об издательстве, которое издает оригинальные и переведенные книги. В нашей базе четыре таблицы: книг
, авторов
, редакторов
и переводчиков
.
книги | |||||
---|---|---|---|---|---|
id | title | type | author_id | editor_id | translator_id |
1 | Время расти! | исходный | 11 | 21 | |
2 | Ваша поездка | переведено | 15 | 22 | 32 |
3 | Lovely Love | оригинал | 14 | 24 | |
4 | Dream Your Life | оригинал | 11 | 24 | |
5 | Апельсины | переведено | 12 | 25 | 31 |
6 | Your Happy Life | переведено | 15 | 22 | 33 |
7 | Прикладной AI | переведенный | 13 | 23 | 34 |
8 | Моя последняя книга | оригинал | 11 | 28 |
авторов | ||
---|---|---|
id | first_name | last_name |
11 | Эллен | Писатель |
12 | Ольга | Савельева |
13 | Джек | Smart |
14 | Дональд | Мозг |
15 | Яо | Доу |
редакторы | ||
---|---|---|
id | first_name | last_name |
21 | Daniel | Коричневый |
22 | Марк | Джонсон |
23 | Мария | Эванс |
24 | Катрин | Робертс |
25 | Себастьян | Райт |
26 | Барбара | Джонс |
27 | Мэтью | Смит |
переводчики | ||
---|---|---|
id | first_name | last_name |
31 | Ира | Дэвис |
32 | Лин | Вен |
33 | Кристиан | Зеленый |
34 | Роман | Эдвардс |
Если вы хотите попрактиковаться в объединении таблиц в SQL с множеством примеров, я рекомендую пройти курс SQL JOINs.Он включает в себя 93 задачи по программированию!
ВНУТРЕННЕЕ СОЕДИНЕНИЕ
Начнем с базового INNER JOIN
или просто JOIN
. Этот тип соединения используется, когда мы хотим отобразить совпадающих записей из двух таблиц .
Пример # 1
Допустим, мы хотим показать названия книг вместе с их авторами (то есть имя и фамилию автора). Названия книг хранятся в таблице книги
, а имена авторов хранятся в таблице авторов
.
В нашем запросе SQL мы объединим эти две таблицы, сопоставив столбец author_id
из таблицы books
и столбец id
из таблицы авторов
:
ВЫБЕРИТЕ b.id, b.title, a.first_name, a.last_name ИЗ книг б INNER JOIN создает ВКЛ b.author_id = a.id ЗАКАЗАТЬ ПО b.id;
В операторе SELECT
мы перечисляем отображаемые столбцы: идентификатор книги, название книги, имя автора и фамилия автора.В предложении FROM
мы указываем первую таблицу для присоединения (также называемую левой таблицей). В предложении INNER JOIN
мы указываем вторую таблицу для присоединения (также называемую правой таблицей).
Затем мы используем ключевое слово ON, чтобы сообщить базе данных, какие столбцы следует использовать для сопоставления записей (например, столбец author_id
из таблицы books
и столбец id
из авторов
стол).
Обратите внимание, что мы используем псевдонимы для имен таблиц (например, b
для книг
и a
для авторов
). Мы назначаем псевдонимы в предложениях FROM
и INNER JOIN
и используем их во всем запросе. Псевдонимы таблиц сокращают ввод текста и делают запрос более читабельным.
Вот получившийся набор:
id | title | first_name | last_name |
1 | Время расти! | Эллен | Писатель |
2 | Ваша поездка | Yao | Dou |
3 | Прекрасная любовь | Дональд | Мозг |
4 | Мечтайте о своей жизни | Эллен | Писатель |
5 | Апельсины | Ольга | Савельева |
6 | Ваша счастливая жизнь | Яо | Доу |
7 | AI | Jack | Smart |
8 | Моя последняя книга | Эллен | Писатель |
Для каждой записи в левой таблице (т.например, книги
), запрос проверяет author_id
, затем ищет тот же id
в первом столбце таблицы авторы
. Затем он извлекает соответствующие имя и фамилию.
Обратите внимание, что порядок таблиц не имеет значения для INNER JOIN или простого JOIN. Набор результатов будет точно таким же, если мы поместим таблицу авторов
в предложение FROM
и таблицу books
в предложение INNER JOIN
.
INNER JOIN
отображает только записи, доступные в обеих таблицах. В нашем примере у всех книг есть автор-корреспондент, а у всех авторов есть хотя бы одна соответствующая книга. Итак, давайте посмотрим, что произойдет, если некоторые записи не совпадают.
Пример # 2
Во втором примере мы будем отображать книги вместе с их переводчиками (т. Е. Фамилией переводчика). Переведена только половина наших книг, и у нас есть переводчик.Итак, каков был бы результат объединения книг
и переводчиков
таблиц с использованием INNER JOIN
?
ВЫБЕРИТЕ b.id, b.title, b.type, t.last_name AS переводчик ИЗ книг б ПРИСОЕДИНЯЙТЕСЬ к переводчикам t ВКЛ b.translator_id = t.id ЗАКАЗАТЬ ПО b.id;
id | название | тип | переводчик |
2 | Ваша поездка | переведено | Weng |
5 | Апельсины | переведено | Дэвис |
6 | Your Happy Life | переведено | Зеленый |
7 | Прикладной AI | переведено | Edwards |
Запрос выводит только те книги, которые были переведены.Я добавил столбец типа, чтобы было понятно. Остальные книги не могут быть сопоставлены с таблицей переводчиков
и поэтому не отображаются. Вот как работает INNER JOIN
.
Также обратите внимание, что во втором примере мы использовали JOIN
, а не ключевое слово INNER JOIN
. Это не влияет на результат, поскольку INNER JOIN
является типом соединения по умолчанию в SQL. Вы можете узнать о других типах SQL JOIN в этом подробном руководстве.
Хорошо. Теперь мы знаем, как объединять таблицы, когда нам нужно отображать только совпадающие записи. Но что, если мы хотим сохранить все книги в результирующем наборе, не сокращая таблицу только на переведенные книги? Пришло время узнать о внешних соединениях!
ЛЕВОЕ СОЕДИНЕНИЕ
Мы начнем наш обзор ВНЕШНИХ объединений с ЛЕВОЕ СОЕДИНЕНИЕ
. Вы должны применить этот тип SQL JOIN, если хотите, чтобы сохранял все записи из левой таблицы и только совпавшие записи из правой таблицы .
Пример # 3
Например, предположим, что мы хотим отобразить информацию об авторе и переводчике каждой книги (т. Е. Их фамилии). Мы также хотим сохранить основную информацию о каждой книге (т.е. id
, title
и type
).
Чтобы получить все эти данные, нам нужно объединить три таблицы: книги
для основной информации о книгах, авторов
для фамилий авторов и переводчиков
для переводчиков ‘ фамилии.
Как мы видели в предыдущем примере, использование INNER JOIN
(или простого JOIN
) для присоединения к таблице переводчиков
приводит к потере всех записей для исходных (не переведенных) книг. Это не то, что мы хотим сейчас. Итак, чтобы сохранить все книги в результирующем наборе, мы объединим таблицы книги
, авторов
и переводчики
, используя ЛЕВОЕ СОЕДИНЕНИЕ
.
ВЫБЕРИТЕ b.id, b.title, b.type, a.last_name как автор, t.last_name AS переводчик ИЗ книг б LEFT JOIN авторы ВКЛ b.author_id = a.id LEFT JOIN переводчики t ВКЛ b.translator_id = t.id ЗАКАЗАТЬ ПО b.id;
Посмотрите, что мы начинаем с таблицы books
в предложении FROM
, что делает ее левой таблицей . Это потому, что мы хотим хранить все записи из этой таблицы. Порядок других таблиц не имеет значения.
В нашем запросе мы сначала LEFT JOIN
таблица авторы
на основе столбца author_id
из таблицы книги
и столбца id
из таблицы авторов
.Затем мы присоединяемся к таблице переводчиков
на основе столбца translator_id
из таблицы books
и столбца id
из таблицы переводчиков
.
Вот итоговая таблица:
id | название | тип | автор | переводчик |
1 | Время расти! | оригинал | Writer | NULL |
2 | Ваша поездка | переведено | Dou | Weng |
3 | Lovely Love | оригинал | Brain | NULL |
4 | Dream Your Life | оригинал | Writer | NULL |
5 | Апельсины | переведено | Савельева | Дэвис |
6 | Your Happy Life | переведено | Dou | Green |
7 | Прикладной AI | переведенный | Smart | Edwards |
8 | Моя последняя книга | оригинал | Writer | NULL |
Отлично! Мы сохранили все книги!
Обратите внимание на значения NULL
в столбце переводчика .Эти значения
NULL
соответствуют записям, которые не были сопоставлены в таблице трансляторов
. Эти записи относятся к оригинальным книгам без привлечения переводчиков.
Надеюсь, вы уловили интуицию, лежащую в основе LEFT JOINs. Вы можете узнать больше об этом типе SQL JOIN в этом вводном руководстве.
Хорошо, давайте рассмотрим еще один пример LEFT JOIN
, чтобы закрепить знания по теме.
Пример # 4
На этот раз мы хотим показать основную информацию о книге (т.е.е., ID и название) вместе с фамилиями соответствующих редакторов. Опять же, мы хотим сохранить все книги в наборе результатов. Итак, каков был бы запрос?
ВЫБРАТЬ b.id, b.title, e.last_name AS редактор ИЗ книг б LEFT JOIN редакторы e ВКЛ b.editor_id = e.id ЗАКАЗАТЬ ПО b.id;
идентификатор | заголовок | редактор |
1 | Время расти! | Коричневый |
2 | Ваша поездка | Джонсон |
3 | Прекрасная любовь | Робертс |
4 | Мечтайте о своей жизни | Робертс |
5 | Апельсины | Райт |
6 | Ваша счастливая жизнь | Джонсон |
7 | Прикладной AI | Evans |
8 | Моя последняя книга | NULL |
Довольно просто, правда? Мы снова сохранили все книги в наборе результатов, включая последнюю, у которой нет соответствующего редактора в нашей базе данных (обратите внимание на значение NULL
в последней строке).
Мы можем представить, что редактора нет в таблице наших нынешних редакторов просто потому, что они покинули издательство после редактирования книги.
Подождите! Что, если в нашей команде есть редакторы, которые еще не опубликовали ни одной книги? Давайте посмотрим на следующий тип внешнего соединения.
ПРАВО СОЕДИНЕНИЕ
RIGHT JOIN
очень похож на LEFT JOIN
. Готов поспорить, вы догадались, что единственная разница в том, что RIGHT JOIN
хранит все записи из правой таблицы, даже если они не могут быть сопоставлены с левой таблицей .Если да, то вы правы!
Пример # 5
Давайте повторим наш предыдущий пример, но на этот раз наша задача будет заключаться в том, чтобы сохранить все записи из таблицы editors
. Таким образом, у нас будет тот же запрос, что и в примере №4 , за исключением того, что мы заменим LEFT JOIN
на RIGHT JOIN
:
ВЫБРАТЬ b.id, b.title, e.last_name AS редактор ИЗ книг б Редакторы RIGHT JOIN e ВКЛ b.editor_id = e.id ЗАКАЗАТЬ ПО b.id;
идентификатор | заголовок | редактор |
1 | Время расти! | Коричневый |
2 | Ваша поездка | Джонсон |
3 | Прекрасная любовь | Робертс |
4 | Мечтайте о своей жизни | Робертс |
5 | Апельсины | Райт |
6 | Ваша счастливая жизнь | Джонсон |
7 | Прикладной AI | Evans |
NULL | NULL | Jones |
NULL | NULL | Smith |
Если в запросе изменено только одно слово, результат будет совсем другим.Мы видим, что у нас действительно есть два редактора ( Jones и Smith ), у которых нет соответствующих книг в нашей базе данных. Похоже, новые сотрудники!
И это не единственное изменение. У нас также нет My Last Book в наборе результатов. Эта запись левой таблицы (то есть книги
) не была сопоставлена в правой таблице (то есть редакторы
) и не добралась до окончательного результата.
ПРАВЫЕ СОЕДИНЕНИЯ редко используются на практике, потому что их обычно можно заменить на ЛЕВЫЕ СОЕДИНЕНИЯ, которые встречаются гораздо чаще.
Например, в нашем случае мы могли бы взять наш запрос из примера № 4 и просто поменять местами книги
и редакторы
, поместив редакторы
в предложение FROM
, сделав его левым. table и поместив books
в предложение LEFT JOIN
, что сделает его правой таблицей . Результат был бы таким же, как в приведенной выше таблице.
ПОЛНОЕ СОЕДИНЕНИЕ
Здесь мы подошли к последнему типу внешнего соединения - FULL JOIN
.Мы используем FULL JOIN
, когда хотим, чтобы сохранял все записи из всех таблиц , даже если они не совпадают. Итак, это похоже на сочетание LEFT JOIN
и RIGHT JOIN
. Давайте сразу перейдем к примерам, чтобы увидеть, как это работает на практике.
Пример # 6
Для начала давайте снова присоединимся к таблицам books
и editors
, но на этот раз мы будем вести все записи из обеих таблиц. Мы просто используем FULL JOIN
в качестве ключевого слова join, оставляя остальную часть запроса без каких-либо изменений:
ВЫБРАТЬ b.id, b.title, e.last_name AS редактор ИЗ книг б Редакторы FULL JOIN e ВКЛ b.editor_id = e.id ЗАКАЗАТЬ ПО b.id;
идентификатор | заголовок | редактор |
1 | Время расти! | Коричневый |
2 | Ваша поездка | Джонсон |
3 | Прекрасная любовь | Робертс |
4 | Мечтайте о своей жизни | Робертс |
5 | Апельсины | Райт |
6 | Ваша счастливая жизнь | Джонсон |
7 | Прикладной AI | Evans |
8 | Моя последняя книга | NULL |
NULL | NULL | Jones |
NULL | NULL | Smith |
Отлично смотрится! Как и ожидалось, мы сохранили все книги, даже ту, у которой не было подходящего редактора.Кроме того, мы сохранили всех редакторов, даже тех, у которых еще нет соответствующих книг.
Обратите внимание, что порядок таблиц не имеет значения с FULL JOIN
. Результат был бы таким же, если бы мы поменяли местами таблицы, поместив таблицу editors
в предложение FROM
и таблицу books
в предложение FULL JOIN
.
Пример # 7
В нашем последнем примере мы хотим объединить все четыре таблицы, чтобы получить информацию обо всех книгах, авторах, редакторах и переводчиках в одной таблице.Итак, мы будем использовать FULL JOIN
во всем нашем SQL-запросе:
ВЫБЕРИТЕ b.id, b.title, a.last_name как автор, e.last_name как редактор, t.last_name AS переводчик ИЗ книг б FULL JOIN авторы a ВКЛ b.author_id = a.id Редакторы FULL JOIN e ВКЛ b.editor_id = e.id Переводчики FULL JOIN t ВКЛ b.translator_id = t.id ЗАКАЗАТЬ ПО b.id;
id | название | автор | редактор | переводчик |
1 | Время расти! | Писатель | Коричневый | NULL |
2 | Ваша поездка | Dou | Johnson | Weng |
3 | Lovely Love | Brain | Roberts | NULL |
4 | Dream Your Life | Writer | Roberts | NULL |
5 | Апельсины | Савельева | Райт | Дэвис |
6 | Your Happy Life | Dou | Johnson | Green |
7 | Прикладной AI | Smart | Evans | Edwards |
8 | Моя последняя книга | Writer | NULL | NULL |
NULL | NULL | NULL | Jones | NULL |
NULL | NULL | NULL | Smith | NULL |
По запросу в таблице отображаются все книги, авторы, редакторы и переводчики.Записи, которые не были сопоставлены, имеют NULL
значений. Это отличный обзор данных, хранящихся в нашей базе данных.
Время попрактиковаться в соединениях SQL!
Знание SQL JOIN - одно из ключевых требований для любого, кто работает с реляционными базами данных. Чтобы помочь вам ориентироваться в различных типах SQL JOIN, LearnSQL.com разработал двухстраничную памятку по SQL JOIN. Он предоставляет синтаксис различных JOIN, а также примеры.
Однако, чтобы освоить JOIN, вам потребуется много практики.Я рекомендую начать с интерактивного курса SQL JOINs, который охватывает важные типы JOIN, пройдя через десятки примеров и упражнений. Узнайте больше об этом курсе в этой обзорной статье.
БОНУС: Вот 10 основных вопросов собеседования по SQL JOIN и способы на них ответить.
Удачного обучения!
Объяснение
SQL-объединений - внутреннее, левое, правое и полное объединение
Язык структурированных запросов, также известный как SQL, является ядром реляционных баз данных, с помощью которого мы можем обрабатывать данные.Он предоставляет нам различные функции, такие как триггеры, внедрение, хостинг и объединение - это лишь одна из самых важных концепций, которые нужно освоить в SQL. В этой статье о соединениях SQL я расскажу о различных типах соединений, используемых в SQL.
В этой статье будут рассмотрены следующие темы.
Что такое объединения?
СОЕДИНЕНИЯ в SQL - это команды, которые используются для объединения строк из двух или более таблиц на основе связанного столбца между этими таблицами. В основном они используются, когда пользователь пытается извлечь данные из таблиц, которые имеют отношения «один ко многим» или «многие ко многим».
Теперь, когда вы знаете, что означают объединения, давайте теперь изучим различные типы объединений.
Сколько типов объединений существует в SQL?
Существует четыре основных типа объединений, которые вам необходимо понять. Это:
Вы можете обратиться к изображению ниже.
Как узнать, какое соединение использовать в SQL?
Разберемся с каждым из них. Для вашего лучшего понимания этой концепции я рассмотрю следующие три таблицы, чтобы показать вам, как выполнять операции соединения с такими таблицами.
Стол сотрудников:
EmpID | EmpFname | EmpLname | Возраст | EmailID | 97 PhoneNo 901 | Вардхан | Кумар | 22 | [email protected] | 9876543210 | Дели |
2 | Химани | Шарма | abc.ком | 9977554422 | Мумбаи | ||||||
3 | Ааюши | Шрешт | 24 | [email protected] | 9977555121 | 9876545666 | Bengaluru | ||||
5 | Swatee | Kapoor | 26 | [email protected] | 9544567301 |
901
30 9012-16
730 9012 901 901 2
Клиентский стол:
ClientFname | ClientLname | Возраст | ClientEmailID | Телефонный номер | Адрес | EmpID | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
1 | Susan | Smith | 30 | susan @ adn.ком | 9765411231 | Калькутта | 3 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2 | Мойс | Али | 27 | [email protected] | 9876543561 | 22 | [email protected] | 9966332211 | Дели | 1 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
4 | Zainab | Daginawala | 40 | zainabком | 9955884422 | Хайдарабад | 5 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
5 | Бхаскар | Редди | 32 | [email protected] | 9636963269 |
EmpID | EmpFname | EmpLname | ProjectID | ProjectName |
Project1 | ||||
2 | Himani | Sharma | 222 | Project2 |
3 | Aayushi | Shreshth | 333 | Project4 |
5 | Swatee | Kapoor | 555 | Project5 |
ПОЛНОЕ СОЕДИНЕНИЕ
Полное соединение или полное внешнее соединение Таблица1) или правая (Таблица2) таблица.
Синтаксис:
SELECT Table1.Column1, Table1.Column2, Table2.Column1, .... ИЗ Table1 ПОЛНОЕ СОЕДИНЕНИЕ Table2 ON Table1.MatchingColumnName = Table2.MatchingColumnName;
Пример:
ВЫБЕРИТЕ Employee.EmpFname, Employee.EmpLname, Projects.ProjectID ОТ Сотрудника FULL JOIN проекты ON Employee.EmpID = Projects.EmpID;
Выход:
EmpFname | EmpLname | ProjectID | |||
Vardhan | Kumar | 11112 Shark 901 901 | 1 | Шрешт | 333 |
Ааюши | Шрешт | 444 | |||
Хемант | Шарма | НУЛЛ | |||
NULL | NULL | 777 | |||
NULL | NULL | 888 |
LEFT JOIN
9000IN LEFT JOIN
9000IN LEFT JOIN LEFT JOIN а также те записи, которые удовлетворяют условию из правой таблицы.Кроме того, для записей, не имеющих совпадающих значений в правой таблице, вывод или набор результатов будут содержать значения NULL.
Синтаксис:
SELECT Table1.Column1, Table1.Column2, Table2.Column1, .... ИЗ Table1 LEFT JOIN Table2 ON Table1.MatchingColumnName = Table2.MatchingColumnName;
Пример:
ВЫБЕРИТЕ Employee.EmpFname, Employee.EmpLname, Projects.ProjectID, Projects.ProjectName ОТ Сотрудника ВЛЕВО ПРИСОЕДИНИТЬСЯ ON Employee.EmpID = Проекты.EmpID;
Выход:
EmpFname | EmpLname | ProjectID | ProjectName | ||
Vardhan | 222 | Project2 | |||
Aayushi | Shreshth | 333 | Project3 | ||
Aayushi | Shreshth | 12 444 | 12 444 | 12 444 | 12 444 |
Hemanth | Sharma | NULL | NULL |
RIGHT JOIN
RIGHT JOIN или RIGHT OUTER JOIN возвращает все записи из правой таблицы, а также условие из тех записей, которые удовлетворяют левый стол.Кроме того, для записей, не имеющих совпадающих значений в левой таблице, вывод или набор результатов будут содержать значения NULL.
Синтаксис:
SELECT Table1.Column1, Table1.Column2, Table2.Column1, .... ИЗ Table1 RIGHT JOIN Table2 ON Table1.MatchingColumnName = Table2.MatchingColumnName;
Пример:
ВЫБЕРИТЕ Employee.EmpFname, Employee.EmpLname, Projects.ProjectID, Projects.ProjectName ОТ Сотрудника ПРАВО ПРИСОЕДИНИТЬСЯ ON Employee.EmpID = Проекты.EmpID;
Выход:
EmpFname | EmpLname | ProjectID | ProjectName | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Vardhan | 222 | Project2 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Aayushi | Shreshth | 333 | Project3 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Aayushi | Shreshth | 12 444 | 12 444 | 12 444 | 12 444 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
NULL | NULL | 666 | Project6 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
NULL | NULL | 777 | Project7 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
NULL |
id | название | возраст | owner_id |
---|---|---|---|
1 | Fido | 7 | 1 |
2 | Мисси | 3 | 1 |
3 | Сисси | 10 | 2 |
4 | Медь | 1 | 3 |
5 | Бункер | 2 | 0 |
id | название | номер телефона |
---|---|---|
1 | Джонни | 4567823 |
2 | Олли | 7486513 |
3 | Илениа | 3481365 |
4 | Луиза | 1685364 |
Вы можете использовать простой запрос, чтобы получить таблицу с именем питомца и именем владельца рядом друг с другом.Давайте сделаем это со всеми различными операторами JOIN.
Пример SQL INNER JOIN
Давайте сначала сделаем это, используя JOIN
.
В этом случае вы должны ВЫБРАТЬ
столбец name
из таблицы pets
(и переименовать его в pet_name
). Затем вы должны выбрать столбец name
из таблицы owner
и переименовать его в owner
. Это будет выглядеть так: SELECT pets.name AS pet_name, владельцы.называть собственника AS
.
Вы должны использовать FROM
, чтобы сказать, что столбцы взяты из таблицы pets
, и JOIN
, чтобы сказать, что вы хотите присоединиться к таблице владельцев , используя следующий синтаксис:
FROM pets JOIN owner
.
И, наконец, вы бы сказали, что хотите объединить две строки вместе, когда столбец owner_id
в таблице pets
равен столбцу id
в таблице owner
с ON pets.owner_id = owner.id
.
Вот это все вместе:
ВЫБЕРИТЕ pets.name AS pet_name, owner.name AS owner
ОТ домашних животных
ПРИСОЕДИНЯЙТЕСЬ к владельцам
ВКЛ pets.owner_id = owner.id;
Вы получите таблицу, как показано ниже, в которую включены только домашние животные, связанные с владельцем, и владельцы, связанные с домашним животным.
pet_name | собственник |
---|---|
Fido | Джонни |
Мисси | Джонни |
Сисси | Олли |
Медь | Илениа |
Пример SQL LEFT JOIN
Давайте сделаем тот же запрос, используя LEFT JOIN
, чтобы вы могли увидеть разницу.Запрос тот же, за исключением добавления ключевого слова LEFT
.
ВЫБРАТЬ pets.name КАК pet_name, owner.name КАК владелец
ОТ домашних животных
LEFT JOIN владельцы
ВКЛ pets.owner_id = owner.id;
В этом случае все строки из левой таблицы, pets
, сохраняются, а когда данные из таблицы владельцев
отсутствуют, она заполняется NULL
.
pet_name | собственник |
---|---|
Fido | Джонни |
Мисси | Джонни |
Сисси | Олли |
Медь | Илениа |
Бункер | ПУСТО |
Кажется, есть домашнее животное, которое не зарегистрировано у владельца.
Пример SQL RIGHT JOIN
Если вы выполните тот же запрос, используя RIGHT JOIN
, вы получите другой результат.
ВЫБРАТЬ pets.name КАК pet_name, owner.name КАК владелец
ОТ домашних животных
RIGHT JOIN владельцев
ВКЛ pets.owner_id = owner.id;
В этом случае все строки из правой таблицы, владельцев
, сохраняются, и если есть пропущенное значение, оно заполняется NULL
.
pet_name | собственник |
---|---|
Fido | Джонни |
Мисси | Джонни |
Сисси | Олли |
Медь | Илениа |
ПУСТО | Луиза |
Кажется, есть владелец, у которого нет зарегистрированного домашнего животного.
Пример SQL FULL JOIN
Вы можете повторить тот же запрос, используя FULL JOIN
.
ВЫБРАТЬ pets.name КАК pet_name, owner.name КАК владелец
ОТ домашних животных
Владельцы FULL JOIN
ВКЛ pets.owner_id = owner.id;
Результирующая таблица снова отличается - в этом случае сохраняются все строки из двух таблиц.
pet_name | собственник |
---|---|
Fido | Джонни |
Мисси | Джонни |
Сисси | Олли |
Медь | Илениа |
Бункер | ПУСТО |
ПУСТО | Луиза |
Кажется, что в нашей базе есть домашнее животное без хозяина и хозяин без домашнего животного.
В реляционной базе данных все данные должны быть записаны только один раз. Чтобы затем проанализировать эти данные, вам нужно что-то, чтобы объединить связанные данные.
Из этой статьи вы узнали, как использовать для этого оператор JOIN. Надеюсь, он будет вам полезен, получайте удовольствие!
SQL OUTER JOIN - левое соединение, правое соединение и полное внешнее соединение
Резюме : в этом руководстве вы узнаете, как использовать внешнее соединение SQL , включая левое внешнее соединение, правое внешнее соединение и полное внешнее соединение.
Если вы хотите узнать о SQL INNER JOIN, ознакомьтесь с руководством по SQL INNER JOIN.
Существует три вида ВНЕШНЕГО СОЕДИНЕНИЯ: левое внешнее соединение, правое внешнее соединение и полное внешнее соединение. Давайте рассмотрим каждый вид соединения более подробно.
SQL OUTER JOIN - левое внешнее соединение
Левое внешнее соединение SQL также известно как левое соединение SQL. Предположим, мы хотим объединить две таблицы: A и B. Левое внешнее соединение SQL возвращает все строки в левой таблице (A) и все совпадающие строки, найденные в правой таблице (B).Это означает, что результат левого соединения SQL всегда содержит строки в левой таблице.
Ниже показан левый внешний синтаксис SQL для объединения двух таблиц: table_A и table_B:
SELECT column1, column2 ... ИЗ table_A LEFT JOIN table_B ON join_condition WHERE row_condition
SQL OUTER JOIN - пример левого внешнего соединения
Следующий запрос выбирает всех клиентов и их заказы:
SELECT c.customerid, c.Название компании, номер заказа ОТ клиентов c LEFT JOIN заказы o ON o.customerid = c.customerid ORDER BY orderid
Перечислены все строки в таблице customers . В случае, если в таблице orders не найдена соответствующая строка для строки в таблице customers , столбец orderid в таблице orders заполняется значениями NULL.
Мы можем использовать диаграмму Венна, чтобы визуализировать, как работает SQL LEFT OUTER JOIN.
SQL OUTER JOIN - правое внешнее соединение
Правое внешнее соединение SQL возвращает все строки в правой таблице и все совпадающие строки, найденные в левой таблице.Синтаксис правого внешнего соединения SQL следующий:
SELECT column1, column2 ... ИЗ table_A RIGHT JOIN table_B ON условие_соединения WHERE row_condition
Правое внешнее соединение SQL также известно как правое соединение SQL.
SQL OUTER JOIN - пример правого внешнего соединения
Следующий пример демонстрирует правое внешнее соединение SQL:
SELECT c.customerid, c.companyName, номер заказа ОТ клиентов c RIGHT JOIN приказывает o ON o.customerid = c.customerid ORDER BY orderid
Запрос возвращает все строки в таблице orders и все совпадающие строки, найденные в таблице customers .
Следующая диаграмма Венна показывает, как работает правое внешнее соединение SQL:
SQL OUTER JOIN - полное внешнее соединение
Синтаксис полного внешнего соединения SQL следующий:
SELECT column1, column2 ... ИЗ table_A ПОЛНОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ table_B ON join_condition WHERE row_condition
Полное внешнее соединение SQL возвращает:
- все строки в левой таблице table_A.
- все строки в правой таблице table_B.
- и все совпадающие строки в обеих таблицах.
Некоторые системы управления базами данных не поддерживают синтаксис полного внешнего соединения SQL, например MySQL. Поскольку полное внешнее соединение SQL возвращает набор результатов, который является комбинированным результатом как левого соединения SQL, так и правого соединения SQL. Следовательно, вы можете легко эмулировать полное внешнее соединение SQL, используя левое соединение SQL и правое соединение SQL с оператором UNION следующим образом:
SELECT column1, column2... ИЗ table_A LEFT JOIN table_B ON join_condition СОЮЗ ВЫБРАТЬ столбец1, столбец2 ... ИЗ table_A RIGHT JOIN table_B ON join_condition
SQL OUTER JOIN - пример полного внешнего соединения
Следующий запрос демонстрирует полное внешнее соединение SQL:
SELECT c.customerid, c.companyName, номер заказа ОТ клиентов c Заказы FULL OUTER JOIN o ON o.customerid = c.customerid ORDER BY orderid
Следующая диаграмма Венна показывает, как работает полное внешнее соединение SQL:
В этом руководстве вы узнали о различных SQL OUTER JOIN, включая левое соединение SQL, правое соединение SQL и полное внешнее соединение SQL.
ВНУТРЕННИЙ, НАРУЖНЫЙ, СЛЕВА, ПРАВЫЙ, КРЕСТ
Что такое JOINS?
Объединения помогают извлекать данные из двух или более таблиц базы данных.
Таблицы взаимно связаны с помощью первичного и внешнего ключей.
Примечание. JOIN - это наиболее неправильно понимаемая тема среди сторонников SQL. Для простоты и простоты понимания мы будем использовать новую базу данных для отработки образца. Как показано ниже
id | first_name | фамилия | movie_id |
---|---|---|---|
1 | Адам | Смит | 1 |
2 | Рави | Кумар | 2 |
3 | Сьюзан | Дэвидсон | 5 |
4 | Дженни | Адрианна | 8 |
6 | Ли | Понг | 10 |
id | название | категория |
---|---|---|
1 | КРЕДА УБИЙЦЫ: EMBERS | Анимации |
2 | Настоящая сталь (2012) | Анимации |
3 | Элвин и бурундуки | Анимации |
4 | Приключения олова Олово | Анимации |
5 | Сейф (2012) | Действие |
6 | Безопасный дом (2012) | Действие |
7 | GIA | 18+ |
8 | Срок 2009 | 18+ |
9 | Грязная картинка | 18+ |
10 | Марли и я | Романс |
Типы соединений
Cross JOIN
Cross JOIN - это простейшая форма JOIN, которая сопоставляет каждую строку одной таблицы базы данных со всеми строками другой.
Другими словами, он дает нам комбинации каждой строки первой таблицы со всеми записями во второй таблице.
Предположим, мы хотим получить все записи участников из всех записей фильмов, мы можем использовать показанный ниже сценарий для получения желаемых результатов.
ВЫБРАТЬ * ИЗ `movies` CROSS JOIN` members`
Выполнение вышеуказанного сценария в рабочей среде MySQL дает следующие результаты.
id | название | id | first_name | фамилия | movie_id | |
---|---|---|---|---|---|---|
1 | КРЕДА УБИЙЦЫ: ЭМБЕРС | Анимации | 1 | Адам | Смит | 1 |
1 | КРЕДА УБИЙЦА: ЭМБЕРС | Анимации | 2 | Рави | Кумар | 2 |
1 | КРЕДА УБИЙЦЫ: ЭМБЕРС | Анимации | 3 | Сьюзан | Дэвидсон | 5 |
1 | КРЕДА УБИЙЦЫ: ЭМБЕРС | Анимации | 4 | Дженни | Адрианна | 8 |
1 | КРЕДА УБИЙЦА: ЭМБЕРС | Анимации | 6 | Ли | Понг | 10 |
2 | Настоящая сталь (2012) | Анимации | 1 | Адам | Смит | 1 |
2 | Настоящая сталь (2012) | Анимации | 2 | Рави | Кумар | 2 |
2 | Настоящая сталь (2012) | Анимации | 3 | Сьюзан | Дэвидсон | 5 |
2 | Настоящая сталь (2012) | Анимации | 4 | Дженни | Адрианна | 8 |
2 | Настоящая сталь (2012) | Анимации | 6 | Ли | Понг | 10 |
3 | Элвин и бурундуки | Анимации | 1 | Адам | Смит | 1 |
3 | Элвин и бурундуки | Анимации | 2 | Рави | Кумар | 2 |
3 | Элвин и бурундуки | Анимации | 3 | Сьюзан | Дэвидсон | 5 |
3 | Элвин и бурундуки | Анимации | 4 | Дженни | Адрианна | 8 |
3 | Элвин и бурундуки | Анимации | 6 | Ли | Понг | 10 |
4 | Приключения олова Олово | Анимации | 1 | Адам | Смит | 1 |
4 | Приключения олова Олово | Анимации | 2 | Рави | Кумар | 2 |
4 | Приключения олова Олово | Анимации | 3 | Сьюзан | Дэвидсон | 5 |
4 | Приключения олова Олово | Анимации | 4 | Дженни | Адрианна | 8 |
4 | Приключения олова Олово | Анимации | 6 | Ли | Понг | 10 |
5 | Сейф (2012) | Действие | 1 | Адам | Смит | 1 |
5 | Сейф (2012) | Действие | 2 | Рави | Кумар | 2 |
5 | Сейф (2012) | Действие | 3 | Сьюзан | Дэвидсон | 5 |
5 | Сейф (2012) | Действие | 4 | Дженни | Адрианна | 8 |
5 | Сейф (2012) | Действие | 6 | Ли | Понг | 10 |
6 | Безопасный дом (2012) | Действие | 1 | Адам | Смит | 1 |
6 | Безопасный дом (2012) | Действие | 2 | Рави | Кумар | 2 |
6 | Безопасный дом (2012) | Действие | 3 | Сьюзан | Дэвидсон | 5 |
6 | Безопасный дом (2012) | Действие | 4 | Дженни | Адрианна | 8 |
6 | Безопасный дом (2012) | Действие | 6 | Ли | Понг | 10 |
7 | GIA | 18+ | 1 | Адам | Смит | 1 |
7 | GIA | 18+ | 2 | Рави | Кумар | 2 |
7 | GIA | 18+ | 3 | Сьюзан | Дэвидсон | 5 |
7 | GIA | 18+ | 4 | Дженни | Адрианна | 8 |
7 | GIA | 18+ | 6 | Ли | Понг | 10 |
8 | Срок (2009 г.) | 18+ | 1 | Адам | Смит | 1 |
8 | Срок (2009 г.) | 18+ | 2 | Рави | Кумар | 2 |
8 | Срок (2009 г.) | 18+ | 3 | Сьюзан | Дэвидсон | 5 |
8 | Срок (2009 г.) | 18+ | 4 | Дженни | Адрианна | 8 |
8 | Срок (2009 г.) | 18+ | 6 | Ли | Понг | 10 |
9 | Грязная картинка | 18+ | 1 | Адам | Смит | 1 |
9 | Грязная картинка | 18+ | 2 | Рави | Кумар | 2 |
9 | Грязная картинка | 18+ | 3 | Сьюзан | Дэвидсон | 5 |
9 | Грязная картинка | 18+ | 4 | Дженни | Адрианна | 8 |
9 | Грязная картинка | 18+ | 6 | Ли | Понг | 10 |
10 | Марли и я | Романс | 1 | Адам | Смит | 1 |
10 | Марли и я | Романс | 2 | Рави | Кумар | 2 |
10 | Марли и я | Романс | 3 | Сьюзан | Дэвидсон | 5 |
10 | Марли и я | Романс | 4 | Дженни | Адрианна | 8 |
10 | Марли и я | Романс | 6 | Ли | Понг | 10 |
ВНУТРЕННЕЕ СОЕДИНЕНИЕ
Внутренний JOIN используется для возврата строк из обеих таблиц, удовлетворяющих заданному условию.
Предположим, вы хотите получить список участников, взявших напрокат фильмы, вместе с названиями фильмов, взятых ими напрокат. Вы можете просто использовать для этого INNER JOIN, который возвращает строки из обеих таблиц, которые удовлетворяют заданным условиям.
ВЫБЕРИТЕ members.`first_name`, members.`last_name`, movies.`title` ОТ участников, фильмы ГДЕ movies.`id` = members.`movie_id`
Выполнение вышеуказанного скрипта дает
first_name | фамилия | название |
---|---|---|
Адам | Смит | КРЕДА УБИЙЦА: ЭМБЕРС |
Рави | Кумар | Настоящая сталь (2012) |
Сьюзан | Дэвидсон | Сейф (2012) |
Дженни | Адрианна | Срок (2009 г.) |
Ли | Понг | Марли и я |
Обратите внимание, что приведенный выше сценарий результатов также может быть записан следующим образом для достижения тех же результатов.
ВЫБЕРИТЕ A.`first_name`, A.`last_name`, B.`title` ОТ `members`AS A ВНУТРЕННЕЕ ПРИСОЕДИНЕНИЕ `movies` AS B НА B.`id` = A.`movie_id`
Внешние СОЕДИНЕНИЯ
MySQL Outer JOIN возвращает все совпадающие записи из обеих таблиц.
Он может обнаруживать записи, не имеющие совпадений в объединенной таблице. Он возвращает NULL значений для записей объединенной таблицы, если совпадений не найдено.
звучит сбивающе с толку? Давайте посмотрим на пример -
ЛЕВОЕ СОЕДИНЕНИЕ
Предположим, теперь вы хотите получить названия всех фильмов вместе с именами участников, которые их взяли напрокат.Понятно, что некоторые фильмы никто не арендует. Для этой цели мы можем просто использовать LEFT JOIN .
LEFT JOIN возвращает все строки из таблицы слева, даже если совпадающие строки не были найдены в таблице справа. Если совпадений в таблице справа не найдено, возвращается NULL.
ВЫБЕРИТЕ A.`title`, B.`first_name`, B.`last_name` ИЗ `movies` КАК А ВЛЕВО ПРИСОЕДИНЯЙТЕСЬ `members` как B ПО Б.`movie_id` = A.`id`
Выполнение вышеуказанного сценария в рабочей среде MySQL дает. Вы можете видеть, что в возвращаемом результате, который указан ниже, для фильмов, которые не были взяты напрокат, поля имен участников имеют значения NULL. Это означает, что для этого конкретного фильма не найдено ни одного подходящего элемента.
титул | first_name | фамилия |
---|---|---|
КРЕДА УБИЙЦА: ЭМБЕРС | Адам | Смит |
Настоящая сталь (2012) | Рави | Кумар |
Сейф (2012) | Сьюзан | Дэвидсон |
Срок (2009 г.) | Дженни | Адрианна |
Марли и я | Ли | Понг |
Элвин и бурундуки | ПУСТО | ПУСТО |
Приключения олова Олово | ПУСТО | ПУСТО |
Убежище (2012) | ПУСТО | ПУСТО |
GIA | ПУСТО | ПУСТО |
Грязная картинка | ПУСТО | ПУСТО |
ПРАВИЛЬНОЕ СОЕДИНЕНИЕ
RIGHT JOIN, очевидно, является противоположностью LEFT JOIN.RIGHT JOIN возвращает все столбцы из таблицы справа, даже если в таблице слева не найдено совпадающих строк. Если в таблице слева совпадений не найдено, возвращается NULL.
В нашем примере предположим, что вам нужно получить имена участников и фильмы, взятые ими напрокат. Теперь у нас есть новый участник, который еще не брал напрокат ни одного фильма
ВЫБЕРИТЕ A.`first_name`, A.`last_name`, B.`title` ОТ `members` AS A ПРАВО ПРИСОЕДИНЯЙТЕСЬ `movies` AS B ПО Б.`id` = A.`movie_id`
Выполнение вышеуказанного сценария в рабочей среде MySQL дает следующие результаты.
first_name | фамилия | название |
---|---|---|
Адам | Смит | КРЕДА УБИЙЦА: ЭМБЕРС |
Рави | Кумар | Настоящая сталь (2012) |
Сьюзан | Дэвидсон | Сейф (2012) |
Дженни | Адрианна | Срок (2009 г.) |
Ли | Понг | Марли и я |
ПУСТО | ПУСТО | Элвин и бурундуки |
ПУСТО | ПУСТО | Приключения олова Олово |
ПУСТО | ПУСТО | Безопасный дом (2012) |
ПУСТО | ПУСТО | GIA |
ПУСТО | ПУСТО | Грязная картинка |
Пункты
«ВКЛЮЧЕНО» и «ИСПОЛЬЗУЕТСЯ»
В приведенных выше примерах запросов JOIN мы использовали предложение ON для сопоставления записей в таблице.
Предложение
USING также может использоваться для той же цели. Разница с USING заключается в том, что должен иметь одинаковые имена для совпадающих столбцов в обеих таблицах.
До сих пор в таблице «movies» мы использовали ее первичный ключ с именем «id». Мы ссылались на то же самое в таблице «members» с именем «movie_id».
Давайте переименуем поле таблицы «movies» в «id» в имя «movie_id». Мы делаем это для того, чтобы имена полей совпадали одинаково.
ALTER TABLE `movies` ИЗМЕНИТЬ` id` `movie_id` INT (11) NOT NULL AUTO_INCREMENT;
Теперь давайте используем USING с приведенным выше примером LEFT JOIN.
ВЫБЕРИТЕ A.`title`, B.`first_name`, B.`last_name` ИЗ `movies` КАК А ВЛЕВО ПРИСОЕДИНЯЙТЕСЬ `members` как B ИСПОЛЬЗУЕТСЯ (`movie_id`)
Помимо использования ON и USING с JOINs , вы можете использовать множество других предложений MySQL, таких как GROUP BY, WHERE и даже такие функции, как SUM , AVG и т. Д.
Почему мы должны использовать объединения?
Теперь вы можете подумать, зачем мы используем JOIN, когда мы можем выполнять ту же задачу, выполняя запросы. Особенно, если у вас есть некоторый опыт программирования баз данных, вы знаете, что мы можем запускать запросы один за другим, использовать вывод каждого в последовательных запросах.Конечно, это возможно. Но, используя JOIN, вы можете выполнить работу, используя только один запрос с любыми параметрами поиска. С другой стороны, MySQL может достичь лучшей производительности с JOIN, поскольку он может использовать индексирование. Простое использование одного запроса JOIN вместо выполнения нескольких запросов снижает накладные расходы на сервер. Вместо этого используется несколько запросов, что приводит к большему количеству передач данных между MySQL и приложениями (программным обеспечением). Кроме того, это также требует дополнительных манипуляций с данными в конце приложения.
Ясно, что мы можем добиться лучшей производительности MySQL и приложений, используя JOIN.
Сводка
- JOINS позволяет нам объединять данные из более чем одной таблицы в единый набор результатов.
- JOINS имеют лучшую производительность по сравнению с подзапросами
- INNER JOINS возвращает только те строки, которые соответствуют заданным критериям.
- OUTER JOINS также может возвращать строки, в которых не было найдено совпадений. Несовпадающие строки возвращаются с ключевым словом NULL.
- Основные типы JOIN включают Inner, Left Outer, Right Outer, Cross JOINS и т. Д.
- Часто используемое предложение в операциях JOIN - «ON». Предложение «USING» требует, чтобы совпадающие столбцы имели одно и то же имя.
- JOINS также можно использовать в других предложениях, таких как GROUP BY, WHERE, SUB QUERIES, AGGREGATE FUNCTIONS и т. Д.
Как объединить три таблицы в запросе SQL - пример MySQL
Три таблицы Пример JOIN SQL
Объединение трех таблиц в один запрос SQL может быть очень сложным, если вы не разбираетесь в концепции объединения SQL.Соединения SQL всегда были сложной задачей не только для начинающих программистов, но и для многих других, которые занимаются программированием и SQL более 2–3 лет. Есть достаточно, чтобы запутать кого-то в SQL JOIN, начиная от различных типов SQL JOIN, таких как INNER и OUTER, внешнее соединение LEFT и RIGHT, CROSS соединение и т.д. . Если вам нужны данные из нескольких таблиц в одном запросе SELECT, вам нужно использовать либо подзапрос, либо JOIN.В большинстве случаев мы объединяем только две таблицы, такие как «Сотрудник» и «Отдел», но иногда может потребоваться объединение более двух таблиц, и популярным случаем является объединение трех таблиц в SQL.
В случае объединения трех таблиц таблица 1 относится к таблице 2, а затем таблица 2 относится к таблице 3. Если вы присмотритесь, вы обнаружите, что таблица 2 представляет собой объединяющую таблицу, которая содержит первичный ключ из таблицы 1 и таблицы 2. Как я уже сказал, может быть очень сложно понять объединение трех или более таблиц.
Я обнаружил, что понимание отношений таблиц как первичного и внешнего ключей помогает избежать путаницы, чем классическая парадигма сопоставления строк.
SQL-соединение также является очень популярной темой в собеседованиях по SQL, и всегда были некоторые вопросы от объединений, например, разница между INNER и OUTER JOIN, SQL-запрос с JOIN, например, отношения сотрудников и разница между LEFT и RIGHT OUTER JOIN и т. Д. Короче говоря, это одна из самых важных тем в SQL как с точки зрения опыта, так и с точки зрения собеседования.
Синтаксис JOIN с тремя таблицами в SQL
Вот общий синтаксис SQL-запроса для объединения трех или более таблиц.Этот SQL-запрос должен работать во всех основных реляционных базах данных, таких как MySQL, Oracle, Microsoft SQLServer, Sybase и PostgreSQL:
.
SELECT t1.col, t3.col
FROM table1
JOIN table2 ON table1.primarykey = table2.foreignkey
JOIN table3 ON table2.primarykey = table3.foreignkey
Сначала мы соединяем таблицу 1 и таблицу 2, которые создают временную таблицу с объединенными данными из таблиц table1 и table2, которые затем присоединяются к table3.Эта формула может быть расширена на более чем 3 таблицы до N таблиц. Вам просто нужно убедиться, что в SQL-запросе должен быть оператор соединения N-1, чтобы объединить N таблиц. для объединения двух таблиц нам потребуется 1 оператор соединения, а для объединения 3 таблиц нам потребуется 2 оператора соединения.
Вот хорошая диаграмма, которая также показывает, как работают разные типы JOIN, например. внутренние, левые внешние, правые внешние и перекрестные соединения работают в SQL:
SQL-запрос для СОЕДИНЕНИЯ трех таблиц в MySQL
Чтобы лучше понять объединение трех таблиц в SQL-запросе , давайте посмотрим на пример.Рассмотрим популярный пример схемы «Сотрудник и отдел». В нашем случае мы использовали таблицу ссылок под названием Register, которая связывает или связывает сотрудников с отделом. Первичный ключ таблицы сотрудников (emp_id) является внешним ключом в регистре, и аналогично первичный ключ таблицы отдела (dept_id) является внешним ключом в таблице регистров.
Кстати, единственный способ освоить SQL-соединение - это как можно больше упражняться. Если бы вы могли решить большинство SQL-головоломок из классической книги Джо Селко «SQL-головоломки и ответы», 2-е издание, вы были бы более уверены в работе с SQL-соединениями, будь то две, три или четыре таблицы.
Чтобы написать SQL-запрос для печати имени сотрудника и названия отдела , нам нужно объединить 3 таблицы . Первый оператор JOIN соединит Employee и Register и создаст временную таблицу, в которой dept_id будет другим столбцом. Теперь второй оператор JOIN соединит эту временную таблицу с таблицей Department на dept_id, чтобы получить желаемый результат.
Вот полный пример SQL-запроса SELECT для объединения 3 таблиц, который может быть расширен для объединения более 3 или N таблиц.
mysql> ВЫБРАТЬ * ИЗ Сотрудник;
+ -------- + ---------- + -------- +
| emp_id | emp_name | зарплата |
+ -------- + ---------- + -------- +
| 1 | Джеймс | 2000 |
| 2 | Джек | 4000 |
| 3 | Генри | 6000 |
| 4 | Том | 8000 |
+ -------- + ---------- + -------- +
4 строки IN SET (0,00 сек)
mysql> ВЫБРАТЬ * ИЗ отдела ;
+ --------- + ----------- +
| dept_id | dept_name |
+ --------- + ----------- +
| 101 | Продажи |
| 102 | Маркетинг |
| 103 | Финансы |
+ --------- + ----------- +
3 ряда IN SET (0.00 сек)
mysql> SELECT * FROM Register;
+ -------- + --------- +
| emp_id | dept_id |
+ -------- + --------- +
| 1 | 101 |
| 2 | 102 |
| 3 | 103 |
| 4 | 102 |
+ -------- + --------- +
4 строки IN SET (0,00 сек)
mysql> SELECT emp_name, dept_name
FROM Сотрудник e
ПРИСОЕДИНЯЙТЕСЬ Зарегистрируйтесь r ON e.emp_id = r.emp_id
ПРИСОЕДИНЯЙТЕСЬ к Отделу d ON r.dept_id = d.dept_id;
+ ---------- + ----------- +
| emp_name | dept_name |
+ ---------- + ----------- +
| Джеймс | Продажи |
| Джек | Маркетинг |
| Генри | Финансы |
| Том | Маркетинг |
+ ---------- + ----------- +
4 ряда IN SET (0,01 сек)
Если вы хотите понять это еще лучше, попробуйте присоединиться к столам шаг за шагом.Поэтому вместо того, чтобы объединять 3 таблицы за один раз, сначала объедините 2 таблицы и посмотрите, как будет выглядеть таблица результатов. Это все о том, как объединить три таблицы в один запрос SQL в реляционной базе данных.
Между прочим, в этом примере SQL JOIN мы использовали ANSI SQL, и он будет работать в другой реляционной базе данных, такой как Oracle, SQL Server, Sybase, PostgreSQL и т. Д. Сообщите нам, если у вас возникнут какие-либо проблемы при запуске этого 3 table JOIN запрос в любой другой базе данных.
Прочие вопросы для собеседования SQL статьи для подготовки
Спасибо, что дочитали эту статью до сих пор. Если вам понравилась эта статья, поделитесь ею со своими друзьями и коллегами.Если у вас есть вопросы, предложения или сомнения, оставьте комментарий, и я постараюсь ответить на ваш вопрос.
.