Verschil tussen natuurlijke join en inner join

Wat is het verschil tussen een natuurlijke join en een inner join?

Antwoord 1, autoriteit 100%

Een significant verschil tussen INNER JOIN en NATURAL JOIN is het aantal geretourneerde kolommen.

Overweeg:

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

De INNER JOINvan TabelA en TabelB op Kolom1 zal terugkeren

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      |
+------------+-----------+----------+----------+

De NATURAL JOINvan TabelA en TabelB op Kolom1 zal terugkeren:

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

De herhaalde kolom wordt vermeden.

(AFAICT uit de standaardgrammatica, u kunt de join-kolommen niet specificeren in een natuurlijke join; de join is strikt op naam gebaseerd. Zie ook Wikipedia.)

(Er zit een cheat in de uitvoer van de inner join; de delen a.en b.zouden niet in de kolomnamen staan; column1, column2, column1, column3als de kopjes.)

Antwoord 2, autoriteit 34%

• Een innerlijkejoin is een join waarbij de overeenkomende rij in de samengevoegde tabel vereist is om een rij uit de eerste tabel te retourneren
• Een outerjoin is een join waarbij de overeenkomende rij in de samengevoegde tabel nietvereist is om een rij uit de eerste tabel te retourneren
• Een natuurlijkejoin is een join (u kunt natural leftof natural righthebben) waarbij wordt aangenomen dat de join-criteria zijn waar hetzelfde -benoemde kolommen in beide tabellen komen overeen

Ik zou het gebruik van natuurlijke verbindingen vermijden als de pest, omdat natuurlijke verbindingen zijn:

• nietstandaard sql [SQL 92] en daarom nietdraagbaar, niet bijzonder leesbaar (door de meeste SQL-codeerders) en mogelijk niet ondersteund door verschillende tools/bibliotheken
• niet informatief; je kunt niet zien aan welke kolommen wordt toegevoegd zonder naar het schema te verwijzen
• uw join-voorwaarden zijn onzichtbaar kwetsbaar voor schemawijzigingen – als er meerdere natuurlijke join-kolommen zijn en één zo’n kolom wordt verwijderd uit een tabel, wordt de query nog steeds uitgevoerd, maar waarschijnlijk niet correct en zal deze gedragsverandering stil zijn

li>

• nauwelijks de moeite waard; je bespaart maar ongeveer 10 seconden typen

Antwoord 3, autoriteit 10%

Een natuurlijke join is slechts een sneltoets om typen te vermijden, met de veronderstelling dat de join eenvoudig is en overeenkomt met velden met dezelfde naam.

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

Is hetzelfde als…

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

Wat u echter niet kunt doen met het snelkoppelingsformaat, zijn complexere joins…

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)

Antwoord 4, autoriteit 6%

SQL is in veel opzichten niet trouw aan het relationele model. Het resultaat van een SQL-query is geen relatie omdat deze kolommen kan bevatten met dubbele namen, ‘anonieme’ (naamloze) kolommen, dubbele rijen, nulls, enz. SQL behandelt tabellen niet als relaties omdat het afhankelijk is van kolomvolgorde enz.

Het idee achter NATURAL JOINin SQL is om het gemakkelijker te maken om trouwer te zijn aan het relationele model. Het resultaat van de NATURAL JOINvan twee tabellen heeft kolommen die op naam zijn gededupliceerd, dus geen anonieme kolommen. Op dezelfde manier worden UNION CORRESPONDINGen EXCEPT CORRESPONDINGgeleverd om de afhankelijkheid van SQL van kolomvolgorde in de verouderde UNION-syntaxis aan te pakken.

Echter, zoals bij alle programmeertechnieken vereist het discipline om nuttig te zijn. Een vereiste voor een succesvolle NATURAL JOINis dat kolommen consequent worden genoemd, omdat joins worden geïmpliceerd voor kolommen met dezelfde naam (het is jammer dat de syntaxis voor het hernoemen van kolommen in SQL uitgebreid is, maar het neveneffect is dat moedig discipline aan bij het benoemen van kolommen in basistabellen en VIEWs 🙂

Let op: een SQL NATURAL JOINis een equi-join**, maar dit is geen belemmering voor het nut. Bedenk dat als NATURAL JOINhet enige join-type was dat in SQL wordt ondersteund, het nog steeds relationeel compleet.

Hoewel het inderdaad waar is dat elke NATURAL JOINkan worden geschreven met behulp van INNER JOINen projectie (SELECT), is het ook waar dat elke INNER JOINkan worden geschreven met product (CROSS JOIN) en beperking (WHERE); merk verder op dat een NATURAL JOINtussen tabellen zonder gemeenschappelijke kolomnamen hetzelfde resultaat zal geven als CROSS JOIN. Dus als je alleen geïnteresseerd bent in resultaten die relaties zijn (en waarom nooit?!), dan is NATURAL JOINhet enige join-type dat je nodig hebt. Natuurlijk is het waar dat vanuit het perspectief van taalontwerp steno’s zoals INNER JOINen CROSS JOINhun waarde hebben, maar bedenk ook dat bijna elke SQL-query kan worden geschreven in 10 syntactisch verschillende, maar semantisch gelijkwaardige manieren en dit is wat het zo moeilijk maakt om SQL-optimizers te ontwikkelen.

Hier zijn enkele voorbeeldquery’s (met behulp van de gebruikelijke onderdelen- en leveranciersdatabase) die semantisch zijn equivalent:

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;

** Relationele natuurlijke join is geen equijoin, het is een projectie van één. – philipxy

5

Natuurlijke join: het is een combinatie of gecombineerd resultaat van alle kolommen in de twee tabellen.
Het retourneert alle rijen van de eerste tafel met betrekking tot de tweede tabel.

Innerlijke join: deze join werkt, tenzij een van de kolomnaam SXAME in twee tabellen

is

6

Een natuurlijke join is waar 2 tafels worden verbonden op basis van alle gangbare kolommen.

Gemeenschappelijke kolom: is een kolom met dezelfde naam in beide tabellen + heeft compatibele datatypes in beide tabellen.
U kunt alleen = bediener

gebruiken

Er is een innerlijke joers waar 2 tabellen worden verbonden op basis van gemeenschappelijke kolommen die in de onderweg zijn vermeld.

Gemeenschappelijke kolom: is een kolom met compatibele datatypes in beide tabellen, maar hoeft niet dezelfde naam te hebben.
U kunt alleen elke vergelijkingsexploitant gebruiken zoals =, <=, >=, <, >, <>

7

Verschil is dat Int The Inner (EQUI / Default) join en natuurlijke join die in de Natuarl-lid worden in de gemeenschappelijke kolomwinst in één keer wordt weergegeven, maar innerlijk / Equi / Standaard / Simple Join De Common Column wordt display Double Time.

8

Inner join en natural join zijn bijna hetzelfde, maar er is een klein verschil tussen beide. Het verschil is dat bij natuurlijke join geen voorwaarde hoeft te worden opgegeven, maar bij inner join is de voorwaarde verplicht. Als we de voorwaarde specificeren in inner join , zijn de resulterende tabellen als een cartesiaans product.

Antwoord 9

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)

INNER JOIN:

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)

Antwoord 10

Inner join, join twee tabellen waarvan de kolomnaam hetzelfde is.

Natuurlijke samenvoeging, voeg twee tabellen samen waarbij de kolomnaam en gegevenstypen hetzelfde zijn.