Pour les débutants · T-SQL · SSMS

SQL Server
Cheat Sheet

Toutes les commandes à connaître pour écrire tes premières requêtes, du CREATE TABLE aux transactions, avec des exemples prêts à copier, du plus simple au plus avancé.

-- Les 3 meilleurs clients
SELECT TOP 3 cl.Nom, COUNT(*) AS NbCommandes, SUM(cm.Total) AS CA
FROM   Clients   AS cl
JOIN   Commandes AS cm ON cm.ClientID = cl.ClientID
GROUP BY cl.Nom
ORDER BY CA DESC;
14chapitres
100+exemples
1jeu de données commun
Avant de commencer

Un jeu de données pour tout le cheat sheet

Tous les exemples utilisent la même petite base Boutique. Copie le script, exécute-le dans SSMS, puis teste chaque requête.

Les 5 tables et leurs relations

Clients

  • ClientID PK
  • Nom
  • Prenom
  • Email
  • Ville
  • DateInscription

Commandes

  • CommandeID PK
  • ClientID FK
  • DateCommande
  • Statut
  • Total

LignesCommande

  • LigneID PK
  • CommandeID FK
  • ProduitID FK
  • Quantite
  • PrixUnitaire

Produits

  • ProduitID PK
  • Nom
  • Prix
  • Stock
  • CategorieID FK

Categories

  • CategorieID PK
  • Nom
Clients 1 ──< N Commandes 1 ──< N LignesCommande N >── 1 Produits N >── 1 Categories

PK = clé primaire (identifie la ligne) · FK = clé étrangère (pointe vers une autre table) · 1 ──< N = « un client a plusieurs commandes ».

Script de création + données À exécuter

CREATE DATABASE Boutique;
GO
USE Boutique;
GO

CREATE TABLE Categories (
    CategorieID INT IDENTITY(1,1) PRIMARY KEY,
    Nom         NVARCHAR(50) NOT NULL
);
CREATE TABLE Produits (
    ProduitID   INT IDENTITY(1,1) PRIMARY KEY,
    Nom         NVARCHAR(100) NOT NULL,
    Prix        DECIMAL(10,2) NOT NULL,
    Stock       INT NOT NULL DEFAULT 0,
    CategorieID INT NULL REFERENCES Categories(CategorieID)
);
CREATE TABLE Clients (
    ClientID        INT IDENTITY(1,1) PRIMARY KEY,
    Nom             NVARCHAR(50) NOT NULL,
    Prenom          NVARCHAR(50) NOT NULL,
    Email           NVARCHAR(120) NULL,
    Ville           NVARCHAR(50) NULL,
    DateInscription DATE NOT NULL DEFAULT GETDATE()
);
CREATE TABLE Commandes (
    CommandeID   INT IDENTITY(1,1) PRIMARY KEY,
    ClientID     INT NOT NULL REFERENCES Clients(ClientID),
    DateCommande DATETIME2 NOT NULL DEFAULT SYSDATETIME(),
    Statut       VARCHAR(20) NOT NULL DEFAULT 'En attente',
    Total        DECIMAL(10,2) NULL
);
CREATE TABLE LignesCommande (
    LigneID      INT IDENTITY(1,1) PRIMARY KEY,
    CommandeID   INT NOT NULL REFERENCES Commandes(CommandeID),
    ProduitID    INT NOT NULL REFERENCES Produits(ProduitID),
    Quantite     INT NOT NULL CHECK (Quantite > 0),
    PrixUnitaire DECIMAL(10,2) NOT NULL
);
GO

INSERT INTO Categories (Nom) VALUES (N'Informatique'), (N'Livres'), (N'Maison');
INSERT INTO Produits (Nom, Prix, Stock, CategorieID) VALUES
    (N'Clavier mécanique',   79.90,  25, 1),
    (N'Souris sans fil',     29.50,  60, 1),
    (N'Roman SQL pour tous', 19.00, 100, 2),
    (N'Lampe de bureau',     35.00,   0, 3);
INSERT INTO Clients (Nom, Prenom, Email, Ville) VALUES
    (N'Benali',  N'Sara',  'sara@mail.dz',  N'Alger'),
    (N'Haddad',  N'Karim', 'karim@mail.dz', N'Oran'),
    (N'Merabet', N'Lina',  NULL,            N'Alger');
INSERT INTO Commandes (ClientID, Statut, Total) VALUES
    (1, 'Livree',     109.40),
    (1, 'En attente',  19.00),
    (2, 'Livree',      35.00);
INSERT INTO LignesCommande (CommandeID, ProduitID, Quantite, PrixUnitaire) VALUES
    (1, 1, 1, 79.90), (1, 2, 1, 29.50), (2, 3, 1, 19.00), (3, 4, 1, 35.00);

Contenu des tables

ClientID Nom Prenom Email Ville
1 Benali Sara sara@mail.dz Alger
2 Haddad Karim karim@mail.dz Oran
3 Merabet Lina NULL Alger
ProduitID Nom Prix Stock Cat.
1 Clavier mécanique 79.90 25 1
2 Souris sans fil 29.50 60 1
3 Roman SQL pour tous 19.00 100 2
4 Lampe de bureau 35.00 0 3
CommandeID ClientID Statut Total
1 1 Livree 109.40
2 1 En attente 19.00
3 2 Livree 35.00

Lina n'a aucune commande et n'a pas d'email : parfait pour comprendre LEFT JOIN et NULL.

01

Démarrer avec SQL Server

SQL est le langage des bases de données ; T-SQL (Transact-SQL) est la version de Microsoft, avec variables, conditions, boucles et gestion d'erreurs. Tu l'écris dans SSMS (SQL Server Management Studio) ou Azure Data Studio.

Ton premier script

Les mots-clés ne sont pas sensibles à la casse. Le ; final est facultatif mais recommandé.

-- Commentaire sur une ligne
/* Commentaire
   sur plusieurs lignes */
SELECT 'Bonjour SQL Server' AS Message;   -- affiche un texte
SELECT 1 + 1 AS Resultat;                 -- calcule : 2
GO   -- sépare les lots (batch) : commande de SSMS, pas du T-SQL

Infos utiles sur le serveur

SELECT @@VERSION;       -- version de SQL Server
SELECT @@SERVERNAME;    -- nom de l'instance
SELECT DB_NAME();       -- base de données courante
SELECT SUSER_SNAME();   -- login connecté
SELECT GETDATE();       -- date et heure actuelles
SELECT NEWID();         -- identifiant unique (GUID)

Ordre d'exécution d'une requête

SQL ne s'exécute pas dans l'ordre où tu l'écris. C'est la clé pour comprendre pourquoi un alias du SELECT n'est pas utilisable dans le WHERE.

  1. FROM / JOIN
  2. WHERE
  3. GROUP BY
  4. HAVING
  5. SELECT
  6. DISTINCT
  7. ORDER BY
  8. TOP / OFFSET
SELECT   Ville, COUNT(*) AS Nb      -- 5
FROM     Clients                    -- 1
WHERE    Email IS NOT NULL          -- 2
GROUP BY Ville                      -- 3
HAVING   COUNT(*) > 0               -- 4
ORDER BY Nb DESC;                   -- 7 (ici l'alias Nb est autorisé)

Les familles de commandes

Famille Rôle Commandes
DDL Définir la structure CREATE ALTER DROP TRUNCATE
DML Modifier les données INSERT UPDATE DELETE MERGE
DQL Lire les données SELECT
DCL Gérer les droits GRANT DENY REVOKE
TCL Gérer les transactions BEGIN TRAN COMMIT ROLLBACK

Règles de syntaxe & nommage

  • Chaînes de texte entre apostrophes : 'Alger'. Pour une apostrophe dans le texte, on la double : 'L''été'.
  • Préfixe N pour l'Unicode (arabe, accents, emojis) : N'Café'.
  • Noms avec espaces ou mots réservés entre crochets : [Date commande], [Order].
  • Schéma par défaut : dbo. Nom complet : Boutique.dbo.Clients.
  • Convention conseillée : PascalCase pour les tables et colonnes, préfixes PK_ FK_ IX_ vw_ usp_.
AstuceSélectionne seulement une partie du script avant F5 pour n'exécuter que cette partie.

Raccourcis SSMS Gain de temps

Raccourci Action
F5 ou Ctrl+E Exécuter (la sélection, sinon tout)
Ctrl+L Plan d'exécution estimé
Ctrl+M Inclure le plan d'exécution réel
Ctrl+K, Ctrl+C Commenter la sélection
Ctrl+K, Ctrl+U Décommenter
Ctrl+Shift+U / L Majuscules / minuscules
Alt+F1 Structure de la table sélectionnée
Ctrl+R Masquer / afficher les résultats
sqlcmd -S localhost -E                       # authentification Windows
sqlcmd -S localhost -U sa -P "MotDePasse"    # authentification SQL
sqlcmd -S localhost -d Boutique -Q "SELECT COUNT(*) FROM Clients"
02

Bases de données & schémas

Une instance SQL Server contient plusieurs bases. Chaque base contient des schémas (des « dossiers »), et chaque schéma contient des tables, vues, procédures…

Créer et utiliser DDL

CREATE DATABASE Boutique;
GO
USE Boutique;        -- choisit la base de travail
GO
AttentionCREATE DATABASE doit être exécuté seul dans son lot : mets un GO après.

Lister les bases

SELECT name, create_date, collation_name FROM sys.databases;
EXEC sp_databases;
SELECT DB_NAME();                          -- base courante
SELECT name FROM sys.databases WHERE database_id > 4;   -- sans les bases système

Modifier une base

ALTER DATABASE Boutique MODIFY NAME = BoutiqueV2;       -- renommer
ALTER DATABASE BoutiqueV2 SET RECOVERY SIMPLE;          -- mode de récupération
ALTER DATABASE BoutiqueV2 SET SINGLE_USER WITH ROLLBACK IMMEDIATE;  -- accès exclusif
ALTER DATABASE BoutiqueV2 SET MULTI_USER;               -- retour à la normale

Supprimer une base

USE master;   -- impossible de supprimer la base dans laquelle on se trouve
DROP DATABASE IF EXISTS Boutique;
AttentionIrréversible sans sauvegarde. Fais un BACKUP avant (voir chapitre 13).

Schémas

CREATE SCHEMA Ventes;
GO
CREATE TABLE Ventes.Factures (FactureID INT PRIMARY KEY);
SELECT * FROM Ventes.Factures;
ALTER SCHEMA dbo TRANSFER Ventes.Factures;   -- déplace la table vers dbo
DROP SCHEMA Ventes;                          -- le schéma doit être vide

Collation (tri, casse, accents)

CI = insensible à la casse · CS = sensible · AI / AS = insensible / sensible aux accents.

CREATE DATABASE Boutique COLLATE French_CI_AS;
SELECT SERVERPROPERTY('Collation');             -- collation du serveur
SELECT * FROM Clients
WHERE  Nom = 'benali' COLLATE French_CS_AS;     -- force la sensibilité à la casse
03

Types de données

Chaque colonne a un type. Bien choisir le type économise de l'espace, accélère les requêtes et évite les erreurs.

Les types à connaître

Famille Type Plage / taille Quand l'utiliser
Entiers TINYINT 0 à 255 Petit code, âge
SMALLINT −32 768 à 32 767 Quantités modestes
INT ± 2,1 milliards Identifiants (le plus courant)
BIGINT ± 9,2 × 10¹⁸ Très grandes tables, compteurs
BIT 0, 1 ou NULL Booléen (actif / inactif)
Décimaux DECIMAL(p,s) Exact : p chiffres dont s après la virgule Prix, montants : DECIMAL(10,2)
MONEY 4 décimales Possible, mais préfère DECIMAL
FLOAT / REAL Approximatif Sciences, mesures. Jamais pour de l'argent
Texte CHAR(n) Longueur fixe, jusqu'à 8000 Codes de taille constante ('DZ')
VARCHAR(n) Variable, jusqu'à 8000 Texte ASCII : emails, codes
NVARCHAR(n) Unicode, jusqu'à 4000 Noms, arabe, accents, emojis
VARCHAR(MAX) / NVARCHAR(MAX) Jusqu'à 2 Go Longs textes, JSON
Dates DATE 0001-01-01 à 9999-12-31 Date de naissance, d'inscription
TIME hh:mm:ss.nnnnnnn Heure seule
DATETIME2(n) Précision jusqu'à 100 ns Horodatage (recommandé)
DATETIME Précision ~3 ms Ancien type, à éviter pour du neuf
DATETIMEOFFSET Date + heure + fuseau Applications internationales
Autres UNIQUEIDENTIFIER GUID de 16 octets Identifiant global unique
VARBINARY(MAX) Binaire Fichiers, images
XML Document XML Données XML typées

Déclarer des variables de chaque type

DECLARE @age         TINYINT          = 25;
DECLARE @prix        DECIMAL(10,2)    = 1999.99;
DECLARE @actif       BIT              = 1;
DECLARE @nom         NVARCHAR(50)     = N'Sara Benali';
DECLARE @code        VARCHAR(10)      = 'DZ-16';
DECLARE @naissance   DATE             = '2000-05-17';
DECLARE @maintenant  DATETIME2(0)     = SYSDATETIME();
DECLARE @id          UNIQUEIDENTIFIER = NEWID();

SELECT @age AS Age, @prix AS Prix, @nom AS Nom, @naissance AS Naissance;

Unicode et formats de date

Sans N, les caractères hors de ta collation peuvent devenir des ?. Pour les dates, le format YYYYMMDD est le seul indépendant de la langue du serveur.

SELECT N'Équipe d''été' AS Texte;      -- Unicode + apostrophe doublée
SELECT CAST('20261120' AS DATE);        -- YYYYMMDD : toujours sûr
SELECT CAST('2026-11-20' AS DATE);      -- ISO : sûr avec DATE / DATETIME2
SELECT CAST('20/11/2026' AS DATE);      -- ⚠ dépend de SET LANGUAGE / DATEFORMAT
AstuceUtilise NVARCHAR par défaut pour les noms de personnes, VARCHAR pour les codes techniques.
04

Tables & contraintes

Les contraintes protègent la qualité de tes données : la base refuse automatiquement ce qui n'a pas de sens.

Créer une table DDL

CREATE TABLE Clients (
    ClientID        INT IDENTITY(1,1) PRIMARY KEY,
    Nom             NVARCHAR(50)  NOT NULL,
    Prenom          NVARCHAR(50)  NOT NULL,
    Email           NVARCHAR(120) NULL,
    Ville           NVARCHAR(50)  NULL,
    DateInscription DATE          NOT NULL DEFAULT GETDATE()
);

Les 7 contraintes essentielles

Contrainte Rôle Exemple
PRIMARY KEY Identifie chaque ligne (unique, jamais NULL) ClientID INT PRIMARY KEY
FOREIGN KEY Relie à la clé d'une autre table REFERENCES Clients(ClientID)
UNIQUE Interdit les doublons Email NVARCHAR(120) UNIQUE
CHECK Impose une condition CHECK (Prix >= 0)
DEFAULT Valeur si non renseignée DEFAULT 0
NOT NULL Valeur obligatoire Nom NVARCHAR(50) NOT NULL
IDENTITY Numéro auto-incrémenté IDENTITY(1,1) (départ, pas)

Contraintes nommées Recommandé

Donner un nom facilite les messages d'erreur et les ALTER ultérieurs.

CREATE TABLE Commandes (
    CommandeID   INT IDENTITY(1,1),
    ClientID     INT           NOT NULL,
    DateCommande DATETIME2     NOT NULL CONSTRAINT DF_Cmd_Date   DEFAULT SYSDATETIME(),
    Statut       VARCHAR(20)   NOT NULL CONSTRAINT DF_Cmd_Statut DEFAULT 'En attente',
    Total        DECIMAL(10,2) NULL,
    CONSTRAINT PK_Commandes   PRIMARY KEY (CommandeID),
    CONSTRAINT FK_Cmd_Clients FOREIGN KEY (ClientID)
        REFERENCES Clients (ClientID) ON DELETE CASCADE,
    CONSTRAINT CK_Cmd_Total   CHECK (Total >= 0)
);

Clés étrangères : que faire à la suppression ?

Option Effet quand la ligne parente change
NO ACTION Refuse l'opération (par défaut)
CASCADE Supprime / modifie aussi les lignes enfants
SET NULL Met la clé enfant à NULL
SET DEFAULT Met la clé enfant à sa valeur par défaut
ALTER TABLE Commandes ADD CONSTRAINT FK_Cmd_Clients
    FOREIGN KEY (ClientID) REFERENCES Clients (ClientID)
    ON DELETE NO ACTION ON UPDATE CASCADE;

Modifier une table ALTER

ALTER TABLE Clients ADD Telephone VARCHAR(20) NULL;           -- ajouter une colonne
ALTER TABLE Clients ALTER COLUMN Telephone VARCHAR(30) NULL;  -- changer le type
EXEC sp_rename 'Clients.Telephone', 'Mobile', 'COLUMN';       -- renommer la colonne
ALTER TABLE Clients DROP COLUMN Mobile;                       -- supprimer la colonne

ALTER TABLE Clients  ADD CONSTRAINT UQ_Clients_Email UNIQUE (Email);
ALTER TABLE Produits ADD CONSTRAINT CK_Produits_Prix CHECK (Prix >= 0);
ALTER TABLE Clients  DROP CONSTRAINT UQ_Clients_Email;

EXEC sp_rename 'AncienNom', 'NouveauNom';                     -- renommer une table
AttentionUNIQUE n'accepte qu'un seul NULL. Pour plusieurs emails vides, utilise un index unique filtré (chapitre 11).

Supprimer ou vider

DROP TABLE IF EXISTS Archives;   -- supprime la table ET ses données
TRUNCATE TABLE Logs;             -- vide très vite, remet IDENTITY à 1
DELETE FROM Logs;                -- vide ligne par ligne, IDENTITY conservé
AttentionImpossible de DROP ou TRUNCATE une table référencée par une clé étrangère : supprime d'abord la contrainte ou la table enfant.

IDENTITY : récupérer et contrôler l'ID

INSERT INTO Clients (Nom, Prenom) VALUES (N'Test', N'User');
SELECT SCOPE_IDENTITY();             -- dernier ID généré ici (à préférer)
SELECT @@IDENTITY;                   -- dernier ID de la session (triggers inclus)
SELECT IDENT_CURRENT('Clients');     -- dernier ID de la table, toutes sessions

DBCC CHECKIDENT ('Clients', RESEED, 0);   -- le prochain ID sera 1
SET IDENTITY_INSERT Clients ON;           -- autorise un ID manuel
INSERT INTO Clients (ClientID, Nom, Prenom) VALUES (100, N'Manuel', N'ID');
SET IDENTITY_INSERT Clients OFF;

Copies et tables temporaires

SELECT * INTO ClientsCopie FROM Clients;               -- structure + données
SELECT * INTO ClientsVide  FROM Clients WHERE 1 = 0;   -- structure seulement

CREATE TABLE #Temp (ID INT, Valeur NVARCHAR(50));      -- visible dans ta session
CREATE TABLE ##TempGlobale (ID INT);                   -- visible par toutes les sessions
DROP TABLE #Temp;                                      -- sinon supprimée à la déconnexion

Colonnes calculées

ALTER TABLE LignesCommande
    ADD SousTotal AS (Quantite * PrixUnitaire);              -- calculée à chaque lecture
ALTER TABLE LignesCommande
    ADD SousTotalStocke AS (Quantite * PrixUnitaire) PERSISTED;  -- stockée sur disque
05

INSERT, UPDATE, DELETE

Les commandes qui modifient les données. Règle d'or : un UPDATE ou un DELETE sans WHERE touche toute la table.

INSERT : ajouter des lignes DML

INSERT INTO Clients (Nom, Prenom, Email, Ville)
VALUES (N'Zidane', N'Amine', 'amine@mail.dz', N'Constantine');

-- plusieurs lignes d'un coup (jusqu'à 1000)
INSERT INTO Categories (Nom)
VALUES (N'Sport'), (N'Jouets'), (N'Jardin');

-- colonnes omises : DEFAULT, IDENTITY ou NULL s'appliquent
INSERT INTO Clients (Nom, Prenom) VALUES (N'Said', N'Nour');

INSERT … SELECT et OUTPUT

-- copier des lignes d'une table vers une autre
INSERT INTO ClientsArchive (Nom, Prenom, Email)
SELECT Nom, Prenom, Email
FROM   Clients
WHERE  DateInscription < '2020-01-01';

-- récupérer les lignes insérées (ID généré inclus)
INSERT INTO Produits (Nom, Prix, Stock, CategorieID)
OUTPUT inserted.ProduitID, inserted.Nom
VALUES (N'Casque audio', 59.00, 15, 1);

UPDATE : modifier des lignes

UPDATE Produits SET Prix = 84.90 WHERE ProduitID = 1;

UPDATE Produits SET Prix = Prix * 1.10 WHERE CategorieID = 1;   -- +10 %

UPDATE Clients
SET    Ville = N'Blida', Email = 'new@mail.dz'
WHERE  ClientID = 3;

-- voir l'ancienne et la nouvelle valeur
UPDATE Produits SET Stock = Stock + 10
OUTPUT deleted.Stock AS Avant, inserted.Stock AS Apres
WHERE ProduitID = 2;

UPDATE avec jointure

-- décrémenter le stock selon les lignes de la commande 1
UPDATE p
SET    p.Stock = p.Stock - l.Quantite
FROM   Produits AS p
JOIN   LignesCommande AS l ON l.ProduitID = p.ProduitID
WHERE  l.CommandeID = 1;

-- recalculer le total d'une commande
UPDATE cm
SET    cm.Total = (SELECT SUM(Quantite * PrixUnitaire)
                   FROM LignesCommande WHERE CommandeID = cm.CommandeID)
FROM   Commandes AS cm
WHERE  cm.CommandeID = 1;

DELETE : supprimer des lignes

DELETE FROM Commandes WHERE CommandeID = 2;
DELETE FROM Clients   WHERE Ville IS NULL;

-- supprimer par lots pour ne pas bloquer la table
DELETE TOP (100) FROM Logs WHERE DateLog < '2025-01-01';

-- supprimer les clients sans commande
DELETE cl
FROM   Clients AS cl
LEFT JOIN Commandes AS cm ON cm.ClientID = cl.ClientID
WHERE  cm.CommandeID IS NULL;

Le filet de sécurité : BEGIN TRAN / ROLLBACK

Teste tes modifications dangereuses dans une transaction, vérifie, puis annule ou valide.

BEGIN TRAN;
    DELETE FROM Clients;             -- oups…
    SELECT COUNT(*) FROM Clients;    -- 0 : on voit l'étendue des dégâts
ROLLBACK;                            -- tout est annulé ! (COMMIT pour valider)
SELECT COUNT(*) FROM Clients;        -- les clients sont de retour

DELETE vs TRUNCATE vs DROP

DELETE TRUNCATE DROP
Supprime Des lignes Toutes les lignes La table entière
WHERE Oui Non Non
Vitesse Lent Très rapide Très rapide
IDENTITY Conservé Remis à zéro Disparaît
Triggers Déclenchés Non Non
Famille DML DDL DDL

MERGE : insérer ou mettre à jour en une fois (upsert)

MERGE Produits AS cible
USING (VALUES (1, 79.90), (9, 12.00)) AS source (ProduitID, Prix)
   ON cible.ProduitID = source.ProduitID
WHEN MATCHED THEN
     UPDATE SET cible.Prix = source.Prix                       -- existe : on met à jour
WHEN NOT MATCHED BY TARGET THEN
     INSERT (Nom, Prix) VALUES (N'Nouveau produit', source.Prix);  -- n'existe pas : on insère
AstuceUn MERGE doit toujours se terminer par un point-virgule.
06

SELECT : lire les données

La commande la plus utilisée. Elle ne modifie rien : tu peux l'essayer sans risque.

Les bases DQL

SELECT * FROM Clients;                                 -- toutes les colonnes
SELECT Nom, Prenom, Ville FROM Clients;                -- colonnes choisies
SELECT Nom AS NomFamille, Prenom AS [Prénom] FROM Clients;   -- alias
SELECT Nom, Prix * 1.19 AS PrixTTC FROM Produits;      -- calcul
SELECT Prenom + ' ' + Nom AS NomComplet FROM Clients;  -- concaténation
SELECT CONCAT(Prenom, ' ', Nom) AS NomComplet FROM Clients;  -- gère les NULL
SELECT 'Livraison offerte' AS Info, 5 AS Valeur;       -- sans FROM

DISTINCT et TOP

SELECT DISTINCT Ville FROM Clients;                     -- valeurs uniques
SELECT TOP 3 * FROM Produits ORDER BY Prix DESC;        -- les 3 plus chers
SELECT TOP 10 PERCENT * FROM Produits ORDER BY Prix;    -- 10 % des lignes
SELECT TOP 3 WITH TIES Nom, Prix
FROM Produits ORDER BY Prix DESC;                       -- garde les ex æquo

WHERE : filtrer les lignes

SELECT * FROM Produits WHERE Prix > 30;
SELECT * FROM Produits WHERE Prix BETWEEN 20 AND 50;           -- bornes incluses
SELECT * FROM Clients  WHERE Ville IN (N'Alger', N'Oran');
SELECT * FROM Clients  WHERE Ville = N'Alger' AND Email IS NOT NULL;
SELECT * FROM Produits WHERE Stock = 0 OR Prix > 100;
SELECT * FROM Clients  WHERE NOT Ville = N'Alger';
SELECT * FROM Clients  WHERE Ville <> N'Alger';                   -- ou !=
AstucePriorité : NOT puis AND puis OR. Mets des parenthèses : WHERE (A OR B) AND C.

Les opérateurs

Opérateur Sens Exemple
= <> != Égal / différent Ville = N'Oran'
> < >= <= Comparaisons Prix >= 30
BETWEEN Entre deux bornes incluses Prix BETWEEN 20 AND 50
IN Dans une liste Ville IN ('A','B')
LIKE Motif de texte Nom LIKE 'B%'
IS NULL Valeur absente Email IS NULL
AND OR NOT Logique A AND NOT B
+ - * / % Calcul (% = modulo) Prix * Stock

LIKE : chercher un motif

% = n'importe quelle suite · _ = un seul caractère · [ ] = un caractère parmi · [^ ] = sauf.

SELECT * FROM Clients WHERE Nom LIKE 'B%';      -- commence par B
SELECT * FROM Clients WHERE Nom LIKE '%li';     -- finit par li
SELECT * FROM Clients WHERE Nom LIKE '%er%';    -- contient er
SELECT * FROM Clients WHERE Nom LIKE '_enali';  -- 1 caractère + enali
SELECT * FROM Clients WHERE Nom LIKE '[BH]%';   -- commence par B ou H
SELECT * FROM Clients WHERE Nom LIKE '[A-C]%';  -- commence par A, B ou C
SELECT * FROM Clients WHERE Nom LIKE '[^BH]%';  -- ne commence pas par B ni H
SELECT * FROM Produits WHERE Nom LIKE '%10!%%' ESCAPE '!';  -- cherche un % littéral

NULL : l'absence de valeur

NULL n'est ni 0 ni vide : c'est « inconnu ». On ne le compare jamais avec =.

SELECT * FROM Clients WHERE Email IS NULL;       -- ✔ correct
SELECT * FROM Clients WHERE Email = NULL;        -- ✘ ne renvoie jamais rien
SELECT ISNULL(Email, 'non renseigné') FROM Clients;      -- remplace NULL
SELECT COALESCE(Email, Ville, 'inconnu') FROM Clients;   -- 1er non NULL de la liste
SELECT 100 / NULLIF(Stock, 0) FROM Produits;     -- NULL au lieu d'une division par 0

ORDER BY et pagination

SELECT * FROM Produits ORDER BY Prix;                  -- croissant (ASC par défaut)
SELECT * FROM Produits ORDER BY Prix DESC, Nom ASC;    -- plusieurs critères
SELECT Nom, Prix FROM Produits ORDER BY 2 DESC;        -- par position (à éviter)

-- Pagination : page 2, 10 lignes par page
SELECT ProduitID, Nom, Prix
FROM   Produits
ORDER BY ProduitID
OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY;

CASE, IIF, CHOOSE : des conditions dans la requête

SELECT Nom, Stock,
       CASE
           WHEN Stock = 0  THEN 'Rupture'
           WHEN Stock < 20 THEN 'Stock faible'
           ELSE 'Disponible'
       END AS Etat
FROM Produits;

SELECT Nom, IIF(Stock > 0, 'Oui', 'Non') AS EnStock FROM Produits;   -- si / sinon
SELECT CHOOSE(2, 'Lundi', 'Mardi', 'Mercredi');                      -- Mardi

-- CASE dans un ORDER BY ou un SUM : compter sous condition
SELECT SUM(CASE WHEN Statut = 'Livree' THEN 1 ELSE 0 END) AS NbLivrees FROM Commandes;
07

Agrégation : COUNT, SUM, GROUP BY

Résumer beaucoup de lignes en quelques chiffres : totaux, moyennes, nombres, par groupe.

Les fonctions d'agrégation

Fonction Résultat
COUNT(*) Nombre de lignes
COUNT(col) Nombre de valeurs non NULL
COUNT(DISTINCT col) Nombre de valeurs différentes
SUM(col) Somme
AVG(col) Moyenne (ignore les NULL)
MIN(col) MAX(col) Plus petite / plus grande valeur
STRING_AGG(col, sep) Concatène les valeurs en un texte

Sur toute la table

SELECT COUNT(*)   AS NbProduits,
       SUM(Stock) AS StockTotal,
       AVG(Prix)  AS PrixMoyen,
       MIN(Prix)  AS PrixMin,
       MAX(Prix)  AS PrixMax
FROM Produits;

SELECT COUNT(*)               AS NbClients,
       COUNT(Email)           AS AvecEmail,    -- ignore les NULL
       COUNT(DISTINCT Ville)  AS NbVilles
FROM Clients;

GROUP BY : un résultat par groupe

SELECT Ville, COUNT(*) AS NbClients
FROM   Clients
GROUP BY Ville;

SELECT CategorieID, AVG(Prix) AS PrixMoyen, SUM(Stock) AS Stock
FROM   Produits
GROUP BY CategorieID
ORDER BY PrixMoyen DESC;

La règle d'or du GROUP BY

Chaque colonne du SELECT doit être soit dans le GROUP BY, soit dans une fonction d'agrégation.

-- ✘ Erreur : Nom n'est ni groupé ni agrégé
SELECT Ville, Nom, COUNT(*) FROM Clients GROUP BY Ville;

-- ✔ Correct
SELECT Ville, COUNT(*) AS Nb FROM Clients GROUP BY Ville;
SELECT Ville, MIN(Nom) AS PremierNom, COUNT(*) AS Nb FROM Clients GROUP BY Ville;

HAVING : filtrer les groupes

WHERE filtre les lignes avant le regroupement, HAVING filtre les groupes après.

SELECT ClientID, COUNT(*) AS NbCommandes, SUM(Total) AS CA
FROM   Commandes
WHERE  Statut = 'Livree'          -- 1) on garde les lignes livrées
GROUP BY ClientID                 -- 2) on regroupe
HAVING COUNT(*) >= 1              -- 3) on filtre les groupes
   AND SUM(Total) > 30;

ROLLUP et STRING_AGG

-- sous-totaux + total général
SELECT ClientID, Statut, SUM(Total) AS CA
FROM   Commandes
GROUP BY ROLLUP (ClientID, Statut);

-- liste des prénoms par ville dans une seule cellule
SELECT Ville,
       STRING_AGG(Prenom, ', ') WITHIN GROUP (ORDER BY Prenom) AS Clients
FROM   Clients
GROUP BY Ville;
08

Jointures : relier plusieurs tables

Une jointure combine les lignes de deux tables grâce à une colonne commune (souvent clé primaire ↔ clé étrangère). Sur chaque schéma, la zone foncée est ce que la requête retourne.

INNER JOIN Le plus courant

Seulement les lignes qui ont une correspondance des deux côtés.

SELECT cl.Nom, cm.CommandeID, cm.Total
FROM   Clients AS cl
INNER JOIN Commandes AS cm ON cm.ClientID = cl.ClientID;
-- Lina (aucune commande) n'apparaît pas

LEFT JOIN

Toutes les lignes de la table de gauche, avec NULL quand il n'y a pas de correspondance.

SELECT cl.Nom, cm.CommandeID
FROM   Clients AS cl
LEFT JOIN Commandes AS cm ON cm.ClientID = cl.ClientID;
-- Lina apparaît avec CommandeID = NULL

RIGHT JOIN

Toutes les lignes de la table de droite. C'est un LEFT JOIN avec les tables inversées : on l'utilise rarement.

SELECT cm.CommandeID, cl.Nom
FROM   Clients AS cl
RIGHT JOIN Commandes AS cm ON cm.ClientID = cl.ClientID;

FULL OUTER JOIN

Toutes les lignes des deux tables, correspondantes ou non.

SELECT cl.Nom, cm.CommandeID
FROM   Clients AS cl
FULL OUTER JOIN Commandes AS cm ON cm.ClientID = cl.ClientID;

Anti-jointure Sans correspondance

Les lignes de A qui n'ont aucune ligne en B : un LEFT JOIN suivi de IS NULL.

SELECT cl.Nom
FROM   Clients AS cl
LEFT JOIN Commandes AS cm ON cm.ClientID = cl.ClientID
WHERE  cm.CommandeID IS NULL;      -- clients qui n'ont jamais commandé

CROSS JOIN et auto-jointure

CROSS JOIN = toutes les combinaisons possibles. L'auto-jointure relie une table à elle-même avec deux alias.

-- 3 tailles × 2 couleurs = 6 combinaisons
SELECT t.Taille, c.Couleur
FROM   (VALUES ('S'), ('M'), ('L')) AS t (Taille)
CROSS JOIN (VALUES ('Noir'), ('Blanc')) AS c (Couleur);

-- table imaginaire Employes (EmployeID, Nom, ManagerID)
SELECT e.Nom AS Employe, m.Nom AS Manager
FROM   Employes AS e
LEFT JOIN Employes AS m ON m.EmployeID = e.ManagerID;

Joindre plusieurs tables

On enchaîne les jointures, une par relation. Ici : client → commande → ligne → produit → catégorie.

SELECT cl.Nom                          AS Client,
       cm.CommandeID,
       p.Nom                           AS Produit,
       l.Quantite,
       l.Quantite * l.PrixUnitaire     AS SousTotal,
       ca.Nom                          AS Categorie
FROM   Clients        AS cl
JOIN   Commandes      AS cm ON cm.ClientID    = cl.ClientID
JOIN   LignesCommande AS l  ON l.CommandeID   = cm.CommandeID
JOIN   Produits       AS p  ON p.ProduitID    = l.ProduitID
LEFT JOIN Categories  AS ca ON ca.CategorieID = p.CategorieID
ORDER BY cm.CommandeID;
AttentionAvec un LEFT JOIN, une condition sur la table de droite placée dans le WHERE transforme la jointure en INNER JOIN. Mets-la dans le ON : LEFT JOIN Commandes cm ON cm.ClientID = cl.ClientID AND cm.Statut = 'Livree'.
09

Sous-requêtes, CTE et ensembles

Imbriquer des requêtes pour résoudre des questions en plusieurs étapes, ou combiner les résultats de plusieurs SELECT.

Sous-requête dans le WHERE

-- produits plus chers que la moyenne
SELECT Nom, Prix
FROM   Produits
WHERE  Prix > (SELECT AVG(Prix) FROM Produits);

-- clients ayant une commande de plus de 50
SELECT Nom FROM Clients
WHERE  ClientID IN (SELECT ClientID FROM Commandes WHERE Total > 50);

EXISTS / NOT EXISTS

Teste simplement « existe-t-il au moins une ligne ? ». Rapide et sans piège avec les NULL.

-- clients qui ont commandé
SELECT cl.Nom FROM Clients AS cl
WHERE EXISTS (SELECT 1 FROM Commandes AS cm WHERE cm.ClientID = cl.ClientID);

-- clients qui n'ont jamais commandé
SELECT cl.Nom FROM Clients AS cl
WHERE NOT EXISTS (SELECT 1 FROM Commandes AS cm WHERE cm.ClientID = cl.ClientID);

Sous-requête dans le SELECT ou le FROM

-- une valeur calculée par ligne
SELECT cl.Nom,
       (SELECT COUNT(*) FROM Commandes AS cm
        WHERE cm.ClientID = cl.ClientID) AS NbCommandes
FROM Clients AS cl;

-- table dérivée (un alias est obligatoire)
SELECT t.Ville, t.NbClients
FROM  (SELECT Ville, COUNT(*) AS NbClients
       FROM Clients GROUP BY Ville) AS t
WHERE  t.NbClients > 1;

CTE : WITH Plus lisible

Une CTE donne un nom à une sous-requête, pour la réutiliser et lire la requête de haut en bas.

WITH CA_Client AS (
    SELECT ClientID, SUM(Total) AS CA
    FROM   Commandes
    GROUP BY ClientID
)
SELECT cl.Nom, ca.CA
FROM   Clients AS cl
JOIN   CA_Client AS ca ON ca.ClientID = cl.ClientID
ORDER BY ca.CA DESC;

CTE récursive

-- génère les nombres de 1 à 10
WITH Nombres AS (
    SELECT 1 AS n                              -- point de départ (ancre)
    UNION ALL
    SELECT n + 1 FROM Nombres WHERE n < 10     -- partie récursive
)
SELECT n FROM Nombres
OPTION (MAXRECURSION 100);                     -- garde-fou (0 = illimité)

UNION, INTERSECT, EXCEPT

Les SELECT combinés doivent avoir le même nombre de colonnes, avec des types compatibles.

SELECT Ville FROM Clients
UNION                         -- fusionne et supprime les doublons
SELECT N'Tizi Ouzou';

SELECT Nom FROM Clients
UNION ALL                     -- garde les doublons (plus rapide)
SELECT Nom FROM Produits;

SELECT Ville FROM Clients INTERSECT SELECT N'Alger';          -- en commun
SELECT ClientID FROM Clients EXCEPT SELECT ClientID FROM Commandes;  -- dans A, pas dans B

CROSS APPLY : le « top N par groupe »

-- la dernière commande de chaque client
SELECT cl.Nom, d.CommandeID, d.DateCommande
FROM   Clients AS cl
CROSS APPLY (
    SELECT TOP 1 CommandeID, DateCommande
    FROM   Commandes AS cm
    WHERE  cm.ClientID = cl.ClientID
    ORDER BY DateCommande DESC
) AS d;                        -- OUTER APPLY garde aussi les clients sans commande
10

Fonctions intégrées

Texte, dates, nombres, conversions, classements… SQL Server en propose des centaines. Voici celles que tu utiliseras tout le temps.

Fonctions de texte

SELECT LEN('SQL Server');                  -- 10
SELECT UPPER('sql'), LOWER('SQL');         -- SQL, sql
SELECT LEFT('Bonjour', 3), RIGHT('Bonjour', 4);   -- Bon, jour
SELECT SUBSTRING('Bonjour', 2, 3);         -- onj (début 2, longueur 3)
SELECT CHARINDEX('jour', 'Bonjour');       -- 4 (0 si absent)
SELECT REPLACE('a-b-c', '-', '/');         -- a/b/c
SELECT TRIM('  texte  ');                  -- sans espaces (LTRIM / RTRIM aussi)
SELECT CONCAT('SQL', ' ', 'Server');       -- SQL Server
SELECT CONCAT_WS(' - ', 'A', 'B', 'C');    -- A - B - C
SELECT REVERSE('abc'), REPLICATE('*', 5);  -- cba, *****
SELECT STUFF('abcdef', 2, 3, 'XYZ');       -- aXYZef
SELECT FORMAT(1234.5, 'N2', 'fr-FR');      -- 1 234,50
SELECT value FROM STRING_SPLIT('a,b,c', ',');   -- une ligne par élément

-- première lettre en majuscule
SELECT UPPER(LEFT(Nom, 1)) + LOWER(SUBSTRING(Nom, 2, 50)) FROM Clients;

Fonctions de date

SELECT GETDATE(), SYSDATETIME(), GETUTCDATE();     -- maintenant
SELECT YEAR(GETDATE()), MONTH(GETDATE()), DAY(GETDATE());
SELECT DATEPART(WEEKDAY, GETDATE());               -- numéro du jour de la semaine
SELECT DATENAME(MONTH, GETDATE());                 -- nom du mois
SELECT DATEADD(DAY, 7, GETDATE());                 -- dans 7 jours
SELECT DATEADD(MONTH, -1, '2026-03-31');           -- 2026-02-28
SELECT DATEDIFF(DAY, '2026-01-01', '2026-11-20');  -- 323
SELECT DATEDIFF(YEAR, '2000-05-17', GETDATE());    -- âge approximatif
SELECT EOMONTH(GETDATE());                         -- dernier jour du mois
SELECT DATEFROMPARTS(2026, 12, 25);                -- construit une date
SELECT CAST(GETDATE() AS DATE);                    -- date sans l'heure
SELECT FORMAT(GETDATE(), 'dd/MM/yyyy HH:mm');      -- mise en forme
SELECT ISDATE('2026-02-30');                       -- 0 : date invalide

-- tout novembre, sans fonction sur la colonne (utilise les index)
SELECT * FROM Commandes
WHERE  DateCommande >= '2026-11-01' AND DateCommande < '2026-12-01';
Partie Abréviations
Année / trimestre / mois YEAR QUARTER MONTH (yy, qq, mm)
Semaine / jour / jour de l'année WEEK DAY DAYOFYEAR (wk, dd, dy)
Heure / minute / seconde HOUR MINUTE SECOND (hh, mi, ss)

Fonctions numériques

SELECT ROUND(123.456, 2);          -- 123.460
SELECT ROUND(123.456, 0);          -- 123.000
SELECT CEILING(4.1), FLOOR(4.9);   -- 5, 4
SELECT ABS(-15);                   -- 15
SELECT POWER(2, 10), SQRT(144);    -- 1024, 12
SELECT 17 % 5;                     -- 2 (reste de la division)
SELECT 7 / 2, 7 / 2.0;             -- 3 (division entière !), 3.5
SELECT RAND();                     -- nombre aléatoire entre 0 et 1
SELECT ABS(CHECKSUM(NEWID())) % 100;   -- entier aléatoire de 0 à 99

Conversion de types

SELECT CAST('123' AS INT);                    -- texte → entier
SELECT CAST(19.99 AS INT);                    -- 19 (tronqué)
SELECT CONVERT(VARCHAR(10), GETDATE(), 103);  -- 20/11/2026 (style 103 = dd/mm/yyyy)
SELECT CONVERT(VARCHAR(10), GETDATE(), 120);  -- 2026-11-20 (style 120 = ISO)
SELECT TRY_CAST('abc' AS INT);                -- NULL au lieu d'une erreur
SELECT TRY_CONVERT(DATE, '31/02/2026', 103);  -- NULL (date impossible)
SELECT 'Total : ' + CAST(150 AS VARCHAR(10)); -- nombre → texte pour concaténer
AstucePréfère TRY_CAST / TRY_CONVERT quand les données viennent d'un import : pas d'erreur bloquante.

Fonctions de fenêtrage : classements

OVER (…) calcule sur un groupe de lignes sans les regrouper.

SELECT Nom, Prix,
       ROW_NUMBER() OVER (ORDER BY Prix DESC) AS Position,   -- 1,2,3,4
       RANK()       OVER (ORDER BY Prix DESC) AS Rang,       -- 1,2,2,4 (ex æquo)
       DENSE_RANK() OVER (ORDER BY Prix DESC) AS RangDense,  -- 1,2,2,3
       NTILE(2)     OVER (ORDER BY Prix DESC) AS Moitie      -- 2 paquets
FROM Produits;

SELECT CategorieID, Nom, Prix,
       AVG(Prix) OVER (PARTITION BY CategorieID) AS MoyenneCategorie,
       ROW_NUMBER() OVER (PARTITION BY CategorieID ORDER BY Prix DESC) AS RangCategorie
FROM Produits;

Cumul, ligne précédente / suivante

SELECT CommandeID, DateCommande, Total,
       SUM(Total) OVER (ORDER BY DateCommande
                        ROWS UNBOUNDED PRECEDING) AS CumulCA,
       LAG(Total)  OVER (ORDER BY DateCommande)   AS TotalPrecedent,
       LEAD(Total) OVER (ORDER BY DateCommande)   AS TotalSuivant
FROM Commandes;

-- le produit le plus cher de chaque catégorie
WITH T AS (
    SELECT *, ROW_NUMBER() OVER (PARTITION BY CategorieID ORDER BY Prix DESC) AS rn
    FROM Produits
)
SELECT * FROM T WHERE rn = 1;

JSON SQL Server 2016+

SELECT ClientID, Nom, Ville FROM Clients FOR JSON PATH;   -- résultat au format JSON

DECLARE @j NVARCHAR(MAX) = N'{"nom":"Sara","ville":"Alger","tags":["a","b"]}';
SELECT ISJSON(@j);                      -- 1 si le JSON est valide
SELECT JSON_VALUE(@j, '$.nom');         -- Sara
SELECT JSON_QUERY(@j, '$.tags');        -- ["a","b"]
SELECT * FROM OPENJSON(@j);             -- une ligne par clé
11

Vues, index, procédures, fonctions, triggers

Des objets stockés dans la base pour réutiliser, accélérer et automatiser.

Vues : une requête enregistrée

Une vue se lit comme une table, mais ne stocke pas de données : elle exécute sa requête.

CREATE OR ALTER VIEW vw_CommandesDetail AS
SELECT cm.CommandeID, cl.Nom AS Client, cm.DateCommande, cm.Total
FROM   Commandes AS cm
JOIN   Clients   AS cl ON cl.ClientID = cm.ClientID;
GO
SELECT * FROM vw_CommandesDetail WHERE Total > 50;
DROP VIEW IF EXISTS vw_CommandesDetail;
AstuceCREATE VIEW doit être la première instruction de son lot : mets GO avant et après.

Index : accélérer les recherches

Comme l'index d'un livre. Il accélère SELECT, WHERE, JOIN et ORDER BY, mais ralentit un peu INSERT / UPDATE.

CREATE INDEX IX_Clients_Ville ON Clients (Ville);                  -- simple
CREATE UNIQUE INDEX UX_Clients_Email ON Clients (Email)
       WHERE Email IS NOT NULL;                                    -- unique et filtré
CREATE INDEX IX_Cmd_Client_Date ON Commandes (ClientID, DateCommande DESC);  -- composite
CREATE INDEX IX_Produits_Cat ON Produits (CategorieID)
       INCLUDE (Nom, Prix);                                        -- « couvrant »
DROP INDEX IX_Clients_Ville ON Clients;
EXEC sp_helpindex 'Clients';                                       -- lister les index

Procédure stockée

Un script T-SQL nommé, avec paramètres, réutilisable et sécurisable.

CREATE OR ALTER PROCEDURE usp_CommandesClient
    @ClientID INT,
    @Statut   VARCHAR(20) = NULL          -- paramètre facultatif
AS
BEGIN
    SET NOCOUNT ON;
    SELECT CommandeID, DateCommande, Statut, Total
    FROM   Commandes
    WHERE  ClientID = @ClientID
      AND (@Statut IS NULL OR Statut = @Statut);
END;
GO
EXEC usp_CommandesClient @ClientID = 1;
EXEC usp_CommandesClient 1, 'Livree';

Paramètre de sortie (OUTPUT)

CREATE OR ALTER PROCEDURE usp_NbClients
    @Ville NVARCHAR(50),
    @Nb    INT OUTPUT
AS
    SELECT @Nb = COUNT(*) FROM Clients WHERE Ville = @Ville;
GO
DECLARE @n INT;
EXEC usp_NbClients N'Alger', @n OUTPUT;
SELECT @n AS NbClients;

Fonctions utilisateur

-- fonction scalaire : renvoie une valeur
CREATE OR ALTER FUNCTION dbo.fn_TTC (@ht DECIMAL(10,2), @tva DECIMAL(4,2) = 19)
RETURNS DECIMAL(10,2)
AS
BEGIN
    RETURN @ht * (1 + @tva / 100);
END;
GO
SELECT Nom, dbo.fn_TTC(Prix, DEFAULT) AS PrixTTC FROM Produits;
GO
-- fonction table (inline) : renvoie un jeu de lignes
CREATE OR ALTER FUNCTION dbo.fn_CommandesClient (@ClientID INT)
RETURNS TABLE
AS
RETURN (SELECT CommandeID, Total FROM Commandes WHERE ClientID = @ClientID);
GO
SELECT * FROM dbo.fn_CommandesClient(1);

Trigger : réagir automatiquement

Dans un trigger, les tables spéciales inserted et deleted contiennent les lignes nouvelles et anciennes.

-- AuditCommandes est une table imaginaire de journalisation
CREATE OR ALTER TRIGGER trg_Commandes_Audit
ON Commandes
AFTER INSERT, UPDATE
AS
BEGIN
    SET NOCOUNT ON;
    INSERT INTO AuditCommandes (CommandeID, Action, DateAction)
    SELECT i.CommandeID,
           IIF(EXISTS (SELECT 1 FROM deleted), 'UPDATE', 'INSERT'),
           SYSDATETIME()
    FROM   inserted AS i;
END;

Séquence : un compteur indépendant des tables

CREATE SEQUENCE seq_Facture START WITH 1000 INCREMENT BY 1;
SELECT NEXT VALUE FOR seq_Facture;      -- 1000, puis 1001, 1002…
DROP SEQUENCE seq_Facture;
12

Programmation T-SQL

Variables, conditions, boucles, erreurs, transactions : de vrais scripts pour automatiser ton travail.

Variables

DECLARE @nom NVARCHAR(50) = N'Benali', @n INT;
SET @n = 5;
SELECT @n = COUNT(*) FROM Clients WHERE Nom = @nom;   -- affecter depuis une requête
SELECT @nom AS Nom, @n AS Nb;
PRINT 'Nombre : ' + CAST(@n AS VARCHAR(10));         -- onglet Messages
AttentionUne variable n'existe que dans son lot : un GO la détruit.

IF / ELSE

DECLARE @stock INT = (SELECT Stock FROM Produits WHERE ProduitID = 1);

IF @stock = 0
    PRINT 'Rupture';
ELSE IF @stock < 10
    PRINT 'Stock faible';
ELSE
BEGIN                                  -- plusieurs instructions : BEGIN … END
    PRINT 'Stock OK';
    PRINT 'Rien à commander';
END;

IF EXISTS (SELECT 1 FROM Clients WHERE Email = 'sara@mail.dz')
    PRINT 'Ce client existe déjà';

WHILE : boucle

DECLARE @i INT = 1;
WHILE @i <= 5
BEGIN
    PRINT 'Itération ' + CAST(@i AS VARCHAR(2));
    SET @i += 1;
    IF @i = 4 BREAK;       -- sort de la boucle (CONTINUE : itération suivante)
END;

TRY / CATCH : gérer les erreurs

BEGIN TRY
    INSERT INTO LignesCommande (CommandeID, ProduitID, Quantite, PrixUnitaire)
    VALUES (1, 1, -5, 10);               -- viole le CHECK (Quantite > 0)
END TRY
BEGIN CATCH
    SELECT ERROR_NUMBER()   AS Numero,
           ERROR_MESSAGE()  AS Message,
           ERROR_SEVERITY() AS Gravite,
           ERROR_LINE()     AS Ligne;
    THROW;                               -- relance l'erreur d'origine
END CATCH;

THROW 50001, 'Stock insuffisant', 1;     -- lever sa propre erreur

Transactions : tout ou rien

Plusieurs modifications forment un seul bloc : si l'une échoue, tout est annulé.

SET XACT_ABORT ON;                       -- annule tout automatiquement en cas d'erreur
BEGIN TRY
    BEGIN TRANSACTION;
        UPDATE Produits SET Stock = Stock - 1 WHERE ProduitID = 1;
        INSERT INTO Commandes (ClientID, Statut, Total) VALUES (1, 'En attente', 79.90);
    COMMIT TRANSACTION;                  -- valide
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;   -- annule
    THROW;
END CATCH;

Variable table et table temporaire

DECLARE @Top TABLE (ProduitID INT, Nom NVARCHAR(100));
INSERT INTO @Top
SELECT TOP 3 ProduitID, Nom FROM Produits ORDER BY Prix DESC;
SELECT * FROM @Top;

SELECT * INTO #Stats FROM Produits WHERE Stock > 0;
SELECT COUNT(*) FROM #Stats;
DROP TABLE #Stats;

SQL dynamique (sécurisé)

DECLARE @sql NVARCHAR(MAX) = N'SELECT * FROM Clients WHERE Ville = @v';
EXEC sp_executesql @sql, N'@v NVARCHAR(50)', @v = N'Alger';   -- ✔ paramétré

-- ✘ DANGER (injection SQL) : ne jamais concaténer une saisie utilisateur
-- EXEC('SELECT * FROM Clients WHERE Ville = ''' + @saisie + '''');

Curseur (à éviter si possible)

Traite les lignes une par une : lent. Préfère une requête ensembliste.

DECLARE @nom NVARCHAR(50);
DECLARE cur CURSOR FAST_FORWARD FOR SELECT Nom FROM Clients;
OPEN cur;
FETCH NEXT FROM cur INTO @nom;
WHILE @@FETCH_STATUS = 0
BEGIN
    PRINT @nom;
    FETCH NEXT FROM cur INTO @nom;
END;
CLOSE cur;
DEALLOCATE cur;

Variables système utiles

Variable Contenu
@@ROWCOUNT Lignes touchées par la dernière instruction
@@ERROR Code d'erreur de la dernière instruction (0 = OK)
@@TRANCOUNT Nombre de transactions ouvertes
@@IDENTITY Dernier IDENTITY généré
@@FETCH_STATUS État du dernier FETCH (0 = succès)
@@SPID Numéro de ta session
@@VERSION Version de SQL Server
UPDATE Produits SET Stock = 0 WHERE CategorieID = 3;
SELECT @@ROWCOUNT AS LignesModifiees;
13

Administration, sécurité et sauvegarde

Donner les bons droits, sauvegarder, surveiller et comprendre les performances.

Logins, utilisateurs et droits DCL

Un login ouvre l'accès au serveur ; un user donne l'accès à une base.

CREATE LOGIN appli WITH PASSWORD = 'Un_MotDePasse_Fort_2026!';  -- niveau serveur
USE Boutique;
CREATE USER appli FOR LOGIN appli;                              -- niveau base

ALTER ROLE db_datareader ADD MEMBER appli;     -- lecture sur toute la base
GRANT SELECT, INSERT ON Clients TO appli;      -- droits précis sur une table
GRANT EXECUTE ON usp_CommandesClient TO appli; -- exécuter une procédure
DENY  DELETE ON Clients TO appli;              -- interdire (prioritaire)
REVOKE INSERT ON Clients FROM appli;           -- retirer un droit accordé

Rôles courants

Rôle Pouvoir
sysadmin Tout, sur tout le serveur
db_owner Tout, dans une base
db_ddladmin Créer / modifier les objets
db_datareader Lire toutes les tables
db_datawriter Insérer, modifier, supprimer
public Tout le monde (droits minimaux)
AstucePrincipe du moindre privilège : donne à chaque application uniquement ce dont elle a besoin, jamais sa.

Sauvegarde et restauration

BACKUP DATABASE Boutique TO DISK = 'C:\Backups\Boutique_full.bak'
    WITH INIT, COMPRESSION, CHECKSUM;                    -- complète

BACKUP DATABASE Boutique TO DISK = 'C:\Backups\Boutique_diff.bak'
    WITH DIFFERENTIAL;                                   -- depuis la dernière complète

BACKUP LOG Boutique TO DISK = 'C:\Backups\Boutique_log.trn';   -- journal de transactions

RESTORE DATABASE Boutique FROM DISK = 'C:\Backups\Boutique_full.bak' WITH REPLACE;
RESTORE HEADERONLY   FROM DISK = 'C:\Backups\Boutique_full.bak';   -- contenu du fichier
RESTORE VERIFYONLY   FROM DISK = 'C:\Backups\Boutique_full.bak';   -- vérifie le fichier

Explorer la base avec les vues système

SELECT name FROM sys.tables;                           -- tables de la base
SELECT name, TYPE_NAME(system_type_id) AS Type
FROM   sys.columns WHERE object_id = OBJECT_ID('Clients');   -- colonnes d'une table
SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'Clients';
SELECT name FROM sys.procedures;                       -- procédures stockées

EXEC sp_help 'Clients';                 -- structure complète d'une table
EXEC sp_helptext 'usp_CommandesClient'; -- code source d'un objet
EXEC sp_who2;                           -- sessions connectées

-- nombre de lignes par table
SELECT t.name AS [Table], SUM(p.rows) AS NbLignes
FROM   sys.tables AS t
JOIN   sys.partitions AS p ON p.object_id = t.object_id AND p.index_id IN (0, 1)
GROUP BY t.name;

Performances et maintenance

SET STATISTICS IO ON;      -- nombre de pages lues
SET STATISTICS TIME ON;    -- temps CPU et temps écoulé
-- Ctrl+M dans SSMS : plan d'exécution réel
SELECT * FROM Commandes WHERE ClientID = 1;

UPDATE STATISTICS Commandes;              -- rafraîchit les statistiques
ALTER INDEX ALL ON Commandes REBUILD;     -- reconstruit les index
DBCC CHECKDB ('Boutique');                -- vérifie l'intégrité de la base
AstuceDans le plan d'exécution, cherche les Table Scan / Clustered Index Scan sur de grosses tables : c'est souvent un index manquant.

Importer un fichier CSV

BULK INSERT Clients
FROM 'C:\Data\clients.csv'                -- chemin vu par le SERVEUR, pas par ton PC
WITH (FIELDTERMINATOR = ',',
      ROWTERMINATOR   = '\n',
      FIRSTROW        = 2,                -- saute la ligne d'en-tête
      CODEPAGE        = '65001');         -- UTF-8

Pour un import visuel : clic droit sur la base → Tasks → Import Flat File… dans SSMS.

14

Bonnes pratiques et erreurs de débutant

Les pièges classiques, et comment les éviter dès le début.

Les 10 réflexes

  1. Liste les colonnes au lieu de SELECT *.
  2. Teste un UPDATE / DELETE avec un SELECT d'abord, puis dans un BEGIN TRAN … ROLLBACK.
  3. Nomme tes contraintes et index : PK_, FK_, UQ_, CK_, IX_.
  4. DECIMAL pour l'argent, NVARCHAR pour les noms, DATETIME2 pour les dates.
  5. Utilise des alias courts et cohérents dans les jointures.
  6. Passe des paramètres, ne concatène jamais une saisie utilisateur (injection SQL).
  7. N'applique pas de fonction sur la colonne filtrée : compare avec une plage.
  8. Préfère EXISTS / NOT EXISTS à IN / NOT IN sur de grosses tables.
  9. Ajoute un ORDER BY dès que l'ordre compte : sans lui, aucun ordre n'est garanti.
  10. Fais une sauvegarde avant toute opération destructrice.

Comparer avec NULL

-- ✘ Ne retourne jamais de ligne
SELECT * FROM Clients WHERE Email = NULL;
-- ✔ Correct
SELECT * FROM Clients WHERE Email IS NULL;

Division entière

SELECT 1 / 2;       -- ✘ 0 (entier ÷ entier = entier)
SELECT 1.0 / 2;     -- ✔ 0.5
SELECT CAST(Total AS DECIMAL(10,2)) / NULLIF(Quantite, 0) FROM Commandes;

NOT IN et les NULL

-- ✘ Si la sous-requête contient un seul NULL : 0 ligne retournée !
SELECT * FROM Clients
WHERE  ClientID NOT IN (SELECT ClientID FROM Commandes);

-- ✔ Sûr
SELECT * FROM Clients AS cl
WHERE  NOT EXISTS (SELECT 1 FROM Commandes AS cm WHERE cm.ClientID = cl.ClientID);

Fonction sur une colonne indexée

-- ✘ Lit toute la table : l'index est ignoré
SELECT * FROM Commandes WHERE YEAR(DateCommande) = 2026;

-- ✔ Utilise l'index (plage de dates)
SELECT * FROM Commandes
WHERE  DateCommande >= '2026-01-01' AND DateCommande < '2027-01-01';

BETWEEN avec des dates et heures

-- ✘ Perd les commandes du 30 novembre après 00:00
SELECT * FROM Commandes
WHERE  DateCommande BETWEEN '2026-11-01' AND '2026-11-30';

-- ✔ Borne haute exclusive (jour suivant)
SELECT * FROM Commandes
WHERE  DateCommande >= '2026-11-01' AND DateCommande < '2026-12-01';

UPDATE / DELETE sans WHERE

-- ✘ Change le prix de TOUS les produits
UPDATE Produits SET Prix = 0;

-- ✔ Toujours cibler, et vérifier @@ROWCOUNT
BEGIN TRAN;
    UPDATE Produits SET Prix = 0 WHERE ProduitID = 4;
    SELECT @@ROWCOUNT AS LignesModifiees;   -- doit afficher 1
ROLLBACK;   -- ou COMMIT si tout est bon

Injection SQL

-- ✘ Un utilisateur qui saisit  ' OR 1=1 --  récupère toute la table
-- 'SELECT * FROM Clients WHERE Nom = ''' + @saisie + ''''

-- ✔ Requête paramétrée
EXEC sp_executesql
     N'SELECT * FROM Clients WHERE Nom = @nom',
     N'@nom NVARCHAR(50)',
     @nom = @saisie;

ORDER BY dans une vue ou sous-requête

-- ✘ Erreur : ORDER BY sans TOP / OFFSET dans une vue
CREATE VIEW vw_Produits AS
SELECT * FROM Produits ORDER BY Prix;

-- ✔ Trie à la lecture de la vue
SELECT * FROM vw_Produits ORDER BY Prix;