Comment SQL travailler?

Je suis en train d'essayer de comprendre comment se joint à travailler à l'interne. Quelle sera la différence entre la façon dont les deux requêtes suivantes irait?

For example

(A)

Select * 
FROM TABLE1
FULL JOIN TABLE2 ON TABLE1.ID = TABLE2.ID
FULL JOIN TABLE3 ON TABLE1.ID = TABLE3.ID

And

(B)

Select * 
FROM TABLE1
FULL JOIN TABLE2 ON TABLE1.ID = TABLE2.ID
FULL JOIN TABLE3 ON TABLE2.ID = TABLE3.ID

Edit: je parle d'oracle ici.
Considérons quelques enregistrements présents dans le tableau 2 et le tableau 3, mais pas dans le tableau 1, la requête A deux lignes pour le relevé, mais B ne donner qu'une seule ligne.

  • PLEIN est la même que EXTERNE COMPLÈTE. EXTÉRIEURE est ambigu (est-il de GAUCHE, de DROITE, ou PLEIN?) - mais la plupart vont l'interpréter pour être COMPLET.
  • Une jointure EXTERNE COMPLÈTE renvoie toutes les lignes des DEUX tables, avec des valeurs Null pour les colonnes d'une table qui ne correspondent pas aux critères de jointure. Comme une sorte de JOINTURE EXTERNE GAUCHE et une JOINTURE EXTERNE DROITE combinés.
InformationsquelleAutor MOZILLA | 2009-01-13
  1. 9

    Votre SGBD de l'optimiseur va déterminer la meilleure façon d'effectuer la requête. Habituellement, cela se fait par "coût de base de l'optimisation", où un certain nombre de différents plans de requête sont pris en considération et la plus efficace sélectionné. Si vos deux requêtes sont logiquement identiques, il est plus que probable que l'optimiseur finira par utiliser le même plan de requête selon la manière dont vous l'écrivez. En fait, ce serait une mauvaise utilisation de l'optimiseur de ces jours qui produit différents plans de requête basés sur de telles différences mineures dans le SQL.

    Toutefois, les jointures externes sont une autre affaire (dans Oracle au moins), puisque la manière dont les colonnes sont rejoints influence le résultat. c'est à dire les 2 requêtes sont pas interchangeables.

    Vous pouvez utiliser AUTOTRACE dans SQL Plus pour voir les différents plans:

    SQL> select *
2  from t1
3  full join t2 on t2.id = t1.id
4  full join t3 on t3.id = t2.id;
ID         ID         ID
---------- ---------- ----------
1          1
1 row selected.
Execution Plan
----------------------------------------------------------
---------------------------------------------------------------------
| Id  | Operation               | Name | Rows  | Bytes | Cost (%CPU)|
---------------------------------------------------------------------
|   0 | SELECT STATEMENT        |      |     3 |   117 |    29  (11)|
|   1 |  VIEW                   |      |     3 |   117 |    29  (11)|
|   2 |   UNION-ALL             |      |       |       |            |
|*  3 |    HASH JOIN OUTER      |      |     2 |   142 |    15  (14)|
|   4 |     VIEW                |      |     2 |    90 |    11  (10)|
|   5 |      UNION-ALL          |      |       |       |            |
|*  6 |       HASH JOIN OUTER   |      |     1 |    91 |     6  (17)|
|   7 |        TABLE ACCESS FULL| T1   |     1 |    52 |     2   (0)|
|   8 |        TABLE ACCESS FULL| T2   |     1 |    39 |     3   (0)|
|*  9 |       HASH JOIN ANTI    |      |     1 |    26 |     6  (17)|
|  10 |        TABLE ACCESS FULL| T2   |     1 |    13 |     3   (0)|
|  11 |        TABLE ACCESS FULL| T1   |     1 |    13 |     2   (0)|
|  12 |     TABLE ACCESS FULL   | T3   |     1 |    26 |     3   (0)|
|* 13 |    HASH JOIN ANTI       |      |     1 |    26 |    15  (14)|
|  14 |     TABLE ACCESS FULL   | T3   |     1 |    13 |     3   (0)|
|  15 |     VIEW                |      |     2 |    26 |    11  (10)|
|  16 |      UNION-ALL          |      |       |       |            |
|* 17 |       HASH JOIN OUTER   |      |     1 |    39 |     6  (17)|
|  18 |        TABLE ACCESS FULL| T1   |     1 |    26 |     2   (0)|
|  19 |        TABLE ACCESS FULL| T2   |     1 |    13 |     3   (0)|
|* 20 |       HASH JOIN ANTI    |      |     1 |    26 |     6  (17)|
|  21 |        TABLE ACCESS FULL| T2   |     1 |    13 |     3   (0)|
|  22 |        TABLE ACCESS FULL| T1   |     1 |    13 |     2   (0)|
---------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
3 - access("T3"."ID"(+)="T2"."ID")
6 - access("T2"."ID"(+)="T1"."ID")
9 - access("T2"."ID"="T1"."ID")
13 - access("T3"."ID"="T2"."ID")
17 - access("T2"."ID"(+)="T1"."ID")
20 - access("T2"."ID"="T1"."ID")
SQL> select *
2  from t1
3  full join t2 on t2.id = t1.id
4  full join t3 on t3.id = t1.id;
ID         ID         ID
---------- ---------- ----------
1
1
2 rows selected.
Execution Plan
----------------------------------------------------------
---------------------------------------------------------------------
| Id  | Operation               | Name | Rows  | Bytes | Cost (%CPU)|
---------------------------------------------------------------------
|   0 | SELECT STATEMENT        |      |     3 |   117 |    29  (11)|
|   1 |  VIEW                   |      |     3 |   117 |    29  (11)|
|   2 |   UNION-ALL             |      |       |       |            |
|*  3 |    HASH JOIN OUTER      |      |     2 |   142 |    15  (14)|
|   4 |     VIEW                |      |     2 |    90 |    11  (10)|
|   5 |      UNION-ALL          |      |       |       |            |
|*  6 |       HASH JOIN OUTER   |      |     1 |    91 |     6  (17)|
|   7 |        TABLE ACCESS FULL| T1   |     1 |    52 |     2   (0)|
|   8 |        TABLE ACCESS FULL| T2   |     1 |    39 |     3   (0)|
|*  9 |       HASH JOIN ANTI    |      |     1 |    26 |     6  (17)|
|  10 |        TABLE ACCESS FULL| T2   |     1 |    13 |     3   (0)|
|  11 |        TABLE ACCESS FULL| T1   |     1 |    13 |     2   (0)|
|  12 |     TABLE ACCESS FULL   | T3   |     1 |    26 |     3   (0)|
|* 13 |    HASH JOIN ANTI       |      |     1 |    26 |    15  (14)|
|  14 |     TABLE ACCESS FULL   | T3   |     1 |    13 |     3   (0)|
|  15 |     VIEW                |      |     2 |    26 |    11  (10)|
|  16 |      UNION-ALL          |      |       |       |            |
|* 17 |       HASH JOIN OUTER   |      |     1 |    39 |     6  (17)|
|  18 |        TABLE ACCESS FULL| T1   |     1 |    26 |     2   (0)|
|  19 |        TABLE ACCESS FULL| T2   |     1 |    13 |     3   (0)|
|* 20 |       HASH JOIN ANTI    |      |     1 |    26 |     6  (17)|
|  21 |        TABLE ACCESS FULL| T2   |     1 |    13 |     3   (0)|
|  22 |        TABLE ACCESS FULL| T1   |     1 |    13 |     2   (0)|
---------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
3 - access("T3"."ID"(+)="T1"."ID")
6 - access("T2"."ID"(+)="T1"."ID")
9 - access("T2"."ID"="T1"."ID")
13 - access("T3"."ID"="T1"."ID")
17 - access("T2"."ID"(+)="T1"."ID")
20 - access("T2"."ID"="T1"."ID")

    En fait, les plans de requête sont identiques, sauf pour le Prédicat de l'information

    • Ouais mais comment cela est excecuted permettrait également de déterminer le résultat que nous obtenons. Considérons quelques enregistrements présents dans le tableau 2 et le tableau 3, mais pas dans le tableau 1, la requête A deux lignes pour le relevé, mais B ne donner qu'une seule ligne.
    • La méthode d'exécution doit JAMAIS modifier les résultats finaux d'un correctement formé instruction SQL. Si c'est le cas, votre SGBD a un bug. La raison qu'ils vous donnent des résultats différents est parce qu'ils posent deux questions différentes.
    • C'est vrai, je n'avais pas pris note de mot-clé, je pensais à des jointures internes.
    InformationsquelleAutor Tony Andrews
  2. 5

    Vous avez déclaré d'intérêt pour les "internes", et a ensuite demandé un exemple qui illustre la "sémantique". Je vais répondre à la sémantique.

    Tenir compte de ces tables.

    Table1 : 1, 4, 6
Table2 : 2, 4, 5
Table3 : 3, 5, 6

    Les deux exemples effectuer la même la première, donc je vais effectuer ici.

    FirstResult = T1 FULL JOIN T2 : (T1, T2)
(1, null)
(4, 4)
(6, null)
(null, 2)
(null, 5)

    L'Exemple (A)

    FirstResult FULL JOIN T3 ON FirstItem : (T1, T2, T3)
(1, null, null)
(4, 4, null)
(6, null, 6)   <----
(null, 2, null)
(null, 5, null)   <----
(null, null, 3)

    L'Exemple (B)

    FirstResult FULL JOIN T3 ON SecondItem : (T1, T2, T3)
(1, null, null)
(4, 4, null)
(6, null, null)   <----
(null, 2, null)
(null, 5, 5)   <----
(null, null, 3)

    Cela vous montre logiquement la façon de produire les résultats de la rejoint.

    Pour "internals", il y a quelque chose qui s'appelle un optimiseur de requête, qui va produire les mêmes résultats, mais il fera de la mise en œuvre de choix à faire le calcul/io rapide. Ces choix incluent:

    • les tables pour accéder à la première
    • regarder dans un tableau à l'aide d'un index ou d'une table d'analyse
    • qui adhèrent à la mise en œuvre type d'utilisation (boucle imbriquée, de fusion, de hachage).

    Également note: en raison de l'optimiseur de faire ces choix, et la modification de ces choix sur la base de ce qu'il considère être optimale - l'ordre des résultats peut changer. L'ordre par défaut des résultats est toujours "ce qui est plus facile". Si vous ne voulez pas la valeur par défaut de la commande, vous devez spécifier la commande dans votre requête.

    Pour voir exactement ce que l'optimiseur de le faire avec une requête (à ce moment, car il peut changer d'avis), vous devez afficher le plan d'exécution.

    InformationsquelleAutor Amy B
  4. 0

    Avec Une requête à ce que vous obtenez des entrées dans le tableau 1 avec une entrée correspondante dans le tableau3 sans entrées correspondantes dans le tableau3 (les valeurs null pour les t2 colonnes)

    Avec la requête B uou n'obtenez pas les écritures, parce que vous allez seulement à tableau3 par le biais de table2. Si vous n'avez pas d'entrée correspondante dans la table2, la table2.id sera nulle et ne pourra jamais correspondre à un tableau3.id

    InformationsquelleAutor Gary Myers
  5. 0

    Pour la compréhension de Gauche à Droite/à les rejoindre, comment ils fonctionne Cochez cette

    InformationsquelleAutor Shantanu Gupta