Quelle est la différence entre ces deux requêtes comme l'obtention de deux autre ensemble de résultats?

Il fait vraiment aucune différence lorsque vous faites cela dans la JOINTURE INTERNE.

Toutefois, lorsque vous utilisez les boutons GAUCHE ou DROIT de la REJOINDRE, il ne faire une différence, si vous mettez le filtre supplémentaire dans la JOINTURE ou dans la clause where.

Lorsque vous mettez le filtre dans la clause where SQL Server effectue la jointure, puis complètement filtre les lignes où le filtre ne correspond pas.

--> cela permettra de réduire le nombre de lignes qui sont retournés

Lorsque vous mettez le filtre dans la JOINTURE, SQL Server ne le filtrage lors de la rejoindre, mais seulement sur la table où vous mettez le filtre.

Vous obtenez toujours toutes les lignes dans les autres tables, mais seulement ceux qui ont les données de la table filtrée où le filtre s'adapte.

--> ce ne sera pas de réduire le nombre de lignes, mais les colonnes avec des données de la filteres tableau sera vide en plus de lignes

C'est difficile à expliquer...pour le rendre plus clair, voici un exemple:

Prendre l'exemple de données de RedFilter réponse:

CREATE TABLE [dbo].[t1](
    [ID] [int] NULL,
    [StatusID] [int] NULL
) ON [PRIMARY]
CREATE TABLE [dbo].[t2](
    [ID] [int] NULL
) ON [PRIMARY]
INSERT INTO t1 (ID, StatusID) VALUES (1, 10)
INSERT INTO t1 (ID, StatusID) VALUES (2, 11)
INSERT INTO t1 (ID, StatusID) VALUES (3, 12)
INSERT INTO t1 (ID, StatusID) VALUES (4, 12)
INSERT INTO t2 (ID) VALUES (1)
INSERT INTO t2 (ID) VALUES (3)
INSERT INTO t2 (ID) VALUES (5)

...et d'exécuter les requêtes suivantes:

/* this returns four rows, but only two will have data 
from the second table in the second column */
SELECT t1.ID, t2.ID
FROM t1 
LEFT JOIN t2 ON t1.Id = t2.Id 

/* this returns only one row: the one where t2.ID = 1 */
SELECT t1.ID, t2.ID
FROM t1 
LEFT JOIN t2 ON t1.Id = t2.Id 
WHERE t2.ID = 1 

/* this returns four rows as in the first query, but only one 
row will have data in the second column: the one where t2.ID = 1 */
SELECT t1.ID, t2.ID
FROM t1 
LEFT JOIN t2 ON t1.Id = t2.Id 
AND t2.ID = 1 

Note les différents résultats, comme indiqué dans les commentaires.

OriginalL'auteur Christian Specht

En regardant l'historique d'édition de la question, il semble que vos requêtes sont le long des lignes suivantes.

Requête De L'Une

  INNER JOIN dbo.T2
        ON ...
    LEFT OUTER  JOIN dbo.T3
        ON  ...
    WHERE 
     T3.col = somevalue AND ...

Requête De Deux

  INNER JOIN dbo.T2
        ON ...
    LEFT OUTER  JOIN dbo.T3
        ON  ... AND T3.col = somevalue
   WHERE 
        ... 

La différence entre eux est que la Requête de l'Un convertit efficacement les LEFT se Joindre à un INNER Rejoindre.

Pour une jointure externe gauche, conceptuellement, la suite se passe.

1. T2 est rejoint sur le T3 et le prédicat de la clause de jointure est évaluée.
2. Non les lignes correspondantes de T2 sont rajoutés avec des valeurs NULL pour les T3 valeurs de la colonne.
3. OÙ la clause est appliquée.

Aucun de ces lignes d'un ajout à l'étape 2 permettra de répondre à la T3.col = somevalue prédicat à l'étape 3 comme nous savons que la valeur de cette colonne pour l'ensemble de ces lignes est NULL.

OriginalL'auteur Martin Smith

La différence sous le capot, c'est que la clause where est accessible après toutes les jointures.

Cela signifie que peut-être, dans ce cas, il n'y a pas de différence, mais cela ne serait pas toujours vrai quand il y a plusieurs jointures. Ils pourraient être pris en compte de l'virtuel jeux de résultats (selon les circonstances) avant le OÙ est traitée.

De bien vouloir voir ce lien: http://blog.sqlauthority.com/2009/04/06/sql-server-logical-query-processing-phases-order-of-statement-execution/

OriginalL'auteur Mike Cheel