SQL

1
 Introduction
• Structured Query Language (SQL) is the most widely used
commercial relational database language.
• It was originally developed at IBM in the SEQUEL-XRM
and System-R projects (1974-1977).
• Almost immediately, other vendors introduced DBMS
products based on SQL, and it is now a de facto standard.
• The SQL continues to evolve in response to the changing
need.

2
• The SQL language has several aspects to it:
– The Data Manipulation Language (DML)
• The subset of SQL allows users to pose queries and
to insert, delete, and modify rows.
– The Data Definition Language (DDL)
• The subset of SQL supports the creation, deletion,
and modification to definitions for tables and views.
– Triggers and Advanced Integrity Constraints
• The feature was introduced in SQL:1999. The
standard includes support for triggers, which are
action executed by the DBMS whenever changes to
the database meet conditions specified in the trigger

3
– Embedded and Dynamic SQL
• Embedded SQL features allow SQL code to be
called from a host language such as C or COBOL.
• Dynamic SQL features allow a query to be
constructed and executed at run-time.
– Client-Server Execution and Remote Database
Access
• Client application can connect to an SQL server.
• Access data from a database over a network.
– Transaction Management
• Control how transaction are executed.
– Security
• Provides mechanisms to control users’ access to
data.
4
Basic SQL Query

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification

5
Basic SQL Query

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification

A list of relation names

(possibly with a range-variable
after each name).

6
Basic SQL Query

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification

A list of attributes from

relations in relation-list.

7
 Basic SQL Query

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification

Comparisons
• [Attr op const] or [Attr1 op Attr2],
where op is one of <, >, =, ≤, ≥, ≠
• combined using AND, OR and NOT.

8
 Basic SQL Query

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification

An optional keyword indicating that

the answer should not contain duplicates.
Default is that duplicates are not eliminated.

9
 Basic SQL Query

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification

• SELECT clause
– specifies columns to be retained in the result.
• FROM clause
– specifies a cross-product of tables.
• WHERE clause (optional)
– specifies selection conditions on the tables mentioned in the
FROM clause.

10
SELECT DISTINCT a1, a2, …, an
FROM R1, R2, …, Rm
WHERE P

An SQL query intuitively corresponds to a

relational algebra expression involving
selections, projections, and cross-products.

 a1, a2, …, an (  P ( R1 x R2 x … x Rm ) )

11
• Example: Find the names of all branches in
the loan relation.
SELECT branch-name
FROM Loan

Loan Result
branch_name loan_number amount branch_name
CUHK 222 2 CUHK
CMTR 333 1 CMTR
CUHK 777 2 CUHK

12
• To remove duplications

SELECT DISTINCT branch-name

FROM Loan

Loan Result
branch_name loan_number amount branch_name
CUHK 222 2 CUHK
CMTR 333 1 CMTR
CUHK 777 2

13
• Conceptual Evaluation Strategy
 Compute the cross-product of relation-list.
 Discard resulting tuples if they fail
qualifications.
 Delete attributes that are not in target-list.
 If DISTINCT is specified, eliminate duplicate
rows.
(This strategy is probably the least efficient way to
compute a query! An optimizer will find more efficient
strategies to compute the same answers.)

14
• Example (Q1, p.137): Find the names of sailors
who have reserved boat number 103.

sid bid day sid sname rating age

22 101 10/10/19 22 dustin 7 45.0
58 103 11/12/19 31 lubber 8 55.5
58 rusty 10 35.0
Instance R3 of Reserves
Instance S4 of Sailors

15
 sid sname rating age
sid bid day
22 dustin 7 45.0
22 101 10/10/19
31 lubber 8 55.5
58 103 11/12/19
58 rusty 10 35.0

SELECT S.sname
FROM Sailors S, Reserves R
WHERE S.sid=R.sid AND R.bid=103

S.sid sname rating age R.sid bid day

22 dustin 7 45.0 22 101 10/10/19
22 dustin 7 45.0 58 103 11/12/19
31 lubber 8 55.5 22 101 10/10/19
31 lubber 8 55.5 58 103 11/12/19
58 rusty 10 35.0 22 101 10/10/19
58 rusty 10 35.0 58 103 11/12/19

Row remains after

selection. S4 X R3
Result
16
• A Note on Range Variables
– Really needed only if the same relation appears
twice in the FROM clause. The previous query
can also be written as:
SELECT S.sname
FROM Sailors S, Reserves R
WHERE S.sid=R.sid AND bid=103
It is good style,
or however, to use
range variables
SELECT sname always!
FROM Sailors, Reserves
WHERE Sailors.sid=Reserves.sid
AND bid=103
17
 More Examples
• Given the following schema:
Sailors(sid: integer, sname: string, rating:integer, age: real)
Boats(bid: integer, bname; string, color: string)
Reserves(sid: integer, bid: integer, day: date)

sailors sid sname rating age

Boats bid bname color

Reserves sid bid day

18
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find the sids of sailors who have

reserved a red boat.
SELECT R.sid
FROM Boat B, Reserves R
WHERE B.bid = R.bid AND B.color = ‘red’

Example: Find the names of sailors who have

reserved a red boat.

SELECT S.sname
FROM Sailors S, Reserves R, Boat B
WHERE S.sid = R.sid AND R.bid = B.bid AND
B.color = ‘red’
19
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find the colors of boats reserved

by Lubber.

SELECT B.color
FROM Sailors S, Reserves R, Boat B
WHERE S.sid = R.sid AND R.bid = B.bid AND
S.sname = ‘Lubber’.

(In general, there may be more than one sailor called

Lubber. In this case, it will return the colors of boats
reserved by all sailors called Lubber).

20
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find the names of sailors who

have reserved at least one boat.
SELECT S.sname
FROM Sailors S, Reserves R
WHERE S.sid = R.sid

(If a sailor has not made a reservation, the second step in

the conceptual evaluation strategy would eliminate all
rows in the cross-product that involve this sailor).

21
 Expressions and Strings
SELECT S.age, age1=S.age-5, 2*S.age AS age2
FROM Sailors S
WHERE S.sname LIKE ‘B_%B’

• Illustrates use of arithmetic expressions and string pattern

matching: Find triples (of ages of sailors and two fields
defined by expressions) for sailors whose names begin and
end with B and contain at least three characters.
• AS and = are two ways to name fields in result.
• LIKE is used for string matching. `_’ stands for any one
character and `%’ stands for 0 or more arbitrary characters.

22
 Union, Intersect, and Except
• SQL provides three set-manipulation
constructs that extend the basic query form
presented earlier.
– Union ()
– Intersection ()
– Except ()
(many systems recognize the keyword MINUS for EXCEPT)

23
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find sid’s of sailors who’ve reserved a red or a green

boat
SELECT S.sid
• UNION: Can be used to compute FROM Sailors S, Boats B, Reserves R
the union of any two union- WHERE S.sid=R.sid AND R.bid=B.bid
compatible sets of tuples (which AND (B.color=‘red’ OR B.color=‘green’)

are themselves the result of SQL

queries).
SELECT S.sid
• If we replace OR by AND in the
FROM Sailors S, Boats B, Reserves R
first version, what do we get? WHERE S.sid=R.sid AND R.bid=B.bid
• Also available: EXCEPT (What AND B.color=‘red’
UNION
do we get if we replace UNION SELECT S.sid
by EXCEPT?) FROM Sailors S, Boats B, Reserves R
WHERE S.sid=R.sid AND R.bid=B.bid
AND B.color=‘green’

24
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find sid’s of sailors who’ve reserved a red and a green

boat
• INTERSECT: Can be used to SELECT S.sid
FROM Sailors S, Boats B1, Reserves R1,
compute the intersection of Boats B2, Reserves R2
any two union-compatible WHERE S.sid=R1.sid AND R1.bid=B1.bid
AND S.sid=R2.sid AND R2.bid=B2.bid
sets of tuples. AND (B1.color=‘red’ AND B2.color=‘green’)

• Included in the SQL/92 SELECT S.sid

FROM Sailors S, Boats B, Reserves R
standard, but some systems WHERE S.sid=R.sid AND R.bid=B.bid
don’t support it. AND B.color=‘red’
INTERSECT
SELECT S.sid
FROM Sailors S, Boats B, Reserves R
WHERE S.sid=R.sid AND R.bid=B.bid
AND B.color=‘green’ 25
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find sid’s of all sailors who’ve reserved red boat but
not green boat.
SELECT S.sid
FROM Sailors S, Boats B, Reserves R
Indeed, since the Reserves
WHERE S.sid=R.sid AND R.bid=B.bid
relation contains sid information, AND B.color=‘red’
there is no need to look at the EXCEPT
Sailors relation. SELECT S.sid
FROM Sailors S, Boats B, Reserves R
WHERE S.sid=R.sid AND R.bid=B.bid
AND B.color=‘green’

SELECT R.sid
FROM Boats B, Reserves R
WHERE R.bid=B.bid AND B.color=‘red’
EXCEPT
SELECT R.sid
FROM Boats B, Reserves R
WHERE R.bid=B.bid AND B.color=‘green’
26
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find sid’s of all sailors who have a rating of 10 or

reserved boat 104

SELECT S.sid
FROM Sailor S
WHERE S.rating = 10
UNION
SELECT R.sid
FROM Reserves R
WHERE R.bid=104

27
 SQL IN operator
• The IN operator allows you to specify
multiple values in a WHERE clause
Example: Find the names of boats which are red, blue,
or green.

SELECT B.bname
FROM Boats B
WHERE B.color IN (‘red’, ‘blue’, ’green’)

sailors sid sname rating age

Boats bid bname color
Reserves sid bid day
28
 Nested Queries
• A nested query is a query that has another
query embedded within it.
• The embedded query is called a subquery.
• The embedded query can be a nested query
itself.
– Queries may have very deeply nested
structures.

29
Example: Find names of sailors who’ve reserved boat #103:
SELECT S.sname Note that this query can
FROM Sailors S be implemented easily
WHERE S.sid IN (SELECT R.sid without using nested
FROM Reserves R structure.
WHERE R.bid=103)

• A very powerful feature of SQL: a WHERE clause can itself

contain an SQL query! (Actually, so can FROM and HAVING
clauses.)
• To find sailors who’ve not reserved #103, use NOT IN.
• To understand semantics of nested queries, think of a nested
loops evaluation: For each Sailors tuple, check the
qualification by computing the subquery.
30
 Correlated Nested Queries
• In the previous example, the inner subquery
has been completely independent of the
outer query.
• In general, the inner subquery could depend
on the row currently being examined in the
outer query.

31
 Example: Find names of sailors who’ve reserved
boat #103:
SELECT S.sname
FROM Sailors S
WHERE EXISTS (SELECT *
FROM Reserves R
WHERE R.bid=103 AND S.sid=R.sid)

• EXISTS is another set comparison operator, which allows us to

test whether a set is nonempty. (Return true if the result is non-empty)
• If UNIQUE is used, and * is replaced by R.bid, finds sailors with
at most one reservation for boat #103. (UNIQUE checks for
duplicate tuples (Return true if the result has no duplicate record);
* denotes all attributes. Why do we have to replace * by
R.bid?)
• Illustrates why, in general, subquery must be re-computed 32 for
each Sailors tuple.
 Set-comparison Operators
• We’ve already seen IN, EXISTS and UNIQUE.
We can also use NOT IN, NOT EXISTS and NOT UNIQUE.
• Also available: op ANY, op ALL
– Where op is one of the arithmetic comparison operators,,,,,
– SOME is also available, but it is just a synonym for ANY.
• Example: Find sailors whose rating is greater than that of
some sailor called Horatio:

SELECT *
FROM Sailors S
WHERE S.rating > ANY (SELECT S2.rating
FROM Sailors S2
WHERE S2.sname=‘Horatio’)
33
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find sailors whose rating is better than every sailor

called Horatio.

SELECT *
FROM Sailors S
WHERE S.rating > ALL (SELECT S2.rating
FROM Sailors S2
WHERE S2.sname=‘Horatio’)

Example: Find the sailors with the highest rating.

SELECT *
FROM Sailors S
WHERE S.rating >= ALL (SELECT S2.rating
FROM Sailors S2)

34
• Rewriting INTERSECT queries using IN
Example: Find sid’s of sailors who’ve reserved both a red and a
green boat:
SELECT S.sid
FROM Sailors S, Boats B, Reserves R
WHERE S.sid=R.sid AND R.bid=B.bid AND B.color=‘red’
AND S.sid IN (SELECT S2.sid
FROM Sailors S2, Boats B2, Reserves R2
WHERE S2.sid=R2.sid AND R2.bid=B2.bid
AND B2.color=‘green’)

• Similarly, EXCEPT queries can be re-written using NOT IN.

• To find names (not sid’s) of Sailors who’ve reserved both red
and green boats, just replace S.sid by S.sname in SELECT clause.
(What about INTERSECT query? [ see p. 150 of the textbook])
35
 Division in SQL
Example: Find sailors who’ve reserved all boats.
sailors sid sname rating age
SELECT S.sname
Boats bid bname color
FROM Sailors S
WHERE NOT EXISTS Reserves sid bid day
((SELECT B.bid
FROM Boats B)
All boats
EXCEPT
(SELECT R.bid
FROM Reserves R All boats reserved by S
WHERE R.sid=S.sid))

Note that this query is correlated – for each sailor S, we check to

see if the set of boats reserved by S includes every boat.

36
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

An Alternative way to write the previous query without

using EXCEPT Boat b will be returned if it has been
reserved by sailor s; otherwise the result
will be empty.
SELECT S.sname Boats haven’t been
reserved by sailor s
FROM Sailors S
WHERE NOT EXISTS (SELECT B.bid
FROM Boats B
WHERE NOT EXISTS (SELECT R.bid
FROM Reserves R
WHERE R.bid=B.bid
AND R.sid=S.sid))

Intuitively, for each sailor we check that there is no boat

that has not been reserved by this sailor.

37
 Aggregate Operators
• SQL allows the use of arithmetic expressions.
• SQL supports five aggregate operations, which
can be applied on any column of a relation.
COUNT([DISTINCT] A) The number of (unique) value in the A
column.
SUM ( [DISTINCT] A) The sum of all (unique) values in the A
column.
AVG ([DISTINCT] A) The average of all (unique) values in the A
column.
MAX (A) The maximum value in the A column.

MIN (A) The minimum value in the A column.

38
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find the average age of all sailors

SELECT AVG (S.age)
FROM Sailors S

Example: Find the average age of sailors with rating of 10

SELECT AVG (S.age)

FROM Sailors S
WHERE S.rating = 10

39
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Find the name and age of the oldest sailor

SELECT S.sname, MAX (S.age)
FROM Sailors S

SELECT S.sname, S.age

FROM Sailors S
WHERE S.age =
(SELECT MAX (S2.age)
FROM Sailors S2)

SELECT S.sname, S.age

Equivalent to the second
FROM Sailors S
query, and is allowed in the
WHERE (SELECT MAX (S2.age)
SQL/92 standard, but is not
FROM Sailors S2)
supported in some systems.
= S.age 40
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Example: Count the number of Sailors

SELECT COUNT (*)
FROM Sailors S

Example: Count the number of different sailor names

SELECT COUNT (DISTINCT S.sname)

FROM Sailors S

41
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Aggregate operations offer an alternative to the ANY

and ALL constructs.
Example: Find the names of sailors who are older
than the oldest sailor with a rating of 10.
SELECT S.sname
FROM Sailors S
WHERE S.age > ( SELECT MAX (S2.age)
FROM Sailors S2
WHERE S2.rating = 10)

42
 Group by and Having
• So far, we’ve applied aggregate operators to all (qualifying)
tuples. Sometimes, we want to apply them to each of several
groups of tuples.
• Consider: Find the age of the youngest sailor for each rating
level.
– In general, we don’t know how many rating levels exist, and what the
rating values for these levels are!
– Suppose we know that rating values go from 1 to 10; we can write 10
queries that look like this (!):

SELECT MIN (S.age)

For i = 1, 2, ... , 10: FROM Sailors S
WHERE S.rating = i

43
• To write such queries, we need a major extension to the
basic SQL query form, namely the Group BY clause.
• The extension also includes an optional HAVING clause
that can be used to specify qualifications over groups.

The query can be expressed as follows

SELECT S.rating, MIN (S.age)

FROM Sailors S
GROUP BY S.rating

44
 The general format of GROUP BY and Having

SELECT [DISTINCT] target-list

FROM relation-list
WHERE qualification
GROUP BY grouping-list
HAVING group-qualification

• The target-list contains (i) attribute names (ii) terms

with aggregate operations (e.g., MIN (S.age)).
– The attribute names (i) must be a subset of grouping-list.
Intuitively, each answer tuple corresponds to a group, and these
attributes must have a single value per group. (A group is a set
of tuples that have the same value for all attributes in grouping-
list.)
45
 SELECT [DISTINCT] target-list
FROM relation-list
WHERE qualification
Conceptual Evaluation GROUP BY grouping-list
HAVING group-qualification

• The cross-product of relation-list is computed, tuples that

fail qualification are discarded, `unnecessary’ fields are
deleted, and the remaining tuples are partitioned into
groups by the value of attributes in grouping-list.
• The group-qualification is then applied to eliminate some
groups. Expressions in group-qualification must have a
single value per group!
– In effect, an attribute in group-qualification that is not an
argument of an aggregate op also appears in grouping-list. (SQL
does not exploit primary key semantics here!)
• One answer tuple is generated per qualifying group.

46
Example: Find the age of the youngest sailor with age  18, for
each rating with at least 2 such sailors
sid sname rating age
SELECT S.rating, MIN (S.age) 22 dustin 7 45.0
FROM Sailors S 31 lubber 8 55.5
WHERE S.age >= 18 71 zorba 10 16.0
GROUP BY S.rating 64 horatio 7 35.0
HAVING COUNT (*) > 1
29 brutus 1 33.0
58 rusty 10 35.0
• Only S.rating and S.age are
mentioned in the SELECT, rating age rating
GROUP BY or HAVING clauses; 1 33.0 7 35.0
other attributes are 7 45.0
`unnecessary’. 7 35.0 Answer relation
• 2nd column of result is unnamed. 8 55.5
(Use AS to name it. See Q32 on 10 35.0
p. 155 of your textbook.)
47
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

For each red boat, find the number of reservations for this
boat

SELECT B.bid, COUNT (*) AS reservationcount Only columns that appear in the
GROUP BY clause can appear in
FROM Boats B, Reserves R
the HAVING clause, unless
WHERE R.bid=B.bid they appear as arguments to an
GROUP BY B.bid aggregate operator in the HAVING
HAVING B.color = ‘red’ clause.

SELECT B.bid, COUNT (*) AS reservationcount

FROM Boats B, Reserves R
WHERE R.bid=B.bid AND B.color=‘red’
GROUP BY B.bid

48
Example: Find the average age of sailors for each rating level
that has at least two sailors.
sid sname rating age
SELECT S.rating, AVG(S.age) AS avgage 22 Dustin 7 45.0
FROM Sailor S
29 Brutus 1 33.0
GROUP BY S.rating
HAVING COUNT (*) > 1 31 Lubber 8 55.5
OR 32 Andy 8 25.5
SELECT S.rating, AVG(S.age) AS avgage 58 Rusty 10 35.0
FROM Sailor S 64 Horatio 7 35.0
GROUP BY S.rating
71 Zorba 10 16.0
HAVING 1 < (SELECT COUNT (*)
FROM Sailors S2 74 Horatio 9 35.0
WHERE S.rating = S2.rating) 85 Art 3 25.5
Rating avgage 95 Bob 3 63.5
We can use S.rating 96 Frodo 3 25.5
3 38.2 inside the nested
7 40.0 subquery in the HAVING
because it has a single Instance S3 of Sailor
8 40.5 value for the current group
10 25.5 of sailors (specified in the
GROUP BY clause). 49
Answer
 Example: Find the average age of sailors who are at least 18
years old for each rating level that has at least two sailors.
sid sname rating age
SELECT S.rating, AVG(S.age) AS avgage
22 Dustin 7 45.0
FROM Sailor S
WHERE S.age >=18 29 Brutus 1 33.0
GROUP BY S.rating 31 Lubber 8 55.5
HAVING 1 < (SELECT COUNT (*)
32 Andy 8 25.5
FROM Sailors S2
WHERE S.rating = S2.rating) 58 Rusty 10 35.0
64 Horatio 7 35.0
71 Zorba 10 16.0
Rating avgage
Note that the answer is very 74 Horatio 9 35.0
similar to the previous one, with the 3 38.2
only difference being that for the 85 Art 3 25.5
7 40.0
group 10, we now ignore the 95 Bob 3 63.5
sailor with age 16 while computing 8 40.5
96 Frodo 3 25.5
the average. 10 35.0
Answer Instance S3 of Sailor

50
 Example: Find the average age of sailors who are at least 18
years old for each rating level that has at least two such sailors.
sid sname rating age
SELECT S.rating, AVG(S.age) AS avgage
22 Dustin 7 45.0
FROM Sailor S
WHERE S.age >=18 29 Brutus 1 33.0
GROUP BY S.rating 31 Lubber 8 55.5
HAVING 1 < (SELECT COUNT (*)
32 Andy 8 25.5
FROM Sailors S2
WHERE S.rating = S2.rating AND 58 Rusty 10 35.0
S2.age >=18) 64 Horatio 7 35.0
71 Zorba 10 16.0
Rating avgage
It differs from the answer of the 74 Horatio 9 35.0
previous question in that there is no 3 38.2
tuple for rating 10, since there 85 Art 3 25.5
7 40.0
is only one tuple with rating 10 and 95 Bob 3 63.5
age >= 18. 8 40.5
96 Frodo 3 25.5
Answer
Instance S3 of Sailor

51
Some other ways to write the previous query.

SELECT S.rating, AVG(S.age) AS avgage

FROM Sailor S
WHERE S.age >=18
GROUP BY S.rating
HAVING COUNT (*) > 1

SELECT Temp.rating, Temp.avgage

FROM (SELECT S.rating, AVG(S.age) AS avgage,
count (*) As ratingcount
FROM Sailor S
WHERE S.age >=18
GROUP BY S.rating) AS Temp
WHERE Temp.ratingcount > 1

In Oracle, you don’t need to type

“AS”.

52
 sailors sid sname rating age
Boats bid bname color
Reserves sid bid day

Find those ratings for which the average age is the

minimum over all ratings

SELECT S.rating
FROM Sailors S
WHERE S.age = (SELECT MIN (AVG (S2.age))
FROM Sailors S2
GROUP BY S2.rating)

Aggregate operations cannot be nested!

This query will not work even if the expression MIN(AVG(S2.age)), which is illegal,
is allowed. In the nested query, Sailors is partitioned into groups by rating, and the
average age is computed for each rating value. For each group, applying MIN to this
average age value for the group will return the same value.

53
Correct solution (in SQL/92):

SELECT Temp.rating, Temp.avgage

FROM (SELECT S.rating, AVG (S.age) AS avgage
FROM Sailors S
GROUP BY S.rating) AS Temp
WHERE Temp.avgage = (SELECT MIN (Temp.avgage)
FROM Temp)

It essentially computes a temporary table containing the average age for

each rating value and then finds the rating(s) for which this average age is
the minimum.

54
 NULL Value
• field value unknown
– A new employee has not been assigned a
supervisor yet.

Employee eno ename supervisor_eno spouse_name

• field attribute inapplicable

– An unmarried employee does not have a spouse

e.g. INSERT INTO Employee VALUES (123,’Peter’, NULL, NULL);

55
Complications caused by NULL values
• Special operators provided to check if value is /
is not NULL
e.g. SELECT name, address
You cannot use comparison operators
FROM employee
(e.g. =, < , < >) to test for NULL values
WHERE address is NOT NULL

For a person who hasn’t been assigned a supervisor yet, is

supervisor_eno = 3334445555 true or false?
(We need a three value logic: true, false, unknown)
NOT unknown -> unknown
OR (TRUE, unknown) -> TRUE , OR (FALSE, unknown) -> unknown
AND (TRUE, unknown) -> unknown, AND (FALSE, unknown) -> FALSE

• The condition following ‘where’ clause

eliminates FALSE or unknown 56
• Two rows are duplicates if matching
columns are either equal or both NULL
– implicitly NULL=NULL.
– But for comparison in where clause,
(NULL=NULL) = unknown.

• NULL is counted in COUNT(*)

• All other aggregate discard NULL values

57
 General Constraints

• Useful when more CREATE TABLE Sailors

general ICs than ( sid INTEGER,
sname CHAR(10),
keys are involved. rating INTEGER,
• Can use queries to age REAL,
PRIMARY KEY (sid),
express constraint. CHECK ( rating >= 1
AND rating <= 10 )

58
• Constraints can be named.
• When a record is inserted into Reserves or an existing
row is modified, the conditional expression in the
CHECK constraint is evaluated. If it evaluates to
false, the command is rejected.

CREATE TABLE Reserves

(sid INTEGER,
bid INTEGER,
day DATE,
PRIMARY KEY (sid,bid,day),
CONSTRAINT noInterlakeRes
CHECK (`Interlake’ <>
( SELECT B.bname
FROM Boats B
WHERE B.bid=bid)))
59
 Domain Constraints
• We can define a new domain using the CREATE
DOMAIN statement, which uses CHECK
constraints.
CREATE DOMAIN ratingval INTEGER DEFAULT 1
CHECK (VALUE >=1 AND VALUE <=10)

60
 Distinct Type
CREATE TYPE ratingtype AS INTEGER

• This statement defines a new distinct type called

ratingtype, with INTEGER as its source type.
• Values of type ratingtype can be compared with
each other, but they cannot be compared with
values of other types.
• Ratingtype values are treated as being distinct
from values for the source type.

61
Constraints Over Multiple Relations
CREATE TABLE Sailors
( sid INTEGER, Number of boats
sname CHAR(10), plus number of
rating INTEGER, sailors is < 100
age REAL,
PRIMARY KEY (sid),
CHECK
( (SELECT COUNT (S.sid) FROM Sailors S)
+ (SELECT COUNT (B.bid) FROM Boats B) < 100 )

• Awkward and wrong!

• If Sailors is empty, the number of Boats tuples
can be anything!

62
• ASSERTION is the right solution; not associated
with either table.

CREATE ASSERTION smallClub

CHECK
( (SELECT COUNT (S.sid) FROM Sailors S)
+ (SELECT COUNT (B.bid) FROM Boats B) < 100 )

63
 Triggers
• Trigger: procedure that starts automatically if
specified changes occur to the DBMS
• Three parts:
– Event (activates the trigger)
– Condition (tests whether the triggers should run)
– Action (what happens if the trigger runs)

64
Triggers: Example (SQL:1999)

CREATE TRIGGER youngSailorUpdate

AFTER INSERT ON SAILORS
REFERENCING NEW TABLE NewSailors
FOR EACH STATEMENT
INSERT
INTO YoungSailors(sid, name, age, rating)
SELECT sid, name, age, rating
FROM NewSailors N
WHERE N.age <= 18

65
 Appendix: Natural Join
• Note that some systems may support natural join.
This query
SELECT S.sname
FROM Sailors S, Reserves R
WHERE S.sid=R.sid AND R.bid=103

can be rewritten as
SELECT S.sname
FROM Sailors S natural join Reserves R
WHERE R.bid=103
• Some systems also support inner join, left join,
right join and full join.
66
 Appendix: Create view
• A view is a virtual table based on the result
of an SQL statement
CREATE VIEW Temp AS
SELECT S.rating, AVG (S.age) AS avgage
FROM Sailors S
GROUP BY S.rating

• The view can be used as if it is a relation

SELECT Temp.rating, Temp.avgage
FROM Temp
WHERE Temp.avgage = (SELECT MIN (Temp.avgage)
FROM Temp)
67
• You can delete a view using the DROP
VIEW command
DROP VIEW Temp

• Try to find out more features about SQL

views yourself.

68