sql - outer - wikipedia inner join




Qual è la differenza tra "INNER JOIN" e "OUTER JOIN"? (20)

Qual è la differenza tra "INNER JOIN" e "OUTER JOIN"?

Sono gli operatori esistenziali più comunemente utilizzati in SQL, dove INNER JOINviene utilizzato per "esiste" e LEFT OUTER JOINviene utilizzato per "non esiste".

Considera queste domande:

users who have posted and have votes
users who have posted but have no badges

Le persone che cercano soluzioni basate su set (un termine del settore) riconoscono le rispettive query come:

users who have posted INTERSECT users who have votes
users who have posted MINUS users who have badges

Traducendo questi in SQL standard:

SELECT UserId FROM Posts
INTERSECT 
SELECT UserId FROM Votes;

SELECT UserId FROM Posts
EXCEPT 
SELECT UserId FROM Badges;

Altri penseranno lungo linee simili di inclusione dell'insieme:

users who have posted and IN the set of users who have votes
users who have posted and NOT IN the set of users who have badges

Traducendo questi in SQL standard:

SELECT UserId 
  FROM Posts
 WHERE UserId IN ( SELECT UserId FROM Votes );

SELECT UserId 
  FROM Posts
 WHERE UserId NOT IN ( SELECT UserId FROM Badges );

Alcuni penseranno in termini di "esistenza" all'interno di insiemi, ad es

users who have posted and EXIST in the set of users who have votes
users who have posted and do NOT EXIST in the set of users who have badges

Traducendo questi in SQL standard (nota ora abbiamo bisogno di usare le variabili gamma cioè p, v, b):

SELECT p.UserId 
  FROM Posts p
 WHERE EXISTS ( SELECT *
                  FROM Votes v
                 WHERE v.UserId = p.UserId );

SELECT p.UserId 
  FROM Posts p
 WHERE NOT EXISTS ( SELECT *
                      FROM Badges b
                     WHERE b.UserId = p.UserId );

Tuttavia, ho trovato che l'approccio "standard di settore" è quello di utilizzare esclusivamente join. Non so quale sia il pensiero qui ( Legge dello strumento ? Ottimizzazione prematura ?), Quindi andrò direttamente alla sintassi:

SELECT p.UserId 
  FROM Posts p
       INNER JOIN Votes v ON v.UserId = p.UserId;

SELECT p.UserId 
  FROM Posts p
       LEFT JOIN Badges b ON b.UserId = p.UserId
 WHERE b.UserId IS NULL;

Cose da notare:

  • L'unica proiezione è da Usersma abbiamo ancora bisogno di tutte quelle variabili raggio ( p, v, b) per le condizioni di ricerca.
  • La UserId IS NULLcondizione di ricerca 'appartiene' al the OUTER JOINma è disconnessa nella query.
  • LEFTè lo standard del settore: i professionisti riscrivono una query per evitare l'utilizzo RIGHT!
  • La OUTERparola chiave da LEFT OUTER JOINè omessa.

Commenti finali:

Talvolta i join vengono utilizzati nelle query esclusivamente per determinare se i valori esistono o non esistono in un altro set. Impara a guardare attentamente gli attributi proiettati (le colonne nella SELECTclausola): se non ci sono nessuno della tabella unita, vengono semplicemente usati come operatori esistenziali. Inoltre per l'outer join, cerca le istanze <key_column> IS NULLnella WHEREclausola.

In che modo si inseriscono LEFT JOIN , RIGHT JOIN e FULL JOIN ?


Join interno

Recupera solo le righe corrispondenti, ovvero A intersect B

SELECT *
FROM dbo.Students S
INNER JOIN dbo.Advisors A
    ON S.Advisor_ID = A.Advisor_ID

Left Outer Join

Seleziona tutti i record dalla prima tabella e tutti i record nella seconda tabella che corrispondono alle chiavi unite.

SELECT *
FROM dbo.Students S
LEFT JOIN dbo.Advisors A
    ON S.Advisor_ID = A.Advisor_ID

Full Outer Join

Seleziona tutti i record dalla seconda tabella e tutti i record nella prima tabella che corrispondono alle chiavi unite.

SELECT *
FROM dbo.Students S
FULL JOIN dbo.Advisors A
    ON S.Advisor_ID = A.Advisor_ID

Riferimenti


I join interni richiedono che un record con un ID correlato esista nella tabella unita.

I join esterni restituiranno i record per il lato sinistro anche se non esiste nulla per il lato destro.

Ad esempio, hai una tabella Orders e OrderDetails. Sono collegati da un "OrderID".

Ordini

  • ID ordine
  • Nome del cliente

OrderDetails

  • OrderDetailID
  • ID ordine
  • Nome del prodotto
  • Quantità
  • Prezzo

La richiesta

SELECT Orders.OrderID, Orders.CustomerName
  FROM Orders 
 INNER JOIN OrderDetails
    ON Orders.OrderID = OrderDetails.OrderID

restituirà solo Ordini che hanno anche qualcosa nella tabella OrderDetails.

Se lo si cambia in OUTER LEFT JOIN

SELECT Orders.OrderID, Orders.CustomerName
  FROM Orders 
  LEFT JOIN OrderDetails
    ON Orders.OrderID = OrderDetails.OrderID

quindi restituirà i record dalla tabella Ordini anche se non hanno record OrderDetails.

Puoi usare questo per trovare Ordini che non hanno OrderDetails che indicano un possibile ordine orfano aggiungendo una clausola WHERE OrderDetails.OrderID IS NULL .


In parole semplici:

Un join interno recupera solo le righe corrispondenti.

Mentre un join esterno recupera le righe corrispondenti da una tabella e tutte le righe in un'altra tabella .... il risultato dipende da quale si sta utilizzando:

  • A sinistra : righe corrispondenti nella tabella di destra e tutte le righe nella tabella di sinistra

  • A destra : righe corrispondenti nella tabella di sinistra e tutte le righe nella tabella di destra o

  • Completo : tutte le righe in tutte le tabelle. Non importa se c'è una partita o no



Quanto segue è stato tratto dall'articolo " MySQL - LEFT JOIN e RIGHT JOIN, INNER JOIN e OUTER JOIN " di Graham Ellis sul suo blog Horse's Mouth.

In un database come MySQL, i dati vengono divisi in un numero di tabelle che vengono quindi connesse (unite) insieme da JOIN nei comandi SELECT per leggere i record da più tabelle. Leggi questo esempio per vedere come funziona.

Innanzitutto, alcuni dati di esempio:

people
    mysql> select * from people;
    +------------+--------------+------+
    | name       | phone        | pid  |
    +------------+--------------+------+
    | Mr Brown   | 01225 708225 |    1 |
    | Miss Smith | 01225 899360 |    2 |
    | Mr Pullen  | 01380 724040 |    3 |
    +------------+--------------+------+
    3 rows in set (0.00 sec)

property
    mysql> select * from property;
    +------+------+----------------------+
    | pid  | spid | selling              |
    +------+------+----------------------+
    |    1 |    1 | Old House Farm       |
    |    3 |    2 | The Willows          |
    |    3 |    3 | Tall Trees           |
    |    3 |    4 | The Melksham Florist |
    |    4 |    5 | Dun Roamin           |
    +------+------+----------------------+
    5 rows in set (0.00 sec)

REGOLARE ISCRIVITI

Se eseguiamo un JOIN regolare (con nessuna delle parole chiave INNER, OUTER, LEFT o RIGHT), otteniamo tutti i record che corrispondono in modo appropriato nelle due tabelle e i record in entrambe le tabelle in entrata che non corrispondono non vengono segnalati :

mysql> select name, phone, selling 
from people join property 
on people.pid = property.pid;
+-----------+--------------+----------------------+
| name      | phone        | selling              |
+-----------+--------------+----------------------+
| Mr Brown  | 01225 708225 | Old House Farm       |
| Mr Pullen | 01380 724040 | The Willows          |
| Mr Pullen | 01380 724040 | Tall Trees           |
| Mr Pullen | 01380 724040 | The Melksham Florist |
+-----------+--------------+----------------------+
4 rows in set (0.01 sec)

SINISTRA

Se facciamo un SINISTRA SINISTRO, otteniamo tutti i record che corrispondono allo stesso modo e IN AGGIUNTA otteniamo un record extra per ogni record non abbinato nella tabella sinistra del join - assicurando così (in questo esempio) che ogni PERSON riceve una menzione :

   mysql> select name, phone, selling 
    from people left join property 
    on people.pid = property.pid; 
    +------------+--------------+----------------------+
    | name       | phone        | selling              |
    +------------+--------------+----------------------+
    | Mr Brown   | 01225 708225 | Old House Farm       |
    | Miss Smith | 01225 899360 | NULL <<-- unmatch    |
    | Mr Pullen  | 01380 724040 | The Willows          |
    | Mr Pullen  | 01380 724040 | Tall Trees           |
    | Mr Pullen  | 01380 724040 | The Melksham Florist |
    +------------+--------------+----------------------+
    5 rows in set (0.00 sec)

GIUSTO PARTITO

Se facciamo un GIUSTO PARTITO, otteniamo tutti i record che corrispondono e IN AGGIUNTA un record extra per ogni record ineguagliato nella tabella di destra del join - nel mio esempio, questo significa che ogni proprietà riceve una menzione anche se non lo facciamo avere i dettagli del venditore:

mysql> select name, phone, selling 
from people right join property 
on people.pid = property.pid;
+-----------+--------------+----------------------+
| name      | phone        | selling              |
+-----------+--------------+----------------------+
| Mr Brown  | 01225 708225 | Old House Farm       |
| Mr Pullen | 01380 724040 | The Willows          |
| Mr Pullen | 01380 724040 | Tall Trees           |
| Mr Pullen | 01380 724040 | The Melksham Florist |
| NULL      | NULL         | Dun Roamin           |
+-----------+--------------+----------------------+
5 rows in set (0.00 sec)

Un INNER JOIN esegue un join completo, proprio come il primo esempio, e la parola OUTER può essere aggiunta dopo la parola LEFT o RIGHT negli ultimi due esempi: è prevista per la compatibilità ODBC e non aggiunge funzionalità extra.


Supponendo che ti unisci a colonne senza duplicati, che è un caso molto comune:

  • Un'unione interna di A e B dà il risultato di Un'intersezione B, cioè la parte interna di un'intersezione di diagramma di Venn .

  • Un'unione esterna di A e B dà i risultati di un'unione B, cioè le parti esterne di un'unione di diagrammi di Venn.

Esempi

Supponiamo di avere due tabelle, ognuna con una singola colonna e dati come segue:

A    B
-    -
1    3
2    4
3    5
4    6

Nota che (1,2) sono unici per A, (3,4) sono comuni e (5,6) sono unici per B.

Join interno

Un join interno che utilizza una delle query equivalenti fornisce l'intersezione delle due tabelle, ovvero le due righe che hanno in comune.

select * from a INNER JOIN b on a.a = b.b;
select a.*, b.*  from a,b where a.a = b.b;

a | b
--+--
3 | 3
4 | 4

Giuntura esterna sinistra

Un join esterno sinistro fornirà tutte le righe in A, più eventuali righe comuni in B.

select * from a LEFT OUTER JOIN b on a.a = b.b;
select a.*, b.*  from a,b where a.a = b.b(+);

a |  b
--+-----
1 | null
2 | null
3 |    3
4 |    4

Giuntura esterna destra

Un join esterno destro darà tutte le righe in B, più tutte le righe comuni in A.

select * from a RIGHT OUTER JOIN b on a.a = b.b;
select a.*, b.*  from a,b where a.a(+) = b.b;

a    |  b
-----+----
3    |  3
4    |  4
null |  5
null |  6

Full outer join

Un join esterno completo ti darà l'unione di A e B, cioè tutte le righe in A e tutte le righe in B. Se qualcosa in A non ha un dato corrispondente in B, allora la parte B è nullo, e viceversa versa.

select * from a FULL OUTER JOIN b on a.a = b.b;

 a   |  b
-----+-----
   1 | null
   2 | null
   3 |    3
   4 |    4
null |    6
null |    5

Un join interno mostra solo le righe se c'è un record corrispondente sull'altro lato (a destra) del join.

Un join esterno (a sinistra) mostra le righe per ogni record sul lato sinistro, anche se non vi sono righe corrispondenti sull'altro lato (a destra) del join. Se non c'è una riga corrispondente, le colonne per l'altro lato (a destra) mostrerebbero NULL.



INNER JOINrichiede che ci sia almeno una corrispondenza nel confronto tra le due tabelle. Ad esempio, la tabella A e la tabella B che implica A 8 B (A intersezione B).

LEFT OUTER JOINe LEFT JOINsono la stessa cosa Fornisce tutti i record corrispondenti in entrambe le tabelle e tutte le possibilità della tabella sinistra.

Allo stesso modo, RIGHT OUTER JOINe RIGHT JOINsono la stessa cosa. Fornisce tutti i record corrispondenti in entrambe le tabelle e tutte le possibilità del tavolo giusto.

FULL JOINè la combinazione di LEFT OUTER JOINe RIGHT OUTER JOINsenza duplicazione.


I join vengono utilizzati per combinare i dati di due tabelle, con il risultato di essere una nuova tabella temporanea. I join vengono eseguiti in base a qualcosa chiamato predicato, che specifica la condizione da utilizzare per eseguire un join. La differenza tra un join interno e un join esterno è che un join interno restituirà solo le righe effettivamente corrispondenti in base al predicato di join. Consideriamo la tabella Employee e Location:

Inner Join: - Inner join crea una nuova tabella dei risultati combinando i valori delle colonne di due tabelle ( Employee e Location ) in base al predicato join. La query confronta ogni riga di Dipendente con ciascuna riga di Ubicazione per trovare tutte le coppie di righe che soddisfano il predicato di join. Quando il predicato di join viene soddisfatto dall'accoppiamento di valori non NULL, i valori di colonna per ciascuna coppia di righe corrispondenti di Employee e Location vengono combinati in una riga di risultati. Ecco come apparirà l'SQL per un join interno:

select  * from employee inner join location on employee.empID = location.empID
OR
select  * from employee, location where employee.empID = location.empID

Ora, ecco come apparirà il risultato dell'esecuzione di tale SQL:

Outer Join: - Un outer join non richiede che ogni record nelle due tabelle unite abbia un record corrispondente. La tabella unita conserva ogni record, anche se non esiste nessun altro record corrispondente. I join esterni si suddividono ulteriormente in join esterni a sinistra e giunti esterni a destra, a seconda delle righe di tabella che vengono mantenute (a sinistra oa destra).

Left Outer Join: - Il risultato di un join esterno sinistro (o semplicemente left join) per le tabelle Employee e Location contiene sempre tutti i record della tabella "left" ( Employee ), anche se la condizione di join non trova alcun record corrispondente in la tabella "giusta" ( posizione ). Ecco come apparirebbe l'SQL per un join esterno sinistro, usando le tabelle sopra:

select  * from employee left outer join location on employee.empID = location.empID;
//Use of outer keyword is optional

Ora, ecco come apparirà il risultato dell'esecuzione di questo SQL:

Giuntura esterna destra: - Un'unione esterna destra (o giunzione destra) assomiglia molto ad un'unione esterna sinistra, tranne che per il trattamento dei tavoli invertiti. Ogni riga della tabella "giusta" ( Posizione ) verrà visualizzata nella tabella unita almeno una volta. Se non esiste alcuna riga corrispondente dalla tabella "left" ( Employee ), NULL verrà visualizzato nelle colonne da Employee per quei record che non hanno corrispondenza in Location . Questo è ciò che sembra l'SQL:

select * from employee right outer join location  on employee.empID = location.empID;
//Use of outer keyword is optional

Usando le tabelle sopra, possiamo mostrare come sarebbe il set di risultati di un join esterno destro:

Full Outer Joins: - Full Outer Join o Full Join è per conservare le informazioni non corrispondenti includendo righe non corrispondenti ai risultati di un join, utilizzare un join esterno completo. Include tutte le righe di entrambe le tabelle, indipendentemente dal fatto che l'altra tabella abbia o meno un valore corrispondente.

Fonte dell'immagine

MySQL 8.0 Manuale di riferimento - Partecipa alla sintassi

Operazioni di Oracle Join


INNER JOIN

Un join interno produce un set di risultati limitato alle righe in cui vi è una corrispondenza in entrambe le tabelle per quello che stiamo cercando. Se non conosci il tipo di iscrizione di cui hai bisogno, questo di solito è la soluzione migliore.

SINISTRA ESTERNO

Un join esterno sinistro o join sinistro, produce un set in cui vengono conservate tutte le righe dalla prima o dalla sinistra. Le righe della seconda o della tabella di destra si mostrano solo se hanno una corrispondenza con le righe della prima tabella. Dove ci sono valori dalla tabella di sinistra ma non da destra, la tabella leggerà null, il che significa che il valore non è stato impostato.

GIUSTO ESTERNO

Un join esterno destro o join destro è uguale a un join sinistro, ad eccezione dei ruoli invertiti. Tutte le righe della tabella di destra vengono visualizzate nel risultato, ma le righe della tabella a sinistra sono presenti solo se corrispondono alla tabella a destra. Gli spazi vuoti sono nulli, proprio come con il join sinistro.

FULL OUTER JOIN

Un join esterno completo o solo join esterno produce un set di risultati con tutte le righe di entrambe le tabelle, indipendentemente dal fatto che vi siano corrispondenze. Analogamente ai join sinistro e destro, chiamiamo gli spazi vuoti null.

Per ulteriori Reference


Join interno Un join interno si concentra sulla comunanza tra due tabelle. Quando si utilizza un join interno, devono essere presenti almeno alcuni dati corrispondenti tra due (o più) tabelle confrontate. Un join interno cerca le tabelle per i dati corrispondenti o sovrapposti. Dopo averlo trovato, il join interno combina e restituisce le informazioni in una nuova tabella.

Outer Join Un outer join restituisce un set di record (o righe) che include ciò che un join interno restituisce ma include anche altre righe per le quali non viene trovata alcuna corrispondenza corrispondente nell'altra tabella.

Esistono tre tipi di join esterni:

Join esterno sinistro (o Join sinistro) Join esterno destro (o Join destro) Join esterno completo (o Join completo) Ciascuno di questi join esterni fa riferimento alla parte dei dati che viene confrontata, combinata e restituita. A volte in questo processo verranno prodotti valori null poiché alcuni dati vengono condivisi mentre altri dati non lo sono.


Avendo criticato il tanto amato diagramma di Venn dalle sfumature rosse, ho pensato che fosse giusto pubblicare il mio tentativo.

Sebbene la risposta di @Martin Smith sia la migliore di questo gruppo da molto tempo, la sua unica mostra la colonna chiave di ogni tabella, mentre penso che idealmente dovrebbero essere mostrate anche le colonne non chiave.

Il meglio che potevo fare nella mezz'ora permessa, continuo a non pensare che dimostri adeguatamente che i valori nulli ci sono dovuti all'assenza di valori chiave TableBo che OUTER JOINè in realtà un sindacato piuttosto che un join:


La differenza è nel modo in cui le tabelle vengono unite se non ci sono record comuni.

JOINè uguale a INNER JOINe indica solo i record comuni a entrambe le tabelle. Se i record sono comuni è determinato dai campi nella clausola join.

Per esempio:

SELECT * 
FROM t1
JOIN t2 on t1.ID = t2.ID

Significa mostrare solo i record in cui IDesiste lo stesso valore in entrambe le tabelle.

LEFT JOINè uguale a LEFT OUTER JOINe indica la visualizzazione di tutti i record dalla tabella sinistra (ovvero quella che precede nell'istruzione SQL) indipendentemente dall'esistenza di record corrispondenti nella tabella di destra.

RIGHT JOINè uguale a RIGHT OUTER JOINe significa opposto a LEFT JOIN, cioè mostra tutti i record dalla seconda tabella (a destra) e solo i record corrispondenti dalla prima tabella (a sinistra).


La differenza è nel modo in cui le tabelle vengono unite se non ci sono record comuni.

  • JOINè uguale a INNER JOINe indica solo i record comuni a entrambe le tabelle. Se i record sono comuni è determinato dai campi nella clausola join. Per esempio:

    FROM t1
    JOIN t2 on t1.ID = t2.ID
    

    indica solo i record in cui IDesiste lo stesso valore in entrambe le tabelle.

  • LEFT JOINè uguale a LEFT OUTER JOINe indica la visualizzazione di tutti i record dalla tabella sinistra (ovvero quella che precede nell'istruzione SQL) indipendentemente dall'esistenza dei record corrispondenti nella tabella di destra.

  • RIGHT JOINè uguale a RIGHT OUTER JOINe significa opposto a LEFT JOIN, cioè mostra tutti i record dalla seconda tabella (a destra) e solo i record corrispondenti dalla prima tabella (a sinistra).

Fonte: qual è la differenza tra SINISTRA, DESTRA, INTERIORE, ESTERNO, UNISCITI?


La risposta è nel significato di ciascuno, quindi nei risultati.

Nota:
in SQLitenon c'è RIGHT OUTER JOINo o FULL OUTER JOIN.
E anche dentro MySQLnon c'è FULL OUTER JOIN.

La mia risposta è basata sulla nota di cui sopra .

Quando hai due tabelle come queste:

--[table1]               --[table2]
id | name                id | name
---+-------              ---+-------
1  | a1                  1  | a2
2  | b1                  3  | b2

CROSS JOIN / OUTER JOIN:
puoi avere tutti questi dati di tabelle con CROSS JOINo semplicemente con ,questo tipo:

SELECT * FROM table1, table2
--[OR]
SELECT * FROM table1 CROSS JOIN table2

--[Results:]
id | name | id | name 
---+------+----+------
1  | a1   | 1  | a2
1  | a1   | 3  | b2
2  | b1   | 1  | a2
2  | b1   | 3  | b2

INNER JOIN:
quando vuoi aggiungere un filtro ai risultati sopra basati su una relazione come table1.id = table2.idpuoi usare INNER JOIN:

SELECT * FROM table1, table2 WHERE table1.id = table2.id
--[OR]
SELECT * FROM table1 INNER JOIN table2 ON table1.id = table2.id

--[Results:]
id | name | id | name 
---+------+----+------
1  | a1   | 1  | a2

SINISTRA [OUTER] JOIN:
quando vuoi avere tutte le righe di una delle tabelle nel risultato sopra riportato - con la stessa relazione- puoi usare LEFT JOIN:
(Per RIGHT JOIN basta cambiare il posto delle tabelle)

SELECT * FROM table1, table2 WHERE table1.id = table2.id 
UNION ALL
SELECT *, Null, Null FROM table1 WHERE Not table1.id In (SELECT id FROM table2)
--[OR]
SELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id

--[Results:]
id | name | id   | name 
---+------+------+------
1  | a1   | 1    | a2
2  | b1   | Null | Null

FULL OUTER JOIN:
quando vuoi anche avere tutte le righe dell'altra tabella nei tuoi risultati puoi usare FULL OUTER JOIN:

SELECT * FROM table1, table2 WHERE table1.id = table2.id
UNION ALL
SELECT *, Null, Null FROM table1 WHERE Not table1.id In (SELECT id FROM table2)
UNION ALL
SELECT Null, Null, * FROM table2 WHERE Not table2.id In (SELECT id FROM table1)
--[OR] (recommended for SQLite)
SELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id
UNION ALL
SELECT * FROM table2 LEFT JOIN table1 ON table2.id = table1.id
WHERE table1.id IS NULL
--[OR]
SELECT * FROM table1 FULL OUTER JOIN table2 On table1.id = table2.id

--[Results:]
id   | name | id   | name 
-----+------+------+------
1    | a1   | 1    | a2
2    | b1   | Null | Null
Null | Null | 3    | b2

Bene, in base alle tue necessità scegli ognuno di quelli che coprono le tue necessità;).


Non vedo molti dettagli su prestazioni e ottimizzatore nelle altre risposte.

A volte è bene sapere che solo INNER JOINassociativo significa che l'ottimizzatore ha la maggior possibilità di giocarci. Può riordinare l'ordine di join per renderlo più veloce mantenendo lo stesso risultato. L'ottimizzatore può utilizzare la maggior parte delle modalità di join.

Generalmente è una buona pratica cercare di usare al INNER JOINposto del diverso tipo di join. (Naturalmente se è possibile considerare il set di risultati atteso.)

Ci sono un paio di buoni esempi e spiegazioni su questo strano comportamento associativo:


L'algoritmo preciso per INNER JOIN, LEFT/RIGHT OUTER JOINsono i seguenti:

  1. Prendi ciascuna riga dalla prima tabella: a
  2. Considera tutte le righe dalla seconda tabella accanto: (a, b[i])
  3. Valuta la ON ...clausola contro ogni coppia:ON( a, b[i] ) = true/false?
    • Quando la condizione viene valutata true, restituisci quella riga combinata (a, b[i]).
    • Quando raggiungi la fine della seconda tabella senza alcuna corrispondenza, e questo è un Outer Joinritorno quindi una coppia (virtuale) usando Nullper tutte le colonne di un'altra tabella: (a, Null)per l'unione esterna SINISTRA o (Null, b)per l'unione esterna DESTRO. Questo per garantire che tutte le righe della prima tabella siano presenti nei risultati finali.

Nota: la condizione specificata nella ONclausola potrebbe essere qualsiasi cosa, non è necessario utilizzare le chiavi primarie (e non è necessario fare sempre riferimento alle colonne di entrambe le tabelle)! Per esempio:

  • ... ON T1.title = T2.title AND T1.version < T2.version(=> vedi questo post come esempio di utilizzo: seleziona solo le righe con valore massimo su una colonna )
  • ... ON T1.y IS NULL
  • ... ON 1 = 0 (solo come campione)

Nota: Join sinistro = Join esterno sinistro, Join destro = Join esterno destro.


Si utilizza INNER JOINper restituire tutte le righe da entrambe le tabelle in cui è presente una corrispondenza. cioè nella tabella risultante tutte le righe e le colonne avranno valori.

Nella OUTER JOINtabella risultante potrebbero avere colonne vuote. L'unione esterna può essere LEFTo RIGHT.

LEFT OUTER JOIN restituisce tutte le righe dalla prima tabella, anche se non ci sono corrispondenze nella seconda tabella.

RIGHT OUTER JOIN restituisce tutte le righe dalla seconda tabella, anche se non ci sono corrispondenze nella prima tabella.





outer-join