LA COMMANDE SQL WHERE

L’utilité de la clause WHERE

La clause WHERE spécifie une ou plusieurs lignes à sélectionner grâce à la condition lors de la récupération des données. Une requête qui utilise SELECT contenant la clause WHERE permet de renvoyer la valeur d’une ligne de la base de données qui remplit la condition. La requête peut renvoyer plusieurs lignes de plusieurs tables  dans le cas de jointures de tables avec des conditions à remplir.

La clause WHERE a pour rôle de filtrer les tuples ou les lignes, c’est-à-dire spécifier la sélection de certaines lignes.

Elle est utilisée avec des commandes comme SELECT, DELETE  et UPDATE.

La syntaxe avec la commande SELECT est donc :

SELECT  nom_attribut   FROM nom_table  WHERE  nom_attribut  condition.

Cette condition peut être une comparaison d’expression ou un opérateur logique (combinaison d’expression).

En ce qui concerner les comparaisons d’expression, on a :

<, >, =, !=, < =, >=, LIKE, IN, NOT IN, NULL, NOT NULL, BETWEEN.

Pour les opérateurs logiques  (combinaisons d’expression), on a: «et »,  « ou », qui signifient  (AND, OR).

Remarque : On peut classer les comparaisons d’expression (<, >, =, !=, < =, >=, LIKE, IN, NOT IN, IS NULL, IS NOT NULL, BETWEEN) en plusieurs types.

  • Les comparaisons d’expression de type arithmétique (<, >, =, !=, <=, >=) ;
  • Les comparaisons d’expression de type texte (LIKE) ;
  • Les comparaisons d’expression de type ensemble de valeur (IN, NOT IN) ;
  • Les comparaisons d’expression de type intervalle (BETWEEN) ;
  • Les comparaisons d’expression de type test de nullité (IS NULL, IS NOT NULL) ;

Tableau de comparaisons d’expression de :

Comparaison d’expressionSignification
Inférieur
Supérieur
=Égale
!=Différent
<=Inférieur ou égale
>=Supérieur ou égale
LIKEComme
INEnsemble de valeurs
NOT INHors ensemble de valeurs
IS NULLValeur nulle
IS NOT NULLValeur non nulle
BETWEENValeur comprise dans l’intervalle

 

Nous allons utiliser chacun de ces exemples pour former des requêtes et exploiter notre base de données Person.

On commence  avec des comparaisons d’expression et en suite on termine avec les opérateurs logiques.

Voici notre table de nom employee.

Table  employee     

id_employeelast_namefirst_namesalaryid_customer
 1JonesSmith12001
 2JackHarry60303
3WilliamJames70052
4MichaelOliver35001

 

 

 

 

 

  • La clause WHERE avec des comparaisons d’expression

                        (<, >, =, !=, < =, >=, LIKE, IN, NOT IN, NULL, NOT NULL, BETWEEN).

Pour les comparaisons d’expression simples (<, >, =, !=, <=, >=), on va juste donner des exemples à suivre par contre les autres seront plus détailler.

La syntaxe générale pour ces comparaisons d’expression simple est la suivante:

SELECT nom_attribut (s) FROM nom_table + WHERE nom_attribut  Expression_simple  valeur ;

Exemples :

WHERE avec l’expression <

On affiche la liste des noms, prénoms et salaire des personnes dont le salaire est inférieur à 7000.

SELECT last_name, first_name, salary FROM employee WHERE salary < 7000 ;

Resultat :

last_namefirst_namesalary
JonesSmith1200
JackHarry6030
MichaelOliver3500

 

 

 

 

WHERE avec l’expression > 

 On affiche la liste des noms, prénoms et salaire des employés dont le salaire est supérieur à 3000.

SELECT last_name, first_name, salary FROM employee WHERE salary >  3000;

Résultat :

last_namefirst_namesalary
JackHarry6030
WilliamJames7005
MichaelOliver3500

 

WHERE avec l’expression !=

On affiche la liste des noms, prenoms et salaire des employés dont le dont le numéro du client est différent de 3.

SELECT last_name, first_name, salary FROM employee WHERE id_customer != 3;

Résultat :

last_namefirst_namesalary
JonesSmith1200
WilliamJames7005
MichaelOliver3500

 

 

 

WHERE avec l’expression <=

On affiche les prénoms et salaire des employés qui gagnent moins de 3000.

SELECT first_name, salary FROM employee WHERE salary <= 3000 ;

Résultat :

first_namesalary
Smith1200

 

 

 

WHERE avec l’expression =  et >=

On affiche la liste des noms, prénoms des employés dont le salaire est supérieur ou égal à 3000.

SELECT last_name, first_name  FROM employee WHERE salary >=3000 ;

Résultat :

last_namefirst_name
JackHarry
WilliamJames
MichaelOliver

 

 

 

WHERE avec l’expression LIKE 

La clause WHERE avec l’expression LIKE permet de chercher une chaine (texte) de caractères spécifique.

L’expression LIKE est très utilisée en ce qui concerne les recherches dans les systèmes de gestion de bases de données. On peut utiliser LIKE pour

  • Renvoyer toutes les valeurs des lignes ayant un caractère en commun (exemple qui commence par la lettre V) ;
  • Renvoyer une valeur de certains caractères spécifiques dans un SGBD (exemple des mots)

La syntaxe donne :

SELECT nom_attribut (s) FROM  nom_table  WHERE  condition  LIKE  valeur ;

Pour chercher les chaines de caractères, LIKE utilise  deux symboles :

% : Le symbole pourcentage (%) représente 0, un, ou plusieurs caractères.

_ : Le symbole de soulignement ( _ ) représente un seul caractère.

LIKE ‘Smith’ ;Affiche  la valeur Smith
LIKE ‘H%’ ;Affiche toutes les chaines qui commencent par H
LIKE ‘%H’ ;Affiche toutes les chaines qui se terminent par H
LIKE ‘%H%’ ;Affiche toutes les chaines qui contiennent H
LIKE ‘H%G’ ;Affiche toutes les chaines qui commencent par H et se terminent par G
LIKE ‘_H%’ ;Affiche toutes les chaines qui contiennent H en seconde position
LIKE ‘H_t’ ;Affiche toutes les chaines de 3 caractères commençant par H et se terminant par t

 

Exemples :

LIKE ‘Smith’ ;

On affiche le nom et prénom et le salaire de l’employé de nom Smith.

SELECT last_name, first_name, salary  FROM employee WHERE first_name LIKE ‘Smith’ ;

Résultat :

last_namefirst_namesalary
JonesSmith1200

 

LIKE ‘H%’ ;  

On affiche tous les noms, prénoms, pays des employés dont les noms  commencent par « J »

SELECT last_name, first_name FROM employee WHERE last_name LIKE ‘J%’ ;

Résultat :

last_namefirst_name
JonesSmith
JackHarry

 

LIKE ‘%H’ ;

On affiche tous les noms, prénoms et salaire des personnes dont les noms se terminent par « m ».

SELECT last_name, first_name, salary FROM employee WHERE last_name LIKE ‘%m’ ;

Résultat :

last_namefirst_namesalary
WlliamJames7005

 

LIKE ‘%H%’ ;

On affiche toutes les personnes dont les prénoms contiennent « i ».

SELECT first_name FROM employee WHERE first_name LIKE ‘%i%’ ;

Résultat :

first_name
Smith
Oliver

 

LIKE ‘H%G’ ;

On affiche les prénoms des personnes dont les prénoms commencent par «h » et se terminent par « y ».

SELECT first_name FROM employee WHERE first_name LIKE ‘h%y’ ;

Résultat :

first_name
Harry

 

LIKE ‘_H%’ ;

On affiche les prénoms et salaires des personnes dont les le deuxième caractère des prénoms commencent par «a ».

SELECT first_name, salary FROM employee WHERE first_name LIKE ‘_a%’ ;

Résultat :

first_namesalary
Harry6030
James7005

 

LIKE ‘H_t’ ;

On affiche les noms et prénoms  des personnes dont les noms sont composés de trois caractères et commencent par « j » et se termine par « a ».

SELECT last_name, first_name FROM employee WHERE first_name LIKE ‘j_a’ ;

Résultat :

Pas de résultat.

WHERE avec l’expression IN

La comparaison d’expression IN avec la clause WHERE permet de vérifier si un attribut (colonne) a une ou plusieurs valeurs choisies parmi une liste de valeurs.

La clause WHERE avec l’expression IN permet  d’afficher certaines valeurs spécifiques parmi un ensemble de valeurs.

La syntaxe donne :

SELECT nom_attribut (s)  FROM nom_table  WHERE nom_attribut  IN  valeurs;

On affiche la liste des noms, prénoms et salaires des employés dont les salaires sont 2000 et 7000.

SELECT last_name, first_name, salary FROM employee WHERE salary IN (3500, 7005) ;

Résultat :

Last_nameFirst_nameStudentCountry
WilliamJames7005
MichaelOliver3500

 

WHERE avec l’expression NOT IN

La comparaison d’expression NOT IN est le contraire de celle IN. NOT IN affiche les résultats contraires de ceux de l’expression IN.

La clause WHERE avec l’expression NOT IN fournit une liste de valeurs en absence d’une ou des valeurs qui ont été indexées.

La syntaxe donne :

SELECT nom_attribut (s) FROM nom_table  WHERE nom_attribut NOT IN  (valeurs) ;

On affiche la liste des noms, prénoms des employés sauf des noms comme « Jones, William et Charles).

SELECT last_name, first_name FROM employee WHERE last_name NOT IN (‘Jones’, ‘William’, ‘Charles’) ;

Résultat :

last_namefirst_name
MichaelOlivier

 

 

WHERE avec l’expression IS NULL:

La syntaxe est donc :

SELECT nom_attribut (s)  FROM nom_table  WHERE  nom_attribut  IS  NULL ;

L’expression IS NULL permet d’afficher les lignes qui ont de valeurs nulles ; autrement des lignes qui n’ont pas de valeurs.

On affiche les noms, prénom des employés qui n’ont pas des clients :

SELECT Last_name, First_name,  id_customer FROM employee WHERE id_customer IS NULL ;

Résultat :

Pas de résultat.  Ici on a voulu afficher les lignes de la colonne id_customer qui contient des valeurs nulles, autrement dit les lignes qui ne contiennent pas des valeurs. Étant donné que notre table contient toutes des valeurs, il n’y aura pas de résultat en retour.

 

WHERE avec l’expression IS NOT NULL

La syntaxe est donc :

SELECT nom_attribut (s)  FROM nom_table WHERE  nom_attribut IS NOT NULL ;

L’expression IS NOT NULL  donne des resultats contraires à celle d’IS NULL.

Elle permet d’afficher une colonne où les valeurs ne sont pas nulles.

La clause WHERE avec l’expression IS NOT NULL retour retournent uniquement les lignes qui contiennent des valeurs.

Nous pouvons afficher les lignes de la colonne id_custumer de notre table employee qui contient des valeurs par exemple.

On affiche les noms, prénoms des employés qui ont des clients.

SELECT last_name, first_name, id_customer FROM employee WHERE id_customer IS NOT NULL ;

Résultat :

last_namefirst_nameid_customer
JonesSmith1
JackHarry3
WilliamJames2
MichaelOliver1

 

 

 

 

On obtient la liste complète car les employés enregistrées dans de notre base de données ont tous des clients.

WHERE avec l’expression BETWEEN

 La syntaxe est donc :

SELECT nom_attribut (s) FROM nom_table WHERE nom_attribut BETWEEN Valeur1  AND Valeur2 ;

L’expression BETWEEN permet de renvoyer une ou plusieurs valeurs prises dans un intervalle. L’intervalle peut être de nature des nombres comme dans notre cas, des chaines de caractères ou des dates.

On affiche les prénoms, les salaires des employés ayant un salaire compris entre 2000 et 7000.

SELECT first_name, salary FROM employee WHERE salary BETWEEN 2000 AND 7000 ;

Résultat :

firt_namesalary
Harry6030
Oliver3500

 

 

 

  • La clause WHERE avec des comparaisons d’expression

 

WHERE avec opérateur logiques : AND

La syntaxe est donc :

SELECT nom_attribut (s)  FROM nom_table  WHERE condition1 AND condition2

L’opérateur logique AND permet de vérifier  deux conditions. Si les deux conditions (condition1 et condition2) ne sont pas remplies, il n’y aura pas de résultats. Les deux conditions doivent forcement être remplies pour que l’on obtient de réponse.

On affiche les noms, prénoms et numeros des employés le salaire est 3500.

SELECT last_name, first_name, id_employee FROM employee WHERE salary=3500 ;

Résultat :

last_namefirst_nameId_employee
MichaelOliver4

 

 

 

 WHERE avec opérateur logique OR

La syntaxe est donc :

SELECT nom_attribut (s)] FROM nom_table  WHERE  condition1  OR  condition2

L’opérateur logique OR permet de vérifier  deux conditions.

  • Si les deux conditions (condition1 et condition2) ne sont pas remplies, il n’y aura pas de résultats.
  • Si une seule parmi les deux est remplie, il y aura de résultat.
  • Si les deux conditions aussi sont toutes remplies, il y aura de résultat mais il va afficher la condition qui est remplie en premier seulement.

On affiche les noms, prénom numéros employés des employés dont le nom est Jones ou Jules.

SELECT last_name, first_name, id_employee FROM employee WHERE last_name= ‘Jones’ OR ‘Jules’ ;

Résultat :

last_namefirst_nameId_employee
JonesSmith1

 

 

 

Conclusion :

Les commandes SELECT, DELETE et UPDATE ont des effets collectifs respectivement comme la sélection, la suppression et la mise à jour d’un ensemble de lignes ou de colonnes d’une table. Pour annuler ces effets sur le collectif et les spécifier sur certaines  valeurs bien précises, on utilise WHERE.