.......1 INTRODUCTION ...........................2 THE PROBLEM: KEEPING TRACK OF A STACK OF INVOICES ...................................5 SECOND NORMAL FORM: NO PARTIAL DEPENDENCIES ON A CONCATENATED KEY...................................................................................................3 FIRST NORMAL FORM: NO REPEATING ELEMENTS OR GROUPS OF ELEMENTS.......8 SECOND NORMAL FORM: PHASE II ....................15 REFERENCES FOR FURTHER READING ...............................com/resources/nf3/
........................................................................................................................18
3 Normal Forms Tutorial 1
http://phlonx................................................................................................12 THIRD NORMAL FORM: NO DEPENDENCIES ON NON-KEY ATTRIBUTES....................Table of Contents
Table of Contents
TABLE OF CONTENTS ..................................

com/resources/nf3/
. Just memorize them for now: 1. To demonstrate the main principles involved. No repeating elements or groups of elements 2. Denormalization is a fairly common task. For those who wish to pursue the matter in greater depth. No partial dependencies on a concatenated key 3. No dependencies on non-key attributes
3 Normal Forms Tutorial 2
http://phlonx. When people sit down to design a database. In fact. The sample database screenshots are not meant to be taken literally. they often already have a partially-normalized structure in mind—normalization is a natural way of perceiving relationships between data and no special skill in mathematics or set theory is required. For the most part. remove the natural efficient relationships that a normalized data structure provides).Introduction
Introduction
This is meant to be a very brief tutorial aimed at beginners who want to get a conceptual grasp on the database normalization process. The meaning will become clear as we go. I find it very difficult to visualize these concepts using words alone. Important Note: This is not a description of how you would actually design and implement a database. Purists and academics may not be interested in this treatment. I will not cover issues such as the benefits and drawbacks of normalization. memorize the 3 normal forms so that you can recite them in your sleep. it usually takes quite a bit of work to de-normalize a database (that is. but merely as visual aids to show how the raw data gets shuffled about as the table structure becomes increasingly normalized. the first three normal forms are common sense. To begin: First. a list of references for further reading is provided at the end. so I shall rely as much as possible upon pictures and diagrams. we will take the classic example of an Invoice and level it to the Third Normal Form. We will also construct an Entity Relationship Diagram (ERD) of the database as we go. but it is beyond the scope of this presentation.

The Problem: Keeping Track of a Stack of Invoices
The Problem: Keeping Track of a Stack of Invoices
Consider a typical invoice (Figure A).
Figure A: Invoice
Those of us who have an ordered mind but aren't quite aware of relational databases might try to capture the Invoice data in a spreadsheet. such as Microsoft Excel.com/resources/nf3/
.
3 Normal Forms Tutorial 3
http://phlonx.

The Problem: Keeping Track of a Stack of Invoices
Figure A-1: orders spreadsheet
This isn't a bad approach. such as: • • • How many 3" Red Freens did Freens R Us order in 2002? What are total sales of 56" Blue Freens in the state of Texas? What items were sold on July 14. 2003?
As the spreadsheet grows it becomes increasingly difficult to ask the spreadsheet these questions. In an attempt to put the data into a state where we can reasonably expect to answer such questions. But what if you started to ask complicated questions. since it records every purchase made by every customer.
3 Normal Forms Tutorial 4
http://phlonx.com/resources/nf3/
. we begin the normalization process.

Cells H2. We can satisfy NF1's need for atomicity quite simply: by separating each item in these lists into its own row. we will refer to this thing as a row. I2-I4 constitute a single column. L2-L4. On Figure A-1. First Normal Form (NF1) wants us to get rid of repeating elements. and M2-M4. you'll never hear it again for the rest of your database career). same with J2-J4. These represent all the data we have for a single invoice (Invoice #125). and H4 contain a list of Item ID numbers. H3. 3 and 4 on the spreadsheet in Figure A-1.
3 Normal Forms Tutorial 5
http://phlonx. 3 and 4 as a tuple (pronounced tu'ple or too'ple). So.First Normal Form: No Repeating Elements or Groups of Elements
First Normal Form: No Repeating Elements or Groups of Elements
Take a look at rows 2. In database lingo. Never mind the fact that one database row is made up here of three spreadsheet rows: It's an unfortunate ambiguity of language. K2K4. We're not going to use that word here (and if you're lucky. NF1 craves atomicity: the indivisibility of an attribute into similar parts. that is the following cells: • • • H2 through M2 H3 through M3 H4 through M4
Similar (though not necessarily identical) data repeats within Invoice #125's row. Similarly. Academic database theoreticians have a special word that helps a bit with the ambiguity: they refer to the "thing" encapsulated by rows 2. this group of rows is referred to as a single database row. Database columns are sometimes referred to as attributes (rows/columns are the same as tuples/attributes).com/resources/nf3/
. You will notice that each of these columns contains a list of values. Therefore it is clear that we have to do something about the repeating item information data within the row for Invoice #125. This is a column within our first database row. It is precisely these lists that NF1 objects to: NF1 abhors lists or arrays within a single database column. What are those? Again we turn our attention to the first invoice (#125) in Figure A-1. Here.

Even though they are in two different table columns. this is a necessary step in the process. When this value is made up of two or more columns. But to make the point about Primary Keys.First Normal Form: No Repeating Elements or Groups of Elements
Figure A-2: flattened orders spreadsheet
I can hear everyone objecting: We were trying to reduce the amount of duplication. Strictly speaking. and here we have introduced more! Just look at all that duplicated customer data! Don't worry.
The two columns that together uniquely identify each row are order_id and item_id: no two rows have the same combination of order_id and item_id. but the difference is that within an RDBMS we can identify a primary key.com/resources/nf3/
. A row of data cannot contain repeating groups of similar data (atomicity) 2.
identifies a row is called a primary key. NF1 addresses two issues: 1. Please be patient. they are treated as a single entity. The kind of duplication that we introduce at this stage will be addressed when we get to the Third Normal Form. Therefore. As you can see from Figure B. Here we shall use Microsoft Access to create the orders table. together they qualify to be used as the table's primary key. Each row of data must have a unique identifier (or Primary Key) We have already dealt with atomicity.
3 Normal Forms Tutorial 6
http://phlonx. However. A primary key is A value that uniquely a column (or group of columns) that uniquely identifies each row. we shall bid farewell to the spreadsheet and move our data into a relational database management system (RDBMS). if we put a number of columns together. it is referred to as a concatenated primary key. we can satisfy this requirement. as in Figure B:
Figure B: orders table
This looks pretty much the same as the spreadsheet. We have actually only told half the story of NF1. We call them concatenated. there is no single column that uniquely identifies each row.

First Normal Form: No Repeating Elements or Groups of Elements The underlying structure of the orders table can be represented as Figure C: We identify the columns that make up the primary key with the PK notation. Our database schema now satisfies the two requirements of First Normal Form: atomicity and uniqueness. Figure C is the beginning of our Entity Relationship Diagram (or ERD). Thus it fulfills the most basic criteria of a relational database. What's next?
Figure C: orders table structure
3 Normal Forms Tutorial 7
http://phlonx.com/resources/nf3/
.

recall the meaning of the two columns in the primary key: • • order_id identifies the invoice that this item comes from. You can think of it as a part number. Some of you might object. Now consider the remaining columns. Can this column exist without one or the other part of the concatenated primary key? If the answer is "yes" — even once — then the table fails Second Normal Form. in effect).Second Normal Form: No Partial Dependencies on a Concatenated Key
Second Normal Form: No Partial Dependencies on a Concatenated Key
Next we test each table for partial dependencies on a concatenated key. order_date is the date on which the order was made. each column in the table that is not part of the primary key must depend upon the entire concatenated key for its existence. then we say that the entire table has failed Second Normal Form and we must create another table to rectify the failure. inventory control number.
Figure C: orders table structure
We don't analyze these columns (since they are part of the primary key).. thinking that this means you could have a dated order with no items (an empty invoice. otherwise it is only a date. SKU. For each column we will ask the question. or UPC code.. But can an order date exist without an item_id? The short answer is yes: order_date relies on order_id. let's take apart the orders table column by column. This means that for a table that has a concatenated primary key. Still not clear? To try and understand this. Obviously it relies on order_id. it does not. The problem of how to prevent empty
3 Normal Forms Tutorial 8
http://phlonx. item_id is the inventory item's unique identifier. But this is not what we are saying at all: All we are trying to establish here is whether a particular order on a particular date relies on a particular item. Refer to Figure C again to remind us of the orders table structure. not item_id. an order date has to have an order. First. If any column only depends upon one part of the concatenated key. Clearly.com/resources/nf3/
.

Can the quantity exist without an order_id? No: a quantity that is purchased with an invoice is meaningless without an invoice. But can it exist without an order_id? Yes! An inventory item (together with its "description") could sit on a warehouse shelf forever. in which case it passes Second Normal Form. Does it rely on order_id? No: a customer can exist without placing any orders. What to do with this field? In fact. It can exist independent of an order. What do we do with these columns? We don't have to worry about them until we get to Third Normal Form. item_description fails the test. item_description is the next column that is not itself part of the primary key. So this column does not violate Second Normal Form: item_qty depends on both parts of our concatenated primary key.com/resources/nf3/
. But let's continue with testing the other columns. We mark them as "unknown" for now. and never be purchased. and then we do something special with them.. Can this quantity exist without an item_id? Impossible: we cannot talk about the "amount of nothing" (at least not in database design). On the one hand. to include it would be redundant (and could quite possibly introduce corruption). Obviously it relies on item_id. item_qty refers to the number of items purchased on a particular invoice. Therefore we will discard it and speak of it no more. On the other hand. Therefore: order_date fails Second Normal Form. item_price is similar to item_description. So voilá. It depends on the item_id but not on the order_id. it is a derived value: it is merely the product of item_qty and item_price. We have to find all the columns that fail the test. this field does not belong in our database at all. it is not an issue for Normalization to solve. Does it rely on item_id? No: for the same reason. so it does violate Second Normal Form. customer_id is the ID number of the customer who placed the order. This is interesting: customer_id (along with the rest of the customer_* columns) does not rely on either member of the primary key.. it seems to depend on both order_id and item_id. our table has already failed Second Normal Form.
3 Normal Forms Tutorial 9
http://phlonx. item_total_price is a tricky one.Second Normal Form: No Partial Dependencies on a Concatenated Key orders falls under a discussion of "business rules" and could be resolved using check constraints or application logic. This is the plain-language description of the inventory item. It can easily be reconstructed outside of the database proper.

Here is the markup from our NF2 analysis of the orders table:
Figure C (revised):
What do we do with a table that fails Second Normal Form.com/resources/nf3/
. the sum of all the item_total_price fields for a particular order. is another derived value.
Figure D: orders and order_items tables
3 Normal Forms Tutorial 10
http://phlonx. as this one has? First we take out the second half of the concatenated primary key (item_id) and put it in its own table.Second Normal Form: No Partial Dependencies on a Concatenated Key order_total_price.follow it into the new table. We discard this field too. All the columns that depend on item_id whether in whole or in part . We call this new table order_items (see Figure D). The other fields — those that rely on just the first half of the primary key (order_id) and those we aren't sure about — stay where they are.

but at least one.Second Normal Form: No Partial Dependencies on a Concatenated Key There are several things to notice: 1. This allows each order_item to "remember" which order it is a part of.com/resources/nf3/
. order_id.
There are other ways of depicting these table-to-table relationships. The primary key now consists of a single column.
3 Normal Forms Tutorial 11
http://phlonx. The orders table no longer has a concatenated primary key.
• •
each order can be associated with any number of order-items. We have brought a copy of the order_id column over into the order_items table. in English. pay close attention to the line that connects these two tables. The order_items table does have a concatenated primary key. The orders table has fewer rows than it did before. 2. and only one. Here is the table structure (Figure E):
Figure E: orders and order_items table structure
If you are new to Entity Relationship Diagrams. each order-item is associated with one order. 4. This line means. here I am using one of many standard conventions. 3.

this column once again fails NF2. item_qty relies on both members of the primary key.com/resources/nf3/
. to remind us of the order_items table structure. So (surprise). We have to pass it through the NF2 analysis again. We should be getting good at this now. refer to Figure F. item_description relies on item_id. still has a concatenated primary key. Now that orders has a single-column primary key. but not order_id. It does not violate NF2. there's more! Remember. however. item_price relies on the item_id but not on the order_id.Second Normal Form: Phase II
Second Normal Form: Phase II
But wait. and see if it measures up. Here is the marked up table diagram:
Figure F (revised): Figure F:
3 Normal Forms Tutorial 12
http://phlonx. Congratulations! order_items. NF2 only applies to tables with a concatenated primary key. so it does violate Second Normal Form.. Now consider the columns that are not part of the primary key.. We ask the same question we did before: Can this column exist without one or the other part of the concatenated primary key? First. it has passed Second Normal Form.

com/resources/nf3/
. item_qty stays where it is. we took out all the fields that relied on item_id and put them into the new table. we removed the item_id key from the orders table altogether. because of the one-to-many relationship between orders and order-items. When we did our first pass through the NF2 test.Second Normal Form: Phase II So. we take the fields that fail NF2 and create a new table. we are only taking the fields that failed the test: in other words. This time. item_id was not removed from the order_items table because of the many-to-one relationship between order-items and items. We call this new table items:
Figure G: order_items and items table
But wait. Therefore. Therefore the item_qty field had to follow item_id into the new table. since item_qty does not violate NF2 this time. something's wrong. Why? What's different this time? The difference is that in the first pass. In the second pass.
3 Normal Forms Tutorial 13
http://phlonx. it is permitted to stay in the table with the two primary key parts that it relies on.

com/resources/nf3/
.
These two lines are examples of one-to-many relationships. each item can belong to many orders. This is because individual items do not need to have knowledge of the orders they are part of. is how we express a many-to-many relationship: Each order can have many items. we have succeeded in attaining Second Normal Form!
3 Normal Forms Tutorial 14
http://phlonx. so it passes NF2. each order-item is associated with one item.Second Normal Form: Phase II This should be clearer with a new ERD. Here is how the items table fits into the overall database schema:
Figure H:
The line that connects the items and order_items tables means the following:
• •
Each item can be associated with any number of lines on any number of invoices. we did not bring a copy of the order_id column into the new table. The order_items table takes care of remembering this relationship via the order_id and item_id columns. Taken together these columns comprise the primary key of order_items. Notice. but taken separately they are foreign keys or pointers to rows in other tables. Notice that this time. This three-table structure. More about foreign keys when we get to Third Normal Form. including zero. too. At this point. considered in its entirety. and only one. that our new table does not have a concatenated primary key.

These four columns actually rely on customer_id. Can it exist independent of the order_id column? No: an "order date" is meaningless without an order. outside of the orders table? Yes.
3 Normal Forms Tutorial 15
http://phlonx. we return to the problem of the repeating Customer information. To better understand this concept. consider the order_date column. customer_city. order_date is said to depend on a key attribute (order_id is the "key attribute" because it is the primary key of the table). These fields belong in their own table. This is because there are columns in the orders table that rely on "non-key attributes". you will notice in Figure I that we have severed the relationship between the orders table and the Customer data that used to inhabit it. The same goes for customer_address.
Figure I:
However. It is meaningful to talk about a customer name without referring to an order or invoice. if a customer places more than one order then we have to input all of that customer's contact information again. which is not a key in this table (it is a non-key attribute). As our database now stands. and customer_state.Third Normal Form: No Dependencies on Non-Key Attributes
Third Normal Form: No Dependencies on Non-Key Attributes
At last. What about customer_name — can it exist on its own. with customer_id as the primary key (see Figure I).com/resources/nf3/
. This won't do at all.

One final refinement. and only one customer. A foreign key is essentially a column that points to the primary key in another table..com/resources/nf3/
.Third Normal Form: No Dependencies on Non-Key Attributes We have to restore the relationship by creating an entity called a foreign key (indicated in our diagram by (FK)) in the orders table.. including zero. they also individually serve as foreign keys to the order table and items table respectively.1 documents this fact. and shows our completed ERD:
Figure J: Final ERD
The relationship that has been established between the orders and customers table may be expressed in this way:
• •
each order is made by one. Figure J. You will notice that the order_id and item_id columns in order_items perform a dual purpose: not only do they function as the (concatenated) primary key for order_items. Figure J describes this relationship. each customer can make any number of orders. and shows our completed ERD:
3 Normal Forms Tutorial 16
http://phlonx.

Figure K:
3 Normal Forms Tutorial 17
http://phlonx.com/resources/nf3/
. Notice that NF3 removed columns from a table. here is what the data in each of the four tables looks like.Third Normal Form: No Dependencies on Non-Key Attributes
Figure J: Final ERD
And finally. rather than rows.

there's a lot more to it than this. If you want to read more about the theory and practice of the 3 Normal Forms. Codd's seminal 1969 paper on database normalization: www. Springer-Verlag Telos (January 15. Art Langer. 1997) ISBN: 0387949720 Dr.References for Further Reading
References for Further Reading
Needless to say. by Dr.acm. devotes considerable space to normalization.wikipedia. here are some suggestions:
•
• •
The Art of Analysis.com/resources/nf3/
.org/classics/nov95 The Wikipedia article on normalization discusses all five normal forms: en.org/wiki/Database_normalization
3 Normal Forms Tutorial 18
http://phlonx.