Apprendre SQL pas à pas : de votre première base SQL Server aux requêtes avancées

Pour apprendre SQL, le plus efficace est de suivre une progression en couches : comprendre ce qu’est une base relationnelle, créer ses propres tables, écrire des requêtes de lecture, filtrer et agréger, relier plusieurs tables par des jointures, puis automatiser avec des vues et des procédures stockées. Chaque couche s’appuie sur la précédente, et SQL Server avec SSMS offre un environnement gratuit et complet pour les pratiquer.

Cette feuille de route s’adresse aux débutants complets comme aux utilisateurs d’Excel, de Power BI ou d’Access qui veulent interroger directement leurs bases de données. Vous y trouverez l’installation de l’environnement, la création d’une première base, les commandes essentielles dans l’ordre où les apprendre, les bons réflexes de sécurité et de performance, et un plan de progression réaliste.

Qu’est-ce que le SQL ?

Le SQL (Structured Query Language) est le langage standard qui sert à créer, interroger et modifier les bases de données relationnelles. Il permet de décrire le résultat voulu, par exemple « le chiffre d’affaires par client en 2025 », et le système de gestion de base de données se charge de trouver comment l’obtenir. SQL Server, MySQL, PostgreSQL, Oracle et SQLite l’utilisent tous.

Une base de données relationnelle organise les informations en tables reliées entre elles. Chaque table décrit un type d’objet (clients, commandes, produits), chaque ligne un enregistrement, chaque colonne un attribut. Les tables sont liées par des clés : la clé primaire identifie une ligne de manière unique, la clé étrangère fait référence à la clé primaire d’une autre table.

Les commandes SQL se répartissent en familles :

Famille	Rôle	Commandes principales
DDL (définition)	Créer et modifier la structure	CREATE, ALTER, DROP
DML (manipulation)	Lire et modifier les données	SELECT, INSERT, UPDATE, DELETE
DCL (contrôle)	Gérer les droits	GRANT, REVOKE
TCL (transactions)	Valider ou annuler des modifications	BEGIN TRANSACTION, COMMIT, ROLLBACK

Pourquoi apprendre SQL ?

Le SQL est l’une des compétences les plus transversales du monde de la donnée :

• Autonomie : vous extrayez vous-même les données dont vous avez besoin, sans attendre un export.
• Volumes : une requête traite des millions de lignes là où un tableur sature.
• Fiabilité : une requête écrite une fois se rejoue à l’identique, sans manipulation manuelle.
• Universalité : le même langage sert dans SQL Server, PostgreSQL, Snowflake, Databricks ou BigQuery.
• Complémentarité : Power BI, Excel, Python et R savent tous exécuter une requête SQL pour récupérer des données.

Contrôleurs de gestion, analystes, développeurs, chefs de projet, responsables marketing : dès qu’une application stocke ses données dans une base, savoir écrire une requête fait gagner un temps considérable.

Comment apprendre SQL avec SQL Server : les étapes

Étape 1 — Installer SQL Server

Téléchargez SQL Server depuis le site de Microsoft et choisissez l’édition Developer (gratuite, complète, réservée au développement et aux tests) ou Express (gratuite, plus légère). Pendant l’installation :

1. choisissez l’installation de base, qui suffit pour apprendre ;
2. conservez le nom d’instance proposé ;
3. notez le nom du serveur affiché à la fin (par exemple localhost ou NOMPC\SQLEXPRESS pour l’édition Express).

Sur Mac ou Linux, SQL Server peut s’exécuter dans un conteneur Docker, avec Visual Studio Code et l’extension mssql comme outil de requête.

Étape 2 — Installer et découvrir SSMS

SQL Server Management Studio (SSMS) est l’outil gratuit de Microsoft pour se connecter à SQL Server, explorer les bases et écrire des requêtes. Installez-le, lancez-le, puis connectez-vous au serveur avec l’authentification Windows.

Repérez trois zones :

• l’Explorateur d’objets, à gauche, qui liste les bases, tables, vues et procédures ;
• l’éditeur de requêtes, ouvert avec le bouton Nouvelle requête (ou Ctrl+N) ;
• le volet des résultats, sous l’éditeur, qui affiche les lignes renvoyées et les messages.

Pour exécuter une requête, appuyez sur F5 ou cliquez sur Exécuter. Si du texte est sélectionné, seule la sélection est exécutée : c’est très pratique pour tester une requête parmi d’autres dans un même script.

Étape 3 — Créer une base de données

Deux méthodes : dans l’Explorateur d’objets, clic droit sur Bases de données > Nouvelle base de données, ou en SQL :

CREATE DATABASE Formation;
GO

USE Formation;
GO

USE indique la base active pour les requêtes suivantes. Le sélecteur de base, dans la barre d’outils de SSMS, remplit le même rôle. Pour modifier ou supprimer une base : ALTER DATABASE et DROP DATABASE, à manier avec précaution.

Étape 4 — Créer des tables reliées

CREATE TABLE dbo.Clients (
    ClientId     INT IDENTITY(1,1) PRIMARY KEY,
    Nom          NVARCHAR(100) NOT NULL,
    Ville        NVARCHAR(50),
    DateCreation DATE DEFAULT GETDATE()
);

CREATE TABLE dbo.Commandes (
    CommandeId   INT IDENTITY(1,1) PRIMARY KEY,
    ClientId     INT NOT NULL,
    DateCommande DATE NOT NULL,
    Montant      DECIMAL(10,2) NOT NULL CHECK (Montant >= 0),
    CONSTRAINT FK_Commandes_Clients
        FOREIGN KEY (ClientId) REFERENCES dbo.Clients (ClientId)
);

Quelques notions apparaissent ici :

• IDENTITY(1,1) génère automatiquement un identifiant qui commence à 1 et augmente de 1 ;
• PRIMARY KEY garantit l’unicité de chaque ligne ;
• NOT NULL rend une colonne obligatoire ;
• DEFAULT fournit une valeur par défaut ;
• CHECK impose une règle de validité ;
• FOREIGN KEY empêche d’enregistrer une commande pour un client qui n’existe pas.

Pour modifier une table existante, utilisez ALTER TABLE (ajouter une colonne, une contrainte) et, pour la renommer, la procédure système sp_rename.

Étape 5 — Insérer, lire, modifier et supprimer des données

INSERT INTO dbo.Clients (Nom, Ville)
VALUES (N'Atelier Nord', N'Lille'),
       (N'Bureau Sud', N'Marseille'),
       (N'Studio Ouest', N'Nantes');

INSERT INTO dbo.Commandes (ClientId, DateCommande, Montant)
VALUES (1, '2026-01-15', 1250.00),
       (1, '2026-02-03', 430.00),
       (2, '2026-02-10', 980.50);

SELECT Nom, Ville
FROM dbo.Clients
WHERE Ville = N'Lille';

UPDATE dbo.Commandes
SET Montant = 450.00
WHERE CommandeId = 2;

DELETE FROM dbo.Commandes
WHERE CommandeId = 3;

Le préfixe N devant une chaîne indique du texte Unicode, adapté aux colonnes NVARCHAR et aux caractères accentués.

La règle d’or : n’exécutez jamais un UPDATE ou un DELETE sans WHERE, sauf si vous voulez réellement modifier toutes les lignes. Écrivez d’abord un SELECT avec la même condition pour vérifier les lignes concernées, puis remplacez le SELECT par la modification.

Étape 6 — Filtrer, trier et agréger

Une fois les données en place, l’essentiel du travail consiste à les interroger. Les clauses à maîtriser, dans l’ordre d’écriture :

SELECT   c.Ville,
         COUNT(*)        AS NbCommandes,
         SUM(o.Montant)  AS ChiffreAffaires
FROM     dbo.Commandes AS o
JOIN     dbo.Clients   AS c ON c.ClientId = o.ClientId
WHERE    o.DateCommande >= '2026-01-01'
GROUP BY c.Ville
HAVING   SUM(o.Montant) > 500
ORDER BY ChiffreAffaires DESC;

• WHERE filtre les lignes avant le regroupement ;
• GROUP BY regroupe pour calculer des agrégats (COUNT, SUM, AVG, MIN, MAX) ;
• HAVING filtre les groupes après le calcul ;
• ORDER BY trie le résultat final.

À cela s’ajoutent les opérateurs de filtre (LIKE, BETWEEN, IN, IS NULL), DISTINCT, TOP et OFFSET pour la pagination. Chacune de ces clauses est illustrée par des exemples commentés dans notre recueil de requêtes SQL expliquées.

Étape 7 — Transformer les données avec les fonctions T-SQL

T-SQL fournit de nombreuses fonctions pour nettoyer et présenter les données :

SELECT
    UPPER(RTRIM(Nom))                          AS NomPropre,
    LEFT(Ville, 3)                             AS CodeVille,
    FORMAT(DateCreation, 'dd/MM/yyyy')         AS DateFr,
    COALESCE(Ville, N'Non renseignée')         AS VilleAffichee,
    IIF(Ville = N'Lille', N'Nord', N'Autre')   AS Zone,
    CASE
        WHEN LEN(Nom) > 12 THEN N'Nom long'
        ELSE N'Nom court'
    END                                        AS TypeNom,
    TRY_CAST(N'12,5' AS DECIMAL(5,2))          AS ConversionEssai
FROM dbo.Clients;

TRY_CAST et TRY_CONVERT renvoient NULL au lieu de provoquer une erreur quand la conversion échoue : ici, la virgule décimale n’étant pas reconnue, la dernière colonne vaut NULL. C’est précieux pour repérer les valeurs mal formatées dans une colonne de texte.

Étape 8 — Relier les tables avec les jointures

Les jointures sont le cœur du SQL relationnel :

• INNER JOIN : uniquement les lignes qui ont une correspondance des deux côtés ;
• LEFT JOIN : toutes les lignes de la table de gauche, avec NULL quand il n’y a pas de correspondance ;
• RIGHT JOIN et FULL JOIN : l’inverse, ou toutes les lignes des deux côtés ;
• CROSS JOIN : toutes les combinaisons possibles.

Exemple classique : trouver les clients qui n’ont jamais commandé.

SELECT c.Nom
FROM dbo.Clients AS c
WHERE NOT EXISTS (
    SELECT 1
    FROM dbo.Commandes AS o
    WHERE o.ClientId = c.ClientId
);

Le même résultat s’obtient avec un LEFT JOIN suivi de WHERE o.CommandeId IS NULL. NOT EXISTS exprime souvent l’intention plus clairement.

Automatiser avec les vues, les procédures et les schémas

Créer une vue

Une vue est une requête enregistrée que l’on interroge comme une table. Elle simplifie l’accès aux données pour les utilisateurs et les outils de reporting :

CREATE OR ALTER VIEW dbo.v_CA_Clients AS
SELECT c.ClientId, c.Nom, c.Ville,
       SUM(o.Montant) AS ChiffreAffaires,
       COUNT(*)       AS NbCommandes
FROM dbo.Clients AS c
JOIN dbo.Commandes AS o ON o.ClientId = c.ClientId
GROUP BY c.ClientId, c.Nom, c.Ville;
GO

SELECT * FROM dbo.v_CA_Clients ORDER BY ChiffreAffaires DESC;

Power BI, Excel et la plupart des outils de BI peuvent se connecter directement à une vue : c’est une bonne façon de leur fournir des données déjà préparées. Pour la suite côté Power BI, notre guide Power Query dans Power BI explique comment importer une table ou une vue SQL Server.

Écrire une procédure stockée

Une procédure stockée est un programme T-SQL enregistré dans la base, qui accepte des paramètres :

CREATE OR ALTER PROCEDURE dbo.ps_CommandesClient
    @ClientId INT,
    @DateDebut DATE = '2026-01-01'
AS
BEGIN
    SET NOCOUNT ON;

    DECLARE @Total DECIMAL(12,2);

    SELECT @Total = SUM(Montant)
    FROM dbo.Commandes
    WHERE ClientId = @ClientId
      AND DateCommande >= @DateDebut;

    PRINT CONCAT(N'Total : ', COALESCE(@Total, 0));

    SELECT CommandeId, DateCommande, Montant
    FROM dbo.Commandes
    WHERE ClientId = @ClientId
      AND DateCommande >= @DateDebut
    ORDER BY DateCommande;
END;
GO

EXEC dbo.ps_CommandesClient @ClientId = 1;

Les procédures centralisent la logique métier, se réutilisent et permettent d’accorder à un utilisateur le droit de les exécuter sans lui donner accès directement aux tables.

Organiser la base avec des schémas

Un schéma est un espace de noms qui regroupe des objets : dbo par défaut, mais vous pouvez créer ventes, rh ou staging pour séparer les domaines et gérer les droits par schéma.

CREATE SCHEMA ventes;
GO
ALTER SCHEMA ventes TRANSFER dbo.Commandes;

Performances et sécurité : les bons réflexes

Écrire des requêtes SARGables

Une condition est SARGable (Search ARGument ABLE) quand le moteur peut utiliser un index pour la résoudre. Appliquer une fonction à la colonne filtrée empêche généralement cet usage :

-- À éviter : la fonction YEAR est appliquée à chaque ligne
SELECT * FROM dbo.Commandes WHERE YEAR(DateCommande) = 2026;

-- Préférable : la colonne reste intacte, l'index est utilisable
SELECT * FROM dbo.Commandes
WHERE DateCommande >= '2026-01-01'
  AND DateCommande <  '2027-01-01';

Même logique pour LEFT(Nom, 3) = 'Ate', à remplacer par Nom LIKE 'Ate%'.

Lire le plan d’exécution

Pour comprendre pourquoi une requête est lente, SSMS affiche le plan d’exécution : activez Inclure le plan d’exécution réel (Ctrl+M) avant d’exécuter la requête, puis ouvrez l’onglet correspondant à côté des résultats. Le schéma montre les opérations effectuées par le moteur, de droite à gauche, avec leur coût relatif. Une opération « Table Scan » ou « Clustered Index Scan » sur une grosse table, là où vous attendiez une recherche ciblée (« Index Seek »), signale souvent une condition non SARGable ou un index manquant. Inutile de tout comprendre au début : repérer l’opération la plus coûteuse suffit déjà à orienter la correction.

Sécuriser les modifications

• Utilisez des transactions : BEGIN TRANSACTION, vérifiez le résultat, puis COMMIT ou ROLLBACK.
• Sauvegardez avant toute opération lourde (clic droit sur la base > Tâches > Sauvegarder).
• Utilisez DROP TABLE IF EXISTS dans vos scripts de test pour qu’ils soient rejouables sans erreur.
• Limitez les droits : un compte de reporting n’a besoin que de lire.
• Commentez vos scripts avec -- ou /* ... */ : vous vous remercierez dans six mois.

Les erreurs fréquentes quand on apprend SQL

Erreur	Conséquence	Bonne pratique
UPDATE ou DELETE sans WHERE	Toutes les lignes modifiées	SELECT de contrôle d’abord, transaction
Tester = NULL	Aucune ligne renvoyée	Utiliser IS NULL ou IS NOT NULL
Oublier une colonne dans GROUP BY	Erreur « n’est pas valide dans la liste de sélection »	Toute colonne non agrégée doit figurer dans GROUP BY
Filtrer un agrégat dans WHERE	Erreur de syntaxe	Utiliser HAVING
Jointure sur une clé non unique	Lignes dupliquées, totaux gonflés	Vérifier la cardinalité avant de joindre
SELECT * partout	Requêtes lentes, fragiles	Nommer les colonnes utiles
Fonction appliquée à une colonne filtrée	Index inutilisable	Réécrire la condition de façon SARGable
Exécuter tout le script par erreur	Commandes non voulues lancées	Sélectionner la requête avant F5

Quel système de base de données choisir pour apprendre ?

Système	Points forts	Idéal pour
SQL Server	Outil SSMS complet, très présent en entreprise, intégration Microsoft et Power BI	Environnements Microsoft, BI, finance
PostgreSQL	Libre, très riche, respect des standards	Développement, data engineering
MySQL / MariaDB	Libre, très répandu sur le web	Sites et applications web
SQLite	Un simple fichier, aucune installation serveur	Premiers pas, applications locales
Oracle	Très présent dans les grands comptes	Grandes entreprises, systèmes critiques

Les bases du langage sont communes à tous ces systèmes : ce que vous apprenez sur SQL Server se transpose facilement. Si vous utilisez aujourd’hui Access pour de petites bases, notre guide Word, Outlook et Access vous aidera à faire le lien avec le modèle relationnel. Et pour découvrir une autre approche, sans tables ni schéma fixe, lisez notre introduction à MongoDB.

Comment se former au SQL efficacement ?

Voici un plan de progression réaliste, à raison de quelques heures par semaine :

1. Semaine 1 : installation, SSMS, création de bases et de tables, INSERT, SELECT, UPDATE, DELETE.
2. Semaine 2 : WHERE, opérateurs, NULL, ORDER BY, DISTINCT, TOP, alias.
3. Semaine 3 : agrégations, GROUP BY, HAVING, fonctions de texte et de date, CASE WHEN.
4. Semaine 4 : jointures, sous-requêtes, UNION, EXCEPT.
5. Semaines 5 et 6 : vues, procédures stockées, variables, schémas, SARGabilité.

À chaque étape, faites des exercices : recréez les rapports que vous produisez dans Excel, posez-vous des questions sur vos données et écrivez la requête qui y répond.

Pour suivre ce parcours avec des exercices corrigés à chaque étape, la formation vidéo SQL Server d’EspritAcadémique réunit 6 h 30 de contenu, sans prérequis. Elle couvre notamment :

• l’installation de SQL Server et de SSMS, puis la création et la modification de bases et de tables ;
• les requêtes fondamentales SELECT, INSERT, UPDATE et DELETE, avec alias, LIKE, TOP, DISTINCT et gestion des NULL ;
• les filtres, tris et agrégations : AND/OR, ORDER BY, GROUP BY, HAVING, MIN/MAX, COUNT/SUM ;
• les fonctions T-SQL de transformation : SUBSTRING, FORMAT, CASE WHEN, IIF, COALESCE, CAST et TRY_CAST ;
• toutes les jointures, CROSS APPLY, EXCEPT et UNION ;
• les vues, les procédures stockées avec variables, les schémas et l’écriture de requêtes SARGables.

Une fois le SQL acquis, il devient un excellent tremplin vers la visualisation : notre feuille de route pour apprendre Power BI vous montre comment exploiter vos requêtes dans des tableaux de bord.

En résumé

Apprendre SQL, c’est d’abord comprendre le modèle relationnel, puis maîtriser dans l’ordre la création de tables, les requêtes de lecture, les filtres et agrégations, les jointures et enfin les vues et procédures. SQL Server Developer et SSMS offrent un environnement gratuit et complet pour pratiquer. Prenez dès le début les bons réflexes : un SELECT de contrôle avant chaque modification, des transactions, des conditions SARGables et des scripts commentés.