Databázové systémy Tomáš Skopal

Transkript

1 Databázové systémy Tomáš Skopal - relační model * základní algoritmy * hledání klíčů * dekompozice a syntéza

2 Osnova přednášky algoritmy pro analýzu schémat základní algoritmy (atributový uzávěr, příslušnost a redundance FZ) hledání klíčů testování normálních forem pro normalizaci univerzálního schématu dekompozice syntéza

3 Algoritmus atributového uzávěru atributový uzávěr množiny atributů X vůči množině závislostí F princip: postupně odvozujeme všechny atributy F-určené atributy z X polynomiální složitost (O(m*n), kde n je počet atributů a m počet závislostí) algorithm AttributeClosure(set of dependencies F, set of attributes X) : returns set X + ClosureX := X; DONE := false; m = F ; while not DONE do DONE := true; for i := 1 to m do if (LS[i] ClosureX and RS[i] ClosureX) then ClosureX := ClosureX RS[i]; DONE := false; endif endfor endwhile return ClosureX; Poznámka: výraz LS[i] (resp. RS[i]) představuje levou (pravou) stranu i-té závislosti v F Využije se triviální FZ (inicializace algoritmu) a potom tranzitivity (test levé strany v uzávěru). Využití kompozice a dekompozice je skrytá v testu inkluze.

4 Příklad atributový uzávěr F = {a b, bc d, bd a} {b,c} + =? 1. ClosureX := {b,c} (inicializace) 2. ClosureX := ClosureX {d} = {b,c,d} (bc d) 3. ClosureX := ClosureX {a} = {a,b,c,d} (bd a) {b,c} + = {a,b,c,d}

5 Algoritmus příslušnosti často potřebujeme zjistit příslušnost nějaké závislosti X Y do F +, tj. vyřešit problém {X Y} F + počítat celý F + je nepraktické, lze použít algoritmus atributového uzávěru algorithm IsDependencyInClosure(set of dependencies F, dependency X Y ) return Y AttributeClosure(F, X);

6 Testování redundancí Algoritmus příslušnosti lze jednoduše použít k testu redundance závislosti X Y v F. atributu v X (vzhledem k F a X Y). algorithm IsDependencyRedundant(set of dependencies F, dependency X Y F) return IsDependencyInClosure(F {X Y}, X Y); algorithm IsAttributeRedundant(set of deps. F, dep. X Y F, attribute a X) return IsDependencyInClosure(F, X {a} Y); V dalším výkladu nám bude užitečný algoritmus vracející k FZ redukovanou levou stranu: algorithm GetReducedAttributes(set of deps. F, dep. X Y F) X := X; for each a X do if IsAttributeRedundant(F, X Y, a) then X := X {a}; endfor return X ;

7 Minimální pokrytí použijeme postupně na všechny FZ testy redundance a ty odstraníme algorithm GetMinimumCover(set of dependencies F): returns minimal cover G decompose each dependency in F into elementary ones for each X Y in F do F := (F {X Y}) {GetReducedAttributes(F, X Y) Y}; endfor for each X Y in F do if IsDependencyRedundant(F, X Y) then F := F {X Y}; endfor return F;

8 Nalezení (prvního) klíče algoritmus testu redundance atributu lze přímo použít při hledání klíčů postupně se odstraňují redundantní atributy z A A algorithm GetFirstKey(set of deps. F, set of attributes A) : returns a key K; return GetReducedAttributes(F, A A); Poznámka: Klíčů samozřejmě může být víc, algoritmus najde jen jeden (který to záleží na pořadí procházení množiny atributů uvnitř algoritmu GetReducedAttributes).

9 Nalezení všech klíčů, princip Máme schéma S(A, F). X Převeďme F do minimálního pokrytí. A K y A 1. Nalezněme libovolný klíč K (viz předchozí slajd). 2. V F nalezněme funkční závislost X y takovou, že y K. (pokud neexistuje, končíme, další klíč není) 3. Protože X y a K A, platí tranzitivně i X{K y} A, tj. X{K y} je nadklíč. 4. Zredukujeme závislost X{K y} A a tím na levé straně dostaneme klíč K. Tento klíč je nutně různý od K, protože jsme z něj odstranili y. 5. Pokud K zatím není mezi nalezenými klíči, přidáme jej, prohlásíme K=K a celý postup opakujeme od kroku 2. V opačné případě končíme.

10 Nalezení všech klíčů, algoritmus Lucchesi-Osborn algoritmus k již nalezenému klíči hledáme ekvivalentní množiny atributů, tj. jiné klíče NP-úplný problém (teoreticky exponenciální počet klíčů/závislostí) algorithm GetAllKeys(set of deps. F, set of attributes A) : returns set of all keys Keys; let all dependencies in F be non-trivial, i.e. replace every X Y by X (Y X) K := GetFirstKey(F, A); Keys := {K}; Done := false; while Done = false do Done := true; for each X Y F do if (Y K and K Keys : K (K X) Y) then K := GetReducedAttributes(F, ((K X) Y) A); Keys := Keys {K}; Done := false; endfor endwhile return Keys;

11 Příklad nalezení všech klíčů Contracts(A, F) A = {c = ContractId, s = SupplierId, j = ProjectId, d = DeptId, p = PartId, q = Quantity, v = Value} F = {c all, sd p, p d, jp c, j s} 1. Najdu první klíč Keys = {c} 2. Iterace 1: najdu jp c, která má na pravé straně kus posledního klíče (v tomto případě celý klíč c) a zároveň jp není nadmnožinou již nalezeného klíče 3. jp all je redukovaná (žádný redundantní atribut), tj. 4. Keys = {c, jp} 5. Iterace 2: najdu sd p, má na pravé straně kus posledního klíče (jp), {jsd} není nadmnožinou ani c ani jp, tj. je to kandidát na klíč 6. v jsd all je redundantní atribut s, tj. 7. Keys = {c, jp, jd} 8. Iterace 3: najdu ještě p d, nicméně jp už jsme našli, takže nepřidávám nic 9. končím, iterace 3 proběhla naprázdno

12 Testování normálních forem NP-úplný problém buď musím znát všechny klíče pak stačí otestovat jen FZ z F, nemusím testovat celý F + nebo musím znát jeden klíč, ale zase potřebuji F rozšířit na celé F + naštěstí v praxi je nalezení všech klíčů rychlé díky omezené velikosti F a separovanosti závislostí v F

13 Návrh schématu databáze Dva způsoby modelování relační databáze: získám množinu relačních schémat (ručně nebo např. převodem z ER diagramu) normalizaci pro dodržení NF provádím pro každou tabulku zvlášť riziko nadbytečného rozdrobení databáze na příliš mnoho tabulek chápu modelování celé databáze na úrovni globálních atributů a navrhnu tzv. univerzální schéma databáze tj. jednu velkou tabulku včetně množiny globálně platných funkčních závislostí normalizaci pro dodržení NF provádím najednou pro celou databázi menší riziko rozdrobení entity jsou vygenerovány (rozpoznány) jako důsledky FZ modelování na úrovni atributů je méně intuitivní než např. ER modelování můžu zkombinovat oba přístupy tj. nejprve vytvořit ER model databáze, ten převést do schémat a postupně některé sloučit (v krajním případě všechny)

14 Normalizace relačního schématu jediný způsob dekompozice na více schémat případně nejdříve sloučení více nenormálních schémat a pak dekompozice přístupy podle různých kritérií zachování integrity dat tzv. bezztrátovost tzv. pokrytí závislostí požadavek na NF (3NF nebo BCNF) ručně nebo algoritmicky

15 Proč zachovávat integritu? Pokud dekompozici nijak neomezíme, můžeme rozložit tabulku na několik jednosloupcových, které jistě všechny splňují BCNF. Firma Sídlo Nadmořská výška Firma Sídlo Nadmořská výška Sun Santa Clara 25 mnm Sun Santa Clara 25 mnm Oracle Redwood 20 mnm Oracle Redwood 20 mnm Microsoft Redmond 10 mnm Microsoft Redmond 10 mnm IBM New York 15 mnm IBM New York 15 mnm Firma, Sídlo Nadmořská výška Firma Sídlo Nadmořská výška Evidentně je ale s takovouto dekompozicí něco špatně......je ztrátová a nezachovává pokrytí závislostí

16 Bezztrátovost vlastnost dekompozice, která zaručuje korektní rekonstrukci univerzální relace z dekomponovaných relací Definice 1: Nechť R({X Y Z}, F) je univerzální schéma, kde Y Z F. Potom dekompozice R 1 ({Y Z}, F 1 ), R 2 ({Y X}, F 2 ) je bezztrátová. Alternativní Definice 2: Dekompozice R(A, F) do R 1 (A 1, F 1 ), R 2 (A 2, F 2 ) je bezztrátová, jestliže platí A 1 A 2 A 1 nebo A 2 A 1 A 2 Alternativní Definice 3: Dekompozice R(A, F) na R 1 (A 1, F 1 ),..., R n (A n, F n ) je bezztrátová, pokud platí R = * i=1..n R [A i ]. Poznámka: R je instance schématu R (tj. konkrétní relace/tabulka s daty). Operace * je přirozené spojení relací a R [A i ] je projekce relace R na podmnožinu atributů A i A. (operace budou blíže vysvětleny na příští přednášce)

17 Příklad ztrátová dekompozice Firma Používá DBMS Spravuje dat Sun Oracle 50 TB Sun DB2 10 GB Microsoft MSSQL 30 TB Microsoft Oracle 30 TB Firma, Používá DBMS Firma Sun Sun Microsoft Microsoft Používá DBMS Oracle DB2 MSSQL Oracle Firma, Používá DBMS Firma Sun Sun Microsoft Spravuje dat 50 TB 10 GB 30 TB Firma, Spravuje dat Firma Používá DBMS Spravuje dat Sun Oracle 50 TB Sun Oracle 10 GB Sun DB2 10 GB Sun DB2 50 TB Microsoft MSSQL 30 TB Microsoft Oracle 30 TB rekonstrukce (přirozené spojení) Firma, Používá DBMS, Spravuje dat

18 Příklad bezztrátová dekompozice Firma Sídlo Nadmořská výška Sun Santa Clara 25 mnm Oracle Redwood 20 mnm Microsoft Redmond 10 mnm IBM New York 15 mnm Firma, Sídlo Nadmořská výška Firma Sídlo Sun Santa Clara Oracle Redwood Microsoft Redmond IBM New York Firma Sídlo Santa Clara Redwood Redmond New York Sídlo Nadmořs ká výška 25 mnm 20 mnm 10 mnm 15 mnm rekonstrukce (přirozené spojení)

19 Pokrytí závislostí vlastnost dekompozice, která zaručuje zachování všech funkčních závislostí Definice: Nechť R 1 (A 1, F 1 ), R 2 (A 2, F 2 ) je dekompozicí R(A, F), potom dekompozice zachovává pokrytí závislostí, pokud F + = ( i=1..n F i ) +. Pokrytí závislostí může být narušeno dvěma způsoby při dekompozici F neodvodíme všechny FZ platné v Fi ztratíme FZ, která má přímo platit v jednou dílčím schématu i když odvodíme všechny platné (tj. provedeme projekci F + ), můžeme v důsledku ztratit FZ, která platí napříč schématy

20 Příklad pokrytí závislostí pokrytí porušeno, ztratili jsme Sídlo Nadmořská výška Firma Nadmořská výška Firma Sídlo Sun 25 mnm Sun Santa Clara Firma Sídlo Nadmořská výška Oracle Microsoft 20 mnm 10 mnm Oracle Microsoft Redwood Redmond Sun Santa Clara 25 mnm IBM 15 mnm IBM New York Oracle Redwood 20 mnm Microsoft Redmond 10 mnm Firma Sídlo IBM New York 15 mnm Firma, Sídlo Nadmořská výška pokrytí zachováno Firma Sun Oracle Microsoft IBM Sídlo Santa Clara Redwood Redmond New York Sídlo Santa Clara Redwood Redmond New York Nadmořs ká výška 25 mnm 20 mnm 10 mnm 15 mnm Firma Sídlo

21 Algoritmus Dekompozice algoritmus pro dekompozici do BCNF, zachovávající bezztrátovost nezachovává pokrytí závislostí nezávisí na algoritmu někdy prostě nelze dekomponovat do BCNF a zároveň pokrýt závislosti algorithm Decomposition(set of elem. deps. F, set of attributes A) : returns set {R i (A i, F i )} Result := {R(A, F)}; Done := false; Create F + ; while not Done do if R i (F i, A i ) Result not being in BCNF then // pokud ve výsledku je schéma porušující BCNF Let X Y F i such that X A i F +. // X není (nad)klíč a X Y tedy narušuje BCNF Result := (Result {R i (A i, F i )}) // odebereme rozkládané schéma z výsledku {R i (A i Y, cover(f, A i Y))} // přidáme rozkládané schéma bez atrib. Y {R j (X Y, cover(f, X Y))} // přidáme schéma s atrib. XY else Done := true; endwhile return Result; Tato dílčí dekompozice na dvě tabulky je bezztrátová, dostaneme dvě schémata, která obě obsahují X, druhé navíc pouze Y a platí X Y. X je nyní v druhé tab. nadklíčem a X Y tedy již neporušuje BCNF (v první tab. už není Y). Poznámka: Funkce cover(x, F) vrátí všechny závislosti platné na atributech z X, tj. podmnožinu z F + takovou, která obsahuje pouze atributy z X. Proto je nutné počítat explicitně F +.

22 Příklad dekompozice Contracts(A, F) A = {c = ContractId, s = SupplierId, j = ProjectId, d = DeptId, p = PartId, q = Quantity, v = Value} F = {c all, sd p, p d, jp c, j s} csjpdqv (1NF) sd p sdp (3NF) csjdqv (1NF) pd p d sp js j s cqjdv Nepokryté závislosti: c p cp (BCNF) sd p (BCNF) sdp (3NF)

23 Algoritmus Syntéza algoritmus pro dekompozici do 3NF, zachovávající pokrytí závislostí základní verze nezachovává bezztrátovost algorithm Synthesis(set of elem. deps. F, set of attributes A) : returns set {R i (F i, A i )} create minimal cover from F into G compose FDs having equal left side into a single FD every composed FD forms a scheme R i (A i, F i ) of decomposition return i=1..n {R i (A i, F i )} bezztrátovost lze zajistit přidáním dalšího schématu do dekompozice, které obsahuje univerzální klíč (tj. nějaký klíč původního univerzálního schématu) schéma v dekompozici, které je podmnožinou jiného můžu vypustit můžu se pokusit sloučit schémata s funkčně ekvivalentními klíči, ale tato operace může obecně porušit 3NF!! (nebo BCNF pokud jí bylo dosaženo)

24 Příklad syntéza Contracts(A, F) A = {c = ContractId, s = SupplierId, j = ProjectId, d = DeptId, p = PartId, q = Quantity, v = Value} F = {c sjdpqv, sd p, p d, jp c, j s} Minimální pokrytí: V závislostech z F nejsou redundantní atributy. Byly vyřazeny redundantní FZ c s a c p. G = {c j, c d, c q, c v, sd p, p d, jp c, j s} Kompozice podle levých stran: G = {c jdqv, sd p, p d, jp c, j s} Výsledek: R 1 ({cqjdv}, {c jdqv}), R 2 ({sdp}, {sd p}), R 3 ({pd},{p d}), R 4 ({jpc}, {jp c}), R 5 ({js}, {j s})) (podmnožina v R 2 ) Ekvivalentní klíče: {c, jp, jd} R 1 ({cqjpdv}, {c jdqv, jp c}), R 2 ({sdp}, {sd p, p d}), R 5 ({js}, {j s})) sloučení R 1 a R 4 (nyní ale p d porušuje BCNF)

25 Bernsteinovo rozšíření syntézy pokud by sloučení schémat podle ekvivalence klíčů K 1, K 2 porušilo 3NF, provedeme dekompozici znovu 1. F new = F {K 1 K 2, K 2 K 1 } 2. zjistíme redundantní závislosti v F new, ale odstraníme je z F 3. tabulky se navrhnou z redukované F a {K 1 K 2 }

26 Demo program Databázové algoritmy stáhnete z mého webu příklad 1 příklad 2