Unit-2

Relational Data Model & Language

 Introduction
 Before 1970 most the database system were based on two models
i.e. Hierarchical Model or Network Model

 Dr. Codd (IBM Scientist) proposed a relational Data Model in 1970.

 A RDBMS is a Database Management system which is based on relational model as

introduced by Dr. Codd. It should satisfy Codd 12 rules but in practice there is no
DBMS that satisfies all these rules.
 Today, popular RDBMS are:
 Microsoft Access
 MSSQL
 MYSQL
 Oracle
 Sybase
 DB2
 Informix
2
 Overview of CODD’s 12 rules
 Dr. E.F. Codd is an IBM researcher who first developed the
relational data model in 1970.

 In 1985 Dr. Codd published a list of 12 rules that define

an ideal relational database and has provided a guideline
for the design of all relational database system
 Codd's Rules
Rule 1 : The information Rule

This rule simply requires that all Information/ data

should be presented in table form.

This is the basis of Relational Model

 Rule 2 : Guaranteed Access Rule

 Each and every data in a relational data base is guaranteed to

be logically accessible by resorting to a combination of table
name, primary key value and column name.

 Every value can be accessed by providing table name, column

name and key.

 All data are uniquely identified and accessible via this identity.
 Rule 3 : Systematic treatment of null values.

 The RDBMS must support the null values

to represent missing information. They
must distinct from zero or spaces.

 They must be independent of data value.

 Rule 4 : Dynamic on-line catalog based on
the relational model

 System catalog is a collection of tables that the

DBMS maintain for its own use.

 These Table hold the description of the authorized

users as the part of the database
 Rule 5 : Comprehensive data sub-language Rule

 The database must support at least one clearly defined

language that includes functionality for Data Definition
Data Manipulation, Integrity Constraints and transaction
process.

 All commercial relational database use forms of SQL as

their supported comprehensive language.
 Rule 6 : View updating Rule

 Data can be presented in different logical combinations

called views.

 Each view should support the full range of data manipulation

that has direct access to a table available.
 Rule 7 : High-level Insert, Update and Delete

 Data can retrieved from a from a relational database in

set constructed of data from multiple rows and tables.

 This rules state that insert, update and delete

operations should be supported for RDBMS
 Rule 8 : Physical data independence

 The users is isolated from the physical method of storing

and retrieving information from the database.

 Change can be made to the basic architecture without

affecting how to user accesses it.
Rule 9 : Logical data independence.

 How data is viewed should not be changed

when the logical structure (Table Structure ) of
the database change.

 This rule is particularly difficult to satisfy

 Rule 10 : Integrity Independence
 The database language (like SQL) should support
constraints on user input maintain database
integrity.

 No component of a primary key can have null

value.

 If a foreign key is defined in one table, any value in

it must exist as a primary key in another table.
 Rule 11 : Distribution Independence.
 Database must allow manipulation of distribution data
located in other computer system.

 Applications should still work in a distributed database (DDB)

 Distribution independence means a Application program that

accesses the DBMS on a single computer should also work,
without modification, even if the data is moved from one
computer to another in a network environment.
 Rule 12: The Non-Subversion rule:

Non-subversion rule

All the database access must be controlled

through the DBMS so that the integrity of the
database cannot be support without the
knowledge of the user.
 Basic Concept of Relational Model
 A database is a collection of one or more relations where
each relation is table rows & columns.

 The main construct for representing data in the relational

model is the relational.

 A relation consists of a relation schema and relation instance.

 The relation instance is a table and relation schema (data

structure) describes the relation name of each fields, field
type, domain name with associated standard data i.e.,
integers, real, character, string, date, time. 16
 Relation Schema and Instance
 A1, A2, …, An are attributes

 R = (A1, A2, …, An ) is a relation schema

Example:
instructor = (ID, name, dept_name, salary)
 Formally, given sets D1, D2, …. Dn a relation r is a subset of Di

 Thus, a relation is a set of n-tuples (a1, a2, …, an) where each ai  Di

 The current values (relation instance) of a relation are specified by a table
 An element t of r is a tuple, represented by a row in a table
Example of a Relation Attributes/ Fields
(or columns)

Tuples/ Records
(or rows)
 Attribute/ Field Types
 The set of allowed values for each attribute is called the
domain of the attribute
(Ex. ID number is a set of valid 9 digit number is a domain)

 Attribute values are (normally) required at the time of data

structure design

 The special value null is a member of every domain

 The null value causes complications in the definition of

many operations
 Relational Constraints
 A database is only as good as the information stored in it and a
RDBMS must therefore help prevent the entry of incorrect
information.
 The constraint is a condition that is specified on a database
schema and prevent the data that can be stored an instance of
the data.
 There are various restrictions on data that can be specified on a
relational database schema such as:
 Domain Constraints
 Key Constraints
 Entity Constraints
 Referential Integrity Constraints
 Domain Constraints
 Domain Constraints specify that the value of each
attribute.
 Value of each attribute must be atomic value from the
domain (Ai).
 The data types associated with domains typically
include standard data type for integers, real, character,
string, date, time also available to specify relation
schema.
Ex. Create domain rate numeric (5,2)
The Constraint rate-value 24.00
 Key Constraints
 A set of attributes that uniquely identifies a record
according to key constraints is called super key for a
relation.
Ex. Primary Key, Candidate Key and Super Key
 For the relation schema R (A1, A2, …, An ), the key
constraints key (K), where K is a subset of R is the
restriction that no two records of relation R define on the
relational schema R have the same value for the
attributes in K
 Integrity Constraints
 An integrity constraints is the condition that can be
applied on a database schema to restrict the data
according to the need. If condition is satisfied, then only
it can be stored in database.
 The purpose of these constraints is to ensure that there
should not be any loss in data consistency due to change
made to the data by the authorized users.
 There are two type of Integrity constrains:
 Entity Integrity Constraints
 Referential Integrity Constraints
 Entity Integrity Constraints
 The entity integrity constraints state that no
primary key value can be null. This is because the
primary key value is used to identify individual
types in a relation, having null values for the
primary key implies that we cannot identify same
record.
 For example two or more records have null value
for their primary key. We not be able to difference
them.
 Referential Integrity Constraints
 Referential integrity constraints is a condition
which ensure that a value that appears in one
relation for a given set of attributes also appears
for a certain set of attributes in another relation.
 Key constraints and entity integrity constrains are
specified an individual relation.
 The referential integrity constraints is specified
between two relations.
 Referential Integrity Constraints
 The relation between primary key and foreign key is the
example of referential integrity constraints.
Foreign Key Primary Key
Course ID Sem S_ ID S_ ID SName Address
B.Tech. (CSE) 1 200518 200512 Anoop AAAAA
B.Tech. (TT) 3 200565 200531 Garrav BBBBB
B.Tech. (TC) 2 200531 200565 Ashima CCCCC
200518 Manshi DDDDD
(Enrol Table) (Student Table)
Note: Insertion of a new record in Enrol table with S_ID (200587) is not possible
until the corresponding value (200587) is not inserted in student table. Similarly in
case of deletion of any existing record from student table S_ID (200518)
automatically delete corresponding record from Enroll Table.
For every update make in referencing relational the rules are similar as in case of
insertion and deletion
Schema Diagram for University Database
 Query Languages
 A query language is a language through which we
communicate with the database.

 When we want to read or write something into from existing

database, then we use query language.

 These language are higher levels then standard programming

language, These are two type of query language:
 Relational Algebra

 Relational Calculus
 Relational Algebra
 Relational Algebra is a procedural query language. It consists of
set of operations that take one or two relations as input and
produce a new relation as their result.
 Relational Algebra is of following eight types:
1. Select (σ )
2. Project (Π )
3. Product (X)
4. Unions (U)
5. Differences (- )
6. Intersection ( )
7. Join ( )
8. Divide/ Division ( / )
 Selection Operation
The selection operation selected records that satisfy
a given condition. It is denoted by (σ ) sigma.

 Relation r

 Select record with A=B and D > 5

 σ
A=B and D > 5 (r)
 Project Operation or
Selection of Columns (Attributes)
This operation shows the list of those attributes
that we wish to appear in the result. It is denoted
by (Π ) Pie.

 Relation r:

 Select A and C
 Projection
 Π A, C (r)
Joining Two Relations – Product Operation
This operation allows us to combine information
from two relations at r and s and relations product
denoted as r x s
 Relations r, s:

 r x s:
Union Operation
This operation allows us to combine information
from two relations at r and s relations and duplicates
records are eliminated

 Relations r, s:

 r  s:
 Difference Operation
This operation allows us to find the records that are in
one relation, but are not in another. Let the two relation
r and s and relations difference denoted by r - s
 Relations r, s:

 r – s:
 Intersection Operation
This operation allows us to find the records that are in
common. Let the two relation r and s and relations
intersection denoted by r  s

 Relation r, s:

 rs
 Join Operation
 The join operation denoted by , is used to combine related records from
two relations into single records. This operation is very important for any
relational database with more than a single relation.

 The general form of join operation on two relation r (A1, A2, …, An ) and
s (B1, B2, …, Bm ). The result of the join is relation Q with (n + m) attributes
Q (A1, A2, …, An , B1, B2, …, Bm ) in that order. Q has one record for each
combination of records, one from r and one from s whenever the
combination satisfies the join condition.
 Join Operation is four types:
 Natural Join
 Outer Join
 Equal Join
 Theta Join
 Natural Join
This Natural Join is a binary operation that allows us to combine
certain selection and product into one operation
Employee Salary
E_Code E_Name E_Code Salary
E001 Hari E001 2000
E002 Om E002 5000
E003 Smith E003 7000
E004 Jay E004 1000
The result of (Employee Salary) is as follows:
E_Code E_Name Salary
E001 Hari 2000
E002 Om 5000
E003 Smith 7000
E004 Jay 1000
 Outer Join
The Outer Join operation is a extension of the join operation to
deal with missing information. It is basically three types: left outer
join, Right outer join and full outer join Office
Employee E_Name Dept Salary
E_Name Street City
Ram EDP 2000
Ram Civil line Mumbai
Shyam MIS 5000
Shyam Park street Kolkata
Kuber Account 7000
Ravi MG Street Delhi
Rohit Admin 1000
Rohit Nehru Nagar Ghaziabad
The result of (Employee Salary) is as follows:
E_Name Street City Dept Salary
Ram Civil line Mumbai EDP 2000
Shyam Park street Kolkata MIS 5000
Rohit Nehru Nagar Ghaziabad Admin 1000
From the result, only common attributes are displayed. Hence the
avoid such loss of information we can use the concept of outer join
 Left Outer Join
It is denoted by the symbol . All information from the left
relation is present in the result of the left outer join.

The result of (Employee Office) is as follows:

E_Name Street City Dept Salary

Ram Civil line Mumbai EDP 2000
Shyam Park street Kolkata MIS 5000
Rohit Nehru Nagar Ghaziabad Admin 1000
Ravi MG Street Delhi Null Null

Note that the tuple (Ravi , MG Street, Delhi, Null, Null) is such a tuple,
which is added.
 Right Outer Join
It is denoted by the symbol . All information from the right
relation is present in the result of the right outer join.

The result of (Employee Office) is as follows:

E_Name Street City Dept Salary

Ram Civil line Mumbai EDP 2000
Shyam Park street Kolkata MIS 5000
Rohit Nehru Nagar Ghaziabad Admin 1000
Kuber Null Null Account 7000

Note that the tuple (Kuber, Null, Null, Account, 7000) is such a tuple,
which is added.
 Full Outer Join
It is denoted by the symbol . All information from the left and
right relations are present in the result.

The result of (Employee Office) is as follows:

E_Name Street City Dept Salary

Ram Civil line Mumbai EDP 2000
Shyam Park street Kolkata MIS 5000
Rohit Nehru Nagar Ghaziabad Admin 1000
Ravi MG Street Delhi Null Null
Kuber Null Null Account 7000

Note that the tuple (Ravi , MG Street, Delhi, Null, Null) and
(Kuber, Null, Null, Account, 7000) are such a tuples, which are added.
 Equality Join
The most common use of join involves join condition with equality
comparisons only. Such a join, where the only comparison operation
(‘=‘) is used is called as Equi Join

(Employee E_name = E_name Office)

E_Name Street City Dept Salary

Ram Civil line Mumbai EDP 2000
Shyam Park street Kolkata MIS 5000
Rohit Nehru Nagar Ghaziabad Admin 1000
 Theta Join
A general join condition is of the form

<Condition 1> AND <Condition 2> AND ………AND<Condition n>

E_Name Street City Dept Salary

Ram Civil line Mumbai EDP 2000
Shyam Park street Kolkata MIS 5000
Rohit Nehru Nagar Ghaziabad Admin 1000
 Introduction to SQL
Introduction
DDL Commands
DML Commands
SQL Statements, Operators, Clauses
Aggregate Functions
Sub-Queries
Indexes
Views
 History
IBM Sequel language developed as part of System R project at the IBM
San Jose Research Laboratory

Renamed Structured Query Language (SQL)

As per IEE, ANSI and ISO standard for SQL:

SQL-86,
SQL-89,
SQL-92
SQL:1999,
SQL:2003,
SQL:2008
The ANSI and ISO standard language for the definition and
manipulation of relational database.

Includes data definition language (DDL), statements that specify

and modify database schemas.

Includes a data manipulation language (DML), statements that

manipulate database content.

47
 SQL: DDL Commands

CREATE TABLE: used to create a table.

ALTER TABLE: modifies a table after it was created.

DROP TABLE: removes a table from a database.

 SQL: CREATE TABLE Statement
Things to consider before you create your table are:
The type of data
the table name
what column(s) will make up the primary key
the names of the columns

CREATE TABLE statement syntax:

CREATE TABLE <table name>

( field1 datatype ( Size ),
field2 datatype ( Size ), ..............);
SQL: Attributes/Domain/Field/Data Type
 SQL: ALTER TABLE Statement
To add or drop columns on existing tables.

ALTER TABLE statement syntax

ALTER TABLE <table name>(

ADD attr datatype);
or
DROP COLUMN attr);
 SQL: DROP TABLE Statement
Has two options:
CASCADE: Specifies that any foreign key constraint
violations that are caused by dropping the table will cause the
corresponding rows of the related table to be deleted.

RESTRICT: blocks the deletion of the table of any foreign key

constraint violations would be created.

DROP TABLE statement syntax:

DROP TABLE <table name> [ RESTRICT|CASCADE ];

 SQL: Example
FoodCart
CREATE TABLE FoodCart (
date varchar(10), date food qty
food varchar(20),
qty int );

FoodCart
ALTER TABLE FoodCart ( date food qty rate
ADD rate float );

FoodCart
ALTER TABLE FoodCart(
DROP COLUMN profit ); date food sold

DROP TABLE FoodCart;

 SQL: DML Commands

INSERT: adds new rows to a table.

UPDATE: modifies one or more attributes.

DELETE: deletes one or more rows from a table.

 SQL: INSERT Statement
To insert a row into a table, it is necessary to have a value for each
attribute, and order matters.
INSERT statement syntax:

INSERT into <table name> VALUES ('value1', 'value2', NULL);

Example: INSERT into FoodCart VALUES (’02/26/08', ‘pizza', 70 );

FoodCart

date food rate date food rate

02/25/08 pizza 350
02/25/08 pizza 350
02/26/08 hotdog 500
02/26/08 hotdog 500 02/26/08 pizza 70
 SQL: UPDATE Statement
To update the content of the table:
UPDATE statement syntax:
UPDATE <table name> SET <attr> = <value> WHERE <selection condition>;

Example: UPDATE FoodCart SET rate = 349 WHERE date = ’02/25/08’ AND food = ‘pizza’;

FoodCart
date food rate date food rate
02/25/08 pizza 350 02/25/08 pizza 349
02/26/08 hotdog 500 02/26/08 hotdog 500
02/26/08 pizza 70 02/26/08 pizza 70
 SQL: DELETE Statement
To delete rows from the table:
DELETE statement syntax:
DELETE FROM <table name> WHERE <condition>;

Example: DELETE FROM FoodCart WHERE food = ‘hotdog’;

FoodCart
date food rate date food rate
02/25/08 pizza 349 02/25/08 pizza 349
02/26/08 hotdog 500 02/26/08 pizza 70
02/26/08 pizza 70
Note: If the WHERE clause is omitted all rows of data are deleted from the table.
SQL Statements, Operations, Clauses
SQL Statements:
Select
SQL Operations:
Join
Left Join
Right Join
Like
SQL Clauses:
Order By
Group By
Having
 SQL: SELECT Statement
A basic SELECT statement includes 3 clauses

SELECT <attribute name> FROM <tables> WHERE <condition>

SELECT FROM WHERE

Specifies the Specifies the tables Specifies the selection

attributes that are that serve as the condition, including
part of the resulting input to the statement the join condition.
relation

Note: that you don't need to use WHERE

 SQL: SELECT Statement (cont.)
Using a “*” in a select statement indicates that every attribute of
the input table is to be selected.

Example: SELECT * FROM … WHERE …;

To get unique rows, type the keyword DISTINCT after

SELECT.

Example: SELECT DISTINCT * FROM … WHERE …;

 Examples
Table: Person
1) SELECT * FROM person
Name Age Weight WHERE age > 30;
Harry 34 80
Sally 28 64 Name Age Weight
George 29 70 Harry 34 80
Helena 54 54 Helena 54 54
Peter 34 80 Peter 34 80

2) SELECT weight FROM person 3) SELECT distinct weight

WHERE age > 30; FROM person WHERE age > 30;

Weight Weight
80 80
54
54
 SQL: Join operation
A join can be specified in the FROM clause which list the
two input relations and the WHERE clause which lists the
join condition.
Example:
Emp Dept
ID State ID Division
1000 CA 1001 IT
1001 MA 1002 Sales
1002 TN 1003 Biotech
 SQL: Join operation (cont.)
inner join = join

SELECT * FROM emp join dept (or FROM emp, dept)

on emp.id = dept.id;

Emp.ID Emp.State Dept.ID Dept.Division

1001 MA 1001 IT
1002 TN 1002 Sales
SQL: Join operation (cont.)
left outer join = left join

SELECT * FROM emp left join dept on emp.id = dept.id;

Emp.ID Emp.State Dept.ID Dept.Division

1000 CA null null
1001 MA 1001 IT
1002 TN 1002 Sales
SQL: Join operation (cont.)
right outer join = right join

SELECT * FROM emp right join dept on emp.id = dept.id;

Emp.ID Emp.State Dept.ID Dept.Division

1001 MA 1001 IT
1002 TN 1002 Sales
null null 1003 Biotech
 SQL: Like operation
Pattern matching selection:

% (arbitrary string)
SELECT * FROM emp WHERE ID like ‘%01’;
(Finds ID that ends with 01, e.g. 1001, 2001, etc )

_ (a single character)
SELECT * FROM emp WHERE ID like ‘_01_’;
(Finds ID that has the second and third character as 01, e.g. 1010,
1011, 1012, 1013, etc)
 SQL: The ORDER BY Clause
Ordered result selection:

desc (descending order)

SELECT * FROM emp order by state desc
( puts state in descending order, e.g. TN, MA, CA)

asc (ascending order)

SELECT *
FROM emp order by id asc
( puts ID in ascending order, e.g. 1001, 1002, 1003)
 SQL: The GROUP BY Clause
The function to divide the tuples into groups and returns an aggregate
for each group.

Usually, it is an aggregate function’s companion

SELECT food, sum(amt) as totalamt FROM FoodCart group by food;

FoodCart
date food amt food totalamt
02/25/08 pizza 349 hotdog 500
02/26/08 hotdog 500 pizza 419
02/26/08 pizza 70
 SQL: The HAVING Clause
The substitute of WHERE for aggregate functions

Usually, it is an aggregate function’s companion

SELECT food, sum(amt) as totalamtm FROM FoodCart

group by food having sum(sold) > 450;
FoodCart
date food amt food totalamt
02/25/08 pizza 349 hotdog 500
02/26/08 hotdog 500
02/26/08 pizza 70
 SQL: Aggregate Functions

Are used to provide summarization information for SQL statements,

which return a single value.

COUNT(attr)
SUM(attr)
MAX(attr)
MIN(attr)
AVG(attr)

Note: when using aggregate functions, NULL values are not

considered, except in COUNT(*) .
 SQL: Aggregate Functions (cont.)
FoodCart
date food sold
02/25/08 pizza 349
02/26/08 hotdog 500
02/26/08 pizza 70
COUNT(attr) -> return # of rows that are not null
Ex: COUNT(distinct food) from FoodCart; -> 2

SUM(attr) -> return the sum of values in the attr

Ex: SUM(sold) from FoodCart; -> 919

MAX(attr) -> return the highest value from the attr

Ex: MAX(sold) from FoodCart; -> 500
 SQL: Aggregate Functions (cont.)
FoodCart
date food sold
02/25/08 pizza 349
02/26/08 hotdog 500
02/26/08 pizza 70
MIN(attr) -> return the lowest value from the attr
Ex: MIN(sold) from FoodCart; -> 70

AVG(attr) -> return the average value from the attr

Ex: AVG(sold) from FoodCart; -> 306.33

Note: value is rounded to the precision of the datatype

 Sub-Queries
A SELECT statement can be nested inside another select,

Example: Assume we have following two tables:

Emp (name, deptName, sales)
DeptSales (deptName, itemSold, Cost)
Which items are sold in Anil department? Following query will be
executed.

SELECT itemSold
from DeptSales
Where deptName = (SELECT deptName from Emp where name=‘Anil’);
 Indexes
• An index can be created in a table to find out more quickly
and efficiently.
• Indexing is a way to sort and search records in the table.
• Indexing are essential to improve the speed with which
record can be located and retrieved from a table.
• Indexes in database are similar to indexes in books.

Syntax :

CREATE INDEX <Index Name> ON <Table Name> (<Column Name>);

 Views
• In SQL, a view is a virtual table based on the result set of
SQL statement.
• A view contains rows and columns, just like a real table.
• We can add SQL function, WHERE and JOIN statements to a
view.
Create View Syntax :
CREATE VIEW < View Name> AS SELECT <Column Names > FROM
<Table Name> WHERE condition;
Delete View Syntax :
DROP VIEW <View Name>;
 PL/SQL
In Oracle database management, PL/SQL is a procedural language extension to
Structured Query Language (SQL). The purpose of PL/SQL is to combine database
language and procedural programming language.

PL/SQL extends SQL by adding constructs found in procedural languages, resulting in a

structural language that is more powerful than SQL. The basic unit in PL/SQL is a block.
All PL/SQL programs are made up of blocks, which can be nested within each other.

A block has the following structure:

DECLARE
declaration statements;
BEGIN
executable statements
EXCEPTIONS
exception handling statements
76
END;
77
 Cursors
In PL/SQL, the context area is controlled by Cursor. A cursor contains
information on a select statement and the rows of data accessed by it.
A cursor is used to referred to a program to fetch and process the rows
returned by the SQL statement, one at a time.

78
Syntax:

DECLARE variables;
records;
create a cursor;
BEGIN OPEN cursor;
FETCH cursor;
process the records;
CLOSE cursor;
END;

79
 Trigger
In a DBMS, a Trigger is a SQL procedure that initiates an action (i.e., fires an
action) when an event (INSERT, DELETE or UPDATE) occurs. Since triggers are
event-driven specialized procedures, they are stored in and managed by the
DBMS.

A trigger cannot be called or executed; the DBMS automatically fires the trigger
as a result of a data modification to the associated table. Triggers are used to
maintain the referential integrity of data by changing the data in a systematic
fashion. Each trigger is attached to a single, specified table in the database.

A trigger can also contain INSERT, UPDATE and DELETE logic within itself, so
when the trigger is fired because of data modification it can also cause another
data modification, thereby firing another trigger.
80
 Create the Triggers
.
Step1: Create Database

Step2: Create Table

Step3: insert and display the records.

81
 Create the Triggers
.

Step4: Create the Trigger

Step5: Action the Trigger

82