1. Создание БД

CREATE DATABASE database_name
[ON
{ [PRIMARY] (NAME = logical_file_name,
FILENAME = 'os_file_name'
[, SIZE = size]
[, MAXSIZE = max_size]
[, FILEGROWTH = growth_increment] )
} [,...n]
]
[LOG ON
{ ( NAME = logical_file_name,
FILENAME = 'os_file_name'
[, SIZE = size] )
} [,...n]
]
[FOR RESTORE]

FILENAME - полный путь и имя файла для размещения БД, должен указывать на локальный диск компьютера, на котором установлен SQL Server.
SIZE - начальный размер каждого файла в Мб.
MAXSIZE - максимальный размер файла в Мб, если не указана размер не ограничивается.
FILEGROWTH - единица увеличения файла, указывается в Мб (по умолчанию) или в процентах (т.е. к числу добавляется %), значение 0 запрещает увеличение файла.

CREATE DATABASE SQLStepByStep
ON
PRIMARY (NAME=SQLStepData,
FILENAME='c:\mssql7\data\sqlstep_data.mdf',
SIZE=5,
MAXSIZE=10,
FILEGROWTH=10% )
LOG ON (
NAME=SQLStepLog,
FILENAME='c:\mssql7\data\sqlstep_log.ldf',
SIZE=1,
MAXSIZE=5,
FILEGROWTH=1
)

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

CREATE TABLE table_name
(column_name data_type [NULL | NOT NULL]
[,...n])

пример

CREATE TABLE member
( member_no int NOT NULL,
lastname char(50) NOT NULL,
firstname char(50) NOT NULL,
photo image NULL
)

Этим оператором создается таблица member, состоящая из четырех колонок:

* member_no - имеет тип int, значения NULL не допускаются
* lastname - имеет тип char(50) - 50 символов, значения NULL не допускаются
* firstname - аналогично lastname
* photo - имеет тип image (изображение), допускается значение NULL

3. Извлечение данных из таблиц

SELECT <столбцы через запятую или * - все столбцы>
FROM <наименование таблицы\таблиц>

например
select *
from member

*******
устранение двойного вывода одинаковых значений в столбце

SELECT DISTINCT <столбец>
FROM <таблица>

условие

SELECT <столбцы>
FROM <таблица>
WHERE <столбец> = 'условие' - с кавычками если текст "москва" и без если число, напр 100

# = Равно
# > Больше чем
# < Меньше чем
# >= Больше или равно
# <= Меньше или равно
# <> Не равно
# AND логическое "И"
# OR логическое "ИЛИ"
# NOT логическое отрицание

Оператор AND сравнивает два логических значения и возвращает TRUE (истина), если оба значения истинны (т.е. равны TRUE), в остальных случаях - FALSE (ложь). Оператор OR возвращает TRUE, если хотя бы один из аргументов равен TRUE. Оператор NOT возвращает TRUE, если его аргумент равен FALSE и наоборот.
Использование логических операторов значительно увеличивает возможности команды SELECT. Например, для просмотра заказчиков из Караганды, которые имеют рейтинг выше 200 достаточно команды.

Для группировки выражений Transact-SQL позволяет использовать круглые скобки ( ).
Этот запрос отбирает заказчиков, которые НЕ находятся в Караганде или НЕ имеют рейтинг больше 200.

Рассмотрим теперь специальные операторы: IN, BETWEEN, LIKE, IS NULL.

Оператор IN определяет список значений, в который должно входить значение поля.
WHERE city IN ( 'Москва', 'Хабаровск' )
Оператор BETWEEN похож на оператор IN. В отличие от списка допустимых значений BETWEEN определяет диапазон значений. В запросе Вы должны указать слово BETWEEN затем начальное значение, ключевое слово AND и конечное значение.
WHERE comm BETWEEN 10 AND 12
Оператор LIKE применим только к символьным полям, с которыми он используется, чтобы находить подстроки. Т.е. он ищет поле символа, чтобы видеть совпадает ли с условием часть его строки. В качестве условия он использует специальные символы:

* символ подчеркивания _ - замещает любой одиночный символ. Например, 'к_т' будет соответствовать 'кот' и 'кит', но не 'крот'.
* знак процента % - замещает последовательность любого числа символов. Например, '%м%р' будет соответствовать 'компьютер' и 'омар'.
WHERE cname LIKE 'О%'
LIKE удобен поиске значений, если Вы точно не помните как они пишутся. Вы просто можете использовать ту часть, которую помните.
Так как NULL указывает на отсутствие значения Вы не можете знать каков бужет результат любого сравнения с NULL. Часто Вам различать строки, содержащие значения NULL в каком-либо столбце. Для этого существует специальный оператор IS NULL.
WHERE city IS NULL


4. Обобщение данных с помощью агрегатных функций

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

SQL Server предоставляет несколько агрегатных функций:

* COUNT - производит подсчет строк, удовлетворяющих условию запроса
* SUM - вычисляет арифметическую сумму всех значений колонки
* AVG - вычисляет среднее арифметическое всех значений
* MAX - определяет наибольшее из всех выбранных значений
* MIN - определяет наименьшее из всех выбранных значений

Функции SUM и AVG применимы только к числовым полям. С COUNT, MAX, MIN могут использоваться числовые или символьные поля. При использовании с символьными полями MAX, MIN сравнивают значения в алфавитном порядке. Агрегатные функции при своей работе игнорируют значения NULL.
Чтобы найти сумму всех единиц в таблице можно ввести запрос:
SELECT SUM( amt )

Функция COUNT несколько отличается от остальных. Она подсчитывает число значений в данной колонке или число строк в таблице.

Предложение GROUP BY позволяет задавать Вам подмножество значений, для которых применяется агрегатная функция. Это дает возможность объединять поля и агрегатные функции в одном предложении SELECT. Предположим, что Вам надо найти наибольшую сумму заказа, полученного каждым торговым агентом.
SELECT snum, MAX( amt )
FROM Orders
GROUP BY snum


GROUP BY применяет агрегатные функции независимо к группам записей. Условие формирования группы - одинаковое значение поля (в данном случае snum). При обработке этого запроса функция MAX вычисляется для каждого из значений snum.
GROUP BY можно использовать с несколькими полями. Усложним предыдущий запрос:
SELECT snum, odate, MAX( amt )
FROM Orders
GROUP BY snum, odate
Т.е. мы выбираем коды агентов и максимальные суммы полученных ими заказов на каждую дату

Усложним задачу: теперь надо получить максимальную сумму заказов каждого агента, которая больше 3000. Для достижения такого эффекта применяется предложение HAVING, которое определяет критерий, используемый для удаления групп из результата запроса, как это делает предложение WHERE для отдельных строк. Вот как это делается:
SELECT snum, odate, MAX( amt )
FROM ORDERS
GROUP BY snum, odate
HAVING MAX( amt ) > 3000

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

Полное имя столбца в таблице фактически состоит из имени таблицы, за которым идет точка и имя столбца. (По правде говоря, вначале еще указывается и имя пользователя, но это скорее относится к правам доступа и мы вернемся к этому позднее). Примеры имен:
Salespeople.snum
Salespeople.city
Orders.odate

До этого в запросах мы опускали имена таблиц, потому что мы запрашивали только одну таблицу. Если мы хотим связать столбцы разных таблиц, то их надо указать с именами Salespeople.city или Customers.city, чтобы сервер мог их различать.
Предположим вы хотите увидеть комбинации торговых агентов и заказчиков по городам.Это делается так:
SELECT Customers.cname, Salespeople.sname, Salespeople.city
FROM Salespeople, Customers
WHERE Salespeople.city = Customers.city

т.к. поле city имеется в таблицах Торговые агенты и Заказчики, имена таблиц должны использоваться как префиксы.
Как работает этот запрос? SQL Server проверяет каждую комбинацию строк двух таблиц и проверяет их на условие указанное в предложении WHERE. Если эта комбинация удовлетворяет ему, то она выводится.
Для объединения таблиц можно использовать любые условия, а не только равенство. Например:
SELECT Salespeople.sname, Customers.cname
FROM Salespeople, Customers
WHERE Salespeople.sname < Customers.cname AND
Customers.rating < 200

В принципе это не слишком полезный запрос. Он воспроизводит все комбинации имени продавца и имени заказчика так, что первый предшествует последнему в алфавитном порядке, а заказчик имеет рейтинг меньше 200.
Предположим, что мы хотим найти все заказы заказчиков, не находящихся в одном городе с агентом. Для этого требуется связать три таблицы:
SELECT Orders.onum, Customers.cname, Orders.cnum, Orders.snum
FROM Salespeople, Customers, Orders
WHERE Customers.city <> Salespeople.city AND
Orders.cnum = Customers.cnum AND
Orders.snum = Salespeople.snum

6. Помещение одного запроса внутрь другого.

Запросы могут управлять другими запросами. Это делается путем помещения запроса внутрь условия другого запроса и использования вывода внутреннего запроса в верном или неверном условии.
Обычно внутренний запроса генерирует значение, которое проверяется в условии внешнего запроса, определяющего верно оно или нет. Например, мы знаем имя торгового агента - Сидоров, но не знаем его кода (snum), и хотим получить все его заказы из таблицы Заказов (Orders).
SELECT *
FROM Orders
WHERE snum = (
SELECT snum
FROM Salespeople
WHERE sname = 'Сидоров'
)
Чтобы выполнить внешний (основной запрос), сначала выполняется внутренний запрос (подзапрос) внутри предложения WHERE. При выполнении подзапроса просматривается таблица Salespeople, в которой выбираются строки, где поле sname равно 'Иванов', затем извлекается значение поля snum. Единственной строкой будет snum = 1004. Далее полученное значение помещается в условие основного запроса, вместо самого подзапроса, так что условие примет вид:
WHERE snum = 1004

При использовании подзапросов в условиях основанных на операциях сравнения (больше, меньше, равно, не равно и т.д.) вы должны убедиться, что подзапрос будет возвращать одно и только значение. Если ваш подзапрос не вернет никакого значения, то основной запрос не выведет никаких значений.
Если Вы хотите использовать подзапрос, который возвращает несколько строк, то необходимо использовать оператор IN. Как Вы помните, этот оператор определяет допустимый набор значений, когда он используется с подзапросом этот список формируется из значений, которые возвращает подзапрос. Найдем все заказы для агента из Москвы:
SELECT *
FROM Orders
WHERE snum IN (
SELECT snum
FROM Salespeople
WHERE city = 'Москва'
)

Команды типа SELECT * запрещены в подзапросах.

Подзапросы можно также использовать в предложении HAVING. Эти подзапросы могут использовать собственные предложения GROUP BY или HAVING. Следующий запрос является тому примером:
SELECT rating, COUNT( DISTINCT cnum )
FROM Customers
GROUP BY rating
HAVING rating > (
SELECT AVG( rating )
FROM Customers
WHERE city = 'Москва'
)
Эта команда подсчитывает заказчиков с рейтингом выше среднего в Москве.

7. Связанные подзапросы

Когда Вы используете подзапросы, Вы можете обратиться во вложенном подзапросе к таблицам из внешнего подзапроса. Например, как найти всех заказчиков на 3 октября:
SELECT *
FROM Customers C
WHERE '1999-10-03' IN (
SELECT odate
FROM Orders O
WHERE O.cnum = C.cnum
)

Когда Вы используете подзапросы, Вы можете обратиться во вложенном подзапросе к таблицам из внешнего подзапроса. Например, как найти всех заказчиков на 3 октября:
SELECT *
FROM Customers C
WHERE '1999-10-03' IN (
SELECT odate
FROM Orders O
WHERE O.cnum = C.cnum
)
Как это все работает?
В приведенном выше запросе C и O это псевдонимы таблиц. Так как значение в поле cnum внешнего запроса меняется, то внутренний запрос должен выполняться отдельно для каждой строки внешнего запроса. Строка внешнего запроса, для которой будет выполняться внутренний запрос, называется строкой-кандидатом.
Процедура оценки, выполняемая связанным запросом:
1. Выбрать строку из таблицы, указанной во внешнем запросе. Это будет текущая строка-кандидат.
2. Сохранить значения из этой строки-кандидата во временном буфере
3. Выполнить подзапрос. Для отбора записей использовать строку-кандидат.
4. Вычислить условие во внешнем запросе, на основе результатов внутреннего подзапроса, выполняемого в п.3. Определяется - отбирается ли строка-кандидат для вывода.
5. Повторить процедуру для всех строк.
В принципе можно было бы использовать объединение следующего вида:
SELECT C.*
FROM Customers C, Orders O
WHERE C.cnum = O.cnum AND
O.odate = '1999.10.03'
Но, если один и тот же заказчик сделал бы 2 и более заказов, то он появился в результате несколько раз. Конечно этого можно избежать использовав DISTINCT, но это не эффективное решение. Оператор IN в варианте с подзапросом не делает различия между значениями, которые выбираются подзапросом один раз и которые выбираются многократно. Следовательно DISTINCT необязателен.

Предположим, что мы хотим получить имена и номера всех продавцов, которые имеют более одного заказчика:
SELECT snum, sname
FROM Salespeople S
WHERE 1 < (
SELECT COUNT(*)
FROM Customers c
WHERE c.snum = s.snum
)
Связанные запросы можно использовать для сравнения таблицы с собой. Например, можно найти все заказы со значениями сумм выше среднего для заказчиков:
SELECT *
FROM Orders O
WHERE amt > (
SELECT AVG( amt )
FROM Orders O1
WHERE O1.cnum = O.cnum
)

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

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

Оператор EXISTS берет подзапрос, как аргумент, и оценивает его как верный, если подзапрос возвращает какие-либо записи и неверный, если тот не делает этого. Например, мы можем решить извлекать ли нам некоторые данные из таблицы Заказчиков, если один и более заказчиков в этой таблице находятся в Москве.
SELECT cnum, cname, city
FROM Customers
WHERE EXISTS (
SELECT *
FROM Customers
WHERE city = 'Москва'
)

Внутренний подзапрос выбирает все данные для всех заказчиков из Москвы. Оператор EXISTS во внешнем условии отмечает, что подзапрос вернул некоторые данные, следовательно условие верное. Подзапрос будет выполнен один раз для всего внешнего запроса и имеет одно значение во всех случаях. Поэтому EXISTS, когда используется таким образом, делает условие верным или неверным для всех строк сразу.
В связанных подзапросах, предложение EXISTS оценивается для каждой строки таблицы, имя которой указано во внешнем запросе. Это дает возможность использовать EXISTS, как условие, которое генерирует разные ответы для каждой строки таблицы, указанной в основном запросе. Например, мы можем вывести торговых агентов, у которых несколько заказчиков.
SELECT DISTINCT snum
FROM Customers couter
WHERE EXISTS (
SELECT *
FROM Customers cinner
WHERE cinner.snum = couter.snum
AND cinner.cnum <> couter.cnum
)

Для каждой строки-кандидата внешнего запроса (представляющей заказчика проверяемого в данный момент), внутренний запрос находит строки, которые совпадают со значением поля snum (которое имел агент), но не со значением поля cnum (соответствующего другим заказчикам). Если любые такие строки найдены внутренним запросом, это означает, что имеется два разных заказчика, обслуживаемых одним продавцом. EXISTS поэтому верно для текущей строки и номер продавца (snum) будет выведен. Если бы DISTINCT не было указано, каждый из этих продавцов был бы выбран столько раз, сколько у него заказчиков.
Однако более полезно было бы вывести больше информации об этих агентах, а не только их номера. Это можно сделать объединив таблицу Заказчиков с таблицей Агентов:
SELECT DISTINCT first.snum, first.sname, first.city
FROM Salespeople first, Customers second
WHERE EXISTS (
SELECT *
FROM Customers third
WHERE second.snum = third.snum
AND second.cnum <> third.cnum)
AND first.snum = second.snum
Внутренний запрос такой же как и в предыдущем варианте. Внешний запрос - это объединение таблицы Агентов с таблицей Заказчиков.
Предыдущий пример показал, что оператор EXISTS можно использовать совместно с логическими операторами. Самым простым способом такого использования является применение оператора NOT - видимо самый частый вариант использования EXISTS. Один из способов нахождения продавцов только с одним заказчиком состоит в том, что предыдущий запрос инвертируется:

SELECT DISTINCT snum
FROM Customers couter
WHERE NOT EXISTS (
SELECT *
FROM Customers cinner
WHERE cinner.snum = couter.snum
AND cinner.cnum <> couter.cnum
)

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

Рассмотрим новый способ нахождения агента с заказчиками размещенными в их городах:
SELECT *
FROM Salespeople
WHERE city = ANY (
SELECT city
FROM Customers
)
Оператор ANY берет все значения, выведенные подзапросом, и оценивает их как верные, если любое из них равняется значению города в текущей строке внешнего запроса. Это означает, что подзапрос должен выбирать значения такого же типа как и те, которые сравниваются в основном условии.
В приведенном выше запросе можно было бы использовать оператор IN. Однако оператор ANY можно применять не только с оператором равенства. Например, можно найти всех агентов, у которых заказчики следуют им в алфавитном порядке: SELECT * FROM Salespeople WHERE sname < ANY ( SELECT cname FROM Customers ) Результат:
Оператор ALL считает условие верным, если каждое значение, выбранное подзапросом, удовлетворяет условию внешнего запроса. Выберем тех заказчиков, чьи рейтинги выше чем у каждого заказчика в Москве:
SELECT *
FROM Customers
WHERE rating > ALL(
SELECT rating
FROM Customers
WHERE city = 'Москва'
)

10. Использование команды UNION

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

SELECT snum, sname
FROM Salespeople
WHERE city = 'Москва'
UNION
SELECT cnum, cname
FROM Customers
WHERE city = 'Москва'
Для применения команды UNION существует 2 правила:

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

Совместимость типов определяется просто:
Тип данных колонки Тип результата
Обе колонки типа char с фиксированными длинами L1 и L2 char с длиной равной наибольшему из L1 и L2
Обе колонки типа binary c фиксированной длиной L1 и L2 binary с длиной равной наибольшему из L1 и L2
Одна или обе типа varchar varchar с длиной равной наибольшему из L1 и L2
Одна или обе типа varbinary varbinary с длиной равной наибольшему из L1 и L2
Обе числового типа (smallint,money, float) Тип данных с наибольшей точностью (int=>float)

UNION автоматически исключает дубликаты строк из вывода. Если вы хотите, чтобы все строки из запросов попали в результат используйте UNION ALL:

SELECT snum, city
FROM Customers

UNION ALL

SELECT snum, city
FROM Salespeople

Вместе с UNION может использоваться ORDER BY для упорядочивания вывода. При этом ORDER BY указывается только после последнего запроса, входящего в UNION.

SELECT a.snum, sname, onum, 'Наибольший на ',odate
FROM Salespeople a, Orders b
WHERE a.snum = b.snum AND
b.amt = (
SELECT MAX(amt)
FROM Orders c
WHERE c.odate = b.odate
)

UNION

SELECT a.snum, sname, onum, 'Наименьший на ', odate
FROM Salespeople a, Orders b
WHERE a.snum = b.snum AND
b.amt = (
SELECT MIN(amt)
FROM Orders c
WHERE c.odate = b.odate
)

ORDER BY 3

3 - просто номер колонки вывода. Так проще сортировать записи, т.к. при использовании UNION имена колонок могут выглядеть как угодно.

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

Значения могут быт помещены и удалены из полей, тремя командами:
* INSERT - вставка данных
* UPDATE - изменение данных
* DELETE - удаление

Ввод значений
Все строки вводятся с использованием команды INSERT. В самой простой форме используется следующий синтаксис:
INSERT INTO table_name
VALUES ( value, value, ... )
Так для того чтобы добавить запись в таблицу торговых агентов можно использовать команду:
INSERT INTO Salespeople
VALUES( 1008, 'Johnson', 'London', 12 )
Команды модификации не производят никакого вывода. Но Query Analyzer сообщит Вам, что была добавлена 1 запись. Таблица уже должна существовать к моменту исполнения этой команды, а тип каждого значения в скобках после VALUES должен совпадать с типом данных столбца, в который оно вставляется. Первое значение попадает в столбец 1, второе - 2 и т.д.
Если вам нужно ввести пустое значение (NULL), просто укажите его в списке значений. Например:
INSERT INTO Salespeople
VALUES ( 1009, 'Peel', NULL, 12 )
Вы можете явно указать столбцы, куда Вы хотите вставить значение. Это позволит вставлять значения в любом порядке.
INSERT INTO Customers( city, cname, cnum )
VALUES( 'Новосибирск', 'Петров', 2010 )
Обратите внимание, что столбцы rating и snum отсутствуют. Это значит, что во вставленной записи им будет присвоено значение по умолчанию. Обычно это NULL или значение указанное при создании таблицы. Более подробно мы это рассмотрим далее.
Команду INSERT можно использовать для вставки результатов запроса. Чтобы сделать это, просто заменяем предложение VALUES на соответствующий запрос:
INSERT INTO MoscowStaff
SELECT *
FROM Salespeople
WHERE city = 'Москва'
Здесь выбираются все строки из таблицы "Торговые агенты" со значениями city = 'Москва' и помещаются в таблицу MoscowStaff. Чтобы это сработало таблица MoscowStaffдолжна отвечать следующим условиям:
* Она должна уже быть создана командой CREATE TABLE
* Она должна иметь четыре столбца, которые совпадают с таблицей торговых агентов в терминах типов данных.


Удаление строк из таблиц
Для удаления строк из таблицы используется команда DELETE. Она удаляет не отдельные значения, а строки целиком. Чтобы удалить все содержание таблицы агентов вы можете ввести команду:
DELETE FROM Salespeople
Но я пока не рекомендую Вам этого делать.
Обычно, Вам требуется удалять некоторые определенные строки в таблице. Чтобы определить какие строки будут удалены, используйте условие отбора, как мы это делали для запросов. Например, чтобы удалить агента Шилина можно ввести:
DELETE FROM Salespeople
WHERE snum = 1007
Разумеется, если условию будет соответствовать несколько записей, все они будут удалены.
В отличие от файловых СУБД типа DBASE, SQL Server не помечает записи как удаленные, а удаляет их физически, т.е. восстановлению они не подлежат. Будьте осторожны с командой DELETE!
Изменение значения поля
Команда UPDATE позволяет изменять некоторые или все значения в существующей записи в таблице. Эта команда содержит предложение UPDATE, за которым указывается имя таблицы, и предложение SET, которое указывает на изменение которое нужно сделать для определенного столбца. Например, чтобы изменить рейтинги всех заказчиков на 200 можно ввести команду:
UPDATE Customers
SET rating = 200
Аналогично DELETE, UPDATE может использовать условия для выбора записей, подлежащих изменению. Вот так можно изменить рейтинг для всех заказчиков агента Иванова (код 1001):
UPDATE Customers
SET rating = 300
WHERE snum = 1001
В предложении SET можно указывать несколько столбцов, разделяя их запятыми.

я вот что думаю без курсов и практики реал овладеть sql-ем?

главное выучить команды Select Insert Delete - для моей работы большего не требовалось.

Просто сказано, на деле не так всё просто.

По самому языку есть замечательная книга - Понимание SQL (Understanding SQL)