Decomposition: by Yuhung Chen CS157A Section 2 October 27 2005

Decomposition
By Yuhung Chen
CS157A
Section 2
October 27 2005
Undesirable Properties of Bad Design
 Redundancy, resulting in waste of space

and complicated updates
(inconsistencies.)
 Inability to represent certain information
– ex Null values.
 Loss of information.
How to avoid ?
 Properties of information repetition and null

values suggest -- Decomposition of relation
schema.
 Properties of information loss -- Non-lossy-

join decomposition.
Decompositions
 There are careless, “bad” decompositions.
 There are three desirable properties:
1. Lossless.
2. Dependency preservation.
3. Minimal redundancy.
Relation Decomposition
 One of the properties of bad design suggests
to decompose a relation into smaller
relations.
 Must achieve lossless-join decomposition.
Example of Relation Decomposition
Lossless Join Decomposition
 Definition:
 Let { R1, R2 } be a decomposition of R
(R1 U R2 = R); the decomposition is

lossless if for every legal instance r of R:
r = ΠR1(r) |X| ΠR2(r)
Testing Lossless Join
 Lossless join property is necessary if the decomposed
relation is to be recovered from its decomposition.
 Let R be a schema and F be a set of FD’s on R, and α = (R1,
R2) be a decomposition of R. Then α has a lossless join with

respect to F iff
R1 ∩ R2 -> R1 (or R1 - R2 ) or
R2 ∩ R1 -> R2 (or R2 - R1 )
where such FD exist in Closure of F
PS This is a sufficient condition, but not a necessary
condition.
Example of L-J Decomposition
From the previous example : R = (ABC) F = {A -> B}
R1 = (AB), R2 = (AC)
R1∩ R2 = A, R1- R2 = B
check A -> B in F ? Yes. Therefore lossless
R1 = (AB), R2 = (BC)
R1∩ R2 = B, R1 - R2 = A , R2 - R1= C
check B -> A in F ? NO
check B -> C in F ? NO
So, this is lossy join.
Another example
R = (City, Street, Zip) F = {CS -> Z, Z -> C}
R1 = (CZ) R2 = (SZ)
R1 ∩ R2 = Z , R1 – R2 = (SZ)
check Z -> C in F ? Yes
Therefore, the decomposition to be (CZ) (SZ) is

lossless join decomposition.
Why do we preserve the dependency?
 We would like to check easily that updates
to the database do not result in illegal
relations being created.
 It would be nice if our design allowed us to
check updates without having to compute
natural joins.
Dependency Preservation Decomposition
 Definition: Each FD specified in F either appears directly
in one of the relations in the decomposition, or be inferred
from FDs that appear in some relation.
Test of Dependency Preservation
 If a decomposition is not dependency-preserving,
some dependency is lost in the decomposition.
 One way to verify that a dependency is not lost is to
take joins of two or more relations in the
decomposition to get a relation that contains all of the
attributes in the dependency under consideration and
then check that the dependency holds on the result of
the joins.
Test of Dependency Preservation II
 Find F - F', the functional dependencies not
checkable in one relation.
 See whether this set is obtainable from F'
by using Armstrong's Axioms.
 This should take a great deal less work, as
we have (usually) just a few functional
dependencies to work on.
Dependency Preserving Example
 Consider relation ABCD, with FD’s :
A ->B, B ->C, C ->D
 Decompose into two relations: ABC and
CD.
 ABC supports the FD’s A->B, B->C.
 CD supports the FD C->D.
 All the original dependencies are preserved.
Non-Dependency Preserving Example
 Consider relation ABCD, with FD’s:
A ->B, B ->C, C->D
 Decompose into two relations: ACD and BC.
 ACD supports the FD B ->C and implied FD A
->C.
 BC supports the FD B->C.
 However, no relation supports A ->B.
So the dependency is not preserved.
Minimal Redundancy
 In order to achieve the lack of redundancy,
we do some decomposition which is
represented by several normal forms.
Normal Form Decompositions
Comparison
 3NF Decomposition:
 lossless.
 Dependency preserving.
 BCNF Decomposition:
 Lossless.
 Not necessarily dependency-preserving.
 Component relations are all BCNF, and thus 3NF.
 4NF Decomposition:
 Lossless.
 Not necessarily are all 4NF, and thus BCNF and 3NF.
 No decomposition is guaranteed to preserve all multi-value

dependencies.
Lossless Check Example
 Consider five attributes: ABCDE
 Three relations: ABC, AD, BDE
 FD’s: A ->BD, B ->E
A B C D E
ABC a1 a2 a3 b14 b15
AD a1 b22 b23 a4 b25
BDE b21 a2 b33 a4 a5
Conclusion
 Decompositions should always be lossless.
 Decompositions should be dependency
preserving whenever possible.
 We have to perform the normal
decomposition to make sure we get rid of
the minimal redundant information.
Reference
 http://www.cs.hmc.edu/courses/2004/spring/cs133/de
comp.6.pdf
 http://www.cs.sfu.ca/CC/354/zaiane/material/notes/C
hapter7/node8.html
 http://clem.mscd.edu/~tuckerp/CSI3310/C15.1.html
 http://wwwis.win.tue.nl/~aaerts/2M400/pdf/ColNotes7.
pdf

Decomposition: by Yuhung Chen CS157A Section 2 October 27 2005

Uploaded by

Copyright:

Available Formats

Decomposition: by Yuhung Chen CS157A Section 2 October 27 2005

Uploaded by

Document Information

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

Decomposition: by Yuhung Chen CS157A Section 2 October 27 2005

Uploaded by

Copyright:

Available Formats

Decomposition

 Redundancy, resulting in waste of space

 Properties of information repetition and null

 Properties of information loss -- Non-lossy-

(R1 U R2 = R); the decomposition is

R2) be a decomposition of R. Then α has a lossless join with

Therefore, the decomposition to be (CZ) (SZ) is

 Not necessarily dependency-preserving.

 Component relations are all BCNF, and thus 3NF.

 No decomposition is guaranteed to preserve all multi-value

You might also like