Comprendre à quoi sert SQL

SQL signifie Structured Query Language. C’est le langage utilisé pour communiquer avec une base de données relationnelle comme MySQL ou MariaDB.

Dans cette formation, nous allons travailler avec Laragon pour lancer un environnement local et phpMyAdmin pour exécuter les requêtes SQL directement depuis le navigateur.

Ce que SQL permet de faire

SQL permet de créer une base, créer des tables, insérer des données, lire des données, filtrer les résultats, modifier des lignes, supprimer des lignes, relier plusieurs tables, créer des vues et analyser le contenu d’une base.

SELECT 'Bonjour SQL avec phpMyAdmin' AS message;

Objectif de la formation

À la fin, vous serez capable de comprendre et d’écrire les requêtes SQL classiques utilisées dans un vrai projet PHP, WordPress, WooCommerce ou application maison.

Préparer Laragon et phpMyAdmin

Pour travailler proprement, nous allons utiliser un environnement local. Laragon permet de lancer Apache, PHP et MySQL sur votre ordinateur. phpMyAdmin sert ensuite à gérer les bases de données facilement.

Étapes à suivre

Lancez Laragon, démarrez les services, puis ouvrez phpMyAdmin depuis le menu Laragon ou depuis l’adresse locale prévue selon votre configuration.

SELECT VERSION() AS version_mysql;

Créer une base de test

Dans phpMyAdmin, vous pouvez créer une base manuellement ou lancer cette requête depuis l’onglet SQL.

CREATE DATABASE formation_sql
CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;

Ensuite, sélectionnez la base formation_sql dans phpMyAdmin avant d’exécuter les prochaines requêtes.

USE formation_sql;

Créer des tables avec CREATE TABLE

Une base de données contient des tables. Une table ressemble à un tableau : elle contient des colonnes et des lignes.

Pour notre exemple, nous allons créer une mini base de boutique avec des clients, des produits et des commandes.

CREATE TABLE clients (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    prenom VARCHAR(100) NOT NULL,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(190) NOT NULL,
    telephone VARCHAR(30) DEFAULT NULL,
    ville VARCHAR(120) DEFAULT NULL,
    is_active TINYINT(1) NOT NULL DEFAULT 1,
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (id),
    UNIQUE KEY unique_email (email)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE produits (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    nom VARCHAR(190) NOT NULL,
    slug VARCHAR(190) NOT NULL,
    prix DECIMAL(10,2) NOT NULL DEFAULT 0.00,
    stock INT NOT NULL DEFAULT 0,
    is_active TINYINT(1) NOT NULL DEFAULT 1,
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (id),
    UNIQUE KEY unique_slug (slug)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE commandes (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    client_id INT UNSIGNED NOT NULL,
    statut VARCHAR(50) NOT NULL DEFAULT 'pending',
    total DECIMAL(10,2) NOT NULL DEFAULT 0.00,
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (id),
    KEY idx_client_id (client_id),
    CONSTRAINT fk_commandes_client
        FOREIGN KEY (client_id)
        REFERENCES clients(id)
        ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE commande_lignes (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    commande_id INT UNSIGNED NOT NULL,
    produit_id INT UNSIGNED NOT NULL,
    quantite INT NOT NULL DEFAULT 1,
    prix_unitaire DECIMAL(10,2) NOT NULL DEFAULT 0.00,
    PRIMARY KEY (id),
    KEY idx_commande_id (commande_id),
    KEY idx_produit_id (produit_id),
    CONSTRAINT fk_lignes_commande
        FOREIGN KEY (commande_id)
        REFERENCES commandes(id)
        ON DELETE CASCADE,
    CONSTRAINT fk_lignes_produit
        FOREIGN KEY (produit_id)
        REFERENCES produits(id)
        ON DELETE RESTRICT
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

À retenir

INT sert aux nombres entiers, VARCHAR aux textes courts, DECIMAL aux prix, DATETIME aux dates, et PRIMARY KEY identifie chaque ligne de manière unique.

Insérer des données avec INSERT INTO

La commande INSERT INTO permet d’ajouter des lignes dans une table.

INSERT INTO clients (prenom, nom, email, telephone, ville) VALUES
('Julie', 'Martin', 'julie@example.com', '0600000001', 'Lyon'),
('Karim', 'Bernard', 'karim@example.com', '0600000002', 'Saint-Étienne'),
('Meryem', 'Durand', 'meryem@example.com', '0600000003', 'Paris'),
('Lucas', 'Petit', 'lucas@example.com', NULL, 'Marseille');

INSERT INTO produits (nom, slug, prix, stock) VALUES
('Formation HTML', 'formation-html', 49.00, 100),
('Formation CSS', 'formation-css', 59.00, 80),
('Formation SQL', 'formation-sql', 79.00, 50),
('Audit SEO', 'audit-seo', 149.00, 20);

INSERT INTO commandes (client_id, statut, total) VALUES
(1, 'paid', 128.00),
(2, 'pending', 79.00),
(3, 'paid', 149.00);

INSERT INTO commande_lignes (commande_id, produit_id, quantite, prix_unitaire) VALUES
(1, 1, 1, 49.00),
(1, 3, 1, 79.00),
(2, 3, 1, 79.00),
(3, 4, 1, 149.00);

Erreur fréquente

Si une colonne est obligatoire avec NOT NULL, vous devez fournir une valeur, sauf si une valeur par défaut existe.

Lire les données avec SELECT

SELECT est la commande la plus utilisée. Elle permet de récupérer des données depuis une ou plusieurs tables.

SELECT *
FROM clients;

SELECT id, prenom, nom, email
FROM clients;

SELECT
    id,
    prenom AS first_name,
    nom AS last_name,
    email AS adresse_email
FROM clients;

SELECT *
FROM clients
LIMIT 2;

Conseil important

En développement, SELECT * est pratique. En production, il est souvent préférable de sélectionner uniquement les colonnes nécessaires.

Filtrer avec WHERE

WHERE permet de récupérer uniquement les lignes qui respectent une condition.

SELECT *
FROM clients
WHERE ville = 'Lyon';

SELECT *
FROM produits
WHERE prix >= 50
  AND stock > 0;

SELECT *
FROM clients
WHERE email LIKE '%example.com';

SELECT *
FROM commandes
WHERE statut IN ('paid', 'pending');

SELECT *
FROM clients
WHERE telephone IS NULL;

Attention à NULL

On ne teste pas NULL avec = NULL, mais avec IS NULL ou IS NOT NULL.

Trier et paginer avec ORDER BY et LIMIT

ORDER BY permet de trier les résultats. LIMIT permet de limiter le nombre de lignes retournées.

SELECT *
FROM produits
ORDER BY prix ASC;

SELECT *
FROM commandes
ORDER BY created_at DESC;

SELECT *
FROM produits
ORDER BY id DESC
LIMIT 10 OFFSET 0;

SELECT *
FROM produits
ORDER BY id DESC
LIMIT 10 OFFSET 10;

Modifier des données avec UPDATE

UPDATE permet de modifier des lignes existantes. Il faut toujours utiliser WHERE pour éviter de modifier toute la table.

UPDATE clients
SET ville = 'Saint-Chamond'
WHERE id = 1;

UPDATE produits
SET prix = 89.00
WHERE slug = 'formation-sql';

UPDATE produits
SET is_active = 0
WHERE id = 4;

La règle d’or

Avant un UPDATE, faites souvent un SELECT avec le même WHERE pour vérifier les lignes concernées.

SELECT *
FROM produits
WHERE slug = 'formation-sql';

Supprimer des données avec DELETE

DELETE supprime définitivement des lignes. Cette commande doit être utilisée avec prudence, surtout depuis phpMyAdmin.

DELETE FROM clients
WHERE id = 4;

DELETE FROM commandes
WHERE statut = 'pending';

Alternative plus sûre

Dans beaucoup de projets, on préfère désactiver une ligne plutôt que la supprimer. C’est ce qu’on appelle parfois une suppression logique.

UPDATE clients
SET is_active = 0
WHERE id = 2;

Attention

Un DELETE FROM clients; sans WHERE supprime tous les clients.

Compter et analyser avec COUNT, SUM, AVG, MIN, MAX

SQL permet aussi de faire des calculs sur les données.

SELECT COUNT(*) AS total_clients
FROM clients;

SELECT SUM(total) AS chiffre_affaires
FROM commandes
WHERE statut = 'paid';

SELECT AVG(prix) AS prix_moyen
FROM produits
WHERE is_active = 1;

SELECT
    MIN(prix) AS prix_minimum,
    MAX(prix) AS prix_maximum
FROM produits;

Regrouper les résultats avec GROUP BY

GROUP BY permet de regrouper des lignes pour faire des statistiques.

SELECT
    ville,
    COUNT(*) AS total_clients
FROM clients
GROUP BY ville
ORDER BY total_clients DESC;

SELECT
    statut,
    COUNT(*) AS nombre_commandes,
    SUM(total) AS total_montant
FROM commandes
GROUP BY statut;

SELECT
    statut,
    COUNT(*) AS nombre_commandes
FROM commandes
GROUP BY statut
HAVING nombre_commandes >= 1;

WHERE ou HAVING ?

WHERE filtre avant le regroupement. HAVING filtre après le regroupement.

Relier plusieurs tables avec JOIN

Une jointure permet de récupérer des données réparties dans plusieurs tables. C’est indispensable dans une vraie base relationnelle.

SELECT
    commandes.id AS commande_id,
    commandes.statut,
    commandes.total,
    commandes.created_at,
    clients.prenom,
    clients.nom,
    clients.email
FROM commandes
INNER JOIN clients ON clients.id = commandes.client_id
ORDER BY commandes.created_at DESC;

SELECT
    commandes.id AS commande_id,
    clients.email,
    produits.nom AS produit,
    commande_lignes.quantite,
    commande_lignes.prix_unitaire,
    commande_lignes.quantite * commande_lignes.prix_unitaire AS sous_total
FROM commande_lignes
INNER JOIN commandes ON commandes.id = commande_lignes.commande_id
INNER JOIN clients ON clients.id = commandes.client_id
INNER JOIN produits ON produits.id = commande_lignes.produit_id
ORDER BY commandes.id DESC;

SELECT
    clients.id,
    clients.prenom,
    clients.nom,
    commandes.id AS commande_id
FROM clients
LEFT JOIN commandes ON commandes.client_id = clients.id
ORDER BY clients.id ASC;

INNER JOIN ou LEFT JOIN ?

INNER JOIN affiche uniquement les lignes qui ont une correspondance. LEFT JOIN garde toutes les lignes de la table de gauche, même sans correspondance.

Créer des vues avec CREATE VIEW

Une vue est une requête enregistrée. Elle permet de simplifier des requêtes longues et de les réutiliser plus facilement.

CREATE VIEW vue_commandes_detaillees AS
SELECT
    commandes.id AS commande_id,
    commandes.statut,
    commandes.total,
    commandes.created_at,
    clients.prenom,
    clients.nom,
    clients.email
FROM commandes
INNER JOIN clients ON clients.id = commandes.client_id;

SELECT *
FROM vue_commandes_detaillees
WHERE statut = 'paid'
ORDER BY created_at DESC;

DROP VIEW IF EXISTS vue_commandes_detaillees;

Utilité concrète

Une vue est pratique pour préparer un tableau de bord, une page admin, une exportation ou une requête souvent utilisée.

Accélérer les recherches avec les index

Un index aide MySQL à retrouver plus vite les lignes. Il est utile sur les colonnes souvent utilisées dans les WHERE, JOIN ou ORDER BY.

CREATE INDEX idx_clients_ville
ON clients (ville);

CREATE INDEX idx_commandes_statut
ON commandes (statut);

EXPLAIN
SELECT *
FROM commandes
WHERE statut = 'paid';

Attention

Trop d’index peuvent ralentir les insertions et les mises à jour. Il faut indexer intelligemment, pas tout indexer au hasard.

Modifier la structure avec ALTER TABLE

ALTER TABLE permet de modifier une table existante : ajouter une colonne, modifier un type, ajouter un index ou renommer une colonne.

ALTER TABLE clients
ADD COLUMN notes TEXT NULL AFTER ville;

ALTER TABLE produits
MODIFY COLUMN stock INT NOT NULL DEFAULT 0;

ALTER TABLE produits
ADD COLUMN updated_at DATETIME NULL DEFAULT NULL AFTER created_at;

ALTER TABLE clients
DROP COLUMN notes;

Bonne pratique

Avant un ALTER TABLE, faites toujours une sauvegarde si la base contient des données importantes.

Sécuriser plusieurs actions avec les transactions

Une transaction permet d’exécuter plusieurs requêtes ensemble. Si tout se passe bien, on valide avec COMMIT. En cas de problème, on annule avec ROLLBACK.

START TRANSACTION;

INSERT INTO commandes (client_id, statut, total)
VALUES (1, 'paid', 79.00);

SET @commande_id = LAST_INSERT_ID();

INSERT INTO commande_lignes (commande_id, produit_id, quantite, prix_unitaire)
VALUES (@commande_id, 3, 1, 79.00);

UPDATE produits
SET stock = stock - 1
WHERE id = 3
  AND stock > 0;

COMMIT;

START TRANSACTION;

UPDATE produits
SET stock = stock - 10
WHERE id = 3;

ROLLBACK;

Utilité concrète

Les transactions sont très utiles pour les commandes, paiements, inscriptions, réservations ou opérations sensibles.

Requêtes utiles dans phpMyAdmin

Voici plusieurs requêtes utiles pour explorer une base depuis phpMyAdmin.

SHOW TABLES;

DESCRIBE clients;

SHOW CREATE TABLE clients;

SHOW INDEX FROM clients;

SHOW TABLES LIKE '%client%';

SELECT 'clients' AS table_name, COUNT(*) AS total FROM clients
UNION ALL
SELECT 'produits' AS table_name, COUNT(*) AS total FROM produits
UNION ALL
SELECT 'commandes' AS table_name, COUNT(*) AS total FROM commandes;

Comprendre les erreurs fréquentes

Quand une requête échoue dans phpMyAdmin, le message d’erreur donne souvent une indication utile.

Erreur de syntaxe

Elle arrive souvent à cause d’une virgule oubliée, d’une apostrophe mal fermée ou d’un mot réservé utilisé comme nom de colonne.

-- Mauvais exemple
INSERT INTO clients (prenom, nom, email)
VALUES ('Léo', 'D'argent', 'leo@example.com');

-- Correction possible
INSERT INTO clients (prenom, nom, email)
VALUES ('Léo', 'D''argent', 'leo2@example.com');

Erreur de contrainte unique

Si une colonne possède une contrainte UNIQUE, deux lignes ne peuvent pas avoir la même valeur.

-- Cette requête échoue si julie@example.com existe déjà
INSERT INTO clients (prenom, nom, email)
VALUES ('Julie', 'Dupont', 'julie@example.com');

Erreur de clé étrangère

Elle arrive quand vous essayez de créer une commande pour un client qui n’existe pas.

-- Échoue si aucun client avec id 999 n’existe
INSERT INTO commandes (client_id, statut, total)
VALUES (999, 'paid', 49.00);

SQL et sécurité côté PHP

Dans phpMyAdmin, on écrit directement du SQL. Mais dans un vrai site PHP, il ne faut jamais concaténer directement les données utilisateur dans une requête.

Mauvais exemple

$email = $_POST['email'];

$sql = "SELECT * FROM clients WHERE email = '$email'";
$result = $pdo->query($sql);

Bon exemple avec requête préparée

$stmt = $pdo->prepare("
    SELECT *
    FROM clients
    WHERE email = :email
    LIMIT 1
");

$stmt->execute([
    'email' => $_POST['email'],
]);

$client = $stmt->fetch(PDO::FETCH_ASSOC);

Les requêtes préparées protègent contre les injections SQL et rendent le code plus propre.

Sauvegarder, importer et exporter avec phpMyAdmin

Avant de modifier une base importante, il faut savoir l’exporter. phpMyAdmin permet de générer un fichier SQL contenant la structure et les données.

Exporter une base

Dans phpMyAdmin, sélectionnez la base, cliquez sur Exporter, choisissez le format SQL, puis téléchargez le fichier.

Importer une base

Sélectionnez une base vide, cliquez sur Importer, choisissez le fichier SQL, puis lancez l’import.

-- Exemple de structure exportée
CREATE TABLE exemple_sauvegarde (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    titre VARCHAR(190) NOT NULL,
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (id)
);

INSERT INTO exemple_sauvegarde (titre) VALUES
('Première donnée'),
('Deuxième donnée');

Conseil

Avant une requête risquée comme DELETE, UPDATE massif ou ALTER TABLE, exportez la table ou la base.

Exercices pratiques

Pour valider la formation, essayez de faire ces exercices directement dans phpMyAdmin.

Exercice 1 : afficher les produits actifs

SELECT *
FROM produits
WHERE is_active = 1
ORDER BY prix ASC;

Exercice 2 : afficher les clients de Lyon ou Paris

SELECT *
FROM clients
WHERE ville IN ('Lyon', 'Paris');

Exercice 3 : calculer le total payé

SELECT SUM(total) AS total_paye
FROM commandes
WHERE statut = 'paid';

Exercice 4 : afficher les commandes avec nom du client

SELECT
    commandes.id,
    commandes.statut,
    commandes.total,
    clients.prenom,
    clients.nom
FROM commandes
INNER JOIN clients ON clients.id = commandes.client_id
ORDER BY commandes.id DESC;

Exercice 5 : créer une vue dashboard

CREATE VIEW vue_dashboard_commandes AS
SELECT
    statut,
    COUNT(*) AS nombre_commandes,
    SUM(total) AS montant_total
FROM commandes
GROUP BY statut;

Récapitulatif de la formation SQL

Vous avez maintenant vu les commandes SQL essentielles à connaître pour travailler sur une base MySQL depuis phpMyAdmin.

-- Créer une base
CREATE DATABASE ma_base CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- Créer une table
CREATE TABLE ma_table (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    titre VARCHAR(190) NOT NULL,
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (id)
);

-- Insérer
INSERT INTO ma_table (titre) VALUES ('Mon titre');

-- Lire
SELECT * FROM ma_table;

-- Filtrer
SELECT * FROM ma_table WHERE id = 1;

-- Modifier
UPDATE ma_table SET titre = 'Nouveau titre' WHERE id = 1;

-- Supprimer
DELETE FROM ma_table WHERE id = 1;

-- Trier
SELECT * FROM ma_table ORDER BY created_at DESC;

-- Compter
SELECT COUNT(*) AS total FROM ma_table;

La suite logique

Après cette formation, vous pouvez continuer avec PDO en PHP, les requêtes préparées, la conception de schémas propres, les relations avancées et l’optimisation SQL.