Traditionnellement, vous extrayez des données de deux tables ou plus en utilisant un WHERE clause dans une requête. Mais dans un système de base de données relationnelle (RDBMS), cela peut être réalisé en utilisant un seul SELECT requête. C'est la véritable puissance des systèmes de bases de données relationnelles. Dans ce guide, vous découvrirez les jointures SQL, un moyen puissant de comparer et de sélectionner des lignes et des tables.
Qu'est-ce qu'une jointure SQL ?
En SQL, une join La clause étend la possibilité de comparer et de sélectionner des lignes dans des tables. Il utilise un processus algébrique consistant à combiner des lignes de deux tables ou plus en fonction d'une colonne liée dans ces tables. Selon la définition SQL standard ANSI, il existe cinq types de jointures - Cross Joins , jointures internes , Joints gauches (externes) , Joindre (externe) à droite , et jointures complètes (externes) . Ces jointures sont implémentées dans tous les systèmes de bases de données relationnelles et sont traitées dans les sections ci-dessous.
Remarque Les jointures peuvent être effectuées sur n'importe quel nombre de tables dans une requête donnée. Par souci de concision et de clarté, ce guide traite des jointures appliquées à deux tables.
Ce guide utilise deux tables, Employees et Address , respectivement, pour illustrer les jointures SQL. Chacune de ces tables contient les définitions de colonne et les données suivantes :
-
Tableau des employés
Identifiant de l'employé NomEmployé 1 Jean 2 Marie 3 Robert -
Tableau d'adresses
Identifiant État 1 New York 2 New Jersey 3 Idaho 4 Hawaï
Remarque Sauf mention contraire, toutes les commandes de ce guide fonctionnent bien sur MySQL et PostgreSQL bases de données.
Jointures croisées SQL
Aussi connu sous le nom de jointure cartésienne , les jointures croisées se produisent lorsque vous spécifiez plusieurs tables comme source pour votre SELECT liste des colonnes. Dans ce cas, vous omettez le WHERE expression de jointure de clause pour faire correspondre les lignes. Le jeu de résultats contient une ligne pour chaque combinaison de lignes entre les tables. Dans un scénario à deux tables, chaque ligne d'une table est associée à chaque ligne de l'autre table. Le produit résultant est appelé Produit Cartésien des deux tableaux. La syntaxe d'une jointure croisée est la suivante :
(# Rows in Table A) TIMES (# of Rows in Table B)
RemarqueEn théorie des ensembles, le produit cartésien est une opération de multiplication qui génère toutes les paires ordonnées des ensembles donnés. Par exemple, considérez set
Aavec des éléments{a,b}et définissezBavec les éléments{1,2,3}. Le produit cartésien deAetBest notéAxBet le résultat est le suivant :AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}
La syntaxe SQL d'une jointure croisée est la suivante :
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM [Table_1]
CROSS JOIN [Table_2]
À partir de la syntaxe ci-dessus, Column_1 , Column_2 , Column_N représentent les colonnes d'une table, et le CROSS JOIN la clause sert à combiner les deux tables, Table_1 et Table_2 . À partir des exemples de tableaux ci-dessus, si vous devez effectuer une jointure croisée sur Employees et Address tables, utilisez le code SQL suivant :
SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address
La sortie du code SQL ci-dessus ressemble à ce qui suit :
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| John | New Jersey |
| John | Idaho |
| John | Hawaii |
| John | New York |
| Mary | New York |
| Mary | New Jersey |
| Mary | Idaho |
| Mary | Hawaii |
| Robert | New York |
| Robert | New Jersey |
| Robert | Idaho |
| Robert | Hawaii |
+------------+----------------+Jointure interne SQL
Une jointure interne renvoie les lignes dont les valeurs correspondent dans les deux tables. S'il n'y a pas d'enregistrements correspondants, aucune ligne n'est renvoyée dans les résultats.
La syntaxe SQL pour Inner Join est la suivante :
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;
Dans l'exemple ci-dessus, key est la clé respective des tables. Si vous devez effectuer une jointure interne sur Employees et Address tables, utilisez le code SQL suivant :
SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id
La sortie du code SQL ci-dessus ressemble à ce qui suit :
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
+------------+----------------+Jointure SQL gauche (externe)
Une jointure gauche renvoie un ensemble complet de lignes de la table de gauche avec les lignes correspondantes de la table de droite. S'il n'y a pas d'enregistrements correspondants, alors NULL les valeurs sont renvoyées de la table de droite.
Remarque Certaines implémentations de bases de données relationnelles utilisent les mots clés "Left Outer Join", par opposition à "Left Join", mais ils sont fonctionnellement équivalents.
La syntaxe SQL pour Left Join est la suivante :
SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key
Dans l'exemple ci-dessus, key est la clé respective des tables. Si vous devez effectuer une jointure gauche sur Employees et Address tables, utilisez le code SQL suivant :
SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id
La sortie du code SQL ci-dessus est la suivante :
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
+------------+----------------+Jointure SQL droite (externe)
Une jointure droite renvoie un ensemble complet de lignes de la table de droite et les lignes correspondantes de la table de gauche. Ceci est également connu sous le nom de jointure externe droite. S'il n'y a pas d'enregistrements correspondants, alors NULL les valeurs sont renvoyées du tableau de droite, pour les lignes affectées du tableau de gauche.
Remarque Certaines implémentations de bases de données relationnelles utilisent les mots clés "Right Outer Join", par opposition à "Right Join", mais ils sont fonctionnellement équivalents.
La syntaxe SQL d'une jointure droite est la suivante :
SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key
À partir du code ci-dessus, key est la clé respective des tables. Si vous devez effectuer une jointure à droite sur Employees et Address tables, utilisez le code SQL suivant :
SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id
La sortie du code SQL ci-dessus est la suivante :
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+Jointure SQL complète (externe)
Une jointure complète renvoie toutes les lignes de la table de gauche, toutes les lignes de la table de droite. Ceci est également connu sous le nom de jointure externe complète. Une jointure complète renvoie également tous les enregistrements correspondants des deux tables, le cas échéant. S'il n'y a pas d'enregistrements correspondants, alors NULL les valeurs sont renvoyées du tableau de gauche. Il renvoie également NULL valeurs du tableau de droite.
Remarque Certaines implémentations de bases de données relationnelles utilisent les mots-clés "Full Outer Join", par opposition à "Full Join", mais ils sont fonctionnellement équivalents.
La syntaxe SQL pour la jointure complète est la suivante :
SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key
Dans le code ci-dessus, key est la clé respective des tables. Si vous devez effectuer une jointure complète sur Employees et Address tables, utilisez le code SQL suivant :
SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id
La sortie du code SQL ci-dessus est la suivante :
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+Remarque Lors des calculs de jointure, si vous comparez les données de la table avecNULLvaleurs, elles ne correspondent pas. Par conséquent,NULLles valeurs ne sont renvoyées que dans le cadre des résultats de jointure et sont ignorées lors des calculs de jointure.
Comparaison des performances des jointures SQL
Compte tenu des exemples de tables ci-dessus, la jointure interne est généralement la plus rapide des cinq clauses Join en termes de performances de base de données. La jointure gauche et la jointure droite sont les suivantes les plus rapides en fonction de la taille des deux tables. La jointure complète est généralement plus lente que la jointure gauche ou la jointure droite. La jointure croisée, qui dépend du produit cartésien des deux tables, est généralement la plus lente en termes de performances de base de données. La hiérarchie des performances spécifiée peut varier en fonction de la longueur de la colonne de la table, du type de données de la colonne et des définitions de clé.
Conclusion
L'utilisation de SQL Joins étend la fonctionnalité de pouvoir comparer les lignes de table, par rapport à WHERE traditionnel requêtes de clauses. Les jointures sont un mécanisme précieux pour appliquer une logique algébrique à deux tables ou plus.
