Материал по информатике "Язык запросов SQL"

имя_новой_таблицы – таблица в которую вставляются результаты.

Создается новая таблица, в которую будут вставлены результаты.

Создадим таблицу «Контакты» из таблицы «Студенты»

SELECT ID_ Студент, Адрес, Телефон

INTO Контакты

FROM Студенты;

Остальные столбцы таблицы «Студенты» удалить.

Запрос из таблицы «Контакты»

SELECT *

FROM Контакты

WHERE Телефон LIKE ’120%’;

Столбцы таблицы ID_ Студент, Адрес, Телефон

Для связи с таблицей «Студенты» в таблице «Контакты» построим внешний ключ

ALTER TABLE Контакты

ADD CONSTRAINT FK_Контакт

FOREIGN KEY (ID_ Студент)

REFERENCES Студенты;

Модифицируем запрос для таблицы «Контакты»

SELECT *

FROM Студенты INNER JOIN

Контакты ON

Студенты. ID_ Студент = Контакты. ID_ Студент

WHERE Телефон LIKE ’120%’;

До сюда

10. INSERT -добавление в таблицу новой информации.

Вставка одной и множество строк

- INSERT[INTO][(список_ колонок)] VALUES()

Используемые ключевые слова:

INTO- вставляется между INSERT и именем таблицы куда вставляют данные.

- VALUES- задаются столбцы для вставки данных. Если списка нет, то данные в столбцы заносятся последовательно, начиная с первого.

- DEFULT- данные вставляются по умолчанию.

- INSERT INTO…. SELECT

Конструкция

- INSERT INTO SELECT

10.1. Вставка одной строки с помощью констант.

Рассмотрим Сводная_ ведомость.

Пусть ID_Студент =10, ID_Дисциплина =3. При этом оценка 5.

Команда добавления этих данных в Сводная_ ведомость

INSERT Сводная_ ведомость

VALUES(10,3,5);

Для произвольного порядка и состава столбцов

INSERT INTO Сводная_ ведомость

(ID_Дисциплина , ID_Студент)

VALUES(3,10);

10.2.

Использование INSERT INTO…. SELECT

Примечание.

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

Например для таблицы Студенты (отсюда будем брать данные) создадим таблицу

Студент_2012 (сюда занесем данные).

Тогда

INSERT INTO Студент_2012 SELECT ID_ Студент, Фамилия, Имя, Отчество, Адрес, Телефон

FROM Студенты

WHERE Год_поступления = 2012;

После выполнения этой последовательности команд инициируем запрос на отбор строк из новой таблицы:

SELECT TOP 5 Фамилия, Имя, Отчество

FROM Студент_2012

11. UPDATE- изменение данных, хранящихся в таблице.

Возможный синтаксис

UPDATE SET{={|DEFAULT|NULL}}[,..,n]

{[FROM{}[,..,n]][WHRE]}

SET- отображается список изменяемых столбцов.

Пример

Добавим в таблицу Учебный_план по два часа в столбец Количество_часов для дисциплин 1-го семестра с формой отчетности экзамен.

Посмотрим исходное состояние данных

SELECT *

FROM Учебный_план

WHRE (Отчетность = ‘э’) FND (Семестр =1)

Выполняем изменения

UPDATE Учебный_план SET Количество_часов = Количество_часов + 2

WHRE (Отчетность = ‘э’) FND (Семестр =1)

SELECT *

FROM Учебный_план

WHRE (Отчетность = ‘э’) FND (Семестр =1)

В столбце количество часов мы увидим увеличение значений на 2.

12. DELETE- удаление данных из таблицы.

Возможный синтаксис

DELETE][WHRE]

Удалим из таблицы Учебный_план дисциплины первого семестра с формой отчетности «зачет».

DELETE Учебный_план

WHRE (Отчетность = ‘э’) FND (Семестр =1)

Рассмотрим сначала следующие таблицы

Имя таблицы Имя поля Тип поля Примечание

FAKULTET KOD_F Integer PRIMARY KEY

NAZV_F Char, 30

SPEC KOD_S Integer PRIMARY KEY

KOD_F Integer

NAZV_S Char, 50

STUDENT KOD_STUD Integer PRIMARY KEY

KOD_S Integer

FAM Char, 30

IM Char, 15

OT Char, 15

STIP Decimal, 3

BALL Decimal, 3

Создадим некоторые запросы для данных таблиц(в качестве справки)

SQL SELECT Пример №1

Выбрать студентов, получающих стипендию, равную 150.

SELECT FAM FROM STUDENT WHERE STIP=150;

С помощью данного SQL запроса SELECT выбираются все значения из таблицы STUDENT, поле STIP которых строго равно 150.

SQL SELECT Пример №2

Выбрать студентов, имеющих балл от 82 до 90. Студенты должны быть отсортированы в порядке убывания балла.

SELECT FAM FROM STUDENT WHERE BALL BETWEEN 81 AND 91 ORDER BY BALL DESC;

Как видно из SQL примера, чтобы выбрать студентов, которые имеют балл от 82 до 90, мы используем условие BETWEEN. Чтобы отсортировать в убывающем порядке DESC.

SQL SELECT. Пример №3

Выбрать студентов, фамилии которых начинаются с буквы «А».

SELECT FAM FROM STUDENT WHERE FAM LIKE ‘А%’;

Для того, чтобы выбрать фамилии, начинающиеся с буквы «А», мы используем оператор SQL LIKE для поиска значений по образцу.

SQL SELECT Пример №4

Подсчитать средний балл на каждом факультете.

SELECT NAZV_F As Название, ROUND(AVG(BALL), 2) As СредБалл FROM FAKULTET, SPEC, STUDENT WHERE STUDENT.KOD_S=SPEC.KOD_S AND SPEC.KOD_F=FAKULTET.KOD_F GROUP BY NAZV_F;

Пример запроса SQL SELECT показывает нам использование функции SQL AVG для вычисления среднего значения, ROUND для округления значения, раздела GROUP BY для группировки столбцов.

SQL SELECT. Пример №5.

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

SELECT NAZV_F||’ обучается ‘||COUNT(STUDENT.BALL)||’ человек’ As CountStudOnFakultet FROM FAKULTET, SPEC, STUDENT WHERE STUDENT.KOD_S=SPEC.KOD_S AND SPEC.KOD_F=FAKULTET.KOD_F GROUP BY NAZV_F;

SQL SELECT. Пример №6.

Упорядочить студентов по факультетам, специальностям, фамилиям.

SELECT NAZV_F, NAZV_S, FAM FROM FAKULTET, SPEC, STUDENT WHERE STUDENT.KOD_S=SPEC.KOD_S AND SPEC.KOD_F=FAKULTET.KOD_F ORDER BY NAZV_F, NAZV_S, FAM;

SQL SELECT. Пример №7.

Определить, кто учится на специальности, к которой относится студент «Асанов».

SELECT FAM FROM STUDENT WHERE STUDENT.KOD_S=(SELECT KOD_S FROM STUDENT WHERE FAM=’Асанов’);

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

SQL SELECT. Пример №8.

Показать, какие специальности встречаются в таблице STUDENT. Дубликаты исключить. Вывести в запросе названия специальностей.

SELECT DISTINCT NAZV_S FROM SPEC, STUDENT WHERE STUDENT.KOD_S=SPEC.KOD_S;

Здесь мы с помощью SQL ограничения DISTINCT выводим только различные значения.

SQL SELECT. Пример №9.

Извлечь из базы данных все данные по сотрудникам, принятым на работу после 01.01.1980 г. в формате “Сотрудник принят на работу ”.

SELECT CONCAT(CONCAT(CONCAT(‘Сотрудник ‘, sname), CONCAT(SUBSTR(fname, 0, 1), SUBSTR(otch, 0, 1))), CONCAT(‘принят на работу ‘, acceptdate)) FROM employees WHERE acceptdate to_date(’01.01.80′,’dd.mm.yyyy’);

В данном SQL SELECT, используя SQL функцию CONCAT мы выводим все поля таблицы в одну строчку. SQL функция to_date возвращает привычное для СУБД значение даты.

SQL SELECT. Пример №10.

Извлечь из базы данных перечень должностей, которые имеют сотрудники следующих отделов: ‘БИОТЕХНОЛОГИЙ’, ‘ИНЖЕНЕРНОЙ ЭКОЛОГИИ’. В запросе использовать названия отделов.

SELECT pname FROM posts, departments, employees WHERE posts.pid = employees.pid AND employees.did = departments.did AND (departments.dname = ‘БИОТЕХНОЛОГИЙ’ OR departments.dname = ‘ИНЖЕНЕРНОЙ ЭКОЛОГИИ’);

Примеры на формирование запросов с заполненными таблицами

Пример №1

SELECT Таблица1.Номер, Таблица1.Фамилия, Таблица1.Имя, Таблица1.Отчество

FROM Таблица1

WHERE (((Таблица1.Имя)="Илья"));

Пример № 2

SELECT Таблица1.Номер, Таблица1.Фамилия, Таблица1.Имя, Таблица1.Отчество

FROM Таблица1

WHERE (((Таблица1.Имя)="Илья" Or (Таблица1.Имя)="Сергей"));

Пример №3

FROM Таблица1 INNER JOIN Таблица2 ON Таблица1.ФИО=Таблица2.ФИО;

Пример №4

SELECT Таблица1.ФИО, Таблица2.Должность, Таблица1.Зарплата

FROM Таблица1 LEFT JOIN Таблица2 ON Таблица1.ФИО=Таблица2.ФИО;

Пример №5

FROM Таблица1;

Пример №6

SELECT Sum(Таблица1.Стоимость) AS [Sum-Стоимость], Sum(Таблица1.[Количество на складе]) AS [Sum-Количество на складе]

FROM Таблица1;

Пример №7

Пример №8

FROM Таблица1

WHERE (((Таблица1.Сотрудник)=[Введите фамилию]));

Пример №9

SELECT [Введите фамилию] AS Сотрудник, [Введите должность] AS Должность, [Введите зарплату] AS Зарплата

FROM Таблица1;

Пример №10

SELECT [Введите ФИО сотрудника] AS Сотрудник, [Введите должность] AS Должность, [Введите зарплату] AS Зарплата INTO Таблица;

Пример №11

FROM Таблица1

WHERE (((Таблица1!Подчиненные)"nil"));

Пример №12

SELECT Таблица1.Наименование, Таблица1.Цена, Таблица1.Категория, [Выборка максимального].[Max-Цена], [Выборка минимального].[Min-Цена]

FROM (Таблица1 INNER JOIN [Выборка максимального] ON Таблица1.Категория=[Выборка максимального].Категория) INNER JOIN [Выборка минимального] ON Таблица1.Категория=[Выборка минимального].Категория

GROUP BY Таблица1.Наименование, Таблица1.Цена, Таблица1.Категория, [Выборка максимального].[Max-Цена], [Выборка минимального].[Min-Цена], [Выборка максимального].Категория, [Выборка минимального].Категория;

Пример №13

SELECT Таблица1.Город

FROM Таблица1

GROUP BY Таблица1.Город;

Пример №14

FROM Таблица1;

Пример №15

SELECT Таблица1.[Номер заказа], Таблица1.Фамилия

FROM Таблица1

ORDER BY Таблица1.[Номер заказа];

Пример №16

SELECT Таблица1.[Номер продукта], Sum(Таблица1.Количество) AS [Sum-Количество]

FROM Таблица1

GROUP BY Таблица1.[Номер продукта];

Пример №17

SELECT Таблица1.Покупатель, Таблица1.[Дата покупки]

FROM Таблица1

WHERE (((Таблица1.[Дата покупки]) Between #1/1/1997# And #1/31/1997#));

1.2. INSERT -добавление в таблицу новой информации.

Вставка одной строки

INSERT[INTO][(список_ колонок)] VALUES()

1.3. UPDATE- изменение данных, хранящихся в таблице.

Возможный синтаксис

UPDATE SET{={|DEFAULT|NULL}}[,..,n]

{[FROM{}[,..,n]][WHRE]}

1.4. DELETE- удаление данных из таблицы.

Возможный синтаксис

DELETE][WHRE]

Задание

1. Изучить синтаксис команды SELECT.

2. Набрать в Access таблицы примеров и проверить правильность выполнения запросов.
   Поясняющий материал(Справочно)

Пример. База данных поставщиков и деталей. Таблицы SUPPLIER, SELLS, PART

SUPPLIER SELLS

SNO | SNAME | CITY SNO | PNO

1 | Smith | London 1 | 1

2 | Jones | Paris 1 | 2

3 | Adams ! Vienna 2 | 4

4 | Blake | Rome 3 | 1

3 | 3

4 | 2

PART 4 | 3

PNO | PNAME | PRICE 4 | 4

1 | Screw | 10

2 | Nut | 8

3 | Bolt | 15

4 | Cam | 25

Создание таблицы

CREATE TABLE SUPPLIER

(SNO INTEGER,

SNAME VARCHAR(20),

CITY VARCHAR(20));

CREATE TABLE PART

(PNO INTEGER,

PNAME VARCHAR(20),

PRICE DECIMAL(4 , 2));

CREATE TABLE SELLS

(SNO INTEGER,

PNO INTEGER);

Создание индекса

Для создания индекса с именем I по атрибуту SNAME отношения SUPPLIER используем следующее выражение:

CREATE INDEX I

ON SUPPLIER (SNAME);

Созданный индекс обслуживается автоматически, т.е. при вставке ново кортежа в отношение SUPPLIER, индекс I будет перестроен. Заметим, что пользователь может ощутить изменения в при существовании индекса только по увеличению скорости.

Создание представлений

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

Представления не имеют своих собственных, физически самостоятельных, различимых хранящихся данных. Вместо этого, система хранит определение представления (т.е. правила о доступе к физически хранящимся базовым таблицам в порядке претворения их в представление) где-то в системных каталогах.

Для определения представлений в SQL используется команда CREATE VIEW

CREATE VIEW London_Suppliers

AS SELECT S.SNAME, P.PNAME

FROM SUPPLIER S, PART P, SELLS SE

WHERE S.SNO = SE.SNO AND

P.PNO = SE.PNO AND

S.CITY = 'London';

Теперь мы можем использовать это виртуальное отношение London_Suppliers как если бы оно было ещё одной базовой таблицей:

SELECT *

FROM London_Suppliers

WHERE P.PNAME = 'Screw';

которое возвращает следующую таблицу:

SNAME | PNAME

-------+-------

Smith | Screw

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

Уничтожение объекта

Для уничтожения таблицы (включая все кортежи, хранящиеся в этой таблице) используется команда DROP TABLE:

Для уничтожения таблицы SUPPLIER используется следующее выражение:

DROP TABLE SUPPLIER;

Команда DROP INDEX используется для уничтожения индекса:

DROP INDEX index_name;

Наконец, для уничтожения заданного представления используется команда DROP VIEW:

DROP VIEW view_name;

Манипулирование данными

Insert Into

После создания таблицы (смотри Создание таблицы), её можно заполнять кортежами с помощью команды INSERT INTO.

Чтобы вставить первый кортеж в отношение SUPPLIER (из База данных поставщиков и деталей) мы используем следующее выражение:

INSERT INTO SUPPLIER (SNO, SNAME, CITY)

VALUES (1, 'Smith', 'London');

Чтобы вставить первый кортеж в отношение SELLS используется:

INSERT INTO SELLS (SNO, PNO)

VALUES (1, 1);

Обновление

Для изменения одного или более значений атрибутов кортежей в отношении используется команда UPDATE.

Чтобы изменить значение атрибута PRICE детали 'Screw' в отношении PART используется:

UPDATE PART

SET PRICE = 15

WHERE PNAME = 'Screw';

Новое значение атрибута PRICE кортежа, чьё имя равно 'Screw' теперь стало 15.

Удаление

Для удаления кортежа из отдельной таблицы используется команда DELETE FROM.

Чтобы удалить поставщика называемого 'Smith', из таблицы SUPPLIER используем следующее выражение:

DELETE FROM SUPPLIER

WHERE SNAME = 'Smith';

Выборка

Оператор SELECT

Простые выборки

Простой ограничивающий запрос

Получить все кортежи из таблицы PART, где атрибут PRICE больше 10:

SELECT * FROM PART

WHERE PRICE 10;

Получаемая таблица:

PNO | PNAME | PRICE

-----+---------+--------

3 | Bolt | 15

4 | Cam | 25

Использовав "*" в операторе SELECT, получаем все атрибуты из таблицы. Если мы хотим получить только атрибуты PNAME и PRICE из таблицы PART, то используем следующее выражение:

SELECT PNAME, PRICE

FROM PART

WHERE PRICE 10;

В этом случае получим:

PNAME | PRICE

--------+--------

Bolt | 15

Cam | 25

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

Ограничения в операторе WHERE могут также быть логически соединены с помощью ключевых слов OR, AND, и NOT:

SELECT PNAME, PRICE

FROM PART

WHERE PNAME = 'Bolt' AND

(PRICE = 0 OR PRICE

приведёт к результату:

PNAME | PRICE

--------+--------

Bolt | 15

Арифметические операции могут использоваться в списке объектов и операторе WHERE. Например, если нам надо знать сколько будут стоить две штуки одной детали, то используем следующий запрос:

SELECT PNAME, PRICE * 2 AS DOUBLE

FROM PART

WHERE PRICE * 2

и мы получим:

PNAME | DOUBLE

--------+---------

Screw | 20

Nut | 16

Bolt | 30

Заметим, что слово DOUBLE после ключевого слова AS - это новый заголовок второго столбца. Эта техника может быть использована для любого элемента списка объектов, для того чтобы задать новый заголовок столбцу результата. Этот новый заголовок часто называют псевдонимом. Псевдонимы не могут просто использоваться в запросе.

Соединения

Для объединения трёх таблиц SUPPLIER, PART и SELLS по их общим атрибутам, мы формулируем следующее выражение:

SELECT S.SNAME, P.PNAME

FROM SUPPLIER S, PART P, SELLS SE

WHERE S.SNO = SE.SNO AND

P.PNO = SE.PNO;

и получаем следующую таблицу в качестве результата:

SNAME | PNAME

-------+-------

Smith | Screw

Smith | Nut

Jones | Cam

Adams | Screw

Adams | Bolt

Blake | Nut

Blake | Bolt

Blake | Cam

В операторе FROM мы вводим псевдоним имени для каждого отношения, так как в отношениях есть общие названия атрибутов (SNO и PNO). Теперь мы можем различить общие имена атрибутов, просто предварив имя атрибута псевдонимом с точкой. Соединение вычисляется тем же путём, как показано во внутреннем соединением. Во-первых, определяется декартово произведение SUPPLIER × PART × SELLS . Потом выбираются только те кортежи, которые удовлетворяют условиям, заданным в операторе WHERE (т.е. где общие именованные атрибуты равны). Наконец, убираются все колонки кроме S.SNAME и P.PNAME.

Итоговые операторы

SQL снабжён итоговыми операторами (например AVG, COUNT, SUM, MIN, MAX), которые принимают название атрибута в качестве аргумента. Значение итогового оператора высчитывается из всех значений заданного атрибута(столбца) всей таблицы. Если в запросе указана группа, то вычисления выполняются только над значениями группы (смотри следующий раздел).

Итоги

Если мы хотим узнать среднюю стоимость всех деталей в таблице PART, то используем следующий запрос:

SELECT AVG(PRICE) AS AVG_PRICE

FROM PART;

Результат:

AVG_PRICE

-----------

14.5

Если мы хотим узнать количество деталей, хранящихся в таблице PART, то используем выражение:

SELECT COUNT(PNO)

FROM PART;

и получим:

COUNT

-------

4

Итоги по группам

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

Разбиение кортежей на группы выполняется с помощью ключевых слов GROUP BY и следующим за ними списком атрибутов, которые определяют группы. Если мы имеем GROUP BY A1, ⃛, Ak мы разделяем отношение на группы так, что два кортежа будут в одной группе, если у них соответствуют все атрибуты A1, ⃛, Ak.

Итоги

Если мы хотим узнать сколько деталей продаёт каждый поставщик, то мы так сформулируем запрос:

SELECT S.SNO, S.SNAME, COUNT(SE.PNO)

FROM SUPPLIER S, SELLS SE

WHERE S.SNO = SE.SNO

GROUP BY S.SNO, S.SNAME;

и получим:

SNO | SNAME | COUNT

-----+-------+-------

1 | Smith | 2

2 | Jones | 1

3 | Adams | 2

4 | Blake | 3

Теперь давайте посмотрим что здесь происходит. Во-первых, соединяются таблицы SUPPLIER и SELLS:

S.SNO | S.SNAME | SE.PNO

-------+---------+--------

1 | Smith | 1

1 | Smith | 2

2 | Jones | 4

3 | Adams | 1

3 | Adams | 3

4 | Blake | 2

4 | Blake | 3

4 | Blake | 4

Затем, мы разбиваем кортежи на группы, помещая все кортежи вместе, у которых соответствуют оба атрибута S.SNO и S.SNAME:

S.SNO | S.SNAME | SE.PNO

-------+---------+--------

1 | Smith | 12

--------------------------

2 | Jones | 4

--------------------------

3 | Adams | 13

--------------------------

4 | Blake | 234

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

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

Having

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

Having

Если нас интересуют поставщики, продающие более одной детали, используем запрос:

SELECT S.SNO, S.SNAME, COUNT(SE.PNO)

FROM SUPPLIER S, SELLS SE

WHERE S.SNO = SE.SNO

GROUP BY S.SNO, S.SNAME

HAVING COUNT(SE.PNO) 1;

и получим:

SNO | SNAME | COUNT

-----+-------+-------

1 | Smith | 2

3 | Adams | 2

4 | Blake | 3

Подзапросы

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

Вложенная выборка

Если мы хотим узнать все детали, имеющие цену больше чем деталь 'Screw', то используем запрос:

SELECT *

FROM PART

WHERE PRICE (SELECT PRICE FROM PART

WHERE PNAME='Screw');

Результат:

PNO | PNAME | PRICE

-----+---------+--------

3 | Bolt | 15

4 | Cam | 25

Если мы посмотрим на запрос выше, то увидим ключевое слово SELECT два раза. Первый начинает запрос - мы будем называть его внешним запросом SELECT - и второй в операторе WHERE, который начинает вложенный запрос - мы будем называть его внутренним запросом SELECT. Для каждого кортежа внешнего SELECT внутренний SELECT необходимо вычислить. После каждого вычисления мы узнаём цену кортежа с названием 'Screw' и мы можем проверить выше ли цена из текущего кортежа.

Если мы хотим узнать поставщиков, которые ничего не продают (например, чтобы удалить этих поставщиков из базы данных) используем:

SELECT *

FROM SUPPLIER S

WHERE NOT EXISTS

(SELECT * FROM SELLS SE

WHERE SE.SNO = S.SNO);

В нашем примере результат будет пустым, потому что каждый поставщик продаёт хотя бы одну деталь. Заметим, что мы использовали S.SNO из внешнего SELECT внутри оператора WHERE в внутреннем SELECT. Как описывалось выше подзапрос вычисляется для каждого кортежа из внешнего запроса т.е. значение для S.SNO всегда берётся из текущего кортежа внешнего SELECT.

Объединение, пересечение, исключение

Эти операции вычисляют объединение, пересечение и теоретико-множественное вычитание кортежей из двух подзапросов.

Объединение, пересечение, исключение

Следующий запрос - пример для UNION(объединение):

SELECT S.SNO, S.SNAME, S.CITY

FROM SUPPLIER S

WHERE S.SNAME = 'Jones'

UNION

SELECT S.SNO, S.SNAME, S.CITY

FROM SUPPLIER S

WHERE S.SNAME = 'Adams';

даёт результат:

SNO | SNAME | CITY

-----+-------+--------

2 | Jones | Paris

3 | Adams | Vienna

Вот пример для INTERSECT(пересечение):

SELECT S.SNO, S.SNAME, S.CITY

FROM SUPPLIER S

WHERE S.SNO 1

INTERSECT

SELECT S.SNO, S.SNAME, S.CITY

FROM SUPPLIER S

WHERE S.SNO 2;

даёт результат:

SNO | SNAME | CITY

-----+-------+--------

2 | Jones | Paris

Возвращаются только те кортежи, которые есть в обоих частях запроса

и имеют $SNO=2$.

Наконец, пример для EXCEPT(исключение):

SELECT S.SNO, S.SNAME, S.CITY

FROM SUPPLIER S

WHERE S.SNO 1

EXCEPT

SELECT S.SNO, S.SNAME, S.CITY

FROM SUPPLIER S

WHERE S.SNO 3;

даёт результат:

SNO | SNAME | CITY

-----+-------+--------

2 | Jones | Paris

3 | Adams | Vienna

Задание на самостоятельную работу

1. INSERT - вставка строк в таблицу.

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

Пример 1.Выбрать все данные из таблицы поставщиков.

SELECT *

FROM P;

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

Пример 2.

Вставка в таблицу нескольких строк, выбранных из другой таблицы (в таблицу TMP_TABLE вставляются данные о поставщиках из таблицы P, имеющие номера, большие 2):

INSERT INTO

TMP_TABLE (PNUM, PNAME)

SELECT PNUM, PNAME

FROM P

WHERE P.PNUM2;

2. UPDATE - обновление строк в таблице

Пример 3. Обновление нескольких строк в таблице:

UPDATE P

SET PNAME = "Пушников"

WHERE P.PNUM = 1;

3. DELETE - удаление строк в таблице

Пример 4. Удаление нескольких строк в таблице:

DELETE FROM P

WHERE P.PNUM = 1;

Пример 5. Удаление всех строк в таблице:

DELETE FROM P;

4. Примеры использования оператора SELECT

Пример 6. Выбрать все данные из таблицы поставщиков

SELECT *

FROM P;

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

Пример 7. Выбрать все строки из таблицы поставщиков, удовлетворяющих некоторому условию (ключевое слово WHERE…):

SELECT *

FROM P

WHERE P.PNUM 2;

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

Пример 8. Выбрать некоторые колонки из исходной таблицы (указание списка отбираемых колонок):

SELECT P.NAME

FROM P;

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

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

Пример 9. Выбрать некоторые колонки из исходной таблицы, удалив из результата повторяющиеся строки (ключевое слово DISTINCT):

SELECT DISTINCT P.NAME

FROM P;

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

Пример 10. Использование скалярных выражений и переименований колонок в запросах (ключевое слово AS…):

SELECT

TOVAR.TNAME,

TOVAR.KOL,

TOVAR.PRICE,

"=" AS EQU,

TOVAR.KOL*TOVAR.PRICE AS SUMMA

FROM TOVAR;

В результате получим таблицу с колонками, которых не было в исходной таблице TOVAR

TNAME KOL PRICE EQU SUMMA

Болт 10 100 = 1000

Гайка 20 200 = 4000

Винт 30 300 = 9000

Пример 11.Упорядочение результатов запроса (ключевое слово ORDER BY…):

SELECT

PD.PNUM,

PD.DNUM,

PD.VOLUME

FROM PD

ORDER BY DNUM;

В результате получим следующую таблицу, упорядоченную по полю DNUM:

PNUM DNUM VOLUME

1 1 100

2 1 150

3 1 1000

1 2 200

2 2 250

1 3 300

Пример 12. Упорядочение результатов запроса по нескольким полям с возрастанием или убыванием (ключевые слова ASC, DESC):

SELECT

PD.PNUM,

PD.DNUM,

PD.VOLUME

FROM PD

ORDER BY

DNUM ASC,

VOLUME DESC;

В результате получим таблицу, в которой строки идут в порядке возрастания значения поля DNUM, а строки, с одинаковым значением DNUM идут в порядке убывания значения поля VOLUME:

PNUM DNUM VOLUME

3 1 1000

2 1 150

1 1 100

2 2 250

1 2 200

1 3 300

Если явно не указаны ключевые слова ASC или DESC, то по умолчанию принимается упорядочение по возрастанию (ASC).

Отбор данных из нескольких таблиц

Пример 13. Естественное соединение таблиц (способ 1 - явное указание условий соединения):

SELECT

P.PNUM,

P.PNAME,

PD.DNUM,

PD.VOLUME

FROM P, PD

WHERE P.PNUM = PD.PNUM;

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

PNUM PNAME DNUM VOLUME

1 Иванов 1 100

1 Иванов 2 200

1 Иванов 3 300

2 Петров 1 150

2 Петров 2 250

3 Сидоров 1 1000

Соединяемые таблицы перечислены в разделе FROM оператора, условие соединения приведено в разделе WHERE. Раздел WHERE, помимо условия соединения таблиц, может также содержать и условия отбора строк.

Пример 14. Естественное соединение таблиц (способ 2 - ключевые слова JOIN… USING…):

SELECT

P.PNUM,

P.PNAME,

PD.DNUM,

PD.VOLUME

FROM P JOIN PD USING PNUM;

Замечание. Ключевое слово USING позволяет явно указать, по каким из общих колонок таблиц будет производиться соединение.

Пример 15. Естественное соединение таблиц (способ 3 - ключевое слово NATURAL JOIN):

SELECT

P.PNUM,

P.PNAME,

PD.DNUM,

PD.VOLUME

FROM P NATURAL JOIN PD;

Замечание. В разделе FROM не указано, по каким полям производится соединение. NATURAL JOIN автоматически соединяет по всем одинаковым полям в таблицах.

Пример 16. Естественное соединение трех таблиц:

SELECT

P.PNAME,

D.DNAME,

PD.VOLUME

FROM

P NATURAL JOIN PD NATURAL JOIN D;

В результате получим следующую таблицу:

PNAME DNAME VOLUME

Иванов Болт 100

Иванов Гайка 200

Иванов Винт 300

Петров Болт 150

Петров Гайка 250

Сидоров Болт 1000

Пример 17. Прямое произведение таблиц:

SELECT

P.PNUM,

P.PNAME,

D.DNUM,

D.DNAME

FROM P, D;

В результате получим следующую таблицу:

PNUM P NAME DNUM DNAME

1 Иванов 1 Болт

1 Иванов 2 Гайка

1 Иванов 3 Винт

2 Петров 1 Болт

2 Петров 2 Гайка

2 Петров 3 Винт

3 Сидоров 1 Болт

3 Сидоров 2 Гайка

3 Сидоров 3 Винт

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

Пример 18. Соединение таблиц по произвольному условию. Рассмотрим таблицы поставщиков и деталей, которыми присвоен некоторый статус.

Таблица 1 Отношение P (Поставщики)

PNUM PNAME PSTATUS

1 Иванов 4

2 Петров 1

3 Сидоров 2

Таблица 2 Отношение D (Детали)

DNUM DNAME DSTATUS

1 Болт 3

2 Гайка 2

3 Винт 1

Ответ на вопрос "какие поставщики имеют право поставлять какие детали?" дает следующий запрос:

SELECT

P.PNUM,

P.PNAME,

P.PSTATUS,

D.DNUM,

D.DNAME,

D.DSTATUS

FROM P, D

WHERE P.PSTATUS = D.DSTATUS;

В результате получим следующую таблицу:

PNUM PNAME PSTATUS DNUM DNAME DSTATUS

1 Иванов 4 1 Болт 3

1 Иванов 4 2 Гайка 2

1 Иванов 4 3 Винт 1

2 Петров 1 3 Винт 1

3 Сидоров 2 2 Гайка 2

3 Сидоров 2 3 Винт 1

Использование агрегатных функций в запросах

Пример 20. Получить общее количество поставщиков (ключевое слово COUNT):

SELECT COUNT(*) AS N

FROM P;

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

N

3

Пример 21. Получить общее, максимальное, минимальное и среднее количества поставляемых деталей (ключевые слова SUM, MAX, MIN, AVG):

SELECT

SUM(PD.VOLUME) AS SM,

MAX(PD.VOLUME) AS MX,

MIN(PD.VOLUME) AS MN,

AVG(PD.VOLUME) AS AV

FROM PD;

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

SM MX MN AV

2000 1000 100 333.33333333

Использование агрегатных функций с группировками

Пример 22. Для каждой детали получить суммарное поставляемое количество (ключевое слово GROUP BY…):

SELECT

PD.DNUM,

SUM(PD.VOLUME) AS SM

GROUP BY PD.DNUM;

Этот запрос будет выполняться следующим образом. Сначала строки исходной таблицы будут сгруппированы так, чтобы в каждую группу попали строки с одинаковыми значениями DNUM. Потом внутри каждой группы будет просуммировано поле VOLUME. От каждой группы в результатирующую таблицу будет включена одна строка:

DNUM SM

1 1250

2 450

3 300

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

SELECT

PD.PNUM,

PD.DNUM,

SUM(PD.VOLUME) AS SM

GROUP BY PD.DNUM;

Причина ошибки в том, что в список отбираемых полей включено поле PNUM, которое не входит в раздел GROUP BY. И действительно, в каждую полученную группу строк может входить несколько строк с различными значениями поля PNUM. Из каждой группы строк будет сформировано по одной итоговой строке. При этом нет однозначного ответа на вопрос, какое значение выбрать для поля PNUM в итоговой строке.

Некоторые диалекты SQL не считают это за ошибку. Запрос будет выполнен, но предсказать, какие значения будут внесены в поле PNUM в результатирующей таблице, невозможно.

Пример 23. Получить номера деталей, суммарное поставляемое количество которых превосходит 400 (ключевое слово HAVING…):

Условие, что суммарное поставляемое количество должно быть больше 400 не может быть сформулировано в разделе WHERE, т.к. в этом разделе нельзя использовать агрегатные функции. Условия, использующие агрегатные функции должны быть размещены в специальном разделе HAVING:

SELECT

PD.DNUM,

SUM(PD.VOLUME) AS SM

GROUP BY PD.DNUM

HAVING SUM(PD.VOLUME) 400;

В результате получим следующую таблицу:

DNUM SM

1 1250

2 450

В одном запросе могут встретиться как условия отбора строк в разделе WHERE, так и условия отбора групп в разделе HAVING. Условия отбора групп нельзя перенести из раздела HAVING в раздел WHERE. Аналогично и условия отбора строк нельзя перенести из раздела WHERE в раздел HAVING, за исключением условий, включающих поля из списка группировки GROUP BY.

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

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

Пример 24. Получить список поставщиков, статус которых меньше максимального статуса в таблице поставщиков (сравнение с подзапросом):

SELECT *

FROM P

WHERE P.STATYS

(SELECT MAX(P.STATUS)

FROM P);

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

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

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

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

Пример 25. Использование предиката IN. Получить список поставщиков, поставляющих деталь номер 2:

SELECT *

FROM P

WHERE P.PNUM IN

(SELECT DISTINCT PD.PNUM

FROM PD

WHERE PD.DNUM = 2);

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

Замечание. Результат выполнения запроса будет эквивалентен результату следующей последовательности действий:

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

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

Пример 26. Использование предиката EXIST. Получить список поставщиков, поставляющих деталь номер 2:

SELECT *

FROM P

WHERE EXIST

(SELECT *

FROM PD

WHERE

PD.PNUM = P.PNUM AND

PD.DNUM = 2);

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

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

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

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

Может показаться, что запросы, содержащие коррелируемые подзапросы будут выполняться медленнее, чем запросы с некоррелируемыми подзапросами. На самом деле это не так, т.к. то, как пользователь, сформулировал запрос, не определяет, как этот запрос будет выполняться. Язык SQL является непроцедурным, а декларативным. Это значит, что пользователь, формулирующий запрос, просто описывает, каким должен быть результат запроса, а как этот результат будет получен - за это отвечает сама СУБД.

Пример 27. Использование предиката NOT EXIST. Получить список поставщиков, не поставляющих деталь номер 2:

SELECT *

FROM P

WHERE NOT EXIST

(SELECT *

FROM PD

WHERE

PD.PNUM = P.PNUM AND

PD.DNUM = 2);

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

Пример 28. Получить имена поставщиков, поставляющих все детали:

SELECT DISTINCT PNAME

FROM P

WHERE NOT EXIST

(SELECT *

FROM D

WHERE NOT EXIST

(SELECT *

FROM PD

WHERE

PD.DNUM = D.DNUM AND

PD.PNUM = P.PNUM));

Данный запрос содержит два вложенных подзапроса и реализует реляционную операцию деления отношений.

Самый внутренний подзапрос параметризован двумя параметрами (D.DNUM, P.PNUM) и имеет следующий смысл: отобрать все строки, содержащие данные о поставках поставщика с номером PNUM детали с номером DNUM. Отрицание NOT EXIST говорит о том, что данный поставщик не поставляет данную деталь. Внешний к нему подзапрос, сам являющийся вложенным и параметризованным параметром P.PNUM, имеет смысл: отобрать список деталей, которые не поставляются поставщиком PNUM. Отрицание NOT EXIST говорит о том, что для поставщика с номером PNUM не должно быть деталей, которые не поставлялись бы этим поставщиком. Это в точности означает, что во внешнем запросе отбираются только поставщики, поставляющие все детали.

Использование объединения, пересечения и разности

Пример 29. Получить имена поставщиков, имеющих статус, больший 3 или поставляющих хотя бы одну деталь номер 2 (объединение двух подзапросов - ключевое слово UNION):

SELECT P.PNAME

FROM P

WHERE P.STATUS 3

UNION

SELECT P.PNAME

FROM P, PD

WHERE P.PNUM = PD.PNUM AND

PD.DNUM = 2;

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

Пример 30. Получить имена поставщиков, имеющих статус, больший 3 и одновременно поставляющих хотя бы одну деталь номер 2 (пересечение двух подзапросов - ключевое слово INTERSECT):

SELECT P.PNAME

FROM P

WHERE P.STATUS 3

INTERSECT

SELECT P.PNAME

FROM P, PD

WHERE P.PNUM = PD.PNUM AND

PD.DNUM = 2;

Пример 31. Получить имена поставщиков, имеющих статус, больший 3, за исключением тех, кто поставляет хотя бы одну деталь номер 2 (разность двух подзапросов - ключевое слово EXCEPT):

SELECT P.PNAME

FROM P

WHERE P.STATUS 3

EXCEPT

SELECT P.PNAME

FROM P, PD

WHERE P.PNUM = PD.PNUM AND

PD.DNUM = 2;

Порядок выполнения оператора SELECT

Для того чтобы понять, как получается результат выполнения оператора SELECT, рассмотрим концептуальную схему его выполнения. Эта схема является именно концептуальной, т.к. гарантируется, что результат будет таким, как если бы он выполнялся шаг за шагом в соответствии с этой схемой. На самом деле, реально результат получается более изощренными алгоритмами, которыми "владеет" конкретная СУБД.

Стадия 1. Выполнение одиночного оператора SELECT

Если в операторе присутствуют ключевые слова UNION, EXCEPT и INTERSECT, то запрос разбивается на несколько независимых запросов, каждый из которых выполняется отдельно:

Шаг 1 (FROM). Вычисляется прямое декартовое произведение всех таблиц, указанных в обязательном разделе FROM. В результате шага 1 получаем таблицу A.

Шаг 2 (WHERE). Если в операторе SELECT присутствует раздел WHERE, то сканируется таблица A, полученная при выполнении шага 1. При этом для каждой строки из таблицы A вычисляется условное выражение, приведенное в разделе WHERE. Только те строки, для которых условное выражение возвращает значение TRUE, включаются в результат. Если раздел WHERE опущен, то сразу переходим к шагу 3. Если в условном выражении участвуют вложенные подзапросы, то они вычисляются в соответствии с данной концептуальной схемой. В результате шага 2 получаем таблицу B.

Шаг 3 (GROUP BY). Если в операторе SELECT присутствует раздел GROUP BY, то строки таблицы B, полученной на втором шаге, группируются в соответствии со списком группировки, приведенным в разделе GROUP BY. Если раздел GROUP BY опущен, то сразу переходим к шагу 4. В результате шага 3 получаем таблицу С.

Шаг 4 (HAVING). Если в операторе SELECT присутствует раздел HAVING, то группы, не удовлетворяющие условному выражению, приведенному в разделе HAVING, исключаются. Если раздел HAVING опущен, то сразу переходим к шагу 5. В результате шага 4 получаем таблицу D.

Шаг 5 (SELECT). Каждая группа, полученная на шаге 4, генерирует одну строку результата следующим образом. Вычисляются все скалярные выражения, указанные в разделе SELECT. По правилам использования раздела GROUP BY, такие скалярные выражения должны быть одинаковыми для всех строк внутри каждой группы. Для каждой группы вычисляются значения агрегатных функций, приведенных в разделе SELECT. Если раздел GROUP BY отсутствовал, но в разделе SELECT есть агрегатные функции, то считается, что имеется всего одна группа. Если нет ни раздела GROUP BY, ни агрегатных функций, то считается, что имеется столько групп, сколько строк отобрано к данному моменту. В результате шага 5 получаем таблицу E, содержащую столько колонок, сколько элементов приведено в разделе SELECT и столько строк, сколько отобрано групп.

Стадия 2. Выполнение операций UNION, EXCEPT, INTERSECT

Если в операторе SELECT присутствовали ключевые слова UNION, EXCEPT и INTERSECT, то таблицы, полученные в результате выполнения 1-й стадии, объединяются, вычитаются или пересекаются.

Стадия 3. Упорядочение результата

Если в операторе SELECT присутствует раздел ORDER BY, то строки полученной на предыдущих шагах таблицы упорядочиваются в соответствии со списком упорядочения, приведенном в разделе ORDER BY.

Как на самом деле выполняется оператор SELECT

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

На самом деле в РСУБД имеется оптимизатор, функцией которого является нахождение такого оптимального алгоритма выполнения запроса, который гарантирует получение правильного результата.

Схематично работу оптимизатора можно представить в виде последовательности нескольких шагов:

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

Шаг 2 (Преобразование в каноническую форму). Запрос во внутреннем представлении подвергается преобразованию в некоторую каноническую форму. При преобразовании к канонической форме используются как синтаксические, так и семантические преобразования. Синтаксические преобразования (например, приведения логических выражений к конъюнктивной или дизъюнктивной нормальной форме, замена выражений "x AND NOT x" на "FALSE", и т.п.) позволяют получить новое внутренне представление запроса, синтаксически эквивалентное исходному, но стандартное в некотором смысле. Семантические преобразования используют дополнительные знания, которыми владеет система, например, ограничения целостности. В результате семантических преобразований получается запрос, синтаксически не эквивалентный исходному, но дающий тот же самый результат.

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

Шаг 4. (Выполнение плана запроса). На этом шаге план, выбранный на предыдущем шаге, передается на реальное выполнение.

Во многом качество конкретной СУБД определяется качеством ее оптимизатора. Хороший оптимизатор может повысить скорость выполнения запроса на несколько порядков. Качество оптимизатора определяется тем, какие методы преобразований он может использовать, какой статистической и иной информацией о таблицах он располагает, какие методы для оценки стоимости выполнения плана он знает.