HSQLDB - Jointures

Chaque fois qu'il est nécessaire de récupérer des données de plusieurs tables à l'aide d'une seule requête, vous pouvez utiliser JOINS à partir du SGBDR. Vous pouvez utiliser plusieurs tables dans votre seule requête SQL. L'acte de se joindre dans HSQLDB fait référence à l'écrasement de deux ou plusieurs tables en une seule table.

Considérez les tableaux Clients et Commandes suivants.

Customer:
+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad |  2000.00 |
| 2  |  Khilan  | 25  |   Delhi   |  1500.00 |
| 3  |  kaushik | 23  |   Kota    |  2000.00 |
| 4  | Chaitali | 25  |   Mumbai  |  6500.00 |
| 5  |  Hardik  | 27  |   Bhopal  |  8500.00 |
| 6  |  Komal   | 22  |    MP     |  4500.00 |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+
Orders:
+-----+---------------------+-------------+--------+
|OID  |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Maintenant, essayons de récupérer les données des clients et le montant de la commande que le client respectif a passé. Cela signifie que nous récupérons les données d'enregistrement de la table des clients et des commandes. Nous pouvons y parvenir en utilisant le concept JOINS dans HSQLDB. Voici la requête JOIN pour le même.

SELECT ID, NAME, AGE, AMOUNT FROM CUSTOMERS, ORDERS WHERE CUSTOMERS.ID =
ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+----+----------+-----+--------+
| ID |   NAME   | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |  3000  |
|  3 | kaushik  |  23 |  1500  |
|  2 | Khilan   |  25 |  1560  |
|  4 | Chaitali |  25 |  2060  |
+----+----------+-----+--------+

JOIN Types

Il existe différents types de jointures disponibles dans HSQLDB.

INNER JOIN - Renvoie les lignes lorsqu'il y a une correspondance dans les deux tables.
LEFT JOIN - Renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite.
RIGHT JOIN - Renvoie toutes les lignes de la table de droite, même s'il n'y a aucune correspondance dans la table de gauche.
FULL JOIN - Renvoie les lignes lorsqu'il y a une correspondance dans l'une des tables.
SELF JOIN - Utilisé pour joindre une table à elle-même comme si la table était deux tables, renommant temporairement au moins une table dans l'instruction SQL.

Jointure interne

La jointure la plus fréquemment utilisée et la plus importante est INNER JOIN. Il est également appelé EQUIJOIN.

INNER JOIN crée une nouvelle table de résultats en combinant les valeurs de colonne de deux tables (table1 et table2) en fonction 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 colonne pour chaque paire correspondante de lignes A et B sont combinées dans une ligne de résultat.

Syntaxe

La syntaxe de base de INNER JOIN est la suivante.

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_field = table2.common_field;

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  | SALARY   |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad | 2000.00  |
| 2  |  Khilan  | 25  |   Delhi   | 1500.00  |
| 3  |  kaushik | 23  |   Kota    | 2000.00  |
| 4  | Chaitali | 25  |   Mumbai  | 6500.00  |
| 5  |  Hardik  | 27  |   Bhopal  | 8500.00  |
| 6  |  Komal   | 22  |     MP    | 4500.00  |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      | 3000   |
| 100 | 2009-10-08 00:00:00 |      3      | 1500   |
| 101 | 2009-11-20 00:00:00 |      2      | 1560   |
| 103 | 2008-05-20 00:00:00 |      4      | 2060   |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête INNER JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
| 3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
| 3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
| 2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
| 4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+

Joint gauche

HSQLDB LEFT JOIN renvoie toutes les lignes de la table de gauche, même s'il n'y a aucune correspondance dans la table de droite. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de droite, la jointure renverra toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de droite.

Cela signifie qu'une jointure gauche renvoie toutes les valeurs de la table de gauche, plus les valeurs correspondantes de la table de droite ou NULL en cas d'absence de prédicat de jointure correspondant.

Syntaxe

La syntaxe de base de LEFT JOIN est la suivante -

SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.common_field = table2.common_field;

Ici, la condition donnée peut être n'importe quelle expression donnée basée sur vos besoins.

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  | SALARY   |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad | 2000.00  |
| 2  |  Khilan  | 25  |   Delhi   | 1500.00  |
| 3  |  kaushik | 23  |   Kota    | 2000.00  |
| 4  | Chaitali | 25  |   Mumbai  | 6500.00  |
| 5  |  Hardik  | 27  |   Bhopal  | 8500.00  |
| 6  |  Komal   | 22  |    MP     | 4500.00  |
| 7  |  Muffy   | 24  |  Indore   | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |        DATE         | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |     3       | 3000   |
| 100 | 2009-10-08 00:00:00 |     3       | 1500   |
| 101 | 2009-11-20 00:00:00 |     2       | 1560   |
| 103 | 2008-05-20 00:00:00 |     4       | 2060   |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête LEFT JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
|  1 |  Ramesh  |  NULL  |        NULL         |
|  2 |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  3 |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3 |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  4 | Chaitali |  2060  | 2008-05-20 00:00:00 |
|  5 |  Hardik  |  NULL  |        NULL         |
|  6 |  Komal   |  NULL  |        NULL         |
|  7 |  Muffy   |  NULL  |        NULL         |
+----+----------+--------+---------------------+

Jointure droite

HSQLDB RIGHT JOIN renvoie toutes les lignes de la table de droite, même s'il n'y a aucune correspondance dans la table de gauche. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de gauche, la jointure renverra toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de gauche.

Cela signifie qu'une jointure droite renvoie toutes les valeurs de la table de droite, plus les valeurs correspondantes de la table de gauche ou NULL en cas d'absence de prédicat de jointure correspondant.

Syntaxe

La syntaxe de base de RIGHT JOIN est comme suit -

SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.common_field = table2.common_field;

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad |  2000.00 |
| 2  |  Khilan  | 25  |   Delhi   |  1500.00 |
| 3  |  kaushik | 23  |   Kota    |  2000.00 |
| 4  | Chaitali | 25  |   Mumbai  |  6500.00 |
| 5  |  Hardik  | 27  |   Bhopal  |  8500.00 |
| 6  |  Komal   | 22  |     MP    |  4500.00 |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |       DATE          | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables à l'aide de la requête RIGHT JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez le résultat suivant.

+------+----------+--------+---------------------+
|  ID  |   NAME   | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|  3   |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3   |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  2   |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  4   | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Joindre complet

Le HSQLDB FULL JOIN combine les résultats des jointures externes gauche et droite.

La table jointe contiendra tous les enregistrements des deux tables et remplira les valeurs NULL pour les correspondances manquantes de chaque côté.

Syntaxe

La syntaxe de base de FULL JOIN est la suivante -

SELECT table1.column1, table2.column2...
FROM table1
FULL JOIN table2
ON table1.common_field = table2.common_field;

Ici, la condition donnée peut être n'importe quelle expression donnée basée sur vos besoins.

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  | 32  | Ahmedabad | 2000.00  |
|  2 |  Khilan  | 25  |   Delhi   | 1500.00  |
|  3 |  kaushik | 23  |   Kota    | 2000.00  |
|  4 | Chaitali | 25  |   Mumbai  | 6500.00  |
|  5 |  Hardik  | 27  |   Bhopal  | 8500.00  |
|  6 |  Komal   | 22  |   MP      | 4500.00  |
|  7 |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |    3        | 3000   |
| 100 | 2009-10-08 00:00:00 |    3        | 1500   |
| 101 | 2009-11-20 00:00:00 |    2        | 1560   |
| 103 | 2008-05-20 00:00:00 |    4        | 2060   |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête FULL JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez le résultat suivant.

+------+----------+--------+---------------------+
|  ID  |    NAME  | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|   1  |  Ramesh  |  NULL  |        NULL         |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
|   5  |  Hardik  |  NULL  |        NULL         |
|   6  |   Komal  |  NULL  |        NULL         |
|   7  |   Muffy  |  NULL  |        NULL         |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Auto-rejoindre

Le SQL SELF JOIN est utilisé pour joindre une table à elle-même comme si la table était deux tables, renommant temporairement au moins une table dans l'instruction SQL.

Syntaxe

La syntaxe de base de SELF JOIN est la suivante -

SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_field = b.common_field;

Ici, la clause WHERE peut être une expression donnée en fonction de vos besoins.

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |    NAME  | AGE |   ADDRESS |   SALARY |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  |  32 | Ahmedabad | 2000.00  |
|  2 |  Khilan  |  25 |   Delhi   | 1500.00  |
|  3 |  kaushik |  23 |   Kota    | 2000.00  |
|  4 | Chaitali |  25 |   Mumbai  | 6500.00  |
|  5 |  Hardik  |  27 |   Bhopal  | 8500.00  |
|  6 |  Komal   |  22 |   MP      | 4500.00  |
|  7 |  Muffy   |  24 |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

Maintenant, joignons cette table en utilisant la requête SELF JOIN comme suit -

SELECT a.ID, b.NAME, a.SALARY FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY > b.SALARY;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

+----+----------+---------+
| ID |   NAME   | SALARY  |
+----+----------+---------+
| 2  |  Ramesh  | 1500.00 |
| 2  |  kaushik | 1500.00 |
| 1  | Chaitali | 2000.00 |
| 2  | Chaitali | 1500.00 |
| 3  | Chaitali | 2000.00 |
| 6  | Chaitali | 4500.00 |
| 1  |  Hardik  | 2000.00 |
| 2  |  Hardik  | 1500.00 |
| 3  |  Hardik  | 2000.00 |
| 4  |  Hardik  | 6500.00 |
| 6  |  Hardik  | 4500.00 |
| 1  |  Komal   | 2000.00 |
| 2  |  Komal   | 1500.00 |
| 3  |  Komal   | 2000.00 |
| 1  |  Muffy   | 2000.00 |
| 2  |  Muffy   | 1500.00 |
| 3  |  Muffy   | 2000.00 |
| 4  |  Muffy   | 6500.00 |
| 5  |  Muffy   | 8500.00 |
| 6  |  Muffy   | 4500.00 |
+----+----------+---------+

↰ Previous page Next page ↱

HSQLDB - Jointures

JOIN Types

Jointure interne

Syntaxe

Exemple

Joint gauche

Syntaxe

Exemple

Jointure droite

Syntaxe

Exemple

Joindre complet

Syntaxe

Exemple

Auto-rejoindre

Syntaxe

Exemple

Tutoriel HSQLDB

Ressources utiles HSQLDB