Implémentez vos bases de données relationnelles avec SQL

- Sommaire -

- Ressource -

- Cours et Tutos -

Index

1.1 - Découvrez le système de gestion de base de données (SGBD) -

Découvrez votre mission dans ce cours

Dans ce cours, nous allons créer ensemble une base de données (BDD) pour une application imaginaire, Foodly.
Cette application permet à des internautes de sélectionner les aliments qu’ils souhaitent acheter pour voir leur composition en protéines, graisses, sucres, etc.
foodly

J’utiliserai tout au long du cours l'abréviation BDD pour base de données.
Vous découvrirez quelques autres abréviations que je vous expliquerai au fur et à mesure, mais c’est surtout celle-ci que vous devez retenir pour l’instant !

La BDD de Foodly va donc stocker les données dont l’application a besoin pour fonctionner, à savoir : Chacune de ces données aura des caractéristiques, comme l’e-mail pour l’utilisateur ou les calories pour les aliments.
Nous allons les voir par la suite.
foodly
Les données utilisateur et aliment à stocker dans la BDD Foodly

À la fin de ce cours, vous aurez créé plusieurs utilisateurs en base, de nombreux aliments, ainsi qu’un moyen de lier les utilisateurs aux aliments qu’ils ont achetés.
Avant de mettre les mains dans le cambouis, on doit passer par une partie pas forcément plaisante, mais indispensable : le choix et l’installation de notre système de gestion de bases de données.
Car sans lui, pas de BDD.

Installer des logiciels sur son ordinateur n’est pas la chose la plus drôle.
Pour avoir dû installer deux fois d’affilée toutes les librairies (petits programmes qui nous permettent de coder) sur mon ordinateur professionnel, après me l’être fait voler, je peux vous l’assurer, personne n’aime ça.
Je vous promets de faire au mieux pour rendre cela plaisant et aller droit au but.

Votre objectif une fois cette partie finie : être capable de choisir votre système de gestion de base de données et de l’installer.

Choisissez votre SGBD

Le SGBD est le logiciel qui va vous permettre de manipuler les données d’une base.
C’est ce logiciel qui commande les interactions avec votre base pour y récupérer, ajouter, modifier ou supprimer des données.
Pour échanger avec votre base, vous allez donc donner des ordres à votre SGBD.
Des ordres en français ?
Pas exactement !
Ces ordres, vous allez les lui donner dans un langage très simple : le langage SQL.
Pas d’inquiétude, on va avancer pas à pas ensemble pour que vous puissiez prendre en main ce langage !
Le SQL, abréviation de Structured Query Language (en français, langage de requête structurée), est un langage informatique qui vous permet d'interagir avec vos bases de données.
C’est le plus répandu ; par conséquent il est indispensable de le connaître.
On va donc s’en servir pour gérer notre base de données pour la suite du cours.

Imaginez qu’un utilisateur arrive sur Foodly.
Il scanne un aliment présent dans son supermarché pour connaître ses caractéristiques nutritionnelles.
Que va faire notre application ?
L’application va traduire cette recherche en SQL et l’envoyer au SGBD, qui va récupérer l’aliment en question dans le stockage de la base de données, pour ensuite le redonner à l’application.
L’utilisateur retrouvera ainsi son aliment avec toutes ses caractéristiques.
La relation entre le langage SQL et le SGBD lors d'une action sur l'application

Chaque SGBD implémente sa propre syntaxe du SQL en plus des normes communes à tous.
Vous vous demandez sûrement pourquoi il existe différents SGBD et comment en choisir un plutôt qu’un autre.
C’est exactement ce que je vais vous expliquer dans la suite de ce chapitre.

Découvrez les différents SGBD

Pour vous aider, voici un tableau récapitulatif des forces et faiblesses de chaque SGBD :
MySQL Oracle Database PostgreSQL SQLite
Popularité très répandu Utilisé par les grands groupes
ayant un grand nombre de données
moins répandu que les autres répandu pour le prototypage
Prix gratuit (licence fermée) très cher (licence fermée) gratuit (open-source) gratuit (open-source)
Similarité avec le langage SQL ne suit pas toujours la syntaxe SQL ne suit pas toujours la syntaxe SQL suit la syntaxe SQL de très près suit la syntaxe SQL de très près
Entreprises utilisatrices utilisé par Facebook utilisé par Samsung utilisé par Spotify utilisé pour les apps Android

En résumé

Moteur de stockage

Eviter de lier des tables qui n'ont pas le meme moteur de stockage.

MyISAM (Non transactionnel)

Utile si beaucoup de donnees , acces rapide Lors d'une requete sur une table celle-ci n'est pas accessible pour d'autre requetes

InnoDB (Transactionnel)

Lors d'une requete sur une table seule la ligne concernee n'est pas accessible pour d'autre requetes
Sommaire

1.2 - Installez le SGBD MySQL -

Installez MySQL sur Windows

1.Téléchargez le programme d’installation de MySQL et lancez-le

Rendez-vous sur https://dev.mysql.com/downloads/installer/ et sélectionnez le programme d’installation à télécharger.
Je vous conseille de télécharger le deuxième programme (la version “community”),
qui dispose d’options supplémentaires par rapport au premier (la version “web”).

Écran d'installation MySQL

Une fois le programme téléchargé, lancez-le en double-cliquant dessus ; vous devriez arriver sur cette fenêtre :
Fenêtre d'acceptation des conditions générales

Sur l’écran suivant, on vous demandera de faire un choix.
Sélectionnez “Developer Default” pour installer MySQL dans son entièreté.
Sélection du paramétrage par défaut

Les autres options sont utiles si vous utilisez MySQL via un outil externe,
ou que vous avez déjà votre base de données.
Cliquez ensuite sur Suivant.

Une fois arrivé sur la dernière étape, validez et c’est bon, MySQL est installé sur votre machine !
Il nous reste maintenant à le lancer.

2.Lancez MySQL sur votre ordinateur

Pour lancer MySQL sur Windows, double-cliquez sur la console MySQL.
Celle-ci doit avoir apparu dans vos programmes, suite à l’installation précédente.
Une fois celle-ci lancée, vous vous retrouvez dans un terminal.
C’est ici que vous allez pouvoir gérer votre future base de données.

3.Créez le mot de passe de l’utilisateur root de votre BDD

Avant de pouvoir lancer MySQL, il vous faut créer un utilisateur dit root, qui sera l’utilisateur nous permettant de manipuler notre BDD.

En informatique, et notamment dans le monde des bases de données, l’utilisateur dit “root” (ou racine) est un utilisateur qui a tous les droits (création, suppression, mise à jour).
C’est celui qu’on utilise pour installer des logiciels sur notre machine.
Mais attention à ne jamais l’utiliser en production !
En effet, il serait très dangereux qu’un utilisateur puisse l’utiliser, car il obtiendrait l’accès à toutes nos données.

“Utiliser en production” désigne l’utilisation de votre base par votre application, depuis un serveur.
Alors que “l’utilisation en local” signifie l’utilisation sur votre ordinateur, à des fins de développement uniquement.

Pour créer le mot de passe “root”, utilisez la commande mysqladmin -u root password 'votresupermotdepassetrescomplique' (vous l’aurez compris, remplacez le mot de passe par celui que vous aurez choisi).
Vous pouvez vous féliciter, vous venez d’installer MySQL sur votre Windows !

Installez MySQL sur Mac

La manière la plus simple et efficace pour installer MySQL sur Mac est de passer par Homebrew.

1.Installez le gestionnaire Homebrew

Homebrew est un gestionnaire de paquets.
C’est un petit programme que vous pouvez utiliser dans votre terminal pour installer toutes sortes de choses.
C’est le gestionnaire open-source le plus répandu sur Mac.
Très polyvalent, il va vous permettre d’installer MySQL sur votre machine.
Mais il peut aussi vous permettre d’installer toutes sortes de programmes, allant de navigateurs comme Google Chrome à des langages de programmation comme Python !

Pour installer Homebrew, rendez-vous sur le site web de Homebrew : https://brew.sh/index_fr
La page d’accueil de Homebrew

L’installation de Homebrew devrait se lancer.
Une fois celle-ci terminée, vous pouvez vérifier que l’installation s’est bien déroulée en tapant brew help .
Vous devriez voir ceci apparaître sur votre terminal :
Données affichées dans votre terminal

L’écran liste les commandes disponibles via Homebrew.
Si ce n’est pas le cas, tentez de réinstaller Homebrew.
Soyez sûr d’avoir une connexion Internet fiable, et que votre compte utilisateur a les privilèges administrateur.

2.Installez MySQL via Homebrew

Maintenant que Homebrew est installé, il est temps d’installer MySQL !
Pour ce faire, rien de plus simple : utilisez la commande d’installation de Homebrew :
brew install [le nom de ce qu’on souhaite installer]
La commande complète pour installer MySQL est donc brew install mysql.
Appuyez sur enter pour la valider.

Vous venez d’installer MySQL, mais il vous faut encore le démarrer !
Ne désespérez pas, c’est encore une fois très simple, et tout se fait via Homebrew.

3.Démarrez MySQL avec Homebrew

Pour que Homebrew puisse démarrer des processus (ici, celui de MySQL), utilisez la commande brew tap homebrew/services .
Une fois cette commande effectuée, démarrez MySQL grâce à la commande brew services start mysql .
Pour vérifier que le processus de MySQL est bien lancé, utilisez brew services list.
Si vous voyez apparaître MySQL dans la liste, c’est que tout s’est bien passé !
Vous pouvez même le vérifier doublement en tapant la commande mysql -V qui vous permet de regarder quelle version de MySQL est actuellement en train de tourner sur votre machine (dans mon cas, la version 8.0.21).
Écran confirmant l’installation de Homebrew

4.Créez le mot de passe de l’utilisateur root de votre BDD

Il vous reste une ultime commande et le tour est joué !
C’est celle qui vous permet de créer le mot de passe de l’utilisateur “root”.

En informatique, et notamment dans le monde des bases de données, l’utilisateur dit “root” (ou racine) est un utilisateur qui a tous les droits (création, suppression, mise à jour).
C’est celui qu’on utilise pour installer des logiciels sur notre machine.
Mais attention à ne jamais l’utiliser en production !
En effet, il serait très dangereux qu’un utilisateur puisse l’utiliser, car il obtiendrait l’accès à toutes nos données.

“Utiliser en production” désigne l’utilisation de votre base par votre application, depuis un serveur.
Alors que “l’utilisation en local” signifie l’utilisation sur votre ordinateur, à des fins de développement uniquement.

Pour créer le mot de passe “root”, utilisez la commande mysqladmin -u root password 'votresupermotdepassetrescomplique' (vous l’aurez compris, remplacez le mot de passe par celui que vous aurez choisi).
La commande dans votre terminal

Vous pouvez vous féliciter, vous venez d’installer MySQL sur votre Mac !

Installez MySQL sur Linux (Ubuntu)

La manière la plus simple et efficace pour installer MySQL sur Linux est de passer par le terminal.
Le terminal, c’est un programme qui vous permet de lancer des commandes de programmation (vous savez, le fameux écran avec du texte bizarre comme dans Matrix).
Il se trouve dans vos programmes (il est installé par défaut sur Linux).

1.Installez MySQL via le terminal

Sur Linux, la vie est très simple car vous disposez d’un super gestionnaire de paquets : APT.
C’est un petit programme que vous pouvez utiliser dans votre terminal pour installer toutes sortes de choses.
Très polyvalent, il va vous permettre d’installer MySQL sur votre machine.
Mais il peut aussi vous permettre d’installer toutes sortes de programmes, comme par exemple des langages de programmation comme Python !

Commencez par mettre à jour APT en tapant dans votre terminal la commande sudo apt update .
Appuyez sur enter pour la valider.
Une fois cette commande effectuée, installez MySQL en tapant la commande
sudo apt install mysql-community-server.
MySQL est maintenant installé sur votre machine, il reste à le démarrer et le configurer.

2.Démarrez MySQL avec le terminal

Pour démarrer MySQL, il vous faut lancer le “service” de MySQL.
C’est-à-dire faire comprendre à votre ordinateur qu’il doit lancer MySQL et le laisser tourner.
Pour ce faire, entrez la commande sudo service mysql start dans votre terminal.
MySQL tourne (enfin 🙌🏼), mais il vous reste à le configurer.

3.Créez le mot de passe de l’utilisateur root de votre BDD

Il vous reste une ultime commande et le tour est joué !
C’est celle qui vous permet de créer le mot de passe de l’utilisateur “root”.

En informatique, et notamment dans le monde des bases de données, l’utilisateur dit “root” (ou racine) est un utilisateur qui a tous les droits (création, suppression, mise à jour).
C’est celui qu’on utilise pour installer des logiciels sur notre machine.
Mais attention à ne jamais l’utiliser en production !
En effet, il serait très dangereux qu’un utilisateur puisse l’utiliser, car il obtiendrait l’accès à toutes nos données.

“Utiliser en production” désigne l’utilisation de votre base par votre application, depuis un serveur.
Alors que “l’utilisation en local” signifie l’utilisation sur votre ordinateur, à des fins de développement uniquement.

Pour créer le mot de passe “root”, utilisez la commande mysqladmin -u root password 'votresupermotdepassetrescomplique' (vous l’aurez compris, remplacez le mot de passe par celui que vous aurez choisi).
La commande dans votre terminal

Vous pouvez vous féliciter, vous venez d’installer MySQL sur votre Linux !

En résumé

La première chose à faire pour utiliser un SGBD est de créer un utilisateur “root”, qui aura tous les droits pour créer et modifier des bases de données.
Sommaire

1.3 - Créez votre base de données (BDD) -

Créez votre BDD avec CREATE DATABASE

Une application, c’est le code informatique qui vous permet d’effectuer des actions.
Par exemple, commander un taxi ou écrire du texte.
Or, cette application a besoin de données pour exister, données qu’elle va piocher dans une BDD.

Prenez Le Bon Coin : le code de l’application vous permet de voir des listes d’objets à acheter près de chez vous, de contacter leur propriétaire, etc.
Mais pour connaître ces objets, numéros de téléphone, adresses, Le Bon Coin a dû aller les chercher dans une base de données (probablement MySQL 😉).


Créons la base qui contiendra nos objets. Chaque application est associée à une base de données.
Foodly étant une seule et unique application, nous allons créer une seule BDD.
Base qu’on va tout naturellement appeler… Foodly.

Une application complexe peut être reliée à plusieurs BDD à la fois, et ce, pour plusieurs raisons.
Par exemple, Facebook utilise plusieurs BDD pour des besoins spécifiques (certaines gèrent mieux la recherche, les autres le stockage…),
mais surtout pour des raisons de taille de la donnée !
Vous vous doutez qu’avec plus d’un milliard d’utilisateurs, il leur faut plusieurs bases.

Attention lorsqu’on nomme les bases de données !
Tout comme beaucoup de “noms” en informatique (variables, objets, identifiants…), ceux-ci ne doivent pas contenir de caractères spéciaux ou d’espaces.
Il est même recommandé de n’utiliser que des caractères minuscules.


Pour activer MySQL dans votre terminal, il va falloir exécuter la commande
mysql -u root -p .
Cette commande signale que vous souhaitez lancer MySQL, avec l’utilisateur root en saisissant le mot de passe (vous vous en souvenez ? Nous en avons parlé précédemment).
Justement, MySQL nous demande ledit mot de passe.
Entrez celui que vous avez créé précédemment, et le tour est joué !

Écran du terminal suite à l’entrée de votre mot de passe


Pour créer une base, on utilise la commande CREATE DATABASE nomdelabase; .
Pour créer la base de Foodly, la commande à taper devient CREATE DATABASE foodly;.
Écran du terminal après avoir saisi la commande


SQL vous indique que la commande a fonctionné en répondantQuery OK .


Il reste néanmoins un problème : MySQL ne sait pas que vous souhaitez spécifiquement utiliser cette base de données.
Car vous pourriez en avoir plusieurs !
Imaginez que vous travailliez sur plusieurs projets à la fois, vous pourriez très bien avoir une base de données pour chacun.
Pour sélectionner la base que vous venez de créer, utilisez la commande USE nomdelabase; , qui devient donc… USE foodly;
Écran du terminal pour l’utilisation de la BDD


Une fois USE foodly; exécutée, ça y est, la base Foodly est sélectionnée et vous travaillez uniquement dans cette dernière.

Si jamais vous aviez besoin de changer de base de données, alors vous devriez répéter cette commande pour passer sur la nouvelle base.




Testez l’activation de votre BDD avec SHOW TABLES

Pour tester l’activation de votre base de données, vous allez y insérer votre premier objet.
Dans son état actuel, votre base vide ne vous sert pas à grand-chose...

Définissez les types de données

Avant de pouvoir insérer quoi que ce soit, vous devez d’abord créer une table.
En effet, chaque “table” est l’équivalent d’une feuille de travail dans un logiciel type Excel ou Google Sheets, qui stocke toutes les occurrences d’un objet en particulier.
Qui dit base de données dit type de données.
MySQL doit savoir quelle forme auront vos objets avant de vous laisser les manipuler dans chaque table.
C’est l’équivalent en SQL de la modélisation de bases de données où vous devez déclarer les objets que vous souhaitez stocker et ce qu’ils vont contenir.

Le type de donnée est comme un papier d'identité.
Il est commun à toutes les personnes d’un pays et permet de les identifier selon des critères précis.
Le modèle de données, c’est pareil, mais pour chaque objet de la base de données.


Quand on parle de type en base de données, on peut parler de deux types :

Je vous propose de copier-coller cette commande pour créer la table des utilisateurs.
Je vais ensuite vous l’expliquer, ne vous en faites pas.
CREATE TABLE utilisateur (

id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,

nom VARCHAR(100),

prenom VARCHAR(100),

email VARCHAR(255) NOT NULL UNIQUE

);

On obtient bien Query OK, donc tout s’est bien passé.
Votre objet utilisateur va être composé de plusieurs caractéristiques, aussi appelées champs.
Tout comme votre passeport qui recense votre nom ou votre âge, eh bien, pour vos utilisateurs, on va faire de même.
Chacun de ces champs doit avoir un type, pour que MySQL comprenne à quoi “va ressembler” la donnée qui sera stockée dans ce champ.
Par exemple, est-ce que le champ contiendra du texte, des chiffres, etc. Ici, on déclare plusieurs champs qui seront partagés par tous les utilisateurs.



Voici un tableau récapitulatif du schéma des utilisateurs :
Nom du champ Type du champ et options Description
id PRIMARY KEY (option) Champ spécial obligatoire dans toutes les tables.
Indique à MySQL que ce champ sera l'identifiant permettant d'identifier les objets.
INTEGER (type) Champ numérique sous forme de nombre entier.
NOT NULL (option) Ce champ ne peut pas être nul.
AUTO_INCREMENT (option) Ce champ sera créé par MySQL automatiquement, pas besoin de s'en soucier !
MySQL va utiliser l'id précédent et y ajouter +1 lors de l'ajout d'un nouvel objet.
nom VARCHAR(100) (type) Champ sous forme de texte,
limité à 100 caractères.
prenom VARCHAR(100) (type) Champ sous forme de texte,
limité à 100 caractères.
email VARCHAR(255) (type) Champ sous forme de texte,
limité à 255 caractères.
NOT NULL (option) Ce champ ne peut pas être nul.
UNIQUE (option) Ce champ ne peut pas avoir la même valeur en double.

Une option dans un champ est un attribut optionnel qui va modifier le comportement de ce champ.
Retrouvez sur le site de MySQL tous les types de champs disponibles sur le SGBD (en anglais).

Au tour des aliments !
Copiez-collez cette commande pour créer leur table.

CREATE TABLE aliment (

id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,

nom VARCHAR(100) NOT NULL,

marque VARCHAR(100),

sucre FLOAT,

calories INTEGER NOT NULL,

graisses FLOAT,

proteines FLOAT,

bio BOOLEAN DEFAULT false

);



Et pour les champs, c’est assez simple : Voici un exemple de ce que donnerait cette table avec quelques aliments :
id nom marque calories sucre graisses proteines bio
1 Pomme Monoprix 65 14,4 0,4 0,4 FALSE
2 Oeuf Bio Carrefour 167 0 11,1 14,2 TRUE
3 Brique de lait Intermarché 414 43,2 13,5 28,8 FALSE

Pour vérifier que tout ce que vous avez fait fonctionne, rien de plus simple !
On demande à MySQL de nous afficher toutes les tables présentes dans notre base grâce à la commande SHOW tables;.
Écran du terminal après avoir saisi la commande SHOW tables

On peut même aller encore plus loin en demandant à MySQL de nous afficher le schéma de chaque table grâce à la commande SHOW COLUMNS FROM lenomdematable;.
Pour lire le schéma de vos tables, il vous faut taper SHOW COLUMNS FROM utilisateur;
et SHOW COLUMNS FROM aliment;.
Si vous obtenez le même résultat que sur ces screenshots, c’est que vous avez tout bon !

Affichage des schémas des tables utilisateur et aliment

Vous avez saisi ces nouvelles commandes dans votre terminal ? Vérifiez-les grâce au screencast récapitulatif


Lors des parties suivantes, je vous demanderai parfois de télécharger un fichier afin de mettre votre BDD à jour.
Pour ce faire, j’ai créé un projet GitHub disponible ici : Github
À chaque fois que vous souhaiterez mettre à jour votre BDD :

Et voilà, votre BDD est à jour !

En résumé

Sommaire

1.4 - Les contraintes -

Les contraintes sont les regles definies sur les tables lors de la creation des tables.
Sommaire

2.1 - Insérez des données dans votre BDD -

L’acronyme CRUD où MAJ signifie Mettre À Jour

Commencez d'abord par télécharger la base de donnée Foodly de cette partie 2.

Insérez des objets uniques pour alimenter votre BDD

Première étape : vous allez ajouter un utilisateur à votre BDD, car une application sans utilisateurs n’est pas une BDD.
Imaginez qu’un nouvel utilisateur s’inscrive sur Foodly.
Comment l’application ferait-elle pour inscrire cet utilisateur dans la base MySQL ?
Elle utiliserait la commande SQLINSERT INTO.
Cette commande prend en compte :

Insertion d’un utilisateur dans la BDD de Foodly

Souvenez-vous, votre table “utilisateur” dispose de 4 champs :
Nom du champ Descriptif du champ Exemple de valeur
id identifiant unique de l'utilisateur dans la BDD 1
nom nom de famille de l'utilisateur Durantay
prenom prénom de l'utilisateur Quentin
email email de l'utilisateur quentin@gmail.com

Remarquez que je ne me préoccupe pas de l’id.
Je pourrais tout à fait le renseigner.
Mais souvenez-vous, nous l’avons configuré de manière à ce que MySQL l’auto-incrémente pour nous.
Du coup, soyons fainéants et laissons MySQL gérer ce paramètre pour nous !


Voici, par exemple, la commande pour m’ajouter en tant qu’utilisateur dans la base :
INSERT INTO `utilisateur` (`nom`, `prenom`, `email`)

VALUES

('Durantay', 'Quentin', 'quentin@gmail.com');

Si vous exécutez cette commande plusieurs fois, vous remarquerez un message d’erreur.
C’est tout à fait normal.
Souvenez-vous, l’e-mail d’un utilisateur a été configuré dans le schéma de la table comme une valeur unique.
Vous ne pouvez donc pas créer un 2e utilisateur avec le même e-mail.


Voyons ensemble ce qui vient de se passer :
  1. On indique en SQL qu’on souhaite ajouter un objet avec INSERT INTO.

  2. On écrit ensuite le nom de la table dans laquelle on souhaite ajouter l’objet, ici 'utilisateur'.

  3. On écrit ensuite entre parenthèses la liste des colonnes que l’on va ajouter, ainsi que leur ordre.

  4. On ajoute le mot clé SQL VALUES qui indique qu’on va ensuite déclarer les valeurs que l’on souhaite ajouter.

  5. On écrit la liste des valeurs de l’objet qu’on souhaite ajouter, dans le même ordre que les colonnes citées en 3.

Insérez plusieurs objets à la fois

Vous avez désormais une application avec un utilisateur, mais il va vous en falloir plusieurs !
Je ne sais pas vous, mais je trouve ça fastidieux d’avoir à écrire une commande pour chaque utilisateur que j’ajoute.

SQL a pensé à nous !
Il est possible d’ajouter plusieurs objets en une seule commande en séparant leurs valeurs par des virgules,
comme dans la commande ci-dessous grâce à laquelle j’ajoute 4 utilisateurs à la BDD :
INSERT INTO `utilisateur` (`nom`, `prenom`, `email`)

VALUES

('Doe', 'John', 'john@yahoo.fr'),

('Smith', 'Jane', 'jane@hotmail.com'),

('Dupont', 'Sebastien', 'sebastien@orange.fr'),

('Martin', 'Emilie', 'emilie@gmail.com');


Dans les faits, vous allez user et abuser de cette commande pour ajouter différents objets dans votre base.
Réutilisons-la justement pour ajouter des aliments.

Souvenez-vous, la table “aliment” est constituée des colonnes suivantes :
Nom du champ Descriptif du champ Exemple de valeur
id identifiant unique de l'aliment dans la BDD 1
nom nom de l'aliment poire
marque marque de l'aliment Monoprix
calories nombre de calories contenues dans l'aliment (en kcal) 72
sucre la concentration en sucre de l’aliment (en grammes) 19,1
graisses la concentration en graisses de l’aliment (en grammes) 0,2
proteines la concentration en protéines de l’aliment (en grammes) 0,4

Voici la commande pour ajouter les aliments poire, pomme, œuf et lait d’amande à notre BDD :
INSERT INTO `aliment` (`nom`, `marque`, `sucre`, `calories`, `graisses`, `proteines`,`bio`)

VALUES

('poire', 'monoprix', 27.5, 134, 0.2, 1.1, FALSE),

('pomme', 'monoprix', 19.1, 72, 0.2, 0.4, FALSE),

('oeuf', 'carrefour', 0.6, 82, 5.8, 6.9, FALSE),

('lait d\'amande', 'bjorg', 4.5, 59, 3.9, 1.1, TRUE);

Vous vous demandez sûrement pourquoi certaines valeurs sont entre guillemets simples, d’autres entre backticks (`) et certaines sans rien.

La rédaction des valeurs selon leur type

Les explications sont simples :

À vous de jouer !

Essayez maintenant de créer un nouvel aliment.
Partons sur une boîte de conserve de haricots verts.
En voici les données nutritionnelles :
nom marque calories sucre graisses proteines bio
haricots verts Monoprix 25 3 0 1,7 FALSE

À partir de ce tableau, j’aimerais que vous ajoutiez cet aliment dans la BDD de Foodly.
Regardez bien comment nous nous y sommes pris jusqu’ici.


En résumé

Sommaire

2.2 - Sélectionnez les données présentes dans votre BDD -

Lisez les objets que vous venez de créer

Vous venez d’ajouter vos premières données dans votre BDD, c’est top !
Mais à quoi cela servirait si vous ne pouvez pas les récupérer par la suite ?

Reprenons l’exemple de l’application Foodly.
L’objectif des utilisateurs de cette application est de savoir quelle est la composition des aliments qu’ils envisagent d’acheter.
C’est bien beau d’avoir une BDD, mais encore faut-il que l’application puisse y lire les objets.

C’est ce à quoi on va s’attaquer dans ce chapitre...
Nous allons voir ensemble les commandes qui vous permettent de récupérer et lire la donnée contenue dans la base de Foodly.
Commençons par une question simple : comment faire pour afficher tous les utilisateurs présents dans votre BDD ?
Comme pour les commandes d’insertion, vous allez devoir indiquer la table dans laquelle vous souhaitez récupérer la donnée, ici “utilisateur”.

Le mot clé pour récupérer et lire de la donnée est SELECT.
En commençant une commande SQL par ce mot, MySQL (et les autres SGBD) comprend que vous souhaitez sélectionner (et donc récupérer) de la donnée.


Tapez cette commande dans votre terminal :
SELECT * FROM utilisateur;

Voici ce que vous devriez voir apparaître après avoir saisi la commande

MySQL vous affiche la table “utilisateur” sous forme de tableau récapitulatif, avec chaque objet sur sa propre ligne.

La commande SELECT
Décortiquons ensemble la commande que nous venons d’effectuer pour arriver à ce résultat :

Lisez quelques colonnes seulement

C’est super ça, mais je suis réellement obligé de récupérer toutes les colonnes à chaque fois ?
Avant que je vous réponde, tapez cette commande dans votre terminal :
SELECT `nom`, `prenom`, `email` FROM utilisateur;


Que remarquez-vous après l’avoir tapée ?
Eh oui, la colonne id n’est plus visible dans le tableau récapitulatif !
Écran du terminal suite à la commande saisie

De la même manière qu’on précisait les colonnes que l’on souhaitait ajouter avec INSERT, on peut préciser celles que l’on veut que l’application lise avec SELECT.
Pour cela, il suffit de mentionner les noms de colonnes que l’on souhaite récupérer après le mot clé SELECT, comme dans l’exemple ci-dessus.

À votre tour d’essayer !

Je vous propose de lister tous les noms et les calories associées pour chaque aliment présent dans la BDD de Foodly.
Comment feriez-vous ?
SELECT `nom`,`calories` FROM aliment;

En résumé

Sommaire

2.3 - Mettez à jour les données de votre BDD -

Mettez à jour un objet en particulier

Admettons maintenant qu’un utilisateur souhaite mettre à jour son e-mail via l’application.
Comment Foodly traduirait ceci en commande SQL pour MySQL ?
Ici, le mot clé magique est UPDATE, qui signifie “mise à jour” en anglais.
Tapez cette commande dans votre terminal pour changer l’e-mail du premier utilisateur :
UPDATE `utilisateur` SET `email` = 'quentind@gmail.com' WHERE `id` = '1';

Vous devriez avoir un message qui confirme ce changement.
Si vous lisez à nouveau les données de votre BDD sur la table “utilisateur”,
vous remarquerez que l’e-mail de l’utilisateur avec l’id 1 est celui qu’on vient de taper.

La commande UPDATE

Mot clé Description
UPDATE table Signifie à SQL que vous souhaitez mettre à jour de la donnée dans votre BDD.
Vous indiquez aussi la table dans laquelle se trouve(nt) le ou les objets que vous souhaitez modifier.
SET colonne = valeur Sert à indiquer à SQL quelles sont la ou les colonnes à modifier,
et quelles sont la ou les valeurs qu’elles doivent désormais prendre.
WHERE colonne = valeur C’est ce qu’on appelle un filtre.
Vous allez les voir plus en détail dans la partie 3, mais sachez qu’ils servent à restreindre
la commande en cours à un ou des objets répondant à des conditions précises.
Ici, on va mettre à jour uniquement l’objet dont l’id est 1, soit le premier utilisateur !

Il est tout à fait possible d’utiliser UPDATE sans filtres (sans WHERE ).
Néanmoins, la commande modifierait tous les objets de notre table.
C’est très rarement ce que l’on souhaite.

À vous de jouer !

Nous avons oublié de préciser le type de pomme vendue à Intermarché.
Il s'agit d'une pomme golden.
Comment feriez-vous pour rectifier le tir ?
Reponse
UPDATE aliment SET `nom`= 'Pomme Golden' WHERE `id`= '2';

En résumé

Sommaire

2.4 - Supprimez des objets dans votre BDD -

Supprimez un objet en particulier

Finissons par un dernier cas d’usage.
Admettons qu’un utilisateur souhaite se désinscrire de Foodly.
Il faudrait alors le supprimer de votre BDD.
Mais comment faire ?

Ici, le mot clé est DELETE. Signifiant “supprimer” en anglais.

Attention toutefois, cette commande est très simple à utiliser, parfois trop même !
Une fois la donnée supprimée de votre BDD, impossible de la récupérer !
À utiliser avec parcimonie.

Voici par exemple la commande pour supprimer le deuxième utilisateur :
DELETE FROM `utilisateur` WHERE `id` = '2';

Une fois cette commande effectuée, vous pouvez vérifier qu’elle a fonctionné en listant les utilisateurs (commande SELECT).
Là aussi, il vaut mieux utiliser cette commande avec WHERE pour en limiter l’effet.
Si vous ne le faites pas, vous risqueriez de supprimer tous les objets d’une table !
Dans notre cas, adieu à nos utilisateurs.

À vous de jouer !

Bon, on va dire qu’on s’est complètement trompé pour notre pomme golden.
Même en la modifiant précédemment dans la BDD de Foodly, les données sont complètement fausses.
Comment feriez-vous pour la supprimer définitivement de la BDD ?
Reprenez votre terminal et essayez de supprimer la pomme golden.
Reponse
DELETE FROM aliment WHERE `id`='2';



En résumé

Sommaire

3.1 - Extrayez des informations spécifiques de votre BDD -

Vous allez apprendre dans cette partie comment extraire uniquement l’information qui vous intéresse, et en tirer quelques enseignements !
Avant tout, téléchargez la base de données Foodly pour cette partie.

Isolez un objet unique

Dans la partie précédente, à chaque fois que vous lisiez de la donnée, c’était celle d’une table toute entière.
Pour rappel, une commande telle que SELECT * FROM aliment; va vous afficher tous les aliments de votre BDD.

Imaginons un utilisateur dans votre application Foodly. Il est en train de scanner un aliment lors de ses courses.
L’application demandera à la BDD de lui restituer l’aliment en question.
Pour ce faire, il existe une commande en SQL que l’application pourra utiliser pour récupérer uniquement cet aliment.
Il s’agit de la commande WHERE.

Par exemple, la commande :
SELECT * FROM aliment WHERE id = 4;

va nous restituer uniquement l’aliment dont l’id est le numéro 4 !

WHERE ne se limite pas uniquement aux id.
SELECT * FROM aliment WHERE nom = “poire”;

va nous restituer uniquement l’aliment dont le nom est 'poire' !

Vous pouvez appliquer WHERE à n’importe quelle colonne en utilisant le nom de cette colonne.

À noter que WHERE peut s'exécuter avec SELECT ,
mais aussi avec n’importe quelle autre commande :
vous pouvez l’utiliser avec UPDATE ou DELETE pour ne mettre à jour ou supprimer qu’un objet spécifique, et non tous les objets de votre table !

Isolez plusieurs objets répondant à un critère de comparaison

OK, c’est utile de ne pouvoir sélectionner qu’un seul objet.
Mais admettons que votre utilisateur souhaite voir tous les aliments bio de son hypermarché, ou bien ceux qui ne sont pas trop caloriques.

WHERE fonctionne avec un principe de comparaison.
Dans vos précédentes commandes, vous utilisiez l’opérateur égal = pour indiquer que vous ne vouliez que l’objet dont le nom était égal à une valeur.

Or, vous pouvez utiliser tous les opérateurs classiques, tels que :
SELECT * FROM aliment WHERE calories < 90;

va afficher tous les aliments dont la teneur en calories n’excède pas (strictement) 90 kcal

Isolez des objets à partir d’une comparaison sur du texte

La limite de WHERE est que la comparaison ne peut s’effectuer que sur des données chiffrées.


Il existe un autre mot clé pour effectuer des comparaisons sur du texte : il s’agit du mot clé LIKE.


Ce dernier permet de sélectionner les objets dont le texte d’une colonne répond à un modèle spécifique.
C’est en fait lui-même un opérateur, car il s’ajoute au sein d’une commande WHERE.
SELECT * FROM utilisateur WHERE email LIKE “%gmail.com”;

va afficher tous les utilisateurs dont l’e-mail se termine par “gmail.com”.
L’utilisation du pourcentage (%)

Ce “%gmail.com” signifie que vous souhaitez récupérer tout texte finissant par “gmail.com”.
Le pourcentage (%) indique à SQL : Si vous souhaitiez récupérer le texte qui commence par “gmail.com” vous écririez : “gmail.com%”.
Enfin, si vous cherchiez tout texte qui contient “gmail”, peu importe qu’il soit au début ou à la fin, vous écririez “%gmail%”.

Ordonnez les objets récupérés pour chaque requête

Reprenons l’exemple de notre utilisateur qui cherche à afficher les aliments peu caloriques dans Foodly.

Grâce à ce que vous avez appris, vous pouvez désormais afficher les aliments dont les calories ne dépassent pas un certain seuil.
Le mot clé ORDER BY calories ASC permet d’afficher les aliments par ordre croissant de calories.
Le mot clé ORDER BY
Ce mot clé vous permet d’ordonner une colonne par ordre croissant (ascending en anglais, d’où le mot clé SQL ASC),
ou décroissant (descending en anglais, soit le mot clé DESC).
Voici donc la commande à effectuer pour afficher les aliments par ordre croissant de calories :
SELECT * FROM aliment ORDER BY calories ASC;


Bien sûr, vous pouvez mixer les commandes entre elles !
Voici la commande pour n’afficher que les aliments dont les calories ne dépassent pas 90 kcal, mais de manière décroissante :
SELECT * FROM aliment WHERE calories < 90 ORDER BY calories DESC;


Cette commande fonctionne aussi avec le texte !
Si vous effectuez un ORDER BY sur une colonne de texte, celle-ci sera ordonnée :

À vous de jouer !

Imaginons que je vous demande tous les aliments qui ne sont pas bio dans la base, classés par ordre décroissant de contenance en protéines.

SELECT * FROM aliment WHERE bio = false ORDER BY proteines DESC;



En résumé

Sommaire

3.2 - Effectuez des opérations et sauvegardez vos requêtes -

Comptez le nombre d’objets récupérés via une requête

Combien d’objets répondent à un critère (ou une requête SQL) donné ?
Par exemple, admettons qu’un utilisateur de Foodly souhaite savoir combien il existe d’aliments bio, ou que vous souhaitiez compter le nombre d’utilisateurs dans l’application.

Il existe le mot clé COUNT, qui permet justement cela.
Appliqué à n’importe quelle commande SQL de type SELECT , il vous donnera le nombre d’objets récupérés plutôt que leur valeur.

En plus de ne faire “que compter”, COUNT est bien plus rapide à effectuer qu’un SELECT “classique” pour votre base de données.
Le SGBD et la BDD arriveront à retrouver le résultat de votre commande bien plus rapidement (parfois, la différence se compte en minutes !).
Privilégiez-le avant d’effectuer des requêtes sur un large groupe de données !


Vous souvenez-vous de la commande que nous avions effectuée pour récupérer uniquement les utilisateurs dont l’e-mail était un Gmail ?
Comment l’adapter pour connaître le nombre d’utilisateurs avec une adresse Gmail dans la base ?

SELECT COUNT(*) FROM utilisateur WHERE email LIKE "%gmail.com";


MySQL vous affiche le nombre d’objets plutôt que leur contenu.
Vous voyez donc combien d’utilisateurs répondent à ce critère.

En appliquant un COUNT(*) , vous comptez le nombre d’objets.
Mais vous pouvez aussi restreindre le comptage à une colonne spécifique en écrivant COUNT(colonne) .
Enfin, vous pouvez aussi compter le nombre d’éléments uniques d’une colonne avec COUNT(DISTINCT colonne) .


Par exemple,SELECT COUNT(*)FROM utilisateur; compte tous les utilisateurs,
tandis que SELECT COUNT(nom) FROM utilisateur; compte tous les noms de famille.

Ok, vous allez me dire qu’on trouve exactement le même nombre. Et c’est vrai.
Compter dans une colonne prend vraiment son sens en comptant le nombre de valeurs distinctes.

SELECT COUNT(DISTINCT nom) FROM utilisateur; comptera uniquement les noms de familles différents, vous permettant de voir si certains utilisateurs ont le même nom !

Effectuez des opérations sur des données chiffrées

Admettons que l’on souhaite connaître le total calorique d’un groupe d’articles, ou bien la contenance moyenne en sucre d’un groupe d’aliments : au lieu de tout noter à la main depuis la base de données, laissez MySQL effectuer ces opérations pour vous !

Pour cela, il existe plusieurs mots clés que vous pouvez appliquer à une colonne lors d’une requête pour en modifier le résultat :
Envie de connaître le maximum de teneur en sucre des aliments dans notre base ?
Rien de plus simple :
SELECT MAX(sucre) FROM aliment;


Quelle est la teneur moyenne en calories des aliments de 30 kcal ou plus ?
SELECT AVG(calories) FROM aliment WHERE calories >= 30;


À vous de jouer !

Je vous laisse tester ces opérations avec MIN et SUM !
Pour voir à quoi cela ressemble dans le terminal, voici un screencast explicatif où je reprends une à une toutes ces commandes sur la liste des aliments qui ne sont pas bio :
SELECT COUNT(*) FROM aliment WHERE bio = false;

Compte le nombre d'aliment qui ne sont pas bio

SELECT MAX(proteines) FROM aliment WHERE bio = false;

Selectionne l'aliment qui a le max de proteine qui n'est pas bio
(et affiche le nombre de proteines)

SELECT MIN(proteines) FROM aliment WHERE bio = false;

Selectionne l'aliment qui a le moins de proteine qui n'est pas bio
(et affiche le nombre de proteines)

SELECT AVG(proteines) FROM aliment WHERE bio = false;

Affiche la moyenne de proteines dans les aliments qui ne sont pas bio
(et affiche le nombre de proteines)



Sauvegardez vos requêtes avec CREATE VIEW

MySQL a un système de “vues” qui permet de créer des tables temporaires à partir d’une commande SQL.
Entendez par là que vous allez “sauvegarder” une commande SQL pour ne plus avoir à la réeffectuer à chaque fois !

Admettons que vous souhaitiez sauvegarder dans une vue la commande suivante : les utilisateurs dont l’adresse mail est une adresse Gmail.
Vous utilisez la commandeCREATE VIEW!
CREATE VIEW utilisateurs_gmail_vw AS SELECT * FROM utilisateur WHERE email LIKE "%gmail.com";


La commande CREATE VIEW


Je viens de créer la vue “utilisateurs_gmail_vw”.
Cette dernière s’utilise désormais comme une table.
Ainsi, pour récupérer les utilisateurs avec une adresse Gmail, plus besoin d’écrire ma requête compliquée !
Je n’ai plus qu’à écrire :
SELECT * FROM utilisateurs_gmail_vw;


Utilisation de la commande CREATION VIEW avec SELECT * FROM


La convention chez les utilisateurs de SQL est de toujours préfixer le nom d’une vue avec “_vw”, pour la distinguer des “vraies” tables.


Le plus utile avec cela, c’est que la vue se comporte comme une vraie table.
Vous pouvez ainsi réappliquer d’autres commandes SQL sur cette dernière.

Par exemple : afficher les utilisateurs dont l’adresse e-mail est une adresse Gmail ET dont le prénom contient la lettre “m” :
SELECT * FROM utilisateurs_gmail_vw WHERE prenom LIKE "%m%";


Grâce aux vues, vous pouvez “raccourcir” des requêtes SQL complexes et rébarbatives, vous permettant d’aller encore plus loin dans vos analyses !

À vous de jouer !

Essayez à présent par vous-même la création d'une vue.
Créez une vue reprenant notre liste des aliments non bio, classés par contenance en protéines (de manière décroissante).

CREATE VIEW aliments_non_bio_vw AS SELECT * FROM aliment WHERE bio = false ORDER BY proteines DESC;



En résumé

Sommaire

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

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.
La relation un à plusieurs entre les utilisateurs et les langues

On parle alors d’une relation 1 à plusieurs entre utilisateur et langue (one-to-many, en anglais).


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.
Il existe une commande qui est justement là pour régler ce genre de problème.
La commande JOIN.


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 : 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`;

Que s’est-il passé dans cette commande ?
L'utilisation de la commande JOIN


Ici, vous avez utilisé la commande SQL pour lier la totalité d’une table (utilisateur) avec une autre (langue).
Mais on peut tout à fait limiter cette jointure à seulement quelques objets en particulier.

À vous de jouer !

Admettons que je vous demande de me donner tous les noms de famille des utilisateurs ayant sélectionné le français.
SELECT * FROM utilisateur

JOIN langue

ON utilisateur.langue_id = langue.id WHERE langue.nom = 'français';




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 :
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.

Par défaut, le SQL ne sait modéliser que des relations 1 à plusieurs.
Une relation plusieurs à plusieurs, c’est une multitude de relations 1 à plusieurs.
Regardez les tables présentes dans la BDD que vous avez téléchargées pour cette partie.
Elle contient 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.

On appelle table de liaison ce genre de table.
Par convention, elle prend le nom {table1}_{table2} ,
et sert à relier les tables 1 et 2 qui y sont stockées,
en sauvegardant l’id d’un objet de la table 1, à l’id de l’objet de la table 2 correspondant.


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 !

La table de liaison relie les utilisateurs aux aliments

On utilise aussi 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);

Décomposons cette commande ensemble :

À 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.
SELECT * FROM utilisateurs_gmail_vw
JOIN utilisateur_aliment ON (utilisateurs_gmail_vw.id = utilisateur_aliment.utilisateur_id)
JOIN aliment ON (aliment.id = utilisateur_aliment.aliment_id);



En résumé

Sommaire

4.1 - Modifiez la structure d’un objet avec ALTER TABLE -

Ajoutez ou supprimez un champ

Ajoutez un champ aux aliments

Le dernier rapport sur l’utilisation de Foodly vient de tomber.
Dans celui-ci, les utilisateurs ont pu voter pour les améliorations qu’ils souhaiteraient voir apparaître dans l’application.
La plus demandée était celle de voir la contenance en vitamines de chaque aliment.

Sachant cela, l’équipe de Foodly organise une réunion concernant l’implémentation d’une telle fonctionnalité.
Le design est prêt, les développeurs ont codé l’interface, mais il manque une chose cruciale pour récupérer la contenance en vitamines dans l’application : l’ajout de cette donnée dans la BDD.

Prenons l’exemple de la vitamine C.
Cette colonne n’apparaît nulle part dans le schéma de la table aliment.
Il nous faut la créer.
De la même manière que vous l’avez fait lors de la première partie, il faudra spécifier son type à MySQL.

Pour ce faire, utilisez la commande ALTER TABLE.

Voyons à quoi ressemble la commande SQL pour rajouter cette colonne, puis décortiquons-la ensemble :
ALTER TABLE aliment ADD vitamines_c FLOAT;


Ici, on signale à MySQL :
La commande ALTER TABLE

À noter que le type n’est parfois pas seul.
On peut aussi (comme dans la partie 1), mentionner à MySQL qu’on rajoute une colonne qui est :

À vous de jouer !

Admettons que l’on souhaite rajouter une colonne à la table “langue”
Cette colonne, c’est le code ISO des langues (par exemple : “fr-fr” pour le Français de métropole).

ALTER TABLE langue ADD code VARCHAR(100);



Supprimez un champ aux aliments

Le management de chez Foodly nous mentionne d’autres changements à effectuer sur l’application, qui impliquent la BDD.
Les utilisateurs de Foodly n’utilisent que très rarement la fonctionnalité pour savoir si un aliment est bio ou non.
Les développeurs, dans leur volonté de toujours diminuer la dette technique (à savoir, le code à maintenir), souhaitent retirer l’affichage bio de la fiche des aliments sur Foodly.
En tant que gestionnaire de la BDD, vous pensez qu’il serait pratique de faire de même de votre côté, pour éviter de maintenir un champ qui ne sera plus mis à jour.
Pour ce faire, rien de plus simple :
supprimons la colonne “bio” de la table “aliment” avec DROP.
Voici la commande SQL pour le faire :
ALTER TABLE aliment DROP bio;


Décomposons cette commande ensemble :
Utilisation de DROP


Il faut néanmoins faire attention lorsqu’on utilise cette commande.
Une fois la colonne supprimée, celle-ci est définitivement détruite et ne peut plus être récupérée.
Vous perdez l’information pour tous les objets présents en base.
À utiliser avec parcimonie !


À vous de jouer !

Maintenant, admettons que le service légal de Foodly vous dise que stocker des noms de famille va à l’encontre des conditions de protection des données des utilisateurs.
Comment feriez-vous pour supprimer les noms de famille ?

ALTER TABLE utilisateur DROP nom;




Modifiez un champ existant

Modifiez un champ des aliments

Le management de Foodly revient encore une fois vers vous !
Après avoir regardé des utilisateurs se servir de Foodly, ils se sont rendu compte que les utilisateurs souhaiteraient pouvoir filtrer les aliments selon leurs apports calorifiques avec plus de précision.
Pour ce faire, les développeurs vous indiquent qu’ils vont devoir comparer les calories de deux aliments entre eux, et ce, à la virgule près.
Or, les calories sont actuellement stockées sous forme d’entiers (sans décimales, du coup).
Voici la commande pour effectuer cette opération :

ALTER TABLE aliment MODIFY calories FLOAT;


Analysons cette commande :

L'utilisation de FLOAT

À vous de jouer !

Les développeurs viennent vous voir affolés !
Certains utilisateurs ne peuvent pas s’inscrire car leur email dépasse les 255 caractères.
Pourriez-vous augmenter la limite à 500 ?

ALTER TABLE utilisateur MODIFY email varchar(500);



Renommez un champ des aliments

Ce coup-ci, c’est la designer de Foodly qui revient vers vous : les utilisateurs sont perturbés…
Pour chaque aliment, la valeur en protéines, vitamines, matières grasses est mentionnée au pluriel.
Alors que les sucres, eux, sont mentionnés au singulier.
Ce qui perturbe la compréhension des aliments par les utilisateurs.
Comment renommer cette colonne dans la BDD ?
Voici la commande à effectuer :
ALTER TABLE aliment CHANGE sucre sucres FLOAT;


Voici les explications de cette commande :

C’est une spécificité propre à MySQL : pour renommer une colonne, il faut aussi indiquer son type.
Ce qui n’est pas nécessaire si vous utilisez un autre SGBD.
Cela permet de modifier à la fois le nom et le type d’une colonne dans une seule commande.
Et ce, même si vous ne souhaitez pas le modifier(réutilisez alors le même type)

À vous de jouer !

A présent, les développeurs trouvent que le nom code dans la table des langues est peu explicite.
Ils aimeraient qu’elle s’appelle code_pays.

ALTER TABLE langue CHANGE code code_pays varchar(100);



En résumé

Sommaire

4.2 - Ajoutez une relation un à plusieurs -

Voyons dans ce chapitre comment ajouter une relation un à plusieurs, en créant notre table "famille".
Puis retrouvez dans le chapitre suivant comment ajouter une relation plusieurs à plusieurs avec la création de la table "lieu".

Ajoutez une nouvelle table "famille"

Nous avons obtenu une nouvelle demande d’amélioration de l’application de la part des utilisateurs !
Ces derniers aimeraient pouvoir trier les aliments selon leur "famille".
Par exemple, regrouper ensemble les fruits, les légumes, les viandes, etc.
Les développeurs pensent qu’il serait utile de séparer ces familles des aliments.
En effet, ils pensent que les familles d’aliments pourront être utilisées de manière indépendante, pas forcément uniquement sur les fiches des aliments.
Par exemple, pour effectuer un résumé de la consommation en fruits ou légumes d’une personne sur un mois, ou la répartition au sein de ses courses.

Pour cela, il faudrait que les familles d’aliments soient sur une table distincte de celle des aliments !


Maintenant que vous savez joindre plusieurs tables entre elles, il est temps de construire une telle relation entre tables.
Avant de pouvoir relier les aliments à leur famille, il faut d’abord… eh bien, créer la table famille !
Pour l’instant, un objet de type famille ne devra contenir que le nom de cette famille (“fruit”, “viande”, etc.).

CREATE TABLE famille (

id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,

nom VARCHAR(100) NOT NULL

);


Maintenant que cette table est créée, insérons un objet dans celle-ci.
Disons, l’objet qui va représenter les légumes.

INSERT INTO famille (`nom`) VALUES ('légumes');


Et voilà, vous voici en possession d’une nouvelle table “famille” qui dispose d’un objet “légumes”.

Ajoutez la relation entre famille et aliment

Une des choses à déterminer lors de l’ajout d’une relation, c’est de savoir si :
Ici, un aliment peut avoir une seule famille, mais une famille peut être présente sur plusieurs aliments.
Par exemple, une poire et une pomme font partie de la famille “fruits”.
Il s’agit donc d’une relation un à plusieurs.


Dans le cadre d’une telle relation, c’est l’objet qui se trouve du côté “plusieurs” de la relation qui va être modifié, ici les aliments.
On va devoir y stocker l’id de l’objet “un” associé, par exemple “fruits”.
Ici, les aliments vont donc devoir être mis à jour pour y stocker une référence à leur famille.
Cette référence, par convention, sera l’id de la famille.

Voici les étapes que l’on va suivre :
  1. Ajout du champ famille_id sur les aliments.
  2. Modification de ce champ pour signaler à MySQL que c’est une référence à la table famille.
  3. Modification d’un objet pour y stocker une relation.

Ajout du champ famille_id sur les aliments.
ALTER TABLE aliment
ADD famille_id INT NOT NULL;


Il faut qu’on indique à MySQL que ce champ est une référence à une autre table,
en lui précisant quel champ de cette autre table on référence.
Pour modifier le champ famille_id, on utilise la commande :
ALTER TABLE aliment
ADD FOREIGN KEY (famille_id) REFERENCES famille (id)
ON DELETE CASCADE;

Voyons ensemble ce que cette commande signifie :
Actions de la commande ON DELETE


Voilà, MySQL sait que “famille_id” est une référence à l’id de la table famille !
Reste maintenant à mettre à jour vos aliments !
Ajouter la relation de l’objet “haricots verts” vers la famille “légumes”.
Voici la commande :
UPDATE `aliment` SET `famille_id` = '1' WHERE `nom` = 'haricots verts';


N’oubliez pas, “légumes” ayant été ajouté en premier à la table “famille”, il a l’id numéro 1.


Pour vérifier que cela a bien fonctionné, vous pouvez sélectionner les haricots verts avec leur famille grâce à un JOIN.
SELECT * FROM aliment
JOIN famille ON aliment.famille_id = famille.id
WHERE
aliment.nom = "haricots verts";


Grâce à cette commande, vous verrez apparaître un tableau récapitulatif, où la famille de “haricots verts” est bien “légumes”.

Il ne vous reste plus qu’à ajouter les autres familles vous-même, rajouter sa famille à chaque aliment, et le tour est joué !

À vous de jouer !

Faisons un petit exercice :
On souhaite rajouter les réductions disponibles sur les aliments.
Une réduction pouvant être la même pour plusieurs aliments mais chaque aliment pouvant n’avoir qu’une seule réduction, il s’agit d’une relation un à plusieurs.
Les réductions sont uniquement constituées d’un champ “valeur”, qui va contenir la réduction au format texte.
Comment feriez-vous pour créer cette table et la lier aux aliments ?

Creation de la table "reduction"
CREATE TABLE reduction
(id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
valeur VARCHAR(100) NOT NULL).

Creation des valeurs
INSERT INTO reduction (valeur) VALUES ('-30%');

INSERT INTO reduction (valeur) VALUES ('-50%');

Ajout de la colonne reduction_id
ALTER TABLE aliment ADD reduction_id INT;

Ajout de la liaison des tables
ALTER TABLE aliment
ADD FOREIGN KEY (reduction_id)
REFERENCES reduction (id);
ON DELETE SET NULL;

Affecter une reduction de 50% à l'aliment dont l'id=1
UPDATE aliment SET reduction_id=1 WHERE id=1;

Utilisation de JOIN
SELECT * from aliment JOIN reduction ON aliment.reduction_id = reduction.id WHERE aliment.id=1;




En résumé

Vous savez ajouter une relation un à plusieurs entre deux objets en ajoutant à l’objet A un champ qui contiendra l’id (ou clé primaire) de l’objet B.
Sommaire

4.3 - Ajoutez une relation plusieurs à plusieurs -

Souvenez-vous on aimerait ensuite ajouter le type de magasin où sont présents les aliments.
Un même aliment pouvant être présent dans plusieurs lieux, nous allons créer une relation plusieurs à plusieurs.

Ajoutez une nouvelle table “lieu”

La dernière demande de mise à jour des utilisateurs est arrivée !
Ces derniers réclament une chose en théorie simple : pouvoir visualiser dans l’application de Foodly dans quel magasin sont disponibles leurs aliments préférés.
Par exemple, savoir si leur jambon de prédilection est disponible aussi bien à Carrefour que chez Leclerc.
Les développeurs se sont de nouveau regroupés : il va falloir stocker les lieux de vente dans la BDD.
Un lieu pouvant vendre plusieurs aliments, et ces mêmes aliments pouvant être vendus dans plusieurs lieux, vous allez devoir créer une relation plusieurs à plusieurs.
Mais avant toute chose, il vous faut créer la nouvelle table des lieux de vente (que nous allons sobrement appeler “lieu”).
Un lieu de vente, c’est :

CREATE TABLE lieu (
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(100) NOT NULL,
type VARCHAR(100) NOT NULL
);


insérons un lieu dans cette dernière, partons sur un simple Carrefour City
INSERT INTO `lieu` (`nom`, `type`) VALUES ('Carrefour City', 'supermarché');
La nouvelle table est créée, et un objet y a été inséré.
Passons maintenant aux choses sérieuses en créant la relation plusieurs à plusieurs avec les aliments.

Ajoutez la table de liaison

Les aliments vont avoir des relations un à plusieurs avec la table de liaison.
Les lieux, eux aussi, vont disposer de telles relations avec cette table.
Et c’est en reliant ces deux tables via cette table de liaison que vous allez pouvoir ressortir les relations entre lieux et aliments.

Pour ce faire, une table de liaison doit être créée.
Par convention, elle doit toujours avoir cette forme :

Dans notre cas, cela donne ceci en commande SQL :
CREATE TABLE aliment_lieu (
aliment_id INT NOT NULL,
lieu_id INT NOT NULL,
FOREIGN KEY (aliment_id) REFERENCES aliment (id) ON DELETE RESTRICT ON UPDATE CASCADE,
FOREIGN KEY (lieu_id) REFERENCES lieu (id) ON DELETE RESTRICT ON UPDATE CASCADE,
PRIMARY KEY (aliment_id, lieu_id)

);


Décortiquons cette commande ensemble :
ON UPDATE est le comportement que doit adopter MySQL en cas de mise à jour d’un champ.
Il peut avoir les mêmes options que ON DELETE


Actions de la commande ON UPDATE

Admettons que le “oeuf” présent dans notre BDD soit vendu chez “Carrefour City”.
Il vous faudrait alors créer un objet dans “aliment_lieu”, avec l’id de “oeuf” ainsi que l’id de “Carrefour City”.

Retrouvez ces id dans votre BDD et écrivez la commande SQL pour créer cette relation.
Sachant que 3 est l’id de “oeuf”, 1 celui du “Carrefour City”, cela donne ça :
INSERT INTO `aliment_lieu` (`aliment_id`, `lieu_id`) VALUES ('3', '1');


Le fait que le blanc de dinde soit vendu à Carrefour est stocké en base de données.

Pour retrouver cette relation, il vous faudra faire un double JOIN.
SELECT * FROM aliment
JOIN aliment_lieu ON aliment.id = aliment_lieu.aliment_id
JOIN lieu ON lieu.id = aliment_lieu.lieu_id
WHERE aliment.id = 3;


Ici, on joint la table aliment à la table lieu via la table de liaison, comme si c’était une simple relation un à plusieurs répétée.

À vous de jouer !

On souhaite savoir quels sont les appareils sur lesquels les utilisateurs ont installé Foodly (par exemple : mac, pc, android, etc).
Un utilisateur peut utiliser Foodly sur plusieurs appareils, et un même appareil peut être commun à plusieurs utilisateurs.
Il s’agit d’une relation plusieurs à plusieurs

Un appareil est uniquement constitué de son type au format texte.
Comment feriez-vous pour créer cette table et la lier aux utilisateurs ?

Creation de la table "appareil"
CREATE TABLE appareil (
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
type VARCHAR(100) NOT NULL);

Ajout d'appareil dans la table "appareil"
INSERT INTO appareil (type) VALUES ('Iphone');

INSERT INTO appareil (type) VALUES ('Android');

INSERT INTO appareil (type) VALUES ('PC');

INSERT INTO appareil (type) VALUES ('MAC');

Creation de la table de liaison utilisateur_appareil
CREATE TABLE utilisateur_appareil ( utilisateur_id INT NOT NULL,
appareil_id INT NOT NULL,
FOREIGN KEY (utilisateur_id) REFERENCES utilisateur (id) ON DELETE RESTRICT ON UPDATE CASCADE,
FOREIGN KEY (appareil_id) REFERENCES appareil (id) ON DELETE RESTRICT ON UPDATE CASCADE,
PRIMARY KEY (utilisateur_id, appareil_id)
)

Lier le premier utilisateur (id=1) à ses appareils
INSERT INTO utilisateur_appareil (utilisateur_id, appareil_id)
VALUES
(1,2);

INSERT INTO utilisateur_appareil (utilisateur_id, appareil_id)
VALUES
(1,4);

Verification du lien
SELECT * FROM utilisateur
JOIN utilisateur_appareil ON utilisateur.id = utilisateur_appareil.utilisateur_id
JOIN appareil ON appareil.id = utilisateur_appareil.appareil_id
WHERE utilisateur.id = 1;




En résumé

Vous savez ajouter une relation plusieurs à plusieurs entre deux objets en créant une table de liaison qui contiendra les id de chaque objet.
Sommaire

5 - Connecter une base de données MySQL à une app Node.js

Plusieurs librairies NodeJS permettent d’établir une connexion avec une base de données MySQL et d'exécuter des requêtes.
Parmi elles, les deux plus populaires sont :

Utiliser le module mysql pour utiliser une base de données MySql en Node

Commencez par installer le module mysql dans le dossier de votre projet Node.js avec npm install :
npm install mysql

Dans le fichier point d’entrée de votre projet Node.js, initialisez le module dans une variable avec require() :
const mysql = require('mysql');

Votre app NodeJS peut maintenant se connecter à votre base de données MySQL.

Se connecter à la base MySQL avec le module mysql

Pour vous connecter à votre base MySQL, renseignez l’hôte, l’utilisateur et le mot de passe spécifié lors de l’installation de MySQL sur votre système :
const db = mysql.createConnection({
host: "localhost",
user: "nom_utilisateur",
password: "mot_de_passe_utilisateur"
});


Enfin, utilisez la fonction connect pour vous connecter à votre base de données MySQL.
Une exception sera jetée en cas d’erreur :
db.connect(function(err) {
if (err) throw err;
console.log("Connecté à la base de données MySQL!");
});


Votre utilisateur est désormais connecté à la base de données MySQL et peut y exécuter des requêtes.

Créer une base de données MySQL en Node.js avec le module mysql

Pour créer une base de données MySQL, exécutez simplement une requête
CREATE DATABASE
avec la fonction query() dans le code de votre app :
const mysql = require('mysql');
const db = mysql.createConnection({
host: "localhost",
user: "nom_utilisateur",
password: "mot_de_passe_utilisateur"
});

db.connect(function(err) {
if (err) throw err;
console.log("Connecté à la base de données MySQL!");
db.query("CREATE DATABASE mabdd", function (err, result) {
if (err) throw err;
console.log("Base de données créée !");
});
});


Exécuter des requêtes SQL sur une base MySQL avec NodeJS

Vous pouvez ainsi exécuter tout type de requête SQL, comme par exemple une jointure :
const mysql = require('mysql');

const con = mysql.createConnection({
host: "localhost",
user: "nom_utilisateur",
password: "mot_de_passe_utilisateur"
database : "mabdd"
});

con.connect(function(err) {
if (err) throw err;
console.log("Connecté à la base de données MySQL!");
con.query("SELECT eleves.id as 'eleve_id', eleves.nom as 'eleve_nom', eleves.cours_id, cours.nom as 'cours_nom', cours.date as 'cours_date' FROM eleves
JOIN cours on eleves.cours_id = cours.id", function (err, result) {
if (err) throw err;
console.log(result);
});
});


Notez que nous avons cette fois précisé le nom de la base de données MySQL sur laquelle se connecter dans l’appel à la fonction createConnection().
On retrouve ces mêmes résultats:
Voici la réponse fournie par le package mysql invoqué depuis notre fichier javascript

Utiliser une base de données MySQL en NodeJS avec Sequelize

Pour utiliser Sequelize afin d’interagir avec votre base de données MySQL en Node, il vous faut d’abord installer le driver mysql2.
Il s’agit d’un driver distinct du module mysql, moins populaire que ce dernier, mais qui propose quelques fonctionnalités supplémentaires.

Installez mysql2 avec npm install :
npm install mysql2


Dans le code de votre app, initialisez Sequelize avec require() :
const { Sequelize } = require('sequelize');


Dans un nouvel objet Sequelize, indiquez le nom d’utilisateur, le nom d’utilisateur, le mot de passe et le nom de la base de données MySQL afin d’établir la connexion :
const sequelize = new Sequelize("nom_base_de_donnees", "nom_utilisateur", "mot_de_passe_utilisateur", {
dialect: "mysql",
host: "localhost"
});


Enfin, vous pouvez vérifier que la connexion est bien établie avec
authenticate()
, mais cette partie n’est pas nécessaire pour exécuter des requêtes sur votre base :
try {
sequelize.authenticate();
console.log('Connecté à la base de données MySQL!');
} catch (error) {
console.error('Impossible de se connecter, erreur suivante :', error);
}


Créer une base de données MySQL en Node.js avec Sequelize

Pour créer une base de données MySQL en Node avec Sequelize, ajoutez simplement une requête
CREATE DATABASE
dans un appel à la fonction query() à votre code :
const sequelize = new Sequelize("", "nom_utilisateur", "mot_de_passe_utilisateur", {
dialect: "mysql",
host: "localhost"
});

try {
sequelize.authenticate();
console.log('Connecté à la base de données MySQL!');
sequelize.query("CREATE DATABASE `mabdd`;").then(([results, metadata]) => {
console.log('Base de données créée !');
})
} catch (error) {
console.error('Impossible de se connecter, erreur suivante :', error);
}


Exécuter des requêtes SQL sur une base MySQL avec Sequelize

Avec la fonction
query()
, vous pouvez exécuter n’importe quelle requête SQL sur votre base de données,
comme par exemple la jointure de lo'exemple precedent :
const sequelize = new Sequelize("mabdd", "nom_utilisateur", "mot_de_passe_utilisateur", {
dialect: "mysql",
host: "localhost"
});

try {
sequelize.authenticate();
console.log('Connecté à la base de données MySQL!');
sequelize.query("SELECT eleves.id as 'eleve_id', eleves.nom as 'eleve_nom', eleves.cours_id, cours.nom as 'cours_nom', cours.date as 'cours_date'
FROM eleves JOIN cours on eleves.cours_id = cours.id").then(([results, metadata]) => {
console.log(results);
})
} catch (error) {
console.error('Impossible de se connecter, erreur suivante :', error);
}


On retrouve le même résultat dans la console :
Réponse SQL via le package Seequelize