tra - union sql




Join SQL impliciti e impliciti (8)

Per quanto riguarda le prestazioni, sono esattamente gli stessi (almeno in SQL Server), ma si tenga presente che stanno deprecando questa sintassi del join e non è supportata da sql server2005.

Penso che stai pensando agli operatori deprecati * = e = * rispetto a "outer join".

Ho appena testato i due formati indicati e funzionano correttamente su un database SQL Server 2008. Nel mio caso hanno prodotto piani di esecuzione identici, ma non potevo dire con certezza che questo sarebbe sempre stato vero.

C'è qualche differenza di efficienza in un join interno esplicito vs implicito? Per esempio:

SELECT * FROM
table a INNER JOIN table b
ON a.id = b.id;

vs.

SELECT a.*, b.*
FROM table a, table b
WHERE a.id = b.id;

@lomaxx: giusto per chiarire, sono abbastanza sicuro che entrambe le sintassi di cui sopra sono supportate da SQL Serv 2005. La sintassi di seguito non è tuttavia supportata

select a.*, b.*  
from table a, table b  
where a.id *= b.id;

In particolare, il join esterno (* =) non è supportato.


La prima risposta che hai dato utilizza quella che è nota come sintassi di join ANSI, l'altra è valida e funzionerà in qualsiasi database relazionale.

Sono d'accordo con grom sul fatto che dovresti usare la sintassi di join ANSI. Come hanno detto, il motivo principale è per chiarezza. Piuttosto che avere una clausola where con un sacco di predicati, alcuni dei quali uniscono tabelle e altri che limitano le righe restituite con la sintassi del join ANSI, si sta rendendo esplicitamente chiaro quali condizioni vengono utilizzate per unire le tabelle e che vengono utilizzate per limitare il risultati.


La seconda sintassi ha la possibilità indesiderata di un cross join: è possibile aggiungere tabelle alla parte FROM senza la corrispondente clausola WHERE. Questo è considerato dannoso.


Per quanto riguarda le prestazioni, non dovrebbe fare alcuna differenza. La sintassi esplicita del join mi sembra più pulita in quanto definisce chiaramente le relazioni tra le tabelle nella clausola from e non ingombra la clausola where.



Su MySQL 5.1.51, entrambe le query hanno piani di esecuzione identici:

mysql> explain select * from table1 a inner join table2 b on a.pid = b.pid;
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
| id | select_type | table | type | possible_keys | key  | key_len | ref          | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
|  1 | SIMPLE      | b     | ALL  | PRIMARY       | NULL | NULL    | NULL         |  986 |       |
|  1 | SIMPLE      | a     | ref  | pid           | pid  | 4       | schema.b.pid |   70 |       |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
2 rows in set (0.02 sec)

mysql> explain select * from table1 a, table2 b where a.pid = b.pid;
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
| id | select_type | table | type | possible_keys | key  | key_len | ref          | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
|  1 | SIMPLE      | b     | ALL  | PRIMARY       | NULL | NULL    | NULL         |  986 |       |
|  1 | SIMPLE      | a     | ref  | pid           | pid  | 4       | schema.b.pid |   70 |       |
+----+-------------+-------+------+---------------+------+---------+--------------+------+-------+
2 rows in set (0.00 sec)

table1 ha 166208 righe; table2 ha circa 1000 righe.

Questo è un caso molto semplice; non dimostra in alcun modo che Query Optimizer non si confonda e generi piani diversi in un caso più complicato.


Su alcuni database (in particolare su Oracle) l'ordine dei join può fare una grande differenza per le prestazioni delle query (se ci sono più di due tabelle). In una applicazione, in alcuni casi abbiamo avuto letteralmente due ordini di grandezza. L'uso della sintassi del join interno ti dà il controllo su questo - se usi la sintassi dei suggerimenti giusti.

Non hai specificato quale database stai usando, ma la probabilità suggerisce SQL Server o MySQL dove non fa alcuna differenza.





join