• 6 hours
  • Medium

Free online content available in this course.

course.header.alt.is_video

course.header.alt.is_certifying

Got it!

Last updated on 5/31/22

Implémentez des relations entre vos données grâce à JOIN

Log in or subscribe for free to enjoy all this course has to offer!

Les bases de données SQL sont dites de type “relationnel”. Cela sous-entend que leur force réside sur leur capacité à relier plusieurs types de données entre elles.

Pour l’instant, vous avez utilisé de la donnée sans relations. Par exemple, pour récupérer ou mettre à jour un utilisateur ou un aliment.

Or, si vous reprenez l’exemple de Foodly, l’application doit stocker les aliments qu’un utilisateur a scannés. Pour ce faire, il faut stocker les relations entre ces mêmes utilisateurs et certains aliments.

Nous verrons comment mettre en place de telles relations dans la partie 4. Mais en attendant, voyons comment récupérer des objets selon les relations qu’ils ont entre eux.

Extrayez des informations via une relation 1 à plusieurs

Beaucoup d’utilisateurs vont utiliser Foodly, et ce, dans plusieurs pays.

Afin de pouvoir s’adapter à chacun, l’application va devoir stocker la langue préférée de chaque utilisateur. Pour ce faire, la table “langue” a été rajoutée à la base de données Foodly que vous avez téléchargée au début de cette partie.

Chaque utilisateur est relié à une langue. Et chaque langue peut être reliée à plusieurs utilisateurs.

Schéma représentant 2 utilisateurs reliés à une langue 1 et un utilisateurs relié à une langue 2
La relation un à plusieurs entre les utilisateurs et les langues

Pour matérialiser une telle relation dans une base SQL telle que MySQL, on suit un principe assez simple :

1.Dans ce cas spécifique, une langue est reliée à plusieurs utilisateurs. On crée donc cet objet normalement, comme vous avez pu le faire précédemment.

INSERT INTO `langue` VALUES ('français'); 

2.Chaque utilisateur se voyant relié à une langue, c’est l’utilisateur qui va devoir stocker l’id unique de la langue associée.
Par convention, on utilise comme nom de ce champ  {nom de l’objet associé}_id   (donc ici,  langue_id  ).

Les utilisateurs de la base de données mise à jour dans la partie 2 ont ainsi un champ  langue_id  , où est stocké l’id de la langue qu’ils souhaitent utiliser.

Par exemple, le premier utilisateur a comme langue_id 1, soit l’id du français dans la table des langues.

Imaginez désormais qu’on vous demande de ressortir toutes les langues utilisées par les 10 premiers utilisateurs, ou tous les utilisateurs ayant configuré Foodly en anglais.

Ce serait fastidieux de tout vérifier à la main, non ? 😨

Grâce à cette commande, vous allez pouvoir expliquer à MySQL comment joindre deux tables selon un identifiant qu’elles ont en commun.

Partons du principe que :

  • la langue_id du premier utilisateur est le français ;

  • l’id du français est 1.

Vous allez spécifier à MySQL de joindre les tables “utilisateur” et “langue” en lui précisant que l’id de langue et langue_id de l’utilisateur doivent êtres égaux !

Prenons un exemple. Regardons tous les utilisateurs avec les langues qui leur sont associées. Tapez cette commande dans votre terminal :

SELECT * FROM `utilisateur`
JOIN `langue`
ON `utilisateur`.`langue_id` = `langue`.`id`;

Vous devriez obtenir ce tableau, où sont visibles les langues utilisées par chaque utilisateur.

Que s’est-il passé dans cette commande ?

  • Nous avons demandé à MySQL de sélectionner tous les utilisateurs.

    • SELECT * FROM `utilisateur` 

  • Auxquels nous voulons joindre les langues.

    • JOIN `langue` 

  • En précisant à MySQL de les relier, en considérant que l’id de la langue est stockée dans chaque utilisateur dans le champ langue_id.

    • ON `utilisateur`.`langue_id` = `langue`.`id` 

Récapitulatif visuel du paragraphe rédigé ci-dessus
L'utilisation de la commande JOIN

À vous de jouer !

Admettons que je vous demande de me donner tous les noms de famille des utilisateurs ayant sélectionné le français. Comment feriez-vous cela ?

Testez la commande et vérifiez la solution ci-dessous :

Voilà, vous pouvez désormais relier entre elles deux tables unies par une relation 1 à plusieurs. Vous pouvez être fier de vous ! 👏

Maintenant, passons à la prochaine étape : les relations plusieurs à plusieurs.

Obtenez des informations complexes via une relation plusieurs à plusieurs

Reprenons ensemble l’idée première de l’application Foodly. Cette dernière sert à des utilisateurs (comme vous et moi) à scanner des aliments.

Une fois ces aliments scannés, il serait plus qu’utile que la base de données les garde en mémoire, afin que les utilisateurs puissent les retrouver par la suite (pour par exemple faire leur prochaine liste de courses).

Pour ce faire, il faudrait un moyen de stocker dans la BDD tous les aliments qui ont été scannés par un utilisateur précis. Sachant que :

  • un même utilisateur peut stocker plusieurs aliments scannés ;

  • un aliment peut lui-même être scanné par plusieurs utilisateurs.

Schéma représentant des utilisateurs reliés à plusieurs aliments
La relation un à plusieurs entre les utilisateurs et les aliments

On parle ici de relation plusieurs à plusieurs. Chaque objet d’une table pouvant être relié à plusieurs objets de l’autre table, et vice versa.

Or, tout ce que sait faire MySQL (et les bases de données SQL en général), c’est de stocker une valeur unique par champ. Il n’est pas possible par exemple de stocker plusieurs id d’aliments au sein d’un même utilisateur.

Comment faire dans ce cas ? 🤔

Vous allez “tricher”. Une relation plusieurs à plusieurs, c’est une multitude de relations 1 à plusieurs.

Hum, oui mais encore ?

Regardez les tables présentes dans la BDD que vous avez téléchargées pour cette partie. Voyez-vous une table appelée  utilisateur_aliment   ?

Celle-ci contient des  utilisateur_id   et des  aliment_id  . Vous l’avez peut-être deviné : elle sert à stocker des relations entre un utilisateur et un aliment précis.

En récupérant tous les objets présents dans cette base, qui ne sont autres que des relations 1 à plusieurs vers utilisateur et aliment, on peut reconstituer les relations plusieurs à plusieurs entre ces mêmes utilisateurs et aliments !

schéma représentant à gauche des utilisateurs et à droites des aliments. Tous sont reliés grâce à la table de liaison, au centre.
La table de liaison relie les utilisateurs aux aliments

Comment cela se passe-t-il côté SQL ? 😉

Eh bien, il s’agit toujours d’un bon vieux  JOIN  !

Voici la commande pour relier tous les utilisateurs aux aliments qu’ils ont scannés :

SELECT
*
FROM
utilisateur
JOIN utilisateur_aliment ON (utilisateur.id = utilisateur_aliment.utilisateur_id)
JOIN aliment ON (aliment.id = utilisateur_aliment.aliment_id);

On obtient ce magnifique tableau où sont liés tous les utilisateurs aux aliments qu’ils ont scannés.

À vous de jouer !

Admettons que vous souhaitiez voir tous les aliments sélectionnés par les utilisateurs dont l’adresse e-mail et une adresse Gmail. Comment feriez-vous ?

Faites le test et vérifiez votre commande avec ce screencast :

Vous voilà capable de relier entre elles deux tables ayant une relation plusieurs à plusieurs, via leur table de liaison. Vous êtes très fort. 💪

En résumé

  • Vous savez désormais joindre plusieurs objets entre eux grâce au mot clé JOIN.

  • Et ce, que ce soit pour une relation un à plusieurs ou pour une relation plusieurs à plusieurs grâce à une table de liaison.

Maintenant que vous savez donner du sens à la donnée présente dans votre BDD, il vous reste une ultime partie !

Vous allez y apprendre comment modifier la structure d’une base de données, afin de la faire évoluer selon les besoins de votre application.

Example of certificate of achievement
Example of certificate of achievement