MySQL: rapida suddivisione dei tipi di join

Vorrei una rapida ripartizione dei tipi di join MySQL. Conosco questi, per il resto non sono sicuro di cosa intendano.

  • separate da virgola (che cosa è esattamente questo abbreviazione?): SELECT * FROM a, b WHERE b.id = a.beeId AND ...
  • mostra le informazioni da a, anche se non ci sono corrispondenze in b: SELECT * FROM a LEFT OUTER JOIN b ON b.id = a.beeId WHERE ...

Ho visto altri join, ma voglio sapere cosa li rende diversi, cosa è INNER / OUTER , aggiunge LEFT cambia le cose.

So già come funzionano i join, voglio solo sapere se ci sono altri tipi di join o se sono solo modi diversi per ottenere lo stesso risultato.

In base al tuo commento, le definizioni semplici di ciascuna di esse sono meglio reperibili su W3Schools. La prima riga di ciascun tipo fornisce una breve spiegazione del tipo di join

  • UNISCI: restituisce le righe quando c’è almeno una corrispondenza in entrambe le tabelle
  • LEFT JOIN: restituisce tutte le righe dalla tabella di sinistra, anche se non ci sono corrispondenze nella tabella giusta
  • RIGHT JOIN: restituisce tutte le righe dalla tabella di destra, anche se non ci sono corrispondenze nella tabella di sinistra
  • FULL JOIN: restituisce righe quando c’è una corrispondenza in una delle tabelle

FINE MODIFICA

In poche parole, l’esempio separato da virgola di cui hai dato

 SELECT * FROM a, b WHERE b.id = a.beeId AND ... 

sta selezionando ogni record dalle tabelle aeb con le virgole che separano le tabelle, questo può essere usato anche in colonne come

 SELECT a.beeName,b.* FROM a, b WHERE b.id = a.beeId AND ... 

Quindi ottiene le informazioni istruite nella riga in cui la colonna b.id e la colonna a.beeId hanno una corrispondenza nell’esempio. Quindi nel tuo esempio otterrà tutte le informazioni dalle tabelle aeb dove il b.id è uguale a a.beeId. Nel mio esempio otterrà tutte le informazioni dalla tabella b e solo le informazioni dalla colonna a.beeName quando b.id è uguale a a.beeId. Nota che c’è anche una clausola AND, questo ti aiuterà a perfezionare i tuoi risultati.

Per alcune semplici esercitazioni e spiegazioni sui join mySQL e sui join di sinistra è ansible consultare le esercitazioni mySQL di Tizag. Puoi anche controllare il sito web di Keith J. Brown per ulteriori informazioni sui join che è anche abbastanza buono.

Spero che questo ti aiuta

Il join esterno completo non esiste in mysql, potrebbe essere necessario utilizzare una combinazione di join sinistro e destro.

Ho 2 tavoli come questo:

 > SELECT * FROM table_a; +------+------+ | id | name | +------+------+ | 1 | row1 | | 2 | row2 | +------+------+ > SELECT * FROM table_b; +------+------+------+ | id | name | aid | +------+------+------+ | 3 | row3 | 1 | | 4 | row4 | 1 | | 5 | row5 | NULL | +------+------+------+ 

INNER JOIN si prende cura di entrambi i tavoli

INNER JOIN si preoccupa di entrambi i tavoli, quindi ottieni solo una riga se entrambi i tavoli ne hanno uno. Se c’è più di una coppia corrispondente, ottieni più righe.

 > SELECT * FROM table_a a INNER JOIN table_b b ON a.id=b.aid; +------+------+------+------+------+ | id | name | id | name | aid | +------+------+------+------+------+ | 1 | row1 | 3 | row3 | 1 | | 1 | row1 | 4 | row4 | 1 | +------+------+------+------+------+ 

L’INNER JOIN non fa alcuna differenza se si inverte l’ordine perché si preoccupa di entrambe le tabelle:

 > SELECT * FROM table_b b INNER JOIN table_a a ON a.id=b.aid; +------+------+------+------+------+ | id | name | aid | id | name | +------+------+------+------+------+ | 3 | row3 | 1 | 1 | row1 | | 4 | row4 | 1 | 1 | row1 | +------+------+------+------+------+ 

Ottieni le stesse righe, ma le colonne sono in un ordine diverso perché abbiamo menzionato le tabelle in un ordine diverso.

LEFT JOIN si interessa solo del primo tavolo

LEFT JOIN si preoccupa del primo tavolo che gli dai, e non si preoccupa molto del secondo, quindi ottieni sempre le righe dalla prima tabella, anche se nel secondo non c’è una riga corrispondente:

 > SELECT * FROM table_a a LEFT JOIN table_b b ON a.id=b.aid; +------+------+------+------+------+ | id | name | id | name | aid | +------+------+------+------+------+ | 1 | row1 | 3 | row3 | 1 | | 1 | row1 | 4 | row4 | 1 | | 2 | row2 | NULL | NULL | NULL | +------+------+------+------+------+ 

Sopra puoi vedere tutte le righe di table_a anche se alcune di esse non corrispondono a nulla nella tabella b, ma non tutte le righe di table_b – solo quelle che corrispondono a qualcosa in table_a.

Se invertiamo l’ordine delle tabelle, LEFT JOIN si comporta in modo diverso:

 > SELECT * FROM table_b b LEFT JOIN table_a a ON a.id=b.aid; +------+------+------+------+------+ | id | name | aid | id | name | +------+------+------+------+------+ | 3 | row3 | 1 | 1 | row1 | | 4 | row4 | 1 | 1 | row1 | | 5 | row5 | NULL | NULL | NULL | +------+------+------+------+------+ 

Ora otteniamo tutte le righe di table_b, ma solo le righe corrispondenti di table_a.

RIGHT JOIN si interessa solo del secondo tavolo

a RIGHT JOIN b ottiene esattamente le stesse file di b LEFT JOIN a . L’unica differenza è l’ordine predefinito delle colonne.

 > SELECT * FROM table_a a RIGHT JOIN table_b b ON a.id=b.aid; +------+------+------+------+------+ | id | name | id | name | aid | +------+------+------+------+------+ | 1 | row1 | 3 | row3 | 1 | | 1 | row1 | 4 | row4 | 1 | | NULL | NULL | 5 | row5 | NULL | +------+------+------+------+------+ 

Queste sono le stesse file table_b LEFT JOIN table_a , che abbiamo visto nella sezione LEFT JOIN.

Allo stesso modo:

 > SELECT * FROM table_b b RIGHT JOIN table_a a ON a.id=b.aid; +------+------+------+------+------+ | id | name | aid | id | name | +------+------+------+------+------+ | 3 | row3 | 1 | 1 | row1 | | 4 | row4 | 1 | 1 | row1 | | NULL | NULL | NULL | 2 | row2 | +------+------+------+------+------+ 

Sono le stesse righe di table_a LEFT JOIN table_b .

No join affatto ti dà le copie di tutto

Se scrivi le tue tabelle senza alcuna clausola JOIN, solo separate da virgole, ottieni ogni riga della prima tabella scritta accanto a ogni riga del secondo tavolo, in ogni combinazione ansible:

 > SELECT * FROM table_b b, table_a; +------+------+------+------+------+ | id | name | aid | id | name | +------+------+------+------+------+ | 3 | row3 | 1 | 1 | row1 | | 3 | row3 | 1 | 2 | row2 | | 4 | row4 | 1 | 1 | row1 | | 4 | row4 | 1 | 2 | row2 | | 5 | row5 | NULL | 1 | row1 | | 5 | row5 | NULL | 2 | row2 | +------+------+------+------+------+ 

(Questo è dal mio post sul blog Esempi di tipi di join di SQL )