Articolul 6.6 · 9 min de citit
Condiționale
Alegem exact rândurile de care avem nevoie, cu operatori de comparație, AND, OR, IN, BETWEEN și IS NULL.
Publicat în februarie 2006 · Actualizat în octombrie 2026 · Drogoreanu Catalin Gabriel
Clauza WHERE alege rândurile asupra cărora lucrează o comandă SQL: ce rânduri citește un SELECT, ce rânduri modifică un UPDATE și ce rânduri șterge un DELETE. Condiția din WHERE este verificată pentru fiecare rând, iar rândul este păstrat doar dacă rezultatul este adevărat. În exemple folosim tabelul proba cu cele cinci persoane adăugate în articolul despre INSERT:
| id | nume | prenume | data_inreg | |
|---|---|---|---|---|
| 1 | Popescu | Ion | ion.popescu@example.com | 2026-09-14 10:12:05 |
| 2 | Ionescu | Maria | maria.ionescu@example.com | 2026-09-15 18:40:31 |
| 3 | Ștefănescu | Ana | NULL | 2026-09-20 09:03:47 |
| 4 | Popescu | Andrei | andrei.popescu@example.com | 2026-10-02 21:15:10 |
| 5 | Dumitrescu | Ioana | ioana.d@example.com | 2026-10-05 07:55:22 |
Operatorii
| Operator | Semnificație | Exemplu |
|---|---|---|
= | egal | id = 3 |
<> sau != | diferit | nume <> 'Popescu' |
<, > | mai mic, mai mare | id > 3 |
<=, >= | mai mic sau egal, mai mare sau egal | data_inreg >= '2026-10-01' |
BETWEEN … AND … | în interval, cu tot cu capete | id BETWEEN 2 AND 4 |
NOT BETWEEN | în afara intervalului | id NOT BETWEEN 2 AND 4 |
IN (…) | egal cu una dintre valorile din listă | nume IN ('Popescu', 'Ionescu') |
NOT IN (…) | diferit de toate valorile din listă | id NOT IN (1, 2) |
IS NULL | nu are valoare | email IS NULL |
IS NOT NULL | are o valoare | email IS NOT NULL |
LIKE, NOT LIKE | potrivire după un model de text | nume LIKE 'Pop%' (vezi LIKE) |
AND | ambele condiții sunt adevărate | nume = 'Popescu' AND id > 1 |
OR | cel puțin una dintre condiții este adevărată | id = 1 OR id = 5 |
NOT | neagă condiția care urmează | NOT (id = 1 OR id = 5) |
Textul și datele calendaristice se scriu între apostrofuri, numerele fără. Articolul vechi prezenta și formele &&, || și ! pentru AND, OR și NOT. Ele sunt specifice MySQL, iar && și || sunt marcate ca învechite (deprecated) din MySQL 8.0.17; în alte baze de date, || înseamnă chiar lipirea a două texte. Scrie cuvintele AND, OR, NOT: sunt standard și se citesc mai ușor.
Comparații: numere, text și date
SELECT id, nume, prenume FROM proba WHERE id > 3;| id | nume | prenume |
|---|---|---|
| 4 | Popescu | Andrei |
| 5 | Dumitrescu | Ioana |
Datele calendaristice se compară în formatul 'AAAA-LL-ZZ' sau 'AAAA-LL-ZZ HH:MM:SS'. Persoanele înscrise începând cu 1 octombrie 2026:
SELECT id, nume, prenume, data_inreg FROM proba WHERE data_inreg >= '2026-10-01';| id | nume | prenume | data_inreg |
|---|---|---|---|
| 4 | Popescu | Andrei | 2026-10-02 21:15:10 |
| 5 | Dumitrescu | Ioana | 2026-10-05 07:55:22 |
La text, comparația ține cont de colația coloanei. Cu utf8mb4_unicode_ci (ci = case insensitive), literele mari și mici sunt egale, deci WHERE nume = 'popescu' găsește și „Popescu”. Această colație ignoră și diacriticele: WHERE nume = 'Stefanescu' găsește „Ștefănescu”. De cele mai multe ori este exact ce vrei la o căutare. Dacă ai nevoie de o comparație exactă, literă cu literă, schimbă colația doar pentru acea comparație: WHERE nume COLLATE utf8mb4_bin = 'Popescu'.
AND, OR și parantezele
AND cere ca ambele condiții să fie adevărate, OR cere cel puțin una. Persoanele cu numele Popescu înscrise în octombrie:
SELECT id, nume, prenume, data_inreg FROM proba
WHERE nume = 'Popescu' AND data_inreg >= '2026-10-01';| id | nume | prenume | data_inreg |
|---|---|---|---|
| 4 | Popescu | Andrei | 2026-10-02 21:15:10 |
Atenție când combini AND cu OR: AND are prioritate, la fel ca înmulțirea față de adunare. Dacă vrei persoanele cu numele Popescu sau Ionescu înscrise în octombrie și scrii:
SELECT id, nume, prenume, data_inreg FROM proba
WHERE nume = 'Popescu' OR nume = 'Ionescu' AND data_inreg >= '2026-10-01';| id | nume | prenume | data_inreg |
|---|---|---|---|
| 1 | Popescu | Ion | 2026-09-14 10:12:05 |
| 4 | Popescu | Andrei | 2026-10-02 21:15:10 |
serverul citește condiția ca nume = 'Popescu' OR (nume = 'Ionescu' AND data_inreg >= '2026-10-01') și returnează toți cei cu numele Popescu, inclusiv Ion, înscris în septembrie. Cu paranteze, condiția spune exact ce ai vrut:
SELECT id, nume, prenume, data_inreg FROM proba
WHERE (nume = 'Popescu' OR nume = 'Ionescu') AND data_inreg >= '2026-10-01';| id | nume | prenume | data_inreg |
|---|---|---|---|
| 4 | Popescu | Andrei | 2026-10-02 21:15:10 |
Regula practică: când apar și AND, și OR, pune paranteze, chiar dacă ordinea implicită ți-ar da rezultatul corect. Codul devine mai clar pentru oricine îl citește.
IN și NOT IN
O serie de condiții OR pe aceeași coloană se scrie mai scurt cu IN. Interogarea de mai sus devine:
SELECT id, nume, prenume FROM proba
WHERE nume IN ('Popescu', 'Ionescu') AND data_inreg >= '2026-10-01';Fără prima condiție ai obține toate persoanele cu cele două nume (1, 2 și 4). NOT IN le păstrează pe celelalte:
SELECT id, nume, prenume FROM proba WHERE nume NOT IN ('Popescu', 'Ionescu');| id | nume | prenume |
|---|---|---|
| 3 | Ștefănescu | Ana |
| 5 | Dumitrescu | Ioana |
BETWEEN și intervalele de date
BETWEEN a AND b înseamnă >= a AND <= b, deci include ambele capete:
SELECT id, nume, prenume FROM proba WHERE id BETWEEN 2 AND 4;| id | nume | prenume |
|---|---|---|
| 2 | Ionescu | Maria |
| 3 | Ștefănescu | Ana |
| 4 | Popescu | Andrei |
La coloanele DATETIME, BETWEEN are o capcană. Vrei persoanele înscrise între 14 și 20 septembrie:
SELECT id, nume, prenume, data_inreg FROM proba
WHERE data_inreg BETWEEN '2026-09-14' AND '2026-09-20';| id | nume | prenume | data_inreg |
|---|---|---|---|
| 1 | Popescu | Ion | 2026-09-14 10:12:05 |
| 2 | Ionescu | Maria | 2026-09-15 18:40:31 |
Ana Ștefănescu, înscrisă pe 20 septembrie la ora 09:03, lipsește. O dată fără oră înseamnă începutul zilei, deci capătul intervalului este '2026-09-20 00:00:00'. Pentru intervale de zile, folosește o condiție „mai mare sau egal cu prima zi” și „mai mic decât ziua de după ultima”:
SELECT id, nume, prenume, data_inreg FROM proba
WHERE data_inreg >= '2026-09-14' AND data_inreg < '2026-09-21';| id | nume | prenume | data_inreg |
|---|---|---|---|
| 1 | Popescu | Ion | 2026-09-14 10:12:05 |
| 2 | Ionescu | Maria | 2026-09-15 18:40:31 |
| 3 | Ștefănescu | Ana | 2026-09-20 09:03:47 |
Tot așa se scriu și condițiile pe o lună sau pe un an întreg: data_inreg >= '2026-01-01' AND data_inreg < '2027-01-01'. Forma YEAR(data_inreg) = 2026 dă același rezultat, dar când aplici o funcție asupra coloanei, serverul nu mai poate folosi un eventual index pe acea coloană și trebuie să verifice fiecare rând.
NULL: IS NULL și IS NOT NULL
NULL înseamnă „valoare necunoscută”, iar orice comparație obișnuită cu ea dă tot NULL, adică nici adevărat, nici fals. De aceea WHERE email = NULL nu găsește niciodată nimic. Se scrie:
SELECT id, nume, prenume FROM proba WHERE email IS NULL;| id | nume | prenume |
|---|---|---|
| 3 | Ștefănescu | Ana |
Același lucru are o consecință mai puțin evidentă: un rând cu NULL nu trece nici de condiția „diferit de”.
SELECT id, nume, prenume, email FROM proba WHERE email <> 'ion.popescu@example.com';| id | nume | prenume | |
|---|---|---|---|
| 2 | Ionescu | Maria | maria.ionescu@example.com |
| 4 | Popescu | Andrei | andrei.popescu@example.com |
| 5 | Dumitrescu | Ioana | ioana.d@example.com |
Ana Ștefănescu nu apare, deși nu are adresa lui Ion. Dacă vrei să o incluzi, spune explicit: WHERE email <> 'ion.popescu@example.com' OR email IS NULL. Aceeași regulă se aplică la NOT IN și NOT LIKE. MySQL are și operatorul <=>, o egalitate care tratează NULL ca pe o valoare obișnuită (NULL <=> NULL este adevărat).
Condiții în PHP, cu interogări pregătite
Exemplul din articolul vechi caută o persoană după nume și prenume. Căutarea doar citește date, așa că formularul folosește metoda GET:
<form action="where1.php" method="get">
<p><label for="nume">Nume:</label>
<input type="text" id="nume" name="nume" maxlength="50" required></p>
<p><label for="prenume">Prenume:</label>
<input type="text" id="prenume" name="prenume" maxlength="50" required></p>
<p><button type="submit">Caută</button></p>
</form><?php
// where1.php
require 'conexiune.php';
$nume = isset($_GET['nume']) ? trim($_GET['nume']) : '';
$prenume = isset($_GET['prenume']) ? trim($_GET['prenume']) : '';
$stmt = mysqli_prepare($conexiune,
'SELECT id, nume, prenume, email
FROM proba
WHERE nume = ? AND prenume = ? AND sters = 0');
mysqli_stmt_bind_param($stmt, 'ss', $nume, $prenume);
mysqli_stmt_execute($stmt);
$rezultat = mysqli_stmt_get_result($stmt);
if ($rand = mysqli_fetch_assoc($rezultat)) {
echo '<p>' . htmlspecialchars($rand['prenume'] . ' ' . $rand['nume'])
. ' are numărul de înscriere ' . (int) $rand['id'] . '.</p>';
} else {
echo '<p>Persoana nu a fost găsită.</p>';
}
mysqli_stmt_close($stmt);Condițiile (nume = ? AND prenume = ?) se scriu în comanda SQL, iar valorile venite de la vizitator iau locul semnelor de întrebare, prin mysqli_stmt_bind_param(), exact ca la INSERT și SELECT. Pentru where1.php?nume=popescu&prenume=andrei scriptul afișează „Andrei Popescu are numărul de înscriere 4.” Condiția sters = 0 ascunde rândurile șterse logic (vezi DELETE).
Filtre opționale
Un formular de filtrare are de obicei câmpuri pe care vizitatorul le poate lăsa goale. Condiția se construiește atunci din bucăți: pentru fiecare câmp completat adaugi o condiție cu ? și valoarea corespunzătoare.
<form action="filtrare.php" method="get">
<p><label for="nume">Nume:</label>
<input type="text" id="nume" name="nume" maxlength="50"></p>
<p><label for="de_la">Înscriși începând cu:</label>
<input type="date" id="de_la" name="de_la"></p>
<p><label><input type="checkbox" name="cu_email" value="1"> doar cei cu adresă de e-mail</label></p>
<p><button type="submit">Filtrează</button></p>
</form><?php
// filtrare.php
require 'conexiune.php';
$conditii = array('sters = 0');
$tipuri = '';
$valori = array();
$nume = isset($_GET['nume']) ? trim($_GET['nume']) : '';
if ($nume !== '') {
$conditii[] = 'nume = ?';
$tipuri .= 's';
$valori[] = $nume;
}
$de_la = isset($_GET['de_la']) ? $_GET['de_la'] : ''; // AAAA-LL-ZZ
if (preg_match('/^(\d{4})-(\d{2})-(\d{2})$/', $de_la, $p) && checkdate($p[2], $p[3], $p[1])) {
$conditii[] = 'data_inreg >= ?';
$tipuri .= 's';
$valori[] = $de_la;
}
if (!empty($_GET['cu_email'])) {
$conditii[] = 'email IS NOT NULL';
}
$sql = 'SELECT id, nume, prenume, email FROM proba WHERE '
. implode(' AND ', $conditii)
. ' ORDER BY nume, prenume LIMIT 100';
$stmt = mysqli_prepare($conexiune, $sql);
if ($valori) {
mysqli_stmt_bind_param($stmt, $tipuri, ...$valori); // ... necesită PHP 5.6+
}
mysqli_stmt_execute($stmt);
$rezultat = mysqli_stmt_get_result($stmt);
echo '<ul>';
while ($rand = mysqli_fetch_assoc($rezultat)) {
echo '<li>' . htmlspecialchars($rand['prenume'] . ' ' . $rand['nume']) . '</li>';
}
echo '</ul>';
mysqli_stmt_close($stmt);Pentru filtrare.php?nume=&de_la=2026-09-15&cu_email=1, comanda trimisă serverului este:
SELECT id, nume, prenume, email FROM proba
WHERE sters = 0 AND data_inreg >= ? AND email IS NOT NULL
ORDER BY nume, prenume LIMIT 100iar pagina afișează Ioana Dumitrescu, Maria Ionescu și Andrei Popescu. Câteva observații:
- în textul comenzii ajung doar bucăți scrise de tine în cod (
'nume = ?','email IS NOT NULL'); valorile vizitatorului merg numai prinmysqli_stmt_bind_param(). Nu construi niciodată numele coloanelor sau operatorii din ce trimite formularul; - câmpul
<input type="date">trimite data în formatulAAAA-LL-ZZ, dar pe server data trebuie verificată oricum:preg_match()verifică forma, iarcheckdate()verifică dacă ziua există; - operatorul
...(din PHP 5.6) desface tabloul$valoriîn parametri separați, oricâte valori ar avea. Fără nicio valoare,mysqli_stmt_bind_param()nu se apelează; LIMIT 100pune o limită rezonabilă, ca un filtru gol să nu încarce un tabel întreg în pagină.
IN cu o listă de valori venită din formular
Dacă vizitatorul bifează mai multe persoane (câmpuri <input type="checkbox" name="id[]" value="…">), lista de valori pentru IN are lungime variabilă. Generezi câte un semn de întrebare pentru fiecare valoare:
<?php
require 'conexiune.php';
$iduri = isset($_GET['id']) ? (array) $_GET['id'] : array();
$iduri = array_values(array_unique(array_filter(array_map('intval', $iduri), function ($n) {
return $n > 0;
})));
if ($iduri) {
$semne = implode(', ', array_fill(0, count($iduri), '?')); // "?, ?, ?"
$stmt = mysqli_prepare($conexiune,
"SELECT id, nume, prenume FROM proba WHERE id IN ($semne) AND sters = 0");
mysqli_stmt_bind_param($stmt, str_repeat('i', count($iduri)), ...$iduri);
mysqli_stmt_execute($stmt);
$rezultat = mysqli_stmt_get_result($stmt);
while ($rand = mysqli_fetch_assoc($rezultat)) {
echo htmlspecialchars($rand['prenume'] . ' ' . $rand['nume']) . '<br>';
}
mysqli_stmt_close($stmt);
}Valorile sunt transformate în numere întregi pozitive, iar cele duplicate eliminate; în comandă ajung doar semnele de întrebare, nu valorile. Pentru ?id[]=2&id[]=5 se afișează Maria Ionescu și Ioana Dumitrescu.
Condițiile din acest articol funcționează la fel în UPDATE și DELETE, unde o condiție greșită are urmări mult mai grave decât o listă greșită. Pentru legarea a două tabele printr-o condiție, vezi secțiunea despre JOIN din articolul SELECT.
Următorul pas: LIKE și NOT LIKE, căutarea după o parte din text.