une illustration de W3schools :

---

---

---

---

---

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;

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.

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

j'ai créé une illustration qui explique mieux que des mots, à mon avis:

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)

je trouve cela très pratique, lisible, et pas assez utilisé.