CS2102 Database Systems Null Values & Truth Table: Aggregate Functions: MIN, MAX, ER Diagrams Suppose S → T, to check
, ER Diagrams
Integrity Constraints:
 Key Constraints
 Foreign Key Constraints
 Other General Constraints
Superkey: subset of attributes that
uniquely identifies the tuple
(unique not null). Candidate Key
is a superkey in which no proper
subset is a superkey (minimal
subset).
Foreign Key Constraint: Foreign
keys must be (1) appear as primary
key in referenced table or (2) null
Relational Algebra
c(R) Selection: selects tuples from
R that satisfies condition c.
e.g. price<20(Sells)
l(R) Projection: projects attributes
given by l from Relation R,
duplicates are removed in
projections
e.g. rname, pizza (Sells)
S(X,Y,Z)(R) Renaming: renames
R(A,B,C) to S(X,Y,Z)
e.g. shops(sname, region)(Restaurants)
 Cross-Product: Consider
R(A,B,C)  S(X,Y), get all combi
of (A,B,C,X,Y)
Set Operations (requires
compatibility: same # of attributes,
attributes have same domain)
 Union: R  S
 Intersection: R  S
 Set-Difference: R – S
e.g. Find customer pairs (C1, C2)
s.t. they like some common pizza
and C1 < C2
R = (pizza=pizza2)(cname<cname2) (Likes
 Likes2( cname2, pizza2)( Likes))
Data Definition Language (DDL):
 CRUD on Schemas
Data Manipulation Language
DML:
 CRUD on Data
Suppose S → T, to check FD:
- Unknown and/or/not is unknown
- False and _ is false, not is true
- True or _ is true, not is false
- Op on NULL is unknown
- Need to use IS NULL
- Need to use IS DISTINCT
SQL Samples
CREATE TABLE students (
studentId integer primary key,
name varchar(100) not null,
birthdate date,
dept varchar(20) default ‘CS’,
rating numeric(3,1),
# 3 digits, 1 decimal place
CHECK(rating > 8.0),
FOREIGN KEY (name)
REFERENCES table(tname)
);
SELECT DISTINCT s1.rname, s2.rname
FROM Sells s1, Sells S2 WHERE
s1.rname < s2.rname AND s1.pizza =
s2.pizza
Set Operations: UNION, INTERSECT,
EXCEPT, if ALL, preserves duplicate
records
NATURAL JOIN: Join on common
attributes
INNER JOIN ON _: Join on specified
attributes
LEFT OUTER JOIN ON _: Join on
preserving left attributes
FULL OUTER JOIN ON _: Join on
preserving both attributes
e.g. Find distinct customers who like
some pizza by restaurant A
SELECT distinct cname FROM Likes L
WHERE EXISTS (SELECT 1 FROM
Sells S WHERE S.rname = A AND
S.pizza = L.pizza);
Subqueries: IN, ANY, ALL
SELECT * FROM Sells WHERE price >
ANY/ALL (SELECT price from Sells
WHERE rname = A)
UNIQUE: Returns false if the result
subquery contains at least 2 distinct
records t1 and t2 s.t. t1 = t2
AVG, SUM, COUNT
Note that: COUNT(A) returns 0 and
COUNT(*) returns n for n NULL,
other functions return NULL
SELECT pizza, rname FROM Sells
WHERE price = (SELECT MAX(price)
FROM Sells)
ORDER BY area ASC, price DESC
LIMIT 20
GROUP BY A Clause:
1. Partition the tuples in table into
groups based on A
2. Compute SELECT for each group
3. Output one tuple for each group
GROUP BY Properties, for each
column A in relation R in SELECT, 1
of the following must hold:
1. A appears in the GROUP BY
2. A appears in an aggregated
function in SELECT (min(A))
3. Primary Key of R appears in the
GROUP BY clause
HAVING Properties: for each column
A in relation R in HAVING, 1 of the
following must hold:
1. A appears in the GROUP BY
2. A appears in an aggregated
functions in HAVING
3. Primary Key of R appears in the
GROUP BY clause
Order of Evaluation of Queries
1. compute cross-product in FROM
2. select tuples that fulfil WHERE
3. partition with GROUP BY
4. select groups that fulfil HAVING
5. generate output in SELECT
6. remove duplicates
7. sort based on ORDER BY
8. truncate based on LIMIT
Conditional Expressions: CASE
SELECT name, CASE
WHEN marks >= 70 THEN ‘A’,
WHEN marks >= 60 THEN ‘B’,
WHEN marks >= 50 THEN ‘C’,
ELSE ‘D’
END AS grade
- Rectangle for Entities
- Lozenge for Relationships
Weak Entities
- Attribute only unique within the - Best implemented as PK or Unique
scope of a relationship
- primary key: primary key of
dominant entities + own PK
Participation Constraints
- (1,2), (0, 5), (1,n), (0,n)
- Interpret as 1 of entity can be
mapped to (0,n) of other entity
- Weak entities have (1,1)
Relationships have primary key:
sum of PK of entities
Exception 1: (0,1) mapping
- Relationship have (0,1) entity’s
PK as PK
Exception 2: (1,1) mapping
- merge (1,1) entity and
relationship table
Exception 3: Weak Entities
- merge weak entity with
relationship table
Functional Dependencies
Analysed because tables have
 Redundant Storage
 Update Anomaly
 Deletion Anomaly
 Insertion Anomaly
Definition of FD
- For a relation R, a FD from S of R is the union of the sets Z of attributes s.t.
to T of R exists iff:
 For every instance of R, if 2 Minimal Set of Dependencies:
tuples agree on the values of 1. Every RHS is a single attribute
attributes in S, then they
agree on the values of
attributes of T. S uniquely
identifies T.
 Write: S → T
 FD are integrity constraints
and can be checked
CHECK ( NOT EXISTS ( SELECT 1
FROM R r1, R r2 WHERE r1.S = r2.S
AND r1.T <> r2.T))
Trivial FD: X→Y, Y ⸦ X; {A,B}→{A}
Non-trivial FD: X→Y, Y  X;
Completely Non-trivial FD: X→Y,
Y /⊂ X, X  Y = 
Armstrong’s Axioms
Let X, Y, Z be subsets of Relation R
Reflexivity: If Y ⸦ X, then X→Y;
Augmentation: If X→Y, then
XZ→YZ
Transitivity: If X→Y & Y→Z, then X→Z
Other useful logical relations:
Weak Augmentation: If X→Y, then
XZ→Y
Pseudo-transitivity: If X→Y & A→B &
A⸦Y, then X→B
Check Super-key of R(A,B,C,D):
- Suppose we check {A,B}, check if
{A,B}→{A,B,C,D}
Check candidate key of R(A,B,C,D):
- Suppose we check {A,B}, check that
neither {A} nor {B} are candidate key
Closure of a set of FD (F+)
- All the FD that F entails, can be found
by applying Armstrong Axioms in all
possible ways until nothing new comes
- 2 sets of FD are equivalent iff F+ == G+
- Attribute Closure: a set S of attributes,
we call the closure of S, S+, the maximum
set of attributes s.t. S → S+
e.g. F = {A→C, B→D}, then A+ = {A,C}
Algo: X(0) =X; X(i+1) := X(i)  A, where A
Y→Z in F, and F ⸦ X(i); end: X(i+1) = X(i)
2. For no FD X→A in F and proper
subset Z of X is F –
{X→A}{Z→A} is equivalent to F
3. For no FD X→A in F is the set F –
{X→A} equivalent to F
Minimal Cover: F is minimal & F is
equivalent to G