Advanced SQL

Advanced SQL
Example 1 (aggregate function)

 SELECT MAX(amount)
FROM DEPOSIT
 Answer: 100k
 MAX is an aggregate function.

 Other aggregation functions include MIN, COUNT, SUM, AVG.
 For example, if we replace MAX in the earlier query with the above
functions, the answers are:
 5k, 5, 195k, 39k, respectively.
2
Example 2
 Find the total amount of money ever
deposited into account A1.
 SELECT SUM(amount)
FROM DEPOSIT
WHERE acc-id = ‘A1’
 Find the total number of times that account A1 has been deposited
into.
 SELECT COUNT(*)
FROM DEPOSIT
3
Example 2 (cont.)
 Find the number of distinct customers
that ever deposited into account A1.
 SELECT COUNT(DISTINCT cust-id)

FROM DEPOSIT
 Answer: 1
 Repeat the above query with respect to ‘A3’, the answer is 2.
4
Example 3 (group by)
 SELECT acc-id, SUM(amount)  SELECT acc-id, cust-id, SUM(amount)

FROM DEPOSIT FROM DEPOSIT
GROUP BY acc-id GROUP BY acc-id, cust-id
3 groups
4 groups
5
Constraint of group by
 In a group-by query, the SELECT clause
can involve i) attribute names and
ii) aggregate functions
 attribute name must be some attribute
appeared in the GROUP BY clause
 aggregate function can take any
attribute as argument
 have a single value per group!
 For example
SELECT acc-id, cust-id, SUM(amount)
FROM DEPOSIT
GROUP BY acc-id
is wrong, due to the presence of cust-id.
6
Example 4 (having)
deposited into each account, provided that
the account has been deposited at least
twice.
 SELECT acc-id, SUM(amount)

FROM DEPOSIT
GROUP BY acc-id
HAVING COUNT(*) >= 2
 HAVING applies only to groups, and hence, can be used with GROUP
BY only.
 HAVING usually contains only aggregate functions.
 Let us see how the above query is executed.

7
Example 4 (having)
FROM DEPOSIT
GROUP BY acc-id
 First, process GROUP BY.
GROUP 1
GROUP 2
GROUP 3
8
Example 4 (having)
FROM DEPOSIT
GROUP BY acc-id
 Then, process HAVING to eliminate the

groups that do not qualify the HAVING
condition.
GROUP 1
GROUP 3
9
Example 4 (having)
FROM DEPOSIT
GROUP BY acc-id
 Finally, process SELECT.
10
A common mistake
deposited into each account, provided that
the account has been deposited at least
twice.

FROM DEPOSIT
WHERE COUNT(*) >= 2
GROUP BY acc-id
 The above query is wrong!

 There can be no aggregate function in WHERE.
 Remember: WHERE filters tuples, while an aggregate function applies to

a group. So they are incompatible.
11
Example 5
 For each customer, display her/his name, and the total amount of
money in her/his accounts.
 If a customer ever deposited in an account, we consider s/he
owns the account.
 SELECT name, SUM(balance)

FROM CUST, ACC, DEPOSIT
WHERE CUST.cust-id = DEPOSIT.cust-id AND ACC.acc-id =
DEPOSIT.acc-id
GROUP BY CUST.cust-id, name
 Let us understand the query step-by-step.

12
Example 5 (cont.)

DEPOSIT.acc-id
 First, the cartesian product.
13
Example 5 (cont.)

DEPOSIT.acc-id
 Then, filter tuples.
14
Example 5 (cont.)

DEPOSIT.acc-id
 Third, create groups.
group 1
group 2
15
Example 5 (cont.)

DEPOSIT.acc-id
 Finally, do projection and summarize aggregates.

One tuple per group.
16
Example 6
 For each customer who has made at least 2 deposits, display

her/his name, and the total amount of money in her/his accounts.

DEPOSIT.acc-id
17
Example 6 (cont.)

DEPOSIT.acc-id
 Do cartesian product, tuple filtering, and then create groups.
group 1
group 2
18
Example 6 (cont.)

DEPOSIT.acc-id
 Process HAVING.
group 1
19
Example 6 (cont.)

DEPOSIT.acc-id
 Finally, process SELECT.
20
Example 7
 For each customer, display her/his name, and the total amount of
money in her/his accounts whose balances are larger than 15k.

DEPOSIT.acc-id AND ACC.balance > 15000
 Note: Here we put the addition condition into WHERE, not HAVING.
21
Example 7 (cont.)

 Do cartesian product, tuple filtering, and then create groups.
22
Example 7 (cont.)

 Process SELECT.
23
Example 8 (nested query)
 Find the id of the account with the largest
balance.
 SELECT acc-id
FROM ACC
WHERE balance = (SELECT MAX(balance)
FROM ACC)
a nested query
24
Example 9 (all)
 Find the ids of the accounts whose balances
are larger than the balances of all accounts
owned by the customer with cust-id = 1.
 SELECT acc-id
FROM ACC
WHERE balance > ALL (SELECT balance
FROM ACC
WHERE cust-id = 1)
 Answer:
A4
25
Example 10 (some)
are larger than the balance of at least one
account owned by the customer with
cust-id = 1.
 SELECT acc-id
FROM ACC
WHERE balance > SOME (SELECT balance
FROM ACC
WHERE cust-id = 1)
 Answer:
A1
A3
A4
26
Example 11 (exists)
are not the largest.
 SELECT T1.acc-id
FROM ACC T1
WHERE EXISTS (SELECT *
FROM ACC T2
WHERE T1.balance < T2.balance)
 Note that this nested query is different from the previous nested
queries we have seen: It depends on the outside query.
 T1 in the nested query references the table in the outside query.
 Lets see how it is executed.

27
Example 11 (exists)
FROM ACC T1
FROM ACC T2
 Lets go over every tuple in T1 one by one. For each tuple, get its balance,
and place it at the position of T1.balance to make the nested query
complete.
 Specifically, when we are looking at the first tuple in T1, the nested query
becomes:
SELECT *
FROM ACC T2
WHERE 20k < T2.balance
 Execute it – does it return any tuples?

 Yes, so EXISTS evaluates to true, and the acc-id of the tuple in T1 we are
looking at is displayed. 28
Example 11 (exists)
FROM ACC T1
FROM ACC T2
 Repeat the above process for all tuples in T1.

 The acc-ids of all tuples are displayed, until we come to the last tuple, for
which the nested query has the form:
SELECT *
FROM ACC T2
WHERE 100k < T2.balance
 Execute it – does it return any tuples?

 No, so EXISTS evaluates to false, and the acc-id of the last tuple in T1 is
not displayed.
29
Example 12 (not exists)
 Find the id of the account whose balance
is the largest.
FROM ACC T1
WHERE NOT EXISTS (SELECT *
FROM ACC T2
30
Example 13 (not exists)
 Find the ids of the customers who have
deposited into all accounts with balances
larger than 15k.
 SELECT DISTINCT cust-id
FROM DEPOSIT T1
WHERE NOT EXISTS (
(SELECT DISTINCT acc-id
FROM ACC
WHERE balance > 15000)
EXCEPT
FROM DEPOSIT T2
WHERE T1.cust-id = T2.cust-id))
 Answer: 1
 What an inscrutable query! Lets understand it step-by-step.
31
Example 13
 SELECT DISTINCT cust-id FROM DEPOSIT T1
WHERE NOT EXISTS (
FROM ACC
EXCEPT
FROM DEPOSIT T2
 The nested query depends on the outside

query.
 So, we look at each tuple in T1, and use its cust-id to complete the
nested query.
 Lets start with the first tuple in T1.
32
Example 13
WHERE NOT EXISTS (
FROM ACC
EXCEPT
FROM DEPOSIT T2
 Lets start with the first tuple in T1. The nested
query becomes:
 (SELECT DISTINCT acc-id
FROM ACC
EXCEPT
(SELECT DISTINCT acc-id returns {A1, A2}
FROM DEPOSIT T2
WHERE 1 = T2.cust-id)) returns {A1, A2}
 The above query returns empty. So NOT EXIST evaluates to true, and
cust-id 1 is displayed. 33
Example 13
WHERE NOT EXISTS (
FROM ACC
EXCEPT
FROM DEPOSIT T2
 Lets look at the 4th tuple in T1. The nested
query becomes:
 (SELECT DISTINCT acc-id
FROM ACC
EXCEPT
(SELECT DISTINCT acc-id returns {A1, A2}
FROM DEPOSIT T2
WHERE 2 = T2.cust-id)) returns {A2, A3}
 The above query returns {A1}. So NOT EXIST evaluates to false, and
cust-id 2 is not displayed. 34
Example 14 (in)
 Find the ids of accounts that were
deposited into by both customers with
cust-id = 1 and 2.
 SELECT acc-id
FROM DEPOSIT
WHERE cust-id = 2 AND acc-id IN (SELECT acc-id
FROM DEPOSIT
WHERE cust-id = 1)
 Answer:
A2
35
Example 15 (not in)
 Find the ids of accounts that were
deposited into by the customer with
cust-id = 2 but not by the customer with
and cust-id = 1.
 SELECT acc-id
FROM DEPOSIT
WHERE cust-id = 2 AND acc-id NOT IN (SELECT acc-id
FROM DEPOSIT
WHERE cust-id = 1)
 Answer:
A3
36
Example 16 (nested query in FROM)
 Let us define the wealth of a customer
as the total amount of money in all
her/his accounts.
 Display the average wealth of the
customers whose wealth is larger
than 20k.
 SELECT AVG(wealth)
FROM (SELECT SUM(balance) as wealth FROM ACC
GROUP BY cust-id)
AS TMP
WHERE wealth > 20000
 Result:
61k

37
Example 16 (nested query in FROM)
 SELECT AVG(wealth)
FROM (SELECT SUM(balance)
as wealth
FROM ACC
GROUP BY cust-id)
AS TMP
 First, execute the nested query in FROM, which produces a table

named TMP, involving a single column wealth.
 Conceptually, the above query can be simplified as:

SELECT AVG(wealth)
FROM TMP
 Hence, the result is the average of38the first two rows in TMP.
Example 17 (with)
 Let us define the wealth of a customer
as the total amount of money in all
her/his accounts.
 Display the average wealth of the
customers whose wealth is larger
than 20k.
 WITH TMP AS
(SELECT SUM(balance) as wealth FROM ACC
GROUP BY cust-id)
SELECT AVG(wealth)
FROM TMP
 Result:
61k
 The execution is the same as the query on the previous slide.

39
What have we learned?
 Aggregate functions
MAX, MIN, COUNT, SUM, AVG
 GROUP BY, HAVING
 ALL, SOME
 EXISTS, NOT EXISTS
 IN, NOT IN
 Nested queries in FROM
 WITH
40

Advanced SQL

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Advanced SQL

Uploaded by

Copyright:

Available Formats

Advanced SQL

Example 1 (aggregate function)

 MAX is an aggregate function.

 SELECT COUNT(DISTINCT cust-id)

 Repeat the above query with respect to ‘A3’, the answer is 2.

 SELECT acc-id, SUM(amount)  SELECT acc-id, cust-id, SUM(amount)

is wrong, due to the presence of cust-id.

 SELECT acc-id, SUM(amount)

 Let us see how the above query is executed.

 First, process GROUP BY.

 Then, process HAVING to eliminate the

 Finally, process SELECT.

 SELECT acc-id, SUM(amount)

 The above query is wrong!

 Remember: WHERE filters tuples, while an aggregate function applies to

 SELECT name, SUM(balance)

 Let us understand the query step-by-step.

 SELECT name, SUM(balance)

 SELECT name, SUM(balance)

 Then, filter tuples.

 SELECT name, SUM(balance)

 Third, create groups.

 SELECT name, SUM(balance)

 Finally, do projection and summarize aggregates.

 For each customer who has made at least 2 deposits, display

 SELECT name, SUM(balance)

 Let us understand the query step-by-step.

 SELECT name, SUM(balance)

 Do cartesian product, tuple filtering, and then create groups.

 SELECT name, SUM(balance)

 SELECT name, SUM(balance)

 Finally, process SELECT.

 SELECT name, SUM(balance)

 SELECT name, SUM(balance)

 Do cartesian product, tuple filtering, and then create groups.

 SELECT name, SUM(balance)

 Lets see how it is executed.

 Execute it – does it return any tuples?

 Repeat the above process for all tuples in T1.

 Execute it – does it return any tuples?

 The nested query depends on the outside

 Let us understand the query step-by-step.

 First, execute the nested query in FROM, which produces a table

 Conceptually, the above query can be simplified as:

 The execution is the same as the query on the previous slide.

You might also like