Installation de MySQL et Looping

Introduction à MySQL

Il repose sur un modèle client-serveur. MySQL tourne en permanence comme un service en arrière-plan sur la machine : c'est le serveur, et c'est lui qui détient les données. La ligne de commande et MySQL Workbench sont des clients : ils ne contiennent aucune donnée, ils envoient des requêtes SQL au service et affichent ce qu'il renvoie.

Cette séparation explique la panne la plus fréquente du chapitre. Si le service est arrêté, aucun client ne peut rien faire, même en local, et le message d'erreur parle alors de connexion impossible et non de SQL. Avant de soupçonner une requête, vérifier que le serveur tourne.

Essayer une requête sans rien installer

Installer MySQL reste indispensable dès qu'une base doit vivre quelque part pour de bon, avec ses comptes, ses droits et ses sauvegardes. Mais pour apprendre le langage, on n'a besoin d'attendre personne : dans les chapitres qui suivent, chaque bloc SQL porte un bouton Exécuter.

Ce que la page accepte et que MySQL refuse

Le cours est écrit en MySQL, le moteur de la page est SQLite. Les blocs des chapitres sont écrits pour rendre les mêmes lignes dans l'un et dans l'autre. Mais SQLite est plus permissif : il accepte des requêtes que MySQL refuse, et cinq différences comptent dès qu'on essaie ses propres variantes. Les écritures en cause sont expliquées dans les chapitres sur les requêtes SQL et sur le SQL avancé : ce tableau sert de repère, à retrouver le moment venu.

Les cinq requêtes suivantes en font l'essai sur la base de démonstration. Elles passent toutes dans la page.

MySQL refuse les quatre premières, et rend 4 pour la cinquième là où la page rend 0. La troisième est la plus traîtresse : deux classes sont en première année, la sous-requête rend donc deux lignes, et la page n'en garde qu'une. Elle affiche les quatre élèves de la classe 1A, oublie ceux de la 1B, et ne prévient de rien : la réponse reste plausible. La base de démonstration écrit d'ailleurs ses intitulés sans accents (Mathematiques, Reseaux) : dans la page, il faut les recopier tels quels.

La règle. Une requête qui passe dans la page n'est pas forcément juste : la règle est celle du cours, pas celle que tolère le moteur. Les exercices SQL du parcours l'appliquent : ils refusent un alias de SELECT employé dans WHERE, une colonne nue à côté d'un agrégat et une sous-requête de FROM sans nom, même quand la page les exécute.

Deux écarts de calcul s'y ajoutent. SELECT 7/2 rend 3 dans la page, qui garde la division entière entre deux entiers, et 3.5000 dans MySQL : écrire 7/2.0 donne 3,5 partout. Et || colle deux textes dans la page, alors que MySQL y lit un OU logique et rend 0 : CONCAT(nom, ' ', prenom) marche dans les deux.

Deux autres passent sans aucun message à la création d'une table. INT AUTO_INCREMENT est accepté, mais la colonne ne s'incrémente pas et les identifiants valent NULL : dans la page, écrire INTEGER PRIMARY KEY, qui s'incrémente seul. Et une colonne de clé primaire accepte NULL si elle n'est pas déclarée NOT NULL, ce que MySQL refuse toujours : la base de démonstration déclare donc NOT NULL les colonnes de ses clés composées.

Les clés étrangères, elles, sont vérifiées dans la page : supprimer un cours qui a des inscrits y est refusé. MySQL 8.4 les vérifie aussi, à une condition : qu'elles soient déclarées par une clause FOREIGN KEY (colonne) REFERENCES Table(colonne), comme le fait la base de démonstration. Écrite à côté de sa colonne, idEnseignant INT REFERENCES Enseignant(idEnseignant), la même contrainte est appliquée par la page et ignorée sans message par MySQL 8.4 ; la série 9 l'applique. L'écart joue ici à l'envers : la page fait respecter une contrainte que MySQL laisse tomber, et une base qui passe de l'une à l'autre la perd en silence.

Enfin, SHOW, DESCRIBE, USE, ENGINE=InnoDB, ENUM et GRANT sont propres à MySQL. Les blocs qui les emploient sont présentés sans bouton ; si l'une de ces commandes est saisie malgré tout, le moteur de la page le signale et propose un équivalent quand il en existe un.

Le bac à sable des chapitres repart de la base du cours à chaque exécution. Le poste SQL de la salle machine garde la sienne d'une visite à l'autre, dans le navigateur : on y crée ses tables, on y importe un fichier CSV comme une table, on y télécharge la base entière. Ni l'un ni l'autre n'a de comptes ni de droits, et un seul programme s'y connecte à la fois : c'est l'objet de l'installation qui suit.

Installation de MySQL

Choisir une version

MySQL publie des versions à support long (LTS), maintenues plusieurs années, et des versions d'innovation, remplacées tous les trois mois environ. Ce cours suit MySQL 8.4 LTS. MySQL 8.0 ne reçoit plus de correctifs depuis avril 2026 : ne pas l'installer, même si un ancien tutoriel le propose. La page de téléchargement propose aussi une 9.7 LTS, plus récente : elle conviendrait à ce cours, mais Ubuntu 26.04 et Fedora 44 fournissent la 8.4, et un groupe gagne à travailler sur la même version.

Installation sous Windows

1. Sur la page de téléchargement de MySQL Community Server, choisir la version 8.4 LTS dans la liste des versions (la page propose d'abord la plus récente), le système Microsoft Windows, et télécharger l'installateur MSI.
2. Lancer le fichier téléchargé et accepter l'installation proposée.
3. À la fin, l'installateur propose de lancer MySQL Configurator : accepter. Le serveur n'est pas utilisable tant qu'il n'a pas été configuré.
4. Dans Configurator, choisir le type de configuration Development : un poste de travail, qui fait tourner bien d'autres programmes, et sur lequel le serveur se contente de peu de mémoire.
5. Définir le mot de passe du compte root, et le conserver par écrit : il est redemandé à chaque connexion.
6. Laisser cochées les options qui installent MySQL comme service Windows et le démarrent avec l'ordinateur.
7. Cliquer sur Execute, et attendre que chaque étape soit cochée.

L'ancien « MySQL Installer » (mysql-installer-community), que citent beaucoup de tutoriels, s'arrête à la série 8.0 : il n'installe plus de version maintenue. MySQL Workbench ne fait plus partie de l'installation : il se télécharge à part (voir plus bas).

Pour lancer le client mysql depuis l'invite de commandes, son dossier doit figurer dans le PATH. Si la commande est introuvable, ajouter C:\Program Files\MySQL\MySQL Server 8.4\bin à la variable Path du système (Propriétés système, onglet Avancé, bouton Variables d'environnement).

Installation sous macOS

Sur macOS, l'installation se fait via Homebrew, le gestionnaire de paquets de référence.

Si Homebrew n'est pas encore installé sur la machine, ouvrir le Terminal et exécuter :

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

À la fin, l'installateur affiche sous le titre « Next steps » deux ou trois commandes qui rendent brew accessible : les copier et les exécuter, sans quoi la commande brew reste introuvable.

Ensuite, installer et démarrer MySQL 8.4 :

brew install mysql@8.4brew services start mysql@8.4

La formule mysql, sans numéro, installe la dernière version d'innovation, qui change tous les trois mois ; mysql@8.4 est la version à support long. Homebrew l'installe à part, pour qu'elle puisse cohabiter avec une autre version, et ne l'ajoute donc pas au PATH. La ligne qui le fait est affichée à la fin de l'installation ; sur un Mac à puce Apple, c'est :

echo 'export PATH="/opt/homebrew/opt/mysql@8.4/bin:$PATH"' >> ~/.zshrcsource ~/.zshrc

Sur un Mac à processeur Intel, /usr/local remplace /opt/homebrew.

Homebrew installe le serveur sans mot de passe pour root. Sécuriser ensuite l'installation (définit le mot de passe root et supprime les accès anonymes) :

mysql_secure_installation

Pour se connecter depuis le Terminal :

mysql -u root -p

Le mot de passe saisi ensuite ne s'affiche pas, pas même sous forme d'étoiles : c'est normal. L'invite mysql> qui apparaît est le signe que le client est connecté au serveur, et c'est là que s'écrivent les requêtes.

À retenir. Sur macOS, le service MySQL est géré par Homebrew. Pour le démarrer, l'arrêter ou vérifier son état :
brew services start mysql@8.4 | brew services stop mysql@8.4 | brew services list

Installation sous Linux

Les distributions installent MySQL par leur gestionnaire de paquets. Ubuntu 26.04 et Fedora 44 fournissent MySQL 8.4 ; Ubuntu 24.04 fournit encore la série 8.0.

# Ubuntu : installer, puis vérifier que le service tournesudo apt install mysql-serversudo systemctl status mysql# Fedora : installer, démarrer le service (il s'appelle mysqld), le sécurisersudo dnf install mysql-serversudo systemctl enable --now mysqldsudo mysql_secure_installation

Sous Ubuntu, le compte root de MySQL est réservé à l'administrateur du système : on s'y connecte par sudo mysql, sans mot de passe, parce que MySQL reconnaît le compte système (auth_socket). mysql -u root -p y répond « Access denied » quel que soit le mot de passe saisi. C'est une raison de plus de créer tout de suite un compte de travail (voir plus bas).

Vérification de l'installation

Une installation qui se termine sans message d'erreur n'est pas encore une installation qui fonctionne. Trois requêtes le prouvent, lancées depuis le client en ligne de commande.

La première demande au serveur de dire qui il est : elle rend une seule ligne d'une seule colonne, le numéro de version du serveur installé (8.4. suivi d'un numéro de correctif). Elle prouve que le client atteint le serveur et que le serveur répond.

La deuxième liste ce que le compte a le droit de faire, base par base. C'est elle qu'il faut lancer pour diagnostiquer un problème de droits.

La troisième rend une ligne par base, mais elle ne prouve aucun droit : elle ne refuse jamais, elle masque seulement les bases sur lesquelles le compte n'a aucun droit, et montre toujours au moins information_schema. Pour root, elle affiche toutes les bases, dont les bases système mysql et information_schema.

Trois échecs reviennent régulièrement, et chacun a sa cause :

Lire le message avant d'agir fait gagner l'essentiel du temps : les trois causes n'ont rien en commun, et aucune ne se corrige par une réinstallation. Le premier cas se règle en démarrant le service, le deuxième avec le bon mot de passe, le troisième par le PATH.

Le message se lit pourtant mal quand il arrive juste après une saisie qui a l'air d'être en cause.

Un mot de passe root oublié ne se retrouve pas, mais il se réinitialise : la documentation de MySQL décrit la manœuvre, qui demande d'arrêter le serveur. Mieux vaut le conserver au moment où on le choisit.

Utilisation de MySQL en ligne de commande

Connexion au serveur

Ouvrir un terminal (l'invite de commandes sous Windows) et taper :

mysql -u root -p

Sous Ubuntu, sudo mysql remplace cette commande pour le compte root.

Commandes essentielles

Gérer les bases

SHOW DATABASES affiche une liste. USE n'affiche rien, mais change la base courante : toutes les commandes suivantes s'y appliqueront, et oublier cette ligne est la cause la plus banale d'un « table introuvable ». DROP DATABASE ne demande aucune confirmation et ne s'annule pas. MySQL appelle aussi une base un « schéma » (CREATE SCHEMA est un synonyme de CREATE DATABASE), et c'est le mot qu'emploient les outils graphiques.

Gérer les tables

DESCRIBE rend une ligne par colonne de la table, avec son type, sa nullabilité et son éventuel rôle de clé. C'est le moyen le plus rapide de vérifier qu'une table créée correspond bien au modèle prévu, avant d'y insérer quoi que ce soit.

La même table peut s'écrire en déclarant la clé primaire en fin de définition, forme que produisent souvent les outils graphiques :

Les deux formes sont équivalentes : seule la clé primaire change de place.

À retenir. Utiliser INT AUTO_INCREMENT (et non SMALLINT) pour les identifiants : SMALLINT est limité à 32 767 valeurs, ce qui peut être insuffisant dès que la table grossit.

Un plafond se traduit en durée, et la durée se calcule avant de choisir le type.

Travailler avec un compte à soi

Tout faire en root est une mauvaise habitude : ce compte peut tout, y compris supprimer toutes les bases d'une faute de frappe, et un programme qui s'y connecte hérite de ce pouvoir. On crée donc, une fois pour toutes, un compte de travail qui n'a de droits que sur sa base, et seulement ceux dont il a besoin.

'appli'@'localhost' désigne le compte appli quand il se connecte depuis la machine elle-même. La dernière commande rend deux lignes :

GRANT USAGE ON *.* TO `appli`@`localhost`
GRANT SELECT, INSERT, UPDATE, DELETE ON `ma_base`.* TO `appli`@`localhost`

La première, USAGE, signifie « aucun droit en dehors de ce qui suit » : elle figure toujours. La seconde donne les quatre droits sur les lignes de ma_base, et rien d'autre.

On se connecte ensuite avec ce compte, directement sur sa base : mysql -u appli -p ma_base. Il lit et modifie les lignes, mais ne peut ni créer ni supprimer de table (MySQL répond CREATE command denied ou DROP command denied), ni ouvrir une autre base (Access denied). Pour créer les tables, on repasse par root, ou on donne aussi CREATE, ALTER, DROP au compte, sur cette seule base. Connecté en appli, SHOW DATABASES ne montre que ma_base et les bases d'information de MySQL : les autres sont masquées, pas refusées.

Ce compte suffit pour suivre le parcours. Le reste de l'exploitation d'une base se comprend mieux une fois le SQL connu, et fait l'objet du chapitre Exploiter une base : un compte par application, le retrait d'un droit par REVOKE, une vue qui ne montre à un compte qu'une partie d'une table, et la sauvegarde de la base par mysqldump, avec sa restauration.

MySQL Workbench

Installation de Workbench

Télécharger MySQL Workbench à part, depuis sa page officielle, dans la version que propose la page. L'ancienne série 8.0 de Workbench, encore très répandue, n'est plus maintenue, et signale un serveur 8.4 comme « incompatible ». Sous macOS, éviter de l'installer par Homebrew, qui fournit encore cette ancienne série.

Se connecter au serveur local

Au premier lancement, créer une connexion avec les paramètres d'une installation locale : hôte 127.0.0.1, port 3306, et le compte de travail créé plus haut (ou root, pour administrer). Workbench propose de tester la connexion avant de l'enregistrer : le faire, car un échec à ce moment désigne les paramètres, pas MySQL.

Une fois connecté, Workbench affiche les bases (qu'il appelle des schémas) et leurs tables, ouvre un éditeur où s'écrivent et s'exécutent les requêtes, et montre le contenu d'une table sous forme de tableau. Quand on crée une table à la souris, il affiche le script SQL qu'il s'apprête à exécuter : le relire est le meilleur moyen d'apprendre ce que fait chaque case cochée.

Workbench administre une base qui existe déjà. Reste l'outil qui intervient avant elle, quand le modèle n'est pas encore arrêté.

Modéliser avant de construire : Looping ou Mocodo

Installation de Looping, sous Windows

Looping est un programme Windows (Windows 7 et suivants) qui ne s'installe pas : télécharger l'archive .zip depuis le site officiel, en extraire Looping.exe et le lancer tel quel, depuis n'importe quel dossier ou une clé USB.

Looping sur Mac

Looping n'existe qu'en version Windows. Sur un Mac, trois voies, de la plus simple à la plus lourde :

• Mocodo, dans le navigateur : rien à installer, et le même résultat, un MCD dessiné, son MLD et le script SQL. C'est la voie conseillée.
• Looping dans une couche de compatibilité Windows, comme Wine (gratuit) ou CrossOver (payant), qui lancent Looping.exe sans Windows ; le site de Looping indique qu'il y fonctionne.
• Une machine virtuelle Windows, si un cours impose Looping et que rien d'autre ne passe.

Mocodo, dans le navigateur

Mocodo fonctionne dans le navigateur, sans rien installer, et suit la même notation Merise : chaque cardinalité est écrite à côté de l'entité qu'elle décrit. On y décrit le modèle par un texte, et Mocodo le dessine : une ligne par entité, son nom suivi de ses attributs, le premier étant l'identifiant ; une ligne par association, son nom suivi, pour chaque entité reliée, de sa cardinalité en deux caractères et du nom de l'entité.

Client: idClient, nom, email
Passe, 0N Client, 11 Commande
Commande: idCommande, dateCommande

Dessiner un premier modèle

Les étapes sont les mêmes dans les deux outils :

1. Créer deux entités, Client et Commande, avec leurs attributs. L'identifiant de chacune (idClient, idCommande) est souligné sur le dessin.
2. Créer une association, Passe, et la relier aux deux entités.
3. Poser les cardinalités : 0,N côté Client, 1,1 côté Commande.
4. Placer chaque attribut dans l'entité qu'il décrit (ex : dateCommande dans Commande). Un attribut ne se pose sur l'association que s'il dépend des deux entités à la fois, comme la note d'un étudiant dans un cours : cela n'arrive que pour une association dont les deux maxima valent N.

À retenir. La cardinalité se lit du côté de l'entité vers l'association, et les deux nombres sont le minimum et le maximum de participations, dans cet ordre.
(0,N) côté Client se lit : « un client passe zéro, une ou plusieurs commandes ». (1,1) côté Commande se lit : « une commande est passée par un client et un seul ».

Générer le script SQL

Les deux outils déduisent du dessin le modèle logique et le script SQL de création des tables : Looping les affiche en temps réel à côté du modèle et exporte le script pour les principaux SGBD (choisir MySQL) ; Mocodo les produit à la demande. Le fichier .sql obtenu s'exécute ensuite dans Workbench ou en ligne de commande.

Le script contient un CREATE TABLE par entité et par association dont les deux maxima valent N, plus les clés étrangères déduites des cardinalités. Le relire avant de l'exécuter reste indispensable : l'outil traduit fidèlement le modèle dessiné, y compris ses erreurs.

Ressources complémentaires

• Documentation officielle MySQL 8.4
• Documentation MySQL Workbench
• Looping MCD, Site officiel
• Mocodo en ligne
• Tutoriel SQL, W3Schools
• Homebrew, macOS