HSQLDB - Si unisce
Ogni volta che è necessario recuperare i dati da più tabelle utilizzando una singola query, è possibile utilizzare JOINS da RDBMS. È possibile utilizzare più tabelle nella singola query SQL. L'atto di unirsi in HSQLDB si riferisce a frantumare due o più tabelle in una singola tabella.
Considera le seguenti tabelle di clienti e ordini.
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 |
+-----+---------------------+-------------+--------+
Ora, proviamo a recuperare i dati dei clienti e l'importo dell'ordine che il rispettivo cliente ha effettuato. Ciò significa che stiamo recuperando i dati dei record sia dalla tabella dei clienti che da quella degli ordini. Possiamo ottenere ciò utilizzando il concetto JOINS in HSQLDB. Di seguito è la query JOIN per lo stesso.
SELECT ID, NAME, AGE, AMOUNT FROM CUSTOMERS, ORDERS WHERE CUSTOMERS.ID =
ORDERS.CUSTOMER_ID;
Dopo l'esecuzione della query precedente, riceverai il seguente output.
+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+
Tipi di JOIN
Sono disponibili diversi tipi di join in HSQLDB.
INNER JOIN - Restituisce le righe quando c'è una corrispondenza in entrambe le tabelle.
LEFT JOIN - Restituisce tutte le righe della tabella di sinistra, anche se non ci sono corrispondenze nella tabella di destra.
RIGHT JOIN - Restituisce tutte le righe della tabella di destra, anche se non ci sono corrispondenze nella tabella di sinistra.
FULL JOIN - Restituisce le righe quando c'è una corrispondenza in una delle tabelle.
SELF JOIN - Utilizzato per unire una tabella a se stessa come se la tabella fosse due tabelle, rinominando temporaneamente almeno una tabella nell'istruzione SQL.
Inner Join
Il join più utilizzato e importante è l'INNER JOIN. Viene anche definito EQUIJOIN.
INNER JOIN crea una nuova tabella dei risultati combinando i valori di colonna di due tabelle (table1 e table2) in base al predicato di join. La query confronta ogni riga di table1 con ogni riga di table2 per trovare tutte le coppie di righe che soddisfano il predicato di join. Quando il predicato di join è soddisfatto, i valori di colonna per ciascuna coppia di righe A e B abbinate vengono combinati in una riga di risultati.
Sintassi
La sintassi di base di INNER JOIN è la seguente.
SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_field = table2.common_field;
Esempio
Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:
+----+----------+-----+-----------+----------+
| 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 |
+-----+---------------------+-------------+--------+
Ora, uniamo queste due tabelle usando la query INNER JOIN come segue:
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
Dopo l'esecuzione della query precedente, riceverai il seguente output.
+----+----------+--------+---------------------+
| 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 |
+----+----------+--------+---------------------+
Unisciti a sinistra
HSQLDB LEFT JOIN restituisce tutte le righe dalla tabella di sinistra, anche se non ci sono corrispondenze nella tabella di destra. Ciò significa che se la clausola ON corrisponde a 0 (zero) record nella tabella di destra, il join restituirà comunque una riga nel risultato, ma con NULL in ogni colonna della tabella di destra.
Ciò significa che un join sinistro restituisce tutti i valori dalla tabella di sinistra, più i valori corrispondenti dalla tabella di destra o NULL in caso di nessun predicato di join corrispondente.
Sintassi
La sintassi di base di LEFT JOIN è la seguente:
SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.common_field = table2.common_field;
Qui la condizione data potrebbe essere qualsiasi espressione data in base alle tue esigenze.
Esempio
Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:
+----+----------+-----+-----------+----------+
| 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 |
+-----+---------------------+-------------+--------+
Ora, uniamo queste due tabelle utilizzando la query LEFT JOIN come segue:
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
Dopo l'esecuzione della query precedente, riceverai il seguente output:
+----+----------+--------+---------------------+
| 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
HSQLDB RIGHT JOIN restituisce tutte le righe della tabella di destra, anche se non ci sono corrispondenze nella tabella di sinistra. Ciò significa che se la clausola ON corrisponde a 0 (zero) record nella tabella di sinistra, il join restituirà comunque una riga nel risultato, ma con NULL in ogni colonna della tabella di sinistra.
Ciò significa che un join destro restituisce tutti i valori dalla tabella destra, più i valori corrispondenti dalla tabella sinistra o NULL in caso di nessun predicato di join corrispondente.
Sintassi
La sintassi di base di RIGHT JOIN è il seguente -
SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.common_field = table2.common_field;
Esempio
Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:
+----+----------+-----+-----------+----------+
| 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 |
+-----+---------------------+-------------+--------+
Ora, uniamo queste due tabelle usando la query RIGHT JOIN come segue:
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
Dopo l'esecuzione della query precedente, riceverai il seguente risultato.
+------+----------+--------+---------------------+
| 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 |
+------+----------+--------+---------------------+
Full Join
HSQLDB FULL JOIN combina i risultati dei join esterni sinistro e destro.
La tabella unita conterrà tutti i record di entrambe le tabelle e inserirà NULL per le corrispondenze mancanti su entrambi i lati.
Sintassi
La sintassi di base di FULL JOIN è la seguente:
SELECT table1.column1, table2.column2...
FROM table1
FULL JOIN table2
ON table1.common_field = table2.common_field;
Qui la condizione data potrebbe essere qualsiasi espressione data in base alle tue esigenze.
Esempio
Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:
+----+----------+-----+-----------+----------+
| 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 |
+-----+---------------------+-------------+--------+
Ora, uniamo queste due tabelle usando la query FULL JOIN come segue:
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
Dopo l'esecuzione della query precedente, riceverai il seguente risultato.
+------+----------+--------+---------------------+
| 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 |
+------+----------+--------+---------------------+
Self Join
L'SQL SELF JOIN viene utilizzato per unire una tabella a se stessa come se la tabella fosse due tabelle, rinominando temporaneamente almeno una tabella nell'istruzione SQL.
Sintassi
La sintassi di base di SELF JOIN è la seguente:
SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_field = b.common_field;
In questo caso, la clausola WHERE potrebbe essere una qualsiasi espressione in base alle tue esigenze.
Esempio
Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
Ora, uniamoci a questa tabella utilizzando la query SELF JOIN come segue:
SELECT a.ID, b.NAME, a.SALARY FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY > b.SALARY;
Dopo l'esecuzione della query precedente, riceverai il seguente output:
+----+----------+---------+
| 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 |
+----+----------+---------+