Union и union all в чем разница
Объединение UNION и UNION ALL в SQL – описание и примеры
Пришло время поговорить об объединении данных по средствам конструкции union и union all, так как это иногда бывает очень полезно, и без использования такой конструкции бывает порой не обойтись. Примеры будем писать в СУБД MSSQL 2008, используя язык SQL.
И начать хотелось бы с того, что мы с Вами уже рассматривали много примеров написания запросов на SQL, например, оператор select языка SQL, или использование строковых функций SQL, также рассматривали программирование как на plpgsql так и на transact-sql, например, Как написать функцию на PL/pgSQL и Transact-sql – Табличные функции и временные таблицы соответственно.
Я не просто так указал вышеперечисленные статьи, а указал я их, потому, что для более лучшего понимания и усвоения сегодняшнего урока, необходимо начальные знания (это сайт для начинающих программистов), которые как раз Вы можете получить из вышеупомянутого материала.
И так приступим. И для начала давайте рассмотрим, что же это за операторы union и union all.
Что такое UNION и UNION ALL в SQL?
Необходимые условия для операторов union и union all
Теперь давайте поговорим о том, в каких случаях нам может понадобиться использование этих операторов. Ну, например, у Вас есть несколько баз со схожей структурой, каждая из которых создана, например, для какого-нибудь филиала, а Вам необходимо объединить эти данные для предоставления отчетности по всем филиалам руководству и самое простое как это можно сделать, это написать запросы на SQL, каждый из которых будет обращаться к разным базам, и через конструкцию union или union all объединить их. Также иногда бывает необходимо объединить данные в одной базе таким образом, что обычными объединениями это не реализовать и приходится использовать union. Почему я говорю «приходится» да потому что данная конструкция значительно увеличивает время выполнения запроса, если например данных очень много, и злоупотреблять ею не нужно.
Хватит теории, переходим к практике.
Примечание! Как уже говорилось, запросы будем писать в Management Studio для SQL Server 2008
Примеры использования union и union all
Для начала создадим две простых таблицы test_table и test_table_2
Они одинаковые для примера, только разные названия. Я заполнил их вот такими данными:
Теперь давайте напишем запрос, который объединит результирующие данные в одни, например через union. Синтаксис очень прост:
Как Вы видите, вывелось всего 5 строк, так как у нас первая строка в первом запросе и первая строка во втором запросе одинаковые, поэтому они объединились.
Теперь давайте объединим через union all
Здесь уже вывелись все строки, так как мы указали union all.
А теперь давайте рассмотрим, какие могут быть ошибки даже в этом простом запросе. Например, мы перепутали последовательность полей:
Или мы в первом запросе указали дополнительное поле, а во втором этого не сделали.
Также, например, при использовании order by:
Здесь мы указали сортировку в каждом запросе, а нужно было только в последнем, например:
И напоследок, хотел рассказать об одной хитрости, которую можно использовать тогда когда, например, все-таки необходимо вывести в одном запросе какое-то поле, а в других его нет или просто оно не нужно, для этого можете написать вот такой запрос:
т.е. как Вы видите просто там, где должно быть поле ставить пусто и запрос отлично отработает, например:
И еще один небольшой совет, так как запросы при объединении через union довольно обширные, то лучше на их основе создать представление (Views), в случае если данный запрос Вам требуется постоянно, и уже к этому представлению обращаться каждый раз, когда требуется, а зачем нужны представления мы с Вами уже рассматривали вот здесь – Что такое представления и зачем они нужны.
Наверное, все, что я хотел рассказать о конструкции union и union all языка SQL я рассказал, если есть вопросы по использованию этих операторов, задавайте их в комментариях. Удачи!
Заметка! Для комплексного изучения языка T-SQL рекомендую посмотреть мои видеокурсы по T-SQL, в которых используется последовательная методика обучения и рассматриваются все конструкции языка SQL и T-SQL.
Oracle PL/SQL •MySQL •MariaDB •SQL Server •SQLite
Базы данных
SQL оператор UNION ALL
В этом учебном материале вы узнаете, как использовать SQL оператор UNION ALL с синтаксисом и примерами.
Описание
SQL оператор UNION ALL используется для объединения результирующих наборов из 2 или более операторов SELECT. Он не удаляет повторяющиеся строки между различными операторами SELECT (возвращаются все строки).
Каждый оператор SELECT в UNION ALL должен иметь одинаковое количество полей в наборах результатов с одинаковыми типами данных.
В чем разница между UNION и UNION ALL?
Синтаксис
Синтаксис для оператора UNION ALL в SQL.
Параметры или аргумент
Примечание
Давайте посмотрим, как использовать SQL оператор UNION ALL, который возвращает одно поле. В этом простом примере поле в обоих операторах SELECT будет иметь одинаковое имя и тип данных.
Например.
supplier_id | supplier_name |
---|---|
1000 | Microsoft |
2000 | Oracle |
3000 | Apple |
4000 | Samsung |
И таблица orders заполнена следующими записями.
order_id | order_date | supplier_id |
---|---|---|
2019-07-01 | 2000 | |
2019-07-01 | 6000 | |
2019-07-02 | 7000 | |
2019-07-03 | 8000 |
И вы выполнили следующий оператор UNION ALL.
Вы получите следующие результаты.
supplier_id |
---|
1000 |
2000 |
2000 |
3000 |
4000 |
6000 |
7000 |
8000 |
Нет необходимости, чтобы соответствующие столбцы в каждом операторе SELECT имели одинаковые имена, но они должны быть с одинаковыми соответствующими типами данных.
Если у вас нет одинаковых имен столбцов в операторах SELECT, это становится немного сложнее, особенно если вы хотите упорядочить результаты запроса, используя оператор ORDER BY.
Давайте посмотрим, как использовать оператор UNION ALL с разными именами столбцов, и упорядочить результаты запроса.
Например.
В чем разница между UNION и UNION ALL?
Ответов: 22
UNION удаляет повторяющиеся записи (где все столбцы в результатах одинаковы), UNION ALL нет.
SELECT ‘foo’ AS bar UNION SELECT ‘foo’ AS bar Пример:
Результат:
Результат:
И UNION, и UNION ALL объединяют результат двух разных SQL. Они отличаются тем, как они обрабатывают дубликаты.
UNION выполняет DISTINCT в результирующем наборе, исключая любые повторяющиеся строки.
UNION ALL не удаляет дубликаты, а потому быстрее, чем UNION.
Примечание. При использовании этих команд все выбранные столбцы должны быть одного типа данных.
Пример: если у нас есть две таблицы, 1) Сотрудник и 2) Клиент
UNION удаляет дубликаты, тогда как UNION ALL нет.
В принципе, сортировка выполняется быстрее, если она может выполняться в памяти, но применяется одна и та же оговорка об объеме данных.
Конечно, если вам нужны данные, возвращенные без дубликатов, вы должны использовать UNION, в зависимости от источника ваших данных.
Я бы прокомментировал первый пост, чтобы квалифицировать комментарий «гораздо менее результативный», но для этого недостаточно репутации (баллы).
В ORACLE: UNION не поддерживает типы столбцов BLOB (или CLOB), UNION ALL делает.
Учебник по языку SQL (DDL, DML) на примере диалекта MS SQL Server. Часть четвертая
Предыдущие части
В данной части мы рассмотрим
Добавим немного новых данных
Для демонстрационных целей добавим несколько отделов и должностей:
JOIN-соединения – операции горизонтального соединения данных
Здесь нам очень пригодится знание структуры БД, т.е. какие в ней есть таблицы, какие данные хранятся в этих таблицах и по каким полям таблицы связаны между собой. Первым делом всегда досконально изучайте структуру БД, т.к. нормальный запрос можно написать только тогда, когда ты знаешь, что откуда берется. У нас структура состоит из 3-х таблиц Employees, Departments и Positions. Приведу здесь диаграмму из первой части:
Если суть РДБ – разделяй и властвуй, то суть операций объединений снова склеить разбитые по таблицам данные, т.е. привести их обратно в человеческий вид.
Если говорить просто, то операции горизонтального соединения таблицы с другими таблицами используются для того, чтобы получить из них недостающие данные. Вспомните пример с еженедельным отчетом для директора, когда при запросе из таблицы Employees, нам для получения окончательного результата недоставало поля «Название отдела», которое находится в таблице Departments.
Понимание каждого вида соединения очень важно, т.к. от применения того или иного вида, результат запроса может отличаться. Сравните результаты одного и того же запроса с применением разного типа соединения, попробуйте пока просто увидеть разницу и идите дальше (мы сюда еще вернемся):
ID | Name | DepartmentID | ID | Name |
---|---|---|---|---|
1000 | Иванов И.И. | 1 | 1 | Администрация |
1001 | Петров П.П. | 3 | 3 | ИТ |
1002 | Сидоров С.С. | 2 | 2 | Бухгалтерия |
1003 | Андреев А.А. | 3 | 3 | ИТ |
1004 | Николаев Н.Н. | 3 | 3 | ИТ |
ID | Name | DepartmentID | ID | Name |
---|---|---|---|---|
1000 | Иванов И.И. | 1 | 1 | Администрация |
1001 | Петров П.П. | 3 | 3 | ИТ |
1002 | Сидоров С.С. | 2 | 2 | Бухгалтерия |
1003 | Андреев А.А. | 3 | 3 | ИТ |
1004 | Николаев Н.Н. | 3 | 3 | ИТ |
1005 | Александров А.А. | NULL | NULL | NULL |
ID | Name | DepartmentID | ID | Name |
---|---|---|---|---|
1000 | Иванов И.И. | 1 | 1 | Администрация |
1002 | Сидоров С.С. | 2 | 2 | Бухгалтерия |
1001 | Петров П.П. | 3 | 3 | ИТ |
1003 | Андреев А.А. | 3 | 3 | ИТ |
1004 | Николаев Н.Н. | 3 | 3 | ИТ |
NULL | NULL | NULL | 4 | Маркетинг и реклама |
NULL | NULL | NULL | 5 | Логистика |
ID | Name | DepartmentID | ID | Name |
---|---|---|---|---|
1000 | Иванов И.И. | 1 | 1 | Администрация |
1001 | Петров П.П. | 3 | 3 | ИТ |
1002 | Сидоров С.С. | 2 | 2 | Бухгалтерия |
1003 | Андреев А.А. | 3 | 3 | ИТ |
1004 | Николаев Н.Н. | 3 | 3 | ИТ |
1005 | Александров А.А. | NULL | NULL | NULL |
NULL | NULL | NULL | 4 | Маркетинг и реклама |
NULL | NULL | NULL | 5 | Логистика |
ID | Name | DepartmentID | ID | Name |
---|---|---|---|---|
1000 | Иванов И.И. | 1 | 1 | Администрация |
1001 | Петров П.П. | 3 | 1 | Администрация |
1002 | Сидоров С.С. | 2 | 1 | Администрация |
1003 | Андреев А.А. | 3 | 1 | Администрация |
1004 | Николаев Н.Н. | 3 | 1 | Администрация |
1005 | Александров А.А. | NULL | 1 | Администрация |
1000 | Иванов И.И. | 1 | 2 | Бухгалтерия |
1001 | Петров П.П. | 3 | 2 | Бухгалтерия |
1002 | Сидоров С.С. | 2 | 2 | Бухгалтерия |
1003 | Андреев А.А. | 3 | 2 | Бухгалтерия |
1004 | Николаев Н.Н. | 3 | 2 | Бухгалтерия |
1005 | Александров А.А. | NULL | 2 | Бухгалтерия |
1000 | Иванов И.И. | 1 | 3 | ИТ |
1001 | Петров П.П. | 3 | 3 | ИТ |
1002 | Сидоров С.С. | 2 | 3 | ИТ |
1003 | Андреев А.А. | 3 | 3 | ИТ |
1004 | Николаев Н.Н. | 3 | 3 | ИТ |
1005 | Александров А.А. | NULL | 3 | ИТ |
1000 | Иванов И.И. | 1 | 4 | Маркетинг и реклама |
1001 | Петров П.П. | 3 | 4 | Маркетинг и реклама |
1002 | Сидоров С.С. | 2 | 4 | Маркетинг и реклама |
1003 | Андреев А.А. | 3 | 4 | Маркетинг и реклама |
1004 | Николаев Н.Н. | 3 | 4 | Маркетинг и реклама |
1005 | Александров А.А. | NULL | 4 | Маркетинг и реклама |
1000 | Иванов И.И. | 1 | 5 | Логистика |
1001 | Петров П.П. | 3 | 5 | Логистика |
1002 | Сидоров С.С. | 2 | 5 | Логистика |
1003 | Андреев А.А. | 3 | 5 | Логистика |
1004 | Николаев Н.Н. | 3 | 5 | Логистика |
1005 | Александров А.А. | NULL | 5 | Логистика |
Настало время вспомнить про псевдонимы таблиц
Пришло время вспомнить про псевдонимы таблиц, о которых я рассказывал в начале второй части.
В многотабличных запросах, псевдоним помогает нам явно указать из какой именно таблицы берется поле. Посмотрим на пример:
В нем поля с именами ID и Name есть в обоих таблицах и в Employees, и в Departments. И чтобы их различать, мы предваряем имя поля псевдонимом и точкой, т.е. «emp.ID», «emp.Name», «dep.ID», «dep.Name».
Вспоминаем почему удобнее пользоваться именно короткими псевдонимами – потому что, без псевдонимов наш запрос бы выглядел следующим образом:
По мне, стало очень длинно и хуже читаемо, т.к. имена полей визуально потерялись среди повторяющихся имен таблиц.
В многотабличных запросах, хоть и можно указать имя без псевдонима, в случае если имя не дублируется во второй таблице, но я бы рекомендовал всегда использовать псевдонимы в случае соединения, т.к. никто не гарантирует, что поле с таким же именем со временем не добавят во вторую таблицу, а тогда ваш запрос просто сломается, ругаясь на то что он не может понять к какой таблице относится данное поле.
Только используя псевдонимы, мы сможем осуществить соединения таблицы самой с собой. Предположим встала задача, получить для каждого сотрудника, данные сотрудника, который был принят прямо до него (табельный номер отличается на единицу меньше). Допустим, что у нас табельные номера выдаются последовательно и без дырок, тогда мы можем это сделать примерно следующим образом:
Т.е. здесь одной таблице Employees, мы дали псевдоним «e1», а второй «e2».
Разбираем каждый вид горизонтального соединения
Для этой цели рассмотрим 2 небольшие абстрактные таблицы, которые так и назовем LeftTable и RightTable:
Посмотрим, что в этих таблицах:
LCode | LDescr |
---|---|
1 | L-1 |
2 | L-2 |
3 | L-3 |
5 | L-5 |
RCode | RDescr |
---|---|
2 | B-2 |
3 | B-3 |
4 | B-4 |
LCode | LDescr | RCode | RDescr |
---|---|---|---|
2 | L-2 | 2 | B-2 |
3 | L-3 | 3 | B-3 |
Здесь были возвращены объединения строк для которых выполнилось условие (l.LCode=r.RCode)
LEFT JOIN
LCode | LDescr | RCode | RDescr |
---|---|---|---|
1 | L-1 | NULL | NULL |
2 | L-2 | 2 | B-2 |
3 | L-3 | 3 | B-3 |
5 | L-5 | NULL | NULL |
Здесь были возвращены все строки LeftTable, которые были дополнены данными строк из RightTable, для которых выполнилось условие (l.LCode=r.RCode)
RIGHT JOIN
LCode | LDescr | RCode | RDescr |
---|---|---|---|
2 | L-2 | 2 | B-2 |
3 | L-3 | 3 | B-3 |
NULL | NULL | 4 | B-4 |
Здесь были возвращены все строки RightTable, которые были дополнены данными строк из LeftTable, для которых выполнилось условие (l.LCode=r.RCode)
По сути если мы переставим LeftTable и RightTable местами, то аналогичный результат мы получим при помощи левого соединения:
LCode | LDescr | RCode | RDescr |
---|---|---|---|
2 | L-2 | 2 | B-2 |
3 | L-3 | 3 | B-3 |
NULL | NULL | 4 | B-4 |
Я за собой заметил, что я чаще применяю именно LEFT JOIN, т.е. я сначала думаю, данные какой таблицы мне важны, а потом думаю, какая таблица/таблицы будет играть роль дополняющей таблицы.
FULL JOIN – это по сути одновременный LEFT JOIN + RIGHT JOIN
LCode | LDescr | RCode | RDescr |
---|---|---|---|
1 | L-1 | NULL | NULL |
2 | L-2 | 2 | B-2 |
3 | L-3 | 3 | B-3 |
5 | L-5 | NULL | NULL |
NULL | NULL | 4 | B-4 |
Вернулись все строки из LeftTable и RightTable. Строки для которых выполнилось условие (l.LCode=r.RCode) были объединены в одну строку. Отсутствующие в строке данные с левой или правой стороны заполняются NULL-значениями.
CROSS JOIN
LCode | LDescr | RCode | RDescr |
---|---|---|---|
1 | L-1 | 2 | B-2 |
2 | L-2 | 2 | B-2 |
3 | L-3 | 2 | B-2 |
5 | L-5 | 2 | B-2 |
1 | L-1 | 3 | B-3 |
2 | L-2 | 3 | B-3 |
3 | L-3 | 3 | B-3 |
5 | L-5 | 3 | B-3 |
1 | L-1 | 4 | B-4 |
2 | L-2 | 4 | B-4 |
3 | L-3 | 4 | B-4 |
5 | L-5 | 4 | B-4 |
Каждая строка LeftTable соединяется с данными всех строк RightTable.
Возвращаемся к таблицам Employees и Departments
Надеюсь вы поняли принцип работы горизонтальных соединений. Если это так, то возвратитесь на начало раздела «JOIN-соединения – операции горизонтального соединения данных» и попробуйте самостоятельно понять примеры с объединением таблиц Employees и Departments, а потом снова возвращайтесь сюда, обсудим это вместе.
Давайте попробуем вместе подвести резюме для каждого запроса:
Запрос | Резюме |
---|---|
По сути данный запрос вернет только сотрудников, у которых указано значение DepartmentID. Т.е. мы можем использовать данное соединение, в случае, когда нам нужны данные по сотрудникам числящихся за каким-нибудь отделом (без учета внештаткиков). | |
Вернет всех сотрудников. Для тех сотрудников у которых не указан DepartmentID, поля «dep.ID» и «dep.Name» будут содержать NULL. Вспоминайте, что NULL значения в случае необходимости можно обработать, например, при помощи ISNULL(dep.Name,’вне штата’). Этот вид соединения можно использовать, когда нам важно получить данные по всем сотрудникам, например, чтобы получить список для начисления ЗП. | |
Здесь мы получили дырки слева, т.е. отдел есть, но сотрудников в этом отделе нет. Такое соединение можно использовать, например, когда нужно выяснить, какие отделы и кем у нас заняты, а какие еще не сформированы. Эту информацию можно использовать для поиска и приема новых работников из которых будет формироваться отдел. | |
Этот запрос важен, когда нам нужно получить все данные по сотрудникам и все данные по имеющимся отделам. Соответственно получаем дырки (NULL-значения) либо по сотрудникам, либо по отделам (внештатники). Данный запрос, например, может использоваться в целях проверки, все ли сотрудники сидят в правильных отделах, т.к. может у некоторых сотрудников, которые числятся как внештатники, просто забыли указать отдел. | |
В таком виде даже сложно придумать где это можно применить, поэтому пример с CROSS JOIN я покажу ниже. |
Обратите внимание, что в случае повторения значений DepartmentID в таблице Employees, произошло соединение каждой такой строки со строкой из таблицы Departments с таким же ID, то есть данные Departments объединились со всеми записями для которых выполнилось условие (emp.DepartmentID=dep.ID):
В нашем случае все получилось правильно, т.е. мы дополнили таблицу Employees, данными таблицы Departments. Я специально заострил на этом внимание, т.к. бывают случаи, когда такое поведение нам не нужно. Для демонстрации поставим задачу – для каждого отдела вывести последнего принятого сотрудника, если сотрудников нет, то просто вывести название отдела. Возможно напрашивается такое решение – просто взять предыдущий запрос и поменять условие соединение на RIGHT JOIN, плюс переставить поля местами:
ID | Name | ID | Name |
---|---|---|---|
1 | Администрация | 1000 | Иванов И.И. |
2 | Бухгалтерия | 1002 | Сидоров С.С. |
3 | ИТ | 1001 | Петров П.П. |
3 | ИТ | 1003 | Андреев А.А. |
3 | ИТ | 1004 | Николаев Н.Н. |
4 | Маркетинг и реклама | NULL | NULL |
5 | Логистика | NULL | NULL |
Но мы для ИТ-отдела получили три строчки, когда нам нужна была только строчка с последним принятым сотрудником, т.е. Николаевым Н.Н.
Задачу такого рода, можно решить, например, при помощи использования подзапроса:
ID | Name | ID | Name |
---|---|---|---|
1 | Администрация | 1000 | Иванов И.И. |
2 | Бухгалтерия | 1002 | Сидоров С.С. |
3 | ИТ | 1004 | Николаев Н.Н. |
4 | Маркетинг и реклама | NULL | NULL |
5 | Логистика | NULL | NULL |
При помощи предварительного объединения Employees с данными подзапроса, мы смогли оставить только нужных нам для соединения с Departments сотрудников.
Здесь мы плавно переходим к использованию подзапросов. Я думаю использование их в таком виде должно быть для вас понятно на интуитивном уровне. То есть подзапрос подставляется на место таблицы и играет ее роль, ничего сложного. К теме подзапросов мы еще вернемся отдельно.
Посмотрите отдельно, что возвращает подзапрос:
MaxEmployeeID |
---|
1005 |
1000 |
1002 |
1004 |
Т.е. он вернул только идентификаторы последних принятых сотрудников, в разрезе отделов.
Соединения выполняются последовательно сверху-вниз, наращиваясь как снежный ком, который катится с горы. Сначала происходит соединение «Employees emp JOIN (Подзапрос) lastEmp», формируя новый выходной набор:
Потом идет объединение набора, полученного «Employees emp JOIN (Подзапрос) lastEmp» (назовем его условно «ПоследнийРезультат») с Departments, т.е. «ПоследнийРезультат RIGHT JOIN Departments dep»:
Самостоятельная работа для закрепления материала
Если вы новичок, то вам обязательно нужно прорабатывать каждую JOIN-конструкцию, до тех пор, пока вы на 100% не будете понимать, как работает каждый вид соединения и правильно представлять результат какого вида будет получен в итоге.
Для закрепления материала про JOIN-соединения сделаем следующее:
Посмотрим, что в таблицах:
LCode | LDescr |
---|---|
1 | L-1 |
2 | L-2a |
2 | L-2b |
3 | L-3 |
5 | L-5 |
RCode | RDescr |
---|---|
2 | B-2a |
2 | B-2b |
3 | B-3 |
4 | B-4 |
А теперь попытайтесь сами разобрать, каким образом получилась каждая строчка запроса с каждым видом соединения (Excel вам в помощь):
LCode | LDescr | RCode | RDescr |
---|---|---|---|
2 | L-2a | 2 | B-2a |
2 | L-2a | 2 | B-2b |
2 | L-2b | 2 | B-2a |
2 | L-2b | 2 | B-2b |
3 | L-3 | 3 | B-3 |
LCode | LDescr | RCode | RDescr |
---|---|---|---|
1 | L-1 | NULL | NULL |
2 | L-2a | 2 | B-2a |
2 | L-2a | 2 | B-2b |
2 | L-2b | 2 | B-2a |
2 | L-2b | 2 | B-2b |
3 | L-3 | 3 | B-3 |
5 | L-5 | NULL | NULL |
LCode | LDescr | RCode | RDescr |
---|---|---|---|
2 | L-2a | 2 | B-2a |
2 | L-2b | 2 | B-2a |
2 | L-2a | 2 | B-2b |
2 | L-2b | 2 | B-2b |
3 | L-3 | 3 | B-3 |
NULL | NULL | 4 | B-4 |
LCode | LDescr | RCode | RDescr |
---|---|---|---|
1 | L-1 | NULL | NULL |
2 | L-2a | 2 | B-2a |
2 | L-2a | 2 | B-2b |
2 | L-2b | 2 | B-2a |
2 | L-2b | 2 | B-2b |
3 | L-3 | 3 | B-3 |
5 | L-5 | NULL | NULL |
NULL | NULL | 4 | B-4 |
LCode | LDescr | RCode | RDescr |
---|---|---|---|
1 | L-1 | 2 | B-2a |
2 | L-2a | 2 | B-2a |
2 | L-2b | 2 | B-2a |
3 | L-3 | 2 | B-2a |
5 | L-5 | 2 | B-2a |
1 | L-1 | 2 | B-2b |
2 | L-2a | 2 | B-2b |
2 | L-2b | 2 | B-2b |
3 | L-3 | 2 | B-2b |
5 | L-5 | 2 | B-2b |
1 | L-1 | 3 | B-3 |
2 | L-2a | 3 | B-3 |
2 | L-2b | 3 | B-3 |
3 | L-3 | 3 | B-3 |
5 | L-5 | 3 | B-3 |
1 | L-1 | 4 | B-4 |
2 | L-2a | 4 | B-4 |
2 | L-2b | 4 | B-4 |
3 | L-3 | 4 | B-4 |
5 | L-5 | 4 | B-4 |
Еще раз про JOIN-соединения
Еще один пример с использованием нескольких последовательных операций соединении. Здесь повтор получился не специально, так получилось – не выбрасывать же материал. 😉 Но ничего «повторение – мать учения».
Если используется несколько операций соединения, то в таком случае они применяются последовательно сверху-вниз. Грубо говоря, после каждого соединения создается новый набор и следующее соединение уже происходит с этим расширенным набором. Рассмотрим простой пример:
Первым делом выбрались все записи таблицы Employees:
Дальше произошло соединение с таблицей Departments:
Дальше уже идет соединение этого набора с таблицей Positions:
Т.е. это выглядит примерно так:
И в последнюю очередь идет возврат тех данных, которые мы просим вывести:
Соответственно, ко всему этому полученному набору можно применить фильтр WHERE и сортировку ORDER BY:
ID | EmployeeName | PositionName | DepartmentName |
---|---|---|---|
1004 | Николаев Н.Н. | Программист | ИТ |
1001 | Петров П.П. | Программист | ИТ |
То есть последний полученный набор – представляет собой такую же таблицу, над которой можно выполнять базовый запрос:
То есть если раньше в роли источника выступала только одна таблица, то теперь на это место мы просто подставляем наше выражение:
В результате чего получаем тот же самый базовый запрос:
А теперь, применим группировку:
Видите, мы все так же крутимся вокруг да около базовых конструкций, теперь надеюсь понятно, почему очень важно в первую очередь хорошо понять их.
И как мы увидели, в запросе на месте любой таблицы может стоять подзапрос. В свою очередь подзапросы могут быть вложены в подзапросы. И все эти подзапросы тоже представляют из себя базовые конструкции. То есть базовая конструкция, это кирпичики, из которых строится любой запрос.
Обещанный пример с CROSS JOIN
Давайте используем соединение CROSS JOIN, чтобы подсчитать сколько сотрудников, в каком отделе и на каких должностях числится. Для каждого отдела перечислим все существующие должности:
В данном случае сначала выполнилось соединение при помощи CROSS JOIN, а затем к полученному набору сделалось соединение с данными из подзапроса при помощи LEFT JOIN. Вместо таблицы в LEFT JOIN мы использовали подзапрос.
Подзапрос заключается в скобки и ему присваивается псевдоним, в данном случае это «e». То есть в данном случае объединение происходит не с таблицей, а с результатом следующего запроса:
DepartmentID | PositionID | EmplCount |
---|---|---|
NULL | NULL | 1 |
2 | 1 | 1 |
1 | 2 | 1 |
3 | 3 | 2 |
3 | 4 | 1 |
Вместе с псевдонимом «e» мы можем использовать имена DepartmentID, PositionID и EmplCount. По сути дальше подзапрос ведет себя так же, как если на его месте стояла таблица. Соответственно, как и у таблицы,
все имена колонок, которые возвращает подзапрос, должны быть заданы явно и не должны повторяться.
Связь при помощи WHERE-условия
Для примера перепишем следующий запрос с JOIN-соединением:
Через WHERE-условие он примет следующую форму:
Здесь плохо то, что происходит смешивание условий соединения таблиц (emp.DepartmentID=dep.ID) с условием фильтрации (emp.DepartmentID=3).
Теперь посмотрим, как сделать CROSS JOIN:
Через WHERE-условие он примет следующую форму:
Т.е. в этом случае мы просто не указали условие соединения таблиц Employees и Departments. Чем плох этот запрос? Представьте, что кто-то другой смотрит на ваш запрос и думает «кажется тот, кто писал запрос забыл здесь дописать условие (emp.DepartmentID=dep.ID)» и с радостью, что обнаружил косяк, дописывает это условие. В результате чего задуманное вами может сломаться, т.к. вы подразумевали CROSS JOIN. Так что, если вы делаете декартово соединение, то лучше явно укажите, что это именно оно, используя конструкцию CROSS JOIN.
Для оптимизатора запроса может быть и без разницы как вы реализуете соединение (при помощи WHERE или JOIN), он их может выполнить абсолютно одинаково. Но из соображения понимаемости кода, я бы рекомендовал в современных СУБД стараться никогда не делать соединение таблиц при помощи WHERE-условия. Использовать WHERE-условия для соединения, в том случае, если в СУБД реализованы конструкции JOIN, я бы назвал сейчас моветоном. WHERE-условия служат для фильтрации набора, и не нужно перемешивать условия служащие для соединения, с условиями отвечающими за фильтрацию. Но если вы пришли к выводу, что без реализации соединения через WHERE не обойтись, то конечно приоритет за решеной задачей и «к черту все устои».
UNION-объединения – операции вертикального объединения результатов запросов
Я специально использую словосочетания горизонтальное соединение и вертикальное объединение, т.к. заметил, что новички часто недопонимают и путают суть этих операций.
Давайте первым делом вспомним как мы делали первую версию отчета для директора:
Так вот, если бы мы не знали, что существует операция группировки, но знали бы, что существует операция объединения результатов запроса при помощи UNION ALL, то мы могли бы склеить все эти запросы следующим образом:
Т.е. UNION ALL позволяет склеить результаты, полученные разными запросами в один общий результат.
Соответственно количество колонок в каждом запросе должно быть одинаковым, а также должны быть совместимыми и типы этих колонок, т.е. строка под строкой, число под числом, дата под датой и т.п.
Немного теории
В MS SQL реализованы следующие виды вертикального объединения:
Операция | Описание |
---|---|
UNION ALL | В результат включаются все строки из обоих наборов. (A+B) |
UNION | В результат включаются только уникальные строки двух наборов. DISTINCT(A+B) |
EXCEPT | В результат попадают уникальные строки верхнего набора, которые отсутствуют в нижнем наборе. Разница 2-х множеств. DISTINCT(A-B) |
INTERSECT | В результат включаются только уникальные строки, присутствующие в обоих наборах. Пересечение 2-х множеств. DISTINCT(A&B) |
Все это проще понять на наглядном примере.
Создадим 2 таблицы и наполним их данными:
Посмотрим на содержимое:
T1 | T2 |
---|---|
1 | Text 1 |
1 | Text 1 |
2 | Text 2 |
3 | Text 3 |
4 | Text 4 |
5 | Text 5 |
B1 | B2 |
---|---|
2 | Text 2 |
3 | Text 3 |
6 | Text 6 |
6 | Text 6 |
UNION ALL
UNION
По сути UNION можно представить, как UNION ALL, к которому применена операция DISTINCT: