...
Pregătire interviuri

100 de întrebări de interviu SQL, cu răspunsuri

Întrebările despre SQL care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs SQL: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 153 minde citit
Întrebări de interviu SQL cu răspunsuri

SQL apare în aproape orice interviu tehnic pentru roluri care lucrează cu date: backend, analist de date, QA, data engineer sau SQL developer. Verificarea are de obicei două forme. Prima sunt întrebările de teorie și de tipul „ce întoarce interogarea”, în care se vede dacă știi cum se comportă NULL, JOIN-urile, agregările și funcțiile fereastră. A doua este scrierea live a unor interogări pe tabele mici date de intervievator, uneori urmată de o discuție despre indexuri, planuri de execuție și tranzacții. Unele companii dau și o temă: o schemă de proiectat sau un set de rapoarte de scris.

La nivel de junior se urmărește dacă scrii corect interogări uzuale și dacă eviți capcanele clasice: comparațiile cu NULL, JOIN-urile care multiplică rânduri, GROUP BY folosit greșit, împărțirea întreagă. La nivel mid contează funcțiile fereastră, CTE-urile recursive, alegerea indexurilor, citirea unui plan de execuție și înțelegerea concurenței. La nivel senior discuția se mută spre compromisuri: modelare, izolare, MVCC, performanță la volum mare și decizii pe care le poți justifica. Unde PostgreSQL și MySQL se comportă diferit, răspunsurile spun explicit, pentru că intervievatorii întreabă des exact aceste diferențe.

Cum să folosești pagina: citește întâi întrebarea și încearcă să scrii singur interogarea sau răspunsul, apoi compară cu răspunsul scurt și cu explicația detaliată. Rulează exemplele într-o bază de date locală (PostgreSQL sau MySQL 8) și modifică datele ca să vezi cazurile limită. Întrebările sunt grupate pe teme și ordonate de la junior la senior, iar secțiunea finală conține situații din practică, cu modele de răspuns structurate.

SELECT, filtre și NULL

1 Junior

Tabelul clienti are coloana oras, cu valorile 'Cluj', 'Iași' și NULL (câte un rând fiecare). Câte rânduri întoarce fiecare interogare și de ce?

SQL
SELECT * FROM clienti WHERE oras = NULL;
SELECT * FROM clienti WHERE oras <> 'Cluj';
SELECT * FROM clienti WHERE NOT (oras = 'Cluj');

Răspuns scurt: Prima întoarce 0 rânduri, a doua și a treia câte un rând ('Iași'). Orice comparație cu NULL dă UNKNOWN, iar WHERE păstrează doar rândurile la care condiția este TRUE.

SQL folosește logica cu trei valori: o condiție poate fi TRUE, FALSE sau UNKNOWN. Orice comparație obișnuită cu NULL (=, <>, <, >) dă UNKNOWN, inclusiv NULL = NULL. Clauza WHERE păstrează doar rândurile la care condiția e TRUE, așa că rândurile cu UNKNOWN dispar la fel ca cele cu FALSE.

  • oras = NULL este UNKNOWN pentru toate rândurile, deci 0 rânduri. Corect se scrie oras IS NULL.
  • oras <> 'Cluj' este FALSE pentru Cluj, TRUE pentru Iași și UNKNOWN pentru NULL, deci un rând.
  • NOT UNKNOWN rămâne UNKNOWN, deci și a treia interogare pierde rândul cu NULL.

Regulile pentru AND și OR merită știute pe de rost: FALSE AND UNKNOWN este FALSE, TRUE OR UNKNOWN este TRUE, iar restul combinațiilor cu UNKNOWN dau UNKNOWN.

Dacă vrei „toți cei care nu sunt din Cluj, inclusiv cei fără oraș”, scrii explicit:

SQL
SELECT * FROM clienti WHERE oras <> 'Cluj' OR oras IS NULL;

Un detaliu care surprinde: constrângerile CHECK se comportă invers față de WHERE. Un CHECK respinge rândul doar dacă expresia e FALSE, deci UNKNOWN trece. CHECK (pret > 0) acceptă un preț NULL dacă nu adaugi și NOT NULL.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că NULL nu este o valoare, ci absența ei. Greșeala tipică este să crezi că <> include automat și rândurile cu NULL.

2 Junior

Ce afișează interogarea următoare în PostgreSQL? Ce se schimbă în MySQL?

SQL
SELECT 7 / 2 AS a, 7 / 2.0 AS b, 7 % 2 AS c;

Răspuns scurt: În PostgreSQL: a = 3 (împărțire întreagă), b = 3.5, c = 1. În MySQL operatorul / întoarce mereu rezultat zecimal, deci a = 3.5000, iar împărțirea întreagă se face cu DIV.

În PostgreSQL, SQL Server și SQLite, împărțirea a două valori întregi dă un întreg: partea zecimală se taie (spre zero), deci 7 / 2 întoarce 3. Dacă măcar un operand este zecimal (2.0 sau o coloană numeric), rezultatul este zecimal: 7 / 2.0 dă 3.5 (PostgreSQL îl afișează cu mai multe zecimale, de exemplu 3.5000000000000000). Operatorul % întoarce restul împărțirii, aici 1.

MySQL se comportă diferit: / produce mereu un rezultat zecimal, deci 7 / 2 dă 3.5000 (numărul de zecimale vine din variabila div_precision_increment). Pentru împărțire întreagă folosești 7 DIV 2.

Capcana apare des în rapoarte cu procente:

SQL
-- PostgreSQL: dă 0 pentru orice rată sub 100%
SELECT platite * 100 / total FROM statistici;

-- corect
SELECT platite * 100.0 / total FROM statistici;
SELECT CAST(platite AS numeric) / total * 100 FROM statistici;

Dacă platite și total sunt coloane integer, prima variantă face întâi înmulțirea, apoi împărțirea întreagă, deci rezultatul e trunchiat. Ordinea contează: platite / total * 100 ar da 0 aproape mereu, pentru că împărțirea se face înaintea înmulțirii. Soluția sigură este să convertești explicit un operand la numeric înainte de împărțire și să rotunjești la final cu ROUND(..., 2).

Ce urmărește intervievatorul: Se verifică atenția la tipurile de date și la diferențele dintre sisteme. Candidații care au lucrat doar în MySQL raportează frecvent procente de 0 când trec pe PostgreSQL.

Eroarea, în practică:no such function: MOD

3 Junior

Vrem comenzile plătite sau expediate care au valoarea peste 100. Unde e bug-ul?

SQL
SELECT id, status, total
FROM comenzi
WHERE status = 'platita' OR status = 'expediata' AND total > 100;

Răspuns scurt: AND are prioritate mai mare decât OR, deci condiția se citește status = 'platita' OR (status = 'expediata' AND total > 100): toate comenzile plătite apar, indiferent de valoare. Rezolvi cu paranteze sau cu IN.

În SQL, la fel ca în majoritatea limbajelor, ordinea de evaluare a operatorilor logici este NOT, apoi AND, apoi OR. Interogarea de mai sus este interpretată astfel:

SQL
WHERE status = 'platita'
   OR (status = 'expediata' AND total > 100)

Rezultatul conține toate comenzile plătite, chiar și cele de 5 lei, plus comenzile expediate de peste 100. Interogarea rulează fără erori și pare corectă la o privire rapidă, de aceea bug-ul ajunge des în rapoarte.

Variantele corecte:

SQL
WHERE (status = 'platita' OR status = 'expediata')
  AND total > 100;

-- mai clar
WHERE status IN ('platita', 'expediata')
  AND total > 100;

IN cu o listă de valori este echivalent cu un șir de OR-uri pe aceeași coloană, dar elimină riscul de precedență și se citește mai ușor.

Regula practică: ori de câte ori amesteci AND și OR în aceeași clauză, pune paranteze, chiar dacă precedența implicită ar da rezultatul dorit. Codul SQL este citit de colegi, iar parantezele fac intenția evidentă. Pentru a testa o astfel de interogare, caută un rând care ar trebui exclus (o comandă plătită cu total 50) și verifică dacă apare în rezultat.

Ce urmărește intervievatorul: Se verifică dacă știi precedența operatorilor și dacă scrii defensiv. Mulți candidați citesc condiția „cu voce tare” și nu observă că SQL o grupează altfel.

4 Junior

Sortezi produsele după rating descrescător, iar unele produse nu au rating (NULL). Unde apar acestea în PostgreSQL și unde în MySQL? Cum le trimiți la final în ambele?

Răspuns scurt: PostgreSQL consideră NULL mai mare decât orice valoare, deci la DESC NULL-urile apar primele. MySQL îl consideră mai mic, deci la DESC apar ultimele. În PostgreSQL scrii NULLS LAST, în MySQL sortezi întâi după rating IS NULL.

Standardul SQL lasă la latitudinea fiecărui sistem unde se pun NULL-urile la sortare, iar sistemele au ales diferit:

  • PostgreSQL și Oracle tratează NULL ca fiind mai mare decât orice valoare: la ASC apar la final, la DESC apar primele.
  • MySQL, SQLite și SQL Server tratează NULL ca fiind mai mic: la ASC apar primele, la DESC la final.

Asta înseamnă că un clasament „cele mai bine notate produse” scris în PostgreSQL cu ORDER BY rating DESC LIMIT 10 poate întoarce exact produsele fără nicio notă.

PostgreSQL, Oracle și SQLite (de la versiunea 3.30) acceptă sintaxa standard:

SQL
SELECT nume, rating
FROM produse
ORDER BY rating DESC NULLS LAST;

MySQL nu are NULLS FIRST/LAST, așa că folosești o expresie de sortare suplimentară. rating IS NULL întoarce 0 sau 1, iar 0 vine înainte:

SQL
SELECT nume, rating
FROM produse
ORDER BY rating IS NULL, rating DESC;

O variantă portabilă este ORDER BY CASE WHEN rating IS NULL THEN 1 ELSE 0 END, rating DESC. Reține că expresiile din ORDER BY pot împiedica folosirea unui index pentru sortare; în PostgreSQL poți crea indexul direct cu ordinea dorită: CREATE INDEX ON produse (rating DESC NULLS LAST).

Ce urmărește intervievatorul: Întrebarea testează experiența practică cu mai multe sisteme. Greșeala tipică este să presupui că NULL-urile ajung mereu la final.

Eroarea, în practică:unsupported use of NULLS FIRST

5 Junior

Calculezi rata de conversie pe zi ca comenzi / vizite. În unele zile vizite este 0, iar în altele comenzi lipsește (NULL). Cum scrii expresia ca să nu dea eroare și să afișeze 0 unde nu au fost comenzi?

Răspuns scurt: Folosești NULLIF(vizite, 0) la numitor, ca împărțirea la zero să devină NULL în loc de eroare, și COALESCE(comenzi, 0) la numărător, ca lipsa comenzilor să conteze ca 0.

Două funcții standard rezolvă problema:

  • COALESCE(a, b, c, ...) întoarce primul argument care nu este NULL.
  • NULLIF(a, b) întoarce NULL dacă a = b, altfel întoarce a.
SQL
SELECT zi,
       ROUND(COALESCE(comenzi, 0) * 100.0 / NULLIF(vizite, 0), 2) AS rata_pct
FROM trafic_zilnic;

În PostgreSQL, împărțirea la zero aruncă eroarea division by zero și oprește toată interogarea, nu doar rândul respectiv. NULLIF(vizite, 0) transformă zero în NULL, iar orice operație aritmetică cu NULL dă NULL, deci rândul primește o rată NULL („nu se poate calcula”), ceea ce e corect semantic. Dacă raportul cere totuși 0, învelești tot rezultatul: COALESCE(... / NULLIF(vizite, 0), 0).

MySQL, în mod implicit, întoarce NULL la împărțirea la zero într-un SELECT (cu un warning), dar în INSERT și UPDATE, cu modul strict activ, poate da eroare. Codul cu NULLIF se comportă la fel peste tot.

Alte detalii utile:

  • argumentele lui COALESCE trebuie să aibă tipuri compatibile; COALESCE(data_livrare, 'necunoscut') dă eroare în PostgreSQL dacă data_livrare este date.
  • MySQL are și IFNULL(a, b), iar SQL Server ISNULL(a, b), dar COALESCE este standard și acceptă oricâte argumente.

Ce urmărește intervievatorul: Se verifică dacă știi să faci un calcul robust la date reale, incomplete. Candidații uită adesea că o singură zi cu zero vizite oprește tot raportul în PostgreSQL.

Eroarea, în practică:near "ISNULL": syntax error

6 Junior

Cauți un utilizator după email, dar emailurile sunt salvate cu majuscule amestecate („Ana.Pop@Exemplu.ro”). Cum faci căutarea insensibilă la majuscule în PostgreSQL și cum se comportă MySQL?

Răspuns scurt: În PostgreSQL comparația = și LIKE țin cont de majuscule, deci folosești LOWER(email) = LOWER($1), ILIKE sau tipul citext. În MySQL, colațiile implicite (_ci) sunt deja insensibile la majuscule.

Comportamentul ține de colație (collation), adică regulile după care sistemul compară și sortează textele.

În PostgreSQL, colațiile obișnuite sunt sensibile la majuscule: 'Ana' = 'ana' este FALSE. Opțiunile:

SQL
-- comparație normalizată
SELECT * FROM utilizatori WHERE LOWER(email) = LOWER('ana.pop@exemplu.ro');

-- căutare după tipar, insensibilă la majuscule (specific PostgreSQL)
SELECT * FROM utilizatori WHERE email ILIKE 'ana.%';

-- index care face prima variantă rapidă
CREATE INDEX idx_utilizatori_email_lower ON utilizatori (LOWER(email));

Fără indexul pe expresie, LOWER(email) = ... nu poate folosi un index simplu pe email. O alternativă este extensia citext, un tip de text care se compară mereu insensibil la majuscule.

În MySQL, colația implicită pentru utf8mb4 în versiunea 8.0 este utf8mb4_0900_ai_ci: ci înseamnă case-insensitive, iar ai accent-insensitive. Acolo 'Ana' = 'ANA' este adevărat și, de regulă, și 'Brasov' = 'Brașov'. E comod pentru căutări, dar poate surprinde la o constrângere UNIQUE: două valori care diferă doar prin diacritice sau majuscule sunt considerate duplicate. Când ai nevoie de comparație exactă, folosești o colație _bin sau _as_cs pe coloana respectivă.

Pentru emailuri, cea mai curată soluție este să normalizezi la salvare (litere mici) și să păstrezi o constrângere unică pe valoarea normalizată.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi de colații și că te gândești la index. Greșeala tipică este presupunerea că toate bazele de date compară textul la fel.

Eroarea, în practică:no such collation sequence: utf8mb4_general_cinear "ILIKE": syntax error

7 Junior

De ce interogarea următoare funcționează în MySQL, dar dă eroare în PostgreSQL?

SQL
SELECT "nume", prenume FROM clienti WHERE nume = "Ana";

Răspuns scurt: În standardul SQL, ghilimelele simple marchează texte, iar cele duble marchează identificatori (nume de tabele sau coloane). PostgreSQL caută o coloană numită Ana și dă eroare; MySQL tratează implicit ghilimelele duble ca text.

Standardul SQL face o distincție clară:

  • 'Ana' (ghilimele simple) este un literal de tip text.
  • "Ana" (ghilimele duble) este un identificator, adică numele unei coloane, al unui tabel sau al unui alias.

PostgreSQL respectă standardul, deci WHERE nume = "Ana" înseamnă „unde coloana nume este egală cu coloana Ana”. Rezultatul este eroarea column "Ana" does not exist. În schimb "nume" din SELECT funcționează, pentru că e chiar numele coloanei.

MySQL, cu setările implicite, acceptă ghilimelele duble ca delimitator de text, iar identificatorii se delimitează cu backtick: ` nume . Dacă activezi modul ANSI_QUOTES`, MySQL se comportă ca standardul.

Al doilea detaliu legat de ghilimele duble în PostgreSQL: numele fără ghilimele sunt convertite la litere mici. Un tabel creat cu CREATE TABLE "Clienti" trebuie apoi scris mereu "Clienti"; SELECT * FROM Clienti caută tabelul clienti și nu îl găsește. Asta apare des când tabelele sunt create de un ORM sau de o unealtă grafică.

Regulile practice:

SQL
SELECT nume, prenume
FROM clienti
WHERE nume = 'Ana'
  AND observatii = 'Nu e acasă după ora 18';

Folosește ghilimele simple pentru texte, nume de identificatori cu litere mici și underscore, fără ghilimele, iar un apostrof din text se dublează: 'O''Brien'.

Ce urmărește intervievatorul: Se verifică dacă ai scris SQL pe mai multe sisteme și dacă știi standardul. Candidații care vin din MySQL fac frecvent această greșeală la primele interogări în PostgreSQL.

Eroarea, în practică:near "group": cuvânt rezervat ca nume

8 Junior

Un coleg afișează „ultimele 10 comenzi” cu SELECT * FROM comenzi LIMIT 10, iar alt coleg cu ORDER BY data_comanda DESC LIMIT 10. Sunt rezultatele garantat stabile? Ce ar trebui schimbat?

Răspuns scurt: Fără ORDER BY, LIMIT întoarce 10 rânduri oarecare, fără nicio garanție. Cu ORDER BY pe o coloană care are valori egale, ordinea rândurilor egale nu este nici ea garantată; adaugi o coloană unică la final, de exemplu id.

Un tabel relațional nu are o ordine intrinsecă. Fără ORDER BY, baza de date întoarce rândurile în ordinea în care îi este cel mai comod (ordinea fizică, ordinea dintr-un index, ordinea în care termină procesele paralele). Poate părea stabilă luni de zile și se schimbă după un VACUUM, după un index nou sau după un upgrade.

A doua problemă este subtilă: dacă sortezi după data_comanda și mai multe comenzi au aceeași valoare, ordinea dintre ele rămâne nedeterministă. La paginare asta înseamnă rânduri care apar pe două pagini sau care nu apar deloc. Soluția este o cheie de departajare unică:

SQL
SELECT id, client_id, data_comanda, total
FROM comenzi
ORDER BY data_comanda DESC, id DESC
LIMIT 10;

LIMIT nu este standard SQL, deși îl au PostgreSQL, MySQL și SQLite. Standardul (SQL:2008) definește:

SQL
SELECT id, data_comanda
FROM comenzi
ORDER BY data_comanda DESC
FETCH FIRST 10 ROWS ONLY;

Această sintaxă merge în PostgreSQL, Oracle (12c+) și SQL Server (cu OFFSET 0 ROWS înainte). SQL Server are și TOP 10. PostgreSQL 13+ suportă FETCH FIRST 10 ROWS WITH TIES, care include și rândurile egale cu al zecelea, util când nu vrei să tai arbitrar un clasament.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi că un tabel este o mulțime, nu o listă. Mulți candidați uită de rândurile egale și obțin paginare instabilă.

9 Junior

Ce afișează coloana categorie pentru un rând cu total = 150 și pentru unul cu total = NULL?

SQL
SELECT total,
       CASE
         WHEN total > 50  THEN 'mediu'
         WHEN total > 100 THEN 'mare'
         WHEN total <= 50 THEN 'mic'
       END AS categorie
FROM comenzi;

Răspuns scurt: Pentru 150 afișează 'mediu', pentru că CASE se oprește la prima ramură adevărată, iar total > 50 este verificată înaintea lui total > 100. Pentru NULL afișează NULL: nicio ramură nu e TRUE și lipsește ELSE.

Expresia CASE evaluează ramurile WHEN în ordinea scrierii și întoarce rezultatul primei ramuri a cărei condiție este TRUE. Restul ramurilor nu mai sunt verificate.

  • Pentru 150: 150 > 50 este TRUE, deci rezultatul e 'mediu'. Ramura 'mare' nu este atinsă niciodată, pentru că orice valoare peste 100 este și peste 50. Este un bug de logică frecvent.
  • Pentru NULL: toate comparațiile dau UNKNOWN, iar UNKNOWN nu activează o ramură. Când nu există ELSE, CASE întoarce NULL.

Varianta corectă ordonează intervalele de la cel mai restrictiv și tratează explicit lipsa valorii:

SQL
SELECT total,
       CASE
         WHEN total IS NULL THEN 'necunoscut'
         WHEN total > 100   THEN 'mare'
         WHEN total > 50    THEN 'mediu'
         ELSE 'mic'
       END AS categorie
FROM comenzi;

Încă o capcană: forma simplă CASE total WHEN NULL THEN ... nu se potrivește niciodată, pentru că se traduce în total = NULL. Pentru NULL folosești mereu forma cu condiții (WHEN total IS NULL).

Toate ramurile trebuie să întoarcă tipuri compatibile. În PostgreSQL, CASE WHEN x THEN 1 ELSE 'zero' END dă eroare, pentru că 'zero' nu se poate converti la întreg.

Ce urmărește intervievatorul: Se verifică atenția la ordinea ramurilor și tratarea lui NULL. Candidații scriu des intervalele în ordine crescătoare și nu observă că o ramură devine imposibilă.

Eroarea, în practică:near "'scump'": syntax error

10 Junior

Construiești numele complet al clientului din prenume și nume. Ce afișează fiecare expresie dacă prenume este NULL, în PostgreSQL și în MySQL?

SQL
SELECT prenume || ' ' || nume       AS v1,
       CONCAT(prenume, ' ', nume)   AS v2,
       CONCAT_WS(' ', prenume, nume) AS v3
FROM clienti;

Răspuns scurt: În PostgreSQL || dă NULL, CONCAT ignoră NULL-ul și dă ' Pop', iar CONCAT_WS dă 'Pop'. În MySQL || înseamnă implicit OR logic, CONCAT dă NULL, iar CONCAT_WS dă 'Pop'.

Operatorul standard de concatenare este ||, iar regula standard spune că orice operație cu NULL dă NULL. Funcțiile CONCAT diferă însă între sisteme.

PostgreSQL:

  • prenume || ' ' || nume dă NULL, deci clientul apare fără nume.
  • CONCAT(...) ignoră argumentele NULL și dă ' Pop', cu un spațiu în față.
  • CONCAT_WS(' ', ...) (with separator) ignoră NULL-urile și pune separatorul doar între valorile existente, deci 'Pop'.

MySQL:

  • || este implicit operatorul logic OR (comportament marcat ca depreciat din 8.0.17), deci expresia nu concatenează deloc; devine concatenare doar cu modul PIPES_AS_CONCAT sau ANSI.
  • CONCAT(...) întoarce NULL dacă oricare argument este NULL.
  • CONCAT_WS(' ', ...) dă 'Pop', la fel ca în PostgreSQL.

Varianta portabilă și explicită este fie CONCAT_WS, fie tratarea fiecărui câmp:

SQL
SELECT TRIM(COALESCE(prenume, '') || ' ' || COALESCE(nume, '')) AS nume_complet
FROM clienti;

În MySQL scrii aceeași idee cu CONCAT(COALESCE(prenume, ''), ' ', COALESCE(nume, '')). TRIM elimină spațiul rămas când lipsește una din părți. Merită verificat și cazul în care ambele lipsesc: rezultatul devine șirul gol, iar uneori raportul preferă NULL, caz în care adaugi NULLIF(..., '').

Ce urmărește intervievatorul: Întrebarea verifică dacă știi că funcțiile „uzuale” diferă între sisteme. Greșeala clasică este mutarea unei interogări din PostgreSQL în MySQL fără să observi că || a devenit OR.

11 Mid

Ai un tabel de import clienti_import și tabelul principal clienti. Vrei clienții al căror email s-a schimbat. De ce condiția de mai jos ratează unele modificări și cum o corectezi?

SQL
SELECT i.id
FROM clienti_import i
JOIN clienti c ON c.id = i.id
WHERE i.email <> c.email;

Răspuns scurt: Dacă unul dintre emailuri este NULL, <> dă UNKNOWN și rândul dispare, deși valoarea s-a schimbat. Folosești comparația null-safe IS DISTINCT FROM (standard, PostgreSQL) sau NOT (a <=> b) în MySQL.

Situația apare la orice sincronizare de date: un client care avea email și acum nu mai are (sau invers) este o modificare reală, dar NULL <> 'a@b.ro' este UNKNOWN, deci rândul nu trece de WHERE. Și invers, dacă ai scrie = pentru a găsi rândurile neschimbate, două NULL-uri nu ar fi considerate egale.

Standardul SQL definește comparația null-safe:

SQL
-- PostgreSQL, SQLite (3.39+), SQL Server 2022
SELECT i.id
FROM clienti_import i
JOIN clienti c ON c.id = i.id
WHERE i.email IS DISTINCT FROM c.email;

a IS DISTINCT FROM b întoarce mereu TRUE sau FALSE: două NULL-uri sunt considerate egale, iar NULL față de o valoare este considerat diferit. Negația este IS NOT DISTINCT FROM.

MySQL nu are această sintaxă, dar are operatorul <=> (null-safe equal):

SQL
WHERE NOT (i.email <=> c.email)

Varianta portabilă, mai lungă:

SQL
WHERE i.email <> c.email
   OR (i.email IS NULL AND c.email IS NOT NULL)
   OR (i.email IS NOT NULL AND c.email IS NULL)

Când compari multe coloane deodată, în PostgreSQL poți compara rânduri întregi: WHERE (i.email, i.telefon, i.oras) IS DISTINCT FROM (c.email, c.telefon, c.oras). Reține că optimizatorul folosește mai greu un index pentru IS DISTINCT FROM, dar aici nu contează, pentru că oricum compari coloane după un JOIN pe cheie.

Ce urmărește intervievatorul: Se verifică dacă știi să compari corect date incomplete, o sarcină zilnică în ETL și sincronizări. Greșeala tipică este o detecție de modificări care pierde exact cazurile în care o valoare a fost ștearsă.

JOIN-uri

12 Junior

Tabelul a are în coloana x valorile 1, 1, 2, NULL, iar tabelul b are 1, 2, 2, NULL. Câte rânduri întoarce fiecare interogare?

SQL
SELECT * FROM a JOIN b ON a.x = b.x;
SELECT * FROM a LEFT JOIN b ON a.x = b.x;
SELECT * FROM a CROSS JOIN b;

Răspuns scurt: INNER JOIN întoarce 4 rânduri (2 pentru valoarea 1, 2 pentru valoarea 2), LEFT JOIN 5 (se adaugă rândul NULL din a, fără pereche), iar CROSS JOIN 16 (4 x 4).

Un JOIN combină fiecare rând din stânga cu fiecare rând din dreapta pentru care condiția este TRUE. Când cheile se repetă, rezultatul este produsul numărului de apariții.

INNER JOIN:

  • valoarea 1 apare de 2 ori în a și o dată în b: 2 x 1 = 2 rânduri;
  • valoarea 2 apare o dată în a și de 2 ori în b: 1 x 2 = 2 rânduri;
  • NULL = NULL este UNKNOWN, deci rândurile cu NULL nu se potrivesc între ele.

Total: 4 rânduri.

LEFT JOIN păstrează în plus fiecare rând din a care nu are nicio pereche, completând coloanele din b cu NULL. Singurul astfel de rând este cel cu x = NULL, deci 4 + 1 = 5 rânduri.

CROSS JOIN este produsul cartezian, fără nicio condiție: 4 x 4 = 16 rânduri.

Exercițiul nu e doar teoretic. Când un raport „umflă” cifrele după un JOIN, cauza este aproape mereu o cheie care se repetă pe partea pe care o credeai unică. O verificare rapidă înainte de JOIN:

SQL
SELECT x, COUNT(*)
FROM b
GROUP BY x
HAVING COUNT(*) > 1;

Dacă vrei ca NULL-urile să se potrivească între ele (rar, dar se întâmplă la coduri opționale), condiția trebuie scrisă explicit cu a.x IS NOT DISTINCT FROM b.x, nu cu =.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanica JOIN-ului la nivel de rânduri, nu doar diagramele cu cercuri. Greșeala tipică este să crezi că NULL-urile se potrivesc sau că un JOIN nu poate crește numărul de rânduri.

Eroarea, în practică:unknown join type: OUTER

13 Junior

Care este diferența dintre JOIN ... ON, JOIN ... USING și NATURAL JOIN? De ce NATURAL JOIN este considerat periculos în cod de producție?

Răspuns scurt: ON primește orice condiție, USING leagă după coloane cu același nume și le afișează o singură dată, iar NATURAL JOIN leagă automat după toate coloanele cu nume comun. Dacă cineva adaugă o coloană cu nume comun, NATURAL JOIN își schimbă tacit rezultatul.

Cele trei forme exprimă condiția de legătură diferit:

SQL
-- ON: orice condiție, cea mai explicită
SELECT * FROM comenzi c JOIN clienti cl ON cl.id = c.client_id;

-- USING: coloane cu același nume în ambele tabele
SELECT * FROM comenzi JOIN clienti USING (client_id);

-- NATURAL: toate coloanele cu nume comun, alese automat
SELECT * FROM comenzi NATURAL JOIN clienti;

Cu USING (client_id), coloana apare o singură dată în SELECT * și o poți referi fără prefix de tabel. E comod când schema folosește aceleași nume pentru cheile străine și cheile primare (client_id în ambele tabele).

NATURAL JOIN alege singur coloanele. Să presupunem că ambele tabele au, pe lângă client_id, coloanele de audit creat_la și modificat_la. NATURAL JOIN va cere egalitate și pe ele, deci aproape niciun rând nu se mai potrivește. Mai rău, interogarea poate funcționa corect azi și să se strice peste o lună, când cineva adaugă o coloană status în ambele tabele, fără ca vreo eroare să semnaleze ceva. Dacă tabelele nu au nicio coloană comună, NATURAL JOIN devine un CROSS JOIN.

Recomandarea obișnuită în echipe:

  • ON ca variantă implicită;
  • USING acceptat când convenția de denumire este consecventă;
  • NATURAL JOIN evitat în codul aplicației, eventual folosit doar în explorări rapide.

Ce urmărește intervievatorul: Se verifică dacă te gândești la mentenanța codului, nu doar la rezultatul de azi. Candidații care cunosc NATURAL JOIN rareori pot spune de ce nu se folosește.

Eroarea, în practică:cannot join using columna NATURAL join may not have an ON or USING clause

14 Junior

Tabelul linii_comanda are cheia primară (comanda_id, produs_id), la fel și tabelul retururi. Raportul de mai jos arată cantități returnate prea mari. Unde e bug-ul?

SQL
SELECT l.comanda_id, l.produs_id, l.cantitate, r.cantitate AS returnat
FROM linii_comanda l
LEFT JOIN retururi r ON r.comanda_id = l.comanda_id;

Răspuns scurt: Condiția de JOIN folosește doar o parte din cheia compusă. Fiecare linie a comenzii se combină cu toate retururile din aceeași comandă, nu doar cu returul aceluiași produs. Condiția trebuie să includă și produs_id.

Când cheia unui tabel este compusă din mai multe coloane, JOIN-ul trebuie să folosească toate coloanele cheii. Aici fiecare rând din linii_comanda se potrivește cu toate retururile din aceeași comandă. O comandă cu 3 produse, din care 2 au fost returnate, produce 3 x 2 = 6 rânduri în loc de 3, iar cantitățile returnate apar lângă produse greșite.

Varianta corectă:

SQL
SELECT l.comanda_id, l.produs_id, l.cantitate,
       COALESCE(r.cantitate, 0) AS returnat
FROM linii_comanda l
LEFT JOIN retururi r
       ON r.comanda_id = l.comanda_id
      AND r.produs_id  = l.produs_id;

Cum găsești astfel de bug-uri:

  • compari numărul de rânduri al rezultatului cu cel al tabelului principal; la un LEFT JOIN pe o cheie unică, trebuie să fie egale;
  • pornești de la cheia tabelului din dreapta: dacă e (comanda_id, produs_id), condiția trebuie să le conțină pe amândouă ca să garanteze cel mult o potrivire;
  • verifici o comandă concretă, cu mai multe produse, rând cu rând.

O atenție suplimentară: dacă un produs poate fi returnat de mai multe ori din aceeași comandă (mai multe rânduri în retururi), atunci nici cheia completă nu mai e unică pe partea dreaptă și trebuie să agregi retururile înainte de JOIN, într-o subinterogare cu GROUP BY comanda_id, produs_id.

Ce urmărește intervievatorul: Se verifică dacă gândești în termeni de chei și granularitate. Greșeala tipică este legarea „după ce pare evident” (comanda), fără să verifici cheia tabelului din dreapta.

15 Junior

Tabelul comenzi are coloanele adresa_livrare_id și adresa_facturare_id, ambele chei străine către adrese. Scrie interogarea care afișează, pentru fiecare comandă, orașul de livrare și orașul de facturare.

Răspuns scurt: Faci JOIN cu tabelul adrese de două ori, cu aliasuri diferite, câte unul pentru fiecare rol. Folosești LEFT JOIN dacă una dintre adrese poate lipsi.

Același tabel poate apărea de mai multe ori într-o interogare, câte o dată pentru fiecare rol pe care îl joacă. Aliasurile sunt obligatorii, pentru că altfel nu poți spune la care „copie” se referă fiecare coloană.

SQL
SELECT c.id,
       c.data_comanda,
       al.oras AS oras_livrare,
       af.oras AS oras_facturare
FROM comenzi c
LEFT JOIN adrese al ON al.id = c.adresa_livrare_id
LEFT JOIN adrese af ON af.id = c.adresa_facturare_id;

De ce LEFT JOIN: la multe magazine adresa de facturare este opțională (NULL înseamnă „la fel ca livrarea”). Cu INNER JOIN, comenzile fără adresă de facturare ar dispărea din raport.

Poți aplica imediat logica de business:

SQL
SELECT c.id,
       al.oras AS oras_livrare,
       COALESCE(af.oras, al.oras) AS oras_facturare
FROM comenzi c
LEFT JOIN adrese al ON al.id = c.adresa_livrare_id
LEFT JOIN adrese af ON af.id = c.adresa_facturare_id;

Aliasurile scurte, dar cu sens (al, af, sau chiar livrare, facturare), fac interogarea ușor de citit. Aliasuri ca a1, a2 sunt o sursă clasică de confuzii la code review.

O greșeală frecventă este încercarea de a lega o singură dată, cu ON a.id = c.adresa_livrare_id OR a.id = c.adresa_facturare_id. Rezultatul are două rânduri pe comandă, iar orașele nu mai pot fi atribuite rolului corect.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi rolul aliasurilor și al tabelelor folosite de mai multe ori. Candidații încearcă uneori un singur JOIN cu OR, care dublează rândurile.

16 Junior

Interogarea de mai jos dă eroarea column reference "id" is ambiguous în PostgreSQL. De ce, și ce faci ca să eviți eroarea pe viitor?

SQL
SELECT id, nume, total
FROM clienti
JOIN comenzi ON clienti.id = comenzi.client_id
WHERE id > 100;

Răspuns scurt: Ambele tabele au o coloană id, iar în SELECT și în WHERE nu ai precizat din care tabel o vrei. Soluția este să prefixezi fiecare coloană cu aliasul tabelului, chiar și cele care azi nu sunt ambigue.

După JOIN, rezultatul intermediar conține toate coloanele din ambele tabele. Dacă două tabele au o coloană cu același nume (id, nume, creat_la, status), baza de date nu poate ghici la care te referi și oprește interogarea. MySQL dă o eroare similară: Column 'id' in field list is ambiguous.

Varianta corectă, cu aliasuri:

SQL
SELECT cl.id AS client_id,
       cl.nume,
       co.id AS comanda_id,
       co.total
FROM clienti cl
JOIN comenzi co ON co.client_id = cl.id
WHERE cl.id > 100;

Câteva reguli care previn problema:

  • prefixezi toate coloanele când interogarea are mai mult de un tabel, nu doar pe cele ambigue. Altfel, o coloană nouă adăugată într-un tabel (de exemplu nume în comenzi) strică interogări care mergeau.
  • redenumești în rezultat coloanele cu nume comun (cl.id AS client_id), ca aplicația sau raportul să nu primească două coloane numite id. Multe drivere păstrează doar una dintre ele când transformă rândul într-un dicționar.
  • eviți SELECT * în JOIN-uri pentru același motiv.

Reține și unde se pot folosi aliasurile de coloană: un alias definit în SELECT (AS comanda_id) nu există încă în WHERE, pentru că WHERE se evaluează logic înaintea lui SELECT. În ORDER BY însă îl poți folosi.

Ce urmărește intervievatorul: Se verifică disciplina de scriere în interogări cu mai multe tabele. Răspunsul slab doar adaugă prefixul acolo unde a apărut eroarea.

Eroarea, în practică:ambiguous column name

17 Junior

Vrei lista clienților care au cel puțin o comandă peste 500 de lei. Colegul tău scrie interogarea de mai jos și un client apare de 4 ori. De ce, și cum o rescrii?

SQL
SELECT c.id, c.nume
FROM clienti c
JOIN comenzi o ON o.client_id = c.id
WHERE o.total > 500;

Răspuns scurt: JOIN-ul produce câte un rând pentru fiecare comandă care îndeplinește condiția, deci un client cu 4 astfel de comenzi apare de 4 ori. Întrebarea este de tip „există”, așa că o scrii cu EXISTS, care întoarce fiecare client o singură dată.

Cererea „clienții care au cel puțin o comandă cu proprietatea X” se numește semi-join: vrei rânduri din clienti, filtrate după existența unor rânduri în comenzi, fără să aduci comenzile în rezultat. Un JOIN obișnuit nu exprimă asta, ci combinarea rândurilor, deci multiplică.

Varianta recomandată:

SQL
SELECT c.id, c.nume
FROM clienti c
WHERE EXISTS (
  SELECT 1
  FROM comenzi o
  WHERE o.client_id = c.id
    AND o.total > 500
);

Alternativa cu IN este echivalentă aici:

SQL
SELECT id, nume
FROM clienti
WHERE id IN (SELECT client_id FROM comenzi WHERE total > 500);

De ce nu SELECT DISTINCT c.id, c.nume ... JOIN? Funcționează, dar baza de date produce întâi toate combinațiile și apoi elimină duplicatele, ceea ce costă la volume mari. În plus, DISTINCT ascunde problema: dacă mai târziu adaugi o coloană din comenzi în SELECT, duplicatele revin. EXISTS spune exact ce vrei și se poate opri la prima comandă găsită pentru fiecare client.

Optimizatoarele moderne (PostgreSQL, MySQL 8) transformă de obicei EXISTS și IN într-un semi-join intern, deci performanța este similară; avantajul principal este corectitudinea și claritatea intenției.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că recunoști o întrebare de tip „există”. Răspunsul slab este să pui DISTINCT peste orice JOIN care produce duplicate.

18 Mid

Raportul trebuie să arate toți clienții, cu comenzile și plățile lor, dacă există. Clienții fără comenzi lipsesc din rezultat. De ce?

SQL
SELECT c.nume, o.id AS comanda_id, p.suma
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
JOIN plati p ON p.comanda_id = o.id;

Răspuns scurt: Al doilea JOIN este INNER: pentru clienții fără comenzi, o.id este NULL, condiția p.comanda_id = o.id dă UNKNOWN și rândul este eliminat. Un INNER JOIN după un LEFT JOIN anulează efectul acestuia; folosești LEFT JOIN și la plăți sau grupezi JOIN-urile cu paranteze.

JOIN-urile se evaluează logic de la stânga la dreapta. Primul LEFT JOIN produce un rând pentru fiecare client, cu NULL în coloanele din comenzi pentru cei fără comenzi. Al doilea JOIN, fiind INNER, păstrează doar rândurile pentru care găsește o plată. Pentru un rând cu o.id NULL nu există potrivire, deci rândul dispare, iar efectul final este al unui INNER JOIN pe tot lanțul.

Ai două variante, în funcție de ce vrei să afișezi.

Clienți, comenzi și plăți, toate opționale:

SQL
SELECT c.nume, o.id AS comanda_id, p.suma
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
LEFT JOIN plati p   ON p.comanda_id = o.id;
  • Toți clienții, dar doar comenzile care au plată (comenzile neplătite nu apar, clienții apar oricum):
SQL
SELECT c.nume, o.id AS comanda_id, p.suma
FROM clienti c
LEFT JOIN (comenzi o
           JOIN plati p ON p.comanda_id = o.id)
       ON o.client_id = c.id;

În a doua variantă, parantezele fac ca INNER JOIN-ul dintre comenzi și plăți să se evalueze întâi, iar rezultatul lui să fie atașat clienților prin LEFT JOIN. Aceeași logică se poate scrie cu o subinterogare sau un CTE, ceea ce mulți colegi găsesc mai lizibil.

Regula de verificat la code review: după primul LEFT JOIN, orice JOIN sau condiție din WHERE care atinge tabelele „opționale” trebuie privită cu atenție.

Ce urmărește intervievatorul: Se verifică dacă poți raționa despre un lanț de JOIN-uri, nu doar despre unul singur. Greșeala tipică este amestecul de LEFT și INNER JOIN fără să observi că al doilea îl anulează pe primul.

19 Mid

Vrei să potrivești clienții din două sisteme după email sau după telefon. Interogarea de mai jos e corectă, dar rulează foarte lent pe tabele mari. De ce, și cum o rescrii?

SQL
SELECT a.id AS id_crm, b.id AS id_shop
FROM crm_clienti a
JOIN shop_clienti b
  ON a.email = b.email OR a.telefon = b.telefon;

Răspuns scurt: Cu OR în condiția de JOIN, optimizatorul nu mai poate folosi un hash join sau un singur index și ajunge des la nested loop pe toate perechile. Rescrii ca două JOIN-uri simple, fiecare pe o singură coloană, unite cu UNION.

Algoritmii eficienți de JOIN (hash join, merge join) au nevoie de o condiție de egalitate pe care să o folosească drept cheie. O condiție a.email = b.email OR a.telefon = b.telefon nu are o singură cheie, așa că planul cade de obicei pe un nested loop care verifică fiecare pereche de rânduri. Pentru 200.000 x 200.000 de rânduri înseamnă 40 de miliarde de comparații.

Rescrierea separă condițiile:

SQL
SELECT a.id AS id_crm, b.id AS id_shop
FROM crm_clienti a
JOIN shop_clienti b ON a.email = b.email
UNION
SELECT a.id, b.id
FROM crm_clienti a
JOIN shop_clienti b ON a.telefon = b.telefon;

Fiecare ramură are o singură egalitate și poate folosi un hash join sau indexurile de pe email și telefon. UNION (fără ALL) elimină perechile găsite pe ambele căi, deci rezultatul este identic cu cel al interogării originale.

Câteva aspecte de calitate a datelor, pe care un intervievator le apreciază:

  • normalizezi înainte de potrivire: LOWER(TRIM(email)), telefonul fără spații și cu prefix unificat; altfel ratezi potriviri reale.
  • valorile NULL nu se potrivesc, ceea ce e bine; dar valorile „de umplutură” ('0000000000', 'n/a') trebuie excluse explicit, altfel creezi mii de perechi false.
  • un client poate potrivi mai mulți clienți din celălalt sistem; verifici cu GROUP BY id_crm HAVING COUNT(*) > 1 înainte să folosești rezultatul.

Ce urmărește intervievatorul: Întrebarea arată dacă știi cum execută baza de date un JOIN și dacă ai lucrat cu potriviri reale între surse. Mulți candidați nu văd problema de performanță a lui OR.

20 Mid

Tabelul tarife(produs_id, pret, valid_de_la, valid_pana_la) păstrează istoricul prețurilor (valid_pana_la este NULL pentru prețul curent, iar intervalul este închis la stânga și deschis la dreapta). Scrie interogarea care atașează fiecărei linii din vanzari(produs_id, data_vanzare, cantitate) prețul valabil la data vânzării.

Răspuns scurt: Faci un JOIN pe produs și pe interval: data vânzării trebuie să fie cel puțin valid_de_la și strict mai mică decât valid_pana_la, sau valid_pana_la să fie NULL. Este un non-equi join.

Un non-equi join folosește în condiție și altceva decât egalitatea: aici o comparație de interval. Condiția trebuie să respecte exact convenția intervalului (închis la stânga, deschis la dreapta), ca o vânzare din ziua schimbării prețului să primească un singur preț.

SQL
SELECT v.produs_id,
       v.data_vanzare,
       v.cantitate,
       t.pret,
       v.cantitate * t.pret AS valoare
FROM vanzari v
LEFT JOIN tarife t
       ON t.produs_id = v.produs_id
      AND v.data_vanzare >= t.valid_de_la
      AND (t.valid_pana_la IS NULL OR v.data_vanzare < t.valid_pana_la);

De ce LEFT JOIN: dacă o vânzare cade într-o „gaură” din istoric (de exemplu înainte de primul tarif), vrei să o vezi cu preț NULL, nu să dispară din raport. Un număr de rânduri diferit de cel al tabelului vanzari indică imediat o problemă de date:

  • mai multe rânduri înseamnă intervale suprapuse pentru același produs;
  • prețuri NULL înseamnă goluri în istoric.

Pentru performanță, un index pe tarife (produs_id, valid_de_la) ajută, iar în PostgreSQL poți modela intervalul ca tip daterange și scrie condiția t.perioada @> v.data_vanzare, cu un index GiST. Pentru a evita condiția cu NULL, unele echipe pun în valid_pana_la o dată foarte îndepărtată (9999-12-31) pentru prețul curent.

Ce urmărește intervievatorul: Se verifică dacă știi JOIN-uri care nu sunt pe egalitate și dacă te gândești la granițele intervalelor. Greșeala tipică este BETWEEN, care atribuie două prețuri vânzărilor din ziua schimbării.

21 Mid

Folosind linii_comanda(comanda_id, produs_id), scrie interogarea care găsește perechile de produse cumpărate cel mai des împreună în aceeași comandă.

Răspuns scurt: Faci un self join pe linii_comanda după comanda_id, cu condiția a.produs_id < b.produs_id ca să eviți perechile unui produs cu el însuși și dublurile (A,B)/(B,A), apoi grupezi pe pereche și numeri comenzile.

Este o analiză de tip „coș de cumpărături” (market basket). Unim tabelul cu el însuși pe aceeași comandă, astfel încât fiecare rând al rezultatului să reprezinte o pereche de produse din aceeași comandă.

SQL
SELECT a.produs_id AS produs_1,
       b.produs_id AS produs_2,
       COUNT(DISTINCT a.comanda_id) AS nr_comenzi
FROM linii_comanda a
JOIN linii_comanda b
  ON b.comanda_id = a.comanda_id
 AND a.produs_id < b.produs_id
GROUP BY a.produs_id, b.produs_id
ORDER BY nr_comenzi DESC
LIMIT 20;

Rolul condiției a.produs_id < b.produs_id:

  • cu <> ai obține fiecare pereche de două ori, (A,B) și (B,A), deci numărătorile ar fi dublate pe rânduri separate;
  • fără nicio condiție, ai obține și perechile (A,A).

COUNT(DISTINCT a.comanda_id) protejează rezultatul dacă același produs poate apărea pe mai multe linii ale aceleiași comenzi (de exemplu la variante diferite). Dacă cheia tabelului garantează un singur rând pe (comandă, produs), ajunge COUNT(*).

Atenție la volum: o comandă cu n produse produce n(n-1)/2 perechi. Comenzile foarte mari (de exemplu achiziții en-gros cu sute de produse) pot domina calculul și distorsiona rezultatul; e rezonabil să le excluzi sau să le analizezi separat. Pentru un rezultat mai informativ, raportezi și ponderea: câte comenzi cu produsul 1 conțin și produsul 2.

Ce urmărește intervievatorul: Se verifică stăpânirea self join-ului într-un caz de business real. Greșeala tipică este condiția <>, care dublează toate perechile.

22 Senior

Pentru fiecare client vrei ultimele 3 comenzi. În PostgreSQL, cum rezolvi cu LATERAL și când este această variantă mai bună decât o funcție fereastră?

Răspuns scurt: Cu CROSS JOIN LATERAL rulezi, pentru fiecare client, o subinterogare care poate referi coloanele clientului și face ORDER BY ... LIMIT 3. Cu un index pe (client_id, data_comanda) citește doar 3 rânduri pe client, în loc să numeroteze toate comenzile.

O subinterogare din FROM nu poate referi, în mod normal, alte tabele din același FROM. Cuvântul LATERAL ridică această restricție: subinterogarea se evaluează pentru fiecare rând din stânga și poate folosi coloanele lui, ca un „for each”.

SQL
SELECT c.id, c.nume, u.id AS comanda_id, u.data_comanda, u.total
FROM clienti c
CROSS JOIN LATERAL (
  SELECT o.id, o.data_comanda, o.total
  FROM comenzi o
  WHERE o.client_id = c.id
  ORDER BY o.data_comanda DESC, o.id DESC
  LIMIT 3
) u;

CROSS JOIN LATERAL elimină clienții fără comenzi; dacă vrei să-i păstrezi, scrii LEFT JOIN LATERAL (...) u ON true.

Cu indexul CREATE INDEX ON comenzi (client_id, data_comanda DESC, id DESC), fiecare execuție a subinterogării este o căutare în index care se oprește după 3 rânduri. Varianta cu ROW_NUMBER() OVER (PARTITION BY client_id ORDER BY data_comanda DESC) trebuie, în schimb, să citească și să numeroteze toate comenzile tuturor clienților, apoi să filtreze rn <= 3.

Când alegi fiecare:

  • LATERAL câștigă când ai puțini clienți selectați (o pagină, un segment) și mulți clienți cu istoric lung.
  • Funcția fereastră câștigă când procesezi oricum tot tabelul (un raport complet), pentru că un singur parcurs secvențial este mai ieftin decât milioane de căutări în index.

MySQL suportă LATERAL din versiunea 8.0.14, iar SQL Server are echivalentele CROSS APPLY și OUTER APPLY.

Ce urmărește intervievatorul: Se verifică dacă știi mai multe tehnici pentru „top N pe grup” și dacă le poți alege după volumul datelor. Candidații de nivel mid cunosc de obicei doar varianta cu ROW_NUMBER.

Agregări și GROUP BY

Exersează capitolul cu exerciții reale: Curs SQL online →
23 Junior

Tabelul note(elev, nota) are trei rânduri pentru același elev: 10, NULL și 20 (nota NULL înseamnă că elevul nu a dat testul). Ce afișează interogarea?

SQL
SELECT AVG(nota)               AS a,
       SUM(nota) / COUNT(*)    AS b,
       AVG(COALESCE(nota, 0))  AS c
FROM note;

Răspuns scurt: a = 15, pentru că AVG ignoră NULL-urile (30 / 2). b = 10, pentru că COUNT(*) numără toate cele 3 rânduri. c = 10, pentru că NULL devine 0 înainte de medie. Care e „corect” depinde de ce înseamnă NULL în business.

Funcțiile de agregare (SUM, AVG, MIN, MAX, COUNT(coloana)) ignoră valorile NULL. Doar COUNT(*) numără rânduri, indiferent de conținut.

  • AVG(nota) = (10 + 20) / 2 = 15.
  • SUM(nota) / COUNT(*) = 30 / 3 = 10. În PostgreSQL, dacă nota este integer, atenție: SUM pe integer întoarce bigint, iar împărțirea la COUNT(*) (tot bigint) este întreagă. Aici 30 / 3 iese exact, dar 31 / 3 ar da 10, nu 10.33.
  • AVG(COALESCE(nota, 0)) = (10 + 0 + 20) / 3 = 10.

În PostgreSQL, AVG pe întregi întoarce numeric, deci a se afișează de obicei 15.0000000000000000. În MySQL rezultatul e 15.0000.

Partea importantă a răspunsului nu e aritmetica, ci întrebarea de business: ce înseamnă NULL aici?

  • Dacă înseamnă „testul nu s-a dat încă”, media corectă este 15: evaluezi doar ce există.
  • Dacă înseamnă „a lipsit și primește 0”, media corectă este 10, iar regula trebuie scrisă explicit cu COALESCE.

Într-un raport bun, afișezi și câte valori au intrat în calcul, ca cititorul să poată judeca: COUNT(nota) AS note_existente, COUNT(*) AS total_elevi. Diferența dintre ele arată imediat cât de incomplete sunt datele.

Ce urmărește intervievatorul: Se verifică dacă știi cum tratează agregatele NULL-ul și dacă te gândești la sensul datelor. Răspunsul slab dă o singură cifră fără să întrebe ce înseamnă valoarea lipsă.

24 Junior

Vrei numele angajatului cel mai bine plătit din fiecare departament. Ce face interogarea de mai jos în PostgreSQL și ce poate face într-un MySQL configurat fără ONLY_FULL_GROUP_BY?

SQL
SELECT departament, nume, MAX(salariu)
FROM angajati
GROUP BY departament;

Răspuns scurt: PostgreSQL dă eroare, pentru că nume nu este în GROUP BY și nici într-o funcție de agregare. Un MySQL permisiv întoarce un nume oarecare din grup, care nu este neapărat al celui cu salariul maxim. Corect folosești o funcție fereastră sau DISTINCT ON.

După GROUP BY departament, fiecare grup devine un singur rând. Pentru coloanele din GROUP BY valoarea e clară; pentru agregate (MAX(salariu)) la fel. Dar nume are mai multe valori în grup și standardul nu spune pe care să o aleagă, de aceea PostgreSQL oprește interogarea cu column "angajati.nume" must appear in the GROUP BY clause or be used in an aggregate function.

MySQL are modul ONLY_FULL_GROUP_BY activ implicit din versiunea 5.7.5 și dă o eroare asemănătoare. Pe servere vechi sau configurate permisiv, MySQL întoarce o valoare arbitrară din grup. MAX(salariu) nu „trage” după el numele angajatului respectiv: cele două coloane sunt calculate independent. Rezultatul arată plauzibil și e greșit.

Variante corecte:

SQL
-- portabil, cu funcție fereastră
SELECT departament, nume, salariu
FROM (
  SELECT departament, nume, salariu,
         RANK() OVER (PARTITION BY departament ORDER BY salariu DESC) AS rk
  FROM angajati
) t
WHERE rk = 1;

-- PostgreSQL, un singur rând pe departament
SELECT DISTINCT ON (departament) departament, nume, salariu
FROM angajati
ORDER BY departament, salariu DESC, nume;

RANK întoarce toți angajații la egalitate pe primul loc, iar DISTINCT ON alege unul, după criteriul de departajare din ORDER BY. Reține și o excepție utilă: dacă grupezi după cheia primară a unui tabel, PostgreSQL și MySQL 8 îți permit să selectezi celelalte coloane ale lui, pentru că depind funcțional de cheie.

Ce urmărește intervievatorul: Întrebarea testează înțelegerea reală a lui GROUP BY. Greșeala tipică, moștenită din MySQL vechi, este credința că MAX aduce cu el și celelalte coloane ale rândului maxim.

25 Junior

Scrie o singură interogare care afișează, pe fiecare lună, numărul total de comenzi, numărul de comenzi plătite și numărul de comenzi anulate, din tabelul comenzi(id, data_comanda, status).

Răspuns scurt: Grupezi pe lună și folosești agregare condiționată: COUNT(*) FILTER (WHERE status = 'platita') în PostgreSQL sau SUM(CASE WHEN status = 'platita' THEN 1 ELSE 0 END), care merge peste tot.

Agregarea condiționată calculează mai multe indicatori dintr-o singură trecere prin tabel, câte unul pe coloană, în loc să rulezi trei interogări separate sau să faci JOIN între ele.

Varianta portabilă:

SQL
SELECT DATE_TRUNC('month', data_comanda) AS luna,
       COUNT(*) AS total,
       SUM(CASE WHEN status = 'platita' THEN 1 ELSE 0 END) AS platite,
       SUM(CASE WHEN status = 'anulata' THEN 1 ELSE 0 END) AS anulate
FROM comenzi
GROUP BY DATE_TRUNC('month', data_comanda)
ORDER BY luna;

(DATE_TRUNC este din PostgreSQL; în MySQL folosești DATE_FORMAT(data_comanda, '%Y-%m-01').)

PostgreSQL (de la 9.4) și SQLite (de la 3.30) au clauza standard FILTER, mai lizibilă:

SQL
COUNT(*) FILTER (WHERE status = 'platita') AS platite,
SUM(total) FILTER (WHERE status = 'platita') AS incasat

În MySQL există o scurtătură: o comparație întoarce 1 sau 0, deci SUM(status = 'platita') numără direct rândurile adevărate. E comod, dar nu e portabil.

Alte forme întâlnite: COUNT(CASE WHEN status = 'platita' THEN 1 END), care profită de faptul că CASE fără ELSE dă NULL, iar COUNT ignoră NULL. Atenție la varianta COUNT(CASE WHEN ... THEN 1 ELSE 0 END): numără și zerourile, deci întoarce totalul.

Pe aceeași idee poți calcula direct și procentul: ROUND(100.0 * SUM(CASE ...) / COUNT(*), 1) AS pct_platite.

Ce urmărește intervievatorul: Se verifică dacă știi să produci un raport compact dintr-o singură interogare. Greșeala frecventă este COUNT cu ELSE 0, care numără tot.

Eroarea, în practică:FILTER may not be used with non-aggregate upper()FILTER only with aggregate window functions

26 Junior

Un coleg grupează vânzările pe lună cu GROUP BY EXTRACT(MONTH FROM data_vanzare), iar cifrele pentru ianuarie par dublate. Ce s-a întâmplat și cum grupezi corect pe lună?

Răspuns scurt: EXTRACT(MONTH) întoarce doar numărul lunii (1–12), deci ianuarie 2025 și ianuarie 2026 intră în același grup. Grupezi după an și lună împreună, de exemplu cu DATE_TRUNC('month', ...) în PostgreSQL sau DATE_FORMAT(..., '%Y-%m') în MySQL.

EXTRACT(MONTH FROM data) (sau MONTH(data) în MySQL) scoate o componentă a datei, fără anul. Dacă tabelul conține mai mult de 12 luni de date, toate lunile cu același număr se adună în același grup. Bug-ul apare tipic la începutul unui an nou, când un raport care mergea bine începe să arate cifre duble pentru ianuarie.

Variante corecte:

SQL
-- PostgreSQL: prima zi a lunii, tip timestamp
SELECT DATE_TRUNC('month', data_vanzare) AS luna,
       SUM(valoare) AS total
FROM vanzari
GROUP BY 1
ORDER BY 1;

-- MySQL
SELECT DATE_FORMAT(data_vanzare, '%Y-%m') AS luna,
       SUM(valoare) AS total
FROM vanzari
GROUP BY luna
ORDER BY luna;

-- portabil
SELECT EXTRACT(YEAR FROM data_vanzare) AS an,
       EXTRACT(MONTH FROM data_vanzare) AS luna,
       SUM(valoare) AS total
FROM vanzari
GROUP BY EXTRACT(YEAR FROM data_vanzare), EXTRACT(MONTH FROM data_vanzare)
ORDER BY an, luna;

DATE_TRUNC are un avantaj practic: rezultatul este tot o dată, deci se sortează cronologic și se poate lega ușor de un tabel calendar. Un text de forma '2026-01' se sortează corect doar dacă are luna scrisă pe două cifre.

Două detalii: GROUP BY 1 (după poziția coloanei) este acceptat de PostgreSQL și MySQL, dar unele echipe îl evită pentru lizibilitate. Iar dacă datele sunt timestamptz, „luna” depinde de fusul orar al sesiunii: o vânzare din 31 ianuarie, ora 23:30 la București, poate cădea în altă lună dacă sesiunea rulează în UTC.

Ce urmărește intervievatorul: Se verifică atenția la granularitatea grupării. Greșeala clasică e să grupezi după o componentă a datei în loc de perioada completă.

Eroarea, în practică:no such function: YEARno such function: DATE_TRUNC

27 Junior

Pentru fiecare comandă vrei un singur rând cu lista produselor, separate prin virgulă și sortate alfabetic. Cum scrii asta în PostgreSQL și în MySQL? Ce capcană are MySQL?

Răspuns scurt: În PostgreSQL folosești STRING_AGG(p.nume, ', ' ORDER BY p.nume), iar în MySQL GROUP_CONCAT(p.nume ORDER BY p.nume SEPARATOR ', '). Capcana MySQL: rezultatul este tăiat la group_concat_max_len, implicit 1024 de octeți, doar cu un warning.

Funcțiile de concatenare la agregare transformă valorile unui grup într-un singur text.

SQL
-- PostgreSQL (și SQL Server 2017+ cu WITHIN GROUP)
SELECT l.comanda_id,
       STRING_AGG(p.nume, ', ' ORDER BY p.nume) AS produse
FROM linii_comanda l
JOIN produse p ON p.id = l.produs_id
GROUP BY l.comanda_id;

-- MySQL
SELECT l.comanda_id,
       GROUP_CONCAT(p.nume ORDER BY p.nume SEPARATOR ', ') AS produse
FROM linii_comanda l
JOIN produse p ON p.id = l.produs_id
GROUP BY l.comanda_id;

Ambele ignoră valorile NULL. Fără ORDER BY în interiorul funcției, ordinea elementelor din listă nu este garantată.

Capcana din MySQL este variabila group_concat_max_len, cu valoarea implicită 1024. Când lista depășește limita, rezultatul este tăiat tacit, iar serverul emite doar un warning pe care aplicațiile rar îl citesc. Dacă exporți astfel liste de emailuri sau de ID-uri, pierzi date fără nicio eroare. Soluția este SET SESSION group_concat_max_len = 1000000; înainte de interogare.

Ambele funcții acceptă și DISTINCT: STRING_AGG(DISTINCT p.nume, ', '); în PostgreSQL, cu DISTINCT, expresia din ORDER BY trebuie să fie chiar valoarea agregată.

Folosește aceste funcții pentru afișare. Dacă aplicația are nevoie de date structurate, e mai sigur să agregi într-un array (ARRAY_AGG în PostgreSQL) sau în JSON (JSON_AGG, respectiv JSON_ARRAYAGG în MySQL), ca să nu mai „parsezi” textul înapoi și să nu ai probleme cu numele care conțin virgule.

Ce urmărește intervievatorul: Se verifică familiaritatea cu funcțiile de agregare pe text și cu limitele lor. Puțini candidați știu de trunchierea tacită din MySQL.

Eroarea, în practică:DISTINCT aggregates must have exactly one argumentno such function: ARRAY_AGG

28 Mid

Ce întorc interogările următoare dacă tabelul comenzi nu are niciun rând pentru clientul 999? De ce contează diferența în cod?

SQL
SELECT COUNT(*), SUM(total), MAX(total) FROM comenzi WHERE client_id = 999;

SELECT client_id, COUNT(*), SUM(total) FROM comenzi WHERE client_id = 999 GROUP BY client_id;

Răspuns scurt: Prima întoarce un rând: 0, NULL, NULL. A doua întoarce zero rânduri, pentru că nu există niciun grup. Codul care așteaptă un rând sau un număr trebuie să trateze ambele situații.

Un agregat fără GROUP BY tratează tot rezultatul filtrat ca un singur grup, chiar dacă e gol. De aceea întoarce mereu exact un rând:

  • COUNT(*) și COUNT(coloana) dau 0;
  • SUM, AVG, MIN, MAX dau NULL, nu 0. Suma unei mulțimi goale este NULL în SQL.

Cu GROUP BY, rezultatul are câte un rând pentru fiecare grup existent. Dacă nu există rânduri, nu există grupuri, deci nici rânduri în rezultat.

Consecințe practice:

SQL
-- totalul cheltuit, cu 0 în loc de NULL
SELECT COALESCE(SUM(total), 0) AS total_cheltuit
FROM comenzi
WHERE client_id = 999;
  • În aplicație, codul care face row["total"] + 10 crapă pe NULL. Codul care citește „primul rând” al unei interogări cu GROUP BY primește nimic.
  • Într-o subinterogare scalară, (SELECT SUM(total) FROM comenzi WHERE client_id = c.id) dă NULL pentru clienții fără comenzi, iar o comparație > 1000 va fi UNKNOWN, deci clientul nu e nici „peste”, nici „sub”.
  • HAVING fără GROUP BY lucrează pe acel grup unic: SELECT COUNT(*) FROM comenzi WHERE client_id = 999 HAVING COUNT(*) > 0 întoarce zero rânduri, un truc util când vrei rezultat gol în loc de 0.

Când un raport pe grupuri trebuie să arate și entitățile cu zero (clienți fără comenzi, zile fără vânzări), soluția nu e COALESCE, ci pornirea de la tabelul complet al entităților și un LEFT JOIN.

Ce urmărește intervievatorul: Se verifică dacă știi semantica agregatelor pe mulțimi goale, o sursă frecventă de erori în aplicații. Mulți candidați cred că SUM întoarce 0.

29 Mid

Scrie interogarea care afișează, pe fiecare categorie, valoarea vânzărilor și procentul din totalul general, într-o singură interogare, din vanzari(categorie, valoare).

Răspuns scurt: Grupezi pe categorie și împarți suma categoriei la totalul general calculat cu o funcție fereastră peste rezultatul agregat: SUM(valoare) / SUM(SUM(valoare)) OVER ().

Funcțiile fereastră se evaluează după GROUP BY, deci pot lucra pe rândurile deja agregate. Expresia SUM(SUM(valoare)) OVER () arată ciudat la prima vedere, dar se citește din interior spre exterior: SUM(valoare) este suma pe categorie (agregatul obișnuit), iar SUM(...) OVER () adună aceste sume peste toate rândurile rezultatului, adică totalul general.

SQL
SELECT categorie,
       SUM(valoare) AS valoare,
       ROUND(100.0 * SUM(valoare) / SUM(SUM(valoare)) OVER (), 2) AS pct_din_total
FROM vanzari
GROUP BY categorie
ORDER BY valoare DESC;

Variante echivalente, utile dacă sistemul nu are funcții fereastră (MySQL înainte de 8.0) sau dacă vrei claritate:

SQL
WITH pe_categorie AS (
  SELECT categorie, SUM(valoare) AS valoare
  FROM vanzari
  GROUP BY categorie
)
SELECT categorie, valoare,
       ROUND(100.0 * valoare / (SELECT SUM(valoare) FROM pe_categorie), 2) AS pct_din_total
FROM pe_categorie;

Detalii care contează:

  • 100.0 evită împărțirea întreagă în PostgreSQL când valoare este întreg.
  • procentele rotunjite pot să nu adune exact 100; dacă raportul cere asta, explici diferența sau o atribui ultimei categorii.
  • dacă vrei procentul în cadrul unui părinte (de exemplu subcategorie din categorie), folosești OVER (PARTITION BY categorie) și grupezi pe ambele niveluri.

Ce urmărește intervievatorul: Se verifică dacă înțelegi ordinea în care se evaluează GROUP BY și funcțiile fereastră. Candidații fac adesea două interogări sau un CROSS JOIN cu totalul, ceea ce merge, dar arată că nu cunosc tehnica.

30 Mid

Raportul de vânzări trebuie să arate suma pe regiune și oraș, subtotalul fiecărei regiuni și totalul general, într-un singur rezultat. Cum faci asta și cum deosebești un subtotal de un oraș cu valoare NULL?

Răspuns scurt: Folosești GROUP BY ROLLUP (regiune, oras) (în MySQL, GROUP BY regiune, oras WITH ROLLUP). Rândurile de subtotal au NULL în coloanele „rulate”, iar funcția GROUPING(oras) întoarce 1 pentru ele, ca să le separi de NULL-urile reale.

ROLLUP produce mai multe niveluri de grupare într-o singură interogare. ROLLUP (regiune, oras) este echivalent cu trei grupări unite: (regiune, oras), (regiune) și (), adică totalul general.

SQL
-- PostgreSQL, SQL Server, Oracle
SELECT CASE WHEN GROUPING(regiune) = 1 THEN 'TOTAL' ELSE regiune END AS regiune,
       CASE WHEN GROUPING(oras) = 1 AND GROUPING(regiune) = 0 THEN 'Subtotal'
            ELSE oras END AS oras,
       SUM(valoare) AS valoare
FROM vanzari
GROUP BY ROLLUP (regiune, oras)
ORDER BY GROUPING(regiune), regiune, GROUPING(oras), oras;

-- MySQL 8
SELECT regiune, oras, SUM(valoare) AS valoare, GROUPING(oras) AS e_subtotal
FROM vanzari
GROUP BY regiune, oras WITH ROLLUP;

Pe rândurile de subtotal, coloana agregată „în sus” este NULL. Dacă în date există și orașe necunoscute (NULL), nu poți deosebi un subtotal de grupul „oraș necunoscut” doar uitându-te la valoare. GROUPING(col) întoarce 1 când NULL-ul provine din ROLLUP și 0 când este o valoare reală. În MySQL, GROUPING() există din versiunea 8.0.

Variante înrudite:

  • CUBE (a, b) produce toate combinațiile: (a,b), (a), (b), ();
  • GROUPING SETS ((regiune), (canal), ()) îți dă exact grupările enumerate, util pentru totaluri pe dimensiuni independente. MySQL nu are CUBE sau GROUPING SETS, doar WITH ROLLUP.

Pentru rapoarte destinate Excel sau unui dashboard, ROLLUP evită calculul subtotalurilor în aplicație, unde apar ușor diferențe de rotunjire.

Ce urmărește intervievatorul: Se verifică dacă știi extensiile GROUP BY folosite în raportare. Puțini candidați știu de GROUPING() și de ambiguitatea NULL-urilor.

Eroarea, în practică:near "WITH": syntax error (GROUP BY ... WITH ROLLUP)

31 Mid

Cum calculezi salariul median pe departament în PostgreSQL? Dar în MySQL, care nu are o funcție de mediană?

Răspuns scurt: În PostgreSQL folosești PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY salariu). În MySQL numerotezi salariile din fiecare departament cu ROW_NUMBER, numeri rândurile și faci media valorii sau valorilor din mijloc.

Media aritmetică este sensibilă la valori extreme: un director cu salariu foarte mare trage în sus media unui departament mic. Mediana, valoarea din mijloc, descrie mai bine „salariul tipic”.

PostgreSQL are funcții de agregare ordonată:

SQL
SELECT departament,
       PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY salariu) AS mediana,
       PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY salariu) AS mediana_disc
FROM angajati
GROUP BY departament;
  • PERCENTILE_CONT interpolează: pentru 4 valori întoarce media celor două din mijloc.
  • PERCENTILE_DISC întoarce o valoare care există efectiv în date (prima a cărei poziție atinge percentila).

Cu aceleași funcții calculezi și quartile: PERCENTILE_CONT(ARRAY[0.25, 0.5, 0.75]) WITHIN GROUP (ORDER BY salariu).

MySQL 8 nu are aceste funcții, dar mediana se poate calcula cu funcții fereastră:

SQL
SELECT departament, AVG(salariu) AS mediana
FROM (
  SELECT departament, salariu,
         ROW_NUMBER() OVER (PARTITION BY departament ORDER BY salariu) AS rn,
         COUNT(*)     OVER (PARTITION BY departament) AS n
  FROM angajati
) t
WHERE rn IN (FLOOR((n + 1) / 2), CEIL((n + 1) / 2))
GROUP BY departament;

Pentru n impar, cele două expresii dau aceeași poziție; pentru n par, dau cele două poziții din mijloc, iar AVG face media lor. PERCENTILE_CONT ignoră NULL-urile; în varianta MySQL le filtrezi explicit în subinterogare (WHERE salariu IS NOT NULL), altfel intră în numărare.

Ce urmărește intervievatorul: Se verifică dacă știi să calculezi statistici care nu sunt agregate simple și dacă te descurci și fără funcția dedicată. Greșeala tipică este calculul greșit al pozițiilor din mijloc pentru număr par de rânduri.

32 Senior

Scrie interogarea care găsește clienții care au cumpărat toate produsele din categoria 'Cafea'. Ce întoarce soluția ta dacă în categorie nu există niciun produs?

Răspuns scurt: Grupezi achizițiile din categorie pe client și păstrezi clienții la care numărul de produse distincte cumpărate este egal cu numărul de produse din categorie. Dacă categoria e goală, această variantă nu întoarce pe nimeni, iar varianta cu dublu NOT EXISTS întoarce toți clienții.

Problema se numește diviziune relațională: „găsește X care sunt asociați cu toți Y dintr-o mulțime”. Două soluții clasice.

Cu numărare:

SQL
SELECT o.client_id
FROM comenzi o
JOIN linii_comanda l ON l.comanda_id = o.id
JOIN produse p       ON p.id = l.produs_id
WHERE p.categorie = 'Cafea'
GROUP BY o.client_id
HAVING COUNT(DISTINCT p.id) = (SELECT COUNT(*) FROM produse WHERE categorie = 'Cafea');

COUNT(DISTINCT) este esențial, pentru că un client poate cumpăra același produs de mai multe ori.

Cu dublă negație („nu există niciun produs din categorie pe care clientul să nu-l fi cumpărat”):

SQL
SELECT c.id
FROM clienti c
WHERE NOT EXISTS (
  SELECT 1 FROM produse p
  WHERE p.categorie = 'Cafea'
    AND NOT EXISTS (
      SELECT 1
      FROM comenzi o JOIN linii_comanda l ON l.comanda_id = o.id
      WHERE o.client_id = c.id AND l.produs_id = p.id
    )
);

Cazul categoriei goale scoate la iveală diferența: numărarea nu găsește niciun rând în JOIN, deci nu întoarce niciun client; dubla negație este adevărată „prin vid” pentru toți clienții. Logic, a doua variantă este corectă matematic, dar rar e ce vrea business-ul. Un răspuns de nivel senior semnalează explicit cazul și întreabă ce comportament se dorește.

Ca performanță, varianta cu numărare se execută de obicei ca o singură agregare și scalează bine. Dubla negație beneficiază de indexuri pe linii_comanda (produs_id, comanda_id) și comenzi (client_id).

Ce urmărește intervievatorul: Întrebarea verifică dacă recunoști un tipar clasic și dacă te gândești la cazurile limită. Greșeala frecventă este COUNT(*) fără DISTINCT, care numără achiziții repetate ca produse diferite.

Subinterogări și CTE

33 Junior

Interogarea de mai jos dă în PostgreSQL eroarea more than one row returned by a subquery used as an expression. Ce înseamnă și cum o repari, în funcție de ce vrei să afișezi?

SQL
SELECT c.nume,
       (SELECT o.total FROM comenzi o WHERE o.client_id = c.id) AS total
FROM clienti c;

Răspuns scurt: O subinterogare folosită ca valoare (scalară) trebuie să întoarcă cel mult un rând și o coloană. Un client cu mai multe comenzi produce mai multe rânduri. Repari agregând (SUM, MAX), alegând explicit un rând cu ORDER BY și LIMIT, sau mutând logica într-un JOIN.

O subinterogare scalară apare acolo unde SQL așteaptă o singură valoare: în SELECT, în WHERE lângă = sau >, în SET la UPDATE. Regulile sunt:

  • zero rânduri: valoarea devine NULL;
  • un rând: valoarea lui;
  • mai multe rânduri: eroare la execuție (în MySQL: Subquery returns more than 1 row).

Eroarea apare doar când datele o declanșează, deci interogarea poate merge în teste și să crape în producție, la primul client cu două comenzi.

Reparația depinde de ce înseamnă „totalul clientului”:

SQL
-- suma tuturor comenzilor
SELECT c.nume,
       (SELECT SUM(o.total) FROM comenzi o WHERE o.client_id = c.id) AS total
FROM clienti c;

-- valoarea ultimei comenzi
SELECT c.nume,
       (SELECT o.total FROM comenzi o
        WHERE o.client_id = c.id
        ORDER BY o.data_comanda DESC, o.id DESC
        LIMIT 1) AS ultima_comanda
FROM clienti c;

-- echivalent cu JOIN și agregare
SELECT c.nume, SUM(o.total) AS total
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
GROUP BY c.id, c.nume;

Același tip de eroare apare la WHERE id = (SELECT ...). Când subinterogarea poate întoarce mai multe valori, folosești IN în loc de =. Iar dacă știi că trebuie să fie un singur rând (o setare, un curs valutar pe o zi), lasă eroarea să apară: e mai bine să afli că datele sunt duplicate decât să alegi tacit unul.

Ce urmărește intervievatorul: Se verifică dacă înțelegi regulile subinterogărilor scalare. Greșeala tipică este adăugarea unui LIMIT 1 fără ORDER BY doar ca să dispară eroarea.

Eroarea, în practică:sub-select returns 2 columns - expected 1

34 Junior

Scrie interogarea care întoarce al doilea cel mai mare salariu din tabelul angajati(id, nume, salariu). Ce întoarce soluția ta dacă toți angajații au același salariu?

Răspuns scurt: SELECT MAX(salariu) FROM angajati WHERE salariu < (SELECT MAX(salariu) FROM angajati). Dacă toți au același salariu, nu există un al doilea salariu distinct, iar interogarea întoarce un rând cu NULL.

Întrebarea cere de obicei a doua valoare distinctă: dacă doi angajați au salariul maxim, al doilea salariu este următoarea valoare, nu aceeași cifră. Merită să clarifici asta cu intervievatorul înainte să scrii codul.

Varianta cu subinterogare, portabilă:

SQL
SELECT MAX(salariu) AS al_doilea_salariu
FROM angajati
WHERE salariu < (SELECT MAX(salariu) FROM angajati);

Dacă nu există al doilea salariu, WHERE nu lasă niciun rând, iar MAX pe mulțime goală dă NULL, deci rezultatul este un rând cu NULL, un comportament ușor de tratat în aplicație.

Varianta cu sortare:

SQL
SELECT DISTINCT salariu
FROM angajati
ORDER BY salariu DESC
LIMIT 1 OFFSET 1;

Aici, dacă nu există al doilea salariu, rezultatul are zero rânduri, nu un NULL. Fără DISTINCT, două salarii maxime egale ar face ca „al doilea” să fie tot maximul.

Pentru varianta generală, al N-lea salariu, funcția fereastră e cea mai clară:

SQL
SELECT DISTINCT salariu
FROM (
  SELECT salariu, DENSE_RANK() OVER (ORDER BY salariu DESC) AS rk
  FROM angajati
) t
WHERE rk = 2;

DENSE_RANK dă același rang valorilor egale și nu lasă goluri, deci rangul 2 este a doua valoare distinctă. Toate variantele ignoră salariile NULL, deoarece MAX și comparațiile le exclud; la sortare însă, în PostgreSQL NULL ar ieși primul la DESC, deci în a doua variantă adaugi WHERE salariu IS NOT NULL.

Ce urmărește intervievatorul: Este o întrebare clasică ce verifică atenția la duplicate și la cazul gol. Răspunsul slab folosește LIMIT 1 OFFSET 1 fără DISTINCT și fără să discute egalitățile.

35 Junior

Scrie interogarea care afișează produsele mai scumpe decât prețul mediu din propria lor categorie, din tabelul produse(id, nume, categorie_id, pret).

Răspuns scurt: Folosești o subinterogare corelată care calculează media pentru categoria rândului curent: WHERE p.pret > (SELECT AVG(p2.pret) FROM produse p2 WHERE p2.categorie_id = p.categorie_id). O alternativă este media calculată cu o funcție fereastră într-o subinterogare.

Comparația nu se face cu o medie globală, ci cu media grupului din care face parte fiecare rând. O subinterogare corelată referă o coloană a interogării exterioare (p.categorie_id), deci logic se evaluează pentru fiecare rând.

SQL
SELECT p.id, p.nume, p.categorie_id, p.pret
FROM produse p
WHERE p.pret > (
  SELECT AVG(p2.pret)
  FROM produse p2
  WHERE p2.categorie_id = p.categorie_id
);

Aliasurile diferite (p și p2) sunt obligatorii: fără ele, categorie_id = categorie_id s-ar referi la același tabel interior și ar compara fiecare rând cu el însuși, deci ai obține media globală.

Varianta cu funcție fereastră îți permite să afișezi și media, util într-un raport:

SQL
SELECT id, nume, categorie_id, pret, medie_categorie
FROM (
  SELECT p.*,
         AVG(pret) OVER (PARTITION BY categorie_id) AS medie_categorie
  FROM produse p
) t
WHERE pret > medie_categorie;

A treia variantă calculează mediile o singură dată într-un tabel derivat și face JOIN:

SQL
SELECT p.*
FROM produse p
JOIN (SELECT categorie_id, AVG(pret) AS m FROM produse GROUP BY categorie_id) a
  ON a.categorie_id = p.categorie_id
WHERE p.pret > a.m;

Optimizatoarele moderne transformă adesea subinterogarea corelată într-o formă asemănătoare cu a treia, dar nu întotdeauna. Pe tabele mari, variantele cu fereastră sau cu tabel derivat sunt mai previzibile.

Ce urmărește intervievatorul: Se verifică dacă știi să compari un rând cu grupul lui și dacă stăpânești aliasurile în subinterogări corelate. Greșeala tipică este o subinterogare necorelată, care compară cu media tuturor produselor.

Eroarea, în practică:misuse of aggregate function AVG()

36 Junior

Care este diferența dintre IN (subinterogare) și EXISTS (subinterogare)? Ce contează ce scrii în SELECT-ul din interiorul lui EXISTS?

Răspuns scurt: IN verifică dacă o valoare se află în lista întoarsă de subinterogare; EXISTS verifică doar dacă subinterogarea întoarce cel puțin un rând. Conținutul SELECT-ului din EXISTS nu contează, de aceea se scrie convențional SELECT 1.

Cele două exprimă aceeași idee, „există o potrivire”, în moduri diferite.

SQL
-- IN: subinterogare independentă, care produce o listă de valori
SELECT * FROM produse
WHERE id IN (SELECT produs_id FROM linii_comanda);

-- EXISTS: subinterogare corelată, care întoarce rânduri sau nu
SELECT * FROM produse p
WHERE EXISTS (SELECT 1 FROM linii_comanda l WHERE l.produs_id = p.id);

Diferențe practice:

  • EXISTS întoarce doar TRUE sau FALSE, niciodată UNKNOWN. Poate opri căutarea la primul rând găsit. Coloanele din SELECT-ul lui sunt ignorate; SELECT 1, SELECT * și SELECT NULL se comportă identic.
  • IN compară o expresie cu valorile listei. Merge natural și cu liste fixe (IN (1, 2, 3)) și cu potriviri pe mai multe coloane: (a, b) IN (SELECT x, y FROM ...).
  • EXISTS permite condiții mai complexe decât egalitatea în corelare: WHERE l.produs_id = p.id AND l.cantitate > 10 AND l.data > p.lansat_la.

În privința performanței, PostgreSQL și MySQL 8 transformă de obicei ambele forme într-un semi-join și aleg același plan, așa că diferența de viteză, despre care circulă multe mituri, a dispărut în mare parte. Alegerea ține mai mult de claritate.

Unde diferă semnificativ este negația: NOT IN cu o subinterogare care conține NULL nu întoarce niciun rând, în timp ce NOT EXISTS se comportă cum te aștepți. De aceea, pentru „nu există”, regula sigură este NOT EXISTS.

Ce urmărește intervievatorul: Se verifică înțelegerea semanticii celor două forme și a miturilor de performanță. Răspunsul slab afirmă fără nuanțe că „EXISTS e mereu mai rapid”.

37 Junior

Vrei doar primul produs adăugat în fiecare categorie. De ce nu poți scrie condiția de mai jos și cum o rescrii?

SQL
SELECT categorie_id, nume, adaugat_la
FROM produse
WHERE ROW_NUMBER() OVER (PARTITION BY categorie_id ORDER BY adaugat_la) = 1;

Răspuns scurt: Funcțiile fereastră se calculează după WHERE (și după GROUP BY și HAVING), deci nu pot fi folosite în WHERE. Calculezi numărul de ordine într-o subinterogare din FROM (tabel derivat) sau într-un CTE și filtrezi în interogarea exterioară.

Ordinea logică de evaluare este FROM, WHERE, GROUP BY, HAVING, apoi funcțiile fereastră și SELECT, apoi ORDER BY și LIMIT. În momentul în care WHERE filtrează rândurile, numerotarea nu există încă; de altfel, ea depinde chiar de rândurile care trec de WHERE. Rezultatul este o eroare: window functions are not allowed in WHERE.

Soluția este un tabel derivat, o subinterogare în FROM al cărei rezultat devine un tabel temporar pentru interogarea exterioară:

SQL
SELECT categorie_id, nume, adaugat_la
FROM (
  SELECT categorie_id, nume, adaugat_la,
         ROW_NUMBER() OVER (PARTITION BY categorie_id
                            ORDER BY adaugat_la, id) AS rn
  FROM produse
) AS t
WHERE rn = 1;

Sau, echivalent, cu un CTE, mai ușor de citit când pașii se înmulțesc:

SQL
WITH numerotate AS (
  SELECT categorie_id, nume, adaugat_la,
         ROW_NUMBER() OVER (PARTITION BY categorie_id ORDER BY adaugat_la, id) AS rn
  FROM produse
)
SELECT categorie_id, nume, adaugat_la FROM numerotate WHERE rn = 1;

Detalii:

  • MySQL și PostgreSQL până la versiunea 15 cer un alias pentru tabelul derivat (AS t); PostgreSQL 16 l-a făcut opțional.
  • id în ORDER BY departajează produsele adăugate în aceeași secundă, ca rezultatul să fie determinist.
  • unele sisteme (Snowflake, BigQuery, DuckDB) au clauza QUALIFY, care filtrează direct după funcții fereastră; nu există în PostgreSQL sau MySQL.

Ce urmărește intervievatorul: Se verifică dacă știi ordinea de evaluare a clauzelor și tehnica tabelului derivat. Candidații încearcă uneori să mute condiția în HAVING, care nici el nu vede funcțiile fereastră.

Eroarea, în practică:misuse of aggregate: COUNT()misuse of window function ROW_NUMBER()

38 Mid

Raportul de vânzări zilnice din octombrie nu afișează zilele fără vânzări. Cum generezi lista completă de zile cu un CTE recursiv, ca să apară și zilele cu 0?

Răspuns scurt: Generezi zilele cu WITH RECURSIVE: un membru de pornire cu prima zi și un membru recursiv care adaugă o zi până la ultima. Apoi faci LEFT JOIN cu vânzările și COALESCE pe sumă.

Un CTE recursiv are două părți legate prin UNION ALL: un membru ancoră, care produce rândurile de start, și un membru recursiv, care se referă la CTE-ul însuși și produce rânduri noi pornind de la cele anterioare. Iterația se oprește când membrul recursiv nu mai produce nimic.

PostgreSQL:

SQL
WITH RECURSIVE zile(zi) AS (
  SELECT DATE '2026-10-01'
  UNION ALL
  SELECT zi + 1 FROM zile WHERE zi < DATE '2026-10-31'
)
SELECT z.zi, COALESCE(SUM(v.valoare), 0) AS vanzari
FROM zile z
LEFT JOIN vanzari v
       ON v.data_vanzare >= z.zi
      AND v.data_vanzare <  z.zi + 1
GROUP BY z.zi
ORDER BY z.zi;

În PostgreSQL, date + integer dă tot o dată. Condiția de JOIN pe interval funcționează și dacă data_vanzare este timestamp, și poate folosi un index pe coloană.

MySQL 8:

SQL
WITH RECURSIVE zile(zi) AS (
  SELECT DATE('2026-10-01')
  UNION ALL
  SELECT zi + INTERVAL 1 DAY FROM zile WHERE zi < '2026-10-31'
)
SELECT ...

MySQL limitează adâncimea recursiei prin cte_max_recursion_depth (implicit 1000), ceea ce ajunge pentru aproape 3 ani de zile.

În PostgreSQL există și varianta mai scurtă generate_series(DATE '2026-10-01', DATE '2026-10-31', INTERVAL '1 day'), care întoarce timestamp-uri. În proiectele mari se folosește adesea un tabel calendar permanent, cu coloane pentru zi lucrătoare, săptămână sau trimestru fiscal, generat o singură dată.

Ce urmărește intervievatorul: Se verifică dacă știi CTE-urile recursive și problema „golurilor” din rapoarte. Greșeala tipică este condiția de oprire scrisă greșit, care produce o zi în plus sau o buclă infinită.

39 Mid

Tabelul categorii(id, nume, parinte_id) descrie un arbore de categorii. Scrie interogarea care întoarce toate subcategoriile categoriei 1, la orice adâncime, cu nivelul și calea completă. Cum te protejezi de cicluri?

Răspuns scurt: Folosești un CTE recursiv care pornește de la categoria 1 și adaugă la fiecare pas copiii rândurilor găsite, incrementând nivelul și concatenând calea. Te protejezi de cicluri păstrând lista ID-urilor vizitate și oprind recursia când un ID apare din nou.

Structura „fiecare rând are un părinte” (listă de adiacență) este cea mai simplă reprezentare a unui arbore, iar CTE-ul recursiv este modul standard de a o parcurge.

PostgreSQL:

SQL
WITH RECURSIVE arbore AS (
  SELECT id, nume, parinte_id,
         0 AS nivel,
         nume::text AS cale,
         ARRAY[id] AS vizitate
  FROM categorii
  WHERE id = 1
  UNION ALL
  SELECT c.id, c.nume, c.parinte_id,
         a.nivel + 1,
         a.cale || ' > ' || c.nume,
         a.vizitate || c.id
  FROM categorii c
  JOIN arbore a ON c.parinte_id = a.id
  WHERE NOT c.id = ANY(a.vizitate)
)
SELECT id, nume, nivel, cale
FROM arbore
ORDER BY cale;

Ciclurile apar când datele sunt greșite (A are părinte pe B și B pe A). Fără protecție, recursia nu se oprește. Coloana vizitate reține drumul parcurs, iar condiția NOT c.id = ANY(...) refuză să revină într-un nod deja vizitat. PostgreSQL 14+ are și clauza standard CYCLE id SET are_ciclu USING drum, care face asta automat.

În MySQL 8 nu ai array-uri, așa că păstrezi drumul ca text, de exemplu CONCAT(',', id, ','), și verifici cu LOCATE(CONCAT(',', c.id, ','), a.drum) = 0. Ai grijă ca expresia de text din membrul ancoră să fie destul de lată (CAST(... AS CHAR(1000))), pentru că MySQL deduce tipul coloanei din ancoră și altfel trunchiază sau dă eroare.

Pentru citiri foarte frecvente pe arbori mari există alternative de modelare: closure table, materialized path sau tipul ltree din PostgreSQL.

Ce urmărește intervievatorul: Se verifică parcurgerea ierarhiilor și gândirea defensivă față de date corupte. Candidații scriu des recursia corect, dar uită complet de cicluri.

40 Mid

Ce întoarce fiecare interogare, dacă a(x) conține 1, 1, 2, NULL, NULL, iar b(x) conține 1, NULL? De ce se comportă EXCEPT diferit de NOT EXISTS față de NULL?

SQL
SELECT x FROM a INTERSECT SELECT x FROM b;
SELECT x FROM a EXCEPT    SELECT x FROM b;
SELECT DISTINCT x FROM a WHERE NOT EXISTS (SELECT 1 FROM b WHERE b.x = a.x);

Răspuns scurt: INTERSECT întoarce 1 și NULL; EXCEPT întoarce doar 2; NOT EXISTS întoarce 2 și NULL. Operatorii pe mulțimi consideră două NULL-uri egale (ca DISTINCT), în timp ce condiția b.x = a.x din NOT EXISTS nu le potrivește.

INTERSECT și EXCEPT lucrează pe mulțimi de rânduri: elimină duplicatele și compară rânduri întregi. La această comparație, SQL tratează NULL-urile ca „nedistincte”, exact cum face DISTINCT sau GROUP BY. Deci NULL din a îl „întâlnește” pe NULL din b.

  • INTERSECT: valorile distincte prezente în ambele: 1 și NULL.
  • EXCEPT: valorile distincte din a care nu sunt în b: doar 2 (NULL este considerat prezent în b).
  • NOT EXISTS ... b.x = a.x: pentru a.x = NULL, condiția e UNKNOWN pentru orice rând din b, deci subinterogarea nu găsește nimic, iar NOT EXISTS e TRUE. Rezultat: 2 și NULL.

De reținut:

  • există și variantele INTERSECT ALL și EXCEPT ALL, care păstrează multiplicitatea: a EXCEPT ALL b ar întoarce 1, 2 și un NULL (fiecare rând din b „consumă” un rând din a). PostgreSQL le are; MySQL le are din 8.0.31, versiunea în care a introdus INTERSECT și EXCEPT.
  • coloanele se potrivesc după poziție, nu după nume, și trebuie să aibă tipuri compatibile.
  • EXCEPT este o metodă excelentă de a compara rezultatul a două variante ale unei interogări în timpul unei refactorizări: rulezi (v1 EXCEPT v2) și (v2 EXCEPT v1); dacă ambele sunt goale, rezultatele sunt identice ca mulțimi (pentru duplicate folosești varianta ALL).

Ce urmărește intervievatorul: Se verifică înțelegerea fină a lui NULL în operatorii pe mulțimi. Majoritatea candidaților presupun că EXCEPT și NOT EXISTS sunt mereu echivalente.

41 Senior

Un coleg a rescris o interogare lungă cu CTE-uri, iar în PostgreSQL 11 a devenit mult mai lentă, deși logica e identică. De ce? S-ar întâmpla la fel în PostgreSQL 16 sau în MySQL 8?

Răspuns scurt: Până la PostgreSQL 12, CTE-urile erau mereu materializate, deci funcționau ca o barieră de optimizare: filtrele exterioare nu erau împinse înăuntru. Din versiunea 12, un CTE simplu folosit o singură dată este integrat în interogare, iar comportamentul se poate controla cu MATERIALIZED și NOT MATERIALIZED.

Un CTE poate fi executat în două moduri:

  • materializat: rezultatul se calculează o dată, complet, și se stochează temporar; interogarea exterioară citește din acest rezultat;
  • integrat (inlined): textul CTE-ului este pus în interogarea exterioară ca o subinterogare, iar optimizatorul poate împinge filtre și JOIN-uri în interiorul lui și poate folosi indexuri.
SQL
WITH comenzi_extinse AS (
  SELECT o.*, c.segment
  FROM comenzi o JOIN clienti c ON c.id = o.client_id
)
SELECT * FROM comenzi_extinse WHERE id = 12345;

În PostgreSQL 11 și mai vechi, CTE-ul se calculează pentru toate comenzile, apoi se caută comanda 12345: un JOIN pe milioane de rânduri pentru un singur rezultat. În PostgreSQL 12+, CTE-ul nerecursiv, fără efecte secundare și referit o singură dată este integrat automat, iar filtrul pe id ajunge direct la indexul cheii primare.

Controlul explicit în PostgreSQL 12+:

SQL
WITH x AS MATERIALIZED (...)      -- forțează calculul o singură dată
WITH x AS NOT MATERIALIZED (...)  -- forțează integrarea

Materializarea este utilă când CTE-ul este scump și referit de mai multe ori sau când vrei intenționat să fixezi ordinea de execuție pentru un plan instabil.

MySQL 8 tratează CTE-urile ca tabelele derivate: le poate integra (derived_merge) sau materializa, în funcție de conținut (agregările, DISTINCT sau LIMIT împiedică integrarea) și de numărul de referințe.

Concluzia practică: CTE-urile sunt în primul rând un instrument de lizibilitate. Când schimbi structura unei interogări critice, compari planurile cu EXPLAIN înainte și după.

Ce urmărește intervievatorul: Se verifică experiența cu optimizatorul și cu diferențele de versiune. Un răspuns de nivel senior știe că „echivalent logic” nu înseamnă „același plan”.

42 Senior

Tabelul componente(parinte_id, copil_id, cantitate) descrie din ce piese este făcut un produs (o piesă poate fi la rândul ei compusă), iar piese(id, cost) are costul pieselor de bază. Scrie interogarea care calculează costul total al produsului 1.

Răspuns scurt: Folosești un CTE recursiv care „explodează” structura produsului, înmulțind cantitățile pe drum, apoi aduni cantitate x cost doar pentru piesele de bază, adică cele care nu au la rândul lor componente.

Este problema clasică de bill of materials: structura e un graf orientat, iar cantitatea necesară dintr-o piesă de bază este produsul cantităților de pe drumul de la produs până la ea. Dacă o piesă se ajunge pe mai multe drumuri (același șurub în două subansamble), fiecare drum contribuie separat, ceea ce aici este corect.

SQL
WITH RECURSIVE explozie AS (
  SELECT copil_id, cantitate::numeric AS cant, 1 AS nivel
  FROM componente
  WHERE parinte_id = 1
  UNION ALL
  SELECT c.copil_id, e.cant * c.cantitate, e.nivel + 1
  FROM explozie e
  JOIN componente c ON c.parinte_id = e.copil_id
  WHERE e.nivel < 20
)
SELECT SUM(e.cant * p.cost) AS cost_total
FROM explozie e
JOIN piese p ON p.id = e.copil_id
WHERE NOT EXISTS (
  SELECT 1 FROM componente c WHERE c.parinte_id = e.copil_id
);

Puncte de discutat cu intervievatorul:

  • UNION ALL, nu UNION: două drumuri diferite pot produce rânduri identice (aceeași piesă, aceeași cantitate), iar UNION le-ar comasa și ar pierde cost.
  • condiția nivel < 20 este o plasă de siguranță contra ciclurilor; în date corecte de BOM nu există cicluri, dar o eroare de introducere ar bloca altfel interogarea.
  • filtrul NOT EXISTS păstrează doar piesele de bază, ca un subansamblu să nu fie numărat și ca piesă, și prin componentele lui. Alternativ, dacă subansamblele au propriul cost de manoperă, îl incluzi explicit.
  • tipul numeric evită erorile de rotunjire ale lui float la înmulțiri repetate.

Pentru produse cu mii de componente, un index pe componente (parinte_id) este obligatoriu: fiecare pas recursiv caută copiii unui set de părinți.

Ce urmărește intervievatorul: Întrebarea verifică stăpânirea recursiei dincolo de ierarhii simple: acumulare pe drum, tipuri numerice, cicluri. Greșeala tipică este UNION în loc de UNION ALL sau numărarea dublă a subansamblelor.

Eroarea, în practică:recursive aggregate queries not supported

Funcții fereastră

43 Junior

Scrie interogarea care afișează fiecare angajat cu salariul lui, salariul mediu din departamentul lui și diferența față de această medie, din tabelul angajati(id, nume, departament, salariu).

Răspuns scurt: Folosești AVG(salariu) OVER (PARTITION BY departament), care calculează media pe departament, dar păstrează fiecare rând în rezultat, spre deosebire de GROUP BY.

Cu GROUP BY ai obține un singur rând pe departament și ai pierde angajații. O funcție de agregare urmată de OVER (...) devine funcție fereastră: calculează valoarea pe un grup de rânduri înrudite (fereastra), dar o atașează fiecărui rând, fără să le comaseze.

SQL
SELECT id,
       nume,
       departament,
       salariu,
       ROUND(AVG(salariu) OVER (PARTITION BY departament), 2) AS medie_departament,
       ROUND(salariu - AVG(salariu) OVER (PARTITION BY departament), 2) AS diferenta
FROM angajati
ORDER BY departament, diferenta DESC;

PARTITION BY departament împarte rândurile în ferestre, câte una pe departament. Fără PARTITION BY, adică OVER (), fereastra este întregul rezultat, deci obții media pe toată firma.

Observă că aliasul diferenta poate fi folosit în ORDER BY, pentru că ORDER BY se evaluează după SELECT; nu l-ai putea folosi însă în WHERE.

Aceeași tehnică funcționează cu alte agregate: COUNT(*) OVER (PARTITION BY departament) (câți colegi are fiecare în departament), MAX(salariu) OVER (PARTITION BY departament) (cât de departe e de maximul departamentului) sau SUM(salariu) OVER (PARTITION BY departament) pentru ponderea fiecărui salariu în costul departamentului.

Înainte de funcțiile fereastră (MySQL le are din 8.0, PostgreSQL de mult timp), rezultatul se obținea cu un JOIN la o subinterogare grupată pe departament. Varianta cu fereastră e mai scurtă și citește tabelul o singură dată.

Ce urmărește intervievatorul: Se verifică dacă înțelegi diferența practică dintre agregarea care comasează rânduri și cea care le păstrează. Mulți candidați încearcă întâi un GROUP BY și se blochează.

44 Junior

Din vanzari(produs_id, categorie, cantitate), scrie interogarea care afișează primele 3 produse din fiecare categorie după cantitatea totală vândută. Produsele la egalitate pe locul 3 trebuie incluse toate.

Răspuns scurt: Grupezi pe produs și categorie, aplici RANK() OVER (PARTITION BY categorie ORDER BY SUM(cantitate) DESC) peste rezultatul agregat, apoi filtrezi rang <= 3 într-o interogare exterioară. RANK păstrează egalitățile.

Cerința are doi pași: întâi totalul pe produs (o agregare), apoi clasamentul în cadrul categoriei (o funcție fereastră). Le poți face la același nivel, pentru că funcțiile fereastră se evaluează după GROUP BY și pot folosi agregate.

SQL
WITH clasament AS (
  SELECT categorie,
         produs_id,
         SUM(cantitate) AS total,
         RANK() OVER (PARTITION BY categorie
                      ORDER BY SUM(cantitate) DESC) AS rang
  FROM vanzari
  GROUP BY categorie, produs_id
)
SELECT categorie, produs_id, total, rang
FROM clasament
WHERE rang <= 3
ORDER BY categorie, rang, produs_id;

Alegerea funcției depinde de cerință, iar aici cerința spune explicit că egalitățile pe locul 3 intră toate:

  • RANK: dacă două produse sunt la egalitate pe locul 2, ambele primesc 2, iar următorul primește 4. Cu rang <= 3 pot ieși mai mult de 3 produse.
  • ROW_NUMBER ar tăia arbitrar egalitățile, exact cât să rămână 3 rânduri.
  • DENSE_RANK ar include „primele 3 valori distincte”, deci, cu multe egalități, mult mai multe produse.

Filtrarea se face în exterior, deoarece WHERE nu vede funcțiile fereastră. Dacă vrei și numele produsului, faci JOIN cu produse în interogarea finală, nu în CTE, ca să nu agregi coloane în plus.

Un detaliu de calitate: dacă cantitate poate fi negativă (retururi înregistrate ca rânduri negative), totalul reflectă vânzările nete, ceea ce merită confirmat cu cine a cerut raportul.

Ce urmărește intervievatorul: Se verifică combinarea agregării cu funcțiile fereastră și alegerea conștientă între RANK și ROW_NUMBER. Greșeala tipică este să faci clasamentul pe rânduri individuale de vânzare, nu pe totaluri.

Eroarea, în practică:misuse of window function ROW_NUMBER()near "QUALIFY": syntax error

45 Junior

Tabelul istoric_preturi(produs_id, pret, valid_de_la) are câte un rând la fiecare schimbare de preț. Scrie interogarea care adaugă fiecărui rând data până la care a fost valabil prețul (data următoarei schimbări pentru același produs).

Răspuns scurt: Folosești LEAD(valid_de_la) OVER (PARTITION BY produs_id ORDER BY valid_de_la), care întoarce valoarea din rândul următor al aceluiași produs. Pentru prețul curent, LEAD întoarce NULL, adică „valabil în continuare”.

LEAD(expresie, n, implicit) întoarce valoarea expresiei din al n-lea rând de după cel curent, în ordinea ferestrei; LAG face același lucru înapoi. Implicit n este 1, iar dacă nu există un astfel de rând, rezultatul este NULL sau valoarea implicită dată.

SQL
SELECT produs_id,
       pret,
       valid_de_la,
       LEAD(valid_de_la) OVER (PARTITION BY produs_id
                               ORDER BY valid_de_la) AS valid_pana_la
FROM istoric_preturi
ORDER BY produs_id, valid_de_la;

Rezultatul transformă o listă de evenimente într-o listă de intervale [valid_de_la, valid_pana_la), deschise la dreapta: prețul vechi e valabil până înainte de momentul în care începe cel nou. Așa nu există nicio zi cu două prețuri.

Variante utile:

  • dacă vrei intervale închise, cu ultima zi inclusă, scrii LEAD(valid_de_la) OVER (...) - 1 în PostgreSQL pentru coloane date (MySQL: - INTERVAL 1 DAY);
  • dacă preferi o dată fixă în loc de NULL pentru prețul curent: LEAD(valid_de_la, 1, DATE '9999-12-31') OVER (...);
  • LAG(pret) OVER (PARTITION BY produs_id ORDER BY valid_de_la) îți dă prețul anterior, deci poți calcula direct variația la fiecare schimbare.

PARTITION BY produs_id este esențial: fără el, ultimul preț al unui produs ar primi ca dată de sfârșit primul preț al produsului următor. Dacă pot exista două rânduri cu aceeași dată pentru același produs, ordinea e ambiguă și trebuie mai întâi curățate datele sau adăugată o coloană de departajare.

Ce urmărește intervievatorul: Se verifică folosirea LEAD/LAG și gândirea în intervale. Greșeala clasică este lipsa lui PARTITION BY, care amestecă istoricul produselor.

46 Mid

Vrei să afișezi lângă fiecare vânzare ultima valoare din luna respectivă. De ce interogarea de mai jos întoarce, de fapt, valoarea rândului curent?

SQL
SELECT luna, zi, valoare,
       LAST_VALUE(valoare) OVER (PARTITION BY luna ORDER BY zi) AS ultima_din_luna
FROM vanzari_zilnice;

Răspuns scurt: Când fereastra are ORDER BY, cadrul implicit este de la începutul partiției până la rândul curent (inclusiv rândurile egale cu el). Ultimul rând din acest cadru este rândul curent. Repari extinzând cadrul până la finalul partiției sau folosind FIRST_VALUE cu ordinea inversă.

Pe lângă partiție și ordine, o fereastră are un cadru (frame): submulțimea de rânduri din partiție pe care se aplică funcția pentru rândul curent. Dacă scrii ORDER BY și nu specifici cadrul, standardul îl definește ca RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Pentru SUM asta produce un total cumulat, ceea ce e adesea util. Pentru LAST_VALUE înseamnă însă „ultimul rând văzut până acum”, adică rândul curent (sau ultimul dintre rândurile cu aceeași valoare a lui zi).

Variante corecte:

SQL
-- cadrul extins la toată partiția
SELECT luna, zi, valoare,
       LAST_VALUE(valoare) OVER (
         PARTITION BY luna ORDER BY zi
         ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
       ) AS ultima_din_luna
FROM vanzari_zilnice;

-- echivalent, mai ușor de citit
SELECT luna, zi, valoare,
       FIRST_VALUE(valoare) OVER (PARTITION BY luna ORDER BY zi DESC) AS ultima_din_luna
FROM vanzari_zilnice;

FIRST_VALUE nu are problema, pentru că primul rând se află mereu în cadrul implicit.

Aceeași capcană apare la NTH_VALUE(valoare, 3): pentru primele două rânduri ale partiției întoarce NULL, pentru că al treilea rând nu a intrat încă în cadru. Și la MAX(...) OVER (ORDER BY ...), care devine un „maxim de până acum”.

Regula practică: când folosești o funcție fereastră cu ORDER BY, întreabă-te dacă vrei un calcul „cumulat până aici” sau unul „pe toată partiția”, și scrie cadrul explicit ori de câte ori răspunsul nu este evident.

Ce urmărește intervievatorul: Se verifică înțelegerea cadrului implicit, o sursă clasică de bug-uri subtile. Candidații care au folosit doar ROW_NUMBER nu știu de existența cadrului.

Eroarea, în practică:RANGE with offset requires one ORDER BY expressionunsupported frame specification

47 Mid

Vrei să împarți clienții în 4 segmente egale după valoarea totală cheltuită. Ce face NTILE(4) și ce problemă apare la clienții cu aceeași valoare? Prin ce diferă PERCENT_RANK și CUME_DIST?

Răspuns scurt: NTILE(4) împarte rândurile ordonate în 4 grupuri cu număr aproape egal de rânduri, deci doi clienți cu aceeași valoare pot ajunge în segmente diferite. PERCENT_RANK și CUME_DIST dau poziția relativă (între 0 și 1) și tratează egalitățile la fel.

NTILE(n) numerotează grupurile de la 1 la n după ordinea din fereastră. Dacă rândurile nu se împart exact, primele grupuri primesc câte un rând în plus: 10 clienți în 4 grupuri dau 3, 3, 2, 2.

SQL
WITH totaluri AS (
  SELECT client_id, SUM(total) AS valoare
  FROM comenzi
  GROUP BY client_id
)
SELECT client_id,
       valoare,
       NTILE(4)       OVER (ORDER BY valoare DESC) AS quartila,
       PERCENT_RANK() OVER (ORDER BY valoare)      AS pr,
       CUME_DIST()    OVER (ORDER BY valoare)      AS cd
FROM totaluri;

Problema lui NTILE: grupurile sunt definite de numărul de rânduri, nu de valori. Dacă 50 de clienți au exact 100 de lei, granița dintre segmentul 2 și 3 poate trece prin mijlocul lor. Doi clienți identici ar primi tratament diferit într-o campanie, ceea ce e greu de explicat.

Funcțiile de distribuție tratează egalitățile consecvent:

  • PERCENT_RANK = (rang - 1) / (numărul de rânduri - 1), deci între 0 și 1; primul rând are 0.
  • CUME_DIST = numărul de rânduri cu valoare mai mică sau egală / numărul total; este mereu peste 0 și ultimul rând are 1.

Segmentare robustă la egalități:

SQL
CASE WHEN CUME_DIST() OVER (ORDER BY valoare DESC) <= 0.25 THEN 'top 25%' ... END

Alternativ, calculezi pragurile valorice cu PERCENTILE_CONT (PostgreSQL) și compari valoarea cu ele. Segmentele nu vor avea exact același număr de clienți, dar granițele vor fi valori clare, ușor de comunicat.

Ce urmărește intervievatorul: Se verifică dacă știi cum se comportă funcțiile de distribuție și dacă te gândești la consecințele de business. Greșeala tipică este folosirea lui NTILE fără să observi că rupe grupurile de valori egale.

Eroarea, în practică:argument of ntile must be a positive integer

48 Mid

Din comenzi(id, client_id, data_comanda), scrie interogarea care găsește clienții a căror a doua comandă a venit la cel mult 30 de zile după prima.

Răspuns scurt: Numerotezi comenzile fiecărui client cu ROW_NUMBER în ordinea datei și calculezi data primei comenzi cu MIN peste aceeași partiție; apoi păstrezi rândurile cu numărul 2 a căror dată este în 30 de zile de la prima.

Indicatorul „a revenit repede” este folosit des în analiza retenției. Funcțiile fereastră îți dau, pe fiecare rând, atât poziția comenzii în istoricul clientului, cât și informații despre prima comandă.

SQL
WITH numerotate AS (
  SELECT client_id,
         data_comanda,
         ROW_NUMBER() OVER (PARTITION BY client_id
                            ORDER BY data_comanda, id) AS nr_comanda,
         MIN(data_comanda) OVER (PARTITION BY client_id) AS prima_comanda
  FROM comenzi
  WHERE status <> 'anulata'
)
SELECT client_id,
       prima_comanda,
       data_comanda AS a_doua_comanda
FROM numerotate
WHERE nr_comanda = 2
  AND data_comanda <= prima_comanda + INTERVAL '30 days';

(În MySQL scrii prima_comanda + INTERVAL 30 DAY.)

O alternativă este LAG(data_comanda) OVER (PARTITION BY client_id ORDER BY data_comanda, id): pe rândul numărul 2, valoarea anterioară este chiar prima comandă.

Puncte care merită clarificate cu cel care a cerut raportul:

  • comenzile anulate sau returnate contează? Filtrul din CTE le exclude înainte de numerotare, ceea ce schimbă cine este „a doua comandă”. Dacă filtrezi după numerotare, rezultatul e diferit.
  • două comenzi în aceeași zi: sunt „a doua comandă” sau o comandă împărțită? Departajarea după id face rezultatul determinist, dar decizia de business rămâne.
  • „30 de zile” înseamnă 30 de zile calendaristice de la momentul exact sau de la data calendaristică? Pentru coloane timestamp, cele două interpretări diferă la margine.

Ce urmărește intervievatorul: Se verifică dacă poți combina mai multe funcții fereastră pentru o metrică de business și dacă observi ambiguitățile. Mulți candidați filtrează comenzile anulate după numerotare, fără să-și dea seama că asta schimbă rezultatul.

49 Mid

Tabelul abonati(id, email, creat_la) are duplicate: același email, scris uneori cu majuscule, apare de mai multe ori. Scrie comanda care șterge duplicatele și păstrează, pentru fiecare email, cea mai recentă înregistrare. Cum previi reapariția lor?

Răspuns scurt: Numerotezi rândurile cu ROW_NUMBER() OVER (PARTITION BY LOWER(email) ORDER BY creat_la DESC, id DESC) și ștergi rândurile cu numărul mai mare decât 1. Apoi adaugi un index unic pe LOWER(email).

Pașii sunt: identifici grupurile de duplicate, alegi un „câștigător” per grup după o regulă deterministă și ștergi restul. ROW_NUMBER face ambele lucruri.

PostgreSQL:

SQL
BEGIN;

DELETE FROM abonati a
USING (
  SELECT id,
         ROW_NUMBER() OVER (PARTITION BY LOWER(email)
                            ORDER BY creat_la DESC, id DESC) AS rn
  FROM abonati
) d
WHERE a.id = d.id
  AND d.rn > 1;

CREATE UNIQUE INDEX ux_abonati_email ON abonati (LOWER(email));

COMMIT;

MySQL 8:

SQL
DELETE a
FROM abonati a
JOIN (
  SELECT id,
         ROW_NUMBER() OVER (PARTITION BY LOWER(email)
                            ORDER BY creat_la DESC, id DESC) AS rn
  FROM abonati
) d ON d.id = a.id
WHERE d.rn > 1;

În MySQL, tabelul derivat cu funcție fereastră este materializat, deci nu apare eroarea care interzice citirea din tabelul pe care îl modifici. Pentru unicitate, MySQL 8.0.13+ acceptă indexuri funcționale: CREATE UNIQUE INDEX ux_email ON abonati ((LOWER(email))); cu colația implicită _ci, un index unic simplu pe email ar fi oricum insensibil la majuscule.

Înainte de ștergere, în producție:

  • rulezi întâi partea de SELECT și verifici câte rânduri vor dispărea;
  • verifici dacă alte tabele au chei străine către abonati; rândurile de șters pot avea dependențe care trebuie mutate pe rândul păstrat;
  • faci totul într-o tranzacție și, la volume mari, în loturi.

id DESC în ORDER BY departajează înregistrările create în același moment, ca rezultatul să fie reproductibil.

Ce urmărește intervievatorul: Este o sarcină reală, frecventă la curățarea datelor. Se verifică dacă știi să ștergi sigur și dacă te gândești la prevenire și la dependențe, nu doar la interogare.

50 Mid

Din vanzari(produs_id, valoare), scrie interogarea care întoarce produsele care, împreună, aduc primele 80% din venituri (analiza Pareto), inclusiv produsul care trece pragul.

Răspuns scurt: Calculezi venitul pe produs, apoi totalul cumulat în ordine descrescătoare și totalul general cu funcții fereastră. Păstrezi produsele la care totalul cumulat dinaintea lor era încă sub 80% din total.

Analiza Pareto (sau ABC) identifică puținele produse care aduc cea mai mare parte din venit. Pașii sunt: venit pe produs, sortare descrescătoare, total cumulat, comparare cu pragul.

SQL
WITH pe_produs AS (
  SELECT produs_id, SUM(valoare) AS venit
  FROM vanzari
  GROUP BY produs_id
),
cumulat AS (
  SELECT produs_id,
         venit,
         SUM(venit) OVER (ORDER BY venit DESC, produs_id
                          ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumulat,
         SUM(venit) OVER () AS total
  FROM pe_produs
)
SELECT produs_id,
       venit,
       ROUND(100.0 * cumulat / total, 2) AS pct_cumulat
FROM cumulat
WHERE cumulat - venit < 0.8 * total
ORDER BY venit DESC, produs_id;

De ce condiția cumulat - venit < 0.8 * total: cumulat - venit este totalul cumulat înainte de produsul curent. Produsul intră în listă dacă, până la el, încă nu se atinsese pragul, deci și produsul care trece de 80% este inclus. Cu condiția simplă cumulat <= 0.8 * total l-ai pierde pe acesta, iar suma produselor selectate ar fi sub 80%.

ROWS și departajarea după produs_id sunt necesare: cu cadrul implicit RANGE, produsele cu venit egal ar primi același total cumulat, iar rezultatul ar depinde de egalități.

Pentru o clasificare ABC completă, transformi pragurile într-un CASE: A până la 80%, B până la 95%, C restul, folosind aceeași valoare „cumulat înainte de produs”.

Ce urmărește intervievatorul: Se verifică combinarea agregării cu totalurile cumulate și atenția la condiția de prag. Greșeala tipică este pierderea produsului care trece pragul.

51 Senior

Tabelul evenimente(user_id, ts) conține acțiunile utilizatorilor pe site. O sesiune se încheie după 30 de minute de inactivitate. Scrie interogarea care întoarce, pentru fiecare sesiune, începutul, sfârșitul și numărul de evenimente.

Răspuns scurt: Cu LAG compari fiecare eveniment cu precedentul aceluiași utilizator și marchezi cu 1 începutul unei sesiuni noi (primul eveniment sau o pauză de peste 30 de minute). Suma cumulată a marcajelor dă un număr de sesiune, după care grupezi.

Problema se numește sessionization și se rezolvă în trei pași, pentru că funcțiile fereastră nu se pot imbrica direct una în alta.

SQL
WITH marcate AS (
  SELECT user_id, ts,
         CASE
           WHEN LAG(ts) OVER w IS NULL
             OR ts - LAG(ts) OVER w > INTERVAL '30 minutes'
           THEN 1 ELSE 0
         END AS sesiune_noua
  FROM evenimente
  WINDOW w AS (PARTITION BY user_id ORDER BY ts)
),
numerotate AS (
  SELECT user_id, ts,
         SUM(sesiune_noua) OVER (PARTITION BY user_id ORDER BY ts
                                 ROWS UNBOUNDED PRECEDING) AS nr_sesiune
  FROM marcate
)
SELECT user_id,
       nr_sesiune,
       MIN(ts)  AS inceput,
       MAX(ts)  AS sfarsit,
       COUNT(*) AS evenimente
FROM numerotate
GROUP BY user_id, nr_sesiune
ORDER BY user_id, nr_sesiune;
  • marcate: un eveniment începe o sesiune dacă nu are predecesor sau dacă pauza de la predecesor depășește pragul. Clauza WINDOW w evită repetarea definiției ferestrei.
  • numerotate: suma cumulată a marcajelor crește cu 1 la fiecare început de sesiune, deci toate evenimentele aceleiași sesiuni primesc același număr. ROWS evită problemele cu evenimente care au exact același ts.
  • agregarea finală pe (user_id, nr_sesiune).

Pentru MySQL, condiția devine TIMESTAMPDIFF(MINUTE, LAG(ts) OVER w, ts) > 30 (atenție: TIMESTAMPDIFF trunchiază la minute întregi).

La volume mari, interogarea sortează toate evenimentele după (user_id, ts); un index pe aceste coloane ajută, iar într-un sistem real calculul se face incremental, doar pe evenimentele noi, eventual cu o marjă de 30 de minute înapoi pentru sesiunile care continuă.

Ce urmărește intervievatorul: Întrebarea verifică stăpânirea tiparului „marchează începutul, apoi sumă cumulată”, folosit la multe probleme de tip gaps and islands. Candidații de nivel mid se blochează de obicei la ideea de a imbrica funcțiile fereastră.

52 Senior

O interogare de raportare cu cinci funcții fereastră diferite durează minute pe un tabel de zeci de milioane de rânduri. Ce costă, de fapt, o funcție fereastră și cum ai optimiza interogarea în PostgreSQL?

Răspuns scurt: Costul principal este sortarea: fiecare combinație distinctă de PARTITION BY și ORDER BY cere o sortare, care la volume mari se face pe disc. Optimizezi unificând ferestrele, filtrând rândurile înainte, folosind indexuri în ordinea ferestrei și, la nevoie, mai multă memorie de sortare.

Pentru a calcula o funcție fereastră, motorul trebuie să aibă rândurile grupate pe partiții și ordonate în fiecare partiție. În planul de execuție apare un nod WindowAgg precedat de un Sort. Câteva consecințe:

  • Ferestrele cu aceeași specificație (aceleași PARTITION BY și ORDER BY) se calculează în aceeași trecere. Cinci specificații diferite pot însemna cinci sortări ale întregului set. Unifică-le unde se poate și folosește WINDOW w AS (...) ca să fie evident că sunt aceleași.
  • Dacă sortarea nu încape în work_mem, PostgreSQL scrie pe disc; în EXPLAIN (ANALYZE, BUFFERS) vezi Sort Method: external merge Disk: .... Creșterea lui work_mem doar pentru sesiunea raportului (SET LOCAL work_mem = '256MB') poate ajuta mult.
  • Un index pe coloanele (partiție, ordine) poate furniza rândurile deja sortate, iar sortarea dispare. PostgreSQL 13+ poate face și incremental sort când indexul acoperă doar primele coloane.
  • Filtrele din interogarea exterioară nu pot fi împinse sub funcția fereastră (ar schimba rezultatul), cu excepția celor pe coloanele din PARTITION BY. Pune filtrele cât mai devreme, în subinterogarea care alimentează fereastra.
  • Cadrele ROWS sunt de obicei mai ieftine decât RANGE pentru totaluri cumulate, iar cadrele cu mișcare (de exemplu ultimele 7 rânduri) costă mai puțin decât recalcularea manuală cu subinterogări corelate, care sunt O(n²).

Dacă raportul rulează des pe aceleași date istorice, alternativa cea mai eficientă este precalcularea într-un tabel de rezumat sau o vedere materializată, actualizată incremental, astfel încât interogarea zilnică să lucreze doar pe ultimele zile.

Ce urmărește intervievatorul: Se verifică dacă înțelegi execuția funcțiilor fereastră și dacă poți diagnostica dintr-un plan. Un răspuns de nivel senior pornește de la sortări și memorie, nu de la rescrieri la întâmplare.

DML, DDL și constrângeri

Exersează capitolul cu exerciții reale: Curs SQL online →
53 Junior

Ai de corectat prețul unui singur produs direct în baza de date de producție. Ce pași urmezi ca să eviți un UPDATE care modifică, din greșeală, toate rândurile?

Răspuns scurt: Scrii întâi un SELECT cu exact același WHERE și verifici rândurile, rulezi UPDATE-ul într-o tranzacție, verifici numărul de rânduri afectate și abia apoi dai COMMIT. În MySQL poți activa și sql_safe_updates.

Un UPDATE fără WHERE (sau cu un WHERE greșit) modifică toate rândurile și, după COMMIT, nu există „undo”. Rutina sigură:

SQL
-- 1. Verifici ținta cu exact aceeași condiție
SELECT id, nume, pret FROM produse WHERE id = 4182;

-- 2. Rulezi modificarea într-o tranzacție
BEGIN;
UPDATE produse SET pret = 249.90 WHERE id = 4182;
-- clientul raportează: UPDATE 1

-- 3. Verifici rezultatul
SELECT id, nume, pret FROM produse WHERE id = 4182;

-- 4. Confirmi sau anulezi
COMMIT;   -- sau ROLLBACK;

Dacă numărul de rânduri afectate nu este cel așteptat (de exemplu 4.182 în loc de 1), dai ROLLBACK și nimic nu s-a schimbat.

Alte plase de siguranță:

  • În MySQL, SET sql_safe_updates = 1; (sau clientul pornit cu --safe-updates) refuză UPDATE și DELETE fără un WHERE pe cheie sau fără LIMIT.
  • În PostgreSQL poți folosi RETURNING ca să vezi exact ce s-a modificat: UPDATE ... RETURNING id, pret;.
  • Condiția pe cheia primară este mai sigură decât una pe nume („Cafea boabe 1kg” poate exista de două ori).
  • Multe echipe nu permit modificări manuale în producție decât prin scripturi revizuite, iar utilizatorii de zi cu zi au doar drept de citire.

Atenție la tranzacțiile lăsate deschise: un BEGIN uitat ține blocate rândurile modificate și poate bloca aplicația. Termini mereu explicit cu COMMIT sau ROLLBACK.

Ce urmărește intervievatorul: Se verifică disciplina de lucru cu date reale. Un răspuns bun arată un proces, nu doar sintaxa; candidații fără experiență spun doar „am grijă să pun WHERE”.

54 Junior

Care este diferența dintre DELETE FROM comenzi, TRUNCATE TABLE comenzi și DROP TABLE comenzi? Când îl folosești pe fiecare?

Răspuns scurt: DELETE șterge rânduri, eventual filtrate, unul câte unul, cu triggere și jurnalizare pe rând. TRUNCATE golește tot tabelul rapid, fără WHERE. DROP elimină tabelul cu totul, inclusiv structura, indexurile și permisiunile.

DELETE este o comandă DML: poate avea WHERE, declanșează triggerele pe rând, respectă cheile străine (inclusiv ON DELETE CASCADE) și poate fi anulată cu ROLLBACK. Pe un tabel mare este lentă, pentru că fiecare rând este marcat și jurnalizat. În PostgreSQL, spațiul nu se eliberează imediat; rândurile șterse sunt curățate ulterior de VACUUM.

TRUNCATE golește tot tabelul dintr-o dată, eliberând fișierele de date, deci este foarte rapidă indiferent de mărime. Diferențe importante:

  • nu acceptă WHERE și nu declanșează triggerele pe rând (de tip FOR EACH ROW la DELETE);
  • în PostgreSQL este tranzacțională (o poți anula cu ROLLBACK) și cere CASCADE dacă alte tabele au chei străine către acest tabel; contorul de identitate se resetează doar cu RESTART IDENTITY;
  • în MySQL este tratată ca DDL: face commit implicit, nu poate fi anulată, eșuează dacă tabelul este referit de chei străine din alt tabel și resetează mereu AUTO_INCREMENT.
  • ia un lock exclusiv pe tabel, deci blochează și citirile cât durează.

DROP TABLE elimină tabelul: date, structură, indexuri, constrângeri, triggere și permisiuni. Vederile care depind de el blochează comanda (în PostgreSQL ai nevoie de CASCADE, care le șterge și pe ele).

Folosire tipică:

  • DELETE pentru ștergeri selective în aplicație;
  • TRUNCATE pentru tabele de staging sau de test golite înainte de un import;
  • DROP la refactorizări de schemă, prin migrări, niciodată ad hoc în producție.

Ce urmărește intervievatorul: Se verifică dacă știi consecințele fiecărei comenzi, inclusiv diferențele dintre sisteme. Greșeala tipică este presupunerea că TRUNCATE se poate anula peste tot.

Eroarea, în practică:near "TRUNCATE": syntax error

55 Junior

Trebuie să muți comenzile mai vechi de 1 ianuarie 2024 din comenzi în comenzi_arhiva, care are aceleași coloane plus arhivat_la. Scrie comenzile SQL și explică de ce enumeri coloanele.

Răspuns scurt: Faci INSERT INTO comenzi_arhiva (coloane...) SELECT coloane..., now() FROM comenzi WHERE data_comanda < '2024-01-01', apoi DELETE cu aceeași condiție, ambele în aceeași tranzacție. Enumeri coloanele ca operația să nu depindă de ordinea lor și să nu se strice la schimbări de schemă.

INSERT ... SELECT inserează rezultatul unei interogări, fără să treci datele prin aplicație.

SQL
BEGIN;

INSERT INTO comenzi_arhiva (id, client_id, data_comanda, status, total, arhivat_la)
SELECT id, client_id, data_comanda, status, total, CURRENT_TIMESTAMP
FROM comenzi
WHERE data_comanda < DATE '2024-01-01';

DELETE FROM comenzi
WHERE data_comanda < DATE '2024-01-01';

COMMIT;

De ce lista explicită de coloane:

  • INSERT INTO comenzi_arhiva SELECT * FROM comenzi funcționează doar dacă tabelele au exact aceleași coloane, în aceeași ordine. Când cineva adaugă o coloană în comenzi, comanda fie dă eroare, fie, mai rău, pune valori în coloane greșite dacă tipurile sunt compatibile.
  • coloana suplimentară arhivat_la nu ar avea altfel de unde primi valoare.
  • codul spune explicit ce date se mută, ușor de verificat la code review.

De ce tranzacția: dacă DELETE-ul eșuează după INSERT, fără tranzacție ai date dublate; dacă INSERT-ul eșuează, nu vrei să ștergi nimic.

Atenție la două detalii:

  • condiția trebuie să fie identică în ambele comenzi; o variantă mai sigură în PostgreSQL este un singur statement: WITH mutate AS (DELETE FROM comenzi WHERE ... RETURNING *) INSERT INTO comenzi_arhiva (...) SELECT ..., now() FROM mutate;
  • dacă există linii de comandă sau plăți cu chei străine către comenzi, le arhivezi întâi pe ele, altfel DELETE-ul eșuează (sau, cu CASCADE, le șterge fără să fie arhivate).

La milioane de rânduri, faci mutarea în loturi (de exemplu câte o lună), ca să eviți o tranzacție uriașă.

Ce urmărește intervievatorul: Se verifică folosirea lui INSERT ... SELECT și gândirea în tranzacții. Candidații uită des de dependențele prin chei străine.

56 Junior

Primești zilnic un fișier cu stocurile produselor, identificate prin sku. Produsele noi trebuie inserate, cele existente actualizate. Cum scrii asta într-o singură comandă în PostgreSQL și în MySQL?

Răspuns scurt: În PostgreSQL folosești INSERT ... ON CONFLICT (sku) DO UPDATE SET stoc = EXCLUDED.stoc, iar în MySQL INSERT ... ON DUPLICATE KEY UPDATE. Ambele au nevoie de o constrângere unică pe sku.

Operația se numește upsert (update sau insert). Varianta naivă, „caut cu SELECT, apoi decid INSERT sau UPDATE”, are o problemă de concurență: două procese pot vedea simultan că produsul lipsește și ambele încearcă să-l insereze. Upsert-ul nativ face verificarea și scrierea atomic.

PostgreSQL (9.5+):

SQL
INSERT INTO stocuri (sku, stoc, actualizat_la)
VALUES ('CAF-1KG', 42, now())
ON CONFLICT (sku)
DO UPDATE SET stoc = EXCLUDED.stoc,
              actualizat_la = EXCLUDED.actualizat_la;

EXCLUDED este rândul care s-ar fi inserat. Poți adăuga și o condiție: ... DO UPDATE SET ... WHERE stocuri.stoc IS DISTINCT FROM EXCLUDED.stoc, ca să nu rescrii rândurile neschimbate. ON CONFLICT DO NOTHING ignoră pur și simplu duplicatele.

MySQL 8.0.19+:

SQL
INSERT INTO stocuri (sku, stoc, actualizat_la)
VALUES ('CAF-1KG', 42, NOW()) AS nou
ON DUPLICATE KEY UPDATE stoc = nou.stoc,
                        actualizat_la = nou.actualizat_la;

Forma veche stoc = VALUES(stoc) este încă acceptată, dar marcată ca depreciată din 8.0.20.

Ambele variante au nevoie de o cheie primară sau un index unic pe coloana de conflict. În MySQL, ON DUPLICATE KEY se declanșează la conflict pe orice index unic al tabelului, nu doar pe cel la care te gândești, deci un tabel cu mai multe chei unice poate actualiza alt rând decât te aștepți.

Standardul SQL are comanda MERGE, disponibilă în PostgreSQL de la versiunea 15, SQL Server și Oracle, utilă pentru sincronizări mai complexe (inclusiv ștergerea rândurilor care nu mai apar în sursă).

Ce urmărește intervievatorul: Se verifică dacă știi să faci sincronizări corecte la concurență. Răspunsul slab propune SELECT urmat de INSERT sau UPDATE, fără să vadă condiția de cursă.

Eroarea, în practică:UNIQUE constraint failedUNIQUE constraint failed: produse.id (cheie primară)

57 Junior

După ce inserezi o comandă nouă, aplicația are nevoie de id-ul generat de baza de date. Cum îl obții în PostgreSQL și în MySQL, și de ce nu e bine să faci SELECT MAX(id) FROM comenzi?

Răspuns scurt: În PostgreSQL adaugi RETURNING id la INSERT; în MySQL apelezi LAST_INSERT_ID() pe aceeași conexiune. MAX(id) poate întoarce id-ul inserat între timp de altă sesiune.

PostgreSQL (și SQLite 3.35+, MariaDB 10.5+) are clauza RETURNING, care întoarce coloane din rândurile afectate chiar în comanda de scriere:

SQL
INSERT INTO comenzi (client_id, total)
VALUES (17, 349.90)
RETURNING id, creata_la;

Funcționează și cu mai multe rânduri (întoarce câte un rând pentru fiecare) și la UPDATE sau DELETE: DELETE FROM sesiuni WHERE expira_la < now() RETURNING user_id;. Primești și valorile calculate de baza de date (DEFAULT, triggere), fără o interogare suplimentară.

MySQL nu are RETURNING. Folosești funcția LAST_INSERT_ID(), al cărei rezultat este păstrat per conexiune:

SQL
INSERT INTO comenzi (client_id, total) VALUES (17, 349.90);
SELECT LAST_INSERT_ID();

Pentru un INSERT cu mai multe rânduri, LAST_INSERT_ID() întoarce id-ul primului rând inserat. Driverele (PDO, JDBC, mysql2) îl expun direct, de exemplu lastInsertId().

De ce nu MAX(id):

  • între INSERT și SELECT, altă sesiune poate insera un rând, iar tu primești id-ul ei;
  • valorile generate nu sunt garantat în ordinea commit-urilor; o tranzacție care a obținut un id mai mic poate face commit mai târziu;
  • este și o citire în plus pe tabel.

SQL Server are echivalentul OUTPUT inserted.id. Indiferent de sistem, regula e aceeași: obții id-ul din comanda de inserare sau din sesiunea care a inserat, niciodată deducându-l din tabel.

Ce urmărește intervievatorul: Se verifică înțelegerea concurenței la nivelul cel mai simplu. Greșeala clasică este MAX(id), care funcționează perfect în teste cu un singur utilizator.

Eroarea, în practică:no such function: LAST_INSERT_ID

58 Junior

Scrie CREATE TABLE pentru tabelul produse: id generat automat, cod SKU unic și obligatoriu, nume obligatoriu, preț nenegativ cu două zecimale, stoc implicit 0 și niciodată negativ, data creării completată automat. Folosește PostgreSQL.

Răspuns scurt: Folosești GENERATED ALWAYS AS IDENTITY PRIMARY KEY pentru id, NOT NULL UNIQUE pentru sku, numeric(10,2) cu CHECK (pret >= 0), DEFAULT 0 și CHECK (stoc >= 0) pentru stoc, DEFAULT now() pentru data creării, cu constrângeri denumite.

Constrângerile mută regulile de business în baza de date, unde se aplică pentru orice aplicație, script sau import, nu doar pentru codul care ține minte să le verifice.

SQL
CREATE TABLE produse (
  id        bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  sku       varchar(40)   NOT NULL,
  nume      varchar(200)  NOT NULL,
  pret      numeric(10,2) NOT NULL,
  stoc      integer       NOT NULL DEFAULT 0,
  creat_la  timestamptz   NOT NULL DEFAULT now(),
  CONSTRAINT uq_produse_sku     UNIQUE (sku),
  CONSTRAINT ck_produse_pret    CHECK (pret >= 0),
  CONSTRAINT ck_produse_stoc    CHECK (stoc >= 0)
);

Alegeri de explicat:

  • GENERATED ALWAYS AS IDENTITY este forma standard (PostgreSQL 10+) și refuză valori introduse manual, cu excepția lui OVERRIDING SYSTEM VALUE; serial e varianta veche.
  • numeric(10,2) stochează exact valori de bani; float ar introduce erori de rotunjire.
  • NOT NULL pe lângă CHECK: un CHECK acceptă NULL, pentru că NULL >= 0 dă UNKNOWN, iar CHECK respinge doar FALSE.
  • numele constrângerilor apar în mesajele de eroare (violates check constraint "ck_produse_stoc"), ceea ce face erorile ușor de tradus în mesaje pentru utilizator.
  • UNIQUE creează automat un index pe sku.

În MySQL scrii id BIGINT AUTO_INCREMENT PRIMARY KEY, DECIMAL(10,2) și DATETIME DEFAULT CURRENT_TIMESTAMP. Atenție: MySQL respectă CHECK abia de la versiunea 8.0.16; versiunile mai vechi îl acceptau sintactic și îl ignorau.

Ce urmărește intervievatorul: Se verifică dacă știi să pui regulile în schemă și dacă îți alegi tipurile corect. Un răspuns slab creează doar coloanele și lasă toată validarea în aplicație.

Eroarea, în practică:near "AUTO_INCREMENT": syntax errorNOT NULL constraint failed

59 Junior

Coloana email din utilizatori are o constrângere UNIQUE, dar este opțională. Pot exista doi utilizatori cu email NULL? Răspunsul diferă între PostgreSQL, MySQL și SQL Server?

Răspuns scurt: În PostgreSQL, MySQL și SQLite da: NULL-urile nu sunt considerate egale, deci oricâte rânduri pot avea NULL. SQL Server permite un singur NULL într-o constrângere UNIQUE. PostgreSQL 15+ poate cere și unicitatea NULL-urilor cu NULLS NOT DISTINCT.

O constrângere UNIQUE interzice două rânduri cu valori egale. Deoarece NULL = NULL nu este TRUE, standardul și majoritatea sistemelor permit mai multe rânduri cu NULL. Pentru un email opțional, acesta este exact comportamentul dorit: mulți utilizatori fără email, dar niciun email repetat.

SQL
CREATE TABLE utilizatori (
  id    bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  email varchar(254) UNIQUE
);

INSERT INTO utilizatori (email) VALUES (NULL), (NULL);   -- funcționează
INSERT INTO utilizatori (email) VALUES ('a@b.ro'), ('a@b.ro'); -- eroare la al doilea

Excepții și variante:

  • SQL Server tratează NULL-urile ca egale într-un index unic, deci un singur rând poate avea NULL. Soluția acolo este un index filtrat: CREATE UNIQUE INDEX ux_email ON utilizatori(email) WHERE email IS NOT NULL;.
  • PostgreSQL 15+ acceptă UNIQUE NULLS NOT DISTINCT (email), care permite un singur NULL. E util la combinații: într-un tabel setari(user_id, cheie, tenant_id), unde tenant_id NULL înseamnă „setare globală”, vrei o singură setare globală pentru aceeași cheie.
  • la o constrângere pe mai multe coloane, UNIQUE (a, b), un rând cu b NULL nu intră în conflict cu nimic; asta permite tacit duplicate de tipul (1, NULL), (1, NULL).

Dacă ai nevoie de unicitate doar pe o parte din rânduri (de exemplu doar utilizatorii activi), în PostgreSQL folosești un index unic parțial: CREATE UNIQUE INDEX ... ON utilizatori (email) WHERE activ;.

Ce urmărește intervievatorul: Se verifică înțelegerea interacțiunii dintre NULL și unicitate, care diferă între sisteme. Capcana frecventă este cheia unică compusă care lasă să treacă duplicate cu NULL.

Eroarea, în practică:UNIQUE constraint failedUNIQUE constraint failed: index 'ix_clienti_email'

60 Junior

Coloana id a tabelului facturi este generată automat. După câteva luni observi goluri în numerotare: 1041, 1042, 1045. De ce apar și ce faci dacă legea cere numere de factură consecutive?

Răspuns scurt: Secvențele și AUTO_INCREMENT nu sunt tranzacționale: o valoare consumată de un INSERT anulat, eșuat sau de un upsert nu se mai refolosește. Numerele consecutive cerute legal nu se bazează pe id, ci pe un contor separat, actualizat în aceeași tranzacție cu factura.

O secvență (PostgreSQL: serial, IDENTITY; MySQL: AUTO_INCREMENT) furnizează valori unice și crescătoare foarte repede, inclusiv pentru sesiuni concurente. Ca să fie rapidă, nu așteaptă commit-ul tranzacției: valoarea se consumă la cerere și rămâne consumată. Goluri apar când:

  • tranzacția care a primit valoarea face ROLLBACK sau eșuează la o constrângere;
  • un INSERT ... ON CONFLICT DO NOTHING/UPDATE consumă o valoare chiar dacă nu inserează;
  • PostgreSQL pre-alocă valori pe sesiune (CACHE) sau pierde câteva la un crash;
  • în MySQL, modurile de blocare ale AUTO_INCREMENT pentru inserări în masă pot rezerva intervale nefolosite complet.

Golurile sunt normale și nu trebuie „reparate”. O cheie primară surogat nu are sens de business.

Dacă reglementările cer numere consecutive fără goluri (cum e cazul facturilor în multe țări, pe serii), folosești un contor dedicat:

SQL
BEGIN;
UPDATE serii_facturi
SET ultimul_numar = ultimul_numar + 1
WHERE serie = 'AP'
RETURNING ultimul_numar;   -- de exemplu 1043

INSERT INTO facturi (serie, numar, client_id, total)
VALUES ('AP', 1043, 17, 349.90);
COMMIT;

UPDATE-ul blochează rândul seriei până la commit, deci emiterile concurente pe aceeași serie se serializează, iar un ROLLBACK anulează și incrementarea. Costul este throughput mai mic, acceptabil pentru facturi. Adaugi și UNIQUE (serie, numar) ca plasă de siguranță.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce secvențele nu sunt tranzacționale și dacă separi cheia tehnică de un identificator de business. Răspunsul slab propune MAX(numar) + 1, care produce duplicate la concurență.

61 Mid

Ai prețurile noi în tabelul preturi_noi(sku, pret) și vrei să actualizezi produse. Scrie UPDATE-ul în PostgreSQL și MySQL. Ce se întâmplă cu varianta standard de mai jos pentru produsele care nu apar în preturi_noi?

SQL
UPDATE produse p
SET pret = (SELECT n.pret FROM preturi_noi n WHERE n.sku = p.sku);

Răspuns scurt: Varianta standard setează prețul la NULL pentru toate produsele fără rând în preturi_noi, pentru că subinterogarea întoarce NULL. Folosești UPDATE ... FROM în PostgreSQL sau UPDATE ... JOIN în MySQL, care modifică doar rândurile cu potrivire, sau adaugi WHERE EXISTS.

În varianta standard, SET se evaluează pentru fiecare rând din produse, pentru că nu există WHERE. Pentru produsele fără preț nou, subinterogarea scalară nu găsește nimic și întoarce NULL, deci prețurile lor sunt șterse. Dacă pret este NOT NULL, comanda eșuează; altfel, distruge datele tacit.

Corect în forma standard:

SQL
UPDATE produse p
SET pret = (SELECT n.pret FROM preturi_noi n WHERE n.sku = p.sku)
WHERE EXISTS (SELECT 1 FROM preturi_noi n WHERE n.sku = p.sku);

PostgreSQL, cu JOIN implicit:

SQL
UPDATE produse p
SET pret = n.pret
FROM preturi_noi n
WHERE n.sku = p.sku
  AND p.pret IS DISTINCT FROM n.pret;

MySQL:

SQL
UPDATE produse p
JOIN preturi_noi n ON n.sku = p.sku
SET p.pret = n.pret;

Ambele modifică doar produsele cu potrivire. Condiția suplimentară din PostgreSQL evită rescrierea rândurilor la care prețul nu s-a schimbat, ceea ce reduce scrierile și nu declanșează triggere degeaba.

Capcana variantelor cu JOIN: dacă preturi_noi conține același sku de două ori, PostgreSQL actualizează rândul folosind unul dintre rândurile potrivite, fără eroare și fără să poți prezice care. Varianta standard, în schimb, ar da eroarea „more than one row”. Înainte de UPDATE verifici unicitatea sursei (GROUP BY sku HAVING COUNT(*) > 1) sau, mai bine, sursa are o cheie primară pe sku.

Ca la orice UPDATE în masă, rulezi întâi un SELECT cu același JOIN și compari numărul de rânduri.

Ce urmărește intervievatorul: Se verifică dacă știi sintaxa specifică fiecărui sistem și capcanele UPDATE-ului cu date din alt tabel. Greșeala clasică este forma cu subinterogare fără WHERE EXISTS.

Eroarea, în practică:near "JOIN": syntax error (UPDATE ... JOIN)target object/alias may not appear in FROM clause

62 Mid

În MySQL, comanda de mai jos dă eroarea 1093: „You can't specify target table 'angajati' for update in FROM clause”. De ce, și cum o rescrii? Apare la fel în PostgreSQL?

SQL
DELETE FROM angajati
WHERE salariu < (SELECT AVG(salariu) FROM angajati) * 0.5;

Răspuns scurt: MySQL nu permite ca un UPDATE sau DELETE să citească, într-o subinterogare, din același tabel pe care îl modifică. Rescrii cu un JOIN la un tabel derivat care calculează media, materializat înainte de ștergere. PostgreSQL acceptă comanda așa cum este.

Restricția vine din modul în care MySQL execută subinterogările: modificarea s-ar putea face în timp ce subinterogarea încă citește tabelul, iar rezultatul ar depinde de ordinea rândurilor. MySQL preferă să refuze comanda.

Rescrierea cu un tabel derivat care conține o agregare:

SQL
DELETE a
FROM angajati a
JOIN (SELECT AVG(salariu) AS medie FROM angajati) m
  ON a.salariu < m.medie * 0.5;

Tabelul derivat cu AVG nu poate fi integrat (merged) în interogarea exterioară, deci MySQL îl materializează complet înainte de ștergere, iar restricția nu mai este încălcată. Același truc funcționează la UPDATE:

SQL
UPDATE produse p
JOIN (SELECT categorie_id, AVG(pret) AS medie FROM produse GROUP BY categorie_id) m
  ON m.categorie_id = p.categorie_id
SET p.peste_medie = (p.pret > m.medie);

Atenție la varianta adesea recomandată pe forumuri, WHERE id IN (SELECT id FROM (SELECT id FROM angajati WHERE ...) AS t): funcționează doar dacă optimizatorul materializează tabelul derivat; dacă îl integrează, eroarea revine. Agregările, DISTINCT, LIMIT sau funcțiile fereastră din tabelul derivat garantează materializarea.

O altă variantă sigură, în doi pași: calculezi media într-o variabilă (SELECT AVG(salariu) INTO @m FROM angajati;) și o folosești în DELETE.

PostgreSQL nu are această restricție: datorită MVCC, subinterogarea vede tabelul așa cum era la începutul comenzii, deci media se calculează pe datele dinainte de ștergere, iar rezultatul este determinist.

Ce urmărește intervievatorul: Se verifică experiența practică cu MySQL și înțelegerea materializării. Un răspuns slab știe trucul cu subinterogarea dublă, dar nu și de ce poate eșua.

63 Mid

Care este diferența dintre acțiunile RESTRICT, NO ACTION și SET NULL ale unei chei străine? Ce înseamnă o constrângere DEFERRABLE INITIALLY DEFERRED în PostgreSQL și când ai nevoie de ea?

Răspuns scurt: RESTRICT refuză imediat ștergerea părintelui care are copii; NO ACTION refuză la sfârșitul comenzii (sau al tranzacției, dacă e amânată); SET NULL pune NULL în cheia copiilor. O constrângere amânată se verifică abia la COMMIT, util la modificări care trec temporar prin stări inconsistente.

O cheie străină definește ce se întâmplă cu rândurile copil când părintele este șters sau i se schimbă cheia:

  • RESTRICT: operația pe părinte eșuează imediat dacă există copii.
  • NO ACTION (implicit în standard): eșuează tot, dar verificarea se face la sfârșitul comenzii, deci comanda poate „repara” situația în același statement. În MySQL InnoDB, NO ACTION este identic cu RESTRICT.
  • SET NULL: cheia copiilor devine NULL; coloana trebuie să permită NULL. Potrivit pentru relații opționale, de exemplu produse.furnizor_id când un furnizor dispare.
  • SET DEFAULT: pune valoarea implicită; PostgreSQL îl suportă, InnoDB nu.

În PostgreSQL, constrângerile de tip NO ACTION pot fi declarate amânabile:

SQL
ALTER TABLE angajati
  ADD CONSTRAINT fk_manager
  FOREIGN KEY (manager_id) REFERENCES angajati(id)
  DEFERRABLE INITIALLY DEFERRED;

Cu INITIALLY DEFERRED, verificarea se face la COMMIT. Situații tipice:

  • referințe circulare: departamente.sef_id către angajati, iar angajati.departament_id către departamente; inserezi ambele rânduri în aceeași tranzacție, în orice ordine;
  • reorganizări: muți un subarbore de angajați, iar între comenzi există momentan referințe către rânduri inserate mai târziu;
  • importuri în care ordinea datelor nu respectă dependențele.

RESTRICT nu poate fi amânată. O constrângere DEFERRABLE INITIALLY IMMEDIATE se comportă normal, dar o poți amâna punctual cu SET CONSTRAINTS fk_manager DEFERRED; doar în tranzacția care are nevoie. Costul: constrângerile amânabile nu pot fi folosite de optimizator pentru unele simplificări, iar erorile apar la COMMIT, mai departe de comanda care le-a provocat.

Ce urmărește intervievatorul: Se verifică o înțelegere a cheilor străine dincolo de CASCADE. Puțini candidați știu că RESTRICT și NO ACTION diferă și ce rezolvă constrângerile amânate.

Eroarea, în practică:FOREIGN KEY constraint failed

Modelare și normalizare

64 Junior

Modelează relația dintre studenți și cursuri: un student se poate înscrie la mai multe cursuri, un curs are mai mulți studenți, iar pentru fiecare înscriere vrei data înscrierii și nota finală. Scrie tabelele.

Răspuns scurt: Relația mulți-la-mulți se modelează cu un tabel de legătură, inscrieri, care are chei străine către studenti și cursuri, cheie primară compusă (student_id, curs_id) și atributele înscrierii: data și nota.

O relație N-N nu se poate reprezenta direct prin chei străine: un student nu poate avea o coloană curs_id (ar avea doar un curs), iar o listă de ID-uri într-o celulă încalcă prima formă normală și nu poate fi protejată cu chei străine. Soluția standard este un tabel de legătură (asociativ), în care fiecare rând reprezintă o înscriere.

SQL
CREATE TABLE studenti (
  id   bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  nume varchar(200) NOT NULL
);

CREATE TABLE cursuri (
  id    bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  titlu varchar(200) NOT NULL
);

CREATE TABLE inscrieri (
  student_id     bigint NOT NULL REFERENCES studenti(id),
  curs_id        bigint NOT NULL REFERENCES cursuri(id),
  data_inscriere date   NOT NULL DEFAULT CURRENT_DATE,
  nota_finala    numeric(4,2) CHECK (nota_finala BETWEEN 1 AND 10),
  PRIMARY KEY (student_id, curs_id)
);

CREATE INDEX ix_inscrieri_curs ON inscrieri (curs_id);

Explicații:

  • Cheia primară compusă împiedică dublarea aceleiași înscrieri.
  • Data și nota aparțin înscrierii, nu studentului sau cursului, de aceea stau în tabelul de legătură.
  • nota_finala poate fi NULL cât timp cursul nu s-a încheiat; CHECK-ul permite NULL.
  • Indexul pe curs_id ajută la întrebarea „cine e înscris la cursul X”. Cheia primară începe cu student_id, deci acoperă deja „la ce cursuri e înscris studentul Y”.

Întrebare de pus intervievatorului: se poate înscrie un student de două ori la același curs (de exemplu, repetând anul)? Dacă da, cheia (student_id, curs_id) nu mai e potrivită; adaugi un id surogat sau un an_universitar în cheie.

Ce urmărește intervievatorul: Se verifică modelarea de bază a relațiilor și plasarea corectă a atributelor. Greșeala tipică este punerea notei în tabelul studenților sau o coloană cu liste de cursuri.

Eroarea, în practică:table has more than one primary key

65 Junior

Ce tip de date folosești pentru prețuri și sume de bani? Ce afișează în PostgreSQL SELECT 0.1::float8 + 0.2::float8 = 0.3::float8; și de ce?

Răspuns scurt: Folosești NUMERIC/DECIMAL cu precizie fixă, de exemplu numeric(12,2), sau un întreg care stochează bani în subunități. Interogarea afișează false, pentru că float reprezintă binar aproximativ, iar 0.1 + 0.2 dă 0.30000000000000004.

Tipurile real, float și double precision stochează numerele în virgulă mobilă binară (IEEE 754). Multe fracții zecimale simple, ca 0.1, nu au reprezentare binară exactă, așa cum 1/3 nu are reprezentare zecimală finită. Erorile sunt mici, dar se acumulează la sume și apar la comparații de egalitate:

SQL
SELECT 0.1::float8 + 0.2::float8;            -- 0.30000000000000004
SELECT 0.1::float8 + 0.2::float8 = 0.3::float8;  -- false
SELECT 0.1::numeric + 0.2::numeric = 0.3;    -- true

Într-un sistem financiar, asta înseamnă facturi care nu se închid la ban, totaluri care diferă de suma liniilor și reconcilieri care eșuează.

Opțiuni corecte:

  • NUMERIC(p, s) / DECIMAL(p, s): stocare zecimală exactă. numeric(12,2) acceptă până la 9.999.999.999,99. Operațiile sunt mai lente decât cele pe float, dar diferența rar contează pentru aplicații de business.
  • întregi în subunități (bani, cenți): bigint cu 34990 pentru 349,90 lei. Rapid și exact; aplicația trebuie să convertească la afișare. Folosit des în plăți (de exemplu API-uri de plăți lucrează cu sume în cea mai mică unitate a monedei).

Ce să eviți:

  • tipul money din PostgreSQL: depinde de setarea de locale a serverului și are o precizie fixă, ceea ce face migrările și operațiile cu mai multe valute riscante.
  • float pentru orice sumă care trebuie să se închidă exact.

Mai rămân decizii de business: coloana de valută lângă sumă, regula de rotunjire (ROUND la 2 zecimale pe linie sau pe total) și ordinea în care se aplică TVA-ul.

Ce urmărește intervievatorul: Întrebarea este clasică și verifică înțelegerea reprezentării numerelor. Răspunsul slab alege float sau double „pentru că are zecimale”.

66 Junior

Coloana status a comenzilor poate avea doar câteva valori fixe: noua, platita, expediata, anulata. Cum impui asta în baza de date? Compară ENUM, CHECK și un tabel de referință.

Răspuns scurt: Ai trei variante: tip ENUM, CHECK (status IN (...)) sau tabel de referință cu cheie străină. CHECK e simplu și portabil, ENUM e compact dar greu de modificat, tabelul de referință e cel mai flexibil.

CHECK cu listă:

SQL
status varchar(20) NOT NULL DEFAULT 'noua'
  CHECK (status IN ('noua', 'platita', 'expediata', 'anulata'))

Este portabil și ușor de citit. Pentru o valoare nouă înlocuiești constrângerea (DROP și ADD CONSTRAINT), ceea ce în PostgreSQL verifică tot tabelul; cu NOT VALID urmat de VALIDATE CONSTRAINT se poate face fără blocare lungă.

ENUM:

SQL
-- PostgreSQL
CREATE TYPE status_comanda AS ENUM ('noua', 'platita', 'expediata', 'anulata');
-- MySQL: status ENUM('noua','platita','expediata','anulata') NOT NULL

Valorile se stochează compact. În PostgreSQL adaugi valori cu ALTER TYPE ... ADD VALUE, dar eliminarea sau redenumirea sunt complicate. În MySQL, modificarea listei este un ALTER TABLE (de obicei rapid doar dacă adaugi valori la final). Capcană: un ENUM se sortează după ordinea declarării, nu alfabetic, iar în MySQL, fără mod strict, o valoare invalidă devine șirul gol.

Tabel de referință:

SQL
CREATE TABLE statusuri (cod varchar(20) PRIMARY KEY, eticheta varchar(100), final boolean);
-- comenzi.status varchar(20) NOT NULL REFERENCES statusuri(cod)

Valorile se schimbă cu INSERT, fără modificare de schemă, și pot avea atribute: eticheta pentru interfață, dacă statusul e final, ordinea de afișare. Costul este un JOIN în plus când ai nevoie de atribute.

Regulă practică: CHECK pentru liste mici și stabile, tabel de referință pentru liste gestionate de business sau care au atribute, ENUM când echipa îl folosește deja consecvent.

Ce urmărește intervievatorul: Se verifică dacă știi compromisurile dintre variante, nu doar una dintre ele. Candidații care propun ENUM rareori știu cât de greu se modifică.

Eroarea, în practică:subqueries prohibited in CHECK constraintsnear "TYPE": syntax error (CREATE TYPE ... ENUM)

67 Junior

Ce este o vedere (VIEW) și ce este o vedere materializată? Dă un exemplu de folosire pentru fiecare.

Răspuns scurt: O vedere este o interogare salvată sub un nume: nu stochează date, iar la fiecare citire se execută interogarea. O vedere materializată stochează rezultatul și trebuie reîmprospătată explicit; e utilă pentru rapoarte scumpe care tolerează date ușor întârziate.

O vedere se comportă ca un tabel virtual:

SQL
CREATE VIEW v_comenzi_active AS
SELECT o.id, o.data_comanda, o.total, c.nume AS client, c.email
FROM comenzi o
JOIN clienti c ON c.id = o.client_id
WHERE o.status <> 'anulata';

SELECT * FROM v_comenzi_active WHERE data_comanda >= DATE '2026-10-01';

Când o interoghezi, optimizatorul integrează definiția vederii în interogarea ta, deci filtrele se aplică pe tabelele de bază, cu indexurile lor. Folosiri tipice:

  • simplificare: JOIN-urile și regulile repetate (excluderea comenzilor anulate) sunt scrise o singură dată;
  • securitate: un utilizator de raportare primește drept doar pe vedere, care nu expune coloane sensibile;
  • stabilitate: aplicațiile citesc vederea, iar tabelele de dedesubt se pot reorganiza.

Vederile simple, pe un singur tabel, sunt de obicei și actualizabile (INSERT/UPDATE prin vedere).

O vedere materializată (PostgreSQL, Oracle; SQL Server are echivalentul indexed views) rulează interogarea o dată și salvează rezultatul:

SQL
CREATE MATERIALIZED VIEW mv_vanzari_lunare AS
SELECT DATE_TRUNC('month', data_comanda) AS luna, SUM(total) AS total
FROM comenzi
GROUP BY 1;

CREATE UNIQUE INDEX ON mv_vanzari_lunare (luna);
REFRESH MATERIALIZED VIEW CONCURRENTLY mv_vanzari_lunare;

Citirea e rapidă, dar datele sunt la nivelul ultimului REFRESH. Varianta CONCURRENTLY nu blochează citirile, dar cere un index unic. În PostgreSQL reîmprospătarea recalculează tot. MySQL nu are vederi materializate; se folosesc tabele de rezumat actualizate de un job.

Ce urmărește intervievatorul: Se verifică dacă știi diferența dintre o vedere și o copie de date și când alegi fiecare. Greșeala tipică este credința că o vedere obișnuită „memorează” rezultatul și deci e mai rapidă.

Eroarea, în practică:cannot modify ... because it is a viewnear "MATERIALIZED": syntax error

68 Mid

Pentru tabelul utilizatori, ai folosi ca cheie primară emailul (cheie naturală) sau un id generat (cheie surogat)? Dacă alegi un id, ar fi bigint sau UUID?

Răspuns scurt: De obicei un id surogat, cu emailul păstrat ca UNIQUE, pentru că emailul se schimbă și se copiază în toate cheile străine. bigint e mai compact; UUID, de preferat UUIDv7, e util când id-ul se generează în afara bazei.

O cheie naturală are sens de business (email, CNP, cod de produs). O cheie surogat este un identificator fără sens propriu, generat de sistem.

Argumente împotriva emailului ca cheie primară:

  • se schimbă; fiecare schimbare trebuie propagată în toate tabelele care îl referă;
  • este lung (până la 254 de caractere), iar cheia primară se repetă în fiecare cheie străină și în fiecare index secundar (în InnoDB);
  • comparațiile pe text depind de colație și de normalizarea majusculelor;
  • apare în URL-uri și loguri, ceea ce poate fi o problemă de confidențialitate.

Varianta uzuală: id surogat ca PK, iar cheia naturală protejată cu UNIQUE. Unicitatea de business rămâne garantată, iar referințele sunt stabile.

bigint față de UUID:

  • bigint: 8 octeți, generat secvențial, indexuri compacte, inserări la finalul indexului. Dezavantaj: id-urile se pot ghici și enumera (/facturi/1042, /facturi/1043) și trebuie generate de baza de date.
  • UUID: 16 octeți, poate fi generat de aplicație sau de clienți offline, unic la fuziunea mai multor baze de date, nu se poate ghici. Un UUID v4 este complet aleator, deci inserările ajung în locuri aleatoare ale indexului: pagini fragmentate și cache folosit ineficient, mai ales în InnoDB, unde tabelul este organizat după PK.
  • UUIDv7 (RFC 9562) începe cu un timestamp, deci e aproape ordonat și evită fragmentarea. PostgreSQL 18 are funcția uuidv7(); în versiunile anterioare se generează în aplicație.

Faptul că un id e greu de ghicit nu înlocuiește verificarea permisiunilor.

Ce urmărește intervievatorul: Se verifică dacă poți argumenta o decizie de modelare cu compromisuri concrete. Răspunsul slab spune „UUID e mai sigur” fără să discute costul pe indexuri.

Eroarea, în practică:no such function: UUID

69 Mid

Cum stochezi data și ora la care a fost plasată o comandă, pentru o aplicație folosită în mai multe țări? Ce diferență este între timestamp și timestamptz în PostgreSQL și între DATETIME și TIMESTAMP în MySQL?

Răspuns scurt: Momentele din trecut le stochezi ca instant absolut: timestamptz în PostgreSQL, salvat în UTC. În MySQL, TIMESTAMP convertește la UTC dar se oprește în 2038; DATETIME nu are fus orar, deci stochezi explicit UTC.

Trebuie separate două tipuri de informație:

  • un instant: momentul exact în care s-a întâmplat ceva (comandă plasată, plată, login). Este același pentru toată lumea și se afișează diferit în funcție de fusul orar al cititorului.
  • o oră locală: „programarea e la ora 10:00, la București”. Dacă se schimbă regulile orei de vară, ora locală trebuie să rămână 10:00.

PostgreSQL:

  • timestamp (without time zone) stochează data și ora exact cum le dai, fără fus orar. '2026-10-25 10:00' nu spune în ce țară.
  • timestamptz convertește valoarea primită în UTC, folosind fusul indicat sau setarea TimeZone a sesiunii, și o afișează convertită înapoi în fusul sesiunii. Nu stochează numele fusului, doar instantul.

MySQL:

  • TIMESTAMP convertește din fusul sesiunii în UTC la salvare și invers la citire, dar acceptă doar intervalul 1970 - 2038-01-19 03:14:07 UTC.
  • DATETIME nu face nicio conversie și acoperă anii 1000 - 9999. Convenția obișnuită este să stochezi în el ora UTC și să fixezi fusul conexiunii la UTC.

Recomandări:

  • instantele: timestamptz / UTC; conversia la ora locală se face la afișare;
  • evenimentele viitoare legate de un loc: ora locală plus numele fusului (Europe/Bucharest), nu un offset fix ca +03:00, pentru că offsetul se schimbă la ora de vară;
  • datele fără oră (ziua de naștere, data facturii): tipul date.

Atenție la rapoarte: „vânzările de luni” depind de fusul în care calculezi ziua. Un raport în UTC pentru clienți din România mută în altă zi comenzile dintre miezul nopții și ora 2 sau 3.

Ce urmărește intervievatorul: Se verifică dacă ai înțeles diferența dintre instant și oră locală. Greșeala tipică este stocarea orei locale a serverului fără fus orar.

70 Mid

Echipa vrea ca utilizatorii șterși să poată fi restaurați 30 de zile, așa că propune „ștergere logică” cu o coloană sters_la. Ce probleme apar și cum le rezolvi, de exemplu pentru unicitatea emailului?

Răspuns scurt: Fiecare interogare trebuie să excludă rândurile șterse, unicitatea trebuie aplicată doar pe rândurile active (index unic parțial în PostgreSQL), iar cheile străine nu mai garantează că referința e „vie”. În plus, ștergerea logică nu este ștergere în sensul GDPR.

Ștergerea logică (soft delete) marchează rândul ca șters în loc să-l elimine:

SQL
ALTER TABLE utilizatori ADD COLUMN sters_la timestamptz;
UPDATE utilizatori SET sters_la = now() WHERE id = 42;

Problemele și soluțiile lor:

  • Filtrarea uitată. Orice interogare fără WHERE sters_la IS NULL afișează utilizatori șterși. Soluții: o vedere utilizatori_activi folosită de aplicație, scope-uri implicite în ORM, sau Row Level Security în PostgreSQL.
  • Unicitatea. Un utilizator șters cu emailul ana@x.ro împiedică o înregistrare nouă cu același email. În PostgreSQL folosești un index unic parțial:
SQL
CREATE UNIQUE INDEX ux_utilizatori_email_activ
  ON utilizatori (email)
  WHERE sters_la IS NULL;

MySQL nu are indexuri parțiale; se folosește o coloană generată care e NULL pentru rândurile șterse și un index unic pe ea: email_activ varchar(254) AS (IF(sters_la IS NULL, email, NULL)), apoi UNIQUE (email_activ).

  • Cheile străine. Comenzile pot referi în continuare un utilizator șters; baza de date nu mai poate preveni asta. Decizi explicit ce înseamnă: comenzile istorice rămân, comenzile noi verifică statusul.
  • Performanța. Rândurile șterse ocupă loc în tabel și indexuri; indexurile parțiale pe rândurile active ajută.
  • GDPR. Ștergerea logică nu șterge datele personale. După perioada de grație ai nevoie de un job care face ștergerea fizică sau anonimizarea.

Alternativă: mutarea rândurilor într-un tabel utilizatori_stersi la ștergere. Tabelul principal rămâne curat, iar restaurarea înseamnă mutarea înapoi.

Ce urmărește intervievatorul: Se verifică dacă vezi consecințele unei decizii de design aparent simple. Candidații propun des coloana, fără să se gândească la unicitate și la conformitatea legală.

71 Mid

Proiectează schema pentru un blog: articole scrise de autori, fiecare articol cu mai multe taguri, comentarii la articole cu posibilitatea de a răspunde la un comentariu. Ce tabele, chei și indexuri pui?

Răspuns scurt: Tabelele autori, articole (cu cheie străină către autor și slug unic), taguri, tabelul de legătură articole_taguri și comentarii, cu cheie străină către articol și parinte_id către alt comentariu pentru răspunsuri. Indexurile urmează interogările principale: lista de articole publicate și comentariile unui articol.

Înainte de schemă, pui câteva întrebări: un articol poate avea mai mulți autori? Comentariile sunt moderate? Vrem istoricul versiunilor? Presupun un singur autor, comentarii moderate și fără versiuni.

SQL
CREATE TABLE autori (
  id    bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  nume  varchar(200) NOT NULL,
  email varchar(254) NOT NULL UNIQUE
);

CREATE TABLE articole (
  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  autor_id    bigint NOT NULL REFERENCES autori(id),
  titlu       varchar(300) NOT NULL,
  slug        varchar(300) NOT NULL UNIQUE,
  continut    text NOT NULL,
  status      varchar(20) NOT NULL DEFAULT 'ciorna'
              CHECK (status IN ('ciorna', 'publicat', 'arhivat')),
  publicat_la timestamptz
);

CREATE TABLE taguri (
  id   bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  nume varchar(100) NOT NULL UNIQUE
);

CREATE TABLE articole_taguri (
  articol_id bigint REFERENCES articole(id) ON DELETE CASCADE,
  tag_id     bigint REFERENCES taguri(id),
  PRIMARY KEY (articol_id, tag_id)
);

CREATE TABLE comentarii (
  id         bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  articol_id bigint NOT NULL REFERENCES articole(id) ON DELETE CASCADE,
  parinte_id bigint REFERENCES comentarii(id),
  autor_nume varchar(200) NOT NULL,
  continut   text NOT NULL,
  aprobat    boolean NOT NULL DEFAULT false,
  creat_la   timestamptz NOT NULL DEFAULT now()
);

CREATE INDEX ix_articole_publicate ON articole (status, publicat_la DESC);
CREATE INDEX ix_articole_autor ON articole (autor_id);
CREATE INDEX ix_articole_taguri_tag ON articole_taguri (tag_id);
CREATE INDEX ix_comentarii_articol ON comentarii (articol_id, creat_la);

parinte_id NULL înseamnă comentariu de prim nivel. Indexurile servesc pagina de start, articolele unui tag și comentariile unui articol.

Ce urmărește intervievatorul: Se verifică dacă pornești de la cerințe și de la interogări, nu doar de la entități. Un răspuns bun pune întrebări de clarificare și justifică fiecare index.

72 Senior

Dă un exemplu de tabel care este în a treia formă normală (3NF), dar nu în forma normală Boyce-Codd (BCNF). Cum îl descompui și ce pierzi?

Răspuns scurt: programari(student, materie, profesor), unde fiecare profesor predă o singură materie. Dependența profesor → materie încalcă BCNF; descompunerea în (profesor, materie) și (student, profesor) pierde regula „un profesor pe materie pentru fiecare student”.

Reguli: un tabel e în 3NF dacă, pentru orice dependență funcțională X → A, fie X este supercheie, fie A face parte dintr-o cheie candidat. BCNF cere mai strict ca X să fie mereu supercheie.

Exemplu, programari(student, materie, profesor), cu regulile:

  • un student are un singur profesor pentru o materie: (student, materie) → profesor;
  • fiecare profesor predă o singură materie: profesor → materie.

Cheile candidat sunt (student, materie) și (student, profesor). Dependența profesor → materie:

  • profesor nu este supercheie, deci tabelul nu e în BCNF;
  • materie face parte dintr-o cheie candidat, deci condiția 3NF e satisfăcută.

Anomalia rămâne: dacă profesorul Ionescu predă Baze de date, faptul acesta este repetat pentru fiecare student al lui, iar o actualizare parțială poate produce rânduri contradictorii.

Descompunerea BCNF:

SQL
CREATE TABLE profesori_materii (
  profesor varchar(100) PRIMARY KEY,
  materie  varchar(100) NOT NULL
);

CREATE TABLE studenti_profesori (
  student  varchar(100),
  profesor varchar(100) REFERENCES profesori_materii(profesor),
  PRIMARY KEY (student, profesor)
);

Ce pierzi: regula (student, materie) → profesor nu mai poate fi impusă cu o constrângere pe un singur tabel. Nimic nu împiedică un student să aibă doi profesori diferiți la aceeași materie, pentru că materia se află în celălalt tabel. Descompunerea este fără pierdere de date (lossless), dar nu păstrează toate dependențele. Rămâi cu o alegere: 3NF cu o redundanță controlată, sau BCNF plus verificarea regulii printr-un trigger ori o coloană redundantă cu constrângere compusă.

Ce urmărește intervievatorul: Se verifică o înțelegere teoretică solidă, nu doar recitarea definițiilor 1NF-3NF. Un candidat de nivel senior poate explica și compromisul dintre BCNF și păstrarea dependențelor.

73 Senior

Pagina cu lista de articole afișează numărul de comentarii, iar numărarea la fiecare afișare a devenit scumpă. Colegul propune o coloană nr_comentarii în articole. Când este justificată o asemenea denormalizare și cum menții datele consistente?

Răspuns scurt: E justificată când citirile domină, iar măsurătorile arată că agregarea e problema. Actualizezi contorul în aceeași tranzacție cu comentariul (aplicație sau trigger), adaugi un job de reconciliere și ții cont de contenția pe articolele populare.

Denormalizarea înseamnă stocarea intenționată a unei informații care se poate deriva din alte date, ca să câștigi la citire. Costul este că acum există două surse pentru același adevăr, care se pot desincroniza.

Când e justificată:

  • citirile sunt mult mai frecvente decât scrierile;
  • ai măsurat cu EXPLAIN și cu timpii reali că agregarea este costul dominant, iar un index (de exemplu pe comentarii (articol_id)) nu mai ajunge;
  • poți defini clar cine actualizează valoarea și ce toleranță ai la întârzieri.

Opțiuni, de la cea mai consistentă la cea mai relaxată:

SQL
-- 1. în aceeași tranzacție cu scrierea
BEGIN;
INSERT INTO comentarii (articol_id, autor_nume, continut) VALUES (7, 'Ana', '...');
UPDATE articole SET nr_comentarii = nr_comentarii + 1 WHERE id = 7;
COMMIT;
  • un trigger AFTER INSERT OR DELETE ON comentarii, care garantează actualizarea indiferent de sursa scrierii, dar ascunde logica și costă la importuri în masă;
  • o vedere materializată sau un tabel de rezumat recalculat periodic, când câteva minute de întârziere sunt acceptabile.

Riscuri de discutat:

  • contenția: toate comentariile la un articol viral actualizează același rând, deci tranzacțiile se așteaptă una pe alta. Soluții: contoare pe mai multe rânduri (sharded counters) adunate la citire, sau actualizare asincronă printr-o coadă;
  • deriva: un bug, o ștergere directă în baza de date sau un trigger dezactivat la import strică valoarea. Un job de reconciliere (UPDATE ... SET nr_comentarii = (SELECT COUNT(*) ...)) o corectează periodic.

Nu orice copie e denormalizare: prețul salvat pe linia comenzii este un fapt istoric distinct, nu o duplicare.

Ce urmărește intervievatorul: Se verifică judecata de inginerie: când merită compromisul și cum îl controlezi. Un răspuns slab denormalizează „pentru performanță” fără măsurători și fără un plan de consistență.

74 Senior

Păstrezi istoricul prețurilor într-un tabel cu perioade de valabilitate. Cum garantezi, la nivel de bază de date, că pentru același produs nu există două perioade care se suprapun? Ce opțiuni ai în PostgreSQL și în MySQL?

Răspuns scurt: În PostgreSQL folosești o constrângere de excludere, EXCLUDE USING gist (produs_id WITH =, perioada WITH &&), pe o coloană daterange (cu extensia btree_gist). MySQL nu are mecanism declarativ: triggere plus serializarea scrierilor cu un lock.

O constrângere UNIQUE compară valori pentru egalitate; aici ai nevoie de o regulă „nu există două rânduri cu același produs și intervale care se intersectează”, pe care UNIQUE nu o poate exprima.

PostgreSQL are tipuri interval (daterange, tstzrange) și constrângeri de excludere, care generalizează UNIQUE la orice operator indexabil:

SQL
CREATE EXTENSION IF NOT EXISTS btree_gist;

CREATE TABLE preturi (
  produs_id bigint NOT NULL REFERENCES produse(id),
  pret      numeric(10,2) NOT NULL,
  perioada  daterange NOT NULL,
  EXCLUDE USING gist (produs_id WITH =, perioada WITH &&)
);

INSERT INTO preturi VALUES (1, 100, daterange('2026-01-01', '2026-07-01'));
INSERT INTO preturi VALUES (1, 120, daterange('2026-07-01', NULL));      -- ok
INSERT INTO preturi VALUES (1, 110, daterange('2026-06-15', '2026-08-01')); -- eroare

daterange('2026-01-01', '2026-07-01') este implicit [), închis la stânga și deschis la dreapta, deci perioadele care se ating nu se suprapun. Capătul NULL înseamnă „fără sfârșit”. Extensia btree_gist permite folosirea egalității pe bigint într-un index GiST. Căutarea prețului valabil la o dată devine WHERE produs_id = 1 AND perioada @> DATE '2026-10-31', servită de același index.

PostgreSQL 18 a introdus sintaxa temporală standard: PRIMARY KEY (produs_id, perioada WITHOUT OVERLAPS).

MySQL nu are tipuri interval și nici constrângeri de excludere. Variante:

  • un trigger BEFORE INSERT/UPDATE care caută suprapuneri și dă eroare cu SIGNAL SQLSTATE '45000'; la concurență însă două inserări simultane pot trece amândouă, așa că trebuie combinat cu SELECT ... FOR UPDATE pe rândul produsului din produse, care serializează scrierile pentru același produs;
  • logica în aplicație, cu același lock pe rândul părinte.

Ce urmărește intervievatorul: Se verifică dacă știi să impui reguli complexe în schemă și dacă te gândești la concurență. Majoritatea candidaților propun doar validare în aplicație, care se rupe la scrieri simultane.

Indexuri și planuri de execuție

75 Junior

Tabelul comenzi are indexul (client_id, data_comanda). Care dintre interogările de mai jos îl pot folosi eficient și de ce?

SQL
-- 1
SELECT * FROM comenzi WHERE client_id = 17;
-- 2
SELECT * FROM comenzi WHERE client_id = 17 AND data_comanda >= '2026-01-01';
-- 3
SELECT * FROM comenzi WHERE data_comanda >= '2026-01-01';
-- 4
SELECT * FROM comenzi WHERE client_id = 17 ORDER BY data_comanda DESC LIMIT 5;

Răspuns scurt: 1, 2 și 4 îl folosesc eficient, pentru că pornesc de la prima coloană a indexului. 3 nu îl poate folosi eficient: filtrează doar după a doua coloană, iar valorile ei sunt împrăștiate în tot indexul.

Un index B-tree compus este sortat după prima coloană, apoi, în cadrul fiecărei valori a primei coloane, după a doua, la fel ca o carte de telefon sortată după nume și apoi după prenume. De aici regula prefixului din stânga: indexul poate fi parcurs eficient când condițiile pornesc de la prima coloană.

  • client_id = 17: găsește direct zona clientului 17. Folosește prefixul.
  • client_id = 17 AND data_comanda >= ...: găsește clientul, apoi, în zona lui, poziția datei și citește în continuare. Cel mai bun caz: egalitate pe prima coloană, interval pe a doua.
  • doar data_comanda: comenzile din 2026 sunt răspândite în zona fiecărui client. Baza de date ar trebui să parcurgă tot indexul, așa că de obicei preferă o scanare a tabelului. MySQL 8.0.13+ poate face uneori skip scan (sare de la un client la altul) dacă prima coloană are puține valori distincte; PostgreSQL a introdus skip scan pentru B-tree abia în versiunea 18.
  • Indexul e deja sortat după data_comanda în zona clientului, deci baza de date citește ultimele 5 intrări și se oprește, fără sortare. Indexurile se pot parcurge în ambele direcții.

Consecința pentru proiectare: ordinea coloanelor contează. Pui întâi coloanele comparate prin egalitate, apoi pe cea de interval sau de sortare. Dacă ai nevoie frecvent și de interogarea 3, ai nevoie de un index separat pe data_comanda.

Un index (client_id, data_comanda) face de prisos un index separat pe client_id, pentru că îi acoperă toate folosirile.

Ce urmărește intervievatorul: Se verifică înțelegerea structurii unui index compus. Greșeala tipică este credința că un index pe (a, b) ajută la orice condiție pe b.

76 Junior

Există un index pe comenzi(data_comanda) și unul pe utilizatori(email), dar interogările de mai jos fac scanare completă. De ce și cum le rescrii?

SQL
SELECT * FROM comenzi WHERE YEAR(data_comanda) = 2026;
SELECT * FROM utilizatori WHERE LOWER(email) = 'ana@exemplu.ro';
SELECT * FROM comenzi WHERE total * 1.19 > 1000;

Răspuns scurt: Când coloana indexată este învelită într-o funcție sau o expresie, indexul (care conține valorile brute) nu mai poate fi folosit pentru căutare. Rescrii condiția ca intervalul să fie pe coloana „goală” sau creezi un index pe expresie.

Un index stochează valorile coloanei, sortate. Pentru YEAR(data_comanda) = 2026, baza de date ar trebui să calculeze YEAR pe fiecare rând ca să afle care se potrivesc, deci nu poate „sări” în index. O condiție care poate folosi un index se numește sargable (search argument able).

Rescrieri:

SQL
-- interval pe coloana originală
SELECT * FROM comenzi
WHERE data_comanda >= '2026-01-01'
  AND data_comanda <  '2027-01-01';

-- expresia mutată pe partea constantei
SELECT * FROM comenzi WHERE total > 1000 / 1.19;

Intervalul închis la stânga și deschis la dreapta funcționează corect și pentru coloane de tip timestamp, inclusiv pentru ultima zi a anului.

Pentru LOWER(email) nu există o rescriere echivalentă pe coloana brută, așa că creezi un index pe expresie:

SQL
-- PostgreSQL
CREATE INDEX ix_utilizatori_email_lower ON utilizatori (LOWER(email));
-- MySQL 8.0.13+
CREATE INDEX ix_utilizatori_email_lower ON utilizatori ((LOWER(email)));

Interogarea trebuie să folosească exact aceeași expresie ca indexul.

Alte forme care blochează indexul fără să fie evidente:

  • WHERE data_comanda::date = '2026-10-31' (conversie de tip pe coloană);
  • WHERE cod + 0 = 123 sau WHERE COALESCE(status, 'x') = 'noua';
  • comparații între tipuri diferite, unde baza de date convertește coloana.

Verificarea se face mereu cu EXPLAIN: vrei să vezi o scanare de index (Index Scan, Bitmap Index Scan, sau type: range în MySQL) în loc de Seq Scan / type: ALL.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente probleme de performanță și se verifică dacă o recunoști imediat. Candidații juniori presupun adesea că existența unui index pe coloană e suficientă.

Eroarea, în practică:expressions prohibited in PRIMARY KEY and UNIQUE

77 Junior

Pagina de căutare folosește WHERE nume LIKE '%cafea%' pe 2 milioane de produse și este lentă, deși nume are un index. De ce? Ce variante ai ca să o accelerezi în PostgreSQL și MySQL?

Răspuns scurt: B-tree-ul ajută doar căutările cu prefix fix (LIKE 'cafea%'); cu % la început trebuie verificat fiecare rând. Soluțiile sunt un index de trigrame (pg_trgm) sau căutarea full-text (tsvector în PostgreSQL, FULLTEXT în MySQL).

Un B-tree este ca un dicționar sortat alfabetic: poți găsi rapid toate cuvintele care încep cu „cafea”, dar nu și pe cele care conțin „cafea” la mijloc. De aceea:

  • LIKE 'cafea%' poate folosi un index. În PostgreSQL, doar dacă baza de date folosește colația C sau dacă indexul e creat cu clasa de operatori potrivită: CREATE INDEX ON produse (nume text_pattern_ops);. Cu o colație lingvistică obișnuită, indexul standard nu servește LIKE.
  • LIKE '%cafea%' și LIKE '%cafea' nu pot folosi un B-tree.

PostgreSQL, trigrame:

SQL
CREATE EXTENSION IF NOT EXISTS pg_trgm;
CREATE INDEX ix_produse_nume_trgm ON produse USING gin (nume gin_trgm_ops);

SELECT id, nume FROM produse WHERE nume ILIKE '%cafea%';

Indexul descompune textul în secvențe de 3 caractere și accelerează LIKE, ILIKE și potrivirea aproximativă (similarity, operatorul %), utilă pentru greșeli de scriere.

Căutare full-text, când utilizatorii caută cuvinte, nu fragmente:

SQL
-- PostgreSQL
CREATE INDEX ix_produse_fts ON produse
  USING gin (to_tsvector('simple', nume || ' ' || coalesce(descriere, '')));
SELECT id, nume FROM produse
WHERE to_tsvector('simple', nume || ' ' || coalesce(descriere, '')) @@ plainto_tsquery('simple', 'cafea boabe');

-- MySQL
ALTER TABLE produse ADD FULLTEXT INDEX ft_nume (nume, descriere);
SELECT id, nume FROM produse WHERE MATCH(nume, descriere) AGAINST ('cafea boabe');

Full-text înțelege cuvinte, ordonează după relevanță și scalează bine. PostgreSQL nu are configurație lingvistică pentru română inclusă implicit, deci se folosește simple, eventual cu extensia unaccent. La volume și cerințe mari (sinonime, fațete, toleranță la greșeli) se trece la un motor dedicat, ca Elasticsearch sau OpenSearch.

Ce urmărește intervievatorul: Se verifică dacă știi limitele B-tree și alternativele concrete. Răspunsul slab propune „un index pe nume”, care există deja și nu ajută.

78 Junior

Ai o cheie străină linii_comanda.comanda_id către comenzi.id. Creează PostgreSQL automat un index pe linii_comanda.comanda_id? Dar MySQL? Ce se întâmplă dacă indexul lipsește?

Răspuns scurt: PostgreSQL indexează automat doar PRIMARY KEY și UNIQUE, nu și coloana care referă. MySQL InnoDB creează indexul dacă lipsește. Fără el, JOIN-urile și ștergerile din tabelul părinte scanează tot tabelul copil.

O cheie străină are două capete:

  • părintele (comenzi.id) trebuie să fie PRIMARY KEY sau UNIQUE, deci are deja index;
  • copilul (linii_comanda.comanda_id) este coloana care referă.

În PostgreSQL, indexul pe coloana copil nu se creează automat. În MySQL InnoDB, este obligatoriu: dacă nu există un index care să înceapă cu acea coloană, InnoDB îl creează la definirea cheii străine.

Ce se întâmplă în PostgreSQL fără index:

  • SELECT ... FROM comenzi JOIN linii_comanda ON ... pentru o singură comandă scanează toate liniile;
  • la fiecare DELETE FROM comenzi WHERE id = ... (sau UPDATE pe cheie), baza de date verifică dacă există copii, deci scanează tabelul linii_comanda. Ștergerea a 10.000 de comenzi înseamnă 10.000 de scanări;
  • cu ON DELETE CASCADE, aceeași scanare pentru a găsi rândurile de șters;
  • verificările țin lock-uri mai mult timp, ceea ce crește riscul de blocări.
SQL
CREATE INDEX ix_linii_comanda_comanda ON linii_comanda (comanda_id);

Dacă există deja un index compus care începe cu această coloană, de exemplu cheia primară (comanda_id, produs_id), nu mai ai nevoie de unul separat.

O interogare utilă la un audit de schemă în PostgreSQL caută în pg_constraint cheile străine (contype = 'f') ale căror coloane nu apar ca prefix în niciun index din pg_index. Multe echipe adaugă acest control în CI, ca să nu ajungă în producție chei străine fără index.

Excepție rezonabilă: tabele copil foarte mici sau părinți care nu se șterg niciodată, unde indexul ar costa la scriere fără să aducă beneficii.

Ce urmărește intervievatorul: Se verifică experiența practică cu PostgreSQL, unde lipsa acestor indexuri este o cauză frecventă de lentoare. Mulți candidați presupun că orice cheie străină are automat un index.

79 Mid

Ce îți spune planul de execuție de mai jos, obținut cu EXPLAIN ANALYZE în PostgreSQL? Ce ai verifica mai departe?

Seq Scan on comenzi  (cost=0.00..21846.00 rows=12 width=64) (actual time=0.040..142.913 rows=48210 loops=1)
  Filter: (status = 'in_asteptare'::text)
  Rows Removed by Filter: 951790
Planning Time: 0.110 ms
Execution Time: 145.307 ms

Răspuns scurt: Tabelul e citit complet (Seq Scan) și 95% din rânduri sunt aruncate de filtru. Optimizatorul a estimat 12 rânduri, dar au fost 48.210, deci statisticile sunt probabil învechite. Verifici statisticile cu ANALYZE și dacă un index (eventual parțial) pe status ar ajuta.

Cum se citește:

  • Seq Scan on comenzi: tabelul este parcurs integral, rând cu rând.
  • cost=0.00..21846.00: estimarea optimizatorului în unități abstracte (costul până la primul rând și costul total). Nu sunt milisecunde; se folosesc pentru a compara planuri.
  • rows=12: câte rânduri estima optimizatorul că vor ieși.
  • actual time=0.040..142.913 rows=48210 loops=1: ce s-a întâmplat de fapt: timpul până la primul și până la ultimul rând, în milisecunde, și rândurile reale. La noduri cu loops mai mare decât 1, timpul și rândurile sunt per iterație, deci le înmulțești.
  • Rows Removed by Filter: 951790: rândurile citite și aruncate. Un raport mare între rânduri eliminate și rânduri păstrate arată că un index ar fi util.

Diagnosticul: diferența dintre 12 estimate și 48.210 reale este cea mai importantă informație. Estimările greșite duc la alegeri greșite mai sus în plan (de exemplu un nested loop gândit pentru 12 rânduri, executat pentru 48.000). Pași:

SQL
ANALYZE comenzi;  -- reîmprospătează statisticile
CREATE INDEX ix_comenzi_in_asteptare ON comenzi (data_comanda)
  WHERE status = 'in_asteptare';
EXPLAIN (ANALYZE, BUFFERS) SELECT ...;   -- compari din nou

BUFFERS arată câte pagini au venit din cache (shared hit) și câte de pe disc (read).

Atenție: EXPLAIN ANALYZE execută comanda. Pentru UPDATE sau DELETE o rulezi între BEGIN și ROLLBACK. În MySQL, echivalentele sunt EXPLAIN FORMAT=TREE și EXPLAIN ANALYZE (8.0.18+).

Ce urmărește intervievatorul: Se verifică dacă poți citi efectiv un plan, nu doar să spui „mă uit în EXPLAIN”. Semnul unui candidat bun este că observă imediat diferența dintre rândurile estimate și cele reale.

80 Mid

Ce este un index acoperitor (covering index)? Cum creezi unul în PostgreSQL pentru interogarea de mai jos și de ce uneori planul spune Index Only Scan dar tot citește tabelul?

SQL
SELECT data_comanda, total
FROM comenzi
WHERE client_id = 17
ORDER BY data_comanda DESC;

Răspuns scurt: Un index care conține toate coloanele cerute de interogare, deci aceasta se servește fără citiri în tabel. În PostgreSQL 11+: (client_id, data_comanda) INCLUDE (total). Citiri în tabel apar pentru paginile nemarcate încă în visibility map.

Un index obișnuit conține valorile coloanelor indexate și un pointer la rând. După ce găsește intrările, baza de date citește rândul din tabel pentru celelalte coloane. Dacă interogarea are nevoie numai de coloane prezente în index, pasul acesta dispare.

SQL
CREATE INDEX ix_comenzi_client_data
  ON comenzi (client_id, data_comanda DESC)
  INCLUDE (total);
  • client_id și data_comanda sunt coloane cheie: se folosesc pentru căutare și sortare.
  • total este o coloană inclusă: stă doar în frunzele indexului, nu influențează ordinea, dar e disponibilă pentru SELECT. INCLUDE există în PostgreSQL 11+ și în SQL Server.

În MySQL nu există INCLUDE; adaugi coloana la finalul cheii: (client_id, data_comanda, total). În InnoDB, fiecare index secundar conține automat și cheia primară, deci id este mereu „inclus”. În EXPLAIN, MySQL afișează Using index când indexul acoperă interogarea.

De ce Index Only Scan mai citește tabelul în PostgreSQL: din cauza MVCC, indexul nu știe dacă o versiune de rând este vizibilă pentru tranzacția ta. PostgreSQL consultă visibility map, o hartă care marchează paginile în care toate rândurile sunt vizibile pentru toți. Pentru paginile marcate, nu citește tabelul; pentru celelalte, da. În EXPLAIN ANALYZE apare Heap Fetches: N. Un tabel cu multe modificări și un autovacuum care nu ține pasul are multe heap fetches; un VACUUM le reduce.

Costul: indexul devine mai mare, iar orice modificare a coloanelor incluse îl actualizează. Merită pentru interogări foarte frecvente.

Ce urmărește intervievatorul: Se verifică înțelegerea modului în care se execută efectiv citirile, inclusiv detalii de MVCC. Candidații de nivel mid știu de obicei conceptul, dar nu și ce înseamnă heap fetches.

81 Mid

În MySQL, coloana telefon este VARCHAR(20) cu index. Interogarea de mai jos e lentă și întoarce uneori rânduri neașteptate. De ce? Ce s-ar întâmpla în PostgreSQL?

SQL
SELECT * FROM clienti WHERE telefon = 723456789;

Răspuns scurt: MySQL convertește valoarea fiecărui rând în număr: indexul nu se mai folosește, iar '0723456789' devine egal cu numărul. PostgreSQL refuză comparația cu eroare de tip. Compari text cu text: '0723456789'.

Când tipurile operanzilor diferă, MySQL aplică reguli de conversie implicită. La comparația dintre un șir și un număr, ambele sunt convertite în numere în virgulă mobilă. Consecințe:

  • performanța: conversia se aplică pe coloană, pentru fiecare rând, deci indexul pe telefon nu poate fi folosit pentru căutare. În EXPLAIN apare type: ALL.
  • corectitudinea: '0723456789' devine 723456789 (zeroul din față dispare), '723456789abc' devine 723456789 cu un warning, iar un șir nenumeric devine 0. Rezultatul poate conține rânduri care nu au fost căutate. Pentru numere mari, conversia în float pierde precizie, deci pot apărea și potriviri între valori diferite.

Corect:

SQL
SELECT * FROM clienti WHERE telefon = '0723456789';

Invers, dacă o coloană numerică este comparată cu un text (WHERE id = '17'), MySQL convertește constanta, nu coloana, deci indexul se folosește. Problema apare când coloana este cea convertită.

PostgreSQL este strict la tipuri: varchar = integer dă eroarea operator does not exist: character varying = integer. E incomod la început, dar previne exact acest bug.

Variante ale aceleiași probleme, frecvente în practică:

  • JOIN între coloane de tipuri diferite (int față de varchar), de exemplu după un import;
  • JOIN în MySQL între coloane cu seturi de caractere sau colații diferite (utf8mb3 față de utf8mb4), unde una trebuie convertită și indexul ei nu se mai folosește;
  • parametri trimiși de aplicație cu tipul greșit de un ORM sau driver.

Telefoanele, codurile poștale și CNP-urile sunt identificatori, nu numere: le stochezi ca text și le compari ca text.

Ce urmărește intervievatorul: Se verifică atenția la tipuri și experiența cu comportamentul permisiv al MySQL. Bug-ul este greu de observat, pentru că interogarea pare corectă și chiar întoarce rezultate.

82 Mid

Ai un index pe comenzi(status), dar planul pentru WHERE status = 'livrata' arată o scanare completă a tabelului. De ce ar alege optimizatorul asta? Când ai interveni și cum?

Răspuns scurt: Dacă o mare parte din rânduri au statusul căutat, citirea secvențială a tabelului e mai ieftină decât mii de salturi aleatoare prin index. Intervii doar dacă estimările sunt greșite: actualizezi statisticile, verifici distribuția valorilor și, eventual, ajustezi indexul, nu forțezi indexul.

Optimizatorul bazat pe cost estimează câte rânduri trec de filtru (selectivitatea) și compară costul planurilor posibile.

  • O scanare secvențială citește paginile în ordine, eficient pentru disc și cache.
  • O scanare de index face, pentru fiecare intrare găsită, un acces la o pagină de tabel aflată oriunde. Pentru 5 rânduri e ideal; pentru 70% din tabel înseamnă că citești aproape fiecare pagină de mai multe ori, în ordine aleatoare.

Dacă 70% din comenzi sunt livrate, scanarea completă este alegerea corectă. Pragul depinde de mărimea rândurilor, de cache și de setări (random_page_cost în PostgreSQL), dar de obicei indexul câștigă doar când filtrul păstrează un procent mic de rânduri.

Alte motive legitime: tabelul e mic (încape în câteva pagini) sau interogarea cere majoritatea coloanelor dintr-un volum mare de rânduri.

Când e o problemă reală:

  • statistici învechite: după un import mare, optimizatorul crede că 'livrata' e rar sau frecvent fără să fie. Rulezi ANALYZE comenzi; (MySQL: ANALYZE TABLE comenzi;).
  • distribuție neuniformă: unele valori sunt rare ('in_asteptare'), altele dese. PostgreSQL păstrează cele mai frecvente valori; poți crește detaliul cu ALTER TABLE comenzi ALTER COLUMN status SET STATISTICS 1000;.
  • coloane corelate: filtrele pe oras și judet combinate sunt subestimate; PostgreSQL are CREATE STATISTICS pentru dependențe între coloane.

Pentru valorile rare, un index parțial (WHERE status = 'in_asteptare') e mai mic și mai potrivit decât unul pe toate statusurile. Forțarea unui index (MySQL FORCE INDEX, PostgreSQL prin extensia pg_hint_plan) rămâne ultima soluție, pentru că fixează un plan care poate deveni greșit când datele se schimbă.

Ce urmărește intervievatorul: Se verifică dacă înțelegi optimizarea bazată pe cost. Răspunsul slab spune că „optimizatorul greșește” și propune forțarea indexului.

83 Mid

Ce este un index parțial? Dă un exemplu în care este net mai bun decât un index obișnuit și spune ce condiție trebuie să îndeplinească interogarea ca să îl folosească.

Răspuns scurt: Un index care conține doar rândurile ce respectă o condiție dată la creare, de exemplu comenzile în așteptare. E mic, ieftin de întreținut și stă în memorie. Interogarea trebuie să conțină o condiție din care rezultă condiția indexului.

Exemplu tipic: o coadă de procesare. Tabelul comenzi are 50 de milioane de rânduri, dar doar câteva mii sunt 'in_asteptare' la un moment dat, iar un job le caută la fiecare câteva secunde.

SQL
-- PostgreSQL, SQLite
CREATE INDEX ix_comenzi_de_procesat
  ON comenzi (creata_la)
  WHERE status = 'in_asteptare';

SELECT id
FROM comenzi
WHERE status = 'in_asteptare'
ORDER BY creata_la
LIMIT 100;

Avantaje față de un index pe (status, creata_la):

  • indexul are câteva mii de intrări, nu 50 de milioane, deci stă mereu în memorie;
  • inserările și actualizările rândurilor care nu respectă condiția nu modifică indexul; o comandă livrată iese din index și nu mai costă nimic;
  • costul de întreținere și spațiul sunt neglijabile.

Condiția de folosire: optimizatorul trebuie să poată demonstra că WHERE-ul interogării implică predicatul indexului. WHERE status = 'in_asteptare' merge. O interogare parametrizată WHERE status = $1 nu poate folosi indexul într-un plan generic, pentru că valoarea nu e cunoscută la planificare; PostgreSQL face uneori planuri specifice pe valoare, dar nu e garantat. De aceea, condiția indexului se scrie literal în interogările care trebuie să-l folosească.

Alte utilizări:

  • unicitate condiționată: CREATE UNIQUE INDEX ... ON utilizatori (email) WHERE sters_la IS NULL;
  • excluderea valorilor NULL dintr-o coloană rar completată: WHERE cod_promo IS NOT NULL.

MySQL nu are indexuri parțiale; alternativa este o coloană generată care e NULL în afara condiției, indexată normal, sau un tabel separat pentru elementele de procesat.

Ce urmărește intervievatorul: Se verifică dacă știi instrumente de indexare dincolo de cele de bază și condițiile lor de folosire. Puțini candidați știu de problema interogărilor parametrizate.

Eroarea, în practică:subqueries prohibited in partial index WHERE clausesno query solution (INDEXED BY)

84 Mid

Ce înseamnă că în MySQL InnoDB tabelul este organizat ca index clustered după cheia primară, iar în PostgreSQL tabelul este un heap? Ce consecințe practice are diferența?

Răspuns scurt: În InnoDB, rândurile sunt stocate chiar în B-tree-ul cheii primare, iar indexurile secundare conțin valoarea PK. În PostgreSQL, rândurile stau într-un heap fără ordine, iar toate indexurile, inclusiv PK, pointează la poziția fizică. Diferența influențează alegerea PK-ului, costul indexurilor secundare și al UPDATE-urilor.

InnoDB (index clustered):

  • tabelul este un B-tree sortat după cheia primară, iar frunzele conțin rândurile complete;
  • căutarea după PK ajunge direct la rând; intervalele pe PK (WHERE id BETWEEN ...) citesc pagini consecutive;
  • fiecare index secundar stochează, lângă valoarea indexată, valoarea PK. O căutare printr-un index secundar face două coborâri: în indexul secundar, apoi în cel primar;
  • un PK lat (de exemplu un varchar(100) sau un UUID stocat ca text) mărește toate indexurile secundare;
  • un PK aleator (UUID v4) inserează în locuri aleatoare ale arborelui, cu pagini despicate (page splits) și fragmentare; un PK crescător inserează mereu la final;
  • dacă nu definești un PK, InnoDB creează unul ascuns.

PostgreSQL (heap):

  • rândurile se adaugă unde există spațiu, fără ordine; fiecare rând are o adresă fizică (ctid);
  • toate indexurile, inclusiv cel al cheii primare, sunt structuri separate care conțin adresa rândului;
  • un UPDATE creează o versiune nouă a rândului (MVCC) cu altă adresă, deci, în principiu, toate indexurile trebuie actualizate. Optimizarea HOT (heap-only tuple) evită asta când nu se modifică nicio coloană indexată și există spațiu liber în aceeași pagină; de aceea contează și fillfactor;
  • comanda CLUSTER reordonează fizic tabelul după un index, dar o singură dată; ordinea nu se menține la scrieri ulterioare.

Consecințe practice: în MySQL alegi un PK scurt și crescător, pentru că influențează tot tabelul; în PostgreSQL alegerea PK-ului afectează mai puțin structura, dar numărul de indexuri afectează costul fiecărui UPDATE. SQL Server lasă alegerea: tabel clustered sau heap.

Ce urmărește intervievatorul: Se verifică înțelegerea organizării fizice a datelor, care explică multe decizii de design. Un candidat care știe asta poate argumenta de ce un PK aleator costă diferit în cele două sisteme.

Eroarea, în practică:PRIMARY KEY missing on table

85 Senior

Explică cei trei algoritmi principali de JOIN: nested loop, hash join și merge join. Când alege optimizatorul fiecare și ce se întâmplă când alege greșit?

Răspuns scurt: Nested loop caută perechi pentru fiecare rând exterior, bun pentru puține rânduri cu index. Hash join construiește o tabelă hash din setul mic, bun pe volume mari cu egalitate. Merge join interclasează seturi sortate. Estimările greșite duc la alegeri dezastruoase.

Nested loop: pentru fiecare rând din setul exterior, caută rândurile potrivite în setul interior.

  • cu index pe partea interioară, costul e aproximativ (rânduri exterioare) x (cost căutare în index);
  • ideal când setul exterior este mic (o comandă, o pagină de rezultate) sau când există LIMIT;
  • merge pentru orice condiție, inclusiv inegalități și OR.

Hash join: citește setul mai mic, construiește în memorie o tabelă hash după cheia de JOIN, apoi parcurge setul mare și caută fiecare rând în tabelă.

  • funcționează doar pentru egalitate;
  • excelent pentru volume mari, fără indexuri utile;
  • are nevoie de memorie (work_mem în PostgreSQL); dacă nu ajunge, împarte datele în loturi pe disc (Batches: 8 în EXPLAIN ANALYZE).

Merge join: ambele seturi sunt sortate după cheia de JOIN și se parcurg simultan, ca la interclasare.

  • eficient când datele vin deja sortate (din indexuri) sau când oricum trebuie sortate pentru ORDER BY;
  • funcționează pentru egalitate.

PostgreSQL le are pe toate trei. MySQL folosește nested loop (cu optimizări ca Batched Key Access) și hash join de la 8.0.18; nu are merge join.

Ce se întâmplă la o alegere greșită: dacă optimizatorul estimează 10 rânduri în setul exterior și sunt 2 milioane, alege nested loop, iar interogarea face 2 milioane de căutări în index; durează minute în loc de secunde. În EXPLAIN ANALYZE vezi rows=10 estimat față de rows=2000000 real și loops=2000000 pe nodul interior. Soluția nu este dezactivarea algoritmului (SET enable_nestloop = off servește doar la diagnostic), ci repararea estimării: ANALYZE, statistici extinse, condiții care pot fi estimate.

Ce urmărește intervievatorul: Se verifică dacă poți explica de ce un plan e rapid sau lent, nu doar să citești numele nodurilor. Un răspuns de nivel senior leagă alegerea algoritmului de estimările de cardinalitate.

86 Senior

Un tabel de comenzi are 14 indexuri și inserările au devenit lente. Cum decizi ce indexuri păstrezi? Cum găsești indexurile nefolosite sau redundante în PostgreSQL și cum elimini unul în siguranță?

Răspuns scurt: Fiecare index costă la scriere, în spațiu și în memorie. Cauți indexurile cu zero scanări în pg_stat_user_indexes, pe toate serverele, și pe cele redundante (prefixul altui index), apoi le elimini cu DROP INDEX CONCURRENTLY.

Costul indexurilor:

  • la fiecare INSERT se scrie în tabel și în fiecare index; cu 14 indexuri, o inserare înseamnă cel puțin 15 scrieri, plus jurnal (WAL) pentru fiecare;
  • în PostgreSQL, un UPDATE pe o coloană indexată împiedică optimizarea HOT și obligă la actualizarea tuturor indexurilor;
  • indexurile ocupă memorie de cache, concurând cu datele utile;
  • backup-urile, replicarea și operațiile de mentenanță durează mai mult.

Indexuri nefolosite:

SQL
SELECT s.relname AS tabel, s.indexrelname AS index, s.idx_scan,
       pg_size_pretty(pg_relation_size(s.indexrelid)) AS marime
FROM pg_stat_user_indexes s
JOIN pg_index i ON i.indexrelid = s.indexrelid
WHERE s.idx_scan = 0
  AND NOT i.indisunique
ORDER BY pg_relation_size(s.indexrelid) DESC;

Atenție: statisticile sunt per server. Un index nefolosit pe primar poate fi esențial pentru rapoartele rulate pe o replică. Verifici și de când s-au resetat statisticile; un index folosit doar de raportul lunar arată zero scanări după două săptămâni.

Indexuri redundante: un index pe (client_id) este acoperit de unul pe (client_id, data_comanda); două indexuri identice cu nume diferite apar des după migrări generate automat.

Eliminarea în siguranță:

  • excluzi indexurile care susțin PRIMARY KEY, UNIQUE sau constrângeri de excludere;
  • DROP INDEX CONCURRENTLY ix_vechi; nu blochează scrierile pe tabel;
  • păstrezi definiția (pg_get_indexdef), ca să-l poți recrea rapid cu CREATE INDEX CONCURRENTLY;
  • monitorizezi interogările lente câteva zile.

În MySQL 8, poți face un index invizibil (ALTER TABLE ... ALTER INDEX ix INVISIBLE): optimizatorul nu îl mai folosește, dar e întreținut, deci îl poți reactiva instant dacă apare o regresie. sys.schema_unused_indexes listează candidații.

Pentru indexurile umflate (bloat), PostgreSQL 12+ are REINDEX CONCURRENTLY.

Ce urmărește intervievatorul: Se verifică dacă tratezi indexurile ca un cost, nu ca o soluție gratuită, și dacă știi să faci schimbări sigure în producție. Greșeala tipică este ștergerea unui index pe baza statisticilor de pe un singur server.

Tranzacții și concurență

Exersează capitolul cu exerciții reale: Curs SQL online →
87 Junior

Scrie tranzacția care transferă 100 de lei din contul 1 în contul 2 din tabelul conturi(id, sold), fără ca soldul să devină negativ. Ce se întâmplă dacă o comandă din tranzacție dă eroare, în PostgreSQL și în MySQL?

Răspuns scurt: Pui cele două UPDATE-uri între BEGIN și COMMIT, cu sold >= 100 la debitare și verificarea rândurilor afectate. În PostgreSQL, după o eroare tranzacția cere ROLLBACK; în MySQL se anulează de obicei doar comanda eșuată.

Tranzacția garantează că ambele modificări se aplică împreună sau deloc:

SQL
BEGIN;

UPDATE conturi
SET sold = sold - 100
WHERE id = 1 AND sold >= 100;
-- aplicația verifică: dacă 0 rânduri au fost afectate, ROLLBACK (fonduri insuficiente)

UPDATE conturi
SET sold = sold + 100
WHERE id = 2;

COMMIT;

Condiția sold >= 100 face verificarea și debitarea atomic, în aceeași comandă. Varianta „citesc soldul în aplicație, apoi scad” permite ca două transferuri simultane să treacă amândouă de verificare. Ca plasă de siguranță, adaugi și CHECK (sold >= 0) pe tabel.

Comportamentul la erori diferă între sisteme:

  • PostgreSQL: după orice eroare, tranzacția intră în starea „aborted”. Orice comandă următoare primește current transaction is aborted, commands ignored until end of transaction block, iar singura ieșire este ROLLBACK (chiar și un COMMIT se transformă în ROLLBACK). Nu poți ajunge accidental la un commit parțial.
  • MySQL InnoDB: majoritatea erorilor (de exemplu o încălcare de constrângere) anulează doar comanda respectivă; tranzacția rămâne activă cu modificările anterioare. Dacă aplicația ignoră eroarea și dă COMMIT, debitarea se salvează fără creditare. Excepție: un deadlock sau un timeout de lock anulează toată tranzacția (timeout-ul, doar dacă innodb_rollback_on_timeout este activ).

De aceea codul aplicației trebuie să trateze explicit orice eroare cu ROLLBACK. Majoritatea framework-urilor fac asta automat când folosești blocuri tranzacționale (with transaction:, @Transactional), cu condiția să nu prinzi și să ignori excepția în interior.

Ce urmărește intervievatorul: Se verifică dacă știi să scrii o tranzacție corectă și dacă știi diferențele de comportament la erori. Puțini candidați știu că MySQL poate face commit parțial dacă aplicația ignoră eroarea.

88 Junior

Importi 10.000 de rânduri într-o tranzacție, iar câteva sunt invalide. Vrei să le sari pe cele invalide fără să pierzi restul. Cum te ajută SAVEPOINT?

Răspuns scurt: Un SAVEPOINT marchează un punct în tranzacție la care poți reveni cu ROLLBACK TO SAVEPOINT, anulând doar ce s-a întâmplat de atunci. Pui un savepoint înaintea fiecărui rând sau lot, revii la el la eroare și continui, apoi dai COMMIT la final.

Fără savepoint, în PostgreSQL prima eroare face tranzacția inutilizabilă și pierzi tot importul. Un savepoint creează o subtranzacție care poate fi anulată independent:

SQL
BEGIN;

SAVEPOINT rand;
INSERT INTO clienti (email, nume) VALUES ('ana@x.ro', 'Ana');
RELEASE SAVEPOINT rand;

SAVEPOINT rand;
INSERT INTO clienti (email, nume) VALUES ('ana@x.ro', 'Ana Pop');
-- eroare: duplicate key
ROLLBACK TO SAVEPOINT rand;   -- doar acest INSERT e anulat

SAVEPOINT rand;
INSERT INTO clienti (email, nume) VALUES ('ion@x.ro', 'Ion');
RELEASE SAVEPOINT rand;

COMMIT;   -- Ana și Ion sunt salvați

În practică, bucla e în aplicație: pentru fiecare rând (sau lot de 500 de rânduri), creează savepoint, încearcă, la eroare revine și înregistrează rândul într-un jurnal de respinse.

Unde mai apar savepoint-urile:

  • framework-urile le folosesc pentru „tranzacții imbricate”: Django atomic() în interiorul altui atomic(), Spring cu propagarea NESTED;
  • clientul psql are \set ON_ERROR_ROLLBACK on, care pune automat un savepoint înaintea fiecărei comenzi interactive.

Considerente de performanță: fiecare savepoint costă. În PostgreSQL, o tranzacție cu foarte multe subtranzacții active poate degrada performanța întregului server. Pentru importuri mari, sunt adesea mai bune alternative fără erori:

  • INSERT ... ON CONFLICT DO NOTHING pentru duplicate;
  • încărcarea întâi într-un tabel de staging fără constrângeri, validarea cu SQL, apoi un singur INSERT ... SELECT doar cu rândurile valide.

Ce urmărește intervievatorul: Se verifică dacă știi controlul fin al tranzacțiilor și alternativele lui. Candidații fără experiență propun un commit după fiecare rând, ceea ce pierde atomicitatea importului.

Eroarea, în practică:cannot start a transaction within a transaction

89 Junior

Sesiunea A rulează BEGIN; UPDATE produse SET stoc = stoc - 1 WHERE id = 7; și nu dă încă COMMIT. Sesiunea B rulează UPDATE produse SET stoc = stoc - 1 WHERE id = 7;, iar sesiunea C rulează SELECT stoc FROM produse WHERE id = 7;. Ce se întâmplă cu B și cu C?

Răspuns scurt: B așteaptă, pentru că A ține un lock de scriere pe rând; după COMMIT-ul lui A, B continuă pe valoarea nouă, deci stocul scade corect cu 2. C nu așteaptă: vede ultima valoare confirmată, cea de dinainte de modificarea lui A.

Un UPDATE blochează rândurile pe care le modifică (row-level lock) până la sfârșitul tranzacției. Alte scrieri pe aceleași rânduri trebuie să aștepte; rândurile diferite nu sunt afectate.

Sesiunea B se blochează. Când A termină:

  • dacă A dă COMMIT, B reia comanda pe versiunea nouă a rândului. În PostgreSQL, la nivelul implicit READ COMMITTED, B reevaluează condiția WHERE pe rândul actualizat și aplică stoc - 1 pe valoarea scrisă de A. Dacă stocul era 10, rezultatul final este 8, corect.
  • dacă A dă ROLLBACK, B lucrează pe valoarea originală, deci rezultatul este 9.

Sesiunea C nu se blochează. PostgreSQL și InnoDB folosesc MVCC: cititorii văd ultima versiune confirmată a rândului, deci C citește 10, fără să aștepte și fără să vadă modificarea neconfirmată a lui A.

De aceea, SET stoc = stoc - 1 este sigur la concurență, în timp ce „citesc stocul în aplicație, scad 1, scriu valoarea” nu este.

Așteptarea nu e infinită:

  • MySQL: innodb_lock_wait_timeout, implicit 50 de secunde, apoi eroare;
  • PostgreSQL: așteaptă nelimitat, dacă nu setezi lock_timeout (de exemplu SET lock_timeout = '5s').

O tranzacție uitată deschisă (un BEGIN dintr-un client interactiv sau o conexiune scăpată din pool) poate bloca astfel toate scrierile pe rândurile atinse. În PostgreSQL găsești blocajele cu pg_stat_activity și funcția pg_blocking_pids(pid).

Ce urmărește intervievatorul: Se verifică înțelegerea concretă a lock-urilor și a MVCC, nu doar a definițiilor. Greșeala tipică este presupunerea că și citirile sunt blocate sau că B suprascrie modificarea lui A.

90 Mid

Ce înseamnă autocommit? O migrare care conține mai multe ALTER TABLE eșuează la jumătate: în ce stare rămâne schema în PostgreSQL și în ce stare în MySQL?

Răspuns scurt: În autocommit, fiecare comandă este propria tranzacție și se confirmă imediat. În PostgreSQL, DDL-ul este tranzacțional: migrarea într-o tranzacție se anulează complet. În MySQL, fiecare comandă DDL face commit implicit, deci schema rămâne pe jumătate modificată.

Autocommit este modul implicit în majoritatea clienților și driverelor (psql, clientul mysql, JDBC): fără un BEGIN explicit, fiecare comandă rulează într-o tranzacție proprie, confirmată imediat la final. O tranzacție cu mai multe comenzi există doar dacă o deschizi explicit (sau dacă driverul are autocommit dezactivat, cum fac unele framework-uri).

PostgreSQL are DDL tranzacțional: CREATE TABLE, ALTER TABLE, DROP, chiar și CREATE INDEX (varianta obișnuită) pot fi anulate:

SQL
BEGIN;
ALTER TABLE comenzi ADD COLUMN canal varchar(20);
ALTER TABLE comenzi ADD CONSTRAINT ck_canal CHECK (canal IN ('web', 'app'));
UPDATE comenzi SET canal = 'web';   -- presupunem că eșuează
ROLLBACK;                           -- coloana și constrângerea dispar

Excepții: CREATE INDEX CONCURRENTLY, CREATE DATABASE și VACUUM nu pot rula într-un bloc de tranzacție. Uneltele de migrare (Flyway, Liquibase, Alembic) rulează de obicei fiecare migrare PostgreSQL într-o tranzacție.

MySQL face commit implicit înainte și după majoritatea comenzilor DDL. Un BEGIN urmat de ALTER TABLE confirmă și eventualele modificări de date anterioare. MySQL 8 are DDL atomic per comandă (un singur ALTER fie reușește complet, fie deloc), dar o migrare cu trei ALTER-uri care eșuează la al doilea rămâne cu primul aplicat.

Consecințe pentru MySQL:

  • migrări mici, cu o singură modificare, ușor de reluat;
  • scripturi idempotente (ADD COLUMN IF NOT EXISTS în MariaDB, sau verificări în information_schema în MySQL);
  • o strategie de recuperare manuală documentată pentru cazul în care o migrare se oprește la jumătate.

Ce urmărește intervievatorul: Se verifică dacă știi cum se comportă tranzacțiile cu schimbările de schemă, cu impact direct asupra deploy-urilor. Mulți candidați presupun că orice poate fi anulat cu ROLLBACK.

91 Mid

Două cereri simultane citesc stocul unui produs (10), aplicația scade 1 și scrie înapoi 9. Rezultatul final este 9 în loc de 8. Cum se numește problema și care sunt soluțiile?

Răspuns scurt: Este un lost update: a doua scriere o suprascrie pe prima, pentru că ambele au pornit de la aceeași valoare. Soluțiile sunt UPDATE atomic (stoc = stoc - 1), blocare pesimistă cu SELECT ... FOR UPDATE sau blocare optimistă cu o coloană de versiune.

Secvența problematică este citire, calcul în aplicație, scriere a valorii calculate:

A: SELECT stoc ... -> 10        B: SELECT stoc ... -> 10
A: UPDATE ... SET stoc = 9      B: UPDATE ... SET stoc = 9

La nivelul READ COMMITTED (implicit în PostgreSQL), nimic nu oprește asta.

UPDATE atomic, când calculul se poate exprima în SQL:

SQL
UPDATE produse SET stoc = stoc - 1
WHERE id = 7 AND stoc >= 1;
-- 0 rânduri afectate = stoc epuizat

E cea mai simplă și mai rapidă soluție.

Blocare pesimistă, când logica din aplicație e complexă:

SQL
BEGIN;
SELECT stoc FROM produse WHERE id = 7 FOR UPDATE;   -- blochează rândul
-- calcule în aplicație
UPDATE produse SET stoc = 9 WHERE id = 7;
COMMIT;

A doua tranzacție așteaptă la FOR UPDATE și citește apoi valoarea actualizată. Tranzacția trebuie să fie scurtă.

  • Blocare optimistă, potrivită pentru editări lungi (un formular deschis minute în șir):
SQL
UPDATE produse
SET stoc = 9, versiune = versiune + 1
WHERE id = 7 AND versiune = 14;
-- 0 rânduri afectate = altcineva a modificat; reîncarci și reîncerci

ORM-urile oferă direct acest mecanism (@Version în JPA, de exemplu).

Nivelurile de izolare ajută diferit: în PostgreSQL, la REPEATABLE READ, a doua tranzacție primește eroarea could not serialize access due to concurrent update și trebuie reluată. În MySQL, REPEATABLE READ (nivelul implicit) nu previne acest tipar, pentru că UPDATE-ul lucrează pe ultima versiune confirmată, iar valoarea calculată în aplicație o suprascrie.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente erori de concurență în aplicații. Se verifică dacă știi mai multe soluții și când o alegi pe fiecare.

Eroarea, în practică:near "FOR": syntax error (SELECT ... FOR UPDATE)

92 Mid

De ce sunt periculoase tranzacțiile lungi, de exemplu una care rămâne deschisă 40 de minute în timp ce aplicația apelează un serviciu extern? Ce efecte are asupra PostgreSQL și asupra MySQL?

Răspuns scurt: Țin lock-uri care blochează alte scrieri, împiedică curățarea versiunilor vechi ale rândurilor (bloat în PostgreSQL, istoric de undo în creștere în InnoDB) și pot întârzia replicarea și operațiile de schemă. Regula: tranzacții scurte, fără așteptări după rețea sau după utilizator.

Efectele unei tranzacții deschise mult timp:

  • Lock-uri: rândurile modificate rămân blocate până la final. Alte tranzacții care vor să le modifice așteaptă, iar în spatele lor se formează cozi. Un ALTER TABLE care cere un lock exclusiv așteaptă tranzacția, iar toate interogările care vin după ALTER așteaptă și ele, inclusiv citirile simple. Așa poate o migrare banală să oprească o aplicație.
  • PostgreSQL: MVCC păstrează versiunile vechi ale rândurilor cât timp există o tranzacție care ar putea să le vadă. VACUUM nu le poate elimina, așa că tabelele și indexurile se umflă (bloat), iar interogările citesc tot mai multe pagini. E suficient ca tranzacția să fie deschisă; nu trebuie să fi modificat ceva. Starea apare în pg_stat_activity ca idle in transaction.
  • MySQL InnoDB: versiunile vechi stau în undo log. Cu o tranzacție veche activă, procesul de purge nu le poate curăța, „history list length” crește, iar citirile consistente trebuie să reconstruiască versiuni tot mai vechi, deci devin mai lente.
  • Replicarea: pe unele configurații, tranzacțiile mari ajung pe replică doar la commit, cu lag brusc.

Prevenire:

SQL
-- PostgreSQL: închide sesiunile lăsate idle într-o tranzacție
SET idle_in_transaction_session_timeout = '60s';
SET statement_timeout = '30s';

În cod:

  • nu ții tranzacția deschisă cât aștepți un API extern, un email sau confirmarea utilizatorului; apelul extern se face înainte sau după, cu un mecanism de compensare dacă e nevoie;
  • modificările în masă se fac în loturi (de exemplu 5.000 de rânduri per tranzacție);
  • rapoartele lungi rulează pe o replică.

Ce urmărește intervievatorul: Se verifică înțelegerea impactului operațional al tranzacțiilor, dincolo de corectitudine. Candidații care au avut incidente în producție recunosc imediat „idle in transaction”.

93 Senior

Mai mulți workeri preiau joburi din tabelul joburi(id, status, creat_la). Cum scrii interogarea de preluare astfel încât doi workeri să nu ia același job și să nu se aștepte unul pe altul?

Răspuns scurt: Folosești SELECT ... FOR UPDATE SKIP LOCKED într-un UPDATE sau CTE: fiecare worker blochează primul job liber, iar ceilalți sar peste rândurile deja blocate în loc să aștepte. Este disponibil în PostgreSQL 9.5+ și MySQL 8.0+.

Fără SKIP LOCKED, toți workerii încearcă să blocheze același „primul job”. Primul îl obține, iar ceilalți așteaptă, deci rulează practic unul câte unul. Cu FOR UPDATE fără blocare, doi workeri pot citi același job și îl procesează de două ori.

PostgreSQL:

SQL
WITH urmatorul AS (
  SELECT id
  FROM joburi
  WHERE status = 'nou'
  ORDER BY creat_la
  LIMIT 1
  FOR UPDATE SKIP LOCKED
)
UPDATE joburi j
SET status = 'in_lucru',
    preluat_la = now(),
    worker = 'worker-3'
FROM urmatorul
WHERE j.id = urmatorul.id
RETURNING j.id;

SKIP LOCKED face ca rândurile blocate de alte tranzacții să fie ignorate, deci fiecare worker primește imediat alt job. Comanda se rulează în autocommit sau într-o tranzacție scurtă; procesarea efectivă se face după commit, iar la final jobul se marchează terminat.

În MySQL 8 faci același lucru în doi pași, într-o tranzacție: SELECT id ... FOR UPDATE SKIP LOCKED, apoi UPDATE ... WHERE id = ?.

Probleme de rezolvat într-un sistem real:

  • workeri căzuți: un job rămas in_lucru pentru că workerul a murit. Soluție: preluat_la plus un job care readuce la nou joburile vechi, sau un heartbeat.
  • index: un index parțial ON joburi (creat_la) WHERE status = 'nou' face selecția instantanee chiar dacă tabelul are milioane de joburi terminate.
  • bloat: tabelul are multe UPDATE-uri; arhivezi joburile terminate și urmărești autovacuum.

La volume moderate, coada în baza de date are avantajul că jobul se creează în aceeași tranzacție cu datele de business; la volume foarte mari, un broker dedicat (RabbitMQ, Kafka) e mai potrivit.

Ce urmărește intervievatorul: Se verifică dacă știi un tipar de concurență folosit des în producție. Candidații de nivel mid propun adesea un flag fără lock, care lasă doi workeri să ia același job.

Eroarea, în practică:near "FOR": syntax error (SELECT ... FOR UPDATE)

94 Senior

Explică MVCC (multiversion concurrency control) și cum îl implementează diferit PostgreSQL și MySQL InnoDB. Ce consecințe practice are fiecare implementare?

Răspuns scurt: MVCC păstrează mai multe versiuni ale rândului, ca fiecare tranzacție să vadă un instantaneu consistent, iar cititorii să nu blocheze scriitorii. PostgreSQL scrie versiuni noi în tabel și le curăță cu VACUUM; InnoDB modifică pe loc și păstrează trecutul în undo log.

Ideea comună: o tranzacție nu modifică datele „sub ochii” altora. Fiecare tranzacție lucrează cu un instantaneu (snapshot): vede doar modificările confirmate înainte de un anumit moment. Astfel, citirile nu iau lock-uri și nu așteaptă scrierile, iar scrierile nu așteaptă citirile.

PostgreSQL:

  • fiecare versiune de rând (tuple) are câmpurile xmin (tranzacția care a creat-o) și xmax (tranzacția care a șters-o sau înlocuit-o);
  • un UPDATE este, intern, o ștergere logică și o inserare nouă: versiunea veche rămâne în tabel, cea nouă se scrie în altă parte;
  • vizibilitatea se decide comparând xmin/xmax cu instantaneul tranzacției;
  • versiunile care nu mai sunt vizibile pentru nimeni (dead tuples) sunt eliminate de VACUUM, rulat automat de autovacuum.

Consecințe: tabelele cu multe UPDATE-uri se umflă dacă autovacuum nu ține pasul; un UPDATE pe o coloană indexată scrie și în indexuri (excepție: HOT); identificatorii de tranzacție sunt pe 32 de biți și trebuie „înghețați” periodic de VACUUM, altfel apare riscul de transaction ID wraparound, pe care PostgreSQL îl previne oprind scrierile.

MySQL InnoDB:

  • rândul este modificat pe loc, în indexul clustered;
  • valoarea anterioară se scrie în undo log, iar rândul păstrează un pointer spre ea;
  • o tranzacție cu un instantaneu mai vechi reconstruiește versiunea potrivită urmând lanțul de undo;
  • un proces de purge șterge intrările de undo care nu mai sunt necesare.

Consecințe: tabelul nu se umflă la fel; în schimb, tranzacțiile lungi fac lanțurile de undo lungi, iar citirile vechi devin lente.

MVCC elimină conflictele citire-scriere, nu și pe cele scriere-scriere: acestea se serializează tot prin lock-uri.

Ce urmărește intervievatorul: Se verifică o înțelegere a mecanismelor interne care explică problemele operaționale (bloat, tranzacții lungi, VACUUM). Un răspuns de nivel senior leagă implementarea de simptomele observate în producție.

95 Senior

Un spital cere ca, în orice moment, cel puțin un medic să fie de gardă. Doi medici de gardă își anulează simultan garda: fiecare tranzacție verifică că mai există un alt medic de gardă, apoi îl scoate pe cel curent. La REPEATABLE READ în PostgreSQL, ambele reușesc. De ce, și cum previi?

Răspuns scurt: Este write skew: tranzacțiile citesc aceleași date, dar modifică rânduri diferite, deci nu există conflict de scriere, iar snapshot isolation nu îl detectează. Previi cu SERIALIZABLE și retry, cu lock-uri pe rândurile citite sau cu un rând comun.

Secvența:

SQL
-- T1 (medicul 1) și T2 (medicul 2), în paralel
BEGIN ISOLATION LEVEL REPEATABLE READ;
SELECT COUNT(*) FROM garzi WHERE tura = 't7' AND de_garda;   -- ambele văd 2
UPDATE garzi SET de_garda = false WHERE tura = 't7' AND medic_id = 1;  -- T2: medic_id = 2
COMMIT;

Fiecare tranzacție are propriul instantaneu, în care încă sunt 2 medici. Ele modifică rânduri diferite, deci nu se blochează reciproc și nici nu apare eroarea de actualizare concurentă. Ambele fac commit, iar tura rămâne fără medic. REPEATABLE READ din PostgreSQL este snapshot isolation, care permite write skew.

Soluții:

  • SERIALIZABLE. PostgreSQL implementează Serializable Snapshot Isolation (din 9.1): urmărește dependențele dintre ce a citit și ce a scris fiecare tranzacție și anulează una dintre ele cu could not serialize access due to read/write dependencies among transactions (SQLSTATE 40001). Aplicația trebuie să reia tranzacția. E cea mai generală soluție, dar cere logică de retry pentru toate tranzacțiile implicate.

Lock-uri explicite pe datele citite:

SQL
SELECT medic_id FROM garzi WHERE tura = 't7' AND de_garda FOR UPDATE;

A doua tranzacție așteaptă și, după commit-ul primei, recitește rândurile blocate și vede situația nouă.

  • Materializarea conflictului: ambele tranzacții actualizează un rând comun (de exemplu ture.nr_medici), cu CHECK (nr_medici >= 1).

În MySQL, SERIALIZABLE transformă SELECT-urile simple în citiri cu lock partajat, deci tranzacțiile ajung la un deadlock, din care una este anulată. Rezultatul e corect, dar tot e nevoie de retry.

Ce urmărește intervievatorul: Se verifică înțelegerea anomaliilor de izolare dincolo de lista standard (dirty read, phantom). Write skew este exemplul care separă candidații care au citit definițiile de cei care au înțeles snapshot isolation.

Situații din practică

96 Junior

Un coleg de la vânzări îți spune că raportul tău „nu are toate comenzile”: în CRM vede 1.240, în raport 1.198. Cum procedezi și cum îi explici cauza?

Răspuns scurt: Reproduci diferența pe aceeași perioadă și aceleași definiții, găsești câteva comenzi concrete care lipsesc, cauți de ce sunt filtrate (de obicei un INNER JOIN, un filtru pe NULL sau o diferență de fus orar), apoi îi explici cu exemplele respective și convii o definiție comună.

Un model de răspuns structurat:

Clarific întrebarea. Ce perioadă, ce filtru și ce înseamnă „comandă” în CRM: include anulatele? comenzile de test? Diferența de 42 poate fi chiar aici.

Găsesc rândurile concrete. În loc să compar doar totaluri, îi cer exportul sau compar ID-urile:

SQL
SELECT c.id, c.client_id, c.status, c.creata_la
FROM comenzi c
WHERE c.creata_la >= '2026-10-01' AND c.creata_la < '2026-11-01'
  AND NOT EXISTS (SELECT 1 FROM raport_comenzi r WHERE r.comanda_id = c.id);

Caut cauza în interogarea raportului. Suspecții obișnuiți:

  • un INNER JOIN cu un tabel unde lipsesc date (comenzi fără client asociat, fără adresă), care elimină tacit rânduri;
  • un filtru WHERE canal <> 'telefon' care exclude și rândurile cu canal NULL;
  • fusul orar: CRM-ul afișează ora României, raportul calculează în UTC, deci comenzile din primele ore ale lunii cad în altă lună;
  • datele raportului sunt actualizate o dată pe noapte.
  • Explic fără jargon. De exemplu: „42 de comenzi au fost introduse fără client asociat, iar raportul le ignora pentru că lega comenzile de clienți. Uite trei dintre ele.” Exemplele concrete conving mai mult decât explicațiile despre JOIN-uri.
  • Repar și previn. Corectez interogarea (LEFT JOIN, tratarea NULL), semnalez problema de date sursă echipei responsabile și adaug în raport un control: numărul total de comenzi din sursă afișat lângă numărul raportat.

Ce urmărește intervievatorul: Se verifică metoda de investigație și capacitatea de a comunica cu oameni fără pregătire tehnică. Răspunsul slab rescrie interogarea „până iese cifra” fără să înțeleagă cauza.

97 Junior

Primești acces la o bază de date pe care nu ai mai văzut-o și o cerere de raport pentru mâine. Cum descoperi rapid structura și cum te asiguri că interpretezi corect datele?

Răspuns scurt: Listezi tabelele și coloanele din information_schema (sau cu \d în psql, SHOW CREATE TABLE în MySQL), urmărești cheile străine ca să înțelegi relațiile, verifici granularitatea fiecărui tabel și distribuția valorilor, apoi validezi rezultatul cu cifre cunoscute de cineva din business.

Inventar. Ce tabele există și cât de mari sunt:

SQL
SELECT table_schema, table_name
FROM information_schema.tables
WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
ORDER BY table_schema, table_name;

În psql: \dt și \d comenzi; în MySQL: SHOW TABLES; și SHOW CREATE TABLE comenzi;, care arată și indexurile și cheile străine.

Relații. Cheile străine spun cum se leagă tabelele; le găsești în information_schema.table_constraints și key_column_usage. Dacă lipsesc (frecvent în baze de date vechi), cauți convenții de denumire (client_id) și verifici cu interogări că valorile chiar se potrivesc.

  • Granularitate. Pentru fiecare tabel important afli ce reprezintă un rând: o comandă, o linie de comandă, o stare a comenzii la un moment dat?
SQL
SELECT COUNT(*), COUNT(DISTINCT comanda_id) FROM istoric_comenzi;

Dacă cele două diferă, tabelul are mai multe rânduri pe comandă, iar un JOIN cu el va multiplica rezultatele.

  • Valori. Te uiți la câteva rânduri (LIMIT 20) și la distribuții: valorile distincte din coloanele de status, proporția de NULL-uri, intervalul de date (MIN, MAX). Așa afli de comenzile de test, de statusurile istorice și de datele lipsă.
  • Validare. Înainte să trimiți raportul, compari o cifră cu o sursă cunoscută: totalul vânzărilor dintr-o lună, așa cum îl știe contabilitatea. Notezi presupunerile pe care le-ai făcut și le trimiți împreună cu raportul.

Dacă există documentație sau un coleg care cunoaște schema, o jumătate de oră de discuție economisește adesea o zi de explorare.

Ce urmărește intervievatorul: Se verifică metoda de lucru într-o situație foarte frecventă pentru juniori. Răspunsul slab începe direct să scrie interogarea finală, fără să înțeleagă granularitatea datelor.

Eroarea, în practică:near "SHOW": syntax errornear ".": syntax error (.tables, .schema)

98 Mid

Ai rulat în producție un UPDATE cu WHERE greșit și ai modificat prețul a 3.000 de produse în loc de 30. Ai dat deja COMMIT. Ce faci, pas cu pas?

Răspuns scurt: Oprești orice altă modificare, anunți imediat echipa, stabilești exact ce rânduri au fost afectate și ce valori aveau, recuperezi valorile din backup sau dintr-o restaurare point-in-time într-o bază separată, le aplici înapoi controlat, apoi faci o analiză a incidentului fără vinovați.

Un model de răspuns structurat:

Stabilizare. Nu încerci reparații grăbite peste reparații. Dacă produsele sunt vizibile clienților, ceri oprirea temporară a vânzării produselor afectate sau a jobului care sincronizează prețurile către alte sisteme.

Comunicare imediată. Anunți echipa și responsabilul de incident: ce ai rulat, la ce oră, câte rânduri. Ascunderea problemei o agravează; ora exactă este esențială pentru recuperare.

  • Delimitarea impactului. Reconstitui condiția greșită și identifici rândurile afectate. Dacă există coloane de audit (modificat_la) sau un tabel de istoric, le folosești. Verifici dacă între timp au fost plasate comenzi cu prețuri greșite.

Recuperarea valorilor vechi, în ordinea preferinței:

  • tabel de audit sau istoric de prețuri alimentat de triggere;
  • restaurare point-in-time (PITR) într-o instanță separată, la un moment imediat dinaintea comenzii, din backup plus WAL (PostgreSQL) sau binlog (MySQL);
  • ultimul backup complet, dacă prețurile nu s-au schimbat legitim de atunci.

Nu restaurezi peste baza de producție, ci copiezi doar valorile necesare:

SQL
UPDATE produse p
SET pret = r.pret
FROM produse_restaurate r
WHERE r.id = p.id
  AND p.id IN (SELECT id FROM produse_afectate);
  • Verificare pe câteva produse, cu cineva din business.
  • Analiză post-incident (blameless): de ce a fost posibil? Măsuri tipice: modificări manuale doar prin scripturi revizuite, rularea lor în tranzacție cu verificarea numărului de rânduri, utilizatori fără drept de scriere pentru lucrul zilnic, tabele de audit, backup-uri PITR testate periodic.

Ce urmărește intervievatorul: Se verifică maturitatea profesională: calm, transparență și o metodă de recuperare. Intervievatorul apreciază candidații care spun imediat că anunță echipa.

99 Mid

Un coleg îți cere code review pentru o interogare SQL nouă care va rula în aplicație. Ce verifici, în ce ordine?

Răspuns scurt: Verifici întâi corectitudinea (granularitate, JOIN-uri care multiplică, NULL-uri, intervale de date, egalități la sortare), apoi securitatea (parametri, nu concatenare), performanța (EXPLAIN pe date realiste, indexuri, condiții sargable) și la final lizibilitatea și testele.

Ordinea contează: o interogare rapidă și frumoasă, dar greșită, e mai periculoasă decât una lentă.

Corectitudine:

  • ce reprezintă un rând din rezultat și dacă JOIN-urile păstrează această granularitate (fără duplicate ascunse de DISTINCT);
  • tratarea NULL-urilor în WHERE, în agregări și în NOT IN;
  • intervale de date închise la stânga și deschise la dreapta, fus orar;
  • LEFT JOIN-uri anulate de condiții în WHERE sau de JOIN-uri ulterioare;
  • ORDER BY determinist când există LIMIT sau paginare;
  • cazuri limită: client fără comenzi, tabel gol, valori egale.

Securitate:

  • valorile primite de la utilizator ajung ca parametri ($1, ?), nu prin concatenare de text;
  • nume de coloane sau direcții de sortare dinamice sunt alese dintr-o listă permisă, pentru că nu pot fi parametrizate;
  • interogarea nu întoarce coloane sensibile de care ecranul nu are nevoie.

Performanță:

  • EXPLAIN (ANALYZE) pe un volum de date apropiat de producție, nu pe 50 de rânduri de test;
  • condiții sargable și indexuri potrivite; cere indexul nou în aceeași migrare;
  • fără SELECT *; fără interogări în buclă din aplicație (N+1);
  • cât crește costul când tabelul crește de zece ori.

Mentenanță:

  • CTE-uri cu nume care spun ce calculează, aliasuri clare, formatare consecventă;
  • un comentariu pentru regulile de business neevidente („excludem comenzile de test, client_id 1”);
  • un test automat cu date mici care acoperă cazurile limită.

Feedback-ul îl formulez concret, cu un exemplu de date care ar produce rezultatul greșit, nu doar „aici poate fi o problemă”.

Ce urmărește intervievatorul: Se verifică dacă ai o listă mentală structurată și prioritizată. Răspunsul slab se oprește la stil și formatare.

100 Senior

Un raport nocturn care agregă toate comenzile din istoric durează acum 4 ore, iar dimineața încetinește aplicația. Business-ul îl vrea în continuare zilnic. Cum abordezi problema?

Răspuns scurt: Măsori întâi unde se duce timpul, apoi separi raportarea de aplicație (replică sau bază analitică) și treci de la recalcularea întregului istoric la agregare incrementală în tabele de rezumat, cu o prospețime a datelor agreată cu business-ul.

Un model de răspuns structurat:

Măsurare înainte de soluții. Cu pg_stat_statements (sau Performance Schema în MySQL) și EXPLAIN (ANALYZE, BUFFERS) află ce pas consumă timpul: scanări complete, sortări pe disc, JOIN-uri cu estimări greșite. Verifici și efectul asupra aplicației: tranzacția raportului ține lock-uri? Blochează VACUUM? Consumă tot I/O-ul?

Câștiguri rapide. Indexuri pentru filtrele raportului, mai multă memorie de lucru doar pentru sesiunea raportului (SET LOCAL work_mem), rescrierea pașilor care se calculează de mai multe ori, rularea într-o fereastră cu trafic minim.

  • Separarea sarcinilor. Raportul rulează pe o replică de citire, deci nu mai concurează cu aplicația. Atenție la replicile PostgreSQL: interogările lungi pot intra în conflict cu replicarea (hot_standby_feedback, max_standby_streaming_delay). Pentru analize mari, datele merg într-un depozit analitic (ClickHouse, BigQuery, Snowflake, sau un PostgreSQL separat).
  • Calcul incremental. Istoricul de acum un an nu se schimbă, deci nu trebuie recalculat în fiecare noapte:
SQL
INSERT INTO vanzari_zilnice (zi, produs_id, cantitate, valoare)
SELECT data_comanda::date, produs_id, SUM(cantitate), SUM(valoare)
FROM linii_comanda
WHERE data_comanda >= CURRENT_DATE - 3 AND data_comanda < CURRENT_DATE
GROUP BY 1, 2
ON CONFLICT (zi, produs_id) DO UPDATE
  SET cantitate = EXCLUDED.cantitate, valoare = EXCLUDED.valoare;

Recalculezi doar ultimele zile, care pot primi corecturi (retururi), iar raportul citește tabelul de rezumat. Partiționarea tabelelor mari pe lună ajută la încărcare și arhivare.

  • Contract cu business-ul. Cât de proaspete trebuie să fie datele, ce întârziere e acceptabilă, cine e anunțat dacă jobul eșuează. Adaugi monitorizare pe durata jobului, ca degradarea să fie văzută înainte să devină incident.

Ce urmărește intervievatorul: Se verifică gândirea de arhitectură și prioritizarea, nu doar optimizarea unei interogări. Un răspuns de nivel senior măsoară întâi și schimbă modelul de calcul, nu doar adaugă indexuri.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de SQL, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață SQL scriind cod, nu doar citind

Curs SQL: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.