Parte 1 - Associazioni e sindacati
Questa risposta riguarda:
- Parte 1
- Parte 2
- Sottoquery: cosa sono, dove possono essere utilizzate e a cosa prestare attenzione
- Cartesian si unisce ad AKA - Oh, la miseria!
Esistono diversi modi per recuperare dati da più tabelle in un database. In questa risposta, userò la sintassi del join ANSI-92. Questo potrebbe essere diverso da un numero di altri tutorial là fuori che usano la vecchia sintassi ANSI-89 (e se sei abituato a 89, può sembrare molto meno intuitivo - ma tutto ciò che posso dire è provarlo) in quanto è molto più facile per capire quando le query iniziano a diventare più complesse. Perché usarlo C'è un guadagno in termini di prestazioni? La risposta breve è no, ma è più facile da leggere quando ci si abitua. È più facile leggere le query scritte da altre persone che utilizzano questa sintassi.
Userò anche il concetto di un piccolo cortile con un database per tenere traccia di quali auto ha a disposizione. Il proprietario ti ha assunto come suo informatico informatico e si aspetta che tu sia in grado di rilasciargli i dati che chiede al volo di un cappello.
Ho creato una serie di tabelle di ricerca che verranno utilizzate dal tavolo finale. Questo ci darà un modello ragionevole su cui lavorare. Per iniziare, eseguirò le mie query su un database di esempio che ha la seguente struttura. Proverò a pensare agli errori comuni che vengono fatti all'inizio e spiegherò cosa non va in loro - oltre ovviamente a mostrare come correggerli.
La prima tabella è semplicemente un elenco di colori in modo da sapere quali colori abbiamo nel cortile dell'auto.
mysql> create table colors(id int(3) not null auto_increment primary key,
-> color varchar(15), paint varchar(10));
Query OK, 0 rows affected (0.01 sec)
mysql> show columns from colors;
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
| id | int(3) | NO | PRI | NULL | auto_increment |
| color | varchar(15) | YES | | NULL | |
| paint | varchar(10) | YES | | NULL | |
+-------+-------------+------+-----+---------+----------------+
3 rows in set (0.01 sec)
mysql> insert into colors (color, paint) values ('Red', 'Metallic'),
-> ('Green', 'Gloss'), ('Blue', 'Metallic'),
-> ('White' 'Gloss'), ('Black' 'Gloss');
Query OK, 5 rows affected (0.00 sec)
Records: 5 Duplicates: 0 Warnings: 0
mysql> select * from colors;
+----+-------+----------+
| id | color | paint |
+----+-------+----------+
| 1 | Red | Metallic |
| 2 | Green | Gloss |
| 3 | Blue | Metallic |
| 4 | White | Gloss |
| 5 | Black | Gloss |
+----+-------+----------+
5 rows in set (0.00 sec)
La tabella dei marchi identifica le diverse marche di auto che il cantiere potrebbe eventualmente vendere.
mysql> create table brands (id int(3) not null auto_increment primary key,
-> brand varchar(15));
Query OK, 0 rows affected (0.01 sec)
mysql> show columns from brands;
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
| id | int(3) | NO | PRI | NULL | auto_increment |
| brand | varchar(15) | YES | | NULL | |
+-------+-------------+------+-----+---------+----------------+
2 rows in set (0.01 sec)
mysql> insert into brands (brand) values ('Ford'), ('Toyota'),
-> ('Nissan'), ('Smart'), ('BMW');
Query OK, 5 rows affected (0.00 sec)
Records: 5 Duplicates: 0 Warnings: 0
mysql> select * from brands;
+----+--------+
| id | brand |
+----+--------+
| 1 | Ford |
| 2 | Toyota |
| 3 | Nissan |
| 4 | Smart |
| 5 | BMW |
+----+--------+
5 rows in set (0.00 sec)
La tabella dei modelli coprirà diversi tipi di auto, sarà più semplice per questo utilizzare diversi tipi di auto piuttosto che modelli di auto reali.
mysql> create table models (id int(3) not null auto_increment primary key,
-> model varchar(15));
Query OK, 0 rows affected (0.01 sec)
mysql> show columns from models;
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
| id | int(3) | NO | PRI | NULL | auto_increment |
| model | varchar(15) | YES | | NULL | |
+-------+-------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)
mysql> insert into models (model) values ('Sports'), ('Sedan'), ('4WD'), ('Luxury');
Query OK, 4 rows affected (0.00 sec)
Records: 4 Duplicates: 0 Warnings: 0
mysql> select * from models;
+----+--------+
| id | model |
+----+--------+
| 1 | Sports |
| 2 | Sedan |
| 3 | 4WD |
| 4 | Luxury |
+----+--------+
4 rows in set (0.00 sec)
E infine, per legare tutti questi altri tavoli, il tavolo che lega tutto insieme. Il campo ID è in realtà il numero di lotto univoco utilizzato per identificare le auto.
mysql> create table cars (id int(3) not null auto_increment primary key,
-> color int(3), brand int(3), model int(3));
Query OK, 0 rows affected (0.01 sec)
mysql> show columns from cars;
+-------+--------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------+------+-----+---------+----------------+
| id | int(3) | NO | PRI | NULL | auto_increment |
| color | int(3) | YES | | NULL | |
| brand | int(3) | YES | | NULL | |
| model | int(3) | YES | | NULL | |
+-------+--------+------+-----+---------+----------------+
4 rows in set (0.00 sec)
mysql> insert into cars (color, brand, model) values (1,2,1), (3,1,2), (5,3,1),
-> (4,4,2), (2,2,3), (3,5,4), (4,1,3), (2,2,1), (5,2,3), (4,5,1);
Query OK, 10 rows affected (0.00 sec)
Records: 10 Duplicates: 0 Warnings: 0
mysql> select * from cars;
+----+-------+-------+-------+
| id | color | brand | model |
+----+-------+-------+-------+
| 1 | 1 | 2 | 1 |
| 2 | 3 | 1 | 2 |
| 3 | 5 | 3 | 1 |
| 4 | 4 | 4 | 2 |
| 5 | 2 | 2 | 3 |
| 6 | 3 | 5 | 4 |
| 7 | 4 | 1 | 3 |
| 8 | 2 | 2 | 1 |
| 9 | 5 | 2 | 3 |
| 10 | 4 | 5 | 1 |
+----+-------+-------+-------+
10 rows in set (0.00 sec)
Questo ci fornirà dati sufficienti (spero) per coprire gli esempi seguenti dei diversi tipi di join e anche dati sufficienti per renderli utili.
Quindi, entrando in gioco, il capo vuole conoscere gli ID di tutte le auto sportive che ha .
Questo è un semplice join a due tabelle. Abbiamo una tabella che identifica il modello e la tabella con lo stock disponibile al suo interno. Come puoi vedere, i dati nella modelcolonna della carstabella si riferiscono alla modelscolonna della carstabella che abbiamo. Ora sappiamo che la tabella dei modelli ha un ID di 1for Sportsquindi scriviamo il join.
select
ID,
model
from
cars
join models
on model=ID
Quindi questa query sembra buona, vero? Abbiamo identificato le due tabelle e contenente le informazioni di cui abbiamo bisogno e utilizziamo un join che identifichi correttamente su quali colonne unire.
ERROR 1052 (23000): Column 'ID' in field list is ambiguous
Oh no! Un errore nella nostra prima query! Sì, ed è una prugna. Vedete, la query ha effettivamente le colonne giuste, ma alcune di esse esistono in entrambe le tabelle, quindi il database si confonde su quale colonna reale intendiamo e dove. Esistono due soluzioni per risolvere questo problema. Il primo è carino e semplice, possiamo usare tableName.columnNameper dire al database esattamente cosa intendiamo, in questo modo:
select
cars.ID,
models.model
from
cars
join models
on cars.model=models.ID
+----+--------+
| ID | model |
+----+--------+
| 1 | Sports |
| 3 | Sports |
| 8 | Sports |
| 10 | Sports |
| 2 | Sedan |
| 4 | Sedan |
| 5 | 4WD |
| 7 | 4WD |
| 9 | 4WD |
| 6 | Luxury |
+----+--------+
10 rows in set (0.00 sec)
L'altro è probabilmente più spesso usato e si chiama aliasing della tabella. Le tabelle in questo esempio hanno nomi semplici belli e brevi, ma digitare qualcosa del genere KPI_DAILY_SALES_BY_DEPARTMENTprobabilmente invecchierebbe rapidamente, quindi un modo semplice è soprannominare la tabella in questo modo:
select
a.ID,
b.model
from
cars a
join models b
on a.model=b.ID
Ora, torniamo alla richiesta. Come puoi vedere, abbiamo le informazioni di cui abbiamo bisogno, ma abbiamo anche informazioni che non sono state richieste, quindi dobbiamo includere una clausola where nella dichiarazione per ottenere solo le auto sportive come richiesto. Dato che preferisco il metodo alias di tabella piuttosto che usare i nomi delle tabelle più e più volte, da questo punto in poi mi atterrò.
Chiaramente, dobbiamo aggiungere una clausola where alla nostra query. Siamo in grado di identificare le auto sportive da ID=1o model='Sports'. Poiché l'ID è indicizzato e la chiave primaria (e sembra essere meno digitante), usiamola nella nostra query.
select
a.ID,
b.model
from
cars a
join models b
on a.model=b.ID
where
b.ID=1
+----+--------+
| ID | model |
+----+--------+
| 1 | Sports |
| 3 | Sports |
| 8 | Sports |
| 10 | Sports |
+----+--------+
4 rows in set (0.00 sec)
Bingo! Il capo è felice. Certo, essendo un capo e non essere mai contento di ciò che ha chiesto, guarda le informazioni, poi dice che voglio anche i colori .
Ok, quindi abbiamo già scritto buona parte della nostra query, ma dobbiamo usare una terza tabella che è i colori. Ora, la nostra tabella di informazioni principale carsmemorizza l'ID colore dell'auto e questo rimanda alla colonna ID colori. Quindi, in modo simile all'originale, possiamo unire un terzo tavolo:
select
a.ID,
b.model
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
where
b.ID=1
+----+--------+
| ID | model |
+----+--------+
| 1 | Sports |
| 3 | Sports |
| 8 | Sports |
| 10 | Sports |
+----+--------+
4 rows in set (0.00 sec)
Dannazione, sebbene la tabella sia stata correttamente unita e le relative colonne siano state collegate, abbiamo dimenticato di estrarre le informazioni effettive dalla nuova tabella che abbiamo appena collegato.
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
where
b.ID=1
+----+--------+-------+
| ID | model | color |
+----+--------+-------+
| 1 | Sports | Red |
| 8 | Sports | Green |
| 10 | Sports | White |
| 3 | Sports | Black |
+----+--------+-------+
4 rows in set (0.00 sec)
Bene, questo è il capo che ci sta alle spalle per un momento. Ora, per spiegare alcuni di questi in modo un po 'più dettagliato. Come puoi vedere, la fromclausola nella nostra dichiarazione collega la nostra tabella principale (utilizzo spesso una tabella che contiene informazioni anziché una tabella di ricerca o dimensione. La query funzionerebbe altrettanto bene con le tabelle tutte invertite, ma avrebbe meno senso quando torniamo a questa query per leggerla tra qualche mese, quindi è spesso meglio provare a scrivere una query che sia piacevole e facile da capire - disponila in modo intuitivo, usa un rientro piacevole in modo che tutto sia chiaro come Se continui a insegnare agli altri, prova a instillare queste caratteristiche nelle loro domande, specialmente se le risolverai.
È del tutto possibile continuare a collegare sempre più tabelle in questo modo.
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
where
b.ID=1
Anche se ho dimenticato di includere una tabella in cui potremmo voler unire più di una colonna joinnell'istruzione, ecco un esempio. Se la modelstabella avesse modelli specifici del marchio e quindi avesse anche una colonna chiamata brandche si collegava alla brandstabella sul IDcampo, si potrebbe fare come segue:
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
and b.brand=d.ID
where
b.ID=1
Come puoi vedere, la query sopra non solo collega le tabelle unite alla carstabella principale , ma specifica anche i join tra le tabelle già unite. Se ciò non è stato fatto, il risultato si chiama join cartesiano - che è dba che parla male. Un join cartesiano è quello in cui vengono restituite le righe perché le informazioni non indicano al database come limitare i risultati, quindi la query restituisce tutte le righe che soddisfano i criteri.
Quindi, per dare un esempio di join cartesiano, eseguiamo la seguente query:
select
a.ID,
b.model
from
cars a
join models b
+----+--------+
| ID | model |
+----+--------+
| 1 | Sports |
| 1 | Sedan |
| 1 | 4WD |
| 1 | Luxury |
| 2 | Sports |
| 2 | Sedan |
| 2 | 4WD |
| 2 | Luxury |
| 3 | Sports |
| 3 | Sedan |
| 3 | 4WD |
| 3 | Luxury |
| 4 | Sports |
| 4 | Sedan |
| 4 | 4WD |
| 4 | Luxury |
| 5 | Sports |
| 5 | Sedan |
| 5 | 4WD |
| 5 | Luxury |
| 6 | Sports |
| 6 | Sedan |
| 6 | 4WD |
| 6 | Luxury |
| 7 | Sports |
| 7 | Sedan |
| 7 | 4WD |
| 7 | Luxury |
| 8 | Sports |
| 8 | Sedan |
| 8 | 4WD |
| 8 | Luxury |
| 9 | Sports |
| 9 | Sedan |
| 9 | 4WD |
| 9 | Luxury |
| 10 | Sports |
| 10 | Sedan |
| 10 | 4WD |
| 10 | Luxury |
+----+--------+
40 rows in set (0.00 sec)
Buon Dio, è brutto. Tuttavia, per quanto riguarda il database, è esattamente ciò che è stato richiesto. Nella query, abbiamo chiesto il IDda carse il modelda models. Tuttavia, poiché non abbiamo specificato come unire le tabelle, il database ha abbinato ogni riga della prima tabella con ogni riga della seconda tabella.
Ok, quindi il capo è tornato e vuole di nuovo ulteriori informazioni. Voglio la stessa lista, ma includo anche 4 ruote motrici .
Questo, tuttavia, ci offre un'ottima scusa per esaminare due modi diversi per raggiungere questo obiettivo. Potremmo aggiungere un'altra condizione alla clausola where in questo modo:
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
where
b.ID=1
or b.ID=3
Mentre quanto sopra funzionerà perfettamente, guardiamolo in modo diverso, questa è un'ottima scusa per mostrare come funzionerà una unionquery.
Sappiamo che quanto segue restituirà tutte le auto sportive:
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
where
b.ID=1
E quanto segue restituirebbe tutti i 4 ruote motrici:
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
where
b.ID=3
Quindi aggiungendo una union allclausola tra loro, i risultati della seconda query verranno aggiunti ai risultati della prima query.
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
where
b.ID=1
union all
select
a.ID,
b.model,
c.color
from
cars a
join models b
on a.model=b.ID
join colors c
on a.color=c.ID
join brands d
on a.brand=d.ID
where
b.ID=3
+----+--------+-------+
| ID | model | color |
+----+--------+-------+
| 1 | Sports | Red |
| 8 | Sports | Green |
| 10 | Sports | White |
| 3 | Sports | Black |
| 5 | 4WD | Green |
| 7 | 4WD | White |
| 9 | 4WD | Black |
+----+--------+-------+
7 rows in set (0.00 sec)
Come puoi vedere, i risultati della prima query vengono restituiti per primi, seguiti dai risultati della seconda query.
In questo esempio, ovviamente sarebbe stato molto più semplice utilizzare semplicemente la prima query, ma le unionquery possono essere ottime per casi specifici. Sono un ottimo modo per restituire risultati specifici da tabelle da tabelle che non sono facilmente unibili tra loro - o del resto tabelle completamente non correlate. Ci sono alcune regole da seguire comunque.
- I tipi di colonna della prima query devono corrispondere ai tipi di colonna di ogni altra query di seguito.
- I nomi delle colonne della prima query verranno utilizzati per identificare l'intero set di risultati.
- Il numero di colonne in ciascuna query deve essere lo stesso.
Ora, ti starai chiedendo quale sia la differenza tra l'utilizzo di unione union all. Una unionquery rimuoverà i duplicati, mentre union allnon lo farà. Questo significa che c'è un piccolo successo prestazionale quando si usa unionover union allma i risultati potrebbero valerne la pena - non speculerò su quel genere di cose in questo.
In questa nota, potrebbe valere la pena notare alcune note aggiuntive qui.
- Se volessimo ordinare i risultati, possiamo usare un
order byma non puoi più usare l'alias. Nella query sopra, l'aggiunta e la visualizzazione order by a.IDcomporterebbe un errore - per quanto riguarda i risultati, viene chiamata la colonna IDanziché a.ID- anche se lo stesso alias è stato utilizzato in entrambe le query.
- Possiamo avere solo
order byun'istruzione e deve essere come l'ultima istruzione.
Per i prossimi esempi, sto aggiungendo alcune righe extra alle nostre tabelle.
Ho aggiunto Holdenalla tabella dei marchi. Ho anche aggiunto una riga carsche ha il colorvalore di 12- che non ha alcun riferimento nella tabella dei colori.
Ok, il capo è tornato di nuovo, abbaiando richieste - * Voglio un conteggio di ogni marchio che trasportiamo e il numero di auto in esso! `- Tipico, arriviamo a una sezione interessante della nostra discussione e il capo vuole più lavoro .
Bene, quindi la prima cosa che dobbiamo fare è ottenere un elenco completo di possibili marchi.
select
a.brand
from
brands a
+--------+
| brand |
+--------+
| Ford |
| Toyota |
| Nissan |
| Smart |
| BMW |
| Holden |
+--------+
6 rows in set (0.00 sec)
Ora, quando ci uniamo a questo al tavolo delle nostre auto, otteniamo il seguente risultato:
select
a.brand
from
brands a
join cars b
on a.ID=b.brand
group by
a.brand
+--------+
| brand |
+--------+
| BMW |
| Ford |
| Nissan |
| Smart |
| Toyota |
+--------+
5 rows in set (0.00 sec)
Il che è ovviamente un problema: non stiamo vedendo alcuna menzione dell'adorabile Holdenmarchio che ho aggiunto.
Questo perché un join cerca le righe corrispondenti in entrambe le tabelle. Poiché non vi sono dati nelle auto di tipo Holdennon vengono restituiti. Qui è dove possiamo usare un outerjoin. Ciò restituirà tutti i risultati da una tabella indipendentemente dal fatto che siano stati trovati nell'altra tabella o meno:
select
a.brand
from
brands a
left outer join cars b
on a.ID=b.brand
group by
a.brand
+--------+
| brand |
+--------+
| BMW |
| Ford |
| Holden |
| Nissan |
| Smart |
| Toyota |
+--------+
6 rows in set (0.00 sec)
Ora che ce l'abbiamo, possiamo aggiungere un'adorabile funzione aggregata per ottenere un conteggio e toglierci il capo dalle spalle per un momento.
select
a.brand,
count(b.id) as countOfBrand
from
brands a
left outer join cars b
on a.ID=b.brand
group by
a.brand
+--------+--------------+
| brand | countOfBrand |
+--------+--------------+
| BMW | 2 |
| Ford | 2 |
| Holden | 0 |
| Nissan | 1 |
| Smart | 1 |
| Toyota | 5 |
+--------+--------------+
6 rows in set (0.00 sec)
E con ciò, via il boss si masturba.
Ora, per spiegarlo in modo più dettagliato, i join esterni possono essere del tipo lefto right. Sinistra o Destra definisce quale tabella è completamente inclusa. A left outer joinincluderà tutte le righe dalla tabella a sinistra, mentre (hai indovinato) a right outer joinporta tutti i risultati dalla tabella a destra nei risultati.
Alcuni database consentiranno un risultato full outer joinche restituirà risultati (corrispondenti o meno) da entrambe le tabelle, ma questo non è supportato in tutti i database.
Ora, probabilmente immagino a questo punto nel tempo, ti stai chiedendo se puoi unire i tipi di join in una query - e la risposta è sì, puoi assolutamente farlo.
select
b.brand,
c.color,
count(a.id) as countOfBrand
from
cars a
right outer join brands b
on b.ID=a.brand
join colors c
on a.color=c.ID
group by
a.brand,
c.color
+--------+-------+--------------+
| brand | color | countOfBrand |
+--------+-------+--------------+
| Ford | Blue | 1 |
| Ford | White | 1 |
| Toyota | Black | 1 |
| Toyota | Green | 2 |
| Toyota | Red | 1 |
| Nissan | Black | 1 |
| Smart | White | 1 |
| BMW | Blue | 1 |
| BMW | White | 1 |
+--------+-------+--------------+
9 rows in set (0.00 sec)
Quindi, perché non sono i risultati previsti? È perché, sebbene abbiamo selezionato l'unione esterna dalle automobili alle marche, non è stata specificata nell'unione ai colori, quindi quella particolare unione restituirà solo risultati che corrispondono in entrambe le tabelle.
Ecco la query che funzionerebbe per ottenere i risultati previsti:
select
a.brand,
c.color,
count(b.id) as countOfBrand
from
brands a
left outer join cars b
on a.ID=b.brand
left outer join colors c
on b.color=c.ID
group by
a.brand,
c.color
+--------+-------+--------------+
| brand | color | countOfBrand |
+--------+-------+--------------+
| BMW | Blue | 1 |
| BMW | White | 1 |
| Ford | Blue | 1 |
| Ford | White | 1 |
| Holden | NULL | 0 |
| Nissan | Black | 1 |
| Smart | White | 1 |
| Toyota | NULL | 1 |
| Toyota | Black | 1 |
| Toyota | Green | 2 |
| Toyota | Red | 1 |
+--------+-------+--------------+
11 rows in set (0.00 sec)
Come possiamo vedere, abbiamo due join esterni nella query e i risultati stanno arrivando come previsto.
Ora, che ne dici di quegli altri tipi di join che chiedi? Che dire di intersezioni?
Bene, non tutti i database supportano intersectionma praticamente tutti i database ti permetteranno di creare un'intersezione attraverso un join (o almeno un'istruzione dove ben strutturata).
Un'intersezione è un tipo di unione in qualche modo simile a unionquella descritta sopra, ma la differenza è che restituisce solo file di dati identici (e intendo identici) tra le varie singole query unite dall'unione. Verranno restituite solo righe identiche sotto ogni aspetto.
Un semplice esempio sarebbe come tale:
select
*
from
colors
where
ID>2
intersect
select
*
from
colors
where
id<4
Mentre una unionquery normale restituirebbe tutte le righe della tabella (la prima query restituirà qualsiasi cosa ID>2e la seconda qualsiasi cosa abbia ID<4) che comporterebbe un set completo, una query intersecata restituirebbe solo la corrispondenza delle righe id=3poiché soddisfa entrambi i criteri.
Ora, se il tuo database non supporta una intersectquery, è possibile integrare facilmente quanto sopra con la seguente query:
select
a.ID,
a.color,
a.paint
from
colors a
join colors b
on a.ID=b.ID
where
a.ID>2
and b.ID<4
+----+-------+----------+
| ID | color | paint |
+----+-------+----------+
| 3 | Blue | Metallic |
+----+-------+----------+
1 row in set (0.00 sec)
Se si desidera eseguire un'intersezione su due diverse tabelle utilizzando un database che non supporta intrinsecamente una query di intersezione, sarà necessario creare un join su ogni colonna delle tabelle.