Saviez-vous qu'en SQL, une jointure ne doit pas nécessairement être basée sur des correspondances identiques ? Dans cet article, nous examinons la jointure SQL non equi, qui utilise des opérateurs " non égaux " pour faire correspondre les enregistrements.

Nous avons déjà abordé plusieurs types de jointures, notamment les auto-joints et les CROSS JOIN, INNER JOIN et OUTER JOIN. Ces types de jointures apparaissent généralement avec le signe égal (=). Cependant, certaines jointures utilisent des conditions autres que le signe égal (=). C'est un exemple de jointure non équivoque en SQL, et c'est ce dont nous allons parler dans cet article.

Qu'est-ce qu'une jointure non équivoque en SQL ?

Si vous avez lu les autres articles de cette série, vous savez comment utiliser les jointures SQL pour combiner des enregistrements sur la base de correspondances de valeurs exactes. Mais que se passe-t-il si vous recherchez un enregistrement qui n'a pas besoin d'une correspondance exacte ? Supposons que vous vouliez joindre des enregistrements sur la base d'une plage de valeurs. Ou bien vous voulez tous les enregistrements qui ne correspondent pas à une valeur donnée. Dans ces cas, vous devez utiliser une jointure SQL non équivoque.

Comme une jointure automatique, une jointure SQL non équi n'a pas de mot clé spécifique ; vous ne verrez jamais les mots NON EQUI JOIN dans le code SQL de quiconque. Au lieu de cela, elles sont définies par le type d'opérateur dans la condition de jointure : tout ce qui n'est pas un signe égal signifie une jointure non equi. Comme vous le verrez dans l'encadré ci-dessous, le signe égal fait parfois partie de l'opérateur. Mais dans une jointure SQL non equi, il ne s'agit jamais de l'opérateur entier en soi. Vous trouverez ci-dessous quelques opérateurs de jointure non équi et leur signification :

Enfin, il est bon de savoir qu'une jointure SQL non equi ne peut être utilisée qu'avec une ou deux tables.

Apprendre à connaître nos données

Avant de commencer à décrire les jointures non équi, nous allons nous familiariser avec certaines des données que nous allons utiliser. Nous allons également passer en revue les jointures équi.

Ci-dessous, nous avons la table "person"qui contient les enregistrements des personnes impliquées dans l'achat d'un appartement (c'est-à-dire d'une copropriété). Toutes ses colonnes sont explicites, mais remarquez les colonnes "min_price" et "max_price". Il s'agit de la fourchette de prix de la personne pour un appartement. La colonne "apartment_id" reliera cette table à la table "apartment".

La table "apartment" contient des informations sur les appartements, le nombre de pièces et la ville. Remarquez que les valeurs de la colonne "id" sont fondamentalement les mêmes que celles de la colonne "apartment_id" ci-dessus.

Passons maintenant en revue les jointures équi.

Qu'est-ce qu'une jointure SQL équi ?

La majorité des jointures SQL sont des jointures équi. Une jointure équi est une opération de jointure qui utilise un signe égal et uniquement un signe égal. Vous verrez des requêtes qui utilisent plus d'une condition de jointure ; si l'une des conditions est un signe égal et que l'autre ne l'est pas, cela est considéré comme une jointure non équi en SQL.

Comme nous l'avons déjà dit, les jointures équi nécessitent une correspondance exacte entre deux colonnes. Jetez un coup d'œil à la requête ci-dessous :

SELECT first_name, last_name, price, city 
FROM person 
JOIN  apartment  ON   apartment.id = person.apartment_id ;

Cette requête sélectionne le prénom et le nom du client, le prix de l'appartement, et la ville dans laquelle l'appartement est situé. Nous avons utilisé un JOIN (alias un INNER JOIN) pour combiner les données des colonnes "person" et "apartment". Cette jointure n'affiche que les enregistrements qui peuvent être mis en correspondance dans les deux tables. Dans la condition de jointure, nous avons utilisé l'opérateur égal sur la colonne "apartment_id" de la table " " et la colonne " id " de la table " ".person" et la colonne "id" de la table "apartment" pour trouver une correspondance exacte.

Le tableau résultant contient les lignes suivantes :

Nous avons vu comment fonctionne une jointure equi. Voyons maintenant les jointures SQL non équi.

Utilisation d'une jointure SQL non équi avec deux tables

SELECT first_name, last_name, min_price, max_price, price, city 
FROM person JOIN apartment ON apartment.id != person.apartment_id
    AND price BETWEEN min_price AND max_price
ORDER BY last_name;

Nous avons utilisé l'opérateur JOIN pour combiner les enregistrements des tables "person" et "apartment". Nous avons sélectionné le prénom et le nom de chaque personne, les prix minimal et maximal souhaités, ainsi que le prix et la ville de tous les appartements non choisis par le client. Nous avons utilisé l'opérateur BETWEEN... AND pour faire correspondre les prix des appartements. Nous avons également utilisé l'opérateur "!=" dans une condition avec "apartment_id" de la table "person"et "id" de la table "apartment". Ce faisant, nous avons supprimé l'appartement qui a été choisi dans le tableau des résultats.

Le tableau de résultat ressemble à ceci :

L'appartement de Dallas choisi par John Harris n'est pas affiché. Notez qu'il aurait pu choisir un appartement à Houston (30 000 $) ou à Cleveland (36 000 $). Ces deux appartements entrent dans sa fourchette de prix de 20 000 à 50 000 dollars.

SQL Non Equi Join dans Self Join

Voyons maintenant comment fonctionne une jointure SQL non equi lorsqu'une table est jointe à elle-même. Nos exemples seront basés sur la table "playing_cards" présentée ci-dessous. Elle contient les colonnes suivantes : "id" (un identifiant interne), "rank" (le rang ou la valeur faciale de la carte), et "suit" (la couleur de la carte).

Voici les cartes stockées dans la table "playing_cards" :

Notez que nous n'avons que sept cartes dans le jeu.

Voyons trois façons d'utiliser les jointures non équivoques dans ces circonstances.

1. Recherche de toutes les paires de cartes

En se basant sur l'ensemble des cartes de la table "playing_cards", nous trouverons toutes les paires de cartes possibles.

Jetez un coup d'oeil à la requête :

SELECT c1.rank, c1.suit, c2.rank,c2.suit
FROM playing_cards c1 
JOIN playing_cards c2 ON c1.id != c2.id 
ORDER BY c1.rank;

Dans la requête ci-dessus, nous avons joint la table "playing_cards" à elle-même en utilisant les alias c1 et c2. () Nous avons ensuite utilisé l'opérateur d'inégalité "!=", en créant une jointure SQL non équi, pour obtenir toutes les paires de cartes possibles. Cet opérateur affiche les paires de cartes dans un ordre variable et supprime les paires de cartes identiques en même temps.

Le tableau ci-dessous montre certaines des lignes qui en résultent. Nous avons mis en évidence les lignes contenant des paires en double.

Nous voyons les 12 premiers des 42 enregistrements totaux. L'image ci-dessous montre ces paires sélectionnées :

2. Élimination des paires de cartes en double

Les paires de cartes retournées par la dernière requête n'étaient pas uniques car le résultat de la requête incluait des paires présentées dans l'ordre inverse, c'est-à-dire "As de pique avec As de trèfle" et "As de trèfle avec As de pique".

Dans la prochaine requête, nous ne retournerons que les paires uniques. La position des cartes dans la paire n'a pas d'importance.

SELECT c1.rank, c1.suit,c2.rank,c2.suit
FROM playing_cards c1 
JOIN playing_cards c2 ON c1.id < c2.id 
ORDER BY c1.rank;

Comme vous le voyez, nous avons utilisé une jointure SQL non equi avec l'opérateur "<" au lieu de "!=". En conséquence, nous avons obtenu des paires de cartes uniques.

Et voici les résultats :

Dans ce cas, 21 enregistrements correspondent à la condition, et toutes les paires résultantes n'apparaissent qu'une seule fois.

3. Recherche de paires de cartes de même couleur

Dans la requête suivante, nous allons sélectionner des paires uniques de cartes de la même couleur (cœur, pique, trèfle et carreau). Pouvez-vous trouver l'opérateur non equi que nous avons utilisé ?

SELECT c1.rank, c1.suit,c2.rank,c2.suit
FROM playing_cards c1 
JOIN playing_cards c2 ON c1.rank < c2.rank AND c1.suit = c2.suit ;

La requête ci-dessus utilise deux conditions : une qui compare le "rang" des cartes et une autre qui compare la colonne "suit".

Jetez un coup d'œil au résultat de la requête.

Seuls quatre enregistrements correspondent aux conditions de JOIN. La situation est illustrée ci-dessous.

En savoir plus sur SQL

Vous savez maintenant ce qu'est une jointure non équi SQL et comment elle fonctionne. Si vous souhaitez en savoir plus sur SQL, consultez les cours de LearnSQL.fr. Vous pourrez mettre en pratique vos nouvelles connaissances grâce à des exercices interactifs. Vous pouvez également en apprendre davantage sur les jointures SQL dans nos articles, Joints SQL et Apprendre Les jointures en SQL en utilisant des situations réelles.