Relational Database Design-111

By:D Mishra
Functional Dependency

Functional dependency in DBMS, as the name suggests

is a relationship between attributes of a table dependent
on each other. Introduced by E. F. Codd, it helps in
preventing data redundancy and gets to know about bad
designs.
 We have a <Department> table with two attributes − DeptId and DeptName.

The DeptId is our primary key. Here, DeptId uniquely identifies the DeptName attribute. This
is because if you want to know the department name, then at first you need to have the
DeptId.

Therefore, the above functional dependency between DeptId and DeptName can be
determined as DeptId is functionally dependent on DeptName −

DeptId = Department ID
DeptName = Department Name

DeptId DeptName

DeptId -> DeptName 001 Finance

002 Marketing

003 HR
 Trivial Functional Dependency
A ->B

It occurs when B is a subset of A in −

Example

We are considering the same <Department> table with two attributes to

understand the concept of trivial dependency.

The following is a trivial functional dependency since DeptId is a subset of

DeptId and DeptName
Non –Trivial Functional Dependency
It occurs when B is not a subset of A in −

Example
A ->B

DeptId -> DeptName

Different anomalies in designing a Database

Database anomalies are the problems in relations that

occur due to redundancy in the relations. These
anomalies affect the process of inserting, deleting, and
modifying data in the relations. Some important data
may be lost if a relation is updated that contains
database anomalies.
 Insertion Anomaly

The insertion anomaly occurs when a new record is inserted

in the relation. In this
anomaly, the user cannot insert a fact about an entity until he
has an additional fact about
another entity.
Deletion Anomaly

The deletion anomaly occurs when a record is

deleted from the relation. In this
anomaly, the deletion of facts about an entity
automatically deletes the fact of another entity.
 Modification Anomaly

The modification anomaly occurs when the record is

updated in the relation. In this
anomaly, the modification in the value of a specific
attribute requires modification in all
records in which that value occurs.
Normalization using functional dependencies

1. It makes the database design efficient in performance.

2. It reduces the amount of data if possible.
3. It makes the database design free of update, insertion, and deletion
anomalies.
4. It makes the design according to the rules of relational databases.
5. It identifies relationships between entities.
6. It makes a design that allows the simple retrieval of data.
7. It simplifies data maintenance and reduces the need to restructure
data.
First Normal Form

A relation is in first normal form (INF) if it does not

contain a repeating group. A repeating group is a
set of one or more data items that may occur a
variable number of times in a tuple.
Second Normal Form

A relation is in Second Normal Form (2NF) if it is in 1NF and if all of its

non-key attributes are fully functionally dependent on the whole key. It
means that none of the non-key attributes are related to a part of the key.

The above relation in INF has some attributes which are not depending
on the whole primary key. For example, Accountant Name, Accountant
Age, and group information are determined by Accountant Number and
are not dependent on Skill
Decomposition

● Decomposition is the process of breaking down in parts or elements.

● It replaces a relation with a collection of smaller relations.
● It breaks the table into multiple tables in a database.
● It should always be lossless, because it confirms that the information in the
original relation can be accurately reconstructed based on the decomposed
relations.
● If there is no proper decomposition of the relation, then it may lead to problems
like loss of information.
Lossless Decomposition

● Decomposition must be lossless. It means that the

information should not get lost from the relation that is

decomposed.

● It gives a guarantee that the join will result in the same

relation as it was decomposed.
 Eid Ename Age City Salary Deptid DeptName

E001 ABC 29 Pune 20000 D001 Finance

E002 PQR 30 Pune 30000 D002 Production

E003 LMN 25 Mumbai 5000 D003 Sales

E004 XYZ 24 Mumbai 4000 D004 Marketing

E005 STU 32 Bangalore 25000 D005 Human Resource

Decompose the above relation into two relations to check

whether a decomposition is lossless or lossy.

Now, we have decomposed the relation that is Employee and

Department.
 ● <Employee> Table

Employee Schema contains (Eid, Ename, Age, City, Salary).

Eid Ename Age City Salary

E001 ABC 29 Pune 20000

E002 PQR 30 Pune 30000

E003 LMN 25 Mumbai 5000

E004 XYZ 24 Mumbai 4000

E005 STU 32 Bangalore 25000

 ● <Department> Table

Deptid Eid DeptName

D001 E001 Finance

D002 E002 Production

D003 E003 Sales

D004 E004 Marketing

D005 E005 Human Resource

Department Schema contains (Deptid, Eid, DeptName).

● So, the above decomposition is a Lossless Join Decomposition, because the two relations

contains one common field that is 'Eid' and therefore join is possible.

● Now apply natural join on the decomposed relations.

 ● Employee ⋈ Department

Eid Ename Age City Salary Deptid DeptName

E001 ABC 29 Pune 20000 D001 Finance

E002 PQR 30 Pune 30000 D002 Production

E003 LMN 25 Mumbai 5000 D003 Sales

E004 XYZ 24 Mumbai 4000 D004 Marketing

E005 ● STU 32 Bangalore 25000 D005 Human Resource

Hence, the decomposition is Lossless Join Decomposition.

If the <Employee> table contains (Eid, Ename, Age, City, Salary) and <Department> table contains

(Deptid and DeptName), then it is not possible to join the two tables or relations, because there is no

common column between them. And it becomes Lossy Join Decomposition.

 Dependency Preservation

● Dependency is an important constraint on the database.

● Every dependency must be satisfied by at least one decomposed table.
● If {A → B} holds, then two sets are functional dependent. And, it becomes more
useful for checking the dependency easily if both sets in a same relation.
● This decomposition property can only be done by maintaining the functional
dependency.
● In this property, it allows to check the updates without computing the natural join of
the database structure.
 Lack of Data Redundancy

● Lack of Data Redundancy is also known as a Repetition of

Information.

● The proper decomposition should not suffer from any data

redundancy.

● The careless decomposition may cause a problem with the data.

● The lack of data redundancy property may be achieved by
Normalization process.
Boyce-Codd Normal Form (BCNF)

BCNF is an extension to Third Normal Form (3NF) and is slightly stronger than
3NF.

A relation R is in BCNF, if P -> Q is a trivial functional dependency and P is a

superkey for R.

If a relation is in BCNF, that would mean that redundancy based on function

dependency have been removed, but some redundancies are still there.
 Ground Begin_Time End_Time Package

G01 07:00 09:00 Gold

G01 10:00 12:00 Gold

G01 10:30 11:00 Bronze

G02 10:15 11:15 Silver

G02 08:00 09:00 Silver

The above relation is in 1NF, 2NF, 3NF, but not in BCNF. Here is the reason −Functional Dependency
{Package->Ground}

It has the determinant attribute Package on which Ground depends on is neither a Candidate Key nor a
superset of the candidate key.
 <Package>

Package Ground

Gold G01

Silver G02

Bronze G01
<TomorrowBookings>

Ground Begin_Time End_Time

G01 07:00 09:00

G01 10:00 12:00

G01 10:30 11:00

G02 10:15 11:15

G02 08:00 09:00