Comp

Comp 231
231 Database
Database Management
Management Systems
Systems

6. Integrity Constraints

Department of Computer Science and Engineering, HKUST

Slide 1
 Integrity
Integrity Constraints
Constraints

Integrity constraints guard against accidental damage to

the database, by ensuring that authorized changes
to the database do not result in a loss of data consistency.

• Domain Constraints
• Referential Integrity
• Assertions
• Triggers
• Functional Dependencies

Department of Computer Science and Engineering, HKUST

Slide 2
 Domain
Domain Constraints
Constraints

• They define valid values for attributes

• They are the most elementary form of integrity
constraint.
• They test values inserted in the database, and test
queries to ensure that the comparisons make sense.

Department of Computer Science and Engineering, HKUST

Slide 3
 Domain
Domain Constraints
Constraints
• The check clause in SQL-92 permits domains to be restricted
• use check clause to ensure that an hourly-wage domain allows
only values greater than a specified value.
new domain name
create domain hourly-wage numeric(5,2)
constraint value-test check (value>=4.00)
name of constraint
condition must be TRUE
• The domain hourly-wage is declared to be a decimal number
with 5 digits, 2 of which are after the decimal point
• The domain has a constraint that ensures that the hourly-wage
is greater than 4.00.
• constraint value-test is optional; useful to indicate which
constraint an update violated.
Department of Computer Science and Engineering, HKUST
Slide 4
 Specifying
Specifying Constraints
Constraints
• Can have complex conditions in domain check
• create domain AccountType char(10)
constraint account-type-test
check (value in (‘Checking’, ‘Saving’))
an SQL condition

• check can be associated with a table definition:

create table account … …

check (branch-name in (select branch-name
from branch))

Department of Computer Science and Engineering, HKUST

Slide 5
 Referential
Referential Integrity
Integrity
• Ensures that a value that appears in one relation for a given set of
attributes also appears for a certain set of attribute in another
relation.
– If an account exists in the database with branch name “Perryridge”,
then the branch “Perryridge” must actually exist in the database.

Foreign key

account ( account-no, branch-name, balance )

A-123 Perryridge 5000

branch (branch-name, branch-city, asset )

Primary keys of Perryridge Brooklyn 500,000
respective relations

A set of attributes X in R is a foreign key if it is not a primary key of R but

it is a primary key of some relation S.

Department of Computer Science and Engineering, HKUST

Slide 6
 Referential
Referential Integrity
Integrity
• Formal Definition
– Let r1(R1) and r2(R2) be relations with primary keys K1 and K2
respectively.

– The subset  of R2 is a foreign key referencing K1 in relation r1, if

for every t2 in r2 there must be a tuple t1 in r1 such that
t1[K1]=t2[].

– Referential integrity constraint: (r2)  K1 (r1)

R1 ( K1, …, … ) R2 ( K2, …, , … )
t2
x
t1
x

Department of Computer Science and Engineering, HKUST

Slide 7
 Referential
ReferentialIntegrity
Integrityininthe
theE-R
E-RModel
Model

works-
Works-for ( employee-no, dept-no) Primary key
Emp for Dep of Works-for
Foreign keys

• Consider relationship R between entity E1 and E2. R is represented as a

relation including primary keys K1 of E1 and K2 of E2. Then K1 and K2
form foreign keys on the relational schemas for E1 and E2 respectively.

• Weak entity sets are also a source of referential integrity constraints.

For, the relation schema for a weak entity set must include the primary
key of the entity set which it depends.

Dependent ( employee-no, dependent-name, age, sex )

Primary key of Dependent
Foreign key of Dependent since
it is a primary key of Employee
Department of Computer Science and Engineering, HKUST
Slide 8
 Referential
Referential Integrity
Integrity for
for Insertion
Insertion and
and Deletion
Deletion
• The following tests must be made in order to preserve the followi
ng referential integrity constraint:
(r2)  K(r1)

• Insert. If a tuple t2 is inserted into r2. The system must ensure th

at there is a tuple t1 in r1 such that t 1[K] = t2[]. That is
t2[] K(r1)
• Delete. If a tuple t1 is deleted from r1, the system must compute t
he set of tuples in r2 that reference t1:
=t1[K](r2)
if this set is not empty, either the delete command is rejected as
an error, or the tuples that reference t 1 must themselves be delet
ed (cascading deletions are possible)

Department of Computer Science and Engineering, HKUST

Slide 9
 Referential
Referential Integrity
Integrity for
for Update
Update
• if a tuple t2 is updated in relation r2 and the update modifies value
s for the foreign key , then a test similar to the insert case is ma
de. Let t2’ denote the new value of tuple t2. The system must ens
ure that
new foreign key
t2’[] K(r1) value must exist

• if a tuple t1 is updated in r1, and the update modifies values for pr

imary key(K), then a test similar to the delete case is made. The
system must compute no foreign keys contain
=t1[K](r2) the old primary key

using the old value of t1 (the value before the update is applied).
If this set is not empty, the update may be rejected as an error, o
r the update may be applied to the tuples in the set (cascade upd
ate), or the tuples in the set may be deleted.
Department of Computer Science and Engineering, HKUST
Slide 10
 Referential
Referential Integrity
Integrity in
in SQL
SQL
• Primary and candidate keys and foreign keys can be specified as
part of the SQL create table statement:
– The primary key clause of the create table statement
includes a list of the attributes that comprise the primary
key.
– The unique key clause of the create table statement includes
a list of the attributes that comprise a candidate key.
– The foreign key clause of the create table statement
includes both a list of the attributes that comprise the
foreign key and the name of the relation referenced by the
foreign key.

Department of Computer Science and Engineering, HKUST

Slide 11
Referential
ReferentialIntegrity
IntegrityininSQL
SQL-example
-example

create table customer

(customer-name char(20) not null,
customer-street char(30),
customer-city char(30),
primary key (customer-name))

create table branch

(branch-name char(15) not null,
branch-city char(30),
assets integer,
primary key (branch-name))

Department of Computer Science and Engineering, HKUST

Slide 12
 Referential
Referentialintegrity
integrityininSQL-
SQL- example
example

create table account

(branch-name char(15),
account-number char(10) not null,
balance integer,
primary key(account-number),
foreign key (branch-name) references branch)

create table depositor

(customer-name char(20) not null,
account-number char(10) not null,
primary key (customer-name, account-number),
foreign key (account-number) references account,
foreign key (customer-name) references customer)

Department of Computer Science and Engineering, HKUST

Slide 13
 Cascading
Cascading Actions
Actions in
in SQL
SQL

create table account

…..
foreign key (branch-name) references branch
on delete cascade
on update cascade,
…)

• Due to the on delete cascade clauses, if a delete of a tuple in branch re

sults in referential-integrity constraint violation, the delete “cascades” t
o the account relation, deleting the tuple that refers to the branch that
was deleted.
• Cascading updates are similar.

Department of Computer Science and Engineering, HKUST

Slide 14
 Cascading
Cascading Actions
Actions in
in SQL
SQL
• If there is a chain of foreign-key dependencies across multiple
relations, with on delete cascade specified for each dependency,
a deletion or update at one end of the chain can propagate
across the entire chain.

• If a cascading update or delete causes a constraint violation

that cannot be handled by further cascading operation, the
system aborts the transaction. As a result, all the changes
caused by the transaction and its cascading actions are undone.

Department of Computer Science and Engineering, HKUST

Slide 15
 Assertions
Assertions
• An assertion is predicate expressing a condition that we wish
the database always to satisfy.
• An assertion in SQL-92 takes the form
create assertion <assertion-name> check <predicate>
• When an assertion is made, the system tests it for validity. This
testing may introduce a significant amount of overhead; hence
assertions should be used with great care.
• Any predicate allowed in SQL can be used.

Department of Computer Science and Engineering, HKUST

Slide 16
 Assertion
Assertion Example
Example 11
• The sum of all loan amounts for each branch must be less than
the sum of all account balances at the branch.

create assertion sum-constraint check

(not exists (select * from branch
where (select sum(amount) from loan
where loan.branch-name=branch.branch-
name) >=
(select sum(amount) from account
where loan.number-name=branch.branch-
name) ))

Department of Computer Science and Engineering, HKUST

Slide 17
 Assertion
Assertion Example
Example 22
• Every loan has at least one borrower who maintains an
account with a minimum balance of $1000.00.

create assertion balance-constraint check loans without

(not exists (select * from loan such an account
where not exists
(select * from borrower, depositor, account
where loan.loan-number=borrower.loan-number
and borrower.customer-name=depositor.customer-
name
and depositor.account-number=account.account-
number
and account.balance >=1000) ))
must return T or F

Department of Computer Science and Engineering, HKUST

Slide 18
 Triggers
Triggers
• A trigger is a statement that is executed automatically by the
system as a side effect of a modification to the database.

• To design a trigger mechanism, we must:

– Specify the conditions under which the trigger is to be
executed.
– Specify the actions to be taken when the trigger executes.

• The SQL-92 standard does not include triggers, but many

implementations support triggers.

Department of Computer Science and Engineering, HKUST

Slide 19
 Trigger
Trigger Example
Example
• Suppose that instead of allowing negative account balances, the
bank deals with overdrafts by
– setting the account balance to zero
– creating a loan in the amount of the overdraft
– giving this loan a loan number which is identical to the
account number of the overdrawn account.

• The condition for executing the trigger is an update to the

account relation that results in a negative balance value.

Department of Computer Science and Engineering, HKUST

Slide 20
 Trigger
Trigger Example
Example

define trigger overdraft on update of account T

(if new T.balance < 0
then (insert into loan values
(T.branch-name, T.account-number, - new T.balance)
insert into borrower
(select customer-name, account-number
from depositor
where T.account-number = depositor.account-
number)
update account S
set S.balance =0
where S.account-number =T.account-number))
The keyword new used before T.balance indicates that the value of
T.balance after the update should be used; if it is omitted, the value
before the update is used.
PL/SQL Trigger Example
Department of Computer Science and Engineering, HKUST
Slide 21
 Leaving
Leaving SQL
SQL
Going
Going into
into Relation
Relation Database
Database Theory
Theory

Department of Computer Science and Engineering, HKUST

Slide 22
 Functional
Functional Dependence
Dependence
• Existence dependence: The existence of B depends on A
• Functional dependence: B’s value depends on A’s value
– EmpName is functionally dependent on EmpNo
– Given the EmpNo, I can one and only one value of EmpName
• Constraints on the set of legal relation instances
• Require that the value for a certain set of attributes determines
uniquely the value for another set of attributes.
• Functional dependence is a generalization of the notion of a key.

Department of Computer Science and Engineering, HKUST

Slide 23
 Functional
Functional Dependencies
Dependencies
• Let R be a relation schema R = ( A, B, C, D, E )
  R,   R  = A, B, C
• The functional dependency  = C, D

holds on R if and only if for a
ny legal relation r(R), whenev Example:
er any two tuples t1 and t2 of r HKID  DoB
agree on the attributes , the
Person
y also agree on the attributes
HKID DoB
. That is, t1
K222222 31/4/1948
t1[] = t2[]  t1[] = t1 P111111 29/2/1979
t2[] R333333 31/2/1961
t2
– True for all tuple pairs K222222 31/4/1948
– True for all instances t2
P111111 31/2/1971 ?
D123456 31/2/1961 ?
Department of Computer Science and Engineering, HKUST
Slide 24
 Alternative
Alternative Definitions
Definitions of
of Keys
Keys
• K is a superkey for relation schema R if and only if K  R
– This is the uniqueness property of “key”
• K is a candidate key for R if and only if
– K  R, and
– there is no   K,   R make sure key is shortest possible
(minimality)

Department of Computer Science and Engineering, HKUST

Slide 25
 Functional
Functional Dependencies
Dependencies
• Functional dependencies allow us to express constraints that ca
nnot be expressed using superkeys. Consider the schema:

Loan-info = (branch-name, loan-number, customer-name, amo

unt)

We expect the following set of functional dependencies to hold:

loan-number  amount
loan-number  branch-name

but would not expect the following to hold:

loan-number  customer-name

Department of Computer Science and Engineering, HKUST

Slide 26
 Examples
Examples

loan-number  amount loan-info

loan-number  branch-name branch-nm loan-no cust-nm amount
Perryridge L-001 Peter Yeung 100000
 customer-name
loan-number  Perryridge L-001 David Chan 100000
Perryridge L-001 May Chan 100000
Wanchai L-002 Leon Lai 100000

loan-info
Another example:
branch-nm loan-no cust-nm amount
reverse of the fd’s above Perryridge L-001 Peter Yeung 100000
Perryridge L-001 Peter Yeung 100000
Central L-001 Peter Yeung 250000
Wanchai L-002 Leon Lai 100000

Department of Computer Science and Engineering, HKUST

Slide 27
 Use
Use of
of Functional
Functional Dependencies
Dependencies
• We use functional dependencies to:
– test relations to see if they are legal under a given set of
functional dependencies. If a relation r is legal under a set F
of functional dependencies, we say that r satisfies F.
– Specify constraints on the set of legal relations; we say that
F holds on R if all legal relations on R satisfy the set of
functional dependencies F.

A specific instance of a relation schema may satisfy a functional

dependency even if the functional dependency does not hold on all
legal instances. For example, a specific instance of Loan-schema may,
by chance, satisfy loan-number  customer-name.

Department of Computer Science and Engineering, HKUST

Slide 28
 Closure
Closure of
of aa Set
Set of
of Functional
Functional Dependencies
Dependencies
• Given a set of functional dependencies F, there are certain other
functional dependencies that are logically implied by F.
• The set of all functional dependencies logically implied by F is
the closure of F.
• We denote the closure of F by F+.
• We can find all of F+ by applying Armstrong’s Axioms:

– if   , then    (reflexivity)
– if   , then    (augmentation)
– if    and  , then    (transitivity)

these rules are sound and complete.

Department of Computer Science and Engineering, HKUST

Slide 29
 Examples
Examples of
of Armstrong’s
Armstrong’s Axioms
Axioms
• We can find all of F+ by applying Armstrong’s Axioms:
– if   , then    (reflexivity)
loan-no  loan-no
loan-no, amount  loan-no
loan-no, amount  amount

– if   , then    (augmentation)
loan-no  amount (given)
loan-no, branch-name  amount, branch-name

– if    and  , then    (transitivity)

loan-no  branch-name (given)
branch-name  branch-city (given)
loan-no  branch-city

Department of Computer Science and Engineering, HKUST

Slide 30
 Closure
Closure
• We can further simplify computation of F+ by using the following ad
ditional rules.

– If    holds and    holds, then    holds (union)

– If    holds, then    holds and    holds (decomposition)
– If    holds and    holds, then    holds (pseudotransitivit
y)

• The above rules can be inferred from Armstrong’s axioms.

E.g.,   ,    (given)
   (by augmentation)
   (by transitivity)

Department of Computer Science and Engineering, HKUST

Slide 31
 Exercise
Exercise
Given loan-no amount
Does loan-no, branch-name  amount
Why???

It is not covered by any of the above axioms, so we must derive it:

loan-no, branch-name  loan-no (reflexivity)

loan-no amount (given)
loan-no, branch-name  amount (transitivity)

Department of Computer Science and Engineering, HKUST

Slide 32
Example

• R = (A, B, C, G, H, I)

• F = {A  B
A C
CG  H
CG  I
B  H}
• some members of F+
A H A  B; B  H
AG  I A  C; AG  CG; CG  I
CG  HI

Department of Computer Science and Engineering, HKUST

Slide 33
 Closure
Closure of
of Attribute
Attribute Sets
Sets
• Define the closure of  under F (denoted by +) as the set of
attributes that are functionally determined by  under F:
   is in F+    +
 is a set of attributes
Given loan-no
If loan-no  amount
then amount is part of loan-no+
I.e., loan-no+= loan-no,amount, …

If loan-no  branch-name
then branch-name is part of loan-no+
I.e., loan-no+= loan-no,amount, branch-name …

If loan-no  customer-name then continue ….

Else stop

Department of Computer Science and Engineering, HKUST

Slide 34
 Algorithm
Algorithm to
to Compute
Compute Closure
Closure
• Algorithm to compute +, the closure of  under F

result:= ; result  a subset of itself

while (changes to result) do
for each    in F do
begin
if   result then result :=result  ;
end
result  

result is a (growing) set of attributes

Department of Computer Science and Engineering, HKUST

Slide 35
Example

• R = (A, B, C, G, H, I)
F= ( A B
A C
CG  H
CG  I
B  H}
• (AG+)
1. Result= AG
2. Result= ABCG (A  C; A  B and A 
AG)
3. Result= ABCGH (CG  H and CG  AGBC)
4. Result=ABCGHI (CG  I and CG  AGBCH)
• Is AG a candidate key? result contains all of
1. AG  R the attributes of R,
2. Does A+  R? so stop
3. Does G+  R?
Question: What is A+ and G+ ?

Department of Computer Science and Engineering, HKUST

Slide 36
 Canonical
Canonical Cover
Cover
• Consider a set F of functional dependencies and the functional depende
ncy    in F.
– Attribute A is extraneous in  if A  and if A is removed from , the set of
functional dependencies implied by F doesn’t change. From A  C

Given AB  C and A  C then B is extraneous in AB I get AB  C
– Attribute A is extraneous in  if A   and if A is removed from , the set o
f functional dependencies implied by F doesn’t change.

Given A  BC and A  B then B is extraneous in BC
• A canonical cover Fc for F is a set of dependencies such that F logically i
mplies all dependencies in Fc and Fc logically implies all dependencies in
F, and further
– No functional dependency in Fc contains an extraneous attribute.
– Each left side of a functional dependency in Fc is unique.

Department of Computer Science and Engineering, HKUST

Slide 37
 Canonical
Canonical Cover
Cover
• Compute a canonical over for F:
repeat
use the union rule to replace any
dependencies in F
1  1 and 1  2 replaced with 1  12
Find a functional dependency   
with an extraneous attribute either in 
or in 
If an extraneous attribute is found, delete it
from

until F does not change
Department of Computer Science and Engineering, HKUST
Slide 38
Example of Computing a Canonical Cover

• R = (A, B, C)
F={ A  BC
A  BC
B  C
B  C
A  B
AB  C
AB  C}
• Combine A  BC and A  B into A 
A  BC
BC A  BC
B C
• A is extraneous in AB  C because B  B C B C
C logically implies AB  C.
• C is extraneous in A  BC since A  BC A B
is logically implied by A  B and B  C. B C
• The canonical cover is:
AB
BC

Department of Computer Science and Engineering, HKUST

Slide 39
 Example
Example
• R = (A, B, C, G, H, I)
F={ AB
AC
CG  H
CG  I
B  H}
• some members of F +
– AH
• by transitivity from A  B and B  H
– AG  I
• by augmenting A  C with G, to get AG  CG
and then transitivity with CG  I
– CG  HI
• from CG  H and CG  I : “union rule” can be inferred from
– definition of functional dependencies, or
– Augmentation of CG  I to infer CG  CGI, augmentation of
CG  H to infer CGI  HI, and then transitivity

Department of Computer Science and Engineering, HKUST

Slide 40