Databases Reference
In-Depth Information
the same tuple to appear in two different places if those two appearances represent the same proposition. (Obviously
we'd like to prohibit duplicate propositions as such; unfortunately, however, the DBMS doesn't understand
propositions as such.) But it's all right for the same tuple to appear twice if those two appearances
don't
represent
the same proposition─and in any case we can have redundancy without any tuple appearing twice at all, as we've
seen.
Normalization and orthogonality seem to be all we have by way of a scientific attack on the redundancy issue
at the present time. Unfortunately, we've seen that normalization and orthogonality don't solve the whole
problem─they can reduce redundancy, but they can't eliminate it entirely, in general. To be specific, we've seen
several examples of designs that fully conform to the principles of normalization and orthogonality and yet display
some redundancy, and those discussions were certainly far from exhaustive. We need more science! (Now I've told
you that at least three times, and what I tell you three times is true.)
Given the foregoing state of affairs, it seems that redundancy will definitely exist in most databases. If it
does:
It should at least be controlled, in the sense that the DBMS should take responsibility for guaranteeing that it
never leads to inconsistency.
If it can't be controlled, then appropriate constraints should at least be declared, and enforced by the system,
to ensure (again) that it never leads to inconsistency.
If it can't be controlled and constraints can't be enforced by the system (or perhaps can't even be formally
declared), then you're on your own─and woe betide you if you make any mistakes.
Sadly, this last scenario is the one most likely to obtain in practice, given the state of today's commercial
implementations.
EXERCISES
15.1 I claimed in the body of the chapter that if proposition
p
involves no existential quantification and database
DB
contains (either explicitly or implicitly) two or more distinct representations of
p
, then
DB
contains some
redundancy. Can you think of a database that doesn't contain two or more distinct representations of any such
proposition (either explicitly or implicitly) and yet in your opinion still displays some redundancy?
