Bonjour,
Je me pose une question (pour l'instant) :
Existe t-il une différence de traitement et d'exécution entre un where et
un
inner join ?
select * from table1 t1, table2 t2 where t1.id = t2.id
select * from table1 t1 inner join table2 t2 on t1.id = t2.id
Quelle est la différence ?
Merci
Bonjour,
Je me pose une question (pour l'instant) :
Existe t-il une différence de traitement et d'exécution entre un where et
un
inner join ?
select * from table1 t1, table2 t2 where t1.id = t2.id
select * from table1 t1 inner join table2 t2 on t1.id = t2.id
Quelle est la différence ?
Merci
Bonjour,
Je me pose une question (pour l'instant) :
Existe t-il une différence de traitement et d'exécution entre un where et
un
inner join ?
select * from table1 t1, table2 t2 where t1.id = t2.id
select * from table1 t1 inner join table2 t2 on t1.id = t2.id
Quelle est la différence ?
Merci
La première syntaxe est obsolète depuis pas mal de temps : elle laissait une
possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
where et ceux qui relèvent du join. En plus une clause join permet de
séparer explicitement ces deux aspects ce qui est plus clair plus les
différentes formes de join offrent plus de possibilités.
La première forme ne devrait plus être utilisée (à vérifier mais je me
demande d'ailleurs si la première forme n'est pas indiquée dans la doc de
SQL Server comme pouvant ne plus être supportée ultérieurement ou peut-être
le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois avoir vu
qq chose comme cela).
--
Patrice
"jerome" a écrit dans le message de news:
Os6CDz$Bonjour,
Je me pose une question (pour l'instant) :
Existe t-il une différence de traitement et d'exécution entre un where et
un
inner join ?
select * from table1 t1, table2 t2 where t1.id = t2.id
select * from table1 t1 inner join table2 t2 on t1.id = t2.id
Quelle est la différence ?
Merci
La première syntaxe est obsolète depuis pas mal de temps : elle laissait une
possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
where et ceux qui relèvent du join. En plus une clause join permet de
séparer explicitement ces deux aspects ce qui est plus clair plus les
différentes formes de join offrent plus de possibilités.
La première forme ne devrait plus être utilisée (à vérifier mais je me
demande d'ailleurs si la première forme n'est pas indiquée dans la doc de
SQL Server comme pouvant ne plus être supportée ultérieurement ou peut-être
le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois avoir vu
qq chose comme cela).
--
Patrice
"jerome" <jerome@hh.fr> a écrit dans le message de news:
Os6CDz$NIHA.5524@TK2MSFTNGP05.phx.gbl...
Bonjour,
Je me pose une question (pour l'instant) :
Existe t-il une différence de traitement et d'exécution entre un where et
un
inner join ?
select * from table1 t1, table2 t2 where t1.id = t2.id
select * from table1 t1 inner join table2 t2 on t1.id = t2.id
Quelle est la différence ?
Merci
La première syntaxe est obsolète depuis pas mal de temps : elle laissait une
possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
where et ceux qui relèvent du join. En plus une clause join permet de
séparer explicitement ces deux aspects ce qui est plus clair plus les
différentes formes de join offrent plus de possibilités.
La première forme ne devrait plus être utilisée (à vérifier mais je me
demande d'ailleurs si la première forme n'est pas indiquée dans la doc de
SQL Server comme pouvant ne plus être supportée ultérieurement ou peut-être
le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois avoir vu
qq chose comme cela).
--
Patrice
"jerome" a écrit dans le message de news:
Os6CDz$Bonjour,
Je me pose une question (pour l'instant) :
Existe t-il une différence de traitement et d'exécution entre un where et
un
inner join ?
select * from table1 t1, table2 t2 where t1.id = t2.id
select * from table1 t1 inner join table2 t2 on t1.id = t2.id
Quelle est la différence ?
Merci
Patrice a écrit :
> La première syntaxe est obsolète depuis pas mal de temps : elle laissait
> possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
> where et ceux qui relèvent du join. En plus une clause join permet de
> séparer explicitement ces deux aspects ce qui est plus clair plus les
> différentes formes de join offrent plus de possibilités.
>
> La première forme ne devrait plus être utilisée (à vérifier mais je me
> demande d'ailleurs si la première forme n'est pas indiquée dans la doc
> SQL Server comme pouvant ne plus être supportée ultérieurement ou
> le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois
> qq chose comme cela).
effectivement *= n'est plus supporté à partir de 2005. En fait cette
syntaxe donnait des résultats faux par rapport à la norme SQL et au
principe de jointure externe.
Voici le pourquoi de l'emploi des JOIN que je donne dans mon site SQlpro
(http://sqlpro.developpez.com/cours/sqlaz/jointures/#L1.2)
"
UN CONSEIL IMPORTANT
Dans la mesure du possible, utilisez toujours un opérateur de jointure
normalisé Sql2 (mot clef JOIN).
En effet :
* Les jointures faites dans la clause WHERE (ancienne syntaxe de
1986 !) ne permettent pas de faire la distinction de prime abord entre
ce qui relève du filtrage et ce qui relève de la jointure.
* Il est à priori absurde de vouloir filtrer dans le WHERE (ce qui
restreint les données du résultat) et de voiloir "élargir" ce résultat
par une jointure dans la même clause WHERE de filtrage.
* La lisibilité des requêtes est plus grande en utilisant la
syntaxe à base de JOIN, en isolant ce qui est du filtrage et de la
jointure, mais aussi en isolant avec clarté chaque condition de
jointures entre chaque couples de table.
* L'optimisation d'exécution de la requête est souvent plus pointue
du fait de l'utilisation du JOIN.
* Lorsque l'on utilise l'ancienne syntaxe et que l'on supprime la
clause WHERE a des fins de tests, le moteur SQL réalise le produit
cartésiens des tables ce qui revient la plupart du temps à mettre à
genoux le serveur !
"
A +
>
> --
> Patrice
>
>
> "jerome" a écrit dans le message de news:
> Os6CDz$
>> Bonjour,
>>
>> Je me pose une question (pour l'instant) :
>> Existe t-il une différence de traitement et d'exécution entre un where
>> un
>> inner join ?
>>
>> select * from table1 t1, table2 t2 where t1.id = t2.id
>> select * from table1 t1 inner join table2 t2 on t1.id = t2.id
>>
>> Quelle est la différence ?
>>
>> Merci
>>
>>
>
>
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
*********************** http://www.sqlspot.com *************************
Patrice a écrit :
> La première syntaxe est obsolète depuis pas mal de temps : elle laissait
> possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
> where et ceux qui relèvent du join. En plus une clause join permet de
> séparer explicitement ces deux aspects ce qui est plus clair plus les
> différentes formes de join offrent plus de possibilités.
>
> La première forme ne devrait plus être utilisée (à vérifier mais je me
> demande d'ailleurs si la première forme n'est pas indiquée dans la doc
> SQL Server comme pouvant ne plus être supportée ultérieurement ou
> le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois
> qq chose comme cela).
effectivement *= n'est plus supporté à partir de 2005. En fait cette
syntaxe donnait des résultats faux par rapport à la norme SQL et au
principe de jointure externe.
Voici le pourquoi de l'emploi des JOIN que je donne dans mon site SQlpro
(http://sqlpro.developpez.com/cours/sqlaz/jointures/#L1.2)
"
UN CONSEIL IMPORTANT
Dans la mesure du possible, utilisez toujours un opérateur de jointure
normalisé Sql2 (mot clef JOIN).
En effet :
* Les jointures faites dans la clause WHERE (ancienne syntaxe de
1986 !) ne permettent pas de faire la distinction de prime abord entre
ce qui relève du filtrage et ce qui relève de la jointure.
* Il est à priori absurde de vouloir filtrer dans le WHERE (ce qui
restreint les données du résultat) et de voiloir "élargir" ce résultat
par une jointure dans la même clause WHERE de filtrage.
* La lisibilité des requêtes est plus grande en utilisant la
syntaxe à base de JOIN, en isolant ce qui est du filtrage et de la
jointure, mais aussi en isolant avec clarté chaque condition de
jointures entre chaque couples de table.
* L'optimisation d'exécution de la requête est souvent plus pointue
du fait de l'utilisation du JOIN.
* Lorsque l'on utilise l'ancienne syntaxe et que l'on supprime la
clause WHERE a des fins de tests, le moteur SQL réalise le produit
cartésiens des tables ce qui revient la plupart du temps à mettre à
genoux le serveur !
"
A +
>
> --
> Patrice
>
>
> "jerome" <jerome@hh.fr> a écrit dans le message de news:
> Os6CDz$NIHA.5524@TK2MSFTNGP05.phx.gbl...
>> Bonjour,
>>
>> Je me pose une question (pour l'instant) :
>> Existe t-il une différence de traitement et d'exécution entre un where
>> un
>> inner join ?
>>
>> select * from table1 t1, table2 t2 where t1.id = t2.id
>> select * from table1 t1 inner join table2 t2 on t1.id = t2.id
>>
>> Quelle est la différence ?
>>
>> Merci
>>
>>
>
>
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
*********************** http://www.sqlspot.com *************************
Patrice a écrit :
> La première syntaxe est obsolète depuis pas mal de temps : elle laissait
> possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
> where et ceux qui relèvent du join. En plus une clause join permet de
> séparer explicitement ces deux aspects ce qui est plus clair plus les
> différentes formes de join offrent plus de possibilités.
>
> La première forme ne devrait plus être utilisée (à vérifier mais je me
> demande d'ailleurs si la première forme n'est pas indiquée dans la doc
> SQL Server comme pouvant ne plus être supportée ultérieurement ou
> le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois
> qq chose comme cela).
effectivement *= n'est plus supporté à partir de 2005. En fait cette
syntaxe donnait des résultats faux par rapport à la norme SQL et au
principe de jointure externe.
Voici le pourquoi de l'emploi des JOIN que je donne dans mon site SQlpro
(http://sqlpro.developpez.com/cours/sqlaz/jointures/#L1.2)
"
UN CONSEIL IMPORTANT
Dans la mesure du possible, utilisez toujours un opérateur de jointure
normalisé Sql2 (mot clef JOIN).
En effet :
* Les jointures faites dans la clause WHERE (ancienne syntaxe de
1986 !) ne permettent pas de faire la distinction de prime abord entre
ce qui relève du filtrage et ce qui relève de la jointure.
* Il est à priori absurde de vouloir filtrer dans le WHERE (ce qui
restreint les données du résultat) et de voiloir "élargir" ce résultat
par une jointure dans la même clause WHERE de filtrage.
* La lisibilité des requêtes est plus grande en utilisant la
syntaxe à base de JOIN, en isolant ce qui est du filtrage et de la
jointure, mais aussi en isolant avec clarté chaque condition de
jointures entre chaque couples de table.
* L'optimisation d'exécution de la requête est souvent plus pointue
du fait de l'utilisation du JOIN.
* Lorsque l'on utilise l'ancienne syntaxe et que l'on supprime la
clause WHERE a des fins de tests, le moteur SQL réalise le produit
cartésiens des tables ce qui revient la plupart du temps à mettre à
genoux le serveur !
"
A +
>
> --
> Patrice
>
>
> "jerome" a écrit dans le message de news:
> Os6CDz$
>> Bonjour,
>>
>> Je me pose une question (pour l'instant) :
>> Existe t-il une différence de traitement et d'exécution entre un where
>> un
>> inner join ?
>>
>> select * from table1 t1, table2 t2 where t1.id = t2.id
>> select * from table1 t1 inner join table2 t2 on t1.id = t2.id
>>
>> Quelle est la différence ?
>>
>> Merci
>>
>>
>
>
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
*********************** http://www.sqlspot.com *************************
Merci,
Donc la requete TJ1.COL1 = TJ2.COL1 AND TJ1.COL2 = 'taratata' and 1=0
retournerait le meme jeu de résultat avec des OR suivant la méthode
d'évaluation que vous décrivez
"Fred BROUARD" wrote in message
news:Patrice a écrit :
> La première syntaxe est obsolète depuis pas mal de temps : elle
> laissait
une> possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
> where et ceux qui relèvent du join. En plus une clause join permet de
> séparer explicitement ces deux aspects ce qui est plus clair plus les
> différentes formes de join offrent plus de possibilités.
>
> La première forme ne devrait plus être utilisée (à vérifier mais je me
> demande d'ailleurs si la première forme n'est pas indiquée dans la doc
de> SQL Server comme pouvant ne plus être supportée ultérieurement ou
peut-être> le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois
avoir vu> qq chose comme cela).
effectivement *= n'est plus supporté à partir de 2005. En fait cette
syntaxe donnait des résultats faux par rapport à la norme SQL et au
principe de jointure externe.
Voici le pourquoi de l'emploi des JOIN que je donne dans mon site SQlpro
(http://sqlpro.developpez.com/cours/sqlaz/jointures/#L1.2)
"
UN CONSEIL IMPORTANT
Dans la mesure du possible, utilisez toujours un opérateur de jointure
normalisé Sql2 (mot clef JOIN).
En effet :
* Les jointures faites dans la clause WHERE (ancienne syntaxe de
1986 !) ne permettent pas de faire la distinction de prime abord entre
ce qui relève du filtrage et ce qui relève de la jointure.
* Il est à priori absurde de vouloir filtrer dans le WHERE (ce qui
restreint les données du résultat) et de voiloir "élargir" ce résultat
par une jointure dans la même clause WHERE de filtrage.
* La lisibilité des requêtes est plus grande en utilisant la
syntaxe à base de JOIN, en isolant ce qui est du filtrage et de la
jointure, mais aussi en isolant avec clarté chaque condition de
jointures entre chaque couples de table.
* L'optimisation d'exécution de la requête est souvent plus pointue
du fait de l'utilisation du JOIN.
* Lorsque l'on utilise l'ancienne syntaxe et que l'on supprime la
clause WHERE a des fins de tests, le moteur SQL réalise le produit
cartésiens des tables ce qui revient la plupart du temps à mettre à
genoux le serveur !
"
A +
>
> --
> Patrice
>
>
> "jerome" a écrit dans le message de news:
> Os6CDz$
>> Bonjour,
>>
>> Je me pose une question (pour l'instant) :
>> Existe t-il une différence de traitement et d'exécution entre un where
et>> un
>> inner join ?
>>
>> select * from table1 t1, table2 t2 where t1.id = t2.id
>> select * from table1 t1 inner join table2 t2 on t1.id = t2.id
>>
>> Quelle est la différence ?
>>
>> Merci
>>
>>
>
>
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
*********************** http://www.sqlspot.com *************************
Merci,
Donc la requete TJ1.COL1 = TJ2.COL1 AND TJ1.COL2 = 'taratata' and 1=0
retournerait le meme jeu de résultat avec des OR suivant la méthode
d'évaluation que vous décrivez
"Fred BROUARD" <brouardf@club-internet.fr> wrote in message
news:u9MAwJBOIHA.2208@TK2MSFTNGP06.phx.gbl...
Patrice a écrit :
> La première syntaxe est obsolète depuis pas mal de temps : elle
> laissait
une
> possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
> where et ceux qui relèvent du join. En plus une clause join permet de
> séparer explicitement ces deux aspects ce qui est plus clair plus les
> différentes formes de join offrent plus de possibilités.
>
> La première forme ne devrait plus être utilisée (à vérifier mais je me
> demande d'ailleurs si la première forme n'est pas indiquée dans la doc
de
> SQL Server comme pouvant ne plus être supportée ultérieurement ou
peut-être
> le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois
avoir vu
> qq chose comme cela).
effectivement *= n'est plus supporté à partir de 2005. En fait cette
syntaxe donnait des résultats faux par rapport à la norme SQL et au
principe de jointure externe.
Voici le pourquoi de l'emploi des JOIN que je donne dans mon site SQlpro
(http://sqlpro.developpez.com/cours/sqlaz/jointures/#L1.2)
"
UN CONSEIL IMPORTANT
Dans la mesure du possible, utilisez toujours un opérateur de jointure
normalisé Sql2 (mot clef JOIN).
En effet :
* Les jointures faites dans la clause WHERE (ancienne syntaxe de
1986 !) ne permettent pas de faire la distinction de prime abord entre
ce qui relève du filtrage et ce qui relève de la jointure.
* Il est à priori absurde de vouloir filtrer dans le WHERE (ce qui
restreint les données du résultat) et de voiloir "élargir" ce résultat
par une jointure dans la même clause WHERE de filtrage.
* La lisibilité des requêtes est plus grande en utilisant la
syntaxe à base de JOIN, en isolant ce qui est du filtrage et de la
jointure, mais aussi en isolant avec clarté chaque condition de
jointures entre chaque couples de table.
* L'optimisation d'exécution de la requête est souvent plus pointue
du fait de l'utilisation du JOIN.
* Lorsque l'on utilise l'ancienne syntaxe et que l'on supprime la
clause WHERE a des fins de tests, le moteur SQL réalise le produit
cartésiens des tables ce qui revient la plupart du temps à mettre à
genoux le serveur !
"
A +
>
> --
> Patrice
>
>
> "jerome" <jerome@hh.fr> a écrit dans le message de news:
> Os6CDz$NIHA.5524@TK2MSFTNGP05.phx.gbl...
>> Bonjour,
>>
>> Je me pose une question (pour l'instant) :
>> Existe t-il une différence de traitement et d'exécution entre un where
et
>> un
>> inner join ?
>>
>> select * from table1 t1, table2 t2 where t1.id = t2.id
>> select * from table1 t1 inner join table2 t2 on t1.id = t2.id
>>
>> Quelle est la différence ?
>>
>> Merci
>>
>>
>
>
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
*********************** http://www.sqlspot.com *************************
Merci,
Donc la requete TJ1.COL1 = TJ2.COL1 AND TJ1.COL2 = 'taratata' and 1=0
retournerait le meme jeu de résultat avec des OR suivant la méthode
d'évaluation que vous décrivez
"Fred BROUARD" wrote in message
news:Patrice a écrit :
> La première syntaxe est obsolète depuis pas mal de temps : elle
> laissait
une> possible ambiguïté sur l'ordre d'exécution des critères qui relèvent du
> where et ceux qui relèvent du join. En plus une clause join permet de
> séparer explicitement ces deux aspects ce qui est plus clair plus les
> différentes formes de join offrent plus de possibilités.
>
> La première forme ne devrait plus être utilisée (à vérifier mais je me
> demande d'ailleurs si la première forme n'est pas indiquée dans la doc
de> SQL Server comme pouvant ne plus être supportée ultérieurement ou
peut-être> le *= qui est d'ores et déjà inutilisable, à vérifier mais je crois
avoir vu> qq chose comme cela).
effectivement *= n'est plus supporté à partir de 2005. En fait cette
syntaxe donnait des résultats faux par rapport à la norme SQL et au
principe de jointure externe.
Voici le pourquoi de l'emploi des JOIN que je donne dans mon site SQlpro
(http://sqlpro.developpez.com/cours/sqlaz/jointures/#L1.2)
"
UN CONSEIL IMPORTANT
Dans la mesure du possible, utilisez toujours un opérateur de jointure
normalisé Sql2 (mot clef JOIN).
En effet :
* Les jointures faites dans la clause WHERE (ancienne syntaxe de
1986 !) ne permettent pas de faire la distinction de prime abord entre
ce qui relève du filtrage et ce qui relève de la jointure.
* Il est à priori absurde de vouloir filtrer dans le WHERE (ce qui
restreint les données du résultat) et de voiloir "élargir" ce résultat
par une jointure dans la même clause WHERE de filtrage.
* La lisibilité des requêtes est plus grande en utilisant la
syntaxe à base de JOIN, en isolant ce qui est du filtrage et de la
jointure, mais aussi en isolant avec clarté chaque condition de
jointures entre chaque couples de table.
* L'optimisation d'exécution de la requête est souvent plus pointue
du fait de l'utilisation du JOIN.
* Lorsque l'on utilise l'ancienne syntaxe et que l'on supprime la
clause WHERE a des fins de tests, le moteur SQL réalise le produit
cartésiens des tables ce qui revient la plupart du temps à mettre à
genoux le serveur !
"
A +
>
> --
> Patrice
>
>
> "jerome" a écrit dans le message de news:
> Os6CDz$
>> Bonjour,
>>
>> Je me pose une question (pour l'instant) :
>> Existe t-il une différence de traitement et d'exécution entre un where
et>> un
>> inner join ?
>>
>> select * from table1 t1, table2 t2 where t1.id = t2.id
>> select * from table1 t1 inner join table2 t2 on t1.id = t2.id
>>
>> Quelle est la différence ?
>>
>> Merci
>>
>>
>
>
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
*********************** http://www.sqlspot.com *************************