2014-07-16 2 views
1

Salut pourriez-vous s'il vous plaît me faire savoir que l'on est plus optimisé:rejoindre sur vs où-SQL

select a.*,b.* from a join b on a.id=b.id and a.name='test'; 

select a.*,b.* from a join b on a.id=b.id where a.name='test'; 

Merci

+2

Dans ce cas, les deux requêtes doivent fonctionner de la même manière. – user2989408

+1

Comparez les plans d'exécution et vous saurez. –

+0

Dans ce cas, la même chose, mais lorsque vous travaillez avec des jointures à gauche ou à droite, le sera un gros diff. Albin a raison, vérifie le plan d'exécution et apprend ... – Paul

Répondre

2

À mon avis avec une bonne syntaxe, il est plus facile de lire une requête si au lieu de ceux 'ET il y a une série de clauses WHERE après.

Puisque vous utilisez une jointure interne, il n'y a pas de différence entre les deux. La jointure interne ne s'affiche que s'il existe une correspondance exacte sur votre jointure.

Si vous utilisiez une jointure gauche, les choses seraient un peu différentes.

1

Dans le cas le plus simple, les deux sont équivalents. Pour prouver, il vous suffit de regarder les deux plans d'exécution

explain select a.*,b.* from a join b on a.id=b.id and a.name='test' 

donne

+----+-------------+-------+------+---------------+------+---------+------+------+--------------------------------+ 
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra       | 
+----+-------------+-------+------+---------------+------+---------+------+------+--------------------------------+ 
| 1 | SIMPLE  | a  | ALL | NULL   | NULL | NULL | NULL | 1 | Using where     | 
| 1 | SIMPLE  | b  | ALL | NULL   | NULL | NULL | NULL | 1 | Using where; Using join buffer | 
+----+-------------+-------+------+---------------+------+---------+------+------+--------------------------------+ 
2 rows in set (0.00 sec) 

puis pour

explain select a.*,b.* from a join b on a.id=b.id where a.name='test' 

donne également

+----+-------------+-------+------+---------------+------+---------+------+------+--------------------------------+ 
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra       | 
+----+-------------+-------+------+---------------+------+---------+------+------+--------------------------------+ 
| 1 | SIMPLE  | a  | ALL | NULL   | NULL | NULL | NULL | 1 | Using where     | 
| 1 | SIMPLE  | b  | ALL | NULL   | NULL | NULL | NULL | 1 | Using where; Using join buffer | 
+----+-------------+-------+------+---------------+------+---------+------+------+--------------------------------+ 
2 rows in set (0.00 sec) 

Voir aussi SQLFiddle

+0

Je ne suis pas surpris, car le chapitre du manuel [Comment MySQL optimise les clauses WHERE] (https://dev.mysql.com/doc/refman/5.6/en/where-optimizations.html) indique: _Pour chaque table dans un join, un WHERE plus simple est construit pour obtenir une évaluation WHERE rapide pour la table et aussi pour sauter des lignes le plus rapidement possible. – VMai