Chapter 3: Formal

Relational Query Languages

Chapter 3: Formal Relational Query Languages

• Relational Algebra
• Tuple Relational Calculus
• Domain Relational Calculus
Relational Algebra
• Procedural language
• Six basic operators
• select: 
• project: 
• union: 
• set difference: –
• Cartesian product: x
• rename: 
• The operators take one or two relations as inputs
and produce a new relation as a result.
Select Operation – Example
 Relation r

A=B ^ D > 5 (r)

 Select Operation
• Notation:  p(r)
• p is called the selection predicate
• Defined as:
p(r) = {t | t  r and p(t)}
Where p is a formula in propositional calculus consisting of terms
connected by :  (and),  (or),  (not)
Each term is one of:
<attribute> op <attribute> or <constant>
where op is one of: =, , >, . <. 
• Example of selection:
 dept_name=“Physics”(instructor)
• Có nghĩa là trong table instructor trong bảng dept_name lấy ra
physics
Project Operation – Example
• Relation r:


A,C (r)
 Project Operation
• Notation:  A1 , A2 ,, Ak (r )

where A1, A2 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
Example: given instructor(ID, name, dept_name, salary)
To eliminate the dept_name attribute of instructor.
ID, name, salary (instructor)
Cho ra 3 cột id name salary
Union Operation – Example
• Relations r, s:

 r  s:
Union Operation
• Notation: r  s
• Example: to find all courses taught in the Fall 2009 semester, or in
the Spring 2010 semester, or in both
• Tra vào bảng section lấy học kì dạy ở mùa thu và năm 2009 xuất
ra course id hợp với course id của mùa xuân 2010
•
course_id ( semester=“Fall” Λ year=2009 (section)) 

• course_id ( semester=“Spring” Λ year=2010 (section))

Set difference of two relations
• Relations r, s:

 r – s:
 Set Difference Operation
• Notation r – s
• Example: to find all courses taught in the Fall 2009 semester,
but not in the Spring 2010 semester
course_id ( semester=“Fall” Λ year=2009 (section)) −
course_id ( semester=“Spring” Λ year=2010 (section))
• Dạy ở học kì thu 2009 nhưng không dạy ở học kì xuân 2010
Cartesian-Product Operation – Example

 Relations r, s:

 r x s:
Cartesian-Product Operation

• Notation r x s
• Defined as:
r x s = {t q | t  r and q  s}

• Assume that attributes of r(R) and s(S) are disjoint.

(That is, R  S = ).
• If attributes of r(R) and s(S) are not disjoint, then
renaming must be used.
Composition of Operations

• Can build expressions using multiple operations

• Example: A=C(r x s)

•r x s

• A=C(r x s)
• Chọn A=C
 Rename Operation
• Allows us to name, and therefore to refer to, the results of
relational-algebra expressions.
• Allows us to refer to a relation by more than one name.
• Example:
 x (E)

returns the expression E under the name X

• If a relational-algebra expression E has arity n, then
 x ( A1 , A2 ,..., An ) ( E )
returns the result of expression E under the name X, and with the
attributes renamed to A1 , A2 , …., An .
 Example Query
• given instructor(ID, name, dept_name, salary). Find the
largest salary in the university
• Step 1: find instructor salaries that are less than some
other instructor salary (i.e. not maximum)
• using a copy of instructor under a new name d
instructor.salary ( instructor.salary < d,salary (instructor x d (instructor)))

• Step 2: Find the largest salary

salary (instructor) –
instructor.salary ( instructor.salary < d,salary (instructor x d (instructor)))
Example Queries
Given instructor(ID, name, dept_name, salary) and
teaches(ID, courseID, sec_ID, semester, year)
•Find the names of all instructors in the Physics department, along
with the course_id of all courses they have taught

 Query 1
instructor.ID,course_id (dept_name=“Physics” (
 instructor.ID=teaches.ID (instructor x teaches)))

 Query 2
instructor.ID,course_id (instructor.ID=teaches.ID (
 dept_name=“Physics” (instructor) x teaches))
 Formal Definition
• A basic expression in the relational algebra consists of either one of
the following:
• A relation in the database
• A constant relation
• Let E1 and E2 be relational-algebra expressions; the following are all
relational-algebra expressions:
• E 1  E2
• E1 – E2
• E 1 x E2
• p (E1), P is a predicate on attributes in E1
• s(E1), S is a list consisting of some of the attributes in E1
•  x (E1), x is the new name for the result of E1
Additional Operations
We define additional operations that do not add any power to
the
relational algebra, but that simplify common queries.

• Set intersection
• Natural join
• Assignment
• Outer join
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)
Set-Intersection Operation – Example

• Relation r, s:

•rs
 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))
Natural Join Example
• Relations r, s:

 r s
 Natural Join and Theta Join
• Find the names of all instructors in the Comp. Sci. department
together with the course titles of all the courses that the instructors
teach
•  name, title ( dept_name=“Comp. Sci.” (instructor teaches course))
• Natural join is associative
• (instructor teaches) course is equivalent to
instructor (teaches course)
• Natural join is commutative
• instruct teaches is equivalent to
teaches instructor
• The theta join operation r  s is defined as
• r  s =  (r x s)
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.
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
Outer Join – Example
• Relation instructor1

• Relation teaches1
Outer Join – Example
• Join (inner join)
instructor teaches
ID name dept_name course_id
10101 Srinivasan Comp. Sci. CS-101
12121 Wu Finance FIN-201

 Left Outer Join

instructor teaches

ID name dept_name course_id

10101 Srinivasan Comp. Sci. CS-101
12121 Wu Finance FIN-201
15151 Mozart Music null
Outer Join – Example
 Right Outer Join
instructor teaches

 Full Outer Join

instructor teaches
ID name dept_name course_id
10101 Srinivasan Comp. Sci. CS-101
12121 Wu Finance FIN-201
15151 Mozart Music null
76766 null null BIO-101
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)
Division Operator
• Given relations r(R) and s(S), such that S  R, r  s is the largest
relation t(R-S) such that
txsr
• E.g. let r(ID, course_id) = ID, course_id (takes ) and
s(course_id) = course_id (dept_name=“Biology”(course )
then r  s gives us students who have taken all courses in the
Biology department
• Can 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.
Schema Diagram for University Database
Extended Relational-Algebra-Operations

• Generalized Projection
• Aggregate Functions
Generalized Projection
• Extends the projection operation by allowing arithmetic
functions to be used in the projection list.
 F1 , F2 ,..., Fn ( Eexpression
E is any relational-algebra )
• Each of F1, F2, …, Fn are arithmetic expressions involving
constants and attributes in the schema of E.
• Given relation instructor(ID, name, dept_name, salary)
where salary is annual salary, get the same information
but with monthly salary
ID, name, dept_name, salary/12 (instructor)
Aggregate Functions and Operations
• Aggregation function takes a collection of values and returns a
single value as a result.
avg, min, max, sum, count
• Aggregate operation in relational algebra

G1 ,G2 ,,Gn F F ( A ),F ( A ,, F ( A ) ( E )

1 1 2 2 n n

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
• Note: Some books/articles use  or (Calligraphic G)
F : pronounced script F
Aggregate Operation – Example
• Relation r:
A B C

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

 F sum(c (r)
)
sum(c )

27
Aggregate Operation – Example
• Find the average salary in each department
dept_name Favg(salary) (instructor)

avg_salary
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

dept_name Favg(salary) as avg_sal (instructor)

Modification of the Database
• The content of the database may be modified
using the following operations:
• Deletion
• Insertion
• Updating
• All these operations can be expressed using
the assignment operator
Given a banking database:
BRANCH(branch name, branch city, assets)
CUSTOMER (customer name, customer street, customer city)
LOAN (loan number, branch name, amount)
BORROWER (customer name, loan number)
ACCOUNT (account number, branch name, balance)
DEPOSITOR (customer name, account number)
Deletion
• A delete request is expressed similarly to a query,
except instead of displaying tuples to the user,
the selected tuples are removed from the
database.
• Can delete only whole tuples; cannot delete
values on only particular attributes
• A deletion is expressed in relational algebra by:
rr–E
where r is a relation and E is a relational algebra
query.
Deletion Examples
• Delete all account records in the Perryridge branch.
account  account – branch_name = “Perryridge” (account )

 Delete all loan records with amount in the range of 0 to 50

loan  loan – amount 0and amount  50 (loan)
 Delete all accounts at branches located in Needham.
r1  branch_city = “Needham” (account branch )
r2   account_number, branch_name, balance (r1)
r3   customer_name, account_number (r2 depositor)
account  account – r2
depositor  depositor – r3
Insertion

• To insert data into a relation, we either:

• specify a tuple to be inserted
• write a query whose result is a set of tuples to be
inserted
• in relational algebra, an insertion is expressed by:
r r  E
where r is a relation and E is a relational algebra
expression.
• The insertion of a single tuple is expressed by letting E
be a constant relation containing one tuple.
Insertion Examples
• Insert information in the database specifying that Smith has $1200
in account A-973 at the Perryridge branch.

account  account  {(“A-973”, “Perryridge”, 1200)}

depositor  depositor  {(“Smith”, “A-973”)}

 Provide as a gift for all loan customers in the Perryridge

branch, a $200 savings account. Let the loan number serve
as the account number for the new savings account.

r1  (branch_name = “Perryridge” (borrower loan))

account  account  loan_number, branch_name, 200 (r1)
depositor  depositor  customer_name, loan_number (r1)
Updating
• A mechanism to change a value in a tuple without
charging all values in the tuple
• Use the generalized projection operator to do this task
r   F ,F ,,F , (r )
1 2 l

• Each Fi is either
• the i th attribute of r, if the i th attribute is not updated,
or,
• if the attribute is to be updated Fi is an expression,
involving only constants and the attributes of r, which
gives the new value for the attribute
Update Examples
• Make interest payments by increasing all balances by 5
percent.

account   account_number, branch_name, balance * 1.05 (account)

 Pay all accounts with balances over $10,000 6 percent

interest and pay all others 5 percent

account   account_number, branch_name, balance * 1.06 ( BAL  10000 (account ))

  account_number, branch_name, balance * 1.05 (BAL  10000 (account))
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)

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.

 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))
End of Chapter 6
 Multiset Relational Algebra
• Pure relational algebra removes all duplicates
• e.g. after projection
• Multiset relational algebra retains duplicates, to match
SQL semantics
• SQL duplicate retention was initially for efficiency, but is
now a feature
• Multiset relational algebra defined as follows
• selection: has as many duplicates of a tuple as in the
input, if the tuple satisfies the selection
• projection: one tuple per input tuple, even if it is a
duplicate
• cross product: If there are m copies of t1 in r, and n
copies of t2 in s, there are m x n copies of t1.t2 in r x s
• Other operators similarly defined
• E.g. union: m + n copies, intersection: min(m, n) copies
difference: min(0, m – n) copies