Relational Design Theory. Relational Design Theory. Example. Example. A badly designed schema can result in several anomalies.

Transcription

1 Relational Design Theory Relational Design Theory A badly designed schema can result in several anomalies Update-Anomalies: If we modify a single fact, we have to change several tuples Insert-Anomalies: When inserting a tuple, we can not provide values for all attributes (in the worst case, a key attribute is not available; result: the tuple can not be inserted) Delete-Anomalies: When deleting a tuple, we have to delete more information than intended Example Example A financial broker company is using a relational DBMS We have (B)roker with an (O)ffice. They service (I)nvestors that hold (S)tocks in a certain (Q)uantity. A stock can pay (D)ividends We have all attributes in a single relation: Finance(B, O, I, S, D, Q) B O I S D Q Finance Allianz BASF

2 Example Finance Revisited What happens if the office of is changed from to 127? What happens if we get a new broker Meier that does not yet service an investor? What happens if sells all his stocks and will no longer be a client? The quality of a schema can be formally checked It is obvious that the relation Finance contains redundant information: is the office of pays a dividend of is the broker of What is the reason for this redundancy? Some attributes determine the values of other attributes; we have functional dependencies Functional Dependancies Functional Dependancies (2) Example for a functional dependency (FD): The office is determined by the broker Broker Office Formal definition of a FD and are sets of attributes of a relational schema We have a FD, iff for all instances R of it holds: for all pairs of tuples r, t R we have: r. = t. r. = t. To find FDs we do not check the existing instances R! checking an instance can only show that a FD does not hold but can never prove the existence of a FD FDs have to be derived from the knowledge about the application domain What other FDs do exist for the relation Finance?

3 Functional Dependancies (3) Key F = {B O, S D, I B, IS Q} What do we do with these FDs? In the first step we derive the key(s) Properties of a key : There does not exist a with Property 2 is called completeness Property 3 is called minimality is also called candidate key (there can be more than one with the properties above) One candidate key is selected as the primary key When the properties 1 and 2 are fulfilled we call a superkey Key Derivation of additional FDs Is IS a key of Finance? Property 1: To check properties 2 and 3 we need additional concepts From a set F of FDs we can derive additional FDs F +, the set of all FDs that can be derived from F, is called the closure (Hülle) of F There exist inference rules, the Armstrong Axioms, to derive FDs

4 Armstrong Axioms Armstrong Axioms (2) Let, and be sets of Attributes of a relational Schema Then the following rules hold: Reflexivity: Augmentation : ( means ) Transitivity: and By means of the Armstrong Axioms we can derive all FDs that hold for the schema The following rules can be derived from the Armstrong Axioms and can often be handy: Union: and Decomposition: and Pseudotransitivity: and As the usage of the Armstrong Axioms is a bit cumbersome to determine the keys, we will usually use attribute closures Attribute Closure Attribute Closure (2) The attribute closure AC( ) of a set of attributes is the set of all attributes of, that functionally depend on We can use the following algorithm to determine AC( ) AC(IS) = SOISQD IS is complete IS is a superkey AC := while (AC did not stay the same) do for each FD in F do if ( AC) then AC := AC If we use different sets of FDs, we can also write AC(F, ) AC(I) = IBO AC(S) = SD IS is minimal IS is complete and minimal IS is a key

5 Determine Keys Checking the Quality of a Schema An algorithm to determine the keys of a relation 1. Starting point: all attributes, that are not contained in any right side of a FD these have to be part of each key 2. Calculate the attribute closure 3. As long the closure does not contain all attributes: Add an attribute that is not an element of the closure but contained in the left side of some FD calculate each time the attribute closure Check the minimality Depending on the order in which we add attributes in step 3, the generated set of attributes need not be minimal Depending on the order in which we add attributes in step 3, we get different keys Normal forms (NF) give us information about the quality of a schema Important normal forms: 1NF, 2NF, 3NF, BCNF, 4NF There exist some more, higher normal forms that are just of theoretical relevance First Normal Form (1NF) Second Normal Form (2NF) A relational schema is in 1NF, iff all attributes have only atomic domains Mother Anna Not in 1NF Father Hans parent Children {Lisa, David} Mother Anna Anna In 1NF parent Father Hans Hans Child Lisa David A relational schema is in 2NF, iff it is in 1NF and each nonkey attribute (NKA) is full functionally dependent on each key is full functionally dependent on ( ), iff und there does not exists an, so that Note: An attribute is a key-attribute (also called prime attribute) if it is part of at least one key Thus, an attribute is a NKA (also called non-prime attribute) if it is not contained in any (of possibly several) key In other words: A schema in 1NF is in 2NF iff no NKA is functionally dependent on any proper subset of a key

6 Second Normal Form (2NF) Third Normal Form (3NF) Example: Finance is not in 2NF as IS is a key and D a NKA but it holds: S D Violation of 2NF is a sign that different relationships between entities are contained in the same relation Even if 2NF is fulfilled we still have not eliminated redundancies that result from transitive dependencies A relational schema is in 3NF, iff for each FD at least one of the following properties is fulfilled: is trivial, i.e., is a superkey each attribute in is part of a key When 3NF is fulfilled we avoid transitive dependencies; these are dependencies in which NKAs depend indirectly via other NKAs on a key Boyce-Codd Normal Form (BCNF) Normal Forms In BCNF all attributes have to depend directly on the key A higher normal form implies all lower normal forms: A relational schema is in BCNF, iff for each FD at least one of the following properties is fulfilled: is trivial, i.e., is a superkey To describe redundancies that go beyond BCNF we need additional concepts beside FDs 4NF BCNF 3NF 2NF 1NF A higher normal form means that the quality of the schema is better, i.e., we reduce the redundancy What do we do if the quality of our current schema is not sufficient? We transform the schema into a higher normal form by means of decompositions

7 Decomposition of Relations Lossless Decomposition A relation can be decomposed into the relations 1,..., n, with i for1 i n A decomposition should have the following properties: lossless: we have to be able to reconstruct the instance R from the instances R 1,... R n (for all possible instances R) dependency preservation: all FDs in F shall be preserved in the F 1,...,F n Consider the decomposition of in 1 and 2 (with = 1 2 and R1 = 1 (R), R2 = 2 (R)) The decomposition is lossless iff for each possible instance R of it holds: R = R1AR2 A sufficient (but not necessary) condition for a lossless decomposition is: ( 1 2) 1 F + or R1 R R2 ( 1 2) 2 F + Example for a Violation of Losslessness Finance Example for a Violation of Losslessness B O I S D Q Finance 1AFinance 2 B Finance 1 O S I S D Q Finance B O I S D Q Finance

8 Lossless Decomposition Parents Father Mother Child Johann Martha Else Johann Maria Theo Father, Child Heinz Martha Cleo Fathers Father Child Johann Else Johann Theo Heinz Cleo Mother, Child Mothers Mother Child Martha Else Maria Theo Martha Cleo Lossless Decomposition of the Parents-Relation Parents(Father, Mother, Child) Fathers(Father, Child) Mothers(Mother, Child) Losslessness guaranteed We fulfill even both sufficient conditions: {Child} {Mother} {Child} {Father} Note: The decomposition of the relation Parents is lossless but there is no reason to perform a decomposition as the BCNF is fulfilled Dependency Preservation Violation of Dependency Preservation Consider a decomposition of in 1,..., n The decomposition is dependency preserving iff F (F 1... F n ) or written differently F + = (F 1... F n ) + In our previous example of the relation Finance we lose the FD I B. Therefore, it is not dependency preserving, either. ZIPdirectory(Street, City, State, ZIP) Assumptions A city can be uniquely identified by the combination its name (City) and state A street has only one ZIP-code A ZIP-code is used only within a single city A city is only within a single state This results in the following FDs {ZIP} {City, State} {Street, City, State} {Zip} Consider the following decomposition: Streets(ZIP, Street) Cities(ZIP, City, State)

9 Decomposition ZIPdirectory City State Street ZIP Frankfurt Hessen Goethestraße Frankfurt Hessen Galgenstraße Frankfurt Brandenburg Goethestraße ZIP, Street City, State, ZIP Streets Cities ZIP Street City State ZIP Goethestraße Frankfurt Hessen Goethestraße Frankfurt Hessen Galgenstraße Frankfurt Brandenburg The FD {Street, City, State} {ZIP} is not contained in the decomposed schema!!! Lost FD {City, State, Street} PLZ ZIPdirectory City State Street ZIP Frankfurt Hessen Goethestraße Frankfurt Hessen Galgenstraße Frankfurt Brandenburg Goethestraße ZIP, Street City, State, ZIP Streets Cities ZIP Street City State ZIP Goethestraße Goethestraße Galgenstraße Goethestraße Frankfurt Frankfurt Frankfurt Frankfurt Hessen Hessen Brandenburg Brandenburg Decomposition Algorithms Canonical Cover A decomposition is usually performed by appropriate algorithms that guarantee the required normal form Important algorithm: 3NF-synthesis algorithm Is decomposing a schema lossless and dependency preserving into 3NF Is based on set of FDs that is free from redundant attributes (canonical cover) F c is a canonical cover of F, iff the following three properties are fulfilled: F c F, i.e., F + c = F + In F c exist no FDs, with redundant attributes in or The left side of each FD in F c is unique. This can easily be achieved by applying the union-rule: If and, then it holds

10 Canonical Cover (2) Left-Reduction When do we have no redundant attributes? Apply for each FD F a left-reduction: A : (F c ( ) (( A) )) + F + c B : (F c ( ) ( ( B))) + F + c Check for each A, if A is redundant, i.e., if AC(F, A) If this is true, replace the FD by ( A) We can remove redundant attributes by means of left- and right-reduction Right-Reduction Two more Steps Apply for each FD F a right-reduction: Check for each B, if B is redundant, i.e., if B AC(F ( ) ( ( B)), ) If this is true, replace the FD by ( B) Remove all FDs in the form, that might be produced in a right-reduction Combine by means of the union rule FDs of the form 1,..., n so that we get n Then we have produced the canonical cover Depending on the order we process the FDs, we can get different canonical covers (but each of them is free from redundant attributes)

11 3NF-Synthesis Algorithm Example First Step: Create for each FD in F c a relation We apply the 3NF-synthesis algorithm to Finance with R = assign to R the FDs F := { F c R } F c = {B O, S D, I B, IS Q} Second Step: Add a relation R that contains the attributes of a key Third Step: Remove redundant relations, i.e., if R i R j, eliminate R i Result: R M (B, O) R A (S, D) R I (I, B) R IA (I, S, Q) Decomposition into BCNF Decomposition into BCNF There exist decomposition algorithms for higher normal forms like BCNF Problem: There exist schemas that can not be decomposed dependency preserving into BCNF Usually, we then stick to 3NF Start with Z = { } As long as there is a i Z that is not in BCNF: Take a FD ( ) F + with i = i F + Decompose i in i1 := and i2 := i - Remove i from Z and insert instead i1 and i2,i.e., Z := (Z { i }) { i1 } { i2 }

12 Decomposition of ZIPdirectory in BCNF Multivalued Dependencies ZIPdirectory(Street, City, State, ZIP) Skills FDs {ZIP} {City, State} {Street, City, State} {ZIP} Consider the following decomposition: Streets(ZIP, Street) Cities(ZIP, City, State) This decomposition is EmpNr Language English German English German English German ProgLang C C Java Java C C lossless but not dependency preserving In this schema we do not have FDs, but nevertheless we have redundancy Multivalued Dependencies (2) Multivalued Dependencies (3) For someone who is capable to handle five programming languages and speaks four natural languages we need 20 tuples to represent this information We have mixed independent concepts A more compact representation is possible: EmpNr Skills_1 Language English German English German EmpNr 3005 Skills_2 ProgLang C Java C There exist multivalued dependencies (MVDs) in this schema: EmpNr Language EmpNr ProgLang Formal definition: Let, with = and = ( ) iff for each instance R it holds: For each pair of tuples t 1, t 2 R with t 1. = t 2. there exists a tuple t 3 R with t 3. = t 1., t 3. = t 1. and t 3. = t 2. In other words: For all tuples with the same value for we have all possible, -combinations

13 Multivalued Dependencies (4) Fourth Normal Form (4NF) MVDs are a generalization of FDs, i.e., each FD is a MVD (but not necessary the other way round) In the fourth normal form (4NF) the properties of BCNF are extended to MVDs Similar to the Armstrong Axioms, the exist rules to derive dependencies also for MVDs (we do not discuss details) A relational schema is in 4NF, iff for each MVD at least one of the following properties is fulfilled: Just one important property of MVDs: for = ( ) is trivial, i.e., OR = R is a superkey It holds : 4NF BCNF Therefore, we have the same problem as for BCNF: schemas exist that that cannot be decomposed without violating dependency preservation Decomposition into 4NF Start with Z = { } As long as there is a i Z that is not in 4NF: Take a MVD ( ) F + with i = i F + Decompose i in i1 := and i2 := i - Remove i from Z and insert instead i1 and i2,i.e., Z := (Z { i }) { i1 } { i2 } Functional Dependencies as Integrity Constraints Functional dependencies can be considered as integrity constraints It is desirable to let the DBMS check these integrity constraints This is simple in the case that BCNF is fulfilled We can formulate the set of FDs so that for each FD we have a key on the left side Then we can declare one key as primary key and the others as unique

14 Chosing the Primary Key in Practice (1) Chosing the Primary Key in Practice (2) The primary key is often used in other relations as a foreign key Therefore, the primary key should be simple and compact It is therefore common to use as a primary key an additional, artificial attribute Many DBMS support the automatic generation of unique values for such attributes by means of (vendor specific) extensions Example in HSQLDB: create table Professor ( Prof_ID integer identity primary key, ProfNr integer, PName varchar(80), RoomNr integer, unique (ProfNr), unique (PName) ) Other systems use keywords like autoincrement or auto_increment The automatic assignment of a value takes place when insert a tuple and use null for this attribute: insert into Professor values (null, 12345, '', 107) Summary Functional Dependencies (FDs) Goal: Determine the highest normal form Step 1: Identify all FDs Step 2: Determine all keys Step 3: Check the conditions for the normal forms Step 4: If necessary: Decompose the relation into different relations so that each one fulfills the desired normal form Step 1: Identify all FDs Can only be performed by analyzing the application semantics Is to a certain extend a modeling decision. Thus, different people might produce different results Can not be performed by looking at example tables Even if people agree on the existing dependencies, the dependencies might be formulated differently Example: R(A, B, C) Variant 1: F1 = {A B, B A, A C} Variant 2: F2 = {A B, B A, B C} When comparing different sets of FDs, we have to check the closure, i.e., the set of FDs that can be derived using the Armstrong Axioms. In our example it holds F1 + = F2 + Therefore, both sets are equivalent

15 Keys Normal Forms (1) Step 2: Determine all keys Step 3: Check the conditions for the normal forms Why all? Some conditions are fulfilled, if they hold for an (arbitrary) key Only if we have checked all keys, we know that such a condition is violated Example: An attribute is a NKA, if it is not part of any key How? Use the given algorithm Start with 1NF/2NF and proceed step by step to more restrictive ones Note: if one normal form is violated, all higher ones are also violated Normal Forms (2) Normal Forms (3) Test for 2NF Test for 3NF / BCNF Starting point: all keys and all NKAs (and indirectly all FDs) Approach 1: Consider all NKAs and determine for each NKA the sets of attributes from which it is dependent. If it is dependent on a proper subset of a key, the 2NF is violated. Approach 2: Consider for each key every proper subset and calculate the attribute closure. If we find a NKA in such a closure, the 2NF is violated. 2NF is trivially fulfilled if no NKA exists or all keys have just one attribute Starting point: all keys and all FDs Consider all FDs and check whether one of the three (or two for BCNF) conditions is fulfilled. If we find a FD that violates all conditions, the normal form is violated. Test for 4NF Like above but also take into account MVDs