Menu

Formation SQL

Apprenez SQL, le langage standard pour gérer et manipuler les bases de données

Faire un don

Créez un compte gratuitement

Suivez votre progression, sauvegardez vos avancées et obtenez des certificats de complétion. Rejoignez des milliers d'apprenants qui développent leurs compétences avec nous !

Suivi de progression détaillé
Certificats téléchargeables
Badges et accomplissements

Introduction à SQL

SQL (Structured Query Language) est le langage standard pour gérer et manipuler les bases de données relationnelles. Créé dans les années 1970, SQL est aujourd'hui utilisé par tous les systèmes de gestion de bases de données (SGBD) majeurs : MySQL, PostgreSQL, SQL Server, Oracle, SQLite, etc.

🗄️ Qu'est-ce que SQL ?

SQL est un langage déclaratif utilisé pour interagir avec les bases de données relationnelles. Contrairement aux langages de programmation impératifs, SQL décrit ce que vous voulez plutôt que comment l'obtenir. SQL permet de créer, lire, modifier et supprimer des données dans une base de données.

💡 Pourquoi SQL est si important ?

  1. Standard universel - SQL est le langage standard pour interagir avec les bases de données relationnelles, utilisé partout dans le monde
  2. Indispensable pour les développeurs - Presque toutes les applications modernes utilisent des bases de données, SQL est donc essentiel
  3. Gestion efficace des données - Permet de stocker, récupérer, modifier et analyser de grandes quantités de données efficacement
  4. Compatible avec tous les SGBD - Fonctionne avec MySQL, PostgreSQL, SQL Server, Oracle, SQLite, etc.
  5. Syntaxe déclarative - Vous décrivez ce que vous voulez, pas comment l'obtenir, ce qui rend le code plus lisible
  6. Très demandé - Compétence essentielle recherchée par les employeurs dans le développement web, data science, business intelligence

🚀 Pourquoi apprendre SQL ?

SQL est essentiel pour tout développeur ou professionnel travaillant avec des données :

  • ✅ Développement web - Toutes les applications web modernes utilisent des bases de données (e-commerce, réseaux sociaux, CMS)
  • ✅ Data Science - Extraction et analyse de données pour prendre des décisions basées sur les données
  • ✅ Business Intelligence - Création de rapports, tableaux de bord, analyses commerciales
  • ✅ Très demandé - Compétence recherchée dans presque tous les domaines : développement, marketing, finance, gestion
  • ✅ Syntaxe simple - SQL est relativement facile à apprendre avec une syntaxe proche de l'anglais
  • ✅ Standard universel - Une fois appris, vous pouvez l'utiliser avec n'importe quel système de gestion de base de données
  • ✅ Performance - Permet d'optimiser les requêtes pour gérer efficacement de grandes quantités de données

📋 Prérequis pour apprendre SQL

Pour apprendre SQL, il est recommandé d'avoir :

  • ✅ Informatique de base - Savoir utiliser un ordinateur, créer et éditer des fichiers
  • ✅ Logique - Comprendre les concepts de base (conditions, filtres) est utile mais pas obligatoire
  • ✅ Notions de bases de données - Comprendre ce qu'est une table, une ligne, une colonne facilite l'apprentissage

💡 Note importante : Pour pratiquer SQL, vous pouvez installer un système de gestion de base de données gratuit comme MySQL, PostgreSQL ou SQLite. SQLite est particulièrement simple car il ne nécessite pas de serveur. Vous pouvez aussi utiliser des environnements en ligne comme SQLFiddle, DB-Fiddle, ou des outils comme phpMyAdmin, DBeaver, ou MySQL Workbench pour une interface graphique.

🎯 Cas d'usage de SQL

SQL est utilisé dans de nombreux domaines :

  • Développement web - Sites e-commerce, réseaux sociaux, CMS, applications web stockent leurs données en base
  • Data Science - Extraction, transformation et analyse de données pour l'analyse prédictive
  • Business Intelligence - Création de rapports, tableaux de bord, analyses commerciales et financières
  • Finance - Gestion des transactions, comptabilité, rapports financiers
  • Santé - Gestion des dossiers patients, systèmes d'information hospitaliers
  • E-commerce - Gestion des produits, commandes, clients, inventaires
  • Applications mobiles - Stockage local avec SQLite ou synchronisation avec serveurs distants
  • Recherche - Moteurs de recherche, catalogues, systèmes de recommandation

📝 Syntaxe de base

SQL (Structured Query Language) est le langage standard pour interagir avec les bases de données relationnelles. SQL permet de créer, lire, modifier et supprimer des données dans une base de données.

-- Commentaire SQL (ligne unique)
/* Commentaire multi-lignes */

-- Requête SELECT de base
SELECT * FROM utilisateurs;

-- Sélectionner des colonnes spécifiques
SELECT nom, email FROM utilisateurs;

-- Filtrer avec WHERE
SELECT nom, age FROM utilisateurs WHERE age >= 18;

-- Trier avec ORDER BY
SELECT nom, age FROM utilisateurs ORDER BY age DESC;

-- Limiter les résultats
SELECT * FROM utilisateurs LIMIT 10;

💡 Points importants sur la syntaxe SQL :

  • SQL n'est pas sensible à la casse - SELECT et select sont équivalents (mais utilisez les majuscules pour les mots-clés)
  • Les commentaires utilisent -- pour une ligne ou /* */ pour plusieurs lignes
  • Le point-virgule ; termine généralement une requête (optionnel dans certains SGBD)
  • Les chaînes de caractères utilisent des guillemets simples ' ou doubles " selon le SGBD
  • Les noms de tables et colonnes peuvent être entre guillemets si ils contiennent des caractères spéciaux
  • SQL est déclaratif - Vous décrivez ce que vous voulez, pas comment l'obtenir

🔍 Exemple détaillé de requête SQL

Voici un exemple complet montrant plusieurs aspects de SQL :

-- Requête complexe avec plusieurs clauses
SELECT 
    u.nom,
    u.email,
    COUNT(c.id) AS nombre_commandes,
    SUM(c.montant) AS total_achats
FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id
WHERE u.ville = 'Dakar'
    AND u.age >= 18
GROUP BY u.id, u.nom, u.email
HAVING COUNT(c.id) > 0
ORDER BY total_achats DESC
LIMIT 10;

📊 Types de données

SQL supporte plusieurs types de données pour stocker différentes sortes d'informations. Les types varient légèrement selon le SGBD (MySQL, PostgreSQL, SQL Server, etc.), mais les principaux types sont similaires.

-- Types numériques
INT                 -- Entier (ex: 42)
BIGINT              -- Grand entier (ex: 1234567890)
DECIMAL(10, 2)      -- Nombre décimal avec précision (ex: 19.99)
FLOAT               -- Nombre à virgule flottante (ex: 3.14)
DOUBLE              -- Double précision

-- Types texte
VARCHAR(255)        -- Chaîne de caractères variable (max 255)
CHAR(10)            -- Chaîne de caractères fixe (10 caractères)
TEXT                -- Texte long (illimité)
TINYTEXT            -- Texte très court

-- Types date/heure
DATE                -- Date uniquement (YYYY-MM-DD)
TIME                -- Heure uniquement (HH:MM:SS)
DATETIME            -- Date et heure (YYYY-MM-DD HH:MM:SS)
TIMESTAMP           -- Horodatage (auto-mise à jour)

-- Types booléens
BOOLEAN             -- Booléen (TRUE/FALSE)
TINYINT(1)          -- Alternative (0/1)

-- Types binaires
BLOB                -- Données binaires
JSON                -- Données JSON (PostgreSQL, MySQL 5.7+)

-- Exemple de création de table avec types
CREATE TABLE utilisateurs (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE,
    age INT,
    solde DECIMAL(10, 2) DEFAULT 0.00,
    actif BOOLEAN DEFAULT TRUE,
    date_creation DATETIME DEFAULT CURRENT_TIMESTAMP
);

📌 Règles pour les types de données :

  • INT - Pour les nombres entiers (positifs, négatifs, zéro)
  • VARCHAR(n) - Pour les chaînes de longueur variable (spécifiez la longueur max)
  • CHAR(n) - Pour les chaînes de longueur fixe (rempli avec des espaces si nécessaire)
  • DECIMAL(p, s) - Pour les nombres décimaux précis (p = précision totale, s = décimales)
  • DATE/DATETIME - Pour stocker des dates et heures
  • NOT NULL - Contrainte pour empêcher les valeurs nulles
  • DEFAULT - Valeur par défaut si non spécifiée

🔢 Opérateurs SQL

SQL supporte plusieurs types d'opérateurs pour comparer, combiner et manipuler des données dans les requêtes.

-- Opérateurs de comparaison
SELECT * FROM produits WHERE prix > 100;        -- Supérieur à
SELECT * FROM produits WHERE prix < 50;         -- Inférieur à
SELECT * FROM produits WHERE prix >= 100;       -- Supérieur ou égal
SELECT * FROM produits WHERE prix <= 50;        -- Inférieur ou égal
SELECT * FROM produits WHERE prix = 99.99;      -- Égal à
SELECT * FROM produits WHERE prix != 100;       -- Différent de
SELECT * FROM produits WHERE prix <> 100;       -- Différent de (alternative)

-- Opérateurs logiques
SELECT * FROM utilisateurs 
WHERE age >= 18 AND ville = 'Dakar';           -- ET logique

SELECT * FROM produits 
WHERE categorie = 'Électronique' OR prix < 50;  -- OU logique

SELECT * FROM commandes 
WHERE NOT statut = 'annulée';                  -- NON logique

-- Opérateur LIKE (recherche de motifs)
SELECT * FROM utilisateurs WHERE nom LIKE 'B%';     -- Commence par 'B'
SELECT * FROM utilisateurs WHERE email LIKE '%@gmail.com';  -- Se termine par
SELECT * FROM produits WHERE nom LIKE '%téléphone%'; -- Contient 'téléphone'

-- Opérateur IN (dans une liste)
SELECT * FROM produits 
WHERE categorie IN ('Électronique', 'Informatique', 'Téléphonie');

-- Opérateur BETWEEN (entre deux valeurs)
SELECT * FROM produits 
WHERE prix BETWEEN 50 AND 200;

-- Opérateur IS NULL / IS NOT NULL
SELECT * FROM utilisateurs WHERE email IS NULL;
SELECT * FROM utilisateurs WHERE email IS NOT NULL;

📋 Requêtes SELECT

La commande SELECT est la commande la plus utilisée en SQL. Elle permet de récupérer des données d'une ou plusieurs tables.

-- SELECT de base : récupérer toutes les colonnes
SELECT * FROM utilisateurs;

-- SELECT avec colonnes spécifiques
SELECT nom, email, age FROM utilisateurs;

-- SELECT avec alias de colonnes
SELECT 
    nom AS nom_utilisateur,
    email AS adresse_email,
    age AS age_utilisateur
FROM utilisateurs;

-- SELECT avec calculs
SELECT 
    nom,
    prix,
    quantite,
    prix * quantite AS total
FROM commandes;

-- SELECT DISTINCT : éliminer les doublons
SELECT DISTINCT ville FROM utilisateurs;

-- SELECT avec ORDER BY : trier les résultats
SELECT nom, age FROM utilisateurs ORDER BY age ASC;   -- Croissant
SELECT nom, age FROM utilisateurs ORDER BY age DESC;  -- Décroissant
SELECT nom, age, ville FROM utilisateurs ORDER BY ville, age DESC;  -- Tri multiple

-- SELECT avec LIMIT : limiter le nombre de résultats
SELECT * FROM produits LIMIT 10;              -- 10 premiers
SELECT * FROM produits LIMIT 10 OFFSET 20;     -- 10 résultats à partir du 21ème

🔍 Clause WHERE

La clause WHERE permet de filtrer les résultats selon des conditions spécifiques.

-- WHERE simple
SELECT * FROM utilisateurs WHERE age >= 18;

-- WHERE avec plusieurs conditions (AND)
SELECT * FROM produits 
WHERE categorie = 'Électronique' AND prix < 100;

-- WHERE avec OR
SELECT * FROM commandes 
WHERE statut = 'en_attente' OR statut = 'en_cours';

-- WHERE avec LIKE (recherche de motifs)
SELECT * FROM utilisateurs WHERE nom LIKE 'B%';        -- Commence par 'B'
SELECT * FROM utilisateurs WHERE email LIKE '%@gmail.com';  -- Se termine par
SELECT * FROM produits WHERE nom LIKE '%téléphone%';   -- Contient 'téléphone'

-- WHERE avec IN
SELECT * FROM produits 
WHERE categorie IN ('Électronique', 'Informatique', 'Téléphonie');

-- WHERE avec BETWEEN
SELECT * FROM commandes 
WHERE date_commande BETWEEN '2024-01-01' AND '2024-12-31';

-- WHERE avec IS NULL / IS NOT NULL
SELECT * FROM utilisateurs WHERE email IS NULL;
SELECT * FROM utilisateurs WHERE email IS NOT NULL;

🔀 Requêtes SELECT avec conditions

La clause WHERE permet de filtrer les résultats selon des conditions. Vous pouvez combiner plusieurs conditions avec AND, OR et NOT.

-- Condition simple
SELECT * FROM utilisateurs WHERE age >= 18;

-- Conditions multiples avec AND
SELECT * FROM produits 
WHERE categorie = 'Électronique' AND prix < 100;

-- Conditions multiples avec OR
SELECT * FROM commandes 
WHERE statut = 'en_attente' OR statut = 'en_cours';

-- Combinaison AND/OR avec parenthèses
SELECT * FROM utilisateurs 
WHERE (ville = 'Dakar' OR ville = 'Thiès') AND age >= 18;

-- Utilisation de NOT
SELECT * FROM produits 
WHERE NOT categorie = 'Alimentaire';

-- Conditions avec LIKE
SELECT * FROM utilisateurs 
WHERE nom LIKE 'B%' AND email LIKE '%@gmail.com';

-- Conditions avec IN
SELECT * FROM produits 
WHERE id IN (1, 5, 10, 15);

-- Conditions avec BETWEEN
SELECT * FROM commandes 
WHERE date_commande BETWEEN '2024-01-01' AND '2024-12-31';

-- Conditions avec IS NULL
SELECT * FROM utilisateurs 
WHERE telephone IS NULL;

🔗 Jointures (JOINs)

Les jointures permettent de combiner des données de plusieurs tables. Il existe plusieurs types de JOINs : INNER JOIN, LEFT JOIN, RIGHT JOIN, et FULL JOIN.

-- INNER JOIN (jointure interne)
-- Retourne uniquement les lignes qui ont une correspondance dans les deux tables
SELECT u.nom, u.email, c.montant, c.date_commande
FROM utilisateurs u
INNER JOIN commandes c ON u.id = c.utilisateur_id;

-- LEFT JOIN (jointure gauche)
-- Retourne toutes les lignes de la table de gauche, même sans correspondance
SELECT u.nom, u.email, c.montant
FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id;

-- RIGHT JOIN (jointure droite)
-- Retourne toutes les lignes de la table de droite
SELECT u.nom, p.nom AS produit
FROM commandes c
RIGHT JOIN produits p ON c.produit_id = p.id;

-- FULL JOIN (jointure complète) - PostgreSQL, SQL Server
SELECT u.nom, c.montant
FROM utilisateurs u
FULL OUTER JOIN commandes c ON u.id = c.utilisateur_id;

-- Jointure multiple (plusieurs tables)
SELECT u.nom, p.nom AS produit, c.quantite, c.montant
FROM utilisateurs u
INNER JOIN commandes c ON u.id = c.utilisateur_id
INNER JOIN produits p ON c.produit_id = p.id;

-- Auto-jointure (jointure d'une table avec elle-même)
SELECT e1.nom AS employe, e2.nom AS manager
FROM employes e1
LEFT JOIN employes e2 ON e1.manager_id = e2.id;

📊 Fonctions d'agrégation

Les fonctions d'agrégation permettent de calculer des statistiques sur un ensemble de lignes : COUNT, SUM, AVG, MAX, MIN.

-- COUNT : Compter le nombre de lignes
SELECT COUNT(*) FROM utilisateurs;
SELECT COUNT(*) FROM commandes WHERE statut = 'livrée';

-- COUNT avec DISTINCT
SELECT COUNT(DISTINCT ville) FROM utilisateurs;

-- SUM : Somme des valeurs
SELECT SUM(montant) FROM commandes;
SELECT SUM(quantite * prix) AS total FROM commandes;

-- AVG : Moyenne
SELECT AVG(prix) FROM produits;
SELECT AVG(age) FROM utilisateurs WHERE ville = 'Dakar';

-- MAX : Valeur maximale
SELECT MAX(prix) FROM produits;
SELECT MAX(date_commande) FROM commandes;

-- MIN : Valeur minimale
SELECT MIN(prix) FROM produits;
SELECT MIN(age) FROM utilisateurs;

-- Combinaison de fonctions d'agrégation
SELECT 
    COUNT(*) AS nombre_commandes,
    SUM(montant) AS total_ventes,
    AVG(montant) AS moyenne_vente,
    MAX(montant) AS plus_grande_commande,
    MIN(montant) AS plus_petite_commande
FROM commandes
WHERE date_commande >= '2024-01-01';

📦 GROUP BY et HAVING

La clause GROUP BY permet de regrouper des lignes ayant des valeurs identiques dans certaines colonnes. HAVING filtre les groupes après agrégation (similaire à WHERE mais pour les groupes).

-- GROUP BY simple
SELECT ville, COUNT(*) AS nombre_utilisateurs
FROM utilisateurs
GROUP BY ville;

-- GROUP BY avec plusieurs colonnes
SELECT ville, statut, COUNT(*) AS nombre
FROM commandes
GROUP BY ville, statut;

-- GROUP BY avec fonctions d'agrégation
SELECT 
    categorie,
    COUNT(*) AS nombre_produits,
    AVG(prix) AS prix_moyen,
    SUM(stock) AS stock_total
FROM produits
GROUP BY categorie;

-- HAVING : Filtrer les groupes (après GROUP BY)
SELECT 
    utilisateur_id,
    COUNT(*) AS nombre_commandes,
    SUM(montant) AS total
FROM commandes
GROUP BY utilisateur_id
HAVING COUNT(*) > 5;  -- Seulement les utilisateurs avec plus de 5 commandes

-- GROUP BY avec ORDER BY
SELECT 
    ville,
    COUNT(*) AS nombre_utilisateurs,
    AVG(age) AS age_moyen
FROM utilisateurs
GROUP BY ville
ORDER BY nombre_utilisateurs DESC;

-- GROUP BY avec WHERE et HAVING
SELECT 
    categorie,
    AVG(prix) AS prix_moyen
FROM produits
WHERE stock > 0  -- Filtrer avant le GROUP BY
GROUP BY categorie
HAVING AVG(prix) > 50  -- Filtrer après le GROUP BY
ORDER BY prix_moyen DESC;

➕ INSERT, UPDATE, DELETE

Les commandes INSERT, UPDATE et DELETE permettent de modifier les données dans une base de données.

-- INSERT : Insérer de nouvelles lignes
INSERT INTO utilisateurs (nom, email, age, ville)
VALUES ('Bassirou Niang', 'bassirou@example.com', 25, 'Dakar');

-- INSERT multiple
INSERT INTO utilisateurs (nom, email, age, ville)
VALUES 
    ('Aminata Diallo', 'aminata@example.com', 30, 'Thiès'),
    ('Ibrahima Ba', 'ibrahima@example.com', 28, 'Dakar'),
    ('Fatou Sarr', 'fatou@example.com', 22, 'Saint-Louis');

-- INSERT avec SELECT (copier des données)
INSERT INTO utilisateurs_archive (nom, email, age)
SELECT nom, email, age
FROM utilisateurs
WHERE date_creation < '2020-01-01';

-- UPDATE : Modifier des lignes existantes
UPDATE utilisateurs
SET age = 26, ville = 'Thiès'
WHERE id = 1;

-- UPDATE multiple colonnes
UPDATE produits
SET prix = prix * 1.1,  -- Augmenter de 10%
    stock = stock - 5
WHERE categorie = 'Électronique';

-- UPDATE avec condition
UPDATE commandes
SET statut = 'livrée', date_livraison = CURRENT_DATE
WHERE id = 100 AND statut = 'en_cours';

-- DELETE : Supprimer des lignes
DELETE FROM utilisateurs
WHERE id = 5;

-- DELETE avec condition
DELETE FROM commandes
WHERE statut = 'annulée' AND date_commande < '2023-01-01';

-- DELETE avec JOIN (MySQL)
DELETE u FROM utilisateurs u
LEFT JOIN commandes c ON u.id = c.utilisateur_id
WHERE c.id IS NULL;  -- Supprimer les utilisateurs sans commandes

-- TRUNCATE : Vider une table (plus rapide que DELETE)
TRUNCATE TABLE logs;  -- Supprime toutes les lignes mais garde la structure

🔍 Sous-requêtes (Subqueries)

Les sous-requêtes sont des requêtes SQL imbriquées à l'intérieur d'une autre requête. Elles permettent de résoudre des problèmes complexes en plusieurs étapes.

-- Sous-requête dans WHERE (scalaire)
SELECT * FROM produits
WHERE prix > (SELECT AVG(prix) FROM produits);

-- Sous-requête avec IN
SELECT * FROM utilisateurs
WHERE id IN (
    SELECT utilisateur_id 
    FROM commandes 
    WHERE montant > 1000
);

-- Sous-requête avec NOT IN
SELECT * FROM produits
WHERE id NOT IN (
    SELECT produit_id 
    FROM commandes
);

-- Sous-requête dans SELECT (corrélée)
SELECT 
    nom,
    (SELECT COUNT(*) 
     FROM commandes c 
     WHERE c.utilisateur_id = u.id) AS nombre_commandes
FROM utilisateurs u;

-- Sous-requête dans FROM (table dérivée)
SELECT 
    ville,
    COUNT(*) AS nombre_utilisateurs
FROM (
    SELECT DISTINCT ville, id
    FROM utilisateurs
    WHERE age >= 18
) AS utilisateurs_majeurs
GROUP BY ville;

-- Sous-requête avec EXISTS
SELECT * FROM utilisateurs u
WHERE EXISTS (
    SELECT 1 
    FROM commandes c 
    WHERE c.utilisateur_id = u.id
);

-- Sous-requête avec ALL
SELECT * FROM produits
WHERE prix > ALL (
    SELECT prix 
    FROM produits 
    WHERE categorie = 'Alimentaire'
);

-- Sous-requête avec ANY/SOME
SELECT * FROM produits
WHERE prix > ANY (
    SELECT prix 
    FROM produits 
    WHERE categorie = 'Électronique'
);

🏗️ CREATE TABLE et contraintes

La commande CREATE TABLE permet de créer de nouvelles tables dans la base de données. Vous pouvez définir des contraintes pour garantir l'intégrité des données.

-- Création de table simple
CREATE TABLE utilisateurs (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE,
    age INT,
    date_creation DATETIME DEFAULT CURRENT_TIMESTAMP
);

-- Création avec contraintes
CREATE TABLE produits (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nom VARCHAR(255) NOT NULL,
    description TEXT,
    prix DECIMAL(10, 2) NOT NULL CHECK (prix > 0),
    stock INT DEFAULT 0 CHECK (stock >= 0),
    categorie_id INT,
    date_ajout DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (categorie_id) REFERENCES categories(id),
    UNIQUE (nom)
);

-- Contraintes principales
-- PRIMARY KEY : Clé primaire (unique et non nulle)
-- FOREIGN KEY : Clé étrangère (référence une autre table)
-- UNIQUE : Valeur unique dans la colonne
-- NOT NULL : La colonne ne peut pas être NULL
-- CHECK : Vérifie une condition
-- DEFAULT : Valeur par défaut

-- ALTER TABLE : Modifier une table existante
ALTER TABLE utilisateurs
ADD COLUMN telephone VARCHAR(20);

ALTER TABLE utilisateurs
MODIFY COLUMN email VARCHAR(255) NOT NULL;

ALTER TABLE utilisateurs
DROP COLUMN telephone;

-- DROP TABLE : Supprimer une table
DROP TABLE IF EXISTS ancienne_table;

🏗️ CREATE TABLE et contraintes

La commande CREATE TABLE permet de créer de nouvelles tables dans la base de données. Vous pouvez définir des contraintes pour garantir l'intégrité des données.

-- Création de table simple
CREATE TABLE utilisateurs (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nom VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE,
    age INT,
    date_creation DATETIME DEFAULT CURRENT_TIMESTAMP
);

-- Création avec contraintes
CREATE TABLE produits (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nom VARCHAR(255) NOT NULL,
    description TEXT,
    prix DECIMAL(10, 2) NOT NULL CHECK (prix > 0),
    stock INT DEFAULT 0 CHECK (stock >= 0),
    categorie_id INT,
    date_ajout DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (categorie_id) REFERENCES categories(id),
    UNIQUE (nom)
);

-- Contraintes principales
-- PRIMARY KEY : Clé primaire (unique et non nulle)
-- FOREIGN KEY : Clé étrangère (référence une autre table)
-- UNIQUE : Valeur unique dans la colonne
-- NOT NULL : La colonne ne peut pas être NULL
-- CHECK : Vérifie une condition
-- DEFAULT : Valeur par défaut

-- ALTER TABLE : Modifier une table existante
ALTER TABLE utilisateurs
ADD COLUMN telephone VARCHAR(20);

ALTER TABLE utilisateurs
MODIFY COLUMN email VARCHAR(255) NOT NULL;

ALTER TABLE utilisateurs
DROP COLUMN telephone;

ALTER TABLE produits
ADD CONSTRAINT fk_categorie
FOREIGN KEY (categorie_id) REFERENCES categories(id);

-- DROP TABLE : Supprimer une table
DROP TABLE IF EXISTS ancienne_table;

📇 Index et optimisation

Les index améliorent les performances des requêtes en permettant un accès plus rapide aux données. Ils sont particulièrement utiles sur les colonnes fréquemment utilisées dans WHERE, JOIN, et ORDER BY.

-- Créer un index simple
CREATE INDEX idx_email ON utilisateurs(email);

-- Créer un index unique
CREATE UNIQUE INDEX idx_email_unique ON utilisateurs(email);

-- Créer un index composite (plusieurs colonnes)
CREATE INDEX idx_nom_ville ON utilisateurs(nom, ville);

-- Index sur une expression (PostgreSQL)
CREATE INDEX idx_nom_lower ON utilisateurs(LOWER(nom));

-- Vérifier les index d'une table (MySQL)
SHOW INDEX FROM utilisateurs;

-- Supprimer un index
DROP INDEX idx_email ON utilisateurs;

-- Index automatiques
-- PRIMARY KEY crée automatiquement un index
-- UNIQUE crée automatiquement un index

-- Bonnes pratiques pour les index
-- ✅ Créer des index sur les colonnes utilisées dans WHERE
-- ✅ Créer des index sur les colonnes utilisées dans JOIN
-- ✅ Créer des index sur les colonnes utilisées dans ORDER BY
-- ❌ Éviter trop d'index (ralentissent les INSERT/UPDATE)
-- ❌ Éviter les index sur des colonnes peu utilisées

-- EXPLAIN : Analyser l'exécution d'une requête
EXPLAIN SELECT * FROM utilisateurs WHERE email = 'test@example.com';

-- ANALYZE TABLE : Mettre à jour les statistiques (MySQL)
ANALYZE TABLE utilisateurs;

💡 Bonne pratique : Les index améliorent les performances de lecture mais ralentissent les opérations d'écriture (INSERT, UPDATE, DELETE). Créez des index stratégiquement sur les colonnes les plus utilisées dans vos requêtes !

🎓 Prochaines étapes

Félicitations ! Vous avez maintenant une solide base en SQL.

✅ Ce que vous avez appris :

  • Syntaxe SQL de base (SELECT, FROM, WHERE)
  • Types de données SQL (INT, VARCHAR, DATE, DECIMAL, etc.)
  • Opérateurs SQL (comparaison, logiques, LIKE, IN, BETWEEN)
  • Requêtes SELECT avec conditions
  • Jointures (INNER JOIN, LEFT JOIN, RIGHT JOIN)
  • Fonctions d'agrégation (COUNT, SUM, AVG, MAX, MIN)
  • GROUP BY et HAVING
  • INSERT, UPDATE, DELETE
  • Sous-requêtes (subqueries)
  • CREATE TABLE et contraintes
  • Index et optimisation

🚀 Pour aller plus loin :

  • Vues (VIEWS) - Créer des requêtes réutilisables
  • Procédures stockées - Stocker du code SQL réutilisable
  • Triggers - Automatiser des actions sur les données
  • Transactions - Gérer l'intégrité des données
  • Fonctions SQL - Fonctions personnalisées
  • Optimisation avancée - EXPLAIN, query optimization
  • Sécurité - Gestion des utilisateurs et permissions
❮ Précédent: IA Pratiquer avec des exercices ❯
Cliquer pour discuter avec NiangProgrammeur
NiangProgrammeur
En ligne

Bonjour ! 👋

Comment puis-je vous aider aujourd'hui ?

Ouvrir WhatsApp