Quando usare LEFT JOIN e quando usare INNER JOIN?

Question

Mi sembra che mi sia sempre stato insegnato a utilizzare LEFT JOIN s e spesso li vedo mescolati con INNER s per eseguire lo stesso tipo di query su diversi pezzi di codice che dovrebbero fare la stessa cosa su pagine diverse. Qui va:

SELECT ac.reac, pt.pt_name, soc.soc_name, pt.pt_soc_code 
FROM 
    AECounts ac 
    INNER JOIN 1_low_level_term llt on ac.reac = llt.llt_name 
    LEFT JOIN 1_pref_term pt ON llt.pt_code = pt.pt_code 
    LEFT JOIN 1_soc_term soc ON pt.pt_soc_code = soc.soc_code 
LIMIT 100,10000 

Quello è uno sto lavorando su:

vedo un po 'come:

SELECT COUNT(DISTINCT p.`case`) as count 
FROM FDA_CaseReports cr 
    INNER JOIN ae_indi i ON i.isr = cr.isr 
    LEFT JOIN ae_case_profile p ON cr.isr = p.isr 

Questo mi sembra la sinistra può anche essere INNER c'è qualche trucco?

Answer 1

C'è qualche cattura? Sì, i join di sinistra sono una forma di join esterno, mentre i join interni sono una forma di, well, inner join.

Ecco alcuni esempi che mostrano la differenza. Inizieremo con i dati di base:

mysql> select * from j1; 
+----+------------+ 
| id | thing  | 
+----+------------+ 
| 1 | hi   | 
| 2 | hello  | 
| 3 | guten tag | 
| 4 | ciao  | 
| 5 | buongiorno | 
+----+------------+ 

mysql> select * from j2; 
+----+-----------+ 
| id | thing  | 
+----+-----------+ 
| 1 | bye  | 
| 3 | tschau | 
| 4 | au revoir | 
| 6 | so long | 
| 7 | tschuessi | 
+----+-----------+ 

E qui vedremo la differenza tra un inner join e un LEFT JOIN:

mysql> select * from j1 inner join j2 on j1.id = j2.id; 
+----+-----------+----+-----------+ 
| id | thing  | id | thing  | 
+----+-----------+----+-----------+ 
| 1 | hi  | 1 | bye  | 
| 3 | guten tag | 3 | tschau | 
| 4 | ciao  | 4 | au revoir | 
+----+-----------+----+-----------+ 

Hmm, 3 file.

mysql> select * from j1 left join j2 on j1.id = j2.id; 
+----+------------+------+-----------+ 
| id | thing  | id | thing  | 
+----+------------+------+-----------+ 
| 1 | hi   | 1 | bye  | 
| 2 | hello  | NULL | NULL  | 
| 3 | guten tag | 3 | tschau | 
| 4 | ciao  | 4 | au revoir | 
| 5 | buongiorno | NULL | NULL  | 
+----+------------+------+-----------+ 

Wow, 5 righe! Quello che è successo?

Join esterni come left join preservano le righe che non corrispondono, quindi le righe con ID 2 e 5 vengono mantenute dalla query di join sinistra. Le colonne rimanenti sono riempite con NULL.

In altre parole, le giunzioni a sinistra e interne non sono intercambiabili.

Answer 2

Un join interno restituirà solo le righe dove ci sono valori corrispondenza di entrambe le tabelle, mentre un LEFT JOIN restituirà tutte le righe della tabella LEFT anche se non c'è nessuna riga corrispondente nella tabella di destra

A rapido esempio

TableA 
ID Value 
1 TableA.Value1 
2 TableA.Value2 
3 TableA.Value3 

TableB 
ID Value 
2 TableB.ValueB 
3 TableB.ValueC 

inner join produce:

SELECT a.ID,a.Value,b.ID,b.Value 
FROM TableA a INNER JOIN TableB b ON b.ID = a.ID 

a.ID a.Value   b.ID b.Value 
2  TableA.Value2  2  TableB.ValueB 
3  TableA.Value3  3  TableB.ValueC 

A LEFT JOIN produce:

SELECT a.ID,a.Value,b.ID,b.Value 
FROM TableA a LEFT JOIN TableB b ON b.ID = a.ID 

a.ID a.Value   b.ID b.Value 
1  TableA.Value1  NULL NULL 
2  TableA.Value2  2  TableB.ValueB 
3  TableA.Value3  3  TableB.ValueC 

Come si può vedere, il LEFT JOIN include la riga dalla TableA dove ID = 1, anche se non c'è nessuna riga corrispondente nella TabellaB dove ID = 1, mentre l'INNER JOIN esclude la riga proprio perché non c'è riga corrispondente in TabellaB

HTH

Answer 3

Ecco una risposta approssimativa, è una specie di come penso ai join. Sperando che questo sarà più utile di una risposta molto precisa a causa dei problemi di matematica di cui sopra ... ;-)

I join interni restringono il set di ritorni di righe. I join esterni (a sinistra oa destra) non cambiano il numero di righe restituite, ma solo "prelevano" colonne aggiuntive se possibile.

Nel tuo primo esempio, il risultato saranno righe da AECounts corrispondenti alle condizioni specificate nella tabella 1_low_level_term. Quindi per quelle file, lo tenta di di unirsi a 1_pref_term e 1_soc_term. Ma se non c'è corrispondenza, le righe rimangono e le colonne unite sono nulle.

Answer 4

Utilizzare un join interno quando si desidera che solo i risultati visualizzati in entrambe le tabelle corrispondano alla condizione Join.

Utilizzare un join sinistro quando si desidera ottenere tutti i risultati dalla tabella A, ma se la tabella B contiene dati rilevanti per alcuni record della tabella A, si desidera utilizzare tali dati nella stessa query.

Utilizzare un join completo quando si desidera ottenere tutti i risultati da entrambe le tabelle.