четверг, 23 февраля 2017 г.

Оператор SELECT

Оператор SELECT

Оператор SELECT осуществляет выборку из базы данных и имеет наиболее сложную структуру среди всех операторов языка SQL. Практически любой пользователь баз данных в состоянии написать простейший оператор SELECT типа
SELECT * FROM PC;
который осуществляет выборку всех записей из объекта БД табличного типа с именем PC. При этом столбцы и строки результирующего набора не упорядочены. Чтобы упорядочить поля результирующего набора, их следует перечислить через запятую в нужном порядке после слова SELECT:
SELECT price, speed, hd, ram, cd, model, code
FROM Pc;

Ниже приводится результат выполнения этого запроса.

pricespeedhdramcdmodelcode
600.050056412x12321
850.07501412840x11212
600.050056412x12333
850.06001412840x11214
850.0600812840x11215
950.07502012850x12336
400.0500103212x12327
350.045086424x12328
350.0450103224x12329
350.0500103212x126010
980.09004012840x123311
Вертикальную проекцию таблицы РC можно получить, если перечислить только необходимые поля. Например, чтобы получить информацию только о скорости процессора и объеме оперативной памяти компьютеров, следует выполнить запрос:
SELECT speed, ram FROM PC;

который вернет следующие данные:

speedram
50064
750128
50064
600128
600128
750128
50032
45064
45032
50032
900128
Следует отметить, что вертикальная выборка может содержать дубликаты строк в том случае, если она не содержит потенциального ключа, однозначно определяющего запись. В таблице PC потенциальным ключом является поле code, которое выбрано в качестве первичного ключа таблицы. Поскольку это поле отсутствует в запросе, в приведенном выше результирующем наборе имеются дубликаты строк (например, строки 1 и 3). Если требуется получить уникальные строки (скажем, нас интересуют только различные комбинации скорости процессора и объема памяти, а не характеристики всех имеющихся компьютеров), то можно использовать ключевое слово DISTINCT:
SELECT DISTINCT speed, ram FROM Pc;

что даст такой результат:

speedram
45032
45064
50032
50064
600128
750128
900128
Помимо DISTINCT может применяться также ключевое слово ALL (все строки), которое принимается по умолчанию.
Чтобы упорядочить строки результирующего набора, можно выполнить сортировку по любому количеству полей, указанных в предложении SELECT. Для этого используетсяпредложение ORDER BY <список полей>, являющееся всегда последним предложением в операторе SELECT. При этом в списке полей могут указываться как имена полей, так и их порядковые позиции в списке предложения SELECT. Так если требуется упорядочить результирующий набор по объему оперативной памяти в порядке убывания, можно записать

SELECT DISTINCT speed, ram
FROM Pc
ORDER BY ram DESC

или

SELECT DISTINCT speed, ram
FROM Pc
ORDER BY 2 DESC

Результат, приведенный ниже, будет одним и тем же.

speedram
600128
750128
900128
45064
50064
45032
50032
Сортировку можно проводить по возрастанию (параметр ASC принимается по умолчанию) или по убыванию (параметр DESC). Сортировка по двум полям
SELECT DISTINCT speed, ram
FROM Pc
ORDER BY ram DESC, speed DESC

даст следующий результат:
speedram
900128
750128
600128
50064
45064
50032
45032
Горизонтальную выборку реализует предложение WHERE <предикат>, которое записывается после предложения FROM. При этом в результирующий набор попадут только те строки из источника записей, для каждой из которых значение предиката равно TRUE. То есть предикат проверяется для каждой записи. Например, запрос "получить информацию о частоте процессора и объеме оперативной памяти для компьютеров с ценой ниже $500" можно сформулировать следующим образом:
SELECT DISTINCT speed, ram
FROM Pc
WHERE price<500
ORDER BY 2 DESC

speedram
45064
45032
50032
В последнем запросе использовался предикат сравнения с использованием операции сравнения "<" (меньше чем). Кроме этой операции сравнения могут использоваться: "=" (равно), ">" (больше), ">=" (больше или равно), "<=" (меньше или равно) и "<>" (не равно). Выражения в предикатах сравнения могут содержать любые поля из таблиц, указанных в предложении FROM. Символьные строки и константы типа дата/время записываются в апострофах.
Примеры простых предикатов сравнения:

price < 1000Цена меньше $1000.
type = 'laptop'Типом продукции является ПК-блокнот.
cd = '24x'24-скоростной CD-ROM.
color <>'y'Не цветной принтер.
ram - 128 >0Объем оперативной памяти свыше 128 Mb.
price <= speed*2Цена не превышает удвоенной частоты процессора.
Рекомендуемые упражнения: 23442.

Предикаты (часть I)

Предикаты (часть I)

Предикаты представляют собой выражения, принимающие истинностное значение. Они могут представлять собой как одно выражение, так и любую комбинацию из неограниченного количества выражений, построенную с помощью булевых операторов ANDOR или NOT. Кроме того, в этих комбинациях может использоваться SQL-оператор IS, а также круглые скобки для конкретизации порядка выполнения операций.
Предикат в языке SQL может принимать одно из трех значений TRUE (истина), FALSE (ложь) или UNKNOWN (неизвестно). Исключение составляют следующие предикаты: NULL (отсутствие значения), EXISTS (существование), UNIQUE (уникальность) и MATCH (совпадение), которые не могут принимать значение UNKNOWN.
Правила комбинирования всех трех истинностных значений легче запомнить, обозначив TRUE как 1, FALSE как 0 и UNKNOWN как 1/2 (где то между истинным и ложным).
  • AND с двумя истинностными значениями дает минимум этих значений. Например, TRUE AND UNKNOWN будет равно UNKNOWN.
  • OR с двумя истинностными значениями дает максимум этих значений. Например, FALSE OR UNKNOWN будет равно UNKNOWN.
  • Отрицание истинностного значения равно 1 минус данное истинностное значение. Например, NOT UNKNOWN будет равно UNKNOWN.

Предикаты сравнения

Предикат сравнения представляет собой два выражения, соединяемых оператором сравнения. Имеется шесть традиционных операторов сравнения: =><>=<=<>.
Данные типа NUMERIC (числа) сравниваются в соответствии с их алгебраическим значением.
Данные типа CHARACTER STRING (символьные строки) сравниваются в соответствии с их алфавитной последовательностью. Если a1a2…an и b1b2…bn - две последовательности символов, то первая "меньше" второй, если а1<b1, или а1=b1 и а2<b2 и т.д. Считается также, что а1а2…аn<b1b2…bm, если n<m и а1а2…аn=b1b2…bn, т.е. если первая строка является префиксом второй. Например, 'folder' < 'for', т.к. первые две буквы этих строк совпадают, а третья буква строки 'folder' предшествует третьей букве строки 'for'. Также справедливо неравенство 'bar' < 'barber', поскольку первая строка является префиксом второй.
Данные типа DATETIME (дата/время) сравниваются в хронологическом порядке.
Данные типа INTERVAL (временной интервал) преобразуются в соответствующие типы, а затем сравниваются как обычные числовые значения типа NUMERIC.Пример. Получить информацию о компьютерах, имеющих частоту процессора не менее 500 Мгц и цену ниже $800:
SELECT * FROM Pc
WHERE speed >= 500 AND price < 800;

Запрос возвращает следующие данные:

codemodelspeedramhdcdprice
1123250064512x600.0
3123350064512x600.0
71232500321012x400.0
101260500321012x350.0
Пример. Получить информацию обо всех принтерах, которые не являются матричными и стоят меньше $300:
SELECT * FROM Printer
WHERE NOT (type = 'matrix') AND price < 300;

Результат выполнения запроса:

codemodelcolortypeprice
21433yJet270.0
31434yJet290.0

Предикат BETWEEN

Предикат BETWEEN проверяет, попадают ли значения проверяемого выражения в диапазон, задаваемый пограничными выражениями, соединяемыми служебным словом AND. Естественно, как и для предиката сравнения, выражения в предикате BETWEEN должны быть совместимы по типам.Синтаксис BETWEEN::=
<Проверяемое выражение> [NOT] BETWEEN
<Начальное выражение> AND <Конечное выражение>
Предикат
      exp1 BETWEEN exp2 AND exp3
равносилен предикату
      exp1>=exp2 AND exp1<=exp3
А предикат
      exp1 NOT BETWEEN exp2 AND exp3
равносилен предикату
      NOT (exp1 BETWEEN exp2 AND exp3)
Если значение предиката exp1 BETWEEN exp2 AND exp3 равно TRUE, в общем случае это отнюдь не означает, что значение предиката exp1 BETWEEN exp3 AND exp2 тоже будет TRUE, так как первый можно интерпретировать как предикат
      exp1>=exp2 AND exp1<=exp3
а второй как
      exp1>=exp3 AND exp1<=exp2
Пример. Найти модель и частоту процессора компьютеров стоимостью от $400 до $600:
SELECT model, speed FROM Pc
WHERE price BETWEEN 400 AND 600;

modelspeed
1232500
1233500
1232500

Предикат IN

Предикат IN определяет, будет ли значение проверяемого выражения обнаружено в наборе значений, который либо явно определен, либо получен с помощью табличного подзапроса. Табличный подзапрос это обычный оператор SELECT, который создает одну или несколько строк для одного столбца, совместимого по типу данных со значением проверяемого выражения. Если целевой объект эквивалентен хотя бы одному из указанных в предложении IN значений, истинностное значение предиката IN будет равно TRUE. Если для каждого значения Х в предложении IN целевой объект<>X, истинностное значение будет равно FALSE. Если подзапрос выполняется, и результат не содержит ни одной строки (пустая таблица), предикат принимает значение FALSE. Когда не соблюдается ни одно из упомянутых выше условий, значение предиката равно UNKNOWN.Синтаксис IN::=
<Проверяемое выражение> [NOT] IN (<подзапрос>)
| (<выражение для вычисления значения>,...)
Пример. Найти модель, частоту процессора и объем жесткого диска тех компьютеров, которые комплектуются накопителями 10 или 20 Мб:
SELECT model, speed, hd FROM Pc
WHERE hd IN (10, 20);

modelspeedhd
123375020
123250010
123245010
126050010
Пример. Найти модель, частоту процессора и объем жесткого диска тех компьютеров, которые комплектуются накопителями 10 или 20 Мб и выпускаются производителем А:
SELECT model, speed, hd
FROM Pc
WHERE hd IN (10, 20) AND
            model IN (SELECT model FROM product
            WHERE maker = 'A');

modelspeedhd
123375020
123250010
123245010
Рекомендуемые упражнения: 1582338.

Переименование столбцов и вычисления в результирующем наборе

Переименование столбцов и вычисления в результирующем наборе

Имена столбцов, указанные в предложении SELECT, можно переименовать. Это делает результаты более читабельными, поскольку имена полей в таблицах часто сокращают с целью упрощения набора. Ключевое слово AS, используемое для переименования, согласно стандарту можно и опустить, т.к. оно неявно подразумевается.
Например, запрос
SELECT ram AS Mb, hd Gb
FROM Pc
WHERE cd = '24x';

переименует столбец ram в Mb (мегабайты), а столбец hd в Gb (гигабайты). Этот запрос возвратит объемы оперативной памяти и жесткого диска для тех компьютеров, которые имеют 24-скоростной CD-ROM:

MbGb
648
3210
Переименование особенно желательно при использовании в предложении SELECT выражений для вычисления значения. Эти выражения позволяют получать данные, которые не находятся непосредственно в таблицах. Если выражение содержит имена столбцов таблицы, указанной в предложении FROM, то выражение подсчитывается для каждой строки выходных данных. Так, например, чтобы вывести объем оперативной памяти в килобайтах, можно написать:
SELECT ram * 1024 AS Kb, hd Gb
FROM Pc
WHERE cd = '24x';

Теперь будет получен следующий результат:

KbGb
655368
3276810
Иногда бывает необходимо выводить поясняющую информацию рядом с соответствующим значением. Это можно сделать, добавив строковое выражение как дополнительный столбец. Например, запрос
SELECT ram, 'Mb' AS ram_units, hd, 'Gb' AS hd_units
FROM Pc
WHERE cd = '24x';

даст следующий результат:

ramram_unitshdhd_units
64Mb8Gb
32Mb10Gb
Если же явно не указать имя для выражения, то будет использован способ именования по умолчанию, который зависит от используемой СУБД. Так в MS Access будут использованы имена типа выражение1 и т.д., а выходной столбец в MS SQL Server вообще не будет иметь заголовка.

Предикаты (часть 2)

Предикат LIKE

Синтаксис LIKE::=
<Выражение для вычисления значения строки>
[NOT] LIKE
<Выражение для вычисления значения строки>
[ESCAPE <символ>]
Предикат LIKE сравнивает строку, указанную в первом выражении для вычисления значения строки, называемого проверяемым значением, с шаблоном, который определен во втором выражении для вычисления значения строки. В образце разрешается использовать два трафаретных символа:
  • Символ подчеркивания (_), который можно использовать вместо любого единичного символа в проверяемом значении.
  • Символ процента (%), который заменяет набор любых символов (число символов в наборе может быть от 0 и более) в проверяемом значении.
Если проверяемое значение соответствует образцу с учетом трафаретных символов, то значение предиката равно TRUE. Ниже приводится несколько примеров написания шаблонов.

ШаблонОписание
'abc%'Любые строки, которые начинаются с букв "abc".
'abc_'Строки длиной строго 4 символа, причем первыми символами строки должны быть "abc".
'%z'Любая последовательность символов, которая обязательно заканчивается символом "z".
'%Rostov%'Любая последовательность символов, содержащая слово "Rostov" в любом месте строки.
Пример. Найти все корабли, имена классов которых заканчиваются на букву 'о':
SELECT *
FROM Ships
WHERE class LIKE '%o';

Результатом выполнения запроса будет следующая таблица:

nameclasslaunched
HarunaKongo1916
HieiKongo1914
KirishimaKongo1915
KongoKongo1913
MusashiYamato1942
YamatoYamato1941
Пример. Найти все корабли, имена классов которых заканчиваются на букву 'о', но не на 'go':
SELECT *
FROM Ships
WHERE class NOT LIKE '%go' AND class LIKE '%o';

nameclasslaunched
MusashiYamato1942
YamatoYamato1941
Если искомая строка содержит трафаретный символ, то следует задать управляющий символ в предложении ESCAPE. Этот управляющий символ должен использоваться в шаблоне перед трафаретным символом, сообщая о том, что трафаретный символ следует трактовать как обычный символ. Например, если в некотором поле следует отыскать все значения, содержащие символ "_", то шаблон '%_%' приведет к тому, что будут возвращены все записи из таблицы. В данном случае шаблон следует записать следующим образом:
'%#_%' ESCAPE '#'
Для проверки значения на соответствие строке "25%" можно воспользоваться таким предикатом:
LIKE '25|%' ESCAPE '|'
Истинностное значение предиката LIKE присваивается в соответствии со следующими правилами:
  • Если либо проверяемое значение, либо образец, либо управляющий символ равен NULL, истинностное значение равно UNKNOWN.
  • В противном случае, если проверяемое значение и образец имеют нулевую длину, истинностное значение равно TRUE.
  • В противном случае, если проверяемое значение соответствует шаблону, то предикат LIKE равен TRUE.
  • Если не соблюдается ни одно из перечисленных выше условий, предикат LIKE равен FALSE.

Использование значения NULL в условиях поиска

Предикат
IS [NOT] NULL

позволяет проверить отсутствие (наличие) значения в полях таблицы. Использование в этих случаях обычных предикатов сравнения может привести к неверным результатам, т.к. сравнение со значением NULL дает результат UNKNOWN (неизвестно).
Так, если требуется найти записи в таблице Pc, для которых в поле price отсутствует значение (поиск ошибок ввода), можно воспользоваться следующим оператором:
SELECT *
FROM Pc
WHERE price IS NULL;

Рекомендуемые упражнения: 44.

Получение итоговых значений

Получение итоговых значений

Как узнать количество моделей ПК, выпускаемых тем или иным поставщиком? Как определить среднее значение цены на компьютеры, имеющие одинаковые технические характеристики? На эти и многие другие вопросы, связанные с некоторой статистической информацией, можно получить ответы при помощи итоговых (агрегатных) функций. Стандартом предусмотрены следующие агрегатные функции:

ФункцияОписание
COUNT(*)Возвращает количество строк источника записей.
COUNT(<имя поля>)Возвращает количество значений в указанном столбце.
SUM(<имя поля>)Возвращает сумму значений в указанном столбце.
AVG(<имя поля>)Возвращает среднее значение в указанном столбце.
MIN(<имя поля>)Возвращает минимальное значение в указанном столбце.
MAX(<имя поля>)Возвращает максимальное значение в указанном столбце.
Все эти функции возвращают единственное значение. При этом функции COUNT, MIN и MAX применимы к любым типам данных, в то время как SUM и AVG используются только для числовых полей. Разница между функцией COUNT(*) и COUNT(<имя поля>) состоит в том, что вторая при подсчете не учитывает NULL-значения.
Пример. Найти минимальную и максимальную цену на персональные компьютеры:
SELECT MIN(price) AS Min_price, MAX(price) AS Max_price
FROM PC;

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

Min_priceMax_price
350.0980.0
Пример. Найти имеющееся в наличии количество компьютеров, выпущенных производителем А:
SELECT COUNT(*) AS Qty
FROM PC
WHERE model IN
       (SELECT model
       FROM Product
       WHERE maker = 'A');

В результате получим:

Qty
7
Пример. Если же нас интересует количество различных моделей, выпускаемых производителем А, то запрос можно сформулировать следующим образом (пользуясь тем фактом, что в таблице Product каждая модель записывается один раз):
SELECT COUNT(model) AS Qty_model
FROM Product
WHERE maker = 'A';

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

Qty_model
7
Пример. Найти количество имеющихся различных моделей, выпускаемых производителем А. Запрос похож на предыдущий, в котором требовалось определить общее число моделей, выпускаемых производителем А. Здесь же требуется найти число различных моделей в таблице PC (т.е. имеющихся в продаже).
Для того, чтобы при получении статистических показателей использовались только уникальные значения, при аргументе агрегатных функций можно использовать параметр DISTINCT. Другой параметр ALL используется по умолчанию и предполагает подсчет всех возвращаемых значений в столбце. Оператор,
SELECT COUNT(DISTINCT model) AS Qty
FROM PC
WHERE model IN
       (SELECT model
       FROM Product
       WHERE maker = 'A');

даст следующий результат:

Qty
2
Если же нам требуется получить количество моделей ПК, производимых каждым производителем, то потребуется использовать предложение GROUP BY, синтаксически следующего после предложения WHERE.

Предложение GROUP BY

Предложение GROUP BY используется для определения групп выходных строк, к которым могут применяться агрегатные функции (COUNT, MIN, MAX, AVG и SUM). Если это предложение отсутствует, и используются агрегатные функции, то все столбцы с именами, упомянутыми в SELECT, должны быть включены в агрегатные функции, и эти функции будут применяться ко всему набору строк, которые удовлетворяют предикату запроса. В противном случае все столбцы списка SELECT, не вошедшие в агрегатные функции, должны быть указаны в предложении GROUP BY. В результате чего все выходные строки запроса разбиваются на группы, характеризуемые одинаковыми комбинациями значений в этих столбцах. После этого к каждой группе будут применены агрегатные функции. Следует иметь в виду, что для GROUP BY все значения NULL трактуются как равные, т.е. при группировке по полю, содержащему NULL-значения, все такие строки попадут в одну группу.
Если при наличии предложения GROUP BY, в предложении SELECT отсутствуют агрегатные функции, то запрос просто вернет по одной строке из каждой группы. Эту возможность, наряду с ключевым словом DISTINCT, можно использовать для исключения дубликатов строк в результирующем наборе.
Рассмотрим простой пример:
SELECT model, COUNT(model) AS Qty_model, AVG(price) AS Avg_price
FROM PC
GROUP BY model;

В этом запросе для каждой модели ПК определяется их количество и средняя стоимость. Все строки с одинаковыми значениями model (номер модели) образуют группу, и на выходе SELECT вычисляются количество значений и средние значения цены для каждой группы. Результатом выполнения запроса будет следующая таблица:

modelQty_modelAvg_price
11213850.0
12324425.0
12333843.33333333333337
12601350.0
Если бы в SELECT присутствовал столбец с датой, то можно было бы вычислять эти показатели для каждой конкретной даты. Для этого нужно добавить дату в качестве группирующего столбца, и тогда агрегатные функции вычислялись бы для каждой комбинации значений (модель−дата).
Существует несколько определенных правил выполнения агрегатных функций:
  • Если в результате выполнения запроса не получено ни одной строки (или не одной строки для данной группы), то исходные данные для вычисления любой из агрегатных функций отсутствуют. В этом случае результатом выполнения функций COUNT будет нуль, а результатом всех других функций - NULL.
  • Аргумент агрегатной функции не может сам содержать агрегатные функции (функция от функции). Т.е. в одном запросе нельзя, скажем, получить максимум средних значений.
  • Результат выполнения функции COUNT есть целое число (INTEGER). Другие агрегатные функции наследуют типы данных обрабатываемых значений.
  • Если при выполнении функции SUM был получен результат, превышающий максимальное значение используемого типа данных, возникает ошибка.
Итак, если запрос не содержит предложения GROUP BY, то агрегатные функции, включенные в предложение SELECT, исполняются над всеми результирующими строками запроса. Если запрос содержит предложение GROUP BY, каждый набор строк, который имеет одинаковые значения столбца или группы столбцов, заданных в предложении GROUP BY, составляет группу, и агрегатные функции выполняются для каждой группы отдельно.

Предложение HAVING

Если предложение WHERE определяет предикат для фильтрации строк, то предложение HAVING применяется после группировки для определения аналогичного предиката, фильтрующего группы по значениям агрегатных функций. Это предложение необходимо для проверки значений, которые получены с помощью агрегатной функции не из отдельных строк источника записей, определенного в предложении FROM, а из групп таких строк. Поэтому такая проверка не может содержаться в предложении WHERE.
Пример. Получить количество ПК и среднюю цену для каждой модели при условии, что средняя цена менее $800:
SELECT model, COUNT(model) AS Qty_model, AVG(price) AS Avg_price
FROM PC
GROUP BY model
HAVING AVG(price) < 800;

В результате выполнения запроса получим:

modelQty_modelAvg_price
12324425.0
12601350.0
Заметим, что в предложении HAVING нельзя использовать псевдоним (Avg_price), используемый для именования значений агрегатной функции. Дело в том, что предложение SELECT, формирующее выходной набор запроса, выполняется предпоследним перед предложением ORDER BY.
Ниже приведен порядок обработки предложений в операторе SELECT:
  1. FROM
  2. WHERE
  3. GROUP BY
  4. HAVING
  5. SELECT
  6. ORDER BY
Этот порядок не соответствует синтаксическому порядку общего формата оператора SELECT, представленному ниже:
SELECT [DISTINCT | ALL]{*
| [<выражение для столбца> [[AS] <псевдоним>]] [,…]}
FROM <имя таблицы> [[AS] <псевдоним>] [,…]
[WHERE <предикат>]
[[GROUP BY <список столбцов>]
[HAVING <условие на агрегатные значения>] ]
[ORDER BY <список столбцов>]
Рекомендуемые упражнения: 1011121415202233435152.

Использование в запросе нескольких источников записей

Использование в запросе нескольких источников записей

Как видно из приведенного в конце предыдущего раздела синтаксиса оператора SELECT, в предложении FROM допускается указание нескольких таблиц. Простое перечисление таблиц практически не используется, поскольку оно соответствует реляционной операции декартова произведения. Т.е. в результирующем наборе каждая запись из одной таблицы будет сочетаться с каждой записью в другой. Например, для таблиц
A    B
abcd
1224
2133
Результат запроса
SELECT * FROM A, B;

будет выглядеть следующим образом:

abcd
1224
1233
2124
2133
Поэтому перечисление таблиц, как правило, используется совместно с условием соединения записей из разных таблиц, указываемым в предложении WHERE. Для приведенных выше таблиц таким условием может быть совпадение значений, скажем, в полях a и c:
SELECT * FROM A, B WHERE a=c;

Теперь результатом выполнения этого запроса будет следующая таблица:
abcd
2124
т.е. соединяются только те строки таблиц, у которых в указанных полях находятся равные значения (эквисоединение). Естественно, могут быть использованы любые условия, хотя эквисоединение используется чаще всего, поскольку эта операция воссоздает некую сущность, декомпозированную на две других в результате процедуры нормализации.
Если разные таблицы имеют столбцы с одинаковыми именами, то для однозначности требуется использовать точечную нотацию:
    <имя таблицы>.<имя поля>
В тех случаях, когда это не вызывает неоднозначности, использование данной нотации не является обязательным.
Пример. Найти номер модели и производителя ПК, имеющих цену менее $600:
SELECT DISTINCT PC.model, maker
FROM PC, Product
WHERE PC.model = Product.model AND price < 600;

В результате каждая модель одного и того же производителя выводится только один раз:

modelmaker
1232A
1260E
Иногда в предложении FROM требуется указать одну и ту же таблицу несколько раз. В этом случае обязательным является переименование.
Пример. Вывести пары моделей, имеющих одинаковые цены:
SELECT DISTINCT A.model AS model_1, B.model AS model_2
FROM PC AS A, PC B
WHERE A.price = B.price AND A.model < B.model;

Здесь условие A.model < B.model используется для того, чтобы не выводились одинаковые пары, отличающиеся только перестановкой, например: 1232, 1233 и 1233, 1232. DISTINCT применяется для того, чтобы исключить одинаковые строки, поскольку в таблице PC имеются одинаковые модели по одной и той же цене. В результате получим следующую таблицу:

model_1model_2
12321233
12321260
Переименование также требуется, если в предложении FROM используется подзапрос. Так, первый пример можно переписать следующим образом:
SELECT DISTINCT PC.model, maker
FROM PC,
       (SELECT maker, model
       FROM Product) AS prod
WHERE PC.model = prod.model AND price < 600;

Обратите внимание, что в этом случае в других предложениях оператора SELECT уже нельзя использовать квалификатор Product, поскольку таблица Product уже не используется. Вместо него используется псевдоним prod. Кроме того, ссылаться теперь можно только на те поля таблицы Product, которые перечислены в подзапросе.

Явные операции соединения

В предложении FROM может быть указана явная операция соединения двух и более таблиц. Среди ряда операций соединения, описанных в стандарте языка SQL, многими серверами баз данных поддерживается лишь операция соединения по предикату. Синтаксис соединения по предикату имеет вид:FROM <таблица 1> [INNER]
       | {{LEFT | RIGHT | FULL } [OUTER]} JOIN <таблица 2>
[ON <предикат>]
Соединение может быть либо внутренним (INNER), либо одним из внешних (OUTER). Служебные слова INNER и OUTER можно опускать, поскольку внешнее соединение однозначно определяется его типом - LEFT (левое), RIGHT (правое) или FULL (полное), а просто JOIN будет означать внутреннее соединение.
Предикат определяет условие соединения строк из разных таблиц. При этом INNER JOIN означает, что в результирующий набор попадут только те соединения строк двух таблиц, для которых значение предиката равно TRUE. Как правило, предикат определяет эквисоединение по внешнему и первичному ключам соединяемых таблиц, хотя это не обязательно.
Пример. Найти производителя, номер модели и цену каждого компьютера, имеющегося в базе данных:
SELECT maker, Product.model AS model_1, PC.model AS model_2, price
FROM Product INNER JOIN PC ON PC.model = Product.model
ORDER BY maker, PC.model;

В данном примере в результирующем наборе будут соединяться только те строки из таблиц PC и Product, у которых совпадают номера моделей.
Для контроля в результат включен как номер модели из таблицы PC, так и из таблицы Product:

makermodel_1model_2price
A12321232600.0
A12321232400.0
A12321232350.0
A12321232350.0
A12331233600.0
A12331233950.0
A12331233980.0
B11211121850.0
B11211121850.0
B11211121850.0
E12601260350.0
Внешнее соединение LEFT JOIN означает, что помимо строк, для которых выполняется условие предиката, в результирующий набор попадут все остальные строки из первой таблицы (левой). При этом отсутствующие значения полей из правой таблицы будут заполнены NULL-значениями.
Пример. Привести все модели ПК, их производителей и цену:
SELECT maker, Product.model AS model_1, PC.model AS model_2, price
FROM Product LEFT JOIN PC ON PC.model = Product.model
WHERE type = 'PC'
ORDER BY maker, PC.model;

Обратите внимание на то, что по сравнению с предыдущим примером, пришлось использовать предложение WHERE для отбора только производителей ПК. В противном случае в результирующий набор попали бы также и модели ПК-блокнотов и принтеров. В рассмотренном ранее примере это условие было бы излишним, т.к. соединялись только те строки, у которых совпадали номера моделей, и одной из таблиц была таблица PC, содержащая только ПК. В результате выполнения запроса получим:

makermodel_1model_2price
A12321232600.0
A12321232400.0
A12321232350.0
A12321232350.0
A12331233600.0
A12331233950.0
A12331233980.0
B11211121850.0
B11211121850.0
B11211121850.0
E2111NULLNULL
E2112NULLNULL
E12601260350.0
Поскольку моделей 2111 и 2112 из таблицы Product нет в таблице PC, в полях из таблицы PC содержится NULL.
Соединение RIGHT JOIN обратно соединению LEFT JOIN, т.е. в результирующий набор попадут все строки из второй таблицы, которые будут соединяться только с теми строками из первой таблицы, для которых выполняется условие соединения. В нашем случае левое соединение
Product LEFT JOIN PC ON PC.model = Product.model
будет эквивалентно правому соединению
PC RIGHT JOIN Product ON PC.model = Product.model
Запрос же
SELECT maker, Product.model AS model_1, PC.model AS model_2, price
FROM Product RIGHT JOIN PC ON PC.model = Product.model
ORDER BY maker, PC.model;

даст те же результаты, что и внутреннее соединение, поскольку в правой таблице (PC) нет таких моделей, которые отсутствовали бы в левой таблице (Product), что вполне естественно для типа связи "один-ко-многим", которая имеется между таблицами PC и Product. Наконец, при полном соединении (FULL JOIN) в результирующую таблицу попадут не только те строки, которые имеют одинаковые значения в сопоставляемых столбцах, но и все остальные строки исходных таблиц, не имеющие соответствующих значений в другой таблице. В этих строках все столбцы той таблицы, в которой не было найдено соответствия, заполняются NULL-значениями. Полное соединение представляет собой комбинацию левого и правого внешних соединений.
Так запрос для таблиц A и B, приведенных в начале главы,
SELECT A.*, B.*
FROM A FULL JOIN B
ON A.a = B.c;

даст следующий результат:

abcd
12NULLNULL
2124
NULLNULL33
Заметим, что это соединение симметрично, т.е. "A FULL JOIN B" эквивалентно "B FULL JOIN A". Обратите также внимание на обозначение A.*, что означает "все поля таблицы А".
Рекомендуемые упражнения: 6913161921345055.

Традиционные операции над множествами и оператор SELECT

Традиционные операции над множествами и оператор SELECT

Традиционные операции над множествами - это объединениепересечениеразность и декартово произведение.

Декартово произведение

Ранее мы уже рассмотрели реализацию декартова произведения, перечисляя через запятую табличные выражения в предложении FROM (таблицы, представления, подзапросы). Кроме того, можно использовать еще одну явную операцию соединения:

SELECT Laptop.model, Product.model
FROM Laptop CROSS JOIN Product;

Напомним, что при декартовом произведении каждая строка из одной таблицы соединяется с каждой строкой второй таблицы. В результате количество строк результирующего набора равно произведению количества строк операндов декартова произведения. В нашем примере таблица Laptop содержит 5 строк, а таблица Product - 16. В результате получается 5*16 = 80 строк. Поэтому мы не приводим здесь результат выполнения этого запроса. Вы можете сами проверить это утверждение, выполнив приведенный выше запрос на учебной базе данных.
В чистом виде декартово произведение практически не используется. Оно, как правило, является промежуточным результатом выполнения операции горизонтальной проекции (выборки) при наличии в операторе SELECT предложения WHERE.

Объединение

Для объединения запросов используется служебное слово UNION:
<запрос 1>
UNION [ALL]
<запрос 2>
Оператор UNION объединяет выходные строки каждого из запросов в один результирующий набор. Если определен параметр ALL, то сохраняются все дубликаты выходных строк, в противном случае в результирующем наборе остаются только уникальные строки. Заметим, что можно связывать вместе любое число запросов. Кроме того, с помощью скобок можно менять порядок объединения.
При этом должны выполняться следующие условия:
  • Количество выходных столбцов каждого из запросов должно быть одинаковым.
  • Выходные столбцы каждого из запросов должны быть сравнимыми между собой (в порядке их следования) по типам данных.
  • В результирующем наборе используются имена столбцов, заданные в первом запросе.
  • Предложение ORDER BY применяется к результату соединения, поэтому оно может быть указано только в конце составного запроса.
Пример. Найти номера моделей и цены ПК и ПК-блокнотов:
SELECT model, price
FROM PC
UNION
SELECT model, price
FROM Laptop
ORDER BY price DESC;

modelprice
17501200.0
17521150.0
12981050.0
1233980.0
1321970.0
1233950.0
1121850.0
1298700.0
1232600.0
1233600.0
1232400.0
1232350.0
1260350.0
Пример. Найти тип продукции, номер модели и цену ПК и ПК-блокнотов:
SELECT Product .type, PC.model, price
FROM PC INNER JOIN
    Product ON PC.model = Product .model
UNION
SELECT Product .type, Laptop.model, price
FROM Laptop INNER JOIN
    Product ON Laptop.model = Product .model
ORDER BY price DESC;

typemodelprice
Laptop17501200.0
Laptop17521150.0
Laptop12981050.0
PC1233980.0
Laptop1321970.0
PC1233950.0
PC1121850.0
Laptop1298700.0
PC1232600.0
PC1233600.0
PC1232400.0
PC1232350.0
PC1260350.0

Пересечение и разность

В стандарте языка SQL имеются предложения оператора SELECT для выполнения операций пересечения и разности запросов. Этими предложениями являются INTERSECT(пересечение) и EXCEPT (разность), которые работают аналогично предложению UNION. В результирующий набор попадают только те строки, которые присутствуют в обоих запросах (INTERSECT) или только те строки первого запроса, которые отсутствуют во втором (EXCEPT).
Однако многие СУБД не поддерживают эти предложения в операторе SELECT. Это справедливо и для MS SQL Server. Поэтому для выполнения операций пересечения и разности могут быть использованы другие средства. Здесь уместно заметить, что один и тот же результат можно получить с помощью различных формулировок оператора SELECT. В случае пересечения и разности можно воспользоваться предикатом существования EXISTS.

Предикат EXISTS

EXISTS::=
        [NOT] EXISTS (<табличный подзапрос>)
Предикат EXISTS принимает значение TRUE, если подзапрос возвращает любое количество строк, иначе его значение равно FALSE. Для NOT EXISTS все наоборот. Этот предикат никогда не принимает значение UNKNOWN.
Обычно (как и в нашем случае) предикат EXISTS используется в зависимых подзапросах. Этот вид подзапроса имеет внешнюю ссылку, связанную со значением в основном запросе. Результат подзапроса может зависеть от этого значения и должен оцениваться отдельно для каждой строки запроса, в котором содержится данный подзапрос. Поэтому предикат EXISTS может иметь разные значения для каждой строки основного запроса.
Пример на пересечение. Найти тех производителей ПК-блокнотов, которые производят также и принтеры:
SELECT DISTINCT maker
FROM Product AS Lap_product
WHERE type = 'Laptop' AND EXISTS
       (SELECT maker
       FROM Product
       WHERE type = 'Printer' AND maker = Lap_product.maker);

В подзапросе выбираются производители принтеров и сравниваются с производителем, значение которого передается из основного запроса. В основном же запросе отбираются производители ПК-блокнотов. Таким образом, для каждого производителя ПК-блокнотов проверяется, возвращает ли подзапрос строки (т.е. этот производитель также производит принтеры). Поскольку два условия в предложении WHERE должны выполняться одновременно (AND), то в результирующий набор попадут нужные строки. DISTINCT используется для того, чтобы каждый производитель присутствовал в выходных данных только один раз. В результате получим:

maker
A
Пример на разность. Найти тех производителей ПК-блокнотов, которые не производят принтеров:
SELECT DISTINCT maker
FROM Product AS Lap_product
WHERE type = 'Laptop' AND NOT EXISTS
       (SELECT maker
       FROM Product
       WHERE type = 'Printer' AND maker = Lap_product.maker);

В этом случае достаточно заменить в предыдущем примере EXIST на NOT EXIST. Т.е. выходные данные составят только те уникальные строки основного запроса, для которых подзапрос не возвращает ни одной строки. В итоге получим:

maker
B
C
Рекомендуемые упражнения: 729353641454849.

Использование ключевых слов SOME | ANY и ALL с предикатами сравнения

Использование ключевых слов SOME | ANY и ALL с предикатами сравнения

<выражение> <оператор сравнения> SOME|ANY (<подзапрос>)
SOME и ANY являются синонимами, т.е. может использоваться любое из них. Результатом подзапроса является один столбец величин. Если для какого-нибудь значения V, получаемого из подзапроса, результат операции "<значение выражения> <оператор сравнения> V " равняется TRUE, то предикат ANY также равняется TRUE.


<выражение> <оператор сравнения> ALL (<подзапрос>)
исполняется так же, как и ANY, но для всех значений, получаемых из подзапроса, проверка должна удовлетворять результату TRUE для предиката "<значение выражения> <оператор сравнения> V ".
Пример. Найти поставщиков компьютеров, моделей которых нет в продаже (т.е. отсутствуют в таблице PC):
SELECT DISTINCT maker
FROM Product
WHERE type = 'PC' AND NOT model = ANY
       (SELECT model
       FROM PC);

Оказалось, что только у поставщика Е есть модели отсутствующие в продаже:

maker
E
Рассмотрим подробно этот пример. Предикат
model = ANY (SELECT model FROM PC);
вернет значение TRUE, если модель, определяемая полем model основного запроса, найдется в списке моделей таблицы PC (возвращаемом подзапросом). Поскольку предикат используется в запросе с отрицанием NOT, то значение TRUE будет получено, если модели не окажется в списке. Этот предикат проверяется для каждой записи основного запроса, которыми являются все модели ПК (предикат type = 'PC') из таблицы Product. Результирующий набор состоит из одного столбца - имени производителя. Чтобы один производитель не выводился несколько раз (что может случиться, если он производит несколько моделей, отсутствующих в таблице PC), используется служебное слово DISTINCT.
Пример. Найти модели и цены ПК-блокнотов, стоимость которых превышает стоимость любого ПК:
SELECT DISTINCT model, price
FROM Laptop
WHERE price > ALL
       (SELECT price
       FROM PC);

modelprice
12981050.0
17501200.0
17521150.0
Приведем формальные правила оценки предикатов, использующих параметры ANY|SOME и ALL:
  • Если определен параметр ALL или SOME и все результаты сравнения значения выражения и каждого значения, полученного из подзапроса, являются TRUE, истинностное значение равно TRUE.
  • Если результат выполнения подзапроса не содержит строк и определен параметр ALL, результат равен TRUE. Если же определен параметр SOME, результат равен FALSE.
  • Если определен параметр ALL и результат сравнения значения выражения хотя бы с одним значением, полученным из подзапроса, является FALSE, истинностное значение равно FALSE.
  • Если определен параметр SOME и хотя бы один результат сравнения значения выражения и значения, полученного из подзапроса, является TRUE, истинностное значение равно TRUE.
  • Если определен параметр SOME и каждое сравнение значения выражения и значений, полученных из подзапроса, равно FALSE, истинностное значение тоже равно FALSE.
  • В любом другом случае результат будет равен UNKNOWN.
Рекомендуемые упражнения: 172430.

Еще о подзапросах

Заметим, что в общем случае запрос возвращает множество значений. Поэтому использование подзапроса в предложении WHERE без операторов EXISTSINALL и ANY, которые дают булево значение, может привести к ошибке времени выполнения запроса.
Пример. Найти модели и цены ПК, стоимость которых превышает минимальную стоимость ПК-блокнотов:
SELECT DISTINCT model, price
FROM PC
WHERE price >
       (SELECT MIN(price)
       FROM Laptop);

Этот запрос вполне корректен, т.к. скалярное значение price сравнивается с подзапросом, который возвращает единственное значение. В результате получим три модели ПК:

modelprice
1121850.0
1233950.0
1233980.0
Однако, если в ответ на вопрос "найти модели и цены ПК, стоимость которых совпадает со стоимостью ПК-блокнота" написать следующий запрос:
SELECT DISTINCT model, price
FROM PC
WHERE price =
       (SELECT price
       FROM Laptop);

то при выполнении последнего мы можем получить такое сообщение об ошибке:
Эта ошибка будет возникать при сравнении скалярного значения с подзапросом, который либо возвращает более одного значения, либо ни одного.
Подзапросы, в свою очередь, также могут содержать вложенные запросы.
С другой стороны, подзапрос, возвращающий множество строк и содержащий несколько столбцов, вполне естественно может использоваться в предложении FROM. Это позволяет ограничить набор столбцов и/или строк при выполнении операции соединения таблиц.
Пример. Вывести производителя, тип, модель и частоту процессора для ПК-блокнотов, частота процессора которых превышает 600 МГц.
Этот запрос может быть сформулирован, например, следующим образом:
SELECT prod.maker, lap.*
FROM (SELECT 'Laptop' AS type, model, speed
       FROM Laptop
       WHERE speed > 600) AS lap INNER JOIN
       (SELECT maker, model
       FROM Product) AS prod ON lap.model = prod.model;

В результате получим:
makertypemodelspeed
BLaptop1750750
ALaptop1752750
Наконец, подзапросы могут присутствовать в предложении SELECT. Это иногда позволяет весьма компактно сформулировать запрос.
Пример. Найти разницу между средними значениями цены ПК-блокнотов и ПК, т.е. на сколько в среднем ПК-блокнот стоит дороже, чем ПК.
Здесь вообще можно обойтись одним предложением SELECT:
SELECT (SELECT AVG(price)
       FROM Laptop) -
       (SELECT AVG(price)
       FROM PC) AS dif_price;

В результате получим:
dif_price
365.81818181818187
Рекомендуемые упражнения: 18252627283739465657.