Schema Refinement and Normal Forms. Why schema refinement?

Transcription

1 Schema Refinement and Normal Forms Why schema refinement? Consider relation obtained from Hourly_Emps: Hourly_Emps (sin,rating,hourly_wages,hourly_worked) Problems: Update Anomaly: Can we change the wages only in the 1st tuple? Insertion Anomaly: What if we want to insert an employee and don t know the hourly wage for her/his rating? Insertion Anomaly II: We can only introduce a new rating scheme when we enter an employee with this rating into the relation Deletion Anomaly: If we delete all employees with rating 5, we lose the information about the wage for rating 5! Storage Redundancy sin rat wages hours

2 Recall Course Entity-Set A course term course id (special format) CRN type credits title days time capacity enrollment one or more instructors room 3 Functional Dependencies (FDs) A functional dependency X Y (X and Y are sets of attributes; X,Y schema(r)) holds over relation R if for every allowable instance r of R: Given two tuples t1 and t2 in instance r of R, if the X values of t1 and t2 agree, then the Y values must also agree t1 r, t2 r, π X (t1) = π X (t2) implies π Y (t1) = π Y (t2) FDs are determined by the semantics of the application no two courses can meet in the same room at the same time {room, time} {course} Or short: room, time course course-id --> title Key candidates: Let schema(r) = (a1,a2, an); a set of attributes X schema(r) is a candidate key for a relation R if X R (= X a1,a2, an) i.e., X implies all attributes of R (typically, the key K of an entity-set has been chosen exactly because K R) 4 2

3 FDs (contd.) An FD is a constraint on all allowable instances of a relation R (on data that might appear in R) Given some instance r of R, we can check if it violates some FD f, but we CANNOT deduce that some FD f holds over R only because it holds over r Goal (very informal): a relation should only contain key induced FDs We will see that other FDs lead to some form of redundancy We achieve this goal by decomposing relations into smaller relations 5 Example FDs Consider relation obtained from Hourly_Emps: Hourly_Emps (sin,rating,hourly_wages,hourly_worked) Notation: we will denote this relation schema by listing the attributes SRWH Some FDs on Hourly_Emps: sin is the key: S SRWH rating determines hourly_wages: R W S R W H

4 Example Redundancy Anomalies Update/Insertion/Deletion Anomalies due to R W How to solve the problems? Wages is an entity set by itself with two attributes. S R W H S R H R W Reasoning about FDs Armstrong s Axioms (X, Y, Z are sets of attributes,i.e, X,Y,Z schema(r)): Reflexivity: If Y X, then X Y Augmentation: If X Y, then XZ YZ for any Z Transitivity: If X Y and Y Z, then X Z These are sound and complete inference rules for FDs (only deduce FDs that hold and deduce all FDs) Given a set of FDs F F + = closure of F: set of all FDs that are implied by F through Armstrong s Axioms Some additional rules (that follow from AA): Union: If X Y and X Z, then X YZ Decomposition: If X YZ, then X Y and X Z 8 4

5 Examples Hourly_Emp(sin, rating, hourly_wages, hours_worked) Reflexivity (I call this trivial FDs): {sin} --> {sin} or short sin --> sin {rating} --> {rating} or short rating --> rating {hourly_wages, hours_worked} --> {hourly_wages} Augmentation (I again call this trivial FDs) rating, hours_worked --> hourly_wages, hours_worked A --> B and Z --> Z therefore A, Z --> B, Z Transitivity (NOT trivial) sin --> rating and rating --> hourly_wages therefore sin --> hourly_wages Union (also kind of trivial) sin --> rating and sin --> hours_worked therefore sin --> rating, hourly_worked A --> B and A --> C, therefore A --> B,C Decomposition sin --> rating, hourly_wages, hours_worked therefore sin --> rating sin --> hourly_wages sin --> hours_worked 9 Attribute Closure Attribute closure of X = X + wrt F: set of all attributes A such that X A is in F + Basis: X + = X Induction: If Z X +, and Z A is in F, then add A to X + End when X + cannot be changed Linear time Example F = {A B, BC D} : A + = AB, B + = B, C + = C, (AB) + = AB More precise: {A} + = {A, B}, {B} + = {B}, {C} + = {C}, {AB} + = {A,B} (BC) + = BCD, (AC) + = ABCD 10 5

6 Finding all key candidates Given a set of FDs F for a relation a set of attributes X is a key candidate if X R in F + and there is no subset Y X such that Y R sin --> sin, rating, hours_worked, hourly_wages given a set of FDs F for a relation R X is a key candidate if X + = R und there is no subset Y of X such that Y + = R {sin} + = {sin, rating, hours_worked, hourly_wages} 11 Example Bottom Up R(S,C,R,P) and CS P, CS R, CR S S=student-id, C=course-id, R=ranking, P=examining prof. CS P: a student has in a given course only one examining prof. CS R: in a given course a student receives exactly one ranking CR S: in a given course a specific ranking value can only be assigned to one student (relative evaluation of students) Key candidates Informal Reasoning S + = {S}, C + = {C}, R + = {R}, P + = {P} No attribute alone is primary (SC) + = {S,C,R,P} key because of CS P and CS R C is not on the right site of any (SR) + = {S, R}, (SP) + = FD, therefore it must be part {S,P} of any candidate key (CR) + = {C,R,S,P} CS is key candidate as shown because of CR S and then CS P on the left (CP) + = {C,P}, (RP) + = {R,P} CR is key candidate as shown (SRP) + on the left = {S, R, P} CP is not candidate Not interesting: No 3-attribute or 4-attribute (SCR) + / (SCP) + / (CRP) + / (SCRP) + = superkey set is key candidate because It either does not contain C Or it is a superset of CS or CR 12 6

7 Normalization Remind the relation between redundancy anomalies and FDs Only key-induced FDs hold: there is no redundancy Given A B and A is not key candidate: several tuples could have the same A value, and if so, they ll have the same B value! If a relation is in a certain normal form (BCNF, 3NF) it is known that only certain kind of FDs hold. Hence, some forms of anomalies are avoided or minimized. 13 BCNF and 3NF A relation R with FDs F is in Boyce-Codd Normal Form (BCNF) if for all X A in F+ A X (trivial FDs) or X contains a key for R (X is superkey) In other words, R is in BCNF if the only non-trivial FDs that hold over R are key constraints. If there are two tuples that agree upon the X value we cannot infer the A value in one tuple from the A value in the other tuple A relation R with FDs F is in 3NF (3rd Normal Form), if for all X A in F+ A X (trivial FDs) or X contains a key for R (X is superkey) or A is part of some key for R. If R is in BCNF, then it is in 3NF X A x a x? 14 7

8 Examples An additional FD Hourly_Emps (sin,rating,hourly_wages,hourly_worked) S SRWH (sin key) and R W (rating determines wages) R W violates both BCNF and 3NF conditions Dependency only on subkey Works In(sin,did,daddress) Did daddress violates both BCNF and 3NF Hourly_Emps2 and Wages Hourly_Emps2 (sin,rating,hourly_worked) Wages (rating, hourly_wages) Physics Course Time Room 421 T TH M 2-4 Aaud Room time course, course room Key candidates are {room, time} and {time, course} The FD course room violates the BCNF condition. The FD course room does not violate 3NF since room part of a key candidate 3NF means third normal form. 1NF and 2NF do exist, but only of historical interest 15 Decomposition If a relation is not in the desired normal form we decompose it: given relation R with attributes A1 An. A decomposition of R consists of replacing R by two or more relations such that Each new relation scheme contains a subset of the attributes of R (and no attributes that do not appear in R), and Every attribute of R appears as an attribute in one of the new relations The tuples of R are split such that the corresponding subtuples appear in the new relations. For instance, decompose Hourly_Emps SRWH into SRH and RW Tuples of SRH: π SRH (SRWH) Tuples of RW: π RW (SRWH) Disadvantage of Decomposition: some queries become more expensive since several relations must be joined (salary = wages * hours) 16 8

9 Lossless Join Decompositions A decomposition of schema R into schemas R1 with attribute set X and R2 with attribute set Y is lossless-join w.r.t. to a set of FDs F, if for any instance r of R satisfying F, π X (r) π y (r) = r I.e., we can reconstruct r by joining the corresponding decomposed relation instances r1 and r2. Lossless decomposition is crucial! A B C π AB (r) = r1 π BC(r) = r2 Decomp. A B B C Reconstruction r1 r2 A B C Lossless Join Decompositions The decomposition of R into R1 and R2 is lossless-join wrt F if and only if the closure of F contains Let {a1, an} be the set of attributes that are both in R1 and R2: then {a1, an} R1 or {a1,.. an} R2 In particular, if U V (non trivial) holds over R then the decomposition of R into UV and R-V is lossless-join (rejoin does not create new tuples because U is key in UV and foreign key in R-V). We denote this as a decomposition along FD U V S R W H S R H R W

10 Decomposition into BCNF Given relation R with FDs F and X Y FD violating BCNF Compute X + (cannot be all attributes!) Decompose R into X + and (R - X + ) X. Repeat until all relations in BCNF. R X X + If X + = {X,Y} we denote this as a decomposition along X Y Decomposition is lossless join Example CSJDPV, key C, JP C, SD P, J S Determine key candidates: C, JP, DJ SD P violates BCNF (SD)+ = {S, D, P} decompose into SDP, CSJDV along FD SD P Only FD in SDP is SD P; SD key candidate for this relation, so in BCNF FDs in CSJDV are C CSJDV and J S; C key candidate, J S violates BCNF for CSJDV decompose CSJDV into JS and CJDV along J S For JS, F+ = {J S}; J is key candidate for this relation, so in BCNF For CJDV, F+ = {C CSJDV}; C key candidate for this relation, so in BCNF In general, several dependencies may cause violation of BCNF. The order in which we deal with them could lead to very different sets of relations Note that we only need to look at F, not at F BCNF and Dependency Preservation Dependency preserving decomposition (intuitive) Give relation R with FDs F. A dependency preserving decomposition allows us to check each dependency in F by looking at one of the decomposed relations. Not all BCNF decompositions are dependency preserving E.g., given CSJDPV, key C, JP C, SD P, J S: Decompose into SDP, JS and CJDQV (covering SD P and J S) But now checking JP C requires a join! Example 2: time room course, course room Keys are {time, room} and {time, course}, but course room has a left side which is not a superkey Decompose along course room: R1(course,room) and R2(course,time) Problem: you can only check the FD time room course when joining R1 and R2 Possible workaround in some situations E.g., in CSJDPV example above, add JPC to the collection of relations; note that JPC tuples only stored for checking FD on a single relation (Redundancy!) 20 10

11 3NF is Dependency Preserving We can decompose any relation R with an arbitrary set FD, such that all decomposed relations are in 3NF and the decomposition is dependency preserving. However, it might happen that not all dependencies are key induced dependencies Room time course, course room Key candidates are {room, time} and {time, course} The FD course room does not violate 3NF since room part of a key. However, it cannot be guaranteed by the key condition but must be guaranteed by other forms of constraints. Obviously, the algorithm for decomposition into BCNF can be used to obtain a decomposition into 3NF (typically can stop earlier) but it does not preserve dependencies