Exemples pratiques d'utilisation de JOIN non égaux en SQL

Si vous pensez que deux tables en SQL peuvent être jointes uniquement à l'aide du champ commun, vous serez ravi d'apprendre qu'il existe d'autres façons de les joindre. Les JOIN non équitables utilisent différents types d'opérateurs de comparaison dans la condition JOIN. Dans cet article, je vous guiderai à travers des exemples de JOIN non équi pour vous montrer les cas d'utilisation courants de ce type de JOIN.

JOIN équi et JOIN non-équi

Comment joint-on généralement deux tables en SQL ? Le plus souvent, vous sélectionnez le champ commun à ces deux tables et vous les joignez en utilisant le signe égal dans la condition de jointure. Par exemple, vous pouvez faire correspondre l'ID du produit de la table des produits avec l'ID du produit de la table des commandes ou le nom de famille de la table des employés avec le nom de famille de la feuille de temps.

Dans ces cas, vous utilisez une jointure equi, qui est juste un nom fantaisiste pour une jointure avec un signe égal dans la condition de jointure. Beaucoup de débutants en SQL utilisent des jointures equi et ne savent même pas que vous pouvez utiliser une condition de non-égalité dans une jointure.

Ces jointures sont appelées jointures non égales, et elles sont également possibles en SQL. Lorsque vous joignez deux tables en utilisant d'autres opérateurs conditionnels, au-delà du signe égal, les jointures non égales entrent en jeu. Les opérateurs de comparaison, comme <, >, <=, >=, != et <> et l'opérateur BETWEEN fonctionnent parfaitement pour joindre des tables en SQL.

Consultez ce guide illustré sur les jointures non égales en SQL pour mieux comprendre leur fonctionnement.

Apprendre à connaître les données

Avant de nous plonger dans différents exemples de jointures non équivoques, voyons d'abord les données que nous allons explorer dans cet article. Nous allons effectuer des analyses de données pour une agence immobilière qui gère une activité de location. Nous avons trois tables dans notre base de données imaginaire :

• houses avec l'ID de la maison, le quartier, l'adresse, le nombre de chambres et le loyer
• renters avec l'ID du locataire, son nom, son quartier préféré, le nombre minimum de chambres à coucher requis et la fourchette de loyer acceptable
• deals avec l'identifiant de l'affaire, la date, l'identifiant du locataire, l'identifiant de la maison et les frais d'agent reçus pour l'affaire correspondante.

Voir ces trois tables ci-dessous.

Houses

Renters

Deals

Maintenant, nous sommes prêts à passer aux exemples de JOIN non équi.

Cas d'utilisation des JOIN non équivoques

Si vous n'avez jamais utilisé de jointures non équivoques auparavant, vous vous demandez peut-être quels sont les scénarios les plus courants pour appliquer ce type de jointure non standard. En fait, il y en a un grand nombre. Vous pouvez utiliser les jointures non équitables pour répertorier toutes les paires (uniques) d'éléments, identifier les doublons, répertorier les éléments compris dans une certaine plage de valeurs ou entre certaines dates, calculer des totaux courants, etc.

Nous allons commencer par les cas d'utilisation les plus courants des jointures non équivoques.

Combinaisons de paires de listes

Imaginons que nos locataires soient prêts à envisager de partager une maison avec une autre famille. Nous voulons donc répertorier toutes les paires possibles de nos locataires avec leur district préféré pour voir quels locataires pourraient potentiellement louer une maison ensemble. Voici la requête SQL que vous pouvez utiliser :

SELECT r1.name, r1.preferred_district, r2.name, r2.preferred_district
FROM renters r1
JOIN renters r2
ON r1.preferred_district = r2.preferred_district AND r1.id != r2.id;

Comme vous pouvez le voir dans cet exemple, nous avons joint la table renters avec elle-même. Nous avons utilisé deux conditions avec des opérateurs de comparaison différents dans notre instruction JOIN :

• Le signe égal standard garantit que nous ne joignons que les clients ayant le même district préféré.
• L'opérateur de comparaison != garantit que le résultat inclura toutes les paires de locataires possibles, à l'exception de l'association des locataires avec eux-mêmes.

La deuxième condition avec l'opérateur != fait de ce JOIN un JOIN non égal.

Le résultat est plutôt bon, sauf que nous avons les mêmes paires de locataires listées deux fois dans notre tableau. Il serait plus logique de n'avoir que des paires uniques dans notre résultat. Cette très petite modification de notre requête est une astuce utile :

SELECT r1.name, r1.preferred_district, r2.name, r2.preferred_district
FROM renters r1
JOIN renters r2
ON r1.preferred_district = r2.preferred_district AND r1.id < r2.id;

En changeant l'opérateur de comparaison dans la deuxième condition de jointure de != à <, nous ne listons que les paires dans lesquelles la valeur d'identification du premier locataire est inférieure à la valeur d'identification du deuxième locataire. Ainsi, nous avons maintenant uniquement la ligne avec Michael Lane (ID 2) dans la première colonne et Susan Sanders (ID 3) dans la troisième colonne, et non la ligne où Susan Sanders vient en premier.

Pour répertorier toutes les paires (uniques) de clients, nous avons joint la table Renters avec elle-même, ce qui est en fait un self JOIN. Pour en savoir plus sur les self JOIN, consultez ce guide complet avec des exemples faciles à suivre.

Identification des doublons

Une autre application courante des jointures non égales est la recherche de doublons dans un ensemble de données. Par exemple, disons que nous voulons vérifier si notre table des maisons contient des doublons, c'est-à-dire des maisons ayant la même adresse mais des identifiants différents.

Notre requête sera très similaire à celle que nous avons utilisée pour lister les paires uniques, mais cette fois-ci, nous allons auto-joindre la table des maisons :

SELECT h1.id, h1.address, h2.id, h2.address
FROM houses h1
JOIN houses h2
ON h1.address = h2.address AND h1.id < h2.id;

Nous avons à nouveau deux conditions de jointure : (1) pour vérifier si l'adresse est la même, et (2) pour s'assurer que nous ne listons que les paires uniques avec des ID différents.

Le tableau ci-dessus montre qu'il y a un doublon dans notre ensemble de données. La maison située dans la rue Rose, 5 est mentionnée deux fois dans le tableau, avec l'ID 1 et l'ID 3.

Joindre des tables en utilisant une plage de valeurs

Parmi les autres applications populaires des jointures non équitables, citons la jointure de deux tables à l'aide de :

• L'opérateur BETWEEN pour vérifier si une certaine valeur/date tombe dans une plage spécifiée.
• des opérateurs de comparaison tels que >= ou <= pour vérifier la capacité.

Pour voir comment ces jointures non équitables fonctionnent dans la pratique, dressons une liste d'autres maisons que nous pouvons proposer à nos locataires comme alternative. Il doit s'agir de maisons (1) dans leur quartier préféré, (2) dans leur gamme de prix, (3) avec le nombre de chambres à coucher requis, et (4) non occupées (c'est-à-dire non répertoriées dans notre table des transactions). Voici la requête SQL que nous pouvons utiliser :

SELECT r.id, r.name, h.id, h.address, h.rent, h.bedrooms
FROM renters r
JOIN houses h
ON h.district = r.preferred_district
    AND h.rent BETWEEN r.min_rent AND r.max_rent
    AND h.bedrooms >= r.min_bedrooms
WHERE h.id NOT IN (SELECT house_id FROM deals);

Ici, dans la condition JOIN, nous avons vérifié les trois premières conditions mentionnées ci-dessus :

• si le quartier de la maison correspond au quartier préféré du locataire (condition d'égalité)
• si le loyer se situe dans la fourchette acceptable pour le locataire (condition de non-égalité avec la fourchette de valeurs)
• si le nombre de chambres à coucher est conforme aux exigences minimales (condition de non-égalité pour vérifier la capacité).

Ensuite, dans l'instruction WHERE, nous avons utilisé une sous-requête pour filtrer uniquement les maisons qui sont vraisemblablement libres, c'est-à-dire qui ne figurent pas encore dans notre table deals.

Et voici la liste des maisons que nous pouvons suggérer à nos clients (notez que la maison avec l'ID 3 est juste un duplicata de la maison que ce client loue actuellement) :

Pour vous entraîner davantage sur ces types de jointures SQL non équivoques, consultez notre cours complet sur les jointures SQL. Les jointures en SQL.

Scénarios avancés d'utilisation des jointures non équivoques

Outre les applications courantes des jointures non équivoques mentionnées ci-dessus, il existe des scénarios plus avancés pour l'utilisation de ces types de jointures. Nous allons nous plonger dans deux exemples.

Calcul des totaux courants

Une jointure non équivoque peut être utilisée pour calculer le total courant d'une colonne particulière. Par exemple, disons qu'après chaque transaction conclue, nous voulons connaître le total des honoraires d'agent reçus jusqu'à présent. Voici la requête SQL que nous pouvons utiliser :

SELECT d1.date, d1.agent_fee, SUM(d2.agent_fee) AS total_agent_fee
FROM deals d1
JOIN deals d2
ON d1.date >= d2.date
GROUP BY d1.agent_fee, d1.date
ORDER BY d1.date;

Nous avons auto-joint la table deals et utilisé une condition non-equi JOIN pour additionner tous les frais d'agent reçus jusqu'à la date de la transaction. Voici le résultat.

Veuillez noter qu'une meilleure façon de calculer un total courant est d'utiliser les fonctions de fenêtre. Notre guide correspondant explique ce qu'est un total courant et comment écrire une requête SQL pour le calculer. Pour vous entraîner, consultez le cours interactif LearnSQL.fr Fonctions de fenêtrage.

Résolution des conflits entre les LEFT JOIN et WHERE

Les JOIN non équivoques peuvent également être utiles dans certaines situations où LEFT JOIN combiné à l'instruction WHERE ne fonctionne pas comme prévu. En particulier, il arrive souvent que la condition WHERE "annule" la condition LEFT JOIN, la faisant fonctionner comme une INNER JOIN à la place.

Par exemple, disons que nous voulons répertorier toutes les maisons de notre base de données avec la date de la transaction correspondante, si elle a eu lieu. Nous voulons également prendre en compte uniquement les transactions qui ont eu lieu après le 1er mars.

Puisque nous souhaitons répertorier toutes les maisons, qu'elles aient ou non une transaction correspondante, nous utiliserons LEFT JOIN dans notre requête SQL. Nous ajouterons également une condition WHERE pour ne considérer que les transactions réalisées après une certaine date :

SELECT h.id, h.address, d.date
FROM houses h
LEFT JOIN deals d
ON h.id = d.house_id
WHERE d.date >= '2020-03-01';

Comme vous pouvez le voir, le résultat n'est pas exactement ce que nous voulions. Le tableau ne comprend que les maisons qui ont été louées après le 1er mars au lieu de toutes les maisons.

Une solution consiste à déplacer la condition WHERE sur ON et à en faire une condition JOIN. Il s'agira d'un JOIN non égal puisqu'il utilise un opérateur de comparaison >=.

SELECT h.id, h.address, d.date
FROM houses h
LEFT JOIN deals d
ON h.id = d.house_id AND d.date >= '2020-03-01';

Maintenant, toutes les maisons apparaissent dans le résultat, même si elles n'ont pas d'offres correspondantes.

Il est temps de pratiquer les jointures non équivoques !

Vous avez appris que les jointures non équivoques peuvent être très utiles dans différents scénarios. Vous pouvez répertorier les paires uniques dans une table, identifier les doublons, joindre des tables à l'aide d'une plage de valeurs et de dates, calculer des totaux courants sans utiliser de fonctions de fenêtre, etc.

Maintenant, quelle est la meilleure façon de pratiquer Les jointures en SQL? Sans aucun doute, en écrivant du code. Passons donc aux exercices interactifs !

Le cours LearnSQL.fr Les jointures en SQL couvre différents types de JOIN, y compris les JOIN non équitables. Vous aurez l'occasion de pratiquer les JOIN non équi dans différents cas d'utilisation. En outre, le cours complet SQL pour les débutants offre une pratique supplémentaire des JOIN non équivoques en expliquant l'interrogation de plus d'une table et en explorant des sujets plus approfondis sur les JOIN.

Bon apprentissage !