Database Lecture Notes

LECTURE NOTES OF DATABASE ENGINEERING
(BCS-204) CR.-04
Prepared by
Dr. Suvasini Panigrahi, Dr. Satyabrata Das, Dr. Rakesh Mohanty
DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING
Veer Surendra Sai University of Technology (VSSUT)
Formerly University College Of Engineering, Burla
Sambalpur, Odisha, India

LECTURE PLAN OF DATABASE ENGINEERING (3-1-0) Cr.-04
MODULE – I (10 Lectures)
Lecture 1: Introduction to Database Systems and its Applications
Lecture 2: Database System Architecture
Lecture 3: Data Abstraction, Data Independence
Lecture 4: Data Models – Network, Hierarchical and Relational Data Models
Lecture 5: Data Models – Relational and Object Oriented Data Models
Lecture 6: Entity Relationship (ER) Model
Lecture 7: Mapping ER Model to Relational Model
Lecture 8: Data Definitions Languages
Lecture 9: Data Manipulation Languages
Lecture 10: Integrity Constraints and Data Manipulation Operations
MODULE – II (08 Lectures)
Lecture 11: Relation Query Language, Fundamental Relation Algebra Operations
Lecture 12: Extended Relation Algebra Operations
Lecture 13: Tuple and Domain Relational Calculus
Lecture 14: SQL
Lecture 15: QBE, Domain and Data Dependency
Lecture 16: Armstrong’s Axioms, Dependency Preservation, Lossless Design
Lecture 17: Normal Forms – 1NF, 2NF, 3NF, BCNF
Lecture 18: Higher Normal Forms – 4NF, 5NF, Comparison of Oracle and DB2
MODULE – III (08 Lectures)
Lecture 19: Introduction to Query Processing
Lecture 20: Translating SQL Queries into Relational Algebra
Lecture 21: Algorithms for External Sorting
Lecture 22: Algorithms for SELECT and JOIN Operations
Lecture 23: Algorithms for PROJECT and SET Operations
Lecture 24: Query Equivalence, Join Strategies
Lecture 25: Overview of Query Optimization
Lecture 26: Query Optimization Algorithms
MODULE – IV (12 Lectures)
Lecture 27: Storage Strategies – Indices, B-Trees
Lecture 28: Storage Strategies – Hashing
Lecture 29: Introduction to Transaction Processing, Transaction and System Concepts
Lecture 30: Desirable Properties of Transactions
Lecture 31: Schedules and Recoverability
Lecture 32: Serializability of Schedules
Lecture 33: Locking Techniques for Concurrency Control, Time-stamp based schedules
Lecture 34: Multi-version and Optimistic Concurrency Control Schemes
Lecture 35: Database Recovery Techniques
Lecture 36: Advanced Topics – Object-Oriented and Object Relational Databases, Logical Database
Lecture 37: Advanced Topics – Web Databases, Distributed Databases
Lecture 38: Advanced Topics – Data Warehouse and Data Mining

Traditional File Oriented Systems
A time when there were no database system
Scenario: University administration
Person incharge Application File name
(University) Program
A
B
C
Assumptions:
• A file named “general data” may contain name, registration no, address and
other information of the student.
• The file “grade data” includes the results of oral exam, written exams, seminars,
projects etc.
• Class data additionally comprises the attendances of the students.
While generating the students progress report, the three files must be updated to give
the consistent report.
Problems of traditional file systems: File oriented systems have many drawbacks of
storing, using and maintaining date.
Redundancy: Repeated occurrences of the same date in different files.
Problems: Wastage of memory, increased management, increased processing time and
cost.
Inconsistency: Logical mismatch of data in files Especially caused due to changes.
Atomicity: There may be partial updates in files.
Data Program dependence: Changes in program structure required to incorporate new
data type. Changes in file structure lead to changes in the application program
structure.
Data isolation: Multiple files and formats.
Inflexibility: Analysis of data as well as the realization of new application is
problematic.
AP1 grade date
AP2 Class date
AP3 General data

Data from several files can only be combined.
With high costs. (DBMS as an interface between user and the database)
No central control: Files are used in decentralized manner. Multiple file names and
data names may be used by different departments.
Limited data sharing: Difficult to obtain data from several (Atomicity) in compartible
files from separate systems.
Security problems: It is difficult to enforce security system.
Requirements of database systems:
Minimal data redundancy: Redundancy is carefully controlled by availed duplicate
copies of the same data by an integrated view on date.
• The controlled redundancy improves performance.
Data independence: Application programmes are independent of representation of
data and data storage (Abstract view)
Efficient data Access: DBMS uses a variety of techniques to store and retrieve data
efficiently.
• Application of index structures to have faster access.
Concurrent data access: System to allow simultaneous access to the same data by
different users.
• Each user gets the impression of exclusively accessing data.
• Concept of transaction for the synchronization of concurrent data access.
Consistency of data: Caused by lack of redundancy. DBMS must ensure consistency
of data after each transaction.
Integrity of data: correctness and completeness of data (Semantic aspects),
formulation of integrity constraints and integrity rules.
• DBMS checks constraints for each insertion, change and deletion of data.
Data Security: Protection of the database against un authorized access (view on data)
Queries
Appln. Programs
DBMS OS DB

• Access control with authentication and encoding as the possible protection
mechanisms.
Database Concepts:
Database: An integrated collection of related files.
• The data must be organized in some logical manner so that it can be processed
effectively and efficiently.
• Generally data can be organized in the form of file, records, fields, characters,
bytes and site.
File: A group of related records is called a file- student.
Record: A set of related data items (fields) is called a record.
Roll Name Age Sex Class
102 Manas 17 M XI
Field: An individual data item within a record is called a field. Ex. Roll, name, age, sex,
class of a student.
Character: A single character, can be an alphabet, a digit or some other special
character a, x, s, o etc. A database may be a collection of files such as student, course,
teacher, fees etc.
DBMS: A set of related programs that controls the creation maintenance and utilization
of database of an organization.
Type of database management systems: There are two types
(i) Corporate/Entreprise databse: Designed primarily for applications in
corporations, government and enterprises. Characterised by huge volume of data
input and output Ex. SQL Server, Oracle, DBL etc.
(ii) Personal database: Designed to be used as learning tools and in small business
firms.
Ex. Personal oracle, Microsoft access, foxpro etc.
There are not highly scalable.
DBMS applications”
• Banking – All applications
• Air ticket reservations, schedules
• University registrations, grades, administrations

• Manufacturing, productions, inventory, orders.
• Human resources: records salaries, tax deduction.
• Database touches all aspects of our lives.
A DBMS – Contains information’s about an enterprise
• A collection of interrelated data
• A set of programs to access data efficiently
• An environment that is convenient to users and effective to use.
Back up and recovery:
Protection against the consequences of system errors.
Backup: Copies an external storage media (e.g. tapes, CDS)
Recovery: Automatic reconstruction of the last up-to-date and consistent database
status with the aid of tapes and a protocol listing the executed changes.
Posing queries: DBMS provides query language, which allows to pose ad hoc queries
by using the key board and to get an immediate answer.
Diversified user Interfaces: DBMS provides query languages for occasional users.
• Programming interfaces for implementers/programmers.
• Menu driven interfaces for naïve users.
• Window based Graphic oriented interfaces for graphics users.
• Data definition languages, data manipulation languages.
Flexibility: Change of database structure without change of existing application
programme (e.g. extension of a record by a new field, insertion of new collection of data
in to database).
• Evaluation of data according to other criteria in an easy way.
Faster development of new application:
• Use of the powerful functions of a DBMS for new applications.
Limitations of DBMS:
• Increased complexity: A multiuser DBMS is extremely complex piece of
software.

• Large storage requirement: The large complexity and wide functionality makes
DBMS complex and large size so it occupies a large storage space (few
gigabytes)
• Specialized manpower is required: To use and maintain the DBMS
• Required more installation and management cost.
• Requires additional hardware: depending upon the environment and
functionality.
• Explicit backup and recovery system is required when damage occurs.
Data Abstraction: The three tier DBMS architecture
DBMS has several abstraction levels such as
• External/view levels- External schema
• Conceptual/logical level- Conceptual schema
• Physical /internal level – Internal schema
View 1 View 2 View n
External
Schema
Conceptual Schema
Internal Schema
Mapping
supplied by DMMS
Mapping supplied
By DBMS/OS
Internal Schema
Mapping / transformation rules
Conceptual / external schema
Conceptual
Schema
Transformation rules
physical / conceptual schema
Database
DBMS
OS

• The view at each level is described by a schema
• The Schema describes the way in which the entities of one level of abstraction
may be mapped in to the next level.
• The overall design of a database is called database schema.
• The database schema includes information such as
Characteristics of data items such as entities & attributes.
Logical structure and relationship among data items.
Format for storage representations.
Integrity parameters such as physically authorization and backup policies.
External Schema:
• The level closest to the user and highest level of abstraction.
• Concerned with the way in which data are required by the user / viewed by the
user.
• Describes only part of the data base called view level.
• Each external schema is used by represented by a data model.
• Described the part of database, which is relevant to the user.
Conceptual Schema:
• It described the logical structure of the data base.
• It described the entities, data types, relationships, user operations and
constraints.
• It defines a schema based on a data model.
• It gives information about existing data and relationships in database.
Internal Schema:
• The lowest level of abstraction. It describes the physical storage structure of the
database.
• The internal schema uses physical data model.
• It describes complete details of the storage and access paths.
• It describes the detailed data structure of the data items.
Database schema and state:
• A schema describes the structural design of the DB.

• A State describes a concrete instances of the DB.
Data Abstraction
• Abstraction is an act of representing the essential features of something without
including much details.
• The data abstraction refers to describing essential features of the data item
without including the implementation details.
• Users can know only the essential features that they are interested but can not
know the internal implementation.
Data Independence:
• Denotes the property that higher levels of abstraction are not influenced by
changes in the lower levels.
• The ability to change the schema at one level of a database system without
affecting a schema definition in the next higher level is called data independence.
• There are three levels of abstractions so there are two types of data
independence.
Logical data independence: The ability to change the conceptual schema without
affecting the external schema.
• Changes of the conceptual schema (e.g. information about new types of entities,
further information about existing entities) do not have impact on external
schema (e.g. existing application programs.)
• Example: extension of the class data for an additional Boolean value expressing
whether the merits required for a master thesis have been performed.
Physical data independence:
• The capacity to change internal schema without having to change the conceptual
schema and thus also not to change the external schema.
• Ex. Creating additional access structure to (implement) improve performance of
the retrieval and update.
• Ex. The class data, which are so far stored in an unsorted file, are to be
reordered /reorganized in a B-tree to enable efficient access by the “registration
number”.

• The three schema architecture can make it easier to achieve true data
independence both physical and logical.
• In general the interfaces between various levels and components should be well
defined so that changes in some part do not seriously influence others.
(Three level architecture of DBMS by example)
Data base languages: There are two main types of languages.
(i) Data definition language (DDL)
(ii) Data manipulation language (DML)
(i) Data Definition language (DDL)
• DBMS provides a facility known as data definition language (DDL)
• DDL is used by DBA to define conceptual and internal schema
• DDL describes the entities, attributes and their relationship.
• Ex. Create table account. (account no char (10), balance integer).
• DDL generates a set of tables stored in a data dictionary
• Data dictionary contains metadata (data about data) such as
User-1
Item name
Item code
price
User-2
Item code
Price
Quantity
User-31
Item name
Price
Quantity
Conceptual Level
Item code number (4)
Item name character (20)
Student (same: String, srno, string,
branch, string….)
Courses (code, string, name, string
credit, integer) Internal Level
Item code length=8 bytes
Item name length = 20 bytes
Relations are stored as unordered
Files Indore on first column of
students items.
Courscito (code stom, srno,
string, sname. String)

• Data base schema
• Data storage and definition language (SDL) which describes storage structure
and access methods used.
• Integrity constraints such as
• Domain constraints
• Referential integrity
• Assertions
• Authorization.
• DDL compiler processes the DDL statements in order to indentity the description
of schema objects / construct.
• DDL statements are used to create / define, update/alter and drop schema
objects.
(ii) Data manipulation language (DML)
• The language for accessing and manipulating data
• Data access involves retrieval of a set of data items.
• Data manipulation involves user queries for insertion, deletion and update of
records.
• Two types of DML statements.
• Procedural- uses specify what data is required and how to get those date
• Non procedural: user only specifies what data is required .
• DML is a part of the query language SQL
• The DML commands of SQL are
• Insert: to insert a new record
• Delete: to delete an existing record
• Update: to modify an existing record
But in a true 3-tier schema architecture, the other languages that are used by the
database are:
(i) Storage Definition language (SDL): Used to specify by the internal schema
• It describes the storage structure and access methods of the database.
(ii) Transaction control language (TCL)

• A transaction is a collection of operations that performs a single logical
function in a database application.
• TCL provides the transaction management commands such as commit and
Roll back.
(iii) View Definition language:
• Used to specify user views and their mapping to conceptual schema.
• Ex. View point.
(iv) Data control languages (DCL)
• Allows a user to grant privileges or right to others to access the database.
• Ex. Grant revoke.
In most of the database, TCL, SDL, VDL and DCL are all part of the DBMS’s DDL
component. Where DDL is used to define both conceptual and external schema.
Data models:
• A collection of tools for describing
• Data
• Relationship among data
• Their semantics and
• Constraints
Types of data models:
1. Object based logical data models
2. Record based logical data models.
3. Physical data models.
4. Semi structured data models (XML)
1. Object based logical data models
• Object oriented logical data model
• Object relational data models Ex. E.R. model
2. Record based logical data models.
• Network data model
• Hierarchical data model
• Relational data model.

3. Physical data models.: Used for internal shcema definition.
Record based data models.
1. Hierarchical data models:
• Data are organized in a ordered tree manner.
• Relationship between records is parent child type.
• The data base in this model is a collection of disjoint trees.
• It is a simple and straight forward model & easy to understand.
• It is used when there is question of hierarchical relationship
• In order to represent link among records pointers are used.
• The relationship among records are physical
• Searching for a record is not easy.
• Represents one to many relationship
• Deletion of an internal node deletion of its leaves.
Advantages.
• Simple and easy to use
• Data with hierarchical relationship can be mapped on this model.
• Suitable for application such as: Employee Dept.
ECE Dept.
Fee AH
CSE Dept.
AH Fees
ECE Dept.
AH Fee
ECE Dept.
AH Fee
College

Disadvantages:
• Search for (an element or ) a record is difficult.
• Insertion, deletion and updation is difficult.
• Many – many relationship can not be established.
• Data with non hierarchical relationship can not be mapped.
• The hierarchical relationship is maintained using points which requires extra
storage.
• Changes in relationship requires changes in entire structure of the database.
• Processing is sequential among branches of the tree so access time is high.
Network data model:
• It was formalized by conference on data system language (codasyl)
• It is an improvement over hierarchical data model.
• It represents many-to-many relationships.
• A child can have multiple parents.
• Relationship between records is maintained by pointers.
• Each record has a pointer field for the record with which it is associated.
Advantages:
• Many to many relationship among records can be implemented .
• Useful for representing such records which are represented in many to many
relationships.
• Searching a record is easy since there are multiple access paths .
• No problem of consistency in case of addition deletion of records.
Disadvantages:
• Implementations of records and relationship is complex.
• Storage space requirement is high because of so many pointers.

(Network data model)
Relational data model:
1. In relational data model the relation or a named table is the only construct
required to represent an association among the attributes of an entity set and the
relationships among different entities.
2. Relationship between record is represented by a relation that contains a key for
each record involved in the relation.
3. Many to many relationship can easily be implemented.
4. Relationship implementation is very easy through the use of key and composite
key fields.
5. Relational model is useful for representing most of the real world entities and
relationships among them.
6. Relational model does not maintain physical connection among records.
7. Data is organized logically in the form of rows and columns.
8. A unique indexed key field is used to search for data element.
9. Data integrity is maintained by the process like normalization .
10.Description of data in terms of this model is called a schema.
11.Schema for relation specifies, its name, name of each field. Ex. Student (sid:
Integer, name: string, login: string etc.)
Advantages:
1. Tabular structure is easy to understand simple.
Dept. of ECE
Attend
Dept. of IT Dept. of CSE Dept. of EEE
College
Attend Fees Attend Attend

2. Data manipulation is easy.
3. We can apply mathematical operation on tables.
4. Built in query language support such as SQL.
5. Very flexible data organization.
Disadvantages:
1. Size of the data base becomes large.
Example: Oracle, Ingress, Sybase, Unity etc.
Customer table :
Account No. :
Properties of a relation/table:
1. The data represented in this model is in the form of two dimensional table called
relation.
2. An entity is represented by a tuple in a row.
3. The rows of a table are distinct.
4. Ordering of rows is immaterial.
5. Each column of the table is assigned distinct heading called name of the
attribute.
6. In each column data item are of similar type.
7. The ordering of the columns is immaterial.
8. If there are M. columns, it is said to be of degreeim.
9. If there are N rows, it is called a N tupple table or cardinality of the table is N.
10.Both the rows and columns can be viewed in any sequence at any time without
affecting the information.
Properties of relational data base management system (RDBMS)
• A relational database management is represented by relational data models.
• It uses a collection of tables to represent the data and the relationship among
them.
• Each table has multiple no of rows and columns
• Supports the concept of null values.
Customer ID Customer Name Customer Street
Account No. Balance

• Does not require the user to understand its physical implementation.
• Provides information about its contents and structure.
Domain and Integrity Constraints:
Domain Constraints:
• Limit the range of domain an attribute values on.
• Specify uniqueness and null ness of attributes.
• Specify default value of an attribute.
Integrity constraints:
Entity integrity: Every tuple is uniquely identified by a unique non null attribute, primary
key i.e. the primary key values can not be null.
Referential integrity: Rows in different tables are correctly related by valid key values
(Foreign keys refers to primary keys)
Basic terminologies of relational data model: (RDBMS)
1. Entity: A real world object with some properties which can be easily identified is
called an entity.
2. Attributes: An attribute is a descriptive property or a characteristics of an entity.
Ex name, roll marks, etc.
3. Degree: The no of columns or attributes associated with a table ( or a relation
among them) is called degree of the relation.
4. Cardinality: The no of rows in a table is called cordinality.
5. Tuples: A relation consisting of a number of records represented in row wise
information called tuples.
6. Domain: The set of possible values that can allotted to an attribute is called
domain of that attribute. Domain d is a set of atomic values of an attribute.
7. Entity set: A set of entities representing a real world object. Ex. Student,
teacher, depositor, player etc.
8. Weak entity: An entity set which may not have sufficient attribute to form a
primary key then it is called an weak entity.
9. Strong entity: An entity set which have a key attribute.
10.Key: An attribute that allows us to uniquely identity a record or an entity type.

11.Super key: A set of attributes that collectively allows us to identify an entity is an
entity set.
12.Candidate key: A candidate key is the minimal super key. The super key for
which no proper subset is a super key.
13.Primary key: Primary key is the one of the candidate key to identify the entity
uniquely. The primary key is the principal means of identifying an entity.
14.Entity type: The occurrences of an entity set are called entities
15.Composite key: A composite key is a candidate key that consists of two or more
attributes.
16.Foreign key: A foreign key is an attribute (a group of attributes) that is primary
key to another relation. A ford on key represents a relationship between two
tables.
Entity- Relationship Model:
• This model is introduced by the scientist peter chen in 76.
• E.R model is a generalization of hierarchical and network data model.
• It allows the representation of explicit constraints as well as relationships.
• The relationship between the entity set is represented by named E-R
relationships such as i:m, m:m, etc mapping from one entity set to another.
Terminologies: (Basic concepts)
Entity: The basic object that the E-R model represents is an entity which is a real world
object.
Ex. A teacher , A student, A depositor, A borrower etc.
Entity set: A collection of entities is known as an entity set, Ex. Teacher, student etc.
Relationship set: A collection of relations between entities.
• The relations can be either.
• One-to-one
• One to many a many to one
• Many to many

Constraints: On the entities, relationships and attributes.
Ex.
Def.: In this model a database is considered as
A collection of entities and
Relationship among entities
An entity : is an object that exists and distinguishable from other objects. A specific
student, a teacher etc.
Types of entities: There are two types of entities
(i). Dependent entity (ii) Independent entity
(i). Dependent entity : An entity whose existence depends on the existence of another
entity is called dependent entity.
Ex.
• The existence of the entity marks depends an existence of student.
• Dependent entities are also called weak entities.
borrower
Customer
street
Customer
Loan
Loan No amount
Customer city
SSN
name
attributes
Entity Relationship Entity
Course Student
Offering Marks

(ii) Independent entity: Independent entities are called strong entities or regular or
strong entities.
Weak entity types: Entity types that do not have key attributes of their own are called
weak entities types.
Attributes:
• The characteristics of an entity are called attributes. Ex. Roll no, name, marks,
etc are the attributes of an entity student.
• An attribute is a descriptive property of an entity
Compound attribute: An attribute which can logically have some supper attributes is
called compound attribute.
Ex.
• A compound attribute is the one that actually consist of all other attributes.
Simple attribute: An attribute composed of a single component with an independent
existence.
A simple attribute can not be decomposed in to smaller components.
Emp
Ename
fname mname
lname

E.R Model
Relationships: A relationship is an association among several entities.
In E.R diagram a relationship is represented by a diamond shape.
Types of relationships: There are three type of relationships
(Binary)
(i) I : I (one-one)
(ii) I : M (one-to many)
(iii) M : I (many to one)
(iv) M : M (many to many
(i) one to one relationship: One to one (I:I) relationship is an association only
between two entities.
Ex.
• One instance of an entity is associated with only one instance of the other entity set.
(ii) One to many relationship: The relationship is said to be one to many, when
one instance of an entity set is related to more than one instance of another
entity set.
Ex.
(a)
(b)
(a)
(b)
Department Head of dept.
EngineAutomobile
Headed by
Has
ChildrenFather Has
CoursesTeacher teaches
FatherFather Children
Teacher Students
teacher Courses
M
MTeacher

(iii) Many to one relationship: When many instances of an entity set are
associated with at most one instance of another entity set.
Ex.
Many students opt. for a single college.
(iv) Many to many relationship: A many to many relationship represents
association of one entity with many entities of other or many entity of one
entity set are associated with one entity of other set.
Ex.
Participation of an entity set in a relationship set: There can be total participation or
partial participation.
(i) Total participation: Every entity in the entity set participates in at least one
relationship in the relationship set.
Eg. Participation of loan in borrower is total.
i.e. Every loan must have a customer associated with it.
(ii) Partial participation: Some entities entities many not participate in any relationship
in the relationship set.
Ex. Participation of customer in borrower is partial.
------------ represents total participation.
---------- represents partial participation.
M CollegeOpt. forStudents I
Students Courses
Opt. for
Enrolls
M M
Customer LoanBrower
amount
Loan #
Cid
C name
Cstreet
Customer LoanBrower
Loan # amount
C name
Cid
Cstreet
C City

E.R. Diagrams: Represents the conceptual E-R data model
Symobols Description
1 Recentagle Represents entity set
2. Diamond Represents relationship set
3. Ellipses Represents attributes.
4. Double ellipse Represents multivalued attributes
5. Dashed ellipse Represents derived attributes
6. Underlined attribute Ex. Represents primary key attributes.
7.
Lines
Link attributes to relate with entity
sets and entity sets to entity sets.
8. Double rectangle Represents weak entity set.
9. Dashed underline
Discriminating attribute of weak entity
set.
10.
Many to many relationship
Empno
A

11. Many to one relationship
12. One to one relationship
13. Specialization or generalization
14. Total Generalization
15. Disjoint generalization
16
Total participation of entity set in
relationship
17 Role indicator
18 Cardinality limits
19.
Identifying relationship set for weak
entity set.
1. A simple E-R diagram:
ISA
ISA
E
E
Customer LoanBorrower
Cust_id
Cust. name
Cust Street
Cust-city
Loan No
Amount

2. E-R diagram with composite, multivalued and denved attributes.
3. E-R diagram with relationship set having attribute.
4. E-R diagram with roles.
• Roles : Manager, Worker
• Role lebels are optional and used to clarify semanties of the relationship .
• Here manager and worker belong to same entinty set.
5. E-R diagram representing cardinality limit.
6. E-R diagram to represent weak entity sets.
• An entity set that does not have a primary key is referred to as a weak entity
set.

• The existence of a weak entity set depends on the existence of identifying
entity set.
• It must relate to the identifying entity set via a total one to many relationship
set from the identifying to weak entity set.
• Identifying relationship depicted from using a double diagram.
• The discriminator (or partial key) of a weak entity set is the set of attributes
that distinguishes among all the entities of a weak entity set.
• The primary key of a weak entity set is formed by the primary key of the
strong entity set on which the weak entity set is existing plus the weak entity
sets discriminator .
• We depict a weak entity set by double rectangles.
• We underline the discriminator of a weak entity set with a dashed line
• Payment number- discriminator of the payment entity set.
• Primary key of payment- (loan no, payment number)
Note: Primary key of the strong entity set is not explicitly stored with the weak entity set
since it is implicit in the identifying relationship.
• Single valued attribute: An attribute that holds a single value for each
occurrence of an entity type Ex. Empid, emphasis ok.
• Multivalued attribute: A multivalue attribute is an attribute that holds multiple
values for each occurance of an entity type Ex. Phone numbers, skill of an
employee.
• Derived attribute: Can be computed from other attributes . Ex. Age, for given
date of birth, year of service, given a date of joining.
• Identifier attribute: An attribute that uniquely identifies a particular entity from an
entity set.
Ex. Empid, personid , regn. No etc.

Super type and sub types.
Here employee is the super type, it can be of two types salaried employee or hourly
employees. So hourly employees and salaried employee are sub types.
Primary key of the super type is the foreign key of sub types.
Ternary relationships.
E. R diagram with ternary relationship.
E-R diagram with ternary relationship.
N. ary relationship: In case of n-ary relationship along a single relationship diagram
with n connections, one to each entity represents some associations among n entities.

Aggregation
• Aggregation in the process of compiling information on an object thereby
abstracting a higher level object.
• Aggregation is the part whole of a part of relationship in which objects representing
the components of something one associated with an object representing the entire
assembly.
Ex.
• Aggregation is an abstraction (such as the one just through which relationships
are treated as higher level entities.
• To eliminate redundancy via aggregation.
- Treat relationship as an abstract entity
- Allows relationship between relationships.
- Abstraction of relationship into new entity.
• Without introducing redundancy, the following diagram represents
- an employee works on a particular job on a branch
- an employee, branch, job combination may have an associated manager.
(E-R diagram with aggregation)
Categorization:
- Categorization is the process of modeling of a single sub type (sub class) with
a relationship that involves more than one distinct super type (or super class)

Aggregation – contd. Another form of aggregation is abstracting a relationship
between objects and viewing the relationship as an object. Ex. Enrollment relationship
student and course could be viewed as registration.
Generalization:
• A button up design process – combines a number of lower level entity sets that
share the common features in to a higher level entity set.
• Generalization is used to emphasize the similarities among lower level entity sets
and to hide the differences.
• It is called as “a kind of” or is a relationship.
• In terms of ER diagram, generalization is pictured through a triangle component
labeled is a relationship.
• Generalization and specialization are inverse of each other .
• Generalization and specialization are inter changeably used.
• Generalization and specialization are used to represent in the E-R diagram in the
same way.
• The ISA relationship is referred to as super class sub class relationship.

Extended E-R features:
• The EE-R model consist of all the concepts of E-R model together with the
following additional concepts.
• Specialization.
• Generalization
• Aggregation
• Categorization
Specialization: Specialization is the process of identifying subsets of an entity set (the
super class or super type) that share some distinguishing characteristics.
• The higher level entity set is called the super class.
• The lower level entity set as a result of specialization is called sub class.
• The supper class includes the properties of the sub classes.
• The sub classes are defined on the basis of some distinguishing characteristics.
Attribute in heritance: a lower level entity set inherits all the attributes and relationship
participation of the higher level entity set to which it is linked.
Specialization: A top down design process. Depicted by a triangle labeled by a ISA
relationship.

E-R Model
Super type and sub type: The sub type / super type relationship is used when either or
both of the following conditions are satisfied.
(i) There are attributes
That are common to some (but not all) of the instances of the entity type.
(ii) The instances of a sub type participate in a relationship unique to that sub type
Advantages of using super type / sub type / class.
The concept of introducing super class and sub class in to ER model provides the
following enhanced feature.
• It avoids the need to described similar concepts more than once, thus saving
time for the data modeling person.
• It results in more reliable and better looking E-R diagram.
• Super class and sub class relationships and more semantic content and
information to the design in a concise form.
Specifying constraints on Specialization and Generalization.
There are mainly two types of constraints.
- Participation constraints.
- Disjoint constraints.
Participation constraints. : Two types of participations constraints (a) total
participation (b) partial participation.
(a) Total participation constraint: Every number in the super type must participate
as a member of some sub class, it is represented by double line.
(b) Partial participation Constraint: A member of super type need not belong to
any of its sub classes of a specialization or generalization.
Ex. An employee may not be a union of club member.

(b) Partial or optional constraints.
Disjoint constraints.: The constraint is only applied only when a super type has more
than one sub type. The sub types are disjoint so entity occurrence can be at most one
place of sub types.
CODD’S Rules: There are twelve rules formulated by Ted codd for RDBMS in 1970.
A database is said to be an RDBMS if it satisfies all the twelve rules.
1. Information presentation: All information should be explicitly and logically
represented by entering the data value in the form of tables.
2. Guaranteed access rule: Every item of data must be logically addressable by
resorting to a combination of table name, primary key value and column name.
3. Systematic treatment of null values: Null values can be supplied if the information
is missing a inapplicable.
4. Database description rule: An RDBMS must have a data dictionary which describes
the database and consist of tables and views.

5. The comprehensive sublanguage rules: There must be at least one language
supporting statements in character strings for
• Data definition (Language)
• Integrity constraints
• View definition (Language)
• Authorization
• Data manipulation
• Transaction boundaries
6. The view updating rule: All views that can be updated in theory can also be
updated by the system.
7. The insert and update rule: Apart from data retrieval an RDBMS must be capable of
updating and deleting data as a relation set.
8. The physical independence rule: The changes in storage structure and access
methods should not affect the application programs through which users access the
database.
9. The logical data independence rules: Application programs must be independent
of changes made to the base table.
10. Integrity rules: There are two types of integrity rules.
(a) Integrity rule 1 (Entity integrity): If the attribute A of a relation R is a prime attribute of
R, then A can not accept null values.
(b) Integrity rule 2 (Referential Integrity): Attributes of a relation having domains that are
those of primary key of another relation.
If relation (A) may contain references to another relation (s) then the relations R and S
may not be distinct.
11. Distribution Rule: An RDBMS must have distribution independence. It should allow
the database to be distributed across multiple computers even though they are having
heterogeneous platforms.
12. No sub version rule: If an RDBMS supports lower (version) level language that
permits for example a row at a time processing. Then this language must not be able to
by pass any integrity rules or constraints of the relational language.

Thus not only an RDBMS be governed by a set of relational rules but those rules (or
constraints of the relational language must be its primary laws.
Note: An RDBMS package should satisfy at least six of the 12 rules to be accepted as
an RDBMS software package.
The is no RDBMS package commercially available that satisfies all the 12 rules
given by ted codd.
Introduction to object oriented database system.
Research to model and process complex data has gone in two way
(a) Extending the functionality of RDBMS
(b) Developing and implementing OODBMS that is based on object oriented
programming paradigm.
Applications of OODBMS:
Multimedia
CAD
Office automation etc.
The next generation database systems
Object orient DBMS (OODBMS)
Knowledge database Management system (KDBMS)
New database applications:
1. Design data bases: Designing CAD/CAM/CASE Systems.
2. Multimedia databases: Designing systems to support data storage and access
which are in the form of text, image, video, voice, graphs, figures etc.
3. Knowledge bases: AI and Expert systems represent information as facts and rules
that can be collectively viewed as knowledge base.
Object oriented Database Management System.
• Object oriented technology includes object oriented programming languages
c++, small talk, object oriented data base system, object oriented user interfaces
(Macintosh & MS windows systems and so on.)
• An object oriented technology makes available to the users facilities that are
based on object oriented concepts

Relational Query Language.
Relational query languages are of two types.
1. Procedural query language e.g. Relational algebra.
2. Non- procedural language e.g. Relational calculus
3. Pure Languages e.g. (i) Relational Algebra (ii) Tuple relational
Relational Algebra: Calculus (iii) Domain relational calculus.
• Relational databases are usually defined by relational algebra.
• It is a procedural language.
• It consists of set of operations that take one or two relations as input and
produces a new relation as output / result.
Relational Algebra is:
• The formal description of how a relational database operates.
• An interface to the data stored in the database it self.
• The mathematics which underpin SQL operations.
The fundamental relational algebra operations are.
(i) Simple operations
(i) Union – U (cup) (ii) Intersection – n (Cap)
(iii) Difference – - minus) (iv) Cartesian product – x (times)
(ii) Special relational operations
(i) Selection – б (sigma) (ii) Projection – π (pie)
(iii) Division ( ) (iv) Join – x (bow-tie)
(v) Rename –ς (Rho)
(i) Simple operations
(i) Union: Union of two relations R, and R2 is a relation R3 that includes all the topples
that are either in R1 or in R2 or in both R1 and R2 and duplicate topples are eliminated.
Requirements for set operations (Union, difference, intersection)
Two relations are said to be union compatible
If (a) They have same no of attributes
(b) the domain of each attribute in column order is the same as in both R1 and R2.

Mathematically, two relations R1 (A1A2….. An) and R2 (B1, B2… Bm) are union
compatible if.
(a) a=n
(b) Domain (Ai) = domain (Bi) for I ≤i ≤n
Notation: R1 UR2
Definition: R1 UR2 = { t l t R1 or t R2}
Ex.
The general form of Union operation is given by
Union Tablename1, table name2
In to table name3, (out put relation)
In SQL the relational Union operation is expressed as
Select from relation1
Union
Select from relation 2
Relational calculus form of union is given by
Π Customer name (depositor) U π customer name (borrower)
(ii) Intersection: Intersection of two relations R1 and R2 is a relation that includes all
tuples that are both in R1 and R2. The resulting relation might have the same attribute
names as the first or the second relation.
Relation R1, R2 .
Notation R1 n R2 .
A B
α 1
β 2
γ 3
Б 2

Definition:
R1 η R2 = { RI t R1 and R2}
• The general form of INTERSECTION operation is given as
INTERSECTION table-name 1 table-name 2
Into Result (output relation 1 table)
• In SQL the relational INTERSECTION OPERATION is expressed as
SELECT From relation 1
INTERSECTION
SELECT from relation 2
• In relational calculus the intersection can be used as
Ex. Find all customers with an account as well as loan
Π Customer name (Depositor) n Π customer name (borrower)
(iii) Difference operation: If two relations R1 and R2 are union compatible then they
can participate in difference operation.
The resultant relation R3 is having the same attributes as that of R1 and R2.
The tuples of R3 are belonging to R1 which do not belong to R2
i.e. R3=R1 – R2 = { RI t R1 and ∉R2}
• The general form of DIFFERENCE operation is given as
DIFFERENCE table-name 1 table-name 2
Into Result (output relation 1 table)
• In SQL the relational difference operation is expressed as
SELECT From relation 1
MINUS
SELECT from relation 2
(iv) Cartesian product: (cross product)

• If two relations R1 and R2 do not have common attributes names then the
relations R1 and R2 are called product compatible.
• If the two relations are product compatible then they can participate in Cartesian
product.
• The resultant relation is a con catenation of each tuple of R1 with each tuple of
R2.
• So the resultant relation R3 will have the attributes which are attributes of both R1
and each tuple of R1 appear with all tuples in R2.
Relation R1, R2 .
Notation R1 n R2 .
Definition: R1 X R2
{ (x,y) ! x R1 and Y R2}
R1XR2
• The Cartesian product of two relations R1 (A1 A2…. An) with cardinality i and R2
(B1 B2 B3….. Bm) with cardinality j is a relation R3 with degree k=n+m, cardinality
i x j and attributes (A1, A2 ………….. An, B1, B2…… Bm)
• Cartesian product operation is costly and its practical use is limited.
• The general form of Cartesian product is given by CARTESIAN PRODUCT table
name 1, table name 2 into Result ( opp. relation)
• In SQL the Cartesian product is expressed as.
CARTESIAN PRODUCT Relation 1, Relation 2
Into Relation 3
Or

R3 = CARTESIAN PRODUCT R1, R2
Note:
1. Cartesian product is possible if attributes of R1 and R2 are disjoint (R1 n R2 =φ)
2. If the attributes of R1 and R2 are not disjoint then renaming must be used.
Composition of operations:
We can build relations using multiple relational operations.
Ex. A = C (R1 X R2)
A B C D E
α
β
1
2
α
β
2
3
A
b
(v) Rename operation:
• Allows us to refer a relation in more than one name.
• The rename operator returns an existing relation under a new name
• Example ƒX (E) returns the expression E under the new name X.
• If the relation algebra expression E has amity n then Example ƒX A1, A2 An (E)
returns the results of expression E under the name X and with the attributes
renamed to A1, A2……An.
Equivalences:
The same relational expression can be written in many different ways.
The order in which the tuples appear in relations is never significant.
≅
∩ ≅ ∩
∪ ≅ ∪
− ≠ −
1 2 ≅ 2 4 1 ∩ 2 (A)
Πa1 (A) ≅ Πa1 ( Πa1 , etc (A))

• The equivalent expression always give same result, but when the query is
submitted to the DBMS, its query optimizer tries to find the most efficient
equivalent expression before evaluating it.
Division operation :
The division of two relations R1 (A1, A2…… An) with cardinality i and R2 (B1, B2….. Bm)
with cardinality j is a relation R3 with degree K=n-m, cardinality idivj and attributes that
satisfy division condition.
Let A ← set of attributes A1, A2, A3 ………… An.
B ← set of attributes B1, B2, B3 ………… Bm.
C ← set of attributes C1, C2, C3 ………… Cn-m.
C = A-B, B ≤ A
C is the set of attributes of R1 that are not in R2
The division operator can be defined as a relation over the attributes C that consist of
the tuples from first relation R1 that match the combination of every tuple in another
relation R2.
• The general form of division operation is
Division relation name2, relation name 1
Into Result (output relation)
• In SQL the division operation may be expressed as:
Select from relation1.
Division
Select from relaiton2
Ex.
Summary of operations:

1. Select
2. Project
3. Union
4. Intersection
5. Difference
6. Division
7. Join
Special operations
Selection: The select operator is used to extract (select) tuples from a specified
relation.
• Selection condition can be applied on attributes of a relation.
• The selection condition may contain the comparison operators = <, >, < >, <= >=
• The selection condition may contain Boolean operators AND, OR, NOT, etc.
The general form of selection operation is
< selection condition > ( < relation name>)
Select table (or relation) name
< where predicates >
In to results (out put relation)
• The result of selection has same attributes as the relation specified in relation
name

• Select is used to obtain a subset of the tuples of a relation that satisfy a select
condition.
Relation:
A B C D A B C D
α
α
β
β
β
α
β
β
β
β
1
5
5
12
13
7
7
7
3
10
α
β
α
β
1
23
7
10
Notation бP (r) P ← selection predicate
Defined as бP (r) = { t I t E K and PCt) }
Where p is a formula is propositional calculus consisting of terms connected by : ^ v 7
etc.
Each term is one of
< attribute> of <attribute> or <constant> where op is one of =<, > =, <=, >, = etc.
Example: б (salary > 2000) EMP
In SQL, the query will be represented as:
Select From EMP
Where Salary > 20000,
If this query is applied to the relation EMP as below.
EMP
EMP
No,
ENAME JOB MGR SALARY

7782 CLERK MANAGER 7839 24,500
7839 KING PRESIDENT 50,000
7934 MILLER CLERK 7782 13,000
The resultant relation will be
EMP
No,
PROJECTION :
• Projection operation is used to extract entire columns or attributes.
• It constructs a new relation by selecting only specified attributes of the existing
relation and eliminating duplicate tuples in the newly formed relation.
• Degree of the new relation is same as the no of attributes. The general format of
representation of Projection operation
Π <attribute list> (<relation name>)
• The project operation is used to select a subset of the attributes of a relation by
specifying the names of the required attributes.
Ex. EMP
EMP
No,
ENAME JOB MGR
7369 SMITH CLERK 7902
7521 JOHNS SALESMAN 7698
7698 BLACKE MANAGER 7839
7782 CLERK MANAGER 7839
After using the relational expression π (job, mgr) EMP on the above relation it would
produce.
JOB MGR

CLERK 7905
SALESMAN 7698
MANAGER 7839
The general form of projection operation is given by.
Project table (relation) name on (or over) column names
Into Result (output relation)
In SQL, the project operation is expresses as.
Select distinct attribute data.
From relation (or table)
The composition of select and project operations:
Select and project can be combined together. For example if the relational expression.
Π (job, mgr) (б (salary > 20000) EMP) is applied on the relation.
EMP
No,
7934 MILLER CLERK 7782 13,000
It will result the following information.
JOB MGR
MANAGER 7839
PRESIDENT
JOIN OPERATION
Notation R1& R2
Let to and s are the pair of tuples from R1 and R2. If t and s have the same value on
each of the attributes in R1nR2 and tupelo t to the result, where
t1
has the same value as t and

t1
has the same value as s
• Join is a method of combining two or more relations in a single relation.
• It brings together nows (tuples) from different relations (table) based on the truth
of same specified condition.
• It requires choosing attributes to match tuples in the relations .
• Tuple in different relations but with the same value of matching attributes are
combined in to a single tuple in the output (result) relation.
• Joining the most useful of all the relational algebra operations.
• The general form of joining operation is
Join relation name 1
With relation name 2
On (or over) domain name
Into result (output relation)
• In SQL the join operation is expressed as
Select attributes data
From outer table (relation), inner table (relation ) name <where predicate(s) >
Ex. Join Warehouse
With items
On whid
Into R6
Or R6 = Join Warehouse, Items over WHID
R1 R2A B C D
α
β
γ
α
б
1
2
4
1
2
α
γ
β
γ
β
a
a
b
a
b
B D E
1
3
1
2
3
a
a
a
b
b
α
β
γ
б
∈

R1 & R2
Example:
R1 = (A,B,C,D)
R2= (E,B,D)
R1 & R2 = (A,B,C,D, E,B,D)
Def: R1 & R2 = π r.A, r.B, r.C, r.D, s.E (6r.B= S.B ^ r.D = S.D (r x s)
Example Query
Find the name of all customers who have a loan at the bank and the loan
amount.
Π c name, Loanno, amount (borrower & loan)
In SQL:
Select district cname, loanno, amount
From borrower natural join loan
Select b.c name l.loanno, l. amount
From borrower e join loan L using l.loanno.
Types of join operation
(i) Equi join
(ii) Theta join
(iii) Natural join
(iv) Outer join
(i) Equijoin: When two relations are joined together using equality of values in one or
more attributes they make an equijoin.
A B C D E
α
α
α
α
α
1
1
1
1
2
α
α
γ
γ
β
a
a
a
a
b
α
γ
α
γ
б

In equijoin the comparison operation (=) is only used. The result of an equijoin will
always have one or more pairs of attributes that have identical values in every
tuple.
Write a query to retrieve empno, empname, salary, mgrno and corresponding
manager name.
Select e.name, e empno, e.sal, emgr, m.ename
From emp e, emp m
Where e.mgr = m.empno;
(ii) Theta Join (Q) : It is denoted by R1 & R2, i Q j
• Where i and j are columns of R and S respectively and Q represents any of the
comparison operators (=,<,≤, ≥, ≠ ).
• The general join condition is of the form < condition> AND <condition>…. Here
each condition is of the form Ai Q Bj.
• Where Ai is an attribute of relation R1 and Bi is an attribute of relation R2.
• A join operation with such a general join condition is called theta join.
(iii) …
(iv) Outer Join: An extension of join operation that avoids loss of information.
• It computer the join operation and address tuples from one relation that does not
match tuples in the other relation to the result of the join.
• An outer join retains the information that would have been lost from the relation
(table), replacing missing data with nulls.
There are three forms of outer join
(i) Left outer join
(ii) Right outer join
(iii) Full outer join
(i) Left outer join: It is represented by R1 & R2

It retains data from the left hand table
(ii) Right outer join: It is represented by R1 & R2
It retains data from right hand table
(iii)Full outer join: It is represented by R1 & R2
It retains data from both the tables.
Example:
R1 R2
The left outer join retains the tuple from the left hand table even when there is not
matching value in other relation.
A B C D
α
β
γ
α
б
1
2
4
1
2
α
γ
β
γ
β
a
a
b
a
b
B D E
1
3
1
2
3
a
a
a
b
b
α
β
γ
б
∈
A B C D E
α
α
α
α
Б
β
1
1
1
1
2
2
4
α
α
γ
γ
β
γ
a
a
a
a
b
a
b
α
γ
α
γ
Б
null

(i) Left outer Join) (ii) ( Right outer join)
(iii) (Full outer join)
General form of outer join:
Outer join outertable name, innertablename
On (or over) domain name
Into result (output relation)
In SQL, the join operation is expreses as
SELECT attribute (s) data
From outer table (relation), inner table (relation) name
< Where predicate (s) >
γ β null A B C D E
α
α
α
α
β
null
null
1
1
1
1
2
3
3
α
α
γ
γ
β
null
null
a
a
a
a
b
a
b
α
γ
α
γ
Б
β
∈
A B C D E
α
α
α
α
β
null
null
1
1
1
1
2
3
3
α
α
γ
γ
β
null
null
a
a
a
a
b
a
b
α
γ
α
γ
Б
β
∈

Example of Queries: With Banking operation
The Banking operation system consists of following entities.
Branch (bname, bcity, assets)
Customer (cname, cstreet, ccity)
Account (accountno, bname, balance)
Loan (loanno, bname, amount)
Depositor (cname, accountno)
Borrower (cname, loanno)
1. Find loans over Rs.12,000
(i) Б amount > 12,000 (loan)
(ii) SELECT * from loan
Where amount > 12000;
2. Find the loan number for each loan of an amount greater than Rs.12,000.
(i) Π loanno (Б amount > 12,000 (loan) )
(ii) SELECT Distinct loanno from loan
Where amount > 12,000;
3. Find the names of all customers who have a loan, an account , or both from the
bank.
(i) Π customer name (borrower) U Π customer – name (depositor)
Π iname (borrower) U Π name (depositor)
(ii) SELECT Distinct name from borrower UNIOR.
SELECT Distinct name from depositor;
4. Find the names of the all customers who have loan at chandaka branch.
(i) Π c name (Бb name = “CHANDAKA”
(Б borrower. Loonno =loan.loan.no (borrower X loan)
5. Find the names of all customers who have a loan at the CHANDAKA branch but do
not have an account at any branch of the bank.
(ii) Π name (Бb name = “CHANDAKA”
(Б borrower. Loonno =loan.loan.no (borrower X loan)- Π c name (depositor)
6. Find names of the customer who have a loan at “CHANDAKA” branch.

(i) Π c name (Бb name = “CHANDAKA”
(Б borrower. Loonno =loan.loan.no (borrower X loan)
Or
Π c name (Бloan. Loan no = borrower. loanno
(Б bname= CHANDAKA (Loan) X borrower )
RELATIONAL DATABASE DESIGN (RDD)
• A database must be designed before its creation and use.
• The database design must confirms to common standards
Such as : Memory saving, faster access, easy maintenance portability, facilities for
future enhancements, performance and cost efficiency etc.
• The final logical design of a database needs to give the optimal performance along
with a database integrity.
• This can be achieved by a procedure called “Narmahzation”
• The data base must be in a state of fully normalized form.
NORMALIZATION:
Def: Normalization is a body of rules addressing analysis and conversion of data
structures in to relations that exhibit more desirable properties of internal consistency,
minimal redundancy and maximum stability.
Def: Normalization is the process of decomposing a set of relations with anamolies to
produce smaller and well structured relations that contain minimum or no redundancy.
Def: Normalization is the process of reducing /decomposing a relation into a set of
small relations free from data redundancy and ensuring data integrity.
Def: Normalization is a procedure of successive reduction of a given collection of
relational schemas based on their FDS and primary keys to achieve desirable form of
minimized redundancy, minimized insertion, deletion and minimized update analmolies.
OBJECTIVES
• The basic objective of normalization is to reduce the data redundancy and
prevent loss of information or avoid inconsistencies when the data base is
altered.
• The types of alterations needed for relations are:

1. Insertion of new data values to a relation.
2. Deletion of tuple or a row in a relation.
3. Updating or changing the value of an attribute in a tuple.
• The normalized relation does not include spurious inform ation when the original
schema is reconstructed.
• Preserves dependencies present in the original database /shed
About Normalization:
• The process of normalization was proposed by EF codd.
• Normalization is a buttom-up design technique for relational database.
• This technique is useful in the circumstances such as .
- A different method of checking the properties of design arrived at through
EER modeling.
- A technique of reverse engineering a design from an existing undocumented
implementation.
Key terms:
Data redundancy: If data in the database exist in two or more places / locations i.e.
direct redundancy or if data can be calculated from other data items i.e. indirect data
redundancy. Then the data base is said to be redundant.
• Data should only be stored once and avoid storing data that can be calculated
from other data.
• During normalization redundancy is removed of course not at the cost of integrity
(rules) of the database.
Data Integrity: All the data in the database are consistent and satisfies all integrity
constraints.
INTEGRITY CONSTRAINTS = An integrity constraint is a rule that restricts the values
that may be present in the database.
• The relational data model includes constraints that are used to verity the validity
or the data as well as adding meaningful structure to it. Value in each row.
Entity Integrity: The primary key must have unique not null.
Referential Integrity: Every foreign key must either be null or its values must be the
actual value of a key in another relation.

INF
Successive normal forms of a relation:
• Converting the relation to INF is the essential step.
• There are successive higher normal forms such as 2NF, 3NF, BCNF, 4NF, 5NF.
• Each normal form is an improvement over the earlier form.
• A higher normal form relation is a subset of lower normal form.
Fig: Successive normal forms
• The higher normalization steps are based on three important steps.
(i) Dependence among attributes in a relation.
(ii) Identification of an attribute or a set of attributes as the key of a relation.
(iii) Multivalued dependency between attributes.
Normalization of data or relations is the process of analyzing the given relation schema
based on their FDS and primary keys to achieve the desirable properties or
(i) Minimizing redundancy
(ii) Minimizing insertion, deletion and updation anamolies.
Normalization procedure provides the database designers.
• A formal frame work for analyzing the relation based on their keys and functional
dependencies among their attributes.
2NF
3NF
BCNF
4 NF
5 NF

• A series of normal form tests that can be carried out on individual relations so
that the relational database can be normalized to any desired degree.
The normal form of a relation refers to highest normal form condition that it meets and
hence indicated the degree to which it has been normalized.
• To reach the highest normal form the designers decompose the relation in top-
down fashion.
• The process of normalization through decomposition must confirm to the
following properties while satisfying the criteria of normal forms.
(i) Loss less join /decomposition
(ii) Functional dependency preservation
(iii) Attribute preservation.
FIRST NORMAL FORM:
• First Normal Form (INF) deals with the shape of the record type.
• The relation is said to be in INF if and only if, it. It contains no repeating attributes
or groups attributes.
• The relation/table is said to be in INF when each cell of the tuble/relation contains
precisely one value (atomic)
• The relation is said to be INF if each cell value is atomic.
Let us consider a relation student (Roll no, name, dob, subject grade)
Roll No Name DOB Subject Grade Teacher
101 Rakesh 14.11.1985 RDBMS
DEC
MATH-II
PHY-II
NT
E
A
O
E
A
Smith
Clark
Allen
Johnes
Martin
102 Tapan 18.07.1986 DEC
MATH-II
PHY-II
RDBMS
A
E
O
E
Clark
Allen
Johnes
Smith

NT B Martin
104 Mohan 19.07.1985 RDBMS
MATH-II
PHY-II
DEC
NT
O
A
E
B
A
Smith
Allen
Johnes
Clark
Martin
Table: An un normalized relation with multiple values in a cell.
• Here the table students is not normalized because the cells in subjects and grade
are not atomic.
• By the definition of INF, each cell value must be atomic so, to normalize the
relation we need to fill all the columns of rollno, name, dob by repeating values
for each rows corresponding to subject and grade or each student.
So, the normalized table would be
Roll No Name DOB Subject Grade Teacher
101
101
101
101
101
Rakesh
Rakesh
Rakesh
Rakesh
Rakesh
14.11.1985
14.11.1985
14.11.1985
14.11.1985
14.11.1985
RDBMS
DEC
MATH-II
PHY-II
NT
E
A
O
E
A
Smith
Clark
Allen
Johnes
Martin
102
102
102
102
102
Tapan
Tapan
Tapan
Tapan
Tapan
18.07.1986
18.07.1986
18.07.1986
18.07.1986
18.07.1986
DEC
MATH-II
PHY-II
RDBMS
NT
A
E
O
E
B
Clark
Allen
Johnes
Smith
Martin
103
103
103
103
103
Mohan
Mohan
Mohan
Mohan
Mohan
19.07.1985
19.07.1985
19.07.1985
19.07.1985
19.07.1985
RDBMS
MATH-II
PHY-II
DEC
NT
O
A
E
B
A
Smith
Allen
Johnes
Clark
Martin

Table-2: Student data representation in relation students.
The table is normalized to INF but it can lead to several undesirable problems
• Redundancy exists which leads to wastage of memory also.
• The multiple copies of same fact leads to update anamolies.
Ex: Change in date of birth leads to change in all tuples.
• If the teacher teaching a subject, it can be entered only if a student enrolls to the
subject.
So it leads to insertion ahamolies.
• If the only student in a given course discontinues the information as to which
course a professor is teaching will be lost if the student information is deleted.
Properties of normalized relation
An ideal relation after normalization should have the following properties so that the
problems of redundancy and in consistency is avoided.
1. No data value should be duplicated in different rows unnecessarily.
2. A value must be specified (and required) for every attribute in a row.
3. Each relation should be self contained. In other words if a row from a relation is
deleted, important information should not be (Deleted) accidentally lost.
4. When a row is added to a relation, other relations in the database should not be
affected.
5. A value of an attribute in a tuple may be changed independent of other tuples in
the relation and other relations.
The idea of normalizing relations to higher and higher normal forms is to attain the
goals of having a set of ideal relations meeting the above criteria.
Decomposing the relation
The decomposition of a relation scheme R= (A1, A2, A3…. An) is its replacement by a
set of relation schems { R1, R2,……Rm) such that for Ri≤ R for ≤ I ≤ m and R1 UR2
UP3….. URm=R.
A relation scheme R can be decomposed in to a collection of relation schemes { R1,
R2… Rm) to eliminate some of the anamolies contained in the original relation R.

Here (i) the relation scheme Ri ≤ R. or Ri ≤ R, I ≤ I ≤ m.
(ii) Ri n Rj for I ≠ j, need not be empty
(iii) Ri u R2 UR3 … URm=R
Decomposition Criteria: The process of normalization through decomposition must
confirm to the following properties while satisfying the criteria of normal forms.
(i) Loss less join / decomposition
(ii) Functional dependency preservation
(iii) Attribute preservation.
Armstrong Rules:
The well known rules called inference rules are defined in functional dependencies.
IRI : Reflexive rule:
If X ⊇ Y then X →Y
If Y ⊆ X then X →Y
Any set of attributes functionally determines itself X →Y
IR2 : Augmentation Rule:
If X →Y then XZ →YZ
The augmentation rule may also be stated as
If X →Y then XZ →Y
Augmenting the left hand side attribute of a functional dependency produces
another functional dependency.
IR3: Decomposition / projective rule:
If X →Y and Y →Z then X →Y
IR4: Decomposition / projective rule:
If X →YZ and Z →Y then X →Z
IR5: Union or Additive rule:
If { X →Y and X →Z} then X →YZ
IR6: Pseudo Transitive rule:
If { X →Y, WY →Z} then WX →YZ

Of these the first three are known as Armstrong rules. These are sound because it is
enough if a set of FDS satisfy these three.
They are complete because using these three rules we can generate the rest of the
inference rules.
Full Functional dependency (FFD)
• The term ful functional dependency (FFD) is used to indicate the minimum set of
attributes in a determinant of a FD.
• In other words, the set of attributes X will be fully functionally dependent on the
set of attributes Y if.
• X is functionally dependent on Y and
• X is not functionally dependent on any subset of Y
Eg.
Note: Like FD, FFD is a property of the information presented by the relation.
• It is not an indication of the way that attributes are formed in to relations or
current contents of the relations.
IR7: Composition:
If X →Y, and Z →W then XZ →YW
IR8: Self Accumulaiton:
If X →YZ, and Z →W then X →YZW
FUNCTIONAL DEPENDENCY
• Normalization beyond INF relies on functional dependency.

• The value of an attribute in a raw will uniquely determine the value of another
attribute.
• Let X and Y be two attributes of a relation. If there is only one attribute value of Y
corresponding to it for a given value of X, then Y is said to be functionally
dependent on X.
• This is indicated by a relation X → Y.
• The arrow notation should be read as “Functionally determines”.
• So X functionally determines Y and X is functionally dependent on X.
• If X → Y, for any two tuples t1 and t2, if t1X = t2 X ⇒ t1Y = t2 Y. Trivial functional
dependency.
• The functional dependency X → Y is said to be trivial if Y≤ X.
• If X → Y in R, this does not mean whether or not Y → X in R.
Ex.: {Roll No} → {Name} ≠ {Name} → {Roll No}
Proof of IRI: suppose that X ⊇ Y and there exist two tuples in some instance of r of R
such that t1 [X] = t2 [X]
Then t1 [Y] t2 [Y] because X ⊇ Y
Hence X → Y must hold in R
Proof of IR2 : if X → Y then X Z → YZ.
Let X → Y holds in a relation instance r of R but XZ → YZ does not hold.
Then there must be two tuples t1 and t2 in r such that
(1) T1 [X] = t2 [X]
(2) T1 [Y] = t2 [Y]
(3) T1 [XZ] = t2 [XZ]
(4) T1 [YZ] = t2 [XZ] which is not possible because from (1) & (3) we deduce (5)
(5) T1 [Z] = t2 [Z] and from (2) and (5) we deduce (6)
(6) T1 [YZ] = t2 [YZ] contradicting (4) Hence the proof
CLOSURE
The set of all functional dependencies that include F as well as al dependencies that
can be inferred from F is called the closure of F and denoted by F+
.
The closure F+
of F is the set of all functional dependencies that can be inferred from F.

Eg.: F= { {A} → {B}
{A} → {B} }
A+
= {A,B,C}
i.e. F+
=A+
= {A,B,C}
Algorithm: Determining X+
, the closure of X under F
X+
= X repeat
Old X+
= X+
For each functional dependency , Y→ Z in F do
If X+
⊇ Y then If X+
= X+
U Z
Until (X+
= old X+
),
Proof of 1R3 “ {X→Y, Y→Z } ⇒ X→Z
Assume that (1) X→Y
(2) Y→Z
For any two tuple T1 and T2 in r such that
T1 [X] = t2 [X] we must have (By asumptn (1)
(3) T1 [Y] = t2 [Y] Hence we must that
(4) T1 [Z] = t2 [Z] from (3) and assumptn (2) Hence X→Z must hold in r from (1) & (4)
Keys of relational schema:
A super key is a set of attributes S of a relation schema R i.e. SCR, with the property
that no two tuples t1 and t2 will have t1 [S]= t2 [S]
The difference between any key and a super key is that a key is minimal.
Ex. {EMPNPO} is a key for the relation EMP whereas {EMPNPO, ENAME} ,
{EMPNPO, ENAME, JOB} and any set of attributes is said to be a super key if it
includes the key {EMPNO}
Candidate key: The minimal super key is called the candidate key.
Primary Key: If a relation schema has more than one key, each is called a candidate
key.

• One of the candidate key is choosen as primary key and others are secondary
keys.
Prime attribute: An attribute of a relation schema R is called a prime attribute of R if it
is a member of some candidate key of R.
Non prime attribute: An attribute is called a non prime attribute if it is not a prime
attribute i.e. an attribute is said to be a non-prime attribute if it is not a part of the
candidate keys.
Prove IR4 through IR8 by using IRI through IR3
Proof of IR4: X→YZ ⇒ X→Y, X→Z
1. X→YZ (Given)
2. YZ→Y (using IRI as YZ ⊇ Y )
3. X→Y (Using IR3 on 1 and 2)
Similarly, we can prove X→Z
Proof of IR5: X→Y, X→Z ⇒ X→YZ
1. X→Y (Given)
2. X→Z (Given )
3. X→ZY (By augmenting with X on IR2)
4. XY→YZ (Using IR2 on 2 by Augmenting with Y)
5. X→YZ (Using IR3 on 3 and 4)
Proof of IR6: {X→Y, WY→Z} ⇒ WX→Z
1. X→Y
2. WY→Z
3. WX→WY (Using IR2 on 1 by augmenting with W)
4. WX→Z (Using IR3 on 3 and 2)
Proof of IR7: {X→Y, Z→W} ⇒ XZ→YW.
1. X→Y (Given)
2. XZ→YZ (Augmenting with Z on 1) –IR2
3. Z→W (Given)
4. YZ→YW (Augmenting with Yon 1) –IR2

5. XZ→YW (Using IR3, transitive on 2 and 5)
Proof of IR8: {X→YZ and Z→W} ⇒ X→YZW.
1. X→YZ (Given)
2. YZ→Z (IRI, on I)
3. X→Z (IR3 on 1 and 2)
4. Z→W (Given)
5. X→W (IR3 on 3 and 4)
6. X→ZYZ (Augmenting with X on (1))- IR2
7. XYZ→YZW (Augmenting with YZ on 5)
8. X→YZ W (Using IR3 on 6 & 7 ) IR2.
Q. State Armstrong’s axioms. Show that Armstrong’s axioms are complete.
Ans. Armstrong’s axioms: Let R (X, Y,Z) is a relation schema with attributes X, Y,Z for
which Armstrong’s axioms are stated as follows.
Inf. Rule-1 : Reflexivity, If X⊇ Y, the X→Y
Inf. Rule-2 : Augmentation, If X→Y then XZ→YZ
Inf. Rule-3 : Transitivity, If X→Y, Y→Z then X→Z.
Completeness of Armstrong’s axioms:
Armstrong’s axioms are said to be complete because for a given set F of functional
dependencies we can determine the closure F+
from the FD’s of F by using the
Armstrong axioms i.e. inference rules 1 through inference rule 3.
Proof: Let us consider a relation scheme R (A,B,C,D,E,F)
With set of FD’S, F= {A→ B, A→C, CD→E, CD→DF, B→E}.
A+ = {A,B,C,E}
{CD} +
= {C,D,E,F}
F+
= (ACD)+
= {A,B,C,D,E,F}
Here, several FDS which are inferred in F+
are:
(i) A→E
(ii) CD→EF
(iii) AD→F

IF we are able to prove the above using Armstrong’s axioms then we can say that the
Armstrong’s axioms are complex.
(i) A→E
Since A →B , and B→E then A→E by IR3: Transitive rule
(ii) CD →EF
We have CD →E ……. (i)
And CD→F ……. (ii)
CD→CDE ……. (iii) using IR2, Augmenting
CDE→ EF……… (iv) using IR2, Augmenting with E on (ii)
(iii), (iv) = CD→EF, using IR3 on (iii) and (iv)
(iii) AD→ F
We have the FD’S A→C …… (i) and CD →F ……. (ii)
AD →CD…..(iii) using IR2, augmenting with D on (1)
AD→F, Using IR3, transitive rule on (2) and (3)
Similarly all the FD’S in F+
can be derived by using Armstrong’s axioms, i.e. IR1
through IRS.
Hence, Armstrong’s axioms are complete.
SECOND NORMAL FORM:
2NF is more stringent normal form than 1 NF.
Def1: A relation is in 2NF if and only if, it is in INF and every non-key attribute is fully
functionally dependent on the whole key.
Def2: A relation schema R is in 2NF if every non prime attribute A in R is fully
functionally dependent on the primary key of R.
Def3: A relation R is in 2NF provided it is in INF and every non prime attribute to be fully
functionally dependent on candidate key of R.
Def4: A relation schema R is in 2NF if every non prime attribute A in R is not partially
dependent on any key of R. or
A relation schema R is in 2NF if every non prime attribute A in R is fully
functionally, dependent on every key of R.
• 2 NF is really a test of primary key.

• 2 NF is concerned with the concept of full functional dependency.
• If a relation is in 1 NF and has a single attribute key it must automatically be in
2Nf.
Decomposing the relation:
As the table-2 for student relation involved redundancy and inconsistencies due to
insertion, deletion & updation. It can be decomposed in the three simple relations to
eliminate the redundancy and inconsistency.
Stdinf (Roll no, name., dob)
Courseinf (subject, grade, rollno)
Teacher inf (subject, teacher)
Since, the dependencies in the student table are:
Roll No Name DOB Teacher Subject Grade
Stdinf
Roll No Name DOB
101
102
103
Rakesh
Tapan
Mohan
14.11.1985
18.07.1986
19.07.1985
Teacherinf
Subject Teacher
RDBMS
DEC
MATH-II
PHY-II
NT
Smith
Johnes
Allen
Clark
Martin
Courseinf

Roll No Subject Grade
101
101
101
101
101
RDBMS
DEC
MATH-II
PHY-II
NT
E
A
O
E
A
Second Normal Form (2NF)
Let us consider a relation schema R (A,B,C,D,E,F) with a set of functional
dependencies.
F= {A} → {B}
{A} → {C}
{A} → {F}
{A} → {B}
{A,D} → {F}
{D} → {E}
(i) Find the scooper key
(ii) Closure
(iii) Identify the candidate key
(iv) IS it in 2NF ?
(v) If not decompose it in to 2 NF form.
Solution: The given functional Dependencies are:
{A} → {B}, {A} → {C}, {D} →{E}, {AD} →{F}
Super key of R is {AD}
Closure A+
= {A,B,C}
D+
= {D,E}
{A,D} +
= {A,B,C,D,E,F}
• There is no such single key that can derive /determine the other attribute.
• Here we take two keys together i.e. {AD} as the minimum super key.
Hence the candidate key is {AD}.

The relation is not is 2 NF since partial dependency exits.
{A, D} → {B} partially dependency
{A, D} → {C}
{A,D} → {F} Full functional dependency
{A,D} → {E} partial dependency
So we decompose our original relations
R1 (A,D,F) Since {A,D} → {F}
R2 (A,B,C) Since {A} → {B}, {A} → {C}
R3 (D,E) Since {D} → {E}
Example:
Let us consider the relation student (Roll No, Name, Address , courseno, cousename,
grade)
Roll No Name Address Courseno Coursename Grade
{RollNo}→ {Name}
{Roll No} → {Address}
{Course no} → {Course name}
{Roll No, Course no} → {Grade}
Problems
(1) IF we want to insert a new course then it can’t be inserted unless a new student
roll no, is created.
(2) If we delete a student roll no, the subject or course information is deleted if the
course in taken by only student.
(3) If we update a name, address it has to be updated at many places.
(4) redundancy exist at many places.
So, we decompose the relation student into subrelators as:
Student (roll no, name, address, courseno, coursename, grade)

Stdinfor (Roll no, name, address) = R1 (A,B,C)
Grade course infor (Rollno, courseno, grade) = R2 (A,D,F)
Course infor (Courseno, coursename) = R3 (D,E)
(Student (rollno, name, address, courseno, coursename, grade)
R (A,B,C,D,E,F)
R1 (A,B,C) R2 (A,D,F) R2 (D,E)
(Rollno, name, address) (rollno, couseno, grade) (courseno, coursename)
THIRD NORMAL FORM (3NF)
• 3NF is more stricter normal form than the 2NF
• 3NF is concerned with transitive functional dependency.
• Transitive functional dependency may exist, only if there are more than one non
key field.
• We may say that if a relation is in 2NF and has zero or one non key field it must
automatically be in 3NF
Definition: A relation is in 3NF if and only if it is in 2NF and there are no transitive
functional dependency.
• Transitive functional dependency arises when one non key attribute is
functionally dependent on another non key attribute .
• In other words, the value of one non key attribute is determined by the value of
another non key attribute.
• This means there is redundancy in the database.
• Let us consider a relation employee (proj.no, manager, address)
Proj.no Manager Address
P1 Black, B 32, High Street

P2
P3
P4
P5
Smith, J
Black, B
Black,B
Thomas,J
11, New street
32 High street
32 High street
69 Black street
• Here transitive dependency exists, as proj. no determines manager and manager
determines address.
• If a manager is associated with more than one project then his address is
repeated leading to data redundancy.
• If we need to change address of a manager we need to change at many places
leading to updation anomalies.
• So, we split the table in to two relations.
• The determinant attributes become the primary key in the new relation
• The attribute manager becomes the link between two tables/new relations.
Project
Proj.no Manager
P1
P2
P3
P4
P5
Black, B
Smith, J
Black, B
Black,B
Thomas,J
Manager
Manager Address
Black, B
Smith, J
Thomas,J
32, High Street
11, New street
69, Back street

• Here in project relation , proj.no serves as the primary key and manager can be
determined by project no.
• In manager relation, address can be determined by knowing the manager name,
so, manager becomes the primary key.
• So, in the above relation the non prime attributes depend upon the primary key.
• Hence we can define the third normal form as below
Alternative
Definion: A relation is said to be in 3NF when it is in 2NF and every non key attributes
is functionally dependent only on the primary key.
Guidelines for converting a table to 3NF:
• Find the non. key attributes and remove them that are functionally dependent on
attributes that are not the primary key.
• Place them in a different relation.
Third Normal Form (3NF) (Summary)
A relation R is said to be in third normal form (3NF) if the relation R is in 2NF and non-
prime attributes are:
• Mutually independent
• Functionally dependent on the primary key
• In other words, no attributes of the relation should be transitively dependent on
the primary key.
• Thus in 3NF, no non prime attribute is functionally dependent on another non-
prime attribute.
• This means that a relation in 3NF consists of the primary key and a set of
independent non prime attributes.
Summary of Normal Forms
1NF Relation should have no non atomic
attributes
Forms new relations for each non atomic
attribute or rested relations.
2NF For relations where primary key Decompose and set up a new relation for

contains multiple attribute s no non
key attribute should be functionally
dependent on a primary key.
each partial key with its dependent
attribute(s) make sure to keep a relation
with the original primary key and any
attributes that are fully functionally
dependent onit.
3NF A relation should have a nonkey
attribute functionally determined by
another nonkey attribute (or by a set
of non key attributes) .That is , there
should be no transitive dependency
of non key attribute on the primary
key.
Decompose and set up a relation that
includes the non key attribute(s) that
functionally determine (s) other non key
attributes.
Third normal form (3Nf) contd.
Definition: A Relation is in if and only if it is in 2NF and for any non trivial functional
dependency.
X→ Y
(i) Either X is the super key or
(ii) Y to be a prime attribute
Example: Let us consider a relation R (A,B,C,D)
With functional dependencies {A} → {B} , {A} → {C}
And {C} → {D} .Determine the candidate key and normalize upto 3NF.
Solution: Functional Dependencies are:
Here {A} → {B}
{A} → {C}
{C}→ {D}
The closure of C =C+
= {C, D}
The closure of A =A+ = {A, B, C, D}
So, A is the candidate key. Since the key determine the non key attributes it is in 2NF.

Since there exist transitive dependencies {A} → {C} and {C} → {D}.
So, we decompose, the relation into two relations
R1 (A, B, C) Since {A→B, A→C}
R (A,B,C,D)
R2 (C, D) Since { C →D }
Lossless join and Dependency preserving Decomposition.
A relation schema R can be decomposed in to collection of relation schemes to
eliminate some of the anomalies contained in the original relation scheme R.
However the decomposition should be maintened with
(i) No loss of information
(ii) Dependency preserved
(iii) Attribute preserved.
To main ten the above properties we check the following.
(i) Lossless join decomposition
(ii) Dependency preserving
(iii) Attribute preserving
Lossless join decomposition
A decomposition of a relation scheme R <S,F> in to the relation schemes, Ri (1≤ i≤ n) is
said to be lossless join decomposition or simply lossless if for every relation R (R) that
satisfies the FDS in F, the natural join of the projections of R gives the original relation
R. is
R = π R1 (R) X π R1 (R) X ………… X π Rn (R)
If RC = π R1 (R) X π R1 (R) X ………… X π Rn (R) then the decomposition is called lossy.
Dependency Preserving:

The given relation scheme R (S,F) where F is the set of functional dependencies on the
attribute in S, R is decomposed in to the relation schemes R1, R2, ….. Rn with the
functional dependencies F1, F2… Fn. Then this decomposition of R is dependency
preserving if the closure of F
Where, F1
= F1 U F2 …… Ufn) is the identical to F+
(i.e. F+
= F) ie. F1 (R1) U F2 (R2) UF3 (R3) …….Fn (Rn) = F+
Thm: A decomposition of relation scheme R<CX, Y,Z) F> into R1 <(C,Y), F1> and R2 <
(X,Z), F2> R2 < (X,Z,F2) is
(a) Dependency preserving if every functional dependency in R can be logically
derived form the functional dependencies of R1 and R2 i.e. (F1, UF2) +
= F+
and
(b) Is lossless if the common attributes X of R1 and R2 from a super key of at least
one of these i.e. X → Y or X → Z.
Example: Check for lossless decomposition:
Let the given relation R (A,B,C,D) with the functional dependencies FD = {A→B, A→C,
C→D} let the relation has been decomposed preserving the dependencies as R1
(A,B,C) and R2 (C,D) let us verify whether it is loss less or not
A B C D A B C D
a1
b2
a2
b2
a3
a3
a4
a4
a1
b2
a2
b2
a3
a3
a4
a4
Here, we considered the FD: C→ D, Since the symbols in column C are same and
hence we made the symbol in column C are same and hence we made the symbols in
column D same as one of the valve in D column is a . For other dependencies A→ B,
A →C we do not find two rows with identical entries for columns of the determinant.
Here we get one row with all a values lossless.
Problem: Given R (A,B,C,D,E) with FDS, F {AB → CD, A→E, C→D}, the
decomposition of R in to R1 (A,B,C) R2 (B,C,D) and R3 (C,D,E) is lossy.
A B C D E
a1 a2
a2
a3
a3 a4

a3 a4 a5
When we consider the FD: C→D, we find all rows of the column C, the determinant of
the FD, are identical this allows us to change the entries in the column D to a4.
No further changes are possible.
Finally, we find no rows in the table with all as and conclude that the decomposition is
lossy.
Problem: The relation R (A,B,C) with FD = {B→C} exists.
Does the relation have potential candidate key
If it does what is it ? if it does not why not.
Solution: R (A,B,C) So, super key = {A,B,C}
F = {B→C}
A+
= {A}
B+
= {B,C}
AB+
= {A,B,C}
The potential candidate key = {A,B}
Problem: Let us consider a relation R (A,B,C,D,E).
With following dependencies {A,B} → {C}
{C,D} → {E}, {D,E} → {B}
Find the candidate key of the given relation.
Solution: FDs
are: {A,B} → {C}
{C,D} → {E}
{D,E} → {B}
{A,B}+
= {A,B,C}
{A,B,D}+
= {A,B,C,D,E}
So, {A,B,D} is the candidate key
Problem: Let the relation R (A,B,C,D,E,F,G,H,I,J) has functional dependencies:
F = {A,B} → {C}
{B,D} → {E,F}
{A,D} → {G,H}

{A} → {I}
{H} → {J}
Solution: {AB}+
= {A,B,C,I}
{BD}+
= {B,D,E,F}
{AD}+
= {A,D,G,H,I,J}
{A}+
= {A,I}
{H}+
= {H,J}
{A,B,D}+
= {A,B,C,D,E,F,G,H,I,J}
Training / Seminar
Roll No. Date Topic Guide Branch Grade Name Dept. Cod.
101 3.4.08 DM CKM
Roll No. Name Branch Sub Teacher Grade Rem.
(i) Here, single dependency, exists so it is in INF.
(ii) Partial dependency exists, so it is not in 2NF Decomposition for 2NF.
R (A,B,C,D,E,F,G,H,I,J)
R1 (A,B,C) R2 (B,D,E,F) R3 (A,D,G,H) R4 (A,I) R5 (A,B,D)
R3 (A,D,G,H) R3 (H,J)
BCNF:
A relation schema R is in BCNF with respect to a set for functional dependencies, if for
all FDS in .
F+ X→ Y atleast one of the following is true.
(i) X→ Y is trivial or
(ii) X is a super key
EX: R (A,B,C) is the given relation schema and the given Functional Dependency is

F ={A →B, B →C}
Solution: Key = {A} since A+ = {A,B,C}
R is not in BCNF as B is not a super key.
Decomposition:
R (ABC)
R1 (A,B) R2 (B,C)
Now R1 and R2 in BCNF
The decomposition is lossless and dependency preserving.
Boyce Code Normal Form (BCNF)
• To eliminate the problems and redundancy of 3NF. Boyce proposed a normal
form known as Boyee code Normal form (BCNF).
• When the relation has more than one candidate key anamolies may arise even
though the relation is in 3NF.
• 3NF does not deal with the case of a relation with overlapping candidate keys.
• BCNF is based on the concept of a determinant
• A determinant is any attribute(s) on which some other attributes is fully
functionally dependent.
Def: A relation is in BCNF if and only if every determinant so candidate key.
Let us consider a relation R (A,B,C,D) with the set of functional dependencies.
{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 {A,C} would be the key then it could also determine all of the non key attributes
present in R.
• However the second determinant indicates that {A,D} determines B. But {A,D}
can’t be the key of R since it does not determine all the non key attributes of R
(Eg.C).
• Here, first determinant is a candidate key → {A,C}.
• But, the second determinant {A,D} is not a candidate key.

• Thus the relation R (A,B,C,D) is not in BCNF, since there exist over lapping keys
candidate keys.
So the decomposition of the relation for BCNF is
R (A,B,C,D) R (A,B,C,D)
R1 (A,C,D) R2 (A,D,B) R1 (A,B,C) R2 (A,D,B)
AC→D AD→B AB→C AD→B
Comparison of 3NF and BCNF:
• BCNF is stronger than 3NF
• The relations there in 3NF are not necessarily in BCNF
• BCNF is needed in certain situations to obtain full under standing of the data
model.
• There are several routes to take to arrive at the same set of relations in BCNF.
Difference: The difference between 3NF and BCNF is that for a functional dependency
A→B, 3NF allows this dependency in a relation if B is a primary key attribute and A is
not a candidate key.
Whereas, BCNF insists that for this dependency to remain in this relation, A must be
candidate key.
Therefore, BCNF is a stronger form of 3NF, such that every relation in BCNF is also in
3NF.
Q. Prove that any binary relation is in BCNF:
A relation R is in BCNF if for every non trivial functional dependency X→Y, X to be the
super key.
Let us consider a binary relation R (A,B).
The possible functional dependencies are
{A,B} → Q
{A,B} → {A}
{A,B} → {B}

{A,B} → {A,B}
{A} → {B}
The non trivial functional dependencies are
(i) {A} → {B}, (ii) {B} →{A}, (iii) {A} → {B}, {B}→{A}
So in any case for X →Y, X is the super key.
Hence, the relation R (A,B) is in BCNF.
BCNF Contd.
Def: A relation R is Said to be in BCNF if for every non trivial FD : X→Y between
attributes X and Y holds in R.
i.e. X is a super key of R.
• X→Y is a trivial functional dependency i.e. YCX.
• In other words, a relation must have candidate keys as determinants.
• To find whether a relation is in BCNF or not, FDS within each relation is
examined. If all non key attributes depend only on the complete key than the
relation is in BCNF.
• Let us consider a relation project (Project code, manager machine,
Quantityused).
Project
Project Code Manager Machine Quantity used
P1
P3
P2
P4
P3
P1
Thomas
John
Abhisek
Avinash
John
Thomas
Excavator
Shovel
Drilling
Dumper
Welding
Drilling
5
2
5
10
3
4
The Functional Dependency diagram is given by:
Quantity used Manager
Machine

Problems
Here, there are two overlapping candidate keys {Manager, Machine} and {Project code,
Machine}
In the functional dependencies
{Manager} → {Project Code}
{Project code} → {Manager}
Neither, manager, nor project code is a super key.
Decomposition for BCNF:
(1) PROJECT (Project code, Machine, Quantity used.
(2) MANAGER (Project code, Manager)
Boyce Code- Normal form (BCNF) contd.
Def: A relation is said to be in BCNF if and only if every determinant is a candidate key.
Def: A relation is said to be in BCNF if and only if it is in 3NF or 2NF and for every non
trivial functional dependency X→Y.
(i) X is a super key
(ii) Y to be the prime attribute X to be super key.
Example: Let us consider a relation R (A,B,C) with the set of functional dependencies.
F = {A,B} → {C} or {A} →{B}, {B} →{C}
{C} → {B}.
Solution:
{A,B} +
= {A,B,C}

Here, {A,B} is the candidate key, since there is no such single key for deriving all the
non key attributes. So we take the minimal super key {A,B} as the candidate key.
The relation is not is BCNF since {C} is not the .
Decomposition for BCNF:
The relation R (A,B,C) can be decomposed in toe R1 (A,C) and R2 (B,C)
R (A,B,C)
R1 (A,C) R2 (B,C)
Design goals of relational database design.
There are three important design goals
(i) BCNF
(ii) Loss less join
(iii) Dependency preservation
If we can’t achieve all these three, we accept
(i) 3NF
(ii) Loss less join
(iii) Dependency preservation
Multivalued Dependencies:
A multivalued dependency corresponds to a many many relationship or a many one or
one many relationship.
Def: The (Functional) Dependency represented by X →→ Y is said to be multivalued
dependency form X to Y if and only if each X value exactly determined a set of Y
values, independently of other attributes.
Def: The dependency X →→Y, Z is said to be a multivalue dependency if.
(i) For a single value of X there exist a set of values of Y
(ii) For a single value of X there exist a set of values of Z

Where Y and Z are independent of each other.
Explanation:
Let R be a relation and X and Y are any arbitrary set of attributes of R, if for any two
tuples, t1 and t2 with t1 [X] = t2 [X], there exists two tuples t3 and t4 such that
(Z=R=(XUY).
t1 [X] = t3 [X] =t4 [X]
t1 [Y] = t3 [Y] & t2 [Y] = t4 [Y]
t1 [Z] = t3 [Z] & t3 [Z] = t4 [Z]
then X →→ Y
Example:
R (A,B,C)
(i) A →→B
(ii) A →→C
Trivial Multivalues Dependencies : Trivial MVDS Let R is a relation with set of
attributes X and Y then X→→Y is said to be trivial iff.
(a) Y⊆ X or
(b) X U Y =R
(c) A trivial MVD does not represent a constraint.
(d) MVDs are generalization of FDS
(e) The existence of non-trivial MVDs that are not FDS causes problems.
A B C
10 a w
10 b t
10 a t
10 b w
20 p u
20 p v
20 q u

Non Trivial MVD : An MVD that satisfies neighther (a) nor (b) conditions above is called
non trivial MVD.
Types: Like trivial FDS, there are two kinds of trivial MVDS.
(a) X →→Q, where Q is an empty set of attributes.
(b) X →→A-X, where A comprises all the attributes in a relation.
Both these types of trivial MVDs hold for any set of attributes of R and therefore can
serve no purpose as design criteria.
Properties of MVDS: Berry described the relevant rules to derive MVD
Rule 1: Reflexive (inclusive ): If YC X then X →→Y
Rule 2: Augmentation rule : If X→→Y and WCV and VCW then WX →→VY.
Rule 3 Transitive rule: If X→→Y and Y→→Z then X→→Z.
Rule 4 Complementation : if X →→Y then X →→U-X-Y holds.
Additional rules to derive closure of set of FDs and MVDs.
Rule 5 Intersection: If X→→Y and X →→Z, then X →→YnZ
Rule 6 Prado transitivity: If X →→Y and WY →→Z the XW→→Z-W
Rule 7 Union: If X →→Y and X →→Z then X→→YZ
Rule 8 Difference: If X →→Y and X→→Z then X→→Y-Z and X→→Z-Y.
Rule 9 Replicaiton : if X→Y , then X→→Y.
Rule 10 coalescence: If X→→Y and ZCY and there is a W such that WCU and WnY =
NULL and W→Z, then X→Z,
Note: U is the set of all attributes of R.
Fourth Normal Form:
Def: A relation R is said to be in fourth normal form (4NF) it is in BCNF and for every
non trivial MVD X→→Yin F+
, X is a super key of R.
• The 4NF is concerned with dependencies between the elements of compound
keys composed of three or more attributes.
• The 4NF eliminates the problems of 3NF.
• The 4NF is violated if the relation has undesirable MVDS and hence can be used
to identify and decompose such relations.

•
Example:
R (A,B,C) with MVDS
(i) A →→B
(ii) A →→C
R (A,B,C)
R1 (A,C) R2 (B,C)
A B A C
10
10
20
20
a
b
P
q
10
10
20
20
w
t
u
v
Here, R = R1 X R2
So, it is a lossless decomposition
Problems: Consider a relation R (A,B,C,D,E,F) with FDS and with MVDS A →→B and
CD →→EF.
Solution: R (A,B,C,D,E,F), the given relation
Here , the MVDS are A→→B
By complement rule A →→CDEF
To decompose the relation R in to two relation for 4NF, such that
R1 (A,B) and R2 (A,C,D,E,F)
A B C
10 a w
10 b t
10 a t
10 b w
20 p u
20 p v
20 q u

As A →→B and A→→C,D,E,F
• Now R1 (A,B) is in 4NF because A →→B is trivial and is the only MVD in the
relation.
• The relation R2 (A,C,D,E,F) is still in BCNF because there exist non trivial MVD
CD→→EF.
• Now R2 (A,C,D,E,F) is decomposed in to relations R2 (C,D,E,F) and R2 (C,F,A)
by applying MVDS, CD→→EF. and CD→→A [By complement rule]
Now both R2 (C,D,E,F) and R2 (C,F,A) are in 4NF.
R (A,B,C,D,E,F),
Join Dependency:
So for every relation was non loss decomposable in to two projections.
In case of n-decomposable relations we think about join dependency.
A join dependency is a further generalization of MVDS
Def: A join dependency (JD) X {R1 ,R2 ….Rn} is said to be hold over a relation R if R1,
…… Rn is a lossless join decomposition of R.
R1 (A,B)
Since A→→B
R2 (A,C,D,E,F)
Since A→→C,D,E,F
R2 (A,C,D,E,F)
Since CD→→E,F
R2 (C,D,A)
Since CD→→A
[By complement]

An MVD X →→Y over a relation R can be expressed as the join dependency {XY, X (R-
Y) }.
Let us consider the relation, CTB (Course, teacher, book)
Course Teacher Book
Phy101
Phy101
Phy101
Phy101
Math 301
Math 301
Math 301
S.K. Biswal
S.K. Biswal
R.K. Pati
R.K. Pati
R.Das
R.Das
R.Das
Mechanics
Optics
Mechanics
Optics
Algebra
Vectors
Geometry
Here in the CTB relation the MVD, C→→T can be expressed as the join dependency
{CT,CB}
Join Dependency and multivalued dependency : (JDS Vs MVDS)
• Join Dependency R (A,B,C) satisfies multivalued dependency (AB, AC) if and
only if it satisfies the MVDs A →→BIC.
• JD is the most general form of dependency (read ad determination) possible
between the attributes of a relation (in the relational model)
Fifth Normal Form: (5 NF)
Def: A relation schema R is said to be in fifth normal form (5NF) if, for every JD X [R1.
R2…Rn} that holds over R, one of the following statements is true.
• R1 = R for some I or
• The JD is implied by the set of those FDS over R in which the left side is a key
for R.
• The decomposition of R in to [R1. R2……….Rn} is lossless join whenever the key
dependencies (Functional dependency in which the left side is a key for R) hold.
• JD X [R1. ……..…Rn} is a trivial FD if R1 = R for some I such a JD always holds.

• If a relation shcema is in 3NF and each of its keys consists of single attribute it is
also in 5NF.
(i) This is sufficient for a relation to be in 5NF but not necessary.
(ii) We conclude that a relation is in 5NF without ever identifying the MVDS
and JDS that may hold over the relation.
NORMALIZAITON
SAMPLE QUESTIONS
1. Define the term functional dependency
2. Why some functional dependencies are called trivial ?
3. Describe the concept of full functional dependency
4. Draw a functional dependency diagram with an example.
5. What is the closer of a functional dependency ?
6. What do you understand by the form normalization ?
7. What is the purpose of normalizing the data ?
8. Define 1NF, 2NF, 3 NF and BCNF
9. Describe the properties of a normalized relation
10. How BCNF is different from 3NF
11. Why 4NF is preferred to BCNF
12. Define MVD and 4NF
13. Define JD and 5NF.
14. When an MVD is said to be trivial ?
15. Write four important armstrongs inference rule of MVD
16. Mention three important armstrongs inferences rules of FDS.
17. Discuss the problems of 2NF. How it is over comed ?
18. Discuss the problems of 3NF. How it is over comed.
19. Discuss the problems of 4NF ? How is over comed ?
20. Explain the lossless join decomposition with example.
21. How do you check for the lossless join decomposition ?
22. How do you test for dependency preserving in a decomposition ?
23. How do you check for existence of redundancy in the relation.
24. Prove that BCNF ⇒ 3NF but the converse is not true.

25. Prove that every binary relation is is in BCNF.
26. Describe Armstrong’s Axioms. What are the derived rules ?
27. Describe how database designees typically identify the set of FDS associated
with a relation.
28. Describe the concept of full functional dependency.
29. What is dependency preservation property of for decomposition why it is
important ?
30. What is lossless or non additive join property of decomposition why it is
important?
Assignment
Problems
1. Give a set of FDS for the relation schema R (A,B,C,D) with primary key AB under
which R is in INF but not in 2NF.
2. Consider a relation R with five attributes R (A,B,C,D,E) with the set of functional
dependencies.
F , A→B, BC→E and ED→A
(i) Find the candidate key
(ii) Is R in 3NF
(iii) Is R in BCNF.
3. Compute the closure of the following set F of functional dependencies for relation
schema R = (A,B,C,D,E)
A→BC
CD→E
B→D
E→A
(a) List the candidate key
(b) Compute the closure B+
4. Give a set of FDs for the relation schema R (A,B,C,D) with primary key AB under
which R is in 2NF but not in 3NF.

5. Consider the relation schema R (ABC) which has the FDS B→C. if A is the
candidate key of R, is it possible for R to be in BCNF ? If so under what
conditions ? If not why not ? Explain.
6. Consider the relation r (ABCDE) with the dependencies A→B, BE→E and
ED→A.
(i) List all the keys
(ii) Is R in 3NF
(iii) Is R in BCNF
(iv) If R is not is BCNF, decompose to obtain BCNF
7. A relation r (A,B,C,D) has FD AB→C and C →A, is R is in 3NF or in BCNF ?
justify your answer
8. A relation R (A,B,C,D) has FD C→B is R is in 3NF ? justify your answer.
9. A relation R (A,B,C) has FDS A→C is R is 3NF ? Does AB→C ?
10. What undesirable dependencies are avoided in 3NF?
Problems: Consider the relation scheme R (A,B,C,D) and the functional dependency
A→B and C→D then the decomposition of R in to R1 (A,B) and R2 (C,D) and R3 (A,C)
(a) Dependency preserving and lossless join
(b) Lossless join but not dependency preserving
(c) Dependency preserving and not loss less join
(d) Not dependency preserving and not lossless join
Solution
R (A,B,C,D)
R1 (A,B) R2 (C,D) R3 (A,C)
A→B C→D
(i) From the above decomposition is in clear that it is dependency
(ii) Lossless check
A B C D

R1
R2
R3
a1
a1
a2
a3
a3
a4
a4
Since there is no single row with all a values . Hence it is a lossy decomposition.
Solution
D3 ={R1,R2,R3,R4,R5}
R1={A,B,C,D}
R2={D,E}
R3={B,F}
R4={F,G,H}
R5={D,I,J}
(i) Dependency Preserving
In R1={A,B,C,D}, {A,B} → {C}, {A} → {D,E} ⇒ {A} → {D}
In R2={D,E}, {D} the candidate key
In R3={B,F}, {B} → {F}
In R4={F,G,H}, {F} → {G,H}
In R5={D,I,J}, {D} → {I,J}
So, the decompositions is dependency preserving
(ii) Check for Lossess
A B C D E F G H I J
R1
R2
R3
R4
R5
a1 a2
a2
a3 a4
a4
a4
a5
a6
a6
a6
a7
a7
a8
a8
a9
a9
a10
a10
Since there is not row with all a values we conclude that the decomposition is lossy.
(iii) Determining the normal form
R1={A,B,C,D}, {A,B} →{C}, {A} →{D} ⇒ partial dependency ⇒ not in 2NF ⇒ in 1 NF.
R2={D,E}, Binary relation ⇒ BCNF

R3={B,F}, Binary relation ⇒ BCNF
R4={F,G,H}, {F} ⇒ {G,H}, {F} → super key ⇒ BCNF
R5={D,I,J}, {D} ⇒ {I,J}, {D} → super key ⇒ BCNF
Problems: Consider the universal relation R (A,B,C,D,E,F,G,H,I,J) and the set of
functional dependencies.
F= {A,B} → {C}, {A} → {D,E}, {B} →{F}, {F} → {G,H}, {D} → {I,J}
Determine whether each decomposition has satisfied.
(i) The dependency preserving property
(ii) Lossless join property with respect to the set of FDS, F.
(iii) Determine in which normal form the decomposed relations exist.
(a) D1 = {R1,R2,R3,R4,R5}
R1={A,B,C,D}, R2={D,E}, R3={B,F}, R4={F,G,H}, R5={D,I,J}
(b) D2 = {R1,R2,R3,}
R1={A,B,C,D}, R2={D,E}, R3={B,F},
(c) D3 = {R1,R2,R3,R4,R5}
R1={A,B,C,D}, R2={D,E}, R3={B,F}, R4={F,G,H}, R5={D,I,J}
Solution
{A,B}+
= {A,B,C}
{A}+
= {A,D,E}
{B}+
= {B,F}
{F} +
= {F,G,H}
{D}+
= {D,I,J}
F+
= {A,B,C,D} +
= {A,B,C,D,E,F,G,H,I,J}
FDS = F1 )R1) U F2 (R2) U F3(R3) U F4(R4) U F5(R5)
= {A,B,C} U {A,D,E} U {B,F} U {F,G,H} U {D,I,J}
= {A,B,C,D,E,F,G,H,I,J} = F+
So, the decomposition D1 is dependency preserving .
(i) Check for Lossess
A B C D E F G H I J

R1
R2
R3
R4
R5
a1 a2
a2
a3 a4
a4
a4
a5
a6
a6
a6
a7
a7
a8
a8
a9
a9
a10
a10
This is a lossless decomposition since one row having all a values.
(ii) Normal form determination
D1 = {R1,R2,R3,R4,R5}
R1={A,B,C,D}, Since {A,B} → (C} → BCNF
R2={A, D,E}, Since {A} → (D,E} → BCNF
R3={B,F}, Since {B} → (F} → BCNF
R4={F,G,H}, Since {F} → (G,H} → BCNF
R5={D,I,J} Since {D} → (I,J} → BCNF
So, all the decomposed relations are in BCNF.
= F1 )R1) U F2 (R2) U F3(R3) =F+
and
R1={A,B,C,D,E} Since {A,B} → {C} and {A} → {D,E}
R2={B,F,G,H}, since {B} → {F} and {F} → {G,H}
R3={D,I,J} Since {D} → {I,J}
(i) Check for Lossess
A B C D E F G H I J
R1
R2
R3
R4
R5
a1 a2
a2
a3 a4
a4
a4
a5
a6
a6
a6
a7
a7
a8
a8
a9
a9
a10
a10

Since all the values in a row are a values then we conclude that the decomposition is
lossess.
R1={A,B,C,D,E} , {A,B} → {C} , {A} → {D,E}
Here the partial dependency exist so it is in INF.
R2={B,F,G,H}, {B} → {F} , {F} → {G,H}
Here, transitive dependency exist, so it is not in 3NF and there in full functional
dependence hence it is in 2NF.
R3={D,I,J} , {D} → {I,J}
Here, D is a super key, Hence R3 is in BCNF
Q2. Given a set of FDS for the relation schema R (A,B,C,D) with primary key of AB
under which R is in INF but not in 2NF.
Ans.: Lets us consider the set of dependencies FD
AB→CD and B→C
So, AB+
= {A,B,C,D}
B+
={B,C}
{AB} is a key for the relation R (A,B,C,D) since AB → ABCD.
{AB} in the candidate key as there is no other minimal key that can determine all the
attributes of R.
• Now the FD, B→C becomes a partial dependency and hence violates the
property of 2NF.
• Again C ∉ B, that is B→C is not trivial FD
• B is not the superkey
• C is not part of some key of R.
• B is the proper subset of the key AB
Q.3. compute the closure of the FD for the relation R (A,B,C,D,E)
A→BC, CD→E, B→D, E→A.
Sol: A→BC, CD→E, B→D, E→A
Cond.key: A+
= {A,B,C,D,E}
E+
= {A,E} = {A,B,C,D,E}
CD+
= (A,B,C,D,E}

Closuring B=B+
= {BD} ← B is not a super key , so R is not in BCNF
(ii) Decompose the relation to obtain BCNF
R (A,B,C,D,E)
R1 (B,D) R2 (A,C,D,E) R3 (A,B)
B→D A→C A→B
CD→ E
E→ A
Q4. Given a set of FDS for relation schema R (A,B,C,D) with primary key AB under
which R is in 2NF but not in 3NF.
Ans. Let us consider the set of FDS: AB→ CD and C →D
AB+
= ABCD and C+
=CD
Obviously, AB is the candidate key of this relation.
• Now there is no partial dependency
i.e. C ∉ AB ⇒ R is in 2NF
• But C→D, violates the property of 3NF.
Since
(i) CEC is false = so it is not trivial FD
(iii) C is not a super key
(iv) D is not part of some key of R
Q5. Consider the relation schema R (A,B,C) which has the FDS
B→C, if A is the candidate key of R if it possible for R to be in BCNF ? if so under what
condition. If not, why not ?
Ans. Yes , it is possible for R (A,B,C) to be in BCNF
Cond. : If there exist FDS, A→C and A→B and B →C there should no be or C→B any
transitive dependency
Verification: For A→C and A→C
A is the super key. Hence it is in BCNF

Q.6: Super we have a relation R (A,B) representations the relationship between two
entity sets with key A and B and suppose that R has the FDS : A →B and B→A Explain
what such a pair of dependencies means.
Ans.: Here FDS
A→B and
B→A
• It means that the relation is one to one
• That is each value of entity A corresponds to one values of the entity B and vice
versa.
Serializability
• A schedule S of n transaction is serialization if it is equivalent o some serial
schedule fo the same on n transaction.
• All transactions are correct in the sense that if any one of the transaction is
executed by itself on a consistent database, the resulting database will be
consistent.
• Any serial execution of the transactions is also correct and preserves the
consistency of the database, the results obtained are correct.
Ex. Schedule-I
T1 T2 T1 T2
Read (x)
Writer (x)
Write (x)
Read (x)
Write (x)
Read (x)
X=x-50
Write(x)
Read (y)
Y=Y+50
Write(y)
Read (x)
Temp =AX0.1
A=A-temp
Write (x)
Read (Y)
Y=Y+temp
Write (Y)
(a) Preserves consistency (b) Does not preserve consistency

Basic assumption: Each transaction preserves database consistency.
• Thus serial execution of a set of transactions preserves database consistency.
• A (Possible concurrent) schedule is serializable if it is equivalent to a serial
schedule.
• Different forms of schedule equivalence gives rise to the notions of
(1) Conflict serializablity (2) View Serializability.
Simplified view of transactions:
• We ignore the operations other than read and rite instructions .
• We assume that transactions may perform arbitrary computation on data in local
buffers in between reads and writes.
• Our simplified schedules consist of any read and write instructions.
1. Conflict serializablity
• If a schedule S can be transformed in to a schedules by a series of swaps of non
conflicting instructions, we say that S and S are conflict equivalent.
• We say that a schedule S is conflict serializable if it is conflict equivalent to a
serial schedule.
• Schedule-1 can be transformed into schedule 2 , a serial schedule where T2
follows T1 by series of swaps of non-conflicting instructions.
• Therefore schdule1 is conflict serializable.
• Ex. Schedule-I
T1 T2 T1 T2
Read (x)
Writer (x)
Read (Y)
Write (Y)
Read (x)
Write (x)
Read (Y)
Write (Y)
Read (x)
Writer (x)
Read (Y)
Write (Y)
Read (x)
Writer (x)
Read (Y)
Write (Y)
Schedule-1 Schedule-2
The example of a schedule that is not conflict serializable
T3 T4

Read (Q)
Writer (Q) Write (Q)
Schedule-2
A serial schedule where T2 is followed by t1
T1 T2
Read (x)
X=X-50
Write (X)
Read (Y)
Y=Y+50
Write (Y)
Read (x)
Temp=X+0.1
X=X-temp
Write (X)
Y=Y+temp
Write(Y)
Schedule-3: Let T1 and T2 be the transactions defined previously. The following
schedule is not a serial schedule but is equivalent to schedule-1.
T1 T2
Read (x)
X=x-50
Write(X)
Read (y)
Y=Y+50
Write(y)
Read (x)
Temp =a*0.1
Y=X-temp
Write (x)
Read (Y)

Y=Y+temp
Write (Y)
In all schedules, 1,2, and 3 the sum X+Y is preserved.
Schedules:
• A schedules is a sequence of instructions that specify the chronological order in
which instructions of concurrent transactions are executed.
• A schedule for a set of transactions must consist of all instructions of those
transactions.
• A Schedule must preserve the order in which the instructions appear in each
individual transaction.
• A transaction that successfully completes its execution will have a commit
instruction at the last instruction.
• A transaction that fails to successfully complete its execution will have an abort
instruction as the last statement.
Schedule-1
Let T1 transfers 50 from X to Y and T2 transfers 10X of the balance from X to Y.
A serial schedule in which T1 is followed by T2
T1 T2
Read (x)
X=x-50
Write(X)
Read (y)
Y=Y+50
Write(y)
Read (x)
Temp =a*0.1
Y=X-temp
Write (x)
Read (Y)
Y=Y+temp

Write (Y)
Rules for locking Technique by DBMS:
• A transaction T must issue the operation lock (x) before any read (X) or write (X)
operations are performed in t.
• A transaction T must issue the operation unlock (X) after all read (X) and write
(X) operations are completed in T.
• A transaction T will not issue a lock (X) operation if it is already holds lock on
item X.
• A transaction T will not issue on unlock (X) operation unless it already holds the
lock on item X.
Shared or Exclusive lock:
• The shared lock is also called a read mode of lock.
• The intention of this mode of locking is to ensure that the date item does not
undergo any modifications while it is locked in this mode.
• Any number of transactions can concurrently lock and access a data item locked
in a shared mode.
Exclusive mode: The exclusive lock is also called an update or write lock.
The intention of this mode of locking is to provide exclusive use of the data item to one
transaction.
If a transaction T locks a data item Q in an exclusive mode no other transaction can
access Q. not even read (Q)
Status Unlock Shared Exclusive
Unlock
Shared
Exclusive
Yes
Yes
Yes
Yes
No
Yes
No
No
Concurrency control techniques:
• The goal of concurrency control is to develop protocols that will assure
serializability and hence ensuring database consistency.

• A policy in which only one transaction can execute at a time generates serial
schedules but provides a poor degree of concurrency.
Techniques of concurrency control.
• Locking : Some of the main techniques used in controlling concurrent execution
of transactions are based on the concept of locking.
• A lock is a variable associated with a data item that describes the status of the
item with respect to possible operations that can be applied to it.
• Generally there is one lock for each data item in the database.
• Lock is used as a means of synchronizing the access by concurrent transactions
to the data base items.
• We use locking to guarantee serializability of transaction schedules.
Types of locks:
There are several types of locks used in concurrency control.
(1) Binary locks (2) Shared /Exclusive (Read/Write)
(1) Binary locks:
A binary lock can have two states or values
Locked -1
Unlocked -0
• If the value of the lock ‘X’ is I, item X can not be accessed by a database
operation that request the item.
• If the value of the lock on ‘X’ is O, item X can be accessed when requested.
Ex. B : Lock (x)=0 (Unlocked)
Lock (X)=1 (Locked item)
___________
Go to B
End.
Two phase locking (2PL)

• Two phase locking is a method or a protocol of controlling concurrent execution
of transactions (Processing) in which all locking operations precede the first
unlocking operations.
• A transaction is said to follow the two phase locking protocol if all locking
operations (such as read lock or write lock) precede the first lock unlock
operation in the transaction.
• Two phase locking is the standard protocol used to maintain level 3 consistency.
• 2PL defines how transaction acquire and reeling wish locks.
• The two phase locking (2PL) has the two phases as (1) growing phase and (2)
Shrinking phase
1. In the growing phase, the transaction acquires all the required data locks (on
desired data) without unlocking any data.
Once all locks have been acquired, the transaction is in its locked point.
In this phase the lock is assigned to the transaction.
2. In the shrinking phase (in which) a transaction released all locks and can not
obtain any newlock.
Rules: The two phase locking is governed by the following rules.
• Two transactions can’t have conflicting locks.
• No unlock operation can precede a lock operation in the same transaction.
• No data are affected until all locks are obtained, that is until the transaction is in
its locked point.

Somatic of two phase locking (2 PL)
Phase-1: Lock acquisition Phase-2 : Lock release.
Start Time End.
Growing phase Locked phase Shrinking phase
• In growing phase the number of locks increases from zero to the maximum for
the transaction.
• In shrinking phase the no. of locks are decreased from maximum to zero.
• Both these phases are monotonic. The no of locks are only increasing in the first
phase and decreasing in the second phase.
• Once the transaction has started releasing locks, it is not allowed to request any
further locks.
Strictly two phase locking:
As given by the semantics of two phase locking in fg.1 . in case of a strict two phase
locking the inter leaving is not allowed
Fig.2 shows a strict two phase locking in which transaction T1 would obtain on
exclusive lock on A first and then Read and write A.
T1 T2
X (A)
Read (A)
Write A Time

Fig.3 shows the example of strict 2PL with serial execution in which first strict locking is
done, then transaction T2 would request on exclusive lock on A.
2PL guarantees serializability. But it (2PL) does not prevent dead locks therefore is
used in conjunction with a dead lock prevention technique.
T1 T2
X (A)
Read (A)
Write A
X (B)
Read (B)
Write B
Commit
X (A)
Read (A)
Write A
X (B)
Read (B)
Write B
Commit
Transaction processing & concurrency control.
Transactions: A transaction is a logical unit of database processing that includes one
or more database access operations.
• A transaction can be defined as an action or series of actions that are carried out
by a single user or operations performed by application programs for accessing
the contents of the database.
• A transaction is a program unit whose execution may change of the database.
• A transaction is a program unit whose execution may change the contents of
database.
• Transactions execution preserves the consistency of database.
• A transaction is said to be atomic if each transaction could access the share data
without interfering with the other transactions and whenever a transaction
successfully completes its execution, its effect should be permanent.

Transaction operations: The operations such as retrieval , insertion, deletion and
modification can be carried out by using transactions.
These operations are performed in the form of read/write.
1. Read (X) : R(X)
2. Write (X) : W (X)
1. Read (X) : Reads a data base item X in to a program variable Y.
2. Write (X): Writes the values of X the program variable Y in to the database item
named X.
Example: T1
1. Read (X)
2. X=X-50
3. Write (X)
4. Read (Y)
5. Y=Y-50
6. Write (Y)
Issues of transaction management:
• Failure
• Concurrent execution.
1. Failure: There are various kinds of failures.
• System crash / Hardware failure.
• Transaction or system error
• Local error or execution condition detected by transaction
• Dist failure
• Physical problems and catastrophes.
• Concurrency control enforcement.
2. Concurrent execution:
• Inconsistencies caused by conflicting updates from concurrent users.
Example: T1 T2
1. Read (X)
2. X=X-50
3. Write (X)

Read (X) , Read(Y), Print (X+Y)
4. Read (Y)
5. Y=Y-50
6. Write (Y)
• When the transaction T1 is executed and in between steps 3 and 6 of T1, if
another transaction T2 is allowed to access the partially updated database,
then it will cause inconsistency in the database, as the sum of X and Y will be
less than it should be.
ACID properties of Transactions:
• A transaction is a unit of program execution that access or updates various
data items.
• To preserve the integrity of data the database system must ensure the
following properties, called ACID properties.
• These ACID properties called ACIDITY of a transaction, to ensure that a
database remains in stable state after the transaction is executed.
Atomicity: A transaction is an atomic unit of processing .
The atomicity property of a transaction requires that all operations of a transaction are
performed completely or not performed (the transaction is aborted)
Consistency: The consistency property of a transaction implies that if the database
was in a consistent state before the start of the transaction, then on termination of a
transaction, the database will also be in a consistent state.
Isolation: The isolation property of a transaction indicates that actions performed by a
transaction will be isolated or hidden from the outside the transaction until the
transaction terminates.
Durability: The durability property of a transaction ensures that the commit action of a
transaction on its termination will be reflected in the database.
These changes must not be lost because of any failure.
States of transaction:
• A transaction which successfully completes its execution is said to be committed.
• Otherwise the transaction is said to be aborted.
A transaction can be in one of the following states:

Active: The initial state, after the transaction starts its operation.
Partially Committed: After the final statement has been executed.
Failed: After detecting that the normal execution can no longer, proceed.
Aborted: When the normal execution can no longer be performed . A transaction may
be aborted when the transaction itself defeats an error during execution which it can
recover from.
After the transaction has been rolled back and the database restored to its state prior to
the start of the transaction.
There are two options after it has been aborted.
Restart the transaction (Only if no internal- logical error)
Kill the transaction.
Committed: After successful completion of the transaction . The transaction also said
to be in a committed state if it has partially committed and it can be ensured that it will
never be aborted.
Read/Write
nTransactio
Begin
(States of transaction)
ACTIVE PARTIALY
COMMITTED
COMMITTEDEnd
transaction
Commit
COMMITTEDCOMMITTED
Abort
Abort

Transaction execution with SQL:
• The ANSI has defined standards that govern SQL database transactions.
• Transaction support is provided by two SQL statements. (a) Commit (b) Rollback
• The ANSI standards require that when a transaction sequence is initiated by a
user or an application program, it must continue through all succeeding SQL
statement. Until one of the following events occur.
(a) Commit : A commit statement is reached, in which case all the (transaction)
changes are permanently recorded in the database.
• The commit statement automatically ends the SQL transaction.
• The commit operations indicate successful end of transaction.
(b) The Rollback: Statement is reached, in which all the change are aborted and the
database is rolled back to its previous consistent state.
• The rollback operation indicates successful end of transaction.
(c) The end of program is successfully reached, in which case all changes are
permanently recorded within the database. The action is equivalent to Commit.
(d) The program is abnormally terminated; in which case all the changes made in the
database are aborted and the database is rolled back to its previous consistent
state. This action is equivalent to rollback.
Ex.: Let us consider the example of commit, which updates an example loan balance
(Emp-loan-bal) and the projects cost (Proj-Cost) in the tables employee and project
respectively.
UPDATA EMPLOYEE
SET EMP-LOAN-BAL = EMP-LOAN-BAL-10000
WHERE EMP-ID= 106519
UPDATA PROJECT
SET PROJ-COST = PROJ-COST +40000
WHERE PROJ-ID= PROJ-1.
COMMIT;

Time stamp ordering: (Time stamp protocol)
• Time stamp is a unique identifier created by the DBMS to identify a transaction.
• In this scheme, the transaction manager assigns unique time stamp TS(T) to each
transaction.
• The idea for this scheme is to order the transaction based on their time stamp.
• In the time stamp based method a serial order is created among the concurrent
transaction by assigning each of the transaction a unique non decreasing number.
• The usual value assigned to each transaction is the system clock time value at
start of the transaction.
Time stamp ordering rules: The following rules are checked when transaction T
attempts to change a data item.
If the rule indicates ABORT, then transaction T is rolled back and aborted.
Rule-1: If T attempts to read a data item which has already been written to by a
younger transaction then ABORT T.
Rule-2: If T attempts to write a data item which has been seen or written to by a
younger transaction then ABORT T.
If a transaction t aborts, then all other transactions which have seen a data item written
to by T must also abort.
In addition other aborting transactions can cause further aborts on other transactions.
This is a cascading roll back.
The time stamp ordering algorithm:
• The idea for this scheme is to order the transactions based on their time spaces/
stamps.
• A schedule in which the transactions participate in the serializable and the
equivalent serial schedule has the transactions in order of their time stamp
values.
• This is called time stamp ordering.
• The algorithm must ensure that for each item accessed by conflicting operations
the schedule, the order in which the item is accessed, the item is accessed does
not violate serializability order.
• In this algorithm, the item X is accessed with two time stamp values (TS)

(i) Read-Ts (X): The read time stamp of item X; this is the largest time stamp
among all the time stamp of transaction that have successfully read item X.
i.e. Read Ts(X)=TS(T), where T is youngest transaction that has read X
successfully.
(ii) Write-Ts (X) : The entire time stamp of item X , this is the largest time stamp
among al the time stamp of transaction that have successfully written item X,
that is write-TS(X)=TS(T), where T is youngest transaction that has written X
successfully.
Basic time stamp ordering (Basic To)
• Whenever some transaction T tries to issue a read (X) or write (X) operation, the
basic time stamp ordering algorithm compares the time stamp of T with read-
Ts(X) and write –Ts(X) to ensure that the time stamp order of transaction
execution is not violated.
• If this order is violated them transaction T is aborted and submitted to the system
as a new transaction with a new time stamp.
• If T is aborted and rollback, any transaction T1 that may have used a value
written by T must be rollback.
• The effect is known as cascading rollback.
• The concurrency control algorithm must check whether conflicting operations
violate the timestamp ordering in the following two cases.
o Transaction T issues a write-item(X) or write (X).
(a) If read-Ts(X) > Ts(T) or if write –Ts(X)>Ts(T), then abort and rolled back T and
reject the operation.
(b) If the condition (a) is not satisfied them execute write(X) operation of T and set
write Ts(X) to Ts(T)
o Transaction T issues a read (X).
(c) If read-Ts(X) > Ts(T) , then abort and rolled back T and reject the operation.
(d) If read-Ts(X) > Ts(T) , then abort and rolled back T and reject the operation. Of T
and set read Ts(X) to Ts(T) the current read Ts(X) which ever is larger.
Thomas write rule: A modifications of basic time stamp ordering algorithm is known a
stomas write rule.

• It does not enforce conflict serializability, However.
• It rejects fewer write operations by modifying the check for the write (X) operation
as follows.
1. If read-Ts(X) >Ts (T), then abort and rollback T and reject the operation.
2. IF write Ts(X) >Ts(T), then do not execute write operation but continue
processing operation, this is because some transaction with time stamp ordering
has already written the value of X, hence we must ignore the write (X) operation
of T because it is already, outdated and absolved.
3. If neither the condition in part (1) nor the condition in part (2) occurs, then
execute the write-item (x) operation of T and set write-Ts (X) to Ts (T).
Strict Time stamp ordering: A variation of basic Time stamp ordering is called strict
time ordering that ensures that the schedules are both strict for easy recoverability and
conflict serializable.
In this variation a transaction T that issues read (X) or write (X) such that Ts(T) >write-
Ts(X) has its read or write operation delayed until the transaction T that write the value
of X has committed or aborted. To implement this algorithm it is necessary to simulate
the locking of an item X that has been written by transaction T until T is either
committed or aborted.
This algorithm does not cause deadlock , since T waits T only for Ts(T) >Ts(T).
Multiversion concurrency control technique:
• In this technique multiple versions (values) of an item are maintained i.e. the old
and updated value of a data item is kept.
• When a transaction requires access to an item, an appropriate version is chosen
to maintain the serializability of the currently executing schedule.
• When a transaction writes an item it writes a new version and the old version of
the item is retained.
• Some multiversion concurrency control algorithms use the concept of view
serializability rather than conflict serializability.
• The main drawback of multiverison technique is that more storage spaces are
needed to maintain multiple versions of the data items.

• The order versions may have to maintained any way for recovery or other
purposes.
Optimistic Concurrency Control:
• In optimistic concurrency control techniques no. checking is done before the
transaction is executed.
• This also called validation or certification techniques.
• In this technique, updates in transaction are not applied directly to the database
items until the transaction reaches its end.
• During transaction execution, all updates are applied to local copies of the data
items that are kept for the transaction.
• After the transaction is executed, a validation phase checks whether any of the
transactions updates violates serializability.
• If serializability is not violated, the transaction is committed and the database is
updated form the local copies; otherwise the transaction is aborted and then
restarted later.
There are three phases for this concurrency control protocol.
1. Read phase: A transaction can read values to the committed data items from the
database. However updates are applied only to local copies (versions) of the
data items kept in the transaction work space.
2. Validation phase: Checking is performed to ensure that serializability will not be
violated if the transaction updates applied to the database.
3. Write phase: If the validation phase is successful, the transaction updates are
applied to the database; otherwise , the updates are discarded and the
transaction is restarted.
This technique is called optimistic because they assume that little interference will occur
and hence there is no need to do checking during transaction execution.
In validation phase for transaction Ti, the protocol check that Ti does not interfere with
any committed transaction or with any other transactions currently in their validation
phase.
The validation phase for Ti checks that for each such transaction Ti that is either
committed or is in its validation phase, one of the following condition holds.

1. Transaction Tj completes its write phase before Ti starts its read phase.
2. Ti starts its write phase after Tj completes its write phase and read-set of Tj has no
items in common with the write – set of Tj.
3. Both the read set and write set of Ti have no items in common with the write set of Ti
and Tj completes its read phase before Ti completes its read phase.
When the validating transaction Ti, the first condition is checked first for each
transaction Tj, since condition (i) is the simplest condition to check.
Only if the condition (i) is false condition (ii) checked and if (ii) is false is condition (iii)
the most complex to evaluate checked. If one of these conditions holds there is no
interference and Ti is validated successfully.
If non of these three conditions holds, the validation of transaction Ti fails and it is
aborted and restarted later because interference may have occurred.
Recovery techniques:
Deferred update: Deferred update or No UNDO/REDO is an algorithm to support
ABORT and machine failure.
• While a transaction runs, no changes made by the transaction are recorded in
the database.
• On a commit:
• The new data is recorded in a log file and flashed to disk
• The new data is then recorded in the database itself.
• On as abort, do nothing (the database has not been check)
• On a system restart after a failure , REDO the log.
Example: Let us consider the following transaction Ti
T1
Read (A)
Write(10,B)
Write (20,C)
Commit

Using deferred update , the process is:
Time Action Log
T1
T2
T3
T4
T5
Start
Read(A)
Write(10,B)
Write(20,C)
Commit
-
-
B=10
C=20
Commit
Before After
Disk
B=6
A=5
C=2
B=10
A=5
C=10
If the DBMS is failed and is restarted
• The disks are physically or logically damaged them recovery from the log is
impossible and instead a restore from a dump is needed.
• If the disks are ok then the database consistency must be maintained. Writes to
the disk which was in progress at the time of failure may have only been partially
done.
• Parse the log file and where a transaction has been ended with COMMIT apply
the data part of the log to the database.
• If a log entry for a transaction ends with any thing other than commit , do nothing
for that transaction.
• Flush the data to the disk and then truncate the log to zero.
• The process or reapplying transaction form the log is some times referred to as
roll forwarded.
Immediate Update:
Immediate update or UNDO/REDO, is another algorithm to support ABORT and
machine failure scenarios.

• While a transaction runs, changes made by that transaction can be written to the
database any time . However, the original and new data being written must both
be stored in the log before storing it on the database disk.
• On a commit
• All the updates which is not yet been recorded on the disk is first stored in the log
file and then flushed to disk.
• The new data is then recorded in the database itself.
• On an abort, REDO all the changes which that transaction has made to the
database disk using the log entries.
• On a system restart after a failure , REDO committed changes from Log.
Example: Using immediate update and the transaction T1 again , the process is:
Time Action Log
T1
T2
T3
T4
T5
Start
Read(A)
Write(10,B)
Write(20,C)
Commit
-
-
Was B=6 now10
Was C=2, now 20
Commit
Before During After
Disk
B=6
A=5
C=2
B=10
A=5
C=2
B=10
A=5
C=20
Recovery: Database recovery from failure such as system crashes, transaction errors
etc.
A database may be in inconsistent state when:
(i) Dead lock has occurred.
(ii) A transaction is aborted after updating the database
(iii) Software or hardware errors are occurred.
(iv) In correct updates have been applied to the database.
If the database is in inconsistent state, it should be recovered to a consistent state.

This basis of recovery is to have back ups of the data in the database.
Types of recovery:
Dump: A full backup of the database. In this method .
• The entire contents of the database is backed up in an a auxiliary storage
• Backup is taken only at the consistent state of the database
• Dumping takes a long time to perform
• Dumping is expensive and can be performed repeatedly
Transaction log: (Journal)
• A log is a sequence of log records recording all the update activities in the
database since the last consistent state.
• Database can have state before and after each transaction (information)
• When the database is returned to a consistent state, the log may be truncated to
remove committed transaction.
• When the database is returned to a consistent state the process is often
referred to as check pointing.
Checkpoint: Checkpoint is a scheme, which is used to limit the volume of log
information that has to be handed and process in the event of a system failure
involving loss of volatile information.
• It is performed periodically. It performs the following sequence of actions to
take place.
• Output all log records currently residing in main memory into stable storage.
• Output all modified buffer blocks to the disk
• Write a log record <check point> on to stable storage.
Recovery using check point:
During recovery we need to consider only the most recent transaction Ti that started
before the check point and transaction that started after Ti.
• Same backwards from end of log to find the most recent <check point> record.
• Continue scanning backwards to a record <Ti start> is found
• Need only consider the part of log following above start record.
• Earlier part of part of log can be ignored during recovery and can be erased
whenever desired.

• For all transactions (starting form Ti or latter) with no <Ti commit>, execute undo
Ti. Done only in case of immediate modification.
• Canning forward in the log, for all transactions starting form Ti or later with a <Ti
commit> execute redo (Ti)
IF the DBMS fails and restarted:
• The disks are physically or logically damaged then the recovery form log is
impossible and instead a restore from a dump is needed.
• If the disks are ok then the database consistency must be maintained. Writes to
disk which was in progress at the time of failure may have only been partially
done .
• Parse the log file and where a transaction has been ended, with commit apply
the new data part of the log to the database.
• IF a log entry for a transaction ends with any thing other than commit, apply the
old data party the log to the database.
• Flush the data to the disk and then truncate the log to Zero.
Roll Back
The process of undoing changes done to the disk under immediate update is frequently
referred to as rollback.
• Where the DBMS does not prevent one transaction from reading un committed
modifications (a dirty read) of another transaction (i.e. the uncommitted
dependency problem,) then aborting the first transaction also means aborting all
transactions which have performed their dirty reads.
• As a transaction is aborted it can therefore cause aborts in other dirty reader
transactions, which in turn can cause other aborts in other dirty reader
transaction.
This is refereed to as cascade roll back.

What is an index ?
Index: An index is a data structure or table, which is maintained to determine the
address (location ) of rows (Records) in a file that satisfy some conditions.
• An index table consists of the value of the key attribute for a particular record and
the pointer to the location where the record is stored.
• The record is retrieved from the disk first by searching the index for the address
of the record in the index table and then reading the record from this address.
What are the uses of indices ?
• An index on a file speeds up selection on the search key fields for the index.
• An index contains a collection of data entries and supports efficient retrieval of
data entries with a given key value .
• Updating a particular record is fast.
• Inserting records is also fast.
What are different types of indexing ? Indices ?
There are two basic kinds of indices
(1) Ordered indices: Based on sort ordering of the values.
(2) Hash indices: Based on the values being distributed uniformly across a range of
buckets.
The bucket to which the value is assigned is determined by a function called a
hash function.
Types of ordered indices: There are two types of ordered indices.
(1) Primary index: The file in which the records are sequentially ordered, the index
whose search key specifies the sequential order of the file is called the primary
index.
The primary index is called also clustering index.
A primary index is an ordered file whose recorded are of fixed length with two
fields. The first field is the same data type as the ordering key field (primary key)
and the second field is the pointer to a disk block (a block address)
There is one index entry in the index file for each block in the data file.
(2) Secondary index: An index whose search key specifies an order different form
the sequential order of the file in called secondary index or no clustering index.

A secondary index is also an order file with two fields . The first filed is of some
data type as some non ordering field of the data file that is an indexing field. The
second field in either a block pointer or record pointer.
The secondary index is used to search a file on the basis of secondary keys.
(3) Dense and sparse indices: These are the ordered indices that we can use.
Dense index: An index record (or index entry) appears for every search key
value in the file
The index record contains the search key value and pointer to the first data
record with that search key value.
Sparse index: An index record is created for only some of the values. Each
index record contains a search key value and a pointer to the first data record for
that search key value.

Database Lecture Notes

Recommended

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Database Lecture Notes (20)

More from FellowBuddy.com (20)

Recently uploaded (20)

Database Lecture Notes