Les requêtes

Benoit BIAUDET

Mis en ligne le 23-09-2021 à 10:50

Langues disponibles

1 . Définition

2 . Créer une table

Dans la Coding School, une fois connecté à la phpMyAdmin comme on a vu précédemment, vous aurez la possibilité de créer une nouvelle table dans votre base de données.

Pour cela, cliquez sur la base de données dans le menu de gauche, ensuite sur `SQL` en haut.

Vous devriez voir un message s'afficher comme quoi les requêtes sont faites sur le nom de votre base de données. Si ce n'est pas le cas, c'est que vous n'avez pas sélectionné la base de données avant de cliquer sur `SQL`.

Ensuite, vous n'avez plus qu'à rentrer votre requête, comme ceci :

![SQL_CREATE_TABLE_1](https://coding-school.fr/images/users/1666877646.png)

C’est-à-dire en SQL la clause ``CREATE`` sert à créer un élément en SQL ici une TABLE nommé ``clients``, ensuite entre parenthèses nous mettons le nom des colonnes avec leur type.

En première colonne ici on peut observer une colonne nommée`` id``.

Je vous conseille dans chaque table que vous créez de mettre une colonne ``id`` avec une clé primaire qui s'auto-incrémente.

C'est-à-dire une clé primaire sert à ce que dans une même table la valeur de cette clé primaire ici `id`  ne peut-être un doublon.

Ça peut servir dans un cas par exemple où dans une table `clients` il y a deux Sophie Lefebvre.  Ces deux Sophie seront différenciées par cette clé primaire qui est unique dans la table : la clause ``PRIMARY KEY`` sert donc à cela.

Ensuite concernant la clause ``NOT NULL`` : ``NULL`` signifie qu'il n'y a aucune valeur.  La clé primaire devant absolument avoir une valeur, nous préciserons bien que cette colonne ne doit être en aucun cas ``NULL`` donc ``NOT NULL``.

Enfin, la clause ``AUTO_INCREMENT`` sert à ce que la valeur s'auto-incrémente. C'est à dire qu'à chaque nouvelle ligne, le champ `id` se remplit tout seul en faisant +1 par rapport à la valeur précédente. Ce qui donnera en 1ère ligne de la table créée un ``id`` à 1, 2ème ligne de la table un ``id`` à 2, etc.

Une fois la requête terminée, cliquez sur "Exécuter" en bas à droite et vous serez redirigé sur la fenêtre suivante :

![SQL_CREATE_TABLE_2](https://coding-school.fr/images/users/1666877669.png)

Si la requête a bien fonctionné, vous devriez voir votre table affichée sur la gauche, et un message avec un fond vert sur la page principale avec la requête en dessous.

Si la requête est mauvaise, vous aurez un message avec un fond rouge expliquant le problème.

3 . SQL DML

4 . SELECT

``SELECT`` est la commande permettant de sélectionner des données dans une table, cela peut-être une sélection d’une table entière, ou d’une colonne seulement, ou encore d’une sélection d’une portion de la table (par exemple : seulement ceux qui ont plus de 40ans). 
 
Je vais vous présenter la syntaxe d’une requête ``SELECT`` avec une condition : 
 
``` 
SELECT nom_colonne(s) 
FROM nom_table 
WHERE condition 
``` 
 
Ou encore plus simple si on enlève la condition : 
 
``` 
SELECT nom_colonne(s) 
FROM nom_table 
``` 
 
Les tests des conditions acceptés en SQL sont : 
 
* ``>`` 
* ``<`` 
* ``=`` 
* ``<=`` 
* ``>=`` 
* ``<>`` 
* AND 
* OR 
* NOT 
* IS NULL 
* IS NOT NULL 
 
Passons maintenant aux exemples : 
 
Pour ces exemples je vais utiliser cette table (nommé ici ``clients`` ) :

![SQL_REQUETE_SELECT_1](https://coding-school.fr/images/users/1666878536.png)

Justement pour faire une projection/sélection de cette table comment je fais ? 
Il faut faire une sélection de toutes les colonnes de la table, pour aller plus vite en SQL il existe un caractère permettant de « dire » TOUT ce caractère est ``*`` passons à l’exemple pour que ça soit plus parlant. 
 
``` 
SELECT * FROM `clients` 
``` 
 
Le caractère ``*`` ici permet de dire que je veux toutes les colonnes.

Pour taper ma requête, je fais de la même façon que pour créer ma table, je clique sur ma base de données à gauche, puis l'onglet `SQL` et je tape ma requête :

![SQL_REQUETE_SELECT_2](https://coding-school.fr/images/users/1666878546.png)

Et maintenant si je voulais seulement afficher le nom de famille et le numéro de téléphone comment cela se passerait ?

Et bien en écrivant le nom des colonnes à la place de ``*`` ! 
 
 ``` 
SELECT `lastname`, `phoneNumber` FROM `clients` 
```

Voici le résultat:

![SQL_REQUETE_SELECT_4](https://coding-school.fr/images/users/1666878568.png)

Bien sûr vous pouvez faire ça avec une seule colonne ou plus si vous le souhaitez. 
 
 
 
<iframe width="100%" height="747" src="https://www.youtube.com/embed/2nCf6p951wM" title="2.2 - Sélection de données  Conditions WHERE simple [SQL]" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

Et maintenant si on voulait sélectionner que les colonnes ``lastname`` et ``age``, mais avec le fait que l’on veuille uniquement les personnes qui ont plus de 30 ans : 
 
``` 
SELECT `lastname`, `age` FROM `clients` WHERE `age` > 30 
``` 
 
Et le résultat:

![SQL_REQUETE_SELECT_5](https://coding-school.fr/images/users/1666878579.png)

Si vous le souhaitez vous pouvez imposer cette condition avec toutes les colonnes : 
 
``` 
SELECT * FROM `clients` WHERE `age` > 30 
```

![SQL_REQUETE_SELECT_6](https://coding-school.fr/images/users/1666878589.png)

En plus des conditions, vous pouvez aussi trier les données à l’aide de ``ORDER BY`` pour que les données soient classées par ordre croissant ou décroissant.

Cette instruction doit être placée après le ``WHERE``, comme ceci : 
 
``` 
SELECT nom_colonne(s) 
FROM nom_table 
WHERE condition 
ORDER BY tri 
``` 
 
Comme exemple je vais vous montrer comment trier des données par ordre croissant et décroissant.

Par ordre croissant : 
 
``` 
SELECT * FROM `clients` WHERE `age` > 30 ORDER BY `age` ASC 
```

Résultat :

![SQL_REQUETE_SELECT_6](https://coding-school.fr/images/users/1666878589.png)

Par ordre décroissant :  
 
``` 
SELECT * FROM `clients` WHERE `age` > 30 ORDER BY `age` DESC 
```

Résultat :

![SQL_REQUETE_SELECT_7](https://coding-school.fr/images/users/1666878599.png)

Vous pouvez aussi bien évidemment le faire sans condition: 
 
``` 
SELECT * FROM `clients` ORDER BY `age` ASC 
``` 
Résultat:

![SQL_REQUETE_SELECT_8](https://coding-school.fr/images/users/1666878609.png)

**BETWEEN**

Pour avoir encore plus de pouvoir sur la sélection des données que l’on souhaite afficher, on peut utiliser la condition BETWEEN.

Par exemple si je souhaite afficher les clients qui ont entre 30 et 53 ans :

```
SELECT * FROM `clients`
WHERE `age` BETWEEN 30 AND 53 ;
```

J’obtiens bien l’affichage de Jean qui a 35 ans et John qui a 53 ans alors que Pierre qui a 21 ans n’apparaît pas.

![SQL_BETWEEN](https://coding-school.fr/images/users/1672647336.png)

**LIKE**

L’opérateur LIKE va être extrêmement pratique pour effectuer des recherches. Il va pouvoir être utilisé de plusieurs façons.

Pour reprendre l’exemple de notre table clients, on va pouvoir demander de rechercher les enregistrements dont la première lettre du prénom commence par un J :

```
SELECT * FROM `clients`
WHERE `firstname` LIKE 'J%' ;
```

On rajoute un % après le J pour remplacer tous les caractères. Ici, on va donc rechercher toutes les chaines de caractères qui commence par un J :

![SQL_LIKE](https://coding-school.fr/images/users/1672647409.png)

La recherche nous a bien retourné Jean et John.

**AND et OR**

AND et OR vont nous servir à combiner les conditions afin de filtrer les données comme on le souhaite.

Prenons l’exemple d’une table books. On a l’id du livre, son nom, son genre et son prix.

![SQL_TABLEBOOKS](https://coding-school.fr/images/users/1672647581.png)

Si je souhaite afficher les livres dont le genre est fantasy avec un prix supérieur ou égal à 20€ je vais procéder de la sorte :

```
SELECT * FROM `books`
WHERE `book_genre` = 'fantasy' AND `book_price` >= 20;
```

Et ça va bien m’afficher les 3 livres selons ces critères :

![SQL_AND](https://coding-school.fr/images/users/1672647260.png)

On va se servir de OR pour obtenir uniquement les données sur les livres « Les misérables » et The Hunger Games :

```
SELECT * FROM `books`
WHERE `book_name` = 'The Hunger Games' OR `book_name` = 'Les misérables' ; 
```

![SQL_OR](https://coding-school.fr/images/users/1672647515.png)

On peut aussi **combiner** AND et OR afin d’avoir des résultats encore plus précis.

Par exemple, filtrer les livres fantasy avec un prix supérieur ou égal à 20€ et les livres fiction avec un prix inférieur ou égal à 50€.

```
SELECT * FROM `books`
WHERE (`book_genre` = 'fantasy' AND `book_price` >= 20 )
OR (`book_genre` = 'fiction' AND `book_price` <= 50) ;
```

Résultat :

![SQL_ANDOR](https://coding-school.fr/images/users/1672647283.png)

**LIMIT**

La clause LIMIT en SQL va nous permettre de spécifier le nombre de résultats maximum que l’on veut afficher.

Si on reprend notre exemple de table books, nous avons 5 enregistrements. Mais si je ne veux en afficher que 3, je vais le spécifier de la sorte :

```
SELECT * FROM `books`
LIMIT 3 ;
```

![SQL_LIMIT](https://coding-school.fr/images/users/1672647424.png)

On a bien que les 3 premiers enregistrements de la table.

Imaginons que je ne veuille pas afficher les premiers enregistrements de ma table mais seulement de 3 à 5, je vais utiliser ce qu’on appelle l’**Offset** qui permet de décaler les lignes.

L’offset commence toujours à 0 c’est à dire que le premier enregistrement de ma table correspond à 0 et non 1.

```
SELECT * FROM `books`
LIMIT 2, 3
```

On précise donc l’offset en premier (2 ici pour commencer au 3ème enregistrement) et ensuite le nombre de résultats que l’on souhaite (ici 3 pour aller jusqu’à 5 puisque nous avons que 5 enregistrements).

Résultat :

![SQL_LIMITOFFSET](https://coding-school.fr/images/users/1672647438.png)

**LA FONCTION SUM()**

En SQL il est possible d’utiliser la fonction SUM() pour calculer la somme totale d’une colonne de types numériques : attention c’est à dire que ça ne fonctionne que sur les types INT, FLOAT, etc.

Si je reprends mon exemple de table `books`, on pourrait additionner le prix de tous les livres comme ceci :

```
SELECT SUM(`book_price`)
FROM `books`
```

On obtient le résultat suivant :

![SQL_SUM](https://coding-school.fr/images/users/1672647530.png)

Il est possible aussi d’ajouter des conditions à la fonction SUM(). Par exemple, si je ne veux qu’additionner le prix des livres du genre Fantasy :

```
SELECT SUM(`book_price`) as prix_total
FROM `books`
WHERE `book_genre` = 'fantasy' ;
```

![SQL_SUMCONDITION](https://coding-school.fr/images/users/1672647545.png)

J’ai bien la somme des prix des livres en ayant bien retiré les 30€ du livre fiction.

On peut grouper aussi nos résultats. Par exemple si je souhaite avoir la somme en distinguant les genres :

```
SELECT `book_genre`, SUM(`book_price`) AS prix_total
FROM `books`
GROUP BY `book_genre`;
```

Résultat :

![SQL_SUMGROUPBY](https://coding-school.fr/images/users/1672647563.png)

**La fonction AVG()**

La fonction AVG() permet de calculer la moyenne sur un ensemble d’enregistrements de types numériques comme on a pu voir pour la fonction SUM().

Reprenons notre table books. Si on veut calculer la moyenne des prix des livres on s’y prendra de cette façon :

```
SELECT AVG(`book_price`) FROM `books` ;
```

Et ça nous retournera :

![SQL_AVG](https://coding-school.fr/images/users/1672647296.png)

De la même manière que pour la somme, on peut distinguer la moyenne par groupe. Par exemple si je veux la moyenne de prix de livre par genre de livre :

```
SELECT `book_genre`, AVG(`book_price`)
FROM `books`
GROUP BY `book_genre` ;
```

Résultat :

![SQL_AVGGROUPBY](https://coding-school.fr/images/users/1672647318.png)

**La fonction COUNT()**

La fonction COUNT() va permettre de compter le nombre d’enregistrements dans une table.

Reprenons notre table books :

```
SELECT COUNT(*) FROM `books`
```

Ça nous retourne bien 5 :

![SQL_COUNT](https://coding-school.fr/images/users/1672647349.png)

Il est possible de préciser le nom de la colonne entre parenthèse comme ceci :

```
SELECT COUNT(`book_name`) FROM `books` ;
```

Comme précédemment, on peut rajouter des conditions à notre fonction. Par exemple compter le nombre de livres du genre fantasy :

```
SELECT COUNT(*) FROM `books`
WHERE `book_genre` = 'fantasy’';
```

Résultat :

![SQL_COUNTCONDITION](https://coding-school.fr/images/users/1672647365.png)

**La fonction MAX()**

La fonction MAX() permet de retourner la valeur maximale d’une colonne parmi les enregistrements. Par exemple, on peut chercher le prix le plus cher d’un livre dans notre table books :

```
SELECT MAX(`book_price`) FROM `books` ;
```

![SQL_MAX](https://coding-school.fr/images/users/1672647456.png)

Notre livre le plus cher coûte donc 45€.

Si je souhaite un peu plus de détails comme avoir le nom du livre le plus cher, son genre etc :

```
SELECT * FROM `books` 
WHERE `book_price` = (SELECT MAX(`book_price`) FROM `books`);
```

On obtient :

![SQL_MAXCONDITION](https://coding-school.fr/images/users/1672647472.png)

**La fonction MIN()**

La fonction MIN(), à l’inverse de la fonction MAX(), va permettre de retourner la valeur minimale d’une colonne parmi les enregistrements. Par exemple, on peut chercher le prix le moins cher d’un livre dans notre table books :

```
SELECT MIN(`book_price`) FROM `books` ;
```

![SQL_MIN](https://coding-school.fr/images/users/1672647486.png)

Notre livre le moins cher coûte donc 20€.

Pour avoir plus de détails sur le livre en question :

```
SELECT * FROM `books` 
WHERE `book_price` = (SELECT MIN(`book_price`) FROM `books`);
```

On obtient :

![SQL_MINCONDITION](https://coding-school.fr/images/users/1672647501.png)

5 . INSERT

``INSERT`` est la commande permettant d’insérer des données dans une table, c’est-à-dire rajouter une ou plusieurs lignes dans votre table. 
 
Voici la syntaxe utilisée : 
 
``` 
INSERT INTO nom_table VALUES (valeur_col1, valeur_col2, valeur_col3, …) 
```

Reprenons la table vue précédemment, et insérons-y une nouvelle ligne. 
 
``` 
INSERT INTO `clients` VALUES ("Potter", "Harry", 34, "0660606060") 
```

Résultat :

![SQL_REQUETES_INSERT1](https://coding-school.fr/images/users/1666879675.png)

On peut aussi insérer plusieurs lignes dans une même requête : 
 
``` 
INSERT INTO `clients` VALUES  
("Denver", "Robert", 67, "0606060606"), 
("Peters", "Tom", 21, "0621212121") 
``` 
 
Résultat :

![SQL_REQUETES_INSERT2](https://coding-school.fr/images/users/1666879687.png)

6 . UPDATE

``UPDATE`` est la commande permettant de mettre à jour des données dans une table, c’est à dire modifier une ou plusieurs lignes dans votre table.

Pour cela vous utiliserez cette syntaxe :

``` 
UPDATE nom_table 
SET nom_col1 = “new_value1”, nom_col2 = “new_value2”, nom_col3 = “new_value3”, … 
WHERE condition(s) 
```

Par exemple si l’on veut changer l’âge de Tom dans la table ``clients`` :

![SQL_REQUETE_UPDATE1](https://coding-school.fr/images/users/1666880323.png)

``` 
UPDATE `clients` 
SET `age` = 26 
WHERE `firstname` = “Tom” 
```

Résultat :

![SQL_REQUETE_UPDATE2](https://coding-school.fr/images/users/1666880340.png)

Il est aussi possible de modifier des prix avec un calcul par exemple.

Si je prends ma table `books` et que je veux augmenter de 5% le prix de vente des livres de genre Fantasy, je vais m'y prendre de la façon suivante :

``` 
UPDATE nom_table 
SET nom_col1 = nom_col1 * augmentation
WHERE condition(s) 
```

Voici ma table d'origine :

![SQL_TABLEBOOKS](https://coding-school.fr/images/users/1672647581.png)

Je vais donc augmenter les prix de 5% avec la requête suivante :

``` 
UPDATE `books` 
SET `book_price` = `book_price` * 1.05
WHERE `book_genre` = 'Fantasy';
```

Et j'obtiens bien le résultat suivant :

![SQL_PRICE_UPDATE](https://coding-school.fr/images/users/1672822554.png)

7 . DELETE

``DELETE`` est la commande permettant de supprimer des données dans une table, c’est-à-dire supprimer une ou plusieurs lignes dans votre table.

Avec ``DELETE`` vous pouvez :

* Supprimer toutes les lignes de la table (vider la table) 
* Supprimer une ou plusieurs lignes en utilisant une condition. 
 
 Voici la syntaxe utilisée pour vider une table: 
 
``` 
DELETE FROM nom_table 
```

Si on l’utilise sur la table précédente :

``` 
DELETE FROM `clients` 
```

Résultat:

![SQL_REQUETE_DELETE1](https://coding-school.fr/images/users/1666880081.png)

Voici la syntaxe utilisée pour supprimer une ou plusieurs lignes:

``` 
DELETE FROM nom_table WHERE condition(s) 
```

Par exemple si on veut supprimer toutes les lignes où l’âge est inférieur à 35ans:

``` 
DELETE FROM `clients` WHERE `age` < 35 
```

Résultat:

![SQL_REQUETE_DELETE2](https://coding-school.fr/images/users/1666880093.png)

Les requêtes

1 . Définition

2 . Créer une table

3 . SQL DML

4 . SELECT

5 . INSERT

6 . UPDATE

7 . DELETE

Sommaire