НЕ УКАЗЫВАТЬ СПИСОК СТОЛБЦОВ ПЕРВИЧНЫХ КЛЮЧЕЙ
Используя ограничение FOREIGN KEY таблицы или столбца, вы можете не указывать список столбцов родительского ключа, если родительский ключ имеет ограничение PRIMARY KEY. Естественно, в случае ключей со многими полями, порядок столбцов во внешних и первичных ключах должен совпадать, и, в любом случае, принцип совместимости между двум ключами всё ещё применим. Например, если мы поместили ограничение PRIMARY KEY в поле snum таблицы Продавцов, мы могли бы использовать его как внешний ключ в таблице Заказчиков (подобно предыдущему примеру) в этой команде:
CREATE TABLE Customers (cnum integer NOT NULL PRIMARY KEY, cname char(10), city char(10), snum integer REFERENCES Salespeople);
Это средство встраивалось в язык, чтобы поощрять вас использовать первичные ключи в качестве родительских ключей.
НЕ ВСТАВЛЯЙТЕ ДУБЛИКАТЫ СТРОК
Последовательность команд в предшествующем разделе может быть критичной. Продавец Serres находится в San Jose и, следовательно, будет вставлен с помощью первой команды. Вторая команда попытается вставить его снова, поскольку он имеет ещё одного заказчика в San Jose. Если имеются любые ограничения в таблице SJpeople, которые вынуждают её иметь уникальные значения, эта вторая вставка потерпит неудачу (как и должно быть).
Дублирующие строки это плохо. (См. в Главе 18 подробности об ограничениях.) Было бы лучше, если бы вы могли как-то выяснить, что эти значения уже были вставлены в таблицу, прежде чем попытаетесь сделать это снова, с помощью добавления другого подзапроса (использующего операторы типа EXISTS, IN, < > ALL и так далее) к предикату.
К сожалению, чтобы сделать эту работу, вы должны будете сослаться на саму таблицу SJpeople в предложении FROM этого нового подзапроса, а, как мы говорили ранее, вы не можете ссылаться на таблицу, которая задействована (целиком) в любом подзапросе команды модификации. В случае с INSERT это будет также препятствовать соотнесённым подзапросам, основанным на таблице, в которую вы вставляете значения. Это имеет значение, потому что, с помощью INSERT, вы создаете новую строку в таблице. "Текущая строка" не будет существовать до тех пор, пока INSERT не закончит её обрабатывать.
Некоторые общие нестандартные средства SQL
Имеется ряд особенностей языка SQL, которые пока не определены как часть стандарта ANSI или стандарта ISO (Международная Организация По Стандартизации), и являются общими для многочисленных реализаций, так как они были получены для практического использования. Конечно, эти особенности меняются от программы к программе, и их обсуждение предназначено только для того, чтобы показать некоторые общие подходы к ним.
ОБЪЕДИНЕНИЕ БОЛЕЕ ДВУХ ТАБЛИЦ
Вы можете также создавать запросы, объединяющие более двух таблиц. Предположим, что мы хотим найти все заказы заказчиков, не находящихся в тех городах, где находятся их продавцы. Для этого необходимо связать все три наши типовые таблицы (вывод показан на Рисунке 8.4):
SELECT onum, cname, Orders.cnum, Orders.snum FROM Salespeople, Customers, Orders WHERE Customers.city < > Salespeople.city AND Orders.cnum = Customers.cnum AND Orders.snum = Salespeople.snum;
=============== SQL Execution Log ============== | | | SELECT onum, cname, Orders.cnum, Orders.snum | | FROM Salespeople, Customers, Orders | | WHERE Customers.city < > Salespeople.city | | AND Orders.cnum = Customers.cnum | | AND Orders.snum = Salespeople.snum; | | =============================================== | | onum cname cnum snum | | ------ ------- ----- ----- | | 3001 Cisneros 2008 1007 | | 3002 Pereira 2007 1004 | | 3006 Cisneros 2008 1007 | | 3009 Giovanni 2002 1003 | | 3007 Grass 2004 1002 | | 3010 Grass 2004 1002 | ===============================================
Рисунок 8.4 Объединение трёх таблиц
Хотя эта команда выглядит скорее как комплексная, вы можете следовать за логикой, просто проверяя, что заказчики не размещены в тех городах, где размещены их продавцы (совпадение двух snum полей), и что перечисленные заказы выполнены с помощью этих заказчиков (совпадение заказов с полями cnum и snum в таблице Заказов).
ОБЪЕДИНЕНИЕ НЕСКОЛЬКИХ ЗАПРОСОВ В ОДИН
Вы можете поместить несколько запросов вместе и объединить их вывод, используя предложение 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 Climens | | | =============================================
Рисунок 14.1 Формирование объединения из двух запросов
ОБЪЕДИНЕНИЕ ТАБЛИЦ
Одна из наиболее важных особенностей запросов SQL - их способность определять связи между многочисленными таблицами и выводить информацию из них, в терминах этих связей, всю внутри одной команды. Этот вид операции называется объединением, которое является одним из видов операций в реляционных базах данных. Как установлено в Главе 1, главное в реляционном подходе это связи, которые можно создавать между позициями данных в таблицах. Используя объединения, мы непосредственно связываем информацию с любым числом таблиц и таким образом способны создавать связи между сравнимыми фрагментами данных. При объединении, таблицы, представленные списком в предложении FROM, отделяются запятыми. Предикат запроса может ссылаться к любому столбцу любой связанной таблицы и, следовательно, может использоваться для связи между ими. Обычно предикат сравнивает значения в столбцах различных таблиц, чтобы определить, удовлетворяет ли WHERE установленному условию.
ОБЪЕДИНЕНИЕ ТАБЛИЦ ЧЕРЕЗ СПРАВОЧНУЮ ЦЕЛОСТНОСТЬ
Эта особенность часто используется просто для эксплуатации связей, встроенных в БД. В предыдущем примере мы установили связь между двумя таблицами в объединении. Это прекрасно. Но эти таблицы уже были соединены через snum-поле. Эта связь называется состоянием справочной целостности, как мы уже говорили в Главе 1. Используя объединение, можно извлекать данные в терминах этой связи.
Например, чтобы показать имена всех заказчиков, соответствующих продавцам, которые их обслуживают, мы будем использовать такой запрос:
SELECT Customers.cname, Salespeople.sname FROM Customers, Salespeople WHERE Salespeople.snum = Customers.snum;
Вывод этого запроса показан на Рисунке 8.2.
Это пример объединения, в котором столбцы используются для определения предиката запроса, и в этом случае snum-столбцы из обеих таблиц удалены из вывода. И это прекрасно. Вывод показывает, какие заказчики каким продавцом обслуживаются; значения поля snum, которые устанавливают связь, отсутствуют. Однако, если вы введёте их в вывод, то вы должны или удостовериться, что вывод понятен сам по себе, или должны обеспечить комментарий данных при выводе.
=============== SQL Execution Log ============ | SELECT Customers.cname, Salespeople.sname, | | FROM Salespeople, Customers | | WHERE Salespeople.snum = Customers.snum | | ============================================= | | cname sname | | ------- -------- | | Hoffman Peel | | Giovanni Axelrod | | Liu Serres | | Grass Serres | | Clemens Peel | | Cisneros Rifkin | | Pereira Motika | =============================================
Рисунок 8.2 Объединение продавцов с их заказчикам
ОБЪЕДИНЕНИЕ ТАБЛИЦ ПО РАВЕНСТВУ ЗНАЧЕНИЙ В СТОЛБЦАХ И ДРУГИЕ ВИДЫ ОБЪЕДИНЕНИЙ
Объединения, которые используют предикаты, основанные на равенствах, называются объединениями по равенству. Все наши примеры в этой главе до настоящего времени относились именно к этой категории, потому что все условия в предложениях WHERE базировались на математических выражениях, использующих знак равенства (=). Строки 'city = 'London' и 'Salespeople.snum = Orders.snum ' - примеры таких типов равенств, найденных в предикатах.
Объединения по равенству это, вероятно, наиболее общий вид объединения, но имеются и другие. Вы можете использовать практически любую реляционную операцию в объединении. Здесь дан пример другого вида объединения (вывод показан на Рисунке 8.3):
SELECT sname, cname FROM Salespeople, Customers WHERE sname < cname AND rating < 200;
=============== SQL Execution Log ============ | SELECT sname, cname | | FROM Salespeople, Customers | | WHERE sname < cname | | AND rating < 200; | | ============================================= | | sname cname | | -------- ------- | | Peel Pereira | | Motika Pereira | | Axelrod Hoffman | | Axelrod Clemens | | Axelrod Pereira | | | =============================================
Рисунок 8.3 Объединение, основанное на неравенстве
Эта команда не часто бывает полезна. Она воспроизводит все комбинации имени продавца и имени заказчика так, что первый предшествует последнему в алфавитном порядке, а последний имеет оценку, меньше чем 200. Обычно вы не создаёте сложных связей, подобно этой, и по этой причине вы, вероятно, будете строить наиболее общие объединения по равенству, но вы должны хорошо знать и другие возможности.
ОБЪЯВЛЕНИЕ ОГРАНИЧЕНИЙ
Вы вставляете ограничение столбца в конец имени столбца после типа данных и перед запятой. Ограничение таблицы помещается в конец имени таблицы после последнего имени столбца, но перед заключительной круглой скобкой. Далее показан синтаксис для команды CREATE TABLE, расширенной для включения в неё ограничения:
CREATE TABLE <table name> (<column name> <data type> <column constraint>, <column name> <data type> <column constraint> ... <table constraint> (<column name> [, <column name> ])...);
(Для краткости мы опустили аргумент размера, который иногда используется с типом данных.) Поля данных в круглых скобках после ограничения таблицы это поля, к которым применено данное ограничение. Ограничение столбца, естественно, применяется к тем столбцам, после чьих имен оно следует. Остальная часть этой глава будет описывать различные типы ограничений и их использование.
ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ
Все переменные, на которые имеется ссылка в предложениях SQL, должны сначала быть объявлены в SQL DECLARE SECTION (РАЗДЕЛЕ ОБЪЯВЛЕНИЙ), использующем обычный синтаксис главного языка. Вы можете иметь любое число таких разделов в программе, и они могут размещаться где-нибудь в коде перед используемой переменной, подчиняясь ограничениям, определённым в соответствии с главным языком.
Раздел объявлений должен начинаться и кончаться вложенными командами SQL: BEGIN DECLARE SECTION (Начало Раздела Объявлений) и END DECLARE SECTION (Конец Раздела Объявлений), которым предшествует, как обычно, EXEC SQL (Выполнить SQL).
Чтобы объявить переменные, используемые в предыдущем примере, вы можете ввести следующее:
EXEC SQL BEGIN DECLARE SECTION; Var id-num: integer; Salesperson: packed array (1 . .10) ot char; loc: packed array (1. .10) ot char; comm: real; EXEC SQL END DECLARE SECTION;
Для не знакомых с ПАСКАЛем: Var это заголовок, который предшествует ряду объявляемых переменных и упакованным (или распакованным) массивам, являющимися серией фиксированных переменных значений, различаемых с помощью номеров (например, третий символ loc будет loc (3)). Использование точки с запятой после каждой переменной указывает на то, что это - Паскаль, а не SQL.
ОДНО ИМЯ ДЛЯ КАЖДОГО
Если вы планируете иметь таблицу Заказчиков, используемую большим числом пользователей, лучше всего, чтобы они обращались к ней с помощью одного и того же имени. Это даст вам возможность, например, использовать это имя в вашем внутреннем общении без ограничений. Чтобы создать единое имя для всех пользователей, вы создаёте общий синоним.
Например, если все пользователи будут вызывать таблицу Заказчиков с именем Customers, вы можете ввести
CREATE PUBLIC SYNONYM Customers FOR Customers;
Мы пронимаем, что таблица Заказчиков, это ваша собственность, поэтому никакого префикса имени пользователя в этой команде не указывается. В основном общие синонимы создаются владельцами объектов или привилегированными пользователями типа DBA. Пользователям, кроме того, должны ещё быть предоставлены привилегии в таблице Заказчиков, чтобы они могли иметь к ней доступ.
Даже если имя является общим, сама таблица общей не является. Общие синонимы становятся собственными с помощью команды PUBLIC, а не с помощью их создателей.
ОГРАНИЧЕНИЕ ПЕРВИЧНЫХ КЛЮЧЕЙ
До этого мы воспринимали первичные ключи исключительно как логические понятия. Хоть мы и знаем, что такое первичный ключ и как он должен использоваться в любой таблице, мы не в курсе, "знает" ли об этом SQL. Поэтому мы использовали ограничение UNIQUE или уникальные индексы в первичных ключах, чтобы предписывать им уникальность. В более ранних версиях языка SQL это было необходимо и могло выполняться данным способом. Однако теперь SQL поддерживает первичные ключи непосредственно ограничением Первичный Ключ (PRIMARE KEY). Это ограничение может быть доступным или недоступным в вашей системе. PRIMARY KEY может ограничивать таблицы или их столбцы. Это ограничение работает так же, как и ограничение UNIQUE, за исключением случая, когда только один первичный ключ (для любого числа столбцов) может быть определен для данной таблицы. Имеется также различие между первичными ключами и уникальностью столбцов в способе их использования с внешними ключами, о которых будет рассказано в Главе 19. Синтаксис и определение их уникальности - те же, что и для ограничения UNIQUE. Первичные ключи не могут позволить значений NULL. Это означает, что, подобно полям в ограничении UNIQUE, любое поле, используемое в ограничении PRIMARY KEY, должно уже быть объявлено NOT NULL. Имеется улучшенный вариант создания нашей таблицы Продавцов:
CREATE TABLE Salestotal (snum integer NOT NULL PRIMARY KEY, sname char(10) NOT NULL UNIQUE, city char(10), comm decimal);
Как видите, уникальность (UNIQUE) полей может быть объявлена для той же самой таблицы. Лучше всего помещать ограничение PRIMARY KEY в поле (или в поля), которое будет образовывать ваш уникальный идентификатор строки, и сохранять ограничение UNIQUE для полей, которые должны быть уникальными логически (такие как номера телефона или поле sname), а не для идентификации строк.
ОГРАНИЧЕНИЕ ПРИВИЛЕГИЙ НА ОПРЕДЕЛЕННЫЕ СТОЛБЦЫ
Все привилегии объекта используют один и тот же синтаксис, кроме команд UPDATE и REFERENCES, в которых не обязательно указывать имена столбцов.
Привилегию UPDATE можно предоставлять наподобие других привилегий:
GRANT UPDATE ON Salespeople TO Diane;
Эта команда позволит Diane изменять значения в любом или во всех столбцах таблицы Продавцов. Однако, если Adrian хочет ограничить Diane в изменении, например, комиссионных, он может ввести:
GRANT UPDATE (comm) ON Salespeople TO Diane;
Другими словами, он просто должен указать конкретный столбец, к которому привилегия UPDATE должна быть применена, в круглых скобках после имени таблицы. Имена нескольких столбцов таблицы могут указываться в любом порядке, отделяемые запятыми:
GRANT UPDATE (city, comm) ON Salespeople TO Diane;
REFERENCES следует тому же самому правилу. Когда вы предоставите привилегию REFERENCES другому пользователю, он сможет создавать внешние ключи, ссылающиеся на столбцы вашей таблицы как на родительские ключи. Подобно UPDATE, для привилегии REFERENCES может быть указан список из одного или более столбцов, для которых ограничена эта привилегия. Например, Diane может предоставить Stephen право использовать таблицу Заказчиков как таблицу родительского ключа с помощью такой команды:
GRANT REFERENCES (cname, cnum) ON Customers TO Stephen;
Эта команда дает Stephen право использовать столбцы cnum и cname в качестве родительских ключей по отношению к любым внешним ключам в его таблицах. Stephen может контролировать то, как это будет выполнено. Он может определить (cname, cnum) или, в нашем случае, (cnum, cname), как двухстолбцовый родительский ключ, совпадающий с помощью внешнего ключа с двумя столбцами в одной из его собственных таблиц. Или он может создать раздельные внешние ключи, чтобы ссылаться на поля индивидуально, обеспечив тем самым, чтобы Diane имела принудительное присвоение родительского ключа (см. Главу 19).
Не имея ограничений на количество внешних ключей, он должен базироваться на этих родительских ключах, а родительские ключи различных внешних ключей разрешены для перекрытия (overlap).
Как и в случае с привилегией UPDATE, вы можете исключить список столбцов и таким образом позволить всем без исключения столбцам быть используемыми в качестве родительских ключей.
Adrian может предоставить Diane право сделать это следующей командой:
GRANT REFERENCES ON Salespeople TO Diane;
Естественно, привилегия будет пригодна для использования только в столбцах, которые имеют ограничения, требуемые для родительских ключей.
ОГРАНИЧЕНИЕ ТАБЛИЦ
Когда вы создаёте таблицу (или, когда вы её изменяете), вы можете указывать ограничения на значения, которые могут быть введены в поля. Если вы это сделали, SQL будет отклонять любые значения, нарушающие критерии, которые вы определили.
Есть два основных типа ограничений: ограничение столбца и ограничение таблицы. Различие между ними в том, что ограничение столбца применяется только к отдельным столбцам, в то время как ограничение таблицы применяется к группам из одного и более столбцов.
ОГРАНИЧЕНИЕ ВНЕШНЕГО КЛЮЧА/FOREIGN KEY
SQL поддерживает справочную целостность с ограничением FOREIGN KEY. Хотя ограничение FOREIGN KEY это новая особенность в SQL, оно ещё не обеспечивает его универсальности. Кроме того, некоторые его реализации более сложны, чем другие. Эта функция должна ограничивать значения, которые вы можете ввести в вашу БД, чтобы заставить внешний ключ и родительский ключ соответствовать принципу справочной целостности.
Одно из действий ограничения Внешнего Ключа - отбрасывание значений для полей, ограниченных как внешний ключ, который ещё не представлен в родительском ключе. Это ограничение также воздействует на вашу способность изменять или удалять значения родительского ключа (мы будем обсуждать это позже в этой главе).
ОГРАНИЧЕНИЯ ПОДЗАПРОСОВ КОМАНД DML
Невозможность обратиться к таблице, задействованной в любом подзапросе, из команды модификации (UPDATE) исключает целые категории возможных действий. Например, вы не можете просто выполнить такую операцию как удаление всех заказчиков с оценками ниже средней. Вероятно, лучше всего вы могли бы сначала (Шаг 1.) выполнить запрос, получающий среднюю величину, а затем (Шаг 2.) удалить все строки с оценкой ниже этой величины.
Шаг 1.
SELECT AVG (rating) FROM Customers;
Вывод = 200.
Шаг 2.
DELETE FROM Customers WHERE rating < 200;
ОГРАНИЧЕНИЯ ВНЕШНЕГО КЛЮЧА
Внешний ключ, в частности, может содержать только те значения, которые фактически представлены в родительском ключе, или пустые (NULL). Попытка ввести другие значения в этот ключ будет отклонена.
Вы можете объявить внешний ключ как NOT NULL, но это не обязательно и, в большинстве случаев, нежелательно. Например, предположим, что вы вводите заказчика, не зная заранее, к какому продавцу он будет назначен. Лучший выход в этой ситуации - использовать значение NOT NULL, которое должно быть изменено позже на конкретное значение.
OPEN CURSOR (ОТКРЫТЬ КУРСОР)
Синтаксис
EXEC SQL OPEN CURSOR <cursorname><SQL term>
OPEN CURSOR выполняет запрос, связанный с курсором <cursor name>. Вывод может теперь извлекать по одной строке для каждой команды FETCH.
ОПЕРАТОР BETWEEN
Оператор BETWEEN похож на оператор IN. Но, в отличие от определения по числам из набора, как это делает IN, BETWEEN определяет диапазон, значения которого должны уменьшаться, что делает предикат верным. Вы должны ввести ключевое слово BETWEEN с начальным значением, ключевое AND и конечное значение. В отличие от IN, BETWEEN чувствителен к порядку, и первое значение в предложении должно быть последним по алфавитному или числовому порядку. (Обратите внимание, что, в отличие от английского языка, SQL не говорит, что "значение находится (между) BETWEEN значением и значением", а просто "значение BETWEEN значение значение". Это применимо и к оператору LIKE). Следующий пример будет извлекать из таблицы Продавцов всех продавцов с комиссионными между .10 и .12 (вывод показан на Рисунке 5.4):
SELECT * FROM Salespeople WHERE comm BETWEEN .10 AND .12;
Для оператора BETWEEN, значение, совпадающее с любым из двух значений границы (в данном случае это .10 и .12 ), заставляет предикат быть верным.
=============== SQL Execution Log ============ | SELECT * | | FROM Salespeople | | WHERE comm BETWEEN .10 AND .12; | | ==============================================| | snum sname city comm | | ------ ---------- ----------- ------- | | 1001 Peel London 0.12 | | 1004 Motika London 0.11 | | 1003 Axelrod New York 0.10 | ===============================================
Рисунок 5.4 SELECT с BETWEEN
SQL не делает непосредственной поддержки невключения граничных значений BETWEEN. Вы должны или определить ваши граничные значения так, чтобы включающая интерпретация была приемлема, или сделать что-нибудь типа этого:
SELECT * FROM Salespeople WHERE (comm BETWEEN .10, AND .12) AND NOT comm IN (.10, .12);
Вывод для этого запроса показан на Рисунке 5.5.
По общему признанию, это немного неуклюже, но зато показывает, как эти новые операторы могут комбинироваться с булевыми операциями, чтобы производить более сложные предикаты.
В основном вы используете IN и BETWEEN так же, как вы использовали реляционные операции при сравнении значений, которые берутся либо из набора (для IN), либо из диапазона (для BETWEEN).
Также, подобно реляционным операциям, BETWEEN может работать с символьными полями в терминах эквивалентов ASCII. Это означает, что вы можете использовать BETWEEN для выборки ряда значений из упорядоченных по алфавиту значений.
=============== SQL Execution Log ============ | | | SELECT * | | FROM Salespeople | | WHERE (comm BETWEEN .10 AND .12) | | AND NOT comm IN (.10 .12); | | ==============================================| | snum sname city comm | | ------ ---------- ----------- ------- | | 1004 Motika London 0.11 | | | ===============================================
Рисунок 5.5 Сделать BETWEEN с невключением
Этот запрос выбирает всех заказчиков, чьи имена попали в определенный алфавитный диапазон:
SELECT * FROM Customers WHERE cname BETWEEN 'A' AND 'G';
Вывод для этого запроса показан на Рисунке 5.6.
Обратите внимание, что Grass и Giovanni отсутствуют даже при включенном BETWEEN. Это происходит из-за того, что BETWEEN сравнивает строки неравной длины. Строка 'G' короче, чем строка Giovanni, поэтому BETWEEN выводит 'G' с пробелами. Пробелы предшествуют символам в алфавитном порядке (в большинстве реализаций), поэтому Giovanni не выбирается. То же самое происходит и с Grass. Важно помнить это, когда вы используете BETWEEN для извлечения значений из алфавитных диапазонов. Обычно вы указываете диапазон с помощью символа начала диапазона и символа конца (вместо которого можно просто поставить z).
=============== SQL Execution Log ============ | | | SELECT * | | FROM Customers | | WHERE cname BETWEEN 'A' AND 'G'; | | ============================================= | | cnum cname city rating snum | | ------ -------- ------ ---- ------ | | 2006 Clemens London 100 1001 | | 2008 Cisneros San Jose 300 1007 | | | =============================================
Рисунок 5.6 Использование BETWEEN в алфавитных порядках
ОПЕРАТОР IN
Оператор IN определяет набор значений, в который данное значение может или может не быть включено. В соответствии с нашей учебной базой данных, на которой вы обучаетесь по настоящее время, если вы хотите найти всех продавцов, которые находятся в Barcelona или в London, вы должны использовать следующий запрос (вывод показан на Рисунке 5.1):
SELECT * FROM Salespeople WHERE city = 'Barcelona' OR city = 'London';
Имеется и более простой способ получить ту же информацию:
SELECT * FROM Salespeople WHERE city IN ('Barcelona', 'London');
Вывод для этого запроса показан на Рисунке 5.2.
Как видите, IN определяет набор значений с помощью имён членов набора, заключённых в круглые скобки и разделённых запятыми. Он затем проверяет различные значения указанного поля, пытаясь найти совпадение со значениями из набора. Если это случается, то предикат верен. Когда набор содержит числовые значения, а не символы, одиночные кавычки опускаются. Давайте найдём всех заказчиков, относящихся к продавцам, имеющих значения snum = 1001, 1007, и 1004. Вывод для следующего запроса показан на Рисунке 5.3:
SELECT * FROM Customers WHERE snum IN (1001, 1007, 1004);
=============== SQL Execution Log ============ | | | SELECT * | | FROM Salespeople | | WHERE city = 'Barcelona' | | OR city = 'London'; | | ==============================================| | snum sname city comm | | ------ ---------- ----------- ------- | | 1001 Peel London 0.12 | | 1004 Motika London 0.11 | | 1007 Rifkin Barcelona 0.15 | | | ===============================================
Рисунок 5.1 Нахождение продавцов в Барселоне и Лондоне
=============== SQL Execution Log ============ | | | SELECT * | | FROM Salespeople | | WHERE city IN ('Barcelona', 'London'; | | ==============================================| | snum sname city comm | | ------ ---------- ----------- ------- | | 1001 Peel London 0.12 | | 1004 Motika London 0.11 | | 1007 Rifkin Barcelona 0.15 | | | ===============================================
Рисунок 5.2 SELECT использует IN
=============== SQL Execution Log ============ | SELECT * | | FROM Customers | | WHERE snum IN ( 1001, 1007, 1004 ); | | ============================================= | | snum cname city rating snum | | ------ -------- ------ ---- ------ | | 2001 Hoffman London 100 1001 | | 2006 Clemens London 100 1001 | | 2008 Cisneros San Jose 300 1007 | | 2007 Pereira Rome 100 1004 | =============================================
Рисунок 5.3 SELECT использует IN с номерами
ОПЕРАТОР IS NULL
Так как NULL указывает на отсутствие значения, вы не можете знать, каков будет результат любого сравнения с использованием NULL. Когда NULL сравнивается с любым значением, даже с другим таким же NULL, результат будет ни true, ни false, он неизвестен/undefined. Неизвестный булев вообще ведёт себя так же, как неверная строка, которая, произведя неизвестное значение в предикате, не будет выбрана запросом. Имейте в виду, что, в то время как NOT (неверное) равняется верно, NOT (неизвестное) равняется неизвестно.
Следовательно, выражение типа 'city = NULL' или 'city IN (NULL)' будет неизвестно в любом случае.
Часто вы должны отличать неверно и неизвестно между строками, содержащими значения столбцов, которые не соответствуют условию предиката и которые содержат NULL в столбцах. По этой причине SQL предоставляет специальный оператор IS, который используется с ключевым словом NULL, для размещения значения NULL.
Найдём все записи в нашей таблице Заказчиков с NULL-значениями в столбце city:
SELECT * FROM Customers WHERE city IS NULL;
Здесь не будет никакого вывода, потому что мы не имеем никаких значений NULL в наших типовых таблицах. Значения NULL очень важны, и мы вернёмся к ним позже.
ОПЕРАТОР LIKE
LIKE применим только к полям типа CHAR или VARCHAR, с которыми он используется для поиска подстрок. Т.е. он ищет поле символа, чтобы увидеть, совпадает ли с условием часть его строки. В качестве условия он использует групповые символы-шаблоны (wildсards) - специальные символы, которые могут соответствовать чему-нибудь.
Имеются два типа шаблонов, используемых с LIKE:
символ подчёркивания ( _ ) замещает любой одиночный символ. Например, 'b_t' будет соответствовать словам 'bat' или 'bit', но не будет соответствовать 'brat'.
знак процента (%) замещает последовательность любого количества символов (включая символы нуля). Например '%p%t' будет соответствовать словам 'put', 'posit', или 'opt, но не 'spite'.
Давайте найдём всех заказчиков, чьи имена начинаются с G (вывод показан на Рисунке 5.7):
SELECT FROM Customers WHERE cname LIKE 'G%';
=============== SQL Execution Log ============ | | | SELECT * | | FROM Customers | | WHERE cname LIKE 'G'; | | ============================================= | | cnum cname city rating snum | | ------ -------- ------ ---- ------ | | 2002 Giovanni Rome 200 1003 | | 2004 Grass Berlin 300 1002 | | | =============================================
Рисунок 5.7 SELECT использует LIKE с %
LIKE может быть удобен, если вы ищете имя или другое значение и если вы не помните, как они точно пишутся. Предположим, что вы не уверены, как записано по буквам имя одного из ваших продавцов - Peal или Peel. Вы можете просто использовать ту часть, которую вы знаете, и групповые символы, чтобы находить все возможные совпадения (вывод этого запроса показан на Рисунке 5.8):
SELECT * FROM Salespeople WHERE sname LIKE 'P _ _ l %';
Группа символов подчёркивания, каждый из которых представляет один символ, добавит только два символа к уже существующим 'P' и 'l' , поэтому имя наподобие Prettel не может быть показано. Групповой символ ' % ' в конце строки необходим в большинстве реализаций, если длина поля sname больше, чем число символов в имени Peel (потому что некоторые другие значения sname длиннее, чем четыре символа). В этом варианте значение поля sname, фактически сохраняемое как имя Peel, сопровождается рядом пробелов. Следовательно, символ 'l' не будет считаться концом строки. Групповой символ ' % ' просто соответствует этим пробелам. Это не обязательно, если поле sname имеет тип VARCHAR.
=============== SQL Execution Log ============ | | | SELECT * | | FROM Salespeople | | WHERE sname LIKE 'P__l'; | | ==============================================| | snum sname city comm | | ------ ---------- ----------- ------- | | 1001 Peel London 0.12 | | | ===============================================
Рисунок 5.8 SELECT использует LIKE с подчёркиванием (_)
А что вы будете делать, если вам нужно искать символ процента или символ подчёркивания в строке? В LIKE-предикате вы можете определить любой одиночный символ как символ ESC. Символ ESC используется сразу перед процентом или подчёркиванием в предикате и означает, что процент или подчёркивание будет интерпретироваться как символ, а не как групповой символ-шаблон. Например, мы могли бы найти наш sname-столбец, где присутствует подчёркивание, следующим образом:
SELECT * FROM Salespeople WHERE sname LIKE '%/_%' ESCAPE '/';
С этими данными не будет никакого вывода, потому что мы не включили никакого подчёркивания в имя нашего продавца. Ключевое слово ESCAPE определяет '/ ' как ESC-символ. ESC-символ, используемый в LIKE-строке, сопровождается знаком процента, знаком подчёркивания или знаком ESCAPE, который будет искаться в столбце, а не обрабатываться как шаблон.
Символ ESC должен быть одиночным символом и применяется только к одиночному символу сразу после него.
В примере выше, символ процента начала и символ процента окончания обрабатываются как групповые символы; только подчёркивание представлено как сам символ.
Как упомянуто выше, символ ESC может также использоваться самостоятельно. Другими словами, если вы будете искать столбец с символом ESC, вы просто вводите его дважды. Символ ESC "берёт следующий символ буквально как символ" и, во-вторых, символ ESC самостоятелен.
Вот предыдущий пример, который пересмотрен, чтобы найти местонахождение строки '_/' в sname-столбце:
SELECT * FROM Salespeople WHERE sname LIKE '%/_//%' ESCAPE'/';
Снова не будет никакого вывода с такими данными. Строка сравнивается с содержанием любой последовательности символов (%), сопровождаемых символом подчёркивания ( /_ ), символом ESC ( // ) и любой последовательностью символов в конце строки (%).
ОПИСАНИЕ ОГРАНИЧЕНИЙ ТАБЛИЦЫ
Имеется несколько атрибутов таких определений, о которых нужно поговорить. Причина, по которой мы решили сделать поля cnum и snum в таблице Заказов единым внешним ключом, это гарантия того, что для каждого заказчика, содержащегося в заказах, продавец, кредитующий этот заказ - тот же, что и указанный в таблице Заказчиков.
Чтобы создать такой внешний ключ, мы должны были бы поместить ограничение таблицы UNIQUE в два поля таблицы Заказчиков, даже если оно необязательно для самой этой таблицы. Пока поле cnum в этой таблица имеет ограничение PRIMARY KEY, оно будет уникально в любом случае, и, следовательно, невозможно получить ещё одну комбинацию поля cnum с каким-то другим полем.
Создание внешнего ключа таким способом поддерживает целостность БД (даже если при этом вам будет запрещено внутреннее прерывание по ошибке) и кредитование любого продавца, отличного от того, который назначен именно этому заказчику.
С точки зрения поддержания целостности БД, внутренние прерывания (или исключения), конечно же, нежелательны. Если вы их допускаете и, в то же время, хотите поддерживать целостность вашей БД, вы можете объявить поля snum и cnum в таблице Заказов независимыми внешними ключами этих полей в таблице Продавцов и таблице Заказчиков, соответственно.
Фактически не обязательно использовать поля snum в таблице Заказов, как это делали мы,
хотя это полезно было сделать для разнообразия. Поле cnum, связывая каждый заказ заказчиков в таблице Заказчиков и в таблице Заказов, должно всегда быть общим, чтобы находить правильное поле snum для данного заказа (не разрешая никаких исключений). Это означает, что мы записываем фрагмент информации - какой заказчик назначен к какому продавцу - дважды, и нужно будет выполнять дополнительную работу чтобы удостовериться, что обе версии согласуются.
Если мы не имеем ограничения внешнего ключа, как сказано выше, эта ситуация будет особенно проблематична, потому что каждый порядок нужно будет проверять вручную (вместе с запросом), чтобы удостовериться, что именно соответствующий продавец кредитовал каждую соответствующую продажу. Наличие такого типа информационной избыточности в вашей БД называется деморализация (denormalization), что нежелательно в идеальной реляционной базе данных, хотя практически и может быть разрешено. Деморализация может заставить некоторые запросы выполняться быстрее, поскольку запрос в одной таблице выполняется всегда значительно быстрее, чем в объединении.
ОПИСАНИЕ SELECT
В общем случае команда SELECT начинается с ключевого слова SELECT, сопровождаемого пробелом. После этого должен следовать список имён столбцов, которые вы хотите видеть, отделяемых запятыми. Если вы хотите видеть все столбцы таблицы, вы можете заменить этот список звездочкой (*). Ключевое слово FROM, следующее далее, сопровождается пробелом и именем таблицы, запрос к которой делается. В конце должна использоваться точка с запятой (;) для окончания запроса и указания на то, что команда готова к выполнению.
ОПРЕДЕЛЕНИЕ МОДИФИЦИРУЕМОСТИ ПРЕДСТАВЛЕНИЯ
Если команды модификации могут выполняться в представлении, представление, как уже говорилось, будет модифицируемым; в противном случае оно предназначено только для чтения при запросе. Не противореча этой терминологии, мы будем использовать выражение "модифицировать представление" (updating a view), что означает возможность выполнения в представление любой из трёх команд модификации DML (Вставить, Изменить и Удалить), которые могут изменять значения.
Как вы определите, является ли представление модифицируемым? В теории базы данных, это - пока обсуждаемая тема. Основной принцип таков: модифицируемое представление это представление, в котором команда модификации может выполниться, чтобы изменить одну, и только одну, строку основной таблицы в каждый момент времени, не воздействуя на любые другие строки любой таблицы. Использование этого принципа на практике, однако, затруднено.
Кроме того, некоторые представления, которые теоретически являются модифицируемыми, на самом деле не являются модифицируемыми в SQL.
Вот критерии, по которым определяют, является ли в SQL-представление модифицируемым, или нет:
Оно должно выводиться из одной, и только из одной, базовой таблицы.
Оно должно содержать первичный ключ этой таблицы (это технически не предписывается стандартом ANSI, но было бы неплохо придерживаться этого).
Оно не должно иметь никаких полей, которые являлись бы агрегатными функциями.
Оно не должно содержать DISTINCT в своем определении.
Оно не должно использовать GROUP BY или HAVING в своем определении.
Оно не должно использовать подзапросы (это ANSI-ограничение, которое не предписано для некоторых реализаций).
Оно может быть использовано в другом представлении, но это представление должно также быть модифицируемым.
Оно не должно использовать константы, строки или выражения для значений (например: comm * 100) среди выбранных полей вывода.
Для INSERT оно должно содержать любые поля основной таблицы, которые имеют ограничение NOT NULL, если другое ограничение по умолчанию не определено.
ОСТАЛЬНОЕ СОДЕРЖИМОЕ КАТАЛОГА
Здесь показаны определения остальных ваших системных таблиц с типовым запросом для каждого:
ОТМЕНА ПРИВИЛЕГИЙ
Также как ANSI предоставляет команду CREATE TABLE, чтобы создать таблицу, а DROP TABLE - чтобы от нее избавиться, так и команда GRANT позволяет вам давать привилегии пользователям, не предоставляя способа отобрать их обратно.
Удаление привилегии выполняется командой REVOKE, фактически - стандартному средству с достаточно понятной формой записи. Синтаксис команды REVOKE похож на GRANT, но имеет обратный смысл.
Чтобы удалить привилегию INSERT для Adrian в таблице Заказов, вы можете ввести
REVOKE INSERT ON Orders FROM Adrian;
Использование списков привилегий и пользователей здесь допустимы, как и в случае с GRANT, так что вы можете ввести следующую команду:
REVOKE INSERT, DELETE ON Customers FROM Adrian, Stephen;
Однако здесь имеется некоторая неясность. Кто имеет право отменять привилегии? Когда пользователь с правом передавать привилегии другим, теряет это право, пользователи, которым он предоставил эти привилегии, также их потеряют?
Так как это нестандартная особенность, нет никаких авторитетных ответов на эти вопросы, но наиболее общий подход таков:
Привилегии отменяются пользователем, который их предоставил, и отмена будет каскадироваться, то есть она будет автоматически распространяться на всех пользователей, получивших от него эту привилегию.
ОТСЛЕЖИВАНИЕ ДЕЙСТВИЙ
Ваша SQL-реализация достаточна хороша, если она доступна многим пользователям, чтобы обеспечивать им некий способ слежения за действиями, выполняемыми в базе данных.
Имеются две основные формы, чтобы реализовать это: Journaling (Протоколирование) и Auditing (Ревизия).
Эти формы отличаются по назначению.
Journaling применяется с целью защиты ваших данных при разрушении вашей системы. Сначала вы используете реализационно зависимую процедуру, чтобы архивировать текущее содержание вашей базы данных, поэтому копия её содержания где-нибудь будет сохранена. Затем вы просматриваете протокол изменений, сделанных в базе данных. Он сохраняется в некоторой области памяти, но не в главной памяти базы данных, а желательно на отдельном устройстве, и содержит список всех команд, которые произвели изменения в структуре или в содержании базы данных.
Если у вас вдруг появились проблемы и текущее содержание вашей базы данных оказалось нарушенным, вы можете повторно выполнить все изменения, зарегистрированные в протоколе на резервной копии вашей базы данных, и снова привести вашу базу данных в состояние, которое было до момента последней записи в протокол. Типичной командой для начала протоколирования будет следующая:
SET JOURNAL ON;
Auditing используется с целью защиты. Она следит за тем, кто и какие действия выполнял в базе данных, и сохраняет эту информацию в таблице, доступной только очень немногим привилегированным пользователям. Конечно, вы редко будете прибегать к процедуре ревизии, потому что очень скоро она займет много памяти и вам будет сложно работать в вашей БД. Но вы можете устанавливать ревизию для определённых пользователей, определённых действий или определённых объектов данных. Имеется такая форма команды AUDIT:
AUDIT INSERT ON Salespeople BY Diane;
Или предложение ON, или предложение BY могут быть исключены, устанавливая ревизию либо всех объектов, либо всех пользователей, соответственно. Применение AUDIT ALL вместо AUDIT INSERT приведет к отслеживанию всех действий Diane в таблице Продавцов.
ПАРАМЕТРЫ DISTINCT
DISTINCT может указываться только один раз в данном предложении SELECT. Если предложение выбирает несколько полей,
=============== SQL Execution Log =========== | | | SELECT DISTINCT snum | | FROM Orders; | | | | ============================================= | | snum | | ------- | | 1001 | | 1002 | | 1003 | | 1004 | | 1007 | =============================================
Рисунок 3.5 SELECT без дублирования
DISTINCT опускает строки, где все выбранные поля идентичны. Строки, в которых некоторые значения одинаковы, а некоторые - различны, будут сохранены. DISTINCT фактически приводит к показу всей строки вывода, не указывая полей (за исключением случав, когда он используется внутри агрегатных функций, как описано в Главе 6), так что нет никакого смысла его повторять.
ПАСКАЛЬ
| INTEGER | INTEGER |
ПЕРЕИМЕНОВАНИЕ С ТЕМ ЖЕ САМЫМ ИМЕНЕМ
Префикс (прозвище) пользователя это фактически часть имени любой таблицы. Всякий раз, когда вы не указываете ваше имя пользователя вместе с именем вашей собственной таблицы, SQL сам заполняет для вас это место. Следовательно, два одинаковых имени таблицы, но связанные с различными владельцами, становятся неидентичными и не приводят к какому-нибудь беспорядку (по крайней мере в SQL). Это означает, что два пользователя могут создать две полностью не связанные таблицы с одинаковыми именами, но это также будет означать, что один пользователь может создать представление, основанное на имени другого пользователя, стоящем после имени таблицы. Это иногда делается, когда представление рассматривается как сама таблица - например, если представление просто использует CHECK OPTION как заменитель ограничения CHECK в базовой таблице (смотрите подробности в Главе 22).
Вы можете также создавать ваши собственные синонимы, имена которых будут такими же, что и первоначальные имена таблиц.
Например, Adrian может определить Customers как свой синоним для таблицы Diane.Customers:
CREATE SYNONYM Customers FOR Diane.Customers;
С точки зрения SQL теперь имеются два разных имени одной таблицы: Diane.Customers и Adrian.Customers. Однако каждый из этих пользователей может обращаться к этой таблице просто Customers. SQL, как говорилось выше, сам добавит недостающие имена пользователей.
ПЕРЕИМЕНОВАНИЕ ТАБЛИЦ
Каждый раз, когда вы ссылаетесь в команде на базовую таблицу или представление, не являющиеся вашей собственностью, вы должны установить в команде префикс имени владельца так, чтобы SQL знал, где искать. Так как это со временем становится неудобным, большинство реализаций SQL позволяют вам создавать синонимы для таблиц (что не является стандартом ANSI). Синоним это альтернативное имя, наподобие прозвища.
Когда вы создаёте синоним, вы становитесь его собственником, так что нет никакой необходимости, чтобы он предшествовал другому пользовательскому идентификатору доступа (имени пользователя).
Если вы имеете по крайней мере одну привилегию в одном или более столбцах таблицы, вы можете создать для них синоним. (Некоторое отношение к этому может иметь специальная привилегия для создания синонимов.)
Adrian может создать синоним с именем Clients для таблицы с именем Diane.Customers с помощью команды CREATE SYNONYM:
CREATE SYNONYM Clients FOR Diane.Customers;
Теперь Adrian может использовать таблицу с именем Clients в команде точно так же, как её использует Diane.Customers. Синоним Clients это собственность, используемая исключительно Adrian.
ПЕРЕМЕННАЯ INDICATOR
Пустые (NULL) значения это специальные маркеры, определяемые самим SQL. Они не могут помещаться в главные переменные. Попытка вставить NULL-значения в главную переменную будет некорректна, так как главные языки не поддерживают NULL-значений в SQL по определению. Хотя результат при попытке вставить NULL-значение в главную переменную определяет проектировщик, этот результат не должен противоречить теории БД и поэтому обязан выдавать ошибку - код SQLCODE в виде отрицательного числа - и вызывать подпрограмму управления ошибкой. Естественно, вам нужно этого избежать. Поэтому вы можете заменить NULL-значения на допустимые значения, не приводящие к разрушению вашей программы. Даже если программа и не разрушится, значения в главных переменных станут неправильными, потому что они не могут иметь NULL-значений.
Альтернативным методом, предоставляемым для этой ситуации, является функция переменной indicator (указатель). Переменная indicator, объявленная в разделе объявлений SQL, напоминает другие переменные. Она может иметь тип главного языка, который соответствует числовому типу в SQL. Всякий раз, когда вы выполняете операцию, которая должна поместить NULL-значение в переменную главного языка, вы должны использовать переменную indicator для надежности.
Вы помещаете переменную indicator в команду SQL непосредственно после переменной главного языка, которую вы хотите защитить, без каких-либо пробелов или запятых, хотя вы и можете, при желании, вставить слово INDICATOR. Переменной indicator в команде изначально присваивается значение 0. Однако, если производится значение NULL, переменная indicator становится равной отрицательному числу. Вы можете проверить значение переменной indicator, чтобы узнать, было ли найдено значение NULL.
Давайте предположим, что поля city и comm таблицы Продавцов не имеют ограничения NOT NULL, и что мы объявили в разделе объявлений SQL две ПАСКАЛевские переменные целого типа, i_a и i_b. (Нет ничего такого в разделе объявлений, что могло бы представить их как переменные indicator. Они станут переменными indicator, когда будут использоваться как переменные indicator.)
Имеется одна возможность:
EXEC SQL OPEN CURSOR High_cust; while SQLCODE = O do begin EXEC SQL FETCH High_cust INTO :id_num, :salesperson, :loc:i_a, :commINDlCATOR:i_b; If i_a > = O and i_b > = O then {no NULLs produced} EXEC SQL UPDATE Salespeople SET comm = comm + .01 WHERE CURRENT OF Hlgh_cust; else {one or both NULL} begin If i_a < O then writeln ('salesperson ', id_num, ' has no city'); If i_b < O then writeln ('salesperson ', id_num, ' has no commission'); end; {else} end; {while} EXEC SQL CLOSE CURSOR High_cust;
Как видите, мы включили, ключевое слово INDICATOR в одном случае и исключили его в другом случае, чтобы показать, что эффект будет одинаковым в любом случае. Каждая строка будет выбрана, но команда UPDATE выполнится, только если NULL-значения не будут обнаружены. Если будут обнаружены NULL-значения, выполнится ещё одна часть программы, которая распечатает предупреждающее сообщение - где было найдено каждое NULL-значение.
Обратите внимание: переменные indicator должны проверяться в главном языке, как указывалось выше, а не в предложении WHERE команды SQL. Последнее в принципе не запрещено, но результат часто бывает непредсказуем.
ПЕРЕУПОРЯДОЧИВАНИЕ СТОЛБЦА
Даже если столбцы таблицы, по определению, упорядочены, это не означает, что вы будете восстанавливать их в том же порядке. Конечно, звёздочка (*) покажет все столбцы в их естественном порядке, но если вы укажете столбцы отдельно, вы можете получить их в том порядке, в котором хотите. Давайте рассмотрим таблицу Заказов, содержащую дату приобретения (odate), номер продавца (snum), номер заказа (onum) и суммы приобретения (amt):
SELECT odate, snum, onum, amt FROM Orders;
Вывод этого запроса показан на Рисунке 3.3.
============= SQL Execution Log ============== | | | SELECT odate, snum, onum, amt | | FROM Orders; | | | | ------------------------------------------------| | odate snum onum amt | | ----------- ------- ------ --------- | | 10/03/1990 1007 3001 18.69 | | 10/03/1990 1001 3003 767.19 | | 10/03/1990 1004 3002 1900.10 | | 10/03/1990 1002 3005 5160.45 | | 10/03/1990 1007 3006 1098.16 | | 10/04/1990 1003 3009 1713.23 | | 10/04/1990 1002 3007 75.75 | | 10/05/1990 1001 3008 4723.00 | | 10/06/1990 1002 3010 1309.95 | | 10/06/1990 1001 3011 9891.88 | | | ===============================================
Рисунок 3.3 Реконструкция столбцов
Как видите, структура информации в таблицах это просто основа для активной перестройки структуры в SQL.
ПЕРВИЧНЫЕ КЛЮЧИ БОЛЕЕ ЧЕМ ОДНОГО ПОЛЯ
Ограничение PRIMARY KEY может также быть применено для нескольких полей, составляющих уникальную комбинацию значений. Предположим, что ваш первичный ключ это имя и вы имеете первое имя и последнее имя, сохранёнными в двух различных полях (так, что вы можете организовывать данные с помощью любого из них). Очевидно, что ни первое, ни последнее имя нельзя заставить быть уникальным самостоятельно, но мы можем каждую из этих двух комбинаций сделать уникальной.
Мы можем применить ограничение таблицы PRIMARY KEY для пар:
CREATE TABLE Namefield (firstname char (10) NOT NULL, lastname char (10) NOT NULL city char (10), PRIMARY KEY (firstname, lastname));
Одна проблема в этом подходе - мы можем вынудить появление уникальности, например, введя Mary Smith и M. Smith. Это может ввести в заблуждение, потому что ваши служащие могут не знать, кто из них кто. Обычно более надежный способ определения числового поля, которое могло бы отличать одну строку от другой, - иметь первичный ключ и применять ограничение UNIQUE для двух имен полей.
ПЕРВИЧНЫЙ КЛЮЧ КАК УНИКАЛЬНЫЙ ВНЕШНИЙ КЛЮЧ
Ссылка ваших внешних ключей только на первичные ключи, как мы это делали в типовых таблицах, - хорошая стратегия. Когда вы используете внешние ключи, вы связываете их не просто с родительскими ключами, на которые они ссылаются; вы связываете их с определённой строкой таблицы, где этот родительский ключ будет найден. Сам по себе родительский ключ не обеспечивает никакой информации, которая не была бы уже представлена во внешнем ключе. Смысл, например, поля snum как внешнего ключа в таблице Заказчиков - это связь, которую оно обеспечивает, но не со значением поля snum, на которое он ссылается, а с другой информацией в таблице Продавцов. Такой, например, как имена продавцов, их местоположение и так далее. Внешний ключ это не просто связь между двум идентичными значениями; это связь - с помощью этих двух значений - между двум строками таблицы, указанной в запросе.
Это поле snum может использоваться, чтобы связывать любую информацию в строке из таблицы Заказчиков со ссылочной строкой из таблицы Продавцов, например, чтобы узнать, живут ли они в том же самом городе, кто имеет более длинное имя, имеет ли продавец кроме данного заказчика каких-то других заказчиков, и так далее.
Так как цель первичного ключа состоит в том, чтобы идентифицировать уникальность строки, это более логичный и менее неоднозначный выбор для внешнего ключа. Для любого внешнего ключа, который использует уникальный ключ как родительский ключ, вы должны создать внешний ключ, который использовал бы первичный ключ той же самой таблицы для того же самого действия.
Внешний ключ, который не имеет никакой другой цели, кроме связывания строк, напоминает первичный ключ, используемый исключительно для идентификации строк, и является хорошим средством сохранить структуру вашей БД ясной и простой и, следовательно, создающей меньше трудностей.
PL/I
| CHAR | CHAR |
| DECIMAL |
ПОДРАЗДЕЛЫ SQL
И в интерактивной, и во вложенной формах SQL имеются многочисленные части, или подразделы. Так как вы, вероятно, столкнетесь с этой терминологией при чтении SQL, мы дадим некоторые пояснения. К сожалению, эти термины не используются повсеместно во всех реализациях. Они указаны ANSI и полезны на концептуальном уровне, но большинство SQL-программ практически не обрабатывают их отдельно, так что они, по существу, становятся функциональными категориями команд SQL.
DDL (Язык Определения Данных) - так называемый Язык Описания Схемы в ANSI - состоит из команд, которые создают объекты (таблицы, индексы, просмотры и так далее) в базе данных.
DML (Язык Манипулирования Данными) это набор команд, которые определяют, какие значения представлены в таблицах в любой момент времени.
DCD (Язык Управления Данными) состоит из средств, которые определяют, разрешить ли пользователю выполнять определённые действия, или нет. Они являются составными частями DDL в ANSI.
Не забывайте эти названия. Это не различные языки, а разделы команд SQL, сгруппированные по их функциям.
ПОДЗАПРОСЫ В ПРЕДЛОЖЕНИИ HAVING
Вы можете также использовать подзапросы внутри предложения HAVING. Эти подзапросы могут использовать свои собственные агрегатные функции, если они не производят нескольких значений, или использовать GROUP BY или HAVING. Следующий запрос является примером этого (вывод показан на Рисунке 10.7):
SELECT rating, COUNT (DISTINCT cnum) FROM Customers GROUP BY rating HAVING rating > (SELECT AVG (rating) FROM Customers WHERE city = " San Jose');
=============== SQL Execution Log ============= | | | SELECT rating,count (DISTINCT cnum) | | FROM Customers | | GROUP BY rating | | HAVING rating > | | (SELECT AVG (rating)snum + 1000 | | FROM Custimers | | WHERE city = 'San Jose'); | |================================================ | | rating | | -------- -------- | | 200 2 | ================================================
Рисунок 10.7 Поиск в San Jose заказчиков с оценкой выше среднего
Эта команда подсчитывает заказчиков в San Jose с рейтингами выше среднего. Так как имеются другие оценки, отличные от 300, они должны быть выведены с числом номеров заказчиков, которые имели эту оценку.
ПОДЗАПРОСЫ ВЫБИРАЮТ ОДИНОЧНЫЕ СТОЛБЦЫ
Смысл всех подзапросов, обсуждённых в этой главе, в том, что все они выбирают одиночный столбец. Это обязательно, поскольку полученный вывод сравнивается с одиночным значением. Подтверждением этому является то, что SELECT * не может использоваться в подзапросе. Имеется исключение из этого, когда подзапросы используются с оператором EXISTS, о котором мы будем говорить в Главе 12.
ПОЛЬЗОВАТЕЛИ
Каждый пользователь в среде SQL имеет специальное идентификационное имя или номер. Терминология везде разная, но мы выбрали (следуя ANSI) ссылку на имя или номер как на Идентификатор (ID) доступа. Команда, посланная в базе данных, ассоциируется с определённым пользователем; или иначе - специальным Идентификатором доступа. Поскольку это относится к БД SQL, ID разрешения это имя пользователя, и SQL может использовать специальное ключевое слово USER, которое ссылается на Идентификатор доступа, связанный с текущей командой. Команда интерпретируется и разрешается (или запрещается) на основе информации, связанной с Идентификатором доступа пользователя, подавшего команду.
ПОМЕЩЕНИЕ ТЕКСТА В ВАШЕМ ВЫВОДЕ ЗАПРОСА
Символ 'A', когда ничего не значит сам по себе, является константой, такой, например, как число 1.
Вы можете вставлять константы в предложение SELECT-запроса, включая и текст. Однако символьные константы, в отличие от числовых констант, не могут использоваться в выражениях. Вы можете иметь выражение 1 + 2 в вашем предложении SELECT, но вы не можете использовать выражение типа 'A' + 'B'; это приемлемо, только если мы имеем в виду, что 'A' и 'B' это просто буквы, а не переменные и не символы.
Тем не менее, возможность вставлять текст в вывод ваших запросов - очень удобная штука.
Вы можете усовершенствовать предыдущий пример, представив комиссионные как проценты со знаком процентов (%). Это даст вам возможность помещать в вывод символы и комментарии, как в следующем примере (вывод показан на Рисунке 7.2):
SELECT snum, sname, city, ' % ', comm * 100 FROM Salespeople;
=============== SQL Execution Log ============ | | | SELECT snum, sname, city, '%' comm * 100 | | FROM Salespeople; | | ==============================================| | snum sname city | | ------ -------- ----------- ---- --------- | | 1001 Peel London % 12.000000 | | 1002 Serres San Jose % 13.000000 | | 1004 Motika London % 11.000000 | | 1007 Rifkin Barcelona % 15.000000 | | 1003 Axelrod New York % 10.000000 | | | ===============================================
Рисунок 7.2 Вставка символов в вывод
Обратите внимание, что пробел перед процентом вставляется как часть строки. Эта же особенность может использоваться, чтобы маркировать вывод вместе с вставляемыми комментариями.
Вы должны помнить, что этот же самый комментарий будет напечатан в каждой строке вывода, а не просто один раз для всей таблицы. Предположим, что вы генерируете вывод для отчёта, который указывал бы число заказов, получаемых в течение каждого дня. Вы можете промаркировать ваш вывод (см. Рисунок 7.3), сформировав запрос следующим образом:
SELECT ' For ', odate, ', there are ', COUNT (DISTINCT onum), 'orders.' FROM Orders GROUP BY odate;
Грамматической некорректности вывода на 5 октября невозможно избежать, не создав запроса, ещё более сложного, чем этот. (Вы должны будете использовать два запроса с UNION, который
=============== SQL Execution Log ============== | | | SELECT 'For', odate, ', ' there are ' , | | COUNT (DISTINCT onum), ' orders ' | | FROM Orders | | GROUP BY odate; | | =============================================== | | odate | | ------ ---------- --------- ------ ------- | | For 10/03/1990 , there are 5 orders. | | For 10/04/1990 , there are 2 orders. | | For 10/05/1990 , there are 1 orders. | | For 10/06/1990 , there are 2 orders. | | | ================================================
Рисунок 7.3: Комбинация текста, значений поля, и агрегатов
мы будем рассматривать в Главе 14.) Как видите, одиночный неизменный комментарий для каждой строки таблицы может быть очень полезен, но имеет ограничения. Иногда изящнее и полезнее создать один комментарий для всего вывода в целом или создавать свой собственный комментарии для каждой строки.
Различные программы, использующие SQL, часто обеспечивают специальные средства типа генератора отчетов (например Report Writer), которые разработаны, чтобы форматировать и совершенствовать вывод. Вложенный SQL может также использовать возможности того языка, в который он вложен. SQL сам по себе интересен прежде всего при операциях с данными. Вывод, по существу, это информация; и программа, использующая SQL, может часто использовать эту информацию и помещать её в более привлекательную форму. Это, однако, вне сферы самого SQL.
ПОРЯДОК СТРОК ПРОИЗВОЛЕН
Чтобы поддерживать максимальную гибкость, строки таблицы, по определению, не должны находиться в каком-то определенном порядке. С этой точки зрения структура БД отличается от нашей адресной книги.
Вход в адресную книгу обычно упорядочивается в алфавитном порядке. В системах с РБД имеется одна мощная возможность для пользователей: способность упорядочивать информацию так, чтобы они могли восстанавливать её.
Рассмотрим вторую таблицу. Иногда вам необходимо видеть эту информацию упорядоченной в алфавитном порядке по именам, иногда - в возрастающем или убывающем порядке, а иногда - сгруппированной по отношению к какому-нибудь доктору.
Порядок набора в строках будет конфликтовать со способностью заказчика изменять его, поэтому строки всегда рассматриваются как неупорядоченные. По этой причине вы не можете просто сказать: "Мы хотим посмотреть пятую строку таблицы". Пренебрегая порядком, в котором данные вводились, или любым другим критерием, мы определим не ту строку, хотя она и будет пятой. Строки таблицы не находятся в какой-либо определенной последовательности.
ПРАВИЛЬНОЕ ПОНИМАНИЕ ANY И ALL
В SQL, сказать, что значение больше (или меньше), чем любое (ANY) из набора значений - то же самое, что сказать, что оно больше (или меньше), чем любое отдельное из этих значений. И наоборот, сказать, что значение не равно всему (ALL) набору значений, это то же, что сказать, что нет такого значения в наборе которому оно равно.
ПРЕДИКАТЫ
Здесь определён список различных типов предиката <predicate>, описанных на следующих страницах:
<predicate> ::= [NOT]
{ <comparison predicate> | <in predicate> | <null predicate> | <between predicate> | <like predicate> | <quantified predicate> | <exists predicate> } [ANDI OR <predicate> ]
<predicate> - это выражение, которое может быть true, false или неизвестным, за исключением
<exists predicate> и <null predicate>, которые могут быть только верными или неверными.
Будет получено "неизвестно", если NULL-значения предотвращают вывод полученного ответа. Это будет случаться всякий раз, когда NULL-значение сравнивается с любым значением. Стандартные булевы операторы - AND, OR и NOT - могут использоваться с предикатом. NOT true = false, NOT false = true, а NOT неизвестно = неизвестно. Результаты AND и OR в комбинации с предикатами, показаны в следующих таблицах:
AND
AND True False Неизвестно
True true false неизвестно False false false false Неизвестно неизвестно false неизвестно
OR
OR True False Неизвестно
True true true true False true false неизвестно Неизвестно true неизвестно неизвестно
Эти таблицы читаются способом, наподобие таблицы умножения: вы объединяете верные, неверные, или неизвестные значения из строк с их столбцами, чтобы на перекрестье получить результат. В таблице AND, например, третий столбец (Неизвестно) и первая строка (Тrue) на пересечении в верхнем правом углу дают результат - неизвестно, другими словами: Верно AND Неизвестно = неизвестно. Порядок вычислений определяется круглыми скобками. Они не представляются каждый раз. NOT оценивается первым, далее AND и OR. Различные типы предикатов <predicate> рассматриваются отдельно в следующем разделе.
<comparison predicate> (предикат сравнения)
Синтаксис
<value expresslon> <relational op> <value expresslon> |
<subquery>
<relatlonal op> :: =
=
| <
|>
| <
|>=
| <>
Если либо <value expression> = NULL, либо <comparison predicate> = неизвестно;
другими словами, это true, если сравнение true, или false, если сравнение false.
<relational op> имеет стандартные математические значения для числовых значений; для других типов значений эти значения определяются конкретной реализацией.
Оба <value expression> должны иметь сравнимые типы данных. Если подзапрос <subquery> используется, он должен содержать одно выражение <value expression> в предложении SELECT, чьё значение будет заменять второе выражение <value expression> в предикате сравнения <comparision predicate> каждый раз, когда <subquery> действительно выполняется.
<between predicate>
Синтаксис
<value expression> [NOT] BETWEEN <value expression>
AND <value expression>
<between predicate> - A BETWEEN B AND C имеет такое же значение, что и <predicate> - ( A>= B AND <= C). <between predicate>, для которого A NOT BETWEEN B AND C, имеет такое же значение, что и NOT (BETWEEN B AND C).
<value expression> может быть выведено с помощью нестандартного запроса <subquery> (*nonstandard*).
<in prediicate>
Синтаксис
<value expression> [NOT] IN <value list> | <subquery>
Список значений <value list> будет состоять из одного или более значений в круглых скобках с разделением запятыми, которые имеют сравнимый с <value expression> тип данных. Если используется подзапрос <subquery>, он должен содержать только одно выражение <value expression> в предложении SELECT (возможно и больше, но это уже будет вне стандарта ANSI).
Подзапрос <subquery> фактически выполняется отдельно для каждой строки-кандидата основного запроса, и значения, которые он выведет, будут составлять список значений <value list> для этой строки. В любом случае предикат <in predicate> будет верен, если выражение <value expression> представленное в списке значений <value list>, если не указан NOT.
Фраза A NOT IN (B, C) является эквивалентом фразы NOT (A IN (B, C)).
<like predicate>
Синтаксис
<charvalue> [NOT] LIKE <pattern> [ESCAPE
<escapechar>]
<charvalue> это любое *нестандартное* выражение <value expression> алфавитно-цифрового типа.
<charvalue> может быть, в соответствии со стандартом, только определенным столбцом <column spec>. Образец <pattern> состоит из строки, которая будет проверена на совпадение с <charvalue>. Символ окончания <escapechar> это одиночный алфавитно-цифровой символ. Совпадение произойдет, если верны следующие условия:
Для каждого символа подчёркивания <underscore> в образце <pattern>, который не предшествует символу окончания <escapechar>, имеется один соответствующий ему символ <charvalue>.
Для каждого <percent sign> в образце <pattern>, который не предшествует <escapechar>, имеются нуль или более соответствующих символов в <charvalue>.
Для каждого <escapechar> в <pattern>, который не предшествует другому <escapechar>, нет никакого соответствующего символа в <charvalue>.
Для каждого иного символа в <pattern>, один и тот же символ устанавливается у соответствующей отметке в <charvalue>.
Если совпадение произошло, <like predicate> верен, если не был указан NOT. Фраза NOT LIKE 'текст' - эквивалентна NOT (A LIKE 'текст').
<null predicate>
Синтаксис
<column spec> IS [NOT] NULL
<column spec> = IS NULL, если NULL значение представлено в этом столбце. Это сделает <null predicate> верным, если не указан NULL. Фраза <column spec> IS NOT NULL, имеет тот же результат что и NOT (<column spec> IS NULL).
<quantified predicate>
Синтаксис
<value expression> <relational op>
<quantifier> <subquery>
<quantifier> :: = ANY | ALL | SOME
Предложение SELECT подзапроса <subquery> должно содержать одно, и только одно, выражение значения <value expression>. Все значения, выведенные подзапросом <subquery>, составляют набор результатов <result set>. <value expression> сравнивается, используя оператор связи <relational operator>, с каждым членом набора результатов <result set>. Это сравнение оценивается следующим образом:
Если <quantifier> = ALL и каждый член набора результатов <result set> делает это сравнение верным, <quantified predicate> верен.
Если <quantifier> = ANY и имеется по крайней мере один член из набора результатов <result set>, который делает верным это сравнение, то <quantified predicate> является верным.
Если набор результатов <result set> пуст, то <quantified predicate> верен, если <quantifier> = ALL , и неверен а ином случае.
Если <quantifier> = SOME, эффект - тот же, что и для ANY.
Если <quantified predicate> неверен и не неверен, он неизвестен.
<exists predicate>
Синтаксис:
EXISTS (<subquery>)
Если подзапрос <subquery> выводит одну или более строк вывода, <exists predicate> верен; и неверен в ином случае.
ПРЕДИКАТЫ И ИСКЛЮЧЁННЫЕ ПОЛЯ
Похожая проблема, о которой вы должны знать, включает в себя вставку строк в представление с предикатом, базирующемся на одном или более исключённых полях. Например, может показаться разумным создание Londonstaff, как здесь:
CREATE VIEW Londonsta1t AS SELECT snum, sname, comm FROM Salespeople WHERE city = 'London';
В конце концов, зачем включать значение city, если все значения city будут одинаковыми?
А как будет выглядеть картинка, получаемая всякий раз, когда мы пробуем вставить строку?
Так как мы не можем указать значение city как значение по умолчанию, этим значением, вероятно, будет NULL, и оно будет введено в поле city (NULL используется, если другое значение по умолчанию не было определено. См. подробности в Главе 18). Так как в этом случае поле city не будет равняться значению London, вставляемая строка будет исключена из представления.
Это будет верным для любой строки, которую вы попробуете вставить в просмотр Londonstaff. Все они должны быть введены с помощью представления Londonstaff в таблицу Продавцов, а затем исключены из самого представления (если определением по умолчанию был не London, то это особый случай). Пользователь не сможет вводить строки в это представление, хотя всё ещё не известно, может ли он вводить строки в базовую таблицу. Даже если мы добавим WITH CHECK OPTION в определение представления,
CREATE VIEW Londonstate AS SELECT snum, sname, comm FROM Salespeople WHERE city = 'London' WITH CHECK OPTION;
проблема не обязательно будет решена. В результате этого мы получим представление, которое мы могли бы модифицировать или из которого мы могли бы удалять, но не вставлять в него. В некоторых случаях это может быть хорошо; хотя, возможно, нет смысла пользователям, имеющим доступ к этому представлению, иметь возможность добавлять строки. Но вы должны точно определить, что может произойти, прежде чем вы создадите такое представление.
Даже если это не всегда может обеспечить вас нужной информацией, полезно включать в ваше представление все поля, на которые имеется ссылка в предикате. Если вы не хотите видеть эти поля в вашем выводе, вы всегда сможете исключить их из запроса в представлении, в противоположность запросу внутри представления. Другими словами, вы могли бы определить представление Londonstaff так:
CREATE VIEW Londonstaff AS SELECT * FROM Salespeople WHERE city = 'London' WITH CHECK OPTION;
Эта команда заполнит представление одинаковыми значениями в поле city, которые вы можете просто исключить из вывода с помощью запроса, где указаны только те поля, которые вы хотите видеть:
SELECT snum, sname, comm FROM Londonstaff;
ПРЕДИКАТЫ С ПОДЗАПРОСАМИ ЯВЛЯЮТСЯ НЕОБРАТИМЫМИ
Вы должны обратить внимание что предикаты, включающие подзапросы, используют выражение
<скалярная форма> <оператор> <подзапрос>,
а не
<подзапрос> <оператор> <скалярное выражение>
или
<подзапрос> <оператор> <подзапрос>.
Другими словами, вы не должны записывать предыдущий пример так:
SELECT * FROM Orders WHERE (SELECT DISTINCT snum FROM Orders WHERE cnum = 2001) = snum;
В строгой ANSI-реализации это приведет к неудаче, хотя некоторые программы и позволяют делать такие вещи. ANSI также предохраняет от появления в выводе подзапроса обоих значений при сравнении.
ПРЕДЛОЖЕНИЕ GROUP BY
Предложение GROUP BY позволяет вам определять подмножество значений в особом поле в терминах другого поля и применять агрегатную функцию к подмножеству. Это дает возможность объединять поля и агрегатные функции в едином предложении SELECT.
Например, предположим, что вы хотите найти наибольшую сумму продажи, полученную каждым продавцом. Вы можете сделать раздельный запрос для каждого из них, выбрав MAX (amt) из таблицы Заказов для каждого значения поля snum. GROUP BY, однако, позволит вам поместить всё в одну команду:
SELECT snum, MAX (amt) FROM Orders GROUP BY snum;
Вывод для этого запроса показан на Рисунке 6.5.
=============== SQL Execution Log ============== | | | SELECT snum, MAX (amt) | | FROM Orders | | GROUP BY snum; | | =============================================== | | snum | | ------ -------- | | 1001 767.19 | | 1002 1713.23 | | 1003 75.75 | | 1014 1309.95 | | 1007 1098.16 | | | ================================================
Рисунок 6.5 Нахождение максимальной суммы продажи у каждого продавца
GROUP BY применяет агрегатные функции, независимо от серий групп, которые определяются с помощью значения поля в целом. В этом случае каждая группа состоит из всех строк с тем же самым значением поля snum, и MAX функция применяется отдельно для каждой такой группы. Это значение поля, к которому применяется GROUP BY, имеет, по определению, только одно значение на группу вывода так же, как это делает агрегатная функция. Результатом является совместимость, которая позволяет агрегатам и полям объединяться таким образом.
Вы можете также использовать GROUP BY с несколькими полями. Совершенствуя вышеупомянутый пример, предположим, что вы хотите увидеть наибольшую сумму продаж, получаемую каждым продавцом каждый день. Чтобы сделать это, вы должны сгруппировать таблицу Заказов по датам продавцов и применить функцию MAX к каждой такой группе:
SELECT snum, odate, MAX ((amt)) FROM Orders GROUP BY snum, odate;
Вывод для этого запроса показан на Рисунке 6.6.
=============== SQL Execution Log ============== | | | SELECT snum, odate, MAX (amt) | | FROM Orders | | GROUP BY snum, odate; | | =============================================== | | snum odate | | ------ ---------- -------- | | 1001 10/03/1990 767.19 | | 1001 10/05/1990 4723.00 | | 1001 10/06/1990 9891.88 | | 1002 10/03/1990 5160.45 | | 1002 10/04/1990 75.75 | | 1002 10/06/1990 1309.95 | | 1003 10/04/1990 1713.23 | | 1014 10/03/1990 1900.10 | | 1007 10/03/1990 1098.16 | | | ================================================
Рисунок 6.6 Нахождение наибольшей суммы приобретений на каждый день
Конечно же, пустые группы в дни, когда текущий продавец не имел заказов, не будут показаны в выводе.
ПРЕДЛОЖЕНИЕ HAVING
Предположим, что в предыдущем примере вы хотели бы увидеть только максимальную сумму приобретений, значение которой выше $3000.00. Вы не сможете использовать агрегатную функцию в предложении WHERE (если вы не используете подзапрос, описанный позже), потому что предикаты оцениваются в терминах одиночной строки, а агрегатные функции оцениваются в терминах групп строк. Это означает, что вы не сможете сделать что-нибудь подобно следующему:
SELECT snum, odate, MAX (amt) FROM Orders WHERE MAX ((amt)) > 3000.00 GROUP BY snum, odate;
Это будет отклонением от строгой интерпретации ANSI. Чтобы увидеть максимальную стоимость приобретений свыше $3000.00, вы можете использовать предложение HAVING.
Предложение HAVING определяет критерии, используемые, чтобы удалять определенные группы из вывода, точно так же, как предложение WHERE делает это для отдельных строк.
Правильной командой будет следующая:
SELECT snum, odate, MAX ((amt)) FROM Orders GROUP BY snum, odate HAVING MAX ((amt)) > 3000.00;
Вывод для этого запроса показан на Рисунке 6. 7.
=============== SQL Execution Log ============== | | | SELECT snum, odate, MAX (amt) | | FROM Orders | | GROUP BY snum, odate | | HAVING MAX (amt) > 3000.00; | | =============================================== | | snum odate | | ------ ---------- -------- | | 1001 10/05/1990 4723.00 | | 1001 10/06/1990 9891.88 | | 1002 10/03/1990 5160.45 | | | ================================================
Рисунок 6.7 Удаление групп агрегатных значений
Аргументы в предложении HAVING следуют тем же самым правилам, что и в предложении SELECT, состоящем из команд, использующих GROUP BY. Они должны иметь одно значение на группу вывода.
Следующая команда будет запрещена:
SELECT snum, MAX (amt) FROM Orders GROUP BY snum HAVING odate = 10/03/1988;
Поле оdate не может быть вызвано предложением HAVING, потому что оно может иметь (и действительно имеет) больше чем одно значение на группу вывода. Чтобы избегать такой ситуации, предложение HAVING должно ссылаться только на агрегаты и поля, выбранные GROUP BY. Имеется правильный способ сделать вышеупомянутый запрос (вывод показан на Рисунке 6.8):
SELECT snum, MAX (amt) FROM Orders WHERE odate = 10/03/1990 GROUP BY snum;
=============== SQL Execution Log ============== | | | SELECT snum, odate, MAX (amt) | | FROM Orders | | GROUP BY snum, odate; | | =============================================== | | snum | | ------ -------- | | 1001 767.19 | | 1002 5160.45 | | 1014 1900.10 | | 1007 1098.16 | | | ================================================
Рисунок 6. 8 Максимальное значение суммы продаж у каждого продавца на 3 октября
Поскольку поля odate нет, не может быть и выбранных полей, и значение этих данных меньше, чем в некоторых других примерах. Вывод должен, вероятно, включать что-нибудь такое, что говорит: "это - самые большие заказы на 3 октября". В Главе 7 мы покажем, как вставлять текст в ваш вывод.
Как говорилось ранее, HAVING может использовать только аргументы, которые имеют одно значение на группу вывода. Практически ссылки на агрегатные функции - наиболее общие, но и поля, выбранные с помощью GROUP BY, также допустимы. Например, мы хотим увидеть наибольшие заказы для Serres и Rifkin:
SELECT snum, MAX (amt) FROM Orders GROUP BY snum HAVING snum B (1002,1007);
Вывод для этого запроса показан на Рисунке 6.9.
=============== SQL Execution Log ============== | | | SELECT snum, MAX (amt) | | FROM Orders | | GROUP BY snum | | HAVING snum IN (1002, 1007); | | =============================================== | | snum | | ------ -------- | | 1002 5160.45 | | 1007 1098.16 | | | ================================================
Рисунок 6.9 Использование HAVING с полями GROUP BY
