English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
La clausola JOIN di PostgreSQL viene utilizzata per combinare le righe provenienti da due o più tabelle, basandosi sui campi comuni tra queste tabelle.
In PostgreSQL ci sono cinque tipi di connessioni JOIN:
CROSS JOIN: connessione crociata
INNER JOIN: connessione interna
LEFT OUTER JOIN: connessione esterna sinistra
RIGHT OUTER JOIN: connessione esterna destra
FULL OUTER JOIN: connessione esterna completa
Creiamo ora due tabelle COMPANY e DEPARTMENT。
Crea la tabella COMPANY (Scarica il file SQL di COMPANY ），i dati contenuti sono i seguenti：
w3codeboxdb# 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)
Aggiungiamo alcuni dati alla tabella:
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);
Al momento, i record della tabella COMPANY sono i seguenti:
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 righe)
Crea una tabella DEPARTMENT e aggiungi tre campi:
CREATE TABLE DEPARTMENT( ID INT PRIMARY KEY NOT NULL DEPT CHAR(50) NOT NULL, EMP_ID INT NOT NULL );
Inserisci tre record nella tabella 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);
Al momento, i record della tabella DEPARTMENT sono i seguenti:
id | dept | emp_id ----+-------------+-------- 1 | IT Billing | 1 2 | Engineering | 2 3 | Finance | 7
Il CROSS JOIN (connessione crociata) abbinisce ogni riga della prima tabella con ogni riga della seconda tabella. Se le tabelle di input hanno rispettivamente x e y righe, la tabella di risultato avrà x*y righe.
Poiché il CROSS JOIN (connessione crociata) può generare tabelle molto grandi, deve essere utilizzato con cautela e solo quando necessario.
Ecco la sintassi di base per il CROSS JOIN:
SELECT ... FROM table1 CROSS JOIN table2 ...
Sulla base della tabella sopra menzionata, possiamo scrivere una connessione crociata (CROSS JOIN), come segue:
w3codeboxdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;
Ecco i risultati ottenuti:
w3codeboxdb=# 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
La connessione interna (INNER JOIN) combina i valori delle colonne di due tabelle (table1 e table2) per creare una nuova tabella di risultato. La query confronta ogni riga di table1 con ogni riga di table2 per trovare tutte le coppie di righe che soddisfano il predicato di connessione.
Quando si soddisfa il predicato di connessione, i valori delle colonne di ogni coppia di righe corrispondenti tra A e B vengono combinati in una riga di risultato.
La connessione interna (INNER JOIN) è il tipo di connessione più comune e il tipo di connessione predefinito.
La parola chiave INNER è opzionale.
Di seguito è riportata la sintassi della connessione interna (INNER JOIN):
SELECT table1.column1, table2.column2... FROM table1 INNER JOIN table2 ON table1.common_filed = table2.common_field;
Sulla base del tavolo sopra menzionato, possiamo scrivere una connessione interna, come segue:
w3codeboxdb=# 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 righe)
La connessione esterna è un'estensione della connessione interna. Lo standard SQL definisce tre tipi di connessioni esterne: LEFT, RIGHT e FULL, PostgreSQL supporta tutte queste.
Per la connessione esterna destra, viene eseguita prima una connessione interna. Poi, per ogni riga non soddisfacente la condizione di connessione nella tabella T2, viene aggiunta una riga di connessione, dove i valori delle colonne nella T2 sono null. Pertanto, ogni riga nella T1 avrà almeno una riga nella connessione.
Di seguito è riportata la sintassi di base della connessione esterna destra (LEFT OUTER JOIN):
SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...
Sulla base dei due tavoli sopra menzionati, possiamo scrivere una connessione esterna destra, come segue:
w3codeboxdb=# 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 righe)
Prima, eseguiamo il join interno. Poi, per ogni riga di T2 che non soddisfa la condizione di connessione con T1, se ci sono valori nulli nella colonna di T1, aggiungiamo una riga di connessione. Questo è il contrario del join a sinistra; per ogni riga di T2, la tabella di risultato avrà sempre una riga.
Di seguito è la sintassi di base per il join esterno a destra (RIGHT OUT JOIN):
SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...
Sulla base delle due tabelle precedenti, creiamo un join esterno a destra:
w3codeboxdb=# 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 righe)
Prima, eseguiamo il join interno. Poi, per ogni riga di T1 che non soddisfa alcuna condizione di connessione con T2, se ci sono valori nulli nella colonna di T2, aggiungiamo anche una riga al risultato. Inoltre, per ogni riga di T2 che non soddisfa alcuna condizione di connessione con T1, aggiungiamo una riga al risultato con valori nulli nella colonna di T1.
Di seguito è la sintassi di base per il join esterno:
SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...
Sulla base di due tabelle, possiamo creare un join esterno:
w3codeboxdb=# 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 righe)