1.

Definiţi următorii termeni:

- baza de date
•O bază de date este o colecţie de informaţii inter-relaţionate gestionate ca o singură unitate.

- sisteme de gestiune a bazei de date

• SGBD este un produs software furnizat de producătorul bazei de date relationale

- entitate
• Entitatea este un obiect sau un concept, care este semnificativ pentru modelul real analizat. O
entitate poate fi dependentă (slabă), existenţa sa depinzând de altă entitate sau independentă (tare), caz
în care ea nu depinde de existenţa altei entităţi.
Entitatea poate fi persoană, loc, concept, activitate etc. Prin urmare, ea poate fi un obiect cu existenţă
fizică, reală sau poate fi un obiect cu existenţă conceptuală, abstractă.

- relație
• Relaţia (asocierea) este o comunicare între două sau mai multe entităţi. O valoare a unei relaţii
este o comunicare între valorile entităţilor pe care le leagă.
Relaţia exprimă un raport care există între aceste entităţi. Gradul unei relaţii este dat de numărul de
entităţi participante într-o relaţie (de exemplu, relaţie binară, ternară, cvadruplă, n-ară).

- atribut
• Atributul este o proprietate descriptivă a unei entităţi sau a unei relaţii. De exemplu, numele ,
genul unei film, sunt atribute al entităţii FILM.
Atributele pot fi simple (pretul de închiriere a unui film), compuse (de exemplu, numele filmului), cu valori
multiple (de exemplu, limbile în care e tradus un film), derivate (de exemplu, vârsta unei persoane se
obţine din data naşterii).

- bază de date relaţională

• este o bază de date care respectă modelul relaţional, dezvoltat de Dr.E.F.Codd. Modelul
relaţional prezintă datele sub forma familiarelor tabele bidimensionale, similar cu o foaie de calcul tabelar.
Spre deosebire de o foaie de calcul tabelar, nu este obligatoriu ca datele să fie stocate într-o formă
tabelară, iar modelul permite şi combinarea tabelelor (crearea uniunilor (joining), în terminologia
relaţională) pentru formarea vizualizarilor, care sunt prezentate tot ca tabele bidimensionale.
Flexibilitatea extraordinară a bazelor de date relaţionale este dată de posibilitatea de a folosi tabelele
independent sau în combinaţii, fără nici o ierarhie sau secvenţa predefinita în care trebuie să se facă
accesul la date.

2. Descrieți pașii pentru construirea unei diagrame E-R.

Prin tehnica entiate-relaţie (denumită şi entitate-asociere) se construieşte o diagramă entiate-relaţie
(notată E-R) prin parcurgerea următorilor paşi:
a) identificarea entităţilor (componentelor) din sistemul proiectului;
b) identificarea asocierilor (relaţiilor) dintre entităţi şi calificarea lor;
c) identificarea atributelor corespunzătoare entităţilor;
d) stabilirea atributelor de identificare a entităţilor.
 3. Daţi exemple de:
- relaţie de tip multe la multe
• Să presupunem existența unei relații între tabelul Produse și tabelul Comenzi. O singură
comandă poate include mai mult de un produs. Pe de cealaltă parte, un singur produs poate apărea în
mai multe comenzi. De aceea, pentru fiecare înregistrare din tabelul Comenzi pot exista mai multe
înregistrări în tabelul Produse. În plus, pentru fiecare înregistrare din tabelul Produse, pot exista mai multe
înregistrări în tabelul Comenzi. Acest tip de relație este denumit o relație mai-mulți-la-mai-mulți deoarece,
pentru orice produs pot exista mai multe comenzi și pentru fiecare comandă pot exista mai multe produse.
Rețineți că, pentru a detecta relații mai-mulți-la-mai-mulți între tabelele dvs., este important să luați în
considerare ambele părți ale relației. Pentru a crea o relație mai-mulți-la-mai-mulți, trebuie să creați mai
întâi un al treilea tabel, denumit deseori tabel de relație, care împarte relația mai-mulți-la-mai-mulți în
două relații unu-la-mai-mulți. Inserați câmpul cheie primară din fiecare dintre cele două tabele în al treilea
tabel. Ca rezultat, al treilea tabel înregistrează fiecare apariție, denumită și instanță, dintr-o relație. De
exemplu, tabelul Comenzi și tabelul Produse au o relație mai-mulți-la-mai-mulți care este definită prin
crearea a două relații unu-la-mai-mulți în tabelul Detalii comenzi. O comandă poate avea mai multe
produse și fiecare produse poate apărea în mai multe comenzi.

- relaţie de tip una la una

• Într-o relație unu-la-unu, fiecare înregistrare din primul tabel poate avea o singură înregistrare
potrivită în al doilea tabel și fiecare înregistrare din al doilea tabel poate avea o singură înregistrare
potrivită în primul tabel. Acest tip de relație nu este comun, deoarece, de cele mai multe ori, informațiile
asociate în acest mod se stochează în același tabel. O relație unu-la-unu poate fi utilizată pentru a diviza
un tabel cu multe câmpuri, pentru a izola o parte dintr-un tabel din motive de securitate sau pentru a
stoca informații care se aplică numai pentru un subset al tabelului principal.

- relaţie de tip una la multe

• Să ne gândim la o bază de date care urmărește comenzi și are un tabel Clienți și un tabel
Comenzi. Un client poate plasa oricâte comenzi. Este logic că, pentru fiecare client din tabelul Clienți, pot
exista una sau mai multe comenzi în tabelul Comenzi. Relația dintre tabelul Clienți și tabelul Comenzi este,
în consecință, o relație unu-la-mai-mulți. Pentru a crea o relație unu-la-mai-mulți în proiectarea bazei de
date, luați cheia primară din partea "unu" a relației și adăugați-o sub formă de câmp suplimentar sau
câmpuri suplimentare la tabelul din partea "mai-mulți" a relației. În acest caz, adăugați un câmp nou —
câmpul ID din tabelul Clienți — la tabelul Comenzi și îl denumiți ID Client. Access utilizează apoi numărul
ID Client în tabelul Comenzi pentru a găsi clientul corect pentru fiecare comandă.

4. Enunțați regulile lui Codd pentru SGBD-urile relaţionale.

Regula 1 – regula gestionării datelor. Un SGBD relaţional trebuie să fie capabil să gestioneze o bază de
date numai prin posibilităţile sale relaţionale.

Regula 2 – regula reprezentării informaţiei. Într-o bază de date relaţională, informaţia este reprezentată
la nivel logic sub forma unor tabele ce poartă numele de relaţii.

Regula 3 – regula accesului garantat la date. Fiecare valoare dintr-o bază de date relaţională trebuie să
poată fi adresată în mod logic printr-o combinaţie formată din numele relaţiei, valoarea cheii primare şi
numele atributului.
Regula 4 – regula reprezentării informaţiei necunoscute. Un sistem relaţional trebuie să permită
utilizatorului definirea unui tip de date numit „null“ pentru reprezentarea unei informaţii necunoscute la
momentul respectiv.

Regula 5 – regula dicţionarelor de date. Asupra descrierii bazelor de date (informaţii relative la relaţii,
vizualizări, indecşi etc.) trebuie să se poată aplica aceleaşi operaţii ca şi asupra datelor din baza de date.

Regula 6 – regula limbajului de interogare. Trebuie să existe cel puţin un limbaj pentru prelucrarea bazei
de date.

Regula 7 – regula de actualizare a vizualizării. Un SGBD trebuie să poată determina dacă o vizualizare poate
fi actualizată şi să stocheze rezultatul interogării într-un dicţionar de tipul unui catalog de sistem.

Regula 8 – regula limbajului de nivel înalt. Regulile de prelucrare asupra unei relaţii luată ca întreg sunt
valabile atât pentru operaţiile de regăsire a datelor, cât şi asupra operaţiilor de inserare, actualizare şi
ştergere a datelor.

Regula 9 – regula independenţei fizice a datelor: Programele de aplicaţie şi activităţile utilizatorilor nu

depind de modul de depunere a datelor sau de modul de acces la date.

Regula 10 – regula independenţei logice a datelor. Programele de aplicaţie trebuie să fie transparente la
modificările de orice tip efectuate asupra datelor. Regula 11 – regula independenţei datelor din punct de
vedere al integrităţii. Regulile de integritate trebuie să fie definite într-un sublimbaj relaţional, nu în
programul de aplicaţie.

Regula 12 – regula independenţei datelor din punct de vedere al distribuirii. Distribuirea datelor pe mai
multe calculatoare dintr-o reţea de comunicaţii de date, nu trebuie să afecteze programele de aplicaţie.

Regula 13 – regula versiunii procedurale a unui SGBD. Orice componentă procedurală a unui SGBD trebuie
să respecte aceleaşi restricţii de integritate ca şi componenta relaţională.

5. Descrieți componentele bazelor de date relaționale.

1) structurile de date. O bază de date relaţională (BDR) reprezintă un ansamblu de relaţii, prin care se
reprezintă date şi legăturile dintre ele. Structurile sunt definite de un limbaj de definire a datelor (Data
Definition Language). Datele în modelul relațional sunt structurate în relații (tabele) bidimensionale;

2) operatorii de manipulare a datelor. Relațiile pot fi manipulate utilizând un limbaj de manipularea

datelor (Data Manipulation Language). În modelul relațional, limbajul folosește operatori relaționali bazați
pe conceptul algebrei relaționale. În afară de acesta, există limbaje echivalente algebrei relaționale, cum
ar fi calculul relațional orientat pe tuplu și calculul relațional orientat pe domeniu;

3) constrângerile de integritate. Prin integritatea datelor se subînțelege că datele rămân stabile, în

siguranță și corecte. Integritatea în modelul relațional este menținută de constrângeri interne care nu
sunt cunoscute utilizatorului.
6. Explicaţi următoarele noţiuni:
- restricţii de integritate
• O restricţie este o regulă specificată pentru un obiect al bazei de date (de obicei un table sau o
coloană), având rolul de a limita într-un mod oarecare domeniul de valori permise pentru obiectul
respectiv al bazei de date.După ce sunt specificate, restricţiile sunt impuse automat de sistemul DBMS şi
nu pot fi ocolite decât dacă o persoană autorizata le dezactivează sau le şterge(le elimină).Fiecare
restricţie primeşte un nume unic, astfel încât să poată fi referită în mesajele de eroare şi în comenzile
folosite ulterior în bază de date.Este recomandabil ca proiectanţii bazei de date să denumească restricţiile,
deoarece numele generate automat de bază de date nu sunt foare descriptive.

- cheia primară a unei relaţii

• Fiecare relaţie are cel puţin o cheie. Una dintre cheile candidat va fi aleasă pentru a identifica
efectiv tupluri şi ea va primi numele de cheie primară. Cheia primară nu poate fi reactualizată. Atributele
care reprezintă cheia primară sunt fie subliniate, fie urmate de semnul #.

- cheia externa a unei relatii

• Cheia primară a entităţilor dependente conţine cheia primară a entităţii de care depinde (cheie
externă) plus unul sau mai multe atribute adiţionale.

7. Precizati care sunt restrictiile de integritate minimală ale modelului relaţional, apoi enunţaţi aceste
restricţii.

Restricţiile de integritate ale modelului relaţional reprezintă cerinţe pe care trebuie să le

îndeplinească datele din cadrul bazei de date pentru a putea fi considerate corecte şi coerente în raport
cu lumea reală pe care o reflectă. Dacă o bază de date nu respectă aceste cerinţe, ea nu poate fi utilizată
cu un maxim de eficienţă.
Restricţiile sunt de două tipuri: restricţii de integritate structurală și restricţii de integritate de
comportament.
Restricţii de integritate structurale, care se definesc prin egalitatea sau inegalitatea unor valori din
cadrul relaţiilor. Acestea sunt:
• restricţia de unicitate a cheii - cheia primară trebuie să fie unică și minimală;
• restricţia de integritate a referirii. Într-o tabelă t1 care referă o tabelă t2, valorile cheii externe
trebuie să figureze printre valorile cheii primare din t2 sau să ia valoarea NULL (neprecizat);
• restricţia de integritate a entităţii. Într-o tabelă, atributele din cheia primară nu trebuie să ia
valoarea NULL.

8. Ce înseamnă dependenţă funcţională? Daţi două exemple de DF.

• Pentru această definiţie, voi folosi două atribute arbitrare, denumite „A" şi „B". Atributul B este
dependent funcţional de atributul A dacă în nici un moment nu există mai mult de o valoare a atributului
B asociată cu o valoare dată a atributului A. In primul rând, a spune că atributul B este funcţional
dependent de atributul A înseamnă şi că atributul A determină atributul B sau că A este un determinant
(identificator unic) pentru atributul B.
9.Definiţi următoarele noţiuni:
- atribut simplu (atomic)
• atribut care nu mai poate fi descompus in altea tribute

- atribut compus
• atribut care poate fi descompus in doua sau mai multe atribute atomice

10. Când o relaţie este în:

- forma normală 1?
O relaţie este în FN1 dacă domeniile pe care sunt definite atributele relaţiei sunt constituite numai din
valori atomice. Un tuplu nu trebuie să conţină atribute sau grupuri de atribute repetitive.

- forma normală 2?
O relaţie este în a doua formă normală 2 dacă îndeplineşte următoarele criterii:
• Relaţia este în prima formă normală.
• Toate atributele non-cheie sunt dependente funcţional de identificatorul unic (cheia
primară), luat ca întreg.

- forma normală 3?
O relaţie este în a treia formă normală dacă îndeplineşte următoarele două criterii:
• Relaţia este în a doua formă normală.
• Nu există dependenţe tranzitive (cu alte cuvinte, toate atributele non-cheie depind
numai de identificatorul unic).

11. Descrieți elementele unei instrucţiuni.

Elementele unei instrucţiuni (statement) sunt:

• cuvinte cheie (key words) - dintre care fac parte comenzile (SELECT, UPDATE, INSERT etc),
operatorii (AND, OR, NOT, LIKE), clauzele (WHERE, SET, VALUES etc);

• identificatori (identifier) - sunt elementele care denumesc tabela, coloana sau alt obiect al BD.
SQL face diferenţa între literele mari şi mici, deci este „case-sensitive”; identificatorul care conţine
ghilimele se numeşte identificator delimitat;

• constante (literali) - reprezintă şiruri de caractere (‘ ‘), numere întregi, numere reale (ex. 3.5; 4.;
.001; 5e2), constanta NULL, constante de tip logic (1 pentru TRUE şi 0 pentru FALSE);

• caractere speciale - cum ar fi (;) care semnifică terminarea comenzilor; (.) care semnifică virgula
zecimală; sau (*) care simbolizează operatorul de înmulţire.
12. Operatori SQL.

• operatori aritmetici binari:

+ - / * % modulo ^ ridicarea la putere

• operatori binari de comparaţie:

< ; >; <=; >=; =; <> sau != diferit;

• operatori aritmetici mari:

@ valoarea absolută

! factorial

!! factorial, operator postfix

• operatori de comparaţie:

A BETWEEN min AND max (compară A cu două valori: min şi max)

A IN (v1,...,vn) compară A cu o listă de valori

A IS NULL

A IS NOT NULL

A LIKE model_şir

• operatori logici:

Operatorii logici sunt legaţi prin cuvintele cheie AND, OR, NOT şi returnează o valoare logică TRUE,
FALSE sau NULL.

• operatori relaţionali:

UNION (reuniune)

INTERSECT (intersecţie)

MINUS (diferenţă)

13. Tipuri de funcții scalare.

Funcțiile pe un sigur rând (funcţii scalare) - realizează operații asupra unui singur rând și returnează un
singur rezultat pentru fiecare rând. Funcțiile pe un sigur rând cuprind următoarele tipuri de funcții:

• funcții de tip caracter - acceptă argumente de tip caracter și întorc rezultate de tip caracter (CHR,
CONCAT, INITCAP, LOWER, LPAD, LTRIM, REPLACE, RPAD, RTRIM, SUBSTR, UPPER etc.) sau numeric (ASCII,
INSTR, LENGTH);
• funcții de tip numeric (de calcul trigonometric: sin, cos, tg, ctg etc.; de calcul al logaritmului: ln, log, lg;
de calcul al puterilor: pow; de rotunjire: floor, ceil etc.) - acceptă argumente de tip numeric și întorc
rezultate de tip numeric;

• funcții de tip dată calendaristică (ADD_MONTHS, LAST_DAY, MONTHS_BETWEEN, NEXT_DAY, SYSDATE

etc.) - acceptă argumente de tip dată calendaristică și întorc rezultate de tip dată calendaristică cu excepția
funcției MONTH_BEETWEEN care întoarce o valoare numerică;

• funcții de conversie (TO_CHAR, TO_NUMBER, TO_DATE, CAST) - fac conversia dintr-un tip de dată în
altul;

• funcții generale: NVL, DECODE.

Funcţiile scalare - primesc unul sau mai multe argumente şi returnează valoarea calculată sau NULL în caz
de eroare. Argumentele funcţiilor pot fi constante sau valori ale atributelor specificate prin numele
coloanelor corespunzătoare.

14. Exemple de funcții de grup.

Funcțiile pe mai mutle rânduri (funcții de grup) - lucrează cu grupuri de rânduri pentru a returna un
singur rezultat pentru fiecare grup. Aceste funcții sunt cunoscute cu denumirea de funcții de grup. Toate
funcţiile de grup, mai puţin COUNT(*) ignoră valorile NULL.
Majoritatea funcţiilor de grup acceptă opţiunile: DISTINCT (determină luarea în calcul numai a valorilor
distincte ale rândurilor din cadrul grupului) şi ALL (este implicit și determină luarea în calcul a tuturor
valorilor grupului de rânduri).

15. Sintaxa generală a comenzii SELECT.

Comanda fundamentală a standardului SQL este SELECT, aceasta permiţând interogarea unei baze de date.
Componentele interogării se numesc clause.

Sintaxa generală a comenzii SELECT este următoarea:

SELECT [ALL/DISTINCT/UNIQUE] listă de selecţie

FROM listă de relaţii (tabele)

WHERE condiţie de căutare asupra liniilor

GROUP BY listă de atribute care permit partiţionarea

HAVING condiţie asupra partiţiilor

ORDER BY listă de atribute;

Clauzele SELECT şi FROM sunt obligatorii. SELECT specifică datele care se selectează, iar clauza FROM specifică
relaţiile din care se selectează. Restul clauzelor sunt opţionale.
16. Sintaxa generală instructiunii INSERT

• Instrucţiunea SQL INSERT este folosită pentru inserarea noilor rânduri de date în tabele.
Instrucţiunea are două forme de bază: una în care valorile coloanelor sunt specificate chiar în instrucţiune
şi alta în care valorile sunt selectate dintr-un tabel sau o vizualizare, folosind o subinterogare.

Instrucţiunea INSERT care foloseşte o clauză VALUES poate crea un singur rând la fiecare rulare, deoarece
valorile pentru rândul de date respective sunt specificate chiar în instrucţiune.

INSERT INTO nume_tabel_sau_vizualizare

[(lista_de_coloane)]
VALUES (lista_de_valori);

Sau:

INSERT INTO nume_tabel_sau_vizualizare

[(lista_de_coloane)]
SELECT instructiune_select;

17. Sintaxa generală a instrucţiunii UPDATE.

• Instrucţiunea UPDATE este folosită pentru actualizarea datelor din coloanele unui tabel (sau ale
unei vizualizări). Sintaxa generală a instrucţiunii UPDATE:

UPDATE nume_tabel_sau_vizualizare
SET nume_coloana = expresie
[nume_coloana = expresie...]
[ WHERE conditie];

18. Sintaxa generală a instrucţiunii DELETE.

• Instrucţiunea DELETE şterge unul sau mai multe rânduri dintr-un tabel. Instrucţiunea poate să
folosească şi o vzualizare, dar numai dacă aceasta se bazează pe un singur tabel (ceea ce înseamnă că
instrucţiunile DELETE nu pot fi folosite pentru vizualizări care conţin uniuni). În instrucţiunile DELETE nu
sunt referite niciodată coloane, doarece instrucţiunea şterge rânduri întregi de date, inclusiv toate valorile
datelor (toate coloanele) din rândurile afectate. Dacă vreţi să ştergeţi o singură valoare din rândurile
existente, folosiţi instrucţiunea UPDATE pentru a înlocui valorile respective cu valori nule (presupunând
că valorile nule sunt permise în acele coloane).

Sintaxa generală a instrucţiunii DELETE este

DELETE FROM nume_tabel_sau_vizualizare
[ WHERE conditie ];
19. Comenzile CREATE, ALTER, DROP.

Limbajul de definire a datelor (a schemei unei BD) include instrucţiuni ce permit:

• crearea schemei bazei de date;

• adăugarea relaţiilor la schema bazei;

• ştergerea unor relaţii existente;

• adăugarea de noi atribute relaţiilor existente;

• optimizarea bazei de date (index, grup, declanşator);

• definirea structurii fizice şi logice a unei BD;

• restricţii cu privire la utilizarea structurii.

Comenzi pentru crearea unei baze de date

CREATE DATABASE nume_baza;

Comenzi pentru suprimarea (distrgerea) unei baze de date

DROP DATABASE nume_baza;

Comenzi pentru crearea relaţiilor de bază: in cadrul acestor comenzi se precizează numele relaţiei precum
şi numele şi tipul atributelor.

CREATE TABLE nume_tabela (atribute);

20. Adăugarea/suprimarea unei constrângeri.

• ADD CONSTRAINT <definiţie_restricţie>;

Exemplu:
ADD CONSTRAINT CK_SUMA_DEPOZIT_CLIENT CHECK (SUMA_DEPOZIT_CLIENT >= 0
OR SUMA_DEPOZIT_CLIENT IS NULL);

• ALTER TABLE "nume_tabel"

DROP CONSTRAINT "nume_ restricţie";

Exemplu:
ALTER TABLE Customer DROP CONSTRAINT restrictia_unu;

21. Activarea şi/sau dezactivarea unei constrângeri.

-- Disable all table constraints

ALTER TABLE YourTableName NOCHECK CONSTRAINT ALL
-- Enable all table constraints
ALTER TABLE YourTableName CHECK CONSTRAINT ALL
-------------------------------------------------------------------------------------------------
-- Disable single constraint
ALTER TABLE YourTableName NOCHECK CONSTRAINT YourConstraint
-- Enable single constraint
ALTER TABLE YourTableName CHECK CONSTRAINT YourConstraint

22. Definiți noțiunea de tranzacție. În ce constă controlul tranzacţiilor?

• O tranzacţie în baza de date este un set de comenzi pe care utilizatorul bazei de date vrea sa le
trateze ca pe o unitate funcţionala de tip „totul sau nimic”, întelegând prin aceasta că intreaga tranzactie
trebuie sa reuseasca sau sa esueze. Comenzile pentru cotrolul tranzacţiilor (Transaction Control
Commands ) nu respectă cu exactitate sintaxa instrucţiunilor SQL , dar a fecteaza puternic
comportamentul instructiuunilor SQL incluse în tranzacţii.

Controlul unei baze de date cu ajutorul SQL-ului se referă la:

• asigurarea confidentialitaţii şi securităţii datelor;
• organizarea fizică a datelor;
• realizarea unor performanţe;
• reluarea unor acţiuni în cazul unei defecţiuni;
• garantarea coerenţei datelor în cazul prelucrării concurente.

23. Care sunt modificările pe care le implică execuţia unei comenzi COMMIT? Dar ROLLBACK?

Comanda COMMIT este comanda tranzacțională utilizată pentru salvarea modificărilor invocate de o
tranzacție la baza de date. Comanda COMMIT salvează toate tranzacțiile din baza de date de la ultima
comandă COMMIT sau ROLLBACK.
Sintaxa pentru comanda COMMIT este commit; (doar atat)

Comanda ROLLBACK este comanda tranzacțională utilizată pentru a anula tranzacțiile care nu au fost
deja salvate în baza de date. Această comandă poate fi utilizată numai pentru anularea tranzacțiilor de la
emiterea ultimei comenzi COMMIT sau ROLLBACK.
Sintaxa pentru ROLLBACK:
ROLLBACK; (sau daca se doreste revenirea la un punct de restore, varianta de jos)

ROLLBACK TO SAVEPOINT_NAME;

24. Asigurarea confidențialității și securității datelor.

Sistemul de gestiune trebuie să asigure securitatea fizică şi logică a informaţiei şi să garanteze că

numai utilizatorii autorizaţi pot efectua operaţii corecte asupra bazei de date. Pentru acestea, există

mecanisme care permit identificarea şi autentificarea utilizatorilor şi există proceduri de acces

autorizat care depind de date şi de utilizator, cum ar fi:

• conturi pentru utilizatori, cu parolă folosită pentru autentificare;

• grupuri, roluri, privilegiile și profilurile - acestea permit nu numai constrângeri ci și stabilirea

unei politici de securitate. Pentru a accesa un obiect, un utilizator trebuie să aibă privilegiile

necesare. Privilegiile pot fi acordate direct unui utilizator sau pot fi grupate în roluri, care la

rândul lor pot fi acordate utilizatorului.

Exemplu: Un forum de discuții are utilizatori grupați pe roluri ca: administrator, moderator,

membru. Fiecare rol poate avea privilegii diferite: administratorul poate configura baza de

date (modifică schema, adaugă tabele, configurează interfața); moderatorul poate valida,

modifica, șterge postările membrilor; membrii pot adăuga înregistrări.

25. Reluarea unor acțiuni în cazul unei defecțiuni.

Reluarea unor acțiuni în cazul apariţiei unei defecțiuni hard sau soft presupune recuperarea ultimei

stări coerente a bazei de date. În funcţie de defecţiunea care a determinat întreruperea lucrului,

restaurarea bazei de date se realizează automat de SGBD sau manual, adică necesită intervenţie

umană.

Salvarea bazei de date se realizează conform unei strategii existând combinaţiile:

• copii ale bazei de date şi copii ale jurnalelor acestora;

• jurnale ale tranzacţiilor;

• jurnale ale imaginii înregistrărilor din baza de date.

Copiile bazei de date - pot fi realizate automat de sistem la anumite intervale de timp sau la comanda

administratorului bazei de date, ori de câte ori este nevoie şi de obicei pe un alt suport magnetic decât

cele pe care rezidă baza de date. Aceste copii pot fi utilizate doar în situaţia în care prelucrările

efectuate între momentul realizării copiilor şi cel al apariţiei unei defecţiuni pot fi reluate. Acest lucru

este posibil doar dacă prelucrările sunt efectuate într-o secvenţă cunoscută iar timpul necesar pentru

reprocesarea nu este foarte mare. Durata mare de execuţie pentru astfel de copii face ca anumite

SGBD-uri să recurgă la copii ale jurnalelor bazei de date. Volumul datelor care vor fi copiate în acest

caz va fi mai mic, iar procesul de restaurare va implica într-o măsură mai mică intervenţia umană.

Jurnalul tranzacţiilor - este un fişier special întreţinut de SGBD, în care sunt memorate informaţiile

despre tranzacţiile efectuate asupra bazei de date cum sunt:

 • identificatorul sau codul tranzacţiei;

• momentul începerii execuţiei tranzacţiei;

• numărul terminalului sau identificatorul utilizatorului care a iniţiat tranzacţia;

• datele introduse;

• înregistrările modificate şi tipul modificării.

Jurnalul imaginilor înregistrărilor din baza de date - se deosebeşte de jurnalul tranzacţiilor prin aceea

că el nu conţine descrierea operaţiilor efectuate asupra bazei de date, ci efectul acestora.

26. Se dă următorul tabel: STUDENT(id_student#, nume, prenume, data_nasterii, localitate). Ce va

determina execuția comenzii următoare?
SELECT id_student, nume, prenume
FROM student
WHERE localitate=’Craiova’
AND TO_CHAR(data_nasterii,’MM-YYYY’)=’07-1993’;

 Afiseaza ID-ul, numele si prenumele studentilor din localitatea „Craiova” care sunt nascuti in
iulie 1993

27. Se dă următorul tabel: TABLOU(id_tablou#, titlu, pictor, an_creare). Ce va determina execuția

comenzii următoare?
INSERT INTO tablou(id_tablou, titlu, an_creare)
VALUES (22, ‘Camp cu maci’, 1850);

 Se insereaza un tuplu nou cu detaliile: id_tablou =22, titlu=Camp cu maci si an_creare=1850.

Valoarea pentru „pictor” va fi NULL.

28. Se dă tabelul: ANGAJATI(cod_ang#, nume, pren, data_angajarii, salariu,cod_manager). Ce va

determina execuția comenzii următoare?
SELECT nume, salariu
FROM salariati
WHERE cod_manager = (SELECT cod_ang
FROM salariati
WHERE UPPER(nume) ='POPESCU'
AND UPPER(pren) ='ION);
 Afiseaza numele si salariul angajatilor care au ca manager pe Popescu Ion.
29. Pentru acționarii unei firme se consideră tabelul următor: ACTIUNI (id_actionar#, nume, seriain,
seriaout, valoare) (unde seriain și seriaout reprezintă seria de început, respectiv de sfârșit al intervalului
de acțiuni pe care îl are un acționar). Ce va determina execuția comenzii următoare?
SELECT SUM((seriaout-seriain+1)*valoare))
FROM actiuni;

 Afiseaza valoarea totala a actiunilor pentru actionarul definit de seriaIn si SeriaOut.

30. Se dă următorul tabel: MELODII(id_melodie#, titlu, textier, compozitor, gen, durata). Ce va

determina execuția comenzii următoare?
SELECT *
FROM melodii
WHERE textier IS NOT NULL;

 Va afisa ID-ul, titlul, textierul, compozitorul, genul si durata pentru toate melodiile al caror
textier este cunoscut (diferit de NULL).

31. Se dă următorul tabel: ANGAJATI(id_angajat#, nume, prenume, data_angajarii, salariu, comision,

functia). Ce va determina execuția comenzii următoare?
SELECT nume, functia, salariu
FROM angajati
WHERE salariu > ALL(SELECT salariu
FROM angajati
WHERE functia=’Programator IT’);

 Afiseaza numele, functia si salariul angajatului care are salariul mai mare decat al oricarui
programator IT.

32. Se dă următorul tabel MASINA(id_masina#, denumire, pret_unitar, stoc_curent, categorie,

localitate). Ce va determina execuția comenzii următoare?

SELECT localitate, categorie, SUM(pret_unitar*stoc_curent) as total_valoare

FROM masina
GROUP BY ROLLUP (localitate, categorie);
  Afiseaza toate subtotalurile posibile: valoarea tuturor masinilor din Bucuresti care sunt SUV, --“--
care sunt “alta”, toate masinile din Bucuresti indifferent de categorie (categorie=NULL),etc.
Ultima linie afiseaza totalul pentru toate masinile din stoc. Screenshots cu tabela (primul) si
rezultatele dupa rularea comenzii; as total_valoare e adaugat de mine ca sa fie mai intuitiv ce se
calculeaza in ultima coloana (ar fi fost No_name altfel)

33. Se dă următorul tabel: ANGAJATI(id_angajat#, nume, prenume, data_angajarii, salariu, functia,

id_sef). Ce va determina execuția comenzii următoare?
SELECT id_angajat, nume
FROM angajati
WHERE id_angajat IN (SELECT DISTINCT id_sef
FROM angajati);

 Afiseaza id-ul si numele angajatilor care sunt sefi, o singura data (SELECT DISTINCT selecteaza
doar valorile unice din rezultate).

34. Se dă următorul tabel: SALARIATI(id_angajat#, nume, prenume, cnp, data_angajarii, salariu). Ce

va determina execuția comenzii următoare?
ALTER TABLE SALARIATI
ADD (cod_functie NUMBER(2), email CHAR(25));

 Adauga in tabela SALARIATI doua coloane noi: cod_functie de tip Number(2) si email de tip
Char(25).

35. Se dă următorul tabel: SALARIATI(id_angajat#, nume, prenume, cnp, data_angajarii, salariu,

cod_fuctie, email). Ce va determina execuția comenzii următoare?
ALTER TABLE SALARIATI
DROP (cod_functie, email);

 Nimic, pentru ca cele 2 argumente sunt coloane in SALARIATI, iar comanda este de eliminare de
restrictii (constraints). E posibil sa fie o eroare si comanda pe care intentiona sa o puna sa fie
DROP COLUMN (cod_functie, email);, caz in care se eliminau cele 2 coloane din tabel.
36. Se dau următoarele tabele:
TABLOU (id_tablou#, titlu, data_crearii, valoare, cod_pictor)
PICTOR (id_pictor#, nume, prenume, data_nasterii)
Ce va determina execuția comenzii următoare?
SELECT nume
FROM pictor, tablou
WHERE id_pictor = cod_pictor
GROUP BY nume
HAVING SUM(valoare) > = 200000;

 Afiseaza numele pictorilor care au tablouri cu o valoare totala mai mare sau egala cu 200.000

37. Se dau următoarele două tabele:

FIRMA(id_firma#, denumire, oras)
ANGAJAT(id_angajat#, nume, prenume, salariu, cod_firma)
Ce va determina execuția comenzii următoare?
SELECT id_firma, denumire, AVG(salariu)
FROM angajat, firma
WHERE id_firma = cod_firma
AND oras = ’Bucuresti’
GROUP BY id_firma, denumire;

 Afiseaza ID-ul, denumirea si salariul mediu pentru firmele din Bucuresti.

38. Se dau următoarele două tabele:

CLIENTI(id_client#, nume, prenume, data_nasterii, id_agent)
AGENTI_IMOBILIARI(id_agent#, nume, prenume, salariu, comision)
Ce va determina execuția comenzii următoare?
SELECT c.nume client, a.id_agent, a.nume agent
FROM clienti c
LEFT OUTER JOIN agenti_imobiliari a
ON (c.id_agent = a.id_agent);

 Afiseaza numele clientilor si id-urile si numele agentilor care au lucrat cu acei clienti(daca exista)

Teorie: selectează toate informaţiile din A, pe care le completează cu informaţii din B, în

măsura în care satisfac condiţiile de join; acolo unde nu vor exista informaţii din B, acestea
vor fi completate cu NULL.
39. Se dau următoareale două tabele:
TABLOU (id_tablou#, denumire, data_crearii, valoare, cod_pictor)
PICTOR(id_pictor#, nume, prenume, data_nastere)
Ce va determina execuția comenzii următoare?
SELECT cod_pictor, denumire, valoare
FROM tablou t1
WHERE valoare = (SELECT MAX(valoare)

FROM tablou t2
WHERE t1.cod_pictor = t2.cod_pictor)

 Afiseaza codul pictorului, denumirea si valoarea maxima a tablourilor lui.

40. Se dau următoareale două tabele:

TABLOU(id_tablou#, denumire, data_crearii, valoare, cod_pictor)
PICTOR(id_pictor#, nume, prenume, data_nastere)

Ce va determina execuția comenzii următoare?

SELECT nume, prenume
FROM pictor
WHERE id_pictor IN (SELECT cod_pictor
FROM tablou
WHERE valoare >50000);

 Afiseaza numele si prenumele pictorilor care au tablouri cu valoare mai mare de 50.000
41. Se dau următoarele două tabele:
OPERA_ARTA(id_opera#, titlu, data_creare, nume_autor, pret, cod_gen)
GEN(id_gen#, denumire, descriere)
Ce va determina execuția comenzii următoare?
UPDATE opera_arta
SET pret = pret * 0.5
WHERE cod_gen IN (SELECT id_gen

FROM gen
WHERE denumire NOT IN (‘pictura’, ‘sculptura’));

 Reduce pretul la jumatate pentru operele de arta care NU SUNT picturi sau sculpturi.

42. Se dau următoarele tabele:

PRODUS (id_produs#, denumire, culoare, pret_unitar, stoc_curent, cod_depozit)
DEPOZIT (id_depozit#, denumire, oras)

Observatie: Stocul curent nu poate fi mai mic decat 1. Ce va determina execuția comenzii următoare?
SELECT d.denumire
FROM produs p, depozit d
WHERE p.cod_depozit = d.id_depozit
GROUP BY d.denumire
HAVING COUNT(*) >= 1000;

 Afiseaza denumirea depozitelor care au cel putin 1000 de obiecte.

43. Dacă în tabelul ANGAJAT sunt menținute informații despre angajați, respectiv despre departamentul
și jobul pe care lucrează în prezent, iar în tabelul ISTORIC_ANGAJAT informații despre departamentele și
joburile pe care au lucrat aceștia în trecut, atunci ce va determina execuția comenzii următoare?
SELECT id_angajat, cod_departament, cod_job
FROM angajat
INTERSECT
SELECT id_angajat, cod_departament, cod_job
FROM istoric_angajat;

 Afiseaza angajatii care au lucrat in trecut in acelasi departament ca si in prezent.

Teorie: The SQL INTERSECT operator is used to return the results of 2 or more SELECT statements.
However, it only returns the rows selected by all queries or data sets. If a record exists in one query
and not in the other, it will be omitted from the INTERSECT results.
44. Se dau următoarele trei tabele:
FACTURA (id_factura#, data_emitere)
CONTINE (cod_factura#, cod_produs#, cantitate)
PRODUS(id_produs#, denumire, pret_unitar)
Observație: Facturile conțin produsele vândute. Ce va determina execuția comenzii următoare?
SELECT id_factura, SUM(cantitate*pret_unitar)
FROM contine c, produs p, factura f
WHERE c.cod_produs = p.id_produs
AND c.cod_factura = f.id_factura
AND TO_CHAR(data_emitere,’YYYY’) =TO_CHAR(sysdate,’YYYY’)
GROUP BY id_factura;

 Afiseaza ID-urile si valoarea totala a facturilor emise in anul rularii comenzii.

45. Se dau urmatoarele trei tabele:

ANGAJAT (id_angajat#, nume, prenume, data_angajarii)
LUCREAZA (id_angajat#, id_proiect#, data_inceput, data_sfarsit)
PROIECT (id_proiect#, denumire, descriere, data_lansare, data_predare)
Ce va determina execuția comenzii următoare?
SELECT p.id_proiect, denumire, nume
FROM angajat, lucreaza l, proiect p
WHERE l.id_angajat = angajat.id_angajat
AND lucreaza.id_proiect = p.id_proiect
AND data_sfarsit<sysdate;

 Afiseaza id-ul + denumirea proiectelor si numele tuturor angajatilor care au lucrat la proiectele
terminate pana la data curenta

Table proiecte:
Rezultatul querry-ului:

46. Se dau urmatoarele trei tabele:

ANGAJAT(id_angajat#, nume, prenume, data_angajarii)
LUCREAZA(id_angajat#, id_proiect#)
PROIECT(id_proiect#, denumire, descriere, data_lansare, data_predare)
Ce va determina execuția comenzii următoare?
SELECT id_angajat, nume
FROM angajat
WHERE id_angajat IN (SELECT l.id_angajat
FROM lucreaza l, proiect p
WHERE l.id_proiect = p.id_proiect AND
TO_CHAR(data_lansare,’YYYY’) = 2017
);
 Afiseaza Id-ul si numele angajatilor implicati in proiecte care au 2017 ca an de lansare.

Comanda din enunt e fara paranteza de la final (cu rosu), caz in care da eroare.

47. Se dă următorul tabel:

ANGAJAT(id_angajat#, nume, prenume, data_angajarii, job, sal, ore_suplimentare, plata_ora)

Ce va determina execuția comenzii următoare?

UPDATE angajat
SET plata_ora = ROUND (plata_ora * 1.1, 2)
WHERE job =‘IT ‘ ;

 Mareste salariile angajatilor care lucreaza in IT cu 10% si face o rotunjire a rezultatului la a 2-a
zecimala.
48. Se dau următoarele două tabele:
EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Ce va determina execuția comenzii următoare?
SELECT mgr, MIN(sal)
FROM emp
WHERE mgr IS NOT NULL
GROUP BY mgr
HAVING MIN(sal) > 3000
ORDER BY MIN(sal) DESC;

Table EMP

Querry result:

Am modificat salariul lui Alex (care il are ca manager pe Andrei) la 2900. Rezultatul este acum

 Afiseaza managerul si salariul minim al subalternilor, cu conditia ca toti subalternii acelui

manager sa aibe salarii mai mari de 3.000

49. Se dau următoarele două tabele:

EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)

Ce va determina execuția comenzii următoare?

SELECT YEAR(hiredate) [Anul angajarii],
COUNT(hiredate) [Nr. de angajati]
FROM emp
GROUP BY YEAR(hiredate);

 Afiseaza anii in care s-au facut angajari si numarul de persoane angajate in anii respectivi.
50. Se dă următorul tabel: DATE_PERSOANA(CNP, nume, prenume, nr_telefon, simbol_judet)
Ce va determina execuția comenzii următoare?
SELECT CONCAT('Numele: ',nume) AS numele,
CONCAT('Anul: ', '19',SUBSTRING(CNP,2,2), ' , ' ,
'Luna:',SUBSTRING(CNP,4,2), ', ' ,
'Ziua: ',SUBSTRING(CNP,6,2))
AS data_nasterii
FROM DATE_PERSOANA

 Afiseaza doua concatenari:

o Numele: _@nume
o Anul: 19YY , Luna:MM, Ziua: DD; y,m,d sunt extrase din CNP cu substring (nume
coloana, pozitie de start, numarul de pozitii spre dreapta)

51. Se dă următorul tabel:

SALARIATI (id_angajat#, nume, prenume, cnp, data_angajarii, salariu, cod_fuctie)

Scrieți comanda care șterge din tabelul SALARIATI coloanele cod_fuctie și email.
ALTER TABLE SALARIATI
DROP COLLUMN (cod_functie, email);
-- Vezi ex 35, unde se cerea efectul comenzii --

52. Se dă următorul tabel: ANGAJATI(id_angajat#, nume, data_angajarii, salariu, functia, id_sef). Scrieți
comanda care obține numărul de angajați care au șef.
SELECT COUNT(*) id_angajat
from ANGAJAT
where Id_sef is NOT NULL;
53. Se dă următorul tabel: SALARIATI (id_angajat#, nume, prenume, cnp, data_angajarii, salariu,
cod_fuctie). Scrieți comanda care afișează numele salariaților care câștigă mai mult decât salariul
mediu pe companie, în ordine crescătoare a salariului.
SELECT nume, prenume
FROM SALARIATI
WHERE salariu > avg(salariu)
ORDER BY salariu ASC;

54. Pentru tabelele:

PROFESORI (id_prof#, nume, pren, salariu)
COPII (id_copil#, nume_copil, varsta, id_prof).
Scrieți secvența pentru a afișa profesorii fără copii.
SELECT nume, pren
FROM PROFESORI
WHERE id_prof NOT IN (SELECT DISTINCT id_prof
FROM COPII);
-- DISTINCT pentru ca un prof poate avea mai multi copii ne intereseaza doar valorile unice

55. Se dau următoarele două tabele:

ANGAJAT (id_angajat#, nume, prenume, data_angajarii, id_job, id_departament)
ISTORIC_JOB (id_angajat#, data_inceput#, data_sfarsit, id_job, id_departament)
Observație: Tabelul ANGAJAT conține informații prezente referitoare la departamentul și
jobul angajatului, iar tabelul ISTORIC_JOB conține informații referitoare la trecut.
Scrieți comanda care obține codul, numele și prenumele tuturor angajatilor firmei care au lucrat
la un moment dat în departamentul 30 și în prezent lucrează în alt departament.
SELECT A.id_angajat, nume, prenume
FROM ANGAJAT A, Istoric_job I
WHERE A.id_departament <> 30
AND I.id_departament = 30
AND A.id_angajat = I.id_angajat;

56. Se dau următoarele două tabele:

TABLOU (id_tablou#, titlu, an_creatie, nume_pictor, id_sala)
SALA (id_sala#, denumire, capacitate)
Scrieți comanda care afișează toate sălile în care nu sunt expuse tablouri.
SELECT denumire
FROM SALA
WHERE id_sala NOT IN (SELECT DISTINCT id_sala
FROM TABLOU);
-- DISTINCT pentru ca intr-o sala sunt mai multe tablouri, ne intereseaza doar valorile unice
57. Se dă următorul tabel: STUDENTI (nume, prenume, nrmatricol, grupa, datan, adresa, media)
Pentru fiecare grupă se cere numărul de studenti, media minimă şi media maximă.
SELECT COUNT (nrmatricol), grupa, MIN(media), MAX(media)
FROM STUDENTI
GROUP BY grupa ASC;

58. Se dau următoarele două tabele:

STUDENTI (nume, prenume, nrmatricol, grupa, datan, adresa, media)
PROFILE (denumire, cod_grupa)
Se cer studenţii de la grupele cu profil electric(ELE) sau mecanic(MEC), care au media mai mare
decât media generală a studenţilor de la aceste grupe.
select denumire, nume, media
from STUDENTI S, PROFILES P
where media > ALL(select avg(media)
from STUDENTI S, PROFILES P
where s.grupa=p.cod_grupa
and denumire IN ('ele', 'mec'))
and s.grupa=p.cod_grupa

59. Se dă următorul tabel: PROFESOR (Cod_Prof#, Nume, Disciplina, DataN, Telefon)

Se cere numărul de profesori născuţi în acelaşi an.
SELECT YEAR(datan) as [Anul nasterii],
COUNT(datan) [Nr. de profesori]
FROM PROFESOR
GROUP BY YEAR(datan);
--ex 49--

60. Se dă următorul tabel: PROFESOR (Cod_Prof#, Nume, Disciplina, DataN, Telefon)

Se cer profesorii care sunt născuţi în număr de 2 în acelaşi an.
SELECT Nume
FROM PROFESOR
GROUP BY YEAR(datan);
HAVING COUNT (YEAR (datan)) = 2;

61. Se dau următoarele două tabele:

SCOALA (Cod_Scoala#, Nume, Adresa, Cod_Director, Cod_Prof)
PROFESOR (Cod_Prof#, Nume, Disciplina, DataN, Telefon)
Se cer toate datele despre profesorii de la şcoala cu codul ’S308’, cu vârsta mai mică decât vârsta
medie a profesorilor (din toate şcolile).
 SELECT Cod_Prof, Nume, Disciplina, DataN, Telefon
FROM PROFESOR
WHERE ((EXTRACT YEAR FROM SYSDATE) - (EXTRACT YEAR FROM DataN )) < select (AVG(((EXTRACT
. YEAR FROM SYSDATE) - (EXTRACT YEAR FROM DataN )))
FROM PROFESOR);
AND Cod_Prof IN (SELECT Cod_Prof
FROM SCOALA
WHERE Cod_Scoala = ‘S308’);

62. Se dau următoarele două tabele:

SCOALA (Cod_Scoala#, Nume, Adresa, Cod_Director, Cod_Prof)
PROFESOR (Cod_Prof#, Nume, Disciplina, DataN, Telefon)
Se cer toate datele despre profesorii care au cel putin un director mai tânăr decât ei.

SELECT p.*
FROM scoala s
natural join profesor p
WHERE p.datan < (SELECT datan
FROM profesor pr
WHERE pr.cod_prof = s.cod_director);

63. Se dau următoarele două tabele:

PROFESORI (cod_profesor#, nume, prenume, salariu, cod_facultate)
TOTALURI (cod_facultate#, nr_profesor, total_salarii)
Folosind informațiile din tabelul PROFESORI, se cere să se insereze în tabelul TOTALURI numărul
de profesori și suma totală a salariilor pentru fiecare facultate.
INTO totaluri (cod_facultate, nr_profesor, total_salarii)
Values (SELECT cod_facultate, count(*), sum(salariu)
FROM profesori p
GROUP BY cod_facultate);

64. Se dă următorul tabel:

DATE_PERSOANA (CNP, nume, prenume, nr_telefon, simbol_judet)
Modificaţi toate numerele de telefon din judeţul Maramureş, astfel ca prefixul să nu mai fie 0262 ci
0362.
UPDATE date_persoana
SET nr_telefon = '0362' || substr(nr_telefon, 4)
WHERE nr_telefon like '0262%';
65. Se dau următoarele trei tabele:
FURNIZORI (id_furnizor#, numeF, oras)
COMPONENTE (cod_componenta#, numeC, culoare, localitate)
FURNIZORI_COMPONENTE (id_furnizor#, cod_componenta#, cantitate)
Se presupune că fiecare furnizor este localizat în exact un singur oraş. Se cere numele furnizorilor ce au
livrat componenta C2 şi care sunt oraşele din care provin aceşti furnizori.
SELECT f.numeF, f.oras
FROM furnizori_componente fc
INNER JOIN componente c on c.cod_componenta = fc.cod_componenta
INNER JOIN furnizori f on f.id_furnizor = cfc.id_furnizor
WHERE c.numeC = 'C2';

66. Se dau următoarele trei tabele:

FURNIZORI (id_furnizor#, numeF, oras)
COMPONENTE (cod_componenta#, numeC, culoare, localitate)
FURNIZORI_COMPONENTE (id_furnizor#, cod_componenta#, cantitate)
Se presupune că fiecare furnizor este localizat în exact un singur oraş. Se cere să se determine
componenta roşie care s-a livrat în cea mai mare cantate.
WITH q AS (
SELECT cod_componenta, numeC, count(*) as cantitate
FROM furnizori_componente fc
INNER JOIN componente c on c.cod_componenta = fc.cod_componenta
WHERE c.culoare = 'rosu')
SELECT *
FROM q
WHERE cantitate = max(cantitate);

67. Se dau următoarele trei tabele:

FURNIZORI (id_furnizor#, numeF, oras)
COMPONENTE (cod_componenta#, numeC, culoare, localitate)
FURNIZORI_COMPONENTE (id_furnizor#, cod_componenta#, cantitate)
Se presupune că fiecare furnizor este localizat în exact un singur oraş. Se cere să se determine din ce
oraş provine furnizorul cu cele mai puţine componente vândute, şi care sunt aceste componente.
WITH q AS (
SELECT id_furnizor, numeF, count(*) cantitate
FROM furnizori_componente fc
INNER JOIN furnizori f on f.id_furnizor = fc.id_furnizor
)
SELECT id_furnizor, numeF, oras, c.numeC
FROM q
INNER JOIN furnizori_componente fc on fc.id_furnizor = q.id_furnizor
INNER JOIN componente c on c.cod_componenta = fc.cod_componenta
WHERE cantitate = min(cantitate);
68. Se dau următoarele două tabele:
EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze angajaţii cu acelaşi job ca şi angajatul cu codul 7369 şi cu salariul mai mare decât al
angajatului cu codul 7876.
SELECT empno, sal
FROM EMP
WHERE job = (SELECT job
FROM EMP
WHERE empno = 7369)
AND sal > (SELECT sal
FROM EMP
WHERE empno = 7876)
-- exercitiu asemanator in cartea de PL/SQL pag 133

69. Se dau următoarele două tabele:

EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze toate departamentele cu salariul minim mai mare decât salariul minim din departamentul
20.
SELECT deptno
FROM emp
GROUP BY deptno
HAVING MIN (sal) > (SELECT MIN(sal)
FROM emp
WHERE deptno = 20);

70. Se dau următoarele două tabele:

EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze codul, numele şi jobul angajaţilor cu salariul mai mic decât cel al oricărui funcţionar şi care
nu sunt funcţionari.
SELECT empno, ename, job
FROM emp
WHERE sal < ANY (SELECT sal
FROM emp
WHERE job = 'functionar')
AND job <> 'functionar';
-- exercitiu asemanator in cartea de PL/SQL pag 134
71. Se dau următoarele două tabele:
EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze angajaţii (nume, nr. departament, salariu şi comision) ale căror salariu şi comision sunt
identice cu cele ale oricărui angajat din departamentul 30.
SELECT ename, deptno, sal, comm
FROM emp
WHERE sal IN (SELECT sal
FROM emp
WHERE deptno = 30)
AND comm IN (SELECT comm
FROM emp
WHERE deptno = 30);

72. Se dau următoarele două tabele:

EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze numele angajatului cu cea mai mare vechime în muncă şi cel mai nou în firmă.
-- Cel mai nou angajat:
select top 1 ename, hiredate
from emp
order by hiredate desc

--Cel mai vechi angajat:

select top 1 ename, hiredate
from emp
order by hiredate asc

73. Se dau următoarele două tabele:

EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze maximul, minimul şi suma salariilor pentru fiecare tip de job, în cadrul fiecărui
departament.
select job,deptno, min(sal) as Sal_min, max(sal) as Sal_max, sum(sal) as Total
from emp
group by job, deptno
74. Se dau următoarele două tabele:
EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze angajaţii care au subordonaţi (sunt şefi).
SELECT ename
FROM EMP
WHERE empno IN (SELECT DISTINCT mgr
FROM EMP);

75. Se dau următoarele două tabele:

EMP (empno#, ename, job, mgr, hiredate, sal, comm, deptno)
DEPT (deptno#, dname, loc)
Să se afişeze salariul total plătit pe fiecare job în cadrul fiecărui departament.
--similar cu 73--
select job, deptno, sum(sal) as Total
from emp
group by job, deptno