La durabilité dans les affaires est difficile sans une gestion appropriée des données. Construire un système bien défini est essentiel pour gérer les opérations internes et externes. Un aperçu détaillé des données de l'entreprise aide à comprendre le flux de travail global et à mesurer les performances. De plus, l'utilisation de bases de données permet de gagner du temps et d'accéder aux informations sans effort.
Qu'est-ce qu'une base de données ?
Une base de données est un système organisé utilisé pour stocker des informations de manière sécurisée. Il offre une catégorisation et permet la création de tables pour trier des éléments similaires sous un même groupe. Les tables offrent des options pour lister les informations dans plusieurs lignes et colonnes. En conséquence, la qualité et la cohérence des données s'améliorent. Outre les capacités de stockage et de facilité d'accès, les bases de données jouent un rôle important dans la protection de la vie privée et la sécurisation des systèmes. Qu'elle soit ponctuelle ou qu'elle fasse partie d'un processus codé dans une application, la récupération de données est l'un des aspects les plus critiques de la gestion de bases de données.
Une requête dans un SGBD relationnel est n'importe quelle commande utilisée pour récupérer des données à partir d'une table. SELECT est une instruction presque toujours utilisée dans les requêtes Structured Query Language (SQL). Il existe plusieurs méthodes pour récupérer des informations à partir d'une base de données. Généralement, les développeurs préfèrent l'option en ligne de commande car elle est rapide et efficace. Elle permet de soumettre des requêtes de manière transparente.
Dans ce guide, nous allons vous présenter MySQL et voir comment travailler avec des requêtes dans MySQL. C’est parti !
Prérequis
Pour suivre ce tutoriel, vous aurez besoin de ce qui suit :
-
La dernière version d' Ubuntu est installée sur votre système.
-
Les utilisateurs du système doivent disposer des privilèges sudo.
-
Si vous rencontrez des difficultés pour accéder à votre compte sudo, envisagez de modifier le MySQL root password.
-
-
MySQL est configuré sur votre serveur.
Étape 1 — Créer et configurer une base de données
Avant de commencer et d'écrire notre première requête SQL, nous devons créer une base de données et y ajouter des tables. Après cela, nous remplirons les tables à l'aide d'exemples de données. Travailler avec des bases de données vous aidera à comprendre la configuration de base et vous donnera confiance dans l'utilisation des requêtes.
L'expérience pratique est le moyen le plus efficace de construire des concepts et de comprendre l'importance des bases de données. Dans ce guide, nous vous accompagnerons dans l'utilisation des bases de données et leur importance pour résoudre des problèmes du monde réel. Examinons un scénario pour comprendre comment les bases de données peuvent aider à organiser les enregistrements de manière structurée.
Scénario : Nous allons créer une base de données dans laquelle un groupe d'étudiants part en vacances pour fêter leurs anniversaires. Avant de partir en vacances, ils prévoient de participer à une compétition amicale de natation. De plus, chaque ami du groupe prévoit une liste de choses à faire pour rendre leur voyage palpitant et agréable.
Tout d'abord, ouvrez MySQL en tant qu'utilisateur root :
|
1 |
$ sudo mysql |
Ensuite, créez une base de données en exécutant la commande suivante :
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Ensuite, utilisons notre base de données à l'aide de la commande suivante :
|
1 |
mysql> USE vacation; |
Après cela, nous allons créer des tables dans notre base de données. Nommez la première table celebration. Notre table aura des colonnes pour les noms de nos amis (name), les tournois qu'ils ont gagnés (wins) et également une colonne pour leur meilleur temps (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Query OK, 0 rows affected (2.03 sec) |
Nous allons ensuite remplir notre table avec des données :
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Query OK, 4 rows affected (0.29 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Ensuite, créez une autre table dans notre base de données pour stocker les informations sur leurs activités d'anniversaire préférées. Nous allons créer une table appelée vacation et contenant les colonnes suivantes :
|
Liste |
Détail |
|
name: |
Stocke le nom de chaque ami. |
|
birthdate: |
Suit la date de naissance de chaque individu. |
|
activity: |
Conserve un enregistrement de leur activité préférée. |
|
Destination: |
Stocke les informations sur la destination préférée de chaque individu. |
|
meal: |
Suit le repas préféré d'un individu. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Populate the table with data:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
You are now done setting up your database.
Step 2 — Get Started with SELECT Statements
Queries in SQL normally begin with SELECT. It is used in queries to specify which columns in a table should be returned with the results. A query must also always include FROM, which is used to specify the table that the statement will query.
Queries follow the syntax below:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
We will use the query syntax to return the meal column from the vacation table:
|
1 |
mysql> SELECT meal FROM vacation; |
Our output will be as follows:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Frites | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Vous pouvez également sélectionner plusieurs colonnes en utilisant une colonne pour les séparer :
|
1 |
mysql> SELECT name, destination FROM vacation; |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
Vous pouvez également utiliser un astérisque (*) si vous souhaitez représenter toutes les colonnes de la table :
|
1 |
mysql> SELECT * FROM celebration; |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Si vous souhaitez filtrer les enregistrements qui répondent à une condition spécifiée, vous utilisez WHERE. Les lignes qui ne répondent pas à la condition spécifiée sont éliminées des résultats. La clause WHERE utilise la syntaxe suivante :
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Il s'agit d'un opérateur de comparaison qui définit comment la colonne spécifiée doit être comparée à la valeur. Les opérateurs de comparaison SQL courants incluent :
|
Opérateur |
Utilisation |
|
= |
Égalité |
|
!= |
Inégalité |
|
< |
Inférieur à |
|
> |
Supérieur à |
|
<= |
Inférieur ou égal à |
|
>= |
Supérieur ou égal à |
|
BETWEEN |
Teste si la valeur se situe dans la plage donnée. |
|
IN |
Teste si la valeur d'une ligne est contenue dans un ensemble de valeurs spécifiées. |
|
EXISTS |
Teste si une ligne existe |
|
LIKE |
Teste si une valeur correspond à la chaîne spécifiée |
|
IS NULL |
Teste les valeurs nulles |
|
IS NOT NULL |
Teste toutes les valeurs autres que NULL |
Si vous vouliez trouver la destination préférée d'Aisha, vous pourriez utiliser la requête ci-dessous :
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
La requête renverra ensuite :
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 ligne dans le jeu (0.03 sec) |
SQL prend en charge l'utilisation de caractères génériques, qui sont particulièrement utiles dans les clauses WHERE. Les signes de pourcentage ( %) désignent zéro ou plusieurs caractères inconnus, tandis que les tirets du bas ( _) désignent un seul caractère inconnu. Ils sont utiles si vous souhaitez trouver une entrée spécifique dans une table mais que vous n'êtes pas sûr de l'entrée.
Par exemple, si vous aviez oublié la destination préférée d'un ami et ne connaissiez que la lettre par laquelle elle commence, par exemple “m”, vous pouvez trouver le nom de la destination en utilisant la requête suivante :
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
La requête renverra :
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldives | | Maurice | +-------------+ 2 lignes dans le jeu (0.04 sec) |
Lorsque vous travaillez avec des bases de données, vous pouvez rencontrer des colonnes ou des tables avec des noms relativement longs ou difficiles à lire. Dans ces cas, vous pouvez rendre les noms plus lisibles en utilisant le mot-clé AS pour créer un alias. Les alias créés avec AS ne sont valides que pour la durée de la requête pour laquelle ils ont été créés :
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Maldives | ski | | Ivan | Maurice | parapente | | Aisha | Colorado | escalade en montagne | | Zane | Bora Bora | pêche | +--------+-----------+-------------------+ 4 lignes dans le jeu (0.00 sec) |
Étape 3 — Introduction aux fonctions d'agrégation
Lorsque vous travaillez avec des données, vous ne voulez pas toujours voir les données elles-mêmes. Vous préférez plutôt obtenir des informations sur ces données. En émettant une requête SELECT, vous pouvez interpréter ou effectuer des calculs sur vos données en utilisant la syntaxe SQL. C'est ce qu'on appelle des fonctions d'agrégation.
La fonction COUNT compte et renvoie le nombre de lignes qui répondent à un ensemble spécifique de critères. Pour exemple, si vous voulez savoir combien d'amis préfèrent aller aux Maldives, vous pouvez utiliser la requête suivante :
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
Les résultats suivants seront renvoyés :
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 ligne dans le jeu (0.06 sec) |
MIN est utilisé pour trouver la plus petite valeur dans une colonne spécifiée :
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
La requête affichera :
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 ligne dans le jeu (0.02 sec) |
MAX est utilisé pour trouver la plus grande valeur numérique dans une colonne donnée :
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
Le résultat attendu est :
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 ligne dans le jeu (0.03 sec) |
Les deux fonctions MIN et MAX peuvent être utilisées sur des données numériques et alphabétiques. Lorsqu'elle est appliquée à une colonne de valeurs de type chaîne, la fonction MIN renvoie la première valeur par ordre alphabétique.
La fonction MIN renvoie la première valeur par ordre alphabétique :
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Voici quel sera le résultat :
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 ligne dans le jeu (0.00 sec) |
La fonction MAX renvoie la dernière valeur par ordre alphabétique :
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Voici ce que sera le résultat :
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 ligne dans ensemble (0.00 sec) |
Étape 4 — Manipuler les résultats des requêtes
Une autre clause populaire qui est utilisée est la clause GROUP BY . Elle est utilisée lors de l'exécution d'une fonction d'agrégation sur une colonne mais en relation avec les valeurs correspondantes d'une autre :
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
Le résultat sera :
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | ski | | 1 | parapente | | 1 | montagne escalade | | 1 | pêche | +-------------+-------------------+ 4 lignes dans ensemble (0.04 sec) |
Pour trier les résultats de la requête, utilisez la clause ORDER BY . Les valeurs numériques sont triées par ordre croissant par défaut, tandis que les valeurs textuelles sont triées par ordre alphabétique. La requête ci-dessous liste les colonnes name et birthdate, mais trie les résultats par birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
Le résultat sera le suivant :
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 lignes dans ensemble (0.04 sec) |
Le résultat est par ordre croissant ; pour trier par ordre décroissant, terminez la requête avec le mot DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Jetez un œil au résultat :
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 lignes dans ensemble (0.00 sec) |
La clause HAVING a été ajoutée à SQL pour fournir une fonctionnalité similaire à la clause WHERE tout en étant également compatible avec les fonctions d'agrégation. La différence entre ces deux clauses est que WHERE sert à faire référence à des enregistrements individuels et HAVING fait référence à des enregistrements de groupe. À cette fin, la clause GROUP BY doit être présente chaque fois qu'une clause HAVING est utilisée :
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
La requête affichera :
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | ski | | 1 | parapente | | 1 | montagne escalade | | 1 | pêche | +-------------+-------------------+ |
Le COUNT est de 1 pour tous car aucun ami n'aime la même activité.
Étape 5 — Interroger plusieurs tables
La clause JOIN peut être utilisée dans un résultat de requête pour combiner des lignes de deux tables ou plus. Elle y parvient en localisant une colonne liée entre les tables et en triant le résultat de manière appropriée.
SELECT Les instructions qui incluent une clause JOIN suivent la syntaxe ci-dessous :
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Si vous vouliez acheter à chacun de vos amis un trophée pour leurs victoires lors de la natation le jour de leurs anniversaires, vous pourriez créer une requête qui joindra les deux tables pour vous aider à trouver toutes les informations que vous souhaitez avec une seule requête :
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
La sortie sera :
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 rows in set (0.00 sec) |
Il s'agit d'une clause JOIN interne. En effet, elle sélectionne tous les enregistrements qui ont des valeurs correspondantes dans les deux tables et les affiche dans un ensemble de résultats. Les enregistrements qui ne correspondent pas à la requête ne sont pas inclus. Nous pouvons inclure une nouvelle ligne dans nos tables qui ne correspond à aucune entrée :
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 row affected (0.01 sec) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 row affected (0.01 sec) |
Ensuite, réexécutez l'instruction SELECT avec la clause JOIN :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 rows in set (0.00 sec) |
Comme la table celebration n'a pas d'entrée pour Peter et la table vacation n'a pas d'entrée pour Ella, ces enregistrements sont absents.
Nous pouvons renvoyer tous les enregistrements de l'une des tables en utilisant une clause JOIN externe. Il peut s'agir d'un LEFT JOIN ou d'un RIGHT JOIN. Un LEFT JOIN renvoie tous les enregistrements de la table de gauche et uniquement les enregistrements correspondants de la table de droite. La table de gauche dans le contexte des jointures externes est celle référencée par la clause FROM, et la table de droite est toute table référencée après l'instruction JOIN.
Exécutez à nouveau la requête mais utilisez une clause LEFT JOIN :
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
La commande renverra tous les enregistrements de la table de gauche ( celebration) même si elle n'a pas d'enregistrement correspondant dans la table de droite. Lorsqu'il n'y a pas d'enregistrement correspondant dans la table de droite, il est renvoyé sous la forme NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 rows in set (0.00 sec) |
Voici maintenant la clause RIGHT JOIN :
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Toutes les valeurs de la table de droite seront renvoyées (vacation). Comme le birthdate de Peter est enregistré dans la table de droite et non dans la table de gauche, les colonnes name et wins renverront des valeurs NULL dans ces lignes :
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | nom | victoires | date de naissance | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 lignes dans jeu (0.01 sec) |
Vous pouvez utiliser la clause UNION plutôt que JOIN pour interroger des enregistrements de plusieurs tables. L'opérateur UNION diffère de la clause JOIN en ce qu'il combine les résultats de deux instructions SELECT en une seule colonne plutôt que d'afficher les résultats de plusieurs tables sous forme de colonnes uniques à l'aide d'une seule instruction SELECT.
Vous pouvez exécuter cette requête pour l'illustrer :
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
La requête supprime les entrées en double. Il s'agit du comportement par défaut de l'opérateur UNION :
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | nom | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 lignes dans jeu (0.00 sec) |
Pour renvoyer toutes les entrées (plus les doublons), utilisez l'opérateur UNION ALL :
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | nom | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 lignes dans jeu (0.00 sec) |
Les sous-requêtes sont une autre méthode pour interroger plusieurs tables. Les sous-requêtes sont des requêtes intégrées dans une autre requête (également appelées requêtes internes ou imbriquées). Elles sont utiles lorsque vous souhaitez comparer les résultats d'une requête aux résultats d'une fonction d'agrégation distincte.
Nous utiliserons l'exemple consistant à chercher quel ami a remporté plus de tournois de natation qu'Ella. Au lieu de demander combien de matchs Ella a gagnés, puis d'exécuter une autre requête pour voir qui a gagné plus de matchs que cela, vous pouvez calculer les deux avec une seule requête :
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
La requête renverra :
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | nom | victoires | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 lignes dans jeu (0.06 sec) |
Si vous vouliez emmener vos amis en vacances surprise, vous pouvez utiliser une requête pour voir qui a le plus de victoires et renvoyer leur destination :
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
La requête renverra :
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | nom | destination | activité | repas | +------+-------------+----------+------+ | Zane | Bora Bora | pêche | Tofu | +------+-------------+----------+------+ 1 ligne dans jeu (0.00 sec) |
Cette instruction contient une sous-requête dans une sous-requête.
Conclusion
La génération de requêtes est l'une des tâches les plus courantes de la gestion de bases de données. Il existe plusieurs outils d'administration de bases de données comme phpMyAdmin et pgAdmin que vous pouvez utiliser pour travailler avec des requêtes et visualiser leurs résultats. Cependant, l'instruction SELECT depuis la ligne de commande reste le choix préféré en raison de sa facilité d'utilisation et de son excellent contrôle.
De plus, il existe de nombreux tutoriels sur les bases de données que vous pouvez explorer sur notre blog:
- SQLite vs MySQL vs. PostgreSQL : Comparatif des systèmes de gestion de bases de données relationnelles
- Solutions rapides pour réparer des tables corrompues dans MySQL : un tutoriel
- Comment installer MySQL sur Centos 7
- Utilisateur MySQL — Créer et accorder des permissions
- Configuration de la réplication dans MySQL sur Ubuntu
Bonne informatique !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.