Справка по SQL

Оператор SELECT

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

SELECT * FROM PC;

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

SELECT price, speed, hd, ram, cd, model, code

FROM Pc;

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

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

SELECT speed, ram FROM PC;

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

Устранение дубликатов. Предложение DISTINCT.

Следует отметить, что вертикальная выборка может содержать дубликаты строк в том случае, если она не содержит потенциального ключа, однозначно определяющего запись. В таблице PC потенциальным ключом является поле code, которое выбрано в качестве первичного ключа таблицы. Поскольку это поле отсутствует в запросе, в приведенном выше результирующем наборе имеются дубликаты строк (например, строки 1 и 3). Если требуется получить уникальные строки (скажем, нас интересуют только различные комбинации скорости процессора и объема памяти, а не характеристики всех имеющихся компьютеров), то можно использовать ключевое слово DISTINCT:

SELECT DISTINCT speed, ram FROM Pc;

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

Помимо DISTINCT может применяться также ключевое слово ALL (все строки), которое принимается по умолчанию.

Сортировка результирующего набора. Предложение ORDER BY.

Чтобы упорядочить строки результирующего набора, можно выполнить сортировку по любому количеству полей, указанных в предложении SELECT. Для этого используется предложение ORDER BY , являющееся всегда последним предложением в операторе SELECT. При этом в списке полей могут указываться как имена полей, так и их порядковые позиции в списке предложения SELECT. Так если требуется упорядочить результирующий набор по объему оперативной памяти в порядке убывания, можно записать

SELECT DISTINCT speed, ram

FROM Pc

ORDER BY ram DESC

или

SELECT DISTINCT speed, ram

FROM Pc

ORDER BY 2 DESC

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

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

SELECT DISTINCT speed, ram

FROM Pc

ORDER BY ram DESC, speed DESC

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

Выборка. Предложение WHERE.

Горизонтальную выборку реализует предложение WHERE , которое записывается после предложения FROM. При этом в результирующий набор попадут только те строки из источника записей, для каждой из которых значение предиката равно TRUE. То есть предикат проверяется для каждой записи. Например, запрос "получить информацию о частоте процессора и объеме оперативной памяти для компьютеров с ценой ниже $500" можно сформулировать следующим образом:

SELECT DISTINCT speed, ram

FROM Pc

WHERE price<500

ORDER BY 2 DESC

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

Примеры простых предикатов сравнения:

Булевы операторы AND, OR, NOT и трехзначная логика. Предикаты

Предикаты представляют собой выражения, принимающие истинностное значение. Они могут представлять собой как одно выражение, так и любую комбинацию из неограниченного количества выражений, построенную с помощью булевых операторов AND, OR или NOT. Кроме того, в этих комбинациях может использоваться SQL-оператор IS, а также круглые скобки для конкретизации порядка выполнения операций.

Предикат в языке SQL может принимать одно из трех значений TRUE (истина), FALSE (ложь) или UNKNOWN (неизвестно). Исключение составляют следующие предикаты: NULL (отсутствие значения), EXISTS (существование), UNIQUE (уникальность) и MATCH (совпадение), которые не могут принимать значение UNKNOWN.

Правила комбинирования всех трех истинностных значений легче запомнить, обозначив TRUE как 1, FALSE как 0 и UNKNOWN как 1/2 (где то между истинным и ложным).

* AND с двумя истинностными значениями дает минимум этих значений. Например, TRUE AND UNKNOWN будет равно UNKNOWN.

* OR с двумя истинностными значениями дает максимум этих значений. Например, FALSE OR UNKNOWN будет равно UNKNOWN.

* Отрицание истинностного значения равно 1 минус данное истинностное значение. Например, NOT UNKNOWN будет равно UNKNOWN.

SELECT * FROM Pc

WHERE speed = 500 AND price < 800;

SELECT * FROM Printer

WHERE NOT (type = 'matrix') AND price < 300;

SELECT model, speed FROM Pc

WHERE price BETWEEN 400 AND 600;

SELECT model, speed, hd FROM Pc

WHERE hd IN (10, 20);

SELECT model, speed, hd

FROM Pc

WHERE hd IN (10, 20) AND

 model IN (SELECT model FROM product

 WHERE maker = 'A');

SELECT ram AS Mb, hd Gb

FROM Pc

WHERE cd = '24x';

SELECT ram * 1024 AS Kb, hd Gb

FROM Pc

WHERE cd = '24x';

SELECT ram, 'Mb' AS ram_units, hd, 'Gb' AS hd_units

FROM Pc

WHERE cd = '24x';

SELECT *

FROM Ships

WHERE class LIKE '%o';

SELECT *

FROM Ships

WHERE class NOT LIKE '%go' AND class LIKE '%o';

SELECT *

FROM Pc

WHERE price IS NULL;

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

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

Все эти функции возвращают единственное значение. При этом функции COUNT, MIN и MAX применимы к любым типам данных, в то время как SUM и AVG используются только для числовых полей. Разница между функцией COUNT(*) и COUNT() состоит в том, что вторая при подсчете не учитывает NULL-значения.

Пример. Найти минимальную и максимальную цену на персональные компьютеры:

SELECT MIN(price) AS Min_price, MAX(price) AS Max_price

FROM PC;

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

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

SELECT COUNT(*) AS Qty

FROM PC

WHERE model IN

 (SELECT model

 FROM Product

 WHERE maker = 'A');

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

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

SELECT COUNT(model) AS Qty_model

FROM Product

WHERE maker = 'A';

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

Пример. Найти количество имеющихся различных моделей, выпускаемых производителем А. Запрос похож на предыдущий, в котором требовалось определить общее число моделей, выпускаемых производителем А. Здесь же требуется найти число различных моделей в таблице PC (т.е. имеющихся в продаже).

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

SELECT COUNT(DISTINCT model) AS Qty

FROM PC

WHERE model IN

 (SELECT model

 FROM Product

 WHERE maker = 'A');

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

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

SELECT model, COUNT(model) AS Qty_model, AVG(price) AS Avg_price

FROM PC

GROUP BY model;

SELECT model, COUNT(model) AS Qty_model, AVG(price) AS Avg_price

FROM PC

GROUP BY model

HAVING AVG(price) < 800;

Использование в запросе нескольких таблиц. Предложение FROM

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

Результат запроса

SELECT * FROM A, B;

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

Поэтому перечисление таблиц, как правило, используется совместно с условием соединения записей из разных таблиц, указываемым в предложении WHERE. Для приведенных выше таблиц таким условием может быть совпадение значений, скажем, в полях a и c:

SELECT * FROM A, B WHERE a=c;

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

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

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

.

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

Пример. Найти номер модели и производителя ПК, имеющих цену менее $600:

SELECT DISTINCT PC.model, maker

FROM PC, Product

WHERE PC.model = Product.model AND price < 600;

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

Иногда в предложении FROM требуется указать одну и ту же таблицу несколько раз. В этом случае обязательным является переименование.

Пример. Вывести пары моделей, имеющих одинаковые цены:

SELECT DISTINCT A.model AS model_1, B.model AS model_2

FROM PC AS A, PC B

WHERE A.price = B.price AND A.model < B.model;

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

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

SELECT DISTINCT PC.model, maker

FROM PC,

 (SELECT maker, model

 FROM Product) AS prod

WHERE PC.model = prod.model AND price < 600;

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

Операции соединения. Предложения JOIN

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

FROM [INNER]

| {{LEFT | RIGHT | FULL } [OUTER]} JOIN

[ON ]

Соединение может быть либо внутренним (INNER), либо одним из внешних (OUTER). Служебные слова INNER и OUTER можно опускать, поскольку внешнее соединение однозначно определяется его типом - LEFT (левое), RIGHT (правое) или FULL (полное), а просто JOIN будет означать внутреннее соединение.

Предикат определяет условие соединения строк из разных таблиц. При этом INNER JOIN означает, что в результирующий набор попадут только те соединения строк двух таблиц, для которых значение предиката равно TRUE. Как правило, предикат определяет эквисоединение по внешнему и первичному ключам соединяемых таблиц, хотя это не обязательно.

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

SELECT maker, Product.model AS model_1, PC.model AS model_2, price

FROM Product INNER JOIN PC ON PC.model = Product.model

ORDER BY maker, PC.model;

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

Для контроля в результат включен как номер модели из таблицы PC, так и из таблицы Product:

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

Пример. Привести все модели ПК, их производителей и цену:

SELECT maker, Product.model AS model_1, PC.model AS model_2, price

FROM Product LEFT JOIN PC ON PC.model = Product.model

WHERE type = 'PC'

ORDER BY maker, PC.model;

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

Поскольку моделей 2111 и 2112 из таблицы Product нет в таблице PC, в полях из таблицы PC содержится NULL.

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

Product LEFT JOIN PC ON PC.model = Product.model

будет эквивалентно правому соединению

PC RIGHT JOIN Product ON PC.model = Product.model

Запрос же

SELECT maker, Product.model AS model_1, PC.model AS model_2, price

FROM Product RIGHT JOIN PC ON PC.model = Product.model

ORDER BY maker, PC.model;

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

Так запрос для таблиц A и B, приведенных в начале главы,

SELECT A.*, B.*

FROM A FULL JOIN B

ON A.a = B.c;

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

Заметим, что это соединение симметрично, т.е. "A FULL JOIN B" эквивалентно "B FULL JOIN A". Обратите также внимание на обозначение A.*, что означает "все поля таблицы А".

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

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

SELECT Laptop.model, Product.model

FROM Laptop CROSS JOIN Product;

SELECT model, price

FROM PC

UNION

SELECT model, price

FROM Laptop

ORDER BY price DESC;

SELECT Product .type, PC.model, price

FROM PC INNER JOIN

 Product ON PC.model = Product .model

UNION

SELECT Product .type, Laptop.model, price

FROM Laptop INNER JOIN

 Product ON Laptop.model = Product .model

ORDER BY price DESC;

Проверка наличия записей. Предикат EXISTS

EXISTS::=

[NOT] EXISTS ()

Предикат EXISTS принимает значение TRUE, если подзапрос возвращает любое количество строк, иначе его значение равно FALSE. Для NOT EXISTS все наоборот. Этот предикат никогда не принимает значение UNKNOWN.

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

Пример на пересечение. Найти тех производителей ПК-блокнотов, которые производят также и принтеры:

SELECT DISTINCT maker

FROM Product AS Lap_product

WHERE type = 'Laptop' AND EXISTS

 (SELECT maker

 FROM Product

 WHERE type = 'Printer' AND maker = Lap_product.maker);

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

Пример на разность. Найти тех производителей ПК-блокнотов, которые не производят принтеров:

SELECT DISTINCT maker

FROM Product AS Lap_product

WHERE type = 'Laptop' AND NOT EXISTS

 (SELECT maker

 FROM Product

 WHERE type = 'Printer' AND maker = Lap_product.maker);

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

SELECT DISTINCT maker

FROM Product

WHERE type = 'PC' AND NOT model = ANY

 (SELECT model

 FROM PC);

SELECT DISTINCT model, price

FROM Laptop

WHERE price ALL

 (SELECT price

 FROM PC);

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

Заметим, что в общем случае запрос возвращает множество значений. Поэтому использование подзапроса в предложении WHERE без операторов EXISTS, IN, ALL и ANY, которые дают булево значение, может привести к ошибке времени выполнения запроса.

Пример. Найти модели и цены ПК, стоимость которых превышает минимальную стоимость ПК-блокнотов:

SELECT DISTINCT model, price

FROM PC

WHERE price

 (SELECT MIN(price)

 FROM Laptop);

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

model	price
1121	850.0
1233	950.0
1233	980.0

Однако, если в ответ на вопрос "найти модели и цены ПК, стоимость которых совпадает со стоимостью ПК-блокнота" написать следующий запрос:

SELECT DISTINCT model, price

FROM PC

WHERE price =

 (SELECT price

 FROM Laptop);

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

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

Подзапросы, в свою очередь, также могут содержать вложенные запросы.

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

Пример. Вывести производителя, тип, модель и частоту процессора для ПК-блокнотов, частота процессора которых превышает 600 МГц.

Этот запрос может быть сформулирован, например, следующим образом:

SELECT prod.maker, lap.*

FROM (SELECT 'Laptop' AS type, model, speed

 FROM Laptop

 WHERE speed 600) AS lap INNER JOIN

 (SELECT maker, model

 FROM Product) AS prod ON lap.model = prod.model;

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

maker	type	model	speed
B	Laptop	1750	750
A	Laptop	1752	750

Наконец, подзапросы могут присутствовать в предложении SELECT. Это иногда позволяет весьма компактно сформулировать запрос.

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

Здесь вообще можно обойтись одним предложением SELECT:

 SELECT (SELECT AVG(price)

 FROM Laptop) -

 (SELECT AVG(price)

 FROM PC) AS dif_price;

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

dif_price
365.81818181818187

Преобразование типов

В реализациях языка SQL может быть выполнено неявное преобразование типов. Так, например, в T-SQL при сравнении или комбинировании значений типов smallint и int, данные типа smallint неявно преобразуются к типу int. Подробно о явном и неявном преобразовании типов в MS SQL Server можно прочитать в BOL.

Пример. Вывести среднюю цену ПК-блокнотов с предваряющим текстом "средняя цена = ".

Попытка выполнить запрос

SELECT 'Средняя цена = ' + AVG(price) FROM laptop;

приведет к сообщению об ошибке

Implicit conversion from data type varchar to money is not allowed. Use the CONVERT function to run this query.

Это сообщение означает, что система не может выполнить неявное преобразование типа varchar к типу money. В подобных ситуациях может помочь явное преобразование типов. При этом, как указано в сообщении об ошибке, можно воспользоваться функцией CONVERT. Однако эта функция не стандартизована, поэтому в целях переносимости рекомендуется использовать стандартное выражение CAST. С него и начнем.

Если переписать наш запрос в виде

SELECT 'Средняя цена = ' + CAST(AVG(price) AS CHAR(15)) FROM laptop;

в результате получим то, что требовалось:

Мы использовали выражение явного преобразования типов CAST для приведения среднего значения цены к строковому представлению. Синтаксис выражения CAST очень простой:

CAST( AS )

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

Рассмотрим еще один пример: определить средний год спуска на воду кораблей из таблицы Ships. Запрос

SELECT AVG(launched) FROM ships;

даст результат 1926. В принципе все правильно, т.к. мы получили в результате то, что просили - ГОД. Однако среднее арифметическое будет составлять примерно 1926,2381. Тут следует отметить, что агрегатные функции (за исключением функции COUNT, которая всегда возвращает целое число) наследуют тип данных обрабатываемых значений. Поскольку поле launched - целочисленное, мы и получили среднее значение с отброшенной дробной частью (заметьте - не округленное).

А если нас интересует результат с заданной точностью, скажем, до двух десятичных знаков? Применение выражения CAST к среднему значению ничего не даст по указанной выше причине. Действительно,

SELECT CAST(AVG(launched) AS NUMERIC(6,2)) FROM ships;

вернет значение 1926.00. Следовательно, CAST нужно применить к аргументу агрегатной функции:

SELECT AVG(CAST(launched AS NUMERIC(6,2))) FROM ships;

Результат - 1926.238095. Опять не то. Причина состоит в том, что при вычислении среднего значения было выполнено неявное преобразование типа. Сделаем еще один шаг:

SELECT CAST(AVG(CAST(launched AS NUMERIC(6,2))) AS NUMERIC(6,2)) FROM ships;

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

SELECT CAST(AVG(launched*1.0) AS NUMERIC(6,2)) FROM ships;

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

Аналогичные преобразования типа можно выполнить с помощью функции CONVERT:

SELECT CONVERT(NUMERIC(6,2),AVG(launched*1.0)) FROM ships;

Функция CONVERT имеет следующий синтаксис:

CONVERT ([()], [, ])

Основное отличие функции CONVERT от функции CAST состоит в том, что первая позволяет форматировать данные (например, темпоральные данные типа datetime) при преобразовании их к символьному типу и указывать формат при обратном преобразовании. Разные целочисленные значения необязательного аргумента стиль соответствуют определенным форматам. Рассмотрим следующий пример

SELECT CONVERT(char(25),CONVERT(datetime,'20030722'));

Здесь мы преобразуем строковое представление даты к типу datetime, после чего выполняем обратное преобразование, чтобы продемонстрировать результат форматирования. Поскольку значение аргумента стиль не задано, используется значение по умолчанию (0 или 100). В результате получим

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

Перечень всех возможных значений аргумента стиль можно посмотреть в BOL.

Оператор CASE

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

Список всех моделей ПК с ценами можно получить с помощью запроса:

SELECT DISTINCT product.model, price FROM product LEFT JOIN pc c

 ON product.model=c.model

 WHERE product.type='pc';

В результирующем наборе отсутствующая цена будет заменена NULL-значением:

Чтобы заменить NULL-значения нужным текстом, можно воспользоваться оператором CASE:

SELECT DISTINCT product.model,

 CASE WHEN price IS NULL THEN 'Нет в наличии' ELSE CAST(price AS CHAR(20)) END price

 FROM product LEFT JOIN pc c ON product.model=c.model

 WHERE product.type='pc'

Оператор CASE в зависимости от указанных условий возвращает одно из множества возможных значений. В нашем примере условием является проверка на NULL. Если это условие выполняется, то возвращается текст "Нет в наличии", в противном случае (ELSE) возвращается значение цены. Здесь есть один принципиальный момент. Поскольку результатом оператора SELECT всегда является таблица, то все значения любого столбца должны иметь один и тот же тип данных (с учетом неявного приведения типов). Поэтому мы не можем наряду с ценой (числовой тип) выводить символьную константу. Вот почему к полю price применяется преобразование типов, чтобы привести его значения к символьному представлению. В результате получим

Оператор CASE может быть использован в одной из двух синтаксических форм записи:

1-я форма

CASE

WHEN

THEN

…

WHEN

THEN

[ELSE ]

END

2-я форма

CASE

WHEN

THEN

…

WHEN

THEN

[ELSE ]

END

Все предложения WHEN должны иметь одинаковую синтаксическую форму, т.е. нельзя смешивать первую и вторую формы. При использовании первой синтаксической формы условие WHEN удовлетворяется, как только значение проверяемого выражения станет равным значению выражения, указанного в предложении WHEN. При использовании второй синтаксической формы условие WHEN удовлетворяется, как только предикат принимает значение TRUE. При удовлетворении условия оператор CASE возвращает значение, указанное в соответствующем предложении THEN. Если ни одно из условий WHEN не выполнилось, то будет использовано значение, указанное в предложении ELSE. При отсутствии ELSE, будет возвращено NULL-значение. Если удовлетворены несколько условий, то будет возвращено значение предложения THEN первого из них.

В приведенном выше примере была использована вторая форма оператора CASE.

Заметим, что для проверки на NULL стандарт предлагает более короткую форму оператора - COALESCE. Этот оператор имеет произвольное число параметров и возвращает значение первого, отличного от NULL. Для двух параметров оператор COALESCE(A, B) эквивалентен следующему оператору CASE:

CASE WHEN A IS NOT NULL THEN A ELSE B END

Решение рассмотренного выше примера при использовании оператора COALESCE можно переписать следующим образом:

SELECT DISTINCT product.model,

 COALESCE(CAST(price as CHAR(20)),'Нет в наличии') price

 FROM product LEFT JOIN pc c ON product.model=c.model

 WHERE product.type='pc';

Использование первой синтаксической формы оператора CASE можно продемонстрировать на следующем примере: Вывести все имеющиеся модели ПК с указанием цены. Отметить самые дорогие и самые дешевые модели.

SELECT DISTINCT model, price,

 CASE price WHEN (SELECT MAX(price) FROM pc) THEN 'Самый дорогой'

 WHEN (SELECT MIN(price) FROM pc) THEN 'Самый дешевый'

 ELSE 'Средняя цена' END comment

 FROM pc ORDER BY price;

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

Функции Transact-SQL для обработки даты/времени

Стандарт SQL-92 специфицирует только функции, возвращающие системную дату/время. Например, функция CURRENT_TIMESTAMP возвращает сразу и дату, и время. Плюс имеются функции возвращающие что-либо одно.

Естественно, в силу такой ограниченности, реализации языка расширяют стандарт за счет добавления функций, облегчающий работу пользователей с данными этого типа. Здесь мы рассмотрим функции обработки даты/времени в T-SQL.

SELECT DATEADD(day, 7, current_timestamp)

SELECT DATEADD(ww, 1, current_timestamp)

SELECT DATEADD(mm, 1/4, current_timestamp)

SELECT DATEADD(day, 7, (SELECT MAX(date) max_date FROM pass_in_trip))

SELECT DATEDIFF(dd, (SELECT MIN(date) FROM pass_in_trip), (SELECT MAX(date) FROM pass_in_trip))

SELECT DATEDIFF(mi, time_out, time_in) dur FROM trip WHERE trip_no=1123,

SELECT DATEPART(hh, time_out)*60 + DATEPART(mi, time_out) FROM trip WHERE trip_no=1123

SELECT DATEPART(hh, time_in)*60 + DATEPART(mi, time_in) FROM trip WHERE trip_no=1123

SELECT CASE WHEN time_dep=time_arr THEN time_arr-time_dep+1440 ELSE time_arr-time_dep END dur FROM

( SELECT DATEPART(hh, time_out)*60 + DATEPART(mi, time_out) time_dep, DATEPART(hh, time_in)*60 + DATEPART(mi, time_in) time_arr FROM trip WHERE trip_no=1123) tm

SELECT pt.trip_no, DATEADD(mi, DATEPART(hh,time_out)*60 + DATEPART(mi,time_out), date) [time]

FROM pass_in_trip pt JOIN trip t ON pt.trip_no=t.trip_no WHERE t.trip_no=1123

SELECT DATENAME ( weekday , '2003-12-31' )+', '+DATENAME ( day , '2003-12-31' )+' '+ DATENAME ( month , '2003-12-31' )+' '+DATENAME ( year , '2003-12-31' )

SELECT DATENAME ( day , '2003-12-31' )

SELECT DATENAME ( dayofyear , '2003-12-31' )

Функции работы со строками в MS SQL SERVER 2000

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

Начнем с двух взаимно обратных функций - ASCII и CHAR.

Функция ASCII возвращает ASCII-код крайнего левого символа строкового выражения, являющегося аргументом функции.

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

SELECT COUNT(DISTINCT ASCII(name)) FROM Ships

Результат - 11. Чтобы выяснить, какие это буквы, мы можем применить функцию CHAR, которая возвращает символ по известному ASCII-коду (от 0 до 255):

SELECT DISTINCT CHAR(ASCII(name)) FROM Ships ORDER BY 1

Следует отметить, что аналогичный результат можно получить проще с помощью еще одной функции - LEFT, которая имеет следующий синтаксис:

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

SELECT DISTINCT LEFT(name, 1) FROM Ships ORDER BY 1

А вот как, например, можно получить таблицу кодов всех алфавитных символов:

SELECT CHAR(ASCII('a')+ num-1) letter, ASCII('a')+ num - 1 [code]

FROM (SELECT 5*5*(a-1)+5*(b-1) + c AS num

 FROM (SELECT 1 a UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5) x

  CROSS JOIN

  (SELECT 1 b UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5) y

  CROSS JOIN

  (SELECT 1 c UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5) z

 ) x

WHERE ASCII('a')+ num -1 BETWEEN ASCII('a') AND ASCII('z')

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

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

UNION

SELECT CHAR(ASCII('A')+ num-1) letter, ASCII('A')+ num - 1 [code]

FROM (SELECT 5*5*(a-1)+5*(b-1) + c AS num

 FROM (SELECT 1 a UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5) x

  CROSS JOIN

  (SELECT 1 b UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5) y

  CROSS JOIN

  (SELECT 1 c UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5) z

 ) x

WHERE ASCII('A')+ num -1 BETWEEN ASCII('A') AND ASCII('Z')

Чтобы таблица выглядела более патриотично, достаточно заменить латинские буквы "a" и "A" на неотличимые на взгляд русские - "а" и "А", а "z" и "Z" на "я" и "Я". Вот только буквы "ё" вы не увидите в этой таблице, т.к. в кодовой таблице ASCII эти символы лежат отдельно, что легко проверить:

SELECT ASCII('ё') UNION ALL SELECT ASCII('Ё')

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

Рассмотрим теперь задачу определения нахождения искомой подстроки в строковом выражении. Для этого могут использоваться две функции - CHARINDEX и PATINDEX. Обе они возвращают начальную позицию (позицию первого символа подстроки) подстроки в строке. Функция CHARINDEX имеет синтаксис:

CHARINDEX (искомое_выражение, строковое_выражение[, стартовая_позиция])

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

SELECT name FROM Ships WHERE CHARINDEX('sh', name) 0

будет выводить те корабли, в которых имеется сочетание символов "sh". Здесь используется тот факт, что если искомая строка не будет обнаружена, то функция CHARINDEX возвращает 0. Результат выполнения запроса будет содержать следующие корабли:

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

Следующий пример определяет позиции первого и второго вхождения символа "a" в имени корабля "California"

SELECT CHARINDEX('a',name) first_a,

 CHARINDEX('a', name, CHARINDEX('a', name)+1) second_a

FROM Ships WHERE name='California'

Обратите внимание, что при определении второго символа в функции используется стартовая позиция, которой является позиция следующего за первой буквой "a" символа - CHARINDEX('a', name)+1. Правильность результата - 2 и 10 - легко проверить :-).

Функция PATINDEX имеет синтаксис:

Главное отличие этой функции от CHARINDEX заключается в том, что поисковая строка может содержать подстановочные знаки - % и _. При этом концевые знаки "%" являются обязательными. Например, использование этой функции в первом примере будет иметь вид

SELECT name FROM Ships WHERE PATINDEX('%sh%', name) 0

А вот, например, как можно найти имена кораблей, которые содержат последовательность из трех символов, первый и последний из которых есть "e":

SELECT name FROM Ships WHERE PATINDEX('%e_e%', name) 0

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

Парная к LEFT функция RIGHT возвращает заданное число символов справа из строкового выражения:

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

SELECT name FROM Ships WHERE LEFT(name, 1) = RIGHT(name, 1)

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

Соединение двух строковых значений в одно называется конкатенацией, и в SQL Server для этой операции используется знак "+" (в стандарте "||"). Итак,

SELECT * FROM (

 SELECT class +' '+ name AS cn FROM Ships

  ) x

WHERE LEFT(cn, 1)=RIGHT(cn, 1)

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

А если строковое выражение будет содержать лишь одну букву? Запрос выведет ее. В этом легко убедиться, написав

SELECT * FROM (

 SELECT class +' '+ name AS cn FROM Ships

 UNION ALL

 SELECT 'a' as nc

  ) x

WHERE LEFT(cn, 1)=RIGHT(cn, 1)

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

SELECT * FROM (

 SELECT class +' '+ name AS cn FROM Ships

 UNION ALL

 SELECT 'a' as nc

  ) x

WHERE LEFT(cn, 1)=RIGHT(cn, 1) AND LEN(cn)1

Замечание. Реализация этой функции в MS SQL Server имеет одну особенность, а именно, при подсчете длины не учитываются концевые пробелы.

Действительно, выполним следующий код:

DECLARE @chr AS CHAR(12), @vchr AS VARCHAR(12)

SELECT @chr = 'abcde' + REPLICATE(' ', 5), @vchr = 'abcde'+REPLICATE(' ', 5)

SELECT LEN(@chr), LEN(@vchr)

SELECT DATALENGTH(@chr), DATALENGTH(@vchr)

Функция REPLICATE дополняет константу 'abcde' пятью пробелами справа, которые не учитываются функцией LEN, - в обоих случаях получаем 5.

Функция DATALENGTH возвращает число байтов в представлении переменной и демонстрирует нам различие между типами CHAR и VARCHAR. DATALENGTH даст нам 12 для типа CHAR и 10 - для VARCHAR.

Как и следовало ожидать, DATALENGTH для переменной типа VARCHAR вернула фактическую длину переменной. Но почему для переменной типа CHAR результат оказался равным 12? Дело в том, что CHAR - это тип фиксированной длины. Если значение переменной оказывается меньше ее длины, а длину мы объявили как CHAR(12), то значение переменной будет "выровнено" до требуемой длины за счет добавления концевых пробелов.

На сайте имеются задачи, в которых требуется упорядочить (найти максимум и т.д.) в числовом порядке значения, представленные в текстовом формате. Например, номер места в самолете ("2d") или скорость CD ("24x"). Проблема заключается в том, что текст сортируется так (по возрастанию)

Действительно,

SELECT '1a' AS place

UNION ALL SELECT '2a'

UNION ALL SELECT '11a'

ORDER BY 1

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

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

1. Извлечь число из строки.

2. Привести его к числовому формату.

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

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

LEFT(place, LEN(place)-1)

Если только этим и ограничиться, то получим

Приведение к числовому формату может быть следующим:

CAST (LEFT(place, LEN(place)-1) AS INT)

Осталось выполнить сортировку

SELECT * FROM (

 SELECT '1a' AS place

 UNION ALL SELECT '2a'

 UNION ALL SELECT '11a'

  ) x

ORDER BY CAST(LEFT(place, LEN(place)-1) AS INT)

Что и требовалось доказать.

Ранее мы для извлечения числа из текстовой строки пользовались функцией LEFT, т.к. нам было известно априори, какое число символов нужно убрать справа (один). А если же нужно извлечь строку из подстроки не по известной позиции символа, а по самому символу? Например: извлечь все символы до первой буквы "х" (значение скорости CD).

В этом случае мы можем использовать также уже рассмотренную ранее функцию CHARINDEX, которая позволит определить неизвестную позицию символа:

SELECT model, LEFT(cd, CHARINDEX('x', cd) -1) FROM PC

SELECT name, SUBSTRING(name, 2, 3) FROM Ships

SELECT name, SUBSTRING(name, 2, LEN(name)) FROM Ships

SELECT REVERSE('abcdef')

SELECT RIGHT('abcdef',3)

SELECT REVERSE(LEFT(REVERSE('abcdef'),3))

SELECT CHARINDEX('a', name) first_a

FROM Ships WHERE name='California'

CHARINDEX('a', REVERSE(name))

SELECT LEN(name) + 1 - CHARINDEX('a', REVERSE(name)) first_a

FROM Ships WHERE name='California'

UPDATE Ships

SET name = REPLACE(name, ' ', '-')

SELECT name, LEN(REPLACE(name, 'a', 'aa')) - LEN(name) FROM Ships

DECLARE @str AS VARCHAR(100)

SET @str='ma'

SELECT name, (LEN(REPLACE(name, @str, @str + @str)) - LEN(name))/LEN(@str) FROM Ships

SELECT name, (LEN(REPLACE(name, @str, REPLICATE(@str, 2))) - LEN(name))/LEN(@str) FROM Ships

SELECT name, STUFF(name, 6, LEN(name), '_'+launched) FROM Ships

SELECT name, STUFF(name, 6, LEN(name), '_'+STR(launched, 4)) FROM Ships

SELECT name, STUFF(name + SPACE(6), 6, LEN(name), '_'+STR(launched,4)) FROM Ships

SELECT name + '_' + CAST(id_psg AS VARCHAR) FROM Passenger,

SELECT RTRIM(name) + '_' + CAST(id_psg AS VARCHAR) FROM Passenger

SELECT ASCII('а'), UNICODE('а')

SELECT CHAR(ASCII('а')), CHAR(UNICODE('а'))

SELECT CHAR(ASCII('а')), NCHAR(UNICODE('а'))

SELECT NCHAR(ASCII('а'))

Оператор INSERT

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

Синтаксис оператора

INSERT INTO <имя таблицы[(<имя столбца,...)]

{VALUES (< значение столбца,…)}

| <выражение запроса

| {DEFAULT VALUES};

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

CREATE TABLE [dbo].[product] (

 [maker] [char] (1) NOT NULL ,

 [model] [varchar] (4) NOT NULL ,

 [type] [varchar] (7) NOT NULL )

Пусть требуется добавить в эту таблицу модель ПК 1157 производителя B. Это можно сделать следующим оператором:

INSERT INTO Product VALUES ('B', 1157, 'PC');

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

INSERT INTO Product (type, model, maker) VALUES ('PC', 1157, 'B');

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

CREATE TABLE [product_D] (

 [maker] [char] (1) NULL ,

 [model] [varchar] (4) NULL ,

 [type] [varchar] (7) NOT NULL DEFAULT 'PC' )

Отметим, что здесь значения всех столбцов имеют значения по умолчанию (первые два - NULL, а последний столбец - type - 'PC'). Теперь мы могли бы написать:

INSERT INTO Product_D (model, maker) VALUES (1157, 'B');

В этом случае отсутствующее значение при вставке строки будет заменено значением по умолчанию - 'PC'. Заметим, что если для столбца в операторе CREATE TABLE не указано значение по умолчанию и не указано ограничение NOT NULL, запрещающее использование NULL в данном столбце таблицы, то подразумевается значение по умолчанию NULL.

Возникает вопрос: а можно ли не указывать список столбцов и, тем не менее, воспользоваться значениями по умолчанию? Ответ положительный. Для этого нужно вместо явного указания значения использовать зарезервированное слово DEFAULT:

INSERT INTO Product_D VALUES ('B', 1158, DEFAULT);

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

INSERT INTO Product_D VALUES (DEFAULT, DEFAULT, DEFAULT);

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

INSERT INTO Product_D DEFAULT VALUES;

Заметим, что при вставке строки в таблицу проверяются все ограничения, наложенные на данную таблицу. Это могут быть ограничения первичного ключа или уникального индекса, проверочные ограничения типа CHECK, ограничения ссылочной целостности. В случае нарушения какого-либо ограничения вставка строки будет отвергнута.

Рассмотрим теперь случай использования подзапроса. Пусть нам требуется вставить в таблицу Product_D все строки из таблицы Product, относящиеся к моделям персональных компьютеров (type = 'PC'). Поскольку необходимые нам значения уже имеются в некоторой таблице, то формирование вставляемых строк вручную, во-первых, является неэффективным, а, во-вторых, может допускать ошибки ввода. Использование подзапроса решает эти проблемы:

INSERT INTO Product_D SELECT * FROM Product WHERE type = 'PC';

Использование в подзапросе символа "*" является в данном случае оправданным, т.к. порядок следования столбцов является одинаковым для обеих таблиц. Если бы это было не так, следовало бы использовать список столбцов либо в операторе INSERT, либо в подзапросе, либо в обоих местах, который приводил бы в соответствие порядок следования столбцов:

INSERT INTO Product_D(maker, model, type)

 SELECT * FROM Product WHERE type = 'PC';

или

INSERT INTO Product_D

 SELECT maker, model, type FROM Product WHERE type = 'PC';

или

INSERT INTO Product_D(maker, model, type)

 SELECT maker, model, type FROM Product WHERE type = 'PC';

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

INSERT INTO Product_D (maker, model)

 SELECT maker, model FROM Product WHERE type = 'PC';

В данном случае в столбец type таблицы Product_D будет подставлено значение по умолчанию 'PC' для всех вставляемых строк.

Отметим, что при использовании подзапроса, содержащего предикат, будут вставлены только те строки, для которых значение предиката равно TRUE (не UNKNOWN!). Другими словами, если бы столбец type в таблице Product допускал бы NULL-значение, и это значение присутствовало бы в ряде строк, то эти строки не были бы вставлены в таблицу Product_D.

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

INSERT INTO Product_D

 SELECT 'B' AS maker, 1158 AS model, 'PC' AS type

 UNION ALL

 SELECT 'C', 2190, 'Laptop'

 UNION ALL

 SELECT 'D', 3219, 'Printer';

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

CREATE TABLE [Printer_Inc] (

 [code] [int] IDENTITY(1,1) PRIMARY KEY ,

 [model] [varchar] (4) NOT NULL ,

 [color] [char] (1) NOT NULL ,

 [type] [varchar] (6) NOT NULL ,

 [price] [float] NOT NULL )

INSERT INTO Printer_Inc VALUES (15, 3111, 'y', 'laser', 2599);

INSERT INTO Printer_Inc (model, color, type, price)

 VALUES (3111, 'y', 'laser', 2599);

SET IDENTITY_INSERT Printer_Inc ON;

INSERT INTO Printer_Inc(code, model, color, type, price)

 VALUES (15, 3111, 'y', 'laser', 2599);

SET IDENTITY_INSERT Printer_Inc ON;

INSERT INTO Printer_Inc

 VALUES (15, 3111, 'y', 'laser', 2599);

SET IDENTITY_INSERT Printer_Inc ON;

INSERT INTO Printer_Inc(model, color, type, price)

 VALUES (3111, 'y', 'laser', 2599);

SET IDENTITY_INSERT Printer_Inc ON;

INSERT INTO Printer_Inc(code, model,color,type,price)

 SELECT * FROM Printer;

Оператор UPDATE

Оператор UPDATE изменяет имеющиеся данные в таблице. Команда имеет следующий синтаксис

UPDATE

SET {имя столбца = {выражение для вычисления значения столбца

| NULL

| DEFAULT},...}

[ {WHERE }];

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

Если столбец допускает NULL-значение, то его можно указать в явном виде. Кроме того, можно заменить имеющееся значение на значение по умолчанию (DEFAULT) для данного столбца.

Ссылка на "выражение" может относиться к текущим значениям в изменяемой таблице. Например, мы можем уменьшить все цены ПК-блокнотов на 10 процентов с помощью следующего оператора:

UPDATE Laptop SET price=price*0.9

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

UPDATE Laptop SET hd=ram/2 WHERE hd<10

Естественно, типы данных столбцов hd и ram должны быть совместимы. Для приведения типов может использоваться выражение CAST.

Если требуется изменять данные в зависимости от содержимого некоторого столбца, можно воспользоваться выражением CASE. Если, скажем, нужно поставить жесткие диски объемом 20 Гб на ПК-блокноты с памятью менее 128 Мб и 40 гигабайтные - на остальные ПК-блокноты, то можно написать такой запрос:

UPDATE Laptop

 SET hd = CASE WHEN ram<128 THEN 20 ELSE 40 END

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

UPDATE Laptop

 SET speed = (SELECT MAX(speed) FROM Laptop)

Необходимо сказать несколько слов об автоинкрементируемых столбцах. Если столбец code в таблице Laptop определен как IDENTITY(1,1), то следующий оператор

UPDATE Laptop SET code=5 WHERE code=4

не будет выполнен, т.к. автоикрементируемое поле не допускает обновления, и мы получим соответствующее сообщение об ошибке. Чтобы выполнить все же эту задачу, можно поступить следующим образом. Сначала вставить нужную строку, используя SET IDENTITY_INSERT, после чего удалить старую строку:

SET IDENTITY_INSERT Laptop ON

INSERT INTO Laptop_ID(code, model, speed, ram, hd, price, screen)

 SELECT 5, model, speed, ram, hd, price, screen

 FROM Laptop_ID WHERE code=4

DELETE FROM Laptop_ID WHERE code=4

Разумеется, другой строки со значением code=5 в таблице быть не должно.

В Transact-SQL оператор UPDATE расширяет стандарт за счет использования необязательного предложения FROM. В этом предложении специфицируется таблица, обеспечивающая критерий для операции обновления. Дополнительную гибкость здесь дает использование операций соединения таблиц.

Пример. Пусть требуется указать "No PC" (нет ПК) в столбце type для тех моделей ПК из таблицы Product, для которых нет соответствующих строк в таблице PC. Решение посредством соединения таблиц можно записать так:

UPDATE Product

 SET type='No PC'

 FROM Product pr LEFT JOIN PC ON pr.model=pc.model

 WHERE type='pc' AND pc.model IS NULL

Здесь используется внешнее соединение, в результате чего столбец pc.model для моделей ПК, отсутствующих в таблице PC, будет содержать NULL-значение, что и используется для идентификации подлежащих обновлению строк. Естественно, эта задача имеет решение и в "стандартном" исполнении:

UPDATE Product

 SET type='No PC'

 WHERE type='pc' and model NOT IN (SELECT model FROM PC)

Оператор DELETE

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

DELETE FROM [WHERE ];

Если предложение WHERE отсутствует, удаляются все строки из таблицы или представления (представление должно быть обновляемым). Более быстро эту операцию (удаление всех строк из таблицы) в Transact-SQL можно также выполнить с помощью команды

TRUNCATE TABLE

Однако есть ряд отличий в реализации команды TRUNCATE TABLE по сравнению с использованием оператора DELETE, которые следует иметь в виду:

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

2. Не отрабатывают триггеры. Как следствие, эта команда неприменима, если на данную таблицу имеется ссылка по внешнему ключу.

3. Значение счетчика (IDENTITY) сбрасывается в начальное значение.

Пример. Требуется удалить из таблицы Laptop все ПК-блокноты с размером экрана менее 12 дюймов.

DELETE FROM Laptop

 WHERE screen<12

Все блокноты можно удалить с помощью оператора

DELETE FROM Laptop

или

TRUNCATE TABLE Laptop

Transact-SQL расширяет синтаксис оператора DELETE, вводя дополнительное предложение FROM

FROM

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

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

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

Используя стандартный синтаксис, эту задачу можно решить следующим запросом:

DELETE FROM Product

 WHERE type='pc' AND model NOT IN (SELECT model FROM PC)

Заметим, что предикат type='pc' необходим здесь, чтобы не были удалены также модели принтеров и ПК-блокнотов.

Эту же задачу можно решить с помощью дополнительного предложения FROM следующим образом:

DELETE FROM Product

 FROM Product pr LEFT JOIN PC ON pr.model=pc.model

 WHERE type='pc' AND pc.model IS NULL

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

1. UNION ALL

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

SELECT col1 col FROM T

UNION ALL

SELECT col2 FROM T

2. FULL JOIN

Чтобы не потерять дубликаты, находящиеся в разных столбцах, выполним полное соединение (FULL JOIN) по заведомо ложному предикату, скажем, 1 = 2:

SELECT T.col1,T1.col2

FROM T FULL JOIN T AS T1 ON 1=2

Результат:

col1 col2

1 NULL

1 NULL

NULL NULL

NULL NULL

NULL 1

NULL 3

NULL NULL

NULL 2

Далее используем функцию COALESCE, которая даст нам все, что нужно:

SELECT COALESCE(T.col1,T1.col2) col

FROM T FULL JOIN T AS T1 ON 1=2

3. UNPIVOT

Конструкции PIVOT и UNPIVOT появились в последних версиях стандарта SQL и были реализованы SQL Server, начиная с версии 2005. Первая из них позволяет значения в столбце вытянуть в строку, а вторая поможет нам выполнить обратную операцию:

SELECT col

FROM

(SELECT col1, col2

FROM T) p

UNPIVOT

(col FOR xxx IN

(col1, col2)

)AS unpvt

Значения из столбцов col1 и col2 собираются в одном столбце col вспомогательной таблицы unpvt. Однако есть одна особенность в использовании операторов PIVOT и UNPIVOT - они не учитывают NULL-значения. Результат последнего запроса будет таким:

col

1

1

1

3

2

Это препятствие на пути к решению нашей задачи можно преодолеть, если заменить NULL-значение на входе оператора UNPIVOT псевдозначением, т.е. значением, которого заведомо не может быть в исходных данных, а потом выполнить обратное преобразование:

SELECT NULLIF(col,777)

FROM

(SELECT COALESCE(col1,777) col1, COALESCE(col2,777) col2

FROM T) p

UNPIVOT

(col FOR xxx IN

(col1, col2)

)AS unpvt

Здесь COALESCE(colx,777) заменяет NULL-значения в столбце colx на 777, а функция NULLIF(col,777) выполняет обратное преобразование.

Последнее решение дает нам требуемый результат, однако содержит один изъян - значение 777 может рано или поздно появиться в данных, что будет приводить к неверным результатам. Чтобы устранить этот огрех, можно использовать значение другого типа, которого заведомо не может присутствовать в целочисленном столбце, например, символ 'x'. Естественно, чтобы применить этот подход, для совместимости типов целочисленный тип столбцов следует конвертировать к символьному типу, выполнив при необходимости обратное преобразование конечного результата:

SELECT CAST(NULLIF(col,'x') AS INT)

FROM

(SELECT COALESCE(CAST(col1 AS VARCHAR),'x') col1,

COALESCE(CAST(col2 AS VARCHAR),'x') col2

FROM T) p

UNPIVOT

(col FOR xxx IN

(col1, col2)

)AS unpvt

Несколько слов об эффективности представленных решений. Согласно плану выполнения запроса, основные затраты обусловлены чтением данных (операция сканирования таблицы - Table scan). Для двух первых решений сканирование выполняется дважды, в то время как для последнего (UNPIVOT) - один раз, чем и обусловлено его двойное преимущество в производительности.

DROP TABLE T

Комментарии

Н.Петров (aka sql chuvak) 28-08-2008

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

SELECT

CASE a WHEN 1 THEN col1 ELSE col2 END col

FROM T, (SELECT 1 a UNION ALL SELECT 2) B

Декартово произведение таблицы T с выборкой из 2-х строк дает "удвоение" (каждая строка таблицы повторяется 2 раза - для а=1 и а=2). Для первого случая берем значение из col1, а для второго - из col2.

Тут, конечно, есть и union, и join, но, по-моему, в данном вопросе интересует именно единственное сканирование таблицы.