Adapted for SEN2104 – DBMS

Week 4: Relational Algebra (Part II)

Database System Concepts

©Silberschatz, Korth and Sudarshan
 Additional Operations

▪ Additional Operations

▪ Set intersection
▪ Natural join
▪ Division
▪ Assignment

▪ All above, other than aggregation, can be expressed using basic

operations we have seen earlier

2
 Set-Intersection Operation
▪ Notation: r  s
▪ Defined as:
▪ r  s = { t | t  r and t  s }
▪ Assume:
▪ r, s have the same arity
▪ attributes of r and s are compatible
▪ Note: r  s = r – (r – s)

3
 Set-Intersection Operation – Example

▪ Relation r, s: A B A B

 1  2
 2  3
 1
s
r

▪ rs
A B

 2

4
 Natural-Join Operation
▪ Notation: r s
▪ Let r and s be relations on schemas R and S respectively.
Then, r s is a relation on schema R  S obtained as follows:
▪ Consider each pair of tuples tr from r and ts from s.
▪ If tr and ts have the same value on each of the attributes in R  S, add a
tuple t to the result, where
▪ t has the same value as tr on r
▪ t has the same value as ts on s
▪ Example:
R = (A, B, C, D)
S = (E, B, D)
▪ Result schema = (A, B, C, D, E)
▪ r s is defined as:
r.A, r.B, r.C, r.D, s.E (r.B = s.B  r.D = s.D (r x s))

5
 Natural Join Operation – Example
▪ Relations r, s:

A B C D B D E

 1  a 1 a 
 2  a 3 a 
 4  b 1 a 
 1  a 2 b 
 2  b 3 b 
r s

▪ r s
A B C D E
 1  a 
 1  a 
 1  a 
 1  a 
 2  b 

6
 Division Operation

▪ Notation: rs
▪ Suited to queries that include the phrase “for all”.
▪ Let r and s be relations on schemas R and S respectively
where
▪ 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 ) }
Where tu means the concatenation of tuples t and u to
produce a single tuple

7
 Division Operation – Example I
▪ Relations r, s:
A B B

 1 1
 2
 3 2
 1 s
 1
 1
 3
 4
 6
 1
 2
r

▪ r  s: A


 8
 Division Operation – Example II
▪ 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

▪ r  s: A B C

 a 
 a 

9
 Division Operation – Example III

sno pno pno pno pno

s1 p1 p2 p2 p1
s1 p2 b1 p4 p2
s1 p3 b2 p4
s1 p4 b3
s2 p1 sno
s2 p2 s1
s3 p2 s2 sno
s4 p2 s3 s1 sno
s4 p4 s4 s4 s1

a a  b1 a  b2 a  b3

10
10
 Assignment Operation
▪ The assignment operation () provides a convenient way to express
complex queries.
▪ Write query as a sequential program consisting of
▪ a series of assignments
▪ followed by an expression whose value is displayed as a result of
the query.
▪ Assignment must always be made to a temporary relation variable.
▪ Example: Write r  s as
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 the relation variable on
the left of the .
▪ May use variable in subsequent expressions.

11
Banking Enterprise Schema Diagram

branch (branch-name, branch-city, assets)

customer (customer-name, customer-street, customer-city)
account (account-number, branch-name, balance)
loan (loan-number, branch-name, amount)
depositor (customer-name, account-number)
borrower (customer-name, loan-number)

12
12
 Bank Example Queries
▪ Find the names of all customers who have a loan and an account at
bank.

customer_name (borrower)  customer_name (depositor)

▪ Find the name of all customers who have a loan at the bank and the
loan amount.

customer_name, loan_number, amount (borrower loan)

13
 Bank Example Queries
▪ Find all customers who have an account from at least the “Downtown”
and the “Uptown” branches.
▪ Query 1

customer_name (branch_name = “Downtown” (depositor account )) 

customer_name (branch_name = “Uptown” (depositor account))

▪ Query 2
customer_name, branch_name (depositor account)
 temp(branch_name) ({(“Downtown” ), (“Uptown” )})

Note that Query 2 uses a constant relation.

14
 Bank Example Queries
▪ Find all customers who have an account at all branches located in
Brooklyn city.

customer_name, branch_name (depositor account)

 branch_name (branch_city = “Brooklyn” (branch))

15
Extended Relational Algebra Operations

▪ Generalized Projection
▪ Aggregate Functions
▪ Outer Join

16
 Generalized Projection
▪ Extends the projection operation by allowing arithmetic functions to be
used in the projection list.

F1, F2, …, Fn (E)

▪ E is any relational-algebra expression
▪ Each of F1, F2, …, Fn are are arithmetic expressions involving constants
and attributes in the schema of E.
▪ Given relation credit_info(customer_name, limit, credit_balance), find
how much more each person can spend:
customer_name, limit – credit_balance as credit_available (credit_info)

credit_info result
17
 Aggregate Functions and Operations
▪ Aggregation function takes a collection of values and returns a single
value as a result.
avg: average value
min: minimum value
max: maximum value
sum: sum of values
count: number of values
▪ Aggregate operation in relational algebra

E is any relational-algebra expression

▪ G1, G2 …, Gn is a list of attributes on which to group (can be empty)
▪ Each Fi is an aggregate function
▪ Each Ai is an attribute name

18
 Aggregate Operation – Example
▪ Relation r:
A B C

  7
  7
  3
  10

▪ g sum(c) (r) sum(C)

27

19
 Aggregate Operation – Example
▪ Relation r:
A B C

  7
  7
  3
  10

▪ a g sum(c) (r) A sum(C)

 14
 13

20
 Aggregate Operation – Example
▪ Relation account grouped by branch-name:

branch_name account_number balance

Perryridge A-102 400
Perryridge A-201 900
Brighton A-217 750
Brighton A-215 750
Redwood A-222 700

branch_name g sum(balance) (account)

branch_name sum(balance)
Perryridge 1300
Brighton 1500
Redwood 700

21
 Aggregate Functions (Cont.)
▪ Result of aggregation does not have a name
▪ Can use rename operation to give it a name
▪ For convenience, we permit renaming as part of aggregate
operation

branch_name g sum(balance) as sum_balance (account)

22
 Outer Join
▪ An extension of the join operation that avoids loss of information.
▪ Computes the join and then adds tuples form one relation that does not
match tuples in the other relation to the result of the join.
▪ Uses null values:
▪ null signifies that the value is unknown or does not exist
▪ All comparisons involving null are (roughly speaking) false by
definition.
▪ We shall study precise meaning of comparisons with nulls later

23
 Outer Join – Example
▪ Relation loan

loan_number branch_name amount

L-170 Downtown 3000
L-230 Redwood 4000
L-260 Perryridge 1700

▪ Relation borrower

customer_name loan_number
Jones L-170
Smith L-230
Hayes L-155

24
 Outer Join – Example
▪ Join

loan borrower

loan_number branch_name amount customer_name

L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith

▪ Left Outer Join

loan borrower
loan_number branch_name amount customer_name
L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-260 Perryridge 1700 null

25
 Outer Join – Example
▪ Right Outer Join
loan borrower

loan_number branch_name amount customer_name

L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-155 null null Hayes

▪ Full Outer Join

loan borrower

loan_number branch_name amount customer_name

L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-260 Perryridge 1700 null
L-155 null null Hayes

26
 Null Values
▪ It is possible for tuples to have a null value, denoted by null, for some
of their attributes
▪ null signifies an unknown value or that a value does not exist.
▪ The result of any arithmetic expression involving null is null.
▪ Aggregate functions simply ignore null values (as in SQL)
▪ For duplicate elimination and grouping, null is treated like any other
value, and two nulls are assumed to be the same (as in SQL)

27
 Null Values
▪ Comparisons with null values return the special truth value: unknown
▪ If false was used instead of unknown, then not (A < 5)
would not be equivalent to A >= 5
▪ Three-valued logic using the truth value unknown:
▪ OR: (unknown or true) = true,
(unknown or false) = unknown
(unknown or unknown) = unknown
▪ AND: (true and unknown) = unknown,
(false and unknown) = false,
(unknown and unknown) = unknown
▪ NOT: (not unknown) = unknown
▪ In SQL “P is unknown” evaluates to true if predicate P evaluates to
unknown
▪ Result of select predicate is treated as false if it evaluates to unknown

28
 Exercises
Given relational schema:
Sailor (sid, sname, city, birthdate)
Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)

1) Find the names of sailors who’ve reserved boat #103.

2) Find the names of sailors who’ve reserved a red boat.
3) Find the sailors who’ve reserved a red or a green boat.
4) Find the sailors who’ve reserved a red and a green boat.
5) Find the names of sailors who’ve reserved all boats.

30
1) Find the names of sailors who’ve reserved boat #103

Solution 1: πsname((σbid = 103 SailorBoat) ⋈ Sailor)

Solution 2: ρtemp1(σbid = 103 (SailorBoat))

ρtemp2(temp1⋈ Sailor)
πsname(temp2)

Solution 3: πsname(σbid = 103 (SailorBoat ⋈ Sailor))

Sailor (sid, sname, city, birthdate)

Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)
31
2) Find the names of sailors who’ve reserved a red boat

▪ Boat (bid, bname, color)

▪ Information about boat color only available in Boat relation; so need an
extra join:

πsname((σcolor = ‘red’ Boat) ⋈ SailorBoat ⋈ Sailor)

A more efficient solution -- why more efficient?

πsname(πsid(πbid(σcolor = ‘red’ Boat) ⋈ SailorBoat) ⋈ Sailor)

A query optimizer can find this, given the first solution!

Sailor (sid, sname, city, birthdate)

Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)
32
3) Find the sailors who’ve reserved a red or a green boat

▪ Can identify all red or green boats, then find sailors who’ve reserved one
of these boats:

ρTempBoats(σcolor = ‘red’  color = ‘green’ (Boat))

πsname(TempBoats ⋈ SailorBoat ⋈ Sailor)

What happens if  is replaced by  in this query?

Sailor (sid, sname, city, birthdate)

Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)
33
4) Find the sailors who’ve reserved a red and a green boat

▪ Previous approach won’t work! Why?

▪ Logically incorrect, an attribute can’t contain two different values
at the same time.

▪ Solution: Must identify sailors who’ve reserved red boats and

sailors who’ve reserved green boats.

▪ Then find the intersection (note that sid is a key for Sailor relation).

Sailor (sid, sname, city, birthdate)

Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)
34
4) Find the sailors who’ve reserved a red and a green boat

ρTempRed(πsid(σcolor = ‘red’ (Boat) ⋈ SailorBoat))

ρTempGreen(πsid(σcolor = ‘green’ (Boat) ⋈ SailorBoat))
πsname((TempRed ∩ TempGreen) ⋈ Sailor)

Sailor (sid, sname, city, birthdate)

Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)
35
5) Find the names of sailors who’ve reserved all boats

▪ Uses division; schemas of the input relations to division (/ or )

must be carefully chosen:

ρTempSids(πsid, bid(SailorBoat)  πbid(Boat))

πsname(TempSids ⋈ Sailor)

Sailor (sid, sname, city, birthdate)

Boat (bid, bname, color)
SailorBoat (sid, bid, reservationdate)
36