Содержание

1. Логическое проектирование базы данных............................................................................2

1.1. Анализ предметной области...............................................................................................2
1.2. Описание атрибутов.............................................................................................................2
1.3. Создание функциональных зависимостей для атрибутов.................................................3
1.4. Кодирование функциональных зависимостей...................................................................3
1.5. Получение схемы нормализованной базы данных методом синтеза..............................3
1.6. Расшифровка атрибутов....................................................................................................11
1.7. Описание связей между атрибутами................................................................................12
2. Создание базы данный в SQL-Server....................................................................................13
2.1. Создание новой базы данных в T-SQL...............................................................................13
2.2. Создание отношение в T-SQL.............................................................................................13
2.3. Создание ограничение целостности..................................................................................14
2.4. Создание внешних ключей................................................................................................14
2.5. Создание диаграммы БД...................................................................................................15
2.6. Заполнение картежей отношений БД...............................................................................15
2.7. Создание схем БД..............................................................................................................17
2.8. Создание пользователей...................................................................................................17
2.9. Создание представлений...................................................................................................17
2.10. Создание синонимов.......................................................................................................18
3. Создание запросов к базе данных.......................................................................................19
3.1. Запросы, реализующие операции реляционной алгебры...............................................19
3.2. Запросы, использующие функции агрегации...................................................................24
3.3. Создание запросов группировки.......................................................................................26
3.4. Подзапросы........................................................................................................................27
3.5. Создание запросов на актуализацию отношений………………………………………………......……28

3.6. Создание хранимых процедур..........................................................................................30

3.7. Создание триггеров............................................................................................................31
Заключение...............................................................................................................................32
1
 1. Логическое проектирование базы данных
На данном этапе мы делаем первые шаги к созданию базы данных. Несмотря на то,
что это первые шаги, они самые сложные в проектировании базы данных. Они состоят из
анализа предметной области, описания атрибутов, созданий функциональных зависимостей и
получение схемы базы данных. В данной курсовой работе будет использован метод синтеза
для получения схемы базы данных.

1.1. Анализ предметной области

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

1.2. Описание атрибутов

В таблице 1 приведены все атрибуты проектируемой базы данных.
Код Название атрибута Описание атрибута Тип данных
атрибута атрибута
A ID_несчастного_случая ID несчастного случая Int
B Начало_больничного Дата начала больничного Datetime
C Конец_больничного Дата окончания больничного Datetime
D Номер_больничного Номер больничного листа Int
G Номер_страховки Страховка сотрудника Int
H Код_уровня_серьезности Уровень серьезности случая Int
I Код_типа_несчастного_случа Код характеризующий Int
я несчастный случай
L Номер_отдела Номер отдела Int
M Количество_сотрудников Количество сотрудников в Int
отделе
N ФИО_Нач_Отдела ФИО начальника отдела Varchar(50)
O ID_сотрудника ID сотрудника Int

2
 P Дата_Рождения Дата рождения сотрудника Datetime
S Адрес Адрес проживания сотрудника Varchar(50)
T Количество_детей Количество детей сотрудника Int
U ФИО_сотрудника ФИО сотрудника Varchar(50)
V Должность Должность сотрудника Varchar(50)
W Оклад Оклад сотрудника Int

1.3. Создание функциональных зависимостей для атрибутов

Создадим функциональные зависимости используя их реальные имена:
F={
Номер_больничного-> ID_несчастного_случая, Начало_больничного,
Конец_больничного, Номер_страховки;
ID_несчастного_случая-> Код_уровня_серьезности, Код_типа_несчастного_случая;
Номер отдела->Количество_сотрудников, ФИО_Нач_Отдела;
ID_сотрудника->Дата_рождения, Адрес, Номер_страховки, Количество_детей;
ID_сотрудника-> ID_несчастного_случая;
ID_сотрудника-> Номер_отдела, ФИО_сотрудника, Должность, Оклад;
}

1.4. Кодирование функциональных зависимостей

В данном пункте происходит кодирование, созданных ранее функциональных
зависимостей, используя латинские заглавные буквы. В таблице 1 указано какая буква какому
атрибуту соответствует.
F={ D->ABCG, A->HI, L->MN, O->PSGT, O->A, O->LUVW}

1.5. Получение схемы нормализованной базы данных

методом синтеза
Для множества функциональных зависимостей
F={ D->ABCG, A->HI, L->MN, O->PSGT, O->A, O->LUVW}
построить схему базы данных в третьей нормальной форме (3NF).

Решение:
0) Приводим функциональные зависимости из F к виду X->A.

3
 F={D->A, D->B, D->C, D->G, A->H, A->I, L->M, L->N, O->P, O->S, O->G, O->T, O->A,
O->L, O->U, O->V, O->W}.
К множеству F добавляем функциональную зависимость вида R->A, где R=R1,..,Rm, A не
принадлежит R:
F={D->A, D->B, D->C, D->G, A->H, A->I, L->M, L->N, O->P, O->S, O->G, O->T, O->A,
O->L, O->U, O->V, O->W, DABCGHILMNOPSTLUVW ->Q}.

1) Строим не избыточное покрытие для множества Fc.

Проверяем каждую функциональную зависимость из Fc на избыточность:
D->A:
(D)+[F\D->A] = <D, DBCG >
A не является подмножеством (D)+, поэтому D->A неизбыточно в F.
D->B:
(D)+[F\D->B] = <D, DACG >
B не является подмножеством (D)+, поэтому D->B неизбыточно в F.
D->C:
(D)+[F\D->C] = <D, DABG >
C не является подмножеством (D)+, поэтому D->C неизбыточно в F.
D->G:
(D)+[F\D->G] = <D, DABC >
G не является подмножеством (D)+, поэтому D->G неизбыточно в F.

A->H:
(A)+[F\A->H] = <A, AI >
H не является подмножеством (A)+, поэтому A->H неизбыточно в F.
A->I:
(A)+[F\A->I] = <A, AH >
I не является подмножеством (A)+, поэтому A->I неизбыточно в F.
L->M:
(L)+[F\L->M] = <L, LN >
M не является подмножеством (L)+, поэтому L->M неизбыточно в F.
L->N:

4
 (L)+[F\L->N] = < L, LM >
N не является подмножеством (L)+, поэтому L->N неизбыточно в F.
O->P:
(O)+[F\O->P] = < O,OSGT >
P не является подмножеством (O)+, поэтому O->P неизбыточно в F.
O->S:
(O)+[F\O->S] = < O,OPGT >
S не является подмножеством (O)+, поэтому O->S неизбыточно в F.
O->G:
(O)+[F\O->G] = < O,OPST >
G не является подмножеством (O)+, поэтому O->G неизбыточно в F.
O->T:
(O)+[F\O->T] = < O,OPSG >
T не является подмножеством (O)+, поэтому O->T неизбыточно в F.
O->A:
(O)+[F\O->A] = <O, O>
A не является подмножеством (O)+, поэтому O->A неизбыточно в F.
O->L:
(O)+[F\O->L] = < O,OUVW>
L не является подмножеством (O)+, поэтому O->L неизбыточно в F.
O->U:
(O)+[F\O->U] = < O,OLVW,OLVWMN >
U не является подмножеством (O)+, поэтому O->U неизбыточно в F.
O->V:
(O)+[F\O->V] = < O,OLUW, OLUWMN >
V не является подмножеством (O)+, поэтому O->V неизбыточно в F.
O->W:
(O)+[F\O->W] = < O,OLUV, OLUVMN >
W не является подмножеством (O)+, поэтому O->W неизбыточно в F.
DABCGHILMNOPSTLUVW ->Q:
(DABCGHILMNOPSTLUVW)+[F\DABCGHILMNOPSTLUVW->Q]=
<DABCGHILMNOPSTLUVW>

5
 Q не является подмножеством (DABCGHILMNOPSTLUVW)+, поэтому
DABCGHILMNOPSTLUVW ->Q неизбыточно в F.
Полученное неизбыточное покрытие для множества Fc:
Fn={D->A, D->B, D->C, D->G, A->H, A->I, L->M, L->N, O->P, O->S, O->G, O->T, O-
>A, O->L, O->U, O->V, O->W, DABCGHILMNOPSTLUVW ->Q}.

2) Редуцируем слева множество Fn.

Проверяем на избыточность каждый атрибут из левой части (для каждой функциональной
зависимости из Fn):
DABCGHILMNOPSTLUVW ->Q:
(ABCGHILMNOPSTLUVW)+[F]=<ABCGHILMNOPSTLUVW,
DABCGHILMNOPSTLUVW, DABCGHILMNOPSTLUVWQ>
Q не является подмножеством (DABCGHILMNOPSTLUVW)+, поэтому D не
избыточно в F.

DABCGHILMNOPSTLUVW ->Q:
(DBCGHILMNOPSTLUVW)+[F]=<DBCGHILMNOPSTLUVW,
DBCGHILMNOPSTLUVWA, DBCGHILMNOPSTLUVWAQ>
Q является подмножеством (DBCGHILMNOPSTLUVW)+, поэтому A избыточно в F.

DBCGHILMNOPSTLUVW ->Q:
(DCGHILMNOPSTLUVW)+[F]=<DCGHILMNOPSTLUVW,
DCGHILMNOPSTLUVWAB, DCGHILMNOPSTLUVWABQ>
Q является подмножеством (DCGHILMNOPSTLUVW)+, поэтому B избыточно в F.

DCGHILMNOPSTLUVW ->Q:
(DGHILMNOPSTLUVW)+[F]=<DGHILMNOPSTLUVW,
DGHILMNOPSTLUVWABC, DGHILMNOPSTLUVWABCQ>
Q является подмножеством (DGHILMNOPSTLUVW)+, поэтому C избыточно в F.

DGHILMNOPSTLUVW ->Q:

6
 (DHILMNOPSTLUVW)+[F]=<DHILMNOPSTLUVW, DHILMNOPSTLUVWABCG,
DHILMNOPSTLUVWABCGQ>
Q является подмножеством (DHILMNOPSTLUVW)+, поэтому G избыточно в F.

DHILMNOPSTLUVW ->Q:
(DILMNOPSTLUVW)+[F]=<DILMNOPSTLUVW,DILMNOPSTLUVWABCGH,
DILMNOPSTLUVWABCGHQ>
Q является подмножеством (DILMNOPSTLUVW)+, поэтому H избыточно в F.

DILMNOPSTLUVW ->Q:
(DLMNOPSTLUVW)+[F]=<DLMNOPSTLUVW, DLMNOPSTLUVWABCGHI,
DLMNOPSTLUVWABCGHIQ>
Q является подмножеством (DLMNOPSTLUVW)+, поэтому I избыточно в F.

DLMNOPSTLUVW ->Q:
(DMNOPSTLUVW)+[F]=<DMNOPSTLUVW, DMNOPSTLUVWABCGHIL,
DMNOPSTLUVWABCGHILQ>
Q является подмножеством (DMNOPSTLUVW)+, поэтому L избыточно в F.

DMNOPSTLUVW ->Q:
(DNOPSTLUVW)+[F]=<DNOPSTLUVW, DNOPSTLUVWABCGHILM,
DNOPSTLUVWABCGHILMQ>
Q является подмножеством (DNOPSTLUVW)+, поэтому M избыточно в F.

DNOPSTLUVW ->Q:
(DOPSTLUVW)+[F]=<DOPSTLUVW, DOPSTLUVWABCGHILMN,
DOPSTLUVWABCGHILMNQ>
Q является подмножеством (DOPSTLUVW)+, поэтому N избыточно в F.

DOPSTLUVW ->Q:

7
 (DPSTLUVW)+[F]=<DPSTLUVW, DOPSTLUVWABCGHILMN,
DOPSTLUVWABCGHILMNQ>
Q не является подмножеством (DOPSTLUVW)+, поэтому O не избыточно в F.

DOPSTLUVW ->Q:
(DOSTLUVW)+[F]=<DOSTLUVW, DOSTLUVWABCGHILMNP,
DOSTLUVWABCGHILMNPQ>
Q является подмножеством (DOSTLUVW)+, поэтому P избыточно в F.

DOSTLUVW ->Q:
(DOTLUVW)+[F]=<DOTLUVW, DOTLUVWABCGHILMNPS,
DOTLUVWABCGHILMNPSQ>
Q является подмножеством (DOTLUVW)+, поэтому S избыточно в F.

DOTLUVW ->Q:
(DOLUVW)+[F]=<DOLUVW, DOTLUVWABCGHILMNPS,
DOTLUVWABCGHILMNPSQ>
Q является подмножеством (DOLUVW)+, поэтому T избыточно в F.

DOLUVW ->Q:
(DOUVW)+[F]=<DOUVW, DOLUVWABCGHILMNPST,
DOLUVWABCGHILMNPSTQ>
Q является подмножеством (DOUVW)+, поэтому L избыточно в F.

DOUVW ->Q:
(DOVW)+[F]=<DOVW, DOVWABCGHILMNPSTLU,
DOVWABCGHILMNPSTLUQ>
Q является подмножеством (DOVW)+, поэтому U избыточно в F.

DOVW ->Q:
(DOW)+[F]=<DOW, DOWABCGHILMNPSTLUV, DOWABCGHILMNPSTLUVQ>
Q является подмножеством (DOW)+, поэтому V избыточно в F.

8
DOW ->Q:
(DO)+[F]=<DO, DOABCGHILMNPSTLUVW, DOABCGHILMNPSTLUVWQ>
Q является подмножеством (DO)+, поэтому W избыточно в F.

Редуцированное слева покрытие для множества Fn:

Flr ={D->A, D->B, D->C, D->G, A->H, A->I, L->M, L->N, O->P, O->S, O->G, O->T, O-
>A, O->L, O->U, O->V, O->W, DO->Q}

3) Разбиваем множество Flr на классы эквивалентности Ef.

Для этого строим замыкания для всех детерминант из Flr:

D->A: (D)+=<D, DABCG>

D->B: (D)+=<D, DABCG >
D->C: (D)+=<D, DABCG >
D->G: (D)+=<D, DABCG >
A->H: (A)+=<A, AHI>
A->I: (A)+=<A, AHI>
L->M: (L)+=<L, LMN>
L->N: (L)+=<L, LMN>
O->P: (O)+=<O, OPSGT>
O->S: (O)+= <O, OPSGT>
O->G: (O)+= <O, OPSGT>
O->T: (O)+= <O, OPSGT>
O->A: (O)+= <O, OA, OAHI>
O->L: (O)+= <O, OLUVW, OLUVWMN>
O->U: (O)+= <O, OLUVW, OLUVWMN>
O->V: (O)+= <O, OLUVW, OLUVWMN>
O->W: (O)+= <O, OLUVW, OLUVWMN>

DO->Q: (DO)+=< DO, DOABCGHILMNPSTLUVW, DOABCGHILMNPSTLUVWQ >

9
Были обнаружены следующие эквивалентные детерминанты:
D<->D<->D<->D
A<->A
L<->L
O<->O<->O<->O<->O<->O<->O<->O<->O
Полученные классы эквивалентности:

F={ D->ABCG, A->HI, L->MN, O->PSGT, O->A, O->LUVW}

1) E(D)={ D->A, D->B, D->C, D->G }

2) E(A)={A->H, A->I }
3) E(L)={L->M, L->N }
4) E(O)={O->P, O->S, O->G, O->T, O->A, O->L, O->U, O->V, O->W}
5) E(DO)={DO->Q}

4) Строим дополнительное множество J в следующем порядке:

Изначально J=0. Для любых двух функциональных зависимостей из F с
детерминантами X и Y, где X<->Y, модифицирует: J:=JU{X->Y,Y->X}.
В результате получаем множество:
J = 0, так как в Flr не оказалось детерминантов удовлетворяющих условию.
Полученные классы эквивалентности:
1) E(D)={ D->A, D->B, D->C, D->G }
2) E(A)={A->H, A->I }
3) E(L)={L->M, L->N }
4) E(O)={O->P, O->S, O->G, O->T, O->A, O->L, O->U, O->V, O->W}
5) E(DO)={DO->Q}

5) Удаляем из F транзитивные зависимости.

Находится подмножество F1 из F, которое удовлетворяет
условию (F1 U J)+=(F U J)+ и нет собственного подмножества F1 не
удовлетворяющего этому условию. Для этого проверяем если F не содержит
избыточные зависимости.

10
Так как J пустое, F1 = F.
Полученное множество F1:
F1={
1) E(D)={ D->A, D->B, D->C, D->G }
2) E(A)={A->H, A->I }
3) E(L)={L->M, L->N }
4) E(O)={O->P, O->S, O->G, O->T, O->A, O->L, O->U, O->V, O->W}
5) E(DO)={DO->Q}
}.
6) Строим схемы R1,..,Rm.
Каждая схема Ri содержит атрибуты функциональных зависимостей
из i-того класса эквивалентности.
Из схемы R5 удаляем атрибут "Q".
Полученные схемы отношений в третьей нормальной форме (3FN):
R1=DABCG k1={D}
R2=AHI k2={A}
R3=LMN k3={L}
R4=OPSGTALUVW k4={O}
R5=DO k5={DO}
Синтезированная схема базы данных в третьей нормальной форме (3NF):
BD = {(DABCG,{D}),(AHI,{A}),(LMN,{L}),( OPSGTALUVW,{O}),(DO,{DO})}

1.6. Расшифровка атрибутов

Ниже представлена схема базы данных, полученная в пункте 1.5, но вместо
символьного (кодированного) представления, схема показана в настоящих атрибутах базы
данных.
BD={
F={
Больничные (Номер_больничного, ID_несчастного_случая, Начало_больничного,
Конец_больничного, Номер_страховки, K={Номер_больничного}),

Несчастные_случаи (ID_несчастного_случая, Код_уровня_серьезности,

Код_типа_несчастного_случая, K={ID_несчастного_случая}),
11
 Отделы (Номер отдела, Количество_сотрудников, ФИО_Нач_Отдела,K={ Номер
отдела }),

Персональные_данные (ID_сотрудника, Дата_рождения, Адрес, Номер_страховки,

Количество_детей, K={ ID_сотрудника }),

Сотрудник_несчастный_случай (ID_сотрудника, ID_несчастного_случая, K={

ID_сотрудника }),

Сотрудники (ID_сотрудника, Номер_отдела, ФИО_сотрудника, Должность, Оклад, K={

ID_сотрудника })

Отношение больничные содержит всю необходимую информацию о больничного

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

1.7. Описание связей между атрибутами

В данной базе данных присутствуют все типы связей, первая 1:1. Сотрудники и
персональные_данные. Была сделана такая связь, тк она является пояснительной, то есть,
одно отношение дополняет другое.
Второй тип связи один ко многим встречается часто, отделы и сотрудники,
персональные_данные и больничные, несчастные_случаи и сотрудник_несчастный_случай,
несчастные_случаи и больничные, сотрудники и сотрудник_несчастный_случай.
Третий тип связь многое ко многим образуется между атрибутами таблиц сотрудники
(ID_сотрудники) и несчастные_случаи (ID_несчастного_случая)

12
 2. Создание базы данный в SQL-Server
В данной главе будет происходить создание базы данных с помощью Microsoft SQL Server
Management Studio 18. Кроме создания базы данных, она будет заполнена, будут созданы
новые отношения, ограничения целостности, ключи, представления и синонимы.

2.1. Создание новой базы данных в T-SQL

Ниже приведённая команда создаёт новую базу данных.
--Удаление старой базы данных и создание новой
USE master
GO
IF EXISTS (SELECT 1
FROM sys.databases WHERE name = N'Acident')
BEGIN ALTER DATABASE [Acident]
SET SINGLE_USER
WITH ROLLBACK
IMMEDIATE DROP DATABASE [Acident]
END
GO
USE master
GO
IF NOT EXISTS (SELECT 1
FROM sys.databases WHERE name = N'Acident')
CREATE DATABASE [Acident];
GO
USE [Acident]
GO

2.2. Создание отношение в T-SQL

С помощью команды CREATE TABLE в БД были добавлены 6 отношений.
--создание отношений,таблиц
USE Acident
CREATE TABLE больничные
( ID_несчастного_случая int NOT NULL,
Начало_больничного datetime NOT NULL,
Конец_больничного datetime NOT NULL,
Номер_больничного int NOT NULL,
Номер_страховки int primary key NOT NULL
);

CREATE TABLE несчастные_случаи

( Код_уровня_серьзности int NOT NULL,
ID_несчастного_случая int primary key NOT NULL,
Код_типа_несчастного_случая int NOT NULL
);

CREATE TABLE отделы

( Номер_отдела int primary key NOT NULL,
Количество_сотрудников int NOT NULL,
ФИО_Нач_Отдела varchar(50) NOT NULL,

13
);

CREATE TABLE персональные_данные

( ID_сотрудника int primary key NOT NULL,
Дата_рождения datetime NOT NULL,
Адрес varchar (50) NOT NULL,
Номер_страховки int NOT NULL,
Количество_детей int NOT NULL
);

CREATE TABLE сотрудник_несчастный_случай

( ID_сотрудника int primary key NOT NULL,
ID_несчастного_случая int NOT NULL
);

CREATE TABLE сотрудники

( ID_сотрудника int primary key NOT NULL,
Номер_отдела int NOT NULL,
ФИО_сотрудника varchar(50) NOT NULL,
Должность varchar(50) NOT NULL,
Оклад int NOT NULL);

2.3. Создание ограничение целостности

Для отношений созданной БД были заданы следующие ограничения целостности:
-- создание ограничения целостности

USE Acident

ALTER TABLE dbo.сотрудник_несчастный_случай ADD CONSTRAINT D1 DEFAULT (0) for ID_сотрудника

ALTER TABLE dbo.несчастные_случаи ADD CONSTRAINT D2 DEFAULT (0) for ID_несчастного_случая
ALTER TABLE dbo.больничные ADD CONSTRAINT D3 DEFAULT (0) for Номер_больничного
ALTER TABLE dbo.персональные_данные ADD CONSTRAINT D4 DEFAULT (0) for Номер_страховки
ALTER TABLE dbo.сотрудники ADD CONSTRAINT D5 DEFAULT (0) for Оклад
ALTER TABLE dbo.отделы ADD CONSTRAINT D6 DEFAULT (0) for Количество_сотрудников

2.4. Создание внешних ключей

Для созданной базы данных были созданы внешние ключи для обеспечения
сохранения ограничений целостности. Для создания внешних ключей используются команды
ALTE TABLE и CONSTRAINT.
--Внешние ключи
GO
USE Acident
ALTER TABLE больничные
ADD CONSTRAINT FK_несчастные_случаи FOREIGN KEY (ID_несчастного_случая)
REFERENCES несчастные_случаи(ID_несчастного_случая)
GO
ALTER TABLE персональные_данные
ADD CONSTRAINT FK_больничные_персональн FOREIGN KEY (Номер_страховки)
REFERENCES больничные (Номер_страховки)

14
GO
ALTER TABLE персональные_данные
ADD CONSTRAINT FK_персонально FOREIGN KEY (ID_сотрудника)
REFERENCES сотрудники (ID_сотрудника)
GO
GO
ALTER TABLE сотрудники
ADD CONSTRAINT FK_сотрудники_случай FOREIGN KEY (ID_сотрудника)
REFERENCES сотрудник_несчастный_случай (ID_сотрудника)
GO
ALTER TABLE сотрудники
ADD CONSTRAINT FK_сотрудники FOREIGN KEY (Номер_отдела)
REFERENCES отделы(Номер_отдела)
GO
ALTER TABLE сотрудник_несчастный_случай
ADD CONSTRAINT FK_сотнес FOREIGN KEY (ID_несчастного_случая)
REFERENCES несчастные_случаи (ID_несчастного_случая)
GO

2.5. Создание диаграммы БД

На рисунке 2.1 представлена диаграмма БД с таблицами и со всеми внешними ключами.

Рис. 2.1

2.6. Заполнение картежей отношений БД

Каждая таблица была заполнена картежами для работы с ней.
--заполнение кортежей
USE Acident;
INSERT INTO несчастные_случаи
VALUES
(4,1,3),
(6,2,3),
(8,3,3),
(5,4,3),
(5,5,4),
(4,6,4),
15
(6,7,4),
(8,8,5),
(8,9,5),
(8,10,5)

INSERT INTO больничные

VALUES
(1,2019-02-12,2019-02-21,101,000001),
(2,2019-02-12,2019-03-03,102,000002),
(3,2019-04-12,2019-05-15,103,000003),
(4,2019-05-05,2019-06-21,104,000004),
(5,2019-10-04,2019-10-10,105,000005),
(6,2019-11-11,2019-11-05,106,000006),
(7,2019-12-12,2019-12-30,107,000007),
(8,2019-12-31,2020-01-07,108,000008),
(9,2020-01-03,2020-02-14,109,000009),
(10,2020-01-12,2020-01-28,110,000010)

INSERT INTO отделы

VALUES
(1,12,'Кочуг Виктор'),
(2,34,'Степанов Андрей'),
(3,34,'Данилюк Евгений'),
(4,65,'Обух Дмитрий'),
(5,76,'Сорокин Кирилл'),
(6,43,'Кравец Василий'),
(7,22,'Кара Юрий'),
(8,11,'Константин Райкович'),
(9,43,'Богдан Константин'),
(10,67,'Мущинский Дмитрий')

INSERT INTO сотрудник_несчастный_случай

VALUES
(11,1),
(12,2),
(13,3),
(14,4),
(15,5),
(16,6),
(17,7),
(18,8),
(19,9),
(20,10)

INSERT INTO сотрудники

VALUES
(11,1,'Кравец Виталий','Бригадир',6000),
(12,1,'Кушнир Артем','работник',5000),
(13,1,'Данилюк Олег','работник',5000),
(14,2,'Кочуг Иван','работник',5000),
(15,2,'Сорокин Матвей','работник',5000),
(16,2,'Пупкин Антон','работник',5000),
(17,3,'Шастун Александр','бухгалтер',7000),
(18,3,'Серый Андрей','директор',8000),
(19,4,'Сергей Иванов','водитель',6000),
(20,4,'Андрей Андреев','уборщик',4000)

INSERT INTO персональные_данные

VALUES
(11,2000-02-11,'Малиново 5', 000001,3),
16
(12,2000-04-13,'Малиново 6', 000002,2),
(13,1988-03-04,'Малиново 7', 000003,2),
(14,2000-04-14,'Щусева 5', 000004,1),
(15,1978-12-12,'Щусева 34', 000005,2),
(16,1978-08-11,'Штефан 15', 000006,2),
(17,1989-07-12,'Штефан 13', 000007,2),
(18,1967-03-12,'Колумна 22', 000008,3),
(19,1978-12-10,'Букурешть 10', 000009,1),
(20,1983-02-12,'Букурешть 25', 000010,1)

2.7. Создание схем БД

Были созданы 2 новые схемы, на которые были переведены два отношения
-- создание схемы
USE Acident
GO
CREATE SCHEMA firstshema;
GO
ALTER SCHEMA firstshema
TRANSFER dbo.несчастные_случаи;
GO
CREATE SCHEMA secondshema;
GO
ALTER SCHEMA secondshema
TRANSFER dbo.больничные;
GO

2.8. Создание пользователей

Для БД были созданы 2 пользователя и 2 логина, пользователю Log1 были
предоставлены права владельца БД, а пользователю Log2 лишь право на просматривание
всех данных.
-- Создание пользователей
CREATE LOGIN Log1 WITH PASSWORD = '1234';
CREATE USER Log1 FOR LOGIN Log1;
GO
CREATE LOGIN Log2 WITH PASSWORD = '1234';
CREATE USER Log2 FOR LOGIN Log2;
GO
EXEC sp_addrolemember 'db_owner', 'Log1';
EXEC sp_addrolemember 'db_denydatareader', 'Log1';

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

Было создано 2 представления. 1 Выводим информацию о несчастных случаях и ID
сотрудника с которым этот случай произошел.

17
--Создание представлений Было создано 2 представления. 1 Выводим информацию о
--несчастных случаях и ID сотрудника с которым этот случай произошел.
CREATE VIEW Nesciastie AS
SELECT a. [Код_уровня_серьзности], a. [ID_несчастного_случая], a.
[Код_типа_несчастного_случая], b. [ID_сотрудника]
FROM firstshema.несчастные_случаи a inner join dbo.сотрудник_несчастный_случай b
ON a.[ID_несчастного_случая] = b.[ID_несчастного_случая]
WITH CHECK OPTION
GO
SELECT* from Nesciastie

2 Выводим информацию о отделах по фамилиям начальников отделов.

-- 2 Выводим информацию о отделах по фамилиям начальников отделов.
GO
CREATE VIEW Отделения
AS
SELECT [Номер_отдела],[ФИО_Нач_Отдела], [Количество_сотрудников]
FROM dbo.отделы
WHERE [ФИО_Нач_Отдела] IN ('Кочуг Виктор','Данилюк Евгений')
GO

2.10. Создание синонимов

Были созданы синонимы облегчающие обращение к отношениям отделы, сотрудники
и больничные:
USE Acident
GO
CREATE SYNONYM О
FOR отделы;
CREATE SYNONYM С
FOR сотрудники;
CREATE SYNONYM Б
FOR больничные;

18
 3. Создание запросов к базе данных

3.1. Запросы, реализующие операции реляционной алгебры

1) В данном запросе мы используем операцию объединения двух групп
кортежей из одного и того же отношения персональные данные (первое это адрес
Малиново 7 и кол-во детей равное 2, второе адрес Щусева 5 и кол-во детей равное 1)
(Рис.3.1).

SELECT * FROM персональные_данные

WHERE Адрес = 'Малиново 7' AND Количество_детей = 2
UNION
SELECT * FROM персональные_данные
WHERE Адрес = 'Щусева 5' AND Количество_детей = 1

Рис.3.1
2) В данном запросе мы делаем пересечение отношений сотрудники и отделы
по Номеру отдела. (Показываем отделы в которых работают сотрудники. Они
работают в 1-4, 5-10 пока существуют лишь на бумаге) (Рис.3.2).
select [Номер_отдела]
from сотрудник
intersect
select [Номер_отдела]
from отделы
order by [Номер_отдела]

19
 Рис.3.2

3) В этом запросе из таблицы сотрудники мы выводим сотрудников всех отделов, за

исключением 4 отдела (Рис.3.3).
SELECT * FROM сотрудники
EXCEPT
SELECT * FROM сотрудники
WHERE Номер_отдела = 4

Рис.3.3

20
4) Данный запрос делает декартово произведение отношении отделы и сотрудники (Рис.3.4).
select отделы.*, сотрудники.[ID_сотрудника], сотрудники.[номер_отдела] as Сотрудник,
сотрудники.[Должность]
from отделы, сотрудники
order by [Оклад]

Рис.3.4

5) В данном запросе происходит тета-соединение с выводом стандартной и полной

информации о сотрудниках в отделах. (Полная информация из таблицы
сотрудник_несчастный_случай и информация об окладе из таблицы сотрудники, связь по
кортежу ID сотрудника) (Рис.3.5)
select сотрудник_несчастный_случай.*, сотрудники.[ID_сотрудника] as CountID, сотрудники.
[Оклад]

from сотрудник_несчастный_случай,сотрудники
where сотрудник_несчастный_случай.[ID_сотрудника] = сотрудники.[ID_сотрудника]
order by [ID_сотрудника]

Рис.3.5

21
6) В данном запросе выполняется Внешнее соединение. Вывод ID сотрудников и ID их
несчастных случаев и номера отделов где они работают. (Рис.3.6):

SELECT сотрудники.[Номер_отдела], сотрудник_несчастный_случай.[ID_несчастного_случая],

сотрудник_несчастный_случай.[ID_сотрудника]
FROM сотрудники FULL OUTER JOIN сотрудник_несчастный_случай
ON сотрудники.[ID_сотрудника] = сотрудник_несчастный_случай.[ID_сотрудника]
ORDER BY [ID_сотрудника]

Рис.3.6

7) В данном запросе производится экви-соединение двух отношений персональные

данные и сотрудники при условии, что ID сотрудника совпадает, делаем сортировку по кол-
ву детей (Рис.3.7):

select персональные_данные.*, [сотрудники].*

from персональные_данные,[сотрудники]
where персональные_данные.[ID_сотрудника] = [сотрудники].[ID_сотрудника]
order by [Количество_детей]

Рис.3.7

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

select сотрудники.*
from сотрудники,[отделы]
where сотрудники.[Номер_отдела] = [отделы].[Номер_отдела]
order by [Номер_отдела]

Рис.3.8

9) В данном запросе мы производим деление проекции атрибутов ID сотрудников и

номер отдела на сотрудники на проекцию делитель с атрибутом номер отдела. (Вывод ID
сотрудников и номера их отдела, за исключение отделов 3 и 4) (Рис.3.9):

CREATE TABLE делитель

(Номер_отдела int primary key NOT NULL );
INSERT INTO делитель
VALUES
(3),
(4)
SELECT DISTINCT сотрудники.[ID_сотрудника], сотрудники.[Номер_отдела]
FROM сотрудники
WHERE NOT EXISTS (SELECT *
FROM делитель AS Отделы
WHERE NOT EXISTS (SELECT *
FROM сотрудники AS Сотрудники_отдела
WHERE Сотрудники_отдела.[Номер_отдела] = сотрудники.[Номер_отдела] AND
Сотрудники_отдела.[Номер_отдела] != Отделы.[Номер_отдела]))

23
 Рис.3.9

3.2. Запросы, использующие функции агрегации

1) В данном запросе выводится минимальное значение оклада сотрудников (Рис.3.10):
USE Acident
SELECT MIN (Оклад)
FROM сотрудники

Рис. 3.10

2) В данном запросе выводится максимальное значение оклада сотрудников (Рис.3.11):

USE Acident
SELECT MAX (Оклад)
FROM сотрудники

24
 Рис. 3.11

3) В данном запросе выводится среднее значение оклада сотрудников (Рис.3.12):

USE Acident
SELECT AVG (Оклад)
FROM сотрудники

Рис. 3.12

4) В данном запросе выводится сумма значений оклада сотрудников (Рис.3.13):

USE Acident
SELECT SUM (Оклад)
FROM сотрудники

Рис. 3.13

5) В данном запросе выводится количество кортежей из отношения сотрудники

(Рис.3.14):
USE Acident
SELECT COUNT (Оклад)
FROM сотрудники

25
 Рис. 3.14

3.3. Создание запросов группировки

1) Получить средний оклад по отделам (Рис. 3.14.1)
SELECT Номер_отдела, AVG(Оклад) AS Оклад
FROM сотрудники
GROUP BY сотрудники.Номер_отдела

Рис. 3.14.1

2) Получить самый большой оклад по отделам (Рис. 3.14.2)

SELECT Номер_отдела, MAX(Оклад) AS Оклад
FROM сотрудники
GROUP BY сотрудники.Номер_отдела

26
 Рис. 3.14.2

3.4. Подзапросы
1) В данном коррелированном запросе мы получаем список информации о
персональных данных сотрудников, если если они работают во 2 отделе (Рис.3.15):
SELECT *
FROM персональные_данные
WHERE EXISTS (SELECT 1
FROM сотрудники
WHERE сотрудники.ID_сотрудника = персональные_данные.ID_сотрудника AND
сотрудники.Номер_отдела = 2
);

Рис. 3.15

2) В этом запросе выводим всю информацию о больничном сотрудника если ID

несчастного случая из отношения больничные равен 8 и код уровня серьезности равен 10 из
отношения несчастные случаи. (Рис. 3.16).

USE [Acident]
SELECT *
FROM secondshema.больничные
WHERE [ID_несчастного_случая] IN ((SELECT [ID_несчастного_случая] FROM
firstshema.несчастные_случаи WHERE [Код_уровня_серьзности] = '10'),8 )

27
 Рис. 3.16

3) В данном запросе мы выводим ID сотрудников чей оклад меньше среднего из

отношения сотрудники (Рис.3.17):
SELECT ID_сотрудника
FROM сотрудники
WHERE Оклад < ANY (SELECT AVG (Оклад)
FROM сотрудники);

Рис. 3.17

3.5. Создание запросов на актуализацию отношений

1) В данном запросе в таблицу несчастные случаи был добавлен один кортеж, после
чего вся таблица была выведена на экран (Рис. 3.18).
INSERT INTO firstshema.несчастные_случаи
VALUES (4,11,3)
SELECT * From firstshema.несчастные_случаи

28
 Рис.3.18

2) В данном случае в таблицу несчастные случаи были добавлены несколько

кортежей, после чего вся таблица была выведена на экран (Рис.3.19).
INSERT INTO firstshema.несчастные_случаи
VALUES
(6,12,3),
(8,13,3),
(5,14,3),
(5,15,4)
SELECT * FROM firstshema.несчастные_случаи

Рис.3.19

29
 3.6. Создание хранимых процедур
1) В данном запросе мы создаём хранимую процедуру, которая обновляет
информацию в таблице отделы.(Рис 3.20)
GO
USE Acident
GO
CREATE PROCEDURE NEWOD (@NOD INT,@KOL INT,@FIO VARCHAR(50))
AS
BEGIN
BEGIN TRY
INSERT INTO отделы
VALUES (@NOD,@KOL,@FIO)
END TRY
BEGIN CATCH
PRINT 'Ошибка при выполнении процедуры!'
RETURN -1
END CATCH
END
EXECUTE NEWOD 100,200,'Горыныч'

Рис. 3.20
2) В данном запросе мы сперва создаём новую процедуру, которая просто выводит
нам ФИО сотрудников которые занимают должность работника. Так же запускаем данную
процедуру: (Рис.3.21)
GO
USE Acident
GO
CREATE PROCEDURE simpleSelect
AS
BEGIN
SELECT сотрудники.ФИО_сотрудника, сотрудники.Должность
FROM сотрудники
WHERE сотрудники.Должность LIKE 'работник';
30
END;
GO
EXEC simpleSelect

Рис. 3.21

3.7. Создание триггеров

1) В данном запросе мы создаём триггер, который при добавлении нового кортежа
в отношение «отделы» автоматически выводит информацию о том что данные были
добавлены, дата добавления и сами новые данные. (Рис.3.22)

GO
USE Acident
GO
CREATE TRIGGER Change
ON отделы
AFTER INSERT
AS
DECLARE @nod DATETIME
SET @nod = getdate()
BEGIN TRY
SELECT 'INSERTED ROW', @nod, inserted.[Номер_отдела], inserted.[Количество_сотрудников],
inserted.[ФИО_Нач_Отдела]
FROM INSERTED
END TRY
BEGIN CATCH
PRINT 'Error!'
ROLLBACK TRANSACTION
END CATCH
INSERT INTO отделы VALUES (50,50,'Воронин')

Рис. 3.22

31
 Заключение
В результате проведения данной курсовой работы было изучено большое количество
информации о создании и управлении базами данных. В первую очередь база данных была
спроектирована. Для неё создали конечное множество атрибутов, задали множество
функциональных зависимостей, после чего применяя метод синтеза была получена схема БД
в третей нормальной форме.
После проектирования начался этап создания БД. Данная БД была реализована с
помощью Microsoft SQL Server Management Studio 18 c использованием языка T-SQL. После
создания всех отношений были созданы первичные и внешние ключи, ограничения
целостности различного рода.
Последним этапом создания БД было заполнение таблиц картежами. После того как
БД была создана можно приступать к активному её использованию, для этого было
придумано большое количество простых и сложных запросов к базе дынных. Также были
созданы пользователи, логины, процедуры, представлений и синонимов.

32