Relational Design Theory. Relational Design Theory. Example. Example. A badly designed schema can result in several anomalies.
|
|
- Jemima Porter
- 5 years ago
- Views:
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
Relational Design Theory
Chapter 5 Relational Design Theory Database Systems p. 211/569 Relational Design Theory A badly designed schema can cause a lot of trouble Database designers talk of anomalies and distinguish three different
More informationFunctional Dependencies CS 1270
Functional Dependencies CS 1270 Constraints We use constraints to enforce semantic requirements on a DBMS Predicates that the DBMS must ensure to be always true. Predicates are checked when the DBMS chooses
More informationElmasri/Navathe, Fundamentals of Database Systems, Fourth Edition Chapter 10-2
Elmasri/Navathe, Fundamentals of Database Systems, Fourth Edition Chapter 10-2 Chapter Outline 1 Informal Design Guidelines for Relational Databases 1.1Semantics of the Relation Attributes 1.2 Redundant
More informationRelational Design: Characteristics of Well-designed DB
1. Minimal duplication Relational Design: Characteristics of Well-designed DB Consider table newfaculty (Result of F aculty T each Course) Id Lname Off Bldg Phone Salary Numb Dept Lvl MaxSz 20000 Cotts
More informationNormalization. Murali Mani. What and Why Normalization? To remove potential redundancy in design
1 Normalization What and Why Normalization? To remove potential redundancy in design Redundancy causes several anomalies: insert, delete and update Normalization uses concept of dependencies Functional
More informationUNIT 3 DATABASE DESIGN
UNIT 3 DATABASE DESIGN Objective To study design guidelines for relational databases. To know about Functional dependencies. To have an understanding on First, Second, Third Normal forms To study about
More informationChapter 10. Chapter Outline. Chapter Outline. Functional Dependencies and Normalization for Relational Databases
Chapter 10 Functional Dependencies and Normalization for Relational Databases Chapter Outline 1 Informal Design Guidelines for Relational Databases 1.1Semantics of the Relation Attributes 1.2 Redundant
More informationChapter 8: Relational Database Design
Chapter 8: Relational Database Design Database System Concepts, 6 th Ed. See www.db-book.com for conditions on re-use Chapter 8: Relational Database Design Features of Good Relational Design Atomic Domains
More informationUnit 3 : Relational Database Design
Unit 3 : Relational Database Design Database System Concepts, 6 th Ed. See www.db-book.com for conditions on re-use Content Relational Model: Basic concepts, Attributes and Domains, CODD's Rules, Relational
More informationCOSC Dr. Ramon Lawrence. Emp Relation
COSC 304 Introduction to Database Systems Normalization Dr. Ramon Lawrence University of British Columbia Okanagan ramon.lawrence@ubc.ca Normalization Normalization is a technique for producing relations
More informationChapter 10. Normalization. Chapter Outline. Chapter Outline(contd.)
Chapter 10 Normalization Chapter Outline 1 Informal Design Guidelines for Relational Databases 1.1Semantics of the Relation Attributes 1.2 Redundant Information in Tuples and Update Anomalies 1.3 Null
More informationChapter 14. Database Design Theory: Introduction to Normalization Using Functional and Multivalued Dependencies
Chapter 14 Database Design Theory: Introduction to Normalization Using Functional and Multivalued Dependencies Copyright 2012 Ramez Elmasri and Shamkant B. Navathe Chapter Outline 1 Informal Design Guidelines
More informationFunctional Dependencies and. Databases. 1 Informal Design Guidelines for Relational Databases. 4 General Normal Form Definitions (For Multiple Keys)
1 / 13 1 Informal Design Guidelines for Relational Databases 1.1Semantics of the Relation Attributes 1.2 Redundant d Information in Tuples and Update Anomalies 1.3 Null Values in Tuples 1.4 Spurious Tuples
More informationInformal Design Guidelines for Relational Databases
Outline Informal Design Guidelines for Relational Databases Semantics of the Relation Attributes Redundant Information in Tuples and Update Anomalies Null Values in Tuples Spurious Tuples Functional Dependencies
More informationRELATIONAL DESIGN THEORY / LECTURE 4 TIM KRASKA
RELATIONAL DESIGN THEORY 6.830 / 6.814 LECTURE 4 TIM KRASKA RECAP Physical Independence Logical Independence Simplified Zoo Relations animals name age species cageno keptby feedtime mike 13 giraffe 1 1
More informationDatabase Design Theory and Normalization. CS 377: Database Systems
Database Design Theory and Normalization CS 377: Database Systems Recap: What Has Been Covered Lectures 1-2: Database Overview & Concepts Lecture 4: Representational Model (Relational Model) & Mapping
More informationRelational Database design. Slides By: Shree Jaswal
Relational Database design Slides By: Shree Jaswal Topics: Design guidelines for relational schema, Functional Dependencies, Definition of Normal Forms- 1NF, 2NF, 3NF, BCNF, Converting Relational Schema
More informationSchema Refinement: Dependencies and Normal Forms
Schema Refinement: Dependencies and Normal Forms M. Tamer Özsu David R. Cheriton School of Computer Science University of Waterloo CS 348 Introduction to Database Management Fall 2012 CS 348 Schema Refinement
More informationSchema Refinement: Dependencies and Normal Forms
Schema Refinement: Dependencies and Normal Forms Grant Weddell David R. Cheriton School of Computer Science University of Waterloo CS 348 Introduction to Database Management Spring 2012 CS 348 (Intro to
More informationNormalization. VI. Normalization of Database Tables. Need for Normalization. Normalization Process. Review of Functional Dependence Concepts
VI. Normalization of Database Tables Normalization Evaluating and correcting relational schema designs to minimize data redundancies Reduces data anomalies Assigns attributes to tables based on functional
More informationRelational Database Design Theory. Introduction to Databases CompSci 316 Fall 2017
Relational Database Design Theory Introduction to Databases CompSci 316 Fall 2017 2 Announcements (Thu. Sep. 14) Homework #1 due next Tuesday (11:59pm) Course project description posted Read it! Mixer
More informationCopyright 2016 Ramez Elmasri and Shamkant B. Navathe
CHAPTER 14 Basics of Functional Dependencies and Normalization for Relational Databases Slide 14-2 Chapter Outline 1 Informal Design Guidelines for Relational Databases 1.1 Semantics of the Relation Attributes
More informationFunctional Dependencies and Normalization for Relational Databases Design & Analysis of Database Systems
Functional Dependencies and Normalization for Relational Databases 406.426 Design & Analysis of Database Systems Jonghun Park jonghun@snu.ac.kr Dept. of Industrial Engineering Seoul National University
More informationFunctional Dependencies & Normalization for Relational DBs. Truong Tuan Anh CSE-HCMUT
Functional Dependencies & Normalization for Relational DBs Truong Tuan Anh CSE-HCMUT 1 2 Contents 1 Introduction 2 Functional dependencies (FDs) 3 Normalization 4 Relational database schema design algorithms
More informationDatabase Management System Prof. Partha Pratim Das Department of Computer Science & Engineering Indian Institute of Technology, Kharagpur
Database Management System Prof. Partha Pratim Das Department of Computer Science & Engineering Indian Institute of Technology, Kharagpur Lecture - 19 Relational Database Design (Contd.) Welcome to module
More informationSchema Refinement: Dependencies and Normal Forms
Schema Refinement: Dependencies and Normal Forms Grant Weddell Cheriton School of Computer Science University of Waterloo CS 348 Introduction to Database Management Spring 2016 CS 348 (Intro to DB Mgmt)
More informationRelational Database Design (II)
Relational Database Design (II) 1 Roadmap of This Lecture Algorithms for Functional Dependencies (cont d) Decomposition Using Multi-valued Dependencies More Normal Form Database-Design Process Modeling
More informationDatabases -Normalization I. (GF Royle, N Spadaccini ) Databases - Normalization I 1 / 24
Databases -Normalization I (GF Royle, N Spadaccini 2006-2010) Databases - Normalization I 1 / 24 This lecture This lecture introduces normal forms, decomposition and normalization. We will explore problems
More informationChapter 7: Relational Database Design
Chapter 7: Relational Database Design Database System Concepts, 5th Ed. See www.db-book.com for conditions on re-use Chapter 7: Relational Database Design Features of Good Relational Design Atomic Domains
More informationCSE 544 Principles of Database Management Systems. Magdalena Balazinska Winter 2009 Lecture 4 - Schema Normalization
CSE 544 Principles of Database Management Systems Magdalena Balazinska Winter 2009 Lecture 4 - Schema Normalization References R&G Book. Chapter 19: Schema refinement and normal forms Also relevant to
More informationPart V Relational Database Design Theory
Part V Relational Database Design Theory Relational Database Design Theory 1 Target Model of the Logical Design 2 Relational DB Design 3 Normal Forms 4 Transformation Properties 5 Design Methods Saake
More informationCS 2451 Database Systems: Database and Schema Design
CS 2451 Database Systems: Database and Schema Design http://www.seas.gwu.edu/~bhagiweb/cs2541 Spring 2018 Instructor: Dr. Bhagi Narahari Relational Model: Definitions Review Relations/tables, Attributes/Columns,
More informationHandout 3: Functional Dependencies and Normalization
Virginia Tech. Computer Science CS 4604 Introduction to DBMS Spring 2015, Prakash Handout 3: Functional Dependencies and Normalization Q1: Inferring FDs Consider the following schemas and sets of functional
More informationThis lecture. Databases -Normalization I. Repeating Data. Redundancy. This lecture introduces normal forms, decomposition and normalization.
This lecture Databases -Normalization I This lecture introduces normal forms, decomposition and normalization (GF Royle 2006-8, N Spadaccini 2008) Databases - Normalization I 1 / 23 (GF Royle 2006-8, N
More informationData Modeling and Databases Ch 6: Normal Forms. Gustavo Alonso, Ce Zhang Systems Group Department of Computer Science ETH Zürich
Data Modeling and Databases Ch 6: Normal Forms Gustavo Alonso, Ce Zhang Systems Group Department of Computer Science ETH Zürich Relational Design Theory Assess the quality of a schema redundancy integrity
More informationRelational Database Systems 1
Relational Database Systems 1 Wolf-Tilo Balke Simon Barthel Institut für Informationssysteme Technische Universität Braunschweig www.ifis.cs.tu-bs.de 10.0 Introduction Up to now, we have learned......
More informationSteps in normalisation. Steps in normalisation 7/15/2014
Introduction to normalisation Normalisation Normalisation = a formal process for deciding which attributes should be grouped together in a relation Normalisation is the process of decomposing relations
More informationLecture 6a Design Theory and Normalization 2/2
CompSci 516 Data Intensive Computing Systems Lecture 6a Design Theory and Normalization 2/2 Instructor: Sudeepa Roy 1 HW1 deadline: Announcements Due on 09/21 (Thurs), 11:55 pm, no late days Project proposal
More informationDatabase Design Principles
Database Design Principles CPS352: Database Systems Simon Miner Gordon College Last Revised: 2/11/15 Agenda Check-in Design Project ERD Presentations Database Design Principles Decomposition Functional
More informationRelational Database Systems 1. Christoph Lofi Simon Barthel Institut für Informationssysteme Technische Universität Braunschweig
Relational Database Systems 1 Christoph Lofi Simon Barthel Institut für Informationssysteme Technische Universität Braunschweig www.ifis.cs.tu-bs.de 10.0 Introduction Up to now, we have learned... how
More informationNormalisation. Normalisation. Normalisation
Normalisation Normalisation Main objective in developing a logical data model for relational database systems is to create an accurate and efficient representation of the data, its relationships, and constraints
More informationTheory of Normal Forms Decomposition of Relations. Overview
.. Winter 2008 CPE/CSC 366: Database Modeling, Design and Implementation Alexander Dekhtyar.. Overview Theory of Normal Forms Decomposition of Relations Functional Dependencies capture the attribute dependencies
More informationUNIT -III. Two Marks. The main goal of normalization is to reduce redundant data. Normalization is based on functional dependencies.
UNIT -III Relational Database Design: Features of Good Relational Designs- Atomic Domains and First Normal Form- Second Normal Form-Decomposition Using Functional Dependencies- Functional-Dependency Theory-Algorithms
More informationFUNCTIONAL DEPENDENCIES
FUNCTIONAL DEPENDENCIES CS 564- Spring 2018 ACKs: Dan Suciu, Jignesh Patel, AnHai Doan WHAT IS THIS LECTURE ABOUT? Database Design Theory: Functional Dependencies Armstrong s rules The Closure Algorithm
More informationThe strategy for achieving a good design is to decompose a badly designed relation appropriately.
The strategy for achieving a good design is to decompose a badly designed relation appropriately. Functional Dependencies The single most important concept in relational schema design theory is that of
More informationDatabases The theory of relational database design Lectures for m
Databases The theory of relational database design Lectures for mathematics students April 2, 2017 General introduction Look; that s why there s rules, understand? So that you think before you break em.
More informationMODULE: 3 FUNCTIONAL DEPENDENCIES
MODULE: 3 (13 hours) Database design: functional dependencies - Inference Rules for Functional Dependencies - Closure -- Minimal Cover -Normal forms First-second and third normal forms Boyce- Codd normal
More informationCS 338 Functional Dependencies
CS 338 Functional Dependencies Bojana Bislimovska Winter 2016 Outline Design Guidelines for Relation Schemas Functional Dependency Set and Attribute Closure Schema Decomposition Boyce-Codd Normal Form
More information5 Normalization:Quality of relational designs
5 Normalization:Quality of relational designs 5.1 Functional Dependencies 5.1.1 Design quality 5.1.2 Update anomalies 5.1.3 Functional Dependencies: definition 5.1.4 Properties of Functional Dependencies
More informationCSE 544 Principles of Database Management Systems. Magdalena Balazinska Fall 2009 Lecture 3 - Schema Normalization
CSE 544 Principles of Database Management Systems Magdalena Balazinska Fall 2009 Lecture 3 - Schema Normalization References R&G Book. Chapter 19: Schema refinement and normal forms Also relevant to this
More informationMapping ER Diagrams to. Relations (Cont d) Mapping ER Diagrams to. Exercise. Relations. Mapping ER Diagrams to Relations (Cont d) Exercise
CSC 74 Database Management Systems Topic #6: Database Design Weak Entity Type E Create a relation R Include all simple attributes and simple components of composite attributes. Include the primary key
More informationFunctional dependency theory
Functional dependency theory Introduction to Database Design 2012, Lecture 8 Course evaluation Recalling normal forms Functional dependency theory Computing closures of attribute sets BCNF decomposition
More informationCSE 562 Database Systems
Goal CSE 562 Database Systems Question: The relational model is great, but how do I go about designing my database schema? Database Design Some slides are based or modified from originals by Magdalena
More informationDatabase Systems. Basics of the Relational Data Model
Database Systems Relational Design Theory Jens Otten University of Oslo Jens Otten (UiO) Database Systems Relational Design Theory INF3100 Spring 18 1 / 30 Basics of the Relational Data Model title year
More informationFunctional Dependencies and Normalization
Functional Dependencies and Normalization Jose M. Peña jose.m.pena@liu.se Overview Real world Databases DBMS Model Physical database Queries Processing of queries and updates Access to stored data Answers
More informationRelational Database Design. Announcements. Database (schema) design. CPS 216 Advanced Database Systems. DB2 accounts have been set up
Relational Database Design CPS 216 Advanced Database Systems Announcements 2 DB2 accounts have been set up Let me know if you have not received an email from me regarding your account Recitation session
More informationFunctional Dependencies and Finding a Minimal Cover
Functional Dependencies and Finding a Minimal Cover Robert Soulé 1 Normalization An anomaly occurs in a database when you can update, insert, or delete data, and get undesired side-effects. These side
More informationRelational Database Systems 1 Wolf-Tilo Balke Hermann Kroll, Janus Wawrzinek, Stephan Mennicke
Relational Database Systems 1 Wolf-Tilo Balke Hermann Kroll, Janus Wawrzinek, Stephan Mennicke Institut für Informationssysteme Technische Universität Braunschweig www.ifis.cs.tu-bs.de 10.0 Introduction
More informationCSCI 403: Databases 13 - Functional Dependencies and Normalization
CSCI 403: Databases 13 - Functional Dependencies and Normalization Introduction The point of this lecture material is to discuss some objective measures of the goodness of a database schema. The method
More informationcustomer = (customer_id, _ customer_name, customer_street,
Relational Database Design COMPILED BY: RITURAJ JAIN The Banking Schema branch = (branch_name, branch_city, assets) customer = (customer_id, _ customer_name, customer_street, customer_city) account = (account_number,
More information5 Normalization:Quality of relational designs
5 Normalization:Quality of relational designs 5.1 Functional Dependencies 5.1.1 Design quality 5.1.2 Update anomalies 5.1.3 Functional Dependencies: definition 5.1.4 Properties of Functional Dependencies
More informationDesign Theory for Relational Databases
By Marina Barsky Design Theory for Relational Databases Lecture 15 Functional dependencies: formal definition X Y is an assertion about a relation R that whenever two tuples of R agree on all the attributes
More informationIJREAS Volume 2, Issue 2 (February 2012) ISSN: COMPARING MANUAL AND AUTOMATIC NORMALIZATION TECHNIQUES FOR RELATIONAL DATABASE ABSTRACT
COMPARING MANUAL AND AUTOMATIC NORMALIZATION TECHNIQUES FOR RELATIONAL DATABASE Sherry Verma * ABSTRACT Normalization is a process of analyzing the given relation schemas based on their Functional dependencies
More informationHomework 6: FDs, NFs and XML (due April 13 th, 2016, 4:00pm, hard-copy in-class please)
Virginia Tech. Computer Science CS 4604 Introduction to DBMS Spring 2016, Prakash Homework 6: FDs, NFs and XML (due April 13 th, 2016, 4:00pm, hard-copy in-class please) Reminders: a. Out of 100 points.
More informationINTRODUCTION TO RELATIONAL DATABASE SYSTEMS
INTRODUCTION TO RELATIONAL DATABASE SYSTEMS DATENBANKSYSTEME 1 (INF 3131) Torsten Grust Universität Tübingen Winter 2015/16 1 LEGO BUILDING INSTRUCTIONS Each LEGO set comes with building instructions,
More informationChapter 16. Relational Database Design Algorithms. Database Design Approaches. Top-Down Design
Chapter 16 Relational Database Design Algorithms Database Design Approaches Top-Down design (Starting with conceptual design) Bottom-Up Design (relational synthesis) 2 Top-Down Design Design conceptual
More informationV. Database Design CS448/ How to obtain a good relational database schema
V. How to obtain a good relational database schema Deriving new relational schema from ER-diagrams Normal forms: use of constraints in evaluating existing relational schema CS448/648 1 Translating an E-R
More informationPart II: Using FD Theory to do Database Design
Part II: Using FD Theory to do Database Design 32 Recall that poorly designed table? part manufacturer manaddress seller selleraddress price 1983 Hammers R Us 99 Pinecrest ABC 1229 Bloor W 5.59 8624 Lee
More informationCS411 Database Systems. 05: Relational Schema Design Ch , except and
CS411 Database Systems 05: Relational Schema Design Ch. 3.1-3.5, except 3.4.2-3.4.3 and 3.5.3. 1 How does this fit in? ER Diagrams: Data Definition Translation to Relational Schema: Data Definition Relational
More informationConcepts from
1 Concepts from 3.1-3.2 Functional dependencies Keys & superkeys of a relation Reasoning about FDs Closure of a set of attributes Closure of a set of FDs Minimal basis for a set of FDs 2 Plan How can we
More informationChapter 14 Outline. Normalization for Relational Databases: Outline. Chapter 14: Basics of Functional Dependencies and
Ramez Elmasri, Shamkant B. Navathe(2016) Fundamentals of Database Systems (7th Edition), pearson, isbn 10: 0-13-397077-9;isbn-13:978-0-13-397077-7. Chapter 14: Basics of Functional Dependencies and Normalization
More informationNormalization. Anomalies Functional Dependencies Closures Key Computation Projecting Relations BCNF Reconstructing Information Other Normal Forms
Anomalies Functional Dependencies Closures Key Computation Projecting Relations BCNF Reconstructing Information Other Normal Forms Normalization Niklas Fors (niklas.fors@cs.lth.se) Normalization 1 / 45
More informationDATABASE MANAGEMENT SYSTEM SHORT QUESTIONS. QUESTION 1: What is database?
DATABASE MANAGEMENT SYSTEM SHORT QUESTIONS Complete book short Answer Question.. QUESTION 1: What is database? A database is a logically coherent collection of data with some inherent meaning, representing
More informationDatabase Management System 15
Database Management System 15 Trivial and Non-Trivial Canonical /Minimal School of Computer Engineering, KIIT University 15.1 First characterize fully the data requirements of the prospective database
More informationHomework 6: FDs, NFs and XML (due April 15 th, 2015, 4:00pm, hard-copy in-class please)
Virginia Tech. Computer Science CS 4604 Introduction to DBMS Spring 2015, Prakash Homework 6: FDs, NFs and XML (due April 15 th, 2015, 4:00pm, hard-copy in-class please) Reminders: a. Out of 100 points.
More informationLecture 4. Database design IV. INDs and 4NF Design wrapup
Lecture 4 Database design IV INDs and 4NF Design wrapup Problem description We want a database that we can use for scheduling courses and lectures. This is how it s supposed to work: code name Course dept
More informationNormalisation Chapter2 Contents
Contents Objective... 64 Superkey & Candidate Keys... 65 Primary, Alternate and Foreign Keys... 65 Functional Dependence... 67 Using Instances... 70 Normalisation Introduction... 70 Normalisation Problems...
More informationRedundancy:Dependencies between attributes within a relation cause redundancy.
Normalization Normalization: It is the process of removing redundant data from your tables in order to improve storage efficiency, data integrity and scalability. This improvement is balanced against an
More informationThe Relational Data Model
The Relational Data Model Lecture 6 1 Outline Relational Data Model Functional Dependencies Logical Schema Design Reading Chapter 8 2 1 The Relational Data Model Data Modeling Relational Schema Physical
More informationDatabase Management
Database Management - 2011 Model Answers 1. a. A data model should comprise a structural part, an integrity part and a manipulative part. The relational model provides standard definitions for all three
More informationThe Relational Model and Normalization
The Relational Model and Normalization 1. Introduction 2 2. Relational Model Terminology 3 4. Normal Forms 11 5. Multi-valued Dependency 21 6. The Fifth Normal Form 22 The Relational Model and Normalization
More informationAnnouncements (January 20) Relational Database Design. Database (schema) design. Entity-relationship (E/R) model. ODL (Object Definition Language)
Announcements (January 20) 2 Relational Database Design Review for Codd paper due tonight via email Follow instructions on course Web site Reading assignment for next week (Ailamaki et al., VLDB 2001)
More informationDatabase Management System
Database Management System Lecture 4 Database Design Normalization and View * Some materials adapted from R. Ramakrishnan, J. Gehrke and Shawn Bowers Today s Agenda Normalization View Database Management
More informationDatabase design III. Quiz time! Using FDs to detect anomalies. Decomposition. Decomposition. Boyce-Codd Normal Form 11/4/16
Lecture 3 Quiz time! Database design III Functional dependencies cont. BCNF and 3NF What s wrong with this schema? {(, 2, Databases, Steven Van Acker ), (, 4, Databases, Rogardt Heldal )} Redundancy! Using
More informationFundamentals of Database Systems
Fundamentals of Database Systems Assignment: 3 Due Date: 23st August, 2017 Instructions This question paper contains 15 questions in 6 pages. Q1: Consider the following relation and its functional dependencies,
More informationLectures 12: Design Theory I. 1. Normal forms & functional dependencies 2/19/2018. Today s Lecture. What you will learn about in this section
Today s Lecture Lectures 12: Design Theory I Professor Xiannong Meng Spring 2018 Lecture and activity contents are based on what Prof Chris Ré used in his CS 145 in the fall 2016 term with permission 1.
More informationDr. Anis Koubaa. Advanced Databases SE487. Prince Sultan University
Advanced Databases Prince Sultan University College of Computer and Information Sciences Fall 2013 Chapter 15 Basics of Functional Dependencies and Normalization for Relational Databases Anis Koubaa SE487
More informationTDDD12 Databasteknik Föreläsning 4: Normalisering
What is Good Design TDDD12 Databasteknik Föreläsning 4: Normalisering Can we be sure that the translation from the EER diagram to relational tables results in a good database design? Or: Confronted with
More informationFinal Review. Zaki Malik November 20, 2008
Final Review Zaki Malik November 20, 2008 Basic Operators Covered Renaming If two relations have the same attribute, disambiguate the attributes by prefixing the attribute with the name of the relation
More informationDatabases 1. Daniel POP
Databases 1 Daniel POP Week 6 & 7 Agenda Introduction to normalization Functional dependencies 1NF 2NF 3NF. Transitive dependencies BCNF 4NF. Multivalued dependencies 5NF De-normalization Normalization
More informationChapter 6: Relational Database Design
Chapter 6: Relational Database Design Chapter 6: Relational Database Design Features of Good Relational Design Atomic Domains and First Normal Form Decomposition Using Functional Dependencies Second Normal
More informationSchema Refinement and Normal Forms
Schema Refinement and Normal Forms Chapter 19 Quiz #2 Next Wednesday Comp 521 Files and Databases Fall 2010 1 The Evils of Redundancy Redundancy is at the root of several problems associated with relational
More informationDatabase Constraints and Design
Database Constraints and Design We know that databases are often required to satisfy some integrity constraints. The most common ones are functional and inclusion dependencies. We ll study properties of
More informationCMU SCS CMU SCS CMU SCS CMU SCS whole nothing but
Faloutsos & Pavlo 15-415/615 Carnegie Mellon Univ. Dept. of Computer Science 15-415/615 - DB Applications Lecture #17: Schema Refinement & Normalization - Normal Forms (R&G, ch. 19) Overview - detailed
More informationCS352 Lecture - Conceptual Relational Database Design
CS352 Lecture - Conceptual Relational Database Design Objectives: last revised September 16, 2004 1. To define the concepts functional dependency and multivalued dependency 2. To show how to find the closure
More informationIntroduction to Database Design, fall 2011 IT University of Copenhagen. Normalization. Rasmus Pagh
Introduction to Database Design, fall 2011 IT University of Copenhagen Normalization Rasmus Pagh Based on KBL sections 6.1-6.8 (except p. 203 207m), 6.9 (until Multivalued dependencies ), 6.11, and 6.12.
More informationRyan Marcotte CS 475 (Advanced Topics in Databases) March 14, 2011
Ryan Marcotte www.cs.uregina.ca/~marcottr CS 475 (Advanced Topics in Databases) March 14, 2011 Outline Introduction to XNF and motivation for its creation Analysis of XNF s link to BCNF Algorithm for converting
More informationCS352 Lecture - Conceptual Relational Database Design
CS352 Lecture - Conceptual Relational Database Design Objectives: last revised September 20, 2006 1. To define the concepts functional dependency and multivalued dependency 2. To show how to find the closure
More informationDATABASE MANAGEMENT SYSTEMS
www..com Code No: N0321/R07 Set No. 1 1. a) What is a Superkey? With an example, describe the difference between a candidate key and the primary key for a given relation? b) With an example, briefly describe
More informationFrom Murach Chap. 9, second half. Schema Refinement and Normal Forms
From Murach Chap. 9, second half The need for normalization A table that contains repeating columns Schema Refinement and Normal Forms A table that contains redundant data (same values repeated over and
More information