Format de jointure SQL - jointures internes imbriquées

J'ai l'instruction SQL suivante dans un système d'héritage, je suis refactoring. C'est un abrégé de la vue pour les fins de cette question, juste de retour de count(*) pour le moment.

SELECT COUNT(*)
FROM Table1 
    INNER JOIN Table2 
        INNER JOIN Table3 ON Table2.Key = Table3.Key AND Table2.Key2 = Table3.Key2 
    ON Table1.DifferentKey = Table3.DifferentKey

Il est de la génération d'un très grand nombre d'enregistrements et de tuer le système, mais quelqu'un pourrait-il expliquer la syntaxe? Et cela peut-il être exprimé d'une autre manière?

Table1 contient 419 lignes
Table2 contient 3374 lignes
Tableau3 contient 28182 lignes

EDIT:

Suggéré reformater

SELECT COUNT(*)
FROM Table1 
    INNER JOIN Table3
          ON Table1.DifferentKey = Table3.DifferentKey
    INNER JOIN Table2 
          ON Table2.Key = Table3.Key AND Table2.Key2 = Table3.Key2

source d'informationauteur Tim Peel

16

Pour des raisons de lisibilité, j'ai restructuré la requête... en commençant par l'apparente le plus haut niveau de la Table1, puis des liens Tableau3, puis tableau3 liens à la table2. Beaucoup plus facile à suivre si vous suivez la chaîne de relations.

Maintenant, pour répondre à votre question. Vous êtes l'obtention d'un grand compte comme le résultat d'un produit Cartésien. Pour chaque enregistrement de la table 1 qui correspond Tableau3 vous aurez X * Y. Ensuite, pour chaque match entre tableau3 et Table2 aura le même effet... Y * Z, de Sorte que votre résultat pour juste une ID dans le tableau 1 peut avoir X * Y * Z des dossiers.

Ceci est basé sur ne sachant pas comment la normalisation ou de contenu pour vos tables... si la clé est une clé PRIMAIRE ou pas..
```
Ex:
Table 1       
DiffKey    Other Val
1          X
1          Y
1          Z

Table 3
DiffKey   Key    Key2  Tbl3 Other
1         2      6     V
1         2      6     X
1         2      6     Y
1         2      6     Z

Table 2
Key    Key2   Other Val
2      6      a
2      6      b
2      6      c
2      6      d
2      6      e
```
Ainsi, le Tableau 1 de se joindre à la Table 3 résultat (dans ce scénario) avec 12 disques (dans chaque 1 joint avec chaque 3). Puis, tout ce qui, de nouveau, les temps de chaque enregistrement existant dans le tableau 2 (5 dossiers)... au total 60 ( 3 tbl1 * 4 tbl3 * 5 tbl2 )le comte serait renvoyé.

Donc, maintenant, de prendre et de développer basé sur votre 1000 enregistrements et vous voyez comment foiré en place de la structure pourrait s'étouffer une vache (pour ainsi dire) et de tuer les performances.
```
SELECT
      COUNT(*)
   FROM
      Table1 
         INNER JOIN Table3
            ON Table1.DifferentKey = Table3.DifferentKey
            INNER JOIN Table2
               ON Table3.Key =Table2.Key
               AND Table3.Key2 = Table2.Key2 
```
11

Puisque vous avez déjà reçu de l'aide sur la requête, je vais prendre un poke à votre syntaxe question:

La première requête emploie certains moins connus ANSI SQL syntaxe qui permet d'imbriquer des jointures entre les join et on clauses. Cela vous permet de portée/tier vos jointures et probablement ouvre une foule d'autres mal, arcanes choses.

Dès maintenant, alors que la jointure imbriquée ne peut pas se référer à une valeur plus élevée dans la jointure de la hiérarchie de son parent immédiat, se joint au-dessus ou en dehors de la branche peut reportez-vous à... ce qui est précisément ce que ce vilain petit gars est en train de faire:
```
select
 count(*)
from Table1 as t1
join Table2 as t2
    join Table3 as t3
    on t2.Key = t3.Key                   -- join #1
    and t2.Key2 = t3.Key2 
on t1.DifferentKey = t3.DifferentKey     -- join #2  
```
Cela ressemble un peu à confusion, car join #2 est de rejoindre t1 à t2 sans spécifiquement référence au t2... cependant, il référence t2 indirectement via t3 -que t3 est joint à t2 en join #1. Bien que cela puisse fonctionner, vous pouvez trouver la suite un peu plus (visuellement) linéaire et attrayant:
```
select
 count(*)
from Table1 as t1
    join Table3 as t3
        join Table2 as t2
        on t2.Key = t3.Key                   -- join #1
        and t2.Key2 = t3.Key2   
    on t1.DifferentKey = t3.DifferentKey     -- join #2
```
Personnellement, j'ai trouvé que l'imbrication dans ce mode conserve mes déclarations en ordre en présentant chaque niveau de la relation de hiérarchie. Comme une note de côté, vous n'avez pas besoin de spécifier intérieure. rejoindre est implicitement intérieure sauf s'il est explicitement mention contraire.

Vous devez vous connecter pour publier un commentaire.