Database normalization is the process of organizing the fields and tables of a relational database
to minimize redundancy. Normalization usually involves dividing large tables into smaller
tables and defining relationships between them. The objective is to isolate data so
that additions, deletions, and modifications of a field can be made in just one table and
then propagated through the rest of the database using the defined relationships.
Edgar F. Codd, the inventor of the relational model, introduced the concept of normalization
and what we now know as the First Normal Form in 1970. Codd went on to define the Second
Normal Form and Third Normal Form in 1971, and Codd and Raymond F. Boyce defined the
Boyce-Codd Normal Form in 1974. Informally, a relational database table is often described
as "normalized" if it is in the Third Normal Form. Most 3NF tables are free of insertion,
update, and deletion anomalies. A standard piece of database design guidance
is that the designer should first create a fully normalized design; then selective denormalization
can be performed for performance reasons. A typical example of normalization is that
a unique ID is stored everywhere in the system but its name is held in only one table. The
name can be updated more easily in one row of one table. A typical update in such an
example would be the RIM company changing its name to BlackBerry. That update would
be done in one place and immediately the correct "BlackBerry" name would be displayed throughout
the system.
Objectives A basic objective of the first normal form
defined by Codd in 1970 was to permit data to be queried and manipulated using a "universal
data sub-language" grounded in first-order logic.
The objectives of normalization beyond 1NF were stated as follows by Codd:
1. To free the collection of relations from undesirable insertion, update and deletion
dependencies; 2. To reduce the need for restructuring the
collection of relations, as new types of data are introduced, and thus increase the life
span of application programs; 3. To make the relational model more informative
to users; 4. To make the collection of relations neutral
to the query statistics, where these statistics are liable to change as time goes by.
— E.F. Codd, "Further Normalization of the Data Base Relational Model"
The sections below give details of each of these objectives.
Free the database of modification anomalies
When an attempt is made to modify a table, undesired side-effects may follow. Not all
tables can suffer from these side-effects; rather, the side-effects can only arise in
tables that have not been sufficiently normalized. An insufficiently normalized table might have
one or more of the following characteristics: The same information can be expressed on multiple
rows; therefore updates to the table may result in logical inconsistencies. For example, each
record in an "Employees' Skills" table might contain an Employee ID, Employee Address,
and Skill; thus a change of address for a particular employee will potentially need
to be applied to multiple records. If the update is not carried through successfully—if,
that is, the employee's address is updated on some records but not others—then the
table is left in an inconsistent state. Specifically, the table provides conflicting answers to
the question of what this particular employee's address is. This phenomenon is known as an
update anomaly. There are circumstances in which certain facts
cannot be recorded at all. For example, each record in a "Faculty and Their Courses" table
might contain a Faculty ID, Faculty Name, Faculty Hire Date, and Course Code—thus
we can record the details of any faculty member who teaches at least one course, but we cannot
record the details of a newly hired faculty member who has not yet been assigned to teach
any courses except by setting the Course Code to null. This phenomenon is known as an insertion
anomaly. Under certain circumstances, deletion of data
representing certain facts necessitates deletion of data representing completely different
facts. The "Faculty and Their Courses" table described in the previous example suffers
from this type of anomaly, for if a faculty member temporarily ceases to be assigned to
any courses, we must delete the last of the records on which that faculty member appears,
effectively also deleting the faculty member. This phenomenon is known as a deletion anomaly.
Minimize redesign when extending the database structure
When a fully normalized database structure is extended to allow it to accommodate new
types of data, the pre-existing aspects of the database structure can remain largely
or entirely unchanged. As a result, applications interacting with the database are minimally
affected. It is very useful in table creation. Make the data model more informative to users
Normalized tables, and the relationship between one normalized table and another, mirror real-world
concepts and their interrelationships. Avoid bias towards any particular pattern
of querying Normalized tables are suitable for general-purpose
querying. This means any queries against these tables, including future queries whose details
cannot be anticipated, are supported. In contrast, tables that are not normalized lend themselves
to some types of queries, but not others. For example, consider an online bookseller
whose customers maintain wishlists of books they'd like to have. For the obvious, anticipated
query—what books does this customer want?—it's enough to store the customer's wishlist in
the table as, say, a homogeneous string of authors and titles.
With this design, though, the database can answer only that one single query. It cannot
by itself answer interesting but unanticipated queries: What is the most-wished-for book?
Which customers are interested in WWII espionage? How does Lord Byron stack up against his contemporary
poets? Answers to these questions must come from special adaptive tools completely separate
from the database. One tool might be software written especially to handle such queries.
This special adaptive software has just one single purpose: in effect to normalize the
non-normalized field. Unforeseen queries can be answered trivially,
and entirely within the database framework, with a normalized table.
Example Querying and manipulating the data within
a data structure which is not normalized, such as the following non-1NF representation
of customers' credit card transactions, involves more complexity than is really necessary:
To each customer corresponds a repeating group of transactions. The automated evaluation
of any query relating to customers' transactions therefore would broadly involve two stages:
Unpacking one or more customers' groups of transactions allowing the individual transactions
in a group to be examined, and Deriving a query result based on the results
of the first stage For example, in order to find out the monetary
sum of all transactions that occurred in October 2003 for all customers, the system would have
to know that it must first unpack the Transactions group of each customer, then sum the Amounts
of all transactions thus obtained where the Date of the transaction falls in October 2003.
One of Codd's important insights was that this structural complexity could always be
removed completely, leading to much greater power and flexibility in the way queries could
be formulated and evaluated. The normalized equivalent of the structure above would look
like this: Now each row represents an individual credit
card transaction, and the DBMS can obtain the answer of interest, simply by finding
all rows with a Date falling in October, and summing their Amounts. The data structure
places all of the values on an equal footing, exposing each to the DBMS directly, so each
can potentially participate directly in queries; whereas in the previous situation some values
were embedded in lower-level structures that had to be handled specially. Accordingly,
the normalized design lends itself to general-purpose query processing, whereas the unnormalized
design does not. Background to normalization: definitions
Functional dependency In a given table, an attribute Y is said to
have a functional dependency on a set of attributes X if and only if each X value is associated
with precisely one Y value. For example, in an "Employee" table that includes the attributes
"Employee ID" and "Employee Date of Birth", the functional dependency {Employee ID} → {Employee
Date of Birth} would hold. It follows from the previous two sentences that each {Employee
ID} is associated with precisely one {Employee Date of Birth}.
Full functional dependency An attribute is fully functionally dependent
on a set of attributes X if it is: functionally dependent on X, and
not functionally dependent on any proper subset of X. {Employee Address} has a functional
dependency on {Employee ID, Skill}, but not a full functional dependency, because it is
also dependent on {Employee ID}.Even by the removal of {Skill} functional dependency still
holds between {Employee Address} and {Employee ID}.
Transitive dependency A transitive dependency is an indirect functional
dependency, one in which X→Z only by virtue of X→Y and Y→Z.
Trivial functional dependency A trivial functional dependency is a functional
dependency of an attribute on a superset of itself. {Employee ID, Employee Address} → {Employee
Address} is trivial, as is {Employee Address} → {Employee Address}.
Multivalued dependency A multivalued dependency is a constraint according
to which the presence of certain rows in a table implies the presence of certain other
rows. Join dependency
A table T is subject to a join dependency if T can always be recreated by joining multiple
tables each having a subset of the attributes of T.
Superkey A superkey is a combination of attributes
that can be used to uniquely identify a database record. A table might have many superkeys.
Candidate key A candidate key is a special subset of superkeys
that do not have any extraneous information in them: it is a minimal superkey.
Example: A table with the fields , ,
and has many possible superkeys. Three of these are , <Phone Extension,
Name> and . Of those, only is a candidate key as the others contain information
not necessary to uniquely identify records.
Non-prime attribute A non-prime attribute is an attribute that
does not occur in any candidate key. Employee Address would be a non-prime attribute in
the "Employees' Skills" table. Prime attribute
A prime attribute, conversely, is an attribute that does occur in some candidate key.
Primary key One candidate key in a relation may be designated
the primary key. While that may be a common practice, it is strictly notational and has
no bearing on normalization. With respect to normalization, all candidate keys have
equal standing and are treated the same. Normal forms
The normal forms of relational database theory provide criteria for determining a table's
degree of immunity against logical inconsistencies and anomalies. The higher the normal form
applicable to a table, the less vulnerable it is. Each table has a "highest normal form":
by definition, a table always meets the requirements of its HNF and of all normal forms lower than
its HNF; also by definition, a table fails to meet the requirements of any normal form
higher than its HNF. The normal forms are applicable to individual
tables; to say that an entire database is in normal form n is to say that all of its
tables are in normal form n. Newcomers to database design sometimes suppose
that normalization proceeds in an iterative fashion, i.e. a 1NF design is first normalized
to 2NF, then to 3NF, and so on. This is not an accurate description of how normalization
typically works. A sensibly designed table is likely to be in 3NF on the first attempt;
furthermore, if it is 3NF, it is overwhelmingly likely to have an HNF of 5NF. Achieving the
"higher" normal forms does not usually require an extra expenditure of effort on the part
of the designer, because 3NF tables usually need no modification to meet the requirements
of these higher normal forms. The main normal forms are summarized below.
Denormalization
Databases intended for online transaction processing are typically more normalized than
databases intended for online analytical processing. OLTP applications are characterized by a high
volume of small transactions such as updating a sales record at a supermarket checkout counter.
The expectation is that each transaction will leave the database in a consistent state.
By contrast, databases intended for OLAP operations are primarily "read mostly" databases. OLAP
applications tend to extract historical data that has accumulated over a long period of
time. For such databases, redundant or "denormalized" data may facilitate business intelligence
applications. Specifically, dimensional tables in a star schema often contain denormalized
data. The denormalized or redundant data must be carefully controlled during extract, transform,
load processing, and users should not be permitted to see the data until it is in a consistent
state. The normalized alternative to the star schema is the snowflake schema. In many cases,
the need for denormalization has waned as computers and RDBMS software have become more
powerful, but since data volumes have generally increased along with hardware and software
performance, OLAP databases often still use denormalized schemas.
Denormalization is also used to improve performance on smaller computers as in computerized cash-registers
and mobile devices, since these may use the data for look-up only. Denormalization may
also be used when no RDBMS exists for a platform, or no changes are to be made to the data and
a swift response is crucial. Non-first normal form
Denormalization is the opposite of normalization. In recognition that denormalization can be
deliberate and useful, the non-first normal form is a definition of database designs which
do not conform to first normal form, by allowing "sets and sets of sets to be attribute domains".
The languages used to query and manipulate data in the model must be extended accordingly
to support such values. One way of looking at this is to consider
such structured values as being specialized types of values, with their own domain-specific
languages. However, what is usually meant by non-1NF models is the approach in which
the relational model and the languages used to query it are extended with a general mechanism
for such structure; for instance, the nested relational model supports the use of relations
as domain values, by adding two additional operators to the relational algebra that can
create and flatten nested relations, respectively. Consider the following table:
Assume a person has several favourite colours. Obviously, favourite colours consist of a
set of colours modeled by the given table. To transform a 1NF into an NF² table a "nest"
operator is required which extends the relational algebra of the higher normal forms. Applying
the "nest" operator to the 1NF table yields the following NF² table:
To transform this NF² table back into a 1NF an "unnest" operator is required which extends
the relational algebra of the higher normal forms. The unnest, in this case, would make
"colours" into its own table. Although "unnest" is the mathematical inverse
to "nest", the operator "nest" is not always the mathematical inverse of "unnest". Another
constraint required is for the operators to be bijective, which is covered by the Partitioned
Normal Form. Categorical Normal Form
A relational schema such that every table is either 1) unary or 2) a binary function
between unary tables is a presentation of a freely generated category. An instance on
such a schema is a functor from the free category to the category of sets. If the schema further
imposes path equivalence constraints, then the schema denotes a finitely presented category.
A schema denoting a finitely presented category is said to be in categorical normal form.
See also Aspect
Business rule Canonical form
Cross-cutting concern Database testing
Optimization Refactoring
Universal relation assumption Notes and references
Further reading Litt's Tips: Normalization
Date, C. J., An Introduction to Database Systems. Addison-Wesley Longman. ISBN 0-321-19784-4.
Kent, W. A Simple Guide to Five Normal Forms in Relational Database Theory, Communications
of the ACM, vol. 26, pp. 120–125 H.-J. Schek, P.
Pistor Data Structures for an Integrated Data Base Management and Information Retrieval
System External links
Database Normalization Basics by Mike Chapple Database Normalization Intro, Part 2
An Introduction to Database Normalization by Mike Hillyer.
A tutorial on the first 3 normal forms by Fred Coulson
DB Normalization Examples Description of the database normalization
basics by Microsoft Database Normalization and Design Techniques
by Barry Wise, recommended reading for the Harvard MIS.
A Simple Guide to Five Normal Forms in Relational Database Theory