Utiliser des critères de sélection pour sélectionner des données dans une table MySQL

Télécharger le PDF du cours

Dans la leçon précédente, nous avons appris à sélectionner des données dans une table grâce à l’instruction SQL SELECT… FROM.

Un des grands intérêts des bases de données est que les données sont organisées et classées. Lorsque nous sélectionnons des données dans nos bases de données, nous voudrons souvent tirer avantage de cette organisation et ainsi sélectionner des données précises.

Les critères de sélection vont nous aider à créer des requêtes SQL de sélection puissantes et précises. Dans cette leçon, nous allons nous intéresser aux critères de sélection SQL suivants :

WHERE ;
AND, OR et NOT ;
LIMIT ;
LIKE et les jokers (wildcards) ;
IN et BETWEEN ;
EXISTS ;
ANY et ALL.

La clause SQL WHERE

Nous connaissons déjà cette clause et je ne vais donc pas beaucoup m’étendre sur son fonctionnement.

La clause WHERE va nous permettre de rajouter un conditionnement à une requête SQL. On va ainsi pouvoir ne sélectionner que des valeurs égales, supérieures ou inférieures à une certaine valeur.

Notez que la clause WHERE peut être utilisée dans des requêtes de sélection SQL aussi bien que dans des requêtes de suppression, de mises à jour, etc.

Dans notre table « users » contenant 4 entrées, nous allons par exemple pouvoir sélectionner tous les utilisateurs dont le prénom est « Pierre ».

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        //On sélectionne tous les users dont le nom = Pierre
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE prenom = 'Pierre'
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de la clause SQL where

Les opérateurs SQL AND, OR et NOT

Nous allons pouvoir étendre les possibilités de la clause SQL WHERE grâce aux opérateurs AND, OR et NOT.

L’opérateur AND va nous permettre de rajouter des conditions supplémentaires. Seuls les résultats satisfaisant à toutes les conditions seront sélectionnés. Notez que vous pouvez utiliser autant de AND que vous souhaitez dans une requête SQL.

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        /*On sélectionne tous les users dont le prenom = Pierre et
         *le nom = Giraud*/
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE prenom = 'Pierre' AND nom = 'Giraud'
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de l'opérateur SQL and

L’opérateur SQL OR va lui nous permettre d’élargir notre condition de base en rajoutant d’autres conditions. A la différence de AND, tous les résultats satisfaisants au moins l’une des conditions mentionnées seront affichés.

Nous allons également pouvoir ajouter autant de OR qu’on le souhaite dans une requête SQL.

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        /*On sélectionne tous les users dont le prenom = Pierre ou
         *le nom = Joly*/
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE prenom = 'Pierre' OR nom = 'Joly' 
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de l'opérateur SQL or

Finalement, l’opérateur SQL NOT va nous permettre d’afficher tous les résultats ne satisfaisant pas une condition. On peut par exemple afficher tous les utilisateurs dont le prénom n’est pas « Pierre ».

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        //On sélectionne tous les users dont le prenom n'est pas Pierre
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE NOT prenom = 'Pierre'
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de l'opérateur SQL not

Notez que nous allons également pouvoir utiliser plusieurs opérateurs ensemble dans une requête SQL.

Nous allons ainsi par exemple pouvoir sélectionner tous les utilisateurs de notre table dont l’id est supérieur à 1 et dont le prénom n’est pas « Pierre » ou dont le nom est « Giraud ».

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        /*Sélectionne tous les users dont l'id est spérieur à 1
         *ET dont le prénom n'est pas pierre OU dont le nom est Giraud*/
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE id > 1 AND NOT prenom = 'Pierre' OR nom = 'Giraud'
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de where and or et not en SQL

Ici, faites bien attention à l’ordre des opérations et à bien écrire / lire votre requête afin qu’elle affiche les résultats souhaités.

Notre requête va sélectionner tous les utilisateurs dont l’id est supérieur à 1 ET dont SOIT le prénom n’est pas « Pierre », SOIT le nom est « Giraud ». C’est pour cela que le résultat « Pierre Giraud » est renvoyé.

La clause LIMIT

La clause SQL LIMIT est généralement utilisée pour limiter le nombre de résultats retournés.

En effet, cette clause va nous permettre d’indiquer un nombre de résultats maximum à retourner. Cela peut être utile pour optimiser la performance de votre script dans le cas où un très grand nombre de résultats seraient retournés.

Par défaut, la clause LIMIT va sélectionner des résultats dans l’ordre des entrées de votre table. Cependant, on va pouvoir spécifier à partir de quelle entrée on souhaite commencer à récupérer des résultats grâce au mot OFFSET.

On peut ainsi par exemple récupérer deux résultats dans notre table « users » à partir de la deuxième entrée (comprenez bien « la deuxième entrée satisfaisant notre condition s’il y en a une ») de cette manière :

Notez que le premier résultat dans l’ordre des entrées de la table satisfaisant notre requête correspond à OFFSET 0. Pour commencer à récupérer des résultats à partir du deuxième résultat dans l’ordre des entrées de la table satisfaisant notre requête il faudra donc préciser OFFSET 1 et etc.

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        /*Sélectionne 2 résultats à partir de la 2è entrée de la table*/
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          LIMIT 2 OFFSET 1
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de la clause SQL limit

L’opérateur SQL LIKE et les jokers (wildcards)

Nous allons utiliser l’opérateur SQL LIKE conjointement avec une clause WHERE afin de chercher un schéma spécifique dans une colonne.

Nous allons également généralement utiliser l’opérateur LIKE avec des jokers ou wildcards en anglais.

Les jokers sont des caractères de substitution qui vont nous permettre de rechercher un schéma précis. Vous pouvez comparer les wildcards aux différents caractères que nous utilisions dans nos expressions régulières plus tôt dans ce cours.

Il existe deux jokers que nous allons pouvoir utiliser avec LIKE :

Le signe % qui va représenter zéro, un o plusieurs caractères ;
Le signe _ qui va représenter un caractère exactement.

Nous allons bien entendu pouvoir combiner les jokers entre eux dans nos requêtes.

Pour bien comprendre l’utilisation de LIKE et des jokers, voici quelques exemples de parties de requêtes ainsi que leur signification :

Requête	Signification
WHERE users LIKE ‘p%’	Cherche les valeurs qui commencent par un « p »
WHERE users LIKE ‘%e’	Cherche les valeurs qui se terminent par « e »
WHERE users LIKE ‘%e%’	Cherche les valeurs qui possèdent un « e »
WHERE users LIKE ‘p%e’	Cherche les valeurs qui commencent par « p » et se terminent par « e »
WHERE users LIKE ‘p____e’	Cherche des valeurs de 6 caractères exactement qui commencent par « p » et se terminent par « e »
WHERE users LIKE ‘p_%’	Cherche des valeurs de 2 caractères ou plus qui commencent par « p »

On va ainsi par exemple pouvoir ne sélectionner que les utilisateurs dont le nom contient un « r » dans notre table « users » :

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        //Cherche tous les noms contenant un "r"
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE nom LIKE '%r%'
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de l'opérateur SQL like

Les opérateurs SQL IN et BETWEEN

L’opérateur SQL IN va s’utiliser conjointement avec une clause WHERE. Cet opérateur va nous permettre de préciser une liste de données parmi lesquelles nous devons sélectionner nos données.

Utiliser IN revient finalement à utiliser plusieurs conditions OR mais avec une notation allégée et plus rapide.

On va ainsi par exemple pouvoir facilement sélectionner tous les utilisateurs dont le prénom est « Pierre » ou « Victor » dans notre table « users ».

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        //Cherche tous les utilisateurs dont le prénom est Pierre ou Victor
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE prenom IN ('Pierre', 'Victor')
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de l'opérateur SQL in

Notez qu’on va bien évidemment pouvoir combiner les différents opérateurs SQL entre eux et ainsi par exemple pouvoir utiliser IN avec NOT pour exclure certaines valeurs spécifiques de notre sélection.

L’opérateur SQL BETWEEN va lui nous permettre de sélectionner ou d’exclure d’une sélection des données dans un certain intervalle. Notez que cet opérateur est inclusif (la première et la dernière valeur font partie de l’intervalle).

Les valeurs d’intervalle peuvent être des nombres, des textes ou des dates.

On va par exemple pouvoir sélectionner tous les utilisateurs dont le nom se trouve entre « F » et « Joly », ces deux valeurs étant donc incluses dans notre sélection.

<!DOCTYPE html>
<html>
  <head>
    <title>Cours PHP / MySQL</title>
    <meta charset='utf-8'>
  </head>
  <body>
    <h1>Bases de données MySQL</h1>  
    <?php
      $servname = "localhost"; $dbname = "cours"; $user = "root"; $pass = "root";
      
      try{
        $dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
        $dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        //Sélectionne les utilisateurs dont le nom se trouve entre F et Joly
        $sth = $dbco->prepare("
          SELECT prenom, nom, mail
          FROM users
          WHERE nom BETWEEN 'F' AND 'Joly'
        ");
        $sth-> execute();
        
        $resultat = $sth->fetchAll(PDO::FETCH_ASSOC);
        
        echo '<pre>';
        print_r($resultat);
        echo '</pre>';
      }
            
      catch(PDOException $e){
        echo "Erreur : " . $e->getMessage();
      }
    ?>
  </body>
</html>

Présentation et exemple d'utilisation de l'opérateur SQL between