Introduction to Database Systems

CSE 444

Lecture 3: SQL (part 2)

Magda Balazinska - CSE 444, Fall 2010

 Outline
•  Aggregations (6.4.3 – 6.4.6)
•  Examples, examples, examples…
•  Nulls (6.1.6 - 6.1.7) [Old edition: 6.1.5-6.1.6]
•  Outer joins (6.3.8)

Magda Balazinska - CSE 444, Fall 2010

 Aggregation
SELECT avg(price) SELECT count(*)
FROM Product FROM Product
WHERE maker=‘Toyota’ WHERE year > 1995

SQL supports several aggregation operations:

sum, count, min, max, avg

Except count, all aggregations apply to a single attribute

Magda Balazinska - CSE 444, Fall 2010
 Aggregation: Count
COUNT applies to duplicates, unless otherwise stated:

SELECT Count(category) same as Count(*)

FROM Product
WHERE year > 1995

We probably want:

SELECT Count(DISTINCT category)

FROM Product
WHERE year > 1995
Magda Balazinska - CSE 444, Fall 2010
 More Examples
Purchase(product, date, price, quantity)

SELECT Sum(price * quantity)

FROM Purchase
What do
SELECT Sum(price * quantity) they mean ?
FROM Purchase
WHERE product = ‘bagel’

Magda Balazinska - CSE 444, Fall 2010

 Simple Aggregations
Purchase Product Price Quantity
Bagel 3 20
Bagel 1.50 20
Banana 0.5 50
Banana 2 10
Banana 4 10
SELECT Sum(price * quantity)
FROM Purchase 90 (= 60+30)
WHERE product = ‘Bagel’
Magda Balazinska - CSE 444, Fall 2010
 Grouping and Aggregation
Purchase(product, price, quantity)

Find total quantities for all sales over $1, by product.

SELECT product, Sum(quantity) AS TotalSales

FROM Purchase
WHERE price > 1
GROUP BY product

Let’s see what this means…

Magda Balazinska - CSE 444, Fall 2010
 Grouping and Aggregation

1. Compute the FROM and WHERE clauses.

2. Group by the attributes in the GROUPBY

3. Compute the SELECT clause:

grouped attributes and aggregates.

Magda Balazinska - CSE 444, Fall 2010

1&2. FROM-WHERE-GROUPBY

Product Price Quantity

Bagel 3 20
Bagel 1.50 20
Banana 0.5 50
Banana 2 10
Banana 4 10
Magda Balazinska - CSE 444, Fall 2010
 3. SELECT
Product Price Quantity
Bagel 3 20 Product TotalSales
Bagel 1.50 20 Bagel 40
Banana 0.5 50 Banana 20
Banana 2 10
Banana 4 10

SELECT product, Sum(quantity) AS TotalSales

FROM Purchase
WHERE price > 1
GROUP BY product
 GROUP BY v.s. Nested Queries
SELECT product, Sum(quantity) AS TotalSales
FROM Purchase
WHERE price > 1
GROUP BY product

SELECT DISTINCT x.product, (SELECT Sum(y.quantity)

FROM Purchase y
WHERE x.product = y.product
AND price > 1)
AS TotalSales
FROM Purchase x
WHERE price > 1
Why twice ?
 Another Example
What does
it mean ?

SELECT product,
sum(quantity) AS SumQuantity,
max(price) AS MaxPrice
FROM Purchase
GROUP BY product

Magda Balazinska - CSE 444, Fall 2010

 HAVING Clause
Same query as earlier, except that we consider only products
that had at least 30 sales.

SELECT product, Sum(quantity)

FROM Purchase
WHERE price > 1
GROUP BY product
HAVING Sum(quantity) > 30

HAVING clause contains conditions on aggregates.

Magda Balazinska - CSE 444, Fall 2010
 General form of Grouping
and Aggregation
SELECT S
FROM R1,…,Rn
WHERE C1
GROUP BY a1,…,ak Why ?
HAVING C2

S = may contain attributes a1,…,ak and/or any

aggregates but NO OTHER ATTRIBUTES
C1 = is any condition on the attributes in R1,…,Rn
C2 = is any condition on aggregate expressions
and on attributes a1,…,ak
 General form of Grouping
and Aggregation
SELECT S
FROM R1,…,Rn
WHERE C1
GROUP BY a1,…,ak
HAVING C2
Evaluation steps:
1.  Evaluate FROM-WHERE, apply condition C1
2.  Group by the attributes a1,…,ak
3.  Apply condition C2 to each group (may have aggregates)
4.  Compute aggregates in S and return the result
Magda Balazinska - CSE 444, Fall 2010
 Advanced SQLizing
1.  Getting around INTERSECT and EXCEPT

2.  Unnesting Aggregates

3.  Finding witnesses

Magda Balazinska - CSE 444, Fall 2010

 INTERSECT and EXCEPT: not in some DBMSs

INTERSECT and EXCEPT:

Can unnest.
SELECT R.A, R.B How ?
(SELECT R.A, R.B
FROM R) FROM R
INTERSECT WHERE
(SELECT S.A, S.B EXISTS(SELECT *
FROM S) FROM S
WHERE R.A=S.A and R.B=S.B)
(SELECT R.A, R.B SELECT R.A, R.B
FROM R) FROM R
EXCEPT WHERE
(SELECT S.A, S.B NOT EXISTS(SELECT *
FROM S) FROM S
WHERE R.A=S.A and R.B=S.B)
 Unnesting Aggregates
Product ( pname, price, company)
Company(cname, city)
Find the number of companies in each city

SELECT DISTINCT city, (SELECT count(*)

FROM Company Y
WHERE X.city = Y.city)
FROM Company X

SELECT city, count(*) Equivalent queries

FROM Company Note: no need for DISTINCT
GROUP BY city (DISTINCT is the same as GROUP BY)
Magda Balazinska - CSE 444, Fall 2010
 Unnesting Aggregates
Product ( pname, price, company) What if there
Company(cname, city) are no products
for a city?
Find the number of products made in each city
SELECT DISTINCT X.city, (SELECT count(*)
FROM Product Y, Company Z
WHERE Z.cname=Y.company
AND Z.city = X.city)
FROM Company X

SELECT X.city, count(*)

FROM Company X, Product Y They are NOT
WHERE X.cname=Y.company equivalent !
GROUP BY X.city (WHY?)
 More Unnesting
Author(login,name)
Wrote(login,url)
This is
•  Find authors who wrote ≥ 10 documents:
SQL by
•  Attempt 1: with nested queries a novice
SELECT DISTINCT Author.name
FROM Author
WHERE (SELECT count(Wrote.url)
FROM Wrote
WHERE Author.login=Wrote.login)
> 10

Magda Balazinska - CSE 444, Fall 2010

 More Unnesting
•  Find all authors who wrote at least 10 documents:
•  Attempt 2: SQL style (with GROUP BY)

SELECT Author.name
FROM Author, Wrote This is
WHERE Author.login=Wrote.login SQL by
GROUP BY Author.name an expert
HAVING count(wrote.url) > 10

Magda Balazinska - CSE 444, Fall 2010

 Finding Witnesses

Store(sid, sname)
Product(pid, pname, price, sid)

For each store,

find its most expensive products

Magda Balazinska - CSE 444, Fall 2010

 Finding Witnesses

Finding the maximum price is easy…

SELECT Store.sid, max(Product.price)

FROM Store, Product
WHERE Store.sid = Product.sid
GROUP BY Store.sid

But we need the witnesses, i.e. the products with max price

Magda Balazinska - CSE 444, Fall 2010

 Finding Witnesses
To find the witnesses, compute the maximum price
in a subquery

SELECT Store.sname, Product.pname

FROM Store, Product,
(SELECT Store.sid AS sid, max(Product.price) AS p
FROM Store, Product
WHERE Store.sid = Product.sid
GROUP BY Store.sid) X
WHERE Store.sid = Product.sid
and Store.sid = X.sid and Product.price = X.p

Magda Balazinska - CSE 444, Fall 2010

 Finding Witnesses
There is a more concise solution here:

SELECT Store.sname, x.pname

FROM Store, Product x
WHERE Store.sid = x.sid and
x.price >=
ALL (SELECT y.price
FROM Product y
WHERE Store.sid = y.sid)

Magda Balazinska - CSE 444, Fall 2010

 NULLS in SQL
•  Whenever we don’t have a value, we can put a NULL
•  Can mean many things:
–  Value does not exists
–  Value exists but is unknown
–  Value not applicable
–  Etc.
•  The schema specifies for each attribute if can be null
(nullable attribute) or not
•  How does SQL cope with tables that have NULLs ?

Magda Balazinska - CSE 444, Fall 2010

 Null Values
•  If x= NULL then 4*(3-x)/7 is still NULL

•  If x= NULL then x=‘Joe’ is UNKNOWN

•  In SQL there are three boolean values:
FALSE = 0
UNKNOWN = 0.5
TRUE = 1

Magda Balazinska - CSE 444, Fall 2010

 Null Values
•  C1 AND C2 = min(C1, C2)
•  C1 OR C2 = max(C1, C2)
•  NOT C1 = 1 – C1

SELECT * E.g.
FROM Person age=20
WHERE (age < 25) AND height=NULL
(height > 6 OR weight > 190) weight=200

Rule in SQL: include only tuples that yield TRUE

Magda Balazinska - CSE 444, Fall 2010

 Null Values
Unexpected behavior:

SELECT *
FROM Person
WHERE age < 25 OR age >= 25

Some Person tuples are not included !

Magda Balazinska - CSE 444, Fall 2010

 Null Values
Can test for NULL explicitly:
–  x IS NULL
–  x IS NOT NULL

SELECT *
FROM Person
WHERE age < 25 OR age >= 25 OR age IS NULL

Now it includes all Person tuples

Magda Balazinska - CSE 444, Fall 2010
 Outerjoins
Product(name, category)
Purchase(prodName, store)

SELECT Product.name, Purchase.store

An “inner join”: FROM Product, Purchase
WHERE Product.name = Purchase.prodName
Same as:
SELECT Product.name, Purchase.store
FROM Product JOIN Purchase ON
Product.name = Purchase.prodName
But Products that never sold will be lost !
Magda Balazinska - CSE 444, Fall 2010
 Outerjoins
Product(name, category)
Purchase(prodName, store)

If we want the never-sold products, need an “outerjoin”:

SELECT Product.name, Purchase.store

FROM Product LEFT OUTER JOIN Purchase ON
Product.name = Purchase.prodName

Magda Balazinska - CSE 444, Fall 2010

Product Purchase
Name Category ProdName Store

Gizmo gadget Gizmo Wiz

Camera Photo Camera Ritz

OneClick Photo Camera Wiz

Name Store

Gizmo Wiz

Camera Ritz

Camera Wiz

OneClick NULL
 Application
•  Compute, for each product, the total number of sales in
‘September’
Product(name, category)
Purchase(prodName, month, store)

SELECT Product.name, count(*)

FROM Product, Purchase
WHERE Product.name = Purchase.prodName
and Purchase.month = ‘September’
GROUP BY Product.name

What’s wrong ?
Magda Balazinska - CSE 444, Fall 2010
 Application
•  Compute, for each product, the total number of sales in
‘September’
Product(name, category) Need to use
Purchase(prodName, month, store) attribute to
get correct
zero count
SELECT Product.name, count(store) (6.4.6)
FROM Product LEFT OUTER JOIN Purchase ON
Product.name = Purchase.prodName
and Purchase.month = ‘September’
GROUP BY Product.name

Now we also get the products who sold in 0 quantity

Magda Balazinska - CSE 444, Fall 2010
 Outer Joins

•  Left outer join:

–  Include the left tuple even if there’s no match
•  Right outer join:
–  Include the right tuple even if there’s no match
•  Full outer join:
–  Include both left and right tuples even if there’s no
match

Magda Balazinska - CSE 444, Fall 2010