HSQLDB - Joins

Wenn Daten mit einer einzigen Abfrage aus mehreren Tabellen abgerufen werden müssen, können Sie JOINS aus RDBMS verwenden. Sie können mehrere Tabellen in Ihrer einzelnen SQL-Abfrage verwenden. Der Vorgang des Beitritts zu HSQLDB bezieht sich auf das Zerschlagen von zwei oder mehr Tabellen in einer einzigen Tabelle.

Betrachten Sie die folgenden Kunden- und Auftragstabellen.

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  |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun versuchen, die Daten der Kunden und den Bestellbetrag abzurufen, den der jeweilige Kunde aufgegeben hat. Dies bedeutet, dass wir die Datensatzdaten sowohl aus der Kunden- als auch aus der Auftragstabelle abrufen. Wir können dies erreichen, indem wir das JOINS-Konzept in HSQLDB verwenden. Es folgt die JOIN-Abfrage für dasselbe.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

JOIN-Typen

In HSQLDB stehen verschiedene Arten von Joins zur Verfügung.

INNER JOIN - Gibt die Zeilen zurück, wenn in beiden Tabellen eine Übereinstimmung vorliegt.
LEFT JOIN - Gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Tabelle keine Übereinstimmungen enthält.
RIGHT JOIN - Gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält.
FULL JOIN - Gibt die Zeilen zurück, wenn in einer der Tabellen eine Übereinstimmung vorliegt.
SELF JOIN - Wird verwendet, um eine Tabelle mit sich selbst zu verbinden, als wäre die Tabelle zwei Tabellen, wobei mindestens eine Tabelle in der SQL-Anweisung vorübergehend umbenannt wird.

Inner Join

Die am häufigsten verwendete und wichtigste Verknüpfung ist die INNER JOIN. Es wird auch als EQUIJOIN bezeichnet.

Der INNER JOIN erstellt eine neue Ergebnistabelle, indem die Spaltenwerte zweier Tabellen (Tabelle1 und Tabelle2) basierend auf dem Join-Prädikat kombiniert werden. Die Abfrage vergleicht jede Zeile von Tabelle1 mit jeder Zeile von Tabelle2, um alle Zeilenpaare zu finden, die das Join-Prädikat erfüllen. Wenn das Join-Prädikat erfüllt ist, werden die Spaltenwerte für jedes übereinstimmende Zeilenpaar A und B zu einer Ergebniszeile zusammengefasst.

Syntax

Die grundlegende Syntax von INNER JOIN lautet wie folgt.

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

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

+----+----------+-----+-----------+----------+
| 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   |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen mit der INNER JOIN-Abfrage wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

+----+----------+--------+---------------------+
| 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 |
+----+----------+--------+---------------------+

Links beitreten

Der HSQLDB LEFT JOIN gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Tabelle keine Übereinstimmungen enthält. Dies bedeutet, dass wenn die ON-Klausel mit 0 (Null) Datensätzen in der rechten Tabelle übereinstimmt, der Join weiterhin eine Zeile im Ergebnis zurückgibt, jedoch mit NULL in jeder Spalte aus der rechten Tabelle.

Dies bedeutet, dass ein linker Join alle Werte aus der linken Tabelle sowie übereinstimmende Werte aus der rechten Tabelle oder NULL zurückgibt, falls kein übereinstimmendes Join-Prädikat vorliegt.

Syntax

Die grundlegende Syntax von LEFT JOIN lautet wie folgt:

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

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

+----+----------+-----+-----------+----------+
| 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   |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen mit der Abfrage LEFT JOIN wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

+----+----------+--------+---------------------+
| 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         |
+----+----------+--------+---------------------+

Right Join

Der HSQLDB RIGHT JOIN gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält. Dies bedeutet, dass, wenn die ON-Klausel mit 0 (Null) Datensätzen in der linken Tabelle übereinstimmt, der Join weiterhin eine Zeile im Ergebnis zurückgibt, jedoch mit NULL in jeder Spalte aus der linken Tabelle.

Dies bedeutet, dass ein rechter Join alle Werte aus der rechten Tabelle sowie übereinstimmende Werte aus der linken Tabelle oder NULL zurückgibt, falls kein übereinstimmendes Join-Prädikat vorliegt.

Syntax

Die grundlegende Syntax von RIGHT JOIN ist wie folgt -

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

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

+----+----------+-----+-----------+----------+
| 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  |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen mit der Abfrage RIGHT JOIN wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie das folgende Ergebnis.

+------+----------+--------+---------------------+
|  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 |
+------+----------+--------+---------------------+

Vollständige Teilnahme

Der HSQLDB FULL JOIN kombiniert die Ergebnisse der linken und rechten äußeren Verknüpfungen.

Die verknüpfte Tabelle enthält alle Datensätze aus beiden Tabellen und gibt NULL für die fehlenden Übereinstimmungen auf beiden Seiten ein.

Syntax

Die grundlegende Syntax von FULL JOIN lautet wie folgt:

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

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

+----+----------+-----+-----------+----------+
| 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   |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen mit der FULL JOIN-Abfrage wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie das folgende Ergebnis.

+------+----------+--------+---------------------+
|  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 |
+------+----------+--------+---------------------+

Selbst beitreten

Der SQL SELF JOIN wird verwendet, um eine Tabelle mit sich selbst zu verbinden, als wäre die Tabelle zwei Tabellen, wobei mindestens eine Tabelle in der SQL-Anweisung vorübergehend umbenannt wird.

Syntax

Die grundlegende Syntax von SELF JOIN lautet wie folgt:

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

Hier kann die WHERE-Klausel ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+

Lassen Sie uns nun diese Tabelle mit der SELF JOIN-Abfrage wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

+----+----------+---------+
| 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 |
+----+----------+---------+