SQL Server

JOINs SQL Server en pratique : SELECT multi-tables, UPDATE, DELETE, index et performance

Guide pratique SQL Server sur les JOINs multi-tables, UPDATE et DELETE avec JOIN, doublons, index sur colonnes de jointure et impact sur les performances.

Par JaviPublié 21 min de lectureIntermédiaire

Dans cet article

Les JOINs sont l’un des éléments les plus importants de SQL Server.

C’est aussi l’un des endroits où il est le plus facile de créer des problèmes de performance.

Une jointure peut être logiquement correcte et pourtant coûteuse, à cause :

  • d’index manquants ;
  • de mauvaises estimations de cardinalité ;
  • de correspondances en double ;
  • de relations plusieurs-à-plusieurs ;
  • de conversions implicites ;
  • de prédicats non SARGables ;
  • de statistiques obsolètes ;
  • de jointures sur bien plus de lignes que nécessaire ;
  • de listes SELECT trop larges ;
  • d’un mauvais ordre de filtrage.

Ce guide se concentre sur des patterns de JOIN pratiques, utilisables dans de vraies charges SQL Server.

Il couvre :

  • la jointure de plusieurs tables ;
  • les patterns INNER, LEFT et EXISTS ;
  • UPDATE avec JOIN ;
  • DELETE avec JOIN ;
  • comment éviter les erreurs de lignes en double ;
  • l’indexation des colonnes de jointure ;
  • la conception d’index composites ;
  • les colonnes incluses ;
  • les considérations liées au plan d’exécution ;
  • les algorithmes de jointure ;
  • la cardinalité et les statistiques ;
  • le diagnostic des problèmes de performance.

Modèle d’exemple

Nous utiliserons un petit modèle de type commerce.

Requête SQL: Modèle d’exempleT-SQL
CREATE TABLE dbo.Customers
(
    CustomerId       int           NOT NULL PRIMARY KEY,
    CustomerName     varchar(100)  NOT NULL,
    Status           varchar(20)   NOT NULL
);

CREATE TABLE dbo.Orders
(
    OrderId          bigint        NOT NULL PRIMARY KEY,
    CustomerId       int           NOT NULL,
    OrderDate        datetime2     NOT NULL,
    OrderStatus      varchar(20)   NOT NULL,
    TotalAmount      decimal(18,2) NOT NULL
);

CREATE TABLE dbo.OrderItems
(
    OrderItemId      bigint        NOT NULL PRIMARY KEY,
    OrderId          bigint        NOT NULL,
    ProductId        int           NOT NULL,
    Quantity         int           NOT NULL,
    UnitPrice        decimal(18,2) NOT NULL
);

CREATE TABLE dbo.Products
(
    ProductId        int           NOT NULL PRIMARY KEY,
    ProductName      varchar(150)  NOT NULL,
    CategoryId       int           NOT NULL,
    IsActive         bit           NOT NULL
);

CREATE TABLE dbo.Categories
(
    CategoryId       int           NOT NULL PRIMARY KEY,
    CategoryName     varchar(100)  NOT NULL
);
T-SQL38 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Les relations sont les suivantes :

Customers
   1
   │
   └──< Orders
          1
          │
          └──< OrderItems >── 1 Products >── 1 Categories

INNER JOIN de base

Un INNER JOIN renvoie les lignes pour lesquelles les deux côtés correspondent.

Requête SQL: INNER JOIN de baseT-SQL
SELECT
    o.OrderId,
    o.OrderDate,
    c.CustomerName,
    o.TotalAmount
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId;
T-SQL8 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Le prédicat de jointure est :

c.CustomerId = o.CustomerId

Ce prédicat doit généralement comparer des colonnes de types de données compatibles.

Joindre de nombreuses tables

Une jointure multi-tables n’est qu’une chaîne de relations.

Requête SQL: Joindre de nombreuses tablesT-SQL
SELECT
    o.OrderId,
    o.OrderDate,
    c.CustomerName,
    p.ProductName,
    cat.CategoryName,
    oi.Quantity,
    oi.UnitPrice,
    oi.Quantity * oi.UnitPrice AS LineAmount
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId
INNER JOIN dbo.Products AS p
    ON p.ProductId = oi.ProductId
INNER JOIN dbo.Categories AS cat
    ON cat.CategoryId = p.CategoryId
WHERE o.OrderDate >= '2026-10-01'
  AND o.OrderDate <  '2026-11-01';
T-SQL20 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La question importante n’est pas :

Combien de tables SQL Server peut-il joindre ?

SQL Server peut joindre de nombreuses tables.

La meilleure question est :

Combien de lignes circulent à chaque étape du plan ?

Cinq tables bien indexées peuvent être rapides.

Trois tables mal jointes peuvent être très lentes.

Comprendre la multiplication des lignes

Supposons qu’une commande compte cinq lignes de commande.

Cette requête :

Requête SQL: Comprendre la multiplication des lignesT-SQL
SELECT
    o.OrderId,
    c.CustomerName
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId;
T-SQL8 lignesAffichage en lecture seule. Aucune connexion à une base de données.

renvoie une ligne par ligne de commande, et non une ligne par commande.

Si une commande compte cinq articles, elle apparaît cinq fois.

Ce n’est pas un bug de SQL Server.

C’est le résultat correct pour cette forme de jointure.

Avant d’utiliser DISTINCT, demandez-vous pourquoi les doublons existent.

DISTINCT peut masquer un problème de modélisation ou de jointure tout en ajoutant une opération de tri ou de hachage.

LEFT JOIN

Utilisez LEFT JOIN lorsque vous avez besoin de toutes les lignes du côté gauche, même sans correspondance.

Requête SQL: LEFT JOINT-SQL
SELECT
    c.CustomerId,
    c.CustomerName,
    o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId;
T-SQL7 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Les clients sans commande apparaissent quand même, avec NULL dans les colonnes de commande.

Une erreur fréquente avec LEFT JOIN

Ceci ressemble à un LEFT JOIN :

Requête SQL: Une erreur fréquente avec LEFT JOINT-SQL
SELECT
    c.CustomerId,
    c.CustomerName,
    o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
WHERE o.OrderStatus = 'Open';
T-SQL8 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Mais le prédicat WHERE supprime les lignes où o.OrderStatus est NULL.

La requête devient en pratique un INNER JOIN.

Si vous voulez les clients même lorsqu’ils n’ont pas de commande ouverte, déplacez le filtre dans la jointure :

Requête SQL: Une erreur fréquente avec LEFT JOIN (2)T-SQL
SELECT
    c.CustomerId,
    c.CustomerName,
    o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
   AND o.OrderStatus = 'Open';
T-SQL8 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Utiliser EXISTS quand il suffit de savoir s’il existe une correspondance

Supposons que vous ayez seulement besoin des clients qui ont au moins une commande.

Ceci fonctionne :

Requête SQL: Utiliser EXISTS quand il suffit de savoir s’il existe une correspondanceT-SQL
SELECT DISTINCT
    c.CustomerId,
    c.CustomerName
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Mais EXISTS exprime le besoin plus directement :

Requête SQL: Utiliser EXISTS quand il suffit de savoir s’il existe une correspondance (2)T-SQL
SELECT
    c.CustomerId,
    c.CustomerName
FROM dbo.Customers AS c
WHERE EXISTS
(
    SELECT 1
    FROM dbo.Orders AS o
    WHERE o.CustomerId = c.CustomerId
);
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Quand vous n’avez pas besoin des colonnes de la seconde table, EXISTS est souvent une conception plus propre.

Joindre des données agrégées

Soyez prudent lorsque vous joignez après une agrégation.

Exemple :

Requête SQL: Joindre des données agrégéesT-SQL
WITH OrderTotals AS
(
    SELECT
        oi.OrderId,
        SUM(oi.Quantity * oi.UnitPrice) AS CalculatedTotal
    FROM dbo.OrderItems AS oi
    GROUP BY oi.OrderId
)
SELECT
    o.OrderId,
    o.TotalAmount,
    ot.CalculatedTotal
FROM dbo.Orders AS o
INNER JOIN OrderTotals AS ot
    ON ot.OrderId = o.OrderId;
T-SQL15 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Agréger d’abord peut réduire considérablement le nombre de lignes qui participent aux jointures suivantes.

Cela peut améliorer à la fois l’exactitude et la performance.

UPDATE avec JOIN

SQL Server permet à un UPDATE de cibler une table tout en utilisant des tables jointes pour identifier les lignes ou calculer les valeurs.

Exemple : désactiver les produits d’une catégorie abandonnée.

Requête SQL: UPDATE avec JOINT-SQL
UPDATE p
SET p.IsActive = 0
FROM dbo.Products AS p
INNER JOIN dbo.Categories AS c
    ON c.CategoryId = p.CategoryId
WHERE c.CategoryName = 'Discontinued';
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La cible est :

Requête SQL: UPDATE avec JOIN (2)T-SQL
UPDATE p
T-SQL1 ligneAffichage en lecture seule. Aucune connexion à une base de données.

La table jointe sert à qualifier les lignes.

UPDATE avec des valeurs provenant d’une autre table

Supposons que vous ayez une table de staging :

Requête SQL: UPDATE avec des valeurs provenant d’une autre tableT-SQL
CREATE TABLE dbo.ProductPriceStage
(
    ProductId int NOT NULL,
    NewPrice  decimal(18,2) NOT NULL
);
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Vous pouvez mettre à jour la cible avec les valeurs du staging :

Requête SQL: UPDATE avec des valeurs provenant d’une autre table (2)T-SQL
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
    ON s.ProductId = p.ProductId;
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

L’exigence importante est que la jointure identifie chaque ligne cible de façon déterministe.

UPDATE dangereux : plusieurs lignes source pour une même cible

Supposons que la table de staging contienne plusieurs lignes pour un même ProductId.

Alors :

Requête SQL: UPDATE dangereux : plusieurs lignes source pour une même cibleT-SQL
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
    ON s.ProductId = p.ProductId;
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

est ambigu d’un point de vue métier.

Vous devez d’abord garantir l’unicité :

Requête SQL: UPDATE dangereux : plusieurs lignes source pour une même cible (2)T-SQL
SELECT
    ProductId,
    COUNT(*) AS RowCount
FROM dbo.ProductPriceStage
GROUP BY ProductId
HAVING COUNT(*) > 1;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Une contrainte d’unicité ou un index unique est encore mieux lorsque le modèle impose une ligne par produit.

Requête SQL: UPDATE dangereux : plusieurs lignes source pour une même cible (3)T-SQL
CREATE UNIQUE INDEX UX_ProductPriceStage_ProductId
ON dbo.ProductPriceStage(ProductId);
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Mettre à jour plusieurs tables ?

Une seule instruction UPDATE SQL Server met à jour une seule table cible.

Vous pouvez joindre de nombreuses tables pour décider quelles lignes et quelles valeurs mettre à jour, mais une seule table est la cible.

Si plusieurs tables doivent changer, utilisez des instructions séparées dans une transaction lorsque l’atomicité est requise.

BEGIN TRANSACTION;

UPDATE ...;

UPDATE ...;

COMMIT TRANSACTION;

DELETE avec JOIN

SQL Server permet de supprimer des lignes d’une table en utilisant des tables jointes pour les identifier.

Exemple : supprimer les lignes des commandes annulées antérieures à une date limite.

Requête SQL: DELETE avec JOINT-SQL
DELETE oi
FROM dbo.OrderItems AS oi
INNER JOIN dbo.Orders AS o
    ON o.OrderId = oi.OrderId
WHERE o.OrderStatus = 'Cancelled'
  AND o.OrderDate < '2025-01-01';
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La table cible est :

Requête SQL: DELETE avec JOIN (2)T-SQL
DELETE oi
T-SQL1 ligneAffichage en lecture seule. Aucune connexion à une base de données.

C’est un détail de syntaxe SQL Server important.

Un workflow DELETE plus sûr

Avant d’exécuter le DELETE, exécutez la même logique sous forme de SELECT.

Requête SQL: Un workflow DELETE plus sûrT-SQL
SELECT
    oi.*
FROM dbo.OrderItems AS oi
INNER JOIN dbo.Orders AS o
    ON o.OrderId = oi.OrderId
WHERE o.OrderStatus = 'Cancelled'
  AND o.OrderDate < '2025-01-01';
T-SQL7 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Puis validez le nombre de lignes.

Requête SQL: Un workflow DELETE plus sûr (2)T-SQL
SELECT
    COUNT_BIG(*) AS RowsToDelete
FROM dbo.OrderItems AS oi
INNER JOIN dbo.Orders AS o
    ON o.OrderId = oi.OrderId
WHERE o.OrderStatus = 'Cancelled'
  AND o.OrderDate < '2025-01-01';
T-SQL7 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Seulement ensuite, transformez-la en DELETE.

Pour les suppressions volumineuses, procéder par lots peut être plus sûr.

DELETE par lots

Supprimer des millions de lignes dans une seule transaction peut provoquer :

  • une croissance du journal des transactions ;
  • des blocages ;
  • une escalade de verrous ;
  • de longs temps de rollback ;
  • une pression sur la réplication ou les groupes de disponibilité (AG).

Un pattern par lots peut aider :

Requête SQL: DELETE par lotsT-SQL
WHILE 1 = 1
BEGIN
    DELETE TOP (10000) oi
    FROM dbo.OrderItems AS oi
    INNER JOIN dbo.Orders AS o
        ON o.OrderId = oi.OrderId
    WHERE o.OrderStatus = 'Cancelled'
      AND o.OrderDate < '2025-01-01';

    IF @@ROWCOUNT = 0
        BREAK;
END;
T-SQL12 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La bonne taille de lot dépend de la charge.

DELETE avec EXISTS

Parfois, EXISTS est plus simple :

Requête SQL: DELETE avec EXISTST-SQL
DELETE oi
FROM dbo.OrderItems AS oi
WHERE EXISTS
(
    SELECT 1
    FROM dbo.Orders AS o
    WHERE o.OrderId = oi.OrderId
      AND o.OrderStatus = 'Cancelled'
      AND o.OrderDate < '2025-01-01'
);
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Les deux approches peuvent produire de bons plans.

Choisissez celle qui rend l’intention la plus claire et validez le plan d’exécution.

Les index sont essentiels pour la performance des JOINs

Une jointure tire généralement profit d’index sur :

  • les clés primaires ;
  • les clés étrangères ;
  • les colonnes de filtrage ;
  • les clés métier fréquemment jointes.

Dans notre exemple :

Customers.CustomerId
Orders.CustomerId
OrderItems.OrderId
OrderItems.ProductId
Products.ProductId
Products.CategoryId
Categories.CategoryId

Les clés primaires sont déjà indexées.

Les clés étrangères ne sont pas indexées automatiquement dans SQL Server.

C’est important.

Indexer les colonnes de clé étrangère quand le modèle d’accès l’exige

Par exemple :

Requête SQL: Indexer les colonnes de clé étrangère quand le modèle d’accès l’exigeT-SQL
CREATE INDEX IX_Orders_CustomerId
ON dbo.Orders(CustomerId);
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

et :

Requête SQL: Indexer les colonnes de clé étrangère quand le modèle d’accès l’exige (2)T-SQL
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId);
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Ces index peuvent aider SQL Server à trouver efficacement les lignes enfants pendant les jointures.

Ils peuvent aussi améliorer les mises à jour ou suppressions de lignes parentes lorsque les contrôles référentiels doivent examiner les tables enfants.

Mais n’indexez pas aveuglément chaque clé étrangère.

Mesurez la charge.

Index composites pour JOIN + filtre

Supposons que la requête soit :

Requête SQL: Index composites pour JOIN + filtreT-SQL
SELECT
    o.OrderId,
    o.OrderDate,
    o.TotalAmount
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
WHERE o.CustomerId = @CustomerId
  AND o.OrderDate >= @StartDate
  AND o.OrderDate < @EndDate;
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Un index utile pourrait être :

Requête SQL: Index composites pour JOIN + filtre (2)T-SQL
CREATE INDEX IX_Orders_CustomerId_OrderDate
ON dbo.Orders(CustomerId, OrderDate)
INCLUDE (OrderId, TotalAmount);
T-SQL3 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Pourquoi ?

Les colonnes clés soutiennent :

égalité sur CustomerId
+
plage sur OrderDate

Les colonnes incluses peuvent couvrir la sortie du SELECT.

L’ordre des colonnes compte

Ces deux index ne sont pas équivalents :

(CustomerId, OrderDate)

et :

(OrderDate, CustomerId)

Si le prédicat courant est :

CustomerId = constant
AND OrderDate BETWEEN ...

alors (CustomerId, OrderDate) offre souvent un meilleur chemin d’accès.

Mais la conception des index dépend de la distribution réelle de la charge et des modèles de requêtes.

Index couvrants

Un index couvrant contient assez de colonnes pour satisfaire la requête sans lookups supplémentaires.

Exemple :

Requête SQL: Index couvrantsT-SQL
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId)
INCLUDE (ProductId, Quantity, UnitPrice);
T-SQL3 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Une requête qui filtre ou joint sur OrderId peut alors éviter des key lookups répétés.

La couverture peut réduire les lectures.

Mais chaque colonne incluse augmente la taille de l’index et le coût des écritures.

Trop d’index peuvent ralentir les écritures liées aux JOINs

Les index accélèrent les lectures, mais doivent être maintenus pendant les :

INSERT
UPDATE
DELETE

Si une table a 20 index qui se chevauchent, une mise à jour basée sur une jointure peut passer beaucoup de temps à maintenir les index.

L’optimisation des performances est un équilibre :

bénéfice en lecture
vs
coût en écriture
vs
stockage
vs
maintenance

Les conversions implicites peuvent ruiner une bonne jointure

Supposons :

TableA.CustomerId = int
TableB.CustomerId = varchar(20)

Alors une jointure comme :

ON a.CustomerId = b.CustomerId

nécessite une conversion.

Cela peut :

  • empêcher des seeks efficaces ;
  • augmenter le CPU ;
  • fausser les estimations ;
  • augmenter les lectures.

Les colonnes de jointure doivent utiliser des types de données compatibles dans la mesure du possible.

La meilleure correction est généralement le modèle de données, pas l’ajout de fonctions autour des deux colonnes.

Éviter les fonctions sur les colonnes de jointure

Ceci pose souvent problème :

ON CAST(a.CustomerId AS varchar(20)) = b.CustomerId

ou :

ON UPPER(a.Code) = UPPER(b.Code)

Ces expressions peuvent rendre l’accès par index plus difficile.

Préférez stocker des valeurs comparables dans des types comparables et des formats normalisés.

Les jointures plusieurs-à-plusieurs peuvent faire exploser le nombre de lignes

Supposons que les deux côtés contiennent des clés en double :

Table A :
Key = 10 apparaît 100 fois

Table B :
Key = 10 apparaît 200 fois

Une jointure sur Key peut produire :

100 × 200 = 20 000 lignes

pour cette seule clé.

C’est l’une des raisons pour lesquelles des requêtes de jointure peuvent devenir énormes sans prévenir.

Avant de joindre, comprenez la relation attendue :

un-à-un
un-à-plusieurs
plusieurs-à-un
plusieurs-à-plusieurs

Si vous attendez une relation un-à-un, imposez-la avec une contrainte d’unicité ou un index unique lorsque c’est approprié.

Les statistiques influencent les choix de jointure

SQL Server choisit ses plans à partir des nombres de lignes estimés.

Ces estimations influencent le choix entre :

  • Nested Loops ;
  • Hash Match ;
  • Merge Join ;
  • l’ordre des jointures ;
  • l’allocation mémoire ;
  • le parallélisme.

Si les statistiques sont inexactes, la stratégie de jointure peut être mauvaise.

Nested Loops

Nested Loops fonctionne souvent bien lorsque :

  • l’entrée externe est petite ;
  • le côté interne dispose d’un index efficace ;
  • seul un nombre limité de lignes est attendu.

Conceptuellement :

Pour chaque ligne externe
    chercher (seek) les lignes internes correspondantes

Cela peut être extrêmement rapide.

Cela peut aussi être désastreux si SQL Server attend 10 lignes et en traite en réalité 10 millions.

Hash Match

Les jointures par hachage sont courantes pour les ensembles plus volumineux.

Conceptuellement :

construire une table de hachage à partir d'une entrée
la sonder avec l'autre entrée

Elles peuvent bien fonctionner pour de grosses jointures, même sans ordre utile.

Mais elles peuvent nécessiter beaucoup de mémoire.

De mauvaises estimations peuvent provoquer des débordements (spills) dans tempdb.

Merge Join

Merge Join peut être très efficace lorsque les deux entrées sont déjà triées sur les clés de jointure.

Conceptuellement :

entrée A triée
+
entrée B triée
→ parcourir les deux dans l'ordre

Mais obtenir l’ordre requis peut lui-même coûter cher si SQL Server doit trier.

Ne pas forcer un type de jointure sans preuve

SQL Server prend en charge les hints de jointure, mais ils doivent rester exceptionnels.

Par exemple :

OPTION (HASH JOIN);

peut améliorer un test et dégrader d’autres valeurs de paramètres ou de futures distributions de données.

Préférez corriger le problème de fond :

  • l’index ;
  • les statistiques ;
  • le type de données ;
  • la cardinalité ;
  • la forme de la requête.

Filtrer tôt, mais comprendre l’optimisation de SQL Server

Cela ne veut pas dire envelopper manuellement chaque table dans une CTE simplement pour « filtrer d’abord ».

L’optimiseur de SQL Server peut réordonner les jointures et pousser les prédicats.

Ce qui compte, c’est de lui fournir :

  • des prédicats SARGables ;
  • des index utiles ;
  • de bonnes statistiques ;
  • des relations claires.

Un bon prédicat :

o.OrderDate >= @StartDate
AND o.OrderDate < @EndDate

Un prédicat moins utile :

YEAR(o.OrderDate) = 2026

La première forme a plus de chances de permettre un index seek sur OrderDate.

Éviter SELECT *

Dans les grosses jointures, SELECT * peut :

  • renvoyer des données inutiles ;
  • augmenter le trafic réseau ;
  • augmenter les besoins en mémoire ;
  • empêcher l’usage d’index couvrants étroits ;
  • fragiliser le code lorsque les schémas changent.

Ne sélectionnez que les colonnes dont vous avez besoin.

Ne joindre que ce dont vous avez besoin

Cette requête :

Requête SQL: Ne joindre que ce dont vous avez besoinT-SQL
SELECT
    o.OrderId,
    c.CustomerName
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId
INNER JOIN dbo.Products AS p
    ON p.ProductId = oi.ProductId;
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

ne devrait pas joindre OrderItems et Products si aucun filtre ni aucune colonne de sortie ne l’exige.

Chaque jointure inutile augmente la complexité et peut augmenter le travail.

Les CTE n’améliorent pas automatiquement les performances

Une CTE peut améliorer la lisibilité :

WITH RecentOrders AS
(
    SELECT
        OrderId,
        CustomerId,
        OrderDate
    FROM dbo.Orders
    WHERE OrderDate >= @StartDate
)
SELECT ...

Mais une CTE ordinaire n’est pas automatiquement matérialisée.

SQL Server peut l’intégrer en ligne dans le plan global.

Utilisez les CTE pour la clarté, pas comme une barrière d’optimisation garantie.

Les tables temporaires peuvent aider les grosses jointures en plusieurs étapes

Parfois, découper une requête complexe en étapes améliore :

  • les estimations de cardinalité ;
  • les possibilités d’indexation ;
  • le diagnostic ;
  • la réutilisation.

Exemple :

Requête SQL: Les tables temporaires peuvent aider les grosses jointures en plusieurs étapesT-SQL
SELECT
    o.OrderId,
    o.CustomerId
INTO #RecentOrders
FROM dbo.Orders AS o
WHERE o.OrderDate >= @StartDate
  AND o.OrderDate < @EndDate;

CREATE INDEX IX_RecentOrders_CustomerId
ON #RecentOrders(CustomerId);
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Joignez ensuite #RecentOrders au reste du modèle.

C’est utile lorsqu’un résultat intermédiaire est bien plus petit que les données d’origine.

Mais les tables temporaires ajoutent aussi du travail dans tempdb.

Mesurez le compromis.

UPDATE et DELETE demandent la même réflexion sur la performance que SELECT

Une erreur fréquente consiste à n’optimiser que les requêtes SELECT.

Cet UPDATE :

Requête SQL: UPDATE et DELETE demandent la même réflexion sur la performance que SELECTT-SQL
UPDATE o
SET o.OrderStatus = 'Archived'
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
WHERE c.Status = 'Inactive';
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

oblige toujours SQL Server à :

  1. trouver les clients concernés ;
  2. trouver les commandes correspondantes ;
  3. mettre à jour les lignes ;
  4. maintenir les index ;
  5. journaliser les changements ;
  6. garder des verrous.

La conception des jointures et des index compte tout autant.

Les grosses mises à jour peuvent provoquer des blocages

Un seul UPDATE qui touche des millions de lignes peut :

  • garder des verrous longtemps ;
  • provoquer une escalade de verrous ;
  • faire grossir le journal des transactions ;
  • bloquer lecteurs et écrivains ;
  • entraîner de longs rollbacks.

Procéder par lots peut aider lorsque les règles métier le permettent.

Requête SQL: Les grosses mises à jour peuvent provoquer des blocagesT-SQL
WHILE 1 = 1
BEGIN
    UPDATE TOP (5000) o
    SET o.OrderStatus = 'Archived'
    FROM dbo.Orders AS o
    INNER JOIN dbo.Customers AS c
        ON c.CustomerId = o.CustomerId
    WHERE c.Status = 'Inactive'
      AND o.OrderStatus <> 'Archived';

    IF @@ROWCOUNT = 0
        BREAK;
END;
T-SQL13 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Vérifier le plan d’exécution

Pour les jointures importantes, examinez le plan d’exécution réel.

Recherchez :

  • les lignes estimées et réelles ;
  • les scans sur de grandes tables ;
  • les key lookups répétés ;
  • les spills de hachage ;
  • les spills de tri ;
  • les conversions implicites ;
  • les avertissements ;
  • un comportement plusieurs-à-plusieurs coûteux ;
  • des algorithmes de jointure inattendus.

Ne vous concentrez pas uniquement sur le pourcentage de coût des opérateurs.

Ces pourcentages sont des estimations de l’optimiseur, pas une mesure directe du temps d’exécution.

Mesurer les lectures logiques

SET STATISTICS IO ON est extrêmement utile.

SET STATISTICS IO ON;
SET STATISTICS TIME ON;

SELECT ...

Comparez avant et après.

Une requête qui passe de :

8 000 000 lectures logiques

à :

80 000 lectures logiques

représente généralement une réduction significative du travail.

Exemple : jointure multi-tables mal indexée

Imaginez cette requête :

Requête SQL: Exemple : jointure multi-tables mal indexéeT-SQL
SELECT
    c.CustomerName,
    o.OrderId,
    p.ProductName,
    oi.Quantity
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId
INNER JOIN dbo.Products AS p
    ON p.ProductId = oi.ProductId
WHERE c.Status = 'Active'
  AND o.OrderDate >= '2026-10-01';
T-SQL14 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Index de soutien possibles :

Requête SQL: Exemple : jointure multi-tables mal indexée (2)T-SQL
CREATE INDEX IX_Customers_Status
ON dbo.Customers(Status)
INCLUDE (CustomerId, CustomerName);

CREATE INDEX IX_Orders_CustomerId_OrderDate
ON dbo.Orders(CustomerId, OrderDate)
INCLUDE (OrderId);

CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId)
INCLUDE (ProductId, Quantity);
T-SQL11 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La clé primaire sur Products(ProductId) soutient déjà la dernière jointure.

Ces index sont des exemples, pas des prescriptions universelles.

Testez-les sur la charge réelle.

Un meilleur index peut dépendre du prédicat le plus sélectif

Supposons que presque tous les clients soient actifs.

Alors :

Customers(Status)

peut ne pas être assez sélectif pour aider.

Un index qui paraît logique sur le papier peut malgré tout ne servir à rien.

La conception des index doit tenir compte :

de la sélectivité
du nombre de lignes
de la fréquence des requêtes
du volume d'écriture
des index existants
des plans d'exécution réels

Les index sur clés étrangères peuvent aussi aider les DELETE

Supposons que vous supprimiez un client.

SQL Server peut devoir vérifier si des lignes enfants existent dans Orders.

Si Orders.CustomerId n’est pas indexée, les contrôles référentiels peuvent nécessiter un scan.

Un index sur la clé étrangère peut rendre ces contrôles beaucoup moins coûteux.

C’est l’une des raisons pour lesquelles l’indexation des clés étrangères peut compter au-delà de la performance des SELECT.

Liste de contrôle pour une bonne conception de jointure

Avant d’approuver une jointure en production, posez-vous ces questions :

Exactitude

  • La relation attendue est-elle un-à-un, un-à-plusieurs ou plusieurs-à-plusieurs ?
  • Des correspondances en double peuvent-elles multiplier les lignes ?
  • Le LEFT JOIN reste-t-il un LEFT JOIN après les prédicats WHERE ?
  • La cible de l’UPDATE/DELETE est-elle déterministe ?

Types de données

  • Les colonnes de jointure sont-elles de types identiques ou compatibles ?
  • Y a-t-il des conversions implicites ?
  • Des fonctions sont-elles appliquées aux colonnes de jointure ?

Indexation

  • Les clés primaires sont-elles indexées ?
  • Les clés étrangères fréquemment utilisées ont-elles besoin d’index ?
  • La requête a-t-elle besoin d’un index composite ?
  • Des colonnes INCLUDE éviteraient-elles des lookups coûteux ?
  • Existe-t-il déjà des index qui se chevauchent ?

Filtrage

  • Les prédicats sont-ils SARGables ?
  • La requête peut-elle réduire efficacement le nombre de lignes ?
  • Y a-t-il des jointures inutiles ?

Qualité du plan

  • Lignes estimées ou réelles ?
  • Quel algorithme de jointure ?
  • Un scan sur une très grande table ?
  • Des spills ?
  • Des avertissements ?
  • Des lookups répétés ?

Impact sur les écritures

Pour les UPDATE/DELETE :

  • Combien de lignes ?
  • Quel volume de journalisation ?
  • Quel risque de blocage ?
  • Faut-il procéder par lots ?
  • Combien d’index doivent être maintenus ?

Conclusion

La performance d’une jointure ne dépend pas seulement du nombre de tables.

Elle dépend :

des relations
du nombre de lignes
de la cardinalité
des index
des statistiques
des types de données
des filtres
des prédicats de jointure
des colonnes sélectionnées
du volume d'écriture

Une jointure à cinq tables bien conçue peut s’exécuter en quelques millisecondes.

Une jointure à deux tables mal conçue peut parcourir des centaines de millions de lignes.

Les règles pratiques sont simples :

  • comprenez la relation avant d’écrire le JOIN ;
  • n’utilisez pas DISTINCT pour masquer une logique de doublons ;
  • utilisez EXISTS quand seule l’existence compte ;
  • validez d’abord les jointures d’UPDATE et de DELETE avec un SELECT ;
  • indexez les colonnes de jointure lorsque la charge en tire profit ;
  • concevez les index composites autour des prédicats réels ;
  • évitez les conversions implicites ;
  • examinez les plans réels ;
  • comparez les lectures logiques ;
  • mesurez avant et après.

L’objectif n’est pas seulement d’écrire un SQL syntaxiquement correct.

L’objectif est de rendre la relation claire, déterministe et efficace.

Étiquettes

  • SQL Server
  • Performance
  • Indexation
  • Jointures (JOIN)
  • Plans d’exécution