Differenza tra un theta join, equijoin e natural join

Ho problemi a comprendere l'algebra relazionale quando si tratta di join theta, equijoins e join naturali. Qualcuno potrebbe aiutarmi a capirlo meglio? Se utilizzo il segno = su un join theta, è esattamente lo stesso che utilizzare un join naturale?

Un join theta consente relazioni di confronto arbitrarie (come ≥).

Un equijoin è un join theta che utilizza l'operatore di uguaglianza.

Un join naturale è un equijoin su attributi che hanno lo stesso nome in ogni relazione.

Inoltre, un join naturale rimuove le colonne duplicate coinvolte nel confronto di uguaglianza, quindi rimane solo 1 di ciascuna colonna confrontata; in termini algebrici relazionali approssimativi: ⋈ = πR,S-as ○ ⋈aR=aS

Mentre le risposte che spiegano le differenze esatte vanno bene, voglio mostrare come l'algebra relazionale viene trasformata in SQL e qual è il valore effettivo dei 3 concetti.

Il concetto chiave nella tua domanda è l'idea di un join. Per comprendere un join è necessario comprendere un prodotto cartesiano (l'esempio è basato su SQL dove l'equivalente è chiamato cross join come sottolinea un giorno quando);

Questo non è molto utile nella pratica. Considera questo esempio.

Product(PName, Price)
====================
Laptop,   1500
Car,      20000
Airplane, 3000000


Component(PName, CName, Cost)
=============================
Laptop, CPU,    500
Laptop, hdd,    300
Laptop, case,   700
Car,    wheels, 1000

Il prodotto cartesiano Prodotto x Componente sarà: muggito o violino sql . Puoi vedere che ci sono 12 righe = 3 x 4. Ovviamente righe come "Laptop" con "ruote" non hanno alcun significato, ecco perché in pratica il prodotto cartesiano è usato raramente.

|    PNAME |   PRICE |  CNAME | COST |
--------------------------------------
|   Laptop |    1500 |    CPU |  500 |
|   Laptop |    1500 |    hdd |  300 |
|   Laptop |    1500 |   case |  700 |
|   Laptop |    1500 | wheels | 1000 |
|      Car |   20000 |    CPU |  500 |
|      Car |   20000 |    hdd |  300 |
|      Car |   20000 |   case |  700 |
|      Car |   20000 | wheels | 1000 |
| Airplane | 3000000 |    CPU |  500 |
| Airplane | 3000000 |    hdd |  300 |
| Airplane | 3000000 |   case |  700 |
| Airplane | 3000000 | wheels | 1000 |

I JOIN sono qui per aggiungere più valore a questi prodotti. Quello che vogliamo veramente è "unire" il prodotto con i suoi componenti associati, perché ogni componente appartiene a un prodotto. Il modo per farlo è con un join:

Prodotto JOIN Componente ON Pname

La query SQL associata sarebbe così (puoi giocare con tutti gli esempi qui )

SELECT *
FROM Product
JOIN Component
  ON Product.Pname = Component.Pname

e il risultato:

|  PNAME | PRICE |  CNAME | COST |
----------------------------------
| Laptop |  1500 |    CPU |  500 |
| Laptop |  1500 |    hdd |  300 |
| Laptop |  1500 |   case |  700 |
|    Car | 20000 | wheels | 1000 |

Si noti che il risultato ha solo 4 righe, perché il laptop ha 3 componenti, l'auto ne ha 1 e l'aereo nessuno. Questo è molto più utile.

Tornando alle tue domande, tutti i join di cui chiedi sono variazioni del JOIN che ho appena mostrato:

Natural Join = il join (la clausola ON) viene effettuato su tutte le colonne con lo stesso nome; rimuove le colonne duplicate dal risultato, a differenza di tutti gli altri join; la maggior parte dei DBMS (sistemi di database creati da vari fornitori come SQL Server di Microsoft, MySQL di Oracle ecc.) non si preoccupano nemmeno di supportarlo, è solo una cattiva pratica (o ha scelto di proposito di non implementarlo). Immagina che uno sviluppatore venga e cambi il nome della seconda colonna in Prodotto da Prezzo a Costo. Quindi tutti i join naturali verrebbero eseguiti su PName AND su Cost, risultando in 0 righe poiché nessun numero corrisponde.

Theta Join = questo è il join generale che tutti usano perché ti permette di specificare la condizione (la clausola ON in SQL). Puoi aderire praticamente a qualsiasi condizione tu voglia, ad esempio su Prodotti che hanno le prime 2 lettere simili o che hanno un prezzo diverso. In pratica, questo è raramente il caso: nel 95% dei casi ti unirai a una condizione di parità, il che ci porta a:

Equi Join = il più comune utilizzato nella pratica. L'esempio sopra è un equi join. I database sono ottimizzati per questo tipo di join! L'opposto di un equi join è un non-equi join, ovvero quando ti unisci a una condizione diversa da "=". I database non sono ottimizzati per questo! Entrambi sono sottoinsiemi del join theta generale. Anche il join naturale è un join theta ma la condizione (la theta) è implicita.

Fonte di informazioni: università + sviluppatore SQL Server certificato + recentemente completato il MOO "Introduzione ai database" di Stanford, quindi oso dire che ho in mente l'algebra relazionale.

La risposta di @ outis è buona: concisa e corretta nelle relazioni.

Tuttavia, la situazione è leggermente più complicata per quanto riguarda SQL.

Considera il solito database di fornitori e parti ma implementato in SQL:

SELECT * FROM S NATURAL JOIN SP;

restituirebbe un gruppo di risultati ** con colonne

SNO, SNAME, STATUS, CITY, PNO, QTY

Il join viene eseguita su colonna con lo stesso nome in entrambe le tabelle, SNO. Tieni presente che il gruppo di risultati ha sei colonne e contiene solo una colonna perSNO .

Consideriamo ora un eqijoin theta, in cui i nomi delle colonne per il join devono essere specificati esplicitamente (più le variabili di intervallo Se SPsono obbligatorie):

SELECT * FROM S JOIN SP ON S.SNO = SP.SNO;

Il gruppo di risultati avrà sette colonne, incluse due colonne per SNO. I nomi del set di risultati sono ciò che lo standard SQL definisce "dipendente dall'implementazione", ma potrebbe essere simile a questo:

SNO, SNAME, STATUS, CITY, SNO, PNO, QTY

o forse questo

S.SNO, SNAME, STATUS, CITY, SP.SNO, PNO, QTY

In altre parole, NATURAL JOINin SQL può essere considerato per rimuovere le colonne con i nomi duplicati dal gruppo di risultati (ma ahimè non rimuovere le righe duplicate - si devono ricordare ai cambiamenti SELECTa SELECT DISTINCTte stesso).

** Non so bene quale sia il risultato SELECT * FROM table_expression;. So che non è una relazione perché, tra le altre ragioni, può avere colonne con nomi duplicati o una colonna senza nome. So che non è un insieme perché, tra le altre ragioni, l'ordine delle colonne è significativo. Non è nemmeno una tabella SQL o un'espressione di tabella SQL. Lo chiamo un set di risultati.

Natural è un sottoinsieme di Equi che è un sottoinsieme di Theta.

Se uso il segno = su un join theta, è esattamente lo stesso che usare un join naturale ???

Non necessariamente, ma sarebbe un Equi. Naturale significa che stai facendo corrispondenze su tutte le colonne con nomi simili, Equi significa semplicemente che stai usando esclusivamente "=" (e non "meno di", come, ecc.)

Questo è puramente accademico, potresti lavorare con database relazionali per anni e non sentire mai nessuno usare questi termini.

Theta Join: quando si effettua una query per il join utilizzando un qualsiasi operatore, (ad esempio, =, <,>,> = ecc.), La query di join rientra nel join Theta.

Equi Join: quando esegui una query per il join utilizzando solo l'operatore di uguaglianza, tale query di join rientra in Equi join.

Esempio:

> SELEZIONA * DA Emp JOIN Dept ON Emp.DeptID = Dept.DeptID;
> SELEZIONA * DA Emp INNER JOIN Dept USING (DeptID)

Questo mostrerà:
 _________________________________________________
| Emp.Name | Emp.DeptID | Dept.Name | Dept.DeptID |
| | | | |

Nota: Equi join è anche un join theta!

Natural Join: un tipo di Equi Join che si verifica implicitamente confrontando tutte le colonne con gli stessi nomi in entrambe le tabelle.

Nota: qui, il risultato del join ha solo una colonna per ogni coppia di colonne con lo stesso nome.

Esempio

 SELEZIONA * DA Emp NATURAL JOIN Dept

Questo mostrerà:
 _______________________________
| DeptID | Emp.Name | Dept.Name |
| | | |

Il prodotto cartesiano di due tabelle fornisce tutte le possibili combinazioni di tuple come nell'esempio in matematica il prodotto incrociato di due insiemi. poiché molte volte ci sono alcuni valori spazzatura che occupano spazio non necessario anche nella memoria, quindi qui vengono in soccorso i join che danno la combinazione dei soli valori di attributo che sono richiesti e sono significativi.

L'unione interna fornisce il campo ripetuto nella tabella due volte, mentre l'unione naturale qui risolve il problema semplicemente filtrando le colonne ripetute e visualizzandole solo una volta. Altrimenti, entrambi funzionano allo stesso modo. natural join è più efficiente poiché preserva la memoria. Inoltre, le ridondanze vengono rimosse nel natural join.

l'equi join di due tabelle sono tali da visualizzare solo le tuple che corrispondono al valore in un'altra tabella. ad esempio: siano new1 e new2 due tabelle. se la query sql seleziona * da new1 join new2 su new1.id = new.id (id è la stessa colonna in due tabelle), quindi inizia dalla tabella new2 e unisciti che corrisponde all'id nella seconda tabella. inoltre, non equi join non hanno operatori di uguaglianza che hanno <,> e operatore tra.

theta join è costituito da tutti gli operatori di confronto, inclusa l'uguaglianza e altri operatori di confronto <,>. quando utilizza l'operatore di uguaglianza (=) è noto come equi join.

Natural Join: Natural join può essere possibile quando è presente almeno un attributo comune in due relazioni.

Theta join: il theta join può essere possibile quando due agiscono in condizioni particolari.

Equi Join: Equi può essere possibile quando due agiscono a condizione di equità. È un tipo di join theta.