Instruction SQL WHERE Présentation
- La clause WHERE est utilisée pour inclure une condition lors de la récupération des données des tables.
- Lorsque vous devez spécifier une condition qui doit être respectée pendant que les données sont extraites des tables, dans ce cas la clause where est utilisée.
- La clause Where est utilisée pour filtrer les enregistrements que vous récupérez à partir de l'instruction select afin d'obtenir un sous-ensemble de données plus petit.
- La clause Where est également utilisée pour effectuer des opérations de jointure.
- La clause Where ne renvoie que les enregistrements de la table qui répondent à la condition spécifiée.
- Cette clause n'est pas seulement utilisée avec la requête SELECT, mais peut également être utilisée avec les requêtes UPDATE et DELETE.
- Utilisation de la clause where avec la requête SELECT
- Clause Where avec requête SELECT pour récupérer toutes les colonnes d'une table.
- Pour récupérer tous les enregistrements d'une table, astérisque Le symbole (*) est utilisé.
Syntaxe :
SELECT *FROM TABLE_NAME WHERE condition;
Exemple :
Tout d'abord, nous allons créer une base de données avec le nom "bookdb". Ensuite, dans cette base de données, nous allons créer une table "livre" et insérer des enregistrements dans la table. Nous considérerons la même base de données et également la même table pour les exemples suivants.
Maintenant, nous allons appliquer la clause where avec la requête SELECT pour récupérer toutes les colonnes de la table où le prix du livre est égal à 200.
mysql> CREATE DATABASE bookdb;
Query OK, 1 row affected (0.07 sec)
mysql> USE bookdb;
Database changed
mysql> CREATE TABLE book(Book_ID INT NOT NULL AUTO_INCREMENT, Book_Name VARCHAR(100) NOT NULL, Book_Author VARCHAR(40) NOT NULL, Book_Price INT NOT NULL, PRIMARY KEY(Book_ID));
Query OK, 0 rows affected (0.24 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("Learn MySQL","Abdul S", 180);
Query OK, 1 row affected (0.07 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("MySQL Explained","Andrew Comeau", 150);
Query OK, 1 row affected (0.04 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("MySQL Cookbook","Paul DuBois", 250);
Query OK, 1 row affected (0.08 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("murach's MySQL","Joel Murach", 200);
Query OK, 1 row affected (0.07 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("Head First SQL","Lynn Beighley", 300);
Query OK, 1 row affected (0.07 sec)
mysql> SELECT *FROM book;
+---------+-----------------------------+--------------------+------------+
| Book_ID | Book_Name | Book_Author | Book_Price |
+---------+-----------------------------+--------------------+------------+
| 1 | Learn MySQL | Abdul S | 180 |
| 2 | MySQL Explained | Andrew Comeau | 150 |
| 3 | Database Management Systems | Raghu Ramakrishnan | 250 |
| 4 | murach's MySQL | Joel Murach | 200 |
+---------+-----------------------------+--------------------+------------+
4 rows in set (0.00 sec)
mysql> SELECT *FROM book WHERE Book_Price=200;
+---------+----------------+-------------+------------+
| Book_ID | Book_Name | Book_Author | Book_Price |
+---------+----------------+-------------+------------+
| 4 | murach's MySQL | Joel Murach | 200 |
+---------+----------------+-------------+------------+
1 row in set (0.00 sec) 
Il n'y a qu'un seul enregistrement avec Book_ID =4, dont le prix est égal à 200. Par conséquent, toutes les colonnes de cet enregistrement particulier sont affichées.
- Clause Where avec requête SELECT pour récupérer une ou plusieurs colonnes spécifiques d'une table.
- Pour récupérer des colonnes spécifiques d'une table, les noms de toutes les colonnes à récupérer doivent être spécifiés dans la requête elle-même.
- Les noms de colonne spécifiques à récupérer seront séparés par une virgule.
Syntaxe :
SELECT COLUMN_NAME1,….,COLUMN_NAMEn FROM TABLE_NAME WHERE condition;
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer des colonnes spécifiques (Book_ID, Book_Price) du livre table où le prix du livre est égal à 200.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT Book_ID,Book_Price FROM book where Book_Price=200; +---------+------------+ | Book_ID | Book_Price | +---------+------------+ | 4 | 200 | +---------+------------+ 1 row in set (0.00 sec)
Il n'y a qu'un seul enregistrement avec Book_ID =4, dont le prix est égal à 200. Par conséquent, Book_ID et Book_Price de cet enregistrement particulier sont affichés.
- Utilisation de la clause where avec la requête UPDATE
Syntaxe :
UPDATE TABLE_NAME SET column_name = newvalue WHERE column_name1 = value1;
Exemple :
Nous appliquerons la clause where avec la requête UPDATE sur la table du livre pour mettre à jour le Book_Name et le Book_Author d'un enregistrement particulier en spécifiant le Book_ID comme condition dans la clause where.
mysql> SELECT *FROM book; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | MySQL Cookbook | Paul DuBois | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------+---------------+------------+ 5 rows in set (0.00 sec) mysql> UPDATE book SET Book_name="Database Management Systems", Book_Author="Raghu Ramakrishnan" WHERE Book_ID=3; Query OK, 1 row affected (0.19 sec) Rows matched: 1 Changed: 1 Warnings: 0 mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------------------+--------------------+------------+ 5 rows in set (0.00 sec)
Il n'y a qu'un seul enregistrement avec Book_ID =3, nous avons changé le Book_name et le Book_Author de cet enregistrement. Par conséquent, le tableau mis à jour est affiché.
- Utilisation de la clause where avec la requête DELETE
Syntaxe :
DELETE FROM TABLE_NAME WHERE column_name1 = value1;
Exemple :
Nous appliquerons la clause where avec la requête DELETE sur la table du livre à
supprimez un livre avec un Book_ID particulier en spécifiant le Book_ID comme condition dans la clause where.
mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------------------+--------------------+------------+ 5 rows in set (0.00 sec) mysql> DELETE FROM book WHERE Book_ID=5; Query OK, 1 row affected (0.23 sec) mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec)
Il n'y a qu'un seul enregistrement avec Book_ID =5, nous avons supprimé cet enregistrement entier de la table des livres. Par conséquent, le tableau mis à jour est affiché.
Opérateurs avec instruction WHERE
Vous pouvez utiliser des opérateurs avec la clause where. Ces opérateurs peuvent être utilisés avec la clause where dans les requêtes SELECT, UPDATE et DELETE.
- Égal(=)
Lorsque l'opérateur égal à (=) est utilisé avec la clause where, il récupère ces enregistrements de la table lorsque la valeur du nom de colonne présente dans une table est égale à la valeur du nom de colonne spécifié dans la requête.
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer les enregistrements de la table où le prix du livre est égal à 200.
mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT *FROM book WHERE Book_Price=200; +---------+----------------+-------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+----------------+-------------+------------+ | 4 | murach's MySQL | Joel Murach | 200 | +---------+----------------+-------------+------------+ 1 row in set (0.00 sec)
Il n'y a qu'un seul enregistrement avec Book_ID =4, dont le prix est égal à 200. Par conséquent, toutes les colonnes de cet enregistrement particulier sont affichées.
- Supérieur à(>)
Lorsque l'opérateur supérieur à (>) est utilisé avec la clause Where, il récupère ces enregistrements de la table lorsque la valeur du nom de colonne présente dans une table est supérieure à la valeur du nom de colonne spécifié dans la requête.
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer les enregistrements de la table où le prix du livre est supérieur à 150.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price > 150; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 3 rows in set (0.00 sec)
Il y a trois enregistrements avec Book_ID =1, 3 et 4 dont les prix sont supérieurs à 150. Par conséquent, toutes les colonnes de ces enregistrements sont affichées.
- Moins de (<)
Lorsque l'opérateur inférieur à (<) est utilisé avec la clause where, il récupère ces enregistrements de la table lorsque la valeur du nom de colonne présente dans une table est inférieure à la valeur du nom de colonne spécifié dans la requête.
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer les enregistrements de la table où le prix du livre est inférieur à 200.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price < 200; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | +---------+-----------------+---------------+------------+ 2 rows in set (0.00 sec)
Il y a deux enregistrements avec Book_ID =1 et 2 dont les prix sont inférieurs à 200. Par conséquent, toutes les colonnes de ces enregistrements sont affichées.
- Supérieur ou égal (>=)
Lorsque l'opérateur supérieur ou égal (>=) est utilisé avec la clause where, il récupère ces enregistrements de la table partout où la valeur du nom de colonne présente dans une table est supérieure ou égale à la valeur du nom de colonne spécifié dans le requête.
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer les enregistrements de la table où le prix du livre est supérieur ou égal à 150.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price >= 150; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec)
Nous pouvons voir qu'il y a quatre enregistrements avec Book_ID =1, 2, 3 et 4 dont les prix sont supérieurs ou égaux à 150. Par conséquent, toutes les colonnes de ces enregistrements sont affichées.
- Inférieur ou égal (<=)
Lorsque l'opérateur inférieur ou égal (<=) est utilisé avec la clause where, il récupère ces enregistrements de la table lorsque la valeur du nom de colonne présente dans une table est inférieure ou égale à la valeur du nom de colonne spécifié dans la requête.
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer les enregistrements de la table où le prix du livre est inférieur ou égal à 200.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price <= 200; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------+---------------+------------+ 3 rows in set (0.00 sec)
Il y a trois enregistrements avec Book_ID =1, 2 et 4 dont les prix sont inférieurs ou égaux à 200. Par conséquent, toutes les colonnes de ces enregistrements sont affichées.
- Pas égal (<>)
Lorsque l'opérateur non égal (<>) est utilisé avec la clause where, il récupère ces enregistrements de la table partout où la valeur du nom de colonne spécifié dans la requête ne correspond pas à la valeur du nom de colonne présent dans une table.
Exemple :
Nous appliquerons la clause where avec la requête SELECT pour récupérer les enregistrements de la table où le prix du livre n'est pas égal à 250.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price <> 250; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------+---------------+------------+ 3 rows in set (0.00 sec)
Il y a trois enregistrements avec Book_ID =1, 2 et 4 dont les prix ne sont pas égaux à 250. Par conséquent, toutes les colonnes de ces enregistrements sont affichées.
