Qu'est-ce que SQL JOIN ?
SQL JOIN est une méthode pour extraire des données à partir de deux tables de base de données ou
plus.
Quels sont les différents SQL JOIN s?
il y a un total de cinq JOIN s. Ce sont :
1. JOIN or INNER JOIN
2. OUTER JOIN
2.1 LEFT OUTER JOIN or LEFT JOIN
2.2 RIGHT OUTER JOIN or RIGHT JOIN
2.3 FULL OUTER JOIN or FULL JOIN
3. NATURAL JOIN
4. CROSS JOIN
5. SELF JOIN
1.
dans ce genre de JOIN , nous obtenons tous les enregistrements qui correspondent à l'état dans les
deux tables, et les enregistrements dans les deux tableaux, les résultats qui ne concordent pas ne
sont pas déclarés.
en d'autres termes, INNER JOIN est basé sur le seul fait que: seules les entrées correspondantes
dans les deux tableaux doivent être énumérés.
notez qu'un JOIN sans aucun autre mot-clé JOIN (comme INNER , OUTER , LEFT , etc) est un INNER
JOIN . En d'autres termes, JOIN est un sucre syntaxique pour INNER JOIN (voir: différence entre
jointure et la jointure intérieure ).
2. JOINTURE EXTÉRIEURE:
OUTER JOIN récupère
soit, les lignes correspondantes d'un tableau et toutes les lignes de l'autre tableau Ou, toutes les
lignes dans tous les tableaux (peu importe s'il y a une correspondance ou non).
il y a trois types de jointure extérieure:
2.1 jonction extérieure gauche ou jonction gauche
cette jointure renvoie toutes les lignes de la table de gauche en conjonction avec les lignes
correspondantes de la table de droite. S'il n'y a pas de colonnes correspondant dans le tableau de
droite, il renvoie les valeurs NULL .
2.2 droite jointure extérieure ou droite jointure
Ce JOIN renvoie toutes les lignes de la table de droite, en conjonction avec la mise en
correspondance des lignes de la table de gauche. Si il n'y a pas colonnes correspondant dans la
table de gauche, il renvoie les valeurs NULL .
2.3 assemblage complet extérieur ou assemblage complet
ce JOIN combine LEFT OUTER JOIN et RIGHT OUTER JOIN . Il renvoie les lignes de l'une ou l'autre des
tables lorsque les conditions sont remplies et renvoie la valeur NULL lorsqu'il n'y a pas de
correspondance.
en d'autres termes, OUTER JOIN est basé sur le fait que: les tableaux (à droite ou à gauche) ou les
deux(au complet) doivent être énumérés.
Note that `OUTER JOIN` is a loosened form of `INNER JOIN`.
3. JONCTION NATURELLE:
il est basé sur les deux conditions:
1. le JOIN est faite sur toutes les colonnes avec le même nom pour l'égalité.
2. supprime les doubles colonnes du résultat.
cela semble être de nature plus théorique et en conséquence (probablement) la plupart des SGBD
ne même pas la peine.
4. CROSS JOIN:
C'est le produit Cartésien des deux tables impliquées. Le résultat d'un CROSS JOIN n'aura pas de
sens dans la plupart des situations. De plus, nous n'en aurons pas besoin du tout (ou du moins pas
besoin, pour être précis).
5. SELF JOIN:
Ce n'est pas une autre forme de JOIN , c'est plutôt un JOIN ( INNER , OUTER , etc) d'une table à lui-
même.
joint basé sur les opérateurs
selon l'opérateur utilisé pour une clause JOIN , il peut y avoir deux types de JOIN s. Ils sont
1. Equi JOIN
2. Théta-JOINTURE
1. Equi JOIN:
pour tout JOIN type ( INNER , OUTER , etc), si nous utilisons UNIQUEMENT de l'opérateur d'égalité (=),
alors nous disons que le JOIN est un EQUI JOIN .
2. THETA JOIN:
c'est le même que EQUI JOIN mais il permet tous les autres opérateurs comme >, <, >= etc.
beaucoup considèrent à la fois EQUI JOIN et thêta JOIN similaire à INNER , OUTER etc JOIN s. Mais je
crois fermement que c'est une erreur et fait le idée flou. Parce que INNER JOIN , OUTER JOIN etc sont
tous liés à les tableaux et leurs données alors que EQUI JOIN et THETA JOIN ne sont connecté avec
les opérateurs, nous utilisons dans l'ancien.
de nouveau, il y a beaucoup de gens qui considèrent NATURAL JOIN comme une sorte de "particulier
" EQUI JOIN . En fait, il est vrai, à cause de la première condition mentionnée pour NATURAL JOIN .
Cependant, nous n'avons pas à limitez cela à NATURAL JOIN S seulement. INNER JOIN s, OUTER
JOIN s etc pourrait être un EQUI JOIN .
218
répondu M-D 2018-06-09 22:45:46
définition:
JOINTURES façon d'interroger les données combinées de plusieurs tables simultanément.
types de jointures:
Souci de SGBDR il y a 5 types de jointures:
Equi-Join: combine des enregistrements communs de deux tables basées sur la condition
d'égalité. Techniquement, Rejoindre fait en utilisant l'égalité-opérateur (=) pour comparer les
valeurs de clés primaires de la table et Foriegn valeurs de Clé de antoher table, donc résultat
inclut commun(adapté) les enregistrements des deux tables. Pour la mise en œuvre, Voir
INNER-JOIN.
Natural-Join: il est version améliorée D'Equi-Join, dans lequel sélectionner opération omet la
colonne dupliquée. Pour la mise en œuvre, voir INNER-JOIN
Non Équi-Jointure: C'est l'inverse de l'Équi-jointure où joindre à condition usages autres que
l'opérateur égal(=) e.g, !=, <=, >=, >, < ou entre etc. Pour la mise en œuvre, Voir INNER-JOIN.
Self-joining: : un comportement personnalisé de jointure où une table combinée avec lui-
même; ce qui est généralement nécessaire pour interroger les tables de référence auto-(ou
relation unaire) entité.) Pour la mise en œuvre, voir les jointures internes.
produit cartésien: it cross combine tous les enregistrements des deux tables sans aucune
condition. Techniquement, il renvoie l'ensemble des résultats d'une requête sans Clause-
WHERE.
selon la préoccupation et l'avancement SQL, il y a 3 types de jointures et toutes les jointures RDBMS
peuvent être achviées en utilisant ces types de jointures.
1. INNER-JOIN: it merges(or combiens) match rows from two tables. L'appariement est fait sur la
base des colonnes communes des tableaux et de leur opération de comparaison. Si condition
basée sur l'équilité alors: EQUI-JOIN performed, sinon Non-EQUI-Join.
2. **OUTER-JOIN:**il fusionne(ou combine) des lignes appariées à partir de deux tables et des
lignes non appariées avec des valeurs nulles. Cependant, peut sur mesure la sélection de non-
appariés rangées E. g, sélection d'une ligne non appariée à partir de la première table ou de la
deuxième table par sous-types: jointure externe gauche et jointure externe droite.
2.1. jointure extérieure gauche (A. K. a, JOIN-GAUCHE): Renvoie des lignes appariées de
deux tables et non associées à partir de la table de gauche(I. e, premier tableau) seulement.
2.2. Right Outer jointure (A. K. a, droite-JOIN): renvoie des lignes appariées à partir de deux
tables et non appariées à partir de la table droite seulement.
2.3. FULL OUTER JOIN (A. K. une jointure externe): retours appariés et non appariés des deux
tables.
3. de la CROIX-JOIN: Cette jointure ne fusionne/combiens au lieu de cela, il effectue cartisian
produit.
Remarque: L'auto-jointure peut être réalisée par L'intérieur-jointure, L'extérieur-jointure et la Croix-
jointure basée sur les exigences mais la table doit joindre à lui-même.
pour plus d'informations:
exemples:
1.1: INNER-JOIN: Equi-joinmet implementation
SELECT *
FROM Table1 A
INNER JOIN Table2 B ON A.<PrimaryKey> =B.<ForeignKey>;
1.2: INTÉRIEUR-JOIN: Naturel-REJOIGNEZ la mise en œuvre
Select A.*, B.Col1, B.Col2 --But no B.ForiengKyeColumn in Select
FROM Table1 A
INNER JOIN Table2 B On A.Pk = B.Fk;
1.3: Mise en œuvre interne et externe
Select *
FROM Table1 A INNER JOIN Table2 B On A.Pk <= B.Fk;
1.4: jonction interne avec jonction interne
Select *
FROM Table1 A1 INNER JOIN Table1 A2 On A1.Pk = A2.Fk;
2.1: jointure extérieure (complète)
Select *
FROM Table1 A FULL OUTER JOIN Table2 B On A.Pk = B.Fk;
2.2: JOINDRE À GAUCHE
Select *
FROM Table1 A LEFT OUTER JOIN Table2 B On A.Pk = B.Fk;
2.3: DROIT DE JOINDRE
Select *
FROM Table1 A RIGHT OUTER JOIN Table2 B On A.Pk = B.Fk;
3.1: CROSS JOIN
Select *
FROM TableA CROSS JOIN TableB;
3.2: CROSS JOIN-Self JOIN
Select *
FROM Table1 A1 CROSS JOIN Table1 A2;
// " OU " //
Select *
FROM Table1 A1,Table1 A2;
61
répondu nayeemDotNetAuthorities 2016-07-01 06:11:31
fait intéressant, la plupart des autres réponses souffrent de ces deux problèmes:
ils se concentrent sur les formes de base de la jointure seulement
ils (ab)utilisent les diagrammes de Venn, qui sont un outil inexact pour visualiser les jointures
(ils sont beaucoup mieux pour les syndicats) .
j'ai récemment écrit un article sur le sujet: un guide probablement incomplet, complet aux nombreux
différents Façons de joindre les Tables en SQL , que je vais résumer ici.
D'abord et avant tout: les joints sont des produits
cartésiens
c'est pourquoi les diagrammes de Venn les expliquent de façon inexacte, parce qu'une jointure crée
un produit cartésien entre les deux tables jointes. Wikipedia l'illustre bien:
la syntaxe SQL pour les produits cartésiens est CROSS JOIN . Par exemple:
SELECT *
-- This just generates all the days in January 2017
FROM generate_series(
'2017-01-01'::TIMESTAMP,
'2017-01-01'::TIMESTAMP + INTERVAL '1 month -1 day',
INTERVAL '1 day'
) AS days(day)
-- Here, we're combining all days with all departments
CROSS JOIN departments
qui combine toutes les lignes d'un tableau avec toutes les lignes de l'autre tableau:
Source:
+--------+ +------------+
| day | | department |
+--------+ +------------+
| Jan 01 | | Dept 1 |
| Jan 02 | | Dept 2 |
| ... | | Dept 3 |
| Jan 30 | +------------+
| Jan 31 |
+--------+
résultat:
+--------+------------+
| day | department |
+--------+------------+
| Jan 01 | Dept 1 |
| Jan 01 | Dept 2 |
| Jan 01 | Dept 3 |
| Jan 02 | Dept 1 |
| Jan 02 | Dept 2 |
| Jan 02 | Dept 3 |
| ... | ... |
| Jan 31 | Dept 1 |
| Jan 31 | Dept 2 |
| Jan 31 | Dept 3 |
+--------+------------+
si nous écrivons simplement une liste de tables séparées par des virgules, nous obtiendrons la
même chose:
-- CROSS JOINing two tables:
SELECT * FROM table1, table2
joint intérieur (Theta-JOIN)
Un INNER JOIN est juste un CROSS JOIN filtré où le prédicat de filtre est appelé Theta dans l'algèbre
relationnelle.
par exemple:
SELECT *
-- Same as before
FROM generate_series(
'2017-01-01'::TIMESTAMP,
'2017-01-01'::TIMESTAMP + INTERVAL '1 month -1 day',
INTERVAL '1 day'
) AS days(day)
-- Now, exclude all days/departments combinations for
-- days before the department was created
JOIN departments AS d ON day >= d.created_at
notez que le mot-clé INNER est facultatif (sauf dans MS Access).
( regardez l'article pour des exemples de résultats )
EQUI JOIN
un type spécial de thêta-jointure est équi jointure, que nous utilisons le plus. Le le prédicat se joint à
la clé primaire d'une table avec la clé étrangère d'une autre table. Si nous utilisons le base de
données Sakila pour l'illustration, nous pouvons écrire:
SELECT *
FROM actor AS a
JOIN film_actor AS fa ON a.actor_id = fa.actor_id
JOIN film AS f ON f.film_id = fa.film_id
cela combine tous les acteurs avec leurs films.
ou aussi, sur certaines bases de données:
SELECT *
FROM actor
JOIN film_actor USING (actor_id)
JOIN film USING (film_id)
la syntaxe USING() permet de spécifier une colonne qui doit être présente de chaque côté des tables
D'une opération de jointure et crée une égalité basée sur ces deux colonnes.
JOINT NATUREL
D'autres réponses ont énuméré ce "type de jointure" séparément, mais cela n'a pas de sens. C'est
juste une forme de sucre de syntaxe pour la jointure equi, qui est un cas spécial de jointure Theta ou
de jointure interne. NATURAL JOIN recueille simplement toutes les colonnes qui sont communes
aux deux tables étant jointes et joint USING() ces colonnes. Qui n'est presque jamais utile, en raison
de correspondances accidentelles (comme les colonnes LAST_UPDATE dans la base de données
Sakila ).
Voici la syntaxe:
SELECT *
FROM actor
NATURAL JOIN film_actor
NATURAL JOIN film
JOINT EXTÉRIEUR
Maintenant, OUTER JOIN est un peu différent de INNER JOIN car elle crée un UNION de plusieurs
produits cartésiens. Nous pouvons écrire:
-- Convenient syntax:
SELECT *
FROM a LEFT JOIN b ON <predicate>
-- Cumbersome, equivalent syntax:
SELECT a.*, b.*
FROM a JOIN b ON <predicate>
UNION ALL
SELECT a.*, NULL, NULL, ..., NULL
FROM a
WHERE NOT EXISTS (
SELECT * FROM b WHERE <predicate>
)
personne ne veut écrire ce dernier, donc nous écrivons OUTER JOIN (ce qui est généralement mieux
optimisé pour les bases de données).
Comme INNER , le mot-clé OUTER est facultatif, ici.
OUTER JOIN en trois saveurs:
LEFT [ OUTER ] JOIN : le tableau de gauche de l'expression JOIN est ajouté à l'union comme
indiqué ci-dessus.
RIGHT [ OUTER ] JOIN : le tableau de droite de l'expression JOIN est ajouté à l'union comme
indiqué ci-dessus.
FULL [ OUTER ] JOIN : les deux tableaux de l'expression JOIN sont ajoutés à l'union comme
indiqué ci-dessus.
tous ceux-ci peuvent être combinés avec le mot-clé USING() ou avec NATURAL ( j'ai effectivement eu
un vrai monde d'utilisation-cas pour un NATURAL FULL JOIN récemment )
syntaxes alternatives
il y a des syntaxes historiques et dépréciées dans Oracle et SQL Server, qui supportent OUTER
JOIN déjà avant la norme SQL avait une syntaxe pour ceci:
-- Oracle
SELECT *
FROM actor a, film_actor fa, film f
WHERE a.actor_id = fa.actor_id(+)
AND fa.film_id = f.film_id(+)
-- SQL Server
SELECT *
FROM actor a, film_actor fa, film f
WHERE a.actor_id *= fa.actor_id
AND fa.film_id *= f.film_id
cela dit, n'utilisez pas cette syntaxe. Je viens d'énumérer ceci ici afin que vous puissiez le
reconnaître à partir de vieux billets de blog / code d'héritage.
partitionné OUTER JOIN
peu de gens le savent, mais la norme SQL spécifie OUTER JOIN (et Oracle l'implémente). Vous
pouvez écrire des choses comme ceci:
WITH
-- Using CONNECT BY to generate all dates in January
days(day) AS (
SELECT DATE '2017-01-01' + LEVEL - 1
FROM dual
CONNECT BY LEVEL <= 31
),
-- Our departments
departments(department, created_at) AS (
SELECT 'Dept 1', DATE '2017-01-10' FROM dual UNION ALL
SELECT 'Dept 2', DATE '2017-01-11' FROM dual UNION ALL
SELECT 'Dept 3', DATE '2017-01-12' FROM dual UNION ALL
SELECT 'Dept 4', DATE '2017-04-01' FROM dual UNION ALL
SELECT 'Dept 5', DATE '2017-04-02' FROM dual
)
SELECT *
FROM days
LEFT JOIN departments
PARTITION BY (department) -- This is where the magic happens
ON day >= created_at
parties du résultat:
+--------+------------+------------+
| day | department | created_at |
+--------+------------+------------+
| Jan 01 | Dept 1 | | -- Didn't match, but still get row
| Jan 02 | Dept 1 | | -- Didn't match, but still get row
| ... | Dept 1 | | -- Didn't match, but still get row
| Jan 09 | Dept 1 | | -- Didn't match, but still get row
| Jan 10 | Dept 1 | Jan 10 | -- Matches, so get join result
| Jan 11 | Dept 1 | Jan 10 | -- Matches, so get join result
| Jan 12 | Dept 1 | Jan 10 | -- Matches, so get join result
| ... | Dept 1 | Jan 10 | -- Matches, so get join result
| Jan 31 | Dept 1 | Jan 10 | -- Matches, so get join result
le point ici est que toutes les lignes du côté partitionné de la jointure se terminera dans le résultat
indépendamment si le JOIN correspond à quelque chose sur"l'autre côté de la jointure". Pour faire
court: il s'agit de remplir des données éparses dans les rapports. Très utile!
SEMI JOINTURE
sérieusement? Pas d'autre réponse obtenu cela? Bien sûr que non, parce qu'il n'a pas de syntaxe
native en SQL, malheureusement (comme L'anti JOIN ci-dessous). Mais nous pouvons
utiliser IN() et EXISTS() , par exemple pour trouver tous les acteurs qui ont joué dans des films:
SELECT *
FROM actor a
WHERE EXISTS (
SELECT * FROM film_actor fa
WHERE a.actor_id = fa.actor_id
)
le prédicat WHERE a.actor_id = fa.actor_id agit comme prédicat semi-jointif. Si vous n'y croyez
pas, consultez les plans d'exécution, par exemple dans Oracle. Vous verrez que la base de données
exécute une opération de semi-jointure, pas le prédicat EXISTS() .
ANTI JOIN
c'est tout le contraire de SEMI jointure ( attention à ne pas utiliser NOT IN bien que , car il a une mise
en garde importante)
Voici tous les acteurs sans films:
SELECT *
FROM actor a
WHERE NOT EXISTS (
SELECT * FROM film_actor fa
WHERE a.actor_id = fa.actor_id
)
certaines personnes (surtout MySQL) écrivent aussi anti JOIN comme ceci:
SELECT *
FROM actor a
LEFT JOIN film_actor fa
USING (actor_id)
WHERE film_id IS NULL
je pense que le la raison historique est la performance.
JOINT LATÉRAL
OMG, celui-ci est trop cool. Je suis le seul à le mentionner? Voici une requête cool:
SELECT a.first_name, a.last_name, f.*
FROM actor AS a
LEFT OUTER JOIN LATERAL (
SELECT f.title, SUM(amount) AS revenue
FROM film AS f
JOIN film_actor AS fa USING (film_id)
JOIN inventory AS i USING (film_id)
JOIN rental AS r USING (inventory_id)
JOIN payment AS p USING (rental_id)
WHERE fa.actor_id = a.actor_id -- JOIN predicate with the outer query!
GROUP BY f.film_id
ORDER BY revenue DESC
LIMIT 5
) AS f
ON true
il trouvera les 5 meilleurs films de production de revenus par acteur. Chaque fois que vous avez
besoin D'une requête TOP-N-per-something, LATERAL JOIN sera votre ami. Si vous êtes un serveur
SQL personne, alors vous savez ce JOIN tapez sous le nom APPLY
SELECT a.first_name, a.last_name, f.*
FROM actor AS a
OUTER APPLY (
SELECT f.title, SUM(amount) AS revenue
FROM film AS f
JOIN film_actor AS fa ON f.film_id = fa.film_id
JOIN inventory AS i ON f.film_id = i.film_id
JOIN rental AS r ON i.inventory_id = r.inventory_id
JOIN payment AS p ON r.rental_id = p.rental_id
WHERE fa.actor_id = a.actor_id -- JOIN predicate with the outer query!
GROUP BY f.film_id
ORDER BY revenue DESC
LIMIT 5
) AS f
OK, peut-être que c'est de la triche, parce qu'une expression LATERAL JOIN ou APPLY est vraiment
une "sous-query corrélée" qui produit plusieurs rangées. Mais si nous permettons de "sous-requêtes
corrélées", on peut parler aussi...
MULTISET
ce n'est vraiment implémenté que par Oracle et Informix (à ma connaissance), mais il peut être
émulé dans PostgreSQL en utilisant des tableaux et/ou XML et dans SQL Server en utilisant XML.
MULTISET produit une sous-requête corrélée et niche l'ensemble résultant de lignes dans la requête
externe. La requête ci-dessous sélectionne tous les acteurs et pour chaque acteur recueille leurs
films dans une collection emboîtée:
SELECT a.*, MULTISET (
SELECT f.*
FROM film AS f
JOIN film_actor AS fa USING (film_id)
WHERE a.actor_id = fa.actor_id
) AS films
FROM actor
comme vous l'avez vu, il y a plus de types de jointure que juste le" boring " INNER , OUTER , et CROSS
JOIN qui sont généralement mentionnés. plus de détails dans mon article . Et s'il vous plaît, arrêtez
D'utiliser Venn des diagrammes pour illustrer.
33
répondu Lukas Eder 2017-04-21 17:08:07
dans SQL server, il existe différents types de jointures.
1. CROSS JOIN
2. INNER JOIN
3. JOINT EXTÉRIEUR
les joints extérieurs sont de nouveau divisés en 3 types
1. joindre à gauche ou joindre à gauche
2. jointure droite ou externe droite
3. Full Join or Full Outer Join
jonction ou jonction intérieure
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
INNER JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
OR
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
joindre à gauche ou joindre à gauche
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
LEFT OUTER JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
OR
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
LEFT JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
droit de joindre ou droit extérieur de joindre
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
RIGHT OUTER JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
OR
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
RIGHT JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
full JOIN ou FULL OUTER JOIN
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
FULL OUTER JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
OR
SELECT Name, Gender, Salary, DepartmentName
FROM tblEmployee
FULL JOIN tblDepartment
ON tblEmployee.DepartmentId = tblDepartment.Id
21
répondu Rae Lee 2015-10-28 19:13:45
j'ai créé une illustration qui explique mieux que des mots, à mon avis:
répondu Gisway 2018-03-07 19:27:30
je vais pousser ma peeve de compagnie: le mot-clé D'utilisation.
si les deux tables des deux côtés de la jointure ont leurs clés étrangères correctement nommées
(c'est-à-dire, même nom, pas seulement "id), alors cela peut être utilisé:
SELECT ...
FROM customers JOIN orders USING (customer_id)
