1. Chapter 7: Relational Database Design

2. ©Silberschatz, Korth and Sudarshan7.2Database System Concepts Chapter 7: Relational Database Design Pitfalls in Relational Database Design First Normal Form Functional Dependencies Decomposition Boyce-Codd Normal Form Third Normal Form Multivalued Dependencies and Fourth Normal Form Overall Database Design Process

3. ©Silberschatz, Korth and Sudarshan7.3Database System Concepts Pitfalls in Relational Database Design Relational database design requires that we find a “good” collection of relation schemas. A bad design may lead to  Repetition of Information.  Inability to represent certain information. Design Goals:  Avoid redundant data  Ensure that relationships among attributes are represented  Facilitate the checking of updates for violation of database integrity constraints.

4. ©Silberschatz, Korth and Sudarshan7.4Database System ConceptsExample Consider the relation schema: Lending-schema = (branch-name, branch-city, assets, customer-name, loan-number, amount) Redundancy:  Data for branch-name, branch-city, assets are repeated for each loan that a branch makes  Wastes space  Inconsistency  assets values for Jones vs. Jackson

5. ©Silberschatz, Korth and Sudarshan7.5Database System Concepts Example (Cont’d) Null values  Cannot store information about a branch if no loans exist  Can use null values, but they are difficult to handle.  Delete tuple for Smith. What Happens? Any problem?

6. ©Silberschatz, Korth and Sudarshan7.6Database System Concepts First Normal Form A relational schema R is in first normal form if the domains of all attributes of R are atomic Domain is atomic if its elements are considered to be indivisible units Non-atomic values may cause redundancy and consistency problems  E.g., owner relation in which an account is stored with the set of owners and vice versa  Same customers and accounts are stored repeatedly  What if an account is deleted? Assume all relations are in first normal form Solve consistency & redundancy problems completely?  Any non-atomic attribute in lending-schema?

7. ©Silberschatz, Korth and Sudarshan7.7Database System ConceptsDecomposition Decompose the relation schema Lending-schema into: Branch-schema = (branch-name, branch-city,assets) Loan-info-schema = (customer-name, loan-number, branch-name, amount) All attributes of an original schema (R) must appear in the decomposition (R 1, R 2 ): R = R 1  R 2 Lossless-join decomposition. For all possible relations r on schema R r =  R1 (r)  R2 (r)

8. ©Silberschatz, Korth and Sudarshan7.8Database System Concepts Example of “Lossy” Join Decomposition Decomposition of R = (A, B) R 1 = (A)R 2 = (B) AB  121121 A  B 1212 r A(r)A(r)  B(r)  A (r)  B (r) AB  12121212

9. ©Silberschatz, Korth and Sudarshan7.9Database System Concepts Goal — Devise a Theory for the Following Decide whether a particular relation R is in “good” form.  Minimize redundancy  Easy to maintain consistency In the case that a relation R is not in good form, decompose it into a set of relations {R 1, R 2,..., R n } such that  each relation is in good form  the decomposition is a lossless-join decomposition The theory is based on:  functional dependencies  multivalued dependencies

10. ©Silberschatz, Korth and Sudarshan7.10Database System Concepts Functional Dependencies Constraints on the set of legal relations Generalization of the notion of a key Require that the value for a certain set of attributes determines uniquely the value for another set of attributes Let R be a relation schema   R and   R The functional dependency    holds on R iff for any legal relations r(R), whenever any two tuples t 1 and t 2 of r, t 1 [  ] = t 2 [  ]  t 1 [  ] = t 2 [  ]

11. ©Silberschatz, Korth and Sudarshan7.11Database System Concepts Functional Dependencies (Cont.) K is a superkey for relation schema R if and only if K  R K is a candidate key for R if and only if  K  R, and  for no   K,   R Functional dependencies allow us to express constraints that cannot be expressed using superkeys. Consider the schema: Loan-info-schema = (customer-name, loan-number, branch-name, amount). We expect this set of functional dependencies to hold: loan-number  amount loan-number  branch-name but would not expect the following to hold: loan-number  customer-name

12. ©Silberschatz, Korth and Sudarshan7.12Database System Concepts Use of Functional Dependencies We use functional dependencies to:  test relations to see if they are legal under a given set of functional dependencies.  If a relation r is legal under a set F of functional dependencies, we say that r satisfies F.  specify constraints on the set of legal relations  We say that F holds on R if all legal relations on R satisfy the set of functional dependencies F. Note: A specific instance of a relation schema may satisfy a functional dependency even if the functional dependency does not hold on all legal instances.  For example, a specific instance of Loan-schema may, by chance, satisfy loan-number  customer-name.

13. ©Silberschatz, Korth and Sudarshan7.13Database System Concepts Functional Dependencies (Cont.) A functional dependency is trivial if it is satisfied by all instances of a relation  E.g.  customer-name, loan-number  customer-name  customer-name  customer-name  In general,    is trivial if   

14. ©Silberschatz, Korth and Sudarshan7.14Database System Concepts Closure of a Set of Functional Dependencies Given a set F, a set of functional dependencies, there are certain other functional dependencies that are logically implied by F.  E.g. If A  B and B  C, then we can infer that A  C The set of all functional dependencies logically implied by F is the closure of F. We denote the closure of F by F +. Apply Armstrong’s Axioms to find all of F + :  if   , then    (reflexivity)  if   , then      (augmentation)  if   , and   , then    (transitivity) These rules are  sound (generate only functional dependencies that actually hold) and  complete (generate all functional dependencies that hold).

15. ©Silberschatz, Korth and Sudarshan7.15Database System Concepts Additional Closure Rules Union Rule  If    and   , then     Decomposition Rule  If    , then    and    Are these rules essential?

16. ©Silberschatz, Korth and Sudarshan7.16Database System ConceptsExample R = (A, B, C, G, H, I) F = { A  B A  C CG  H CG  I B  H} some members of F +  A  H  by transitivity from A  B and B  H  AG  I  by augmenting A  C with G, to get AG  CG and then transitivity with CG  I  CG  HI  from CG  H and CG  I : (union rule)

17. ©Silberschatz, Korth and Sudarshan7.17Database System Concepts Procedure for Computing F + To compute the closure of a set of functional dependencies F: F + = F repeat for each functional dependency f in F + apply reflexivity and augmentation rules on f add the resulting functional dependencies to F + for each pair of functional dependencies f 1 and f 2 in F + if f 1 and f 2 can be combined using transitivity then add the resulting functional dependency to F + until F + does not change any further NOTE: We will see an alternative procedure for this task later

18. ©Silberschatz, Korth and Sudarshan7.18Database System Concepts Closure of Attribute Sets Given a set of attributes  define the closure of  under F (denoted by  + ) as the set of attributes that are functionally determined by  under F:    is in F +     + Algorithm to compute  +, the closure of  under F result :=  ; while (changes to result) do for each    in F do begin if   result then result := result   end

19. ©Silberschatz, Korth and Sudarshan7.19Database System Concepts Example of Attribute Set Closure R = (A, B, C, G, H, I) F = {A  B A  C CG  H CG  I B  H} (AG) + 1.result = AG 2.result = ABCG(A  B and A  C) 3.result = ABCGH(CG  H and CG  AGBC) 4.result = ABCGHI(CG  I and CG  AGBCH) Is AG a candidate key? 1. Is AG a super key? 1. Does AG  R? == Is (AG) +  R 2. Is any subset of AG a superkey? 1. Does A  R? == Is (A) +  R 2. Does G  R? == Is (G) +  R

20. ©Silberschatz, Korth and Sudarshan7.20Database System Concepts Uses of Attribute Closure There are several uses of the attribute closure algorithm: Superkey  To test if  is a superkey, we compute  +, and check if  + contains all attributes of R  To find a superkey, start the alg. with a single attribute and stop as soon as closure contains all attributes in R Testing functional dependencies  To check if a functional dependency    holds, check if    +.  Compute  + and then check if it contains  Computing closure of F  For each   R, we find the closure  +, and for each S   +, we output a functional dependency   S

21. ©Silberschatz, Korth and Sudarshan7.21Database System Concepts Canonical Cover Sets of functional dependencies may have redundant dependencies that can be inferred from the others  Eg: A  C is redundant in: {A  B, B  C, A  C} A canonical cover of functional dependencies F  A “minimal” set of functional dependencies equivalent to F, having no redundant dependencies  A database update can be checked using a canonical cover, which is smaller than F

22. ©Silberschatz, Korth and Sudarshan7.22Database System Concepts Extraneous Attributes Consider a set F of functional dependencies and the functional dependency    in F.  Attribute A is extraneous in  if A   and F logically implies (F – {    })  {(  – A)   }.  Attribute A is extraneous in  if A   and the set of functional dependencies (F – {    })  {   (  – A)} logically implies F. Example: Given F = {A  C, AB  C }  B is extraneous in AB  C because {A  C, AB  C} logically implies A  C (I.e. the result of dropping B from AB  C). Example: Given F = {A  C, AB  CD}  C is extraneous in AB  CD since AB  C can be inferred even after deleting C

23. ©Silberschatz, Korth and Sudarshan7.23Database System Concepts Canonical Cover A canonical cover for F is a set of dependencies F c such that  F logically implies all dependencies in F c, and  F c logically implies all dependencies in F, and  No functional dependency in F c contains an extraneous attribute, and  Each left side of functional dependency in F c is unique. To compute a canonical cover for F: repeat Use the union rule to replace any dependencies in F  1   1 and  1   2 with  1   1  2 Find a functional dependency    with an extraneous attribute either in  or in  If an extraneous attribute is found, delete it from    until F does not change

24. ©Silberschatz, Korth and Sudarshan7.24Database System Concepts Example of Computing a Canonical Cover R = (A, B, C) F = {A  BC B  C A  B AB  C} Combine A  BC and A  B into A  BC  Set is now {A  BC, B  C, AB  C} A is extraneous in AB  C  Check if the result of deleting A from AB  C is implied by the other dependencies  Yes: in fact, B  C is already present!  Set is now {A  BC, B  C} C is extraneous in A  BC  Check if A  C is logically implied by A  B and the other dependencies  Yes: using transitivity on A  B and B  C. –Can use attribute closure of A in more complex cases The canonical cover is: A  B B  C

25. ©Silberschatz, Korth and Sudarshan7.25Database System Concepts Goals of Normalization Decide whether a particular relation R is in “good” form. In the case that a relation R is not in “good” form, decompose it into a set of relations {R 1, R 2,..., R n } such that  each relation is in good form  the decomposition is a lossless-join decomposition Our theory is based on:  functional dependencies  multivalued dependencies

26. ©Silberschatz, Korth and Sudarshan7.26Database System ConceptsDecomposition Decompose the relation schema Lending-schema into: Branch-schema = (branch-name, branch-city,assets) Loan-info-schema = (customer-name, loan-number, branch-name, amount) All attributes of an original schema (R) must appear in the decomposition (R 1, R 2 ): R = R 1  R 2 Lossless-join decomposition. For all possible relations r on schema R r =  R1 (r)  R2 (r) A decomposition of R into R 1 and R 2 is lossless join if and only if at least one of the following dependencies is in F + :  R 1  R 2  R 1  R 1  R 2  R 2

27. ©Silberschatz, Korth and Sudarshan7.27Database System Concepts Normalization Using Functional Dependencies When we decompose a relation schema R with a set of functional dependencies F into R 1, R 2,.., R n we want  Lossless-join decomposition: Otherwise decomposition would result in information loss.  No redundancy: The relations R i preferably should be in either Boyce- Codd Normal Form or Third Normal Form.  Dependency preservation: Let F i be the set of dependencies F + that include only attributes in R i.  Preferably the decomposition should be dependency preserving, that is, (F 1  F 2  …  F n ) + = F +  Otherwise, checking updates for violation of functional dependencies may require computing joins, which is expensive.

28. ©Silberschatz, Korth and Sudarshan7.28Database System ConceptsExample R = (A, B, C) F = {A  B, B  C)  Can be decomposed in two different ways R 1 = (A, B), R 2 = (B, C)  Lossless-join decomposition: R 1  R 2 = {B} and B  BC  Dependency preserving R 1 = (A, B), R 2 = (A, C)  Lossless-join decomposition: R 1  R 2 = {A} and A  AB  Not dependency preserving (cannot check B  C without computing R 1 R 2 )

29. ©Silberschatz, Korth and Sudarshan7.29Database System Concepts Testing for Dependency Preservation To check if a dependency  is preserved in a decomposition of R into R 1, R 2, …, R n we apply the following simplified test (with attribute closure done w.r.t. F)  result =  while (changes to result) do for each R i in the decomposition t = (result  R i ) +  R i result = result  t  If result contains all attributes in , then the functional dependency    is preserved. We apply the test on all dependencies in F to check if a decomposition is dependency preserving Polynomial time algorithm

30. ©Silberschatz, Korth and Sudarshan7.30Database System Concepts Boyce-Codd Normal Form     is trivial (i.e.,    )  is a superkey for R A relation schema R is in BCNF with respect to a set F of functional dependencies if for all functional dependencies in F + of the form    , where   R and   R, at least one of the following holds:

31. ©Silberschatz, Korth and Sudarshan7.31Database System ConceptsExample R = (A, B, C) F = {A  B B  C} Key = {A} R is not in BCNF Decomposition R 1 = (A, B), R 2 = (B, C)  R 1 and R 2 in BCNF  Lossless-join decomposition  Dependency preserving

32. ©Silberschatz, Korth and Sudarshan7.32Database System Concepts BCNF Decomposition Algorithm result := {R}; done := false; compute F + ; while (not done) do if (there is a schema R i in result that is not in BCNF) then begin let     be a nontrivial functional dependency that holds on R i such that    R i is not in F +, and    =  ; result := (result – R i )  (R i –  )  ( ,  ); end else done := true; Note: each R i is in BCNF, and decomposition is lossless-join.

33. ©Silberschatz, Korth and Sudarshan7.33Database System Concepts Example of BCNF Decomposition R = (branch-name, branch-city, assets, customer-name, loan-number, amount) F = {branch-name  assets branch-city loan-number  amount branch-name} Key = {loan-number, customer-name} Decomposition  R 1 = (branch-name, branch-city, assets)  R 2 = (branch-name, customer-name, loan-number, amount)  R 3 = (branch-name, loan-number, amount)  R 4 = (customer-name, loan-number) Final decomposition R 1, R 3, R 4

34. ©Silberschatz, Korth and Sudarshan7.34Database System Concepts BCNF and Dependency Preservation Banker-schema = (branch-name, customer-name, banker-name) FDs  banker-name -> branch-name  branch-name customer-name -> banker-name Banker-schema is not in BCNF (banker-name is not a super key) Decompose into  Banker-branch-schema = (banker-name, branch-name)  Customer-banker-schema = (customer-name, banker-name)  Dependency is not preserved It is not always possible to get a BCNF decomposition that is dependency preserving

35. ©Silberschatz, Korth and Sudarshan7.35Database System Concepts Third Normal Form: Motivation Not always possible to achieve:  Lossless join: essential  BCNF  Dependency preservation Third Normal Form.  A relaxtion of BCNF to achieve the lossless-join & dependency- preserving decomposition

36. ©Silberschatz, Korth and Sudarshan7.36Database System Concepts Third Normal Form A relation schema R is in third normal form (3NF) if for all    in F + at least one of the following holds:     is trivial (i.e.,    )   is a superkey for R  Each attribute A in  –  is contained in a candidate key for R. (NOTE: each attribute may be in a different candidate key) If a relation is in BCNF it is in 3NF Third condition is a minimal relaxation of BCNF to ensure dependency preservation

37. ©Silberschatz, Korth and Sudarshan7.37Database System Concepts Testing for 3NF Optimization: Need to check only FDs in F, need not check all FDs in F +. Use attribute closure to check for each dependency   , if  is a superkey. If  is not a superkey, we have to verify if each attribute in  is contained in a candidate key of R  This test is expensive, since it involves finding candidate keys  Testing for 3NF has been shown to be NP-hard  Fortunately, decomposition into third normal form can be done in polynomial time

38. ©Silberschatz, Korth and Sudarshan7.38Database System Concepts 3NF Decomposition Algorithm Let F c be a canonical cover for F; i := 0; for each functional dependency    in F c do if none of the schemas R j, 1  j  i contains   then begin i := i + 1; R i :=   end if none of the schemas R j, 1  j  i contains a candidate key for R then begin i := i + 1; R i := any candidate key for R; end return (R 1, R 2,..., R i )

39. ©Silberschatz, Korth and Sudarshan7.39Database System Concepts 3NF Decomposition Algorithm (Cont.) Above algorithm ensures:  each relation schema R i is in 3NF  decomposition is dependency preserving and lossless-join Example  Banker-info-schema = (branch-name, customer-name, banker-name, office- number)  FDs  banker-name -> branch-name office-number  customer-name branch-name -> banker-name  R0 = Banker-office-schema = (banker-name, branch-name, office-number)  R1 = Banker-schema = (customer, branch-name, banker-name)  R 1 contains a candidate key; therefore, 3NF decomp. Alg. Terminates  Lossless decomposition: R0  R1 -> R0  In R1, branch-name & banker-name can be repeated

40. ©Silberschatz, Korth and Sudarshan7.40Database System Concepts Comparison of BCNF and 3NF It is always possible to decompose a relation into relations in 3NF and  the decomposition is lossless  the dependencies are preserved  but the resulting schema may allow some redundancy It is always possible to decompose a relation into relations in BCNF and  the decomposition is lossless  it may not be possible to preserve dependencies.

41. ©Silberschatz, Korth and Sudarshan7.41Database System Concepts Design Goals Goal for a relational database design is:  BCNF.  Lossless join.  Dependency preservation. If we cannot achieve this, we accept one of  Lack of dependency preservation  Redundancy due to use of 3NF SQL does not provide a direct way of specifying functional dependencies other than superkeys.  Even if we had a dependency preserving decomposition, using SQL we would not be able to efficiently test a functional dependency whose left hand side is not a key.

42. ©Silberschatz, Korth and Sudarshan7.42Database System Concepts Testing for FDs Across Relations If decomposition is not dependency preserving, we can have an extra materialized view for each dependency   in F c that is not preserved in the decomposition Declare  as a candidate key on the materialized view Drawbacks  Space overhead: for storing the materialized view  Time overhead: Need to keep materialized view up to date when relations are updated  Database system may not support key declarations on materialized views

43. ©Silberschatz, Korth and Sudarshan7.43Database System Concepts Multivalued Dependencies MVD X  Y holds over a relation schema R if, in every legal instance r of R, each X value is associated with a set of Y values and this set is independent of the values in the other attributes. E.g., Consider a database classes(course, teacher, book) such that (c,t,b)  classes means that t is qualified to teach c, and b is a required textbook for c.  C  T  C  B

44. ©Silberschatz, Korth and Sudarshan7.44Database System Concepts There are no non-trivial functional dependencies and therefore the relation is in BCNF but there are redundancies courseteacherbook database operating systems Avi Hank Sudarshan Avi Jim DB Concepts Ullman DB Concepts Ullman DB Concepts Ullman OS Concepts Shaw OS Concepts Shaw classes Multivalued Dependencies (Cont.)

45. ©Silberschatz, Korth and Sudarshan7.45Database System Concepts Therefore, it is better to decompose classes into: courseteacher database operating systems Avi Hank Sudarshan Avi Jim teaches coursebook database operating systems DB Concepts Ullman OS Concepts Shaw text We shall see that these two relations are in Fourth Normal Form (4NF) Multivalued Dependencies (Cont.)

46. ©Silberschatz, Korth and Sudarshan7.46Database System Concepts Fourth Normal Form A relation schema R is in 4NF with respect to a set D of functional and multivalued dependencies if for all multivalued dependencies in D + of the form   , where   R and   R, at least one of the following hold:     is trivial (i.e.,    or    = R)   is a superkey for schema R If a relation is in 4NF it is in BCNF

47. ©Silberschatz, Korth and Sudarshan7.47Database System Concepts 4NF Decomposition Algorithm result: = {R}; done := false; compute D + ; Let D i denote the restriction of D + to R i while (not done) if (there is a schema R i in result that is not in 4NF) then begin let    be a nontrivial multivalued dependency that holds on R i such that   R i is not in D i, and    result := (result - R i )  (R i -  )  ( ,  ); end else done:= true; Note: each R i is in 4NF, and decomposition is lossless-join

48. ©Silberschatz, Korth and Sudarshan7.48Database System Concepts Further Normal Forms Join dependencies generalize multivalued dependencies  lead to project-join normal form (PJNF) (also called fifth normal form) A class of even more general constraints, leads to a normal form called domain-key normal form. Problem with these generalized constraints  Hard to reason with, and no set of sound and complete set of inference rules exists.  Hence rarely used

49. ©Silberschatz, Korth and Sudarshan7.49Database System Concepts Overall Database Design Process How to get an initial relation schema R?  Convert an E-R diagram to a set of tables.  R could have been a single relation containing all attributes that are of interest (called universal relation).  R could have been the result of some ad hoc design of relations. Test, convert & decompose relations to a normal form!!!

50. ©Silberschatz, Korth and Sudarshan7.50Database System Concepts Other Design Issues Some aspects of database design are not caught by normalization Examples of bad database design, to be avoided: Instead of earnings(company-id, year, amount), use  earnings-2000, earnings-2001, earnings-2002, etc., all on the schema (company-id, earnings).  BCNF, but make querying across years difficult and needs new table each year  company-year(company-id, earnings-2000, earnings-2001, earnings-2002)  Also in BCNF, but also makes querying across years difficult and requires new attribute each year.

51. End of Chapter