Exemples de jointure LEFT JOIN avec SQL Server

Comment écrire une requête de jointure Left Join avec SQL Server ?

Ces exemples de jointure LEFT JOIN écrites avec SQL Server permettent d’extraire des données de deux ou plusieurs tables en se basant sur les relations entre les objets. Les jointures LEFT JOIN SQL Server indiquent comment le moteur SQL doit utiliser les données d’une table pour sélectionner les lignes d’une autre table.

Une jointure peut regrouper les données de plusieurs tables, et chaque relation entre deux tables est indiquée dans la requête. Les conditions de la requête indiquent comment relier logiquement les données entre les tables. Ainsi, les conditions de jointure peuvent être spécifiées dans la clause FROM ou la clause WHERE. Avec la clause FROM, par exemple, c’est la relation qui filtre les données affichées.

1. Objectif des jointures SQL Server

L’objectif principal de l’utilisation des jointures est d’éviter de stocker les mêmes données plusieurs fois dans une base de données. C’est ce que l’on appelle la normalisation d’une base de données relationnelle.

Par exemple, 2 millions de lignes de vente par an mais seulement 10 magasins physiques différents et 20 000 clients dans la base de données. Il est préférable de stocker toutes les informations dans les tables magasins et clients une seule fois et dans une table dédiée. Cela permet de réduire la taille de la base de données. Et donc d’améliorer les performances.

2. Spécificités d’une requête LEFT JOIN en SQL

Généralement, une requête de jointure LEFT JOIN est filtrée à l’aide d’une clé primaire dans la première table (ou table principale) et d’une clé étrangère dans les autres tables. Cela permet d’assurer la cohérence des données dans la base. Ce sont les clés logiques qui sont utilisées, et il n’est pas obligatoire que des contraintes physiques soient présentes dans le modèle de données.

3. Utilisation de clés primaires et étrangères

L’utilisation de clés primaires et étrangères dans une requête LEFT JOIN permet de relier les tables de manière logique et efficace. La clé primaire est un identifiant unique pour chaque enregistrement dans une table, tandis que la clé étrangère fait référence à la clé primaire d’une autre table. Cette relation entre les clés permet de s’assurer que les données sont cohérentes et fiables.

Les clés primaires et étrangères sont cruciales pour maintenir l’intégrité référentielle dans une base de données relationnelle. L’intégrité référentielle garantit que les relations entre les tables sont maintenues de manière cohérente et qu’aucune donnée orpheline (c’est-à-dire sans référence parente) n’est présente.

4. Contraintes logiques et physiques

Les contraintes logiques sont des règles définies pour les relations entre les tables, comme les clés primaires et étrangères. Les contraintes physiques, en revanche, sont des limitations imposées par le système de gestion de base de données (SGBD) pour assurer l’intégrité et la performance des données.

Dans une requête LEFT JOIN, il n’est pas obligatoire d’avoir des contraintes physiques présentes dans le modèle de données. Cependant, il est toujours recommandé d’utiliser des contraintes logiques pour assurer la cohérence des données et faciliter la compréhension du modèle de données.

5. Les différents types de jointures T-SQL

Quels sont les différents types de jointures T-SQL disponibles avec SQL Server ? Les différents types de jointures en T-SQL sont les suivants :

  • Jointure gauche – LEFT JOIN
  • Jointure externe gauche – LEFT OUTER JOIN
  • Jointure droite – RIGHT JOIN
  • Jointure externe droite – RIGHT OUTER JOIN
  • Jointure complète – FULL JOIN
  • Jointure extérieure complète – FULL OUTER JOIN
  • Jointure interne – INNER JOIN

Nous nous concentrerons ici sur les jointures gauches appelées LEFT JOIN.

Pour commencer à illustrer les différents types de jointures avec des exemples de requêtes, nous avons besoin d’un échantillon de données. Utilisons la base de données Adventure Works, comme j’utilise la version MS SQL 2019, j’ai téléchargé la base de données AdventureWorks2019.

Toutes les étapes sont expliquées sur le site avec les liens vers toutes les versions d’AdventureWorks, de SQL Server 2008 R2 à SQL Server 2019. Considérons donc les tables Salesperson (vendeurs) et la table Store (magasins).

-- La table des vendeurs
SELECT TOP 15
   [BusinessEntityID], 
   [TerritoryID], 
   [SalesQuota], 
   [Bonus], 
   [CommissionPct], 
   [SalesYTD], 
   [SalesLastYear], 
   [rowguid], 
   [ModifiedDate]
FROM [Sales].[SalesPerson];

-- La table des magasins
SELECT TOP 15
   [BusinessEntityID], 
   [Name], 
   [SalesPersonID], 
   [rowguid], 
   [ModifiedDate]
FROM [Sales].[Store] 
ORDER BY [SalesPersonID];

6. Analyse des clefs étrangères entre les tables

Les tables Salesperson et Store sont liées entre elles par une contrainte physique. Noter que la colonne SalesPersonID de la colonne [Sales].[Store] est liée à la colonne BusinessEntityID de la table [Sales].[SalesPerson].

Cette différence dans les noms des colonnes est une source de confusion. Voici un extrait de la façon dont les deux tables sont liées. Le code suivant provient de l’instruction de création de la table [Sales].[Store] qui contient les données des magasins :

ADD CONSTRAINT [FK_Store_SalesPerson_SalesPersonID]
  FOREIGN KEY([SalesPersonID]) 
    REFERENCES [Sales].[SalesPerson] ([BusinessEntityID]);

Les tables SalesPerson et SalesTerritory sont également liées. Script extrait du code [Sales].[SalesPerson] qui contient les informations des vendeurs:

ADD  CONSTRAINT [FK_SalesPerson_SalesTerritory_TerritoryID]
  FOREIGN KEY([TerritoryID])
    REFERENCES [Sales].[SalesTerritory] ([TerritoryID]);

Une autre requête SQL complexe et très pratique permet elle de pivoter les lignes d’une table SQL Server en colonnes.

7. Exemple de requête LEFT JOIN avec SQL Server

Par exemple, pour afficher le nom du magasin et les informations sur les ventes du vendeur, joindre la table SalesPerson et la table Store. Il est recommandé de créer un alias pour les tables afin de rendre la requête lisible.

La jointure LEFT JOIN utilise la première table de la clause FROM. La table des vendeurs (SalesPerson) est donc la première table. Elle joint ensuite les données de la table de gauche (vendeurs) aux données de la table de droite (magasins). Parmi les exemples de jointure LEFT JOIN avec SQL Server, la requête ci-dessous récupère le nom du magasin depuis la table des magasins, c’est à dire Sales.Store.

SELECT 
   person.[BusinessEntityID],
   store.[Name] as StoreName, 
   [TerritoryID], 
   [SalesQuota], 
   [Bonus], 
   [CommissionPct], 
   [SalesYTD], 
   [SalesLastYear], 
   person.[rowguid], 
   person.[ModifiedDate]
FROM [Sales].[SalesPerson] person
   LEFT JOIN [Sales].[Store] store 
      on person.BusinessEntityID = store.[SalesPersonID]
ORDER BY person.[BusinessEntityID];

8. Exemple de requête MS SQL LEFT OUTER JOIN

Les requêtes LEFT JOIN et LEFT OUTER JOIN sont identiques, car elles renvoient exactement le même jeu de données. Pour supprimer les données disponibles uniquement dans la table de droite, utiliser la clause WHERE. Cela permet d’exclure les valeurs NULL, comme dans l’exemple ci-dessous.

SELECT 
   person.[BusinessEntityID],
   store.[Name] as StoreName, 
   [TerritoryID], 
   [SalesQuota], 
   [Bonus], 
   [CommissionPct], 
   [SalesYTD], 
   [SalesLastYear], 
   person.[rowguid], 
   person.[ModifiedDate]
FROM [Sales].[SalesPerson] person
   LEFT JOIN [Sales].[Store] store 
      on person.BusinessEntityID = store.[SalesPersonID]
WHERE store.[SalesPersonID] IS NOT NULL
ORDER BY person.[BusinessEntityID];

Il n’y a donc pas de différence entre LEFT JOIN et LEFT OUTER JOIN dans les jointures SQL Server.

9. Optimiser les performances des jointures gauches avec SQL Server

Enfin, maintenir des temps de réponse acceptables pour les requêtes de type LEFT JOIN nécessite de suivre certaines bonnes pratiques. En effet, suivre ces conseils peut améliorer la performance, la lisibilité et la maintenabilité de vos requêtes LEFT JOIN SQL.

  • Utiliser des index sur les clés primaires et étrangères pour améliorer les performances de la requête.
  • Éviter les jointures inutiles et les colonnes non pertinentes pour réduire la complexité de la requête.
  • Appliquer des filtres et des conditions de recherche appropriés pour limiter le nombre de lignes traitées par la requête.
  • Utiliser des alias pour les noms de table pour améliorer la lisibilité de la requête et faciliter la maintenance.
  • Analyser et surveiller les performances de la requête à l’aide des outils de profilage et d’optimisation fournis par le SGBD.

10. Conclusion sur les requêtes LEFT JOIN SQL Server

Cet article expose quelques Exemples de jointure LEFT JOIN avec SQL Server avec la façon de construire les jointures LEFT JOIN. Les exemples de requêtes SQL Server LEFT JOIN permettent d’extraire des données de plusieurs tables en se basant sur les relations entre les objets. Les conditions de jointures indiquent comment le moteur SQL doit utiliser les données d’une table pour sélectionner les lignes d’une autre table.

L’utilisation de clés primaires et étrangères dans une requête LEFT JOIN permet de relier les tables de manière logique et efficace, garantissant ainsi la cohérence et la fiabilité des données.

Les requêtes SQL Server les plus courantes restent les requêtes de sélection et d’insertion des données.

Retour en haut