Relational Algebra

Maybe -- SQL
Confused by Normal Forms ?

3NF

BCNF

4NF

If a database doesn’t violate 4NF (BCNF) then it

doesn’t violate BCNF (3NF) !
 Natural Join
• Notation: R1 R2
• Input Schema: R1(A1, …, An), R2(B1, …, Bm)
• Output Schema: S(C1,…,Cp)
– Where {C1, …, Cp} = {A1, …, An} U {B1, …, Bm}
• Meaning: combine all pairs of tuples in R1 and R2
that agree on the attributes:
– {A1,…,An}  {B1,…, Bm} (called the join attributes)
• Equivalent to a cross product followed by selection
• Example Employee Dependents
 Natural Join Example
Employee
Name SSN
John 999999999
Tony 777777777

Dependents
SSN Dname
999999999 Emily
777777777 Joe
Employee Dependents =
Name, SSN, Dname( SSN=SSN2(Employee x SSN2, Dname(Dependents))
Name SSN Dname
John 999999999 Emily
Tony 777777777 Joe
 Natural Join
• R= A B S= B C
X Y Z U
X Z V W
Y Z Z V
Z V

A B C
• R S= X Z U
X Z V
Y Z U
Y Z V
Z V W
 Natural Join
• Given the schemas R(A, B, C, D), S(A, C, E),
what is the schema of R S ?

• Given R(A, B, C), S(D, E), what is R S ?

• Given R(A, B), S(A, B), what is R S ?

 Theta Join
• A join that involves a predicate
• Notation: R1  R2 where  is a condition
• Input schemas: R1(A1,…,An), R2(B1,…,Bm)
• Output schema: S(A1,…,An,B1,…,Bm)
• It’s a derived operator:
R1  R2 =   (R1 x R2)
 Equi-join
• Most frequently used in practice:

R1  R2
• Natural join is a particular case of equi-join
• A lot of research on how to do it efficiently
 Semi-join
• R S =  A1,…,An (R S)
• Where the schemas are:
– Input: R(A1,…An), S(B1,…,Bm)
– Output: T(A1,…,An)
 Semi-join
Applications in distributed databases:
• Product(pid, cid, pname, ...) at site 1
• Company(cid, cname, ...) at site 2
• Query: price>1000(Product) cid=cid Company

• Compute as follows:
T1 = price>1000(Product) site 1
T2 = Pcid(T1) site 1
send T2 to site 2 (T2 smaller than T1)
T3 = T2 Company site 2 (semijoin)
send T3 to site 1 (T3 smaller than Company)
Answer = T3 T1 site 1 (semijoin)
 Relational Algebra
• Five basic operators, many derived
• Combine operators in order to construct
queries: relational algebra expressions,
usually shown as trees
 Complex Queries
Product ( pid, name, price, category, maker-cid)
Purchase (buyer-ssn, seller-ssn, store, pid)
Company (cid, name, stock price, country)
Person(ssn, name, phone number, city)

Note:
•in Purchase: buyer-ssn, seller-ssn are foreign keys in Person, pid is foreign key in
Product;
•in Product maker-cid is a foreign key in Company

Find phone numbers of people who bought gizmos from Fred.

Find telephony products that somebody bought

 Exercises
Product ( pid, name, price, category, maker-cid)
Purchase (buyer-ssn, seller-ssn, store, pid)
Company (cid, name, stock price, country)
Person(ssn, name, phone number, city)

Ex #1: Find people who bought telephony products.

Ex #2: Find names of people who bought American products
Ex #3: Find names of people who bought American products and did
not buy French products
Ex #4: Find names of people who bought American products and they
live in Seattle.
Ex #5: Find people who bought stuff from Joe or bought products
from a company whose stock prices is more than $50.
 Operations on Bags
(and why we care)
• Union: {a,b,b,c} U {a,b,b,b,e,f,f} = {a,a,b,b,b,b,b,c,e,f,f}
– add the number of occurrences
• Difference: {a,b,b,b,c,c} – {b,c,c,c,d} = {a,b,b,d}
– subtract the number of occurrences
• Intersection: {a,b,b,b,c,c} {b,b,c,c,c,c,d} = {b,b,c,c}
– minimum of the two numbers of occurrences
• Selection: preserve the number of occurrences
• Projection: preserve the number of occurrences (no
duplicate elimination)
• Cartesian product, join: no duplicate elimination

Reading assignment: 5.3

 Summary of Relational Algebra
• Why bother ? Can write any RA expression
directly in C++/Java, seems easy.
• Two reasons:
– Each operator admits sophisticated
implementations (think of ,  C)
– Expressions in relational algebra can be
rewritten: optimized
 Glimpse Ahead: Efficient
Implementations of Operators
• (age >= 30 AND age <= 35)(Employees)
– Method 1: scan the file, test each employee
– Method 2: use an index on age
– Which one is better ? Well, depends…
• Employees Relatives
– Iterate over Employees, then over Relatives
– Iterate over Relatives, then over Employees
– Sort Employees, Relatives, do “merge-join”
– “hash-join”
– etc
 Glimpse Ahead: Optimizations
Product ( pid, name, price, category, maker-cid)
Purchase (buyer-ssn, seller-ssn, store, pid)
Person(ssn, name, phone number, city)

• Which is better:
price>100(Product) (Purchase city=seaPerson)
price>100(Product) Purchase) city=seaPerson
• Depends ! This is the optimizer’s job…
 Finally: RA has Limitations !
• Cannot compute “transitive closure”
Name1 Name2 Relationship

Fred Mary Father

Mary Joe Cousin

Mary Bill Spouse

Nancy Lou Sister

• Find all direct and indirect relatives of Fred

• Cannot express in RA !!! Need to write C program
 Outline
• Simple Queries in SQL (6.1)
• Queries with more than one relation (6.2)
• Subqueries (6.3)
• Duplicates (6.4)
 SQL Introduction
Standard language for querying and manipulating data

Structured Query Language

Many standards out there: SQL92, SQL2, SQL3, SQL99

Vendors support various subsets of these, but all of what we’ll
be talking about.
 SQL Introduction

Basic form: (many many more bells and whistles in addition)

Select
Select attributes
attributes
From
From relations
relations(possibly
(possiblymultiple,
multiple,joined)
joined)
Where
Where conditions
conditions(selections)
(selections)
 Selections
Company(sticker, name, country, stockPrice)

Find all US companies whose stock is > 50:

SELECT
SELECT **
FROM
FROM Company
Company
WHERE
WHERE country=“USA”
country=“USA”AND
ANDstockPrice
stockPrice>>50
50

Output schema: R(sticker, name, country, stockPrice)

 Selections
What you can use in WHERE:
attribute names of the relation(s) used in the FROM.
comparison operators: =, <>, <, >, <=, >=
apply arithmetic operations: stockprice*2
operations on strings (e.g., “||” for concatenation).
Lexicographic order on strings.
Pattern matching: s LIKE p
Special stuff for comparing dates and times.
 The LIKE operator
• s LIKE p: pattern matching on strings
• p may contain two special symbols:
– % = any sequence of characters
– _ = any single character

Company(sticker, name, address, country, stockPrice)

Find all US companies whose address contains “Mountain”:

SELECT
SELECT **
FROM
FROM Company
Company
WHERE
WHERE country=“USA”
country=“USA”AND
AND
address
addressLIKE
LIKE“%Mountain%”
“%Mountain%”
 Projections
Select only a subset of the attributes

SELECT
SELECT name,
name,stockPrice
stockPrice
FROM
FROM Company
Company
WHERE
WHERE country=“USA”
country=“USA”AND ANDstockPrice
stockPrice>>50
50

Input schema: Company(sticker, name, country, stockPrice)

Output schema: R(name, stock price)
 Projections
Rename the attributes in the resulting table

SELECT
SELECT name
nameAS
AScompany,
company,stockprice
stockpriceAS
ASprice
price
FROM
FROM Company
Company
WHERE
WHERE country=“USA”
country=“USA”AND
ANDstockPrice
stockPrice>>50
50

Input schema: Company(sticker, name, country, stockPrice)

Output schema: R(company, price)
 Ordering the Results
SELECT
SELECT name,
name,stockPrice
stockPrice
FROM
FROM Company
Company
WHERE
WHERE country=“USA”
country=“USA”AND ANDstockPrice
stockPrice>>50
50
ORDERBY
ORDERBY country,
country,name
name

Ordering is ascending, unless you specify the DESC keyword.

Ties are broken by the second attribute on the ORDERBY list, etc.
 Joins
Product (pname, price, category, maker)
Purchase (buyer, seller, store, product)
Company (cname, stockPrice, country)
Person(pname, phoneNumber, city)

Find names of people living in Seattle that bought gizmo

products, and the names of the stores they bought from

SELECT
SELECT pname,
pname,store
store
FROM
FROM Person,
Person,Purchase
Purchase
WHERE
WHERE pname=buyer
pname=buyerAND
ANDcity=“Seattle”
city=“Seattle”
AND
ANDproduct=“gizmo”
product=“gizmo”
 Disambiguating Attributes
Find names of people buying telephony products:

Product (name, price, category, maker)

Purchase (buyer, seller, store, product)
Person(name, phoneNumber, city)

SELECT
SELECT Person.name
Person.name
FROM
FROM Person,
Person,Purchase,
Purchase,Product
Product
WHERE
WHERE Person.name=Purchase.buyer
Person.name=Purchase.buyer
AND
AND Product=Product.name
Product=Product.name
AND
AND Product.category=“telephony”
Product.category=“telephony”
 Tuple Variables
Find pairs of companies making products in the same category

SELECT
SELECT product1.maker,
product1.maker,product2.maker
product2.maker
FROM
FROM Product
ProductAS
ASproduct1,
product1,Product
ProductAS
ASproduct2
product2
WHERE
WHERE product1.category=product2.category
product1.category=product2.category
AND
AND product1.maker
product1.maker<>
<>product2.maker
product2.maker

Product ( name, price, category, maker)

 Tuple Variables
Tuple variables introduced automatically by the system:

Product ( name, price, category, maker)

SELECT
SELECT namename
FROM
FROM Product
Product
WHERE
WHERE priceprice>>100
100
Becomes:

SELECT
SELECTProduct.name
Product.name
FROM
FROM Product
ProductAS
ASProduct
Product
WHERE
WHEREProduct.price
Product.price>>100
100

Doesn’t work when Product occurs more than once:

In that case the user needs to define variables explicitely.
 Meaning (Semantics) of SQL
Queries
SELECT a1, a2, …, ak
FROM R1 AS x1, R2 AS x2, …, Rn AS xn
WHERE Conditions

1. Nested loops:
Answer
Answer=={} {}
for
forx1
x1in
inR1
R1dodo
for
forx2
x2in
inR2
R2do do
…..
…..
for
forxn
xnin inRnRndo
do
ififConditions
Conditions
then
thenAnswer
Answer==Answer
AnswerUU{(a1,…,ak)
{(a1,…,ak)
return
returnAnswer
Answer
 Meaning (Semantics) of SQL
Queries
SELECT a1, a2, …, ak
FROM R1 AS x1, R2 AS x2, …, Rn AS xn
WHERE Conditions

2. Parallel assignment
Answer
Answer=={} {}
for
forall
allassignments
assignmentsx1
x1in
inR1,
R1,…,
…,xn
xnin
inRn
Rndo
do
ififConditions
Conditionsthen
thenAnswer
Answer==Answer
AnswerUU{(a1,…,ak)}
{(a1,…,ak)}
return
returnAnswer
Answer

Doesn’t impose any order !

Like Datalog
 Meaning (Semantics) of SQL
Queries
SELECT a1, a2, …, ak
FROM R1 AS x1, R2 AS x2, …, Rn AS xn
WHERE Conditions

3. Translation to Datalog: one rule

Answer(a ,…,akk)) 
Answer(a11,…,a  RR11(x
(x1111,…,x
,…,x1p1p),…,R
),…,Rnn(x
(xn1n1,…,x
,…,xnpnp),),Conditions
Conditions
 Meaning (Semantics) of SQL
Queries
SELECT a1, a2, …, ak
FROM R1 AS x1, R2 AS x2, …, Rn AS xn
WHERE Conditions

4. Translation to Relational algebra:

 a1,…,ak (  Conditions (R1 x R2 x … x Rn))

Select-From-Where queries are precisely Select-Project-Join

 First Unintuitive SQLism
SELECT R.A
FROM R, S, T
WHERE R.A=S.A OR R.A=T.A

Looking for R  (S  T)

But what happens if T is empty?

 Union, Intersection, Difference
(SELECT name
FROM Person
WHERE City=“Seattle”)

UNION

(SELECT name
FROM Person, Purchase
WHERE buyer=name AND store=“The Bon”)

Similarly, you can use INTERSECT and EXCEPT.

You must have the same attribute names (otherwise: rename).
 Exercises
Product ( pname, price, category, maker)
Purchase (buyer, seller, store, product)
Company (cname, stock price, country)
Person( per-name, phone number, city)

Ex #1: Find people who bought telephony products.

Ex #2: Find names of people who bought American products
Ex #3: Find names of people who bought American products and did
not buy French products
Ex #4: Find names of people who bought American products and they
live in Seattle.
Ex #5: Find people who bought stuff from Joe or bought products
from a company whose stock prices is more than $50.