Chapter 4

Relational Algebra and

Relational Calculus
Transparencies
 Chapter 4 - Objectives
• Meaning of the term relational completeness.

• How to form queries in relational algebra.

• How to form queries in tuple relational calculus.

• How to form queries in domain relational

calculus.
• Categories of relational DML.

2
 Introduction
• Relational algebra and relational calculus are
formal languages associated with the relational
model.
• Informally, relational algebra is a (high-level)
procedural language and relational calculus a
non-procedural language.
• However, formally both are equivalent to one
another.
• A language that produces a relation that can be
derived using relational calculus is relationally
complete.

3
 Relational Algebra
• Relational algebra operations work on one or
more relations to define another relation
without changing the original relations.

• Both operands and results are relations, so

output from one operation can become input to
another operation.

• Allows expressions to be nested, just as in

arithmetic. This property is called closure.

4
 Relational Algebra
• 5 basic operations in relational algebra:
Selection, Projection, Cartesian product,
Union, and Set Difference.

• These perform most of the data retrieval

operations needed.

• Also have Join, Intersection, and Division

operations, which can be expressed in terms of
5 basic operations.
5
Relational Algebra Operations

6
Relational Algebra Operations

7
 Selection (or Restriction)
• predicate (R)
– Works on a single relation R and defines a
relation that contains only those tuples
(rows) of R that satisfy the specified
condition (predicate).

8
 Example - Selection (or
Restriction)
• List all staff with a salary greater than
£10,000.

salary > 10000 (Staff)

9
 Projection
• col1, . . . , coln(R)
– Works on a single relation R and defines a
relation that contains a vertical subset of
R, extracting the values of specified
attributes and eliminating duplicates.

10
 Example - Projection
• Produce a list of salaries for all staff,
showing only staffNo, fName, lName,
and salary details.

staffNo, fName, lName, salary(Staff)

11
 Union
• RS
– Union of two relations R and S defines a
relation that contains all the tuples of R, or
S, or both R and S, duplicate tuples being
eliminated.
– R and S must be union-compatible.

• If R and S have I and J tuples,

respectively, union is obtained by
concatenating them into one relation
with a maximum of (I + J) tuples. 12
 Example - Union
• List all cities where there is either a
branch office or a property for rent.

city(Branch)  city(PropertyForRent)

13
 Set Difference
• R–S
– Defines a relation consisting of the tuples
that are in relation R, but not in S.
– R and S must be union-compatible.

14
 Example - Set Difference
• List all cities where there is a branch
office but no properties for rent.

city(Branch) – city(PropertyForRent)

15
 Intersection
• RS
– Defines a relation consisting of the set
of all tuples that are in both R and S.
– R and S must be union-compatible.

• Expressed using basic operations:

R  S = R – (R – S)

16
 Example – Intersection1
• List all cities where there is both a
branch office and at least one property
for rent.

city(Branch)  city(PropertyForRent)

17
 Cartesian product
• RXS
– Defines a relation that is the concatenation
of every tuple of relation R with every tuple
of relation S.

18
Client Viewing
clientNo fname lname V.ClientNo propNo comment

CR76 John Kay CR56 PA14 Too small

CR76 PG4 Too

CR56 Aline Stewart remote
CR56 PG4

CR74 Mike Ritchie CR62 PA14 No

dinning
room
CR62 Mary Tregear CR56 PG36

19
Example - Cartesian Product
• List the names and comments of all clients
who have viewed a property for rent.
(clientNo, fName, lName(Client)) X (clientNo, propertyNo,comment
(Viewing))

20
 Example - Cartesian Product
and Selection
• Use selection operation to extract those tuples
where Client.clientNo = Viewing.clientNo.
sClient.clientNo = viewing.clientNo((ÕclientNo,fName,lName(Client)) 
(ÕclientNo,propertyNo,comment(Viewing)))

 Cartesian product and Selection can be reduced to a single

operation called a Join.
21
 Join Operations
• Join is a derivative of Cartesian
product.
• Equivalent to performing a Selection,
using join predicate as selection
formula, over Cartesian product of the
two operand relations.
• One of the most difficult operations to
implement efficiently in an RDBMS and
one reason why RDBMSs have intrinsic
performance problems.
22
 Join Operations
• Various forms of join operation
– Theta join
– Equijoin (a particular type of Theta join)
– Natural join
– Outer join
– Semijoin

23
Theta join (-join)
• R FS
– Defines a relation that contains tuples
satisfying the predicate F from the
Cartesian product of R and S.
– The predicate F is of the form R.ai  S.bi
where  may be one of the comparison
operators (<, , >, , =, ).

24
 Theta join (-join)
• Can rewrite Theta join using basic
Selection and Cartesian product
operations.

R FS = F(R  S)
 Degree of a Theta join is sum of degrees of the
operand relations R and S. If predicate F contains
only equality (=), the term Equijoin is used.

25
 Example - Equijoin
• List the names and comments of all
clients who have viewed a property for
rent.
(clientNo,fName,lName(Client)) Client.clientNo =

Viewing.clientNo clientNo,propertyNo,comment(Viewing))

26
 Natural Join
• R S
– An Equijoin of the two relations R and S
over all common attributes x. One
occurrence of each common attribute is
eliminated from the result.

27
 Example - Natural Join
• List the names and comments of all
clients who have viewed a property for
rent.
(clientNo,fName,lName(Client))
(clientNo,propertyNo,comment(Viewing))

28
 Outer join
• To display rows in the result that do not
have matching values in the join column,
use Outer join.

• R S
– (Left) outer join is join in which tuples
from R that do not have matching
values in common columns of S are
also included in result relation.

29
 Example - Left Outer join
• Produce a status report on property
viewings.

propertyNo,street,city(PropertyForRent)
Viewing

30
 Semijoin
• R F S
– Defines a relation that contains the tuples of
R that participate in the join of R with S.

 Can rewrite Semijoin using Projection and Join:

R FS = A(R F S)

31
 Example - Semijoin
• List complete details of all staff who work
at the branch in Glasgow.

Staff Staff.brancNo = Branch.branchNo and branch.city = ‘Glasgow’

Branch

32
 Division
• RS
– Defines a relation over the attributes C that
consists of set of tuples from R that match
combination of every tuple in S.

• Expressed using basic operations:

T1  C(R)
T2  C((S X T1) – R)
T  T1 – T2
33
 Example - Division
• Identify all clients who have viewed all
properties with three rooms.

(clientNo,propertyNo(Viewing))  (propertyNo(rooms = 3
(PropertyForRent)))

34
 Relational Calculus
• Relational calculus query specifies
what is to be retrieved rather than how
to retrieve it.
– No description of how to evaluate a query.

• In first-order logic (or predicate

calculus), predicate is a truth-valued
function with arguments.

• When we substitute values for the

arguments, function yields an
expression, called a proposition, which35
 Relational Calculus
• If predicate contains a variable (e.g. ‘x
is a member of staff’), there must be a
range for x.

• When we substitute some values of

this range for x, proposition may be
true; for other values, it may be false.

• When applied to databases, relational 36

calculus has forms: tuple and domain.
 Tuple Relational Calculus
• Interested in finding tuples for which a
predicate is true. Based on use of tuple
variables.

• Tuple variable is a variable that ‘ranges

over’ a named relation: ie., variable whose
only permitted values are tuples of the
relation.

• Specify range of a tuple variable S as the

Staff relation as: Staff(S) 37
•
Tuple Relational Calculus -
Example
• To find details of all staff earning more than £10,000:
{S | Staff(S)  S.salary > 10000}

• To find a particular attribute, such as salary, write:

{S.salary | Staff(S)  S.salary > 10000}

 means conjunction
Ú means disjunction
~ means negation

38
Tuple Relational Calculus
• Can use two quantifiers to tell how many
instances the predicate applies to:
– Existential quantifier $ (‘there exists’)
– Universal quantifier " (‘for all’)

• Tuple variables qualified by " or $ are

called bound variables, otherwise called free
variables.

39
 Tuple Relational Calculus
• Existential quantifier used in formulae
that must be true for at least one
instance, such as:

Staff(S) Ù ($B)(Branch(B) Ù (B.branchNo =

S.branchNo) Ù B.city = ‘London’)

• Means ‘There exists a Branch tuple

that has the same branchNo as the
branchNo of the current Staff tuple,
S, and is located in London’. 40
 Tuple Relational Calculus
• Universal quantifier is used in statements about
every instance, such as:
("B) (B.city  ‘Paris’)

• Means ‘For all Branch tuples, the address is not in

Paris’.

• Can also use ~($B) (B.city = ‘Paris’) which means

‘There are no branches with an address in Paris’.

41
 Tuple Relational Calculus
• Formulae should be unambiguous and make
sense.
• A (well-formed) formula is made out of
atoms:
• R(Si), where Si is a tuple variable and R is a
relation
• Si.a1 q Sj.a2
• Si.a1 q c

42
 Tuple Relational Calculus
• Can recursively build up formulae from
atoms:
• An atom is a formula
• If F1 and F2 are formulae, so are their
conjunction, F1 Ù F2; disjunction, F1 Ú F2;
and negation, ~F1
• If F is a formula with free variable X, then
($X)(F) and ("X)(F) are also formulae.

43
 Example - Tuple Relational
Calculus
a) List the names of all managers who earn
more than £25,000.

{S.fName, S.lName | Staff(S) 

S.position = ‘Manager’  S.salary > 25000}

b) List the staff who manage properties for

rent in Glasgow.

{S | Staff(S)  ($P) (PropertyForRent(P)  44

(P.staffNo = S.staffNo) Ù P.city = ‘Glasgow’)}

 Example - Tuple Relational
Calculus
c) List the names of staff who currently do not
manage any properties.

{S.fName, S.lName | Staff(S)  (~($P)

(PropertyForRent(P)(S.staffNo = P.staffNo)))}
Or
{S.fName, S.lName | Staff(S)  (P)
(~PropertyForRent(P) 
~(S.staffNo = P.staffNo)))}
45
 Example - Tuple Relational
Calculus
• List the names of clients who have viewed a
property for rent in Glasgow.

{C.fName, C.lName | Client(C) Ù (($V)($P)

(Viewing(V) Ù PropertyForRent(P) Ù (
C.clientNo = V.clientNo) Ù
(V.propertyNo=P.propertyNo)ÙP.city =‘Glasgow’))}

46
 Tuple Relational Calculus
• Expressions can generate an infinite set.
For example:
{S | ~Staff(S)}

• To avoid this, add restriction that all values

in result must be values in the domain of the
expression.

47
 Domain Relational Calculus
• Uses variables that take values from
domains instead of tuples of relations.

• If F(d1, d2, . . . , dn) stands for a formula

composed of atoms and d1, d2, . . . , dn
represent domain variables, then:
{d1, d2, . . . , dn | F(d1, d2, . . . , dn)}
is a general domain relational calculus expression.
48
 Example - Domain Relational
Calculus
a) Find the names of all managers who earn
more than £25,000.

{fN, lN | $sN, posn, sex, DOB, sal, bN)

(Staff (sN, fN, lN, posn, sex, DOB, sal, bN) 
posn = ‘Manager’  sal > 25000)}

49
 Example - Domain Relational
Calculus
b) List the staff who manage properties for
rent in Glasgow.

{sN, fN, lN, posn, sex, DOB, sal, bN |

($sN1,cty)(Staff(sN,fN,lN,posn,sex,DOB,sal,bN) 
(PropertyForRent(pN, st, cty, pc, typ, rms,
rnt,oN, sN1, bN1) Ù
(sN=sN1) Ù
cty=‘Glasgow’)}

50
 Example - Domain Relational
Calculus
c) List the names of staff who currently do
not manage any properties for rent.

{fN, lN | ($sN)
(Staff(sN, fN, lN, posn, sex, DOB, sal, bN) 
(~($sN1) (PropertyForRent(pN, st, cty, pc, typ,
rms, rnt,oN, sN1, bN1) Ù (sN =
sN1))))}

51
 Example - Domain Relational
Calculus
d) List the names of clients who have
viewed a property for rent in Glasgow.

{fN, lN | ($cN, cN1, pN, pN1, cty)

(Client(cN, fN, lN,tel, pT, mR) 
Viewing(cN1, pN1, dt, cmt) 
PropertyForRent(pN, st, cty, pc, typ,
rms, rnt,oN, sN, bN) Ù
(cN = cN1) Ù (pN = pN1) Ù cty = ‘Glasgow’)}

52
 Domain Relational Calculus
• When restricted to safe expressions, domain
relational calculus is equivalent to tuple
relational calculus restricted to safe expressions,
which is equivalent to relational algebra.

• Means every relational algebra expression has

an equivalent relational calculus expression, and
vice versa.

53
 Other Languages
• Transform-oriented languages are non-
procedural languages that use relations
to transform input data into required
outputs (e.g. SQL).

• Graphical languages provide user with

picture of the structure of the relation.
User fills in example of what is wanted
and system returns required data in that
format (e.g. QBE). 54
 Other Languages
• 4GLs can create complete customized
application using limited set of commands
in a user-friendly, often menu-driven
environment.

• Some systems accept a form of natural

language, sometimes called a 5GL,
although this development is still in an
early stage.
55