MyCodeSchool

Pasul 1 din 5

MySQL

Pasul 1 din 5 · Ce construiești

  • MySQL
  • Începător
  • 14 minute

Baza de date a unei biblioteci, de la zero

Biblioteca școlii ține evidența pe hârtie. Tu o muți într-o bază de date MySQL și o întrebi direct: cine are cărți neîntoarse de mai mult de două săptămâni?

mysql, pe 7 noiembrie 2026
mysql> SOURCE intarzieri.sql
+------+-------+------+
| nume | titlu | zile |
+------+-------+------+
| Ana  | Ion   |   18 |
+------+-------+------+
1 row in set (0.00 sec)

Ana a luat „Ion” acum 18 zile și nu l-a adus înapoi. Răspunsul vine din trei tabele legate între ele, pe care le construiești în lecția asta.

Pasul 2 din 5

Construiește baza, apoi urmărește o interogare

Trei tabele: cititori, carti și imprumuturi. Un împrumut nu copiază numele cititorului sau titlul cărții, ci ține doar id-urile lor. Rulează scriptul într-o bază goală.

schema.sql
CREATE TABLE cititori (  id INT PRIMARY KEY AUTO_INCREMENT,  nume VARCHAR(50) NOT NULL,  clasa VARCHAR(5) NOT NULL);CREATE TABLE carti (  id INT PRIMARY KEY AUTO_INCREMENT,  titlu VARCHAR(80) NOT NULL,  autor VARCHAR(50) NOT NULL);CREATE TABLE imprumuturi (  id INT PRIMARY KEY AUTO_INCREMENT,  cititor_id INT NOT NULL,  carte_id INT NOT NULL,  luat DATE NOT NULL,  returnat DATE NULL,  FOREIGN KEY (cititor_id)    REFERENCES cititori(id),  FOREIGN KEY (carte_id)    REFERENCES carti(id));INSERT INTO cititori (nume, clasa) VALUES  ('Ana', '9A'), ('Vlad', '10B'),  ('Irina', '9A');INSERT INTO carti (titlu, autor) VALUES  ('Enigma Otiliei', 'G. Călinescu'),  ('Ion', 'L. Rebreanu'),  ('Moara cu noroc', 'I. Slavici'),  ('Baltagul', 'M. Sadoveanu');INSERT INTO imprumuturi  (cititor_id, carte_id, luat, returnat)VALUES  (1, 1, '2026-10-01', '2026-10-12'),  (1, 2, '2026-10-20', NULL),  (2, 3, '2026-11-02', NULL),  (3, 1, '2026-10-15', '2026-10-30');

Acum întrebarea: ce cărți sunt acum la cititori? MySQL nu citește interogarea de sus în jos. Apasă pe „Linia următoare” și urmărește ordinea reală.

imprumutate.sql
SELECT c.nume, k.titluFROM imprumuturi iJOIN cititori c ON c.id = i.cititor_idJOIN carti k ON k.id = i.carte_idWHERE i.returnat IS NULL;

Rânduri în lucru

Tabelul de lucru


      

  1. Linia 2. Totul pornește de la FROM. MySQL ia cele 4 împrumuturi. Alias-ul i e o poreclă scurtă pentru tabel.
  2. Linia 3. JOIN lipește fiecărui împrumut rândul din cititori cu același id. Condiția din ON spune ce coloane trebuie să se potrivească.
  3. Linia 4. Al doilea JOIN aduce titlul cărții. Acum fiecare rând are nume, titlu și data returnării.
  4. Linia 5. WHERE păstrează doar rândurile în care returnat e gol. Din 4 rânduri rămân 2.
  5. Linia 1. Abia la final, SELECT alege coloanele care se afișează: numele și titlul.
  6. Gata. Ordinea a fost FROM, JOIN, WHERE, SELECT. De aceea, în WHERE nu poți folosi un alias definit în SELECT: încă nu există.

Prezice ieșirea

Ștergi linia 5, cea cu WHERE, și rulezi din nou. Câte rânduri afișează interogarea?

Răspuns: 4.

Fără filtru rămâne tabelul de la linia 4: un rând pentru fiecare împrumut. Ana apare de două ori, pentru că are două împrumuturi.

Pasul 3 din 5

Cum gândește o bază de date relațională

Trei idei, fiecare pe aceeași bibliotecă. La final, două greșeli care nu dau eroare, ci rezultate greșite sau o oprire bruscă.

Cheia străină păzește legătura

Fiecare tabel are o cheie primară, id: un număr unic, dat automat de AUTO_INCREMENT. În imprumuturi, coloana cititor_id e o cheie străină: poate conține doar un id care există în cititori.

fk.sql
INSERT INTO imprumuturi  (cititor_id, carte_id, luat)VALUES (7, 2, CURDATE());
ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`biblioteca`.`imprumuturi`, CONSTRAINT `imprumuturi_ibfk_1` FOREIGN KEY (`cititor_id`) REFERENCES `cititori` (`id`))

Cititorul 7 nu există, deci MySQL refuză împrumutul. Regula merge și invers: nu poți șterge un cititor care are împrumuturi. Fără cheia străină, ai avea împrumuturi „orfane”, pe care nicio interogare cu JOIN nu le-ar mai găsi.

LEFT JOIN găsește ce lipsește

neimprumutate.sql
SELECT k.titluFROM carti kLEFT JOIN imprumuturi i  ON i.carte_id = k.idWHERE i.id IS NULL;

Rezultat

+----------+
| titlu    |
+----------+
| Baltagul |
+----------+

JOIN păstrează doar rândurile care au pereche în ambele tabele. LEFT JOIN păstrează toate cărțile, chiar și pe cele fără niciun împrumut. Pentru ele, coloanele din imprumuturi se umplu cu NULL.

„Baltagul” n-a fost împrumutată niciodată, deci i.id e NULL doar pe rândul ei. Așa întrebi „ce nu are pereche?”.

GROUP BY numără pe grupuri

populare.sql
SELECT k.titlu, COUNT(i.id) AS oriFROM carti kLEFT JOIN imprumuturi i  ON i.carte_id = k.idGROUP BY k.id, k.titluORDER BY ori DESC, k.titlu;

Rezultat

+----------------+-----+
| titlu          | ori |
+----------------+-----+
| Enigma Otiliei |   2 |
| Ion            |   1 |
| Moara cu noroc |   1 |
| Baltagul       |   0 |
+----------------+-----+

GROUP BY strânge rândurile cu aceeași carte într-un singur grup, iar COUNT(i.id) numără împrumuturile din grup. COUNT pe o coloană sare peste NULL, de aceea „Baltagul” are 0, nu 1.

Ca să filtrezi grupurile, folosești HAVING, nu WHERE. WHERE lucrează pe rânduri, înainte de grupare. HAVING lucrează pe grupuri, după.

clase.sql
SELECT c.clasa, COUNT(*) AS totalFROM imprumuturi iJOIN cititori c ON c.id = i.cititor_idGROUP BY c.clasaHAVING COUNT(*) >= 2;

Rezultat

+-------+-------+
| clasa | total |
+-------+-------+
| 9A    |     3 |
+-------+-------+

Capcană: = NULL nu găsește nimic

Vrei să numeri cărțile nereturnate și scrii firesc = NULL. Nu primești nicio eroare, doar un rezultat greșit:

null.sql
SELECT COUNT(*) FROM imprumuturiWHERE returnat = NULL;

Rezultat

+----------+
| COUNT(*) |
+----------+
|        0 |
+----------+

NULL înseamnă „valoare necunoscută”. Orice comparație cu ea, chiar și NULL = NULL, dă tot NULL, nu adevărat. Așa că niciun rând nu trece de filtru.

Repară cu WHERE returnat IS NULL: rezultatul devine 2.

Capcană: coloană care nu e în GROUP BY

Grupezi pe clasă, dar afișezi numele. Într-o clasă sunt mai mulți cititori, deci MySQL nu știe ce nume să aleagă și se oprește:

groupby.sql
SELECT c.nume, COUNT(*)FROM cititori cJOIN imprumuturi i ON i.cititor_id = c.idGROUP BY c.clasa;
ERROR 1055 (42000): Expression #1 of SELECT list is not in GROUP BY clause and contains nonaggregated column 'biblioteca.c.nume' which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by

Repară afișând exact coloana după care grupezi: SELECT c.clasa, COUNT(*). Sau grupează după cititor: GROUP BY c.id, c.nume.

Pasul 4 din 5

Verifică-te

Cinci întrebări pe aceeași bibliotecă. Toate răspunsurile au fost verificate în MySQL 8.4.

1 din 5 · Prezice ieșirea

Ce număr afișează SELECT COUNT(*) FROM carti k LEFT JOIN imprumuturi i ON i.carte_id = k.id;?

Răspuns: 5.

Cele 4 împrumuturi dau 4 rânduri. „Baltagul” nu are niciun împrumut, dar LEFT JOIN o păstrează, cu NULL, deci se adaugă al cincilea rând. Cu JOIN simplu ar fi fost 4.

2 din 5 · Alege varianta

Rulezi DELETE FROM cititori WHERE id = 1;. Ana are două împrumuturi. Ce se întâmplă?

Răspuns: MySQL refuză.

Mesajul real e ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint fails. Ștergerea în cascadă se întâmplă doar dacă ai cerut-o explicit, cu ON DELETE CASCADE.

3 din 5 · Prezice ieșirea

Ce afișează SELECT COUNT(returnat) FROM imprumuturi;?

Răspuns: 2.

COUNT(coloana) numără doar valorile care nu sunt NULL. Două cărți au fost returnate, două nu. COUNT(*) ar fi numărat toate cele 4 rânduri.

4 din 5 · Alege varianta

Vrei doar cărțile împrumutate de cel puțin două ori. Ce adaugi după GROUP BY k.id, k.titlu?

Răspuns: HAVING.

HAVING filtrează grupurile, după ce au fost numărate. WHERE vine înaintea lui GROUP BY și nu poate folosi COUNT. ORDER BY doar sortează, nu elimină nimic.

5 din 5 · Prezice ieșirea

Ce rând apare primul la SELECT clasa, COUNT(*) FROM cititori GROUP BY clasa ORDER BY clasa;?

Răspuns: 10B, cu 1.

clasa e text, deci se sortează caracter cu caracter, ca în dicționar. „1” vine înaintea lui „9”, așa că „10B” e primul. În 9A sunt doi cititori, Ana și Irina.

Pasul 5 din 5

Ce ai învățat

Interogarea de la început

Aceasta e interogarea din pasul 1. DATEDIFF dă numărul de zile dintre două date, iar CURDATE() e data de azi. Copiaz-o și rulează-o pe baza ta.

intarzieri.sql
SELECT c.nume, k.titlu,  DATEDIFF(CURDATE(), i.luat) AS zileFROM imprumuturi iJOIN cititori c ON c.id = i.cititor_idJOIN carti k ON k.id = i.carte_idWHERE i.returnat IS NULL  AND DATEDIFF(CURDATE(), i.luat) > 14;

Pe 7 noiembrie 2026

+------+-------+------+
| nume | titlu | zile |
+------+-------+------+
| Ana  | Ion   |   18 |
+------+-------+------+

Continuă cu