/* Scriei o instruciune SQL care s afieze numrul de produse din fiecare

categorie(cmpuri afiate: id_categorie, denumire i numr produse). */

SELECT c.id_categorie, denumire, COUNT(id_produs) AS nr_produse
FROM categorii c JOIN produse p
ON c.id_categorie = p.id_categorie
GROUP BY c.id_categorie;

/* Scriei o instruciune SQL care s afieze produsele mai ieftine dect preul
mediu al tuturor produselor din baza de date (cmpuri afiate: id_produs,
denumire_produs i pret). */
SELECT id_produs, denumire_produs, pret,
(SELECT AVG(pret) FROM produse) AS pret_mediu
FROM produse
WHERE pret < (SELECT AVG(pret) FROM produse);

/* Scriei o instruciune SQL care s afieze produsele mai scumpe dect toate
produsle din categoria Imprimante (cmpuri afiate: id_produs, denumire_produs i
pret). */
SELECT id_produs, denumire_produs, pret FROM produse
WHERE pret > ALL(SELECT pret FROM produse
WHERE id_categorie = 3);

/* Creai o tabel virtual actualizabil care s stocheze toi clienii din

provincie. */
CREATE VIEW clienti_provincie AS
SELECT * FROM clienti WHERE localitate <> 'Bucuresti';

/* Scriei o instruciune SQL care s afieze clienii care au comandat aceeai

cantitate dintr-un produs ntr-o comand cu primul client introdus n baza de date
(valoarea minim din cmpul id_client). Cmpuri afiate: nume_client (conine
cmpurile nume i prenume din tabela clienti), localitate i cantitate comandat.
*/
SELECT CONCAT_WS(" ",nume,prenume) AS nume_client,
localitate, cantitate FROM clienti c JOIN comenzi com
ON c.id_client = com.id_client
WHERE cantitate IN(SELECT cantitate FROM comenzi
WHERE id_client = (SELECT MIN(id_client) FROM comenzi));

/*Creai o tabel virtual actualizabil care s stocheze toi clienii care au

comandat tablete. */
CREATE VIEW tablete AS
SELECT c.id_client, nume, prenume, denumire_produs FROM
clienti c JOIN comenzi com
ON c.id_client = com.id_client
JOIN produse p ON com.id_produs = p.id_produs

/* afisarea numarului de orase din fiecare tara */

SELECT b.Name, COUNT(a.ID) AS "Numar orase"
FROM city a RIGHT JOIN country b
ON a.CountryCode = b.Code
GROUP BY b.Name
ORDER BY COUNT(a.ID) DESC;

/* limbile oficiale vorbite in Africa */

SELECT a.Name, a.Continent,
 b.`Language`, b.IsOfficial
FROM country a, countrylanguage b
WHERE a.Code = b.CountryCode
AND a.Continent = 'Africa'
AND b.IsOfficial = 'T'
ORDER BY a.Name;

/* capitalele monarhiilor din Europa */

SELECT a.Name, a.Continent, a.GovernmentForm,
b.Name AS Capitala
FROM country a JOIN city b
ON a.Capital = b.ID
WHERE a.Continent = 'Europe'
AND a.GovernmentForm LIKE '%monarchy%';

/* afisare angajati de la locatiile din America */

SELECT e.FIRST_NAME, e.LAST_NAME,
c.CITY, b.COUNTRY_NAME, a.REGION_NAME
FROM regions a, countries b,
locations c, departments d, employees e
WHERE e.DEPARTMENT_ID = d.DEPARTMENT_ID
AND d.LOCATION_ID = c.LOCATION_ID
AND c.COUNTRY_ID = b.COUNTRY_ID
AND b.REGION_ID = a.REGION_ID
AND a.REGION_NAME LIKE 'America%';

/* totalul salariilor angajatilor pe fiecare tara */

SELECT d.COUNTRY_NAME, SUM(a.SALARY) AS
"Total salarii"
FROM employees a, departments b,
locations c, countries d
WHERE a.DEPARTMENT_ID = b.DEPARTMENT_ID
AND b.LOCATION_ID = c.LOCATION_ID
AND c.COUNTRY_ID = d.COUNTRY_ID
GROUP BY d.COUNTRY_NAME
ORDER BY SUM(a.SALARY) DESC;

/* functiile angajatilor din departamentele IT si SALES */

SELECT DISTINCT a.DEPARTMENT_NAME, c.JOB_TITLE
FROM departments a
JOIN employees b
ON a.DEPARTMENT_ID = b.DEPARTMENT_ID
JOIN jobs c
ON c.JOB_ID = b.JOB_ID
WHERE a.DEPARTMENT_NAME LIKE '%IT%'
OR a.DEPARTMENT_NAME LIKE '%Sales%'

/* clientii fara comenzi */

SELECT a.customerName, b.orderNumber
FROM customers a
LEFT JOIN orders b
ON a.customerNumber = b.customerNumber
WHERE b.orderNumber IS NULL;

/* angajatii care nu au interactionat cu clienti */

SELECT a.lastName, a.firstName, a.jobTitle,
 b.customerNumber AS "Nume client"
FROM employees a LEFT JOIN
customers b
ON a.employeeNumber = b.salesRepEmployeeNumber
WHERE b.customerNumber IS NULL
UNION
SELECT a.lastName, a.firstName, a.jobTitle,
b.customerName
FROM employees a RIGHT JOIN
customers b
ON a.employeeNumber = b.salesRepEmployeeNumber
WHERE a.employeeNumber IS NULL;

/* Scrieti o instructiune SQL prin care sa afisati capitalele tarilor din Africa in
care limba oficiala este Engleza sau Franceza */
SELECT a.Name, b.Name, a.Continent,
c.`Language`, c.IsOfficial
FROM country a, city b, countrylanguage c
WHERE a.Capital = b.ID
AND a.Code = c.CountryCode
AND a.Continent = 'Africa'
AND c.IsOfficial = 'T'
AND c.`Language` IN('French','English');

/* Scrieti o instructiune SQL prin care sa afisati clientii cu mai mult de 2

comenzi */
SELECT a.customerName,
COUNT(b.orderNumber) AS "Numar comenzi"
FROM customers a JOIN orders b
ON a.customerNumber = b.customerNumber
GROUP BY a.customerName
HAVING COUNT(b.orderNumber) > 2
ORDER BY COUNT(b.orderNumber);

/* capitalele din Europa; afisare: nume oras */

SELECT name
FROM city
WHERE ID IN
(SELECT Capital FROM country
WHERE Continent LIKE 'Euro%');

/* tarile din Europa cu suprafata mai mare decat suprafata medie a tuturor tarilor
din Europa; afisare: nume tara si suprafata */
SELECT AVG(SurfaceArea) FROM
country WHERE Continent = 'Europe';

SELECT Name, SurfaceArea FROM

country
WHERE SurfaceArea > (SELECT AVG(SurfaceArea) FROM
country WHERE Continent = 'Europe')
AND Continent = 'Europe';

/* tarile cu cea mai mare populatie de pe fiecare continent */

SELECT Continent, MAX(Population)
FROM country
GROUP BY Continent;

SELECT a.Name, a.Continent, a.Population

FROM country AS a,
 (SELECT Continent, MAX(Population)
AS maxim
FROM country
GROUP BY Continent) AS b
WHERE a.Continent = b.Continent
AND Population IN(b.maxim);

/* angajatii de la locatiile din Canada */

SELECT FIRST_NAME, LAST_NAME
FROM employees
WHERE DEPARTMENT_ID IN
(SELECT DEPARTMENT_ID FROM departments
WHERE LOCATION_ID IN
(SELECT LOCATION_ID FROM locations
WHERE COUNTRY_ID =
(SELECT COUNTRY_ID FROM countries
WHERE COUNTRY_NAME LIKE 'Canada')));

/* managerii de departamente */
SELECT FIRST_NAME, LAST_NAME,
DEPARTMENT_ID
FROM employees a
WHERE EMPLOYEE_ID IN
(SELECT MANAGER_ID FROM departments)

/* angajatii si managerii lor; SELF JOIN */

SELECT
CONCAT(ang.FIRST_NAME,' ',ang.LAST_NAME)
AS "Nume angajat",
CONCAT(mng.FIRST_NAME,' ',mng.LAST_NAME)
AS "Nume manager"
FROM employees ang LEFT JOIN employees mng
ON ang.MANAGER_ID = mng.EMPLOYEE_ID;

/* angajatii si managerii lor; subinterogari*/

SELECT
CONCAT(ang.FIRST_NAME,' ',ang.LAST_NAME)
AS "Nume angajat", ang.MANAGER_ID
FROM employees ang
WHERE ang.MANAGER_ID IN
(SELECT mng.EMPLOYEE_ID FROM
employees mng);

/* angajatii care nu sunt manageri - utilizare operator NOT IN */

SELECT FIRST_NAME, LAST_NAME
FROM employees
WHERE employee_ID
NOT IN
(SELECT MANAGER_ID FROM employees);

/* angajatii care nu sunt manageri - utilizare operator NOT EXISTS */

SELECT FIRST_NAME, LAST_NAME
FROM employees mng
WHERE NOT EXISTS
(SELECT FIRST_NAME, LAST_NAME
FROM employees ang
WHERE ang.MANAGER_ID = mng.EMPLOYEE_ID);
/* angajatii de la biroul din Boston */
SELECT lastName, firstName
FROM employees
WHERE officeCode IN
(SELECT officeCode FROM offices
WHERE city = 'Boston');

/* produsele cu stocul mai mare decat al tuturor produselor Ford */

SELECT productName, quantityInStock
FROM products
WHERE quantityInStock >
(SELECT MAX(quantityInStock)
FROM products WHERE productName
LIKE '%Ford%');

/* produsele a caror cantitate totala comandata este mai mica decat 25*media
cantitatilor comandate ale tuturor produselor */
SELECT a.productName, SUM(b.quantityOrdered)
AS "Total Cantitate comandata"
FROM products a JOIN
orderdetails b
USING(productCode)
GROUP BY a.productName
HAVING SUM(quantityOrdered)
< 25*(SELECT AVG(quantityOrdered)
FROM orderdetails);

/* cel mai vechi si cel mai nou angajat din fiecare departament */
SELECT a.DEPARTMENT_NAME,
b.FIRST_NAME, b.LAST_NAME,
b.HIRE_DATE
FROM departments a JOIN
employees b
ON a.DEPARTMENT_ID = b.DEPARTMENT_ID
JOIN
(SELECT DEPARTMENT_ID, MAX(HIRE_Date)
AS maxim
FROM employees
GROUP BY DEPARTMENT_ID) AS c
ON b.DEPARTMENT_ID = c.DEPARTMENT_ID
JOIN
(SELECT DEPARTMENT_ID, MIN(HIRE_Date)
AS minim
FROM employees
GROUP BY DEPARTMENT_ID) AS d
ON b.DEPARTMENT_ID = d.DEPARTMENT_ID
WHERE b.HIRE_DATE IN(c.maxim,d.minim);

SUBINTEROGARI

/*Scrieti o instructiune SQL prin care sa afisati tarile cu mai mult de o limba
oficiala */
SELECT a.Name, a.Continent, COUNT(b.`Language`)
FROM country a JOIN countrylanguage b
ON a.Code = b.CountryCode
WHERE b.IsOfficial = 'T'
GROUP BY a.Name
HAVING COUNT(b.`Language`) > 1;
/* Scrieti o instructiune SQL prin care sa afisati produsele cu cele mai mici 10
totaluri de cantitati comandate */
SELECT productName, b.suma
FROM products a JOIN
(SELECT productCode,
SUM(quantityOrdered) as suma FROM
orderdetails GROUP BY productCode
ORDER BY SUM(quantityOrdered)
LIMIT 10) AS b
ON a.productCode = b.productCode
GROUP BY productName
ORDER BY b.suma;

/*Scrieti o instructiune SQL prin care sa afisati cel mai vechi si cel mai nou
angajat al companiei */
SELECT a.FIRST_NAME, a.LAST_NAME,
a.HIRE_DATE
FROM employees a
WHERE a.HIRE_DATE IN
((SELECT MIN(HIRE_DATE) FROM
employees),(SELECT MAX(HIRE_DATE) FROM
employees));

/* Scrieti o instructiune SQL prin care sa afisati departamentul cu cel mai mic
total al salariilor */
SELECT a.DEPARTMENT_NAME, SUM(b.SALARY)
FROM departments a, employees b
WHERE a.DEPARTMENT_ID = b.DEPARTMENT_ID
GROUP BY a.DEPARTMENT_NAME
HAVING SUM(salary) =
(SELECT SUM(salary) FROM employees
GROUP BY DEPARTMENT_ID ORDER BY
SUM(salary) LIMIT 1);

/* crearea unei tabele temporare ce va contine capitalele din America de Nord */

CREATE TEMPORARY TABLE capitale
AS
SELECT a.Name, a.Continent,
b.Name AS capitala
FROM country a JOIN city b
ON a.Capital = b.ID
WHERE a.Continent LIKE '%North%';

/* afisarea inregistrarilor din tabela temporara */

SELECT * FROM capitale;

DROP TEMPORARY TABLE capitale;

/* exemplu de tranzactie */

START TRANSACTION;
INSERT INTO countries
VALUES ('GR','Grecia',1),
('CY','Cipru',1),
('AT','Austria',1);
SAVEPOINT s1;
DELETE FROM countries
WHERE REGION_ID=2;
ROLLBACK TO s1;

START TRANSACTION;
INSERT INTO countries
VALUES ('IT','Italia',1),
('ES','Spania',1),
('FR','Franta',1);
COMMIT;

ROLLBACK;

PROCEDURI
/* procedura care primeste un continent si returneaza numele tarii cu cea mai mare
suprafata de pe acel continent, capitala acelei tari si suprafata tarii respective
*/
DELIMITER //
CREATE PROCEDURE suprafata(IN pContinent VARCHAR(20), OUT tara VARCHAR(50), OUT
capitala VARCHAR(60), OUT pSuprafata DOUBLE)
BEGIN
SELECT a.Name, a.SurfaceArea, b.Name/
INTO tara, pSuprafata, capitala
FROM country a JOIN city b
ON a.Capital = b.ID
WHERE a.Continent = pContinent
AND a.SurfaceArea = (SELECT
MAX(SurfaceArea) FROM country
WHERE Continent = pContinent);
END;
//
DELIMITER ;

CALL suprafata('Africa',@a,@b,@c);

SELECT @a AS "Tara", @b AS "Capitala",

@c AS "Suprafata";

/* Implementai o procedur stocat care va primi ca valoare de intrare un nume de

departament i va returna numrul de angajai din acel departament, ara n care
i desfoar activitatea angajaii din acel departament, salariul mediu al
angajailor din acel departament, precum i numele managerului departamentului
respectiv. */
USE company;

DROP PROCEDURE IF EXISTS exercitiu;

DELIMITER **
CREATE PROCEDURE exercitiu1(IN dept VARCHAR(30), OUT nr INT(3), OUT tara
VARCHAR(40), OUT sal INT(10), OUT manager VARCHAR(50))
BEGIN
SELECT
COUNT(b.EMPLOYEE_ID) INTO nr
FROM departments a
JOIN employees b
ON a.DEPARTMENT_ID=b.DEPARTMENT_ID
WHERE a.DEPARTMENT_NAME = dept;

SELECT
c.COUNTRY_NAME INTO tara
 FROM departments a
JOIN locations b
ON a.LOCATION_ID = b.LOCATION_ID
JOIN countries c
ON b.COUNTRY_ID=c.COUNTRY_ID
WHERE a.DEPARTMENT_NAME = dept;

SELECT
ROUND(AVG(b.SALARY)) INTO sal
FROM departments a
JOIN employees b
ON a.DEPARTMENT_ID=b.DEPARTMENT_ID
WHERE a.DEPARTMENT_NAME = dept;

SELECT
CONCAT(FIRST_NAME,' ',LAST_NAME)
INTO manager
FROM employees
WHERE EMPLOYEE_ID =
(SELECT MANAGER_ID FROM departments
WHERE DEPARTMENT_NAME LIKE dept);

IF tara IS NULL THEN

SET tara := 'Unknown';
END IF;
IF sal IS NULL THEN
SET sal := 0;
END IF;
IF manager IS NULL THEN
SET manager := 'Unknown';
END IF;
END;
**
DELIMITER ;

CALL exercitiu('IT',@a,@b,@c,@d);
SELECT @a AS "Numarul de angajati din departament",
@b AS "Tara in care se afla locatia",
@c AS "Salariul mediu din departament",
@d AS "Managerul departamentului";

/* Implementati o functie care primeste un numar de comanda (orderNumber) si

returneaza numarul de comenzi neanulate (status != 'Cancelled') din anotimpul
corespunzator comenzii introduse si din anul corespunzator comenzii introduse;
Exemplu:
Valoarea returnata va fi de forma: In anotimpul primavara din anul 2004 au fost 20
de comenzi neanulate */

DROP FUNCTION IF EXISTS comenzi_anotimp;

DELIMITER //
CREATE FUNCTION comenzi_anotimp(nrcom INT(11)) RETURNS VARCHAR(100)
BEGIN
DECLARE rezultat VARCHAR(100);
DECLARE anotimp VARCHAR(15);
DECLARE an, luna, nr INT(4);
SELECT
YEAR(orderDate), MONTH(orderDate)
 INTO an, luna
FROM orders
WHERE orderNumber = nrcom;
CASE
WHEN luna IN(3,4,5) THEN
SELECT COUNT(orderNumber)
INTO nr
FROM orders
WHERE status != 'Cancelled'
AND MONTH(orderDate) IN(3,4,5)
AND YEAR(orderDate) = an;
SET anotimp := 'primavara';

WHEN luna BETWEEN 6 AND 8 THEN

SELECT COUNT(orderNumber)
INTO nr
FROM orders
WHERE status != 'Cancelled'
AND MONTH(orderDate) IN(6,7,8)
AND YEAR(orderDate) = an;
SET anotimp := 'vara';

WHEN luna BETWEEN 9 AND 11 THEN

SELECT COUNT(orderNumber)
INTO nr
FROM orders
WHERE status != 'Cancelled'
AND MONTH(orderDate) IN(9,10,11)
AND YEAR(orderDate) = an;
SET anotimp := 'toamna';

ELSE
SELECT COUNT(orderNumber)
INTO nr
FROM orders
WHERE status != 'Cancelled'
AND MONTH(orderDate) IN(1,2,12)
AND YEAR(orderDate) = an;
SET anotimp := 'iarna';

END CASE;

IF nr = 0 THEN
SET rezultat := 'Numarul de comanda introdus nu exista!';
ELSE
SET rezultat := CONCAT('In anotimpul ',anotimp,' din anul ',an,' au fost
',nr,' comenzi neanulate');
END IF;
RETURN rezultat;
END;
//
DELIMITER ;

SELECT comenzi_anotimp(10248);

/* procedura care afiseaza angajatii si un username pentru fiecare angajat; */

DELIMITER //
CREATE PROCEDURE useri()
BEGIN
DECLARE nume, username VARCHAR(100);

DECLARE cursor_useri CURSOR FOR

SELECT
CONCAT(lastName,' ', firstName),
SUBSTR(email,1,LOCATE('@',email)-1)
FROM employees;

DECLARE CONTINUE HANDLER FOR NOT FOUND

BEGIN
SET @ok := 0;
END;
DROP TEMPORARY TABLE IF EXISTS t1;
CREATE TEMPORARY TABLE t1(
nume VARCHAR(100),
username VARCHAR(100)
);

/* deschiderea cursorului */
OPEN cursor_useri;

SET @ok := 1; /*

WHILE @ok = 1 DO /*
FETCH cursor_useri
INTO nume, username;
INSERT INTO t1
VALUES(nume, username);
END WHILE;

CLOSE cursor_useri;

SELECT * FROM t1;

END;
//
DELIMITER ;

CALL useri();

/* trigger-ul se va declansa automat inainte de efectuarea de comenzi UPDATE pe

tabele orderdetails */
DELIMITER //
CREATE TRIGGER actualizare_stoc BEFORE UPDATE ON orderdetails FOR EACH ROW
BEGIN
DECLARE stoc_actual, stoc_nou INT(5);
DECLARE mesaj VARCHAR(100);
IF NEW.quantityOrdered <> OLD.quantityOrdered THEN
SELECT quantityInStock INTO stoc_actual
FROM products
WHERE productCode = OLD.productCode;

SET stoc_nou = NEW.quantityOrdered - OLD.quantityOrdered;

IF stoc_nou <= stoc_actual THEN

UPDATE products
 SET quantityInStock = stoc_actual - stoc_nou
WHERE productCode = OLD.productCode;

ELSE
SET mesaj := CONCAT('Stoc indisponibl! Din acest produs mai sunt in
stoc ',stoc_actual,' bucati.');
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = mesaj;
END IF;

END IF;

END;
//
DELIMITER ;

UPDATE orderdetails
SET quantityOrdered = 2730
WHERE productCode = 'S18_1749'
AND orderNumber = 10100;

SELECT * FROM products

WHERE productCode = 'S18_1749';

UPDATE orderdetails
SET quantityOrdered = 2770
WHERE productCode = 'S18_1749'
AND orderNumber = 10100;

UPDATE orderdetails
SET quantityOrdered = 20
WHERE productCode = 'S18_1749'
AND orderNumber = 10100;

/* procedura care primeste un id de categorie si returneaza

produsul (denumire, pret) cel mai scump din categoria respectiva */

DELIMITER //
CREATE PROCEDURE pret_maxim(IN id_cat INT(2), OUT den VARCHAR(50),
OUT pret_max DOUBLE(7,2))
BEGIN
SELECT denumire_produs, pret INTO den, pret_max FROM produse
WHERE pret = (SELECT MAX(pret) FROM produse
WHERE id_categorie = id_cat)
AND id_categorie = id_cat;
END;
//
DROP PROCEDURE pret_maxim;

CALL pret_maxim(1,@d,@p);
SELECT @d AS denumire, @p AS pret_maxim;

CALL pret_maxim(2,@d,@p);
SELECT @d AS denumire, @p AS pret_maxim;
/* trigger la INSERT in tabela comenzi
in cazul in care cantitatea comandata dintr-un produs depaseste
cantiatea din tabela produse este afisat un mesaj de eroare,
altfel sa se realizeze update pe cantitate in tabela produse */

DELIMITER //
CREATE TRIGGER verificare_stoc BEFORE INSERT ON comenzi FOR EACH ROW
BEGIN
DECLARE id_prod, cant INT DEFAULT 0;
DECLARE mesaj VARCHAR(50);
SET mesaj := '';
SELECT id_produs, cantitate INTO id_prod, cant FROM produse WHERE
id_produs = NEW.id_produs;
IF cant >= NEW.cantitate THEN
CALL actualizare_stoc(id_prod,NEW.cantitate);
ELSE
SET mesaj := 'Cantitatea comandata nu este disponibila in stoc!';
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = mesaj;
END IF;
END;
//

DELIMITER //
CREATE PROCEDURE actualizare_stoc(IN id INT, IN c INT)
BEGIN
UPDATE produse SET cantitate = cantitate - c WHERE id_produs = id;
END;
//

DROP TRIGGER verificare_stoc;

INSERT INTO comenzi (id_produs, id_client, cantitate)

VALUES (1,2,3);

INSERT INTO comenzi (id_produs, id_client, cantitate)

VALUES (1,2,8);

INSERT INTO comenzi (id_produs, id_client, cantitate)

VALUES (1,2,7);

/* trigger la UPDATE in tabela angajati

daca varsta la momentul angajarii nu este 18 ani afisam un mesaj de
eroare */
DELIMITER $$
CREATE TRIGGER verifica_varsta BEFORE UPDATE ON angajati FOR EACH ROW
BEGIN
DECLARE m VARCHAR(70);
IF YEAR(NEW.data_angajarii) - YEAR(NEW.data_nasterii) < 18 THEN
SET m := 'Persoana nu are 18 ani!';
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = m;
END IF;
END;
$$

UPDATE angajati SET data_nasterii = '1990-10-20' WHERE id_angajat = 1;

UPDATE angajati SET data_nasterii = '2000-07-05' WHERE id_angajat = 2;

/* functie care compara doua numere si returneaza un sir de caractere in functie de
valoarea celor doua numere */
DELIMITER $$
CREATE FUNCTION compara2(a INT, b INT) RETURNS VARCHAR(20)
BEGIN
DECLARE sir VARCHAR(20);
CASE
WHEN a = b THEN SET sir := '=';
WHEN a > b THEN SET sir := '>';
ELSE SET sir := '<';
END CASE;
SET sir := CONCAT_WS(" ",a,sir,b);
RETURN sir;
END;
$$

SELECT compara2(10,8);
SELECT compara2(5,5);