Différence entre la jointure naturelle et la jointure interne

Quelle est la différence entre une jointure naturelle et une jointure interne?

Une différence significative entre INNER JOIN et NATURAL JOIN est le nombre de colonnes renvoyées.

Considérer:

TableA                           TableB
+------------+----------+        +--------------------+    
|Column1     | Column2  |        |Column1  |  Column3 |
+-----------------------+        +--------------------+
| 1          |  2       |        | 1       |   3      |
+------------+----------+        +---------+----------+

Le INNER JOINde TableA et TableB sur Colonne1 sera de retour

SELECT * FROM TableA AS a INNER JOIN TableB AS b USING (Column1);
SELECT * FROM TableA AS a INNER JOIN TableB AS b ON a.Column1 = b.Column1;

+------------+-----------+---------------------+    
| a.Column1  | a.Column2 | b.Column1| b.Column3|
+------------------------+---------------------+
| 1          |  2        | 1        |   3      |
+------------+-----------+----------+----------+

Le NATURAL JOINde TableA et TableB sur Colonne1 renverra:

SELECT * FROM TableA NATURAL JOIN TableB
+------------+----------+----------+    
|Column1     | Column2  | Column3  |
+-----------------------+----------+
| 1          |  2       |   3      |
+------------+----------+----------+

La colonne répétée est évitée.

(AFAICT de la grammaire standard, vous ne pouvez pas spécifier les colonnes de jointure dans une jointure naturelle; la jointure est strictement basée sur le nom. Voir aussi Wikipedia .)

( Il y a un tricheur dans la sortie jointure interne, la a.et les b.parties ne seraient pas dans les noms de colonnes, vous souhaitez simplement avoir column1, column2, column1, column3comme les rubriques. )

• Une jointure interne est celle où la ligne correspondante dans la table jointe est requise pour qu'une ligne de la première table soit renvoyée
• Une jointure externe est une jointure dans laquelle la ligne correspondante dans la table jointe n'est pas requise pour qu'une ligne de la première table soit renvoyée
• Une jointure naturelle est une jointure (vous pouvez avoir l'un natural leftou l' autre natural right) qui suppose que les critères de jointure correspondent aux colonnes du même nom dans les deux tables.

J'éviterais d'utiliser des jointures naturelles comme la peste, car les jointures naturelles sont:

• pas standard SQL [SQL 92] et donc pas portable, pas particulièrement lisible (par la plupart des codeurs SQL) et éventuellement non pris en charge par divers outils / bibliothèques
• non informatif; vous ne pouvez pas dire sur quelles colonnes sont jointes sans faire référence au schéma
• vos conditions de jointure sont invisiblement vulnérables aux modifications de schéma - s'il existe plusieurs colonnes de jointure naturelles et qu'une de ces colonnes est supprimée d'une table, la requête s'exécutera toujours, mais probablement pas correctement et ce changement de comportement sera silencieux
• ne vaut guère l'effort; vous économisez seulement environ 10 secondes de frappe

Une jointure naturelle n'est qu'un raccourci pour éviter de taper, avec la présomption que la jointure est simple et correspond aux champs du même nom.

SELECT
  *
FROM
  table1
NATURAL JOIN
  table2
    -- implicitly uses `room_number` to join

Est le même que...

SELECT
  *
FROM
  table1
INNER JOIN
  table2
    ON table1.room_number = table2.room_number

Ce que vous ne pouvez pas faire avec le format de raccourci, cependant, c'est des jointures plus complexes ...

SELECT
  *
FROM
  table1
INNER JOIN
  table2
    ON (table1.room_number = table2.room_number)
    OR (table1.room_number IS NULL AND table2.room_number IS NULL)

SQL n'est pas fidèle au modèle relationnel à bien des égards. Le résultat d'une requête SQL n'est pas une relation car elle peut avoir des colonnes avec des noms en double, des colonnes `` anonymes '' (sans nom), des lignes en double, des valeurs nulles, etc. SQL ne traite pas les tables comme des relations car elle repose sur l'ordre des colonnes, etc.

L'idée NATURAL JOINsous-jacente à SQL est de faciliter la fidélité au modèle relationnel. Le résultat de l'une NATURAL JOINdes deux tables aura des colonnes dédoublonnées par nom, donc pas de colonnes anonymes. De même, UNION CORRESPONDINGet EXCEPT CORRESPONDINGsont fournis pour répondre à la dépendance de SQL sur l'ordre des colonnes dans la UNIONsyntaxe existante .

Cependant, comme pour toutes les techniques de programmation, la discipline doit être utile. Une condition pour réussir NATURAL JOINest des colonnes nommées de manière cohérente, car les jointures sont implicites sur des colonnes avec les mêmes noms (il est dommage que la syntaxe pour renommer les colonnes en SQL soit verbeuse mais l'effet secondaire est d'encourager la discipline lors du nommage des colonnes dans les tables de base et VIEWs :)

Notez qu'un SQL NATURAL JOINest une équi-jointure **, mais ce n'est pas un obstacle à l'utilité. Considérez que si NATURAL JOINle seul type de jointure était pris en charge dans SQL, il serait toujours relationnellement complet .

S'il est en effet vrai que tout NATURAL JOINpeut être écrit à l'aide de INNER JOINet projection ( SELECT), il est également vrai que tout INNER JOINpeut être écrit à l'aide de product ( CROSS JOIN) et restriction ( WHERE); notez en outre qu'un NATURAL JOINentre tableaux sans nom de colonne en commun donnera le même résultat que CROSS JOIN. Donc, si vous êtes uniquement intéressé par les résultats qui sont des relations (et pourquoi jamais?!), NATURAL JOINC'est le seul type de jointure dont vous avez besoin. Bien sûr, il est vrai que dans une perspective de conception de langage, les raccourcis tels que INNER JOINet CROSS JOINont leur valeur, mais considèrent également que presque toutes les requêtes SQL peuvent être écrites de 10 manières syntaxiquement différentes, mais sémantiquement équivalentes, et c'est ce qui rend les optimiseurs SQL si durs développer.

Voici quelques exemples de requêtes (utilisant la base de données de pièces et fournisseurs habituelles ) qui sont sémantiquement équivalentes:

SELECT *
  FROM S NATURAL JOIN SP;

-- Must disambiguate and 'project away' duplicate SNO attribute
SELECT S.SNO, SNAME, STATUS, CITY, PNO, QTY
  FROM S INNER JOIN SP 
          USING (SNO);                        

-- Alternative projection
SELECT S.*, PNO, QTY
  FROM S INNER JOIN SP 
          ON S.SNO = SP.SNO;

-- Same columns, different order == equivalent?!
SELECT SP.*, S.SNAME, S.STATUS, S.CITY
  FROM S INNER JOIN SP 
      ON S.SNO = SP.SNO;

-- 'Old school'
SELECT S.*, PNO, QTY
  FROM S, SP 
 WHERE S.SNO = SP.SNO;

** La jointure relationnelle naturelle n'est pas une équijoin, c'est une projection d'une. - philipxy

Une NATURALjointure est juste une syntaxe courte pour une jointure spécifique INNER - ou "équi-jointure" - et, une fois la syntaxe déployée, les deux représentent la même opération d'algèbre relationnelle. Ce n'est pas un "type différent" de jointure, comme dans le cas de OUTER( LEFT/ RIGHT) ou de CROSSjointures.

Voir la section equi-join sur Wikipedia:

Une jointure naturelle offre une spécialisation supplémentaire des équi-jointures. Le prédicat de jointure survient implicitement en comparant toutes les colonnes des deux tables qui ont les mêmes noms de colonne dans les tables jointes. La table jointe résultante contient une seule colonne pour chaque paire de colonnes portant le même nom.

La plupart des experts conviennent que les JOINTS NATURELS sont dangereux et déconseillent donc fortement leur utilisation. Le danger vient de l'ajout par inadvertance d'une nouvelle colonne, nommée de la même manière qu'une autre colonne ...

Autrement dit, toutes les NATURALjointures peuvent être écrites sous forme de INNERjointures (mais l'inverse n'est pas vrai). Pour ce faire, il suffit de créer le prédicat explicitement - par exemple USINGou ON- et, comme l'a souligné Jonathan Leffler, sélectionnez les colonnes de l'ensemble de résultats souhaitées pour éviter les "doublons" si vous le souhaitez.

Codage heureux.

(Le NATURALmot-clé peut également être appliqué à LEFTet RIGHTjointures, et la même chose s'applique. Une NATURAL LEFT/RIGHTjointure n'est qu'une courte syntaxe pour une jointure spécifique LEFT/RIGHT .)

Jointure naturelle: c'est la combinaison ou le résultat combiné de toutes les colonnes des deux tables. Il renverra toutes les lignes de la première table par rapport à la deuxième table.

Jointure interne: cette jointure fonctionnera sauf si l'un des noms de colonne doit être sxame dans deux tables

Une jointure naturelle est l'endroit où 2 tables sont jointes sur la base de toutes les colonnes communes.

colonne commune: est une colonne qui a le même nom dans les deux tables + a des types de données compatibles dans les deux tables. Vous ne pouvez utiliser que l'opérateur =

Une jointure interne est l'endroit où 2 tables sont jointes sur la base des colonnes communes mentionnées dans la clause ON.

colonne commune: est une colonne qui a des types de données compatibles dans les deux tables mais qui n'a pas besoin d'avoir le même nom. Vous ne pouvez utiliser que tout opérateur comme comparision =, <=, >=, <, >,<>

la différence est que dans la jointure interne (equi / default) et la jointure naturelle qui, dans la victoire de la colonne commune natuarl join, seront affichées en une seule fois, mais la jointure interne / equi / default / simple la colonne commune sera affichée en double.

La jointure interne et la jointure naturelle sont presque identiques, mais il existe une légère différence entre elles. La différence est dans la jointure naturelle, pas besoin de spécifier de condition mais dans la condition de jointure interne est obligatoire. Si nous spécifions la condition dans la jointure interne, les tables résultantes sont comme un produit cartésien.

mysql> SELECT  * FROM tb1 ;
+----+------+
| id | num  |
+----+------+
|  6 |   60 |
|  7 |   70 |
|  8 |   80 |
|  1 |    1 |
|  2 |    2 |
|  3 |    3 |
+----+------+
6 rows in set (0.00 sec)

mysql> SELECT  * FROM tb2 ;
+----+------+
| id | num  |
+----+------+
|  4 |   40 |
|  5 |   50 |
|  9 |   90 |
|  1 |    1 |
|  2 |    2 |
|  3 |    3 |
+----+------+
6 rows in set (0.00 sec)

JOINTURE INTERNE :

mysql> SELECT  * FROM tb1 JOIN tb2 ; 
+----+------+----+------+
| id | num  | id | num  |
+----+------+----+------+
|  6 |   60 |  4 |   40 |
|  7 |   70 |  4 |   40 |
|  8 |   80 |  4 |   40 |
|  1 |    1 |  4 |   40 |
|  2 |    2 |  4 |   40 |
|  3 |    3 |  4 |   40 |
|  6 |   60 |  5 |   50 |
|  7 |   70 |  5 |   50 |
|  8 |   80 |  5 |   50 |
.......more......
return 36 rows in set (0.01 sec) 
AND NATURAL JOIN :

    mysql> SELECT  * FROM tb1 NATURAL JOIN tb2 ;
    +----+------+
    | id | num  |
    +----+------+
    |  1 |    1 |
    |  2 |    2 |
    |  3 |    3 |
    +----+------+
    3 rows in set (0.01 sec)

Jointure interne, joignez deux tables dont le nom de colonne est identique.

Jointure naturelle, joignez deux tables où le nom de la colonne et les types de données sont identiques.