PostgreSQL JOIN
La clause JOIN de PostgreSQL est utilisée pour combiner des lignes de deux ou plusieurs tables, en fonction des champs communs entre ces tables.
Dans PostgreSQL, il existe cinq types de JOIN :
- CROSS JOIN : jointure croisée
- INNER JOIN : jointure interne
- LEFT OUTER JOIN : jointure externe gauche
- RIGHT OUTER JOIN : jointure externe droite
- FULL OUTER JOIN : jointure externe complète
Ensuite, créons deux tablesCOMPANYetDEPARTMENT。
Exemple
Créez la table COMPANY (Téléchargez le fichier SQL COMPANY), le contenu des données est le suivant :
exampledb# select * from COMPANY; id | name | age | address | salary ----+-------+-----+-----------+-------- 1 | Paul | 32 | California| 20000 2 | Allen | 25 | Texas | 15000 3 | Teddy | 23 | Norway | 20000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall| 45000 7 | James | 24 | Houston | 10000 (7 rows)
Ajoutons quelques enregistrements dans la table :
INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00); INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00); INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00);
À ce stade, les enregistrements dans la table COMPANY sont les suivants :
id | name | age | address | salary ----+-------+-----+--------------+-------- 1 | Paul | 32 | California | 20000 2 | Allen | 25 | Texas | 15000 3 | Teddy | 23 | Norway | 20000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall | 45000 7 | James | 24 | Houston | 10000 8 | Paul | 24 | Houston | 20000 9 | James | 44 | Norway | 5000 10 | James | 45 | Texas | 5000 (10 rows)
Créez une table DEPARTMENT avec trois champs :
CREATE TABLE DEPARTMENT( ID INT PRIMARY KEY NOT NULL, DEPT CHAR(50) NOT NULL, EMP_ID INT NOT NULL );
Insérez trois enregistrements dans la table DEPARTMENT :
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (1, 'IT Billing', 1 ); INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (2, 'Engineering', 2 ); INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (3, 'Finance', 7 );
À ce stade, les enregistrements de la table DEPARTMENT sont les suivants :
id | dept | emp_id ----+-------------+-------- 1 | IT Billing | 1 2 | Engineering | 2 3 | Finance | 7
Jointure croisée
CROSS JOIN associe chaque ligne de la première table à chaque ligne de la seconde table. Si les deux tables d'entrée ont respectivement x et y lignes, la table de résultat comporte x*y lignes.
Comme CROSS JOIN peut produire des tables très volumineuses, vous devez être prudent lors de son utilisation et ne l'utiliser que lorsque c'est approprié.
Voici la syntaxe de base de CROSS JOIN :
SELECT ... FROM table1 CROSS JOIN table2 ...
D'après les tables ci-dessus, nous pouvons écrire un CROSS JOIN comme suit :
exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;
Le résultat obtenu est le suivant :
exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;
emp_id | name | dept
--------+-------+--------------------
1 | Paul | IT Billing
1 | Allen | IT Billing
1 | Teddy | IT Billing
1 | Mark | IT Billing
1 | David | IT Billing
1 | Kim | IT Billing
1 | James | IT Billing
1 | Paul | IT Billing
1 | James | IT Billing
1 | James | IT Billing
2 | Paul | Engineering
2 | Allen | Engineering
2 | Teddy | Engineering
2 | Mark | Engineering
2 | David | Engineering
2 | Kim | Engineering
2 | James | Engineering
2 | Paul | Engineering
2 | James | Engineering
2 | James | Engineering
7 | Paul | Finance
Jointure interne
INNER JOIN crée une nouvelle table de résultat en combinant les valeurs de colonnes de deux tables (table1 et table2) sur la base du prédicat de jointure. La requête compare chaque ligne de table1 avec chaque ligne de table2 pour trouver toutes les paires de lignes qui satisfont le prédicat de jointure.
Lorsque le prédicat de jointure est satisfait, les valeurs de colonnes de chaque paire de lignes correspondantes A et B sont fusionnées en une seule ligne de résultat.
INNER JOIN est le type de jointure le plus courant et est le type de jointure par défaut.
Le mot-clé INNER est facultatif.
Voici la syntaxe de INNER JOIN :
SELECT table1.column1, table2.column2... FROM table1 INNER JOIN table2 ON table1.common_filed = table2.common_field;
D'après les tables ci-dessus, nous pouvons écrire une jointure interne comme suit :
exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
emp_id | name | dept
--------+-------+--------------
1 | Paul | IT Billing
2 | Allen | Engineering
7 | James | Finance
(3 rows)
Jointure externe gauche
Les jointures externes sont une extension des jointures internes. La norme SQL définit trois types de jointures externes : LEFT, RIGHT et FULL. PostgreSQL les prend toutes en charge.
Pour une jointure externe gauche, une jointure interne est d'abord effectuée. Ensuite, pour chaque ligne de la table T1 qui ne satisfait pas la condition de jointure avec la table T2, une ligne jointe avec des valeurs nulles dans les colonnes de T2 est également ajoutée. Par conséquent, la table jointe a au moins une ligne pour chaque ligne de T1.
Voici la syntaxe de base de LEFT OUTER JOIN :
SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...
D'après les deux tables ci-dessus, nous pouvons écrire une jointure externe gauche comme suit :
exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
emp_id | name | dept
--------+-------+----------------
1 | Paul | IT Billing
2 | Allen | Engineering
7 | James | Finance
| James |
| David |
| Paul |
| Kim |
| Mark |
| Teddy |
| James |
(10 rows)
Jointure externe droite
D'abord, une jointure interne est effectuée. Ensuite, pour chaque ligne de la table T2 qui ne satisfait pas la condition de jointure avec la table T1, une ligne jointe avec des valeurs nulles dans les colonnes de T1 est également ajoutée. C'est l'opposé de la jointure gauche ; pour chaque ligne de T2, la table de résultat contient toujours une ligne.
Voici la syntaxe de base de la jointure externe droite (RIGHT OUT JOIN) :
SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...
À partir des deux tables ci-dessus, nous créons une jointure externe droite :
exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY RIGHT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
emp_id | name | dept
--------+-------+-----------------
1 | Paul | IT Billing
2 | Allen | Engineering
7 | James | Finance
(3 rows)
Jointure externe complète
Tout d'abord, une jointure interne est effectuée. Ensuite, pour chaque ligne de la table T1 qui ne satisfait pas la condition de jointure avec une ligne quelconque de la table T2, une ligne avec des valeurs nulles dans les colonnes de T2 est également ajoutée au résultat. De plus, pour chaque ligne de T2 qui ne satisfait pas la condition de jointure avec une ligne quelconque de T1, une ligne avec des valeurs nulles dans les colonnes de T1 est ajoutée au résultat.
Voici la syntaxe de base de la jointure externe complète :
SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...
À partir des deux tables ci-dessus, nous pouvons créer une jointure externe complète :
exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY FULL OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
emp_id | name | dept
--------+-------+-----------------
1 | Paul | IT Billing
2 | Allen | Engineering
7 | James | Finance
| James |
| David |
| Paul |
| Kim |
| Mark |
| Teddy |
| James |
(10 rows)
Autres extensions