Database Management Systems

UNIT II

Introduction of Relational Algebra In DBMS

Relational Algebra is procedural query language, which takes Relation as input and generate
relation as output. N relational algebra is a procedural query language, it means that it tells what
data to be retrieved and how to be retrieved. Relational algebra mainly provides theoretical
foundation for relational databases and SQL.

Relational Model concept

Relational model can represent as a table with columns and rows. Each row is known as a tuple.
Each table of the column has a name or attribute.

In relational model, the data and relationships are represented by collection of inter-related
tables. Each table is a group of column and rows, where column represents attribute of an entity
and rows represents records.

Some popular Relational Database management systems are:

 DB2 and Informix Dynamic Server - IBM

 Oracle and RDB – Oracle

 SQL Server and Access - Microsoft

Domain: It contains a set of atomic values that an attribute can take.

Sukshma RD,Asst Prof,Hindustan College Page 1

 Database Management Systems

Attribute: It contains the name of a column in a particular table. Each attribute Ai must have a
domain, dom(Ai)

Relational instance: In the relational database system, the relational instance is represented by a
finite set of tuples. Relation instances do not have duplicate tuples.

Relational schema: A relational schema contains the name of the relation and name of all
columns or attributes.

Relational key: In the relational key, each row has one or more attributes. It can identify the row
in the relation uniquely.

Degree: The number of attributes in the relation is known as degree of the relation..

Cardinality: The number of tuples in a relation is known as cardinality.

 Relations model Constraints /Integrity Constraints

o Integrity constraints are a set of rules. It is used to maintain the quality of information.

o Integrity constraints ensure that the data insertion, updating, and other processes have to
be performed in such a way that data integrity is not affected.

o Thus, integrity constraint is used to guard against accidental damage to the database.

Types of Integrity Constraint

Sukshma RD,Asst Prof,Hindustan College Page 2

 Database Management Systems

1. Domain constraints

o Domain constraints can be defined as the definition of a valid set of values for an
attribute.

o The data type of domain includes string, character, integer, time, date, currency, etc. The
value of the attribute must be available in the corresponding domain.

2. Entity integrity constraints

o The entity integrity constraint states that primary key value can't be null.

o This is because the primary key value is used to identify individual rows in relation and if
the primary key has a null value, then we can't identify those rows.

o A table can contain a null value other than the primary key field.

Sukshma RD,Asst Prof,Hindustan College Page 3

 Database Management Systems

3. Referential Integrity Constraints

o A referential integrity constraint is specified between two tables.

o In the Referential integrity constraints, if a foreign key in Table 1 refers to the Primary
Key of Table 2, then every value of the Foreign Key in Table 1 must be null or be
available in Table 2.

Example:

4. Key constraints

o Keys are the entity set that is used to identify an entity within its entity set uniquely.

o An entity set can have multiple keys, but out of which one key will be the primary key. A
primary key can contain a unique and null value in the relational table.

Example:

Sukshma RD,Asst Prof,Hindustan College Page 4

 Database Management Systems

 Relational Algebra

Relational algebra is a procedural query language. It gives a step by step process to obtain the
result of the query. It uses operators to perform queries.

Types of Relational operation

Basic Relational Algebra Operations:

1. Unary Relational Operations

 SELECT (symbol: σ) : The SELECT operation is used for selecting a subset of the
tuples according to a given selection condition. Sigma(σ) Symbol denotes it. It is used as
an expression to choose tuples which meet the selection condition. Select operation
selects tuples that satisfy a given predicate

Notation: σ p(r)

Where:

σ is used for selection prediction

r is used for relation
p is used as a propositional logic formula which may use connectors like: AND OR and
NOT. These relational can use as relational operators like =, ≠, ≥, <, >, ≤.

For example −

σsubject = "database"(Books)

Output − Selects tuples from books where subject is 'database'.

Sukshma RD,Asst Prof,Hindustan College Page 5

 Database Management Systems

σsubject = "database" and price = "450"(Books)

Output − Selects tuples from books where subject is 'database' and 'price' is 450.

σsubject = "database" and price = "450" or year > "2010"(Books)

Output − Selects tuples from books where subject is 'database' and 'price' is 450 or those
books published after 2010.

 PROJECT (symbol: π) : The projection eliminates all attributes of the input relation but
those mentioned in the projection list. The projection method defines a relation that
contains a vertical subset of Relation.

This helps to extract the values of specified attributes to eliminates duplicate values. (pi)
The symbol used to choose attributes from a relation. This operation helps you to keep
specific columns from a relation and discards the other columns.

Example of Projection:

Consider the following table

CustomerID CustomerName Status

1 Google Active

2 Amazon Active

3 Apple Inactive

4 Alibaba Active

Here, the projection of CustomerName and status will give

Π CustomerName, Status (Customers)

CustomerName Status

Google Active

Amazon Active

Apple Inactive

Alibaba Active

Sukshma RD,Asst Prof,Hindustan College Page 6

 Database Management Systems

 RENAME (symbol ρ) : Rename is a unary operation used for renaming attributes of a

relation.
We can use the rename operator to rename STUDENT relation to STUDENT1.

ρ(STUDENT1, STUDENT)

2. Relational Algebra Operations From Set Theory

 UNION (υ) : UNION is symbolized by ∪ symbol. It includes all tuples that are in tables
A or in B. It also eliminates duplicate tuples. So, set A UNION set B would be expressed
as:

A∪B

For a union operation to be valid, the following conditions must hold -

 R and S must be the same number of attributes.

 Attribute domains need to be compatible.

 Duplicate tuples should be automatically removed.

Example:

DEPOSITOR RELATION

CUSTOMER_NAME ACCOUNTO

Johnson A-101

Smith A-121

Mayes A-321

Turner A-176

Johnson A-273

Jones A-472

Lindsay A-284

Sukshma RD,Asst Prof,Hindustan College Page 7

 Database Management Systems

BORROW RELATION

CUSTOMER_NAME LOAN_NO

Jones L-17

Smith L-23

Hayes L-15

Jackson L-14

Curry L-93

Smith L-11

Williams L-17

Input:

∏ CUSTOMER_NAME (BORROW) ∪ ∏ CUSTOMER_NAME (DEPOSITOR)

Output:

CUSTOMER_NAME

Johnson

Smith

Hayes

Turner

Jones

Lindsay

Jackson

Sukshma RD,Asst Prof,Hindustan College Page 8

 Database Management Systems

Curry

Williams

Mayes

 INTERSECTION (∩) and it is used to select common rows (tuples) from two tables
(relations).

Lets say we have two relations R1 and R2 both have same columns and we want to select
all those tuples(rows) that are present in both the relations, then in that case we can apply
intersection operation on these two relations R1 ∩ R2.

Example

Table 1: COURSE

Course_Id Student_Name Student_Id

--------- ------------ ----------

C101 Aditya S901

C104 Aditya S901

C106 Steve S911

C109 Paul S921

C115 Lucy S931

Table 2: STUDENT

Student_Id Student_Name Student_Age

------------ ---------- -----------

S901 Aditya 19

S911 Steve 18
Sukshma RD,Asst Prof,Hindustan College Page 9
 Database Management Systems

S921 Paul 19

S931 Lucy 17

S941 Carl 16

S951 Rick 18

Query:

∏ Student_Name (COURSE) ∩ ∏ Student_Name (STUDENT)

Output:

Student_Name

------------

Aditya

Steve

Paul

Lucy

 SET DIFFERENCE (-) : Set Difference is denoted by – symbol. Lets say we have two
relations R1 and R2 and we want to select all those tuples(rows) that are present in
Relation R1 but not present in Relation R2, this can be done using Set difference R1 –
R2.

Example

Table 1: COURSE

Course_Id Student_Name Student_Id

--------- ------------ ----------

C101 Aditya S901

C104 Aditya S901

C106 Steve S911

C109 Paul S921

Sukshma RD,Asst Prof,Hindustan College Page 10

 Database Management Systems

C115 Lucy S931

Table 2: STUDENT

Student_Id Student_Name Student_Age

------------ ---------- -----------

S901 Aditya 19

S911 Steve 18

S921 Paul 19

S931 Lucy 17

S941 Carl 16

S951 Rick 18

Query:

∏ Student_Name (STUDENT) - ∏ Student_Name (COURSE)

Output:

Student_Name

------------

Carl

Rick

 CARTESIAN PRODUCT ( x ) : Cartesian Product is denoted by X symbol. Lets say

we have two relations R1 and R2 then the cartesian product of these two relations (R1 X
R2) would combine each tuple of first relation R1 with the each tuple of second relation
R2. I know it sounds confusing but once we take an example of this, you will be able to
understand this.

Syntax of Cartesian product (X)

Sukshma RD,Asst Prof,Hindustan College Page 11

 Database Management Systems

R1 X R2

Cartesian product (X) Example

Table 1: R

Col_A Col_B

----- ------

AA 100

BB 200

CC 300

Table 2: S

Col_X Col_Y

----- -----

XX 99

YY 11

ZZ 101

Query:
Lets find the cartesian product of table R and S.

RXS

Output:

Col_A Col_B Col_X Col_Y

----- ------ ------ ------

AA 100 XX 99

AA 100 YY 11

AA 100 ZZ 101

Sukshma RD,Asst Prof,Hindustan College Page 12

 Database Management Systems

BB 200 XX 99

BB 200 YY 11

BB 200 ZZ 101

CC 300 XX 99

CC 300 YY 11

CC 300 ZZ 101

3. Binary Relational Operations

 JOIN : Join is a combination of a Cartesian product followed by a selection process. A

Join operation pairs two tuples from different relations, if and only if a given join
condition is satisfied. It is denoted by ⋈.

Example:
EMPLOYEE

EMP_CODE EMP_NAME

101 Stephan

102 Jack

103 Harry

Sukshma RD,Asst Prof,Hindustan College Page 13

 Database Management Systems

SALARY

EMP_CODE SALARY

101 50000

102 30000

103 25000

Operation: (EMPLOYEE ⋈ SALARY)

Result:

EMP_CODE EMP_NAME SALARY

101 Stephan 50000

102 Jack 30000

Sukshma RD,Asst Prof,Hindustan College Page 14

 Database Management Systems

103 Harry 25000

Types of Join operations:

Natural Join:

o A natural join is the set of tuples of all combinations in R and S that are equal on their
common attribute names.

o It is denoted by ⋈.

Example: Let's use the EMPLOYEE table and SALARY table:

Sukshma RD,Asst Prof,Hindustan College Page 15

 Database Management Systems

Example:
EMPLOYEE

EMP_CODE EMP_NAME

101 Stephan

102 Jack

103 Harry

SALARY

EMP_CODE SALARY

101 50000

102 30000

103 25000

Sukshma RD,Asst Prof,Hindustan College Page 16

 Database Management Systems

Input:

∏ EMP_NAME, SALARY (EMPLOYEE ⋈ SALARY)

Output:

EMP_NAME SALARY

Stephan 50000

Jack 30000

Harry 25000

Outer Join:

The outer join operation is an extension of the join operation. It is used to deal with missing
information.

Example:

EMPLOYEE

EMP_NAME STREET CITY

Ram Civil line Mumbai

Shyam Park street Kolkata

Ravi M.G. Street Delhi

Hari Nehru nagar Hyderabad

Sukshma RD,Asst Prof,Hindustan College Page 17

 Database Management Systems

FACT_WORKERS

EMP_NAME BRANCH SALARY

Ram Infosys 10000

Shyam Wipro 20000

Kuber HCL 30000

Hari TCS 50000

Input:

(EMPLOYEE ⋈ FACT_WORKERS)

Output:

EMP_NAME STREET CITY BRANCH SALARY

Ram Civil line Mumbai Infosys 10000

Shyam Park street Kolkata Wipro 20000

Hari Nehru nagar Hyderabad TCS 50000

An outer join is basically of three types:

a. Left outer join

b. Right outer join

c. Full outer join

Sukshma RD,Asst Prof,Hindustan College Page 18

 Database Management Systems

a. Left outer join:

o Left outer join contains the set of tuples of all combinations in R and S that are equal on
their common attribute names.

o In the left outer join, tuples in R have no matching tuples in S.

o It is denoted by ⟕.

Example: Using the above EMPLOYEE table and FACT_WORKERS table

Input:

1. EMPLOYEE ⟕ FACT_WORKERS

EMP_NAME STREET CITY BRANCH SALARY

Ram Civil line Mumbai Infosys 10000

Shyam Park street Kolkata Wipro 20000

Hari Nehru street Hyderabad TCS 50000

Ravi M.G. Street Delhi NULL NULL

b. Right outer join:

o Right outer join contains the set of tuples of all combinations in R and S that are equal on
their common attribute names.

o In right outer join, tuples in S have no matching tuples in R.

o It is denoted by ⟖.

Example: Using the above EMPLOYEE table and FACT_WORKERS Relation

Input:

EMPLOYEE ⟖ FACT_WORKERS

Sukshma RD,Asst Prof,Hindustan College Page 19

 Database Management Systems

Output:

EMP_NAME BRANCH SALARY STREET CITY

Ram Infosys 10000 Civil line Mumbai

Shyam Wipro 20000 Park street Kolkata

Hari TCS 50000 Nehru Hyderabad

street

Kuber HCL 30000 NULL NULL

c. Full outer join:

o Full outer join is like a left or right join except that it contains all rows from both tables.

o In full outer join, tuples in R that have no matching tuples in S and tuples in S that have
no matching tuples in R in their common attribute name.

o It is denoted by ⟗.

Example: Using the above EMPLOYEE table and FACT_WORKERS table

Input:

EMPLOYEE ⟗ FACT_WORKERS

Output:

EMP_NAME STREET CITY BRANCH SALARY

Ram Civil line Mumbai Infosys 10000

Shyam Park street Kolkata Wipro 20000

Hari Nehru street Hyderabad TCS 50000

Sukshma RD,Asst Prof,Hindustan College Page 20

 Database Management Systems

Ravi M.G. Street Delhi NULL NULL

Kuber NULL NULL HCL 30000

d. Equi join:

It is also known as an inner join. It is the most common join. It is based on matched data as per
the

equality condition. The equi join uses the comparison operator(=).

Example:

CUSTOMER RELATION

CLASS_ID NAME

1 John

2 Harry

3 Jackson

PRODUCT

PRODUCT_ID CITY

1 Delhi

2 Mumbai

3 Noida

Input:

CUSTOMER ⋈ PRODUCT

Sukshma RD,Asst Prof,Hindustan College Page 21

 Database Management Systems

Output:

CLASS_ID NAME PRODUCT_ID CITY

1 John 1 Delhi

2 Harry 2 Mumbai

3 Harry 3 Noida

 Aggregate functions:

An aggregate function allows you to perform a calculation on a set of values to return a single
scalar value.

The following are the most commonly used SQL aggregate functions:

 AVG – calculates the average of a set of values.

example:
Id Name Salary
-----------------------
1 A 80
Sukshma RD,Asst Prof,Hindustan College Page 22
 Database Management Systems

2 B 40
3 C 60
4 D 70
5 E 60
6 F Null

Avg(salary) = Sum(salary) / count(salary) = 310/5

Avg(Distinct salary) = sum(Distinct salary) / Count(Distinct Salary) = 250/4

 COUNT – counts rows in a specified table or view.

example:
Id Name Salary
-----------------------
1 A 80
2 B 40
3 C 60
4 D 70
5 E 60
6 F Null

Count(*): Returns total number of records .i.e 6.

Count(salary): Return number of Non Null values over the column salary. i.e 5.
Count(Distinct Salary): Return number of distinct Non Null values over the column salary .i.e 4

Sukshma RD,Asst Prof,Hindustan College Page 23

 Database Management Systems

 MIN – gets the minimum value in a set of values.

example:
Id Name Salary
-----------------------
1 A 80
2 B 40
3 C 60
4 D 70
5 E 60
6 F Null

Min(salary): Minimum value in the salary column except NULL i.e., 40

 MAX – gets the maximum value in a set of values.

example:
Id Name Salary
-----------------------
1 A 80
2 B 40
3 C 60

Sukshma RD,Asst Prof,Hindustan College Page 24

 Database Management Systems

4 D 70
5 E 60
6 F Null

Max(salary): Maximum value in the salary i.e., 80

 SUM – calculates the sum of values.

example:
Id Name Salary
-----------------------
1 A 80
2 B 40
3 C 60
4 D 70
5 E 60
6 F Null
sum(salary): Sum all Non Null values of Column salary i.e., 310
sum(Distinct salary): Sum of all distinct Non-Null values i.e., 250.

 Basic Queries in SQL :

AND Example

The following SQL statement selects all fields from "Customers" where country is "Germany"
AND city is "Berlin":

Sukshma RD,Asst Prof,Hindustan College Page 25

 Database Management Systems

Example

SELECT * FROM Customers WHERE Country='Germany' AND City='Berlin';

OR Example

The following SQL statement selects all fields from "Customers" where city is "Berlin" OR
"München":

Example

SELECT * FROM Customers WHERE City='Berlin' OR City='München';

NOT Example

The following SQL statement selects all fields from "Customers" where country is NOT
"Germany":

Example

SELECT * FROM Customers WHERE NOT Country='Germany';

GROUP BY Statement

The GROUP BY statement groups rows that have the same values into summary rows, like
"find the number of customers in each country".

The GROUP BY statement is often used with aggregate functions (COUNT, MAX, MIN,
SUM, AVG) to group the result-set by one or more columns.

Syntax

SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
ORDER BY column_name(s);

The following SQL statement lists the number of customers in each country:

Example

Sukshma RD,Asst Prof,Hindustan College Page 26

 Database Management Systems

SELECT COUNT(CustomerID), Country

FROM Customers
GROUP BY Country;

 VIEW

a view is a virtual table based on the result-set of an SQL statement. The SQL VIEW is, in
essence, a virtual table that does not physically exist. Rather, it is created by a SQL statement
that joins one or more tables.

A view contains rows and columns, just like a real table. The fields in a view are fields from one
or more real tables in the database.

Views syntax

CREATE VIEW Syntax

CREATE VIEW view_name AS

SELECT column1, column2, ...
FROM table_name
WHERE condition;

Example : The following SQL creates a view that shows all customers from Brazil

CREATE VIEW Brazil Customers AS

SELECT CustomerName, ContactName
FROM Customers
WHERE Country = 'Brazil';

SELECT * FROM [Brazil Customers];

Sukshma RD,Asst Prof,Hindustan College Page 27

 Database Management Systems

UNIT III

Normalization
Normalization is a process of organizing the data in database to avoid data redundancy,
insertion anomaly, update anomaly & deletion anomaly.

o Normalization is the process of organizing the data in the database.

o Normalization is used to minimize the redundancy from a relation or set of relations. It is

also used to eliminate the undesirable characteristics like Insertion, Update and Deletion
Anomalies.

o Normalization divides the larger table into the smaller table and links them using
relationship.

o The normal form is used to reduce redundancy from the database table.

Types of Normal Forms

There are the four types of normal forms:

Sukshma RD,Asst Prof,Hindustan College Page 28

 Database Management Systems

Normal Form Description

1NF A relation is in 1NF if it contains an

atomic value.

2NF A relation will be in 2NF if it is in 1NF

and all non-key attributes are fully
functional dependent on the primary
key.

Sukshma RD,Asst Prof,Hindustan College Page 29

 Database Management Systems

3NF A relation will be in 3NF if it is in 2NF

and no transition dependency exists.

4NF A relation will be in 4NF if it is in

Boyce Codd normal form and has no
multi-valued dependency.

5NF A relation is in 5NF if it is in 4NF and

not contains any join dependency
and joining should be lossless.

Anomalies in DBMS

There are three types of anomalies that occur when the database is not normalized. These are –
Insertion, update and deletion anomaly. Let’s take an example to understand this.

Example: Suppose a manufacturing company stores the employee details in a table named
employee that has four attributes: emp_id for storing employee’s id, emp_name for storing
employee’s name, emp_address for storing employee’s address and emp_dept for storing the
department details in which the employee works. At some point of time the table looks like this:

emp_id emp_name emp_address emp_dept

101 Rick Delhi D001

101 Rick Delhi D002

123 Maggie Agra D890

Sukshma RD,Asst Prof,Hindustan College Page 30

 Database Management Systems

166 Glenn Chennai D900

166 Glenn Chennai D004

The above table is not normalized. We will see the problems that we face when a table is not
normalized.

Update anomaly: In the above table we have two rows for employee Rick as he belongs to two
departments of the company. If we want to update the address of Rick then we have to update the
same in two rows or the data will become inconsistent. If somehow, the correct address gets
updated in one department but not in other then as per the database, Rick would be having two
different addresses, which is not correct and would lead to inconsistent data.

Insert anomaly: Suppose a new employee joins the company, who is under training and
currently not assigned to any department then we would not be able to insert the data into the
table if emp_dept field doesn’t allow nulls.

Delete anomaly: Suppose, if at a point of time the company closes the department D890 then
deleting the rows that are having emp_dept as D890 would also delete the information of
employee Maggie since she is assigned only to this department.

To overcome these anomalies we need to normalize the data. In the next section we will discuss
about normalization.

Here are the most commonly used normal forms:

 First normal form(1NF)

 Second normal form(2NF)

 Third normal form(3NF)

 Boyce & Codd normal form (BCNF)

First normal form (1NF)

As per the rule of first normal form, an attribute (column) of a table cannot hold multiple values.
It should hold only atomic values.

Example: Suppose a company wants to store the names and contact details of its employees. It
creates a table that looks like this:

emp_id emp_name emp_address emp_mobile

Sukshma RD,Asst Prof,Hindustan College Page 31

 Database Management Systems

101 Herschel New Delhi 8912312390

8812121212
102 Jon Kanpur
9900012222

103 Ron Chennai 7778881212

9990000123
104 Lester Bangalore
8123450987

Two employees (Jon & Lester) are having two mobile numbers so the company stored them in
the same field as you can see in the table above.

This table is not in 1NF as the rule says “each attribute of a table must have atomic (single)
values”, the emp_mobile values for employees Jon & Lester violates that rule.

To make the table complies with 1NF we should have the data like this:

emp_id emp_name emp_address emp_mobile

101 Herschel New Delhi 8912312390

102 Jon Kanpur 8812121212

102 Jon Kanpur 9900012222

103 Ron Chennai 7778881212

104 Lester Bangalore 9990000123

104 Lester Bangalore 8123450987

Second normal form (2NF)

A table is said to be in 2NF if both the following conditions hold:

 Table is in 1NF (First normal form)

 No non-prime attribute is dependent on the proper subset of any candidate key of table.

Sukshma RD,Asst Prof,Hindustan College Page 32

 Database Management Systems

An attribute that is not part of any candidate key is known as non-prime attribute.

Example: Suppose a school wants to store the data of teachers and the subjects they teach. They
create a table that looks like this: Since a teacher can teach more than one subjects, the table can
have multiple rows for a same teacher.

teacher_id subject teacher_age

111 Maths 38

111 Physics 38

222 Biology 38

333 Physics 40

333 Chemistry 40

CandidateKeys:{teacher_id,subject}
Non prime attribute: teacher_age

The table is in 1 NF because each attribute has atomic values. However, it is not in 2NF because
non prime attribute teacher_age is dependent on teacher_id alone which is a proper subset of
candidate key. This violates the rule for 2NF as the rule says “no non-prime attribute is
dependent on the proper subset of any candidate key of the table”.

To make the table complies with 2NF we can break it in two tables like this:
teacher_details table:

teacher_id teacher_age

111 38

222 38

333 40

teacher_subject table:

teacher_id Subject

Sukshma RD,Asst Prof,Hindustan College Page 33

 Database Management Systems

111 Maths

111 Physics

222 Biology

333 Physics

333 Chemistry

Now the tables comply with Second normal form (2NF).

Third Normal form (3NF)

A table design is said to be in 3NF if both the following conditions hold:

 Table must be in 2NF

 Transitive functional dependency of non-prime attribute on any super key should be

removed.

An attribute that is not part of any candidate key is known as non-prime attribute.

In other words 3NF can be explained like this: A table is in 3NF if it is in 2NF and for each
functional dependency X-> Y at least one of the following conditions hold:

 X is a super key of table

 Y is a prime attribute of table

An attribute that is a part of one of the candidate keys is known as prime attribute.

Example: Suppose a company wants to store the complete address of each employee, they create
a table named employee_details that looks like this:

emp_id emp_name emp_zip emp_state emp_city emp_district

1001 John 282005 UP Agra Dayal Bagh

1002 Ajeet 222008 TN Chennai M-City

1006 Lora 282007 TN Chennai Urrapakkam

Sukshma RD,Asst Prof,Hindustan College Page 34

 Database Management Systems

1101 Lilly 292008 UK Pauri Bhagwan

1201 Steve 222999 MP Gwalior Ratan

Super keys: {emp_id}, {emp_id, emp_name}, {emp_id, emp_name, emp_zip}…so on

Candidate Keys: {emp_id}
Non-prime attributes: all attributes except emp_id are non-prime as they are not part of any
candidate keys.

Here, emp_state, emp_city & emp_district dependent on emp_zip. And, emp_zip is dependent on
emp_id that makes non-prime attributes (emp_state, emp_city & emp_district) transitively
dependent on super key (emp_id). This violates the rule of 3NF.

To make this table complies with 3NF we have to break the table into two tables to remove the
transitive dependency:

employee table:

emp_id emp_name emp_zip

1001 John 282005

1002 Ajeet 222008

1006 Lora 282007

1101 Lilly 292008

1201 Steve 222999

employee_zip table:

emp_zip emp_state emp_city emp_district

282005 UP Agra Dayal Bagh

222008 TN Chennai M-City

282007 TN Chennai Urrapakkam

Sukshma RD,Asst Prof,Hindustan College Page 35

 Database Management Systems

292008 UK Pauri Bhagwan

222999 MP Gwalior Ratan

Boyce Codd normal form (BCNF)

It is an advance version of 3NF that’s why it is also referred as 3.5NF. BCNF is stricter than
3NF. A table complies with BCNF if it is in 3NF and for every functional dependency X->Y, X
should be the super key of the table.

Example: Suppose there is a company wherein employees work in more than one department.
They store the data like this:

emp_id emp_nationality emp_dept dept_type dept_no_of_emp

1001 Austrian Production and planning D001 200

1001 Austrian stores D001 250

1002 American design and technical support D134 100

1002 American Purchasing department D134 600

Functional dependencies in the table above:

emp_id -> emp_nationality
emp_dept -> {dept_type, dept_no_of_emp}

Candidate key: {emp_id, emp_dept}

The table is not in BCNF as neither emp_id nor emp_dept alone are keys.

To make the table comply with BCNF we can break the table in three tables like this:
emp_nationality table:

emp_id emp_nationality

1001 Austrian

1002 American

emp_dept table:

Sukshma RD,Asst Prof,Hindustan College Page 36

 Database Management Systems

emp_dept dept_type dept_no_of_emp

Production and planning D001 200

Stores D001 250

design and technical support D134 100

Purchasing department D134 600

emp_dept_mapping table:

emp_id emp_dept

1001 Production and planning

1001 Stores

1002 design and technical support

1002 Purchasing department

Functional

dependencies:
emp_id ->

emp_nationality
emp_dept -> {dept_type, dept_no_of_emp}

Candidate keys:
For first table: emp_id
For second table: emp_dept
For third table: {emp_id, emp_dept}

This is now in BCNF as in both the functional dependencies left side part is a key.

 Transaction : A transaction is an action, or series of actions that are being

performed by a single user or application program, which reads or updates the contents
of the database. A transaction can be defined as a logical unit of work on the database. This
Sukshma RD,Asst Prof,Hindustan College Page 37
 Database Management Systems

may be an entire program, a piece of a program or a single command (like the SQL
commands such as INSERT or UPDATE) and it may engage in any number of operations on
the database.

Let’s take an example of a simple transaction. Suppose a bank employee transfers Rs 500
from A's account to B's account. This very simple and small transaction involves several low-
level tasks.
A’s Account

Open_Account(A)

Old_Balance = A.balance

New_Balance = Old_Balance - 500

A.balance = New_Balance

Close_Account(A)

B’s Account

Open_Account(B)

Old_Balance = B.balance

New_Balance = Old_Balance + 500

B.balance = New_Balance

Close_Account(B)

A transaction can include the following basic database access operations:

Operations Descriptions

Retrive To retrieve data stored in a database.

Insert To store new data in database.

Delete To delete existing data from database.

Sukshma RD,Asst Prof,Hindustan College Page 38

 Database Management Systems

Update To modify existing data in database.

Commit To save the work done permanently.

Rollback To undo the work done.

Transaction failure in between the operations

Now that we understand what is transaction, we should understand what are the problems
associated with it.

The main problem that can happen during a transaction is that the transaction can fail before
finishing the all the operations in the set. This can happen due to power failure, system crash etc.
This is a serious problem that can leave database in an inconsistent state. Assume that transaction
fail after third operation (see the example above) then the amount would be deducted from your
account but your friend will not receive it.

To solve this problem, we have the following two operations

Commit: If all the operations in a transaction are completed successfully then commit those
changes to the database permanently.

 Transaction Properties

A transaction is a very small unit of a program and it may contain several low-level tasks. A
transaction in a database system must maintain Atomicity, Consistency, Isolation, and Durability
− commonly known as ACID properties − in order to ensure accuracy, completeness, and data
integrity.

Following are the Transaction Properties, referred to by an acronym ACID properties:

Sukshma RD,Asst Prof,Hindustan College Page 39

 Database Management Systems

1. Atomicity : This property states that a transaction must be treated as an atomic unit, that is,
either all of its operations are executed or none. There must be no state in a database where a
transaction is left partially completed. States should be defined either before the execution of the
transaction or after the execution/abortion/failure of the transaction. Atomicity is also known as
the ‘All or nothing rule’.

Atomicity involves the following two operations:

Abort: If a transaction aborts then all the changes made are not visible.

Commit: If a transaction commits then all the changes made are visible.

Example: Let's assume that following transaction T consisting of T1 and T2. A consists of Rs
600 and B consists of Rs 300. Transfer Rs 100 from account A to account B.

T1 T2

Read(A) Read(B)

Sukshma RD,Asst Prof,Hindustan College Page 40

 Database Management Systems

A:= A-100 Y:= Y+100

Write(A) Write(B)

After completion of the transaction, A consists of Rs 500 and B consists of Rs 400.

If the transaction T fails after the completion of transaction T1 but before completion of
transaction T2, then the amount will be deducted from A but not added to B. This shows the
inconsistent database state. In order to ensure correctness of database state, the transaction must
be executed in entirety.

2. Consistency: The database must remain in a consistent state after any transaction. If the
database was in a consistent state before the execution of a transaction, it must remain consistent
after the execution of the transaction as well. The transaction is used to transform the database
from one consistent state to another consistent state. The execution of a transaction will leave a
database in either its prior stable state or a new stable state. The integrity constraints are
maintained so that the database is consistent before and after the transaction.

For example: The total amount must be maintained before or after the transaction.

1. Total before T occurs = 600+300=900

2. Total after T occurs= 500+400=900
Therefore, database is consistent. Inconsistency occurs in case T1 completes but T2 fails. As a
result T is incomplete.

3. Isolation: Isolation states that for every pair of transactions, one transaction should start
execution only when the other finished execution. Isolation property of a transaction means that
the data used during the execution of a transaction cannot be used by a second transaction until
the first one is completed. This property isolates transactions from one another.In other words, if
a transaction T1 is being executed and is using the data item X, that data item cannot be accessed
by any other transaction (T2………..Tn) until T1 ends.

4. Durability : This property ensures that once the transaction has completed execution, the
updates and modifications to the database are stored in and written to disk. The database should
be durable enough to hold all its latest updates even if the system fails or restarts. If a transaction
updates a chunk of data in a database and commits, then the database will hold the modified data.

Sukshma RD,Asst Prof,Hindustan College Page 41

 Database Management Systems

If a transaction commits but the system fails before the data could be written on to the disk, then
that data will be updated once the system springs back into action.

These updates now become permanent and are stored in non-volatile memory. The effects of the
transaction, thus, are never lost.

 States of Transactions

A transaction in DBMS can be in one of the following states.

1.Active
2.PartiallyCommitted
3.Failed
4.Aborted
5. Committed

State Description

Sukshma RD,Asst Prof,Hindustan College Page 42

 Database Management Systems

Active state A transaction goes into an active state immediately after it starts execution,
where it can issue READ and WRITE operations.
A transaction may be aborted when the transaction itself detects an error
during execution which it cannot recover from, for example, a transaction
trying to debit loan amount of an employee from his insufficient gross salary.
A transaction may also be aborted before it has been committed due to system
failure or any other circumstances beyond its control.

Partially committed When the transaction ends, it moves to the partially committed state.When the
last state is reached.
To this point, some recovery protocols need to ensure that a system failure
will not result in an inability to record the changes of the transaction
permanently. Once this check is successful, the transaction is said to have
reached its commit point and enters the committed state.

Committed After successful completion of transaction.

A transaction is said to be in a committed state if it has partially committed
and it can be ensured that it will never be aborted.

Failed state o If any of the checks made by the database recovery system fails, then
the transaction is said to be in the failed state.
o In the example of total mark calculation, if the database is not able to
fire a query to fetch the marks, then the transaction will fail to execute

Aborted o If any of the checks fail and the transaction has reached a failed state
then the database recovery system will make sure that the database is
in its previous consistent state. If not then it will abort or roll back the
transaction to bring the database into a consistent state.

o If the transaction fails in the middle of the transaction then before

executing the transaction, all the executed transactions are rolled back

Sukshma RD,Asst Prof,Hindustan College Page 43

 Database Management Systems

to its consistent state.

o After aborting the transaction, the database recovery module will

select one of the two operations:

1. Re-start the transaction

2. Kill the transaction

Introduction To transaction Processing

Single User VS Multi User Systems One criteria to classify Database is according to number of
user that concurrently connect to the system.

Single User: only one user use the system in each time

Multi User: many users use the system in the same time.

Transactions, Read and Write Operations, and DBMS Buffers What is a Transaction?

Transaction is an executing program that forms a logical unit of database processing.

A transaction include one or more database access operations. The database operation can be
embedded within an application or can be specified by high level query language. Specified
boundary by Begin and End transaction statements If the database operations in a transaction do
not update the database, it is called “ Read-only transaction ”.

Failure Classification

To find that where the problem has occurred, we generalize a failure into the following
categories:

1. Transaction failure
2. System crash
3. Disk failure

Sukshma RD,Asst Prof,Hindustan College Page 44

 Database Management Systems

1. Transaction failure

The transaction failure occurs when it fails to execute or when it reaches a point from
where it can't go any further. If a few transaction or process is hurt, then this is called as
transaction failure.

Reasons for a transaction failure could be -

1. Logical errors: If a transaction cannot complete due to some code error or an

internal error condition, then the logical error occurs.
2. Syntax error: It occurs where the DBMS itself terminates an active transaction
because the database system is not able to execute it. For example, The system
aborts an active transaction, in case of deadlock or resource unavailability.

2. System Crash
3. System failure can occur due to power failure or other hardware or software
failure. Example: Operating system error.

Fail-stop assumption: In the system crash, non-volatile storage is assumed not to

be corrupted.

3. Disk Failure
4. It occurs where hard-disk drives or storage drives used to fail frequently. It was a
common problem in the early days of technology evolution.
5. Disk failure occurs due to the formation of bad sectors, disk head crash, and
unreachability to the disk or any other failure, which destroy all or part of disk
storage.

Concurrency Control

Concurrent Executions Transaction processing permit Multiple transactions to run concurrently.

Multiple transactions to update data concurrently Cause Complications with consistency of data

Reason for allowing concurrency Improved throughput of transactions and system resource
utilization Reduced waiting time of transactions.

Sukshma RD,Asst Prof,Hindustan College Page 45

 Database Management Systems

DBMS Concurrency Control

Concurrency Control is the management procedure that is required for controlling concurrent
execution of the operations that take place on a database.

But before knowing about concurrency control, we should know about concurrent execution.

Concurrent Execution in DBMS

o In a multi-user system, multiple users can access and use the same database at one time,
which is known as the concurrent execution of the database. It means that the same
database is executed simultaneously on a multi-user system by different users.
o While working on the database transactions, there occurs the requirement of using the
database by multiple users for performing different operations, and in that case,
concurrent execution of the database is performed.
o The thing is that the simultaneous execution that is performed should be done in an
interleaved manner, and no operation should affect the other executing operations, thus
maintaining the consistency of the database. Thus, on making the concurrent execution of
the transaction operations, there occur several challenging problems that need to be
solved.

Problems with Concurrent Execution

In a database transaction, the two main operations are READ and WRITE operations. So, there
is a need to manage these two operations in the concurrent execution of the transactions as if
these operations are not performed in an interleaved manner, and the data may become
inconsistent. So, the following problems occur with the Concurrent Execution of the operations:

Problem 1: Lost Update Problems (W - W Conflict)

The problem occurs when two different database transactions perform the read/write operations
on the same database items in an interleaved manner (i.e., concurrent execution) that makes the
values of the items incorrect hence making the database inconsistent.

For example:

Consider the below diagram where two transactions T X and TY, are performed on the same
account A where the balance of account A is $300.

Sukshma RD,Asst Prof,Hindustan College Page 46

 Database Management Systems

o At time t1, transaction TX reads the value of account A, i.e., $300 (only read).
o At time t2, transaction TX deducts $50 from account A that becomes $250 (only deducted
and not updated/write).
o Alternately, at time t3, transaction TY reads the value of account A that will be $300 only
because TX didn't update the value yet.
o At time t4, transaction TY adds $100 to account A that becomes $400 (only added but not
updated/write).
o At time t6, transaction TX writes the value of account A that will be updated as $250 only,
as TY didn't update the value yet.
o Similarly, at time t7, transaction TY writes the values of account A, so it will write as
done at time t4 that will be $400. It means the value written by T X is lost, i.e., $250 is
lost.

Hence data becomes incorrect, and database sets to inconsistent.

Sukshma RD,Asst Prof,Hindustan College Page 47

 Database Management Systems

Dirty Read Problems (W-R Conflict)

The dirty read problem occurs when one transaction updates an item of the database, and
somehow the transaction fails, and before the data gets rollback, the updated database item is
accessed by another transaction. There comes the Read-Write Conflict between both
transactions.

For example:

Consider two transactions TX and TY in the below diagram performing read/write

operations on account A where the available balance in account A is $300:

o At time t1, transaction TX reads the value of account A, i.e., $300.

o At time t2, transaction TX adds $50 to account A that becomes $350.
o At time t3, transaction TX writes the updated value in account A, i.e., $350.
o Then at time t4, transaction TY reads account A that will be read as $350.
o Then at time t5, transaction T X rollbacks due to server problem, and the value changes
back to $300 (as initially).
o But the value for account A remains $350 for transaction T Y as committed, which is the
dirty read and therefore known as the Dirty Read Problem.

Sukshma RD,Asst Prof,Hindustan College Page 48

 Database Management Systems

Sukshma RD,Asst Prof,Hindustan College Page 49