Conceptual database design gives us a set of relation

schemas and integrity constraints(ICs) taken as a good

starting point for the final database design

This initial design must be refined by taking the ICs into

account

We will discuss how ICs can be used to refine the

conceptual schema produced by translating an ER model
design into a collection of relations

We concentrate on an important class of constraints called

functional dependencies
Other kinds of ICs, for example multivalued dependencies
and join dependencies, also provide useful information

The normal form satisfied by a relation is a measure of the

redundancy in the relation

A relation with redundancy can be refined by decomposing

it with smaller relations that contain the same information,
but without redundancy
Introduction To Schema Refinement

We now present an overview of the problems that schema

refinement is intended to address and a refinement approach
based on decompositions

Redundant storage of information is the root cause of these

problems

Although decomposition can eliminate redundancy, it can

lead to problems of its own and should be used with caution
Problems Caused by Redundancy

Storing the same information redundantly, that is, in more

than one place within a database, can lead to several
problems:

Redundant storage: Some information is stored repeatedly

Update anomalies: If one copy of such repeated data is

updated, an inconsistency is created unless all copies are
similarly updated

Insertion anomalies: It may not be possible to store some

information unless some other information is stored as well
Deletion anomalies: It may not be possible to delete some
information without losing some other information as well

Consider a relation obtained by translating a variant of the

Hourly_Emps entity set from unit3
Hourly_Emps(ssn, name, lot, rating, hourly_wages,
hours_worked)

We will often abbreviate an attribute name to a single letter

and refer to a relation schema by a string of letters, one per
attribute
For example, we will refer to the Hourly_Emps schema as
SNLRWH (W denotes the hourly wages attribute)

The key for Hourly_Emps is ssn

In addition, suppose that the hourly_wages attribute is
determined by the rating attribute. That is, for a given rating
value, there is only one permissible hourly_wages value

This IC is an example of a functional dependency

It leads to possible redundancy in the relation

Hourly_Emps, as illustrated in Figure 15.1

If the same value appears in the rating column of two

tuples, the IC tells us that the same value must appear in the
hourly_wages column as well
This redundancy has several negative consequences:

1. Some information is stored multiple times. For example,

the rating value 8 corresponds to the hourly wage 10, and
this association is repeated three times

In addition to wasting space by storing the same

information many times, redundancy leads to potential
inconsistency
For example, the hourly_wages in the first tuple could be
updated without making a similar change in the second
tuple, which is an example of an update anomaly

Also, we cannot insert a tuple for an employee unless we

know the hourly wage for the employee's rating value,
which is an example of an insertion anomaly

2. If we delete all tuples with a given rating value (e.g., we

delete the tuples for Smethurst and Guldu) we lose the
association between that rating value and its hourly_wage
value (a deletion anomaly)
Example

An update anomaly. Employee 519 is shown as having

different addresses on different records
An insertion anomaly. Until the new faculty member, Dr.
Newsome, is assigned to teach at least one course, his
details cannot be recorded.
A deletion anomaly. All information about Dr. Giddens is
lost when he temporarily ceases to be assigned to any
courses
Null Values
Let us consider whether the use of null values can address
some of these problems

Clearly, null values cannot help eliminate redundant

storage or update anomalies

It appears that they can address insertion and deletion

anomalies

For instance, to deal with the insertion anomaly example,

we can insert an employee tuple with null values in the
hourly wage field

However, null values cannot address all insertion

anomalies
For example, we cannot record the hourly wage for a rating
unless there is an employee with that rating, because we
cannot store a null value in the ssn field, which is a primary
key field
Similarly, to deal with the deletion anomaly example, we
might consider storing a tuple with null values in all fields
except rating and hourly_wages if the last tuple with a given
rating would otherwise be deleted

However, this solution will not work because it requires the

ssn value to be null, and primary key fields cannot be null

Thus, null values do not provide a general solution to the

problems of redundancy, even though they can help in some
cases
Ideally, we want schemas that do not permit redundancy,
but at the very least we want to be able to identify schemas
that do allow redundancy

Use of Decompositions

Redundancy arises when a relational schema forces an

association between attributes that is not natural

Functional dependencies (and, for that matter, other ICs)

can be used to identify such situations and to suggest
refinements to the schema

Problems arising from redundancy can be solved by

replacing a relation with a collection of 'smaller' relations
Each of the smaller relations contains a (strict) subset of
the attributes of the original relation

We refer to this process as decomposition of the larger

relation into the smaller relations

We can deal with the redundancy in Hourly_Emps by

decomposing it into two relations:

Hourly_Emps2(ssn, name, lot, rating, hours_worked)

Wages(rating, hourly_wages)

The instances of these relations corresponding to the

instance of Hourly_Emps relation in Figure 15.1 is shown in
Figure 15.2
Note that we can easily record the hourly wage for any
rating simply by adding a tuple to Wages, even if no
employee with that rating appears in the current instance of
Hourly_Emps

Changing the wage associated with a rating involves

updating a single Wages tuple. This is more efficient than
updating several tuples (as in the original design), and it
also eliminates the potential for inconsistency

Notice that the insertion and deletion anomalies have also

been eliminated
Problems Related to Decomposition

Unless we are careful, decomposing a relation schema can

create more problems than it solves

Two important questions must be asked repeatedly:

1.Do we need to decompose a relation?

2.What problems (if any) does a given decomposition
cause?

To help with the first question, several normal forms have

been proposed for relations
If a relation schema is in one of these normal forms, certain
kinds of problems cannot arise

Considering the normal form of a given relation schema

can help us to decide whether or not to decompose it further

If we decide that a relation schema must be decomposed

further, we must choose a particular decomposition (i.e., a
particular collection of smaller relations to replace the given
relation)

With respect to the second question, two properties of

decompositions are of particular interest
The lossless-join property enables us to recover any
instance of the decomposed relation from corresponding
instances of the smaller relations

The dependency-preservation property enables us to

enforce any constraint on the original relation by simply
enforcing some constraints on each of the smaller relations

That is, we need not perform joins of the smaller relations

to check whether a constraint on the original relation is
violated

A serious drawback of decompositions is that queries over

the original relation may require us to join the decomposed
relations
Functional Dependencies

A functional dependency (FD) is a constraint between

two sets of attributes in a relation from a database

Let R be a relation schema and let X and Y be nonempty

sets of attributes in R

We say that an instance r of R satisfies the if the

following holds for every pair of tuples t1 and t2 in r:
If t1.X = t2.X, then t1.Y = t2.Y

An essentially says that if two tuples agree on the

values in attributes X, they must also agree on the values in
attributes Y
Note: is read as X functionally determines Y, or simply
as X determines Y

Figure 15.3 illustrates the meaning of the by

showing an instance that satisfies this dependency

Recall that a legal instance of a relation must satisfy all

specified ICs, including all specified FDs
ICs must be identified and specified based on the semantics
of the real-world enterprise being modeled

A primary key constraint is a special case of an FD.The

attributes in the key play the role of X, and the set of all
attributes in the relation plays the role of Y
Reasoning About Functional Dependencies

Given a set of FDs over a relation schema R, there are

typically several additional FDs that hold over R whenever
all of the given FDs hold

As an example, consider:
Workers(ssn, name, lot, did, since)

We know that holds, since ssn is the key, and FD

is given to hold

Thus, the FD also holds on Workers

Closure of a Set of FDs

The set of all FDs implied by a given set F of FDs is called

the closure of F and is denoted as

Armstrong's Axioms, can be applied repeatedly to infer all

FDs implied by a set F of FDs

Properties of Functional Dependencies

We use X, Y, and Z to denote sets of attributes over a

relation schema R:
Example: Suppose we are given a Relation schema R with
attributes A, B, C, D, E, F, and the FDs A BC, B E,
CD EF
Show that the FD AD F holds for R and is thus a
member of the closure of the given set:
Ans:
1. A BC (given)
2. A C (1, decomposition)
3. AD CD (2, augmentation)
4. CD EF (given)
5. AD EF (3 and 4, transitivity)
6. AD F (5, decomposition)
Attribute Closure

If we just want to check whether a given dependency, say,

, is in the closure of a set F of FDs, we can do so
efficiently without computing

We first compute the attribute closure with respect to

F, which is the set of attributes A such that can be
inferred using the Armstrong Axioms

The algorithm for computing the attribute closure of a set X

of attributes is shown in Figure 15.6
This algorithm starts with attribute X and stops as soon as
there is no change in the closure

By varying the starting attribute and the order in which the

algorithm considers FDs, we can obtain all candidate keys
Example: Suppose we are given a relation schema R with
attributes A, B, C, D, E, F and FDs: A BC, E CF, B
E, CD EF
Compute the closure {A,B} + of the set of attributes {A,B}
under this set of FDs
Ans:
1. Initialize the closure to {A,B}
2. Go through inner loop 4 times, once for each of the
given FDs
i) FD A BC, here A is a subset of closure, so add B
and C to closure (closure ={ A,B,C})
ii) FD E CF, do not add C and F to closure, because E
is not a subset of closure
iii) FD B E, add E to closure (closure ={ A,B,C,E})
iv) FD CD EF, do not add F to closure
now closure={ A,B,C,E}
3. Go through inner loop 4 times, once for each of the given
FDs
i) FD A BC, no change in closure
ii) FD E CF, closure ={ A,B,C,E,F}
iii) FD B E, no change in closure
iv) FD CD EF, no change in closure
4. Go through inner loop 4 times, once for each of the given
FDs. Closure does not change so the process terminates.
so closure of {A,B} + ={ A,B,C,E,F}
Introduction to Normalization

The normalization process, as first proposed by Codd,

takes a relation schema through a series of tests to "certify"
whether it satisfies a certain normal form

The process, which proceeds in a top-down fashion by

evaluating each relation against the criteria for normal forms
and decomposing relations as necessary, can thus be
considered as relational design by analysis

Initially, Codd proposed three normal forms, which he

called first, second, and third normal form

A stronger definition of 3NF-called Boyce-Codd normal

form (BCNF)-was proposed later by Boyce and Codd
All these normal forms are based on the functional
dependencies among the attributes of a relation

Later, a fourth normal form (4NF) and a fifth normal form

(5NF) were proposed, based on the concepts of multivalued
dependencies and join dependencies, respectively

Normalization of data is a process of analyzing the given

relation schemas based on their FDs and primary keys to
achieve the desirable properties of (1) minimizing
redundancy and (2) minimizing the insertion, deletion, and
update anomalies

Unsatisfactory relation schemas that do not meet certain

conditions-the normal form tests-are decomposed into
smaller relation schemas that meet the tests and hence
possess the desirable properties

Another point is that the database designers need not

normalize to the highest possible normal form

Every relation in BCNF is also in 3NF, every relation in

3NF is also in 2NF, and every relation in 2NF is in 1NF

Single valued attribute: Attribute which has a single value

Example: age

Multi valued attribute: Attribute which has a set of values

Example: color

Composite attribute: These attributes can be divided into

smaller subparts, which represent more basic attributes
Example: Address

StreetAddress City State Zip

Number Street ApartmentNumber

First Normal Form (1NF)

It was defined to disallow multivalued attributes,

composite attributes, and their combinations

It states that
Domain of an attribute must include only atomic
(simple, indivisible) values
The value of any attribute in a tuple must be a single
value
Example1: Consider the DEPARTMENT relation schema
shown in Figure 5.1

DNAME DNUMBER DMGRSSN DLOCATIONS

Research 5 333445555 {Boston,Sugarland,Houston}
Administration 4 987654321 {Stafford}
Headquarters 1 888665555 {Houston}
Fig 5.1

This is not in 1NF because DLOCATIONS is not an atomic

attribute

Convert relation in Fig 5.1 to the relation in Fig 5.2

 DNAME DNUMBER DMGRSSN DLOCATION
Research 5 333445555 Boston
Research 5 333445555 Sugarland
Research 5 333445555 Houston
Administration 4 987654321 Stafford
Headquarters 1 888665555 Houston
Fig 5.2

Redundancy exists in this relation (Fig 5.2), so decompose

this relation into two relations: DEPARTMENT and
DEPT_LOCATIONS as shown in Fig 5.3
DNAME DNUMBER DMGRSSN
Research 5 333445555
Administration 4 987654321
Headquarters 1 888665555
Fig 5.3
 DNUMBER DLOCATION
1 Houston
4 Stafford
5 Boston
5 Sugarland
5 Houston
Fig 5.3

Example2: Consider EMP_PROJ schema shown in Figure

5.4

This is not in 1NF because PNUMBER and HOURS are

not an atomic attributes

Convert relation in Fig 5.4 to the relation in Fig 5.5

 SSN ENAME PNUMBER HOURS
123456789 Smith 1 32.5
2 7.5
666884444 Narayan 3 40.0

453453453 Joyce 1 20.0

2 20.0
999887777 Zelaya 30 30.0
10 10.0
Fig 5.4
 SSN ENAME PNUMBER HOURS
123456789 Smith 1 32.5
123456789 Smith 2 7.5
666884444 Narayan 3 40.0
453453453 Joyce 1 20.0
453453453 Joyce 2 20.0
999887777 Zelaya 30 30.0
999887777 Zelaya 10 10.0
Fig 5.5
Redundancy exists in this relation (Fig 5.5), so decompose
this relation into two relations: EMP_PROJ1 and
EMP_PROJ2 as shown in Fig 5.6
SSN ENAME
123456789 Smith
666884444 Narayan
453453453 Joyce
999887777 Zelaya
SSN PNUMBER HOURS
123456789 1 20.0
453453453 1 32.5
123456789 2 7.5
453453453 2 20.0
666884444 3 40.0 Fig 5.6
999887777 10 10.0
999887777 30 30.0
Second Normal Form (2NF)

It is based on the concept of full functional dependency

A functional dependency X Y is a full functional

dependency if removal of any attribute A from X means that
the dependency does not hold any more;
That is, for any attribute A X, (X - {A}) does not
functionally determine Y

A functional dependency X Y is a partial dependency if

some attribute A X can be removed from X and the
dependency still holds;
That is, for some A X, (X - {A}) Y
In Figure 5.7, {SSN, PNUMBER} HOURS is a full
dependency (neither SSN HOURS nor PNUMBER
HOURS holds)

However, the dependency {SSN, PNUMBER} ENAME

is partial because SSN ENAME holds
SSN PNUMBER HOURS ENAME PNAME PLOCATION
123456789 1 32.5 Smith ProductX Boston
123456789 2 7.5 Smith ProductY Sugarland
666884444 3 40.0 Narayan ProductZ Houston
453453453 1 20.0 Joyce ProductX Boston
453453453 2 20.0 Joyce ProductY Sugarland
333445555 2 10.0 Franklin ProductY Sugarland
Fig 5.7
Prime attribute: An attribute of relation schema R is called a
prime attribute of R if it is a member of some candidate key
of R
Nonprime attribute: An attribute is called nonprime if it is
not a prime attributethat is, if it is not a member of any
candidate key

The test for 2NF involves testing for functional

dependencies whose left-hand side attributes are part of the
primary key

If the primary key contains a single attribute, the test need

not be applied at all
A relation schema R is in 2NF if every nonprime attribute
A in R is fully functionally dependent on the primary key of
R

The EMP_PROJ relation in Fig 5.7 is in 1NF but is not in

2NF. The nonprime attribute ENAME violates 2NF because
of FD2, as do the nonprime attributes PNAME and
PLOCATION because of FD3

FD1 {SSN,PNUMBER} HOURS

FD2 SSN ENAME
FD3 PNUMBER {PNAME, PLOCATION}
If a relation schema is not in 2NF, it can be "second
normalized" or "2NF normalized" into a number of 2NF
relations in which nonprime attributes are associated only
with the part of the primary key on which they are fully
functionally dependent

The functional dependencies FD1, FD2, and FD3 in Fig

5.7 hence lead to the decomposition of EMP_PROJ into the
three relation schemas EP1, EP2, and EP3 shown in Figure
5.8, each of which is in 2NF
SSN PNUMBER HOURS

SSN ENAME

PNUMBER PNAME PLOCATION Fig 5.8

Third Normal Form (3NF)

It is based on the concept of transitive dependency

A functional dependency X Y in a relation schema R is

a transitive dependency if there is a set of attributes Z that is
neither a candidate key nor a subset of any key of R, and
both X Z and Z Y hold

The dependency SSN DMGRSSN is transitive through

DNUMBER in EMP_DEPT of Fig 5.9,because both the
dependencies
SSN DNUMBER and DNUMBER DMGRSSN
hold and DNUMBER is neither a key itself nor a subset of
the key of EMP_DEPT
ENMAE SSN BDATE ADDRESS DNUMBER DNAME DMGRSSN
Smith 123456789 1965-01-09 Houston 5 Research 333445555
Wong 333445555 1955-12-08 Dallas 5 Research 333445555
Alicia 999887777 1968-07-19 Spring 4 Administration 987654321
Jennifer 987654321 1941-06-20 Boston 4 Administration 987654321
Narayan 666884444 1962-09-15 Humble 5 Research 333445555
Fig 5.9
According to Codds original definition, a relation schema
R is in 3NF if it satisfies 2NF and no nonprime attribute of
R is transitively dependent on the primary key

The relation schema EMP_DEPT in Fig 5.9 is in 2NF,

since no partial dependencies on a key exist

However, EMP_DEPT is not in 3NF because of the

transitive dependency of DMGRSSN (and also DNAME) on
SSN via DNUMBER
We can normalize EMP_DEPT by decomposing it into the
two 3NF relation schemas ED1 and ED2 shown in Fig 5.10
ENMAE SSN BDATE ADDRESS DNUMBER

DNUMBER DNAME DMGRSSN Fig 5.10

Normal Test Remedy (Normalization)
Form
First Relation should have no Form new relations for each
(1NF) nonatomic attributes or nonatomic attribute or nested
nested relations relation

Second For relations where Decompose and set up a new

(2NF) primary key contains relation for each partial key
multiple attributes, no with its dependent
nonkey attribute should be attribute(s). Make sure to
functionally dependent on keep a relation with the
a part of the primary key original primary key and any
attributes that are fully
functionally dependent on it.
Third Relation should not have a Decompose and set up a
(3NF) nonkey attribute relation that includes the
functionally determined by nonkey attribute(s) that
another nonkey attribute functionally determine(s)
(or by a set of nonkey other nonkey attribute(s)
attributes.) That is, there
should be no transitive
dependency of a nonkey
attribute on the primary
key

Table 1 Summary of Normal Forms

Boyce-Codd Normal Form (BCNF)

When a relation has more than one candidate key,

anomalies may result even though the relation is in 3NF

3NF does not deal satisfactorily with the case of a relation

with overlapping candidate keys i.e. composite candidate
keys with at least one attribute in common

BCNF is based on the concept of a determinant

A determinant is any attribute (simple or composite) on

which some other attribute is fully functionally dependent

A relation is in BCNF if, and only if, every determinant is a

candidate key
Consider the following relation and determinants
R(a, b, c, d)
a, c b, d
a, d b
Here, the first determinant suggests that the primary key of
R could be changed from a, b to a, c

If this change was done all of the non-key attributes present

in R could still be determined, and therefore this change is
legal

However, the second determinant indicates that a, d

determines b, but a, d could not be the key of R as a, d does
not determine all of the non key attributes of R (it does not
determine c)
:We would say that the first determinant is a candidate key,
but the second determinant is not a candidate key, and thus
rd
this relation is not in BCNF (but is in 3 normal form)
Patient No Patient Name Appointment Id Time Doctor
1 John 0 09:00 Zorro
2 Kerr 0 09:00 Killer
3 Adam 1 10:00 Zorro
4 Robert 0 13:00 Killer
5 Zane 1 14:00 Zorro

Fig 5.11
DB(Patno , appNo,time,doctor)
R1(Patno , PatName)
Consider the determinants:
Patno PatName
Patno is present in DB, but not PatName, so not relevant

Patno, appNo Time, doctor

All LHS attributes present, and time and doctor also
present, so relevant
Is this a candidate key? Patno, appNo is the key, so this is a
candidate key. Thus this is OK for BCNF compliance

Time -> appNo

Time is present, and so is appNo, so relevant. Is this a
candidate key? No

So DB is not in BCNF
BCNF: rewrite to
DB(Patno , time ,doctor)
R1(Patno , PatName)
R2(time , appNo)
Now BCNF is satisfied

Lossless-Join Decomposition

Let R be a relation schema and let F be a set of FDs over R

A decomposition of R into two schemas with attribute sets

X and Y is said to be a lossless-join decomposition with
respect to F if for every instance r of R that satisfies the
dependencies in F,
If we take projections of a relation and recombine them
using natural join, we typically obtain some tuples that were
not in the original relation. This situation is illustrated in
Figure 15.11
The decomposition of schema SPD into SP and PD is
therefore a 'lossy' decomposition

All decompositions used to eliminate redundancy must be

lossless. The following simple test is very useful:

Let R be a relation and F be a set of FDs that hold over R.

The decomposition of R into relations with attribute sets R1
and R2 is lossless if and only if F+ contains either the FD R1
R2 R1 or the FD R1 R2 R2

Example:
Consider the Hourly_Emps relation again. It has attributes
SNLRWH, and the FD R W causes a violation of 3NF
We dealt with this violation by decomposing the relation
into SNLRH and RW

Since R is common to both decomposed relations, and R

W holds, this decomposition is lossless-join

Suppose that a relation R is decomposed into R1 and R2

through a lossless-join decomposition, and that R1 is
decomposed into R11 and R12 through another lossless-join
decomposition

Then the decomposition of R into R11, R12, and R2 is

lossless-join; by joining R11 and R12 we can recover R1,
and by then joining R1 and R2, we can recover R
Dependency-Preserving Decomposition

A Dependency-Preserving Decomposition allows us to

enforce all FDs by examining a single relation instance on
each insertion or modification of a tuple

Deletions cannot cause violation of FDs

To define dependency-preserving decompositions

precisely, we have to introduce the concept of a projection
of FDs

Let R be a relation schema that is decomposed into two

schemas with attribute sets X and Y, and let F be a set of
FDs over R
The projection of F on X is the set of FDs in the closure
F+ (not just F !) that involve only attributes in X

We will denote the projection of F on attributes X as FX

Note that a dependency U V in F+ is in FX only if all the

attributes in U and V are in X

The decomposition of relation schema R with FDs F into

schemas with attribute sets X and Y is dependency-
preserving if (FX U FY )+ = F+

Suppose that a relation R with attributes ABC is

decomposed into relations with attributes AB and BC
The set F of FDs over R includes A B, B C, and C
A. Of these, A B is in FAB and B C is in FBC

But is this decomposition dependency-preserving? What

about C A? This dependency is not implied by the
dependencies listed (thus far) for FAB and FBC

The closure of F contains all dependencies in F plus A

C, B A, and C B

Consequently, FAB also contains B A, and FBC contains

CB

Thus, FAB U FBC contains A B, B C, B A, and C

B
The closure of the dependencies in FAB and FBC now
includes C A (which follows from C B, B A, and
transitivity)

Thus, the decomposition preserves the dependency C A

Multi Valued Dependencies (MVD)

The multivalued dependency X Y is said to hold over

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
ENAME PNAME DNAME
Smith X John
Smith Y Anna
Smith X Anna
Fig 5.12 EMP
Smith Y Jogn

This relation has two MVDs:

ENAME PNAME and
ENAME DNAME
An MVD X Y in R is called a trivial MVD if (a) Y is
a subset of X, or (b) X U Y = R

An MVD that satisfies neither (a) nor (b) is called a

nontrivial MVD

Fourth Normal Form (4NF)

A relation schema R is in 4NF with respect to a set of

dependencies F (that includes FDs and MVDs) if, for every
nontrivial MVD X Y in F+ , X is a superkey for R

The EMP relation of Fig 5.12 is not in 4NF because in the

nontrivial MVDs ENAME PNAME and ENAME
DNAME, ENAME is not a superkey of EMP
We decompose EMP into EMP_PROJECTS and
EMP_DEPENDENTS shown in Fig 5.13
ENAME PNAME ENAME DNAME
Smith X Smith John
Smith Y Smith Anna
EMP_PROJECTS EMP_DEPENDENTS
Fig 5.13