Databases Reference

In-Depth Information

Note that neither kind of redundancy implies the other; that is, a relvar can be FD redundant without being

JD redundant, or JD redundant without being FD redundant.
11
For example:

Relvar SPJ from Chapter 9 (with its attributes SNO, PNO, and JNO; key the combination of all three

attributes; and JD
{{SNO,PNO},{PNO,JNO},{JNO,SNO}}) is in BCNF and hence not FD redundant, but

it's clearly JD redundant.

The suppliers relvar S (with its attributes SNO, SNAME, STATUS, and CITY; key SNO; and FD {CITY} →

{STATUS}) isn't in BCNF and is therefore FD redundant. But no tuple forcing JDs hold in that relvar, and

so it isn't JD redundant.

Now to continue with the definitions:

Definition:
Relvar
R
is
redundancy free
if and only if it's neither FD redundant nor JD redundant.
12

Note that a 5NF relvar is certainly redundancy free by the foregoing definition. So is an SKNF relvar, come

to that; but a relvar doesn't have to be in 5NF, or even SKNF, in order to be redundancy free (see below).

Definition:
Relvar
R
is in
redundancy free normal form
(RFNF) if and only if it's redundancy free.

In other words, relvar
R
is in RFNF if and only if it's neither FD redundant nor JD redundant: equivalently, if

and only if it's in BCNF and no tuple forcing JD holds.

Of course, while the foregoing definition is both precise and accurate, it's of little practical use, because it

doesn't help much with the question of determining whether a given relvar is indeed in RFNF. But there's a

theorem that does help in this regard:

Theorem:
Relvar
R
is in RFNF if and only if it's in BCNF and, for every explicit JD
J
that holds in
R
, some

component of
J
is a superkey for
R
.

This theorem provides both necessary and sufficient conditions for a relvar to be in RFNF. We can therefore

take the theorem as a useful, usable test for RFNF: in effect, as a valid
definition
of RFNF.
Note:
The theorem

refers to
explicit
JDs of
R
, but in fact we could drop that qualifier and what would be left would still be true (i.e.,
R

is in RFNF if and only if
every
JD that holds in
R
has a superkey component). However, including that qualifier

makes the theorem “tighter,” in a sense. In particular, it means there's no need to check a relvar's implicit JDs in

order to test whether the relvar in question is in RFNF. (As a matter of fact, we could make the theorem tighter still

by replacing “every explicit JD” by “every explicit
irreducible
JD.” In practice, however, it would be quite unlikely

for some explicit JD not to be irreducible, so the point is perhaps not very important.)

The next theorem shows that RFNF does indeed fall strictly between 4NF and 5NF; in fact, it falls strictly

between 4NF and SKNF.
13

11
This state of affairs lends weight to something I said in Chapter 9: viz., that it's better to regard FDs and JDs as different phenomena, instead of

thinking of FDs as a special case of JDs.

12
The term
redundancy free
here is perhaps not well chosen, giving as it does a very specialized meaning to an otherwise very general term.

13
Relvar SPJ′ is a concrete example of a relvar that's in RFNF but (as noted in an earlier footnote) not in SKNF.