Integrity Constraints and Functional Dependency

Size: px

Start display at page:

Download "Integrity Constraints and Functional Dependency"

Julia Baker
6 years ago
Views:

1 Integrity Constraints and Fnctional Dependency

2 What are Integrity Constraints? Predicates that ensre the changes made to a DB do not reslt in loss of data consistency Does semantic check Can be declared by Create Table or Alter Table command While inserting a record, IC s are checked and error is thrown in case it is violated

3 Types of Integrity Constraints There are primarily 4 kinds of IC s: 1. Key Constraints (1 table) 2. Attribte Constraints (1 table) 3. Referential Integrity Constraints (2 tables) 4. Global Constraints (n tables)

4 Key Constraints Attribtes declared as key colmns shold be niqe to the table This can be mainly exected throgh two ways: a. Primary Key (declared with the primary key keyword) b. Candidate Key (declared with the niqe keyword) A relation can have only 1 primary key bt mltiple candidate keys

5 Key Constraints (contd.) Primary Key Example: CREATE TABLE Persons(ID int PRIMARY KEY, LastName varchar(255) NOT NULL, FirstName varchar(255) NOT NULL, Age int); OR CREATE TABLE Persons(ID int, LastName varchar(255) NOT NULL, FirstName varchar(255) NOT NULL, or Age int, PRIMARY KEY(ID)); Candidate Key Example: CREATE TABLE cstomer(id CHAR(19) PRIMARY KEY, cname CHAR(15), address CHAR(30), city CHAR(10), UNIQUE (cname, address, city));

6 Attribte Constraints Used to attach constraints to attribtes in a relation It can be done in 3 ways: a. Using NOT NULL: No nll vales can be inserted into the attribte that has this IC For eg: CREATE TABLE Persons (ID int, LastName varchar(255) NOT NULL, FirstName varchar(255) NOT NULL, Age int); First name and last name cannot have nll vales

7 Attribte Constraints(contd.) b. Using check<predicate>: Eg: Used to check certain ser-defined conditions specified in the predicate CREATE TABLE Persons (ID int NOT NULL UNIQUE, LastName varchar(255) NOT NULL, FirstName varchar(255) NOT NULL, Age int, CHECK (Age>=18)); This checks if the age of the person is at least 18

8 Attribte Constraints(contd.) c. By sing Domains: Allows ser to define data types that associate constraints with attribtes and hence avoid redndancy Domain Constraint = data type + Constraints (NOT NULL / UNIQUE / PRIMARY KEY / FOREIGN KEY / CHECK) Eg: Yo want to create a table bank_accont with accont_type field having vale either Checking or Saving : CREATE DOMAIN accont_type char(12) CONSTRAINT acc_type_test check(vale in( Checking, Saving )); CREATE TABLE bank_accont( acc_no INT PRIMARY KEY, acc_holder_name VARCHAR(30), acc_type accont_type);

9 Referential Integrity Constraints Allows vales associated with certain attribtes to appear for certain attribtes in another relation Foreign key in the referencing (child) table shold correspond to a Primary Key in the referenced (Parent) table The main idea behind this is to avoid dangling tples. This affects pdate/delete operation in the following ways: a. Insertions/pdates in the child relation: A tple cannot be inserted/pdated ntil the same operation has been carried ot in the Parent table b. Delete/pdate in the parent relation: A tple cannot be deleted from the parent relation nless the same is deleted in the child (if there is any present)

10 Referential Integrity Constraints (contd.) Resolving Dangling Tples: There are 3 ways to deal with dangling tples: a. Reject the deletion/pdate : Leave blank b. Set the vale in the dangling tple to nll: ON DELETE SET NULL / ON UPDATE SET NULL sets ti[c]= NULL, tj[c]= NULL c. Cascade the operation to the dangling tple: i.e delete/pdate the tple in the child/parent table as well ON DELETE CASCADE delete ti, delete tj ON UPDATE CASCADE sets ti[c], tj[c]to new Key vale

11 Global Constraints Global constraints span mltiple relations. They can be exected in two ways: a. Single relation (constraint spans mltiple colmns) Eg : CHECK (total= svngs+ check) declared in CREATE TABLE for bank relation b. Mltiple relations : Create Assertions Eg: Every loan has a borrower with a savings accont CREATE ASSERTION loan-constraint CHECK (NOT EXISTS (SELECT * FROM loan AS l WHERE NOT EXISTS (SELECT *FROM borrower AS b, depositor AS d, accont AS a, WHERE b.cname= d.cnameand d.acct_no= a.acct_no AND l.lno= b.lno)))

12 Fnctional Dependency Fnctional Dependencies (FD) are sed to define constraints between two attribtes of the given relation Given a relation R, a set of attribtes X in R is said to fnctionally determine another set of attribtes Y, also in R, (written X Y) if, and only if, each X vale in R is associated with precisely one Y vale in R

13 Uses of fnctional dependency Take the following relation schema: inst dept (ID, name, salary, dept name, bilding, bdget) Adding or pdating a record in the given relation might lead to redndancy (mltiple instrctors may belong to the same department)/inconsistency (all the departments shold agree on the same bdget vale) errors which is not desirable FD s break down the relation into smaller one s that are normalized

14 Decomposition sing FD When FD s are sed for decomposition, the decomposed relations shold have the following characteristics : a. Lossless Joins: No information shold be lost i.e if R is decomposed into R1 and R2 then the natral join shold reslt in R and no extra records shold be added Eg: Consider the following relation R = (SSN, Name, Address) SSN Name Address 111 Joe 1 Pine 222 Alice 2 Oak 333 Alice 3 Pine and now do a natral join of R1 and R2, we get SSN Name Address 111 Joe 1 Pine 222 Alice 2 Oak 222 Alice 3 Pine 333 Alice 2 Oak 333 Alice 3 Pine If we decompose this into R1(SSN, Name) SSN Name 111 Joe 222 Alice 333 Alice R2(Name, Address) We are losing the information for the person with SSN vale 222 and 333 as we no longer know where they reside. To fix this we can break them into R1(SSN, Name) R2(SSN, Address) which wold be lossless decomposition Name Joe Alice Alice Address 1 Pine 2 Oak 3 Pine

15 Decomposition sing FD (contd.) b. Dependency Preservation : Ensre that a single table is checked for each FD and it shold not span mltiple relations Eg: Redces the cost of checking FD F = {A B, AB D, C D} R1= (A, B, C); R2= (C, D) is not DP as checking AB D wold span mltiple relations Alternatively, R1= (A, B, D); R2= (C, D) is DP as all FD checks wold span only one relation at any time c. Redndancy avoidance: Avoid deletion, pdate anomalies by ensring the realtion is in BCNF

16 Closres for Fnctional Dependencies For FD F, F + is the set of all FD s implied by F Can be calclated in two ways: a. Attribte Closres b. Armstrong s Axioms

17 Attribte Closres Set of attribtes that can be derived from the given attribte sing FD s Algorithm attr-closre (X: set of attribtes) reslt <- X repeat ntil stable for each FD in F,Y Z, do if Y reslt then reslt <- reslt Z Eg: Consider the following set of FD s: name->color category->department color, category->price The attribte closre for {name, category} wold be calclated as follows: Iteration Reslt 0 {name, category} 1 {name, category, color} 2 {name, category, color, department} 3 {name, category, color, department, price}

18 1. Reflexivity If Y X then X Y 2. Agmentation If X Y then WX WY 3. Transitivity If X Y and Y Z then X Z 4. Union If X Y and X Z, then X YZ 5. Decomposition If X YZ then X Y and X Z 6. Psedotransitivity If X Y and WY Z, then WX Z Armstrong s Axioms

19 Canonical Cover Algorithm (CCA) Given a FD set F, CCA finds the minimal FD set eqivalent of F All the implied FD s are removed from the F ALGORITHM canonical-cover(x: FD Set) BEGIN REPEAT UNTIL STABLE 1. Where possible, apply UNION rle (A s Axioms) 2. Remove all extraneos attribtes: a. Test if B extraneos in A BC (B extraneos if (A B) (F {A BC} U {A C}) + ) = F2 + b. Test if B extraneos in AB C (B extraneos if (A C) F + ) END

20 Canonical Cover (contd.) Eg: Consider the following set of FD s: F={ A BC; B C; A B; AB C } Step 1: Take A BC and A B. Can be combined to get A BC Hence, F={ A BC; B C; AB C } Step 2: There is an extraneos attribte in AB C becase even after removing it, we get the same closres. This is becase B C is already a part of F. Hence, F={ A BC; B C} Note: In Step 2, we cannot get rid of A BC as that wold not imply B C anymore Step 3: C is extraneos in A BC as it can be derived transitively from A B and B->C. Hence F={ A B; B C} F does not change anymore so the final canonical cover of F is F={ A B; B C}

Functional 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