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.
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.
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
);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.
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;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.
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';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 :
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;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.
SELECT
c.CustomerId,
c.CustomerName,
o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
ON o.CustomerId = c.CustomerId;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 :
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';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 :
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';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 :
SELECT DISTINCT
c.CustomerId,
c.CustomerName
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
ON o.CustomerId = c.CustomerId;Mais EXISTS exprime le besoin plus directement :
SELECT
c.CustomerId,
c.CustomerName
FROM dbo.Customers AS c
WHERE EXISTS
(
SELECT 1
FROM dbo.Orders AS o
WHERE o.CustomerId = c.CustomerId
);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 :
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;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.
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';La cible est :
UPDATE pLa table jointe sert à qualifier les lignes.
UPDATE avec des valeurs provenant d’une autre table
Supposons que vous ayez une table de staging :
CREATE TABLE dbo.ProductPriceStage
(
ProductId int NOT NULL,
NewPrice decimal(18,2) NOT NULL
);Vous pouvez mettre à jour la cible avec les valeurs du staging :
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
ON s.ProductId = p.ProductId;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 :
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
ON s.ProductId = p.ProductId;est ambigu d’un point de vue métier.
Vous devez d’abord garantir l’unicité :
SELECT
ProductId,
COUNT(*) AS RowCount
FROM dbo.ProductPriceStage
GROUP BY ProductId
HAVING COUNT(*) > 1;Une contrainte d’unicité ou un index unique est encore mieux lorsque le modèle impose une ligne par produit.
CREATE UNIQUE INDEX UX_ProductPriceStage_ProductId
ON dbo.ProductPriceStage(ProductId);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.
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';La table cible est :
DELETE oiC’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.
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';Puis validez le nombre de lignes.
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';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 :
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;La bonne taille de lot dépend de la charge.
DELETE avec EXISTS
Parfois, EXISTS est plus simple :
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'
);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 :
CREATE INDEX IX_Orders_CustomerId
ON dbo.Orders(CustomerId);et :
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId);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 :
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;Un index utile pourrait être :
CREATE INDEX IX_Orders_CustomerId_OrderDate
ON dbo.Orders(CustomerId, OrderDate)
INCLUDE (OrderId, TotalAmount);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 :
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId)
INCLUDE (ProductId, Quantity, UnitPrice);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 :
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;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 :
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);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 :
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';oblige toujours SQL Server à :
- trouver les clients concernés ;
- trouver les commandes correspondantes ;
- mettre à jour les lignes ;
- maintenir les index ;
- journaliser les changements ;
- 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.
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;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 :
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';Index de soutien possibles :
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);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
DISTINCTpour masquer une logique de doublons ; - utilisez
EXISTSquand 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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireTrouver les index manquantsUtilisez les DMV d’index manquants de SQL Server comme signal de tri, classez les candidats selon leur impact estimé et validez chaque recommandation avant de créer un index.Ouvrir l’aide-mémoire
- RessourceContenu en anglaisSQL Server Performance Tuning ChecklistA one-page troubleshooting reference for slow SQL Server workloads: ten steps from incident scope to measured change, with three diagnostic queries.Voir la ressource
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.