Tradizionalmente, estrai i dati da due o più tabelle usando un WHERE clausola in una query. Ma in un sistema di database relazionale (RDBMS), questo può essere ottenuto usando un singolo SELECT interrogazione. Questo è il vero potere dei sistemi di database relazionali. In questa guida imparerai a conoscere i join SQL, un modo efficace per confrontare e selezionare righe e tabelle.
Cos'è un join SQL?
In SQL, un join La clausola estende la capacità di confrontare e selezionare righe dalle tabelle. Utilizza un processo algebrico di combinazione di righe di due o più tabelle in base a una colonna correlata in tali tabelle. Secondo la definizione SQL standard ANSI, esistono cinque tipi di join:Cross Join , Collegamenti interni , Unisci a sinistra (esterno) , Unisci a destra (esterno) e Join (esterni) completi . Questi join sono implementati in tutti i sistemi di database relazionali e sono trattati nelle sezioni seguenti.
Nota I join possono essere eseguiti su qualsiasi numero di tabelle in una determinata query. Per brevità e chiarezza, questa guida discute i join applicati a due tabelle.
Questa guida utilizza due tabelle, Employees e Address , rispettivamente, per dimostrare i join SQL. Ognuna di queste tabelle contiene le seguenti definizioni e dati di colonna:
-
Tabella dei dipendenti
EmployeeId EmployeeName 1 Giovanni 2 Maria 3 Robert -
Tabella degli indirizzi
Id Stato 1 New York 2 New Jersey 3 Idaho 4 Hawaii
Nota Salvo diversa indicazione, tutti i comandi in questa guida funzionano bene sia su MySQL e PostgreSQL database.
SQL Cross Joins
Conosciuto anche come Unisci cartesiani , I cross join si verificano quando specifichi più tabelle come origine per il tuo SELECT elenco di colonne. In questo caso, ometti il WHERE espressione di unione della clausola per la corrispondenza delle righe. Il set di risultati contiene una riga per ogni combinazione di righe tra le tabelle. In uno scenario a due tabelle, ogni riga di una tabella è associata a ogni riga dell'altra tabella. Il prodotto risultante è noto come Prodotto cartesiano delle due tabelle. La sintassi per un Cross Join è la seguente:
(# Rows in Table A) TIMES (# of Rows in Table B)
NotaNella teoria degli insiemi, il prodotto cartesiano è un'operazione di moltiplicazione che genera tutte le coppie ordinate degli insiemi dati. Ad esempio, considera l'insieme
Acon elementi{a,b}e impostaBcon elementi{1,2,3}. Il prodotto cartesiano diAeBè indicato daAxBe il risultato è il seguente:AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}
La sintassi SQL per un Cross Join è la seguente:
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM [Table_1]
CROSS JOIN [Table_2]
Dalla sintassi sopra, Column_1 , Column_2 , Column_N rappresentano le colonne in una tabella e il CROSS JOIN La clausola serve a combinare le due tabelle, Table_1 e Table_2 . Dalle tabelle di esempio sopra, se devi eseguire un Cross Join su Employees e Address tabelle, utilizzare il seguente codice SQL:
SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address
L'output del codice SQL precedente è simile al seguente:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| John | New Jersey |
| John | Idaho |
| John | Hawaii |
| John | New York |
| Mary | New York |
| Mary | New Jersey |
| Mary | Idaho |
| Mary | Hawaii |
| Robert | New York |
| Robert | New Jersey |
| Robert | Idaho |
| Robert | Hawaii |
+------------+----------------+SQL Inner Join
Un join interno restituisce righe che hanno valori corrispondenti in entrambe le tabelle. Se non ci sono record corrispondenti, nei risultati non vengono restituite righe.
La sintassi SQL per Inner Join è la seguente:
SELECT ColumnName_1,
ColumnName_2,
ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;
Nell'esempio sopra, key è la rispettiva chiave delle tabelle. Se devi eseguire un inner join su Employees e Address tabelle, utilizzare il seguente codice SQL:
SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id
L'output del codice SQL precedente è simile al seguente:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
+------------+----------------+Partecipa a SQL Left (esterno)
Un join sinistro restituisce un set completo di righe dalla tabella di sinistra insieme alle righe corrispondenti dalla tabella di destra. Se non ci sono record corrispondenti, allora NULL i valori vengono restituiti dalla tabella di destra.
Nota Alcune implementazioni di database relazionali utilizzano le parole chiave "Left Outer Join", invece di "Left Join", ma sono funzionalmente equivalenti.
La sintassi SQL per Left Join è la seguente:
SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key
Nell'esempio sopra, key è la rispettiva chiave delle tabelle. Se devi eseguire un join sinistro su Employees e Address tabelle, utilizzare il seguente codice SQL:
SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id
L'output del codice SQL precedente è il seguente:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
+------------+----------------+Partecipa a SQL Right (esterno)
Un join destro restituisce un insieme completo di righe dalla tabella di destra e le righe corrispondenti dalla tabella di sinistra. Questo è anche noto come Right Outer Join. Se non ci sono record corrispondenti, allora NULL i valori vengono restituiti dalla tabella di destra, per le righe interessate nella tabella di sinistra.
Nota Alcune implementazioni di database relazionali utilizzano le parole chiave "Right Outer Join", invece di "Right Join", ma sono funzionalmente equivalenti.
La sintassi SQL per un join destro è la seguente:
SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key
Dal codice sopra, key è la rispettiva chiave delle tabelle. Se è necessario eseguire un diritto di unione su Employees e Address tabelle, utilizzare il seguente codice SQL:
SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id
L'output del codice SQL precedente è il seguente:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+Partecipa a SQL completo (esterno)
Un join completo restituisce tutte le righe della tabella di sinistra, tutte le righe della tabella di destra. Questo è anche noto come Full Outer Join. Un Full Join restituisce anche tutti i record corrispondenti da entrambe le tabelle, ove disponibili. Se non ci sono record corrispondenti, allora NULL i valori vengono restituiti dalla tabella di sinistra. Restituisce anche NULL valori dalla tabella di destra.
Nota Alcune implementazioni di database relazionali utilizzano le parole chiave "Full Outer Join", invece di "Full Join", ma sono funzionalmente equivalenti.
La sintassi SQL per Full Join è la seguente:
SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key
Nel codice sopra, key è la rispettiva chiave delle tabelle. Se devi eseguire un join completo su Employees e Address tabelle, utilizzare il seguente codice SQL:
SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id
L'output del codice SQL precedente è il seguente:
+--------------+--------------+
| EmployeeName | State |
+---------------+-------------+
| John | New York |
| Mary | New Jersey |
| Robert | NULL |
| NULL | Idaho |
| NULL | Hawaii |
+------------+----------------+Nota Durante i calcoli Join, se confronti i dati della tabella conNULLvalori, non corrispondono tra loro. Quindi,NULLi valori vengono restituiti solo come parte dei risultati di unione e vengono ignorati durante i calcoli di unione.
Confronto delle prestazioni dei join SQL
Considerando le tabelle di esempio precedenti, l'Inner Join è in genere la più veloce delle cinque clausole Join in termini di prestazioni del database. Il Left Join e il Right Join sono i successivi più veloci a seconda delle dimensioni delle due tabelle. Il Full Join è in genere più lento del Left Join o del Right Join. Il Cross Join, che si basa sul prodotto cartesiano delle due tabelle, è in genere il più lento in termini di prestazioni del database. La gerarchia delle prestazioni specificata può variare a seconda della lunghezza della colonna della tabella, del tipo di dati della colonna e delle definizioni delle chiavi.
Conclusione
L'uso di SQL Join estende la funzionalità di poter confrontare le righe della tabella, rispetto al tradizionale WHERE interrogazioni sulle clausole. I join sono un meccanismo prezioso per applicare la logica algebrica a due o più tabelle.
