Sunteți pe pagina 1din 37

Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei


Departamentul Inginerie, Software și Automatică

Proiect de curs
Disciplina: Baze de date și cunoștiințe

Efectuat de: st.gr.TI-152 Crivenco Vladislav

Controlat de: lector universitar Saranciuc Dorian

Chișinău 2018
1. Proiectarea logică a bazei de date

Analiza domeniului
Am creat baza de date pentu un magazin de tehnică online. Aceasta conține informații despre
produse și comenzile efectuate. La procurarea unui produs clintul trebuie să introducă datele sale
personale conform buletinului de identitate. Fiecare comandă, produs și client va fi nominalizată
după ID.

1.1 Descrierea Atributelor Descrierea atributelor:

A ProductId
B OrderId
C CustomerId
D EmployeeId
E ProductName
F UnintInStock
G Price
H Quantity
I Name
J Address
K City
L Country
M Phone
N ZipCode
O OrderDate
P LastName
R FirstName
S Title
T BirthDate
U Salary

1.2 Stabilirea depedențelor funcționale între atribute:

Mulțimea de dependențe funcționale F

F={
ProductId->ProductName, UnitInStock, Price

CustomerId->Name, Address, City, Country, Phone, ZipCode

OrderId, ProductId-> Quantity

EmployeeId->LastName, FirstName, Title, BirthDate, Salary,

OrderId->CustomerId, OrderDate, EmployeeId

1.3 Stabilirea depedențelor funcționale între atribute

F={

A->EFG
C->IJKLMN
AB -> H
D-> PRSTU
B->COD
}

1.4Sinteza schemei bazei de date


Aducerea dependețelor la forma X->A:

F={

A->E
A->F
A->G
C->I
C->J
C->K
C->L
C->M
C->N
AB->H
D->P
D->R
D->S
D->T
D->U
B->C
B->O
B->D
}

Se adaugă în mulțimea de dependențe funcționale dependența de forma R -> Q, unde R este


universul bazei de date, iar Q nu îi aparține lui R.

F={
A->E
A->F
A->G
C->I
C->J
C->K
C->L
C->M
C->N
AB->H
D->P
D->R
D->S
D->T
D->U
B->C
B->O
B->D
ABCDEFGHIJKLMNOPRSTU->Q
}

Se construiește acoperirea neredundantă pentru F:

A->E:
(A)+[F\A->E] = <A,AFG> E nu este submulțime a lui (A)+, de aceea A->E nu este redundantă în F
A->F
(A)+[F\A->F] = <A,AEG> F nu este submulțime a lui (A)+, de aceea A->F nu este redundantă în F
A->G
(A)+[F\A->G] = <A,AEF> G nu este submulțime a lui (A)+, de aceea A->G nu este redundantă în F
C->I
(C)+[F\C->I] = <C,CJKLMN> I nu este submulțime a lui (C)+, de aceea C->I nu este redundantă în
F
C->J
(C)+[F\C->J] = <C,CIKLMN> J nu este submulțime a lui (C)+, de aceea C->J nu este redundantă în
F

C->K
(C)+[F\C->K] = <C,CIJLMN> I nu este submulțime a lui (C)+, de aceea C->K nu este redundantă
în F

C->L
(C)+[F\C->L] = <C,CIJKMN> L nu este submulțime a lui (C)+, de aceea C->L nu este redundantă
în F
C->M
(C)+[F\C->I] = <C,CIJKLN> M nu este submulțime a lui (C)+, de aceea C->M nu este redundantă
în F
C->N
(C)+[F\C->N] = <C,CIJKLM> N nu este submulțime a lui (C)+, de aceea C->N nu este redundantă
în F
AB->H
(AB)+[F\AB->H] = <AB, ABEFGCOD> H nu este submulțime a lui (AB)+, de aceea AB->H nu
este redundantă în F
D->P
(D)+[F\D->P] = <D,DRSTU > P nu este submulțime a lui (D)+, de aceea D->P nu este redundantă
în F
D->R
(D)+[F\D->R] = <D,DPSTU > R nu este submulțime a lui (D)+, de aceea D->R nu este redundantă
în F
D->S
(D)+[F\D->S] = <D,DPRTU > S nu este submulțime a lui (D)+, de aceea D->S nu este redundantă
în F
D->T
(D)+[F\D->T] = <D,DPRSU > T nu este submulțime a lui (D)+, de aceea D->T nu este redundantă
în F
D->U
(D)+[F\D->U] = <D,DPRST > U nu este submulțime a lui (D)+, de aceea D->U nu este redundantă
în F
B->C
(B)+[F\B->C] = <B,BOD,BODPRSTU > C nu este submulțime a lui (B)+, de aceea B->C nu este
redundantă în F
B->O
(B)+[F\B->O] = <B,BCD,BCDIJKLMNPRSTU > O nu este submulțime a lui (B)+, de aceea B->O
nu este redundantă în F
B->D
(B)+[F\B->D] = <B,BCO,BCOIJKLMN> B nu este submulțime a lui (B)+, de aceea B->D nu este
redundantă în F

ABCDEFGHIJKLMNOPRSTU ->Q
(ABCDEFGHIJKLMNOPRSTU)+[F\ ABCDEFGHIJKLMNOPRSTU ->Q] = < ABCDEFGHIJKLMNOPRSTU> Q nu
este submulțime a lui (ABCDEFGHIJKLMNOPRSTU)+, de aceea ABCDEFGHIJKLMNOPRSTU ->Q nu este
redundantă în F

Fn = {
A->E
A->F
A->G
C->I
C->J
C->K
C->L
C->M
C->N
AB->H
D->P
D->R
D->S
D->T
D->U
B->C
B->O
B->D
ABCDEFGHIJKLMNOPRSTU->Q
}

Se trece mulțimea de dependențe funcționale prin algoritmul reducerii la stânga:

AB->H
(B)+[F]=<B, BCOD, BCODIJKLMNPRSTU> H nu este o submulțime a lui (B), de aceea A nu este
redundantă în F

ABCDEFGHIJKLMNOPRSTU ->Q
(BCDEFGHIJKLMNOPRSTU)+[F] =<BCDEFGHIJKLMNOPRSTU> Q nu este o submulțime a
lui (ABCDEFGHIJKLMNOPRSTU), de aceea A nu este redundantă în F

ABCDEFGHIJKLMNOPRSTU ->Q
(ACDEFGHIJKLMNOPRSTU)+[F] =< ACDEFGHIJKLMNOPRSTU> Q nu este o submulțime a
lui (ACDEFGHIJKLMNOPRSTU), de aceea B nu este redundantă în F

ABCDEFGHIJKLMNOPRSTU ->Q
(ABDEFGHIJKLMNOPRSTU)+[F] =< ABDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU , ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a
lui (ABDEFGHIJKLMNOPRSTU), de aceea C este redundantă în F

ABDEFGHIJKLMNOPRSTU ->Q
(ABEFGHIJKLMNOPRSTU)+[F] =< ABEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABEFGHIJKLMNOPRSTU), de aceea D este redundantă în F

ABEFGHIJKLMNOPRSTU ->Q
(ABFGHIJKLMNOPRSTU)+[F] =< ABFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABFGHIJKLMNOPRSTU), de aceea E este redundantă în F

ABFGHIJKLMNOPRSTU ->Q
(ABGHIJKLMNOPRSTU)+[F] =< ABGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABGHIJKLMNOPRSTU), de aceea F este redundantă în F

ABGHIJKLMNOPRSTU ->Q
(ABHIJKLMNOPRSTU)+[F] =< ABHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABHIJKLMNOPRSTU), de
aceea G este redundantă în F

ABHIJKLMNOPRSTU ->Q
(ABIJKLMNOPRSTU)+[F] =< ABIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABIJKLMNOPRSTU), de
aceea H este redundantă în F

ABIJKLMNOPRSTU ->Q
(ABJKLMNOPRSTU)+[F] =< ABJKLMNOPRSTU, ABCDEFGHJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABJKLMNOPRSTU), de aceea I este redundantă în F

ABJKLMNOPRSTU ->Q
(ABKLMNOPRSTU)+[F] =< ABKLMNOPRSTU, ABCDEFGHKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABKLMNOPRSTU), de aceea J este redundantă în F

ABKLMNOPRSTU ->Q
(ABLMNOPRSTU)+[F] =< ABLMNOPRSTU, ABCDEFGHLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABLMNOPRSTU), de aceea K este redundantă în F

ABLMNOPRSTU ->Q
(ABMNOPRSTU)+[F] =< ABMNOPRSTU, ABCDEFGHMNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABMNOPRSTU), de aceea L este redundantă în F

ABMNOPRSTU ->Q
(ABNOPRSTU)+[F] =< ABNOPRSTU, ABCDEFGHNOPRSTU,
ABCDEFGHIJKLMNOPRSTU, ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui
(ABNOPRSTU), de aceea M este redundantă în F

ABNOPRSTU ->Q
(ABOPRSTU)+[F] =< ABOPRSTU, ABCDEFGHOPRSTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABOPRSTU), de aceea N este
redundantă în F

ABOPRSTU ->Q
(ABPRSTU)+[F] =< ABPRSTU, ABCDEFGHOPRSTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABPRSTU), de aceea O este
redundantă în F

ABPRSTU ->Q
(ABRSTU)+[F] =< ABRSTU, ABCDEFGHORSTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABRSTU), de aceea P este
redundantă în F
ABRSTU ->Q
(ABSTU)+[F] =< ABSTU, ABCDEFGHOSTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABSTU), de aceea R este
redundantă în F

ABSTU ->Q
(ABTU)+[F] =< ABTU, ABCDEFGHOTU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABTU), de aceea S este
redundantă în F

ABTU ->Q
(ABU)+[F] =< ABU, ABCDEFGHOU, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (ABU), de aceea T este
redundantă în F

ABU ->Q
(AB)+[F] =< AB, ABCDEFGOH, ABCDEFGHIJKLMNOPRSTU,
ABCDEFGHIJKLMNOPRSTUQ> Q este o submulțime a lui (AB), de aceea U este
redundantă în F

Flr = {
A->E
A->F
A->G
C->I
C->J
C->K
C->L
C->M
C->N
AB->H
D->P
D->R
D->S
D->T
D->U
B->C
B->O
B->D
AB->Q
}

Formăm clase de echivalențe pentru mulțimea Flr:

A->E:
(A)+ = <A,AEFG>
A->F
(A)+ = <A,AEFG>
A->G
(A)+= <A,AEFG>
C->I
(C)+= <C,CIJKLMN>
C->J
(C)+= <C,CIKLMNJ>
C->K
(C)+= <C,CIJLMNK>
C->L
(C)+= <C,CIJKMNL>
C->M
(C)+= <C,CIJKLNM>
C->N
(C)+= <C,CIJKLMN>
AB->H
(AB)+ = <AB,ABHEFGCOD, ABHEFGCODPRSTUIJKLMNQ>
D->P
(D)+= <D,DPRSTU>
D->R
(D)+= <D, DPRSTU >
D->S
(D)+ = <D, DPRSTU >
D->T
(D)+ = <D, DPRSTU >
D->U
(D)+ = <D, DPRSTU >
B->C
(B)+= <B, BCOD, BCODIJKLMNPRSTU >
B->O
(B)+ = <B, BCOD, BCODIJKLMNPRSTU >
B->D
(B)+ = < B, BCOD, BCODIJKLMNPRSTU >
AB->Q
(AB)+=<AB,ABHEFGCODQ,ABHEFGCODQIJKLMNPRSTU >

Avem utmatoarele clase de echivalenta


1. E(A)={A->E, A->F, A->G}
2. E(C)={ C->I,C->J,C->K,C->L,C->M,C->N}
3. E(AB)={AB->H, AB->Q}
4. E(D)={ D->P,D->R,D->S,D->T,D->U}
5. E(B)={ B->C,B->O,B->D}

Construim mulțimea J din F, cu determinanții X și Y, unde X<->Y schimbă mulțimea


J=J U {X->Y, Y->X}
În rezultat avem:

J={
1) {}
2) {}
3) {}
4) {}
5) {}
}

Pentru oricare A din Y, dacă X->A se află în F, atunci F=F\{X->A}


Clase de echivalență primite:
1. E(A)={A->E, A->F, A->G}
2. E(C)={ C->I,C->J,C->K,C->L,C->M,C->N}
3. E(AB)={AB->H, AB->Q}
4. E(D)={ D->P,D->R,D->S,D->T,D->U}
5. E(B)={ B->C,B->O,B->D}

Ștergem din F dependențele transitive

A->E:
(A)+[(F\A->E) UJ] = <A,AFG> E nu este submulțime a lui (A)+, de aceea A->E nu este redundantă
în F
A->F
(A)+[(F\A->F) UJ] = <A,AEG> F nu este submulțime a lui (A)+, de aceea A->F nu este redundantă
în F
A->G
(A)+[(F\A->G) UJ] = <A,AEF> G nu este submulțime a lui (A)+, de aceea A->G nu este redundantă
în F
C->I
(C)+[(F\C->I) UJ] = <C,CJKLMN> I nu este submulțime a lui (C)+, de aceea C->I nu este
redundantă în F
C->J
(C)+[(F\C->J) UJ] = <C,CIKLMN> J nu este submulțime a lui (C)+, de aceea C->J nu este
redundantă în F

C->K
(C)+[(F\C->K) UJ] = <C,CIJLMN> I nu este submulțime a lui (C)+, de aceea C->K nu este
redundantă în F

C->L
(C)+[(F\C->L) UJ] = <C,CIJKMN> L nu este submulțime a lui (C)+, de aceea C->L nu este
redundantă în F
C->M
(C)+[(F\C->I) UJ] = <C,CIJKLN> M nu este submulțime a lui (C)+, de aceea C->M nu este
redundantă în F
C->N
(C)+[(F\C->N) UJ] = <C,CIJKLM> N nu este submulțime a lui (C)+, de aceea C->N nu este
redundantă în F
AB->H
(AB)+[(F\AB->H) UJ] = <AB, ABEFGCODQ> H nu este submulțime a lui (AB)+, de aceea AB->H
nu este redundantă în F
D->P
(D)+[(F\D->P) UJ] = <D,DRSTU > P nu este submulțime a lui (D)+, de aceea D->P nu este
redundantă în F
D->R
(D)+[(F\D->R) UJ] = <D,DPSTU > R nu este submulțime a lui (D)+, de aceea D->R nu este
redundantă în F
D->S
(D)+[(F\D->S) UJ] = <D,DPRTU > S nu este submulțime a lui (D)+, de aceea D->S nu este
redundantă în F
D->T
(D)+[(F\D->T) UJ] = <D,DPRSU > T nu este submulțime a lui (D)+, de aceea D->T nu este
redundantă în F
D->U
(D)+[(F\D->U) UJ] = <D,DPRST > U nu este submulțime a lui (D)+, de aceea D->U nu este
redundantă în F
B->C
(B)+[(F\B->C) UJ] = <B,BOD,BODPRSTU > C nu este submulțime a lui (B)+, de aceea B->C nu
este redundantă în F
B->O
(B)+[(F\B->O) UJ] = <B,BCD,BCDIJKLMNPRSTU > O nu este submulțime a lui (B)+, de aceea
B->O nu este redundantă în F
B->D
(B)+[(F\B->D) UJ] = <B,BCO,BCOIJKLMN> B nu este submulțime a lui (B)+, de aceea B->D nu
este redundantă în F
AB->Q
(AB)+[(F\AB->Q) UJ] = <AB, ABEFGCODH> Q nu este submulțime a lui (AB)+, de aceea AB->Q
nu este redundantă în F

Avem mulțimea F1
F1={
1. E(A)={A->E, A->F, A->G}
2. E(C)={ C->I,C->J,C->K,C->L,C->M,C->N}
3. E(AB)={AB->H, AB->Q}
4. E(D)={ D->P,D->R,D->S,D->T,D->U}
5. E(B)={ B->C,B->O,B->D}
}
Nu avem dependențe în mulțimea J, deci vom crea mulțimea G care va fi egală cu F1
G={
1. E(A)={A->E, A->F, A->G}
2. E(C)={ C->I,C->J,C->K,C->L,C->M,C->N}
3. E(AB)={AB->H, AB->Q}
4. E(D)={ D->P,D->R,D->S,D->T,D->U}
5. E(B)={ B->C,B->O,B->D}
}

Construim schemele bazei de date, din R5 eliminăm Q

1) R1=AEFG k1={A}
2) R2=CIJKLMN k2={C}
3) R3=ABH k3={AB}
4) R4=DPRSTU k4={D}
5) R5=BCOD k5={B}

Baza de date sintetizată în 3FN:


DB={(AEFG,{A}), (CIJKLMN, {C}), (ABH, {AB}), (DPRSTU, {D}), (BCOD, {D})}

Decodificarea atributelor
DB={
(Products(ProductId, ProductName, UnitsInStock,Price), K={ProductId}),
(Customers(CustomerId, Name, Address, City, Country, Phone,ZipCode), K={CustomerId}),
(OrderDetail(ProductId, OrderdId,Quantity, {ProductId,OrderId}),
(Employees(EmployeeId, LastName,FirstName, Title, BirthDate, Salary {EmployeeId}),
(Order(OrderId, CustomerId, OrderDate, EmployeeId, {OrderId})
}

Descrierea asocierilor între relații


Nume Primul Tabel Tip Relație Nume al Doilea Tabel
Employees 1:m Order
Customer 1:n Order
Order 1:1 OrderDetail
OrderDetail 1:1 Products

Ordinea în care pot fi înserate tuplurile în relaţiile BD va fi următoarea:


a) Product
b) ProductDescription
c) Emplyees
d) Customers
e) Order
f) OrderDetail

2. Implimentarea bazei de date în SQL

Crearea bazei de date noi în T-SQL


1. USE master
2. IF EXISTS(select * from sys.databases where name='Mag')
3. DROP DATABASE Mag
4.
5. CREATE DATABASE [Mag]
6. ON PRIMARY
7. (NAME = N'Mag',
8. FILENAME = N'E:\Program Files\MSSQL12.MSSQLSERVER\MSSQL\DATA\Mag.mdf' ,
9. SIZE = 5120KB ,
10. MAXSIZE = UNLIMITED,
11. FILEGROWTH = 1024KB )
12. LOG ON
13. (NAME = N'Mag_log',
14. FILENAME = N'E:\Program Files\MSSQL12.MSSQLSERVER\MSSQL\DATA\Mag.ldf' ,
15. SIZE = 2304KB ,
16. MAXSIZE = 2048GB ,
17. FILEGROWTH = 10%)
Figura 1. Crearea bazei de date Mag

Crearea relațiilor și constrîngerilor de integritate


1. use Mag
2.
3. IF OBJECT_ID('ProductDescription', 'U') IS NOT NULL
4. DROP TABLE ProductDescription
5. CREATE TABLE ProductDescription(
6. ProductID int NOT NULL,
7. Description varchar(50) NULL,
8. PRIMARY KEY (ProductID))
9.
10. IF OBJECT_ID('Customers', 'U') IS NOT NULL
11. DROP TABLE Customers
12. CREATE TABLE Customers(
13. CustomerID varchar(25) NOT NULL,
14. Name varchar(50) NOT NULL,
15. Address varchar(50) NOT NULL,
16. City varchar(50) NOT NULL,
17. Country varchar(50) NOT NULL,
18. Phone varchar(50) NOT NULL,
19. ZipCode varchar(10) NOT NULL,
20. PRIMARY KEY(CustomerID))
21.
22.
23. IF OBJECT_ID('Employees', 'U') IS NOT NULL
24. DROP TABLE Employees
25. CREATE TABLE Employees(
26. EmployeeID int NOT NULL,
27. LastName varchar(50) NOT NULL,
28. FirstName varchar(50) NOT NULL,
29. Title varchar(50) NOT NULL,
30. BirthDate varchar(50) NOT NULL,
31. Salary int NOT NULL,
32. PRIMARY KEY(EmployeeID))
33.
34. IF OBJECT_ID('Order', 'U') IS NOT NULL
35. DROP TABLE [Order]
36. CREATE TABLE [Order](
37. OrderID int NOT NULL,
38. CustomerID varchar(25) NOT NULL,
39. OrderDate date NOT NULL,
40. EmployeeID int NOT NULL,
41. PRIMARY KEY (OrderID))
42.
43. IF OBJECT_ID('OrderDetail', 'U') IS NOT NULL
44. DROP TABLE OrderDetail
45. CREATE TABLE OrderDetail(
46. OrderID int NOT NULL,
47. ProductID int NOT NULL,
48. Quantity int NOT NULL,
49. PRIMARY KEY(OrderID, ProductID))
50.
51.
52. IF OBJECT_ID('Products', 'U') IS NOT NULL
53. DROP TABLE Products
54. CREATE TABLE Products(
55. ProductID int NOT NULL,
56. ProductName varchar(50) NOT NULL,
57. UnitsInStock smallint NOT NULL,
58. Price decimal(10, 2) NOT NULL,
59. PRIMARY KEY(ProductID))

Figura 2. Crearea tabelelor

Crearea cheilor externe


1. USE MAG
2.
3. --Chei externe
4. ALTER TABLE [Order] WITH CHECK ADD CONSTRAINT FK_Order_Customers FOREIGN KEY(CustomerID)

5. REFERENCES Customers (CustomerID)


6.
7. ALTER TABLE [Order] WITH CHECK ADD CONSTRAINT FK_Order_Employees FOREIGN KEY(EmployeeID)

8. REFERENCES Employees (EmployeeID)


9.
10. ALTER TABLE OrderDetail WITH CHECK ADD CONSTRAINT FK_OrderDetail_Order FOREIGN KEY(Order
ID)
11. REFERENCES [Order] (OrderID)
12.
13. ALTER TABLE OrderDetail WITH CHECK ADD CONSTRAINT FK_OrderDetail_Products FOREIGN KEY(Pr
oductID)
14. REFERENCES Products (ProductID)
15.
16. ALTER TABLE ProductDescription WITH CHECK ADD CONSTRAINT FK_ProductDescription_Products
FOREIGN KEY(ProductID)
17. REFERENCES Products (ProductID)
18. --Comenzi

19. ALTER TABLE Comenzi ADD CONSTRAINT[FK_ClientiComenzi]

20. FOREIGN KEY(ClientID) REFERENCES Clienti(ClientID)

21. ON UPDATE CASCADE;

22. --CHEIE UNICA

23. ALTER TABLE Clienti

24. ADD CONSTRAINT UC_Clienti UNIQUE(IDNP)

Figura 3. Chei externe

Crearea Diagramei Bazei de Date


Figura 4. Diagrama bazei de date

Popularea cu tupluri a relațiilor BD


1. USE Mag
2.
3. INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'1',
N'Vlad', N'Aleccu Russo', N'Chisinau', N'Moldova', N'079434343', N'2044')
4.
5. INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'2',
N'Dima', N'Alba Iulia', N'Paris', N'Franta', N'068323323', N'2013')
6.
7. INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'3',
N'Vasea', N'Poltava', N'Chisinau', N'Moldova', N'058944949', N'2000')
8.
9. INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'4',
N'Nicu', N'Paris', N'Balti', N'Moldova', N'032393923', N'2033')
10.
11. INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (1, N'
Vika', N'Cherdivara', N'Manager', N'20-05-1950', 2420)
12.
13. INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (2, N'
Adelina', N'Fiodorov', N'Manager', N'13-12-1996', 3146)
14.
15. INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (3, N'
Aliona', N'Scutari', N'Casir', N'04-03-1997', 3630)
16.
17. INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (4, N'
Marusea', N'Loca', N'Paznic', N'30-01-1997', 8470)
18.
19. INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (23, N
'John', N'T', N'HelpDesk', N'30-01-1993', 2701)
20.
21. INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (1, N'1', CAST(N'2017-
12-04' AS Date), 1)
22.
23. INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (2, N'2', CAST(N'2017-
12-04' AS Date), 2)
24.
25. INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (3, N'3', CAST(N'2017-
12-05' AS Date), 2)
26.
27. INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (4, N'3', CAST(N'2017-
12-03' AS Date), 1)
28.
29. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (1, N'Aspirator', 50,
CAST(1230.00 AS Decimal(10, 2)))
30.
31. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (2, N'Televizor', 200
, CAST(14000.00 AS Decimal(10, 2)))
32.
33. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (3, N'Fier de calcat'
, 15, CAST(300.00 AS Decimal(10, 2)))
34.
35. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (4, N'Masina de spala
t', 30, CAST(8000.00 AS Decimal(10, 2)))
36.
37. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (5, N'Calculator', 40
, CAST(400000.00 AS Decimal(10, 2)))
38.
39. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (10, N'test', 1, CAST
(100.00 AS Decimal(10, 2)))
40.
41. INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (11, N'test1', 1, CAS
T(100.00 AS Decimal(10, 2)))
42.
43. INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (1, 1, 3)
44.
45. INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (2, 1, 5)
46.
47. INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (3, 2, 66)
48.
49. INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (4, 3, 12)
50.
51. INSERT ProductDescription (ProductID, Description) VALUES (1, N'aspira tot ce doresti')
52.
53. INSERT ProductDescription (ProductID, Description) VALUES (2, N'acum poti si privi video p
e youtube')
54.
55. INSERT ProductDescription (ProductID, Description) VALUES (3, N'e timpul sa nu arati ca un
vagabond')
56.
57. INSERT ProductDescription (ProductID, Description) VALUES (5, N'You know what to do')

Figura 5. Exemplu de tabel populat

Crearea schemelor
1. USE MAG
2. IF EXISTS(SELECT sys.schemas.name FROM sys.schemas WHERE sys.schemas.name = 'Clienti')
3. DROP SCHEMA Custom
4. GO
5. CREATE SCHEMA Custom
6. GO
7. ALTER SCHEMA Custom TRANSFER dbo.Customers
8. GO
9. IF EXISTS(SELECT sys.schemas.name FROM sys.schemas WHERE sys.schemas.name = 'Prod')
10. DROP SCHEMA Prod
11. GO
12. CREATE SCHEMA Prod
13. GO
14. ALTER SCHEMA Prod TRANSFER dbo.Products

Figura 6. Schemele create

Crearea Utilizatorilor
1. --crearea userilor
2. USE master
3. GO
4. -- Primul user
5. IF EXISTS (SELECT loginname FROM master.dbo.syslogins WHERE name = 'User1')
6. BEGIN
7. DROP LOGIN User1;
8. END
9. GO
10. USE master;
11. GO
12. IF EXISTS (SELECT * FROM sys.database_principals WHERE name = 'User1')
13. BEGIN
14. DROP USER User1;
15. END
16. CREATE LOGIN User1 WITH PASSWORD = '12345';
17. CREATE USER User1 FROM LOGIN User1;
18. GO
19. GRANT SELECT TO User1;
20. ALTER LOGIN User1 ENABLE
21. GO
22.
23. IF EXISTS (SELECT loginname FROM master.dbo.syslogins WHERE name = 'admin1')
24. BEGIN
25. DROP LOGIN admin1;
26. END
27. GO
28. USE master;
29. GO
30. IF EXISTS (SELECT * FROM sys.database_principals WHERE name = 'admin1')
31. BEGIN
32. DROP USER admin1;
33. END
34. CREATE LOGIN admin1 WITH PASSWORD = '54321';
35. CREATE USER admin1 FROM LOGIN admin1;
36. GO
37. ALTER LOGIN admin1 ENABLE
38. GRANT SELECT, UPDATE, INSERT, DELETE TO admin1;

Figura 7.Utilizatori creati

Crearea viziunilor

1. USE MAG
2. GO
3.
4. if exists(select 1 from sys.views where name='CustomerOrders' and type='v')
5. drop view [CustomerOrders];
6. go
7.
8. CREATE VIEW [dbo].[CustomerOrders]
9. AS
10. SELECT dbo.Customers.CustomerID, dbo.Customers.Name, dbo.Products.ProductID, dbo.Pr
oducts.ProductName, dbo.Products.UnitsInStock, dbo.Products.Price
11. FROM dbo.[Order] INNER JOIN
12. dbo.OrderDetail ON dbo.[Order].OrderID = dbo.OrderDetail.OrderID
INNER JOIN
13. dbo.Products ON dbo.OrderDetail.ProductID = dbo.Products.ProductI
D INNER JOIN
14. dbo.Customers ON dbo.[Order].CustomerID = dbo.Customers.CustomerI
D
15.
16. GO
17.
18. if exists(select 1 from sys.views where name='EmployeeOrders' and type='v')
19. drop view [EmployeeOrders];
20. go
21. CREATE VIEW [dbo].[EmployeeOrders]
22. AS
23. SELECT dbo.Employees.EmployeeID, dbo.[Order].OrderID
24. FROM dbo.Employees INNER JOIN
25. dbo.[Order] ON dbo.Employees.EmployeeID = dbo.[Order].EmployeeID
INNER JOIN
26. dbo.Customers ON dbo.[Order].CustomerID = dbo.Customers.CustomerI
D
27.
28. GO
29. if exists(select 1 from sys.views where name='View1' and type='v')
30. drop view [View1];
31. go
32. CREATE VIEW [dbo].[View1] AS
33. SELECT dbo.Employees.EmployeeID, dbo.[Order].OrderID, dbo.Employees.FirstName,
34. dbo.Employees.LastName
35. FROM dbo.Employees INNER JOIN
36. dbo.[Order] ON dbo.Employees.EmployeeID = dbo.[Order].EmployeeID
37. INNER JOIN
38. dbo.Customers ON dbo.[Order].CustomerID = dbo.Customers.CustomerID
39. WHERE dbo.Employees.EmployeeID < 2

Fig. 8 Viziunile create

Crearea sinonimelor
Crearea sinonimelor
1. USE MAG
2. if exists (select * from sys.synonyms where name = 'Clients' and object_id('Clients') is n
ot null)
3. DROP SYNONYM Clients
4.
5. CREATE SYNONYM Clients
6. FOR Mag.Custom.Customers
7.
8. USE MAG
9. if exists (select * from sys.synonyms where name = 'things' and object_id('things') is not
null)
10. DROP SYNONYM things
11.
12. CREATE SYNONYM things
13. FOR Mag.Prod.Products

Fig. 9 Crearea sinonimelor

3. Interogarea bazei de date


3.1 Crearea interogărilor ce exprimă operațiile algebrei relaționale
Sa se gaseasca cumparaturile pentru fiecare client.

1. use Mag
2. select c.*, o.OrderID
3. from [Order] o, Clients c
4. where o.CustomerID = c.CustomerID
5. union
6. select c.*, null
7. from Clients c
8. where not exists
9. ( select * from [Order] o where o.CustomerID = c.CustomerID)

Figura 3.1 Uniune

Sa se arate cumparatorii care sunt din Moldova si au cumparat in ultimele 2 zile.

1. select c.CustomerID
2. from Clients c
3. where Country = 'Moldova'
4. intersect
5. select o.CustomerID
6. from [Order] o
7. where dateadd(day,-2, getdate()) > OrderDate

Figura 3.2 Intersecția

Să se găsească diferența de note dintre numele utilizatorilor din Chisinau si Paris.


1. use Mag
2.
3. select Name AS[Nume Client] from Clients
4. WHERE City='Chisinau'
5. EXCEPT
6. select Name AS[Nume Client] from Clients
7. WHERE City='Paris'
Figura 3.3 Diferența

Să se combine numele clientilor cu numele lucratorilor cu prenumele cumparatorilor


--produs cartezian
use Mag

select c.Name AS[Nume], e.FirstName AS[Prenume] from Clients c


CROSS JOIN dbo.Employees e

Figura 3.4 Produs cartezian

Sa se arate informatii despre produse care au fost cumparate in cantitate mai mare de 50
select * from Prod.Products p, OrderDetail o where p.ProductID = o.ProductID and o.Quantity
> 5

Fig. 3.5 Theta join

Sa se arata toate comenzile fiecarui utilizator.


1. select *
2. from Clients c join [Order] o
3. on c.CustomerID = o.CustomerID

Figura 3.6 Joncțiune naturală

Să se aducă un exemplu de jocțiune externă de stânga.


1. select e.*, o.OrderID
2. from Employees e left join [Order] o
3. on e.EmployeeID = o.EmployeeID

Figura 3.7 Joncțiune de stânga

Să se aducă exemplu de joncțiune externă de dreapta.


1. use Mag
2. select d.OrderID, d.Quantity, p.*
3. from OrderDetail d right join Prod.Products p
4. on d.ProductID = p.ProductID
Figura 3.8 Joncțiune de dreapta

Semijonctiune la stinga
1. select e.* from Employees e, [Order] o where e.EmployeeID = o.EmployeeID

Fig. 3.9 Semijonctiune

3.2 Crearea interogărilor cu funcții de agregare


Sa se arate avg de cantite cumparata pentru fiecare produs care a fost cumparat minimim in cantitate de 50
de unitati.
1. use Mag
2.
3. Select ProductID, avg(Quantity) as average
4. from OrderDetail
5. group by ProductID having sum (Quantity) > 50

Figura 3.2.1 Utilizarea funcției AVG,SUM

Să se găsească cantitatea maxima de un produs cumparat intro comanda pentru fiecarea produs.
1. use Mag
2.
3. Select ProductID, max(Quantity) as max
4. from OrderDetail
5. group by ProductID

Figura 3.2.2 Funcția MAX

Să se afișeze numarul total de cumparaturi pentru fiecare client.


1. Select CustomerID, Count(*) as max
2. from [Order]
3. group by CustomerID

Figura 3.2.3 Funcția Count

3.3 Crearea interogărilor cu grupare


Sa se arate in ce cantitate a fost cumparat fiecare produs.
1. use Mag
2.
3. select p.ProductName, sum(d.Quantity) as Quantity
4. from OrderDetail d right join Prod.Products p
5. on d.ProductID = p.ProductID
6. group by p.ProductName

Figura 3.3.1 Grupare multirelație

Sa se arate avg de cantite cumparata pentru fiecare produs care a fost cumparat minimim in cantitate de 50
de unitati.
1. use Mag
2.
3. Select ProductID, avg(Quantity) as average
4. from OrderDetail
5. group by ProductID having sum (Quantity) > 50
Figura 3.3.2 Grupare unirelatie

3.4 Subinterogări
Afisarea consumatorilor care nu au realizat nici o cumparatura

---EXISTS
1. select c.*
2. from Clients c
3. where not exists
4. ( select * from [Order] o where o.CustomerID = c.CustomerID)

Figura 3.4.1 Rezultatul interogării

Să se găsească comparator care are acelasi nume ca si un angajat


--IN
SELECT * FROM Clients c WHERE c.Name in (select e.LastName from Employees e)

Figura 3.4.2 Rezultatul interogării

Să se afișeze produsele care au fost cumparate macar o data


--ANY
SELECT * FROM Prod.Products p WHERE p.ProductID = ANY(select o.ProductID from [OrderDetail] o)
Figura 3.4.3 Rezultatul interogării

Să se afișeze produsele care coosta mai mult decit salariu oricarui angajat
--ALL
SELECT * FROM Prod.Products p WHERE p.Price > ALL(select e.Salary from Employees e)

Figura 3.4.4 Rezultatul interogării

3.5 Subinterogări în alte locuri decât clauza WHERE

Să se afișeze in ce cantitate a fost cumparat un produs la fiecare comanda


SELECT p.*, OrderDetail.Quantity FROM (Select * FROM Prod.Products WHERE Price > 400) p, OrderDet
ail where p.ProductID = OrderDetail.ProductID

Figura 3.5.1 Rezultatul interogării

Sa se afiseze numele angajatului care a prelucrat comanda si ziua comenzii


SELECT o.OrderDate, (Select p.FirstName FROM dbo.Employees p WHERE p.EmployeeID = o.EmployeeID) F
FOM [Order] o;
Figura 3.5.2 Rezultatul interogării

3.6 Crearea interogărilor de actualizare a relațiilor


Să se scrie o interogare de ștergere condiționată a tuplurilor.

Sterge cel mai scump produs.


DELETE FROM Prod.Products WHERE Price > (select AVG(Price) from Prod.Products)

Să se mareasca pretul cu 10% la produsele care nu au fost cumparate inca niciodata


1. UPDATE p SET Price = (select Price from Prod.Products where p.ProductID = ProductID) * 1.1

2. from Prod.Products p
3. where p.ProductID not in (select ProductID from OrderDetail)

3.7 Crearea procedurilor stocate


Să se creeze o procedura care returneaza orasele ce coincid unui regex
1. CREATE PROCEDURE find_clients
2. @CityLike Varchar(10) = 'F%'
3. AS
4. BEGIN
5. Select Name
6. from Customers
7. where City = 'Balti' or Country like @CityLike
8. END
9. GO
10. )

11. use Mag


12. exec find_clients @CityLike = 'F%';
Figura 3.7.1 Rezultatul procedurii

Să se creeza o functie care arata diferenta in pret intre un produs si produsul urmator in BD
1. CREATE FUNCTION view_diff()
2. RETURNS TABLE
3. AS
4. RETURN
5. (
6. SELECT
7. [current].*,
8. ISNULL([next].Price, 0) - [current].Price as diff
9. FROM
10. Prod.Products as [current]
11. LEFT JOIN
12. Prod.Products AS [next]
13. ON [next].ProductID =
14. (SELECT MIN(ProductID)
15. FROM Prod.Products
16. WHERE ProductID > [current].ProductID)
17. )
18. GO

select * from view_diff()


Figura 3.7.2 Rezultatul interogării

Concluzia
În lucrarea de an prezentă, am creat o bază de date pentru magazin. In ea se poate stoca
inforamatii despre produsele prezente in magazin, despre angati si despre clienti. Înainte de a
implementa baza de date în SQL, am efectuat proiectarea logică a ei. Am stabilit atributele,
dependențele funcționale, asocierile dintre relații, cheile relațiilor, ordinea inserării tuplurilor. Am
utilizat algoritmul de sinteză a BD. Proiectarea logică ne ajută să creăm un model conceptual al
bazei de date, independent de implementarea ei în SGBD. După această etapă, urmează proiectarea
fizică, adică implementarea structurii logice a bazei de date în SGBD. Aici creăm baza de date –
fișierele primare și log, relațiile, constrângerile de integritate și cheile externe, popularea bazei cu
tupluri, crearea schemelor și așa mai departe. După testarea funcționalității bazei de date, putem
efectua interogări.
Anexă – Scriptul T-SQL al bazei de date
1. USE master
2. IF EXISTS(select * from sys.databases where name='Mag')
3. DROP DATABASE Mag
4.
5. CREATE DATABASE [Mag]
6. ON PRIMARY
7. (NAME = N'Mag',
8. FILENAME = N'E:\Program Files\MSSQL12.MSSQLSERVER\MSSQL\DATA\Mag.mdf' ,
9. SIZE = 5120KB ,
10. MAXSIZE = UNLIMITED,
11. FILEGROWTH = 1024KB )
12. LOG ON
13. (NAME = N'Mag_log',
14. FILENAME = N'E:\Program Files\MSSQL12.MSSQLSERVER\MSSQL\DATA\Mag.ldf' ,
15. SIZE = 2304KB ,
16. MAXSIZE = 2048GB ,
17. FILEGROWTH = 10%)
18.
19. use Mag
20.
21. IF OBJECT_ID('ProductDescription', 'U') IS NOT NULL
22. DROP TABLE ProductDescription
23. CREATE TABLE ProductDescription(
24. ProductID int NOT NULL,
25. Description varchar(50) NULL,
26. PRIMARY KEY (ProductID))
27.
28. IF OBJECT_ID('Customers', 'U') IS NOT NULL
29. DROP TABLE Customers
30. CREATE TABLE Customers(
31. CustomerID varchar(25) NOT NULL,
32. Name varchar(50) NOT NULL,
33. Address varchar(50) NOT NULL,
34. City varchar(50) NOT NULL,
35. Country varchar(50) NOT NULL,
36. Phone varchar(50) NOT NULL,
37. ZipCode varchar(10) NOT NULL,
38. PRIMARY KEY(CustomerID))
39.
40.
41. IF OBJECT_ID('Employees', 'U') IS NOT NULL
42. DROP TABLE Employees
43. CREATE TABLE Employees(
44. EmployeeID int NOT NULL,
45. LastName varchar(50) NOT NULL,
46. FirstName varchar(50) NOT NULL,
47. Title varchar(50) NOT NULL,
48. BirthDate varchar(50) NOT NULL,
49. Salary int NOT NULL,
50. PRIMARY KEY(EmployeeID))
51.
52. IF OBJECT_ID('Order', 'U') IS NOT NULL
53. DROP TABLE [Order]
54. CREATE TABLE [Order](
55. OrderID int NOT NULL,
56. CustomerID varchar(25) NOT NULL,
57. OrderDate date NOT NULL,
58. EmployeeID int NOT NULL,
59. PRIMARY KEY (OrderID))
60.
61. IF OBJECT_ID('OrderDetail', 'U') IS NOT NULL
62. DROP TABLE OrderDetail
63. CREATE TABLE OrderDetail(
64. OrderID int NOT NULL,
65. ProductID int NOT NULL,
66. Quantity int NOT NULL,
67. PRIMARY KEY(OrderID, ProductID))
68.
69.
70. IF OBJECT_ID('Products', 'U') IS NOT NULL
71. DROP TABLE Products
72. CREATE TABLE Products(
73. ProductID int NOT NULL,
74. ProductName varchar(50) NOT NULL,
75. UnitsInStock smallint NOT NULL,
76. Price decimal(10, 2) NOT NULL,
77. PRIMARY KEY(ProductID))
78.
79. USE MAG
80.
81. --Chei externe
82. ALTER TABLE [Order] WITH CHECK ADD CONSTRAINT FK_Order_Customers FOREIGN KEY(CustomerID)

83. REFERENCES Customers (CustomerID)


84.
85. ALTER TABLE [Order] WITH CHECK ADD CONSTRAINT FK_Order_Employees FOREIGN KEY(EmployeeID)

86. REFERENCES Employees (EmployeeID)


87.
88. ALTER TABLE OrderDetail WITH CHECK ADD CONSTRAINT FK_OrderDetail_Order FOREIGN KEY(Order
ID)
89. REFERENCES [Order] (OrderID)
90.
91. ALTER TABLE OrderDetail WITH CHECK ADD CONSTRAINT FK_OrderDetail_Products FOREIGN KEY(Pr
oductID)
92. REFERENCES Products (ProductID)
93.
94. ALTER TABLE ProductDescription WITH CHECK ADD CONSTRAINT FK_ProductDescription_Products
FOREIGN KEY(ProductID)
95. REFERENCES Products (ProductID)
96.
97. USE Mag
98.
99. INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'1',
N'Vlad', N'Aleccu Russo', N'Chisinau', N'Moldova', N'079434343', N'2044')
100.
101.INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'2',
N'Dima', N'Alba Iulia', N'Paris', N'Franta', N'068323323', N'2013')
102.
103.INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'3',
N'Vasea', N'Poltava', N'Chisinau', N'Moldova', N'058944949', N'2000')
104.
105.INSERT Customers (CustomerID, Name, Address, City, Country, Phone, ZipCode) VALUES (N'4',
N'Nicu', N'Paris', N'Balti', N'Moldova', N'032393923', N'2033')
106.
107.INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (1, N'
Vika', N'Cherdivara', N'Manager', N'20-05-1950', 2420)
108.
109.INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (2, N'
Adelina', N'Fiodorov', N'Manager', N'13-12-1996', 3146)
110.
111.INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (3, N'
Aliona', N'Scutari', N'Casir', N'04-03-1997', 3630)
112.
113.INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (4, N'
Marusea', N'Loca', N'Paznic', N'30-01-1997', 8470)
114.
115.INSERT Employees (EmployeeID, LastName, FirstName, Title, BirthDate, Salary) VALUES (23, N
'John', N'T', N'HelpDesk', N'30-01-1993', 2701)
116.
117.INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (1, N'1', CAST(N'2017-
12-04' AS Date), 1)
118.
119.INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (2, N'2', CAST(N'2017-
12-04' AS Date), 2)
120.
121.INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (3, N'3', CAST(N'2017-
12-05' AS Date), 2)
122.
123.INSERT [Order] (OrderID, CustomerID, OrderDate, EmployeeID) VALUES (4, N'3', CAST(N'2017-
12-03' AS Date), 1)
124.
125.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (1, N'Aspirator', 50,
CAST(1230.00 AS Decimal(10, 2)))
126.
127.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (2, N'Televizor', 200
, CAST(14000.00 AS Decimal(10, 2)))
128.
129.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (3, N'Fier de calcat'
, 15, CAST(300.00 AS Decimal(10, 2)))
130.
131.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (4, N'Masina de spala
t', 30, CAST(8000.00 AS Decimal(10, 2)))
132.
133.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (5, N'Calculator', 40
, CAST(400000.00 AS Decimal(10, 2)))
134.
135.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (10, N'test', 1, CAST
(100.00 AS Decimal(10, 2)))
136.
137.INSERT Products (ProductID, ProductName, UnitsInStock, Price) VALUES (11, N'test1', 1, CAS
T(100.00 AS Decimal(10, 2)))
138.
139.INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (1, 1, 3)
140.
141.INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (2, 1, 5)
142.
143.INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (3, 2, 66)
144.
145.INSERT OrderDetail (OrderID, ProductID, Quantity) VALUES (4, 3, 12)
146.
147.INSERT ProductDescription (ProductID, Description) VALUES (1, N'aspira tot ce doresti')
148.
149.INSERT ProductDescription (ProductID, Description) VALUES (2, N'acum poti si privi video p
e youtube')
150.
151.INSERT ProductDescription (ProductID, Description) VALUES (3, N'e timpul sa nu arati ca un
vagabond')
152.
153.INSERT ProductDescription (ProductID, Description) VALUES (5, N'You know what to do')
154.
155.USE MAG
156.IF EXISTS(SELECT sys.schemas.name FROM sys.schemas WHERE sys.schemas.name = 'Clienti')
157.DROP SCHEMA Custom
158.GO
159.CREATE SCHEMA Custom
160.GO
161.ALTER SCHEMA Custom TRANSFER dbo.Customers
162.GO
163.IF EXISTS(SELECT sys.schemas.name FROM sys.schemas WHERE sys.schemas.name = 'Prod')
164.DROP SCHEMA Prod
165.GO
166.CREATE SCHEMA Prod
167.GO
168.ALTER SCHEMA Prod TRANSFER dbo.Products
169.
170.--crearea userilor
171.USE master
172.GO
173.-- Primul user
174.IF EXISTS (SELECT loginname FROM master.dbo.syslogins WHERE name = 'User1')
175.BEGIN
176.DROP LOGIN User1;
177.END
178.GO
179.USE master;
180.GO
181.IF EXISTS (SELECT * FROM sys.database_principals WHERE name = 'User1')
182.BEGIN
183.DROP USER User1;
184.END
185.CREATE LOGIN User1 WITH PASSWORD = '12345';
186.CREATE USER User1 FROM LOGIN User1;
187.GO
188.GRANT SELECT TO User1;
189.ALTER LOGIN User1 ENABLE
190.GO
191.
192.IF EXISTS (SELECT loginname FROM master.dbo.syslogins WHERE name = 'admin1')
193.BEGIN
194.DROP LOGIN admin1;
195.END
196.GO
197.USE master;
198.GO
199.IF EXISTS (SELECT * FROM sys.database_principals WHERE name = 'admin1')
200.BEGIN
201.DROP USER admin1;
202.END
203.CREATE LOGIN admin1 WITH PASSWORD = '54321';
204.CREATE USER admin1 FROM LOGIN admin1;
205.GO
206.ALTER LOGIN admin1 ENABLE
207.GRANT SELECT, UPDATE, INSERT, DELETE TO admin1;
208.
209.USE MAG
210.GO
211.
212.if exists(select 1 from sys.views where name='CustomerOrders' and type='v')
213.drop view [CustomerOrders];
214.go
215.
216.CREATE VIEW [dbo].[CustomerOrders]
217.AS
218.SELECT Custom.Customers.CustomerID, Custom.Customers.Name, Prod.Products.ProductID,
Prod.Products.ProductName, Prod.Products.UnitsInStock, Prod.Products.Price
219.FROM dbo.[Order] INNER JOIN
220. dbo.OrderDetail ON dbo.[Order].OrderID = dbo.OrderDetail.OrderID
INNER JOIN
221. Prod.Products ON dbo.OrderDetail.ProductID = Prod.Products.Produc
tID INNER JOIN
222. Custom.Customers ON dbo.[Order].CustomerID = Custom.Customers.Cus
tomerID
223.
224.GO
225.
226.if exists(select 1 from sys.views where name='EmployeeOrders' and type='v')
227.drop view [EmployeeOrders];
228.go
229.CREATE VIEW [dbo].[EmployeeOrders]
230.AS
231.SELECT dbo.Employees.EmployeeID, dbo.[Order].OrderID
232.FROM dbo.Employees INNER JOIN
233. dbo.[Order] ON dbo.Employees.EmployeeID = dbo.[Order].EmployeeID
INNER JOIN
234. Custom.Customers ON dbo.[Order].CustomerID = Custom.Customers.Cus
tomerID
235.
236.GO
237.if exists(select 1 from sys.views where name='View1' and type='v')
238.drop view [View1];
239.go
240.CREATE VIEW [dbo].[View1] AS
241.SELECT dbo.Employees.EmployeeID, dbo.[Order].OrderID, dbo.Employees.FirstName,
242.dbo.Employees.LastName
243.FROM dbo.Employees INNER JOIN
244.dbo.[Order] ON dbo.Employees.EmployeeID = dbo.[Order].EmployeeID
245.INNER JOIN
246.Custom.Customers ON dbo.[Order].CustomerID = Custom.Customers.CustomerID
247.WHERE dbo.Employees.EmployeeID < 2
248.
249.GO
250.USE MAG
251.if exists (select * from sys.synonyms where name = 'Clients' and object_id('Clients') is n
ot null)
252.DROP SYNONYM Clients
253.
254.CREATE SYNONYM Clients
255. FOR Mag.Custom.Customers
256.
257.USE MAG
258.if exists (select * from sys.synonyms where name = 'things' and object_id('things') is not
null)
259.DROP SYNONYM things
260.
261.CREATE SYNONYM things
262. FOR Mag.Prod.Products

S-ar putea să vă placă și