к алгоритмизации к оглавлению Описание SQL

Мартин Грубер

Понимание SQL

(перевод Лебедева В.Н., под редакцией Булычева В.Н.)

Соотнесенные подзапросы

Как сформировать соотнесенный подзапрос
Как работает соотнесенный подзапрос
Использование соотнесенных подзапросов
Сравнение таблицы с собой
Соотнесенные подзапросы в предложении HAVING
Соотнесенные подзапросы и объединения
Резюме
Работа с SQL
Как работает EXISTS?
Выбор столбцов с помощью EXISTS
Использование EXISTS с соотнесенными подзапросами
Комбинация из EXISTS и объединения
Использование NOT EXISTS
EXISTS и агрегаты
Более удачный пример подзапроса
Резюме
Работа с SQL
Использование операторов ANY, ALL и SOME
Специальные операторы ANY или SOME
Использование IN или EXISTS вместо оператора ANY

В ЭТОЙ ГЛАВЕ, МЫ ПРЕДСТАВИМ ВАМ ТИП подзапроса, о котором мы не говорили в Главе 10 — соотнесенный подзапрос. Вы узнаете, как использовать соотнесенные подзапросы в предложениях запросов WHERE и HAVING. Сходства и различия между соотнесенными подзапросами и объединениями будут обсуждаться далее, и вы сможете повысить ваше знание псевдонимов и префиксов имени таблицы, когда они необходимы, и как их использовать.

Как сформировать соотнесенный подзапрос

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

Соотнесенный подзапрос — один из большого количества тонких понятий в SQL из-за сложности в его оценке.

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

Например, имеется один способ найти всех заказчиков в Заказах на 3-е Октября (вывод показывается в Рисунке 11.1):

SELECT *
FROM Customers outer
WHERE 10/03/1990 IN (SELECT odate
FROM Orders inner
WHERE outer.cnum = inner.cnum);

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers outer |
| WHERE 10/03/1990 IN |
| (SELECT odate |
| FROM Orders inner |
| WHERE outer.cnum = inner.cnum); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ----- |
| 2001 Hoffman London 100 1001 |
| 2003 Liu San Jose 200 1002 |
| 2008 Cisneros San Jose 300 1007 |
| 2007 Pereira Rome 100 1004 |
===============================================

Рисунок 11.1. Использование соотнесенного подзапроса.

Примечание. В СУБД Interbase "INNER" и "OUTER" являются ключевыми словами, описывающими тип объединения (JOIN TYPE) поэтому запрос должен быть изменен, например, так:

SELECT *
FROM Customers out
WHERE CAST('10/03/1990' AS DATE) IN (SELECT odate
FROM Orders inn
WHERE out.cnum = inn.cnum);

Как работает соотнесенный подзапрос

В вышеупомянутом примере, "внутренний" (inner) и "внешний" (outer), это псевдонимы, подобно обсужденным в Главе 9. Мы выбрали эти имена для большей ясности; они отсылают к значениям внутренних и внешних запросов, соответственно. Так как значение в поле cnum внешнего запроса меняется, внутренний запрос должен выполняться отдельно для каждой строки внешнего запроса. Строка внешнего запроса, для которого внутренний запрос каждый раз будет выполнен, называется текущей строкой-кандидатом. Следовательно, процедура оценки выполняемой соотнесенным подзапросом — это:

выбрать строку из таблицы именованной во внешнем запросе. Это будет текущая строка-кандидат;

сохранить значения из этой строки-кандидата в псевдониме с именем в предложении FROM внешнего запроса;

выполнить подзапрос. Везде, где псевдоним, данный для внешнего запроса, найден (в этом случае "внешний"), использовать значение для текущей строки-кандидата. Использование значения из строки-кандидата внешнего запроса в подзапросе называется — внешней ссылкой;
оценить предикат внешнего запроса на основе результатов подзапроса выполняемого в шаге 3. Он определяет, выбирается ли строка-кандидат для вывода;

повторить процедуру для следующей строки-кандидата таблицы, и так далее пока все строки таблицы не будут проверены.

В вышеупомянутом примере, SQL осуществляет следующую процедуру:

выбирает строку Hoffman из таблицы Заказчиков;
сохраняет эту строку как текущую строку-кандидат под псевдонимом — "внешним";
затем выполняется подзапрос. Подзапрос просматривает всю таблицу Заказов, чтобы найти строки, где значение поля cnum такое же, как значение outer.cnum, которое в настоящее время равно 2001 — поле cnum строки Hoffman. Затем он извлекает поле odate из каждой строки таблицы Заказов, для которой это верно, и формирует набор значений поля odate;
получив набор всех значений поля odate, для поля cnum = 2001, он проверяет предикат основного запроса, чтобы видеть, имеется ли значение на 3 Октября в этом наборе. Если это так (а это так), то он выбирает строку Hoffmanа для вывода ее из основного запроса.
Он повторяет всю процедуру, используя строку Giovanni как строку-кандидата, и затем сохраняет повторно пока каждая строка таблицы Заказчиков не будет проверена.

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

SELECT *
FROM Customers first, Orders second
WHERE first.cnum = second.cnum AND second.odate = 10/03/1990;

Обратите внимание, что Cisneros был выбран дважды, по одному разу для каждого Заказа, который он имел для данной даты. Мы могли бы устранить это, используя SELECT DISTINCT вместо простого оператора SELECT. Но это необязательно в варианте подзапроса. Оператор IN, используемый в варианте подзапроса, не делает никакого различия между значениями, которые выбираются подзапросом один раз и значениями, которые выбираются неоднократно. Следовательно, DISTINCT необязателен.

========================= SQL Execution Log ========================
|SELECT * |
|FROM Customers first, Orders second |
|WHERE first.cnum = second.cnum AND second.odate = 10/03/1990; |
|======================================================================|
|cnum cname city rating snum onum amt odate cnum1 snum1|
|---- -------- -------- ------ ---- ---- ------- ---------- ----- -----| |2001 Hoffman London 100 1001 3003 767,19 10/03/1990 2001 1001|
|1002 Liu San Jose 200 1002 3005 5160,45 10/03/1990 2003 1002|
|2007 Pereira Rome 100 1004 3002 1900,10 10/03/1990 2007 1004|
|2008 Cisneros San Jose 300 1007 3001 18,69 10/03/1990 2008 1007|
|2008 Cisneros San Jose 300 1007 3006 1098,16 10/03/1990 2008 1007|
======================================================================

Рисунок 11.2. Использование объединения вместо соотнесенного подзапроса.

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

SELECT snum, sname
FROM Salespeople main
WHERE 1 < (SELECT COUNT (*)
FROM Customers
WHERE snum = main.snum);

Обратите внимание, что предложение FROM подзапроса в этом примере не использует псевдоним. При отсутствии имени таблицы или префикса псевдонима, SQL может для начала принять, что любое поле выводится из таблицы с именем, указанным в предложении FROM текущего запроса. Если поле с этим именем отсутствует (в нашем случае — snum) в той таблице, SQL будет проверять внешние запросы. Именно поэтому, префикс имени таблицы обычно необходим в соотнесенных подзапросах для отмены этого предположения. Псевдонимы также часто запрашиваются, чтобы давать вам возможность ссылаться к той же самой таблице во внутреннем и внешнем запросе без какой-либо неоднозначности.

Использование соотнесенных подзапросов для нахождения ошибок

Иногда полезно выполнять запросы, которые разработаны специально так, чтобы находить ошибки. Это всегда возможно при дефектной информации, которую можно ввести в вашу базу данных, и, если она введена, бывает трудно ее определить. Следующий запрос не должен производить никакого вывода. Он просматривает таблицу Заказов, чтобы видеть, совпадают ли поля snum и cnum в каждой строке таблицы Заказчиков, и выводит каждую строку, где этого совпадения нет. Другими словами, запрос выясняет, тот ли продавец кредитовал каждую продажу (он воспринимает поле cnum, как первичный ключ таблицы Заказчиков, который не будет иметь никаких двойных значений в этой таблице).

SELECT *
FROM Orders main
WHERE NOT snum = (SELECT snum
FROM Customers
WHERE cnum = main.cnum);

При использовании механизма справочной целостности (обсужденного в Главе 19), вы можете быть гарантированы от некоторых ошибок такого вида. Этот механизм не всегда доступен, хотя его использование желательно во всех случаях, причем поиск ошибки запроса описанный выше, может быть еще полезнее.

Сравнение таблицы с собой

Вы можете также использовать соотнесенный подзапрос, основанный на той же самой таблице, что и основной запрос. Это даст вам возможность извлечь определенные сложные формы произведенной информации. Например, мы можем найти все Заказы со значениями сумм приобретений выше среднего для их заказчиков (вывод показан в Рисунке 11.4):

SELECT *
FROM Orders outer
WHERE amt > (SELECT AVG (amt)
FROM Orders inner
WHERE inner.cnum = outer.cnum);

=============== SQL Execution Log ==============
| SELECT * |
| FROM Orders outer |
| WHERE amt > |
| (SELECT AVG (amt) |
| FROM Orders inner |
| WHERE inner.cnum = outer.cnum |
| =============================================== |
| onum amt odate cnum snum |
| ----- -------- ---------- ----- ------ |
| 3006 1098.19 10/03/1990 2008 1007 |
| 3010 1309.00 10/06/1990 2004 1002 |
| 3011 9891.88 10/06/1990 2006 1001 |
=================================================

Рисунок 11.4. Соотнесение таблицы с собой.

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

SELECT *
FROM Orders outer
WHERE amt >= (SELECT AVG (amt)
FROM Orders inner
WHERE inner.cnum = outer.cnum);

=============== SQL Execution Log ==============
| SELECT * |
| FROM Orders outer |
| WHERE amt > = |
| (SELECT AVG (amt) |
| FROM Orders inner |
| WHERE inner.cnum = outer.cnum); |
| =============================================== |
| onum amt odate cnum snum |
| ----- -------- ---------- ----- ------ |
| 3003 767.19 10/03/1990 2001 1001 |
| 3002 1900.10 10/03/1990 2007 1004 |
| 3005 5160.45 10/03/1990 2003 1002 |
| 3006 1098.19 10/03/1990 2008 1007 |
| 3009 1713.23 10/04/1990 2002 1003 |
| 3010 1309.95 10/06/1990 2004 1002 |
| 3011 9891.88 10/06/1990 2006 1001 |
=================================================

Рисунок 11.5. Выбираются Заказы, которые >= средней сумме приобретений для их заказчиков.

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

Примечание. В примерах запросов, приведенных в этом разделе, используются псевдонимы "inner" и "outer", которые в СУБД Interbase (возможно, и в других СУБД) являются ключевыми словами, и, следовательно, должны быть изменены.

Соотнесенные подзапросы в предложении HAVING

Также как предложение HAVING может брать подзапросы, оно может брать и соотнесенные подзапросы. Когда вы используете соотнесенный подзапрос в предложении HAVING, вы должны ограничивать внешние ссылки к позициям, которые могли бы непосредственно использоваться в самом предложении HAVING. Вы можете вспомнить из Главы 6, что предложение HAVING может использовать только агрегатные функции, которые указаны в их предложении SELECT или поля используемые в их предложении GROUP BY. Они являются только внешними ссылками, которые вы можете делать. Все это потому, что предикат предложения HAVING оценивается для каждой группы из внешнего запроса, а не для каждой строки. Следовательно, подзапрос будет выполняться один раз для каждой группы выведенной из внешнего запроса, а не для каждой строки.

Предположим, что вы хотите суммировать значения сумм приобретений покупок из таблицы Заказов, сгруппировав их по датам, удалив все даты, где бы сумма (SUM) не была, по крайней мере, на 2000.00 выше максимальной (MAX) суммы:

Select odate, SUM (amt)
FROM orders a
GROUP BY odate
HAVING SUM (amt) > (SELECT 2000.00 + MAX (amt)
FROM Orders b
WHERE a.odate = b.odate);

Подзапрос вычисляет значение MAX для всех строк с той же самой датой, что и у текущей агрегатной группы основного запроса. Это должно быть выполнено, как и ранее, с использованием предложения WHERE. Сам подзапрос не должен использовать предложения GROUP BY или HAVING.

Соотнесенные подзапросы и объединения

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

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

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

Резюме

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

Следующий шаг — описание некоторых специальных операторов SQL. Они берут подзапросы как аргументы, как это делает IN, но в отличие от IN, они могут использоваться только в подзапросах. Первый из них, представленный в Главе 12, — называется EXISTS.

Работа с SQL

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

(См. Приложение A для ответов.)

Использование оператора EXISTS

ТЕПЕРЬ, КОГДА ВЫ ХОРОШО ОЗНАКОМЛЕНЫ С ПОДЗАПРОСАМИ, мы можем говорить о некоторых специальных операторах, которые всегда берут подзапросы как аргументы. Вы узнаете о первом из них в этой главе. Остальные будут описаны в следующей главе.

Оператор EXISTS используется, чтобы указать предикату, производить ли подзапросу вывод или нет. В этой главе вы узнаете, как использовать этот оператор со стандартными и (обычно) соотнесенными подзапросами. Мы будем также обсуждать специальные размышления, которые перейдут в игру, когда вы будете использовать этот оператор, как относительный агрегат, как пустой указатель NULL и как оператор Буля. Кроме того, вы можете повысить ваш профессиональный уровень относительно подзапросов, исследуя их в более сложных прикладных программах, чем те, которые мы видели до сих пор.

Как работает EXISTS?

EXISTS — это оператор, который производит верное или неверное значение, другими словами, выражение Буля (см. Главу 4 для обзора этого термина). Это означает, что он может работать автономно в предикате или в комбинации с другими выражениями Буля, использующими Булевы операторы AND, OR, и NOT. Он берет подзапрос как аргумент и оценивает его как верный, если тот производит любой вывод, или как неверный, если тот не делает этого. Этим он отличается от других операторов предиката, в которых он не может быть неизвестным. Например, мы можем решить, извлекать ли нам некоторые данные из таблицы Заказчиков, если, и только если, один или более заказчиков в этой таблице находятся в San Jose (вывод для этого запроса показывается в Рисунке 12.1):

SELECT cnum, cname, city
FROM Customers
WHERE EXISTS (SELECT *
FROM Customers
WHERE city = 'San Jose');

=============== SQL execution Log ============
| SELECT snum, sname, city |
| FROM Customers |
| WHERE EXISTS |
| (SELECT * |
| FROM Customers |
| WHERE city = 'San Jose'); |
| ============================================= |
| cnum cname city |
| ----- -------- ---- |
| 2001 Hoffman London |
| 2002 Giovanni Rome |
| 2003 Liu San Jose |
| 2004 Grass Berlin |
| 2006 Clemens London |
| 2008 Cisneros San Jose |
| 2007 Pereira Rome |
===============================================

Рисунок 12.1. Использование оператора EXISTS.

Внутренний запрос выбирает все данные для всех заказчиков в San Jose. Оператор EXISTS во внешнем предикате отмечает, что некоторый вывод был произведен подзапросом, и поскольку выражение EXISTS было полным предикатом, делает предикат верным. Подзапрос (не соотнесенный) был выполнен только один раз для всего внешнего запроса, и, следовательно, имеет одно значение во всех случаях. Поэтому EXISTS, когда используется этим способом, делает предикат верным или неверным для всех строк сразу, что это не так уж полезно для извлечения определенной информации.

Выбор столбцов с помощью EXISTS

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

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

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

В соотнесенном подзапросе предложение EXISTS оценивается отдельно для каждой строки таблицы, имя которой указано во внешнем запросе, точно также как и другие операторы предиката, когда вы используете соотнесенный подзапрос. Это дает возможность использовать EXISTS как верный предикат, который генерирует различные ответы для каждой строки таблицы, указанной в основном запросе. Следовательно, информация из внутреннего запроса будет сохранена, если выведена непосредственно, когда вы используете EXISTS таким способом. Например, мы можем вывести продавцов, которые имеют многочисленных заказчиков (вывод для этого запроса показывается в Рисунке 12.2):

SELECT DISTINCT snum
FROM Customers outer
WHERE EXISTS (SELECT *
FROM Customers inner
WHERE inner.snum = outer.snum AND
inner.cnum <> outer.cnum);

============= SQL Execution Log ==============
| SELECT DISTINCT cnum |
| FROM Customers outer |
| WHERE EXISTS |
| (SELECT * |
| FROM Customers inner |
| WHERE inner.snum = outer.snum |
| AND inner.cnum <> outer.cnum); |
|===============================================|
| cnum |
| ----- |
| 1001 |
| 1002 |
===============================================

Рисунок 12.2. Использование EXISTS с соотнесенным подзапросом.

Для каждой строки-кандидата внешнего запроса (представляющей заказчика, проверяемого в настоящее время), внутренний запрос находит строки, которые совпадают со значением поля snum (которое имел продавец), но не со значением поля cnum (соответствующего другим заказчикам). Если любые такие строки найдены внутренним запросом, это означает, что имеются два разных заказчика, обслуживаемых текущим продавцом (т.е. продавцом заказчика в текущей строке-кандидате из внешнего запроса). Поэтому предикат EXISTS верен для текущей строки, и номер продавца — поле (snum) таблицы, указанной во внешнем запросе, будет выведен. Если был DISTINCT не указан, каждый из этих продавцов будет выбран один раз для каждого заказчика, к которому он назначен.

Комбинация из EXISTS и объединения

Однако для нас может быть полезнее вывести больше информации об этих продавцах, а не только их номера. Мы можем сделать это, объединив таблицу Заказчиков с таблицей Продавцов (вывод для запроса показывается в Рисунке 12.3):

SELECT DISTINCT first.snum, sname, first.city
FROM Salespeople first, Customers second
WHERE EXISTS (SELECT *
FROM Customers third
WHERE second.snum = third.snum AND
second.cnum <> third.cnum) AND
first.snum = second.snum;

============= SQL Execution Log ==============
| SELECT DISTINCT first.snum, sname, first.city |
| FROM Salespeople first, Customers second |
| WHERE EXISTS |
| (SELECT * |
| FROM Customers third |
| WHERE second.snum = third.snum |
| AND second.cnum <> third.cnum) |
| AND first.snum = second.snum; |
|===============================================|
| cnum cname city |
| ----- -------- ---- |
| 1001 Peel London |
| 1002 Serres San Jose |
===============================================

Рисунок 12.3. Комбинация EXISTS с объединением.

Внутренний запрос здесь, как и в предыдущем варианте, фактически сообщает, что псевдоним был изменен. Внешний запрос — это объединение таблицы Продавцов с таблицей Заказчиков, наподобие того, что мы видели прежде. Новое предложение основного предиката (AND first.snum = second.snum) естественно оценивается на том же самом уровне, что и предложение EXISTS. Это — функциональный предикат самого объединения, сравнивающий две таблицы из внешнего запроса в терминах поля snum, которое являются для них общим. Из-за Булева оператора AND, оба условия основного предиката должны быть верны в Заказе для верного предиката. Следовательно, результаты подзапроса имеют смысл только в тех случаях, когда вторая часть запроса верна, а объединение выполнимо. Таким образом, комбинация объединения и подзапроса может стать очень мощным способом обработки данных.

Использование NOT EXISTS

Предыдущий пример дал понять, что EXISTS может работать в комбинации с операторами Буля. Конечно, то, что является самым простым способом для использования и вероятно наиболее часто используется с EXISTS — это оператор NOT. Один из способов, которым мы могли бы найти всех продавцов только с одним заказчиком, будет состоять в том, чтобы инвертировать наш предыдущий пример. (Вывод для этого запроса показывается в Рисунке 12.4.)

SELECT DISTINCT snum
FROM Customers outer
WHERE NOT EXISTS (SELECT *
FROM Customers inner
WHERE inner.snum = outer.snum AND
inner.cnum <> outer.cnum);

============== SQL Execution Log =============
| SELECT DISTINCT snum |
| FROM Salespeople outer |
| WHERE NOT EXISTS |
| (SELECT * |
| FROM Customers inner |
| WHERE inner.snum = outer.snum |
| AND inner.cnum <> outer.cnum); |
|===============================================|
| cnum |
| ----- |
| 1003 |
| 1004 |
| 1007 |
===============================================

Рисунок 12.4. Использование NOT EXISTS.

EXISTS и агрегаты

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

Попытка использовать агрегаты с EXISTS таким способом, вероятно, покажет, что проблема неверно решалась от начала до конца.

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

В любом случае, вы можете получить тот же самый результат более легко, выбрав поле которое вы использовали в агрегатной функции, вместо использования самой этой функции. Другими словами, предикат — EXISTS (SELECT COUNT (DISTINCT sname) FROM Salespeople) — будет эквивалентен EXISTS (SELECT sname FROM Salespeople) который был позволен выше.

Более удачный пример подзапроса

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

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

Имеется запрос, который извлекает строки всех продавцов, которые имеют заказчиков с больше чем одним текущим Заказом. Это не обязательно самое простое решение этой проблемы, но оно предназначено, скорее, показать улучшенную логику SQL. Вывод этой информации связывает все три наши типовых таблицы:

SELECT *
FROM Salespeople first
WHERE EXISTS (SELECT *
FROM Customers second
WHERE first.snum = second.snum AND
1 < (SELECT COUNT (*)
FROM Orders
WHERE Orders.cnum = second.cnum));

Вывод для этого запроса показывается в Рисунке 12.5.

============== SQL Execution Log =============
| FROM Salespeople first |
| WHERE EXISTS |
| (SELECT * |
| FROM Customers second |
| WHERE first.snum = second.snum |
| AND 1 < |
| (SELECT CONT (*) |
| FROM Orders |
| WHERE Orders.cnum = second.cnum)); |
|===============================================|
| cnum cname city comm |
| ----- -------- ---- -------- |
| 1001 Peel London 0.17 |
| 1002 Serres San Jose 0.13 |
| 1007 Rifkin Barselona 0.15 |
===============================================

Рисунок 12.5. Использование EXISTS с комплексным подзапросом.

Мы могли бы разобрать вышеупомянутый запрос примерно так:

Берем каждую строку таблицы Продавцов как строку-кандидат (внешний запрос) и выполняем подзапросы. Для каждой строки-кандидата из внешнего запроса берем в соответствие каждую строку из таблицы Заказчиков (средний запрос). Если текущая строка заказчиков не совпадает с текущей строкой продавца (т.е. если first.snum <> second.snum), предикат среднего запроса неправилен. Всякий раз, когда мы находим заказчика в среднем запросе, который совпадает с продавцом во внешнем запросе, мы должны рассматривать сам внутренний запрос, чтобы определить, будет ли наш средний предикат запроса верен. Внутренний запрос считает число Заказов текущего заказчика (из среднего запроса). Если это число больше 1, предикат среднего запроса верен, и строки выбираются. Это делает EXISTS предикат внешнего запроса верным для текущей строки продавца, и означает, что, по крайней мере, один из текущих заказчиков продавца имеет более одного заказа.

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

Кроме того, этот запрос, даже если он кажется удобным, довольно извилистый способ извлечения информации и делает много работы. Он связывает три разных таблицы, чтобы дать вам эту информацию, а если таблиц больше, чем здесь указано, будет трудно получить ее напрямую (хотя это не единственный способ, и не обязательно лучший способ в SQL). Возможно, вам нужно получать эту информацию регулярно — если, например, вы назначаете премию в конце недели продавцам, получившим более одного Заказа от одного заказчика. В этом случае, нужно ввести команду и сохранить ее для повторного использования, по мере того как данные будут меняться (лучше всего сделать это с помощью представления, которое мы будем проходить в Главе 20).

Резюме

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

Следующим шагом будет овладение тремя другими специальными операторами, которые берут подзапросы как аргументы, это — ANY, ALL, и SOME. Как вы увидите в Главе 13, это — альтернативные формулировки некоторых вещей, которые вы уже использовали, но которые в некоторых случаях могут оказаться более предпочтительными.

Работа с SQL

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

(См. Приложение A для ответов.)

Использование операторов ANY, ALL и SOME

ТЕПЕРЬ, КОГДА ВЫ ОВЛАДЕЛИ ОПЕРАТОРОМ EXISTS, Вы узнаете приблизительно три специальных оператора ориентируемых на подзапросы. (Фактически, имеются только два, так как ANY и SOME — одно и то же.) Если вы поймете работу этих операторов, вы будете понимать все типы подзапросов предиката, используемых в SQL. Кроме того, вам будут представлены различным способы, где данный запрос может быть сформирован, используя различные типы подзапросов предиката, и вы поймете преимущества и недостатки каждого из этих подходов.

ANY, ALL, и SOME напоминают EXISTS, который воспринимает подзапросы как аргументы; однако они отличаются от EXISTS тем, что используются совместно с реляционными операторами. В этом отношении, они напоминают оператор IN, когда он используется с подзапросами; они берут все значения, выведенные подзапросом, и обрабатывают их, как модуль. Однако, в отличие от IN, они могут использоваться только с подзапросами.

Специальные операторы ANY или SOME

Операторы SOME и ANY — взаимозаменяемы везде и там где мы используем ANY, SOME будет работать точно так же. Различие в терминологии состоит в том, чтобы позволить людям использовать тот термин, который наиболее однозначен. Это может создать проблему; потому что, как мы это увидим, наша интуиция может иногда вводить в заблуждение.

Имеется новый способ нахождения продавца с заказчиками, размещенными в их городах (вывод для этого запроса показывается в Рисунке 13.1):

SELECT *
FROM Salespeople
WHERE city = ANY (SELECT city
FROM Customers);

Оператор ANY берет все значения выведенные подзапросом, (для этого случая — это все значения city в таблице Заказчиков), и оценивает их как верные, если любой (ANY) из их равняется значению города текущей строки внешнего запроса.

=============== SQL Execution Log ============
| SELECT * |
| FROM Salespeople |
| WHERE city = ANY |
| (SELECT city |
| FROM Customers); |
| ============================================= |
| cnum cname city comm |
| ----- -------- ---- -------- |
| 1001 Peel London 0.12 |
| 1002 Serres San Jose 0.13 |
| 1004 Motika London 0.11 |
===============================================

Рисунок 13.1. Использование оператора ANY.

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

Использование операторов IN или EXISTS вместо оператора ANY

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

SELECT *
from Salespeople
WHERE city IN (SELECT city
FROM Customers);

Этот запрос будет производить вывод, показанный в Рисунке 13.2.

=============== SQL Execution Log ============
| SELECT * |
| FROM Salespeople |
| WHERE city IN (SELECT city |
| FROM Customers); |
| ============================================= |
| cnum cname city comm |
| ----- -------- ---- -------- |
| 1001 Peel London 0.12 |
| 1002 Serres San Jose 0.13 |
| 1004 Motika London 0.11 |
===============================================

Рисунок 13.2. Использование IN в качестве альтернативы к ANY.

Однако оператор ANY может использовать другие реляционные операторы, кроме равенства (=), и, таким образом, делать сравнения, которые являются выше возможностей IN. Например, мы могли бы найти всех продавцов с их заказчиками, имена которых следуют в алфавитном порядке за именами продавцов (вывод показан на Рисунке 13.3).

SELECT *
FROM Salespeople
WHERE sname < ANY (SELECT cname
FROM Customers);

=============== SQL execution Log ============
| SELECT * |
| FROM Salespeople |
| WHERE sname < ANY |
| (SELECT cname |
| FROM Customers); |
| ============================================= |
| cnum cname city comm |
| ----- -------- ---- -------- |
| 1001 Peel London 0.12 |
| 1004 Motika London 0.11 |
| 1003 Axelrod New York 0.10 |
===============================================

Рисунок 13.3. Использование оператора ANY с оператором "меньше" (<).

Были выбраны все строки, кроме Serres и Rifkin, потому что нет заказчиков, чьи имена следовали бы за ними в алфавитном порядке. Обратите внимание, что это является основным эквивалентом следующему запросу с EXISTS (вывод показывается на Рисунке 13.4):

SELECT *
FROM Salespeople outer
WHERE EXISTS (SELECT *
FROM Customers inner
WHERE outer.sname < inner.cname);

=============== SQL Execution Log ============
| SELECT * |
| FROM Salespeople outer |
| WHERE EXISTS |
| (SELECT * |
| FROM Customers inner |
| WHERE outer.sname < inner.cname); |
| ============================================= |
| cnum cname city comm |
| ----- -------- ---- -------- |
| 1001 Peel London 0.12 |
| 1004 Motika London 0.11 |
| 1003 Axelrod New York 0.10 |
===============================================

Рисунок 13.4. Использование EXISTS как альтернатива оператору ANY.

Любой запрос, который может быть сформулирован с ANY (или, как мы увидим, с ALL), мог быть также сформулирован с EXISTS, хотя наоборот будет неверно. Строго говоря, вариант с EXISTS не абсолютно идентичен вариантам с ANY или с ALL из-за различия в том, как обрабатываются пустые (NULL) значения (что будет обсуждаться позже в этой главе). Тем не менее, с технической точки зрения, вы могли бы делать это без ANY и ALL, если бы вы стали очень находчивы в использовании EXISTS (и IS NULL).

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

Подзапросы ANY или ALL могут выполняться один раз и иметь вывод, используемый чтобы определять предикат для каждой строки основного запроса. EXISTS, с другой стороны, берет соотнесенный подзапрос, который требует, чтобы весь подзапрос повторно выполнялся для каждой строки основного запроса. Сервер SQL пытается найти наиболее эффективный способ выполнения любой команды и может попробовать преобразовать менее эффективную формулу запроса в более эффективную, но вы не всегда можете рассчитывать на получение самой эффективной формулировки.

Основная причина для формулировки EXISTS как альтернативы ANY и ALL в том, что ANY и ALL могут быть несколько неоднозначны, из-за способа использования этих терминов в английском языке, как вы это скоро увидите. С приходом понимания различия способов формулирования данного запроса, вы сможете поработать над процедурами, которые сейчас кажутся Вам трудными или неудобными.

Как ANY может стать неоднозначным

Как подразумевалось выше, ANY не полностью однозначен. Если мы создаем запрос, чтобы выбрать заказчиков, которые имеют больший рейтинг чем любой заказчик в Риме, мы можем получить вывод, который несколько отличался бы от того, что мы ожидали (как показано в Рисунке 13.5):

SELECT *
FROM Customers
WHERE rating > ANY (SELECT rating
FROM Customers
WHERE city = 'Rome');

В английском языке, способ которым мы обычно склонны интерпретировать оценку "больше чем любой (где city = 'Rome')", должен вам сообщить, что это значение оценки должно быть выше, чем значение оценки в каждом случае, где значение city = 'Rome'. Однако это не так, в случае ANY, используемом в SQL. ANY оценивает как верно, если подзапрос находит любое значение, которое делает условие верным.

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers |
| WHERE rating > ANY |
| (SELECT rating |
| FROM Customers |
| WHERE city = 'Rome'); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ------ |
| 2002 Giovanni Rome 200 1003 |
| 2003 Liu San Jose 200 1002 |
| 2004 Grass Berlin 300 1002 |
| 2008 Cisneros San Jose 300 1007 |
===============================================

Рисунок 13.5. Как оператор "больше чем" (>) интерпретируется ANY.

Если мы оценим ANY способом, использующим грамматику английского языка, то только заказчики с оценкой 300 будут превышать Giovanni, который находится в Риме и имеет оценку 200. Однако, подзапрос ANY также находит Periera в Риме с оценкой 100. Так как все заказчики с оценкой 200 были выше этой, они будут выбраны, даже если имелся другой заказчик из Рима (Giovanni), чья оценка не была выше (фактически, то, что один из выбранных заказчиков также находится в Риме, несущественно). Так как подзапрос произвел, по крайней мере, одно значение, которое сделает предикат верным в отношении этих строк, строки были выбраны.

Чтобы дать другой пример, предположим, что мы должны были выбирать все Заказы сумм приобретений, которые были больше чем, по крайней мере, один из Заказов на 6-е Октября:

SELECT *
FROM Orders
WHERE amt > ANY (SELECT amt
FROM Orders
WHERE odate = 10/06/1990);

Вывод для этого запроса показывается в Рисунке 13.6.

=============== SQL Execution Log ==============
| SELECT * |
| FROM Orders |
| WHERE amt > ANY |
| (SELECT amt |
| FROM Orders |
| WHERE odate = 10/06/1990); |
| =============================================== |
| onum amt odate cnum snum |
| ----- -------- ---------- ----- ------ |
| 3002 1900.10 10/03/1990 2007 1004 |
| 3005 5160.45 10/03/1990 2003 1002 |
| 3009 1713.23 10/04/1990 2002 1003 |
| 3008 4723.00 10/05/1990 2006 1001 |
| 3011 9891.88 10/06/1990 2006 1001 |
=================================================

Рисунок 13.6. Выбранное значение больше чем любое (ANY) на 6-е Октября.

Даже если самая высокая сумма приобретений в таблице (9891.88) — имелась на 6-е Октября, предыдущая строка имеет более высокое значение суммы, чем другая строка на 6-е Октября, которая имела значение суммы = 1309.95. Если мы введем реляционный оператор ">=" вместо просто ">", эта строка будет также выбрана, потому что она равна самой себе.

Конечно, вы можете использовать ANY с другой SQL техникой, например с техникой объединения. Этот запрос будет находить все Заказы со значением суммы меньшей, чем значение любой суммы для заказчика в San Jose. (вывод показывается в Рисунке 13.7):

SELECT *
FROM Orders
WHERE amt < ANY (SELECT amt
FROM Orders A, Customers b
WHERE a.cnum = b.cnum
AND b.city = 'San Jose');

Даже если наименьший Заказ в таблице был для заказчика из San Jose, то был второй наибольший; следовательно почти все строки будут выбраны. Простой способ запомнить, что < ANY значение меньшее чем наибольшее выбранное значение, а > ANY значение большее чем наименьшее выбранное значение.

=============== SQL Execution Log ==============
| WHERE amt > ANY |
| (SELECT amt |
| FROM Orders a, Customers b |
| WHERE a.cnum = b.cnum |
| AND b.city = 'San Jose'); |
| =============================================== |
| onum amt odate cnum snum |
| ----- -------- ---------- ----- ------ |
| 3001 18.69 10/03/1990 2008 1007 |
| 3003 767.10 10/03/1990 2001 1001 |
| 3002 1900.10 10/03/1990 2007 1004 |
| 3006 1098.10 10/03/1990 2008 1007 |
| 3009 1713.23 10/04/1990 2002 1003 |
| 3007 75.10 10/04/1990 2004 1002 |
| 3008 4723.00 10/05/1990 2006 1001 |
| 3010 1309.88 10/06/1990 2004 1002 |
=================================================

Рисунок 13.7. Использование ANY с объединением.

Фактически, вышеуказанные команды весьма похожи на следующее — (вывод показан на Рисунке 13.8):

SELECT *
FROM Orders
WHERE amt < (SELECT MAX (amt)
FROM Orders a, Customers b
WHERE a.cnum = b.cnum AND b.city = 'San Jose');

=============== SQL Execution Log ==============
| WHERE amt < |
| (SELECT MAX (amt) |
| FROM Orders a, Customers b |
| WHERE a.cnum = b.cnum |
| AND b.city = 'San Jose'); |
| =============================================== |
| onum amt odate cnum snum |
| ----- -------- ---------- ----- ------ |
| 3002 1900.10 10/03/1990 2007 1004 |
| 3005 5160.45 10/03/1990 2003 1002 |
| 3009 1713.23 10/04/1990 2002 1003 |
| 3008 4723.00 10/05/1990 2006 1001 |
| 3011 9891.88 10/06/1990 2006 1001 |
=================================================

Рисунок 13.8. Использование агрегатной функции вместо ANY.

Специальный оператор ALL

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

SELECT *
FROM Customers
WHERE rating > ALL (SELECT rating
FROM Customers
WHERE city = 'Rome');

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers |
| WHERE rating > ALL |
| (SELECT rating |
| FROM Customers |
| WHERE city = 'Rome'); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ------ |
| 2004 Grass Berlin 300 1002 |
| 2008 Cisneros San Jose 300 1007 |
===============================================

Рисунок 13.9. Использование оператора ALL.

Этот оператор проверяет значения оценки всех заказчиков в Риме. Затем он находит заказчиков с оценкой большей, чем у любого из заказчиков в Риме. Самая высокая оценка в Риме — у Giovanni (200). Следовательно, выбираются только значения выше этих 200.

Как и в случае с ANY, мы можем использовать EXISTS для производства альтернативной формулировки такого же запроса — (вывод показан на Рисунке 13.10):

SELECT *
FROM Customers outer
WHERE NOT EXISTS (SELECT *
FROM Customers inner
WHERE outer.rating <= inner.rating
AND inner.city = 'Rome');

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers outer |
| WHERE NOT EXISTS |
| (SELECT * |
| FROM Customers inner |
| WHERE outer rating <= inner.rating |
| AND inner.city = 'Rome'); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ------ |
| 2004 Grass Berlin 300 1002 |
| 2008 Cisneros San Jose 300 1007 |
===============================================

Рисунок 13.10. Использование EXISTS в качестве альтернативы к ALL.

Равенства и неравенства

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

SELECT *
FROM Customers
WHERE rating = ALL (SELECT rating
FROM Customers
WHERE city = 'San Jose');

Эта команда допустима, но с этими данными мы не получим никакого вывода. Только в единственном случае вывод будет выдан этим запросом — если все значения оценки в San Jose окажутся идентичными. В этом случае, можно сказать следующее:

SELECT *
FROM Customers
WHERE rating = (SELECT DISTINCT rating
FROM Customers
WHERE city = 'San Jose');

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

Однако, ALL может более эффективно использоваться с неравенствами, то есть с оператором "<>". Но учтите, что сказанное в SQL что — значение, которое не равняется всем результатам подзапроса, — будет отличаться от того же, но сказанного с учетом грамматики aнглийского языка.

Очевидно, если подзапрос возвращает много различных значений, как это обычно бывает, ни одно отдельное значение не может быть равно им всем в обычном смысле. В SQL, выражение <> ALL — в действительности соответствует "не равен любому" результату подзапроса. Другими словами, предикат верен, если данное значение не найдено среди результатов подзапроса. Следовательно, наш предыдущий пример противоположен по смыслу этому примеру (с выводом показанным в Рисунке 13.11):

SELECT *
FROM Customers
WHERE rating <> ALL (SELECT rating
FROM Customers
WHERE city = 'San Jose');

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers |
| WHERE rating <> ALL |
| (SELECT rating |
| FROM Customers |
| WHERE city = 'San Jose'); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ------ |
| 2001 Hoffman London 100 1001 |
| 2006 Clemens London 100 1001 |
| 2007 Pereira Rome 100 1004 |
===============================================

Рисунок 13.11. Использование ALL с <>.

Вышеупомянутый подзапрос выбирает все оценки для города San Jose. Он выводит набор из двух значений: 200 (для Liu) и 300 (для Cisneros). Затем, основной запрос, выбирает все строки, с оценкой, не совпадающей ни с одной из них — другими словами все строки с оценкой 100. Вы можете сформулировать тот же самый запрос, используя оператор NOT IN:

SELECT*
FROM Customers
WHERE rating NOT IN (SELECT rating
FROM Customers
WHERE city = 'San Jose');

Вы могли бы также использовать оператор ANY:

SELECT *
FROM Customers
WHERE NOT rating = ANY (SELECT rating
FROM Customers
WHERE city = 'San Jose');

Вывод будет одинаков для всех трех условий.

Правильное понимание ANY и ALL

В SQL сказать, что значение больше (или меньше) чем любое (ANY) из набора значений — тоже самое что сказать, что оно больше (или меньше) чем любое одно отдельное из этих значений. И наоборот, сказать, что значение не равно всему (ALL) набору значений, тоже что сказать, что нет такого значения в наборе, которому оно равно.

Как ANY, ALL, и EXIST поступают с отсутствующими и неизвестными данными

Как было сказано, имеются некоторые различия между EXISTS и операторами, представленными в этой главе, относительно того, как они обрабатывают оператор NULL. ANY и ALL также отличаются друг от друга тем, как они реагируют, если подзапрос не произвел никаких значений, чтобы использовать их в сравнении. Эти различия могут привести к непредвиденным результатам на Ваши запросы, если вы не будете их учитывать.

Когда подзапрос возвращается пустым

Одно значительное различие между ALL и ANY — способ действия в ситуации, когда подзапрос не возвращает никаких значений. В принципе, всякий раз, когда допустимый подзапрос не в состоянии сделать вывод, ALL — автоматически верен, а ANY автоматически неверен. Это означает, что следующий запрос

SELECT *
FROM Customers
WHERE rating > ANY (SELECT rating
FROM Customers
WHERE city = 'Boston');

не произведет никакого вывода, в то время как запрос

SELECT *
FROM Customers
WHERE rating > ALL (SELECT rating
FROM Customers
WHERE city = 'Boston');

выведет всю таблицу Заказчиков. Когда нет никаких заказчиков в Boston, естественно, ни одно из этих сравнений не имеет значения.

ANY и ALL вместо EXISTS с пустым указателем (NULL)

Значения NULL также имеют некоторые проблемы с операторами наподобие этих. Когда SQL сравнивает два значения в предикате, одно из которых пустое (NULL), то результат неизвестен (смотрите Главу 5). Неизвестный предикат, подобен неверному и является причиной того, что строка не выбирается, но работать он будет иначе в некоторых похожих запросах, в зависимости от того, используют они ALL или ANY вместо EXISTS. Рассмотрим наш предыдущий пример:

SELECT *
FROM Customers
WHERE rating > ANY (SELECT rating
FROM Customers
WHERE city = 'Rome');

и еще один пример:

SELECT *
FROM Customers outer
WHERE EXISTS (SELECT *
FROM Customers inner
WHERE outer.rating > inner.rating
AND inner.city = 'Rome');

В общем, эти два запроса будут вести себя одинаково. Но предположим, что появилось пустое (NULL) значение в столбце rating таблицы Заказчиков:

CNUM	CNAME	CITY	RATING	SNUM
2003	Liu	SanJose	NULL	1002

В варианте с ANY, где оценка Liu выбрана основным запросом, значение NULL делает предикат неизвестным, а строка Liu не выбирается для вывода. Однако, в варианте с NOT EXISTS, когда эта строка выбрана основным запросом, значение NULL используется в предикате подзапроса, делая его неизвестным в каждом случае. Это означает, что подзапрос не будет производить никаких значений, и EXISTS будет неправилен. Это, естественно, делает оператор NOT EXISTS верным. Следовательно, строка Liu будет выбрана для вывода. Это основное расхождение, в отличие от других типов предикатов, где значение EXISTS независимо от того, верно оно или нет — всегда неизвестно. Все это является аргументом в пользу использования варианта формулировки с ANY. Мы не считаем, что значение NULL является выше, чем допустимое значение. Более того, результат будет тот же, если мы будем проверять для более низкого значения.

Использование COUNT вместо EXISTS

Подчеркнем, что все формулировки с ANY и ALL могут быть в точности выполнены с EXISTS, в то время как наоборот будет неверно. Хотя в этом случае также верно и то, что EXISTS и NOT EXISTS подзапросы можно обманывать при выполнении тех же самых подзапросов с COUNT (*) в предложения SELECT подзапроса. Если больше чем ноль строк выводе будет подсчитано, это эквивалентно EXISTS; в противном случае это работает также как NOT EXISTS. Следующее является этому примером (вывод показывается в Рисунке 13.12).

SELECT *
FROM Customers outer
WHERE NOT EXISTS (SELECT *
FROM customers inner
WHERE outer.rating <= inner.rating
AND inner.city = 'Rome');

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers outer |
| WHERE NOT EXISTS |
| (SELECT * |
| FROM Customers inner |
| WHERE outer.rating <= inner.rating |
| AND inner.city = 'Rome'); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ------ |
| 2004 Grass Berlin 300 1002 |
| 2008 Cisneros San Jose 300 1007 |
===============================================

Рисунок 13.12. Использование EXISTS с соотнесенным подзапросом.

Это может также быть выполнено как

SELECT *
FROM Customers outer
WHERE 1 > (SELECT COUNT (*)
FROM Customers inner
WHERE outer.rating <= inner.rating
AND inner.city = 'Rome');

Вывод к этому запросу показывается в Рисунке 13.13. Теперь Вы начинаете понимать, сколько способов имеется в SQL. Если это все кажется несколько путанным на этой стадии, нет причины волноваться. Вы обучаетесь, чтобы использовать ту технику, которая лучше всего отвечает вашим требованиям и наиболее понятна для вас. Начиная с этого места, мы хотим показать Вам большое количество возможностей, что бы вы могли найти ваш собственный стиль.

=============== SQL Execution Log ============
| SELECT * |
| FROM Customers outer |
| WHERE 1 > |
| (SELECT COUNT (*) |
| FROM Customers inner |
| WHERE outer.rating <= inner.rating |
| AND inner.city = 'Rome'); |
| ============================================= |
| cnum cname city rating snum |
| ----- -------- ---- ------ ------ |
| 2004 Grass Berlin 300 1002 |
| 2008 Cisneros San Jose 300 1007 |
===============================================

Рисунок 13.13. Использование COUNT вместо EXISTS.

Резюме

Итак, вы прошли много чего в этой главе. Подзапросы не простая тема, и мы потратили много времени, чтобы показать их разновидности и неоднозначности. То чему Вы теперь научились, вещи достаточно глубокие. Вы знаете несколько технических решений одной проблемы, и поэтому вы можете выбрать то, которое более подходит вашим целям. Кроме того, вы поняли, как различные формулировки будут обрабатывать пустые значения (NULL) и ошибки.

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

Мы имеем еще одну главу о запросах, которая покажет вам, как объединить выводы любого числа запросов в единое тело, с помощью формирования объединения нескольких запросов, используя оператор UNION.

Работа с SQL

Напишите запрос, который бы выбирал всех заказчиков, чьи оценки равны или больше чем любая (ANY) оценка заказчика Serres.
Что будет выведено вышеупомянутой командой?
Напишите запрос, использующий ANY или ALL, который бы находил всех продавцов, которые не имеют никаких заказчиков, размещенных в их городе.
Напишите запрос, который бы выбирал все Заказы с суммой больше чем любая (в обычном смысле) для заказчиков в Лондоне.
Напишите предыдущий запрос с использованием MAX.

(См. Приложение A для ответов.)

Использование предложения UNION

В ПРЕДШЕСТВУЮЩИХ ГЛАВАХ МЫ ОБСУЖДАЛИ различные способы, которыми запросы могут помещаться один внутрь другого. Имеется другой способ объединения многочисленых запросов — т.е. формирование их в объединение. В этой главе вы научитесь использованию предложения UNION в SQL. UNION отличается от подзапросов тем что в нем ни один из двух (или больше) запросов не управляются другим запросом. Все запросы выполняются независимо друг от друга, а уже вывод их — объединяется.

Объединение нескольких запросов в один

Вы можете поместить несколько запросов вместе и объединить их вывод, используя предложение UNION. Предложение UNION объединяет вывод двух или более SQL запросов в единый набор строк и столбцов. Например, чтобы получить всех продавцов и заказчиков, размещенных в Лондоне, и вывести их как единое целое, вы могли бы ввести:

SELECT snum, sname
FROM Salespeople
WHERE city = 'London'
UNION
SELECT cnum, cname
FROM Customers
WHERE city = 'London';

и получить вывод, показанный в Рисунке 14.1.

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

Кроме того, обратите внимание, что только последний запрос заканчивается точкой с запятой. Отсутствие точки с запятой дает понять SQL, что имеется еще одно или более запросов.

=============== SQL Execution Log ============
| |
| SELECT snum, sname |
| FROM Salespeople |
| WHERE city = 'London' |
| UNION |
| SELECT cnum, cname |
| FROM Customers |
| WHERE city = 'London'; |
| ============================================= |
| |
| ----- -------- |
| 1001 Peel |
| 1004 Motika |
| 2001 Hoffman |
| 2006 Clemens |
| |
===============================================

Рисунок 14.1. Формирование объединения из двух запросов.

Когда вы можете делать объединение между запросами?

Когда два (или более) запроса подвергаются объединению, их столбцы вывода должны быть совместимы для объединения. Это означает, что каждый запрос должен указывать одинаковое число столбцов и в том же порядке что и первый, второй, третий, и так далее, и каждый должен иметь тип, совместимый с каждым. Значение совместимости типов — меняется. ANSI следит за этим очень строго и поэтому числовые поля должны иметь одинаковый числовой тип и размер, хотя некоторые имена, используемые ANSI для этих типов, являются синонимами (смотрите Приложение B для подробностей о числовых типах ANSI). Кроме того, символьные поля должны иметь одинаковую длину.

Хорошо, что некоторые SQL программы обладают большей гибкостью, чем это определяется ANSI. Типы, не определенные ANSI, такие как DATA и BINARY, обычно должны совпадать с другими столбцами такого же нестандартного типа.

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

Другое ограничение на совместимость — это когда пустые значения (NULL) запрещены в любом столбце объединения, причем эти значения необходимо запретить и для всех соответствующих столбцов в других запросах объединения. Пустые значения (NULL) запрещены с ограничением NOT NULL, которое будет обсуждаться в Главе 18. Кроме того, вы не можете использовать UNION в подзапросах, а также не можете использовать агрегатные функции в предложении SELECT запроса в объединении. (Большинство программ пренебрегают этими ограничениями.)

UNION и устранение дубликатов

UNION будет автоматически исключать дубликаты строк из вывода. Это нечто несвойственное для SQL, так как одиночные запросы обычно содержат DISTINCT, чтобы устранять дубликаты. Например, запрос, чей вывод показывается в Рисунке 14.2,

SELECT snum, city
FROM Customers;

имеет двойную комбинацию значений (snum=1001, city='London'), потому что мы не указали, чтобы SQL устранил дубликаты. Однако, если мы используем UNION в комбинации этого запроса с ему подобным в таблице Продавцов, то эта избыточная комбинация будет устранена. Рисунок 14.3 показывает вывод следующего запроса.

SELECT snum, city
FROM Customers

UNION

SELECT snum, city
FROM Salespeople;

=============== SQL Execution Log ============
| SELECT snum, city |
| FROM Customers; |
| ============================================= |
| snum city |
| ----- -------- |
| 1001 London |
| 1003 Rome |
| 1002 San Jose |
| 1002 Berlin |
| 1001 London |
| 1004 Rome |
| 1007 San Jose |
===============================================

Рисунок 14.2. Одиночный запрос с дублированным выводом.

=============== SQL Execution Log ============
| FROM Customers |
| UNION |
| SELECT snum, city |
| FROM Salespeople; |
| ============================================= |
| |
| ----- -------- |
| 1001 London |
| 1002 Berlin |
| 1007 San Jose |
| 1007 New York |
| 1003 Rome |
| 1001 London |
| 1003 Rome |
| 1002 Barcelona |
| 1007 San Jose |
===============================================

Рисунок 14.3. UNION устраняет двойной вывод.

Вы можете получить нечто похожее в некоторых программах SQL, используя UNION ALL вместо просто оператора UNION, наподобие этого:

SELECT snum, city
FROM Customers

UNION ALL

SELECT snum, city
FROM Salespeople;

Использование строк и выражений с UNION

Иногда, вы можете вставлять константы и выражения в предложения SELECT, используемые с UNION. Это не следует строго указаниям ANSI, но это полезная и необычно используемая возможность. Константы и выражения, которые вы используете, должны встречать совместимые стандарты, которые мы выделяли ранее. Эта свойство полезно, например, чтобы устанавливать комментарии, указывающие, какой запрос вывел данную строку.

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

SELECT a.snum, sname, onum, 'Highest on', odate
FROM Salespeople a, Orders b
WHERE a.snum = b.snum AND b.amt = (SELECT MAX (amt)
FROM Orders c
WHERE c.odate = b.odate)

UNION

SELECT a.snum, sname, onum, 'Lowest on ', odate
FROM Salespeople a, Orders b
WHERE a.snum = b.snum AND b.amt = (SELECT MIN (amt)
FROM Orders c
WHERE c.odate = b.odate);

Вывод из этой команды показывается в Рисунке 14.4.

Мы должны были добавить дополнительный пробел в строку 'Lowest on', чтобы сделать ее совпадающей по длине со строкой 'Highest on'. Обратите внимание, что Peel выбран при наличии и самого высокого и самого низкого (фактически, он единственный) Заказа на 5 Октября. Так как вставляемые строки двух этих запросов различны, строки не будут устранены как дубликаты.

=============== SQL Execution Log ============
| AND b.amt = |
| (SELECT min (amt) |
| FROM Orders c |
| WHERE c.odate = b.odate); |
| ============================================= |
| |
| ----- ------- ------ ---------- ----------- |
| 1001 Peel 3008 Highest on 10/05/1990 |
| 1001 Peel 3008 Lowest on 10/05/1990 |
| 1001 Peel 3011 Highest on 10/06/1990 |
| 1002 Serres 3005 Highest on 10/03/1990 |
| 1002 Serres 3007 Lowest on 10/04/1990 |
| 1002 Serres 3010 Lowest on 10/06/1990 |
| 1003 Axelrod 3009 Highest on 10/04/1990 |
| 1007 Rifkin 3001 Lowest on 10/03/1990 |
===============================================

Рисунок 14.4. Выбор наибольших и наименьших Заказов.

Использование UNION с ORDER BY

До сих пор мы не оговаривали, что данные многочисленных запросов будут выводиться в каком то особом порядке. Мы просто показывали вывод сначала из одного запроса, а затем из другого. Конечно, вы не можете полагаться на вывод, приходящий в произвольном порядке. Мы как раз сделаем так, чтобы этот способ для выполнения примеров был более простым. Вы можете использовать предложение ORDER BY чтобы упорядочить вывод из объединения, точно так же как это делается в индивидуальных запросах. Давайте пересмотрим наш последний пример чтобы упорядочить имена с помощью их Заказовых номеров. Это может внести противоречие, такое как повторение имени Peel в последней команде, как вы сможете увидеть из вывода показанного в Рисунке 14.5.

SELECT a.snum, sname, onum, 'Highest on', odate
FROM Salespeople a, Orders b
WHERE a.snum = b.snum AND b.amt = (SELECT MAX (amt)
FROM Orders c
WHERE c.odate = b.odate)

UNION

SELECT a.snum, sname, onum, 'Lowest on', odate
FROM Salespeople a, Orders b
WHERE a.snum = b.snum AND b.amt = (SELECT MIN (amt)
FROM Orders c
WHERE c.odate = b.odate)
ORDER BY 3;

=============== SQL Execution Log ============
| (SELECT min (amt) |
| FROM Orders c |
| WHERE c.odate = b.odate) |
| ORDER BY 3; |
| ============================================= |
| |
| ----- ------- ------ ---------- ----------- |
| 1007 Rifkin 3001 Lowest on 10/03/1990 |
| 1002 Serres 3005 Highest on 10/03/1990 |
| 1002 Serres 3007 Lowest on 10/04/1990 |
| 1001 Peel 3008 Highest on 10/05/1990 |
| 1001 Peel 3008 Lowest on 10/05/1990 |
| 1003 Axelrod 3009 Highest on 10/04/1990 |
| 1002 Serres 3010 Lowest on 10/06/1990 |
| 1001 Peel 3011 Highest on 10/06/1990 |
===============================================

Рисунок 14.5. Формирование объединения с использованием ORDER BY.

Пока ORDER BY используется по умолчанию, мы не должны его указывать. Мы можем упорядочить наш вывод с помощью нескольких полей, одно внутри другого и указать ASC или DESC для каждого, точно также как мы делали это для одиночных запросов. Заметьте, что номер 3 в предложении ORDER BY указывает, какой столбец из предложения SELECT будет упорядочен. Так как столбцы объединения — это столбцы вывода, они не имеют имен, и, следовательно, должны определяться по номеру. Этот номер указывает на их место среди других столбцов вывода (смотрите Главу 7, обсуждающую столбцы вывода).

Внешнее объединение

Операция, которая бывает часто полезна — это объединение из двух запросов, в котором второй запрос выбирает строки, исключенные первым. Наиболее часто вы будете делать это так, чтобы не исключать строки, которые не удовлетворили предикату при объединении таблиц. Это называется внешним объединением.

Предположим, что некоторые из ваших заказчиков еще не были назначены к продавцам. Вы можете захотеть увидеть имена и города всех ваших заказчиков, с именами их продавцов, не учитывая тех, кто еще не был назначен. Вы можете достичь этого, формируя объединение из двух запросов, один из которых выполняет объединение, а другой выбирает заказчиков с пустыми (NULL) значениями поля snum. Этот последний запрос должен вставлять пробелы в поля, соответствующие полю sname в первом запросе.

Как и раньше, вы можете вставлять текстовые строки в ваш вывод, чтобы идентифицировать запрос, который вывел данную строку. Использование этой методики во внешнем объединении дает возможность использовать предикаты для классификации, а не для исключения. Мы использовали пример нахождения продавцов с заказчиками, размещенными в их городах и раньше. Однако вместо просто выбора только этих строк, вы, возможно, захотите, чтобы ваш вывод перечислял всех продавцов, и указывал тех, кто не имел заказчиков в их городах, и кто имел. Следующий запрос, чей вывод показывается в Рисунке 14.6, выполнит это:

SELECT Salespeople.snum, sname, cname, comm
FROM Salespeople, Customers
WHERE Salespeople.city = Customers.city

UNION

SELECT snum, sname, 'NO MATCH ', comm
FROM Salespeople
WHERE NOT city = ANY (SELECT city
FROM Customers)
ORDER BY 2 DESC;

=============== SQL Execution Log ============
| FROM Salespeople |
| WHERE NOT city = ANY (SELECT city |
| FROM Customers) |
| ORDER BY 2 DESC; |
| ============================================= |
| |
| ----- ------- --------- ------------ |
| 1002 Serres Cisneros 0.1300 |
| 1002 Serres Liu 0.1300 |
| 1007 Rifkin NO MATCH 0.1500 |
| 1001 Peel Clemens 0.1200 |
| 1001 Peel Hoffman 0.1200 |
| 1004 Motika Clemens 0.1100 |
| 1004 Motika Hoffman 0.1100 |
| 1003 Axelrod NO MATCH 0.1000 |
===============================================

Рисунок 14.6. Внешнее обьединение.

Строка 'NO MATCH' была дополнена пробелами, чтобы получить совпадение поля cname по длине (это не обязательно во всех реализациях SQL). Второй запрос выбирает даже те строки, которые исключил первый. Вы можете также добавить комментарий или выражение к вашему запросу, в виде дополнительного поля. Если вы сделаете это, вы будете должны добавить некоторый дополнительный комментарий или выражение в той же самой позиции среди выбранных полей, для каждого запроса в операции объединения. Совместимость UNION предотвращает вас от добавления дополнительного поля для первого запроса, но не для второго. Имеется запрос, который добавляет строки к выбранным полям, и указывает, совпадает ли данный продавец с его заказчиком в его городе:

SELECT a.snum, sname, a.city, 'MATCHED '
FROM Salespeople a, Customers b
WHERE a.city = b.city

UNION

SELECT snum, sname, city, 'NO MATCH'
FROM Salespeople
WHERE NOT city = ANY (SELECT city
FROM Customers)
ORDER BY 2 DESC;

Рисунок 14.7 показывает вывод этого запроса.

=============== SQL Execution Log ============
| WHERE a.city = b.city |
| union |
| SELECT snum,sname,city, 'NO MATCH' |
| FROM Salespeople |
| WHERE NOT city = (SELECT city |
| FROM Customers) |
| ORDER BY 2 DESC; |
| ============================================= |
| |
| ----- ------- ------------ --------- |
| 1002 Serres San Jose MATCHED |
| 1007 Rifkin Barselona NO MATCH |
| 1001 Peel London MATCHED |
| 1004 Motika London MATCHED |
| 1003 Axelrod New York NO MATCH |
===============================================

Рисунок 14.7. Внешнее обьединение с полем коментария.

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

SELECT snum, city, 'SALESPERSON — MATCH '
FROM Salespeople
WHERE NOT city = ANY (SELECT city
FROM Customers)

UNION

SELECT snum, city, 'SALESPERSON — NO MATCH'
FROM Salespeople
WHERE NOT city = ANY (SELECT city
FROM Customers)

UNION

SELECT cnum, city, 'CUSTOMER — MATCHED '
FROM Customers
WHERE city = ANY (SELECT city
FROM Salespeople)

UNION

SELECT cnum, city, 'CUSTOMER — NO MATCH '
FROM Customers
WHERE NOT city = ANY (SELECT city
FROM Salespeople)

ORDER BY 2 DESC;

================= SQL Execution Log =============
| FROM Salespeople) |
| ORDER BY 2 DESC; |
| ================================================ |
| |
| ---- -------- ------------------------ |
| 2003 San Jose CUSTOMER — MATCHED |
| 2008 San Jose CUSTOMER — MATCHED |
| 2002 Rome CUSTOMER — NO MATCH |
| 2007 Rome CUSTOMER — NO MATCH |
| 1003 New York SALESPERSON — MATCHED |
| 1003 New York SALESPERSON — NO MATCH |
| 2001 London CUSTOMER — MATCHED |
| 2006 London CUSTOMER — MATCHED |
| 2004 Berlin CUSTOMER — NO MATCH |
| 1007 Barcelona SALESPERSON — MATCHED |
| 1007 Barcelona SALESPERSON — NO MATCH |
==================================================

Рисунок 14.8. Полное внешнее обьединение.

Понятно, что эта формула, использующая ANY, эквивалентна объединению в предыдущем примере.

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

query X UNION query Y UNION query Z;

вы должны указать, или

(query X UNION query Y)UNION query Z;

или

query X UNION (query Y UNION query Z);

Это потому, что UNION и UNION ALL могут быть скомбинированы, чтобы удалять одни дубликаты, не удаляя других. Предложение

(query X UNION ALL query Y)UNION query Z;

не обязательно воспроизведет те же результаты что предложение

query X UNION ALL(query Y UNION query Z);

если двойные строки в нем будут удалены.

Резюме

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

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

Работа с SQL

Создайте объединение из двух запросов, которое показало бы имена, города, и оценки всех заказчиков. Те из них, которые имеют поле rating=200 и более, должны, кроме того, иметь слова "Высокий Рейтинг", а остальные должны иметь слова "Низкий Рейтинг".
Напишите команду, которая бы вывела имена и номера каждого продавца и каждого заказчика, которые имеют больше одного заказа. Результат представьте в алфавитном порядке.
Сформируйте объединение из трех запросов. Первый выбирает поля snum всех продавцов в San Jose; второй, поля cnum всех заказчиков в San Jose; и третий поля onum всех Заказов на 3 Октября. Сохраните дубликаты между последними двумя запросами, но устраните любую избыточность вывода между каждым из них и самым первым. Примечание: в данных типовых таблицах не содержится никакой избыточности. Это только пример.

(См. Приложение A для ответов.)

Ввод, удаление и изменение значений полей

ЭТА ГЛАВА ПРЕДСТАВЛЯЕТ КОМАНДЫ, КОТОРЫЕ управляют значениями, представляемыми в таблице. Когда вы закончите эту главу, вы будете способны помещать строки в таблицу, удалять их, и изменять индивидуальные значения, представленные в каждой строке.

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

Более мощные способы проектирования предикатов будут обсуждены в следующей главе.

Команды модификации языка DML

Значения могут быть помещены и удалены из полей, тремя командами языка DML (Язык Манипулирования Данными):

INSERT (ВСТАВИТЬ),
UPDATE (МОДИФИЦИРОВАТЬ),
DELETE (УДАЛИТЬ).

Не смущайтесь, все они упоминались ранее в SQL, как команды модификации.

Ввод значений

Все строки в SQL вводятся с использованием команды модификации INSERT. В самой простой форме, INSERT использует следующий синтаксис:

INSERT INTO <table name>
VALUES (<value>, <value> . . .);

Так, например, чтобы ввести строку в таблицу Продавцов, вы можете использовать следующее условие:

INSERT INTO Salespeople
VALUES (1001, 'Peel', 'London', .12);

Команды DML не производят никакого вывода, но ваша программа должна дать вам некоторое подтверждение того, что данные были использованы.

Имя таблицы (в нашем случае — Salespeople — Продавцы), должно быть предварительно определено в команде CREATE TABLE (см. Главу 17), а каждое значение пронумерованное в предложении значений, должно совпадать с типом данных столбца, в который оно вставляется. В ANSI, эти значения не могут составлять выражений, что означает, что 3 — это доступно, а выражение 2 + 1 — нет. Значения, конечно же, вводятся в таблицу в поименном порядке, поэтому первое значение с именем, автоматически попадает в столбец 1, второе в столбец 2, и так далее.

Вставка пустых указателей (NULL)

Если вам нужно ввести пустое значение (NULL), вы вводите его точно также как и обычное значение. Предположим, что еще не имелось поля city для мистера Peel. Вы можете вставить его строку со значением=NULL в это поле, следующим образом:

INSERT INTO Salespeople
VALUES (1001, 'Peel', NULL, .12);

Так как значение NULL — это специальный маркер, а не просто символьное значение, оно не заключается в одиночные кавычки.

Именование столбца для вставки (INSERT)

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

INSERT INTO Customers (city, cnamе, cnum)
VALUES ('London', 'Honman', 2001);

Обратите внимание, что столбцы rating и snum — отсутствуют. Это значит, что эти строки автоматически установлены в значение по умолчанию. По умолчанию может быть введено или значение NULL или другое значение, определяемое как значение по умолчанию. Если ограничение запрещает использование значения NULL в данном столбце, и этот столбец не установлен как по умолчанию, этот столбец должен быть обеспечен значением для любой команды INSERT, которая относится к таблице (смотри Главу 18 для информации об ограничениях на NULL и на "по умолчанию").

Вставка результатов запроса

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

INSERT INTO Londonstaff
SELECT *
FROM Salespeople
WHERE city = 'London';

Здесь выбираются все значения, произведенные запросом — то есть, все строки из таблицы Продавцов со значениями city = "London" — и помещаются в таблицу называемую Londonstaff. Чтобы это работало, таблица Londonstaff должна отвечать следующим условиям:

* Она должна уже быть создана командой CREATE TABLE.

* Она должна иметь четыре столбца, которые совпадают с таблицей Продавцов в терминах типа данных; то есть первый, второй, и так далее, столбцы каждой таблицы должны иметь одинаковый тип данных (причем они не обязаны иметь одинаковых имен).

Общее правило то, что вставляемые столбцы таблицы, должны совпадать со столбцами выводимыми подзапросом, в данном случае, для всей таблицы Продавцов.

Londonstaff — это теперь независимая таблица, которая получила некоторые значения из таблицы Продавцов (Salespeople). Если значения в таблице Продавцов будут вдруг изменены, это никак не отразится на таблице Londonstaff (хотя вы могли бы создать такой эффект с помощью Представления (VIEW), описанного в Главе 20).

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

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

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

INSERT INTO Daytotals (date, total)
SELECT odate, SUM (amt)
FROM Orders
GROUP BY odate;

Обратите внимание что, как предложено ранее, имена столбцов таблицы Заказов и таблицы Daytotals — не должны быть одинаковыми. Кроме того, если дата приобретения и общее количество — это единственные столбцы в таблице, и они находятся в данном Заказе, их имена могут быть исключены из вывода из-за их очевидной простоты.

УДАЛЕНИЕ СТРОК ИЗ ТАБЛИЦ

Вы можете удалять строки из таблицы командой модификации — DELETE. Она может удалять только веденные строки, а не индивидуальные значения полей, так что параметр поля является необязательным или недоступным. Чтобы удалить все содержание таблицы Продавцов, вы можете ввести следующее условие:

DELETE FROM Salespeople;

Теперь, когда таблица пуста, ее можно окончательно удалить командой DROP TABLE (это объясняется в Главе 17).

Обычно, вам нужно удалить только некоторые определенные строки из таблицы. Чтобы определить какие строки будут удалены, вы используете предикат, так же как вы это делали для запросов. Например, чтобы удалить продавца Axelrod из таблицы, вы можете ввести

DELETE FROM Salespeople
WHERE snum = 1003;

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

Конечно, вы можете также использовать DELETE с предикатом, который бы выбирал группу строк, как показано в этом примере:

DELETE FROM Salespeople
WHERE city = 'London';

Изменение значений поля

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

Эта команда содержит предложение UPDATE, в котором указано имя используемой таблицы, и предложение SET, указывающее на изменение, которое нужно сделать для определенного столбца. Например, чтобы изменить оценки всех заказчиков на 200, вы можете ввести

UPDATE Customers
SET rating = 200;

Модифицирование только определенных строк

Конечно, вы не всегда захотите указывать все строки таблицы для изменения единственного значения, так что UPDATE, наподобие DELETE, может брать предикаты. Вот как, например, можно выполнить изменение, одинаковое для всех заказчиков продавца Peel (имеющего snum=1001):

UPDATE Customers
SET rating = 200
WHERE snum = 1001;

Команда UPDATE для многих столбцов

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

UPDATE Salespeople
SET sname = 'Gibson', city = 'Boston', comm = .10
WHERE snum = 1004;

Эта команда передаст новому продавцу Gibson, всех текущих заказчиков бывшего продавца Motika и Заказы, в том виде, в котором они были скомпонованы для Motika с помощью поля snum.

Вы не можете, однако, модифицировать сразу много таблиц в одной команде, частично потому, что вы не можете использовать префиксы таблицы со столбцами измененными предложением SET. Другими словами, вы не можете сказать — "SET Salespeople.sname = Gibson" в команде UPDATE, вы можете сказать только так — "SET sname = Gibson".

Использование выражений для модификации

Вы можете использовать скалярные выражения в предложении SET команды UPDATE, однако, включив его в выражение поля, которое будет изменено. В этом их отличие от предложения VALUES команды INSERT, в котором выражения не могут использоваться; это свойство скалярных выражений — весьма полезная особенность. Предположим, что вы решили удвоить комиссионные всем вашим продавцам. Вы можете использовать следующее выражение:

UPDATE Salespeople
SET comm = comm * 2;

Всякий раз, когда вы ссылаетесь к указанному значению столбца в предложении SET, произведенное значение может получиться из текущей строки, прежде в ней будут сделаны какие-то изменения с помощью команды UPDATE. Естественно, вы можете скомбинировать эти особенности, и сказать, — удвоить комиссию всем продавцам в Лондоне, таким предложением:

UPDATE Salespeople
SET comm = comm * 2
WHERE city = 'London';

Модифицирование пустых (NULL) значений

Предложение SET — это не предикат. Он может вводить пустые NULL значения так же, как он вводил значения, не используя какого-то специального синтаксиса (такого, например, как IS NULL). Так что, если вы хотите установить все оценки заказчиков в Лондоне в NULL, вы можете ввести следующее предложение:

UPDATE customers
SET rating = NULL
WHERE city = 'London';

что обнулит все оценки заказчиков в Лондоне.

Резюме

Теперь вы овладели мастерством управления содержанием вашей базы данных с помощью трех простых команд:

INSERT — используемой чтобы помещать строки в базу данных;
DELETE — чтобы удалять их;
UPDATE — чтобы изменять значения в уже вставленных строках.

Вы обучались использованию предиката с командами UPDATE и DELETE, чтобы определять, на которую из строк будет воздействовать команда. Конечно, предикаты как таковые не значимы для INSERT, потому что обсуждаемая строка не существует в таблице до окончания выполнения команды INSERT. Однако, вы можете использовать запросы с INSERT, чтобы сразу помещать все наборы строк в таблицу. Причем это вы можете делать со столбцами в любом порядке.

Вы узнали, что значения по умолчанию могут помещаться в столбцы, если вы не устанавливаете это значение явно. Вы также видели использование стандартного значения по умолчанию, которым является NULL. Кроме того, вы поняли, что UPDATE может использовать выражение значения, тогда как INSERT не может.

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

Работа с SQL

Напишите команду, которая бы поместила следующие значения, в их нижеуказанном Заказе, в таблицу Продавцов:

city — San Jose,
name — Bianco,
comm — NULL,
cnum — 1100.

Напишите команду, которая бы удалила все Заказы заказчика Clemens из таблицы Заказов.
Напишите команду, которая бы увеличила оценку всех заказчиков в Риме на 100.
Продавец Serres оставил компанию. Переназначьте его заказчиков продавцу Motika.

(См. Приложение A для ответов.)

Использование подзапросов с командами модификации

В ЭТОЙ ГЛАВЕ, ВЫ УЗНАЕТЕ, КАК ИСПОЛЬЗОВАТЬ подзапросы в командах модификации.

Вы найдете, что нечто подобное вы уже видели при использовании подзапросов в запросах. Понимание, как подзапросы используются в командах SELECT, сделает их применение в командах модификации более уверенным, хотя и останутся некоторые вопросы. Завершением команды SELECT является подзапрос, но не предикат, и поэтому его использование отличается от использования простых предикатов с командами модификации, которые вы уже выполняли ранее с командами UPDATE и DELETE. Вы использовали простые запросы, чтобы производить значения для INSERT, а теперь мы можем расширить эти запросы, чтобы включать в них подзапросы.

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

Не делайте ссылки к текущей строке таблицы, указанной в команде, которая является соотнесенным подзапросом.

Использование подзапросов с INSERT

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

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

INSERT INTO SJpeople
SELECT *
FROM Salespeople
WHERE city = 'San Jose';

Теперь мы можем использовать подзапрос, чтобы добавить к таблице SJpeople всех продавцов, которые имеют заказчиков в San Jose, независимо от того, находятся ли там продавцы или нет:

INSERT INTO Sjpeople
SELECT *
FROM Salespeople
WHERE snum = ANY (SELECT snum
FROM Customers
WHERE city = 'San Jose');

Оба запроса в этой команде функционируют так же, как если бы они не являлись частью выражения INSERT. Подзапрос находит все строки для заказчиков в San Jose и формирует набор значений snum. Внешний запрос выбирает строки из таблицы Salespeople, где эти значения snum найдены. В этом примере, строки для продавцов Rifkin и Serres, которые назначены заказчикам в San Jose — Liu и Cisneros, будут вставлены в таблицу SJpeople.

Не вставляйте дубликаты строк

Последовательность команд в предшествующем разделе может быть проблематичной. Продавец Serres находится в San Jose, и, следовательно, будет вставлен с помощью первой команды. Вторая команда попытается вставить его снова, поскольку он имеет еще одного заказчика в San Jose. Если имеются любые ограничения в таблице SJpeople, которые вынуждают ее значения быть уникальными, эта вторая вставка потерпит неудачу (как это и должно было быть). Двойные строки это плохо (cм. Главу 18 для подробностей об ограничениях).

Было бы лучше, если бы вы могли как-то выяснить, что эти значения уже были вставлены в таблицу, прежде чем вы попытаетесь сделать это снова, с помощью добавления другого подзапроса (использующего операторы типа EXISTS, IN, <> ALL, и так далее) к предикату.

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

В случае INSERT, это будет также препятствовать соотнесенным подзапросам, основанным на таблице, в которую вы вставляете значения. Это имеет значение, потому что, с помощью INSERT, вы создаете новую строку в таблице. "Текущая строка" не будет существовать до тех пор, пока INSERT не закончит ее обрабатывать.

Использование подзапросов, созданных во внешней таблице запроса

Запрещение на ссылку к таблице, которая модифицируется командой INSERT, не предохранит вас от использования подзапросов, которые ссылаются к таблице, используемой в предложении FROM внешней команды SELECT. Таблица, из которой вы выбираете значения, чтобы произвести их для INSERT, не будет задействована командой; и вы сможете ссылаться к этой таблице любым способом, которым вы обычно это делали, но только если эта таблица указана в автономном запросе. Предположим, что мы имеем таблицу с именем Samecity, в которой мы запомним продавцов с заказчиками в их городах.

Мы можем заполнить таблицу, используя соотнесенный подзапрос:

INSERT INTO (Samecity
SELECT *
FROM (Salespeople outer
WHERE city IN (SELECT city
FROM Customers inner
WHERE inner.snum = outer.snum);

Ни таблица Samecity, ни таблица Продавцов не должны быть использованы во внешних или внутренних запросах INSERT.

В качестве другого примера, предположим, что вы имеете премию для продавца, который имеет самый большой заказ на каждый день. Вы следите за ним в таблице с именем Bonus, которая содержит поле snum продавцов, поле odate и поле amt. Вы должны заполнить эту таблицу информацией, которая хранится в таблице Заказов, используя следующую команду:

INSERT INTO Bonus
SELECT snum, odate, amt
FROM Orders a
WHERE amt = (SELECT MAX (amt)
FROM Orders b
WHERE a.odate = b.odate);

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

Логика запроса, естественно, должна просматривать таблицу Заказов, и находить для каждой строки максимум Заказа сумм приобретений для этой даты. Если эта величина — такая же, как у текущей строки, текущая строка является наибольшим Заказом для этой даты, и данные вставляются в таблицу Bonus.

Использование подзапросов с DELETE

Вы можете также использовать подзапросы в предикате команды DELETE. Это даст вам возможность определять некоторые довольно сложные критерии, чтобы установить, какие строки будут удаляться, что важно, так как вы, конечно же, не захотите по неосторожности удалить нужную строку.

Например, если мы закрыли наше ведомство в Лондоне, мы могли бы использовать следующий запрос, чтобы удалить всех заказчиков, назначенных к продавцам в Лондоне:

DELETE
FROM Customers
WHERE snum = ANY (SELECT snum
FROM Salespeople
WHERE city = 'London');

Эта команда удалит из таблицы Заказчиков строки Hoffman и Clemens (назначенных для Peel), и Periera (назначенного к Motika).

Конечно, вы захотите удостовериться, правильно ли сформирована эта операция, прежде чем удалит или изменит строки Peel и Motika.

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

Если, например, вы решили изменить значение поля city ваших продавцов везде, где они переназначены, вы должны рассмотреть всех этих заказчиков более сложным способом.

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

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

DELETE FROM Salespeople
WHERE EXISTS (SELECT *
FROM Customers
WHERE rating = 100 AND
Salespeople.snum = Customers.snum);

Обратите внимание, что AND часть предиката внутреннего запроса ссылается к таблице Продавцов. Это означает, что весь подзапрос будет выполняться отдельно для каждой строки таблицы Продавцов, также как это выполнялось с другими соотнесенными подзапросами. Эта команда удалит всех продавцов которые имели, по меньшей мере, одного заказчика с оценкой 100 в таблице Продавцов.

Конечно же, имеется другой способ сделать то же:

DELETE FROM Salespeople
WHERE 100 IN (SELECT rating
FROM Customers
WHERE Salespeople.snum = Customers.snum);

Эта команда находит все оценки для каждого заказчика продавцов и удаляет тех продавцов, заказчики которых имеют оценку rating = 100.

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

DELETE FROM Salespeople
WHERE (snum IN (SELECT snum
FROM Orders a
WHERE amt = (SELECT MIN (amt)
FROM Orders b
WHERE a.odate = b.odate));

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

Продавец snum = 1007, который будет удален, имеет наименьшее значение заказа на 3 Октября; поле snum = 1002, наименьшее на 4 Октября; поле snum = 1001, наименьшее в Заказах на 5 Октября (эта команда кажется довольно резкой, особенно когда она удаляет Peel, создавшего единственный заказ на 5 Октября, но зато это хорошая иллюстрация).

Если вы хотите сохранить Peel, вы могли бы добавить другой подзапрос, который бы это делал:

DELETE FROM Salespeople
WHERE snum IN (SELECT snum
FROM Orders a
WHERE amt = (SELECT MIN (amt)
FROM Orders b
WHERE a.odate = b.odate)
AND 1 < (SELECT COUNT onum
FROM Orders b
WHERE a.odate = b.odate));

Теперь для дня, в котором был создан только один заказ, будет произведен COUNT = 1 во втором соотнесенном подзапросе. Это сделает предикат внешнего запроса неправильным, и поля snum следовательно не будут переданы в основной предикат.

Использование подзапросов с UPDATE

UPDATE использует подзапросы тем же самым способом, что и DELETE — внутри этого необязательного предиката. Вы можете использовать соотнесенные подзапросы или в форме пригодной для использования с DELETE — связанной или с модифицируемой таблицей или с таблицей, вызываемой во внешнем запросе. Например, с помощью соотнесенного подзапроса к таблице, которая будет модифицироваться, вы можете увеличить комиссионные всех продавцов которые были назначены по крайней мере двум заказчикам:

UPDATE Salespeople
SET comm = comm + .01
WHERE 2 <= (SELECT COUNT (cnum)
FROM Customers
WHERE Customers.snum = Salespeople.snum);

Теперь продавцы Peel и Serres, имеющие многочисленных заказчиков, получат повышение своих комиссионных.

Имеется разновидность последнего примера из предыдущего раздела с DELETE. Он уменьшает комиссионные продавцов, которые произвели наименьшие Заказы, но не стирает их в таблице:

UPDATE salespeople
SET comm = comm - .01
WHERE snum IN (SELECT snum
FROM Orders a
WHERE amt = (SELECT MIN (amt)
FROM Orders b
WHERE a.odate = b.odate));

Столкновение с ограничениями подзапросов команды DML

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

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

Шаг 1.

SELECT AVG (rating)
FROM Customers;

Вывод = 200.

Шаг 2.

DELETE
FROM Customers
WHERE rating < 200;

Резюме

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

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

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

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

Может показаться, что мы прошли материал SQL, который обладает не самым понятным логическим порядком. Сначала мы сделали запрос таблицы, которая уже заполнена данными. Потом мы показали, как можно фактически помещать эти значения изначально. Но, как вы видите, полное ознакомление с запросами здесь неоценимо.

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

Работа с SQL

Предположите, что имеется таблица, называемая Multicust, с такими же именами столбцов, что и таблица Продавцов. Напишите команду, которая бы вставила всех продавцов (из таблицы Продавцов) имеющих более чем одного заказчика в эту таблицу.
Напишите команду, которая бы удаляла всех заказчиков, не имеющих текущих Заказов.
Напишите команду, которая бы увеличила на двадцать процентов комиссионные всех продавцов, имеющих общие текущие Заказы выше чем $3,000.

(См. Приложение A для ответов.)

продолжение

к алгоритмизации к оглавлению Описание SQL

Знаете ли Вы, что объектно-ориентированное сборочное программирование - это разновидность сборочного программирования:
- основанная на методологии объектно-ориентированного программирования; и
- предполагающая распространение библиотек классов в виде исходного кода (obj) или упаковку классов в динамически компонуемую библиотеку (dll).

НОВОСТИ ФОРУМА

Рыцари теории эфира