4: Relational Algebra

By Vijay Trivedi
VIT Bhopal
Outline
• Structure of Relational Databases
• Database Schema
• Keys
• Schema Diagrams
• Relational Query Languages
• The Relational Algebra
Example of a Instructor Relation
attributes
(or columns)

tuples
(or rows)
Relation Schema and Instance
• A1, A2, …, An are attributes
• R = (A1, A2, …, An ) is a relation schema
• Example:
• instructor = (ID, name, dept_name, salary)
• A relation instance r defined over schema R is denoted by r (R).
• The current values a relation are specified by a table
• An element t of relation r is called a tuple and is represented by a
row in a table
Attributes
• The set of allowed values for each attribute is called the domain of
the attribute
• Attribute values are (normally) required to be atomic; that is,
indivisible
• The special value null is a member of every domain. Indicated that
the value is “unknown”
• The null value causes complications in the definition of many
operations
Relations are Unordered
• Order of tuples is irrelevant (tuples may be stored in an arbitrary
order)
• Example: instructor relation with unordered tuples
Database Schema
• Database schema -- is the logical structure of the database.
• Database instance -- is a snapshot of the data in the database at a
given instant in time.
• Example:
• schema: instructor (ID, name, dept_name, salary)
• Instance:
Keys
• Let K  R
• K is a superkey of R if values for K are sufficient to identify a unique
tuple of each possible relation r(R)
• Example: {ID} and {ID,name} are both superkeys of instructor.
• Superkey K is a candidate key if K is minimal
Example: {ID} is a candidate key for Instructor
• One of the candidate keys is selected to be the primary key.
• Which one?
• Foreign key constraint: Value in one relation must appear in another
• Referencing relation
• Referenced relation
• Example: dept_name in instructor is a foreign key from instructor
referencing department
Schema Diagram for University Database
Relational Query Languages
• Procedural versus non-procedural, or declarative
• “Pure” languages:
• Relational algebra
• Tuple relational calculus
• Domain relational calculus
• The above 3 pure languages are equivalent in computing power
• We will concentrate in this chapter on relational algebra
• Not Turing-machine equivalent
• Consists of 6 basic operations
Relational Algebra
• A procedural language consisting of a set of operations that take
one or two relations as input and produce a new relation as their
result.
• Six basic operators
• select: 
• project: 
• union: 
• set difference: –
• Cartesian product: x
• rename: 
Select Operation
• The select operation selects tuples that satisfy a given predicate.
• Notation:  p (r)
• p is called the selection predicate
• Example: select those tuples of the instructor relation where the
instructor is in the “Physics” department.
• Query
•
 dept_name=“Physics” (instructor)
•
• Result
Select Operation (Cont.)
• We allow comparisons using
• =, , >, . <. 
• in the selection predicate.
• We can combine several predicates into a larger predicate by using
the connectives:
•  (and),  (or),  (not)
• Example: Find the instructors in Physics with a salary greater $90,000,
we write:
•
 dept_name=“Physics”  salary > 90,000 (instructor)
•
• The select predicate may include comparisons between two
attributes.
• Example, find all departments whose name is the same as their building
name:
•  dept_name=building (department)
Project Operation
• A unary operation that returns its argument relation, with certain
attributes left out.
• Notation:
•  A1,A2,A3 ….Ak (r)
• where A1, A2, …, Ak are attribute names and r is a relation
name.
• The result is defined as the relation of k columns obtained by erasing
the columns that are not listed
• Duplicate rows removed from result, since relations are sets
Project Operation Example
• Example: eliminate the dept_name attribute of instructor
• Query:

ID, name, salary (instructor)

• Result:
Composition of Relational Operations
• The result of a relational-algebra operation is relation and therefore
of relational-algebra operations can be composed together into a
relational-algebra expression.
• Consider the query -- Find the names of all instructors in the Physics
department.
•
• name( dept_name =“Physics” (instructor))
•
• Instead of giving the name of a relation as the argument of the
projection operation, we give an expression that evaluates to a
relation.
Cartesian-Product Operation
• The Cartesian-product operation (denoted by X) allows us to
combine information from any two relations.
• Example: the Cartesian product of the relations instructor and
teaches is written as:
• instructor X teaches
• We construct a tuple of the result out of each possible pair of tuples:
one from the instructor relation and one from the teaches relation
(see next slide)
• Since the instructor ID appears in both relations we distinguish
between these attribute by attaching to the attribute the name of
the relation from which the attribute originally came.
• instructor.ID
• teaches.ID
The instructor X teaches table
Join Operation
• The Cartesian-Product
• instructor X teaches
• associates every tuple of instructor with every tuple of teaches.
• Most of the resulting rows have information about instructors who did NOT
teach a particular course.
• To get only those tuples of “instructor X teaches “ that pertain to
instructors and the courses that they taught, we write:
•  instructor.id = teaches.id (instructor x teaches ))
•
• We get only those tuples of “instructor X teaches” that pertain to
instructors and the courses that they taught.
• The result of this expression, shown in the next slide
Join Operation (Cont.)
• The table corresponding to:
•  instructor.id = teaches.id (instructor x teaches))
Join Operation (Cont.)
Union Operation
• The union operation allows us to combine two relations
• Notation: r  s
• For r  s to be valid.
• 1. r, s must have the same arity (same number of attributes)
• 2. The attribute domains must be compatible (example: 2nd
• column of r deals with the same type of values as does the
• 2nd column of s)
• Example: to find all courses taught in the Fall 2017 semester, or in the
Spring 2018 semester, or in both
course_id ( semester=“Fall” Λ year=2017 (section)) 
course_id ( semester=“Spring” Λ year=2018 (section))
Union Operation (Cont.)
• Result of:
course_id ( semester=“Fall” Λ year=2017 (section)) 
course_id ( semester=“Spring” Λ year=2018 (section))
Set-Intersection Operation
• The set-intersection operation allows us to find tuples that are in
both the input relations.
• Notation: r  s
• Assume:
• r, s have the same arity
• attributes of r and s are compatible
• Example: Find the set of all courses taught in both the Fall 2017 and
the Spring 2018 semesters.
• course_id ( semester=“Fall” Λ year=2017 (section)) 
course_id ( semester=“Spring” Λ year=2018 (section))
•
• Result
Set Difference Operation
• The set-difference operation allows us to find tuples that are in one
relation but are not in another.
• Notation r – s
• Set differences must be taken between compatible relations.
• r and s must have the same arity
• attribute domains of r and s must be compatible
• Example: to find all courses taught in the Fall 2017 semester, but not
in the Spring 2018 semester
course_id ( semester=“Fall” Λ year=2017 (section)) −
course_id ( semester=“Spring” Λ year=2018 (section))
The Assignment Operation
• It is convenient at times to write a relational-algebra expression by
assigning parts of it to temporary relation variables.
• The assignment operation is denoted by  and works like
assignment in a programming language.
• Example: Find all instructor in the “Physics” and Music department.

Physics   dept_name=“Physics” (instructor)

• Music   dept_name=“Music” (instructor)
• Physics  Music
•
• With the assignment operation, a query can be written as a
sequential program consisting of a series of assignments followed by
an expression whose value is displayed as the result of the query.
The Rename Operation
• The results of relational-algebra expressions do not have a name that
we can use to refer to them. The rename operator,  , is provided
for that purpose
• The expression:
• x (E)
• returns the result of expression E under the name x
• Another form of the rename operation:
• x(A1,A2, .. An) (E)
Division Operation
▪ Suited to queries that include the phrase “for all”.
▪ Let r and s be relations on schemas R and S respectively
rs
• R = (A1, …, Am , B1, …, Bn )
• S = (B1, …, Bn)
The result of r  s is a relation on schema
R – S = (A1, …, Am)
r  s = { t | t   R-S (r)   u  s ( tu  r ) }
* u representing any tuple in s
Where tu means the concatenation of a tuple t and u to
produce a single tuple
* for every tuple in R-S (called t), there are a set of tuples in R, such that for all tuples (such as
u) in s, the tu is a tuple in R.
Division Operation – Example
Relations r, s:
A B B
 1 1
 2
 3 2
 1 s
 1
 1
 3
 4
 6
e.g.
 1
 2 A is customer name

r  s: A r
B is branch-name
1and 2 here show two specific branch-
 names
(Find customers who have an account in all
 branches of the bank)
Another Division Example
Relations r, s:
A B C D E D E

 a  a 1 a 1
 a  a 1 b 1
 a  b 1 s
 a  a 1
 a  b 3
 a  a 1
 a  b 1
 a  b 1
r
e.g.
r  s: Students who have taken both
A B C "a” and “b” courses, with
instructor “1”
 a 
(Find students who have taken
 a  all courses given by instructor 1)
How Division Works
• Example of writing division with set difference, projection,
and assignments: r  s
temp1  R-S (r )
temp2  R-S ((temp1 x s ) – R-S,S (r ))
result = temp1 – temp2

• The result to the right of the  is assigned to relation

variable on the left of the  .
• May use variables in subsequent expressions

* Try executing the above query at home on the previous example, to convince
yourself about its equivalence to the division operation
Equivalent Queries
• There is more than one way to write a query in relational algebra.
• Example: Find information about courses taught by instructors in the
Physics department with salary greater than 90,000
• Query 1
•  dept_name=“Physics”  salary > 90,000 (instructor)
•
• Query 2
•  dept_name=“Physics” ( salary > 90.000 (instructor))
•
• The two queries are not identical; they are, however, equivalent --
they give the same result on any database.
Equivalent Queries
Thank you