Sei sulla pagina 1di 25

Lezione 14.

Decomposizioni che preservano le


dipendenze - Esercizi

Prof.ssa Maria De Marsico


demarsico@di.uniroma1.it

Parte del materiale è tratto dal materiale preparato dalla prof.ssa Moscarini per il canale A-L
Definizione!

• Definizione Sia R uno schema di relazione, F un insieme di dipendenze


funzionali su R e R1, R2,…, Rk una decomposizione di R.
• Diciamo che  preserva F se Fi=1k Ri (F),
• dove Ri (F) XY XY F+ XYRi.

2
Verifica

•Supponiamo di avere già una decomposizione e di voler verificare se


preserva le dipendenze funzionali.

•Verificare se una decomposizione preserva un insieme di dipendenze


funzionali F richiede che venga verificata l’equivalenza dei due insiemi di
dipendenze funzionali F e Gi=1k Ri (F) e quindi la doppia inclusione F+G+
e che F+G+.

•Nota: per come è stato definito G in questo caso, sarà sicuramente F+G
•Infatti G=i=1k Ri (F), dove Ri (F) XY XY F+ XYRi
•Ogni proiezione di F che viene inclusa per definizione in G è un
sottoinsieme di F+, quindi F+ contiene G (che ovviamente può anche essere
scritto come G F+) e per il lemma sulle chiusure questo implica che G+F+
(che ovviamente può anche essere scritto come F+G+)

•Per il Lemma sulle chiusure è sufficiente quindi verificare che FG+ (che poi
implica F+G+ )
3
Verifica

•La verifica che FG+ (che poi implica che F+G+ )


•può essere fatta con l’algoritmo che segue (la cui correttezza è una banale
conseguenza del Lemma sulla chiusura di un insieme di attributi e del
Teorema sull’uguaglianza F+=FA).
Algoritmo - contenimento di F in G+
•Input due insiemi F e G di dipendenze funzionali su R;
•Output la variabile successo (al termine avrà valore true se FG+ ,
false altrimenti) Lemma Siano R uno schema di relazione ed F
begin un insieme di dipendenze funzionali su R. Si ha
che: XYFA se e solo se Y X+.
successo:true;
for every XYF Teorema Siano R uno schema di relazione ed F
do begin un insieme di dipendenze funzionali su R. Si ha
F+ FA.
calcola X G;
+

if Y X+G then successo:false


end
end
• Se Y X+G allora XYGA per il lemma e quindi XYG+ per il Teorema4
• Basta verificare che anche una sola dipendenza non appartiene alla
chiusura di G per poter affermare che l’equivalenza non sussiste
Problema

• Come calcoliamo X+G?


• Se volessimo utilizzare l’Algoritmo già visto per il calcolo
della chiusura di un insieme di attributi, dovremmo prima
calcolare G …
• … ma, per la definizione di G, ciò richiede il calcolo di F+
che richiede tempo esponenziale.
• Presentiamo un algoritmo che permette di calcolare X+G a
partire da F.

5
Algoritmo
calcolo X+G a partire da F.
Algoritmo - X+G a partire da F.
•Input uno schema R, un insieme F di dipendenze funzionali su R, una
decomposizione R1, R2,…, Rk di R, un sottoinsieme X di R;
•Output la chiusura di X rispetto a Gi=1k Ri (F), (nella variabile Z);
begin Attenzione!!!
Z:X; L’intersezione ha priorità maggiore
S:; dell’unione, quindi Z Ri)+F Ri va
for i:1 to k calcolato prima dell’unione con S. Se si
inverte l’ordine delle operazioni
do S:S(Z Ri)+F Ri
da S potremmo eliminare ciò che non
while S Z rientra in Ri (perché è stato inserito in un
do passaggio precedente grazie alla
begin proiezione su un sottoschema senza
Z:ZS; intersezioni con Ri ) ma questo non
avrebbe senso perché in S stiamo
for i:1 to k
accumulando gli attributi che sono
do S: S (Z Ri) F Ri determinati funzionalmente da X anche se
+

end appartengono a sottoschemi diversi 6


end
Attenzione!

• L’algoritmo (per definizione di algoritmo …) termina


sempre!

• Il fatto che l’algoritmo termini non indica che una


dipendenza XY è preservata!

• Per verificare se XY è preservata, in base al Lemma


sulla chiusura di un insieme di attributi e in base al
Teorema sull’uguaglianza F+ FA , dobbiamo controllare
SE Y è contenuto nella copia finale della variabile Z (che
conterrà la chiusura di X rispetto a G, X+G )

7
Esempio 1

Dato il seguente schema di relazione


R = (A, B, C, D)
e il seguente insieme di dipendenze funzionali
F = { AB C, D C, D B, C B, D A }
dire se la decomposizione  = { ABC,ABD }
preserva le dipendenze in F
In base a quanto visto basta verificare che FG+ cioè che ogni
dipendenza funzionale in F si trova in G+
NOTA IMPORTANTE - In effetti è inutile controllare che vengano preservate
le dipendenze tali che l'unione delle parti destra e sinistra è contenuta
interamente in un sottoschema, perché secondo la definizione
Ri (F) XY XY F+ XYRi.
tali dipendenze fanno parte per definizione di G.
NOTA: Per come è strutturato l’algoritmo, a Z possono solo venire aggiunti
elementi (cioè non succede mai che un attributo venga eliminato da Z), quindi
quando Z arriva a contenere la parte destra della dipendenza possiamo
8
essere sicuri che la dipendenza stessa è preservata e sospendere il seguito
del procedimento (in un compito scritto questo fatto va giustificato).
Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

Menzionando esplicitamente l’osservazione riportata nella prima nota, basta


verificare che sia preservata la dipendenza D  C .
Z=D Attenzione!!!
Ovviamente ()+F= 
S= qualunque sia F!!!
ciclo for esterno sui sottoschemi ABC e ABD
S = S  (D  ABC)+F ABC =   ()+F ABC =   ABC = 
S = S  (D  ABD)+F ABD = S  (D)+F ABD … (continua)
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo (D)+F = DCBA

… (continua) S = S  (D)+F ABD =   DCBA  ABD = ABD

prima l’intersezione!  X = 
qualunque sia X!!!9
Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

ABD  D (S  Z) quindi entriamo nel ciclo while


Z = Z S = ABD
prima l’intersezione!
ciclo for interno al while sui sottoschemi ABC e ABD
S = S  (ABD  ABC)+F ABC = S  (AB)+F ABC = ABD  ABC  ABC =
ABCD
S = S  (ABD  ABD)+F ABD = S  (ABD)+F ABD = ABCD  ABCD  ABD
= ABCD  ABD = ABCD
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo che
(AB)+F = ABC e (ABD)+F = ABCD

ABCD  ABD quindi rientriamo nel ciclo while


Z = Z S = ABCD 10
Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

ABCD  ABD quindi rientriamo nel ciclo while


Z = Z S = ABCD
ciclo for interno al while sui sottoschemi ABC e ABD
S = S  (ABCD  ABC)+F ABC = S  (ABC)+F ABC = ABCD  ABC  ABC
= ABCD
S = S  (ABCD  ABD)+F ABD = S  (ABD)+F ABD = ABCD  ABCD 
ABC = ABCD  ABC = ABCD

S  Z quindi STOP l’algoritmo si ferma, ma va controllato il contenuto di Z


Z= (D)+G = ABCD C  (D)+G quindi la dipendenza è preservata

Poichè (D)+G = ABCD


osserviamo che sono preservate anche D  B e D  A 11
Che però per le note precedenti sapevamo comunque già essere in G
Esempio 1: svolgimento

•In base alle osservazioni sulle dipendenze sicuramente contenute in G


e al fatto di aver verificato che D C è preservata (era l’unica in
dubbio), possiamo già dire che la decomposizione preserva le
dipendenze

•A scopo didattico verifichiamo anche le altre

12
Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

Cominciamo con AB  C
Z = AB
S=
ciclo for esterno sui sottoschemi ABC e ABD
S = S  (AB  ABC)+F ABC = S  (AB)+F ABC
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo
(AB)+F = ABC
S = S  (AB)+F ABC =   ABC  ABC = ABC
S = S  (AB  ABD)+F ABD = ABC  (AB)+F ABD = ABC  ABC  ABD
= ABC

13

Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

ABC  AB quindi entriamo nel ciclo while


Z = Z S = ABC
Secondo la nota precedente (a Z possono solo venire aggiunti
elementi),potremmo interrompere l’algoritmo perché C Z  (AB)+G.
A scopo didattico continuiamo l’esecuzione. In un esercizio di esame ci
si può fermare fornendo la giusta motivazione
ciclo for interno al while sui sottoschemi ABC e ABD
S = S  (ABC  ABC)+F ABC = S  (ABC)+F ABC
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo
(ABC)+F = ABC
S = S  (ABC)+F ABC = ABC  ABC  ABC = ABC
S = S  (ABC  ABD)+F ABD = S  (AB)+F ABD = ABC  ABC  ABD =
ABC  AB = ABC 14
Esempio 1: svolgimento

• S  Z quindi STOP senza rientrare nel while


l’algoritmo si ferma, ma va controllato il contenuto di Z

• Z= (AB)+G = ABC C  (AB)+G quindi la dipendenza è


preservata

15
Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

Infine verifichiamo che venga preservata C  B


Z=C
S=
ciclo for esterno sui sottochemi ABC e ABD
S = S  (C  ABC)+F ABC = S  (C)+F ABC
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo
(C)+F = BC

S = S  (C)+F ABC =   BC  ABC =   BC = BC


S = S  (C  ABD)+F ABD = S  ()+F ABD = BC    ABD = BC   = BC

16
Esempio 1: svolgimento

R = (A, B, C, D) F = { AB C, D C, D B, C B, D A }  = { ABC,ABD }

BC  C quindi entriamo nel ciclo while


Z = Z S = BC
ciclo for interno al while sui sottoschemi ABC e ABD
S = S  (BC  ABC)+F ABC = S  (BC)+F ABC
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo
(BC)+F = BC
S = S  (BC)+F ABC = BC  BC  ABC = BC
S = S  (BC  ABD)+F ABD = S  (B)+F ABD
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo
(B)+F = B
S = S  (B)+F ABD = BC  B  ABD = BC
S  Z quindi STOP l'algoritmo si ferma, ma va controllato il contenuto di17 Z
Z= (C)+G = BC cioè B  (C)+G quindi la dipendenza è preservata.
Esempio 2

Dato il seguente schema di relazione


R = (A, B, C, D, E)
e il seguente insieme di dipendenze funzionali
F = { AB E, B CE, ED C}
dire se la decomposizione  = { ABE, CDE }
preserva le dipendenze in F
In base a quanto visto basta verificare che FG+ cioè che ogni
dipendenza funzionale in F si trova in G+
NOTA – come abbiamo verificato, è inutile controllare che vengano
preservate le dipendenze tali che l'unione delle parti destra e sinistra è
contenuta interamente in un sottoschema, perché secondo la definizione
Ri (F) XY XY F+ XYRi.
tali dipendenze fanno parte per definizione di G.
In questo esempio, questo vale per AB E e per ED C
Quindi verifichiamo solo che venga preservata la dipendenza B CE
18
Esempio 2: svolgimento

R = (A, B, C, D, E) F = { AB E, B CE, ED C}  = { ABE, CDE }


Attenzione!!!
Verifichiamo che sia preservata B C E. ()+F= 
qualunque sia F!!!
Z=B  X = 
S= qualunque sia X!!!
ciclo for esterno sui sottoschemi ABE e CDE
S = S  (B ABE)+F ABE =   (B)+F ABE =  BCE ABE = BE
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo
(B)+F = BCE
S = BE  (B  CDE)+F CDE= BE ()+F CDE = BE

prima l’intersezione! … elimineremmo … la B!

BE  B (S  Z) quindi entriamo nel ciclo while 19


Esempio 2: svolgimento

R = (A, B, C, D, E) F = { AB E, B CE, ED C}  = { ABE, CDE }

BE  B (S  Z) quindi entriamo nel ciclo while


Z = Z S = B  BE = BE prima l’intersezione!
ciclo for interno al while sui sottoschemi ABE e CDE
S = BE (BE  ABE)+F ABE = BE  (BE)+F ABE = BE BCE ABE = BE
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo che
(BE)+F = BCE
S = BE  (BE  CDE)+F CDE = S  (E)+F CDE= BE E CDE= BEE=BE
Applicando l'algoritmo sulla chiusura di un insieme di attributi abbiamo che (E)+F
=E
BE = BE (S Z ) quindi STOP
Z= (B)+G = BE l’algoritmo si ferma, ma controlliamo Z
E (B)+G MA C(B)+G
quindi la dipendenza B CE non è preservata (nella chiusura manca uno degli
attributi che dovrebbero essere determinati funzionalmente da B)
Esempi

•Torniamo alle decomposizioni degli esempi, e verifichiamo se


l’algoritmo avrebbe rilevato la perdita di alcune dipendenze funzionali.

21
Esempi iniziali

RABC con l’insieme di dipendenze funzionali FAB, BC


Decomponiamo R in  = { AB, AC }
Cominciamo a verificare se  preserva AB
Z=A
S=
ciclo for esterno sui sottoschemi AB e AC
S = S  (A  AB)+F AB = S  (A)+F AB
Applicando l'algoritmo sulla chiusura di un insieme di attributi
(A)+F = ABC
S = S  (A)+F AB =   ABC  AB =   AB = AB
S = S  (A  AC)+F AC = S  (A)+F AC = AB  ABC  AC = AB  AC= ABC

ABC  A dovremmo continuare ma Z contiene già tutto R e non possiamo


togliere attributi, quindi ci fermiamo perché sicuramente (A)+G =R
e quindi B  (A)+G
22
Esempi iniziali

RABC FAB, BC  = { AB, AC }


Verifichiamo BC
Z=B
S=
ciclo for esterno sui sottochemi AB e AC
S = S  (B  AB)+F AB = S  (B)+F AB
Applicando l'algoritmo sulla chiusura di un insieme di attributi
(B)+F = BC
S = S  (B)+F AB =   BC  AB =   B = B
S = S  (B  AC)+F AC = S  ()+F AC = B    AC = B   = B
B  B STOP
Z=(B)+G =B l'algoritmo si ferma, ma va controllato il contenuto di Z
e quindi C  (B)+G La dipendenza BC non è preservata
L’algoritmo conferma che la decomposizione  non preserva F, come 23
avevamo già scoperto dall’esempio
Esempi iniziali

• Consideriamo lo schema R(Matricola, Comune, Provincia) con


l’insieme di dipendenze funzionali
FMatricola  Comune, Comune  Provincia
• Decomponiamo R in R1  = {(Matricola, Comune), (Matricola,
Provincia)}
• Cominciamo a verificare se  preserva Matricola  Comune … ma
prima di iniziare sostituiamo i nomi lunghi con lettere più «comode» …
Magari A, B, C … ma allora torniamo all’esempio di prima …

• RABC con l’insieme di dipendenze funzionali FAB, BC


• Decomponiamo R in  = { AB, AC }

• Abbiamo già verificato che Matricola  Comune (AB) viene


preservata, ma Comune  Provincia no … quindi la decomposizione
 = {(Matricola, Comune), (Matricola, Provincia)} non preserva F 24
Finito?

•Abbiamo sottolineato varie volte che una buona decomposizione deve


soddisfare 3 condizioni
• ogni sottoschema deve essere in 3NF
• la decomposizione deve preservare tutte le dipendenze in F+
• la decomposizione deve permettere di ricostruire una istanza legale
decomposta senza perdita di informazione (join senza perdita)

•Abbiamo visto come, data una decomposizione, possiamo verificare che


preservi le dipendenze.

•Vedremo come, data una decomposizione, possiamo verificare che abbia


un join senza perdita.

25