> Installer MySQL, comprendre le modèle relationnel, créer des tables, écrire des requêtes SELECT, INSERT, UPDATE, DELETE, gérer types, contraintes et index : le guide. *Source : https://coder-studio.com/tutoriels/mysql-guide-debutant/* --- [// Bases de données](https://coder-studio.com/tutoriels/) # MySQL : le guide complet pour débuter Par **Kévin Papot** · publié le 14 octobre 2025 MySQL est l’un des systèmes de gestion de bases de données (SGBD) relationnels les plus utilisés au monde. Il fait tourner d’innombrables applications web, de la petite boutique en ligne aux plateformes à très grand trafic. Sa popularité tient à un équilibre solide entre simplicité de prise en main, performances et gratuité de son édition Community. Ce guide vous accompagne des premiers pas — installation, vocabulaire — jusqu’aux requêtes courantes que tout développeur doit maîtriser. ## Qu’est-ce qu’un SGBD relationnel ? Une base **relationnelle** organise les données en **tables**, sortes de tableaux à colonnes et à lignes. Chaque table décrit un type d’entité (des clients, des produits, des commandes), chaque colonne un attribut (nom, prix, date), et chaque ligne un enregistrement concret. Les tables se relient entre elles par des valeurs communes, ce qui évite de répéter l’information. MySQL parle le **SQL** (Structured Query Language), le langage standard pour interroger et modifier ces données. On distingue le serveur MySQL (le moteur qui stocke et traite) des clients (outils ou programmes qui lui envoient des requêtes). MySQL est aujourd’hui développé par Oracle, avec un fork communautaire nommé MariaDB, largement compatible. ## Installer MySQL Sous **Linux (Debian/Ubuntu)**, l’installation passe par le gestionnaire de paquets : ``` sudo apt update sudo apt install mysql-server sudo mysql_secure_installation ``` Le script `mysql_secure_installation` configure le mot de passe root et supprime les comptes de test. Sous **Windows** et **macOS**, le plus simple est de télécharger l’installeur officiel depuis le site de MySQL, ou d’utiliser un environnement complet comme XAMPP (qui embarque MySQL/MariaDB, PHP et Apache) pour un poste de développement. Une fois le serveur lancé, on se connecte au client en ligne de commande : ``` mysql -u root -p ``` ## Créer une base et une table Toute la suite se passe dans le client SQL. On commence par créer une base de données, puis on la sélectionne : ``` CREATE DATABASE boutique; USE boutique; ``` Vient ensuite la création d’une table avec `CREATE TABLE`. On y déclare chaque colonne, son type, et d’éventuelles contraintes. ``` CREATE TABLE clients ( id INT AUTO_INCREMENT PRIMARY KEY, nom VARCHAR(100) NOT NULL, email VARCHAR(150) UNIQUE, ville VARCHAR(80), inscrit_le DATE DEFAULT (CURRENT_DATE) ); ``` Décortiquons cette table : - `id INT AUTO_INCREMENT PRIMARY KEY` : un identifiant entier généré automatiquement à chaque insertion, qui sert de **clé primaire** (identifiant unique de la ligne). - `NOT NULL` : la colonne ne peut pas rester vide. - `UNIQUE` : deux clients ne peuvent pas partager le même email. - `DEFAULT` : une valeur par défaut si aucune n’est fournie. ## Les types de données courants Choisir le bon type améliore la fiabilité et les performances. Voici les familles à connaître. ``` CREATE TABLE produits ( id INT AUTO_INCREMENT PRIMARY KEY, libelle VARCHAR(120), -- chaîne de longueur variable reference CHAR(8), -- chaîne de longueur fixe prix DECIMAL(10,2), -- nombre décimal exact (idéal monnaie) stock INT, -- entier poids FLOAT, -- nombre à virgule flottante actif BOOLEAN, -- vrai/faux (stocké en TINYINT) ajoute_le DATETIME, -- date + heure fiche TEXT -- texte long ); ``` Pour les montants, préférez toujours `DECIMAL` à `FLOAT` : le premier stocke une valeur exacte, le second peut introduire de minuscules erreurs d’arrondi inacceptables en comptabilité. Pour les dates, `DATE` suffit quand l’heure n’importe pas, sinon `DATETIME` ou `TIMESTAMP`. ## Insérer des données : INSERT `INSERT INTO` ajoute des lignes. On peut préciser les colonnes concernées, ce qui est recommandé pour la lisibilité. ``` INSERT INTO clients (nom, email, ville) VALUES ('Dupont', 'dupont@mail.fr', 'Paris'), ('Martin', 'martin@mail.fr', 'Lyon'), ('Bernard', 'bernard@mail.fr', 'Nantes'); ``` Les colonnes non citées (`id`, `inscrit_le`) prennent leur valeur automatique ou par défaut. On peut insérer plusieurs lignes en une seule instruction, comme ci-dessus, ce qui est plus rapide que des `INSERT` séparés. ## Lire des données : SELECT `SELECT` est la commande la plus utilisée. Sa forme minimale lit toutes les colonnes de toutes les lignes : ``` SELECT * FROM clients; ``` En pratique, on nomme les colonnes voulues et on filtre avec `WHERE`. ### Filtrer avec WHERE ``` SELECT nom, ville FROM clients WHERE ville = 'Paris'; ``` Les conditions se combinent avec `AND`, `OR`, `NOT`, et acceptent des opérateurs comme `>`, `<`, `<>` (différent), `BETWEEN`, `IN` ou `LIKE` pour les recherches textuelles. ``` SELECT nom FROM clients WHERE ville IN ('Paris', 'Lyon') AND nom LIKE 'D%'; -- commence par D ``` ### Trier et limiter `ORDER BY` trie le résultat, `LIMIT` en restreint le nombre de lignes. ``` SELECT nom, inscrit_le FROM clients ORDER BY inscrit_le DESC LIMIT 10; ``` ### Agréger avec GROUP BY Les fonctions d’agrégat (`COUNT`, `SUM`, `AVG`, `MAX`, `MIN`) résument des groupes de lignes. ``` SELECT ville, COUNT(*) AS nb_clients FROM clients GROUP BY ville HAVING COUNT(*) > 1; ``` `HAVING` filtre les groupes, là où `WHERE` filtre les lignes avant regroupement. ## Modifier des données : UPDATE `UPDATE` change des valeurs existantes. La clause `WHERE` y est **cruciale** : sans elle, toutes les lignes sont modifiées. ``` UPDATE clients SET ville = 'Marseille' WHERE id = 2; ``` Prenez l’habitude de tester d’abord votre condition avec un `SELECT` portant le même `WHERE`, pour vérifier quelles lignes seront touchées avant de lancer l’`UPDATE`. ## Supprimer des données : DELETE Même logique pour `DELETE`, tout aussi dangereux sans `WHERE`. ``` DELETE FROM clients WHERE id = 3; ``` Pour vider entièrement une table plus efficacement, `TRUNCATE TABLE clients` réinitialise aussi le compteur `AUTO_INCREMENT`, mais reste irréversible. ## Contraintes et clés étrangères Les contraintes garantissent la cohérence des données. La plus importante après la clé primaire est la **clé étrangère**, qui relie deux tables et empêche les références orphelines. ``` CREATE TABLE commandes ( id INT AUTO_INCREMENT PRIMARY KEY, client_id INT NOT NULL, montant DECIMAL(10,2), FOREIGN KEY (client_id) REFERENCES clients(id) ); ``` Ici, impossible d’insérer une commande dont le `client_id` ne correspond à aucun client existant. Ce mécanisme est détaillé dans notre guide sur [la clé primaire et la clé étrangère en SQL](https://coder-studio.com/tutoriels/cle-primaire-etrangere-sql/), qui explique aussi les actions en cascade. ## Les index : accélérer les recherches Un **index** est une structure annexe qui accélère les recherches sur une colonne, à la manière d’un index de livre. MySQL crée automatiquement un index sur les clés primaires et uniques ; on en ajoute d’autres sur les colonnes fréquemment filtrées ou triées. ``` CREATE INDEX idx_ville ON clients(ville); ``` Un index accélère les lectures mais ralentit légèrement les écritures et consomme de l’espace. Il faut donc les poser avec discernement, sur les bonnes colonnes. ## Combiner les tables : les jointures Puisque les données sont réparties dans plusieurs tables, on les recombine à la lecture grâce aux **jointures**. Voici un aperçu reliant clients et commandes : ``` SELECT clients.nom, commandes.montant FROM clients INNER JOIN commandes ON clients.id = commandes.client_id; ``` Les jointures sont un pilier du SQL, avec plusieurs variantes (`INNER`, `LEFT`, `RIGHT`). Le sujet mérite un guide dédié, que vous trouverez ci-dessous. ## Les outils pour travailler avec MySQL Au-delà du client en ligne de commande, plusieurs interfaces graphiques facilitent la vie : - **MySQL Workbench** : l’outil officiel, pour concevoir des schémas, exécuter des requêtes et administrer le serveur. - **phpMyAdmin** : interface web très répandue chez les hébergeurs mutualisés, pratique pour gérer une base sans installer de logiciel. - **DBeaver** ou **Adminer** : alternatives légères et multi-SGBD appréciées des développeurs. ## Pour aller plus loin Vous disposez maintenant des fondations : créer une base, définir des tables typées, insérer, lire, modifier et supprimer des données, et poser les premières contraintes et index. La suite logique consiste à approfondir les jointures, les sous-requêtes et l’optimisation. MySQL récompense la pratique régulière : montez une petite base de test et manipulez-la sans crainte, quitte à la recréer. ## À lire ensuite - [Les jointures SQL expliquées (INNER, LEFT, RIGHT…)](https://coder-studio.com/tutoriels/jointures-sql/) - [Les index SQL : accélérer ses requêtes](https://coder-studio.com/tutoriels/index-sql-performance/) - [MySQL vs PostgreSQL : lequel choisir en 2026 ?](https://coder-studio.com/tutoriels/mysql-vs-postgresql/)